audit-tools 0.52.5 → 0.53.0

package/dist/remediate/state/types.d.ts

@@ -1,191 +1,163 @@
 import type { AcceptedConformanceReview } from "../../shared/types/reviewIndependence.js";
+export type { ExecutionRequirement, ExecutionUnit, ExecutionRequest } from "../../shared/types/executionPlan.js";
 import { z } from "zod";
 import type { RemediationItemStatus } from "./itemStatus.js";
-import type { Finding, RemediationOutcome, MechanicalVerification } from "audit-tools/shared";
+import type { Finding, RemediationOutcome } from "audit-tools/shared";
 export type { Finding };
-import type { Evidence } from "../../shared/types/remediationOutcome.js";
-import type { PerFindingDisposition } from "./disposition.js";
-export declare const RemediationBlockSchema: z.ZodObject<{
-    block_id: z.ZodString;
-    items: z.ZodArray<z.ZodString, "many">;
-    /**
-     * Whether this block may run concurrently with its peers. First-class on the
-     * block contract (not derived host-side) so the scheduler reads one source.
-     */
-    parallel_safe: z.ZodBoolean;
-    /**
-     * Block ids that must complete before this block runs. First-class (the
-     * serialized schema-first chain head, CE-001): producers emit it, the
-     * scheduler consumes it. Optional — absence means no upstream dependency.
-     */
-    dependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    /**
-     * Commands to run as a post-merge verification gate after this block's
-     * worktree branch is merged into the main tree. When present, these are
-     * preferred over `RemediationPlan.test_command` for the gate check.
-     */
-    targeted_commands: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    /**
-     * Repo-relative paths that this block's implementation is expected to touch.
-     * First-class and REQUIRED (an empty array is allowed, an omitted field is
-     * rejected by `validateRemediationBlock` — which the state LOAD gate
-     * delegates to, so the requirement holds on every path a block reaches a
-     * consumer through): the file-ownership-disjoint scheduler and
-     * `blockResolvedItemsOnCombinedFailure` both read it, so a block with no declared
-     * surface is a producer bug, not an implicit empty.
-     */
-    touched_files: z.ZodArray<z.ZodString, "many">;
-    /**
-     * 0-based foundations→consumers phase ordinal (auto-phasing, T3). Derived
-     * mechanically at promotion from the persisted phase cut (the module a block's
-     * obligations belong to). The host handoff treats it as a hard barrier: a
-     * block is never emitted until every lower-ordinal block is verified-complete,
-     * giving a per-phase whole-repo green checkpoint. Optional — absent (or all
-     * blocks sharing one ordinal) means a single phase, i.e. no barrier.
-     */
-    phase_ordinal: z.ZodOptional<z.ZodNumber>;
-    /**
-     * Whether the blocks sharing a co-file (same touched path) may still run in
-     * parallel because their edit regions are disjoint. Additive + optional:
-     * absence is equivalent to `false` (co-file blocks serialize by default), and
-     * a pre-existing block with no such key still validates. Deliberately a bare
-     * boolean — no WriteRegion / WriteAnchor / anchor apparatus lives on the block.
-     */
-    cofile_parallel_safe: z.ZodOptional<z.ZodBoolean>;
-    /**
-     * Deterministic advisory size derived from this block's unique physical
-     * files. It is metadata for the host, never a backend-fit claim.
-     */
-    token_estimate: z.ZodOptional<z.ZodNumber>;
-    /** Distinct instructions from the implementation node, carried into the bound prompt. */
-    implementation_context: z.ZodOptional<z.ZodObject<{
-        description: z.ZodOptional<z.ZodString>;
-        preconditions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        expected_changes: z.ZodOptional<z.ZodString>;
-        counterexamples: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            claim: z.ZodString;
-            reproduction_steps: z.ZodArray<z.ZodString, "many">;
-            expected: z.ZodString;
-            actual: z.ZodString;
-            violated_obligation_ids: z.ZodArray<z.ZodString, "many">;
-        }, "strip", z.ZodTypeAny, {
-            expected: string;
-            id: string;
-            claim: string;
-            reproduction_steps: string[];
-            actual: string;
-            violated_obligation_ids: string[];
+/** One reviewed semantic plan, carrying immutable source provenance. */
+export declare const RemediationPlanSchema: z.ZodObject<{
+    plan_id: z.ZodString;
+    objective: z.ZodString;
+    non_goals: z.ZodArray<z.ZodString, "many">;
+    requirements: z.ZodArray<z.ZodEffects<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        source_finding_ids: z.ZodArray<z.ZodString, "many">;
+        change_kind: z.ZodEnum<["behavior_change", "addition", "structural"]>;
+        assertions: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<["positive", "negative"]>;
+            description: z.ZodString;
+            scope_paths: z.ZodArray<z.ZodString, "many">;
+        }, "strict", z.ZodTypeAny, {
+            kind: "positive" | "negative";
+            description: string;
+            scope_paths: string[];
         }, {
-            expected: string;
-            id: string;
-            claim: string;
-            reproduction_steps: string[];
-            actual: string;
-            violated_obligation_ids: string[];
+            kind: "positive" | "negative";
+            description: string;
+            scope_paths: string[];
+        }>, "many">;
+        inapplicable_reason: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        description: string;
+        source_finding_ids: string[];
+        change_kind: "structural" | "behavior_change" | "addition";
+        assertions: {
+            kind: "positive" | "negative";
+            description: string;
+            scope_paths: string[];
+        }[];
+        inapplicable_reason?: string | undefined;
+    }, {
+        id: string;
+        description: string;
+        source_finding_ids: string[];
+        change_kind: "structural" | "behavior_change" | "addition";
+        assertions: {
+            kind: "positive" | "negative";
+            description: string;
+            scope_paths: string[];
+        }[];
+        inapplicable_reason?: string | undefined;
+    }>, {
+        id: string;
+        description: string;
+        source_finding_ids: string[];
+        change_kind: "structural" | "behavior_change" | "addition";
+        assertions: {
+            kind: "positive" | "negative";
+            description: string;
+            scope_paths: string[];
+        }[];
+        inapplicable_reason?: string | undefined;
+    }, {
+        id: string;
+        description: string;
+        source_finding_ids: string[];
+        change_kind: "structural" | "behavior_change" | "addition";
+        assertions: {
+            kind: "positive" | "negative";
+            description: string;
+            scope_paths: string[];
+        }[];
+        inapplicable_reason?: string | undefined;
+    }>, "many">;
+    units: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodString;
+        source_finding_ids: z.ZodArray<z.ZodString, "many">;
+        requirement_ids: z.ZodArray<z.ZodString, "many">;
+        dependencies: z.ZodArray<z.ZodString, "many">;
+        phase_ordinal: z.ZodOptional<z.ZodNumber>;
+        read_paths: z.ZodArray<z.ZodString, "many">;
+        allowed_files: z.ZodArray<z.ZodString, "many">;
+        required_tests: z.ZodArray<z.ZodString, "many">;
+        affected_interfaces: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            name: string;
+            description: string;
+        }, {
+            name: string;
+            description: string;
         }>, "many">>;
