@renzrollon/interlock 1.0.0

package/lib/prompts/handoff.mjs

@@ -0,0 +1,86 @@
+// The handoff briefing — manual test plan, code explanation, spec
+// conformance and learnings capture, in that order.
+//
+// Moved from `workflows/ship.js` (the handoff section) as part of
+// `emit-strict-tail-from-cli`. The only change is where the two decisions
+// come from (design D5): the retired text told the agent to run
+// `interlock surface` and, when conformance was on, `interlock conformance`,
+// itself. `run judge --context final` now runs both in-process before this
+// briefing is assembled and inlines what they decided — whether a manual
+// test plan is needed (with the reason when it is not) and the scenario
+// checklist to answer. The agent still writes every artifact and reports
+// the counts; nothing about what it is asked to do changed.
+//
+// `needsManualTestPlan` is `null` when the manifest's `handoff` flag is off
+// (a conformance-only run): the manual-test-plan and code-explanation
+// artifacts, and the learnings capture, belong to `handoff`, not to
+// `conformance`, in the retired text (`workflows/ship.js:2295-2328`), so a
+// `null` here skips that whole section rather than guessing which way a
+// boolean should default.
+
+/**
+ * @param {{id: string, artifact: string, line: number, title: string}} scenario
+ * @returns {string} one checklist line, matching `lib/conformance.mjs`'s own `formatChecklist`
+ */
+function renderScenario(scenario) {
+  const s = scenario || {}
+  const loc = s.artifact ? `${s.artifact}:${s.line}` : null
+  return loc ? `  ${s.id}  ${s.title}\n      ${loc}` : `  ${s.id}  ${s.title}`
+}
+
+/**
+ * Assemble the handoff briefing.
+ *
+ * @param {object} input
+ * @param {string} input.change
+ * @param {boolean|null} input.needsManualTestPlan  from `interlock surface`; `null` when `handoff` is off
+ * @param {string} [input.testPlanReason]  why no plan is needed, when `needsManualTestPlan` is `false`
+ * @param {Array<{id: string, artifact: string, line: number, title: string}>|null} input.conformance
+ *   the scenario checklist from `interlock conformance`, or `null` when `conformance` is off
+ * @param {boolean} input.learnings  whether to ask for the learnings-capture paragraph
+ * @returns {string}
+ */
+export function assembleHandoffPrompt({ change, needsManualTestPlan, testPlanReason, conformance, learnings }) {
+  const wantsHandoffArtifacts = needsManualTestPlan !== null && needsManualTestPlan !== undefined
+  const scenarios = Array.isArray(conformance) ? conformance : null
+
+  const parts = [`Produce the handoff artifacts for change "${change}".\n`]
+
+  if (wantsHandoffArtifacts) {
+    parts.push(
+      needsManualTestPlan
+        ? `Write openspec/changes/${change}/manual-test-plan.md covering every touched file, with ` +
+          `spec scenarios and tasks mapped to numbered cases.\n`
+        : `Skip the manual test plan and say why: ${testPlanReason || 'no UI-testable surface was touched'} ` +
+          `— a backend-only change does not get a UI test plan.\n`
+    )
+    parts.push(
+      `Then write openspec/changes/${change}/code-explanation.md as a commit teach-in: why each ` +
+        `file changed, what changed, the blast radius, and what would break if it were left out.\n`
+    )
+  }
+
+  if (scenarios !== null) {
+    const list = scenarios.length ? scenarios.map(renderScenario).join('\n') : '  (no scenarios listed)'
+    parts.push(
+      `Spec conformance — for each scenario below, read the implementation and answer whether the ` +
+        `described behaviour was actually built, citing file:line. Write the answers to ` +
+        `openspec/changes/${change}/conformance.md with one section per scenario id. A scenario you ` +
+        `cannot confirm is recorded as unconfirmed with what you looked at — never as satisfied, and ` +
+        `never omitted. If the checklist is empty, say so and move on.\n\n${list}\n\n` +
+        `This never halts the run: a prose scenario matched to code is a judgement, and a judgement ` +
+        `that stopped a ship run would be a gate built on a guess. Report it and let a person read it.\n`
+    )
+  }
+
+  if (learnings) {
+    parts.push(
+      `Finally, capture at most three learnings from fixes made during this run — recurring failure ` +
+        `modes under .claude/memory/failure-modes/, module coupling under .claude/memory/coupling/ — ` +
+        `each one small file, indexed in .claude/memory/MEMORY.md. Only genuinely recurring patterns; ` +
+        `write nothing if nothing recurred. This is silent.`
+    )
+  }
+
+  return parts.join('\n')
+}

