audit-tools 0.52.5 → 0.53.0

package/dist/remediate/steps/dispatch/hostHandoff.js

@@ -4,15 +4,18 @@ import { corroborateHostResult, corroborateNoChangeClaim } from "./hostCorrobora
 import { runRequiredTest, rerunRequiredTests, requiredTestIssue, requiredTestVerdictKey } from "./requiredTests.js";
 import { readIntentCheckpoint } from "../../../shared/types/intentCheckpoint.js";
 import { checkContractConformance, conformanceReviewPaths } from "./contractConformanceReview.js";
+import { executionPlanReferenceIssues } from "../../../shared/types/executionPlan.js";
+import { executionPlanContextIssues } from "../../contractPipeline/executionPlan.js";
+import { assertApprovedRuntimePlan as assertCurrentPlanAuthority, RemediationPlanAuthorityError } from "../../contractPipeline/runtimePlanAuthority.js";
 // sites-pinned: tests/remediate/host-handoff-corroboration.test.ts, tests/remediate/host-handoff.test.ts
 //   host-handoff-corroboration: the bounded required-test failure message.
 //   host-handoff: the "landing gates" block fails when the close-owns-the-gates prompt line
 //   or the id-glossary write scope is reverted.
 import { mkdir } from "node:fs/promises";
 import { isAbsolute, join } from "node:path";
-import { headCommit, commandLeavesDeclaredShape, FindingSchema, SUBMISSION_ISSUE_REMEDY, WORKLOAD_ISSUE_REMEDY, bindWorkerPrompt, deriveResultId, SUBMISSION_LEDGER_EVENT_CONTRACT_VERSION, appendSubmissionEvent, enrichMissingSubmissionIssues, isMissingObservation, compareCodeUnits, contentSha256, declaredInvariantIds, deriveLaneDemand, discoverLandingGates, hasExactKeys, identityFailureDiagnostic, hostHandoffResultPath, idsAreStrictlyAscending, isCommit, isGitRepo, isRecord, isSha256, LaneDemandSchema, normalizeRepoPath, parseAllWorkloadItems, parseWorkloadEnvelope, readSubmissionDocument, readJsonFile, readSubmissionLedger, readTrailingSubmissionRefusals, recoveryMarkMatches, recordHostResultOutcomes, repoRelativePath, resolveContainedPath, resolveHostHandoffPaths, sameStrings, scanBoundSubmission, SEVERITIES, severityRank, stringArray, stableStringify, withGlossaryScope, writeJsonFile, } from "audit-tools/shared";
+import { headCommit, commandLeavesDeclaredShape, SUBMISSION_ISSUE_REMEDY, WORKLOAD_ISSUE_REMEDY, bindWorkerPrompt, deriveResultId, SUBMISSION_LEDGER_EVENT_CONTRACT_VERSION, appendSubmissionEvent, enrichMissingSubmissionIssues, isMissingObservation, compareCodeUnits, contentSha256, deriveLaneDemand, estimateTokensFromBytes, discoverLandingGates, hasExactKeys, identityFailureDiagnostic, hostHandoffResultPath, idsAreStrictlyAscending, isCommit, isGitRepo, isRecord, isSha256, LaneDemandSchema, normalizeRepoPath, parseAllWorkloadItems, parseWorkloadEnvelope, readSubmissionDocument, readJsonFile, readSubmissionLedger, readTrailingSubmissionRefusals, recoveryMarkMatches, recordHostResultOutcomes, repoRelativePath, resolveContainedPath, resolveHostHandoffPaths, sameStrings, scanBoundSubmission, SEVERITIES, severityRank, stringArray, stableStringify, writeJsonFile, } from "audit-tools/shared";
 import { REMEDIATION_STATE_CONTRACT_VERSION, } from "../../state/store.js";
-import { REMEDIATION_HOST_HANDOFF_RECORD_V1ALPHA1, REMEDIATION_HOST_HANDOFF_RECORD_V1ALPHA2, REMEDIATION_HOST_SCOPE_SEMANTICS, RemediationHostHandoffRecordSchema, ConformanceReviewBindingSchema, RemediationPlanSchema, isClarificationCategory, } from "../../state/types.js";
+import { REMEDIATION_HOST_HANDOFF_RECORD_V1ALPHA2, REMEDIATION_HOST_SCOPE_SEMANTICS, RemediationHostHandoffRecordSchema, ConformanceReviewBindingSchema, RemediationPlanSchema, isClarificationCategory, } from "../../state/types.js";
 import { ITEM_STATUSES, isTerminalStatus, isVerifiedCompleteStatus, } from "../../state/itemStatus.js";
 import { REMEDIATION_HOST_DECISION_CONTRACT_VERSION as DECISION_CONTRACT_VERSION, REMEDIATION_HOST_RESULT_CONTRACT_VERSION as RESULT_CONTRACT_VERSION, REMEDIATION_HOST_WORKLOAD_CONTRACT_VERSION as WORKLOAD_CONTRACT_VERSION, } from "../types.js";
 // The state contract version is the STORE's declaration, not a second literal