+        addresses_counterexample_ids: z.ZodArray<z.ZodString, "many">;
     }, "strict", z.ZodTypeAny, {
-        description?: string | undefined;
-        preconditions?: string[] | undefined;
-        expected_changes?: string | undefined;
-        counterexamples?: {
-            expected: string;
-            id: string;
-            claim: string;
-            reproduction_steps: string[];
-            actual: string;
-            violated_obligation_ids: string[];
-        }[] | undefined;
+        id: string;
+        read_paths: string[];
+        title: string;
+        description: string;
+        source_finding_ids: string[];
+        requirement_ids: string[];
+        dependencies: string[];
+        allowed_files: string[];
+        required_tests: string[];
+        affected_interfaces: {
+            name: string;
+            description: string;
+        }[];
+        addresses_counterexample_ids: string[];
+        phase_ordinal?: number | undefined;
     }, {
-        description?: string | undefined;
-        preconditions?: string[] | undefined;
-        expected_changes?: string | undefined;
-        counterexamples?: {
-            expected: string;
-            id: string;
-            claim: string;
-            reproduction_steps: string[];
-            actual: string;
-            violated_obligation_ids: string[];
+        id: string;
+        read_paths: string[];
+        title: string;
+        description: string;
+        source_finding_ids: string[];
+        requirement_ids: string[];
+        dependencies: string[];
+        allowed_files: string[];
+        required_tests: string[];
+        addresses_counterexample_ids: string[];
+        phase_ordinal?: number | undefined;
+        affected_interfaces?: {
+            name: string;
+            description: string;
         }[] | undefined;
-    }>>;
-    /**
-     * The APPROVED finalized module contract(s) this block implements (the
-     * evidence-coverage entry in docs/backlog/open-bugs.md). Attached VERBATIM at promotion by resolving each DAG
-     * node's obligation-id slugs against `finalized_module_contracts`, and
-     * carried into the sha-bound dispatch prompt so a worker conforms to the
-     * approved interface instead of inventing a locally plausible one that
-     * contradicts it. Optional — a plan from outside the contract pipeline has
-     * no module contracts.
-     */
-    module_contracts: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        module: z.ZodString;
-        contract: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }>, "many">;
+    source_dispositions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        finding_id: z.ZodString;
+        status: z.ZodEnum<["already_fixed", "refuted", "deferred"]>;
+        reason: z.ZodString;
+        evidence: z.ZodArray<z.ZodString, "many">;
     }, "strict", z.ZodTypeAny, {
-        module: string;
-        contract: Record<string, unknown>;
+        status: "refuted" | "already_fixed" | "deferred";
+        reason: string;
+        evidence: string[];
+        finding_id: string;
     }, {
-        module: string;
-        contract: Record<string, unknown>;
+        status: "refuted" | "already_fixed" | "deferred";
+        reason: string;
+        evidence: string[];
+        finding_id: string;
     }>, "many">>;