package/lib/prompts/implementer.mjs

@@ -0,0 +1,150 @@
+// The text a wave implementer is handed is a contract, not a convenience.
+//
+// It used to live inline in `workflows/ship.js`, marked so a test could eval it
+// out of the script's source, because the Workflow runtime rejects a script that
+// loads modules at all. Now the CLI assembles every briefing and the script only
+// carries the path and the hash of the file it wrote (design D2), so this text
+// can live where every other piece of policy lives: in `lib/`, imported, read by
+// one party.
+//
+// The fixtures under `test/fixtures/prompts/` are the contract. Changing the
+// assembled text has to be a deliberate act that updates a file, not a side
+// effect of editing nearby control flow.
+
+export function assembleImplementerPrompt({ change, lane, task, previousHandoffs, isolateWaves, solo }) {
+  // A lane is the unit now; a bare `task` is still accepted and means a lane of
+  // one. That is not politeness to old callers — a one-task lane MUST assemble
+  // byte-identically to the pre-lane prompt, and sharing one code path is the
+  // only way that stays true as this text is edited.
+  const tasks = (Array.isArray(lane) && lane.length ? lane : [task]).filter(
+    t => t && typeof t === 'object'
+  )
+  const first = tasks[0] || { id: '(unknown)', description: '', tier: 1 }
+  // The lane runs on its hardest task's ladder: one agent must be briefed for
+  // everything it is about to do, and a tier is a floor, not an average.
+  //
+  // A solo lane is the whole change, so it is briefed at the full-read ladder
+  // however cheap its hardest task looks: the agent has no other wave to inherit
+  // context from and no sibling to compare notes with. This raises the BRIEFING
+  // only — the tasks keep the tiers the classifier gave them, because tier is
+  // what effort and the promotion report are read from and rewriting it here
+  // would misreport both (design D7).
+  const soloLane = solo === true
+  const laneTier =
+    tasks.reduce((m, t) => (Number.isInteger(t.tier) && t.tier > m ? t.tier : m), 0) || 1
+  const tier = soloLane ? Math.max(laneTier, 4) : laneTier
+
+  const packets = (Array.isArray(previousHandoffs) ? previousHandoffs : []).filter(
+    h => h && typeof h === 'object'
+  )
+
+  // Empty renders nothing at all, so a first wave's prompt is byte-identical to
+  // what it was before handoffs existed and its snapshot stays stable.
+  const previous = packets.length
+    ? `\nPREVIOUS WAVE (schema-validated; do not re-derive from git):\n` +
+      packets
+        .map(
+          h =>
+            `- [${h.taskId} ${h.status}] ${h.summary}\n` +
+            `  evidence: ${(Array.isArray(h.evidence) ? h.evidence : []).join(', ')}\n` +
+            `  next: ${h.next}` +
+            (h.blocker ? `\n  blocker: ${h.blocker}` : '')
+        )
+        .join('\n') +
+      `\n`
+    : ''
+
+  // A lane of one renders exactly the text it rendered before lanes existed —
+  // the single-task fixtures are the pin that keeps that honest.
+  const single = tasks.length === 1
+
+  const list =
+    tasks.map((t, i) => `TASK ${i + 1}/${tasks.length} — ${t.id}: ${t.description}`).join('\n') +
+    `\n\n`
+
+  // The multi-task heading used to say the tasks "edit the same files". That was
+  // true when a lane could only be a path-collision component; a cohesion lane
+  // packs path-DISJOINT tasks, so the sentence became a false statement handed
+  // to every implementer. What replaced it is true of every lane there is: one
+  // agent owns it, and nothing else is writing what it claims.
+  const heading = single
+    ? `Implement exactly one task from OpenSpec change "${change}".\n\n` +
+      `TASK ${first.id}: ${first.description}\n\n`
+    : soloLane
+      ? `Implement OpenSpec change "${change}" end to end — all ${tasks.length} of its tasks, IN ` +
+        `THIS ORDER. You are the only implementer on this change: you own every task listed below, ` +
+        `including its test tasks, and no other agent is touching this repository while you work.\n\n` +
+        list
+      : `Implement ${tasks.length} tasks from OpenSpec change "${change}", IN THIS ORDER. They are ` +
+        `one lane run by you alone — no other agent touches the files they claim while you ` +
+        `work.\n\n` +
+        list
+
+  const scope = single
+    ? `- Implement ONLY this task. Do not modify files outside its scope.\n`
+    : `- Implement ONLY these tasks, in the order listed. Do not modify files outside their scope.\n` +
+      `- Finish a task before starting the next one. Do not skip ahead, and do not do a later ` +
+      `task's work under an earlier task's name.\n` +
+      `- STOP at the first task you cannot complete. Report it as failed and report every task ` +
+      `after it as not-attempted — do not continue past a failure.\n`
+
+  const handoff = single
+    ? `\nHANDOFF — the next wave reads your packet instead of reconstructing your work ` +
+      `from git, so every result MUST carry one:\n` +
+      `  { "schema": "interlock.wave-handoff/1", "taskId": "${first.id}", ` +
+      `"status": "ok" | "blocked" | "partial",\n` +
+      `    "summary": "...", "evidence": ["path:12-40"], "next": "...", "blocker": null }\n`
+    : `\nHANDOFF — the next wave reads your packets instead of reconstructing your work ` +
+      `from git. Report an outcome for EVERY task you were given:\n` +
+      `  { "tasks": [ { "id": "<task id>", "outcome": "ok" | "failed" | "not-attempted",\n` +
+      `      "handoff": { "schema": "interlock.wave-handoff/1", "taskId": "<same id>", ` +
+      `"status": "ok" | "blocked" | "partial",\n` +
+      `        "summary": "...", "evidence": ["path:12-40"], "next": "...", "blocker": null } } ] }\n` +
+      `- One packet per task you ATTEMPTED, keyed by its own id. One packet cannot stand in for ` +
+      `several tasks.\n` +
+      `- A "not-attempted" task carries no packet. That absence is expected, not an error.\n` +
+      `- A result that omits a task you were given fails every task in this lane, so report all ` +
+      `${tasks.length}.\n` +
+      `- Do not pass a packet between your own tasks — you already know what you just did.\n`
+
+  // Rendered only under --isolate-waves. Absent, this function must produce
+  // the exact prompt it produced before worktree isolation existed — that
+  // byte-identity is what the implementer-prompt fixtures pin.
+  const isolation = isolateWaves
+    ? `\nISOLATION — you are running in your own git worktree, not the shared tree. Before you ` +
+      `report your result, run \`pwd\` and report its output as "worktreePath" in your result, ` +
+      `exactly as printed. The orchestrator has no other way to find your worktree, and folds your ` +
+      `writes back into the shared tree using that path, so it must be the real one, not a guess.\n`
+    : ''
+
+  return (
+    heading +
+    `CONTEXT — read only what your tier needs:\n` +
+    `  tier 1: the task description alone\n` +
+    `  tier 2+: the relevant section of openspec/changes/${change}/design.md\n` +
+    `  tier 3+: the relevant file under openspec/changes/${change}/specs/\n` +
+    `  tier 4+: design.md and the specs in full\n` +
+    `Your tier is ${tier}.\n\n` +
+    `RULES:\n` +
+    scope +
+    `- Do not fix unrelated problems you notice; report them instead.\n` +
+    `- Run typecheck and lint on what you changed.\n` +
+    `- Do not commit, and do not edit tasks.md — the orchestrator owns both.\n` +
+    `- If .claude/graph/graph.json exists, interlock-graph query / consumers before grep.\n` +
+    `- Locate (graph or grep) then Read spans. Do not re-read a file unless it changed.\n` +
+    `- Return the schema only. No narrative.\n` +
+    (tier <= 2
+      ? `- If your tier is 1 or 2: after typecheck/lint pass, stop. Do not refactor or polish.\n`
+      : '') +
+    previous +
+    isolation +
+    handoff +
+    `- status "ok" means blocker is null; "blocked" and "partial" need a non-empty blocker.\n` +
+    `- evidence is at most 8 locators (path, path:line, path:start-end) — never file bodies.\n` +
+    `- Keep it terse. A packet over the character cap \`interlock limits\` publishes fails the ` +
+    `task, and it is never truncated for you.\n\n` +
+    (single
+      ? `Report ok:false if you could not complete the task, with what blocked you.`
+      : `Report outcome "failed" for the task that blocked you, with what blocked you.`)
+  )
+}

