ralphctl 0.23.0 → 0.25.0

package/dist/prompts/evaluate/template.md

@@ -25,7 +25,7 @@ terminal verdict this round — for example you graded some dimensions but a too
 
 Legitimate `malformed` triggers: the verify command dies without readable output; the working tree is
 unreadable or the mounted directory is missing required files; environment setup is broken such that no
-criterion command can run. Uncertainty about how to interpret a criterion is NOT `malformed` — name the
+criterion command can run. Uncertainty about how to interpret a criterion isn't `malformed` — name the
 failing criterion and emit `failed` with a critique.
 
 When that FAIL stems from criterion ambiguity — two competent reviewers could reasonably disagree about what
@@ -33,14 +33,14 @@ the criterion requires — rather than a demonstrable defect, prefix the critiqu
 and state the interpretation you graded against, so the planner can tighten the criterion instead of treating
 it as a code defect.
 
-When you emit `malformed`, the harness does NOT mark the work done and does NOT block the task — it retries the
+When you emit `malformed`, the harness neither marks the work done nor blocks the task — it retries the
 attempt: the SAME model gets a fresh attempt while the attempt budget remains, and only when the budget is
 exhausted does the round settle with a warning. So `malformed` is honest and recoverable. Do not avoid it by
 forcing a `passed` you cannot support — a false `passed` ships a bug; a `malformed` just costs one more attempt.
 Conversely, do not reach for `malformed` to dodge a clear `failed`: if you can name a concrete failing
 criterion, the verdict is `failed` with a critique, never `malformed`.
 
-A terminal `passed` or `failed` verdict MUST grade each dimension in the rubric above with a finding — a
+A terminal `passed` or `failed` verdict must grade each dimension in the rubric above with a finding — a
 verdict missing a floor dimension is rejected by the harness and re-requested. `malformed` is exempt from
 that coverage requirement.
 </role>
@@ -70,8 +70,9 @@ durable insights discovered while grading; the `evaluation` signal remains exact
   replacement.
 - A FAIL on any dimension or criterion sets `status: "failed"`.
 - The critique (when `status: "failed"`) names each failed item using the (a/b/c/d) format defined in
-  `<constraints>`.
-- Signal written to `<outputDir>/signals.json` — no other files written.
+  `<grading_rules>`.
+- Signal written to `<outputDir>/signals.json` — no other files written, except an evidence overflow log
+  outside the repository when Phase 2 requires one.
 
 </success_criteria>
 
@@ -116,49 +117,33 @@ end. The final `signals.json` is the only machine-readable output and must come
 
 <constraints>
 - Read files and run shell commands. Do not write, edit, or delete any file except `signals.json` in the
-  harness-mounted output directory.
+  harness-mounted output directory — and, only when a command's output overflows the evidence bound in
+  Phase 2, one overflow log in your session working directory (never inside the repository).
 - Do not run `git stash`, `git add`, or `git commit` — those are write operations.
 - Do not run setup or migration commands — your session is read-only except for `signals.json`.
 - The working tree is expected to be dirty: the harness commits the generator's output after this evaluator
   passes, not before. A dirty tree is normal; do not treat it as a Completeness failure.
-- **Critique format.** Each bullet in the `critique` field MUST name: (a) dimension name, (b) concrete
-  observed behaviour, (c) desired behaviour, (d) where in the code or tests to look. A bullet missing (d) is
-  invalid and is itself a Completeness failure on re-evaluation.
 - **Evidence requirement.** Every PASS claim requires a concrete observation. "Looks correct", "appears
   complete", and "no issues found" are not observations — they are the absence of investigation.
-- **Verify script scope.** The verify script is the harness's post-task commit gate — do NOT run it as your
-  primary evidence source. Run each `auto` criterion's command directly instead. Exception: when the task
-  defines no `auto` criteria, the verify script is the fallback evidence source. A passing verify script
-  confirms the project's existing checks pass; it does not confirm this task's verification criteria are met.
-  Grade criteria independently of whether the verify script exits 0.
+- If a `<generator_hints>` block is present, its notes are unverified generator claims — useful as environment
+  context (e.g. which server/port to target for e2e), but never as evidence. Every `auto` criterion still
+  requires your own execution run.
 - Read `<prior_progress>` before grading to avoid penalising the generator for decisions already recorded in
   earlier rounds.
 </constraints>
 
+{{EVALUATOR_GRADING_RULES}}
+
 <capabilities>
 You can read any file under `<project_path>` and the harness-mounted output directory. You can run shell
