audit-tools 0.52.0 → 0.52.1

package/dist/remediate/steps/nextStep.js

@@ -1,14 +1,15 @@
-// sites-pinned: tests/remediate/friction-capture-closeout.test.ts, tests/remediate/next-step-lifecycle.test.ts, tests/remediate/next-step-pipeline-dispatch.test.ts, tests/remediate/next-step-outcomes-contract.test.ts, tests/remediate/integration-pipeline.test.ts, tests/remediate/outcomes-roundtrip.test.ts, tests/remediate/phase-close.test.ts, tests/remediate/grounding.test.ts
+// sites-pinned: tests/remediate/friction-capture-closeout.test.ts, tests/remediate/next-step-lifecycle.test.ts, tests/remediate/next-step-pipeline-dispatch.test.ts, tests/remediate/next-step-outcomes-contract.test.ts, tests/remediate/integration-pipeline.test.ts, tests/remediate/outcomes-roundtrip.test.ts, tests/remediate/phase-close.test.ts, tests/remediate/grounding.test.ts, tests/remediate/clarification-round-contract.test.ts, tests/remediate/next-step-review-gate.test.ts, tests/remediate/n-r04-intent-checkpoint.test.ts, tests/remediate/final-gate-red-pause.test.ts
 // (the free-form branch's write
 // scope is normalized — a backslash-spelled citation no longer wedges prepare)
 import { AUDIT_TOOLS_DIRNAME } from "../../shared/io/auditToolsPaths.js";
 import { loadRemediateSessionConfig } from "./sessionConfigLoad.js";
+import { z } from "zod";
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 import { StateStore } from "../state/store.js";
 // IO / validation / rendering helpers