-}, "strict", z.ZodTypeAny, {
-    items: string[];
-    block_id: string;
-    parallel_safe: boolean;
-    touched_files: string[];
-    targeted_commands?: string[] | undefined;
-    token_estimate?: number | undefined;
-    dependencies?: string[] | undefined;
-    phase_ordinal?: number | undefined;
-    cofile_parallel_safe?: boolean | undefined;
-    implementation_context?: {
-        description?: string | undefined;
-        preconditions?: string[] | undefined;
-        expected_changes?: string | undefined;
-        counterexamples?: {
-            expected: string;
-            id: string;
-            claim: string;
-            reproduction_steps: string[];
-            actual: string;
-            violated_obligation_ids: string[];
-        }[] | undefined;
-    } | undefined;
-    module_contracts?: {
-        module: string;
-        contract: Record<string, unknown>;
-    }[] | undefined;
-}, {
-    items: string[];
-    block_id: string;
-    parallel_safe: boolean;
-    touched_files: string[];
-    targeted_commands?: string[] | undefined;
-    token_estimate?: number | undefined;
-    dependencies?: string[] | undefined;
-    phase_ordinal?: number | undefined;
-    cofile_parallel_safe?: boolean | undefined;
-    implementation_context?: {
-        description?: string | undefined;
-        preconditions?: string[] | undefined;
-        expected_changes?: string | undefined;
-        counterexamples?: {
-            expected: string;
-            id: string;
-            claim: string;
-            reproduction_steps: string[];
-            actual: string;
-            violated_obligation_ids: string[];
-        }[] | undefined;
-    } | undefined;
-    module_contracts?: {
-        module: string;
-        contract: Record<string, unknown>;
-    }[] | undefined;
-}>;
-export type RemediationBlock = z.infer<typeof RemediationBlockSchema>;
-export declare const RemediationPlanSchema: z.ZodObject<{
-    plan_id: z.ZodString;
+    request_disposition: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<["already_satisfied", "deferred"]>;
+        reason: z.ZodString;
+        evidence: z.ZodArray<z.ZodString, "many">;
+    }, "strict", z.ZodTypeAny, {
+        status: "deferred" | "already_satisfied";
+        reason: string;
+        evidence: string[];
+    }, {
+        status: "deferred" | "already_satisfied";
+        reason: string;
+        evidence: string[];
+    }>>;
+} & {
     goal_id: z.ZodOptional<z.ZodString>;
     source: z.ZodOptional<z.ZodString>;
     findings: z.ZodArray<z.ZodObject<{
@@ -482,200 +454,51 @@ export declare const RemediationPlanSchema: z.ZodObject<{
             confirmation: "lead";
         } | undefined;
     }>, "many">;
-    blocks: z.ZodArray<z.ZodObject<{
-        block_id: z.ZodString;
-        items: z.ZodArray<z.ZodString, "many">;
-        /**
-         * Whether this block may run concurrently with its peers. First-class on the
-         * block contract (not derived host-side) so the scheduler reads one source.
-         */
-        parallel_safe: z.ZodBoolean;
-        /**
-         * Block ids that must complete before this block runs. First-class (the
-         * serialized schema-first chain head, CE-001): producers emit it, the
-         * scheduler consumes it. Optional — absence means no upstream dependency.
-         */
-        dependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        /**
-         * Commands to run as a post-merge verification gate after this block's
-         * worktree branch is merged into the main tree. When present, these are
-         * preferred over `RemediationPlan.test_command` for the gate check.
-         */
-        targeted_commands: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        /**
-         * Repo-relative paths that this block's implementation is expected to touch.
-         * First-class and REQUIRED (an empty array is allowed, an omitted field is
-         * rejected by `validateRemediationBlock` — which the state LOAD gate
-         * delegates to, so the requirement holds on every path a block reaches a
-         * consumer through): the file-ownership-disjoint scheduler and
-         * `blockResolvedItemsOnCombinedFailure` both read it, so a block with no declared
-         * surface is a producer bug, not an implicit empty.
-         */
-        touched_files: z.ZodArray<z.ZodString, "many">;
-        /**
-         * 0-based foundations→consumers phase ordinal (auto-phasing, T3). Derived
-         * mechanically at promotion from the persisted phase cut (the module a block's
-         * obligations belong to). The host handoff treats it as a hard barrier: a
-         * block is never emitted until every lower-ordinal block is verified-complete,
-         * giving a per-phase whole-repo green checkpoint. Optional — absent (or all
-         * blocks sharing one ordinal) means a single phase, i.e. no barrier.
-         */
-        phase_ordinal: z.ZodOptional<z.ZodNumber>;
-        /**
-         * Whether the blocks sharing a co-file (same touched path) may still run in
-         * parallel because their edit regions are disjoint. Additive + optional:
-         * absence is equivalent to `false` (co-file blocks serialize by default), and
-         * a pre-existing block with no such key still validates. Deliberately a bare
-         * boolean — no WriteRegion / WriteAnchor / anchor apparatus lives on the block.
-         */
-        cofile_parallel_safe: z.ZodOptional<z.ZodBoolean>;
-        /**
-         * Deterministic advisory size derived from this block's unique physical
-         * files. It is metadata for the host, never a backend-fit claim.
-         */
-        token_estimate: z.ZodOptional<z.ZodNumber>;
-        /** Distinct instructions from the implementation node, carried into the bound prompt. */
-        implementation_context: z.ZodOptional<z.ZodObject<{
-            description: z.ZodOptional<z.ZodString>;
-            preconditions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            expected_changes: z.ZodOptional<z.ZodString>;
-            counterexamples: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                id: z.ZodString;
-                claim: z.ZodString;
-                reproduction_steps: z.ZodArray<z.ZodString, "many">;
-                expected: z.ZodString;
-                actual: z.ZodString;
-                violated_obligation_ids: z.ZodArray<z.ZodString, "many">;
-            }, "strip", z.ZodTypeAny, {
-                expected: string;
-                id: string;
-                claim: string;
-                reproduction_steps: string[];
-                actual: string;
-                violated_obligation_ids: string[];
-            }, {
-                expected: string;
-                id: string;
-                claim: string;
-                reproduction_steps: string[];
-                actual: string;
-                violated_obligation_ids: string[];
-            }>, "many">>;
-        }, "strict", z.ZodTypeAny, {
-            description?: string | undefined;
-            preconditions?: string[] | undefined;
-            expected_changes?: string | undefined;
-            counterexamples?: {
-                expected: string;
-                id: string;
-                claim: string;
-                reproduction_steps: string[];
-                actual: string;
-                violated_obligation_ids: string[];
-            }[] | undefined;
-        }, {
-            description?: string | undefined;
-            preconditions?: string[] | undefined;
-            expected_changes?: string | undefined;
-            counterexamples?: {
-                expected: string;
-                id: string;
-                claim: string;
-                reproduction_steps: string[];
-                actual: string;
-                violated_obligation_ids: string[];
-            }[] | undefined;
-        }>>;
-        /**
-         * The APPROVED finalized module contract(s) this block implements (the
-         * evidence-coverage entry in docs/backlog/open-bugs.md). Attached VERBATIM at promotion by resolving each DAG
-         * node's obligation-id slugs against `finalized_module_contracts`, and
-         * carried into the sha-bound dispatch prompt so a worker conforms to the
-         * approved interface instead of inventing a locally plausible one that
-         * contradicts it. Optional — a plan from outside the contract pipeline has
-         * no module contracts.
-         */
-        module_contracts: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            module: z.ZodString;
-            contract: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-        }, "strict", z.ZodTypeAny, {
-            module: string;
-            contract: Record<string, unknown>;
-        }, {
-            module: string;
-            contract: Record<string, unknown>;
-        }>, "many">>;
+    request: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+        source_paths: z.ZodArray<z.ZodString, "many">;
     }, "strict", z.ZodTypeAny, {
-        items: string[];
-        block_id: string;
-        parallel_safe: boolean;
-        touched_files: string[];
-        targeted_commands?: string[] | undefined;
-        token_estimate?: number | undefined;
-        dependencies?: string[] | undefined;
-        phase_ordinal?: number | undefined;
-        cofile_parallel_safe?: boolean | undefined;
-        implementation_context?: {
-            description?: string | undefined;
-            preconditions?: string[] | undefined;
-            expected_changes?: string | undefined;
-            counterexamples?: {
-                expected: string;
-                id: string;
-                claim: string;
-                reproduction_steps: string[];
-                actual: string;
-                violated_obligation_ids: string[];
-            }[] | undefined;
-        } | undefined;
-        module_contracts?: {
-            module: string;
-            contract: Record<string, unknown>;
-        }[] | undefined;
+        id: string;
+        text: string;
+        source_paths: string[];
     }, {
-        items: string[];
-        block_id: string;
-        parallel_safe: boolean;
-        touched_files: string[];
-        targeted_commands?: string[] | undefined;
-        token_estimate?: number | undefined;
-        dependencies?: string[] | undefined;
-        phase_ordinal?: number | undefined;
-        cofile_parallel_safe?: boolean | undefined;
-        implementation_context?: {
-            description?: string | undefined;
-            preconditions?: string[] | undefined;
-            expected_changes?: string | undefined;
-            counterexamples?: {
-                expected: string;
-                id: string;
-                claim: string;
-                reproduction_steps: string[];
-                actual: string;
-                violated_obligation_ids: string[];
-            }[] | undefined;
-        } | undefined;
-        module_contracts?: {
-            module: string;
-            contract: Record<string, unknown>;
-        }[] | undefined;
-    }>, "many">;
+        id: string;
+        text: string;
+        source_paths: string[];
+    }>>;
+    review_revision_sha256: z.ZodString;
+    review_counterexamples: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        claim: z.ZodString;
+        reproduction_steps: z.ZodArray<z.ZodString, "many">;
+        expected: z.ZodString;
+        actual: z.ZodString;
+        requirement_ids: z.ZodArray<z.ZodString, "many">;
+        unit_ids: z.ZodArray<z.ZodString, "many">;
+    }, "strict", z.ZodTypeAny, {
+        expected: string;
+        id: string;
+        unit_ids: string[];
+        claim: string;
+        requirement_ids: string[];
+        reproduction_steps: string[];
+        actual: string;
+    }, {
+        expected: string;
+        id: string;
+        unit_ids: string[];
+        claim: string;
+        requirement_ids: string[];
+        reproduction_steps: string[];
+        actual: string;
+    }>, "many">>;
     project_type: z.ZodString;
     test_command: z.ZodOptional<z.ZodString>;
     e2e_command: z.ZodOptional<z.ZodString>;
     test_command_source: z.ZodOptional<z.ZodEnum<["project_facts", "explicit"]>>;
     e2e_command_source: z.ZodOptional<z.ZodEnum<["project_facts", "explicit"]>>;
     candidate_closing_actions: z.ZodArray<z.ZodEnum<["commit", "push", "open-pr", "publish", "tag", "none", "custom"]>, "many">;
