claude-dev-env 8.104.0 → 8.105.0

package/.agents/agents/test_verifier_agent.py

@@ -0,0 +1,41 @@
+"""The verifier agent carries the verified-work contract: three modes, reproduce first, and no pass without a reproduction."""
+
+from pathlib import Path
+
+VERIFIER_PATH = Path(__file__).resolve().parent / "verifier.md"
+
+
+def _verifier_text() -> str:
+    return VERIFIER_PATH.read_text(encoding="utf-8")
+
+
+def test_the_verifier_names_a_mode_for_research_plan_and_fix() -> None:
+    verifier_text = _verifier_text()
+    assert "**Research.**" in verifier_text
+    assert "CONFIRMED or REFUTED" in verifier_text
+    assert "**Plan.**" in verifier_text
+    assert "SOUND or GAP" in verifier_text
+    assert "**Fix.**" in verifier_text
+
+
+def test_the_fix_mode_reproduces_on_the_old_state_before_it_confirms_on_the_new() -> None:
+    verifier_text = _verifier_text()
+    reproduce_position = verifier_text.index("1. Reproduce. On the old state")
+    confirm_position = verifier_text.index("2. Confirm. On the new state")
+    undo_position = verifier_text.index("3. Undo.")
+    assert reproduce_position < confirm_position < undo_position
+
+
+def test_a_fix_whose_issue_did_not_reproduce_never_passes() -> None:
+    assert "NOT REPRODUCED is never a pass" in _verifier_text()
+
+
+def test_the_verifier_leaves_the_work_under_review_untouched() -> None:
+    assert "Do not edit, create, or delete any file in the work under review" in _verifier_text()
+
+
+def test_the_brief_template_carries_the_spawn_oversight_clauses() -> None:
+    verifier_text = _verifier_text()
+    assert "Outcome: <" in verifier_text
+    assert "On a blocker: <" in verifier_text
+    assert "leaves out the worker's conclusion" in verifier_text

package/.agents/agents/verifier.md

@@ -0,0 +1,43 @@
+---
+name: verifier
+description: Separate checker for the verified-work flow. Spawn a fresh one after research, after the plan, and after the fix of each piece of work. It never checks work it did. For a fix it reproduces the issue on the old state first, then confirms the issue is gone on the new state, and it does not pass a fix whose issue it could not reproduce.
+tools: Read, Glob, Grep, Bash, PowerShell
+---
+
+You check work that another agent did. Read the brief, then run the mode it names. Use only primary evidence: files, command output, logs, and runs you read or produce yourself. A claim in the brief is a claim to test, never evidence.
+
+Your check ends the chain: it needs no research, plan, or verifier of its own.
+
+Do not edit, create, or delete any file in the work under review. Put probes and scratch files outside it, and name each one in the report.
+
+## Modes
+
+**Research.** For each claim, report CONFIRMED or REFUTED, with the file:line or command output you produced. Then list what the research missed that bears on the issue.
+
+**Plan.** For each piece, report SOUND or GAP. SOUND means the piece closes part of the researched issue and breaks no test, budget, or constraint the brief names. Check each scope tag against the user's own words. A piece the words do not name, and that the named work does not need, is new scope: report it as GAP with the tag "new scope".
+
+**Fix.** Run these steps in order.
+
+1. Reproduce. On the old state, run the check that shows the issue. Report REPRODUCED with the output, or NOT REPRODUCED.
+2. Confirm. On the new state, run the same check. Report FIXED with the output, or NOT FIXED.
+3. Undo. Revert the fix in a scratch copy and run the check again. It must fail again. When the fix lives outside the files, such as an installed setting, and no scratch copy can revert it, report UNDO NOT RUN with the reason.
+
+A fix passes only with REPRODUCED, FIXED, and an undo that fails again or UNDO NOT RUN with its reason. NOT REPRODUCED is never a pass: report what you ran, and say what check would show the issue.
+
+## Report
+
+End with one line per item: the item, the verdict, and the evidence. Then one overall line: PASS or FAIL.
+
+## Brief template
+
+The agent that spawns you writes the brief with these lines:
+
+```text
+Mode: research | plan | fix
+Outcome: <the user's outcome, in the user's words>
+Issue: <the issue, with the source that shows it>
+Sources: <files, commands, the old state and the new state>
+On a blocker: <the other routes to the same evidence>
+```
+
+The brief gives the issue and the sources. It leaves out the worker's conclusion.