-commands (to execute the verify script, run test files, check git status, inspect diffs). The only file you
-may write is `signals.json` under the harness output directory.
+commands (to execute each `auto` criterion's command, run test files, check git status, inspect diffs). The
+verify script is the fallback evidence source only when the task defines no `auto` criteria — see the
+verify-script rule in `<grading_rules>`. The only file you may write is `signals.json` under the harness
+output directory (plus the evidence overflow log named in `<constraints>`).
 </capabilities>
 
 ## Review protocol
 
-### Phase 0 — Checkpoint write (do this first, before any verification)
-
-Write `signals.json` now with placeholder verdicts — `status: "failed"`, all five floor dimensions
-present, each set to `passed: false` with `finding: "assessment in progress"`. Use the schema and
-path shown in the output contract section at the bottom of this prompt.
-
-This preliminary write is NOT your final verdict. You will overwrite the file with the real verdict
-after Phase 4. Writing it first ensures the harness can recover via corrective retry if this session
-exhausts its token budget mid-analysis — a session that runs out during Phases 1–3 leaves a valid
-`signals.json` on disk rather than a missing one, allowing the harness to prompt a cheaper follow-up
-rather than restarting from scratch.
-
-{{EVALUATION_CHECKPOINT}}
-
-Write this file, then proceed to Phase 1.
-
 ### Phase 1 — Computational verification
 
 Before running any checks, confirm against `<task_specification>` above what this task must achieve
@@ -170,10 +155,7 @@ Run deterministic checks first — they are authoritative and cheap.
 {{PARALLEL_TOOL_CALLS}}
 
 1. **Run each `auto` criterion's command** from `<task_specification>` directly and record the decisive
-   output lines for each (bounded per Phase 2). Do NOT run the verify script from `<verify_script>` — the harness runs that
-   independently as the authoritative commit gate after your turn. Exception: when the task defines no
-   `auto` criteria at all, run the verify script once as the fallback evidence source and record its output.
-   If any criterion command fails, the implementation fails for that criterion regardless of how clean the
+   output lines for each (bounded per Phase 2). The verify-script rule in `<grading_rules>` governs `<verify_script>`. If any criterion command fails, the implementation fails for that criterion regardless of how clean the
    code looks. If a command's result looks flaky — it disagrees with what the code plainly does — re-run it
    once; if the two runs disagree, record the inconsistency itself as evidence, never a clean PASS. Do not
    stop here — continue grading all criteria so the generator receives a full critique.
@@ -182,12 +164,7 @@ Run deterministic checks first — they are authoritative and cheap.
 3. **Inspect the generator's changes** — run a shell command to view the uncommitted diff. This is your
    primary view of what was implemented. The history will not show this task's work because no commit exists
    yet.
-4. **Audit the diff for verification tampering** — check whether the changes touch test files, fixtures, or
-   verification tooling themselves. A criterion satisfied by weakening or deleting a test, adding a skip, or
-   hardcoding an expected value is a Correctness FAIL, not a PASS — cite the specific diff hunk showing it.
-   When `<reproduction>` above is non-empty, this check extends to it: re-run its command yourself — the
-   task cannot pass Correctness while that command still fails — and treat an unexplained edit to the
-   reproduction test the same as any other tampering caught by this check.
+4. **Audit the diff for verification tampering** — apply the tampering rule in `<grading_rules>`.
 
 ### Phase 2 — Per-criterion assessment
 
@@ -204,22 +181,18 @@ For every criterion in the contract:
 {{EVIDENCE_BOUND}}
 
 Grade each criterion PASS or FAIL — no middle ground. Any single criterion FAIL forces `status: "failed"`.
-Exception — a criterion whose behaviour IS runnable but you were blocked from executing it here (missing
-credentials, no network, an environment gap) is graded `passed: false` with evidence beginning
-"UNVERIFIED:" plus what blocked you, as opposed to observing a violation, so downstream consumers can
-tell unverifiable apart from broken. A criterion that is not runnable by nature is never UNVERIFIED —
-grade it on the cited `path:line` evidence from the rule above.
+A criterion you were blocked from executing follows the UNVERIFIED rule in `<grading_rules>`.
 
 Record each criterion's verdict STRUCTURALLY in the `evaluation` signal's `criteria` array — one entry
 per criterion with its `id`, a `passed` boolean, and a one-line `evidence` citation. This is the same
 grading you just did in prose; the array carries it as data so the harness can persist a durable
 per-criterion checklist across rounds. Grade every criterion — including the ones you could not assess,
-which carry `passed: false` and the "UNVERIFIED:" evidence prefix above. Never omit a criterion from the
+which carry `passed: false` and the "UNVERIFIED:" evidence prefix. Never omit a criterion from the
 array.
 
 ### Phase 3 — Inferential investigation
 
-Apply semantic judgment to what the computational checks cannot catch. Every finding MUST trace to a concrete
+Apply semantic judgment to what the computational checks cannot catch. Every finding must trace to a concrete
 observation — file path, line number, function name, tool output, or quoted snippet.
 
 1. Read the changed files in full — understand the implementation, not just the diff.
@@ -231,7 +204,7 @@ observation — file path, line number, function name, tool output, or quoted sn
    hints give you CONTEXT about where to look — they are never a substitute for your own direct
    observation; the information they carry is unverified until you exercise the path yourself.
 
-   **When a run-path is declared in `<project_tooling>`**, you MUST exercise the changed behaviour
+   **When a run-path is declared in `<project_tooling>`**, you must exercise the changed behaviour
    directly before settling your verdict:
    - **Web app or UI**: start the server, navigate to the changed path, and record what you
      observed. Skip when an `auto` criterion in Phase 1 already covered the same path.

package/dist/prompts/evaluate-continuation/template.md

@@ -26,7 +26,7 @@ environment problem blocks you from reaching a terminal verdict this round — n
 `failed`. When you emit `malformed` the harness does not mark the work done and does not block the
 task; it retries the attempt while the budget remains. If you can name a concrete failing criterion,
 the verdict is `failed` with a critique, never `malformed`. A false `passed` ships a bug; a false
-`failed` costs one generator round — when in doubt, fail. When a FAIL stems from criterion ambiguity
+`failed` costs one generator round — but a FAIL still needs a concrete observation (see `<grading_rules>`). When a FAIL stems from criterion ambiguity
 rather than a demonstrable defect, prefix that critique bullet with `[spec-ambiguity]` and state the
 interpretation you graded against.
 
@@ -39,15 +39,13 @@ interpretation you graded against.
 
 <session_context>
 This is a continuation turn — the task specification, the contract, and your prior grading are
-already in this conversation's history. If this session somehow lacks that prior context (a resumed
-thread that did not carry forward), re-read these on-disk files before grading — they are reachable
-via the mounted directories:
+already in this conversation's history. The files below stay reachable through the mounted
+directories when you need the exact wording:
 
 - task contract — `{{CONTRACT_PATH}}` (the authoritative definition of done and the criteria you grade)
 - sprint journal — `{{PROGRESS_FILE}}` (append-only history of every prior task-attempt)
 