package/lib/prompts/index.mjs

@@ -0,0 +1,250 @@
+// The registry of every briefing the run program can assemble.
+//
+// Coverage of assembled prompts is ENUMERATED, never sampled: the prompt-
+// integrity suite iterates this table, and a module under `lib/prompts/` that
+// exports an assembler and is not registered here fails that suite by name. The
+// alternative — a suite that checks the prompts it happens to reach — is how the
+// classifier's tier ladder stayed corrupted while every test passed.
+//
+// `inputs` are the sample inputs the suite assembles with. They are not
+// fixtures: a fixture pins bytes (that is `test/fixtures/prompts/`), while these
+// only have to be well-formed enough to exercise every branch of the assembler.
+
+import { assembleImplementerPrompt } from './implementer.mjs'
+import { assemblePlannerPrompt } from './planner.mjs'
+import { assembleVerifyPrompt } from './verify.mjs'
+import { assembleReplanPrompt } from './replan.mjs'
+import { assembleCommitPrompt } from './commit.mjs'
+import { assembleReviewPrompt } from './review.mjs'
+import { assembleRemediatePrompt, assembleVerdictPrompt } from './remediate.mjs'
+import { assembleHandoffPrompt } from './handoff.mjs'
+import { publishStageLine } from './stage.mjs'
+
+export { assembleImplementerPrompt } from './implementer.mjs'
+export { assemblePlannerPrompt } from './planner.mjs'
+export { assembleVerifyPrompt } from './verify.mjs'
+export { assembleReplanPrompt } from './replan.mjs'
+export { assembleCommitPrompt } from './commit.mjs'
+export { assembleReviewPrompt } from './review.mjs'
+export { assembleRemediatePrompt, assembleVerdictPrompt } from './remediate.mjs'
+export { assembleHandoffPrompt } from './handoff.mjs'
+export { selectDimensions, ALWAYS_ON_DIMENSIONS } from './dimensions.mjs'
+export { publishStageLine } from './stage.mjs'
+export * from './schemas.mjs'
+
+const CHANGE = 'demo-change'
+
+/**
+ * name → { module, assemble, inputs }. One entry per assembler; `inputs` is a
+ * list, so an assembler with a meaningfully different shape per branch (a lane
+ * of one vs a lane of several; inter-wave vs final verification) registers each.
+ */
+export const PROMPTS = Object.freeze({
+  implementer: {
+    module: 'implementer.mjs',
+    assemble: assembleImplementerPrompt,
+    inputs: [
+      {
+        change: CHANGE,
+        task: { id: '1.1', description: 'sessions table', tier: 3, model: 'sonnet' },
+        previousHandoffs: []
+      },
+      {
+        change: CHANGE,
+        lane: [
+          { id: '1.1', description: 'sessions table', tier: 2, model: 'sonnet' },
+          { id: '1.2', description: 'session index', tier: 4, model: 'sonnet' }
+        ],
+        previousHandoffs: [
+          {
+            taskId: '0.1',
+            status: 'ok',
+            summary: 'schema landed',
+            evidence: ['lib/db.mjs:12-40'],
+            next: 'wire the reader',
+            blocker: null
+          }
+        ],
+        isolateWaves: true
+      },
+      {
+        change: CHANGE,
+        lane: [{ id: '1.1', description: 'the whole change', tier: 2, model: 'sonnet' }],
+        solo: true,
+        previousHandoffs: []
+      }
+    ]
+  },
+  planner: {
+    module: 'planner.mjs',
+    assemble: assemblePlannerPrompt,
+    inputs: [{ change: CHANGE, classifiedPath: '.claude/ship/classified.json' }]
+  },
+  verify: {
+    module: 'verify.mjs',
+    assemble: assembleVerifyPrompt,
+    inputs: [
+      {
+        change: CHANGE,
+        context: 'inter-wave',
+        steps: [{ kind: 'unit', command: 'npm test' }],
+        runId: 'run-1',
+        statePath: '.claude/ship/state.json'
+      },
+      {
+        change: CHANGE,
+        context: 'final',
+        steps: [
+          { kind: 'unit', command: 'npm test' },
+          { kind: 'e2e', command: 'npm run e2e' }
+        ],
+        runId: null,
+        statePath: '.claude/ship/state.json'
+      },
+      // The fix branch: a retry carries what the previous attempt reported, and
+      // the integrity sweep must see that branch rendered too.
+      {
+        change: CHANGE,
+        context: 'inter-wave',
+        steps: [{ kind: 'unit', command: 'npm test' }],
+        runId: 'run-1',
+        statePath: '.claude/ship/state.json',
+        fixAttempt: 1,
+        fixAttemptsRemaining: 1,
+        errors: ['unit suite is red (1 failing, 1 root-cause cluster(s))']
+      }
+    ]
+  },
+  replan: {
+    module: 'replan.mjs',
+    assemble: assembleReplanPrompt,
+    inputs: [{ change: CHANGE, replanPath: '.claude/ship/replan.json' }]
+  },
+  commit: {
+    module: 'commit.mjs',
+    assemble: assembleCommitPrompt,
+    inputs: [{ change: CHANGE, stageIndex: 7 }]
+  },
+  review: {
+    module: 'review.mjs',
+    assemble: assembleReviewPrompt,
+    inputs: [
+      {
+        change: CHANGE,
+        dimensions: [
+          { name: 'language', rubric: 'Check idiomatic usage, type safety and error handling.' },
+          { name: 'devops', rubric: null }
+        ],
+        policyProse: 'Blockers must cite evidence; treat purely cosmetic nits as suggestions, not warnings.',
+        findingsPath: '.claude/ship/demo-change/review/findings.json',
+        verdictsPath: '.claude/ship/demo-change/review/verdicts.json',
+        stageLine: publishStageLine('review', CHANGE, 5)
+      },
+      {
+        change: CHANGE,
+        dimensions: [{ name: 'qa', rubric: 'Are edge cases and error paths covered by a test?' }],
+        policyProse: '',
+        findingsPath: '.claude/ship/demo-change/review/findings.json',
+        verdictsPath: '.claude/ship/demo-change/review/verdicts.json',
+        stageLine: publishStageLine('review', CHANGE, 5)
+      }
+    ]
+  },
+  remediate: {
+    module: 'remediate.mjs',
+    assemble: assembleRemediatePrompt,
+    inputs: [
+      {
+        change: CHANGE,
+        round: 1,
+        plan: {
+          fix: {
+            byFile: [
+              {
+                file: 'lib/db.mjs',
+                findings: [
+                  {
+                    severity: 'blocker',
+                    file: 'lib/db.mjs',
+                    line: 42,
+                    title: 'missing null check',
+                    description: 'a null session can reach the query builder unchecked',
+                    suggestion: 'guard before the query is built'
+                  }
+                ]
+              }
+            ],
+            unscoped: [
+              {
+                severity: 'warning',
+                file: null,
+                title: 'naming drift',
+                description: 'the same concept is named two different ways across the diff'
+              }
+            ]
+          },
+          reReviewDimensions: ['language']
+        },
+        dimensions: [{ name: 'language', rubric: 'Check idiomatic usage, type safety and error handling.' }],
+        policyProse: 'Blockers must cite evidence; treat purely cosmetic nits as suggestions, not warnings.',
+        stageLine: publishStageLine('remediation', CHANGE, 6)
+      }
+    ]
+  },
+  verdict: {
+    module: 'remediate.mjs',
+    assemble: assembleVerdictPrompt,
+    inputs: [{ change: CHANGE, round: 3 }]
+  },
+  handoff: {
+    module: 'handoff.mjs',
+    assemble: assembleHandoffPrompt,
+    inputs: [
+      {
+        change: CHANGE,
+        needsManualTestPlan: true,
+        testPlanReason: undefined,
+        conformance: [
+          { id: 'S1', artifact: 'openspec/specs/demo-change/spec.md', line: 12, title: 'rejects an expired session' }
+        ],
+        learnings: true
+      },
+      {
+        change: CHANGE,
+        needsManualTestPlan: false,
+        testPlanReason: 'a backend-only change touches no UI surface',
+        conformance: null,
+        learnings: false
+      },
+      {
+        change: CHANGE,
+        needsManualTestPlan: null,
+        testPlanReason: undefined,
+        conformance: [],
+        learnings: false
+      }
+    ]
+  },
+  stage: {
+    module: 'stage.mjs',
+    assemble: ({ stage, change, index }) => publishStageLine(stage, change, index),
+    inputs: [
+      { stage: 'implement', change: CHANGE, index: 1 },
+      { stage: 'fix-tests', change: CHANGE, index: 2 },
+      { stage: 'commit', change: CHANGE, index: 3 }
+    ]
+  }
+})
+
+/** Every registered assembler's module filename, for the unregistered-module check. */
+export const REGISTERED_MODULES = Object.freeze(
+  Object.values(PROMPTS).map(entry => entry.module)
+)
+
+/**
+ * Modules under `lib/prompts/` that hold no assembler and are not expected in
+ * the registry. `dimensions.mjs` selects which review dimensions run — a
+ * `{ dimensions, reasons }` decision, never a string handed to an agent — so
+ * it has no briefing to register or check for coercion artifacts.
+ */
+export const NON_ASSEMBLER_MODULES = Object.freeze(['index.mjs', 'schemas.mjs', 'dimensions.mjs'])