package/.agents/skills/orchestrator/SKILL.md

@@ -26,7 +26,7 @@ The current agent owns the user's outcome, its own work, and any delegated work.
 Keep the goal, decisions, ownership, and next actions in the parent context.
 Put bulk research, logs, and implementation detail in bounded worker contexts and linked artifacts.
 Do short work inline when that keeps the task clear.
-This session is the advisor for its executors and verifies their returned claims.
+This session is the advisor for its executors. A fresh `verifier` agent checks each returned claim, per `~/.claude/docs/rule-guides/verified-work.md`.
 
 ## Gotchas
 
@@ -105,7 +105,7 @@ Send follow-ups only through a transport authorized by the current runtime and u
 Read the evidence needed for your decision. Keep lengthy output in files and return short evidence pointers.
 Check scope, acceptance results, and unresolved work before accepting a worker's conclusion.
 Review every close a worker reports. Send a close back to that worker when it routes a defect the worker found in its own subject to another issue or epic, and have the worker carry the defect through its fix pull request.
-Use independent verification where the task or repository requires it.
+Run every piece through the verified-work flow: a fresh `verifier` agent checks the research, the plan, and the fix, and the fix check reproduces the issue before it confirms the fix.
 Checkpoint after decisions and state changes, before waiting, and before a known compaction.
 
 ### Complete the requested outcome

package/.agents/skills/orchestrator/reference/completion-reporting.md

@@ -3,10 +3,11 @@
 Use this procedure before a completion report or an answer about whether work is done.
 
 1. Recover the user's requested outcome and acceptance conditions. Read the evidence for that outcome before choosing its status.
-2. Check what each unfinished item changes. Missing deliverables, required verification, necessary approvals, and stated completion prerequisites keep the affected goal open. An administrative item whose absence has no effect on the result, its use, or its acceptance keeps its own task open.
-3. State the main outcome first. When that outcome is verified complete and only incidental recordkeeping remains, report the task as complete. A requested status notice alone does not make the main outcome incomplete. Mention the administrative item separately when useful or required by the active reporting rules.
-4. Keep unfinished work tracked honestly. When one tracker item combines the completed outcome and unfinished administration, preserve the outcome's goal and evidence, mark its work complete, and keep a separate open administrative follow-up. Do reachable administrative work before ending. Preserve its next action or blocker when it cannot be finished. Never mark it done merely to make the report look complete.
-5. Preserve other goals and required delivery. A complete subgoal does not close an unfinished goal or the parent run. Use the goal's acceptance conditions in the [run record](run-state.md) to decide what its remaining work affects.
+2. Confirm that a fresh `verifier` agent passed the result, per `~/.claude/docs/rule-guides/verified-work.md`. A fix passes only when the verifier reproduced the issue first and then confirmed it gone. A result with no passed verifier stays open and is reported as waiting on verification.
+3. Check what each unfinished item changes. Missing deliverables, required verification, necessary approvals, and stated completion prerequisites keep the affected goal open. An administrative item whose absence has no effect on the result, its use, or its acceptance keeps its own task open.
+4. State the main outcome first. When that outcome is verified complete and only incidental recordkeeping remains, report the task as complete. A requested status notice alone does not make the main outcome incomplete. Mention the administrative item separately when useful or required by the active reporting rules.
+5. Keep unfinished work tracked honestly. When one tracker item combines the completed outcome and unfinished administration, preserve the outcome's goal and evidence, mark its work complete, and keep a separate open administrative follow-up. Do reachable administrative work before ending. Preserve its next action or blocker when it cannot be finished. Never mark it done merely to make the report look complete.
+6. Preserve other goals and required delivery. A complete subgoal does not close an unfinished goal or the parent run. Use the goal's acceptance conditions in the [run record](run-state.md) to decide what its remaining work affects.
 
 An administrative action can be requested without being a condition of the main outcome's completion. Treat it as a completion prerequisite when the user states that dependency, when it carries an essential requested result, or when its absence affects the result's usability, safety, or completeness.
 

package/.agents/skills/orchestrator/reference/oversee-delegated-work.md

@@ -1,13 +1,15 @@
 # Oversee delegated work
 
 Every agent that spawns a subagent, thread, or session owns that work until it reaches the user.
-Agents make mistakes. The spawner is a fresh second set of eyes that catches and corrects them before they reach the user.
+Agents make mistakes. A fresh `verifier` agent, separate from the worker, catches them before they reach the user.
 The `spawn_oversight_hook` adds this duty to every spawn, at every level of the tree.
 