-    block_strategy: z.ZodOptional<z.ZodEnum<["test_graph", "git_cocommit", "file_overlap", "manual"]>>;
-    /**
-     * What the AUDIT read (`AuditRead`), stamped by the TOOL at plan application
-     * from the validated source findings report — never taken from the
-     * host-writable extracted plan. It is the `B` of the close phase's two-read
-     * evidence leg (`verifyHeadEvidenceAgainstFindings`). `null` and absent both
-     * mean "no commit is known" (absent only on a state persisted before the
-     * field existed, or a plan with no audit-side source); either way the leg
-     * withholds, and no other commit may stand in.
-     */
     audit_read: z.ZodOptional<z.ZodNullable<z.ZodObject<{
         commit: z.ZodString;
         dirty_paths: z.ZodArray<z.ZodString, "many">;
@@ -751,48 +574,76 @@ export declare const RemediationPlanSchema: z.ZodObject<{
             confirmation: "lead";
         } | undefined;
     }[];
+    plan_id: string;
+    objective: string;
+    non_goals: string[];
+    requirements: {
+        id: string;
+        description: string;
+        source_finding_ids: string[];
+        change_kind: "structural" | "behavior_change" | "addition";
+        assertions: {
+            kind: "positive" | "negative";
+            description: string;
+            scope_paths: string[];
+        }[];
+        inapplicable_reason?: string | undefined;
+    }[];
+    units: {
+        id: string;
+        read_paths: string[];
+        title: string;
+        description: string;
+        source_finding_ids: string[];
+        requirement_ids: string[];
+        dependencies: string[];
+        allowed_files: string[];
+        required_tests: string[];
+        affected_interfaces: {
+            name: string;
+            description: string;
+        }[];
+        addresses_counterexample_ids: string[];
+        phase_ordinal?: number | undefined;
+    }[];
+    source_dispositions: {
+        status: "refuted" | "already_fixed" | "deferred";
+        reason: string;
+        evidence: string[];
+        finding_id: string;
+    }[];
     candidate_closing_actions: ("push" | "custom" | "commit" | "none" | "open-pr" | "publish" | "tag")[];
     project_type: string;