package/lib/prompts/planner.mjs

@@ -0,0 +1,70 @@
+// The wave-classification briefing.
+//
+// This text lived in both drivers, worded differently in each — the one place
+// classifier policy demonstrably drifted, since the same task could classify
+// differently depending on which host ran it. A cross-driver parity test
+// compared the extracted tier boundaries after the fact. There is nothing left
+// to compare: the CLI assembles this once and hands it to whichever host is
+// running (design D7).
+//
+// The form is the ACP driver's — the model writes `classified.json` and reports
+// whether it did. It never runs the interlock CLI; `interlock run classified`
+// does coverage, waves, the plan file and `wave-state create` afterwards. The
+// rules themselves are the Workflow driver's fuller wording, verbatim.
+
+/**
+ * @param {{ change: string, classifiedPath: string }} input
+ * @returns {string}
+ */
+export function assemblePlannerPrompt({ change, classifiedPath }) {
+  return (
+    `For OpenSpec change "${change}": read proposal.md, design.md, tasks.md and specs/**/*.md in full — ` +
+    `this is the artifact leash and is not subject to bounded retrieval.\n\n` +
+    `Classify every UNCHECKED task with: id, group (wave number), description, tier 1-5, model, ` +
+    `isTestTask, paths, and dependsOn.\n\n` +
+    `GROUPING — four rules, in order:\n` +
+    `  1. Default group to the numbered tasks.md section (1.x → group 1, 2.x → group 2).\n` +
+    `  2. A shared file is NOT a reason for a new group. Put the predicted edit paths in \`paths\` ` +
+    `and let the planner fold colliding tasks into one LANE of the SAME wave — an ordered task ` +
+    `list run by a single agent. Inventing a new group to avoid a file clash costs a verification ` +
+    `cycle; naming the path costs nothing and saves a spawn.\n` +
+    `  3. A dependency on a task editing a DIFFERENT file is a reason for a \`dependsOn\` EDGE, ` +
+    `not a reason to increment \`group\`. Incrementing \`group\` to order one cross-file dependency ` +
+    `serializes every task in the new group that is independent of it; an edge orders only the ` +
+    `dependent task, so its independent siblings keep sharing a batch. Prefer the edge.\n` +
+    `  4. Only add a group for a LATER NUMBERED SECTION that needs an earlier section's output ` +
+    `to already exist. The next sequential slice of the same file is NOT a new group — it stays ` +
+    `in that file's section group and becomes a later batch. Groups run sequentially; tasks in a ` +
+    `group are otherwise independent.\n\n` +
+    `\`paths\` is your best prediction of the repo-relative files the task will edit. Predict what you ` +
+    `can and OMIT the field when you genuinely cannot — an invented path serializes a batch for ` +
+    `nothing, while an omitted one only leaves things as they were.\n\n` +
+    `\`dependsOn\` is the array of ids of EARLIER tasks whose output this task needs — the file it ` +
+    `imports, the type it consumes, the helper it calls. Populate it whenever that is true, and ` +
+    `omit it otherwise. Every id must name a task in this same classification, must not point at ` +
+    `a later numbered section, and must not point at a test task; the edges must not form a cycle. ` +
+    `A dangling id, a backward edge or a cycle FAILS the plan rather than being dropped, so declare ` +
+    `only dependencies you can point at.\n\n` +
+    `MODE — beside the task array, emit a top-level "recommendedMode" of "solo" or "waves" and a ` +
+    `one-line "modeReason" saying why. Solo means one agent implements this whole change by ` +
+    `itself, task by task in the planned order, with no parallel waves and no isolation between ` +
+    `tasks; waves means the ordinary parallel plan. Recommend solo when the change is small and ` +
+    `tightly coupled enough that one agent holding all of it beats several agents each holding a ` +
+    `slice, and waves otherwise. Judge the shape only: the planner enforces the published envelope ` +
+    `on how large a change may ship solo and will refuse a recommendation above it, so do not ` +
+    `reason about the size bound and do not state one.\n\n` +
+    // A unary `+` once sat before this operand and coerced it to NaN, so tiers
+    // 1-3 and the haiku routing rule never reached the classifier while the
+    // sentence stayed intact in the source bytes. test/spine/prompts.test.mjs
+    // asserts the ASSEMBLED string for exactly that reason.
+    `Tier 1 trivial one-file edit → haiku. Tier 2 single-concern change. Tier 3 new logic in one ` +
+    `domain. Tier 4 cross-file work following existing patterns — a mechanical refactor across many ` +
+    `files is tier 4 sonnet, because breadth is not depth. Tier 5 only for genuinely novel ` +
+    `architecture, and only tier 5 may be opus. When unsure, sonnet.\n\n` +
+    `Write the classification as { "tasks": [...] } to ${classifiedPath}. ` +
+    `Do NOT run the interlock CLI yourself — the orchestrator runs the planner, the coverage check ` +
+    `and the state machine. Report only whether the file was written and how many tasks it holds.\n\n` +
+    `The planner is authoritative: it clamps over-eager opus, orders the waves, defers test tasks ` +
+    `and splits wide waves into batches. Do not re-derive or override any of it.`
+  )
+}