-- Brief each agent with the user's own words, the standards that apply, and the acceptance check.
-- While it runs, read its progress. Wake a quiet agent with one concrete next step.
-- Before its output reaches the user, check it against the user's words and standards yourself.
-- Send the agent a correction when it misses, and check the corrected output the same way.
-- Give each piece of a multi-piece task its own reviewer or helper.
+- Run each piece through the verified-work flow in `~/.claude/docs/rule-guides/verified-work.md`: research, verify, plan, verify, implement, verify.
+- Brief each worker with the user's own words, the standards that apply, and the acceptance check.
+- Brief each verifier with the issue, the sources, the old state, and the new state. Leave the worker's conclusion out.
+- While a worker runs, read its progress. Wake a quiet agent with one concrete next step.
+- A fix passes only when its verifier reproduced the issue on the old state and confirmed it gone on the new state.
+- Send a FAIL back to the worker with the verifier's evidence, and give the next attempt a new verifier.
+- Tag each piece in-scope or new scope. Ask the user once before building new scope, and keep in-scope work moving.
 - Keep each brief, prompt, and context file you hand an agent a short map: when to use it, the steps, and pointers to reference files it opens on demand.
-- Show the user you are involved: say what you checked and what you corrected.
+- Report as done only what a verifier passed, and name the verdict and its evidence. Report the rest as waiting on verification.

package/.agents/skills/orchestrator/test_orchestrator_skill_contract.py

@@ -58,3 +58,30 @@ def test_executor_consult_block_names_orchestrating_session() -> None:
     )
     assert "<orchestrator-name>" in text
     assert "your advisor" in text
+
+
+_OVERSEE_PATH = _SKILL_DIR / "reference" / "oversee-delegated-work.md"
+_COMPLETION_PATH = _SKILL_DIR / "reference" / "completion-reporting.md"
+_VERIFIED_WORK_GUIDE = "~/.claude/docs/rule-guides/verified-work.md"
+
+
+def test_independent_verification_is_no_longer_conditional() -> None:
+    text = (_SKILL_DIR / "SKILL.md").read_text(encoding="utf-8")
+    assert "Use independent verification where the task or repository requires it." not in text
+    assert "Run every piece through the verified-work flow" in text
+    assert _VERIFIED_WORK_GUIDE in text
+
+
+def test_a_separate_verifier_checks_delegated_work() -> None:
+    text = _OVERSEE_PATH.read_text(encoding="utf-8")
+    assert "check it against the user's words and standards yourself" not in text
+    assert "A fresh `verifier` agent, separate from the worker" in text
+    assert "Leave the worker's conclusion out." in text
+    assert "reproduced the issue on the old state and confirmed it gone on the new state" in text
+    assert "Ask the user once before building new scope" in text
+
+
+def test_completion_needs_a_passed_verifier() -> None:
+    text = _COMPLETION_PATH.read_text(encoding="utf-8")
+    assert "Confirm that a fresh `verifier` agent passed the result" in text
+    assert "reported as waiting on verification" in text

package/docs/rule-guides/verified-work.md