-    blocks: {
-        items: string[];
-        block_id: string;
-        parallel_safe: boolean;
-        touched_files: string[];
-        targeted_commands?: string[] | undefined;
-        token_estimate?: number | undefined;
-        dependencies?: string[] | undefined;
-        phase_ordinal?: number | undefined;
-        cofile_parallel_safe?: boolean | undefined;
-        implementation_context?: {
-            description?: string | undefined;
-            preconditions?: string[] | undefined;
-            expected_changes?: string | undefined;
-            counterexamples?: {
-                expected: string;
-                id: string;
-                claim: string;
-                reproduction_steps: string[];
-                actual: string;
-                violated_obligation_ids: string[];
-            }[] | undefined;
-        } | undefined;
-        module_contracts?: {
-            module: string;
-            contract: Record<string, unknown>;
-        }[] | undefined;
+    review_revision_sha256: string;
+    review_counterexamples: {
+        expected: string;
+        id: string;
+        unit_ids: string[];
+        claim: string;
+        requirement_ids: string[];
+        reproduction_steps: string[];
+        actual: string;
     }[];
-    plan_id: string;
     audit_read?: {
         commit: string;
         dirty_paths: string[];
     } | null | undefined;
+    request_disposition?: {
+        status: "deferred" | "already_satisfied";
+        reason: string;
+        evidence: string[];
+    } | undefined;
+    request?: {
+        id: string;
+        text: string;
+        source_paths: string[];
+    } | undefined;
     source?: string | undefined;
     goal_id?: string | undefined;
     test_command?: string | undefined;
     e2e_command?: string | undefined;
     test_command_source?: "project_facts" | "explicit" | undefined;
     e2e_command_source?: "project_facts" | "explicit" | undefined;
-    block_strategy?: "file_overlap" | "manual" | "test_graph" | "git_cocommit" | undefined;
 }, {
     findings: {
         id: string;
@@ -858,50 +709,153 @@ export declare const RemediationPlanSchema: z.ZodObject<{
             confirmation: "lead";
         } | undefined;
     }[];
-    candidate_closing_actions: ("push" | "custom" | "commit" | "none" | "open-pr" | "publish" | "tag")[];
-    project_type: string;
-    blocks: {
-        items: string[];
-        block_id: string;
-        parallel_safe: boolean;
-        touched_files: string[];
-        targeted_commands?: string[] | undefined;
-        token_estimate?: number | undefined;
-        dependencies?: string[] | undefined;
+    plan_id: string;
+    objective: string;
+    non_goals: string[];
+    requirements: {
+        id: string;
+        description: string;
+        source_finding_ids: string[];
+        change_kind: "structural" | "behavior_change" | "addition";
+        assertions: {
+            kind: "positive" | "negative";
+            description: string;
+            scope_paths: string[];
+        }[];
+        inapplicable_reason?: string | undefined;
+    }[];
+    units: {
+        id: string;
+        read_paths: string[];
+        title: string;
+        description: string;
+        source_finding_ids: string[];
+        requirement_ids: string[];
+        dependencies: string[];
+        allowed_files: string[];
+        required_tests: string[];
+        addresses_counterexample_ids: string[];
         phase_ordinal?: number | undefined;
-        cofile_parallel_safe?: boolean | undefined;
-        implementation_context?: {
-            description?: string | undefined;
-            preconditions?: string[] | undefined;
-            expected_changes?: string | undefined;
-            counterexamples?: {
-                expected: string;
-                id: string;
-                claim: string;
-                reproduction_steps: string[];
-                actual: string;
-                violated_obligation_ids: string[];
-            }[] | undefined;
-        } | undefined;
-        module_contracts?: {
-            module: string;
-            contract: Record<string, unknown>;
+        affected_interfaces?: {
+            name: string;
+            description: string;
         }[] | undefined;
     }[];
-    plan_id: string;
+    candidate_closing_actions: ("push" | "custom" | "commit" | "none" | "open-pr" | "publish" | "tag")[];
+    project_type: string;
+    review_revision_sha256: string;
     audit_read?: {
         commit: string;
         dirty_paths: string[];
     } | null | undefined;
+    source_dispositions?: {
+        status: "refuted" | "already_fixed" | "deferred";
+        reason: string;
+        evidence: string[];
+        finding_id: string;
+    }[] | undefined;
+    request_disposition?: {
+        status: "deferred" | "already_satisfied";
+        reason: string;
+        evidence: string[];
+    } | undefined;
+    request?: {
+        id: string;
+        text: string;
+        source_paths: string[];
+    } | undefined;
     source?: string | undefined;
     goal_id?: string | undefined;
+    review_counterexamples?: {
+        expected: string;
+        id: string;
+        unit_ids: string[];
+        claim: string;
+        requirement_ids: string[];
+        reproduction_steps: string[];
+        actual: string;
+    }[] | undefined;
     test_command?: string | undefined;
     e2e_command?: string | undefined;
     test_command_source?: "project_facts" | "explicit" | undefined;
     e2e_command_source?: "project_facts" | "explicit" | undefined;
-    block_strategy?: "file_overlap" | "manual" | "test_graph" | "git_cocommit" | undefined;
 }>;
 export type RemediationPlan = z.infer<typeof RemediationPlanSchema>;
+export declare const SourceVerificationSchema: z.ZodObject<{
+    disposition_override: z.ZodOptional<z.ZodEnum<["resolved", "resolved_no_change", "ignored", "deemed_inappropriate", "abandoned", "verified_already_fixed", "refuted"]>>;
+    evidence: z.ZodOptional<z.ZodObject<{
+        file: z.ZodString;
+        line: z.ZodString;
+        mechanism: z.ZodEnum<["red_green_test", "build_lint_gate", "read_at_head_verification", "read_at_head_refutation"]>;
+        mechanism_detail: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        line: string;
+        file: string;
+        mechanism: "red_green_test" | "build_lint_gate" | "read_at_head_verification" | "read_at_head_refutation";
+        mechanism_detail?: string | undefined;
+    }, {
+        line: string;
+        file: string;
+        mechanism: "red_green_test" | "build_lint_gate" | "read_at_head_verification" | "read_at_head_refutation";
+        mechanism_detail?: string | undefined;
+    }>>;
+    recorded_by_module: z.ZodOptional<z.ZodString>;
+    mechanical_verification: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<["verified_mechanically", "lead_persists", "skipped"]>;
+        analyzer_id: z.ZodString;
+        reason: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        status: "verified_mechanically" | "lead_persists" | "skipped";
+        analyzer_id: string;
+        reason?: string | undefined;
+    }, {
+        status: "verified_mechanically" | "lead_persists" | "skipped";
+        analyzer_id: string;
+        reason?: string | undefined;
+    }>>;
+    review_revision_sha256: z.ZodOptional<z.ZodString>;
+    source_sha256: z.ZodOptional<z.ZodString>;
+    head_commit: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, "strict", z.ZodTypeAny, {
+    evidence?: {
+        line: string;
+        file: string;
+        mechanism: "red_green_test" | "build_lint_gate" | "read_at_head_verification" | "read_at_head_refutation";
+        mechanism_detail?: string | undefined;
+    } | undefined;
+    mechanical_verification?: {
+        status: "verified_mechanically" | "lead_persists" | "skipped";
+        analyzer_id: string;
+        reason?: string | undefined;
+    } | undefined;
+    recorded_by_module?: string | undefined;
+    source_sha256?: string | undefined;
+    review_revision_sha256?: string | undefined;
+    disposition_override?: "refuted" | "resolved" | "ignored" | "verified_already_fixed" | "resolved_no_change" | "deemed_inappropriate" | "abandoned" | undefined;
+    head_commit?: string | null | undefined;
+}, {
+    evidence?: {
+        line: string;
+        file: string;
+        mechanism: "red_green_test" | "build_lint_gate" | "read_at_head_verification" | "read_at_head_refutation";
+        mechanism_detail?: string | undefined;
+    } | undefined;
+    mechanical_verification?: {
+        status: "verified_mechanically" | "lead_persists" | "skipped";
+        analyzer_id: string;
+        reason?: string | undefined;
+    } | undefined;
+    recorded_by_module?: string | undefined;
+    source_sha256?: string | undefined;
+    review_revision_sha256?: string | undefined;
+    disposition_override?: "refuted" | "resolved" | "ignored" | "verified_already_fixed" | "resolved_no_change" | "deemed_inappropriate" | "abandoned" | undefined;
+    head_commit?: string | null | undefined;
+}>;
+export type SourceVerification = z.infer<typeof SourceVerificationSchema>;
+export interface FindingDisposition {
+    status: "ignored" | "declined";
+    reason: string;
+}
 /**
  * Tool-owned binding for one emitted host workload. The host may write result
  * files, but it must not be able to rewrite the workload and then make the
@@ -925,29 +879,7 @@ export declare const ConformanceReviewBindingSchema: z.ZodObject<{
     checkpoint_sha256?: string | undefined;
 }>;
 export type ConformanceReviewBinding = z.infer<typeof ConformanceReviewBindingSchema>;
-export declare const RemediationHostHandoffRecordSchema: z.ZodDiscriminatedUnion<"contract_version", [z.ZodObject<{
-    run_id: z.ZodString;
-    baseline_commit: z.ZodString;
-    workload_sha256: z.ZodString;
-    /** Enforces persistence of the tool-minted required-review snapshot alongside this handoff. */
-    conformance_policy_sha256: z.ZodOptional<z.ZodString>;
-    work_item_ids: z.ZodArray<z.ZodString, "many">;
-    contract_version: z.ZodLiteral<"remediation-host-handoff-record/v1alpha1">;
-}, "strict", z.ZodTypeAny, {
-    run_id: string;
-    contract_version: "remediation-host-handoff-record/v1alpha1";
-    baseline_commit: string;
-    workload_sha256: string;
-    work_item_ids: string[];
-    conformance_policy_sha256?: string | undefined;
-}, {
-    run_id: string;
-    contract_version: "remediation-host-handoff-record/v1alpha1";
-    baseline_commit: string;
-    workload_sha256: string;
-    work_item_ids: string[];
-    conformance_policy_sha256?: string | undefined;
-}>, z.ZodObject<{
+export declare const RemediationHostHandoffRecordSchema: z.ZodObject<{
     run_id: z.ZodString;
     baseline_commit: z.ZodString;
     workload_sha256: z.ZodString;
@@ -959,34 +891,34 @@ export declare const RemediationHostHandoffRecordSchema: z.ZodDiscriminatedUnion
 }, "strict", z.ZodTypeAny, {
     run_id: string;
     contract_version: "remediation-host-handoff-record/v1alpha2";
+    scope_semantics: "explicit-directory-markers/v1";
     baseline_commit: string;
     workload_sha256: string;
     work_item_ids: string[];
-    scope_semantics: "explicit-directory-markers/v1";
     conformance_policy_sha256?: string | undefined;
 }, {
     run_id: string;
     contract_version: "remediation-host-handoff-record/v1alpha2";
+    scope_semantics: "explicit-directory-markers/v1";
     baseline_commit: string;
     workload_sha256: string;
     work_item_ids: string[];
-    scope_semantics: "explicit-directory-markers/v1";
     conformance_policy_sha256?: string | undefined;
-}>]>;
+}>;
 export type RemediationHostHandoffRecord = z.infer<typeof RemediationHostHandoffRecordSchema>;
 export declare const ClarificationRequestSchema: z.ZodObject<{
-    finding_id: z.ZodString;
+    unit_id: z.ZodString;
     category: z.ZodEnum<["public_contract", "behavioral_semantics", "scope_of_fix", "dependency_introduction", "compatibility_policy", "intent_vs_symptom", "issue_appropriateness"]>;
     description: z.ZodString;
     options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strict", z.ZodTypeAny, {
+    unit_id: string;
     category: "public_contract" | "behavioral_semantics" | "scope_of_fix" | "dependency_introduction" | "compatibility_policy" | "intent_vs_symptom" | "issue_appropriateness";
-    finding_id: string;
     description: string;
     options?: string[] | undefined;
 }, {
+    unit_id: string;
     category: "public_contract" | "behavioral_semantics" | "scope_of_fix" | "dependency_introduction" | "compatibility_policy" | "intent_vs_symptom" | "issue_appropriateness";
-    finding_id: string;
     description: string;
     options?: string[] | undefined;
 }>;