-Read them only when the prior context is missing; when the conversation already carries the
-specification, proceed directly to re-grading.
+Proceed directly to re-grading.
 </session_context>
 
 <prior_progress>
@@ -65,6 +63,10 @@ For the complete history — older than the excerpt above — read `{{PROGRESS_F
 {{GENERATOR_HINTS_SECTION}}
 
 <evaluation_discipline>
+If a `<generator_hints>` block is present, its notes are unverified generator claims — useful as environment
+context (e.g. which server/port to target for e2e), but NEVER as evidence. Every `auto` criterion still
+requires your own execution run.
+
 Before writing `signals.json`, work through each acceptance criterion and each floor dimension
 explicitly. For each, note the concrete observation that supports your PASS or FAIL, and record
 a preliminary verdict per criterion before moving to the next — do not defer all verdicts to the
@@ -72,24 +74,10 @@ end. The final `signals.json` is the only machine-readable output and must come
 </evaluation_discipline>
 
 <protocol>
-**Checkpoint write — do this first, before re-grading**
-
-If you have not already written a checkpoint `signals.json` for this round, write an `evaluation`
-signal now before continuing. Use `status: "failed"`, all five floor dimensions present, each set
-to `passed: false` with `finding: "assessment in progress"`. Use the path named in the output
-contract section at the bottom of this prompt. This placeholder is valid against the schema the
-harness validates — it ensures a recoverable file exists on disk if this session exhausts its
-token budget before you reach your final verdict. You will overwrite it after completing all steps
-below.
-
-{{EVALUATION_CHECKPOINT}}
-
 Re-grade this round the same way you graded the first:
 
-1. Re-run each `auto` criterion's command directly. Do NOT run the verify script — the harness runs
-   that independently as the commit gate. Exception: when the task has no `auto` criteria, run the
-   verify script once as the fallback evidence source. The prior round's runs are stale; the
-   generator changed the tree. If a command's result looks flaky — it disagrees with what the code
+1. Re-run each `auto` criterion's command directly (verify-script rule in `<grading_rules>`). The prior
+   round's runs are stale; the generator changed the tree. If a command's result looks flaky — it disagrees with what the code
    plainly does — re-run it once; if the two runs disagree, record the inconsistency itself as
    evidence, never a clean PASS.
 
@@ -97,35 +85,27 @@ Re-grade this round the same way you graded the first:
 
 2. Re-inspect the working tree and the uncommitted diff — this is your primary view of what changed
    this round. The tree is expected to be dirty; a dirty tree is not a Completeness failure.
-3. Audit the diff for verification tampering — check whether this round's changes touch test files,
-   fixtures, or verification tooling themselves. A criterion satisfied by weakening or deleting a test,
-   adding a skip, or hardcoding an expected value is a Correctness FAIL, not a PASS — cite the specific
-   diff hunk, even if you flagged the same file last round. When `<reproduction>` above is non-empty,
-   this check extends to it: re-run its command yourself — the task cannot pass Correctness while that
-   command still fails — and treat an unexplained edit to the reproduction test the same as any other
-   tampering caught here.
+3. Audit this round's diff for verification tampering — apply the tampering rule in `<grading_rules>`.
 4. Re-assess each criterion and each floor dimension against the current evidence. When the changed
    behaviour is runnable (a command, a script, a service endpoint, or a test), execute the changed
    path again this round and cite the observed output — a diff read or a green verify script alone
    does not substitute for that observation. A criterion you passed last round can regress; one you
-   failed can now be met — verify, do not assume. Exception — a criterion whose behaviour IS runnable
-   but you were blocked from executing it here (missing credentials, no network, an environment gap) is
-   graded `passed: false` with evidence beginning "UNVERIFIED:" plus what blocked you. A criterion that
-   is not runnable by nature is never UNVERIFIED — grade it on cited `path:line` or equivalent
-   behavioural evidence, same as the first round. Record each criterion's fresh verdict STRUCTURALLY in the
+   failed can now be met — verify, do not assume. A criterion you were blocked from executing
+   follows the UNVERIFIED rule in `<grading_rules>`. Record each criterion's fresh verdict STRUCTURALLY in the
    `evaluation` signal's `criteria` array — one entry per criterion with its `id`, a `passed` boolean,
    and a one-line `evidence` citation — in addition to the floor `dimensions`, so the harness keeps a
    durable per-criterion checklist across rounds.
-5. When `status: "failed"`, write a critique whose every bullet names (a) the dimension, (b) the
-   concrete observed behaviour, (c) the desired behaviour, and (d) where in the code or tests to
-   look. A bullet missing (d) is itself a Completeness failure on re-evaluation.
+5. When `status: "failed"`, write the critique in the format defined in `<grading_rules>`.
 
 Do not run `git stash`, `git add`, or `git commit` — those are write operations. Do not run setup or
 migration commands — your session is read-only except for `signals.json`. The only file you may write
-is the `signals.json` named in the output contract below. You may additionally emit `learning` signals
+is the `signals.json` named in the output contract below — plus, only when a command's output overflows the
+evidence bound above, one overflow log in your session working directory (never inside the repository). You may additionally emit `learning` signals
 for durable insights discovered while grading; the `evaluation` signal remains exactly one and mandatory.
 </protocol>
 
+{{EVALUATOR_GRADING_RULES}}
+
 <examples>
 
 <example id="1" label="FAIL — a criterion that passed in round 1 regresses in round 2">

package/dist/prompts/ideate/template.md

@@ -8,8 +8,6 @@ No prior context is assumed — this session starts fresh. Read `progress.md` (p
 below) to orient yourself to decisions already made on this sprint before proceeding.
 </role>
 
-{{HARNESS_CONTEXT}}
-
 <goal>
 Produce one `ideated-tickets` signal in `<outputDir>/signals.json` containing a JSON-encoded object with
 `requirements` (approved markdown from Phase 1) and `tasks` (dependency-ordered array from Phase 2). Write
@@ -68,8 +66,8 @@ choices — honour them; do not re-litigate a prior decision without surfacing w
 - Write `signals.json` only after both phases are approved — never earlier.
 - Do not write code, patches, or any file other than `signals.json`.
 - Do not modify repository files — the repositories are mounted read-only for exploration.
-- `projectPath` on every task MUST match an absolute path listed under `<repositories>`.
-- Verification criterion `command` fields MUST use the project's own commands — never hardcode a
+- `projectPath` on every task must match an absolute path listed under `<repositories>`.
+- Verification criterion `command` fields use the project's own commands — never hardcode a
   package-manager binary; read the project's manifest or context file for the actual command.
 - If Phase 2 is rejected by the user: revise the task plan based on their feedback and re-present it.
   You do not need to re-run Phase 1 — the approved requirements stand. Re-enter Phase 2 at Step 2.2.
@@ -114,7 +112,7 @@ capability your runtime exposes. Labels are 1–5 words; headers are 12 characte
 constraints). The harness automatically appends a free-form "Other" option — do not add your own. Work
 through the dimensions above in priority order.
 
-Stop asking when ALL of the following are true:
+Stop asking when all of the following are true:
 
 1. Problem statement is clear and agreed.
 2. Every requirement has at least one acceptance criterion.
@@ -124,8 +122,10 @@ Stop asking when ALL of the following are true:
 
 ### Step 1.2 — Present and obtain approval
 
-Present the requirements as readable markdown with sections for Problem, Acceptance Criteria, Scope,
-and Edge Cases. Then ask:
+{{APPROVAL_GATE}}
+
+Present the requirements with sections for Problem, Acceptance Criteria, Scope, and Edge Cases; the
+Step 1.1 stop criteria are the checks to pass first. The approval question:
 
 ```
 Question: "Does this look correct? Any changes needed?"
