audit-tools 0.50.21 → 0.51.1

package/dist/remediate/steps/nextStep.js

@@ -4,11 +4,11 @@ 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, formatValidationIssues, isRecord, withFsRetry, RunLogger, coerceJsonObjectArg, headCommit, projectAuditFindingsReportSubset, 
+import { discardOnSchemaVersionMismatch, readOptionalJsonFile, stagedAndUntracked, writeJsonFile, writeTextFile, buildAuditDeliverablePair, formatValidationIssues, isRecord, withFsRetry, RunLogger, coerceJsonObjectArg, renderPromptCommand, headCommit, projectAuditFindingsReportSubset, 
 // obligation engine + intent
 interpretFreeFormIntent, interpretIntent, unresolvedFromClauses, advance, describeStoppedFold, decideFrictionTriage, buildFrictionTriageBlock, linkFrictionRunIds, 
 // domain constants
-LENSES, SEVERITIES, } from "audit-tools/shared";
+LENSES, SEVERITIES, CLOSING_ACTIONS, detectProjectFacts, isClosingAction, neutralProjectFacts, } from "audit-tools/shared";
 import { applyPlanPipeline, buildCoverageLedger } from "../phases/plan.js";
 import { groundExtractedFindings, } from "../phases/grounding.js";
 import { runTriagePhase } from "../phases/triage.js";
@@ -32,9 +32,10 @@ import { contractArtifactExists, contractPipelineDir, } from "../contractPipelin
 import { buildReviewRequest, applyReviewResolution, isResolutionForRequest, screenResolutionIds, REVIEW_REQUEST_SCHEMA_VERSION, } from "../review/reviewGate.js";
 import { buildAutonomousReviewDecision } from "../review/autonomousGate.js";
 import { runFindingFilterPass } from "../findingFilter.js";
-import { intakePaths, isIntakeReady, manifestIsInputBound, readIntakeArtifacts, resolveManifestSources, } from "../intake.js";
+import { droppedFindingsRecordPath, renderDroppedFindingsRecord, } from "../droppedFindingsRecord.js";
+import { intakePaths, isIntakeReady, manifestIsInputBound, readIntakeArtifacts, readProjectFacts, writeProjectFacts, resolveManifestSources, } from "../intake.js";
 import { ensureIntakeRiskSignal, readIntakeRiskSignal, writeIntakeRiskSignal, escalateRiskSignal, findingRiskEvidence, distinctAffectedFiles, } from "../riskSignal.js";
-import { ambiguityReviewPrompt, clarificationPrompt, collectIntakeClarificationsPrompt, collectStartingPointPrompt, loaderCommand, reviewApprovalPrompt, synthesizeIntakePrompt, triagePrompt, } from "./prompts.js";
+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
 // prompt copy. Previously these 11-lens / 5-severity lists were hand-copied as
@@ -355,7 +356,7 @@ async function applyCheckpointIntentOrdering(artifactsDir, plan) {
     const ordered = applyIntentOrdering(plan.findings, plan.blocks, interpretFreeFormIntent(freeForm));
     return { ...plan, findings: ordered.findings, blocks: ordered.blocks };
 }
