End-to-end finish protocol for any Slack thread, CLI invocation, or cron task where the user has handed off a goal. Routes to /fs (spec gen) → /f (Dark Factory loop) → drives to a verifiable conclusion (green PR with non-unit-test evidence, finished code change, or dry-run to local machine state). Never stops halfway. Loads automatically when the SOUL.md `finish-the-job` commit fires.
Standardmäßig ist der Prompt ausgewählt, der zuerst die Quelle prüft. Sie können zu einem direkten Befehl wechseln oder eine lokale Kopie herunterladen.
Quelldateien prüfen
Lesen Sie SKILL.md und alle von SkillsMP angezeigten Begleitdateien, bevor Sie sich für eine Installation entscheiden.
Mit Codex oder Claude installieren Kopieren Sie diesen Prompt, fügen Sie ihn in Codex, Claude oder einen anderen Assistant ein und lassen Sie die Skill-Seite prüfen und installieren.
Ein direkter Befehl überspringt den Prüf-Prompt. Prüfen Sie die Quelle, bevor Sie ihn ausführen.
End-to-end finish protocol for any Slack thread, CLI invocation, or cron task where the user has handed off a goal. Routes to /fs (spec gen) → /f (Dark Factory loop) → drives to a verifiable conclusion (green PR with non-unit-test evidence, finished code change, or dry-run to local machine state). Never stops halfway. Loads automatically when the SOUL.md `finish-the-job` commit fires.
["finish the job","finish it","finish this","finish that","drive to conclusion","see it through","take it all the way","don't stop halfway","why did you stop","hands off mode","hands-off mode","fullsend","full send","take it from here","i started but didn't finish","work started but didn't finish","stalled thread","threads that stalled","threads i started but didn't finish","skillify hermes to be hands off","make hermes hands off","/finish","/auto","auto","automate this","do it autonomously","your call","handle it","ship it","merge it","is this finished","is x finished","did you finish","where is the report","reconstruct from prior session","/learn","/skillify","/harness","/newb","run /learn","run /skillify","run /harness","run /learn and /skillify","/learn and /skillify","/learn and /skillify and /harness","close the loop","persist the learning","capture the learning","stop MCP mail from","stop the bot from","stop X from giving me Y","stop X from these reports","these reports","passively listening","wrong target","I said the agent not the cron","1.7.9 (2026-07-28): Two sub-cases on the worker-execution-checkpoint-gate pitfall (already shipped as a header ref in 1.7.8). (a) Mechanical-closeout prompt template — verified on PR #8661: workers burning `--max-turns` on re-evaluation is the dominant failure mode of mid-task handoffs. The brief shape that lands is 'do not analyze, here are the exact files to add, here is the exact commit prefix, here is the exact end-state' — generic 'continue from here and finish' briefs always re-evaluate. (b) Worker-import environment blocker — the same PR #8661 incident produced `ModuleNotFoundError: No module named 'jsonschema'` because the worker imported `mvp_site` against the system Python, which lacks the transitive deps that only live inside `~/.hermes/projects/your-project.com/venv/`. Same trap family as `always-pr-never-local-edit` v1.5.0 'Worktree-silent-edit trap'; mitigation = `source ~/.hermes/projects/<repo>/venv/bin/activate` in the spawn brief before any `python3 -m unittest` call.","1.7.8 (2026-07-24): New pitfall 'Pre-merge worktree inspection — staged-but-uncommitted changes can re-break a committed fix at merge time' + new reference `references/pre-merge-worktree-sabotage-inspection-2026-07-24.md`. Verified on $GITHUB_REPOSITORY PR #8548 (companion-quest cadence injection, commit ac5d0c400b). Green Gate + CodeRabbit + `gh pr view` all evaluate COMMITTED head SHA, not the worktree's working tree. A prior session had `git add`-ed staged reverts of the committed fix (reverting `os.path.dirname(__file__)` back to the buggy `os.path.join('mvp_site', ...)` and deleting the `test_injection_path_resolves_under_docker_workdir` regression test) but never committed/pushed. Without the 4-line `git diff HEAD` audit, `gh pr merge` would have shipped a re-broken main. Recipe: BEFORE any `gh pr merge` on a worktree touched by a prior session, run `git rev-parse HEAD` + `git diff HEAD` + `git diff --cached HEAD` + `git rev-parse origin/<branch>`; if `git diff HEAD` or `git diff --cached HEAD` reverts a regression test added in this branch, `git restore --staged` + `git checkout` to discard. Class-level rule: Green Gate covers the COMMITTED end of the path; the working-tree end is the agent's responsibility. Companion: bead rev-mgju0 / issue #8563 — 'REPRO: Staged-but-uncommitted revert of merged PR fix can re-break production'.","1.7.7 (2026-07-24): New pitfall '`local.sh` is the canonical local-evidence launcher — never `python -m <package>.main serve` directly' + new reference `references/local-sh-canonical-launcher-2026-07-24.md`. Verified on $GITHUB_REPOSITORY PR #8561 (clean replay of #8139 mobile scroll chevron). Agent self-justified 'fresh Flask server' after running `python3.11 -m mvp_site.main serve` directly — bypassed `local.sh`'s cache-busted frontend copy (`/tmp/<worktree>/<branch>/`), `ENABLE_SEMANTIC_ROUTING=true` + `TESTING=false` env vars, full venv pip-install, and the `/api/campaigns` health-check gate. User pushback verbatim: 'You did you run a fresh local.sh server to get the proof?' Recipe: (1) ALWAYS use `bash local.sh --no-log-stream --force-default-port` for any `/es` evidence capture, not `python -m ... serve`; (2) prove served-bundle-identity via `shasum -a 256` of `curl -fsS <url>/frontend_v1/js/campaign-wizard.js` vs the on-disk source — both SHAs must match byte-for-byte, document in PR body `## Non-Unit Test Evidence`; (3) state the launcher name explicitly in the PR body (not 'fresh Flask server'); (4) never rely on grep counts of function names in the served bundle as proof (cache could serve a stale equal-content file). Compounding pitfall: 'frontend-only change so local.sh's other pieces don't matter' is wrong on the cache-busted-frontend and standard-env-vars axes even when right on the React-v2 axis (local.sh line 867 explicitly says React v2 is removed).","1.7.6 (2026-07-24): Two new pitfalls and a verifier-before-push gate, verified on $GITHUB_REPOSITORY PR #8548 (companion-quest cadence injection). (1) 'New module-relative file path uses repo-root prefix instead of os.path.dirname(__file__) — passes local tests, breaks in Docker WORKDIR' — Codex P1 caught `os.path.join(\"mvp_site\", constants.X_PATH)` that resolves correctly in dev (cwd=repo) but raises FileNotFoundError in Docker (`WORKDIR=/app/mvp_site`). Recipe: switch to `os.path.dirname(__file__)`, add a unittest-level regression test that pins the source contains the fix and does NOT contain the anti-pattern, run locally before pushing. New reference `references/codex-docker-workdir-path-resolution-2026-07-24.md` has the full audit recipe + the pytest-vs-unittest fixture pitfall + the `POST /repos/{owner}/{repo}/issues/{number}/comments` reply endpoint that actually works. (2) '`/er`, `/advice`, `/code-standards` are Claude Code/Codex slash commands, not Hermes skills — when `skill_view` returns Skill-not-found for them, fall back to manual review passes + `pr_description_gate.py --body-file` local verification, do not invent skill behavior.' (3) Verifier-before-push gate: run `python3 .github/scripts/pr_description_gate.py --body-file <new-body> --changed-files-file <(printf ...)` BEFORE pushing to validate `overall: PASS, conditional_violations: []`. Same instinct as `py_compile` for syntax or `pytest -x` for tests — verify locally before triggering CI.","1.7.5 (2026-07-23): Added the PR draft/CI truthfulness gate and explicit fix-vs-detector-vs-evidence classification after the #8528 two-PR dispatch. Draft PR creation now requires independent REST/URL/SHA verification, separate success/skipped/pending counts, exact-body outbound-secret scanning, and an explicit blocker when a log-only validator is not the root-cause repair.","1.7.3 (2026-07-22): New pitfall 'UI change with \\\"add X to settings and prove it works\\\" → claimed X is in the dropdown but no captioned screenshot/video is attached' (verbatim Jeffrey feedback: \\\"Is this finally wokring? show me captioned screeshots/video here. why didnt you alreayd?\\\"). Captures the audit-every-layer-first + proof-before-claim contract: 6 concrete gates (audit-every-layer → run app → capture BEFORE/AFTER PNGs → captioned MP4 → 3-stage Slack upload → vision-verify captions and UI) plus forbidden reply shapes. Companion to `grep-before-constant-change` (every layer touched, same commit) and `evidence-attach-to-slack` (3-stage upload recipe) and `evidence-attach-presend-gate` (5-step pre-send sequence).","1.7.4 (2026-07-23): Tightened pitfall 'Stalled on a preflight menu when the goal had 3+ clear verbs' (changelog 1.7.2) with the BQ-runnable-diagnostic sub-case. Verified on $GITHUB_REPOSITORY issue #8528 (campaign `wc2BBcSgOljiU3vJ160A`): agent posted an A/B/C fix-direction menu ('A: budget-cap directives | B: stop trimming per your literal proposal | C: hybrid') BEFORE running the BQ diagnostic. User pushback was verbatim: *\"Read the actual raw LLM request in BQ did the LLM even see the directive for scaling the equipment?\"* — directly target the missed-diagnostic. Companion to the `repro` skill changelog 3.7.0 (Step 0.77 BQ-first diagnostic for directive-loss reports) — when the bug class is 'directive-loss / LLM ignored / command forgotten / god-mode correction didn't stick', the BQ query is the first tool call, not a fix-direction menu. New reference `references/bq-runnable-diagnostic-first-2026-07-23.md` captures the case-study transcript + the 6-bullet heuristic for any session that has runnable diagnostic tools ready. The general principle: when the bug class is in a known taxonomy AND a runnable diagnostic exists for that class, the diagnostic is the first turn, not a clarifying menu.","1.7.2 (2026-07-22): New pitfall 'Stalled on a preflight menu when the goal had 3+ clear verbs and zero data gaps' + new reference `references/eval-stall-on-preflight-menu-2026-07-22.md`. Verified on the vendor-router eval (clone Medium-linked repo, evaluate against past convos) — agent posted 4 preflight questions before any tool call. User feedback (verbatim): 'Go and you should be able to use headless chrome and why did you even stop? you shouldn't have just done the work.' Same anti-pattern family as the existing '3-option mid-stream menu' but at the pre-execution stage. Companion class skill: `vendor-ml-artifact-eval` (the actual recipe for evaluating third-party routers/classifiers before adoption).","1.7.1 (2026-07-21): New reference `references/prompt-contract-cr-scope-broadening-2026-07-21.md` covering the prompt-edit PR-fix pattern: when CodeRabbit flags static-content blockers (named-entity leaks, formula/example mismatch, hidden-state leaks, contradictory clause pairs, malformed placeholders) wider than the existing static test enforces, the canonical recipe is (1) broaden the static test FIRST, (2) run it locally to enumerate the leak surface before editing the prompt, (3) add a `LockdownTests` class with exact-substring contract pins for the OTHER 4 blocker classes, (4) commit + push as one PR ref. Verified on $GITHUB_REPOSITORY PR #8488 V3.21 (head f9f269a685, 5 blockers closed, 25/25 setting-agnostic tests green, 6 new lockdown tests added in V321ContractualFixesTests).","1.7.0 (2026-07-20): Extended `references/patch-bundle-cwd-preflight-2026-07-20.md` with **cross-fork misroute detection probes**. Distinguishes cwd-level failure (`cd <repo> && git apply --check` passes after cwd fix) from cross-fork misroute (patch from a different repo entirely — author email domain, github existence of source repo, base SHA presence). Verified on Slack thread C09GRLXF9GR/p1784582518.247009 — agent burned budget porting `infra03q-inpipeline-receipt.patch` (author `$USER@snapchat.com`, Snapchat-internal `snap-factory`) onto `jleechanorg/dark-factory` before discovering the cross-fork mismatch. Added right ack shape on misroute + cleanup recipe (`br close` + `git worktree remove --force --force` for locked worktrees + `.git/rebase-apply/` cleanup + `.git/worktrees/<name>` metadata wipe + `git worktree prune` + `git branch -D`). Cross-fork misroute is the github-level analog of the wrong-target-removal pattern in `references/wrong-target-removal-stop-X-from-Y-2026-07-20.md`.","1.6.0 (2026-07-20): New Phase 0 row `Disable / stop / remove something` + new pitfall 'Removed the literal noun from \"stop X from Y\" without tracing symptom provenance' + new reference `references/wrong-target-removal-stop-X-from-Y-2026-07-20.md`. Verified on Slack thread C0AJ3SD5C79/p1784344760053389 — user said 'Lets stop mcp mail from giving these reports', agent removed `clawchief:ea-sweep-hourly` (wrong target). Actual source was the MCP Agent Mail agent's Socket-Mode listener ingesting Slack messages into MCP. User feedback: 'No keep the job you fucking idiot — I said mcp mail agent I don't want it passively listening to my threads.' Phase 0.5 disambiguation rule: trace symptom noun ('these reports', 'passively listening', 'self-reports') to actual source via data-path trace; if ambiguous, ASK ONE QUESTION. Companion: harness-postmortem v0.5.0 Phase 0 working class + SOUL.md `## COMMIT: mcp-agent-mail-no-passive-slack-listening` + 14-gate contract test `~/tests/test_mcp_agent_mail_slack_off.py` (all green).","1.5.0 (2026-07-15): New reference `references/pr-description-validator-gate6b-2026-07-15.md` covering Gate 6b PR description validator diagnostic recipe (pull locally + reproduce FAIL), Evidence Gate Check 7 freshness policy + behavioral-file regex carve-out, and Skeptic Gate 7 NOT-LIVE-in-jleechanorg verification. Verified on $GITHUB_REPOSITORY PR #8406.","1.4.0 (2026-07-14): New pitfall 'User says /learn + /skillify + /harness → must run ALL THREE in the same session, not just one' + new reference `references/learn-skillify-harness-closeout-2026-07-14.md`. Verified on Slack thread C09GRLXF9GR/p1784083166 (this session): user typed '/learn and /skillify and dont we ahvr a fresh worktree skill or instrucitons to use /newb? lets run /harness and then fix it' expecting the full 4-action closeout loop. The agent that runs only ONE of /learn or /skillify or /harness leaves the learning half-captured; the durable rule lands in some artifacts but the SOUL.md COMMIT and the contract test that locks it do not. Trigger: user message contains /learn AND /skillify (and often /harness and /newb) in the same turn.","1.3.0 (2026-07-14): New pitfall 'Stale-PR-branch rebase when `ao spawn` is down' + new reference `references/stale-pr-branch-rebase-conflict-2026-07-14.md`. Verified on $GITHUB_REPOSITORY PR #8290.","1.2.0 (2026-07-14): New pitfall '60-min clarify silence is not a license to stop pushing' + new reference no-stop-after-clarify-silence-2026-07-14.md.","1.1.0 (2026-07-08): Initial fix(watchdog) version.","1.0.0 (2026-06-19: Initial skill — end-state evidence stack, phases 0-4, anti-patterns."]
The hands-off finish protocol. When a user hands you a goal — in Slack, in a CLI turn, or via a cron task that wasn't finished — this skill is the single pipeline that drives it to a verifiable conclusion. It composes existing primitives (/fs, /f, workflow/drive-pr-to-green, workflow/always-pr-never-local-edit) so the assistant stops halfway never.
Why this skill exists
Three drift patterns were observed in the user's last week of Slack threads (2026-06-12 to 2026-06-19, C0AH3RY3DK6 / C09GRLXF9GR):
"Ack + design prose + silence" — agent acknowledges, writes 200 lines of design options, asks one more clarifying question, never executes. The dropped-thread-followup cron fires 4h later.
"Started + fork + multi-option question" — agent reads files, makes a local commit, hits a judgment call, posts a 3-option menu. User doesn't reply (busy). Thread goes cold.
"Investigation without end-state" — agent reads 6 files, posts "Here's what I found: …" with no PR, no commit, or dry-run. The "I'm waiting for the right moment to ship" trap.
The pattern in all three: the agent stopped at a place that required the user to make a decision or supply a follow-up, instead of making the call itself and posting the result. The user's explicit rule (2026-06-19): "I am ok with outcomes that aren't my goal as long as they are correct ie. Green PR, real evidence, like correct but misinterpret is fine but stopping halfway is not."
Contract
When this skill fires, the work is not done until ONE of these end-states is provably true:
End-state
Proof artifact
Green PR merged
gh pr view <N> --json state = MERGED + Green Gate workflow log gate-by-gate PASS + non-unit-test evidence bundle URL
PR open with green CI awaiting user merge
gh pr view <N> --json mergeStateStatus,reviewDecision shows MERGEABLE + review clean; ONE-LINE message naming PR URL + the one gate the user must clear
Local state change verified
git diff + git log --oneline -3 + the actual test run output captured in the final reply (not described — shown)
Diese SKILL.md ist sehr gross, daher zeigt SkillsMP hier nur den ersten Abschnitt.Auf GitHub ansehen
Dry-run to local machine
The exact commands the user would run, executed against a fresh worktree, output captured; the user can paste the same commands and get the same result
NOT acceptable end-states:
❌ "Here's the design, want me to ship it?" — that's design-proposal-and-silence
❌ "Tests pass locally, PR is ready, want me to push?" — that's local-commit-and-ask
❌ "Investigation complete, here are the findings" without a commit, PR, or dry-run
❌ "I've started the worker, will update when done" — that's ack-and-walk-away
❌ Mid-stream question without first exhausting the LLM's own judgment (per the user's rule: "in the middle I want AI to use its best judgement")
❌ "Stale-PR-branch rebase when ao spawn is down" (added 2026-07-14, $GITHUB_REPOSITORY PR #8290). When the user asks for fullrun on a PR that is mergeable=CONFLICTING AND ao spawn returns Internal server error, the right move is NOT to stop at "AO is down, can't dispatch" and NOT to spend the entire budget on a fresh branch. Per the AO-spawn pivot reference (references/ao-spawn-internal-error-pivot-2026-07-12.md), execute the conflict resolution inline in the gateway session using the verified recipe in references/stale-pr-branch-rebase-conflict-2026-07-14.md. Key mechanics: (a) use git merge (not rebase) to preserve the PR's review history when the PR has substantive CodeRabbit/Bugbot review evidence; (b) --theirs and --ours semantics FLIP between merge and rebase — read the conflict markers first (grep -nE "<<<<<<< |=======|>>>>>>>"), do NOT guess; (c) DO NOT use set -e in chained conflict-resolution commands — its first non-zero exit kills the script before git commit fires, leaving the worktree half-resolved; (d) push to the PR's original branch with --force-with-lease (not --force) to preserve PR identity; (e) after your push, GitHub may auto-merge main into the branch (visible as a merge origin/main into <branch> commit) — your SHA changes, but the changes are still in history as an ancestor. Verified PR #8290 went from CONFLICTING → MERGEABLE+CLEAN in 4 commands + 1 push, all inline in the gateway session.
❌ "60-min clarify silence is not a license to stop pushing" (added 2026-07-14, jleechanorg/claude-commands PR #328 + $GITHUB_REPOSITORY PR #8402). When the agent asks a Phase 0 clarification question and the user does not answer within ~60 minutes, the agent's instinct is to either re-ask, proceed locally and stop, or post a status update. Both re-asking and stopping are wrong. Silence is the user being busy / asleep / in a meeting, not authorization to halt mid-stream. Per push-pr-donot-stop-halfway, the right move when scope is even moderately unambiguous is to drive to PR-merged end-state (git commit + git push + gh pr create + Slack reply with PR URL) without re-asking. Verified bug case 2026-07-14: agent asked the clarify, no answer came, agent executed the minimal-scope interpretation LOCALLY but never reached git push. The user came back ~22h later with "why didn't you just do it without stopping?" — the entire 22h gap was avoidable. Recipe: (a) classify scope as "obvious enough to act on" vs "needs the user's call" — when scope can be inferred from prior session context + recent edits, it is obvious enough; (b) make the conservative interpretive call (do less, not more, but DO it); (c) drive to PR-open end-state in the same session — git commit + git push + gh pr create (no "want me to push?" confirmation gate); (d) post the Slack reply with PR URLs as the final reply. Companion reference: references/no-stop-after-clarify-silence-2026-07-14.md with the two-symlink-repo tracing recipe (jleechanorg/claude-commands for user-scope commands vs $GITHUB_REPOSITORY for repo-local commands) + the git rev-parse origin/<branch> push-verified check + the symlink-trap pitfall (~/.claude/commands/auto-factory.md resolves to ~/projects/dark-factory/.claude/commands/auto-factory.md).
❌ "User says /learn + /skillify + /harness → must run ALL THREE in the same session" (added 2026-07-14, Slack thread C09GRLXF9GR/p1784083166). When the user types a message containing /learn AND /skillify (and often /harness and /newb) in the same turn, they are not asking the agent to pick ONE of those actions — they are asking for the full closeout loop: (1) /learn → persist the durable lesson to Claude auto-memory + roadmap + bead + wiki; (2) /skillify → ensure the reusable workflow lives in ~/.hermes/skills/<name>/SKILL.md with tests + RESOLVER entry + contract test; (3) /harness → bootstrap or harden the project harness so the lesson is enforced automatically (mechanical checks, not soft reminders); (4) /newb / fresh-worktree verification → confirm the agent operated from a clean worktree (and verify the fresh-worktree skill exists; if not, surface the gap). Running only /learn and skipping /skillify leaves the lesson in memory but does not capture the reusable workflow. Running only /skillify and skipping /learn captures the workflow but does not persist the incident-class to memory. Either partial closeout produces a half-captured learning the next session has to re-derive. Verified trigger pattern from 2026-07-14: user said "/learn and /skillify and dont we ahvr a fresh worktree skill or instrucitons to use /newb? lets run /harness and then fix it" — all four actions are explicitly named, the expected end-state is a SOUL.md ## COMMIT: block + a new contract test + a pr-cleanup-replay skill Phase -1 + a fresh-worktree verification of the actual fix. Recipe: load learn + skillify + harness-engineering + using-git-worktrees in the first tool call, then sequence the four actions in the order above (learn first so the skill update has a memory anchor; skillify next so the workflow is reusable; harness-engineering last so the mechanical enforcement is layered on top). See references/learn-skillify-harness-closeout-2026-07-14.md for the full sequence + verified outputs from this session (PR #329 clean replay + SOUL.md ## COMMIT: never-push-onto-someone-elses-pr-head + 3 new contract tests + 8/8 contract tests pass).
❌ "Gate 6b PR description validator treats 'harness-only' as no-op, then fails with NO useful error in the GH Actions log" (added 2026-07-15, $GITHUB_REPOSITORY PR #8406). The validator .github/scripts/pr_description_gate.py is fail-closed and demands anchors (URL, fenced code block, end2end marker, or LLM response-shape marker like "candidates" / "role": "model") on ## Non-Unit Test Evidence and (when PR touches $PROJECT_ROOT/prompts/**) ## Real LLM Evidence. The workflow writes the validator output to /tmp/pr_description_gate_output.json then rm -fs it; the GH Actions log only shows GATE-6b FAIL: PR description gate rejected PR body (validator output below) followed by a head -c 2000 of a file that no longer exists. The reproducer recipe: gh api repos/$GITHUB_REPOSITORY/contents/.github/scripts/pr_description_gate.py --jq '.content' | base64 -d > /tmp/pr_desc_gate.py && python3 /tmp/pr_desc_gate.py --body-file /tmp/pr<body>.txt --changed-files-file /tmp/changed.txt | python3 -m json.tool. Without running this you cannot tell whether anchor_missing is on ## Non-Unit Test Evidence or whether the conditional Real-LLM-Evidence violation is firing. Always reproduce locally. See references/pr-description-validator-gate6b-2026-07-15.md for the full recipe + LLM marker list + worked example on PR #8406.
❌ "gh pr edit --body-file does NOT re-trigger Evidence Gate, even though it DOES re-trigger Green Gate Precheck" (added 2026-07-15, $GITHUB_REPOSITORY PR #8406).evidence-gate.yml is configured with pull_request: types: [opened, ready_for_review, reopened, synchronize] — edited is not in the list. So if your PR body fix is the only change, Evidence Gate will keep showing the old FAILURE conclusion. Fix: push a commit (even git commit --allow-empty -m "refresh") to force a synchronize event and re-trigger Evidence Gate. Green Gate Precheck has a broader trigger set and DOES re-evaluate on body-edit, which is why the gate-6b fix appears green immediately while Evidence Gate appears stale until the next push. Verified on PR #8406.
❌ "Skeptic Gate 7 is always non-self-pass in $GITHUB_REPOSITORY — first diagnostic of any /green drive here" (added 2026-07-15). Verified git ls-tree origin/main .github/workflows/ | grep skeptic returns empty + gh api .../actions/workflows has no skeptic-cron entry + gh workflow run skeptic-cron.yml returns HTTP 422 ("no workflow_dispatch trigger"). Per memory item 6, this triggers a MERGE APPROVED required escalation BEFORE the final merge — the gate cannot self-pass and any /green drive on this repo MUST surface that to the user up-front rather than discovering it during the final-merge block. Document this as part of the per-repo pre-flight (alongside the AO spawn health check + working-dir-lock check), not as a Phase 4 surprise.
❌ "Stalled on a preflight menu when the goal had 3+ clear verbs and zero data gaps" (added 2026-07-22, vendor-router eval). When the user says "clone this, evaluate it, replay it against my convos, are the choices right" — the goal is all four actions in sequence + a verdict. Do NOT post a multi-option "which project should I mine / should I try headless chrome / which mode do you want" before doing the work. The user-supplied goal had three verbs (clone, evaluate, replay); execute them, surface the judgment calls in the final reply, and post the verdict. The Phase 0 clarification question is allowed ONCE when classification is genuinely ambiguous (force-push authorization, secrets, env-specific config); it is NOT allowed for "which past project do you want me to mine" when session_search has the answer, and it is NOT allowed for "should I try headless chrome" when the canonical alternative (the repo's README) is already in front of you. Verified incident 2026-07-22: agent stalled twice on preflight menus before user said "Go and you should be able to use headless chrome and why did you even stop? you shouldn't have just done the work" — the article was bot-walled, the README was right there in the cloned repo, and the past convos were one session_search call away. BQ-runnable-diagnostic sub-case (added 2026-07-23, $GITHUB_REPOSITORY #8528): when the bug class is in a known taxonomy AND a runnable diagnostic exists for that class (e.g. bq query on worldarchitecture-ai.llm_forensics.llm_payloads for any directive-loss report), the diagnostic is the first turn — not a fix-direction menu. Agent posted A/B/C ("A: budget-cap directives | B: stop trimming per your literal proposal | C: hybrid"); user pushback was verbatim "Read the actual raw LLM request in BQ did the LLM even see the directive for scaling the equipment?" — directly targeted the missed-diagnostic. Companion to repro skill Step 0.77 (BQ-first diagnostic for directive-loss reports) — load both for any /repro <directive-loss-report> request. Companion reference: references/bq-runnable-diagnostic-first-2026-07-23.md.
❌ "New module-relative file path uses repo-root prefix instead of os.path.dirname(__file__) — passes local tests, breaks in Docker WORKDIR" (added 2026-07-24, $GITHUB_REPOSITORY PR #8548). When a PR adds a new read_file_cached(constants.X_PATH) (or open(X_PATH)) where X_PATH is module-relative, the implementation MUST use os.path.dirname(__file__) to resolve. A repo-root prefix like os.path.join("mvp_site", X_PATH) works in dev (cwd=repo root) but raises FileNotFoundError in production Docker where $PROJECT_ROOT/Dockerfile sets WORKDIR=/app/mvp_site. Existing unit tests do NOT catch this because they run with cwd=. Codex (chatgpt-codex-connector) caught this on PR #8548 as a P1 after CI was already green — would have shipped a real prod bug. Recipe: (1) grep rg -n 'os\.path\.join\("mvp_site",' $PROJECT_ROOT/ -g '*.py' BEFORE opening the PR to catch the anti-pattern pre-merge; (2) switch to os.path.dirname(__file__); (3) add a regression test that pins BOTH assertIn("os.path.dirname(__file__)", inspect.getsource(...)) AND assertNotIn('os.path.join("mvp_site",', ...); (4) test using tempfile.TemporaryDirectory() + os.chdir(tmp) (NOT pytest fixtures — the existing test class is unittest.TestCase); (5) if Codex flags the bug mid-drive, fix it on the SAME branch, do not open a new PR. See references/codex-docker-workdir-path-resolution-2026-07-24.md for the full audit + the working POST /repos/{owner}/{repo}/issues/{number}/comments reply endpoint (the pulls/{number}/comments/{id}/replies endpoint returns 404).
❌ "/er, /advice, /code-standards are Claude Code/Codex slash commands, NOT Hermes skills" (added 2026-07-24, PR #8548). When the user's message names /er / /advice / /code-standards and skill_view(name='advice') returns Skill-not-found, do NOT invent skill behavior, do NOT claim "approved". Fall back to manual review passes: (1) for /advice — read the repo's $PROJECT_ROOT/AGENTS.md + .cursor/rules/ + run a third-pass of the PR diff for prompt-contract violations, naming each concern; (2) for /er (External Review) — apply the pr_description_gate.py --body-file <new-body> --changed-files-file <(printf ...) local verifier + run the full local test sweep + check production-env-specific patterns (Docker WORKDIR, env-var handling); (3) for /code-standards — same as /er + grep for known anti-patterns in $PROJECT_ROOT/. State explicitly in the final reply: "Ran a manual /er pass instead of the slash command (slash command is not a registered Hermes skill in this environment)". Verified on PR #8548: skill_view returned Skill-not-found for code-standards and advice; the drive completed with a manual review instead.
❌ "Push a PR body edit and wait for the gates to re-evaluate without verifying the validator locally first" (added 2026-07-24, PR #8548). The verifier-before-push gate: BEFORE pushing a PR body change that targets GATE-6b / Evidence Gate Check 7, run the local verifier and confirm the validator output is overall: PASS, conditional_violations: []. This avoids the empty-commit-doesn't-help dance (which only fixes gh pr edit's lack of synchronize event, not the underlying validator rejection). Recipe:
Confirm overall: PASS AND empty conditional_violations: []. Then push the body change via PATCH /repos/{owner}/{repo}/pulls/{number} (REST, since GraphQL often rate-limits) AND push an empty commit (git commit --allow-empty -m "refresh") to force synchronize so Evidence Gate re-runs. Same instinct as py_compile for syntax or pytest -x for tests — verify locally before triggering CI. See references/pr-description-validator-gate6b-2026-07-15.md for the full validator recipe + the LLM marker list.
❌ "User instruction conflicts with ground-truth repo state — pause and surface data before destructive action" (added 2026-07-16, $GITHUB_REPOSITORY PR #8411/8413/8316/8309, Slack thread C09GRLXF9GR/p1784235917). When the user says "fullrun / don't stop / all the small PRs / /green them" but the actual PR data contradicts the implied plan (drafts marked as mergeable, merge conflicts on dirty, CI never ran despite "combined status: success", CodeRabbit "success" is a review action not a CI check), STOP and surface the corrected data in one Slack-thread message before any git push / gh pr merge / gh pr ready / draft→ready. The user's "no questions" instruction does NOT override "don't make decisions on bad data." Anti-pattern: composing a confident green-ready table from REST API fields without re-checking the draft field on every PR. Recipe: (a) before composing any "I'm driving Path 1" message, fetch draft for every PR via REST pulls endpoint; (b) build the per-PR table from raw REST JSON, not from prior-session assumptions; (c) if any state field contradicts the implied plan, post the corrected table + the fork before any tool call that mutates a PR (gh pr edit, gh pr merge, git push). The 60-min clarify-silence rule covers silence AFTER a question; this rule covers BAD DATA BEFORE destructive action. Specific wrong-data false-positives caught in 2026-07-16 session: (1) PR #8387 had mergeable_state=clean but draft=true — CodeRabbit skipped review because draft, not because approved; (2) PRs #8332/#8316/#8309/#8413 had "combined status: success" with only 1 status entry = CodeRabbit review pre-action, GH Actions CI never ran; (3) PR #8411 was mergeable_state=dirty = merge conflict on $PROJECT_ROOT/prompts/dice_system_instruction.md + game_state_instruction.md. Cross-check recipe in references/pr-state-preflight-table-2026-07-16.md (companion to drive-pr-to-green).
❌ "local.sh is the canonical local-evidence launcher — never python -m <package>.main serve directly" (added 2026-07-24, $GITHUB_REPOSITORY PR #8561). When the user message contains /es (or any other /es-class evidence ask) against a local dev server, the canonical launcher is bash local.sh --no-log-stream --force-default-port. A direct python -m mvp_site.main serve invocation is NOT canonical, even if it boots cleanly, even if the served bundle contains the right function names. local.sh does FOUR things a bare invocation does not, and skipping them silently produces evidence that the harness does not consider canonical: (1) cache-busted frontend copy — local.sh writes $PROJECT_ROOT/frontend_v1/ to /tmp/<worktree>/<branch>/ so Flask serves a fresh copy, not the worktree path. Without this, Playwright could render against a stale build. (2) standard env vars — ENABLE_SEMANTIC_ROUTING=true, TESTING=false, FRONTEND_V1_DIR=<cache-bust-dir>, RATE_LIMIT_EXEMPT_EMAILS. Without ENABLE_SEMANTIC_ROUTING=true the route the evidence script relies on may not hit the same code path as production. (3) full venv — local.sh creates venv/ if missing and pip-installs requirements.txt. Direct invocation will ModuleNotFoundError: No module named 'firebase_admin' etc. on a partial Python install (verified on this Mac — /opt/homebrew/bin/python3.12 lacks firebase_admin). (4) health-check validation gate — local.sh waits for / to return 200 + /api/campaigns to require auth before exiting the launcher block. User pushback verbatim (2026-07-24, Slack C0AH3RY3DK6/p1784894152): "You did you run a fresh local.sh server to get the proof?". Compounding anti-pattern: "frontend-only change so local.sh's other pieces don't matter" — wrong on the cache-busted-frontend and standard-env-vars axes even when right on the React-v2 axis (local.sh line 867 explicitly says React v2 is removed). Recipe: (a) ALWAYS use bash local.sh --no-log-stream --force-default-port for any /es evidence capture; (b) BEFORE running the capture script, prove served-bundle identity via curl -fsS <url>/frontend_v1/js/<key-bundle>.js -o /tmp/served.js && shasum -a 256 /tmp/served.js $PROJECT_ROOT/frontend_v1/js/<key-bundle>.js — both SHAs must match byte-for-byte; (c) document the launcher name + served SHA + source SHA in the PR body (NOT just "fresh Flask server"); (d) never rely on grep counts of function names in the served bundle as proof — cache could serve a stale equal-content file. See for the full transcript + the byte-identity verification recipe.
❌ "Pre-merge worktree inspection — staged-but-uncommitted changes can re-break a committed fix at merge time" (added 2026-07-24, $GITHUB_REPOSITORY PR #8548). Green Gate, CodeRabbit, and the GitHub mergeable: MERGEABLE state all evaluate the committed head SHA of the PR branch — NOT the working tree of the worktree that contains the branch. If the local worktree for the PR has staged changes that REVERT a fix committed at HEAD (or delete a regression test added at HEAD), the GitHub-side state will be reported as MERGEABLE+CLEAN and gh pr merge will succeed — producing a merged main where the production bug is back. Verified on PR #8548: a codex review had flagged a Docker-WORKDIR path bug; commit ac5d0c400b fixed it via os.path.dirname(__file__) and added test_injection_path_resolves_under_docker_workdir; the PR was 7-green and ready to merge. The worktree's working tree, however, contained two staged changes that reverted the fix and deleted the regression test — neither was pushed (so origin/HEAD still had the correct fix), but any agent picking up the worktree and running git commit && git push (or a rebase) would have silently un-fixed the bug in main. Recipe — run BEFORE gh pr merge on any worktree that someone else (or a prior session) has touched:
cd <worktree>
echo"=== HEAD SHA ===" && git rev-parse HEAD
echo"=== diff HEAD vs working tree ===" && git diff HEAD
echo"=== diff HEAD vs staged ===" && git diff --cached HEAD
echo"=== branch vs origin ===" && git rev-parse origin/<branch> 2>&1
# If `git diff HEAD` or `git diff --cached HEAD` shows ANY change that REVERTS a# regression test added in commits on this branch, STOP. Investigate before merging.# Detect regressions of test-methods added in this branch:# git log --diff-filter=A --name-only origin/main..HEAD -- '$PROJECT_ROOT/tests/*.py' | grep '\.py$' | sort -u# for test_file in $(...); do# if git diff HEAD -- "$test_file" | grep -E '^-[^-]' | xargs -I{} grep -q "{}" "$test_file" 2>/dev/null; then# echo "REGRESSION: $test_file has staged deletions of tests added in this branch"
❌ "claudem is a bashrc function on this host, not a binary on $PATH — calling it from a fresh terminal() subprocess returns claudem: command not found (exit 127) until the user-scope rc is sourced first" (added 2026-07-26, $GITHUB_REPOSITORY#8623 follow-up on PR #24). The ao-spawn-minimax-worker skill README shows the canonical recipe as ao spawn --project <p> --harness minimax --name <slug> --prompt "<task>", but on this host the ao-go daemon only knows agy / claude-code / codex / opencode / cursor / qwen / aider (verified via ao agent ls) — ao spawn --agent minimax returns agent "minimax" is not supported by this daemon. The fallback path is claudem -p "..." --max-turns 20 from the existing scoped worktree, but claudem is a bashrc function not a binary, so the first invocation fails silently with exit 127. Recipe: (a) always prepend source ~/.bashrc >/dev/null 2>&1 && claudem ... to the command; (b) pair with background=true; notify_on_complete=true; pty=true so the TUI banner does not block a foreground poll; (c) treat Error: Reached max turns (<N>) as a normal exit, not a crash — verify durable state in the worktree (git rev-parse origin/<branch>, git diff --name-only origin/main..HEAD, run the test harness) before concluding the work failed. Verified outcome: PR #24 follow-up commit 7e97d91e1 ([claude-code/MiniMax-M3]) pushed via git push -u origin refactor/8623-coder-silent-false-park-probe, remote SHA matched. Cross-references: claude-code-claudem skill for the binary-vs-function distinction; this pitfall is the operational fix. Class-level rule: when the user's literal phrasing names a specific worker skill (e.g. "claude minimax skill") AND the canonical recipe fails on the host, the right move is to (1) verify the failure mode (ao agent ls, command -v claudem, gh api rate_limit), (2) pivot to the documented fallback, (3) do NOT spawn a parallel PR.
❌ "Worker reached max-turns cap before running CI — verify durable state in the worktree, don't re-run the worker" (added 2026-07-26, $GITHUB_REPOSITORY#8623 follow-up on PR #24). When claudem -p "..." --max-turns 20 exits with Error: Reached max turns (20), the worker has not necessarily failed its task — it may have produced a clean commit + push + tests before the turn cap hit, and the gh pr view / commits/<sha>/check-runs curl in turn 21 was the part that got cut. The right move is to inspect the worktree state FIRST (git rev-parse origin/<branch>, git log --oneline origin/main..HEAD, git diff --name-only origin/main..HEAD, run the test harness); if durable state is correct, schedule a one-time cron to re-fetch the GitHub-side state when the rate-limit window resets. The "worker exited non-zero" reflex is to retry AO — that burns another spawn slot and risks a duplicate PR. Verified workflow: claudem -p exits with max-turns 20 → git rev-parse origin/refactor/8623-coder-silent-false-park-probe returns 7e97d91e1 (the worker's commit) → git push already completed → git log --oneline origin/main..HEAD shows 7e97d91e1 + 6fcb28eee (only the expected commits) → test harness passes → cron 9ec6444eb480 scheduled for +25 min to re-verify gh pr view 24 + commits/7e97d91e1/check-runs. The --max-turns cap is a token-budget guard, not a correctness verdict.
❌ "Worker hit max-turns with zero edits — verify worktree, surface process ID, then re-spawn with a hard checkpoint gate" (added 2026-07-28, $GITHUB_REPOSITORY Spellblade/Valeria prompt task). When a claudem / ao spawn worker exits with Error: Reached max turns (N) and git diff --stat <worktree> is empty, the worker burned its budget on startup/analysis without producing any code change. The right move is NOT to declare failure and stop, and NOT to silently re-spawn with another 25-turn budget — that just repeats the same stall. Recipe: (a) verify durable state: git -C <worktree> status --short --branch + git diff --stat + git log --oneline -3; if empty, the worker truly failed; (b) surface the proof in the next thread reply — worker process ID, worktree path, branch, the empty git diff --stat, the exit reason; (c) re-spawn with an execution-shaped brief: explicit "do not re-explain the task and do not stop at analysis — execute now", plus a higher turn budget if the scope warrants (50 not 25), plus an explicit commit SHA + test output gate at the end; (d) after re-spawn, set a checkpoint gate from the gateway session — every ~5 minutes poll process(action='log') and git -C <wt> status --short so a repeat silent-stall worker gets killed early instead of burning the full new budget. Verified on 2026-07-28: first claudem worker proc_eea1ad9d60be exited Error: Reached max turns (25) with empty git diff --stat on branch feat/spellblade-valeria-prompts → re-spawned as proc_71ca51b72247 with --max-turns 50 and an explicit execution brief. User pushback verbatim: "Are you really executing? ... Will I actually see updates in this thread or will you never update it again?" — durable proof-of-execution artifacts (process ID + worktree path + git status snapshots) MUST appear in the thread, not just in internal state. Cross-ref the canonical mechanical-closeout recipe at references/worker-execution-checkpoint-gate-2026-07-28.md (worked example: claude/minimax-M3: feat(spellblade): add Valeria campaign prompts and personality contracts @ a1b2275f0f6906b23161046d89280a911c62ca25, $GITHUB_REPOSITORY PR #8661, 6 files / +817 / -0, 54/55 tests pass — the one failure was the worker-import-environment blocker below, NOT a campaign-contract failure).
Sub-case (added 2026-07-28, same PR #8661 incident): the worker's python3 -m unittest call returned 54 passed, 1 failed with ModuleNotFoundError: No module named 'jsonschema'. The failure was not a campaign-contract failure — it was the worker importing the full mvp_site chain (mvp_site.agent_prompts → $PROJECT_ROOT/dice_strategy.py → $PROJECT_ROOT/llm_providers/provider_utils.py → jsonschema) against the system Python, which lacks the transitive dependencies that only live inside the repo's venv/. This is the same trap family as always-pr-never-local-edit v1.5.0 "Worktree-silent-edit trap" — a fresh worktree lacks the repo's environment, and any test that imports the repo's source against the system Python fails on a transitive dep that exists only inside the repo's venv. Detection: ls -la <worktree>/venv/bin/python 2>/dev/null (does the worktree have its own venv?) OR ls -la ~/.hermes/projects/<repo>/venv/bin/python 2>/dev/null (is the canonical repo venv reachable from this host?). Mitigation in the spawn brief: prepend source ~/.hermes/projects/<repo>/venv/bin/activate (canonical repo venv) or source <worktree>/venv/bin/activate (in-worktree venv) before any python3 -m unittest ... call; if the dep is still missing, pip install -r requirements.txt inside the same venv first. For $GITHUB_REPOSITORY specifically: the canonical venv is ~/.hermes/projects/your-project.com/venv/. pip install -r requirements.txt inside it once, then every subsequent worker run inherits the dep set. Cross-ref always-pr-never-local-edit v1.5.0 "Worktree test-import via Path.home() quirk" for the same pattern in a different shape.
❌ "Research-only reply stops at synthesis without doing the install / configure / dry-run the user asked for" (added 2026-07-30, Slack C09GRLXF9GR/p1785467202). When the goal is "research X and use it" (e.g. /research all of these and see how/if we should use them in combo), the deliverable is NOT a Slack post summarizing findings + asking "want me to install?". The deliverable is the synthesis AND the install + verify pass + documented state of what landed and what got auto-configured. User signal (verbatim, 2026-07-30): "Ok will did you even finish the work?". For a "research + use" goal the correct end-state is "local state change verified": install log + inventory + audit of auto-configured items (~/.claude/settings.json hooks, enabledPlugins, SOUL.md / CLAUDE.md mtimes). Sub-case + the 15-hook inventory + the --profile=core recipe for GSD Core v1.9.0 in references/research-then-install-verify-2026-07-30.md. NEVER post "research complete" without the install + verify pass when the user's goal includes the verb "use".
❌ "User asks the background worker to 'update this thread every minute' — workers cannot post to Slack; the gateway session is the only thread-poster" (added 2026-07-28, Slack C0AH3SD5C79). A background claudem / ao spawn worker runs in its own process with terminal + filesystem access only. It has no Slack MCP tool, no Slack-thread identity, and no way to call mcp__slack__conversations_add_message with the user's thread_ts. When the user asks "tell it to update this thread every minute," the correct answer is structural: the worker cannot do that. The gateway session that spawned it is the only entity that can post. Recipe: (a) state the limitation directly in the thread — "the worker has terminal + filesystem only; it cannot post to this thread"; (b) offer the alternative — "I will post updates here every N minutes from this session by polling process(action='poll') + git -C <wt> status --short"; (c) execute that polling cadence from the gateway session for the duration of the worker run; (d) when the worker completes, post the final state (process exit reason + git log --oneline origin/main..HEAD + test output + PR URL) in a single terminal reply. Anti-pattern: silently letting the worker run and hoping the user can see it from another channel — the user cannot, and "will I actually see updates in this thread or will you never update it again?" is the canonical sign of this gap. The same limitation applies to ALL background workers (claudem / ao spawn / opencode / Codex / openhands) — none of them have Slack-thread identity unless explicitly wired up at the gateway level. Cross-ref the canonical mechanical-closeout recipe at references/worker-execution-checkpoint-gate-2026-07-28.md (worked example: claude/minimax-M3: feat(spellblade): add Valeria campaign prompts and personality contracts @ a1b2275f0f6906b23161046d89280a911c62ca25, $GITHUB_REPOSITORY PR #8661, 6 files / +817 / -0, 54/55 tests pass — the one failure was the worker-import-environment blocker below, NOT a campaign-contract failure).
Sub-case (added 2026-07-28, same PR #8661 incident): the worker's python3 -m unittest call returned 54 passed, 1 failed with ModuleNotFoundError: No module named 'jsonschema'. The failure was not a campaign-contract failure — it was the worker importing the full mvp_site chain (mvp_site.agent_prompts → $PROJECT_ROOT/dice_strategy.py → $PROJECT_ROOT/llm_providers/provider_utils.py → jsonschema) against the system Python, which lacks the transitive dependencies that only live inside the repo's venv/. This is the same trap family as always-pr-never-local-edit v1.5.0 "Worktree-silent-edit trap" — a fresh worktree lacks the repo's environment, and any test that imports the repo's source against the system Python fails on a transitive dep that exists only inside the repo's venv. Detection: ls -la <worktree>/venv/bin/python 2>/dev/null (does the worktree have its own venv?) OR ls -la ~/.hermes/projects/<repo>/venv/bin/python 2>/dev/null (is the canonical repo venv reachable from this host?). Mitigation in the spawn brief: prepend source ~/.hermes/projects/<repo>/venv/bin/activate (canonical repo venv) or source <worktree>/venv/bin/activate (in-worktree venv) before any python3 -m unittest ... call; if the dep is still missing, pip install -r requirements.txt inside the same venv first. For $GITHUB_REPOSITORY specifically: the canonical venv is ~/.hermes/projects/your-project.com/venv/. pip install -r requirements.txt inside it once, then every subsequent worker run inherits the dep set. Cross-ref always-pr-never-local-edit v1.5.0 "Worktree test-import via Path.home() quirk" for the same pattern in a different shape.
When a worker has already produced the intended edits and the next spawn only needs to commit + push, write the brief in this exact shape — generic "continue from here and finish" briefs always re-evaluate:
You are continuing from the existing edits in <worktree>. Do NOT analyze.
Do NOT re-discover. Do NOT inspect unrelated files. Execute a mechanical
closeout now:
1. `git status` and `git diff --stat` to confirm the intended files are present.
2. `git add <exact file1> <exact file2> ...` — the ONLY files named in the
prior worker's diff plus any untracked files in the intended locations.
Do not use `git add -A` or `git add .`.
3. `python3 -m py_compile <python files>` for syntax check.
4. Run the focused test file: `python3 -m unittest <module path> -v`.
Use the repo venv (source ~/.hermes/projects/<repo>/venv/bin/activate)
before invoking python3 so transitive deps resolve.
5. `git commit -m "claude/minimax-M3: <short subject>"` — subject prefix
mandatory per the commit-provenance rule.
6. `git push origin HEAD:refs/heads/<branch>`.
7. Report: exact commands run, exact output, exact commit SHA, exact
remote SHA, exact test summary. If a test fails, still commit and
report the failure.
Do NOT create a PR. The gateway session owns PR creation and Slack-thread
updates.
The brief that failed both times before was "Continue from the existing edits and finish" — workers burned the budget on re-evaluation. The brief that landed was "Do not analyze, do not re-discover, here are the exact files to add, here is the exact commit prefix, here is the exact end-state." Discover / edit / closeout are three different jobs — do NOT mix them in one spawn.
Checkpoint cadence from the gateway session
Per the claude-code-claudem skill v1.6.0 "Worker scope vs gateway scope" pitfall, the worker cannot post to Slack; the gateway session must poll. For background-worker runs that the user wants visible:
# Every ~5 minutes, in the gateway session:echo"=== $(date -u +%FT%TZ) — process status ==="
process_id=<process-id-from-spawn>
ps -p $process_id -o pid,etime,cmd 2>/dev/null || echo"process exited"
git -C <worktree> status --short --branch
git -C <worktree> diff --stat
git -C <worktree> log --oneline origin/main..HEAD 2>/dev/null | head -10
# If running && elapsed > 60s && git diff --stat is empty:# the worker is doing analysis-only work — kill it now, don't wait the full budget.
The "kill on empty + elapsed > 60s" rule is the operationalization of the bullet above — without it, the worker burns the full --max-turns budget on re-evaluation and exits with no code change.
❌ "GitHub REST + GraphQL rate-limit simultaneously at 0 on user ID 13840161 — schedule a one-time cron to re-verify, do NOT keep hammering the API" (added 2026-07-26, $GITHUB_REPOSITORY#8623 follow-up). Verified pattern: gh api rate_limit --jq '{core_remaining: .resources.core.remaining, graphql_remaining: .resources.graphql.remaining}' returns core_remaining: 4245, graphql_remaining: 0 (or core_remaining: 0, graphql_remaining: 0 on subsequent retries), even though the user has thousands of unspent requests in the core bucket. Symptom: gh pr view, gh api repos/.../pulls/<N>, gh api graphql -f query=... all return 403 API rate limit exceeded for user ID 13840161 with request_id E540:... / E789:... style IDs. The bucket the GH API marks is sometimes the user-ID anti-abuse bucket, not the documented core/graphql pair. Recipe: (a) STOP the API hammering after 2 retries (the rep is real); (b) verify durable state locally (git rev-parse origin/<branch>, the new commit SHA, the test harness); (c) post the result to Slack with the durable-state proof + the cron job ID that will re-verify. The user's rule across the SOUL.md ## LOAD commit family is that proof is required, but local SHA + remote SHA + test pass IS proof even when the GH API is blocked. Verified cron recipe:
The next session's first turn (or this session's next turn after the rate-limit window) re-runs the verification and posts the result. Do NOT let the agent stall on "iteration budget exhausted" producing no Slack reply — push-pr-donot-stop-halfway covers the abstract rule; this is the GitHub-side operationalization.
"stop MCP mail from X", "stop the bot from X", "stop X from giving me Y", "stop the cron"
Phase 0.5 disambiguation required — trace symptom provenance to actual source before removing the literal target. See harness-postmortem Phase 0 wrong-target-removal-on-stop-X-from-Y working class + reference references/wrong-target-removal-stop-X-from-Y-2026-07-20.md. If unsure between upstream producer vs downstream consumer, ASK ONE QUESTION — do NOT silently remove the literal noun.
Patch-bundle apply from Slack/upload (added 2026-07-20)
"apply this patch", "use /super to code this", "review and apply infra-XX patch", "git am this"
Phase 0.5b path-validity pre-flight, BEFORE acking the user. Run git apply --check from the actual repo cwd, then if the patch fails, run the cross-fork misroute detection probes (author email domain, base SHA on target repo, source-repo github existence, every diff --git path present in target repo HEAD). See references/patch-bundle-cwd-preflight-2026-07-20.md for the cwd gate + misroute-detection probes + the right ack shape + cleanup recipe. Cross-fork misroute is the github-level analog of the wrong-target-removal pattern (Phase 0.5 disambiguation, "stop X from Y"). The earlier "On it — applying" ack pattern was a premature ack — verify applicability FIRST, ack SECOND.
If the classification is ambiguous after 30 seconds, ASK ONE QUESTION (the only question in this whole pipeline). The user is willing to invest up-front in Q&A specifically to avoid mid-stream steering. Use clarify.
Phase 1 — /fs first if the goal is non-trivial
Trigger /fs if ANY of these are true:
Goal is a new feature or non-trivial refactor (not a 1-line fix)
Goal mentions multiple components, files, or repos
Goal has ambiguous wording that the agent could misinterpret in 2+ ways
Goal is a design task the user wants reviewed
/fs produces spec.md + attractor_spec.md, both codex-cold-reviewed, before any code is written. The user's up-front Q&A investment pays off here — by the time the worker starts, the spec is unambiguous.
Skip /fs if:
Goal is a PR fix on an existing branch (the PR diff IS the spec)
Goal is <50 lines of mechanical change
Goal is investigation / read-only (no code to spec)
Phase 2 — Dispatch (do not self-execute multi-step code work)
For PR fixes: load workflow/drive-pr-to-green and follow its full sequence (worktree at explicit SHA → fix → push → watch CI → clear review → self-merge when authorized).
For new features: dispatch via dispatch-task skill (ao spawn) so the worker gets its own tool-call budget. Inline gateway sessions cap at ~25 tool calls; AO workers have their own budget.
When ao spawn returns Internal server error despite a healthy daemon (ao doctor shows ready + active workers), do NOT keep retrying. Pivot to inline execution per references/ao-spawn-internal-error-pivot-2026-07-12.md. For the conflict-resolution variant (stale PR branch, must preserve PR identity), see references/stale-pr-branch-rebase-conflict-2026-07-14.md — verified on PR #8290.
For new PR from local branch: workflow/always-pr-never-local-edit → fresh worktree from origin/main → port the local diff if needed → push → gh pr create.
For ops/investigation: execute inline (gcloud, curl, file reads). The "inline-able" boundary is one tool call OR a tight sequence with no fork.
For learn + skillify + harness closeout (added 2026-07-14): execute all four actions in order. Do NOT skip any — the user named them together for a reason.
Phase 3 — Drive to conclusion
The dispatched worker OR inline execution runs until one of the end-states in the Contract is provably true. If the worker hits a fork mid-stream:
Apply the user's rule: make the call yourself, surface it in the final reply ("I picked X over Y because Z; if you wanted Y, here's the one-line revert").
Never post a multi-option question to the user mid-stream. The exception is Phase 0 — that's up-front Q&A, which is allowed.
If the fork is truly unrecoverable without user input (e.g. force-push authorization, secrets the agent can't see, env-specific config only the user has), halt with the ONE-LINE BLOCKER shape: "PR #N is at ; one blocker: ."
Phase 4.5 — PR draft and CI truthfulness gate
When the requested end state is “push a draft PR,” distinguish remote reviewability from green CI. A pushed branch is not a PR, and a created draft PR is not green.
Before the final reply:
Verify the branch's exact remote SHA (git ls-remote or REST ref lookup).
Verify the PR exists through an independent read (gh pr view or REST GET /pulls/<number>), including state, draft, headRefName, and head.sha.
Verify ancestry and scope against origin/main; do not rely on the worker's summary.
Query check runs directly. Report success, failure, pending, and skipped separately. mergeable_state=clean means no conflict, not passing CI.
If the PR is draft and required checks are skipped, use the end-state wording “draft PR pushed; CI/evidence incomplete”. Do not say “green,” “ready,” or “all checks pass.”
Resolve the exact PR body to a file and run the outbound-secret gate before any PR create/comment transport. A body reconstructed from memory is not the artifact that was sent.
If GraphQL PR creation hangs or is rate-limited, use the REST fallback documented in dispatch-task/references/rest-pr-create-rate-limit-fallback.md; verify the resulting URL and SHA with a second REST read before claiming completion.
Phase 4.6 — Explicitly separate fix, detector, and evidence blocker
For bug investigations that produce a proposed PR, classify each deliverable as one of:
Root-cause fix — changes the mechanism that causes the defect.
Detector/observability — reports the defect without changing behavior.
Evidence/contract guard — prevents regression or proves an invariant.
A detector must not be reported as the full fix. If the authoritative write/backfill path is unproven, say so directly in the PR body and final report, and name the next evidence required (for example, real-server + real-LLM + BQ capture). This prevents a log-only validator from being mistaken for a state repair.
Every completion reply MUST contain:
End-state declaration — "✅ Done: <green PR #N merged> | <PR #N open + green, awaiting your review> | "
Proof artifact — PR URL, gh pr view JSON, or git log + git diff --stat output, or the actual command output captured
What was decided mid-stream (if anything) — every judgment call the agent made instead of asking, with one-line rationale
No follow-up question — "want me to X?" is the violation. The work is done; the user reviews.
Anti-patterns (do not do)
❌ "I started the worker, will update when done" — the agent has 25 calls; the worker has its own budget. The reply IS the worker. If you have to wait, write the cron babysit reference (see babysit-openclaw skill) and post a status link.
❌ "Here's a design with 3 options, which would you like?" — that's Phase 0 question-count inflation. ONE option (your best judgment) + the path forward. The user's rule: "correct but misinterpret is fine."
❌ "Local commit + ask 'want me to push?'" — always-pr-never-local-edit is in the same skill family; do not violate it.
❌ "Tests pass locally, opening PR now" (then going silent) — the PR URL goes in the final reply, not in a follow-up.
❌ "Investigation complete, here are 6 findings" — every finding needs a "what to do about it" line, and at least one finding must be acted on.
❌ Stopping at "I asked AO to spawn a worker" — that's an ack. The work isn't done until the worker reports OR the cron takes over.
❌ "AO spawn returned Internal server error → gave up" (added 2026-07-14). The 2026-07-12 pivot reference (references/ao-spawn-internal-error-pivot-2026-07-12.md) is the canonical recipe for this wall. The "conflict-resolution variant" recipe (stale PR branch + ao spawn down) is at references/stale-pr-branch-rebase-conflict-2026-07-14.md. Verified PR #8290: ao spawn returned INTERNAL_ERROR on first try → pivoted to inline merge + push → PR went from CONFLICTING to MERGEABLE+CLEAN in one session.
❌ "Used set -e in the conflict-resolution chain" (added 2026-07-14, PR #8290). set -e exits the shell on the first non-zero return code. git commit --no-edit returns 0 only if a commit was actually created; if a prior step in the chain returned non-zero, the script aborts BEFORE the commit fires, leaving the worktree half-resolved. Fix: drop set -e and use explicit && chaining or || true on non-fatal commands.
❌ "Is X finished? → redo X from scratch" (added 2026-06-28). When the user asks whether a recent non-trivial task was finished, do NOT re-pull gog / re-run searches / regenerate the report from scratch. Use session_search + hermes sessions export <path> --session-id <id> to surface the prior session's final assistant text in one turn. The 2026-06-28 audit-recovery case reconstructed a 67-message / 1.55M-cache-token prior session in ~10K tokens by exporting session 20260627_162502_ba20f748. ~150x cheaper, same answer, one reply. Only redo from scratch if the prior session's final text ends in a multi-option menu (it stalled) OR the underlying data has gone stale (the user said "verify it's still correct" not "is it finished"). See references/reconstruct-from-prior-session-2026-06-28.md for the 3-step recipe and decision matrix.
❌ "Ran /learn only — skipped /skillify + /harness + /newb" (added 2026-07-14). When the user types a message containing /learn AND /skillify (often also /harness and /newb), they expect the FULL closeout loop in the same session. Running only /learn and stopping is the same anti-pattern as "tests pass locally, PR is ready, want me to push?" — local-commit-and-ask. The right move is to sequence all four actions (learn → skillify → harness → fresh-worktree verify), each with its own proof artifact, then post the final reply with all four outcomes. Verified incident: Slack thread C09GRLXF9GR/p1784083166 — user said "/learn and /skillify and dont we ahvr a fresh worktree skill or instrucitons to use /newb? lets run /harness and then fix it" in the same message; the four actions are explicitly named and the user expects all four to land, not one. Recipe: (a) load all four skills (learn + skillify + harness-engineering + using-git-worktrees) in parallel at session-start; (b) execute learn first (so the skill update has a memory anchor); (c) execute skillify next (so the reusable workflow is captured); (d) execute harness-engineering after (so mechanical enforcement is layered on top of the soft reminder); (e) verify the fresh-worktree contract last (so the user sees the agent operated from a clean worktree, not a polluted one). See references/learn-skillify-harness-closeout-2026-07-14.md.
❌ "Gate 6b fail — re-ran the workflow and got the same conclusion without re-reading the validator output" (added 2026-07-15, PR #8406). The validator output is NOT in the GH Actions log — it lives in /tmp/pr_description_gate_output.json which gets rm -f'd at end of step. Always reproduce locally with the script pulled from repos/$GITHUB_REPOSITORY/contents/.github/scripts/pr_description_gate.py and the PR body fetched via gh pr view. See references/pr-description-validator-gate6b-2026-07-15.md for the reproducer recipe + LLM marker list + worked example.
❌ "Treated Evidence Gate Check 7 as a one-time failure instead of a per-file category check" (added 2026-07-15, PR #8406). The check's carve-out regex (EVIDENCE_RUNTIME_CONTENT_RE, EVIDENCE_HARNESS_RE, EVIDENCE_MVP_PRODUCTION_RE) determines whether the staleness-tolerance escape hatch applies. PRs touching $PROJECT_ROOT/prompts/** + testing_*/ + $PROJECT_ROOT/** ALWAYS force a fresh capture regardless of how trivial the change looks. Path A is fresh capture (~10 min); Path B is truthful acceptance + MERGE APPROVED. For NON_PRODUCTION tier PRs (testing-only + prompt-doc only) Path B is acceptable when the bundle proves the load-bearing change. Document which path you took in the PR body ## Known Limitations.
❌ "UI change with 'add X to settings and prove it works' → claimed X is in the dropdown but no captioned screenshot/video is attached" (added 2026-07-22, Slack thread C0AH3RY3DK6, $GITHUB_REPOSITORY add-gemini-flash-models-to-settings). When the user message contains all three of ("add X to settings", "iterate and test", "get captioned video / captioned screenshot proof"), the deliverable is the visual evidence IN the reply, not a description of the change plus a local file path. Jeffrey's verbatim reply (verbatim, 2026-07-22): "Is this finally wokring? show me captioned screeshots/video here. why didnt you alreayd?" — the "why didn't you already?" is the canonical sign the agent stopped after writing the code without producing the proof. The audit-before-claim half of this rule is in grep-before-constant-change (every layer touched, same commit) — the proof-before-claim half is here. Concrete gates BEFORE posting "done":
Audit-every-layer first — rg -n "<model-name>|<setting-key>" -g '*.{py,js,ts,tsx,html,json}' across $PROJECT_ROOT/constants.py, $PROJECT_ROOT/templates/settings.html, $PROJECT_ROOT/frontend_v1/js/settings.js, $PROJECT_ROOT/llm_providers/* allowlists, $PROJECT_ROOT/constants.pyMAX_INPUT_TOKENS/MAX_OUTPUT_TOKENS maps, $PROJECT_ROOT/tests/test_* — every registry, alias, limit map, backend allowlist, settings template, frontend mapping, and test that names the key. Edit all of them in the same commit. Skip a layer → the setting silently fails or is hidden.
Run the app (local.sh or equivalent) and exercise the actual UI element headlessly. Capture a BEFORE PNG showing the missing option, then an AFTER PNG showing the option present + selected + saved (reload state proves persistence).
Capture a captioned MP4 (Playwright record_video or ffmpeg over a sequence of PNGs) of the click-through. Caption the MP4 in-place (ffmpeg -vf "drawtext=..." or mp4-caption-burn skill).
Upload via 3-stage files.completeUploadExternal — bare MEDIA:/path text tokens render as literal text in mcp__slack__conversations_add_message and the user sees no attachment. See evidence-attach-to-slack + evidence-attach-presend-gate.
via that the new message has a populated . If empty, the upload failed silently — retry.
Forbidden reply shapes for this task class:
"Settings now include X" with no attached PNG/MP4.
"Evidence saved to /tmp/foo.png" (path is not viewable to the user in Slack).
"Running local.sh now" with no follow-up.
"The change is on branch <branch> ready for review" when no visual proof has been produced yet.
If you cannot complete the full chain in one session, say so explicitly with the exact missing piece: End state: blocked/in progress — not proven working. No PR URL or visual evidence exists yet. Do NOT claim "settings now include X" until evidence is in-thread.
❌ "Removed the literal noun from 'stop X from Y' without tracing symptom provenance" (added 2026-07-20, Slack thread C0AJ3SD5C79/p1784344760053389). When the user says "stop X from Y" / "stop X from giving me Z" / "stop X from doing W", the agent's default is to remove the named noun X. But X is almost always a downstream consumer (a cron, a delivery channel, a notification path); the symptom Y is almost always produced by an upstream source. Verified incident: user said "Lets stop mcp mail from giving these reports" — agent removed clawchief:ea-sweep-hourly (the cron posting the briefs to the DM). Actual source was the MCP Agent Mail agent with Socket-Mode listener ingesting Slack messages into MCP, then re-posting agent replies via chat.postMessage. User feedback (verbatim): "No keep the job you fucking idiot — I said mcp mail agent I don't want it passively listening to my threads." Phase 0.5 disambiguation rule: (a) identify the symptom noun ("these reports", "passively listening", "self-reports") — this is what the user wants to STOP; (b) identify the named target X — usually a consumer; (c) trace the data path from X back to its source (cron → script → MCP server → external API; Slack → Socket-Mode listener → MCP message → agent reply → chat.postMessage); (d) the fix lives at the source layer, not the consumer; (e) if provenance is ambiguous, ASK ONE clarifying question — do NOT silently remove the literal noun. Companion reference: harness-postmortem/references/wrong-target-removal-stop-X-from-Y-2026-07-20.md + SOUL.md ## COMMIT: mcp-agent-mail-no-passive-slack-listening.
Loader / auto-fire contract
This skill is registered in ~/.hermes_prod/skills/RESOLVER.md and the ## COMMIT: finish-the-job block in SOUL.md makes it load automatically for any user message that contains a goal phrase ("can you X", "please Y", "make Z", "investigate A", "fix B"). The trigger phrases are listed in the YAML frontmatter at the top of this file.
When auto-fired: Phase 0 runs first. If classification returns PR-fix / new-code / new-PR, the skill proceeds autonomously. If classification returns investigation / ops, the skill executes inline and posts the final reply with proof. If classification returns learn + skillify + harness closeout (added 2026-07-14), all four sub-actions execute in order.
When explicitly invoked (/finish <goal>): Same as auto-fire, but the user has signaled they want this pipeline regardless of the goal shape.
Deploy sync awareness (read this before rolling out a finish-the-job artifact)
scripts/deploy.sh Stage 4.5 only syncs POLICY_FILES=(CLAUDE.md SOUL.md TOOLS.md HEARTBEAT.md). It does NOT sync skills/ or skills/RESOLVER.md. A skillify pass that creates ~/.hermes_prod/skills/<name>/ works locally, but:
If you only wrote to prod, the staging git checkout at ~/.hermes/skills/<name>/ is empty — a future git pull --ff-only won't reintroduce it.
If you wrote to staging only, the prod resolver won't see the skill — ~/.hermes_prod/skills/RESOLVER.md won't have the trigger entry.
If you wrote both, you still need a manual cp ~/.hermes/SOUL.md ~/.hermes_prod/SOUL.md (the symlink at ~/.hermes/SOUL.md → ~/.hermes/workspace/SOUL.md lands in the staging tree; deploy copies it to prod) — UNLESS you run deploy.sh end-to-end and accept the canary + restart.
The skillify anti-pattern guard (run in the same turn as any rollout claim):
Test portability (CodeRabbit MAJOR, 2026-06-19): the test file tests/test_finish_the_job_contract.py uses HERMES_PROD_SKILLS (env var, defaults to $HERMES_HOME/skills) instead of a hardcoded $HOME/... path. Run the tests with:
If items 1-7 land in the same turn as the rollout and 8-9 land within the next deploy cycle, the work is done. Anything outside that pattern is a half-finished rollout — apply the same anti-pattern audit you'd apply to a PR.
Related skills — load order when this fires
dark-factory (always — for the /f and /fs definitions)
drive-pr-to-green (only if goal shape is PR-fix)
always-pr-never-local-edit (only if goal shape is new-PR or local-changes-exist)
dispatch-task (only if Phase 2 decides to dispatch via ao spawn)
dropped-messages (only if the goal was itself a dropped-thread recovery — meta-finish)
session-history-search (only if the user's question is "is X finished?" — reconstruct from prior session before redoing work; see references/reconstruct-from-prior-session-2026-06-28.md)
pr-cleanup-replay (added 2026-07-14 — only if goal is a polluted-PR cleanup; Phase -1 prevention + Strategy A/B recovery + references/gitleaks-pre-push-hook-bypass.md for the 4259-leaks hook bug)
references/patch-bundle-cwd-preflight-2026-07-20.md (added 2026-07-20, extended 2026-07-20 with cross-fork misroute detection probes) — only if the user's input IS a patch bundle uploaded as a Slack attachment or ~/Downloads file; git apply --check cwd pitfall, cross-fork misroute detection probes (author email + base SHA + source-repo github existence + every diff --git path present in target repo HEAD), /super redirect, /aar semantic mismatch, claude -p rate-limit fallback, right ack shape on misroute, cleanup recipe (br close + locked-worktree git worktree remove --force --force + .git/rebase-apply/ wipe).
learn + skillify + harness-engineering + using-git-worktrees (added 2026-07-14 — load all four in parallel when classification returns learn + skillify + harness closeout)
Reference map — when each reference applies
references/ao-spawn-internal-error-pivot-2026-07-12.md — AO ao spawn returns INTERNAL_ERROR despite healthy daemon. Decision matrix for pivot-to-inline vs surface blocker. Verified on PR #8337.
references/stale-pr-branch-rebase-conflict-2026-07-14.md — companion to the above for the CONFLICTING-PR variant: merge vs rebase decision matrix, --theirs/--ours semantics flip, set -e pitfall, --force-with-lease push to original PR branch, GitHub auto-merge cycle, single-gate pool-exhaustion end-state. Verified on PR #8290.
references/no-stop-after-clarify-silence-2026-07-14.md — 60-min clarify silence ≠ stop authorization. Drive to PR-open end-state in the same session. Verified on PRs #328 + #8402.
references/reconstruct-from-prior-session-2026-06-28.md — when the user asks "is X finished?", reconstruct from prior session via session_search + hermes sessions export instead of redoing. Verified on the 2026-06-28 audit-recovery case.
references/learn-skillify-harness-closeout-2026-07-14.md (added 2026-07-14) — when the user types /learn + /skillify + /harness + /newb in the same turn, the FULL closeout loop is required: learn → skillify → harness-engineering → fresh-worktree verify. Verified on PR #329 clean replay + SOUL.md ## COMMIT: never-push-onto-someone-elses-pr-head + pr-cleanup-replay Phase -1 + 3 new contract tests.
references/pr-description-validator-gate6b-2026-07-15.md (added 2026-07-15) — $GITHUB_REPOSITORY Gate 6b PR description validator (pr_description_gate.py) + Evidence Gate Check 7 freshness policy + Skeptic Gate 7 (NOT LIVE in this repo). Pull-the-validator-locally recipe + LLM marker list + behavioral-file regex carve-out + Path A (fresh capture) vs Path B (truthful acceptance + MERGE APPROVED). Verified on PR #8406.
references/wrong-target-removal-stop-X-from-Y-2026-07-20.md (added 2026-07-20) — Phase 0.5 disambiguation for "stop X from Y" requests where the named target X is the wrong target (downstream consumer). Trace symptom provenance to actual source before removing the literal noun. Companion to harness-postmortem Phase 0 working class wrong-target-removal-on-stop-X-from-Y. Verified on Slack thread C0AJ3SD5C79/p1784344760053389.
references/prompt-contract-cr-scope-broadening-2026-07-21.md (added 2026-07-21) — when CodeRabbit flags static-content blockers (named-entity leaks, formula/example mismatch, hidden-state leaks, contradictory clause pairs, malformed placeholders) wider than the existing static test enforces, the canonical recipe is: (1) broaden the existing static test's forbidden list FIRST, (2) run it locally to enumerate the leak surface before any prompt edit, (3) add a LockdownTests class with contract-pinning assertions for the OTHER 4 blocker classes (exact formula substring, exact phrasing, exact no-leakage of artifacts), (4) commit + push as one PR ref. Companion to references/pr-description-validator-gate6b-2026-07-15.md for prompt-edit PRs specifically. Verified on $GITHUB_REPOSITORY PR #8488 V3.21 (head f9f269a685).
references/eval-stall-on-preflight-menu-2026-07-22.md (added 2026-07-22) — when a user goal has 3+ clear verbs (clone, evaluate, replay, decide if X is right) and the agent stalls on a pre-execution menu, this is the same anti-pattern family as the "3-option mid-stream menu" but at the pre-tool-call stage. Recipe: execute the verbs in sequence, surface judgment calls in the final reply, and treat the user's preflight-question request as a signal that the agent failed to extract verbs from the goal. Companion class skill: vendor-ml-artifact-eval for the third-party-router / third-party-classifier evaluation recipe that this stall was about.
references/bq-runnable-diagnostic-first-2026-07-23.md (added 2026-07-23) — BQ-runnable-diagnostic sub-case of the preflight-menu anti-pattern. When a bug class is in a known taxonomy AND a runnable diagnostic exists for that class, the diagnostic is the first tool call, not a clarifying menu. 6-bullet heuristic + verbatim incident from issue #8528 + companion to repro Step 0.77. Generalizes the worldarchitect-specific Step 0.77 to any domain with a known taxonomy + runnable diagnostic.
references/ui-change-add-X-and-prove-it-2026-07-22.md (added 2026-07-22) — when the user message contains all three of ("add X to settings", "iterate and test", "captioned video / captioned screenshot proof"), the deliverable is the visual evidence IN the reply, not a description of the change. Audit-every-layer recipe (constants, templates, frontend maps, backend allowlists, limit maps, tests), run app, BEFORE/AFTER PNGs, captioned MP4, 3-stage Slack upload, vision-verify. Companion skills: grep-before-constant-change, evidence-attach-to-slack, evidence-attach-presend-gate, ui-change-requires-before-after-visual-proof, web-page-screenshots, mp4-caption-burn. Verified on $GITHUB_REPOSITORY add-gemini-flash-models-to-settings Slack thread C0AH3RY3DK6/p1784653940 (Jeffrey verbatim: "Is this finally wokring? show me captioned screeshots/video here. why didnt you alreayd?").
references/two-pr-dispatch-evidence-pattern.md — class-level recipe for splitting independent mechanisms into sibling PRs, independently proving draft PR creation, distinguishing fix/detector/guard, and separating dynamic LLM directive delivery from structured-state persistence.
references/codex-docker-workdir-path-resolution-2026-07-24.md (added 2026-07-24) — module-relative file paths MUST resolve via os.path.dirname(__file__), not via repo-root prefix. Codex P1 caught on PR #8548: os.path.join("mvp_site", constants.X_PATH) works in dev (cwd=repo) but raises FileNotFoundError in Docker (WORKDIR=/app/mvp_site). Recipe: grep pre-merge, fix with os.path.dirname(__file__), add unittest-level source-inspection regression test, push on the same branch. Also covers the monkeypatch/tmp_path vs unittest.TestCase pitfall + the POST /repos/{owner}/{repo}/issues/{number}/comments reply endpoint that actually works (the pulls/{number}/comments/{id}/replies returns 404).
references/local-sh-canonical-launcher-2026-07-24.md (added 2026-07-24) — local.sh is the canonical local-evidence launcher for any /es ask; python -m <package>.main serve directly is NOT canonical even if it boots cleanly. Four things local.sh does that direct invocation skips: cache-busted frontend copy (/tmp/<worktree>/<branch>/), ENABLE_SEMANTIC_ROUTING=true + TESTING=false env vars, full venv pip-install, /api/campaigns health-check gate. Plus the served-bundle byte-identity verification recipe (curl the served JS, sha256 it, sha256 the on-disk source, both must match — document in PR body). Verified on $GITHUB_REPOSITORY PR #8561 (mobile scroll indicator chevron clean replay of #8139). User pushback verbatim: "You did you run a fresh local.sh server to get the proof?". Compounding anti-pattern documented: "frontend-only change so local.sh's other pieces don't matter" — wrong on the cache-busted-frontend and standard-env-vars axes even when right on the React-v2 axis (local.sh line 867 explicitly says React v2 is removed). Companion to references/ui-change-add-X-and-prove-it-2026-07-22.md (which already says "Run the app (local.sh or equivalent)" — this reference is the strict canonical form for the $GITHUB_REPOSITORY repo where local.sh IS the equivalent, not a substitute).
references/pre-merge-worktree-sabotage-inspection-2026-07-24.md (added 2026-07-24) — BEFORE any gh pr merge on a worktree touched by a prior session, run a 4-line worktree audit (git rev-parse HEAD + git diff HEAD + git diff --cached HEAD + git rev-parse origin/<branch>) to catch staged-but-uncommitted reverts of committed fixes. The Green Gate, CodeRabbit, and gh pr view mergeable: MERGEABLE all evaluate the COMMITTED head SHA — they do NOT see the working tree. If a prior session git add-ed staged reverts (or a malicious agent did), git status will show them and gh pr merge will silently ship the reverted main. Verified on PR #8548: 2 staged reverts of commit ac5d0c400b (reverting os.path.dirname(__file__) to the buggy os.path.join('mvp_site', ...) + deleting the regression test). Recipe + the git diff HEAD vs git diff --cached HEAD distinction + the regression-test-detection loop + the git restore --staged && git checkout discard pattern. Class-level rule: the working-tree end of the merge path is the agent's responsibility; the committed end is the harness's. Companion to the race-with-AO-worker addendum in drive-pr-to-green v2.5.10(b) — that catches the REMOTE-side race; this catches the LOCAL-side sabotage. Bead rev-mgju0 / issue #8563.
Worked example — the 2026-06-19 incident
User said: "Look at the last week of slack threads with work that started but didn't finish. … Is there some way we can /skillify Hermes to be more hands off? I want it to fully drive everything to a conclusion like a final /green PR … correct but misinterpret is fine but stopping halfway is not."
Phase 0 classified: meta / about-Hermes (skillify skill).
Phase 1: /fs was unnecessary — the request itself is a skillify task, not a feature implementation.
Phase 2: Inline execution (single-session skillify pass). No dispatch needed.
Phase 3: Built the skill, ran the 10-item checklist, deployed, verified all artifacts in the same turn.
Phase 4: Final reply with the 10-item re-audit (counts of files, line numbers, deploy SHA) — no follow-up question. The user's rule is satisfied: the work landed, the skill is reachable from the resolver, the SOUL.md commit fires it automatically on the next goal-shaped message.
Worked example — the 2026-07-14 PR #8290 incident
User asked for fullrun on the Slack digest next-actions. The digest flagged: "Daily Level Up (4/8) + Dice Audit (1/2) tests FAILED on 2026-07-14." PR-topology pre-flight identified PR #8290 (feat/daily-level-up-2026-07-08, head f81c860e0) as the canonical fix — but mergeable=CONFLICTING.
Phase 2: ao spawn --claim-pr 8290 --no-takeover --prompt "..." returned Internal server error (INTERNAL_ERROR) despite ao doctor showing the daemon healthy. Per references/ao-spawn-internal-error-pivot-2026-07-12.md, pivoted to inline execution.
Phase 3: Used the verified recipe from references/stale-pr-branch-rebase-conflict-2026-07-14.md. git fetch origin main pull/8290/head:pr8290; git checkout -B fix/pr8290-rebase origin/main; git merge pr8290 --noff --no-edit. One conflict in $PROJECT_ROOT/tests/test_prompt_embedding_store.py — caused by PR #8394 narrowing the deploy-probe contract test after #8290's branch was created. Read conflict markers (grep -nE "<<<<<<< |=======|>>>>>>>"), took HEAD (main, post-#8381 narrower contract — newer wins). git add + git commit --no-edit (dropped set -e after the first attempt aborted the chain before the commit). Pushed with --force-with-lease origin fix/pr8290-rebase:feat/daily-level-up-2026-07-08. PR went from CONFLICTING → MERGEABLE+CLEAN.
Phase 4: Final reply with PR URL, new head SHA 3cbbaf6b7c → GitHub auto-merge cycle produced aff95f87e3, all Gates 1-6 PASS, single remaining gate is the documented pool-exhaustion pattern (verified on 6+ other PRs). Posted PR comment with full resolution notes. Created one-time follow-up cron 13d12449f1cf per one-time-status-cron-after-every-task. User owes MERGE APPROVED.
Worked example — the 2026-07-14 PR #329 + learn/skillify/harness closeout incident
User typed (Slack thread C09GRLXF9GR/p1784083166): "this isnt a clean PR from origin main why do you kee pscrewiing this up? /learn and /skillify and dont we ahvr a fresh worktree skill or instrucitons to use /newb? lets run /harness and then fix it".
Phase 0 classified: learn + skillify + harness closeout (four actions named in the same message — load all four skills, do NOT pick one).
Phase 2: Inline execution. PR-topology pre-flight: PR #321 in jleechanorg/claude-commands is open with head 1a43307a0 (the agent earlier commits) sitting on top of the legitimate head 286311a97 (+670k/-24k / 3001 files baseline). The earlier git push origin HEAD:refs/heads/fix/real-claude-team-tmux polluted the PR. Recovery via pr-cleanup-replay Strategy B (extract file diff). Opened PR #329 with 1 commit / 5 files / +427/-691 branched from origin/main. Closed PR #321 with reference. Hit the gitleaks pre-push hook bypass (4259 false-positive leaks from pre-existing history) — applied git -c core.hooksPath= push -u origin fix/sidekick-5min-checkpoint for the one-shot push.
Phase 3 (closeout loop):
/learn: wrote ~/.claude/projects/-Users-$USER-claude-commands/memory/feedback_2026-07-14_feedback-pr-push-onto-someone-elses-pr-head-pollution.md + appended to ~/roadmap/learnings-2026-07.md + created + closed bead $USER-4a9.
/skillify: extended pr-cleanup-replay with Phase -1 (Prevention), updated RESOLVER.md heading with prevention triggers, added 3 new contract tests (5 → 8 passing). Added references/gitleaks-pre-push-hook-bypass.md (this skill new reference file).
/harness: added ## COMMIT: never-push-onto-someone-elses-pr-head to SOUL.md with Trigger/Action/Why/Files; created docs/agent/anti-patterns.md overlay in the worktree (untracked, for a future PR).
If the working tree has staged reverts of committed fixes, the right move is git restore --staged <files> && git checkout -- <files> (discard the sabotage) BEFORE running gh pr merge. The HEAD commit is the artifact the user reviewed and approved — not the working tree. Verified 2026-07-24: discarded staged reverts of 2 files, ran pytest to confirm 17/17 contract tests still pass at HEAD, then gh pr merge --squash --delete-branch produced clean merge commit 80400c9685 on origin/main. Companion: see references/pre-merge-worktree-sabotage-inspection-2026-07-24.md for the full transcript + the git status vs git diff HEAD vs git diff --cached HEAD distinction + the 4-line audit that takes 10 seconds. Class-level rule (added to agent-autonomy.mdc future): any pre-merge audit must include the local worktree's git diff HEAD, not just origin/<branch> state. The Green Gate covers the COMMITTED end of the path; the working-tree end is the agent's responsibility.
Verify
conversations.replies
files[]
Vision-verify the captions and UI with vision_analyze BEFORE posting — "both screenshots show the new option" must be a verified claim, not a description.