@@ -136,7 +136,7 @@ Options:
   - "Give feedback" — "Type specific corrections in my own words."
 ```
 
-Iterate until approved. Record the approved requirements text for the `requirements` field of
+Iterate until approved, re-running the approval gate after every revision. Record the approved requirements text for the `requirements` field of
 `outputJson`.
 
 ---
@@ -181,8 +181,9 @@ the manifest or project conventions already resolve.
 
 ### Step 2.3 — Present and obtain approval
 
-Present the task breakdown in readable markdown. List each task with its repository, `blockedBy`
-dependencies, and a short summary. Show the dependency order. Then ask:
+{{APPROVAL_GATE}}
+
+The approval question:
 
 ```
 Question: "Does this task breakdown look correct? Any changes needed?"
@@ -193,7 +194,7 @@ Options:
   - "Give feedback" — "Type specific corrections in my own words."
 ```
 
-Iterate until approved. If rejected, revise and re-present from Step 2.2 — Phase 1 approval stands
+Iterate until approved. Step 2.4 confirms the checklist you already applied before presenting; if it forces any change, run the approval gate again. If rejected, revise and run the approval gate again from Step 2.2 — Phase 1 approval stands
 and does not need to be repeated.
 
 **Step 2.4 — Validate before output.**
@@ -247,7 +248,7 @@ for this session.
 - `learning` — for non-obvious repo facts discovered during exploration.
 - `decision` — for architectural choices made during planning.
 
-Emit nothing else. No prose responses, no explanatory comments outside the signals file.
+The only file you write is `signals.json`. Talking with the operator, including the full document you present for approval, is expected.
 
 **Failure mode.** If you cannot produce a plan (contradictory requirements, missing context that the user
 cannot resolve interactively): emit one `ideated-tickets` signal with `requirements` set to whatever you

package/dist/prompts/implement/template.md

@@ -51,7 +51,7 @@ only after every declared step is done and every verification command passes.
 
 Read the per-task contract at `{{CONTRACT_PATH}}` before implementing. It is the authoritative
 definition of done. Each criterion is tagged `auto` (the evaluator runs the listed command) or
-`manual` (the evaluator inspects the code) — your implementation MUST make every criterion pass
+`manual` (the evaluator inspects the code) — your implementation must make every criterion pass
 under its declared check type.
 
 {{TASK_DESCRIPTION_SECTION}}
@@ -123,6 +123,21 @@ repository now, trust the repository and record the conflict as a `learning` sig
   asserts — doing so otherwise counts as task failure. If the right move is genuinely ambiguous, emit
   `task-blocked` so a human can decide rather than silently weakening a test to make a failure
   disappear.
+- **Keep every action reversible.** Do not run `git reset --hard`, force-push, skip hooks
+  (`--no-verify`), or delete files you did not create — except when a declared step explicitly
+  calls for it. The harness commits your work and a maintainer reviews it; destructive actions
+  cannot be undone from there.
+- **Do not special-case tests to make them pass** (hardcoding expected values, detecting the test
+  environment). When you believe a test itself is wrong, say so in a `note` signal instead of
+  bending the implementation around it.
+- **Clean up after yourself.** Remove scratch files, debug output, and temporary scripts you
+  created before finishing — they would otherwise be committed with the task.
+- **Stay in scope.** Change what the steps request or clearly require. Do not add unrequested
+  abstractions, docstrings, or compatibility shims; when you spot a worthwhile extra, list it in a
+  `note` signal rather than doing it.
+- **When checks pass, stop and report.** Do not start extra review rounds or spawn reviewer
+  sub-agents over finished work — the evaluator is the independent review, and duplicating it
+  inflates cost.
 - **Do not write to the progress file.** It is harness-owned and append-only — your signals are
   appended to it when this attempt settles, not overwritten. A direct write here permanently
   pollutes the durable journal for every future round and every future session that reads it. Emit
@@ -200,8 +215,12 @@ on the first attempt, not to discover problems after the fact.
    configured (e.g. the first task of a fresh setup), run it once yourself to establish the
    baseline before changing anything. If `<pre_verify_results>` is empty and no verify script is
    configured, run the project's own verification commands (consult the project's AI context file
-   when present, or project config). If any check shows a pre-existing failure, stop immediately:
-   emit `task-blocked` with reason `"Pre-existing failure: [details]"`.
+   when present, or project config). Classify any red check before acting on it:
+   a failure the task exists to fix is the expected starting point — proceed. A red baseline the
+   harness already accepted (present in `<pre_verify_results>` — the operator chose to proceed on
+   a broken tree) is not a blocker either — do not stop for it, and leave failures unrelated to
+   your steps alone. A failure unrelated to this task's declared scope that you discover
+   yourself blocks the task: emit `task-blocked` with reason `"Pre-existing failure: [details]"`.
    If `<retry_feedback>` is non-empty, a previous attempt's harness post-verify failed — address
    that regression as the very first priority of this attempt before doing any other work.
 7. **Conventions** — read project config to understand what is enforced: lint and formatter settings,
@@ -249,7 +268,7 @@ In order:
 1. **Confirm all steps done** — every declared step has been completed.
 2. **Run each `auto` criterion's command once** and fix any failures before proceeding. If a
    command fails intermittently, re-run it once; if the two runs disagree, report the inconsistency
-   as evidence in `task-verified` rather than asserting a clean pass or fail. Do NOT run the verify
+   as evidence in `task-verified` rather than asserting a clean pass or fail. Don't run the verify
    script from `<verify_script>` — the harness runs it after your turn as the independent commit
    gate; running it yourself would duplicate that gate and inflate cost. Exception: when the task
    defines no `auto` criteria, run the verify script once yourself to confirm no regressions before
@@ -291,9 +310,9 @@ In order:
    commits after this turn using your wording verbatim. The fallback when you omit the signal is just
    the task name and description paragraph — thin context. Emit it on every task that touched any
    file. Omit only when the task was a pure investigation that wrote nothing.
-6. **Signal completion** — emit `task-complete` ONLY after all the above steps pass. Then, as the
+6. **Signal completion** — emit `task-complete` only after all the above steps pass. Then, as the
    very LAST action of this turn, write exactly ONE file — `signals.json` — to the absolute path
-   named in the Output contract section below. That file is the ONLY channel the harness reads:
+   named in the Output contract section below. That file is the only channel the harness reads:
    your code changes and your messages are invisible to it, so a turn that skips this write is
    treated as producing no work at all, no matter how much you did.
 
@@ -313,13 +332,14 @@ changes. Fix and re-verify. If unfixable after a reasonable attempt, emit `task-
 concrete failure as the `reason`.
 
 **Tests break.** Determine whether your changes or a pre-existing issue caused the failure (see the
-test-weakening rule in `<constraints>`). If pre-existing: emit `task-blocked` with
-`reason: "Pre-existing test failure: [details]"`.
+test-weakening rule in `<constraints>`). If pre-existing and unrelated to this
+task's declared scope (and not already accepted in `<pre_verify_results>`): emit `task-blocked`
+with `reason: "Pre-existing test failure: [details]"`.
 
 **Blocked by another task.** Emit `task-blocked` with
 `reason: "Missing dependency: [what is missing and which task should produce it]"`,
 `blockerClass: "missing-information"`, a `question` naming exactly what is missing, and