-import { discardOnSchemaVersionMismatch, readOptionalJsonFile, stagedAndUntracked, writeJsonFile, writeTextFile, buildAuditDeliverablePair, auditReadOf, formatValidationIssues, isMissingObservation, isRecord, withFsRetry, RunLogger, coerceJsonObjectArg, renderPromptCommand, headCommit, projectAuditFindingsReportSubset, 
+import { discardOnSchemaVersionMismatch, readOptionalJsonFile, stagedAndUntracked, writeJsonFile, writeTextFile, buildAuditDeliverablePair, auditReadOf, formatValidationIssues, isRecord, renderIngestReportLines, withFsRetry, RunLogger, coerceJsonObjectArg, renderPromptCommand, headCommit, projectAuditFindingsReportSubset, 
 // obligation engine + intent
 interpretFreeFormIntent, interpretIntent, unresolvedFromClauses, advance, describeStoppedFold, decideFrictionTriage, buildFrictionTriageBlock, linkFrictionRunIds, 
 // domain constants
@@ -19,7 +20,7 @@ import { runTriagePhase } from "../phases/triage.js";
 import { runClosePhase } from "../phases/close.js";
 import { validateRemediationPlan } from "../validation/remediationState.js";
 import { readExtractedPlanIfPresent, } from "./dispatch/marshal.js";
-import { ingestRemediationHostResults, hostDependencyLevels, permanentlyDeadPendingBlocks, precomputeRecoveryTestVerdicts, prepareRemediationHostHandoff, workloadBindingIdentity, } from "./dispatch/hostHandoff.js";
+import { ingestRemediationHostResults, hostDependencyLevels, permanentlyDeadPendingBlocks, precomputeRecoveryTestVerdicts, prepareRemediationHostHandoff, remediationIssueRemedy, workloadBindingIdentity, } from "./dispatch/hostHandoff.js";
 import { FileLockTimeoutError, withFileLock, } from "../../shared/io/fileLock.js";
 import { AUDIT_FINDINGS_FILENAME, AUDIT_REPORT_FILENAME, auditArtifactsDir, auditFindingsPath, auditReportPath, promotedAuditFindingsPath, promotedAuditReportPath, remediationArtifactsDir, } from "../../shared/io/auditToolsPaths.js";
 import { callerWorkingDirectory, discoverRepoRoot, resolveRepoRoot, } from "../../shared/io/repoRoot.js";
@@ -35,13 +36,13 @@ import { renderGateAttribution, worktreeContentId, } from "./gateCommands.js";
 import { buildNextContractPipelineStep, shouldEnterContractPipeline, readSeedAuditRead, writePathASeedFromFindings, normalizeBlockTouchedFiles, checkWriteScopePathsAgainstTrackedTree, } from "./contractPipeline.js";
 import { compareCodeUnits } from "../../shared/compareCodeUnits.js";
 import { contractArtifactExists, contractPipelineDir, } from "../contractPipeline/artifactStore.js";
-import { buildReviewRequest, applyReviewResolution, isResolutionForRequest, screenResolutionIds, REVIEW_REQUEST_SCHEMA_VERSION, } from "../review/reviewGate.js";
+import { buildReviewRequest, applyReviewResolution, parseReviewResolution, REVIEW_REQUEST_SCHEMA_VERSION, } from "../review/reviewGate.js";
 import { buildAutonomousReviewDecision } from "../review/autonomousGate.js";
 import { runFindingFilterPass } from "../findingFilter.js";
 import { droppedFindingsRecordPath, renderDroppedFindingsRecord, } from "../droppedFindingsRecord.js";
-import { intakePaths, isIntakeReady, manifestIsInputBound, readIntakeArtifacts, readProjectFacts, writeProjectFacts, resolveManifestSources, } from "../intake.js";
+import { intakePaths, isIntakeReady, manifestIsInputBound, readIntakeArtifacts, readProjectFacts, readSourceManifest, writeProjectFacts, resolveManifestSources, writeRemediationBrief, } from "../intake.js";
 import { ensureIntakeRiskSignal, readIntakeRiskSignal, writeIntakeRiskSignal, escalateRiskSignal, findingRiskEvidence, distinctAffectedFiles, } from "../riskSignal.js";
-import { readIntentCheckpoint, readIntentCheckpointLenient, } from "audit-tools/shared";
+import { isLegacyDraftCheckpoint, readIntentCheckpoint, readIntentCheckpointLenient, } from "audit-tools/shared";
 import { ambiguityReviewPrompt, clarificationPrompt, collectIntakeClarificationsPrompt, collectStartingPointPrompt, extractedPlanDiscardedPrompt, loaderCommand, reviewApprovalPrompt, synthesizeIntakePrompt, triagePrompt, } from "./prompts.js";
 // Single-sourced prose renders of the canonical lens / severity vocabularies
 // (`audit-tools/shared` `LENSES` / `SEVERITIES`) for the intent-checkpoint
@@ -950,34 +951,24 @@ export async function recoverIngestHostResults(options) {
     return ingested;
 }
 /**
- * Render the host-facing result status for an ingest, split by outcome.
+ * The ingest report for the implement-dispatch prompt, as prompt lines.
  *
- * Takes the whole summary rather than just its issues, because the split needs
- * BOTH halves: which items were refused (from the issues) and which landed
- * without a result (from `work_item_outcomes`, where the run's corroborated
- * commit for the item is what separates that case from plain unfinished work).
+ * Takes the whole summary rather than just its issues, because the report needs
+ * BOTH halves: the classified issues, and the items that landed without a
+ * result (from `work_item_outcomes`, where the run's corroborated commit for
+ * the item is what separates that case from plain unfinished work). The
+ * sections are the shared renderer's; only the remedy map is this draw's.
  */
-function remediationResultDiagnostics(ingested) {
-    const describe = (issue) => `- ${issue.work_item_id ? `\`${issue.work_item_id}\`: ` : ""}${issue.message}${issue.result_path ? ` (\`${issue.result_path}\`)` : ""}`;
-    const section = (heading, lines) => lines.length === 0 ? "" : `\n${heading}\n\n${lines.join("\n")}\n`;
-    const rejected = ingested.issues.filter((issue) => !isMissingObservation(issue));
-    const landedWithoutResult = [...ingested.work_item_outcomes]
-        .filter(([, outcome]) => outcome === "missing_result_with_commit")
-        .map(([id]) => id)
-        .sort(compareCodeUnits);
-    const notYetWritten = ingested.issues.filter((issue) => isMissingObservation(issue));
-    const body = section("## Results already landed, whose result file is missing", landedWithoutResult.map((id) => `- \`${id}\`: this item's edits are IN this repository — a corroborated commit landed ` +
-        `for it and its changed files are recorded — but no result file exists at its bound ` +
-        `\`result_path\`. This is PARTIAL PROGRESS, not absent work: write the result for the ` +
-        `commit that is already there rather than redoing the edit.`)) +
-        section("## Result status requiring attention", rejected.map(describe)) +
-        section("## Results not yet written", notYetWritten.map(describe));
-    if (body === "")
-        return "";
-    return (body +
-        "\nThe workload was restored from its tool-owned digest when necessary. Repair or\n" +
-        "complete only the named result files; do not rewrite the workload or its\n" +
-        "baseline.\n");
+function remediationIngestReportLines(ingested) {
+    return renderIngestReportLines({
+        issues: ingested.issues,
+        remedy: remediationIssueRemedy,
+        workload: "named_above",
+        landedWithoutResult: [...ingested.work_item_outcomes]
+            .filter(([, outcome]) => outcome === "missing_result_with_commit")
+            .map(([id]) => id)
+            .sort(compareCodeUnits),
+    });
 }
 async function buildImplementDispatchStep(ctx) {
     const { root, artifactsDir, state, store, runLogger } = ctx;
@@ -1053,17 +1044,29 @@ async function buildImplementDispatchStep(ctx) {
     // RENDER — a channel that survives exactly as long as the host reads this one
     // step, and that is reached only when nothing was accepted.
     //
-    // THREE STATES, THREE SECTIONS, because they have three different remedies and
-    // a reader must not have to parse prose to tell them apart (the measured
-    // friction: a host parser special-casing "no result file exists"):
-    //   rejected               — something was written and refused; repair it.
-    //   missing + commit       — the edits LANDED but no result exists; write the
-    //                            result FOR THE COMMIT THAT IS ALREADY THERE.
-    //   missing, no commit     — nothing yet; write it when the work is done.
-    // The classification is on CODES, never message text, so rewording a message
-    // cannot move an item between sections.
-    const diagnostics = remediationResultDiagnostics(ingested);
+    // Each issue lands under the section its CODE's remedy names, never under one
+    // its message text suggests, so rewording a message cannot move an item
+    // between sections (the measured friction: a host parser special-casing "no
+    // result file exists").
+    const report = remediationIngestReportLines(ingested);
     const nextCommand = loaderCommand("next-step");
+    const promptLines = [
+        "# Implement the remediation work items",
+        "",
+        "Read the workload file:",
+        "",
+        `\`${handoff.workload_path}\``,
+        "",
+        "The file lists every work item that is ready now. Give each item's prompt to a worker. You choose the order, the groups, and how many run at the same time.",
+        "",
+        ...report,
+        ...(report.length > 0 ? ["Change only the result files named above.", ""] : []),
+        "Do not edit the workload file.",
+        "",
+        "When each item has its commit on HEAD and its result file, run:",
+        "",
+        `\`${nextCommand}\``,
+    ];
     return {
         kind: "emit",
         step: await writeCurrentStep({
@@ -1072,23 +1075,7 @@ async function buildImplementDispatchStep(ctx) {
             runId,
             repoRoot: root,
             artifactsDir,
-            prompt: `
-# Implement the Eligible Remediation Workload
-
-Read the generated workload at:
-
-\`${handoff.workload_path}\`
-
-It contains the complete, dependency-safe current frontier. Complete every work
-item and write its exact prompt-bound result contract to its \`result_path\`.
-The host owns execution choices, grouping, and concurrency; audit-tools performs
-no launch, routing, or quota decision. Do not start a later dependency level.
-${diagnostics}
-
-After all completed changes are merged and their result files exist, run:
-
-\`${nextCommand}\`
-`,
+            prompt: `\n${promptLines.join("\n")}\n`,
             allowedCommands: [
                 ...new Set(handoff.workload.work_items.flatMap((item) => item.required_tests)),
                 nextCommand,
@@ -1490,7 +1477,7 @@ async function handleWaitingForReviewApproval(root, artifactsDir, request, refus
         artifactsDir,
         prompt: reviewApprovalPrompt(request, reviewResolutionPath(artifactsDir), refusal),
         allowedCommands: [loaderCommand("next-step")],
-        stopCondition: "Stop after presenting the findings for approval and collecting the user's approve/disapprove decision, unless the decision is already recorded and the prompt told you to continue.",
+        stopCondition: "Stop after presenting the findings for approval and collecting the user's approve/decline decision, unless the decision is already recorded and the prompt told you to continue.",
         artifactPaths: {
             review_request: reviewRequestPath(artifactsDir),
             review_resolution: reviewResolutionPath(artifactsDir),
@@ -1498,29 +1485,25 @@ async function handleWaitingForReviewApproval(root, artifactsDir, request, refus
     });
 }
 /**
- * Uniform id-join contract pre-screen for the review gate (both paths): a
- * resolution naming an unknown finding id or tier is REFUSED whole — archived
- * (never applied) and the gate re-halts with the refusal and the valid set in
- * the re-prompt. The gate's default is approve, so the silent-drop alternative
- * turns a typo'd decline into an approval. Returns the re-halt step, or null
- * when the resolution's ids are clean. `applyReviewResolution` re-checks as the
- * mechanical backstop.
+ * Read the review resolution for both gate paths, through the one strict
+ * parser ({@link parseReviewResolution}). A refused file (bad JSON, an unknown
+ * field, a wrong type, an id or tier outside the request) is archived as
+ * `.refused-<ts>` — never applied — and the gate re-halts with each problem
+ * named. The gate's default is approve, so reading past a bad file would turn
+ * the user's decline into an approval. A stale file from another run is
+ * archived as `.stale-<ts>` and the gate re-halts with no refusal. Returns the
+ * re-halt step, or the resolution to apply.
  */
-async function refuseUnknownIdResolution(root, artifactsDir, request, resolution, resolutionPath, requestPath) {
-    const screen = screenResolutionIds(request, resolution);
-    if (screen.unknown_finding_ids.length === 0 && screen.unknown_tiers.length === 0) {
-        return null;
-    }
-    await withFsRetry(() => rename(resolutionPath, `${resolutionPath}.refused-${Date.now()}`));
+async function readReviewResolution(root, artifactsDir, request, resolutionPath, requestPath) {
+    const parsed = parseReviewResolution(await readFile(resolutionPath, "utf8"), request);
+    if (parsed.kind === "ok")
+        return { resolution: parsed.resolution };
+    const suffix = parsed.kind === "stale" ? "stale" : "refused";
+    await withFsRetry(() => rename(resolutionPath, `${resolutionPath}.${suffix}-${Date.now()}`));
     await writeJsonFile(requestPath, request);
-    const parts = [];
-    if (screen.unknown_finding_ids.length > 0) {
-        parts.push(`finding id(s) not in the request: ${screen.unknown_finding_ids.map((i) => `\`${i}\``).join(", ")}`);
-    }
-    if (screen.unknown_tiers.length > 0) {
-        parts.push(`unknown tier(s): ${screen.unknown_tiers.map((t) => `\`${t}\``).join(", ")}`);
-    }
-    return handleWaitingForReviewApproval(root, artifactsDir, request, parts.join("; "));
+    return {
+        halt: await handleWaitingForReviewApproval(root, artifactsDir, request, parsed.kind === "refused" ? parsed.reason : undefined),
+    };
 }
 /**
  * Run the review-approval gate over the SURVIVOR finding set (already passed
@@ -1586,21 +1569,10 @@ sourceAuditRead, autonomous = false) {
         // Consume the resolution into a durable, reasoned decision record.
         // Regenerable: a stale-schema request is treated as absent and rebuilt below.
         const request = discardOnSchemaVersionMismatch(await readOptionalJsonFile(requestPath), REVIEW_REQUEST_SCHEMA_VERSION) ?? buildReviewRequest(survivors, randomRunId("path-a-review"));
-        const resolution = await readOptionalJsonFile(resolutionPath);
-        if (!isResolutionForRequest(request, resolution)) {
-            // Stale cross-run resolution (plan_id mismatch): archive it and RE-HALT
-            // with the live request rather than applying another run's answer.
-            await withFsRetry(() => rename(resolutionPath, `${resolutionPath}.stale-${Date.now()}`));
-            await writeJsonFile(requestPath, request);
-            return {
-                kind: "halt",
-                step: await handleWaitingForReviewApproval(root, artifactsDir, request),
-            };
-        }
-        const refusalStep = await refuseUnknownIdResolution(root, artifactsDir, request, resolution, resolutionPath, requestPath);
-        if (refusalStep)
-            return { kind: "halt", step: refusalStep };
-        const decision = applyReviewResolution(request, resolution);
+        const read = await readReviewResolution(root, artifactsDir, request, resolutionPath, requestPath);
+        if ("halt" in read)
+            return { kind: "halt", step: read.halt };
+        const decision = applyReviewResolution(request, read.resolution);
         await writeReviewDecisionRecord(decisionPath, {
             planId: request.plan_id,
             approvedIds: decision.approved_ids,
@@ -1831,9 +1803,10 @@ async function handleReadyIntakeContractPipeline(root, artifactsDir, options, ru
     }
     const paths = intakePaths(artifactsDir);
     const sourcePaths = new Set();
-    if (existsSync(paths.brief)) {
-        sourcePaths.add(paths.brief);
-    }
+    // The brief is the tool's render of the ready summary; write it before it
+    // becomes a pipeline source, so the source is never absent or stale.
+    await writeRemediationBrief(artifactsDir, intake.summary);
+    sourcePaths.add(paths.brief);
     for (const source of manifestSources) {
         // Swap the raw audit-findings.json for the approved-only filtered file so a
         // declined finding can never re-enter the pipeline as a source input.
@@ -1950,59 +1923,128 @@ Stop after presenting this choice. Do not advance the run until the user decides
         },
     });
 }
-const PLAN_CLARIFICATION_ACTIONS = [
-    "clarified",
-    "reject_finding",
-    "defer",
-];
-function isPlanClarificationAction(value) {
-    return (typeof value === "string" &&
-        PLAN_CLARIFICATION_ACTIONS.includes(value));
-}
-/** Carry `scope_additions` through when it is an array; keep string entries. */
-function normalizedScopeAdditions(entry) {
-    if (!Array.isArray(entry.scope_additions))
-        return {};
-    return {
-        scope_additions: entry.scope_additions.filter((p) => typeof p === "string"),
-    };
-}
-function normalizePlanClarificationResolutions(value) {
-    if (Array.isArray(value)) {
-        return value.filter(isRecord).flatMap((entry) => {
-            if (typeof entry.finding_id === "string" && isPlanClarificationAction(entry.action)) {
-                return [
-                    {
-                        finding_id: entry.finding_id,
-                        action: entry.action,
-                        rationale: typeof entry.rationale === "string" ? entry.rationale : undefined,
-                        ...normalizedScopeAdditions(entry),
-                    },
-                ];
-            }
-            return [];
+// Action tokens are deliberately unambiguous so a host CANNOT lose an
+// approved finding by a natural word choice at the ambiguity gate: "this
+// candidate ambiguity isn't genuine" reads as a comment on the AMBIGUITY, so it
+// must map to `clarified` (proceed with the finding), never to a drop. The
+// finding-dropping token is named `reject_finding` — it speaks about the
+// FINDING, not the ambiguity, and so can't be confused with "no ambiguity here."
+const PLAN_CLARIFICATION_ACTIONS = ["clarified", "reject_finding", "defer"];
+/**
+ * One entry of a clarification resolution file. Strict: an unknown field is
+ * refused, not ignored.
+ *
+ * - `rationale` is REQUIRED and non-empty on `clarified`: it becomes the item's
+ *   `clarification_context`, the answer the next worker reads. A `clarified`
+ *   entry without it re-opened the item with no answer attached.
+ * - `scope_additions` lists the files the answer ADDS to the owning block's
+ *   write scope (open-bugs.md:110): every file the fix must create or edit
+ *   beyond the promoted scope — the test a node must write, the source a
+ *   generated artifact mirrors, a new shared module, a manifest. It is allowed
+ *   ONLY on `clarified`, the one action that re-opens the item; on
+ *   `reject_finding` or `defer` it used to be ignored without a word. Each path
+ *   is validated whole-file fail-closed BEFORE anything is applied
+ *   (`validateClarificationScopeAdditions`), so the host never edits the plan
+ *   by hand.
+ */
+const PlanClarificationResolutionSchema = z
+    .object({
+    finding_id: z.string().min(1, "must be a non-empty finding id"),
+    action: z.enum(PLAN_CLARIFICATION_ACTIONS),
+    rationale: z.string().optional(),
+    scope_additions: z.array(z.string()).optional(),
+})
+    .strict()
+    .superRefine((entry, ctx) => {
+    if (entry.action === "clarified" && (entry.rationale ?? "").trim().length === 0) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["rationale"],
+            message: 'is required and must be non-empty when action is "clarified" — it carries the answer to the next worker',
         });
     }
-    if (!isRecord(value))
-        return [];
-    if (Array.isArray(value.resolutions)) {
-        return normalizePlanClarificationResolutions(value.resolutions);
+    if (entry.action !== "clarified" && entry.scope_additions !== undefined) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["scope_additions"],
+            message: `is allowed only with action "clarified" — a ${entry.action} entry widens no write scope`,
+        });
     }
-    if (Array.isArray(value.items)) {
-        return normalizePlanClarificationResolutions(value.items);
+});
+/**
+ * Read and validate a clarification resolution file — the mid-run
+ * `clarification_resolution.json` and the up-front `ambiguity_resolution.json`
+ * share this one parser.
+ *
+ * ONE shape is accepted: a bare JSON array of entries. Every entry is checked
+ * against {@link PlanClarificationResolutionSchema}, and a second entry for the
+ * same finding is refused. Any bad entry refuses the WHOLE file, and the reason
+ * names the entry's index and field. The parser this replaced accepted four
+ * shapes and dropped a bad entry in silence: an `"action": "approve"` lost the
+ * user's answer, and the item then waited forever for a question the round no
+ * longer showed.
+ */
+async function readPlanClarificationResolutions(path) {
+    let value;
+    try {
+        value = JSON.parse(await readFile(path, "utf8"));
+    }
+    catch (error) {
+        return {
+            ok: false,
+            reason: `the file is not valid JSON (${error instanceof Error ? error.message : String(error)})`,
+        };
+    }
+    if (!Array.isArray(value)) {
+        return {
+            ok: false,
+            reason: "the file must be a JSON array of entries — an object wrapper such as " +
+                '`{"resolutions": [...]}` is not accepted',
+        };
     }
-    return Object.entries(value).flatMap(([findingId, entry]) => {
-        if (!isRecord(entry))
-            return [];
-        if (!isPlanClarificationAction(entry.action))
-            return [];
-        return [{
-                finding_id: typeof entry.finding_id === "string" ? entry.finding_id : findingId,
-                action: entry.action,
-                rationale: typeof entry.rationale === "string" ? entry.rationale : undefined,
-                ...normalizedScopeAdditions(entry),
-            }];
+    const problems = [];
+    const firstEntryFor = new Map();
+    const resolutions = [];
+    value.forEach((entry, index) => {
+        const parsed = PlanClarificationResolutionSchema.safeParse(entry);
+        if (!parsed.success) {
+            for (const issue of parsed.error.issues) {
+                const field = issue.path.length > 0 ? ` \`${issue.path.join(".")}\`` : "";
+                problems.push(`entry [${index}]${field}: ${issue.message}`);
+            }
+            return;
+        }
+        const prior = firstEntryFor.get(parsed.data.finding_id);
+        if (prior !== undefined) {
+            problems.push(`entry [${index}] \`finding_id\`: \`${parsed.data.finding_id}\` is already answered by entry [${prior}]`);
+            return;
+        }
+        firstEntryFor.set(parsed.data.finding_id, index);
+        resolutions.push(parsed.data);
     });
+    return problems.length > 0
+        ? { ok: false, reason: problems.join("; ") }
+        : { ok: true, resolutions };
+}
+/**
+ * Every whole-file refusal of a parsed resolution, in check order: the parse,
+ * then the closed id set, then the scope additions. Null means the file may be
+ * applied.
+ */
+async function planClarificationRefusal(root, state, parsed, validIds, outsideSetLabel) {
+    if (!parsed.ok)
+        return parsed.reason;
+    const unknownIds = parsed.resolutions
+        .map((r) => r.finding_id)
+        .filter((id) => !validIds.has(id));
+    if (unknownIds.length > 0) {
+        return `finding id(s) ${outsideSetLabel}: ${unknownIds.map((i) => `\`${i}\``).join(", ")}`;
+    }
+    const scopeRefusals = await validateClarificationScopeAdditions(root, state, parsed.resolutions);
+    if (scopeRefusals.length > 0) {
+        return `invalid scope_additions — fix and re-submit: ${scopeRefusals.join(" | ")}`;
+    }
+    return null;
 }
 /**
  * Validate every `clarified` resolution's `scope_additions` BEFORE anything is
@@ -2059,6 +2101,8 @@ function applyClarificationScopeAdditions(root, state, res) {
  * Never resurrects a terminal item.
  */
 function applyClarificationActionToItem(item, res, now) {
+    // The question is answered (or the finding is closed): it leaves the item.
+    delete item.clarification_question;
     if (res.action === "reject_finding") {
         item.status = "deemed_inappropriate";
         item.failure_reason = res.rationale;
@@ -2087,32 +2131,22 @@ async function applyPlanClarificationResolution(root, artifactsDir, state, store
     if (!state.plan || !state.items)
         return { kind: "applied", state };
     const resolutionPath = join(artifactsDir, "clarification_resolution.json");
-    const resolutions = normalizePlanClarificationResolutions(await readOptionalJsonFile(resolutionPath));
-    // Uniform id-join contract: an unknown finding_id refuses the WHOLE
-    // resolution (archived, nothing applied) and re-halts with the unknown ids
-    // named — the silent-continue alternative drops the user's answer on a typo'd
-    // id and force-closes its item as abandoned at the fall-through below.
-    const unknownIds = resolutions
-        .map((r) => r.finding_id)
-        .filter((id) => !state.items?.[id]);
-    if (unknownIds.length > 0) {
-        await withFsRetry(() => rename(resolutionPath, `${resolutionPath}.refused-${Date.now()}`));
-        return {
-            kind: "refused",
-            step: await handleWaitingForClarification(root, artifactsDir, state, `finding id(s) not in the plan: ${unknownIds.map((i) => `\`${i}\``).join(", ")}`),
-        };
-    }
-    // Scope deltas ride the same whole-file fail-closed contract as unknown ids:
-    // an invalid addition refuses everything, so a decision record never
+    const parsed = await readPlanClarificationResolutions(resolutionPath);
+    // Uniform whole-file fail-closed contract: a malformed entry, an id outside
+    // the paused set, or an invalid scope addition refuses the WHOLE resolution
+    // (archived, nothing applied) and re-halts with the reason named. The
+    // silent-continue alternative drops the user's answer and leaves its item
+    // waiting on a question nobody is asked, so a decision record never
     // half-applies (open-bugs.md:110).
-    const scopeRefusals = await validateClarificationScopeAdditions(root, state, resolutions);
-    if (scopeRefusals.length > 0) {
+    const refusal = await planClarificationRefusal(root, state, parsed, new Set(pausedClarifications(state).map((q) => q.finding_id)), "not waiting for a clarification");
+    if (refusal !== null || !parsed.ok) {
         await withFsRetry(() => rename(resolutionPath, `${resolutionPath}.refused-${Date.now()}`));
         return {
             kind: "refused",
-            step: await handleWaitingForClarification(root, artifactsDir, state, `invalid scope_additions — fix and re-submit: ${scopeRefusals.join(" | ")}`),
+            step: await handleWaitingForClarification(root, artifactsDir, state, refusal ?? "the resolution could not be read"),
         };
     }
+    const resolutions = parsed.resolutions;
     const now = new Date().toISOString();
     let appliedCount = 0;
     for (const res of resolutions) {
@@ -2153,14 +2187,30 @@ async function applyPlanClarificationResolution(root, artifactsDir, state, store
         : hasUnansweredClarification(state)
             ? "waiting_for_clarification"
             : "implementing";
-    state.clarifications = [];
     await store.saveState(state);
     return { kind: "applied", state };
 }
+/**
+ * The open worker questions: one per item paused as `needs_clarification`,
+ * read from the item itself (its `clarification_question`), in content-stable
+ * finding-id order. The item is the question's one home, so this list cannot
+ * disagree with the item statuses the round waits on.
+ */
+function pausedClarifications(state) {
+    return Object.values(state.items ?? {})
+        .filter((item) => item.status === "needs_clarification")
+        .sort((left, right) => compareCodeUnits(left.finding_id, right.finding_id))
+        .map((item) => ({
+        finding_id: item.finding_id,
+        // The state store refuses a paused item without a question, so the
+        // fallback is unreachable from a stored state; it keeps the render total.
+        ...(item.clarification_question ?? {
+            category: "scope_of_fix",
+            description: item.failure_reason ?? "(no question recorded)",
+        }),
+    }));
+}
 async function handleWaitingForClarification(root, artifactsDir, state, refusal) {
-    const clarifications = state.clarifications ??
-        (await readOptionalJsonFile(join(artifactsDir, "clarification_request.json"))) ??
-        [];
     const resolutionPath = join(artifactsDir, "clarification_resolution.json");
     return writeCurrentStep({
         stepKind: "collect_clarifications",
@@ -2168,11 +2218,10 @@ async function handleWaitingForClarification(root, artifactsDir, state, refusal)
         runId: stateRunId(state),
         repoRoot: root,
         artifactsDir,
-        prompt: clarificationPrompt(clarifications, resolutionPath, refusal),
+        prompt: clarificationPrompt(pausedClarifications(state), resolutionPath, refusal),
         allowedCommands: [loaderCommand("next-step")],
         stopCondition: "Stop after asking the user for clarification answers, unless the answers are already available and the prompt told you to continue.",
         artifactPaths: {
-            clarification_request: join(artifactsDir, "clarification_request.json"),
             clarification_resolution: resolutionPath,
         },
     });
@@ -2230,17 +2279,10 @@ async function runPlanningReviewGate(root, artifactsDir, state, store) {
     // Resolution present: consume it into a durable, reasoned decision record.
     // Regenerable: a stale-schema request is treated as absent and rebuilt below.
     const request = discardOnSchemaVersionMismatch(await readOptionalJsonFile(requestPath), REVIEW_REQUEST_SCHEMA_VERSION) ?? buildReviewRequest(findings, reviewPlanId);
-    const resolution = await readOptionalJsonFile(resolutionPath);
-    if (!isResolutionForRequest(request, resolution)) {
-        // Stale cross-run resolution: archive it and re-halt with the live request.
-        await withFsRetry(() => rename(resolutionPath, `${resolutionPath}.stale-${Date.now()}`));
-        await writeJsonFile(requestPath, request);
-        return handleWaitingForReviewApproval(root, artifactsDir, request);
-    }
-    const refusalStep = await refuseUnknownIdResolution(root, artifactsDir, request, resolution, resolutionPath, requestPath);
-    if (refusalStep)
-        return refusalStep;
-    const decision = applyReviewResolution(request, resolution);
+    const read = await readReviewResolution(root, artifactsDir, request, resolutionPath, requestPath);
+    if ("halt" in read)
+        return read.halt;
+    const decision = applyReviewResolution(request, read.resolution);
     await writeReviewDecisionRecord(decisionPath, {
         planId: request.plan_id,
         approvedIds: decision.approved_ids,
@@ -2287,8 +2329,8 @@ function detectPlanAmbiguities(findings, items) {
             out.push({
                 finding_id: f.id,
                 category: "scope_of_fix",
-                description: `"${f.title}" is a ${lens} finding with ${fileCount === 0 ? "no cited files" : `${fileCount} affected files`}; ` +
-                    "confirm how far the fix should reach (minimal local change vs. broader restructuring).",
+                description: `"${f.title}" is a finding in the ${lens} lens with ${fileCount === 0 ? "no cited files" : `${fileCount} affected files`}. ` +
+                    "Confirm how far the fix should reach: a minimal local change, or a broader restructure.",
             });
             continue;
         }
@@ -2296,7 +2338,7 @@ function detectPlanAmbiguities(findings, items) {
             out.push({
                 finding_id: f.id,
                 category: "issue_appropriateness",
-                description: `"${f.title}" is a low-confidence finding; confirm it is a real issue worth fixing in this run.`,
+                description: `"${f.title}" is a low-confidence finding. Confirm that it is a real issue to fix in this run.`,
             });
         }
     }
@@ -2308,8 +2350,8 @@ function detectPlanAmbiguities(findings, items) {
  * ambiguity is asked as a single batched question up front rather than falling
  * silently to triage mid-run. Deterministic heuristics seed CANDIDATES; the host
  * reviews them with repo access, dismisses/adds, and batches one user round. Each
- * item is resolved as `clarified` (answered → re-opened), `deemed_inappropriate`
- * (not a real issue), or `defer` (the user's explicit choice to skip this run).
+ * item is resolved as `clarified` (answered → re-opened), `reject_finding`
+ * (not a real issue → `deemed_inappropriate`), or `defer` (the user's explicit choice to skip this run).
  *
  * Idempotent: once `ambiguity_decision.json` exists the gate is done and never
  * re-halts. An empty resolution proceeds (the host found nothing to ask).
@@ -2348,16 +2390,16 @@ async function runPlanAmbiguityGate(root, artifactsDir, state, store) {
     }
     // Resolution present: apply it to items, mark the gate done, archive inputs so
     // it cannot re-halt.
-    const resolutions = normalizePlanClarificationResolutions(await readOptionalJsonFile(resolutionPath));
-    // Uniform id-join contract: a resolution naming a finding id outside the plan
-    // is REFUSED whole (archived, nothing applied) and the gate re-halts with the
-    // unknown ids named — the silent-continue alternative drops a host answer on a
-    // typo'd id, leaving its item to fall to mid-run triage unexplained.
-    const validIds = new Set(findings.map((f) => f.id));
-    const unknownIds = resolutions
-        .map((r) => r.finding_id)
-        .filter((id) => !validIds.has(id));
-    if (unknownIds.length > 0) {
+    // The same whole-file fail-closed contract as the mid-run round: a malformed
+    // entry, a finding id outside the plan, or an invalid scope addition refuses
+    // the WHOLE resolution (archived, nothing applied) and the gate re-halts with
+    // the reason named — the silent-continue alternative drops a host answer,
+    // leaving its item to fall to mid-run triage unexplained. At this up-front
+    // gate no workload binding exists yet, so an applied scope widening simply
+    // flows into the first dispatch.
+    const parsed = await readPlanClarificationResolutions(resolutionPath);
+    const refusal = await planClarificationRefusal(root, state, parsed, new Set(findings.map((f) => f.id)), "not in the plan");
+    if (refusal !== null || !parsed.ok) {
         await withFsRetry(() => rename(resolutionPath, `${resolutionPath}.refused-${Date.now()}`));
         const candidates = (await readOptionalJsonFile(requestPath)) ??
             detectPlanAmbiguities(findings, state.items);
@@ -2367,30 +2409,7 @@ async function runPlanAmbiguityGate(root, artifactsDir, state, store) {
             runId: stateRunId(state),
             repoRoot: root,
             artifactsDir,
-            prompt: ambiguityReviewPrompt(candidates, resolutionPath, findings.map((f) => f.id), `finding id(s) not in the plan: ${unknownIds.map((i) => `\`${i}\``).join(", ")}`),
-            allowedCommands: [loaderCommand("next-step")],
-            stopCondition: "Stop after re-submitting a corrected ambiguity resolution, unless it is already written and the prompt told you to continue.",
-            artifactPaths: {
-                ambiguity_request: requestPath,
-                ambiguity_resolution: resolutionPath,
-            },
-        });
-    }
-    // Scope deltas: the same whole-file fail-closed contract as unknown ids
-    // (open-bugs.md:110). At this up-front gate no workload binding exists yet,
-    // so an applied widening simply flows into the first dispatch.
-    const scopeRefusals = await validateClarificationScopeAdditions(root, state, resolutions);
-    if (scopeRefusals.length > 0) {
-        await withFsRetry(() => rename(resolutionPath, `${resolutionPath}.refused-${Date.now()}`));
-        const candidates = (await readOptionalJsonFile(requestPath)) ??
-            detectPlanAmbiguities(findings, state.items);
-        return writeCurrentStep({
-            stepKind: "collect_clarifications",
-            status: "blocked",
-            runId: stateRunId(state),
-            repoRoot: root,
-            artifactsDir,
-            prompt: ambiguityReviewPrompt(candidates, resolutionPath, findings.map((f) => f.id), `invalid scope_additions — fix and re-submit: ${scopeRefusals.join(" | ")}`),
+            prompt: ambiguityReviewPrompt(candidates, resolutionPath, findings.map((f) => f.id), refusal ?? "the resolution could not be read"),
             allowedCommands: [loaderCommand("next-step")],
             stopCondition: "Stop after re-submitting a corrected ambiguity resolution, unless it is already written and the prompt told you to continue.",
             artifactPaths: {
@@ -2399,6 +2418,7 @@ async function runPlanAmbiguityGate(root, artifactsDir, state, store) {
             },
         });
     }
+    const resolutions = parsed.resolutions;
     const now = new Date().toISOString();
     let changed = false;
     for (const res of resolutions) {
@@ -2641,16 +2661,18 @@ async function emitFinalGateRedStep(ctx) {
     // edit to a non-ignored file outside the run's own artifacts. This is the
     // same carve-out `worktreeContentId` applies, said in the operator's terms.
     const bindingBlock = ctx.tree === undefined
-        ? "Binding: this gate re-runs the floor on every arrival here, so this red\n" +
-            "describes the tree as it stands right now."
+        ? "The tool keeps no copy of this result. Each next-step runs the full build\n" +
+            "and suite again, which takes minutes. So fix something before you run\n" +
+            "next-step again."
         : ctx.tree === null
-            ? "Binding: no tree content id could be taken, so this red is NOT cached —\n" +
-                "the floor will run again on your next next-step whatever you change."
-            : `Binding: this red is bound to tree \`${ctx.tree}\`. Any edit to a file\n` +
-                `outside \`${AUDIT_TOOLS_DIRNAME}/\` — and outside anything git ignores — moves that\n` +
-                "id, which invalidates the cached verdict and makes the next next-step run\n" +
-                "the WHOLE floor again against what you changed. Editing nothing leaves the\n" +
-                "id identical, so the cached red is served back without spawning anything.";
+            ? "The tool could not take a tree id, so it keeps no copy of this result.\n" +
+                "Each next-step runs the full build and suite again, which takes minutes.\n" +
+                "So fix something before you run next-step again."
+            : `The tool keeps this result for tree \`${ctx.tree}\`. An edit to any file\n` +
+                `outside \`${AUDIT_TOOLS_DIRNAME}/\` and outside git-ignored paths changes that tree.\n` +
+                "The next next-step then runs the full build and suite again, which takes\n" +
+                "minutes. With no edit, next-step shows this same red at once and runs\n" +
+                "nothing. So fix something before you run next-step again.";
     const nextCommand = loaderCommand("next-step");
     return {
         kind: "emit",
@@ -2663,39 +2685,27 @@ async function emitFinalGateRedStep(ctx) {
             prompt: `
 # Remediation paused — the repository suite is red
 
-The tool-owned gate (${scope}) ran the repository's own build/typecheck/test
-floor and it FAILED. Nothing about this run has been changed: every item keeps
-the status it had, the run stays in the same phase, and no work was discarded.
-
-Failing command:
+${ctx.where}, the tool ran the repository's build, typecheck and tests.
+One command failed:
 
 \`${failingCommand}\`
 
-The captured output tail is recorded at:
+The output tail is in \`${recordPath}\`.
 
-\`${recordPath}\`
-
-A red here is whole-repo and says nothing about which remediation item caused
-it — it may not be this run's doing at all (a commit landed alongside the run is
-enough). So this is a PAUSE, not a verdict on the work.
+This pause changes nothing. Every item keeps its status, the run stays in its
+phase, and no work is lost. A red suite does not name the item that caused it.
+A commit made outside this run can also cause it.
 
 ${attributionBlock}
 
-${bindingBlock}
-
-Fix the failing command — or confirm it was already broken independently of this
-run — then run:
+Do these steps:
 
-\`${nextCommand}\`
+1. Fix the failing command, or confirm that it was already broken before this run.
+2. Run \`${nextCommand}\`.
 
-The gate re-runs from scratch. The moment it is green the run continues exactly
-where it left off.
+When the suite is green, the run continues from where it stopped.
 
-Re-run it DELIBERATELY, not on a timer. The gate's verdict is cached against the
-content of the tree, so a re-run with nothing changed serves the recorded verdict
-without spawning anything — and the moment you fix something the tree moves, the
-cache misses, and the whole floor (a full build plus the suite, minutes, holding
-the run's phase lock) runs against your change. Fix something first, then re-run.
+${bindingBlock}
 `,
             allowedCommands: [nextCommand],
             stopCondition: "Stop. Make the repository suite green, then re-run next-step to resume the run.",
@@ -2730,6 +2740,7 @@ async function runPhaseBoundaryGate(ctx) {
     if (phase == null)
         return null;
     const scope = `phase ${phase} boundary`;
+    const where = `At the phase ${phase} boundary`;
     const disabledReason = finalGateDisabledReason(options);
     if (disabledReason !== null) {
         await recordFinalGateOutcome({
@@ -2791,6 +2802,7 @@ async function runPhaseBoundaryGate(ctx) {
             artifactsDir,
             state,
             scope,
+            where,
             gate: {
                 passed: false,
                 results: cached.results,
@@ -2844,6 +2856,7 @@ async function runPhaseBoundaryGate(ctx) {
         artifactsDir,
         state,
         scope,
+        where,
         gate,
         // The id taken BEFORE the floor ran, which is what writeFinalGateVerdict
         // just recorded — so the prompt names the binding the cache will match on.
@@ -2901,6 +2914,7 @@ async function handleAllTerminalTransition(root, artifactsDir, state, store, opt
                 artifactsDir,
                 state,
                 scope,
+                where: "Before the close phase",
                 gate,
                 runLogger,
             });
@@ -3201,7 +3215,7 @@ async function buildConfirmIntentStep(ctx) {
     const runId = stateRunId(state);
     const nextCommand = loaderCommand("next-step");
     const checkpointPath = join(artifactsDir, "intent_checkpoint.json");
-    // Read the pre-drafted checkpoint if one exists (confirmed_by: "draft").
+    // Read a checkpoint the host already wrote, if one exists.
     //
     // This is the GATE, and it reads LENIENTLY on purpose: a checkpoint whose
     // `closing_action` is outside the vocabulary must reach the refusal below,
@@ -3209,14 +3223,16 @@ async function buildConfirmIntentStep(ctx) {
     // would replace that affordance with a zod error. Every field consumed here as
     // a VALUE is still checked by name (`isClosingAction`, `customCommandOf`).
     //
-    // The REFUSED values come from `rejected`, never from `draft`: the returned
+    // The REFUSED values come from `rejected`, never from `existing`: the returned
     // checkpoint is schema-valid, so an out-of-vocabulary key is ABSENT from it
     // (see `parseIntentCheckpointLenient`). The value the refusal quotes is the one
     // the host WROTE, which is exactly what `rejected` carries.
-    const draftRead = await readIntentCheckpointLenient(checkpointPath);
-    const draft = draftRead.checkpoint;
-    const isDraft = draft?.confirmed_by === "draft";
-    const rejectedClosingAction = draftRead.rejected.find((field) => field.key === "closing_action");
+    const existingRead = await readIntentCheckpointLenient(checkpointPath);
+    const existing = existingRead.checkpoint;
+    const rejectedClosingAction = existingRead.rejected.find((field) => field.key === "closing_action");
+    // The proposal comes from the intake summary — the one file the host wrote at
+    // synthesis. There is no draft checkpoint: the facts live in one place.
+    const summary = (await readIntakeArtifacts(artifactsDir)).summary;
     // Closing action: DETECTED candidates, presented for the host to choose
     // from; the tool never selects one (owner decision 92b0e2dd7cfdc06d).
     const facts = await detectProjectFacts(root);
@@ -3226,46 +3242,42 @@ async function buildConfirmIntentStep(ctx) {
     const closingSection = renderClosingActionSection(facts);
     // A confirmed checkpoint whose closing_action is not in the vocabulary
     // re-enters this step by name — a refusal, never a silent default.
-    const rawChoice = draft?.confirmed_by === "host"
-        ? (draft.closing_action ?? rejectedClosingAction?.value)
+    const rawChoice = existing?.confirmed_by === "host"
+        ? (existing.closing_action ?? rejectedClosingAction?.value)
         : undefined;
     const refusal = rawChoice !== undefined && !isClosingAction(rawChoice)
         ? `> **Refused:** \`closing_action\` ${JSON.stringify(rawChoice)} is not one of ${CLOSING_ACTIONS.map((a) => `\`${a}\``).join(", ")}. Rewrite the checkpoint with a valid value, or omit the field for \`none\`.\n`
-        : rawChoice === "custom" && customCommandOf(draft) === null
+        : rawChoice === "custom" && customCommandOf(existing) === null
             ? "> **Refused:** `closing_action` \"custom\" needs `closing_custom_command`, a non-empty argv array such as [\"npm\", \"run\", \"release\"]. Add it, or choose another action.\n"
             : "";
     let prompt;
-    if (isDraft && draft) {
-        // Build a consolidated single-stop proposal from the draft.
-        const draftRaw = draft;
-        const preDraftQuestions = Array.isArray(draftRaw.pre_draft_questions)
-            ? draftRaw.pre_draft_questions
-            : [];
+    if (summary) {
+        // Build a consolidated single-stop proposal from the intake summary.
+        const questions = summary.open_questions ?? [];
         // INV-remediate-state-06: only explicit blocking===true is blocking.
-        const blockingQs = preDraftQuestions.filter((q) => q.blocking === true);
-        const nonBlockingQs = preDraftQuestions.filter((q) => q.blocking !== true);
-        const intentInterpretation = typeof draftRaw.intent_interpretation === "string" ? draftRaw.intent_interpretation : undefined;
+        const blockingQs = questions.filter((q) => q.blocking === true);
+        const nonBlockingQs = questions.filter((q) => q.blocking !== true);
         const questionLines = [
             ...blockingQs.map((q) => `- **[blocking] ${q.id}**: ${q.question}`),
             ...nonBlockingQs.map((q) => `- **[FYI] ${q.id}**: ${q.question}`),
         ].join("\n") || "- None";
-        const filtersBlock = draft.filters && Object.keys(draft.filters).length > 0
-            ? `\`\`\`json\n${JSON.stringify(draft.filters, null, 2)}\n\`\`\``
+        const filtersBlock = Object.keys(summary.filters).length > 0
+            ? `\`\`\`json\n${JSON.stringify(summary.filters, null, 2)}\n\`\`\``
             : "(none — remediating all findings)";
         prompt = `
 ${refusal}# Confirm Remediation Scope and Intent
 
-The intake worker has pre-populated the following proposal. Review each section
+The tool built the following proposal from the intake summary. Review each section
 and adjust where needed, then confirm by writing the final \`intent_checkpoint.json\`.
 
 ## Proposed Scope
 
-${draft.scope_summary ?? "(not set)"}
+${summary.scope_summary}
 
 ## Proposed Intent
 
-${draft.intent_summary ?? "(not set)"}
-${intentInterpretation ? `\n**How free-form intent was interpreted:** ${intentInterpretation}\n` : ""}
+${summary.intent_summary}
+${summary.intent_interpretation ? `\n**How free-form intent was interpreted:** ${summary.intent_interpretation}\n` : ""}
 ## Proposed Filters
 
 ${filtersBlock}
@@ -3287,10 +3299,10 @@ To confirm, write the final checkpoint to:
   "schema_version": "intent-checkpoint/v1",
   "confirmed_at": "<ISO-8601 timestamp>",
   "confirmed_by": "host",
-  "scope_summary": "${draft.scope_summary ?? "<the files/areas in scope>"}",
-  "intent_summary": "${draft.intent_summary ?? "<the goal>"}",
+  "scope_summary": ${JSON.stringify(summary.scope_summary)},
+  "intent_summary": ${JSON.stringify(summary.intent_summary)},
   "free_form_intent": "<optional: additional guidance>",
-  "filters": ${JSON.stringify(draft.filters ?? {}, null, 2)},
+  "filters": ${JSON.stringify(summary.filters, null, 2)},
   "excluded_scope": [{ "path": "<path or prefix>", "reason": "<why>" }],
   "must_not_touch": [],
   "closing_action": "<one of the candidates above, or omit the field for none>",
@@ -3308,7 +3320,7 @@ Once written with \`"confirmed_by": "host"\`, run:
 `;
     }
     else {
-        // Fallback for when there is no pre-drafted checkpoint.
+        // Fallback for when no intake summary exists yet.
         prompt = `
 ${refusal}# Confirm Remediation Scope and Intent
 
@@ -3595,11 +3607,11 @@ export function buildPreIntakeObligations(ctx, snapshot) {
         },
         {
             // Intent gate: fire when no confirmed checkpoint exists (no checkpoint + any
-            // intake artifact or an active run, or a draft checkpoint). Never for
+            // intake artifact or an active run). A legacy draft checkpoint was archived
+            // at the snapshot read, so it counts as no checkpoint. Never for
             // complete/closing — those already confirmed their checkpoint.
             id: "confirm_intent",
             derive: (state) => {
-                const checkpointIsDraft = existingCheckpoint?.confirmed_by === "draft";
                 // A host-confirmed checkpoint carrying a closing_action outside the
                 // vocabulary is not a confirmation: the step re-emits naming the value
                 // (owner decision 92b0e2dd7cfdc06d — never a silent default).
@@ -3622,8 +3634,7 @@ export function buildPreIntakeObligations(ctx, snapshot) {
                     state.status !== "pending" &&
                     state.status !== "complete" &&
                     state.status !== "closing";
-                const fires = checkpointIsDraft ||
-                    invalidClosingAction ||
+                const fires = invalidClosingAction ||
                     (!existsSync(checkpointPath) &&
                         (existsSync(ip.summary) ||
                             existsSync(ip.extractedPlan) ||
@@ -3827,6 +3838,14 @@ export function buildMainObligations(ctx) {
                         return { kind: "emit", step: outcome.step };
                     return { kind: "transition", state: outcome.state };
                 }
+                // A wait with no paused item has no question to ask: a round rendered
+                // from it lists nothing, and no answer can satisfy it. Return to
+                // `implementing`, whose own obligations route the run onward.
+                if (!hasUnansweredClarification(s)) {
+                    s.status = "implementing";
+                    await store.saveState(s);
+                    return { kind: "transition", state: s };
+                }
                 return {
                     kind: "emit",
                     step: await handleWaitingForClarification(root, artifactsDir, s),
@@ -4085,6 +4104,14 @@ async function advanceUnderPhaseLock(deps) {
     // asking only the parsed value reads a refusal as "no answer given, so no
     // question". Strict is not the alternative: it would replace the gate's named
     // refusal with a thrown load error.
+    //
+    // A legacy DRAFT checkpoint (`confirmed_by: "draft"`, written by the retired
+    // synthesis prompt) is not a confirmation. It is archived here, so that every
+    // presence check on the checkpoint path below reads it as absent and the
+    // confirm step asks again.
+    if (isLegacyDraftCheckpoint(await readOptionalJsonFile(checkpointPath))) {
+        await rename(checkpointPath, `${checkpointPath}.legacy-draft-${Date.now()}`);
+    }
     const checkpointRead = existsSync(checkpointPath)
         ? await readIntentCheckpointLenient(checkpointPath)
         : undefined;
@@ -4093,7 +4120,7 @@ async function advanceUnderPhaseLock(deps) {
     // Whether a supplied `--input` matches the input the existing run was built
     // from — so re-passing the same `--input` (the loader does this each next-step)
     // resumes rather than tripping the input_conflict gate.
-    const suppliedInputUnchanged = suppliedInputMatchesRun(inputResolution, await readOptionalJsonFile(intakePaths(artifactsDir).sourceManifest));
+    const suppliedInputUnchanged = suppliedInputMatchesRun(inputResolution, await readSourceManifest(intakePaths(artifactsDir).sourceManifest));
     // The linear pre-intake gates run as obligations through the shared advance
     // loop. An emit returns to the host; a transition re-scans within this call;
     // exhausting them (step === null) means the run is past intake and falls