@@ -82,6 +85,8 @@ const CURRENT_STATE_KEYS = new Set([
     "closing_plan",
     "contract_version",
     "items",
+    "finding_dispositions",
+    "source_verifications",
     "host_handoff",
     "conformance_review",
     "plan",
@@ -92,7 +97,7 @@ const CURRENT_STATE_KEYS = new Set([
     "step_count",
 ]);
 const CURRENT_ITEM_KEYS = new Set([
-    "block_id",
+    "unit_id",
     "clarification_context",
     "clarification_question",
     "completed_at",
@@ -106,10 +111,8 @@ const CURRENT_ITEM_KEYS = new Set([
     "host_landed_files",
     "host_result_evidence",
     "conformance_review",
-    "finding_id",
     "incomplete_coverage_attempts",
     "last_successful_step",
-    "mechanical_verification",
     "rework_count",
     "started_at",
     "status",
@@ -143,37 +146,32 @@ function parseCurrentState(value) {
             return null;
         }
     }
-    const blockById = new Map();
-    for (const block of parsedPlan.data.blocks) {
-        if (blockById.has(block.block_id))
-            return null;
-        blockById.set(block.block_id, block);
-    }
+    const unitIds = new Set(parsedPlan.data.units.map(unit => unit.id));
+    if (unitIds.size !== parsedPlan.data.units.length)
+        return null;
     const knownStatuses = new Set(ITEM_STATUSES);
-    for (const [findingId, item] of Object.entries(stateItems)) {
-        if (!isRecord(item) ||
-            !hasOnlyKnownKeys(item, CURRENT_ITEM_KEYS) ||
-            item.finding_id !== findingId ||
-            typeof item.block_id !== "string" ||
-            !knownStatuses.has(String(item.status))) {
+    for (const [unitId, item] of Object.entries(stateItems)) {
+        if (!isRecord(item) || !hasOnlyKnownKeys(item, CURRENT_ITEM_KEYS) ||
+            item.unit_id !== unitId || !unitIds.has(unitId) || !knownStatuses.has(String(item.status)))
             return null;
-        }
         if (item.conformance_review !== undefined && !AcceptedConformanceReviewSchema.safeParse(item.conformance_review).success)
             return null;
-        const block = blockById.get(item.block_id);
-        if (!block || !block.items.includes(findingId))
-            return null;
-    }
-    for (const block of parsedPlan.data.blocks) {
-        if (block.items.some((findingId) => {
-            const item = stateItems[findingId];
-            return !isRecord(item) || item.block_id !== block.block_id;
-        })) {
-            return null;
-        }
     }
+    if ([...unitIds].some(id => !stateItems[id]))
+        return null;
     return value;
 }
+/** Preserve the host boundary's public repair error while sharing its authority policy. */
+async function assertApprovedRuntimePlan(artifactsDir, state) {
+    try {
+        return await assertCurrentPlanAuthority(artifactsDir, state);
+    }
+    catch (error) {
+        if (!(error instanceof RemediationPlanAuthorityError))
+            throw error;
+        throw new RemediationHostPreparationError(error.code, error.message);
+    }
+}
 function normalizeDeclaredPath(root, candidate, label) {
     if (candidate.length === 0 || isAbsolute(candidate)) {
         throw new Error(`${label} must be a non-empty repository-relative path`);
@@ -181,79 +179,6 @@ function normalizeDeclaredPath(root, candidate, label) {
     const normalized = repoRelativePath(root, candidate, label);
     return candidate.endsWith("/") ? `${normalized}/` : normalized;
 }
-function deriveLegacyDirectoryPathsForBlock(state, blockId, declaredPaths) {
-    const binding = state.host_handoff;
-    if (binding?.contract_version !== REMEDIATION_HOST_HANDOFF_RECORD_V1ALPHA1) {
-        return [];
-    }
-    const block = state.plan.blocks.find((entry) => entry.block_id === blockId);
-    if (!block)
-        return [];
-    const hashedDirectoryPaths = new Set();
-    for (const findingId of block.items) {
-        const finding = state.plan.findings.find((entry) => entry.id === findingId);
-        if (!finding)
-            continue;
-        for (const affectedFile of finding.affected_files) {
-            if (affectedFile.path.endsWith("/") &&
-                isSha256(affectedFile.hash_at_plan_time)) {
-                hashedDirectoryPaths.add(affectedFile.path);
-            }
-        }
-    }
-    return declaredPaths.flatMap((path) => {
-        const directoryPath = `${path}/`;
-        return !path.endsWith("/") && hashedDirectoryPaths.has(directoryPath)
-            ? [directoryPath]
-            : [];
-    });
-}
-function deriveLegacyDirectoryScopeRecovery(state, workItem) {
-    if (!state.host_handoff?.work_item_ids.includes(workItem.id)) {
-        return { workItem, directoryPaths: [] };
-    }
-    const directoryPaths = deriveLegacyDirectoryPathsForBlock(state, workItem.id, workItem.allowed_files);
-    const recovered = new Set(directoryPaths);
-    const allowedFiles = workItem.allowed_files.map((allowed) => {
-        const directoryPath = `${allowed}/`;
-        return recovered.has(directoryPath) ? directoryPath : allowed;
-    });
-    return {
-        workItem: sameStrings(allowedFiles, workItem.allowed_files)
-            ? workItem
-            : { ...workItem, allowed_files: allowedFiles },
-        directoryPaths,
-    };
-}
-function effectiveBoundWorkload(state, workload) {
-    if (!state.host_handoff)
-        return workload;
-    return {
-        ...workload,
-        work_items: workload.work_items.map((workItem) => deriveLegacyDirectoryScopeRecovery(state, workItem).workItem),
-    };
-}
-/**
- * Persist the same directory intent for every block in a legacy plan before
- * its final active workload is cleared. Dependency-blocked blocks are included
- * because their next workload will be minted under v1alpha2 and cannot use
- * legacy inference. This must run only on the final drain: changing a currently
- * bound block sooner would break byte-for-byte canonical re-derivation.
- */
-function migrateLegacyDirectoryScopesAfterFinalDrain(state) {
-    state.plan.blocks = state.plan.blocks.map((block) => {
-        const recovered = new Set(deriveLegacyDirectoryPathsForBlock(state, block.block_id, block.touched_files));
-        if (recovered.size === 0)
-            return block;
-        const touchedFiles = block.touched_files.map((path) => !path.endsWith("/") && recovered.has(`${path}/`) ? `${path}/` : path);
-        return sameStrings(touchedFiles, block.touched_files)
-            ? block
-            : {
-                ...block,
-                touched_files: [...new Set(touchedFiles)].sort(compareCodeUnits),
-            };
-    });
-}
 /**
  * A block that arrived outside the shape this boundary CONSUMES.
  *
@@ -283,42 +208,42 @@ class BlockContractError extends Error {
  * becomes a work item and its commands never run.
  *
  * COVERS THE HANDOFF BOUNDARY ONLY. The other consumer of the same
- * `block.targeted_commands` — `reverifyBlockedItemAgainstTree` in
+ * `block.required_tests` — `reverifyBlockedItemAgainstTree` in
  * `src/remediate/phases/triage.ts` — asks the same declared command-shape rule
  * before spawning and then runs each command through {@link runRequiredTest}
  * (argv-split, no shell, deadline-bounded), so a command this boundary would
  * refuse is refused there too rather than reaching a shell.
  */
 function assertBlockContract(root, block) {
-    for (const raw of block.touched_files) {
+    for (const raw of block.allowed_files) {
         if (typeof raw !== "string" || raw.trim().length === 0) {
-            throw new BlockContractError(block.block_id, "touched_files carries an empty entry");
+            throw new BlockContractError(block.id, "touched_files carries an empty entry");
         }
         if (isAbsolute(raw)) {
-            throw new BlockContractError(block.block_id, `touched_files entry ${JSON.stringify(raw)} is absolute, not repository-relative`);
+            throw new BlockContractError(block.id, `touched_files entry ${JSON.stringify(raw)} is absolute, not repository-relative`);
         }
         let normalized;
         try {
-            normalized = normalizeDeclaredPath(root, raw, `${block.block_id}.touched_files[]`);
+            normalized = normalizeDeclaredPath(root, raw, `${block.id}.touched_files[]`);
         }
         catch {
-            throw new BlockContractError(block.block_id, `touched_files entry ${JSON.stringify(raw)} does not resolve beneath the repository root`);
+            throw new BlockContractError(block.id, `touched_files entry ${JSON.stringify(raw)} does not resolve beneath the repository root`);
         }
         if (normalized !== raw) {
-            throw new BlockContractError(block.block_id, `touched_files entry ${JSON.stringify(raw)} is not in normalized repo-relative form ` +
+            throw new BlockContractError(block.id, `touched_files entry ${JSON.stringify(raw)} is not in normalized repo-relative form ` +
                 `(${JSON.stringify(normalized)})`);
         }
     }
-    for (const command of block.targeted_commands ?? []) {
+    for (const command of block.required_tests ?? []) {
         if (typeof command !== "string" || command.trim().length === 0) {
-            throw new BlockContractError(block.block_id, "targeted_commands carries an empty command");
+            throw new BlockContractError(block.id, "targeted_commands carries an empty command");
         }
         // THE declared-command-shape rule (`audit-tools/shared`), not a local copy:
         // the producer that promotes these commands and the triage path that also
         // spawns them ask the same predicate, so a command cannot clear one boundary
         // and dead-end at another.
         if (commandLeavesDeclaredShape(command)) {
-            throw new BlockContractError(block.block_id, `targeted_command ${JSON.stringify(command)} leaves the declared shape — it chains, ` +
+            throw new BlockContractError(block.id, `targeted_command ${JSON.stringify(command)} leaves the declared shape — it chains, ` +
                 "redirects or substitutes, and this boundary executes commands verbatim through a shell");
         }
     }
@@ -344,22 +269,20 @@ function assertBlockContract(root, block) {
  *     always named" true rather than usually true.
  */
 function planBlockIssues(root, state) {
-    const blockIds = new Set(state.plan.blocks.map((block) => block.block_id));
+    const blockIds = new Set(state.plan.units.map((block) => block.id));
     const boundIds = new Set(state.host_handoff?.work_item_ids ?? []);
     const issues = [];
-    for (const block of state.plan.blocks) {
-        const unsettled = block.items.some((findingId) => {
-            const status = state.items[findingId]?.status;
-            return status !== undefined && !isTerminalStatus(status);
-        });
-        if (!unsettled && !boundIds.has(block.block_id))
+    for (const block of state.plan.units) {
+        const status = state.items[block.id]?.status;
+        const unsettled = status !== undefined && !isTerminalStatus(status);
+        if (!unsettled && !boundIds.has(block.id))
             continue;
         const missing = (block.dependencies ?? []).filter((dependencyId) => !blockIds.has(dependencyId));
         if (missing.length > 0) {
             issues.push({
                 code: "dependency_missing",
-                work_item_id: block.block_id,
-                message: `block '${block.block_id}' declares ${missing.length === 1 ? "a dependency" : "dependencies"} ` +
+                work_item_id: block.id,
+                message: `block '${block.id}' declares ${missing.length === 1 ? "a dependency" : "dependencies"} ` +
                     `${missing.map((id) => `'${id}'`).join(", ")} present in no block of the plan, so it can ` +
                     "never be dependency-verified and is never scheduled",
             });
@@ -373,11 +296,15 @@ function planBlockIssues(root, state) {
                 throw error;
             issues.push({
                 code: "block_contract_invalid",
-                work_item_id: block.block_id,
+                work_item_id: block.id,
                 message: error.message,
             });
         }
     }
+    for (const message of executionPlanReferenceIssues(state.plan, state.plan.findings.map(finding => finding.id))) {
+        if (!issues.some(issue => issue.message === message))
+            issues.push({ code: "block_contract_invalid", message });
+    }
     return issues;
 }
 /**
@@ -470,171 +397,64 @@ export function remediationHostResultFilePath(params) {
  * verified its prerequisites.
  */
 export function hostDependencyLevels(state) {
-    const plan = state.plan;
-    const items = state.items;
+    const { plan, items } = state;
     if (!plan || !items)
         return [];
-    const blockById = new Map(plan.blocks.map((block) => [block.block_id, block]));
-    const pendingBlocks = plan.blocks.filter((block) => block.items.some((findingId) => items[findingId]?.status === "pending"));
-    const isVerifiedNow = (block) => block.items.every((findingId) => isVerifiedCompleteStatus(items[findingId]?.status));
-    const isPending = (block) => block.items.some((findingId) => items[findingId]?.status === "pending");
-    const phaseOf = (block) => block.phase_ordinal ?? 0;
-    const lowerPhaseBlocks = (phase) => plan.blocks.filter((block) => phaseOf(block) < phase);
-    const phaseBarrierClear = (phase) => lowerPhaseBlocks(phase).every(isVerifiedNow);
-    const phaseBarrierUnsatisfiable = (phase) => lowerPhaseBlocks(phase).some((block) => !isVerifiedNow(block) && !isPending(block));
-    const permanentlyIneligible = (block) => {
-        for (const dependencyId of block.dependencies ?? []) {
-            const dependency = blockById.get(dependencyId);
-            // An id that resolves to NO block is not a harmless declaration — it is a
-            // prerequisite that can never be verified, so the block can never become
-            // eligible. Guarding on `dependency &&` skipped exactly this case, which
-            // is the second half of the same hole as the readiness predicate below:
-            // closing only one leaves the block reaching the host anyway.
-            if (dependency === undefined)
-                return true;
-            if (!isVerifiedNow(dependency) && !isPending(dependency)) {
-                return true;
-            }
-        }
-        return phaseBarrierUnsatisfiable(phaseOf(block));
-    };
-    const levels = [];
+    const byId = new Map(plan.units.map(unit => [unit.id, unit]));
+    const lowerPhases = (unit) => plan.units.filter(lower => (lower.phase_ordinal ?? 0) < (unit.phase_ordinal ?? 0));
     const placed = new Set();
-    let remaining = pendingBlocks.filter((block) => !permanentlyIneligible(block));
-    while (remaining.length > 0) {
-        const ready = remaining.filter((block) => phaseBarrierClear(phaseOf(block)) &&
-            (block.dependencies ?? []).every((dependencyId) => {
-                const dependency = blockById.get(dependencyId);
-                // DEPENDENCY READINESS REQUIRES EXISTENCE. `!dependency` used to read
-                // as "satisfied", so a plan naming a block that does not exist had its
-                // dependent placed at level 0 and dispatched with the prerequisite
-                // never verified — silently, because no other check looks at it.
-                if (dependency === undefined)
-                    return false;
-                if (isVerifiedNow(dependency))
-                    return true;
-                return dependency.items.every((findingId) => isVerifiedCompleteStatus(items[findingId]?.status) ||
-                    (items[findingId]?.status === "pending" &&
-                        placed.has(dependency.block_id)));
-            }));
-        if (ready.length === 0)
+    let remaining = plan.units.filter(unit => items[unit.id]?.status === "pending");
+    const levels = [];
+    while (remaining.length) {
+        // A phase is an integration boundary: even projected later dependency levels
+        // wait until every earlier phase actually verified on the current tree.
+        const ready = remaining.filter(unit => lowerPhases(unit).every(lower => isVerifiedCompleteStatus(items[lower.id]?.status)) &&
+            unit.dependencies.every(id => byId.has(id) && (isVerifiedCompleteStatus(items[id]?.status) || placed.has(id))));
+        if (!ready.length)
             break;
         levels.push(ready);
-        for (const block of ready)
-            placed.add(block.block_id);
-        remaining = remaining.filter((block) => !placed.has(block.block_id));
+        for (const unit of ready)
+            placed.add(unit.id);
+        remaining = remaining.filter(unit => !placed.has(unit.id));
     }
     return levels;
 }
-/**
- * Pending blocks that can NEVER dispatch — the dead-end sweep's one source,
- * kept beside {@link hostDependencyLevels} so the sweep and the workload
- * boundary share one eligibility semantics and cannot disagree (the 2026-08-23
- * empty-frontier incident: the old edge-only sweep predicate missed the phase
- * barrier and dependency existence, so a frontier the builder refused looked
- * dispatchable to the guard and next-step threw instead of pausing).
- *
- * Optimistic liveness fixpoint: an item counts as still SATISFIABLE while it is
- * verified-complete, `pending`, or `needs_clarification` — an unanswered
- * question is "awaiting an answer", never "upstream failed" (the 175cfb89
- * pin). A block is LIVE once every one of its items is satisfiable, every
- * declared dependency resolves to a live block, and every lower-phase block is
- * live. What never enters the live set is exactly what can never reach the
- * host: an obstacle chain that bottoms out in a terminal non-verified item
- * (`blocked` or a SKIP — INV-RS-01), a dependency id that resolves to no
- * block, or a dependency cycle.
- */
-export function permanentlyDeadPendingBlocks(state) {
-    const plan = state.plan;
-    const items = state.items;
+/** Questions remain live; skipped/failed prerequisites never authorize a dependent. */
+export function permanentlyDeadPendingUnits(state) {
+    const { plan, items } = state;
     if (!plan || !items)
         return [];
-    const satisfiable = (status) => isVerifiedCompleteStatus(status) ||
-        status === "pending" ||
-        status === "needs_clarification";
-    const phaseOf = (block) => block.phase_ordinal ?? 0;
-    const blockById = new Map(plan.blocks.map((block) => [block.block_id, block]));
-    // Fully-verified blocks seed the live set unconditionally: their work already
-    // landed, so their own declared dependencies are history, not obstacles.
-    const live = new Set(plan.blocks
-        .filter((block) => block.items.every((findingId) => isVerifiedCompleteStatus(items[findingId]?.status)))
-        .map((block) => block.block_id));
-    // Least fixpoint: grow the live set until stable. A cycle never enters it.
-    for (let grew = true; grew;) {
-        grew = false;
-        for (const block of plan.blocks) {
-            if (live.has(block.block_id))
-                continue;
-            if (!block.items.every((findingId) => satisfiable(items[findingId]?.status))) {
+    const live = new Set(plan.units.filter(unit => isVerifiedCompleteStatus(items[unit.id]?.status)).map(unit => unit.id));
+    for (let changed = true; changed;) {
+        changed = false;
+        for (const unit of plan.units) {
+            if (live.has(unit.id))
                 continue;
-            }
-            const dependenciesLive = (block.dependencies ?? []).every((dependencyId) => {
-                const dependency = blockById.get(dependencyId);
-                return dependency !== undefined && live.has(dependency.block_id);
-            });
-            const lowerPhasesLive = plan.blocks
-                .filter((lower) => phaseOf(lower) < phaseOf(block))
-                .every((lower) => live.has(lower.block_id));
-            if (dependenciesLive && lowerPhasesLive) {
-                live.add(block.block_id);
-                grew = true;
+            const status = items[unit.id]?.status;
+            const lowerPhasesLive = plan.units.filter(lower => (lower.phase_ordinal ?? 0) < (unit.phase_ordinal ?? 0)).every(lower => live.has(lower.id));
+            if ((status === "pending" || status === "needs_clarification") && lowerPhasesLive && unit.dependencies.every(id => live.has(id))) {
+                live.add(unit.id);
+                changed = true;
             }
         }
     }
-    return plan.blocks.filter((block) => !live.has(block.block_id) &&
-        block.items.some((findingId) => items[findingId]?.status === "pending"));
+    return plan.units.filter(unit => !live.has(unit.id) && items[unit.id]?.status === "pending");
 }
 function buildPrompt(item) {
-    const assignment = stableStringify({
-        ...(item.implementationContext ? { implementation_context: item.implementationContext } : {}),
-        allowed_files: item.allowedFiles,
-        assignments: item.assignments,
-        baseline_commit: item.baselineCommit,
-        finding_ids: item.findingIds,
-        id: item.blockId,
-        // The approved contract rides the sha-bound prompt (the evidence-coverage
-        // entry in docs/backlog/open-bugs.md): the binding then covers exactly the
-        // interface the worker saw.
-        ...(item.moduleContracts.length > 0
-            ? { module_contracts: item.moduleContracts }
-            : {}),
-        ...(item.obligationIds.length > 0
-            ? { obligation_ids: item.obligationIds }
-            : {}),
-        required_tests: item.requiredTests,
-        result_path: item.resultPath,
-    });
-    // The BODY only. The result template is appended by `bindWorkerPrompt`, and
-    // the prompt digest covers exactly this text (owner review of prompt 20,
-    // 2026-09-18: plain language, rules as bullets, no word a worker cannot act
-    // on).
     return [
-        `# Implement remediation work item \`${item.blockId}\``,
-        "",
-        "Assignment:",
-        "",
-        "```json",
-        assignment,
-        "```",
-        "",
-        "Rules:",
-        "",
-        '- Edit only the files in `allowed_files`. An entry that ends in "/" allows every file below that directory. Every other entry allows only that one file.',
-        "- Apply each finding in `assignments` exactly, with the clarified scope or the retry context it carries.",
-        ...(item.moduleContracts.length > 0
-            ? [
-                "- Conform to each contract in `module_contracts`: every declared input, output, invariant, side effect, validation boundary, failure mode and seam adjustment. Code that breaks a contract is a defect, even when the build and the tests pass.",
-            ]
-            : []),
-        ...(item.requiredTests.length > 0
-            ? [
-                "- Run each command in `required_tests` until it passes. The tool runs each command again before it accepts your result.",
-            ]
-            : []),
-        "- Make one commit on top of `baseline_commit`, with all your edits in it. Merge it so that HEAD contains it.",
-        ...(item.hasLandingGates
-            ? ["- Do not run the landing gates. The close phase runs them once, on the merged tree."]
-            : []),
+        `# Implement execution unit \`${item.unit.id}\``, "", "Assignment:", "", "```json",
+        stableStringify({
+            unit: item.unit, requirements: item.requirements, source_findings: item.sourceFindings,
+            accepted_counterexamples: item.counterexamples,
+            review_revision_sha256: item.revision, baseline_commit: item.baselineCommit,
+            ...item.context, result_path: item.resultPath,
+        }), "```", "", "Rules:", "",
+        '- Edit only `unit.allowed_files`. A trailing "/" permits files below that directory; every other entry permits exactly that file.',
+        '- Read `unit.read_paths`, implement the reviewed unit description, and satisfy every linked requirement and scoped positive/negative assertion. Original source findings are provenance, not substitute execution instructions.',
+        '- Preserve every declared affected interface and address the named counterexamples. Code violating a requirement is a defect even if tests pass.',
+        ...(item.unit.required_tests.length ? ['- Run every `unit.required_tests` command until it passes. The tool reruns each before accepting your result.'] : []),
+        '- Make one commit on top of `baseline_commit`, with all your edits in it. Merge it so HEAD contains it.',
+        ...(item.hasLandingGates ? ['- Do not run the landing gates. The close phase runs them once, on the merged tree.'] : []),
     ].join("\n");
 }
 /**
@@ -727,7 +547,7 @@ export function severityRiskWeight(severity) {
             : (severityRank(severity) - 1) / ladder;
 }
 function blockRiskScore(state, block) {
-    const scores = block.items
+    const scores = block.source_finding_ids
         .map((findingId) => state.plan.findings.find((entry) => entry.id === findingId)?.severity)
         .flatMap((severity) => severity === undefined ? [] : [severityRiskWeight(severity)]);
     if (scores.length === 0)
@@ -739,104 +559,41 @@ function blockRiskScore(state, block) {
     const corroborating = scores.filter((score) => score >= worst / 2).length - 1;
     return Math.min(1, worst + Math.max(0, corroborating) * 0.1);
 }
-function buildFindingAssignments(state, block) {
-    return block.items.map((findingId) => {
-        const finding = state.plan.findings.find((entry) => entry.id === findingId);
-        const item = state.items[findingId];
-        if (!finding || !item) {
-            throw new Error(`Host work item ${block.block_id} references unknown finding ${findingId}`);
-        }
-        return {
-            finding: FindingSchema.parse(finding),
-            ...(item.clarification_context
-                ? { clarification_context: item.clarification_context }
-                : {}),
-            ...(item.failure_context
-                ? { failure_context: item.failure_context }
-                : {}),
-        };
+function buildWorkItem(paths, runId, unit, baselineCommit, state) {
+    assertBlockContract(paths.root, unit);
+    const item = state.items[unit.id];
+    if (!item)
+        throw new Error(`Execution unit ${unit.id} has no runtime item`);
+    const requirements = unit.requirement_ids.map(id => {
+        const requirement = state.plan.requirements.find(entry => entry.id === id);
+        if (!requirement)
+            throw new Error(`Execution unit ${unit.id} references unknown requirement ${id}`);
+        return requirement;
     });
-}
-function buildWorkItem(paths, runId, block, baselineCommit, state) {
-    // The consumed-shape gate runs FIRST: a block outside the write-scope /
-    // command contract must never become a work item, so nothing downstream can
-    // dispatch it or execute its commands.
-    assertBlockContract(paths.root, block);
-    // THE ID-GLOSSARY SCOPE. A block whose contract COINS an invariant id writes
-    // it in `src/`, and the glossary document that has to document it sits
-    // outside every module's file scope — so without this the item is
-    // structurally unable to satisfy the id-glossary gate. Read off the block's
-    // own contract and obligations, never guessed; the ids the document already
-    // carries are subtracted inside `withGlossaryScope`, so a contract that only
-    // MENTIONS an existing id (a seam adjustment citing `INV-COVERAGE`, say) gets
-    // no widening — it coins nothing and needs no row.
-    const declaredIds = declaredInvariantIds({
-        obligations: block.items.flatMap((findingId) => state.plan.findings.find((entry) => entry.id === findingId)
-            ?.contract_obligation_ids ?? []),
-        module_contracts: block.module_contracts ?? [],
+    const sourceFindings = unit.source_finding_ids.map(id => {
+        const finding = state.plan.findings.find(entry => entry.id === id);
+        if (!finding)
+            throw new Error(`Execution unit ${unit.id} references unknown source finding ${id}`);
+        return finding;
     });
-    const allowedFiles = withGlossaryScope(paths.root, [...new Set(block.touched_files)].map((path) => normalizeDeclaredPath(paths.root, path, `${block.block_id}.touched_files[]`)).sort(compareCodeUnits), declaredIds);
-    const resultPath = resultPathFor(paths, block.block_id);
-    // THE LANDING GATES ARE NOT THIS ITEM'S. `check:deadcode`, `check:depgraph`,
-    // lint and the id-glossary gate state facts about the WHOLE tree, so the
-    // boundary that owns them is the CLOSE, on the merged tree — never a
-    // per-item dispatch. Folding them in here was tried and refused a wave item
-    // that added an export whose only consumer lands in a LATER item: no edit
-    // inside the item's scope could pass, and another item's fault could refuse
-    // this one. See CLAUDE.md, *A gate states the boundary it OWNS*; the close
-    // leg is `verifyLandingGates` in `src/remediate/phases/close.ts`.
-    //
-    // The per-item required tests are the block's OWN commands, unchanged, which
-    // is what this field meant before the gates were folded in and what the
-    // tool reruns at ingestion.
-    //
-    // ONE FACT still rides the emitted prompt: whether the target root declares
-    // any landing gate at all, so the host knows a close will run them.
-    const hasLandingGates = discoverLandingGates(paths.root).length > 0;
-    const requiredTests = [...(block.targeted_commands ?? [])];
-    const assignments = buildFindingAssignments(state, block);
-    // The obligation demand is bound here, once, from the same plan findings the
-    // assignments render — ingestion then re-derives this exact set through the
-    // byte-for-byte work-item comparison, so the result's evidence coverage is
-    // checked against a tool-owned binding, never the result's own claim.
-    const obligationIds = [
-        ...new Set(block.items.flatMap((findingId) => state.plan.findings.find((entry) => entry.id === findingId)
-            ?.contract_obligation_ids ?? [])),
-    ].sort(compareCodeUnits);
+    const resultPath = resultPathFor(paths, unit.id);
+    const obligationIds = [...unit.requirement_ids].sort(compareCodeUnits);
     const prompt = bindWorkerPrompt(buildPrompt({
-        blockId: block.block_id,
-        findingIds: block.items,
-        assignments,
-        allowedFiles,
-        baselineCommit,
-        obligationIds,
-        requiredTests,
-        hasLandingGates,
-        resultPath,
-        moduleContracts: block.module_contracts ?? [],
-        implementationContext: block.implementation_context,
-    }), (promptDigest) => renderResultTemplate({
-        runId,
-        blockId: block.block_id,
-        resultPath,
-        obligationIds,
-        promptDigest,
-    }));
+        unit, requirements, sourceFindings, revision: state.plan.review_revision_sha256,
+        counterexamples: (state.plan.review_counterexamples ?? []).filter(example => unit.addresses_counterexample_ids.includes(example.id)),
+        context: {
+            ...(item.clarification_context ? { clarification_context: item.clarification_context } : {}),
+            ...(item.failure_context ? { failure_context: item.failure_context } : {}),
+        }, baselineCommit, resultPath, hasLandingGates: discoverLandingGates(paths.root).length > 0,
+    }), promptDigest => renderResultTemplate({ runId, blockId: unit.id, resultPath, obligationIds, promptDigest }));
+    const tokenEstimate = estimateTokensFromBytes(Buffer.byteLength(prompt.text, "utf8"));
     return {
-        id: block.block_id,
-        finding_ids: [...block.items],
-        allowed_files: allowedFiles,
-        baseline_commit: baselineCommit,
-        obligation_ids: obligationIds,
-        prompt: { text: prompt.text, sha256: prompt.sha256 },
-        required_tests: requiredTests,
-        result_path: resultPath,
-        demand: deriveLaneDemand({
-            tokenEstimate: block.token_estimate ?? 0,
-            fileCount: allowedFiles.length,
-            riskScore: blockRiskScore(state, block),
-        }),
-        token_estimate: block.token_estimate ?? 0,
+        id: unit.id, source_finding_ids: [...unit.source_finding_ids],
+        allowed_files: [...unit.allowed_files], baseline_commit: baselineCommit,
+        obligation_ids: obligationIds, prompt: { text: prompt.text, sha256: prompt.sha256 },
+        required_tests: [...unit.required_tests], result_path: resultPath,
+        demand: deriveLaneDemand({ tokenEstimate, fileCount: unit.allowed_files.length, riskScore: blockRiskScore(state, unit) }),
+        token_estimate: tokenEstimate,
     };
 }
 function buildCanonicalWorkload(params) {
@@ -844,12 +601,12 @@ function buildCanonicalWorkload(params) {
         ? new Set(params.workItemIds)
         : null;
     const sourceBlocks = requestedIds
-        ? params.state.plan.blocks.filter((block) => requestedIds.has(block.block_id))
+        ? params.state.plan.units.filter((block) => requestedIds.has(block.id))
         : hostDependencyLevels(params.state)[0] ?? [];
-    const blocks = [...sourceBlocks].sort((left, right) => compareCodeUnits(left.block_id, right.block_id));
+    const blocks = [...sourceBlocks].sort((left, right) => compareCodeUnits(left.id, right.id));
     if (requestedIds &&
         (blocks.length !== requestedIds.size ||
-            blocks.some((block) => !requestedIds.has(block.block_id)))) {
+            blocks.some((block) => !requestedIds.has(block.id)))) {
         throw new Error("Trusted remediation host workload references an unknown block");
     }
     return {
@@ -864,7 +621,7 @@ function parseWorkItem(value, paths, runId, state, expectedBaselineCommit) {
             "allowed_files",
             "baseline_commit",
             "demand",
-            "finding_ids",
+            "source_finding_ids",
             "id",
             "obligation_ids",
             "prompt",
@@ -875,8 +632,8 @@ function parseWorkItem(value, paths, runId, state, expectedBaselineCommit) {
         typeof value.id !== "string" ||
         !LaneDemandSchema.safeParse(value.demand).success ||
         !isCommit(value.baseline_commit) ||
-        !Array.isArray(value.finding_ids) ||
-        !value.finding_ids.every((entry) => typeof entry === "string") ||
+        !Array.isArray(value.source_finding_ids) ||
+        !value.source_finding_ids.every((entry) => typeof entry === "string") ||
         !Array.isArray(value.obligation_ids) ||
         !value.obligation_ids.every((entry) => typeof entry === "string") ||
         !Array.isArray(value.allowed_files) ||
@@ -892,7 +649,7 @@ function parseWorkItem(value, paths, runId, state, expectedBaselineCommit) {
         !isSha256(value.prompt.sha256)) {
         return null;
     }
-    const block = state.plan.blocks.find((candidate) => candidate.block_id === value.id);
+    const block = state.plan.units.find((candidate) => candidate.id === value.id);
     if (!block)
         return null;
     let expected;
@@ -1184,7 +941,7 @@ function unresolvedFrontierWorkItemIds(state, record) {
     const items = state.items;
     const pendingBlockIds = new Set(Object.values(items)
         .filter((item) => item?.status === "pending")
-        .map((item) => item.block_id));
+        .map((item) => item.unit_id));
     return [...record.work_item_ids]
         .filter((id) => pendingBlockIds.has(id))
         .sort(compareCodeUnits);
@@ -1205,6 +962,7 @@ export async function precomputeRecoveryTestVerdicts(params) {
     if (!state)
         return "unsupported_retired_state";
     const paths = resolveBoundaryPaths(params);
+    await assertApprovedRuntimePlan(paths.artifactsDir, state);
     const verdicts = new MintedRequiredTestVerdicts();
     const workloadRead = await readSubmissionDocument(paths.workloadPath);
     if (workloadRead.kind !== "value")
@@ -1214,7 +972,7 @@ export async function precomputeRecoveryTestVerdicts(params) {
         return verdicts;
     const commands = [];
     for (const workItem of workload.work_items) {
-        const hasPending = workItem.finding_ids.some((findingId) => state.items[findingId]?.status === "pending");
+        const hasPending = state.items[workItem.id]?.status === "pending";
         if (!hasPending)
             continue;
         const absoluteResultPath = resolveContainedPath(paths.root, workItem.result_path, `result path for ${workItem.id}`);
@@ -1262,11 +1020,21 @@ export async function prepareRemediationHostHandoff(params) {
     const state = parseCurrentState(params.state);
     if (!state)
         return "unsupported_retired_state";
+    const paths = resolveBoundaryPaths(params);
+    const approved = await assertApprovedRuntimePlan(paths.artifactsDir, state);
     if (!isCommit(params.baselineCommit)) {
         throw new Error("Remediation host baselineCommit must be a full commit id");
     }
-    const paths = resolveBoundaryPaths(params);
     const existingRecord = state.host_handoff;
+    if (!existingRecord) {
+        const accepted = state.plan.units.flatMap(unit => {
+            const item = state.items[unit.id];
+            return item?.host_landed_commit ? [{ allowed_files: [...unit.allowed_files], landed_commit: item.host_landed_commit }] : [];
+        });
+        const contextIssues = await executionPlanContextIssues(paths.root, approved.canonical, accepted);
+        if (contextIssues.length)
+            throw new RemediationHostPreparationError("plan_repair_required", contextIssues.join("; "));
+    }
     if (existingRecord && existingRecord.run_id !== params.runId) {
         throw new Error("Trusted remediation host handoff belongs to another run");
     }
@@ -1277,6 +1045,9 @@ export async function prepareRemediationHostHandoff(params) {
         }
     }
     const baselineCommit = existingRecord?.baseline_commit ?? params.baselineCommit;
+    const planIssues = planBlockIssues(paths.root, state);
+    if (planIssues.length)
+        throw new RemediationHostPreparationError("plan_repair_required", planIssues.map(issue => issue.message).join("; "));
     let workload;
     try {
         workload = buildCanonicalWorkload({
@@ -1356,6 +1127,7 @@ export async function prepareRemediationHostHandoff(params) {
             work_item_ids: workload.work_items.map((item) => item.id),
         };
     await mkdir(paths.resultDir, { recursive: true });
+    await assertApprovedRuntimePlan(paths.artifactsDir, state);
     await recordHostRootLogBoundary({ ...paths, runId: params.runId, phase: "prepare" });
     await writeJsonFile(paths.workloadPath, workload);
     return {
@@ -1411,6 +1183,8 @@ export async function ingestRemediationHostResults(params) {
     const state = parseCurrentState(params.state);
     if (!state)
         return "unsupported_retired_state";
+    const paths = resolveBoundaryPaths(params);
+    await assertApprovedRuntimePlan(paths.artifactsDir, state);
     // The verdict table is the ONE input whose validity the type system cannot
     // check: a hand-built map of all-green verdicts asserts tests ran that never
     // did. Refuse it up front — before any ledger append, any git probe, and any
@@ -1421,7 +1195,6 @@ export async function ingestRemediationHostResults(params) {
         throw new Error("recovery.requiredTestVerdicts must come from precomputeRecoveryTestVerdicts: " +
             "a caller-supplied verdict table asserts required tests ran that no runner produced");
     }
-    const paths = resolveBoundaryPaths(params);
     if (state.conformance_review && state.conformance_review.run_id !== params.runId) {
         throw new Error("Conformance review policy belongs to another run; refusing result acceptance.");
     }
@@ -1456,6 +1229,9 @@ export async function ingestRemediationHostResults(params) {
         recordedRecoveryMarks: null,
     };
     const verdicts = await executeHostVerificationReruns(validated.ctx, acc);
+    // Tests and independent review involve awaits. A superseding plan/source
+    // invalidates the entire acceptance before any accepted ledger event is minted.
+    await assertApprovedRuntimePlan(paths.artifactsDir, state);
     const issues = await recordAndEnrichHostIssues(params.artifactsDir, params.runId, acc.issues, acc.completed);
     const summary = await commitRemediationStateUpdates(validated.ctx, acc, verdicts, issues);
     await recordHostRootLogBoundary({ ...paths, runId: params.runId, phase: "ingest" });
@@ -1602,8 +1378,8 @@ async function validateHostResultBundle(input) {
             recovery: input.recovery !== undefined,
             state,
             nextState,
-            effectiveWorkload: effectiveBoundWorkload(state, workload),
-            eligibleIds: new Set((hostDependencyLevels(state)[0] ?? []).map((block) => block.block_id)),
+            effectiveWorkload: workload,
+            eligibleIds: new Set((hostDependencyLevels(state)[0] ?? []).map((block) => block.id)),
             // Can this ingest be corroborated against ground truth AT ALL? A git root
             // supplies the tree; a persisted `host_handoff` supplies the trusted
             // binding. With NEITHER there is nothing to check a host's claim against,
@@ -1640,7 +1416,7 @@ async function validateHostResultBundle(input) {
  * the result from scratch.
  */
 function hasLandedCommitFor(state, workItem) {
-    return workItem.finding_ids.some((findingId) => typeof state.items[findingId]?.host_landed_commit === "string");
+    return typeof state.items[workItem.id]?.host_landed_commit === "string";
 }
 async function requiredConformanceReview(ctx, workItem, result) {
     if (!ctx.state.conformance_review?.enabled)
@@ -1648,14 +1424,17 @@ async function requiredConformanceReview(ctx, workItem, result) {
     return checkContractConformance({
         root: ctx.paths.root, artifactsDir: ctx.paths.artifactsDir, runId: ctx.runId,
         item: workItem, result,
-        contracts: ctx.state.plan.blocks.find(block => block.block_id === workItem.id)?.module_contracts ?? [],
+        requirements: ctx.state.plan.requirements.filter(requirement => workItem.obligation_ids.includes(requirement.id)),
+        unit: ctx.state.plan.units.find(unit => unit.id === workItem.id),
+        revision: ctx.state.plan.review_revision_sha256,
+        counterexamples: (ctx.state.plan.review_counterexamples ?? []).filter(example => ctx.state.plan.units.find(unit => unit.id === workItem.id).addresses_counterexample_ids.includes(example.id)),
     });
 }
 async function executeHostVerificationReruns(ctx, acc) {
     const { paths, nextState, state } = ctx;
     const verdicts = [];
     for (const workItem of ctx.effectiveWorkload.work_items) {
-        const pendingItems = workItem.finding_ids.filter((findingId) => nextState.items[findingId]?.status === "pending" &&
+        const pendingItems = [workItem.id].filter((findingId) => nextState.items[findingId]?.status === "pending" &&
             !acc.settledFindingIds.has(findingId));
         if (pendingItems.length === 0)
             continue;
@@ -1942,11 +1721,10 @@ function commitRemediationStateUpdates(ctx, acc, verdicts, issues) {
         nextState.applied_edit_surface = [...acc.landedFiles].sort(compareCodeUnits);
     }
     const pendingWorkItemIds = ctx.effectiveWorkload.work_items
-        .filter((workItem) => workItem.finding_ids.some((findingId) => nextState.items[findingId]?.status === "pending"))
+        .filter((workItem) => [workItem.id].some((findingId) => nextState.items[findingId]?.status === "pending"))
         .map((workItem) => workItem.id);
     let stateChanged = acc.completed.length > 0;
     if (nextState.host_handoff && pendingWorkItemIds.length === 0) {
-        migrateLegacyDirectoryScopesAfterFinalDrain(nextState);
         delete nextState.host_handoff;
         stateChanged = true;
     }