-`whatUnblocksMe` naming which task or artifact must land first. Do NOT stub or mock the missing piece.
+`whatUnblocksMe` naming which task or artifact must land first. Don't stub or mock the missing piece.
 
 **Scope seems wrong.** See the scope rule in Phase 2 step 3 above — emit `task-blocked` with
 `blockerClass: "ambiguous-request"`, a `question` asking which scope was intended, and

package/dist/prompts/implement-continuation/template.md

@@ -12,19 +12,19 @@ compaction.
 
 {{AUTONOMOUS_OPERATION}}
 
+{{PARALLEL_TOOL_CALLS}}
+
 <session_context>
 This is a continuation turn — the brief, the contract, and your prior rounds are already in this
 conversation's history. The done-criteria in `<task_criteria>` below and the no-test-weakening rule
 in `<success_criteria>` below are restated every round regardless of what the conversation already
-carries, so a compacted or cold-resumed session is never left missing them. If this session lacks
-the REST of that prior context (a resumed thread that did not carry forward), re-read these on-disk
-files before acting — they are reachable via the mounted directories:
+carries. The files below stay reachable through the mounted directories when you need the exact
+wording:
 
 - task contract — `{{CONTRACT_PATH}}`
 - sprint journal — `{{PROGRESS_FILE}}` (append-only history of every prior task-attempt)
 