-function normalizeExtractedPlan(value) {
+function normalizeExtractedPlan(value, facts) {
     if (!isRecord(value)) {
         throw new Error("extracted-plan.json must be an object.");
     }
@@ -399,10 +400,28 @@ function normalizeExtractedPlan(value) {
         ...(typeof value.source === "string" ? { source: value.source } : {}),
         findings: dedup.findings,
         blocks: dedupBlocks,
-        project_type: typeof value.project_type === "string" ? value.project_type : "unknown",
-        test_command: typeof value.test_command === "string" ? value.test_command : undefined,
-        e2e_command: typeof value.e2e_command === "string" ? value.e2e_command : undefined,
-        candidate_closing_actions: ["none"],
+        // Project facts (owner decision 92b0e2dd7cfdc06d): the input's own VALID
+        // values win — the contract pipeline detects them itself — and the run's
+        // detected facts fill the rest. Candidates are what the host chooses
+        // FROM at the intent checkpoint; nothing here selects one.
+        project_type: typeof value.project_type === "string" && value.project_type !== "unknown"
+            ? value.project_type
+            : facts.project_type,
+        ...(typeof value.test_command === "string" && value.test_command.trim().length > 0
+            ? { test_command: value.test_command, test_command_source: "explicit" }
+            : facts.commands.test
+                ? { test_command: renderPromptCommand(facts.commands.test), test_command_source: "project_facts" }
+                : {}),
+        ...(typeof value.e2e_command === "string" && value.e2e_command.trim().length > 0
+            ? { e2e_command: value.e2e_command, e2e_command_source: "explicit" }
+            : facts.commands.e2e
+                ? { e2e_command: renderPromptCommand(facts.commands.e2e), e2e_command_source: "project_facts" }
+                : {}),
+        candidate_closing_actions: Array.isArray(value.candidate_closing_actions) &&
+            value.candidate_closing_actions.length > 0 &&
+            value.candidate_closing_actions.every(isClosingAction)
+            ? value.candidate_closing_actions
+            : facts.candidate_closing_actions,
         block_strategy: value.block_strategy === "test_graph" ||
             value.block_strategy === "git_cocommit" ||
             value.block_strategy === "file_overlap" ||
@@ -419,6 +438,33 @@ function normalizeExtractedPlan(value) {
     }
     return { plan, sourceFindings: findings, mergeMap: dedup.mergeMap };
 }
+/**
+ * The closing plan the HOST chose on the confirmed checkpoint: its action, or
+ * `none` when the field is absent, plus the argv a `custom` choice carries.
+ * Never a detected candidate: detection presents, the host chooses (owner
+ * decision 92b0e2dd7cfdc06d). An invalid action, or a `custom` with no
+ * command, cannot reach here — the confirm_intent obligation refuses both —
+ * so membership is the whole check.
+ */
+async function confirmedClosingPlan(artifactsDir) {
+    const checkpoint = await readOptionalJsonFile(join(artifactsDir, "intent_checkpoint.json"));
+    if (!checkpoint || checkpoint.confirmed_by !== "host")
+        return { action: "none" };
+    const chosen = checkpoint.closing_action;
+    if (!isClosingAction(chosen))
+        return { action: "none" };
+    const command = customCommandOf(checkpoint);
+    return chosen === "custom" && command ? { action: chosen, custom_command: command } : { action: chosen };
+}
+/** The checkpoint's `closing_custom_command` when it is a non-empty argv of non-empty strings. */
+function customCommandOf(checkpoint) {
+    const raw = checkpoint.closing_custom_command;
+    return Array.isArray(raw) &&
+        raw.length > 0 &&
+        raw.every((part) => typeof part === "string" && part.length > 0)
+        ? raw
+        : null;
+}
 async function saveStateForPlan(artifactsDir, existing, plan, planCoverage) {
     const { host_handoff: _staleHostHandoff, ...carryForwardState } = existing;
     const items = {};
@@ -435,7 +481,7 @@ async function saveStateForPlan(artifactsDir, existing, plan, planCoverage) {
         status: "planning",
         plan,
         items,
-        closing_plan: { action: "none" },
+        closing_plan: await confirmedClosingPlan(artifactsDir),
         ...(planCoverage ? { plan_coverage: planCoverage } : {}),
     };
     await new StateStore(artifactsDir).saveState(state);
@@ -559,7 +605,13 @@ async function forceReplanFromExistingIntake(root, artifactsDir, previous, store
         await store.saveState(pendingState);
         return null;
     }
-    const replanned = await handlePendingExtractedPlan(root, artifactsDir, pendingState, extractedPlan, runLogger);
+    const outcome = await handlePendingExtractedPlan(root, artifactsDir, pendingState, extractedPlan, runLogger);
+    if (outcome.kind === "discarded") {
+        // Carried up rather than collapsed to null: the decide loop emits the step
+        // that names the discard.
+        return outcome;
+    }
+    const replanned = outcome.state;
     if (!replanned) {
         return null;
     }
@@ -737,6 +789,31 @@ async function buildImplementDispatchStep(ctx) {
     if (ingested === "unsupported_retired_state") {
         throw new Error("Remediation state uses a retired dispatch shape and cannot cross the host handoff boundary.");
     }
+    // DURABLY RECORD EVERY CLASSIFIED ISSUE BEFORE ANY EXIT PATH.
+    //
+    // This loop used to sit below the `state_changed` early return, next to the
+    // prompt that renders the same issues — so it only ran when NOTHING was
+    // accepted. On a partial batch (some results accepted, some rejected)
+    // `state_changed` is true, the call transitions here, and every rejection was
+    // lost: not logged, not rendered, not carried. The one path where a host most
+    // needs to know that some of its work was refused was the path that said
+    // nothing at all.
+    //
+    // The rendering half is separate and still only reached on the re-emit path;
+    // this is the DURABLE half, and it must not depend on which exit is taken. The
+    // ledger already records the rejection, but the run log is what a person reads
+    // when reconstructing a run.
+    for (const issue of ingested.issues) {
+        runLogger.event({
+            phase: "next-step",
+            kind: "outcome",
+            obligation: "host_ingest",
+            note: `host_ingest_issue code=${issue.code}` +
+                (issue.work_item_id ? ` work_item=${issue.work_item_id}` : "") +
+                (issue.result_path ? ` result=${issue.result_path}` : "") +
+                ` message=${issue.message}`,
+        });
+    }
     if (ingested.state_changed) {
         const { contract_version: _contractVersion, ...persistableState } = ingested.state;
         await store.saveState(persistableState);
@@ -768,21 +845,9 @@ async function buildImplementDispatchStep(ctx) {
     // persisted handoff record for the dispatch run, the step contract's own run id for
     // the step — never synthesized from the other.
     await linkFrictionRunIds(artifactsDir, stateRunId(state), { step_run_id: runId, dispatch_run_id: handoff.handoff_record.run_id }, "remediate-code");
-    // Ingest issues reached the PROMPT and nothing else — a channel that survives
-    // exactly as long as the host reads that one step. They are also the durable
-    // record of which submitted results were rejected and why, so they are logged
-    // as well as rendered.
-    for (const issue of ingested.issues) {
-        runLogger.event({
-            phase: "next-step",
-            kind: "outcome",
-            obligation: "host_ingest",
-            note: `host_ingest_issue code=${issue.code}` +
-                (issue.work_item_id ? ` work_item=${issue.work_item_id}` : "") +
-                (issue.result_path ? ` result=${issue.result_path}` : "") +
-                ` message=${issue.message}`,
-        });
-    }
+    // The issues were logged above, before any exit path. What follows is the
+    // RENDER — a channel that survives exactly as long as the host reads this one
+    // step, and that is reached only when nothing was accepted.
     const resultDiagnostics = ingested.issues.length === 0
         ? ""
         : `
@@ -913,6 +978,21 @@ async function archiveExtractedPlan(extractedPlanPath) {
     }
     return archivePath;
 }
+/** Render the step that STATES a discard, rather than asking for an input again. */
+async function emitExtractedPlanDiscardedStep(root, artifactsDir, discard) {
+    const paths = intakePaths(artifactsDir);
+    return writeCurrentStep({
+        stepKind: "extracted_plan_discarded",
+        status: "blocked",
+        runId: randomRunId("PLAN-DISCARD"),
+        repoRoot: root,
+        artifactsDir,
+        prompt: extractedPlanDiscardedPrompt(discard.reason, discard.archivePath, paths),
+        allowedCommands: [loaderCommand("next-step")],
+        stopCondition: "Stop after writing a corrected extracted plan and rerunning next-step.",
+        artifactPaths: { extracted_plan: paths.extractedPlan },
+    });
+}
 async function handlePendingExtractedPlan(root, artifactsDir, existing, extractedPlan, 
 // The plan path's high-consequence events — findings dropped by grounding, and
 // the plan being destroyed — are DURABLE, so the logger is a parameter rather
@@ -938,7 +1018,10 @@ runLogger) {
     let mergeMap;
     let grounding;
     try {
-        ({ plan, sourceFindings, mergeMap } = normalizeExtractedPlan(extractedPlan));
+        ({ plan, sourceFindings, mergeMap } = normalizeExtractedPlan(extractedPlan, 
+        // Persisted by the confirm step; planning spawns nothing (the
+        // backend-independent planning contract), so it never detects here.
+        (await readProjectFacts(artifactsDir)) ?? neutralProjectFacts()));
         // INTENT ORDERING, applied where the plan's findings and blocks are
         // FINALIZED. `applyIntentOrdering` existed with no production caller at all:
         // the checkpoint's interpreted intent was written and never read back, so
@@ -1024,8 +1107,18 @@ runLogger) {
             note: `extracted_plan_removed reason=${reason} ` +
                 `archive=${archivePath ?? "(nothing on disk to archive)"}`,
         });
-        process.stderr.write(`[remediate-code] Unusable extracted-plan.json removed (${reason}); archived at ${archivePath ?? "(nothing on disk to archive)"}. Re-emitting extraction step.\n`);
-        return null;
+        process.stderr.write(`[remediate-code] Unusable extracted-plan.json removed (${reason}); archived at ${archivePath ?? "(nothing on disk to archive)"}. Emitting the plan-discarded step.\n`);
+        // The reason travels with the outcome, so the EMITTED STEP can state it.
+        // Returning a bare `null` here is what made a destroyed plan indistinguishable
+        // from a run that never had an input: the decide loop fell through to
+        // `collect_starting_point` and the host was told to go and find an input it
+        // had already supplied. Everything needed to say so was already computed —
+        // it just had nowhere to go.
+        return {
+            kind: "discarded",
+            reason,
+            ...(archivePath ? { archivePath } : {}),
+        };
     }
     // Past the recovery boundary: a failure below is a real failure and propagates.
     const pipelined = await applyPlanPipeline(plan, { root, artifactsDir });
@@ -1084,7 +1177,10 @@ runLogger) {
                 },
             ])),
         });
-    return await saveStateForPlan(artifactsDir, existing, pipelined, coverage);
+    return {
+        kind: "planned",
+        state: await saveStateForPlan(artifactsDir, existing, pipelined, coverage),
+    };
 }
 // ── Review-approval gate (go-forward program item 1) ───────────────────────────
 //
@@ -1109,6 +1205,42 @@ function reviewResolutionPath(artifactsDir) {
 function reviewDecisionPath(artifactsDir) {
     return join(artifactsDir, "review_decision.json");
 }
+/**
+ * Stamp and persist one review decision. Three sites built this literal — the
+ * autonomous and interactive arms of the approval gate, and the planning gate —
+ * and a schema stamp that lives in three places is one edit away from meaning
+ * two different things on disk.
+ *
+ * Persistence only. WHICH ids are approved, where the plan id comes from, and
+ * what the caller does next are all decided by the caller and stay there: the
+ * autonomous arm mints a run id and declines nothing, the two resolution arms
+ * carry the live plan's id and the operator's declines.
+ */
+async function writeReviewDecisionRecord(decisionPath, fields) {
+    const record = {
+        schema_version: REVIEW_DECISION_SCHEMA_VERSION,
+        plan_id: fields.planId,
+        approved_ids: fields.approvedIds,
+        declined: fields.declined,
+        created_at: new Date().toISOString(),
+    };
+    await writeJsonFile(decisionPath, record);
+}
+/**
+ * Archive the inputs a gate has just consumed, so it cannot re-halt on them.
+ *
+ * Renaming rather than deleting keeps the operator's own answer recoverable;
+ * the timestamp suffix keeps a second consumption from colliding with the
+ * first. An absent path is not an error — a gate reached through the autonomous
+ * arm never wrote one.
+ */
+async function archiveConsumedInputs(paths) {
+    for (const p of paths) {
+        if (existsSync(p)) {
+            await withFsRetry(() => rename(p, `${p}.consumed-${Date.now()}`));
+        }
+    }
+}
 // Up-front ambiguity gate (note 3, part A) — its own request/resolution/decision
 // files, mirroring the review gate so it fires (and halts) at most once per run.
 function ambiguityRequestPath(artifactsDir) {
@@ -1197,14 +1329,11 @@ async function runReviewApprovalGate(root, artifactsDir, survivors, autonomous =
         // Leftovers stay LIVE: declined is EMPTY (no durable rejection). The
         // decision REPLAY keys on approved_ids (COR-227a02ae), so on later calls
         // exactly the approved subset — never the live leftovers — re-enters.
-        const record = {
-            schema_version: REVIEW_DECISION_SCHEMA_VERSION,
-            plan_id: randomRunId("path-a-review"),
-            approved_ids: auto.approved_ids,
+        await writeReviewDecisionRecord(decisionPath, {
+            planId: randomRunId("path-a-review"),
+            approvedIds: auto.approved_ids,
             declined: [],
-            created_at: new Date().toISOString(),
-        };
-        await writeJsonFile(decisionPath, record);
+        });
         // Re-emit the leftovers as a standard, re-consumable audit deliverable pair
         // so the next nightly run picks them up via defaultInputCandidates. Always
         // on disk regardless of whether a git remote / PR is available.
@@ -1248,20 +1377,12 @@ async function runReviewApprovalGate(root, artifactsDir, survivors, autonomous =
         if (refusalStep)
             return { kind: "halt", step: refusalStep };
         const decision = applyReviewResolution(request, resolution);
-        const record = {
-            schema_version: REVIEW_DECISION_SCHEMA_VERSION,
-            plan_id: request.plan_id,
-            approved_ids: decision.approved_ids,
+        await writeReviewDecisionRecord(decisionPath, {
+            planId: request.plan_id,
+            approvedIds: decision.approved_ids,
             declined: decision.declined,
-            created_at: new Date().toISOString(),
-        };
-        await writeJsonFile(decisionPath, record);
-        // Archive the consumed inputs so the gate cannot re-halt.
-        for (const p of [resolutionPath, requestPath]) {
-            if (existsSync(p)) {
-                await withFsRetry(() => rename(p, `${p}.consumed-${Date.now()}`));
-            }
-        }
+        });
+        await archiveConsumedInputs([resolutionPath, requestPath]);
     }
     // Decision recorded (now or on a prior call): split the survivors. The
     // replay honours the recorded approved_ids (COR-227a02ae) — an autonomous
@@ -1349,6 +1470,11 @@ async function persistReviewFilterDispositions(artifactsDir, originals, filter)
         droppedByCheckpoint: filter.droppedByCheckpoint,
     };
     await writeJsonFile(reviewFilterDispositionsPath(artifactsDir), payload);
+    // The human half of the same fact. The JSON above keeps only IDS, which told a
+    // reader an id and nothing else; this states what each removed finding WAS and
+    // why it went. Written beside it, on every pass, so its absence means the pass
+    // did not run rather than "nothing was dropped".
+    await writeFile(droppedFindingsRecordPath(artifactsDir), renderDroppedFindingsRecord(originals, filter), "utf8");
 }
 async function handleReadyIntakeContractPipeline(root, artifactsDir, options, runLogger) {
     // Fast path: if an extracted-plan.json already exists (pipeline complete or
@@ -1357,7 +1483,10 @@ async function handleReadyIntakeContractPipeline(root, artifactsDir, options, ru
     // ground+plan" and the grounding tests that write extracted-plan.json directly.
     const earlyExtractedPlan = await readExtractedPlanIfPresent(artifactsDir);
     if (earlyExtractedPlan) {
-        return handlePendingExtractedPlan(root, artifactsDir, { status: "pending" }, earlyExtractedPlan, runLogger);
+        const outcome = await handlePendingExtractedPlan(root, artifactsDir, { status: "pending" }, earlyExtractedPlan, runLogger);
+        return outcome.kind === "discarded"
+            ? emitExtractedPlanDiscardedStep(root, artifactsDir, outcome)
+            : outcome.state;
     }
     const intake = await readIntakeArtifacts(artifactsDir);
     if (!intake.summary || !isIntakeReady(intake.summary)) {
@@ -1501,7 +1630,10 @@ async function handleReadyIntakeContractPipeline(root, artifactsDir, options, ru
     if (!extractedPlan) {
         return null;
     }
-    return handlePendingExtractedPlan(root, artifactsDir, { status: "pending" }, extractedPlan, runLogger);
+    const outcome = await handlePendingExtractedPlan(root, artifactsDir, { status: "pending" }, extractedPlan, runLogger);
+    return outcome.kind === "discarded"
+        ? emitExtractedPlanDiscardedStep(root, artifactsDir, outcome)
+        : outcome.state;
 }
 async function handlePendingIntake(root, artifactsDir, options, runLogger) {
     // Short-circuit: if an extracted-plan.json already exists (promoted from the
@@ -1881,20 +2013,12 @@ async function runPlanningReviewGate(root, artifactsDir, state, store) {
     if (refusalStep)
         return refusalStep;
     const decision = applyReviewResolution(request, resolution);
-    const record = {
-        schema_version: REVIEW_DECISION_SCHEMA_VERSION,
-        plan_id: request.plan_id,
-        approved_ids: decision.approved_ids,
+    await writeReviewDecisionRecord(decisionPath, {
+        planId: request.plan_id,
+        approvedIds: decision.approved_ids,
         declined: decision.declined,
-        created_at: new Date().toISOString(),
-    };
-    await writeJsonFile(decisionPath, record);
-    // Archive the consumed inputs so the gate cannot re-halt.
-    for (const p of [resolutionPath, requestPath]) {
-        if (existsSync(p)) {
-            await withFsRetry(() => rename(p, `${p}.consumed-${Date.now()}`));
-        }
-    }
+    });
+    await archiveConsumedInputs([resolutionPath, requestPath]);
     // Declined nodes → recorded terminal disposition (never a silent close).
     let changed = false;
     for (const { finding_id, reason } of decision.declined) {
@@ -2695,6 +2819,27 @@ async function buildConfirmResumeOrRestartStep(ctx) {
         },
     });
 }
+/**
+ * The closing-action choice, rendered from DETECTED facts. Lists only the
+ * candidates the repository's shape makes appropriate, each with the fact
+ * behind it, and says outright that the tool selects nothing: an omitted
+ * `closing_action` is `none`.
+ */
+function renderClosingActionSection(facts) {
+    const candidateLines = facts.candidate_closing_actions
+        .map((action) => `- \`${action}\` — ${facts.candidate_rationale[action] ?? ""}`)
+        .join("\n");
+    const vocabulary = CLOSING_ACTIONS.map((action) => `\`${action}\``).join(", ");
+    return [
+        "## Closing Action — you choose",
+        "",
+        `Detected project type: \`${facts.project_type}\`. The repository's shape makes these closing actions appropriate. The tool never selects one: set \`closing_action\` in the checkpoint, or omit it to choose \`none\`.`,
+        "",
+        candidateLines,
+        "",
+        `Any other value from ${vocabulary} is accepted as an explicit alternative. \`custom\` runs the argv you write beside it as \`closing_custom_command\` (for example ["npm", "run", "release"]); a \`custom\` without one is refused.`,
+    ].join("\n");
+}
 async function buildConfirmIntentStep(ctx) {
     const { root, artifactsDir, state } = ctx;
     const runId = stateRunId(state);
@@ -2703,6 +2848,21 @@ async function buildConfirmIntentStep(ctx) {
     // Read the pre-drafted checkpoint if one exists (confirmed_by: "draft").
     const draft = await readOptionalJsonFile(checkpointPath);
     const isDraft = draft?.confirmed_by === "draft";
+    // Closing action: DETECTED candidates, presented for the host to choose
+    // from; the tool never selects one (owner decision 92b0e2dd7cfdc06d).
+    const facts = await detectProjectFacts(root);
+    // Persisted for planning, which spawns nothing by contract and reads this
+    // artifact instead of detecting again.
+    await writeProjectFacts(artifactsDir, facts);
+    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 : 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
+            ? "> **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.
@@ -2714,7 +2874,6 @@ async function buildConfirmIntentStep(ctx) {
         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 suggestedClosingAction = typeof draftRaw.closing_action === "string" ? draftRaw.closing_action : undefined;
         const questionLines = [
             ...blockingQs.map((q) => `- **[blocking] ${q.id}**: ${q.question}`),
             ...nonBlockingQs.map((q) => `- **[FYI] ${q.id}**: ${q.question}`),
@@ -2722,9 +2881,8 @@ async function buildConfirmIntentStep(ctx) {
         const filtersBlock = draft.filters && Object.keys(draft.filters).length > 0
             ? `\`\`\`json\n${JSON.stringify(draft.filters, null, 2)}\n\`\`\``
             : "(none — remediating all findings)";
-        const closingOptions = "`commit` or `none`";
         prompt = `
-# Confirm Remediation Scope and Intent
+${refusal}# Confirm Remediation Scope and Intent
 
 The intake worker has pre-populated the following proposal. Review each section
 and adjust where needed, then confirm by writing the final \`intent_checkpoint.json\`.
@@ -2745,9 +2903,7 @@ ${filtersBlock}
 
 ${questionLines}
 
-## Suggested Closing Action
-
-${suggestedClosingAction ?? "commit"} (valid options: ${closingOptions})
+${closingSection}
 
 ---
 
@@ -2765,7 +2921,9 @@ To confirm, write the final checkpoint to:
   "free_form_intent": "<optional: additional guidance>",
   "filters": ${JSON.stringify(draft.filters ?? {}, null, 2)},
   "excluded_scope": [{ "path": "<path or prefix>", "reason": "<why>" }],
-  "must_not_touch": []
+  "must_not_touch": [],
+  "closing_action": "<one of the candidates above, or omit the field for none>",
+  "closing_custom_command": ["<only with custom: the argv to run>"]
 }
 \`\`\`
 
@@ -2781,7 +2939,7 @@ Once written with \`"confirmed_by": "host"\`, run:
     else {
         // Fallback for when there is no pre-drafted checkpoint.
         prompt = `
-# Confirm Remediation Scope and Intent
+${refusal}# Confirm Remediation Scope and Intent
 
 Please review the intake summary at \`.audit-tools/remediation/intake/intake-summary.json\` (and the audit report, if this run consumes one).
 
@@ -2804,10 +2962,14 @@ Only \`scope_summary\` and \`intent_summary\` are required; add the optional fie
     "themes": ["<theme id>"]
   },
   "excluded_scope": [{ "path": "<path or prefix>", "reason": "<why>" }],
-  "must_not_touch": ["<glob>"]
+  "must_not_touch": ["<glob>"],
+  "closing_action": "<one of the candidates below, or omit the field for none>",
+  "closing_custom_command": ["<only with custom: the argv to run>"]
 }
 \`\`\`
 
+${closingSection}
+
 - \`filters\` drop findings that don't match BEFORE planning, so only the work you want is remediated. Valid severities: ${VALID_SEVERITIES_PROSE}. Valid lenses: ${VALID_LENSES_PROSE}. Draw \`packages\`/\`themes\` from the findings in the audit report.
 - \`excluded_scope\` drops findings whose files match a path or directory prefix; \`must_not_touch\` globs are never written.
 - Skipped findings are listed in the final remediation report under "Skipped by Intent Checkpoint".
@@ -3065,11 +3227,20 @@ export function buildPreIntakeObligations(ctx, snapshot) {
             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).
+                const chosenClosingAction = existingCheckpoint?.confirmed_by === "host"
+                    ? existingCheckpoint.closing_action
+                    : undefined;
+                const invalidClosingAction = (chosenClosingAction !== undefined && !isClosingAction(chosenClosingAction)) ||
+                    (chosenClosingAction === "custom" && customCommandOf(existingCheckpoint) === null);
                 const activeRunState = state != null &&
                     state.status !== "pending" &&
                     state.status !== "complete" &&
                     state.status !== "closing";
                 const fires = checkpointIsDraft ||
+                    invalidClosingAction ||
                     (!existsSync(checkpointPath) &&
                         (existsSync(ip.summary) ||
                             existsSync(ip.extractedPlan) ||
@@ -3493,7 +3664,14 @@ async function advanceUnderPhaseLock(deps) {
     // transitions, never a recursive decideNextStepLoop), so this fires at most once.
     if (options.forceReplan && state != null) {
         await countStep(state);
-        state = await forceReplanFromExistingIntake(root, artifactsDir, state, store, runLogger);
+        const replanOutcome = await forceReplanFromExistingIntake(root, artifactsDir, state, store, runLogger);
+        // A discarded plan is REPORTED here, not collapsed into `state = null`. Once
+        // it is null the loop can no longer tell "the plan was destroyed, and here is
+        // why" from "there was never an input", and it emits the second.
+        if (replanOutcome !== null && "kind" in replanOutcome) {
+            return emitExtractedPlanDiscardedStep(root, artifactsDir, replanOutcome);
+        }
+        state = replanOutcome;
     }
     // Pre-read the once-async signals the pre-intake derive()s consume
     // synchronously (no transition inside this advance call rewrites either file).