@@ -999,13 +931,16 @@ export type ClarificationRequest = z.infer<typeof ClarificationRequestSchema>;
  * others. A separate run-level question list used to be a second copy; clearing
  * it after a partial answer left the unanswered items with no question to show.
  */
-export type ClarificationQuestion = Omit<ClarificationRequest, "finding_id">;
+export type ClarificationQuestion = Omit<ClarificationRequest, "unit_id">;
 /** The canonical clarification categories (single-sourced from the schema). */
 export declare const CLARIFICATION_CATEGORIES: ["public_contract", "behavioral_semantics", "scope_of_fix", "dependency_introduction", "compatibility_policy", "intent_vs_symptom", "issue_appropriateness"];
 export type ClarificationCategory = ClarificationRequest["category"];
 /** Narrow an arbitrary value to a canonical clarification category. */
 export declare function isClarificationCategory(value: unknown): value is ClarificationCategory;
 export declare const ClosingActionPreviewSchema: z.ZodObject<{
+    /** Approval is for this action, never an interchangeable close label. */
+    action: z.ZodEnum<["commit", "push", "open-pr", "publish", "tag", "none", "custom"]>;
+    custom_command: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     /** Repo-relative paths that would be staged for the commit. */
     files: z.ZodArray<z.ZodString, "many">;
     /** Generated commit message derived from item summaries / finding titles. */
@@ -1020,11 +955,15 @@ export declare const ClosingActionPreviewSchema: z.ZodObject<{
     leftover_files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strict", z.ZodTypeAny, {
     files: string[];
+    action: "push" | "custom" | "commit" | "none" | "open-pr" | "publish" | "tag";
     commit_message: string;
+    custom_command?: string[] | undefined;
     leftover_files?: string[] | undefined;
 }, {
     files: string[];
+    action: "push" | "custom" | "commit" | "none" | "open-pr" | "publish" | "tag";
     commit_message: string;
+    custom_command?: string[] | undefined;
     leftover_files?: string[] | undefined;
 }>;
 export declare const ClosingPlanSchema: z.ZodObject<{
@@ -1042,6 +981,9 @@ export declare const ClosingPlanSchema: z.ZodObject<{
      * the host can present them to the user. Cleared once the action executes.
      */
     closing_action_preview: z.ZodOptional<z.ZodObject<{
+        /** Approval is for this action, never an interchangeable close label. */
+        action: z.ZodEnum<["commit", "push", "open-pr", "publish", "tag", "none", "custom"]>;
+        custom_command: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         /** Repo-relative paths that would be staged for the commit. */
         files: z.ZodArray<z.ZodString, "many">;
         /** Generated commit message derived from item summaries / finding titles. */
@@ -1056,11 +998,15 @@ export declare const ClosingPlanSchema: z.ZodObject<{
         leftover_files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, "strict", z.ZodTypeAny, {
         files: string[];
+        action: "push" | "custom" | "commit" | "none" | "open-pr" | "publish" | "tag";
         commit_message: string;
+        custom_command?: string[] | undefined;
         leftover_files?: string[] | undefined;
     }, {
         files: string[];
+        action: "push" | "custom" | "commit" | "none" | "open-pr" | "publish" | "tag";
         commit_message: string;
+        custom_command?: string[] | undefined;
         leftover_files?: string[] | undefined;
     }>>;
 }, "strict", z.ZodTypeAny, {
@@ -1069,7 +1015,9 @@ export declare const ClosingPlanSchema: z.ZodObject<{
     pre_authorized?: boolean | undefined;
     closing_action_preview?: {
         files: string[];
+        action: "push" | "custom" | "commit" | "none" | "open-pr" | "publish" | "tag";
         commit_message: string;
+        custom_command?: string[] | undefined;
         leftover_files?: string[] | undefined;
     } | undefined;
 }, {
@@ -1078,7 +1026,9 @@ export declare const ClosingPlanSchema: z.ZodObject<{
     pre_authorized?: boolean | undefined;
     closing_action_preview?: {
         files: string[];
+        action: "push" | "custom" | "commit" | "none" | "open-pr" | "publish" | "tag";
         commit_message: string;
+        custom_command?: string[] | undefined;
         leftover_files?: string[] | undefined;
     } | undefined;
 }>;
@@ -1087,7 +1037,7 @@ export interface CoverageLedgerEntry {
     finding_id: string;
     title?: string;
     disposition: "planned" | "folded_into" | "dropped_no_evidence" | "dropped_by_checkpoint" | "dropped_phantom_paths" | "declined_by_review";
-    block_id?: string;
+    unit_ids?: string[];
     folded_into?: string;
     rationale?: string;
     /** Phantom (non-existent) cited paths the grounding pass stripped. */
@@ -1128,7 +1078,7 @@ export interface CoverageLedger {
  * `failed` covers blocked and force-closed non-terminal items, `skipped`
  * covers deemed-inappropriate items, `ignored` covers user-ignored items.
  */
-export type RemediationOutcomeFinalStatus = "fixed" | "failed" | "ignored" | "skipped";
+export type RemediationOutcomeFinalStatus = "fixed" | "failed" | "ignored" | "skipped" | "pending" | "deferred";
 /**
  * One fully self-describing entry per finding in `remediation-outcomes.json`.
  * Extends the shared per-finding outcome so the file is retryable on its own:
@@ -1144,10 +1094,9 @@ export type RemediationOutcomeFinalStatus = "fixed" | "failed" | "ignored" | "sk
 export interface RemediationOutcomeItem extends RemediationOutcome {
     /** Full original Finding payload (the shared `Finding` type, verbatim). */
     finding: Finding;
-    /** Owning block id (`RemediationBlock.block_id`). */
-    block_id: RemediationBlock["block_id"];
-    /** The owning block's dependency block ids (`RemediationBlock.dependencies`). */
-    block_dependencies: string[];
+    /** Every execution unit addressing this original source finding. */
+    unit_ids: string[];
+    unit_dependencies: string[];
     /** Retry-oriented final status (see `RemediationOutcomeFinalStatus`). */
     final_status: RemediationOutcomeFinalStatus;
     /**
@@ -1173,9 +1122,8 @@ export interface OutcomeCoverageLedger extends Omit<CoverageLedger, "entries"> {
 }
 export type { PerFindingDisposition } from "./disposition.js";
 export interface RemediationItemState {
-    finding_id: string;
+    unit_id: string;
     status: RemediationItemStatus;
-    block_id: string;
     last_successful_step?: string;
     failure_reason?: string;
     /** Prompt-bound evidence supplied for a verified no-change host outcome. */
@@ -1205,11 +1153,6 @@ export interface RemediationItemState {
     host_landed_commit?: string;
     /** Repo-relative, path-sorted files the landed commit changed (see above). */
     host_landed_files?: string[];
-    /**
-     * Item C — close-gate mechanical re-verify verdict for an analyzer-born
-     * finding (set by `verifyAnalyzerLeads`; copied into the outcomes contract).
-     */
-    mechanical_verification?: MechanicalVerification;
     /** Times this item was sent back for rework via triage (Phase 7B outcomes). */
     rework_count?: number;
     /** ISO-8601 timestamp when this item first left pending. */
@@ -1237,46 +1180,5 @@ export interface RemediationItemState {
      * the cap is hit) instead of re-dispatching the same worker indefinitely.
      */
     incomplete_coverage_attempts?: number;
-    /**
-     * CDC-25/CDC-26 — SOURCE-SIDE SHAPE. The per-finding verification-evidence
-     * triple (file/line/mechanism) a producing module RECORDS onto this item at
-     * its OWN phase (INV-COVERAGE's "evidence producer" half) before the single
-     * run-terminal `runClosePhase` PERSISTS it (INV-ISC-EVIDENCE-EMITTED). The
-     * producer is `verifyHeadEvidenceAgainstFindings`
-     * (`src/remediate/phases/closeVerifyHeadEvidence.ts`), whose own reads of the
-     * finding's cited location — at the audit's commit and at HEAD — are what the
-     * triple names. A runtime data flow through this already-existing state item,
-     * not a build-phase dependency: no cross-phase artifact token is minted for
-     * it.
-     * This field lives here — inside item-status-partition-and-close's own
-     * file_scope — and is therefore owned BY SCOPE, not by a clause 1(c)
-     * declaration (that channel is only for a file outside every module's
-     * file_scope, as `src/shared/types/remediationOutcome.ts` needed one for the
-     * matching widened record shape). No other module edits this file.
-     */
-    evidence?: Evidence;
-    /**
-     * CDC-25 — which module recorded {@link evidence} (and, where set,
-     * {@link disposition_override}) for this finding. Carried byte-exact into the
-     * emitted outcome record's `recorded_by_module` (the ATTRIBUTION ROUND-TRIP)
-     * so the 26 INV-COVERAGE joins' condition (3) can still tell which module
-     * closed which id — the writer must never re-derive this or drop it.
-     */
-    recorded_by_module?: string;
-    /**
-     * CDC-25 — a producing module's own-phase determination that this finding's
-     * true disposition is `verified_already_fixed` or `refuted` rather than the
-     * disposition ordinarily derived from {@link status} alone.
-     * `RemediationItemStatus` stays a closed 12-member enum with no
-     * `verified_already_fixed`/`refuted` values of its own; the two new
-     * `PerFindingDisposition` members are reached ONLY through this explicit
-     * override (see `resolveDisposition` in `itemStatus.ts`), and only honoured
-     * by the writer when this item's {@link status} is terminal and its
-     * {@link evidence} triple is complete (INV-ISC-EVIDENCE-EMITTED) — an
-     * incomplete triple makes the writer refuse the override and fall back to a
-     * non-terminal, force-closed outcome instead of a green close on assertion
-     * alone.
-     */
-    disposition_override?: PerFindingDisposition;
 }
 //# sourceMappingURL=types.d.ts.map