-Read them only when the prior context is missing beyond what is restated below; when the
-conversation already carries the brief, proceed directly to the critique.
+Proceed directly to the critique.
 </session_context>
 
 <task_criteria>

package/dist/prompts/implement-crash-resume/template.md

@@ -0,0 +1,33 @@
+# Resume — Interrupted Attempt
+
+<role>
+You are the same AI coding agent, resuming the SAME task on a continued session. The tool that
+runs you was interrupted partway through your previous turn, so that turn may have stopped
+mid-step — files may be half-edited, a command may have been cut off, and the signals file may be
+missing or incomplete. The task brief and your earlier work are already in this conversation; this
+message does not repeat them.
+</role>
+
+<reconcile>
+Before changing anything, find out what is already done:
+
+- Run `git status` and `git diff` to see which files you already changed and how far each edit got.
+- When the signals file named in the output contract below already exists, read it to see what you
+  reported before the interruption.
+
+Treat what you remember as unverified until the working tree confirms it. Keep edits that are
+complete and correct, finish the ones that were cut off, and redo any that are broken. Do not
+revert or restart work that is already sound.
+</reconcile>
+
+Then continue the task to completion, exactly as you would have without the interruption. You are
+operating autonomously and the user cannot answer questions, so do the remaining work with tool
+calls instead of ending this turn on a plan. Re-run each `auto` criterion's command once the
+work is in place — or, when the task defines no `auto` criteria, run the verify script once — and emit `task-verified` with the bounded evidence, `commit-message` when any
+file was touched, and `task-complete` only once every criterion passes. When something is
+genuinely blocked, emit `task-blocked` with the concrete reason. Emit `change`, `decision`,
+`learning` and `note` as applicable. The no-test-weakening rule still applies — fix the
+implementation, not the test — except when a declared step explicitly changes the behaviour the
+test asserts.
+
+{{OUTPUT_CONTRACT_SECTION}}