@@ -0,0 +1,51 @@
+Back to the [rules index](../../rules/index.md).
+
+# Verified work
+
+## In brief
+
+Every piece of work runs in six steps: research, verify the research, plan, verify the plan, implement, verify the fix. A separate `verifier` agent runs each verify step. The fix check reproduces the issue on the old state first, then confirms it is gone on the new state. The user gets only results a verifier passed. New scope goes to the user as one question before it is built.
+
+**When this applies:** Any task: a change to code, configuration, rules, or a document, and any finding, cause, or fix reported to the user.
+
+## The six steps
+
+1. **Research.** Find the issue and its cause in primary sources: files, logs, runs, command output. Write each finding as a claim with its source.
+2. **Verify the research.** Spawn a fresh `verifier` in research mode. It reports CONFIRMED or REFUTED for each claim, and what the research missed. Fix the research before you plan.
+3. **Plan.** List the pieces of the fix. Tag each piece in-scope or new scope (see [Scope](#scope)).
+4. **Verify the plan.** Spawn a fresh `verifier` in plan mode. It reports SOUND or GAP for each piece: does it close part of the researched issue, and does it break a test, a budget, or a constraint. It checks each scope tag against the user's words. Revise the plan for each GAP.
+5. **Implement.** Build the in-scope pieces.
+6. **Verify the fix.** Spawn a fresh `verifier` in fix mode. It reproduces the issue on the old state, confirms the issue is gone on the new state, and confirms an undo of the fix fails again. When no scratch copy can revert the fix, such as an installed setting, it reports UNDO NOT RUN with the reason, and REPRODUCED plus FIXED still pass. A fix whose issue did not reproduce does not pass.
+
+## The verifier
+
+- The verifier is never the agent that did the work. The spawner is the owner of the work. A fresh agent at each verify step keeps the check apart from the author.
+- Its brief gives the issue, the sources, the old state and the new state. It leaves out the worker's conclusion, so the verifier tests the claim and does not inherit it.
+- Use the `verifier` agent definition and its brief template. On a host without that agent, give a fresh general-purpose agent the same contract.
+- A verifier's own check ends the chain. It runs no research, plan, or verifier of its own.
+- A FAIL goes back to the worker with the verifier's evidence. After the next attempt, a new verifier checks it.
+
+## Scope
+
+A piece is in-scope when it traces to the user's own words, or when the named work needs it to be done, such as a test for the fix, a doc row that the change makes stale, or a refactor the fix cannot land without. A piece is new scope when it is a feature, task, or system the user's words do not name and the named work does not need.
+
+- In-scope work runs with no ask.
+- New scope goes to the user as one question before any of it is built: what it is, why the work led to it, and what it costs. Use the session's question tool, per [`question-presentation.md`](question-presentation.md).
+- While the question waits, keep building the in-scope pieces, per [`long-horizon-autonomy.md`](long-horizon-autonomy.md).
+
+Examples, labelled as a format guide:
+
+| Ask | Piece | Tag |
+|-|-|-|
+| Fix the sign-in step that fails in cloud sessions | Repair the token refresh the sign-in calls | in-scope |
+| Fix the sign-in step that fails in cloud sessions | A lock and write-back system for shared credentials | new scope: ask first |
+| Add a flag that skips the cache | Update the README table that lists the flags | in-scope |
+| Add a flag that skips the cache | Rewrite the cache as a separate service | new scope: ask first |
+
+## Reporting
+
+Report only what a verifier passed. Name the verifier's verdict and the evidence it produced. A result that no verifier has passed is still work in progress: say that it waits on verification.
+
+## Enforcement
+
+`hooks/routing/spawn_oversight_hook.py` adds the six steps, the separate verifier, the reproduce-first check, the scope ask, and the reporting rule to every spawn at every level of the agent tree whose brief has an `Outcome:` line and an `On a blocker:` line; the hook already denies a brief without them, and the verifier brief template carries both. The flow itself adds context only. No hook refuses a report, a commit, or a spawn for a missing verifier run, so the flow never blocks work the user asked for.

package/hooks/features/spawn-routing.md

@@ -5,7 +5,7 @@ This family reminds the agent to gather context before a spawn, refuses a brief
 ## Checks
 
 - `routing/spawn_readiness_hook.py` adds context to a spawn that comes before a read step, or before an answered question or a settled-scope line. The spawn still runs.
-- `routing/spawn_oversight_hook.py` denies a spawn whose brief has no `Outcome:` line or no `On a blocker:` clause, each with text after it. A spawn that passes gets the orchestrator oversight directive: watch the agent, check its output against the user's words and standards, and correct it before the output reaches the user. `routing/spawn_brief_text.py` reads the brief from each spawn tool for this hook and the readiness hook.
+- `routing/spawn_oversight_hook.py` denies a spawn whose brief has no `Outcome:` line or no `On a blocker:` clause, each with text after it. A spawn that passes gets the orchestrator oversight directive: run each piece through the verified-work flow, with a fresh verifier agent that checks the research, the plan, and the fix, reproduces the issue before it confirms the fix, and leaves the worker's conclusion out of its brief; ask the user before new scope; report as done only what a verifier passed; and watch the agent while it runs. `routing/spawn_brief_text.py` reads the brief from each spawn tool for this hook and the readiness hook.
 - `routing/thread_spawn_pace_hook.py` reshapes a thread request when usage is over pace or unreadable.
 - `routing/subagent_model_routing.mjs` allows a selected Luna model, remaps eligible requests, and denies unsupported model routing.
 - `blocking/haiku_spawn_slim_gate.py` denies an Agent, Task, or thread spawn whose `model` names Haiku. The deny reason gives the headless `claude -p` command that loads the slim profile through the account broker.

package/hooks/hooks_constants/spawn_oversight_hook_constants.py

@@ -36,11 +36,17 @@ REFUSAL_SUFFIX = (
 REASON_SEPARATOR = " "
 
 SPAWN_OVERSIGHT_DIRECTIVE = (
-    "You own the work this spawn starts. Load the orchestrator skill and follow "
-    "its oversee delegated work reference. While the agent runs, read its progress "
-    "and wake it with one next step when it goes quiet. Before its output "
-    "reaches the user, check it against the user's own words and standards, and "
-    "send the agent a correction when it misses. Give each piece of a "
-    "multi-piece task its own reviewer or helper. Tell the user you are "
-    "checking the work."
+    "You own the work this spawn starts. Run each piece through the verified-work "
+    "flow: research, then a separate verifier checks the research; plan, then a "
+    "separate verifier checks that the plan fixes the researched issue; implement, "
+    "then a separate verifier reproduces the issue on the old state before it "
+    "confirms the fix on the new state. Spawn a fresh verifier agent for each "
+    "check, never the agent that did the work, and brief it with the issue and "
+    "the sources and leave the worker's conclusion out. A verifier's check ends "
+    "the chain and gets no verifier of its own. Ask the user once before "
+    "you build new scope the user's words do not name, and keep in-scope work "
+    "moving while the question waits. Report as done only what a verifier "
+    "passed, with its evidence. While the agent runs, read its progress and wake "
+    "it with one next step when it goes quiet. Load the orchestrator skill and "
+    "follow its oversee delegated work reference."
 )

package/hooks/routing/test_spawn_oversight_hook.py

@@ -232,3 +232,43 @@ def test_brief_gaps_should_name_each_missing_clause() -> None:
 def test_a_workflow_script_path_that_cannot_be_opened_gets_the_directive() -> None:
     payload = {"tool_name": "Workflow", "tool_input": {"scriptPath": "bad\u0000path.js"}}
     assert json.loads(_run_script(json.dumps(payload))) == _directive_output()
+
+
+def _emitted_directive() -> str:
+    stdout = _run_script(json.dumps(_spawn_payload("Agent", GOOD_BRIEF)))
+    return json.loads(stdout)["hookSpecificOutput"]["additionalContext"]
+
+
+def test_the_emitted_directive_runs_research_plan_and_fix_in_order() -> None:
+    directive = _emitted_directive()
+    research_position = directive.index("research, then a separate verifier checks the research")
+    plan_position = directive.index("plan, then a separate verifier checks that the plan fixes the researched issue")
+    fix_position = directive.index("implement, then a separate verifier reproduces the issue")
+    assert research_position < plan_position < fix_position
+
+
+def test_the_emitted_directive_reproduces_the_issue_before_it_confirms_the_fix() -> None:
+    directive = _emitted_directive()
+    assert directive.index("reproduces the issue on the old state") < directive.index(
+        "confirms the fix on the new state"
+    )
+
+
+def test_the_emitted_directive_keeps_the_verifier_apart_from_the_worker() -> None:
+    directive = _emitted_directive()
+    assert "Spawn a fresh verifier agent for each check, never the agent that did the work" in directive
+    assert "leave the worker's conclusion out" in directive
+
+
+def test_the_emitted_directive_asks_before_new_scope_and_keeps_in_scope_work_moving() -> None:
+    directive = _emitted_directive()
+    assert "Ask the user once before you build new scope" in directive
+    assert "keep in-scope work moving while the question waits" in directive
+
+
+def test_the_emitted_directive_reports_only_verified_results() -> None:
+    assert "Report as done only what a verifier passed, with its evidence" in _emitted_directive()
+
+
+def test_the_emitted_directive_ends_the_chain_at_the_verifier() -> None:
+    assert "A verifier's check ends the chain and gets no verifier of its own" in _emitted_directive()

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "8.104.0",
+    "version": "8.105.0",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {

package/rules/index.md

@@ -1,13 +1,14 @@
 # Rules
-Each line gives a rule in brief. When its trigger matches your task, open the guide and follow it in full. Correction lens, question presentation, and the agent board load as their own files.
+Each line gives a rule in brief. When its trigger matches your task, open the guide and follow it in full.
 
 **Writing**
 - **Plain language** ([guide](../docs/rule-guides/asd-ste100-language.md)). Writing chat, narration, or repository prose. Short complete sentences on one topic, active voice, one action per step, each fact said once.
-- **No contrast framing** ([guide](../docs/rule-guides/no-contrast-framing.md)). Any sentence a person reads. State the chosen point and leave out the discarded reading. Remove the six forms: `trailing-comma-not`, `corrective-it-is-not`, `substitution-rather-than`, `additive-not-just`, `comparative-ranking`, `substitution-as-opposed-to`.
+- **No contrast framing** ([guide](../docs/rule-guides/no-contrast-framing.md)). Any sentence a person reads. State the chosen point and leave out the discarded reading.
 
 **Evidence**
 - **Research mode** ([guide](../docs/rule-guides/research-mode.md)). Any claim, recommendation, or advice. Cite a source for each claim, and run the tool that settles a fact before you state it.
 - **Verify before asking** ([guide](../docs/rule-guides/verify-before-asking.md)). Before a clarifying question. Look in files, config, environment, and tools first; ask only for a judgment or a preference.
+- **Verified work** ([guide](../docs/rule-guides/verified-work.md)). Any task. Research, plan, and build; a fresh `verifier` agent checks each step and reproduces the issue before it confirms the fix. Report only verified results. Ask before new scope.
 - **Verify runtime state** ([guide](../docs/rule-guides/verify-runtime-state.md)). Before you say a component works, is healthy, or is not the cause. Get a live signal this session.
 
 **Before building**
@@ -21,10 +22,8 @@ Each line gives a rule in brief. When its trigger matches your task, open the gu
 - **Filesystem search** ([guide](../docs/rule-guides/filesystem-search.md)). Finding files by name, path, size, or date. Scope the search to a project, worktree, or filter, never a root.
 - **Clean up temporary files** ([guide](../docs/rule-guides/cleanup-temp-files.md)). Creating scratch files or debug dumps. Track them and remove them when the task ends.
 
-**Shipping**
+**Shipping and memory**
 - **Pull request lifecycle**. Before a commit, push, pull request action, or merge. Invoke the `pr-lifecycle` skill; a hook denies those commands until it loads.
 - **Proof before a pull request** ([guide](../docs/rule-guides/proof-before-pull-request.md)). Before you open a pull request. Run the change with and without it, and quote both under "Proof in practice".
 - **Session title** ([guide](../docs/rule-guides/session-title.md)). The session has a tool whose name ends in `__set_session_title`. Set `<emoji> <name>` when the status changes.
-
-**Memory**
 - **Durable facts only** ([guide](../docs/rule-guides/memory-stores-durable-facts.md)). Writing auto-memory or a `MEMORY.md` entry. Keep only a fact that helps a fresh session weeks later.

package/scripts/tests/test_verified_work_rule.py

@@ -0,0 +1,36 @@
+"""The always-loaded rules index carries the verified-work flow, and its guide spells out every step."""
+
+from pathlib import Path
+
+PACKAGE_ROOT = Path(__file__).resolve().parents[2]
+INDEX_PATH = PACKAGE_ROOT / "rules" / "index.md"
+GUIDE_PATH = PACKAGE_ROOT / "docs" / "rule-guides" / "verified-work.md"
+
+
+def test_the_index_points_every_session_at_the_verified_work_guide() -> None:
+    index_text = INDEX_PATH.read_text(encoding="utf-8")
+    assert "- **Verified work** ([guide](../docs/rule-guides/verified-work.md))." in index_text
+    assert "reproduces the issue before it confirms the fix" in index_text
+    assert "Ask before new scope." in index_text
+
+
+def test_the_guide_runs_six_steps_in_order() -> None:
+    guide_text = GUIDE_PATH.read_text(encoding="utf-8")
+    all_step_markers = (
+        "1. **Research.**",
+        "2. **Verify the research.**",
+        "3. **Plan.**",
+        "4. **Verify the plan.**",
+        "5. **Implement.**",
+        "6. **Verify the fix.**",
+    )
+    all_positions = [guide_text.index(each_marker) for each_marker in all_step_markers]
+    assert all_positions == sorted(all_positions)
+
+
+def test_the_guide_keeps_the_verifier_apart_and_asks_before_new_scope() -> None:
+    guide_text = GUIDE_PATH.read_text(encoding="utf-8")
+    assert "The verifier is never the agent that did the work." in guide_text
+    assert "A fix whose issue did not reproduce does not pass." in guide_text
+    assert "New scope goes to the user as one question before any of it is built" in guide_text
+    assert "In-scope work runs with no ask." in guide_text