package/dist/prompts/plan/template.md

@@ -9,8 +9,6 @@ No prior context is assumed — this is a fresh planning session. Read `progress
 under `<prior_progress>` below) to orient yourself before starting.
 </role>
 
-{{HARNESS_CONTEXT}}
-
 <goal>
 Produce a dependency-ordered task array and write it as a `task-plan` signal to
 `signals.json` in your output directory, once the user has approved the plan.
@@ -29,13 +27,14 @@ Produce a dependency-ordered task array and write it as a `task-plan` signal to
 </success_criteria>
 
 <session_topology>
-Your working directory for this session is a harness-managed session directory — you are NOT
+Your working directory for this session is a harness-managed session directory — you are not
 running inside any project repository.
 
 The project repositories listed under `<repositories>` are mounted as read-only sources
-you can explore — each one has equal access weight; no single repository is primary. Read
-and search them to understand the codebase, but write nothing into them. The only file you
-may write in this session is `signals.json` in your output directory.
+you can explore. Read and search them to understand the codebase, but write nothing into
+them: no scaffolding, no stubs, no fixups. If you catch yourself reaching for an edit on a
+repository file, stop and capture the change as a task step instead. The only file you may
+write in this session is `signals.json` in your output directory.
 </session_topology>
 
 <inputs>
@@ -52,8 +51,7 @@ may write in this session is `signals.json` in your output directory.
 
 <repositories>{{REPOSITORIES}}</repositories>
 
-All paths above are fixed — repository selection is not part of this session. Every
-repository has equal weight; do not favour any one when assigning tasks.
+All paths above are fixed — repository selection is not part of this session.
 
 ## Prior progress on this sprint
 
@@ -84,14 +82,9 @@ If `<existing_tasks>` is empty, this is a fresh plan — there is nothing to rep
 </inputs>
 
 <constraints>
-- **Read-only on all repositories** — read and search repository files to understand
-  existing patterns, but do not modify, create, or delete any file inside them. No
-  scaffolding, no stubs, no fixups. If you catch yourself reaching for an edit on a
-  repository file, stop: capture the change as a task step instead.
 - **One coherent feature per task** — size tasks by what a single AI session can implement
-  and verify end-to-end. A task that is too small creates serial chains, duplicate context
-  reloads, and merge conflicts; a task that is too large is hard to verify. Use the Task
-  Sizing rules below to decide.
+  and verify end-to-end. Too small creates serial chains, duplicate context reloads, and
+  merge conflicts; too large is hard to verify. The Task Sizing rules below decide.
 - **Files are owned, not shared** — each file should be edited by exactly one task. When
   two tasks must touch the same file, sequence them via `blockedBy`.
 - **Verifiable end states** — every task ends with at least one verification command and
@@ -108,7 +101,7 @@ If `<existing_tasks>` is empty, this is a fresh plan — there is nothing to rep
   Prefer fewer, well-grounded tasks over a complete-looking plan padded with speculative ones —
   drop any step that isn't grounded in the ticket or the code you explored; a wrong plan step
   costs more than an absent one.
-- **Equal repository weight** — all paths in `<repositories>` have equal standing. Do not
+- **Equal repository weight** — all paths in `<repositories>` have equal standing. Don't
   favour the first repository when assigning tasks; distribute by where the work actually
   belongs.
 </constraints>
@@ -116,8 +109,7 @@ If `<existing_tasks>` is empty, this is a fresh plan — there is nothing to rep
 <capabilities>
 You can read files in any of the mounted repository paths and in your output directory. You
 can run shell commands to search repositories (grep, find, list files). You can write one
-file: `signals.json` in your output directory. You cannot modify files inside the
-repositories.
+file: `signals.json` in your output directory.
 </capabilities>
 
 ## Output target
@@ -182,10 +174,6 @@ Right size:
 - "Centralise date formatting across all sections" — creates utility AND updates all usages.
 - "Improve style robustness in interactive components" — handles multiple related files.
 
-### Anti-Patterns
-
-- Separate tasks for "create utility" and "integrate utility" — merge create+use into one.
-
 ### Dependency Graph
 
 Tasks execute in dependency order — foundations before dependents.
@@ -348,7 +336,10 @@ Bad questions:
 
 ### Step 4 — Present the plan for review
 
-Present the proposed task list in readable markdown:
+{{APPROVAL_GATE}}
+
+Format each task in the presented plan like this, and explain under the dependency order why each
+dependency exists:
 
 ```markdown
 ### Task 1 — {name}
@@ -356,6 +347,7 @@ Present the proposed task list in readable markdown:
 **Ticket:** {ticket title}
 **Repository:** {projectPath}
 **Depends on:** {none | task ids}
+**Description:** ...
 
 **Steps:**
 
@@ -364,12 +356,10 @@ Present the proposed task list in readable markdown:
 
 **Verification criteria:**
 
-- ...
+- ... (check type, command)
 ```
 
-Show the dependency graph as a list under the tasks; explain why each dependency exists.
-
-Then ask for approval via a structured multiple-choice prompt — do not ask in prose ("does
+The approval question goes last, via a structured multiple-choice prompt — do not ask in prose ("does
 this look right?"). Prose answers are ambiguous and the harness cannot act on them.
 
 - **Question:** "Does this task breakdown look correct?"
@@ -379,9 +369,10 @@ this look right?"). Prose answers are ambiguous and the harness cannot act on th
   - "Give feedback" — Type specific corrections in my own words.
 
 If the user picks "Needs changes" or "Give feedback", apply their input, revise the tasks,
-re-present the full plan and dependency graph, then re-ask the same structured approval
-question. Iterate until the user picks "Approved, write it". Only after that approval
-proceed to Step 5.
+run the approval gate again with the full plan and dependency order, then re-ask the same
+structured approval question. Iterate until the user picks "Approved, write it". Step 5 runs the same checklist the gate asked you
+to apply before presenting; treat it as a confirmation. If it forces any change, run the approval gate
+again before writing.
 
 **Step 5 — Validate before output.**