immune-brain 5.1.0 → 5.1.1

package/plugins/immune-brain/dist/claude/mcp-server.mjs

@@ -39,7 +39,7 @@ function probeHost(env = process.env, platform = process.platform, hostVersion)
 }
 
 // plugins/immune-brain/runtime/plugin_version.ts
-var PLUGIN_VERSION = "5.1.0";
+var PLUGIN_VERSION = "5.1.1";
 
 // plugins/immune-brain/runtime/claude/interaction.ts
 import { createHash, randomUUID } from "node:crypto";
@@ -48,7 +48,8 @@ var PRIVILEGED_OPERATIONS = [
   "request_authorization",
   "approve_breaking_intent_revision",
   "stop",
-  "start_unattended_batch"
+  "start_unattended_batch",
+  "retire_stale_batch"
 ];
 var RECOVERY_ACTIONS = {
   interaction_not_opened: "retry through a fresh native gate in the current Host",
@@ -732,6 +733,7 @@ var KERNEL_DB_RELATIVE = ".imm/state/kernel.sqlite";
 var KERNEL_STORE_SCHEMA_VERSION = 1;
 var FILE_STORE_CLAIM_RELATIVE = ".imm/state/active-claim.json";
 var FILE_STORE_WORKSPACE_RELATIVE = ".imm/state/workspace.json";
+var FILE_STORE_TASKS_RELATIVE = ".imm/state/tasks";
 var FILE_STORE_TRANSACTIONS_RELATIVE = ".imm/state/transactions";
 var BATCH_STATE_RELATIVE = ".imm/state/batches";
 function stateDatabasePath() {
@@ -790,6 +792,25 @@ function batchCommitEvidencePath(batchId, taskId) {
   validateTaskId(taskId);
   return `${BATCH_STATE_RELATIVE}/commits/${batchId}-${taskId}.json`;
 }
+function entryStatus(root, relativePath) {
+  const candidate = resolve(root, relativePath);
+  let stat;
+  try {
+    stat = lstatSync2(candidate);
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT" || code === "ENOTDIR")
+      return "absent";
+    return "other";
+  }
+  if (stat.isSymbolicLink())
+    return "symlink";
+  if (stat.isFile())
+    return "file";
+  if (stat.isDirectory())
+    return "directory";
+  return "other";
+}
 function listEntries(root, relativePath) {
   const candidate = resolve(root, relativePath);
   try {
@@ -798,6 +819,44 @@ function listEntries(root, relativePath) {
     return null;
   }
 }
+function readSmallFile(root, relativePath) {
+  const candidate = resolve(root, relativePath);
+  try {
+    const fd = openSync2(candidate, FS_CONSTANTS.O_RDONLY | (FS_CONSTANTS.O_NOFOLLOW ?? 0));
+    try {
+      const stat = fstatSync2(fd);
+      if (stat.size > 4 * 1024 * 1024)
+        throw new Error("file exceeds the inspection read bound");
+      return readFileSync(fd, "utf8");
+    } finally {
+      closeSync2(fd);
+    }
+  } catch {
+    return null;
+  }
+}
+function inspectRetiredStateResidue(root) {
+  const tasksStatus = entryStatus(root, FILE_STORE_TASKS_RELATIVE);
+  if (tasksStatus !== "absent" && tasksStatus !== "directory")
+    throw new Error(`${FILE_STORE_TASKS_RELATIVE} is not a regular directory`);
+  const entries = tasksStatus === "absent" ? [] : listEntries(root, FILE_STORE_TASKS_RELATIVE);
+  if (entries === null)
+    throw new Error(`${FILE_STORE_TASKS_RELATIVE} is unreadable`);
+  const workspaceStatus = entryStatus(root, FILE_STORE_WORKSPACE_RELATIVE);
+  let owner = null;
+  if (workspaceStatus !== "absent") {
+    if (workspaceStatus !== "file")
+      throw new Error(`${FILE_STORE_WORKSPACE_RELATIVE} is not a regular file`);
+    const content = readSmallFile(root, FILE_STORE_WORKSPACE_RELATIVE);
+    if (content === null)
+      throw new Error(`${FILE_STORE_WORKSPACE_RELATIVE} is unreadable`);
+    const raw = JSON.parse(content);
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw) || raw.contract !== "assurance_kernel/workspace/v1" || raw.current_working !== null && (typeof raw.current_working !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(raw.current_working)) || raw.current_working === null && Object.keys(raw).some((key) => !["contract", "current_working"].includes(key)))
+      throw new Error(`${FILE_STORE_WORKSPACE_RELATIVE} has invalid workspace content`);
+    owner = raw.current_working;
+  }
+  return { task_entries: entries, workspace_owner: owner };
+}
 
 // plugins/immune-brain/runtime/kernel/sqlite_store.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
@@ -2144,6 +2203,7 @@ function parseApprovalV2(value, index, violations, allowReviewRevision = false)
     "actor_id",
     "summary",
     "advisory_findings",
+    "reviewer_verdict_sha256",
     ...allowReviewRevision ? ["review_revision"] : []
   ], `record.approvals[${index}]`, violations);
   const intentContentHash = stringAt(item.intent_content_hash, `record.approvals[${index}].intent_content_hash`, violations);
@@ -2164,7 +2224,8 @@ function parseApprovalV2(value, index, violations, allowReviewRevision = false)
     ...allowReviewRevision && item.review_revision !== undefined ? { review_revision: parseReviewRevisionIdentity(item.review_revision, `record.approvals[${index}].review_revision`, violations) } : {},
     ...item.advisory_findings !== undefined ? {
       advisory_findings: arrayAt(item.advisory_findings, `record.approvals[${index}].advisory_findings`, violations).map((entry, advisoryIndex) => parseAdvisoryFinding(entry, `record.approvals[${index}].advisory_findings[${advisoryIndex}]`, violations))
-    } : {}
+    } : {},
+    ...item.reviewer_verdict_sha256 !== undefined ? { reviewer_verdict_sha256: stringAt(item.reviewer_verdict_sha256, `record.approvals[${index}].reviewer_verdict_sha256`, violations) } : {}
   };
 }
 function parseAdvisoryFinding(value, path, violations) {
@@ -2211,6 +2272,7 @@ function parseAttestationV3(value, index, acceptanceIds, violations, allowReview
     "summary",
     "acceptance_results",
     "advisory_findings",
+    "reviewer_verdict_sha256",
     ...allowReviewRevision ? ["review_revision"] : []
   ], path, violations);
   const kind = enumAt(item.kind, APPROVAL_KINDS, `${path}.kind`, violations);
@@ -2248,6 +2310,11 @@ function parseAttestationV3(value, index, acceptanceIds, violations, allowReview
   const advisoryFindings = item.advisory_findings === undefined ? undefined : arrayAt(item.advisory_findings, `${path}.advisory_findings`, violations).map((entry, advisoryIndex) => parseAdvisoryFinding(entry, `${path}.advisory_findings[${advisoryIndex}]`, violations));
   if (advisoryFindings !== undefined && kind !== "review")
     violations.push(`${path}.advisory_findings is only valid on review attestations`);
+  const reviewerVerdictSha256 = item.reviewer_verdict_sha256 === undefined ? undefined : stringAt(item.reviewer_verdict_sha256, `${path}.reviewer_verdict_sha256`, violations);
+  if (reviewerVerdictSha256 !== undefined && kind !== "review")
+    violations.push(`${path}.reviewer_verdict_sha256 is only valid on review attestations`);
+  if (reviewerVerdictSha256 !== undefined && !SHA256_HEX.test(reviewerVerdictSha256))
+    violations.push(`${path}.reviewer_verdict_sha256 must be sha256:<64 hex>`);
   return {
     id: stringAt(item.id, `${path}.id`, violations),
     kind,
@@ -2259,7 +2326,8 @@ function parseAttestationV3(value, index, acceptanceIds, violations, allowReview
     summary: stringAt(item.summary, `${path}.summary`, violations),
     acceptance_results: acceptanceResults,
     ...reviewRevision ? { review_revision: reviewRevision } : {},
-    ...advisoryFindings !== undefined ? { advisory_findings: advisoryFindings } : {}
+    ...advisoryFindings !== undefined ? { advisory_findings: advisoryFindings } : {},
+    ...reviewerVerdictSha256 !== undefined ? { reviewer_verdict_sha256: reviewerVerdictSha256 } : {}
   };
 }
 function parseTaskRecordAtVersion(raw, version) {
@@ -2643,6 +2711,11 @@ function readBoundActiveSpec(root, intent, required = false) {
     throw error;
   }
 }
+function assertValidSpecBinding(intent) {
+  const binding = inspectSpecBinding(intent);
+  if (!binding.ok)
+    throw new KernelInvariantError([binding.message]);
+}
 function inspectSpecBinding(intent) {
   const active = intent.scope_hint.filter((path) => ACTIVE_SPEC_RE.test(path));
   const archived = intent.scope_hint.filter((path) => ARCHIVED_SPEC_RE.test(path));
@@ -2696,6 +2769,8 @@ function asTaskDiffSnapshot(value) {
   return { diff_hash: value.diff_hash, changed_paths: value.changed_paths };
 }
 function resolveProjectedRisk(intent, changedPaths = []) {
+  if (!inspectSpecBinding(intent).ok)
+    return classifyTaskRisk(changedPaths, intent.risk);
   const excluded = ownSidecarPaths(intent);
   return classifyTaskRisk(changedPaths.filter((path) => !excluded.has(path)), intent.risk);
 }
@@ -2754,6 +2829,27 @@ function completionDecision(intent, record, currentDiffHash, currentIntentConten
   };
 }
 function projectTask(intent, record, currentDiffHash, currentIntentContentHash, changedPaths = []) {
+  if (record.lifecycle === "active" && !inspectSpecBinding(intent).ok) {
+    assertKernelInvariantsV3(intent, record);
+    return {
+      contract: "assurance_kernel/projection/v3",
+      task_id: record.task_id,
+      intent_revision: intent.revision,
+      lifecycle: record.lifecycle,
+      artifact_state: record.artifact_state,
+      blocked: true,
+      next_obligation: "revise_intent",
+      complete: false,
+      fresh_acceptance_ids: [],
+      missing_acceptance_ids: intent.acceptance.map((item) => item.id),
+      stale_attestation_ids: record.attestations.map((item) => item.id),
+      missing_approval_kinds: REQUIRED_ATTESTATIONS[resolveProjectedRisk(intent, changedPaths)],
+      blocking_finding_ids: record.findings.filter((item) => item.kind === "blocking" && item.status !== "resolved").map((item) => item.id),
+      unresolved_user_decision_ids: record.findings.filter((item) => item.kind === "unresolved_user_decision" && item.status === "open").map((item) => item.id),
+      replan_required_ids: record.findings.filter((item) => item.kind === "replan_required" && item.status === "open").map((item) => item.id),
+      independence_violations: []
+    };
+  }
   const decision = completionDecision(intent, record, currentDiffHash, currentIntentContentHash, changedPaths);
   const blocked = decision.blocking_finding_ids.length > 0 || decision.unresolved_user_decision_ids.length > 0 || decision.replan_required_ids.length > 0 || decision.independence_violations.length > 0;
   let nextObligation = "none";
@@ -3044,27 +3140,37 @@ function reduceTask(recordRaw, actionRaw, authorityAudit = null, changedPaths) {
       const reviewRevision = approval.review_revision;
       if (reviewRevision && approval.kind !== "review")
         throw new KernelInvariantError(["review_revision is only valid on review approvals"]);
+      if (approval.reviewer_verdict_sha256 && approval.kind !== "review")
+        throw new KernelInvariantError(["reviewer_verdict_sha256 is only valid on review approvals"]);
       if (approval.kind === "review") {
         if (!reviewRevision)
           throw new KernelInvariantError(["v4 review approval requires review_revision"]);
         if (reviewRevision.base_head !== record.git_base_head)
           throw new KernelInvariantError(["review_revision.base_head must equal the Enrollment git_base_head"]);
       }
-      const { review_revision: storedReviewRevision, ...approvalWithoutRevision } = approval;
+      const {
+        review_revision: storedReviewRevision,
+        advisory_findings: storedAdvisoryFindings,
+        reviewer_verdict_sha256: storedReviewerDigest,
+        ...approvalWithoutExtras
+      } = approval;
       record.attestations.push({
-        ...approvalWithoutRevision,
+        ...approvalWithoutExtras,
         acceptance_results: approval.kind === "qa" ? record.intent_snapshot.acceptance.map((item) => ({
           acceptance_id: item.id,
           status: "passed",
           summary: `host-attested QA: ${approval.summary}`
         })) : [],
-        ...storedReviewRevision ? { review_revision: storedReviewRevision } : {}
+        ...storedReviewRevision ? { review_revision: storedReviewRevision } : {},
+        ...storedAdvisoryFindings ? { advisory_findings: storedAdvisoryFindings } : {},
+        ...storedReviewerDigest ? { reviewer_verdict_sha256: storedReviewerDigest } : {}
       });
       appendHistory(record, action, from, approval.id, authorityAudit);
       break;
     }
     case "revise_intent":
     case "approve_breaking_intent_revision": {
+      assertValidSpecBinding(action.next_intent);
       if (record.lifecycle !== "active")
         throw new KernelInvariantError([
           `cannot revise intent while lifecycle is ${record.lifecycle}`
@@ -3544,10 +3650,16 @@ function isRetiredFileProvablySuperseded(path, db, taskId) {
 }
 function assertNoRetiredFileStore(root, db, taskId) {
   const canonical = canonicalRoot2(root);
+  let residue;
+  try {
+    residue = inspectRetiredStateResidue(canonical);
+  } catch (error) {
+    throw new KernelStoreSecurityError(`retired file-store residue is invalid: ${error instanceof Error ? error.message : String(error)}`);
+  }
   const retired = [
     [".imm/tasks", "pre-cutover task store"],
     [".imm/workspace.json", "pre-cutover workspace owner"],
-    [".imm/state/tasks", "task records"]
+    ...residue.task_entries.length > 0 ? [[".imm/state/tasks", "task records"]] : []
   ];
   for (const [path, label] of retired) {
     if (existsSync2(resolve5(canonical, path)))
@@ -3559,6 +3671,8 @@ function assertNoRetiredFileStore(root, db, taskId) {
   ];
   for (const [path, label] of derived) {
     const full = resolve5(canonical, path);
+    if (path === FILE_STORE_WORKSPACE_RELATIVE && residue.workspace_owner === null)
+      continue;
     if (!existsSync2(full))
       continue;
     if (db === undefined || typeof taskId !== "string" || taskId.length === 0)
@@ -3575,10 +3689,16 @@ function assertNoRetiredFileStore(root, db, taskId) {
 }
 function retiredFileStoreConflict(root, db, taskId) {
   const canonical = canonicalRoot2(root);
+  let residue;
+  try {
+    residue = inspectRetiredStateResidue(canonical);
+  } catch (error) {
+    return `retired file-store residue is invalid: ${error instanceof Error ? error.message : String(error)}`;
+  }
   const authority = [
     [".imm/tasks", "pre-cutover task store"],
     [".imm/workspace.json", "pre-cutover workspace owner"],
-    [".imm/state/tasks", "task records"]
+    ...residue.task_entries.length > 0 ? [[".imm/state/tasks", "task records"]] : []
   ];
   for (const [path, label] of authority)
     if (existsSync2(resolve5(canonical, path)))
@@ -3590,7 +3710,7 @@ function retiredFileStoreConflict(root, db, taskId) {
       [FILE_STORE_WORKSPACE_RELATIVE, "workspace owner"]
     ];
     for (const [path, label] of derived)
-      if (existsSync2(resolve5(canonical, path)))
+      if ((path !== FILE_STORE_WORKSPACE_RELATIVE || residue.workspace_owner !== null) && existsSync2(resolve5(canonical, path)))
         return `retired file-store authority is present (${label}: ${path}); import it with the supported migration before mutating this worktree`;
   }
   const transactions = resolve5(canonical, FILE_STORE_TRANSACTIONS_RELATIVE);
@@ -5222,7 +5342,7 @@ function projectFromRecord(record, recordRevision, workspaceRevision, snapshot)
     independence_violations: decision.independence_violations,
     open_user_decision_count: openUserDecisionCount,
     completion_ready: decision.complete,
-    authorization: deriveAssuranceAuthorization({
+    authorization: !inspectSpecBinding(intent).ok ? { state: "none", blocked: "invalid Spec binding requires a valid breaking intent revision" } : deriveAssuranceAuthorization({
       next_obligation: decision.next_obligation,
       open_user_decision_count: openUserDecisionCount
     })
@@ -5555,6 +5675,7 @@ function createCanaryApplication(registry) {
       const current = readTaskRecordRaw(input.root, input.task_id);
       if (!current.record)
         throw new KernelInvariantError([`task ${input.task_id} has no TaskRecord v3`]);
+      assertValidSpecBinding(current.record.intent_snapshot);
       const workspace = readWorkspaceStateRaw(input.root);
       if (current.record.artifact_state === "frozen")
         return { revision: current.revision, record: current.record, workspace };
@@ -5636,7 +5757,11 @@ function createCanaryApplication(registry) {
     const diffHash = asTaskDiffSnapshot((input.diffProvider ?? taskDeliveryIdentity)(input.root, snapshot.record)).diff_hash;
     if (operation.op === "stop" && !("capability" in operation))
       throw new KernelInvariantError(["stop requires user authority capability"]);
-    const hasBoundSpec = boundSpecPath(snapshot.intent_snapshot) !== undefined;
+    if (operation.op === "approve_breaking_intent_revision")
+      assertValidSpecBinding(operation.next_intent);
+    else
+      assertValidSpecBinding(snapshot.intent_snapshot);
+    const hasBoundSpec = operation.op === "approve_breaking_intent_revision" ? boundSpecPath(operation.next_intent) !== undefined : boundSpecPath(snapshot.intent_snapshot) !== undefined;
     if (operation.op === "complete" && hasBoundSpec && snapshot.record.artifact_state !== "frozen")
       throw new KernelInvariantError(["complete requires frozen planning artifacts"]);
     const artifactTransition = snapshot.record.artifact_state === "frozen" && (operation.op === "request_rework" || operation.op === "authorize_rework" || operation.op === "approve_breaking_intent_revision") ? transitionFor(input.root, snapshot.record, "restore") : operation.op === "stop" && snapshot.record.artifact_state !== "frozen" ? transitionFor(input.root, snapshot.record, "freeze", true) : undefined;
@@ -7169,8 +7294,9 @@ function parseVerdictEvidence(value, index) {
 function parseAssuranceVerdict(input, snapshot) {
   let raw;
   if (typeof input === "string") {
-    const cleaned = input.split(`
-`).map((line) => line.trim()).filter((line) => line.startsWith("{") && line.endsWith("}")).join("");
+    const first = input.indexOf("{");
+    const last = input.lastIndexOf("}");
+    const cleaned = first >= 0 && last >= first ? input.slice(first, last + 1) : "";
     if (!cleaned)
       throw new Error("reviewer returned no strict JSON verdict");
     try {
@@ -7798,10 +7924,10 @@ class AssuranceCoordinator {
       signal?.removeEventListener("abort", relayExternalAbort);
     }
   }
-  async submitReview(taskId, ctx, verdictInput) {
-    return this.withRecovery(taskId, ctx, await this.submitReviewOnce(taskId, ctx, verdictInput));
+  async submitReview(taskId, ctx, verdictInput, options) {
+    return this.withRecovery(taskId, ctx, await this.submitReviewOnce(taskId, ctx, verdictInput, options));
   }
-  async submitReviewOnce(taskId, ctx, verdictInput) {
+  async submitReviewOnce(taskId, ctx, verdictInput, options) {
     const unknown = this.unknownOperations.get(taskId);
     if (unknown)
       return { state: "settlement_unknown", operation: unknown.operation, operation_id: unknown.operationId, reason: unknown.reason };
@@ -7842,6 +7968,9 @@ class AssuranceCoordinator {
       reservation.verdictCorrectionRequired = true;
       return { state: "blocked", code: "verdict_invalid", reason: boundedAssuranceError(error) };
     }
+    const receiptError = options?.validateReceipt?.();
+    if (receiptError)
+      return { state: "blocked", reason: receiptError, ...options?.receiptRecoveryAction ? { recovery_action: options.receiptRecoveryAction } : {} };
     const invocation = this.openInvocation(taskId);
     this.releaseReviewReservation(taskId, reservation);
     try {
@@ -7850,7 +7979,8 @@ class AssuranceCoordinator {
         snapshot: reservation.snapshot,
         verdict,
         invocation,
-        actorId: "parent-mediated-review"
+        actorId: "parent-mediated-review",
+        ...options?.reviewer_verdict_sha256 ? { reviewer_verdict_sha256: options.reviewer_verdict_sha256 } : {}
       });
     } catch (error) {
       const reason = boundedAssuranceError(error);
@@ -8143,7 +8273,8 @@ function createVerdictAuthority(options, registry = createMutationAuthorityRegis
         actor_id: actorId,
         summary: verdict.approval.summary,
         ...snapshot.role === "review" && snapshot.review_revision ? { review_revision: snapshot.review_revision } : {},
-        ...snapshot.role === "review" && advisories.length ? { advisory_findings: advisories } : {}
+        ...snapshot.role === "review" && advisories.length ? { advisory_findings: advisories } : {},
+        ...snapshot.role === "review" && input.reviewer_verdict_sha256 ? { reviewer_verdict_sha256: input.reviewer_verdict_sha256 } : {}
       } : undefined;
       const op = verdict.decision === "rework" ? "request_rework" : "record_approval";
       const payload = approval ? { approval } : { findings };
@@ -9489,6 +9620,16 @@ var BATCH_REASONS = Object.freeze({
     state: "rejected",
     reason: (detail) => detail || "batch run rejected",
     recovery_action: "delete or rename the conflicting branch, or commit working changes and retry in the current Host"
+  },
+  stale_batch_absent: {
+    state: "rejected",
+    reason: (detail) => `no retirable batch record to dispose: ${detail}`,
+    recovery_action: "start a batch for this Initiative, or inspect the batch records under .imm/state/batches in the current Host"
+  },
+  stale_batch_in_flight: {
+    state: "blocked",
+    reason: (detail) => `a batch child is still mid-flight, so the record cannot be disposed: ${detail}`,
+    recovery_action: "settle or stop the in-flight child through its own task, then dispose the batch in the current Host"
   }
 });
 function batchReason(key, detail = "") {
@@ -10736,7 +10877,8 @@ var BATCH_RUN_STATES = new Set([
   "completed",
   "budget_stopped",
   "failed",
-  "rejected"
+  "rejected",
+  "superseded"
 ]);
 var ISO_TIMESTAMP_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
 function isCanonicalTimestamp(value) {
@@ -10817,7 +10959,7 @@ function validateRecordShape(value, batchId) {
     if (child.state === "committed" && child.commit !== null && !record.commits.includes(child.commit))
       throw new Error(`batch run state ${batchId} child ${child.task_id} commit is missing from commits`);
   }
-  if ((record.batch_state === "budget_stopped" || record.batch_state === "failed" || record.batch_state === "rejected") && record.children.some((child) => child.state === "enrolled" || child.state === "settled"))
+  if ((record.batch_state === "budget_stopped" || record.batch_state === "failed" || record.batch_state === "rejected" || record.batch_state === "superseded") && record.children.some((child) => child.state === "enrolled" || child.state === "settled"))
     throw new Error(`batch run state ${batchId} is ${String(record.batch_state)} but a child is still mid-flight`);
   if (record.batch_state === "completed" && record.children.some((child) => child.state !== "committed"))
     throw new Error(`batch run state ${batchId} is completed but a child is not committed`);
@@ -10911,6 +11053,21 @@ function replaceBatchRunState(root, expected, next, validate) {
     return stored;
   });
 }
+function replaceAnyBatchRunState(root, expected, next, validate) {
+  const path = statePath(next.batch_id);
+  if (isLaneBatchRecord(next))
+    validateLaneRecordShape(next, next.batch_id);
+  else
+    validateRecordShape(next, next.batch_id);
+  return withKernelStoreLock(root, () => {
+    if (!readSecureProjectBytes(root, path).equals(expected))
+      throw new Error("batch state CAS mismatch");
+    validate();
+    const stored = withoutRetiredClock({ ...next, updated_at: new Date().toISOString() });
+    writeFileAtomically(root, path, canonicalBytes(stored));
+    return stored;
+  });
+}
 function writeBatchRunState(root, record) {
   const path = statePath(record.batch_id);
   validateRecordShape(record, record.batch_id);
@@ -10991,7 +11148,7 @@ function validateLaneRecordShape(value, batchId) {
       throw new Error(`batch run state ${batchId} child ${child.task_id} has an invalid qa_failures`);
     const lane = child.lane;
     if (lane !== null) {
-      if (typeof lane !== "object" || typeof lane.path !== "string" || !lane.path || typeof lane.branch !== "string" || !lane.branch || typeof lane.base_head !== "string" || !lane.base_head || lane.lane_commit !== null && typeof lane.lane_commit !== "string")
+      if (typeof lane !== "object" || typeof lane.path !== "string" || !lane.path || typeof lane.branch !== "string" || !lane.branch || typeof lane.base_head !== "string" || !lane.base_head || lane.lane_commit !== null && typeof lane.lane_commit !== "string" || lane.run_id !== undefined && lane.run_id !== null && (typeof lane.run_id !== "string" || !lane.run_id))
         throw new Error(`batch run state ${batchId} child ${child.task_id} has an invalid lane`);
     }
     if (LANE_BOUND_STATES.has(child.state) && lane === null)
@@ -11018,7 +11175,7 @@ function validateLaneRecordShape(value, batchId) {
       throw new Error(`batch run state ${batchId} child ${child.task_id} commit is missing from commits`);
   }
   const inFlight = (child) => child.state === "lane_admitted" || child.state === "enrolled" || child.state === "settled" || child.state === "lane_committed";
-  if ((record.batch_state === "budget_stopped" || record.batch_state === "failed" || record.batch_state === "rejected") && record.children.some(inFlight))
+  if ((record.batch_state === "budget_stopped" || record.batch_state === "failed" || record.batch_state === "rejected" || record.batch_state === "superseded") && record.children.some(inFlight))
     throw new Error(`batch run state ${batchId} is ${String(record.batch_state)} but a child is still mid-flight`);
   if (record.batch_state === "completed" && record.children.some((child) => child.state !== "integrated" && child.state !== "released"))
     throw new Error(`batch run state ${batchId} is completed but a child is not integrated`);
@@ -11111,7 +11268,7 @@ function canonicalReportBytes(report) {
 `;
 }
 function isTerminalBatchState(state) {
-  return state === "completed" || state === "budget_stopped" || state === "failed" || state === "rejected";
+  return state === "completed" || state === "budget_stopped" || state === "failed" || state === "rejected" || state === "superseded";
 }
 
 // plugins/immune-brain/runtime/unattended/batch_reconfirmation.ts
@@ -11784,15 +11941,7 @@ function findExistingActiveBatch(root, initiativeSlug) {
       continue;
     if (candidate.initiative_slug !== initiativeSlug)
       continue;
-    const validStates = new Set([
-      "prepared",
-      "running",
-      "needs_human",
-      "completed",
-      "budget_stopped",
-      "failed",
-      "rejected"
-    ]);
+    const validStates = new Set(BATCH_RUN_STATES);
     if (typeof candidate.batch_id !== "string" || typeof candidate.base_head !== "string" || !Array.isArray(candidate.children) || !validStates.has(candidate.batch_state)) {
       return { corrupt: true, path: file };
     }
@@ -12149,7 +12298,7 @@ async function projectBatchPreflight(options) {
     try {
       reconfirmation = await captureBatchReconfirmation(root, activeRecord, planSurface.surface.recovery_children);
     } catch {
-      return reject("plan_projection_failed", "batch plan reconfirmation is not eligible");
+      return reject("plan_projection_failed", activeRecord.commits.length ? `batch plan changed after ${activeRecord.commits.length} recorded child commit(s). The old authorization cannot execute the revised plan. Preserve the batch record, report, commit evidence and audit; inspect each remaining child's Kernel run before an explicit imm-run handoff. Do not re-enroll settled children or manufacture batch trailers. To close the parked record explicitly, dispose it with the retire_stale_batch Tool for this Initiative; a child that is still mid-flight must settle first. This rejection neither terminates the old batch nor authorizes the revised plan.` : "batch plan reconfirmation is not eligible");
     }
   }
   const projection = {
@@ -13257,14 +13406,23 @@ function serialGitOf(input) {
   return input.git ?? defaultSerialGit();
 }
 function releaseHandoffs(input, record, lanes) {
+  const lineage = classifyBatchLineage({
+    root: input.root,
+    branch: record.branch ?? "",
+    expectedHead: expectedBatchHead(record),
+    childCommits: record.commits,
+    batchId: record.batch_id
+  });
+  if (lineage.kind === "broken")
+    return [];
   const handoffs = [];
   for (const child of record.children) {
     if (child.state !== "integrated" || !child.lane)
       continue;
     const facts = lanes.inspectLane(input.root, child.lane.path);
-    if (!facts.exists || !facts.same_repository || !facts.clean || facts.branch !== child.lane.branch)
+    if (!facts.exists || !facts.same_repository || !facts.is_worktree_root || !facts.clean || facts.branch !== child.lane.branch || facts.active_claim_task_id !== null)
       continue;
-    if (!lanes.auditReachable({ root: input.root, head: expectedBatchHead(record), task_id: child.task_id }))
+    if (!lanes.auditReachable({ root: input.root, head: lineage.head, task_id: child.task_id }))
       continue;
     handoffs.push({ role: "lane-steward", action: "release", task_id: child.task_id, lane_branch: child.lane.branch });
   }
@@ -13315,6 +13473,7 @@ var TERMINAL_NEXT_ACTIONS = {
   budget_stopped: "The child budget stopped new enrollments; re-confirm to continue under a new authorization.",
   failed: "A lineage failure stopped the batch; inspect the failing child and the branch state.",
   rejected: "The batch was rejected before any enrollment; correct the stated reason and re-confirm.",
+  superseded: "The plan moved past this record and an explicit disposition retired it; it grants no handoff and no child delivery.",
   needs_human: LANE_NEEDS_HUMAN_NEXT_ACTION,
   running: "The batch is still running; no terminal report is due yet.",
   prepared: "The batch is prepared but not started."
@@ -13335,8 +13494,9 @@ function laneReport(record, reason, nextAction, extra = {}) {
     created_at: record.updated_at
   };
 }
-function laneRejectionReport(record, reason, nextAction) {
-  return laneReport({ ...record, batch_state: "rejected" }, reason, nextAction);
+function laneRejectionReport(input, record, reason, nextAction) {
+  const handoffs = releaseHandoffs(input, record, laneGitOf(input));
+  return laneReport({ ...record, batch_state: "rejected" }, reason, handoffs.length ? `${nextAction}. Check each release handoff with the Lane Steward.` : nextAction, { handoffs });
 }
 function finalizeLane(root, record, reason, nextAction, extra = {}) {
   const report = laneReport(record, reason, nextAction, extra);
@@ -13449,8 +13609,34 @@ async function runLaneBatch(input, persisted) {
       return finalizeLane(input.root, record, `terminal state already reached: ${record.batch_state}`, "", {
         handoffs: record.batch_state === "completed" ? releaseHandoffs(input, record, lanes) : []
       });
-    if (record.batch_state === "needs_human")
-      return finalizeLane(input.root, record, "a parked child needs a human decision", LANE_NEEDS_HUMAN_NEXT_ACTION);
+    if (record.batch_state === "needs_human") {
+      const invalid = validateNewAuthorization(input);
+      if (invalid || Date.parse(input.confirmation_time) <= Date.parse(record.confirmation_time))
+        return laneReport(record, invalid ?? "the parked batch requires a fresh literal-user confirmation", LANE_NEEDS_HUMAN_NEXT_ACTION);
+      const resumed = [];
+      for (const child of record.children) {
+        if (child.state !== "needs_human") {
+          resumed.push(child);
+          continue;
+        }
+        if (!child.lane?.run_id)
+          return laneReport(record, "parked Lane has no recorded run identity; inspect it without re-enrolling", LANE_NEEDS_HUMAN_NEXT_ACTION);
+        const facts = lanes.inspectLane(input.root, child.lane.path);
+        const fresh = await input.kernel.projectTask(child.lane.path, child.task_id);
+        if (!facts.exists || !facts.same_repository || !facts.is_worktree_root || facts.branch !== child.lane.branch || fresh.error !== null || fresh.projection.run_id !== child.lane.run_id || fresh.projection.open_user_decision_count > 0 || fresh.projection.replan_required_ids.length > 0)
+          return laneReport(record, "parked Lane identity or decision is unresolved", LANE_NEEDS_HUMAN_NEXT_ACTION);
+        const state = fresh.projection.lifecycle === "done" && fresh.projection.completion_ready ? child.lane.lane_commit ? "lane_committed" : "settled" : fresh.projection.lifecycle === "active" && fresh.claim?.task_id === child.task_id && (facts.active_claim_task_id === null || facts.active_claim_task_id === child.task_id) ? "enrolled" : null;
+        if (!state)
+          return laneReport(record, "parked child has no recoverable owned run", LANE_NEEDS_HUMAN_NEXT_ACTION);
+        resumed.push({ ...child, state, reason: null, qa_failures: 0 });
+      }
+      record = {
+        ...record,
+        batch_state: "running",
+        confirmation_time: input.confirmation_time,
+        children: resumed.map((child) => child.state === "skipped_blocked" ? { ...child, state: "pending", reason: null } : child)
+      };
+    }
   } else {
     const invalid = validateNewAuthorization(input);
     if (invalid)
@@ -13477,6 +13663,7 @@ async function runLaneBatch(input, persisted) {
   const persist = () => {
     record = writeBatchLaneRunState(input.root, record);
   };
+  const resumedPark = persisted?.batch_state === "needs_human" && record.batch_state === "running";
   if (record.batch_state === "prepared") {
     record.batch_state = "running";
     persist();
@@ -13526,6 +13713,8 @@ async function runLaneBatch(input, persisted) {
   } catch (error) {
     return failLineage(input.root, record, error instanceof Error ? error.message : String(error));
   }
+  if (resumedPark)
+    persist();
   const refusals = [];
   let parkedMessage = null;
   const reviewOpen = [];
@@ -13542,7 +13731,10 @@ async function runLaneBatch(input, persisted) {
         task_id: taskId,
         batch: { registry: input.registry, capability: input.capability, binding: { batch_id: record.batch_id, expected_head: lane.base_head } }
       });
-      record.children = record.children.map((c) => c.task_id === taskId ? { ...c, state: "enrolled", reason: null } : c);
+      const fresh = await input.kernel.projectTask(lane.path, taskId);
+      if (fresh.error !== null || !fresh.projection.run_id || fresh.claim?.task_id !== taskId)
+        throw new Error("enrolled Lane has no observable owned run");
+      record.children = record.children.map((c) => c.task_id === taskId ? { ...c, state: "enrolled", reason: null, lane: { ...lane, run_id: fresh.projection.run_id } } : c);
       persist();
       return null;
     } catch (error) {
@@ -13568,10 +13760,14 @@ async function runLaneBatch(input, persisted) {
       parkChild(child.task_id, "batch_lane_lost");
       continue;
     }
+    if (child.lane.run_id && fresh.projection.run_id !== child.lane.run_id) {
+      parkChild(child.task_id, "batch_lane_run_mismatch");
+      continue;
+    }
     const holdsClaim = fresh.claim !== null && fresh.claim.task_id === child.task_id;
     if (child.state === "lane_admitted") {
       if (holdsClaim) {
-        record.children = record.children.map((c) => c.task_id === child.task_id ? { ...c, state: "enrolled", reason: "adopted existing lane claim after interruption" } : c);
+        record.children = record.children.map((c) => c.task_id === child.task_id ? { ...c, state: "enrolled", reason: "adopted existing lane claim after interruption", lane: { ...child.lane, run_id: fresh.projection.run_id } } : c);
         persist();
       } else {
         const failed = await enrollInLane(child.task_id);
@@ -13801,6 +13997,7 @@ var TERMINAL_NEXT_ACTIONS2 = {
   budget_stopped: "The child budget stopped new enrollments; re-confirm to continue under a new authorization.",
   failed: "A commit or lineage failure stopped the batch; inspect the failing child and the branch state.",
   rejected: "The batch was rejected before any enrollment; correct the stated reason and re-confirm.",
+  superseded: "The plan moved past this record and an explicit disposition retired it; it grants no handoff and no child delivery.",
   needs_human: "A parked child needs a human decision; resolve it, then re-confirm to continue.",
   running: "The batch is still running; no terminal report is due yet.",
   prepared: "The batch is prepared but not started."
@@ -13999,7 +14196,7 @@ function rejectionReport(input, reason) {
     }
   })();
   if (persisted !== null && isLaneBatchRecord(persisted))
-    return laneRejectionReport(persisted, reason, "settle the reported kernel store condition and retry in the current Host");
+    return laneRejectionReport(input, persisted, reason, "settle the reported kernel store condition and retry in the current Host");
   return reportFor({
     ...persisted ?? prepareBatchRunState({ ...input, children: [], now: input.now }),
     batch_state: "rejected"
@@ -14460,22 +14657,126 @@ function createBatchKernelPort(input) {
   };
 }
 
-// plugins/immune-brain/runtime/claude/kernel_ports.ts
-function diffSnapshotOf(root, record) {
-  return taskDeliveryIdentity(root, record);
+// plugins/immune-brain/runtime/unattended/batch_disposition.ts
+var SERIAL_IN_FLIGHT = new Set(["enrolled", "settled"]);
+var LANE_IN_FLIGHT = new Set(["lane_admitted", "enrolled", "settled", "lane_committed"]);
+var RETIRE_REASON = "Retired by an explicit literal-user disposition: the batch plan moved past this record, so its authorization could neither reconfirm nor continue. " + "Recorded child commits, child states and the batch branch are preserved as evidence. " + "Children this batch never executed carry no commit, no batch trailer and no approval; nothing infers their delivery from this record.";
+var RETIRE_NEXT_ACTION = "The Initiative has no active batch. Run each remaining child with imm-run under its own authorization, or start a new batch for this Initiative after checking out its batch branch.";
+function childEvidenceOf(record) {
+  if (record.contract === "assurance_kernel/batch_run_state/v2")
+    return record.children.map((child) => ({
+      task_id: child.task_id,
+      slice_id: child.slice_id,
+      state: child.state,
+      commit: child.commit,
+      lane_branch: child.lane?.branch ?? null
+    }));
+  return record.children.map((child) => ({
+    task_id: child.task_id,
+    slice_id: child.slice_id,
+    state: child.state,
+    commit: child.commit,
+    lane_branch: null
+  }));
 }
-function diffHashOf(root, record) {
-  return diffSnapshotOf(root, record).diff_hash;
+function inFlightChildOf(record) {
+  const inFlight = record.contract === "assurance_kernel/batch_run_state/v2" ? LANE_IN_FLIGHT : SERIAL_IN_FLIGHT;
+  return record.children.find((child) => inFlight.has(child.state)) ?? null;
 }
-function readTaskIntentForRecord(root, taskId) {
-  recoverKernelStoreFollowUps(root, taskId);
-  const currentPath = readTaskRecordRaw(root, taskId).record?.intent_ref?.path;
-  return readTaskIntent(root, taskId, currentPath);
+function readStaleBatchLookup(root, initiativeSlug) {
+  const found = findExistingActiveBatch(root, initiativeSlug);
+  if (found === null) {
+    const settled = findSettledBatchRecord(root, initiativeSlug);
+    if (settled)
+      return { kind: "terminal", batch_id: settled.batch_id };
+    return { kind: "none" };
+  }
+  if (found.corrupt)
+    return { kind: "corrupt", path: found.path };
+  const record = found.record;
+  if (isTerminalBatchState(record.batch_state))
+    return { kind: "terminal", batch_id: record.batch_id };
+  const inFlight = inFlightChildOf(record);
+  if (inFlight)
+    return { kind: "in_flight", batch_id: record.batch_id, task_id: inFlight.task_id };
+  return {
+    kind: "retirable",
+    record,
+    facts: {
+      batch_id: record.batch_id,
+      initiative_slug: record.initiative_slug,
+      batch_state: record.batch_state,
+      plan_digest: record.plan_digest,
+      branch: record.branch ?? `imm/${record.initiative_slug}`,
+      base_head: record.base_head,
+      confirmation_time: record.confirmation_time,
+      recorded_commits: [...record.commits],
+      children: childEvidenceOf(record)
+    }
+  };
 }
+async function retireStaleBatch(options) {
+  const { root, initiative_slug: initiativeSlug, now } = options;
+  const lookup = readStaleBatchLookup(root, initiativeSlug);
+  if (lookup.kind === "none")
+    return { outcome: "rejected", rejection: batchReason("stale_batch_absent", `Initiative ${initiativeSlug} has no active batch`) };
+  if (lookup.kind === "corrupt")
+    return { outcome: "rejected", rejection: batchReason("batch_state_unreadable", lookup.path) };
+  if (lookup.kind === "terminal")
+    return {
+      outcome: "rejected",
+      rejection: batchReason("stale_batch_absent", `batch ${lookup.batch_id} already reached a terminal state`)
+    };
+  if (lookup.kind === "in_flight")
+    return {
+      outcome: "rejected",
+      rejection: batchReason("stale_batch_in_flight", `batch ${lookup.batch_id}, child ${lookup.task_id}`)
+    };
+  const { record, facts } = lookup;
+  const expected = readSecureProjectBytes(root, batchStatePath(record.batch_id));
+  const decision = await options.gate(facts);
+  if (decision.kind === "host_rejection")
+    return { outcome: "host_rejection", value: decision.value };
+  if (!readSecureProjectBytes(root, batchStatePath(record.batch_id)).equals(expected))
+    return { outcome: "rejected", rejection: batchReason("plan_changed", record.batch_id) };
+  const retired = { ...record, batch_state: "superseded" };
+  const stored = replaceAnyBatchRunState(root, expected, retired, () => {
+    if (!readSecureProjectBytes(root, batchStatePath(record.batch_id)).equals(expected))
+      throw new Error("batch state changed before the disposition was applied");
+  });
+  const report = stored.contract === "assurance_kernel/batch_run_state/v2" ? writeBatchRunReport(root, {
+    contract: "assurance_kernel/batch_run_report/v1",
+    batch_id: stored.batch_id,
+    initiative_slug: stored.initiative_slug,
+    batch_state: stored.batch_state,
+    max_parallel: stored.max_parallel,
+    children: stored.children,
+    commits: stored.commits,
+    reason: RETIRE_REASON,
+    handoffs: [],
+    next_action: RETIRE_NEXT_ACTION,
+    created_at: now
+  }) : writeBatchRunReport(root, {
+    contract: "assurance_kernel/batch_run_report/v1",
+    batch_id: stored.batch_id,
+    initiative_slug: stored.initiative_slug,
+    batch_state: stored.batch_state,
+    children: stored.children,
+    commits: stored.commits,
+    reason: RETIRE_REASON,
+    next_action: RETIRE_NEXT_ACTION,
+    created_at: now
+  });
+  return { outcome: "retired", batch_id: stored.batch_id, record: stored, report };
+}
+
+// plugins/immune-brain/runtime/assurance/review_mediation.ts
+import { createHash as createHash21 } from "node:crypto";
 function extractVerdictJson(input) {
   if (typeof input === "string") {
-    const cleaned = input.split(`
-`).map((line) => line.trim()).filter((line) => line.startsWith("{") && line.endsWith("}")).join("");
+    const first = input.indexOf("{");
+    const last = input.lastIndexOf("}");
+    const cleaned = first >= 0 && last >= first ? input.slice(first, last + 1) : "";
     if (!cleaned)
       return null;
     try {
@@ -14499,36 +14800,72 @@ function verdictFingerprint(raw) {
     findings: raw.findings ?? null
   });
 }
+function digestOfReviewerBytes(bytes) {
+  return `sha256:${createHash21("sha256").update(bytes).digest("hex")}`;
+}
 var RELEASED_REVIEW_RECOVERY = "Call advance_assurance to obtain a new Review reservation, then dispatch one fresh reviewer with the returned envelope unchanged";
 var RETAINED_REVIEW_RECOVERY = "Wait for the dispatched reviewer to finish, then call submit_review again with its verdict; do not dispatch or continue another reviewer";
-var MISMATCH_REVIEW_RECOVERY = "Resubmit the reviewer's verdict exactly as the reviewer returned it";
+var MISMATCH_REVIEW_RECOVERY = "Resubmit without a verdict to apply the observed reviewer receipt, or resubmit the reviewer's verdict exactly as the reviewer returned it";
 function withReviewRecovery(result, recovery_action) {
   if (result.state !== "blocked" || result.code === "verdict_invalid")
     return result;
   return { ...result, recovery_action };
 }
-async function submitClaudeReview(host, coordinator, ctx, taskId, verdictInput) {
-  if (verdictInput === undefined)
-    throw new Error("verdict is required");
-  const observed = host.inspectReviewForTask(taskId);
+async function submitMediatedReview(coordinator, ctx, taskId, verdictInput, inspect) {
+  if (coordinator.active(taskId)?.state === "settlement_unknown") {
+    return coordinator.submitReview(taskId, ctx, verdictInput);
+  }
+  const observed = inspect();
   if (!observed.ok) {
     if (observed.release)
       return withReviewRecovery(coordinator.abandonReview(taskId, observed.reason), RELEASED_REVIEW_RECOVERY);
     return { state: "blocked", reason: observed.reason, recovery_action: RETAINED_REVIEW_RECOVERY };
   }
+  const receiptBytes = observed.receipt.result;
+  const options = {
+    receiptRecoveryAction: RETAINED_REVIEW_RECOVERY,
+    reviewer_verdict_sha256: digestOfReviewerBytes(receiptBytes),
+    validateReceipt: () => {
+      const current = inspect();
+      if (!current.ok)
+        return current.reason;
+      return current.receipt.actorId === observed.receipt.actorId && current.receipt.result === receiptBytes ? null : "reviewer receipt changed during submission";
+    }
+  };
+  if (verdictInput === undefined) {
+    if (!coordinator.isReviewVerdictValid(taskId, receiptBytes)) {
+      return withReviewRecovery(coordinator.abandonReview(taskId, "reviewer receipt is not a valid verdict"), RELEASED_REVIEW_RECOVERY);
+    }
+    return coordinator.submitReview(taskId, ctx, receiptBytes, options);
+  }
   const parentValid = coordinator.isReviewVerdictValid(taskId, verdictInput);
   if (!parentValid)
     return coordinator.submitReview(taskId, ctx, verdictInput);
-  const receiptValid = coordinator.isReviewVerdictValid(taskId, observed.receipt.result);
-  if (!receiptValid) {
+  if (!coordinator.isReviewVerdictValid(taskId, receiptBytes)) {
     return withReviewRecovery(coordinator.abandonReview(taskId, "reviewer receipt is not a valid verdict"), RELEASED_REVIEW_RECOVERY);
   }
   const parentJson = extractVerdictJson(verdictInput);
-  const receiptJson = extractVerdictJson(observed.receipt.result);
-  if (verdictFingerprint(parentJson) !== verdictFingerprint(receiptJson)) {
+  const receiptJson = extractVerdictJson(receiptBytes);
+  if (!parentJson || !receiptJson || verdictFingerprint(parentJson) !== verdictFingerprint(receiptJson)) {
     return { state: "blocked", reason: "parent verdict does not match reviewer receipt", recovery_action: MISMATCH_REVIEW_RECOVERY };
   }
-  return coordinator.submitReview(taskId, ctx, verdictInput);
+  return coordinator.submitReview(taskId, ctx, verdictInput, options);
+}
+
+// plugins/immune-brain/runtime/claude/kernel_ports.ts
+function diffSnapshotOf(root, record) {
+  return taskDeliveryIdentity(root, record);
+}
+function diffHashOf(root, record) {
+  return diffSnapshotOf(root, record).diff_hash;
+}
+function readTaskIntentForRecord(root, taskId) {
+  recoverKernelStoreFollowUps(root, taskId);
+  const currentPath = readTaskRecordRaw(root, taskId).record?.intent_ref?.path;
+  return readTaskIntent(root, taskId, currentPath);
+}
+async function submitClaudeReview(host, coordinator, ctx, taskId, verdictInput) {
+  return submitMediatedReview(coordinator, ctx, taskId, verdictInput, () => host.inspectReviewForTask(taskId));
 }
 function settledKernelResult(result) {
   const state = result.state;
@@ -15161,6 +15498,81 @@ class ClaudeRuntime {
       report
     };
   }
+  async retireStaleBatch(initiativeSlug, meta) {
+    throwIfCancelled(meta.signal);
+    const probe = probeHost(this.env, process.platform, this.hostVersion);
+    if (!probe.ok)
+      throw new NativeAuthorityError("unsupported_host", probe.reason);
+    if (!this.requestConfirmation)
+      throw new NativeAuthorityError("interaction_not_opened", batchReason("confirmation_port_unavailable").reason);
+    const outcome = await retireStaleBatch({
+      root: this.cwd,
+      initiative_slug: initiativeSlug,
+      now: new Date().toISOString(),
+      gate: async (facts) => {
+        let confirmationResult;
+        try {
+          confirmationResult = await this.requestConfirmation({
+            operation: "retire_stale_batch",
+            initiativeSlug,
+            toolCallId: meta.toolCallId,
+            batchDisposition: {
+              batch_id: facts.batch_id,
+              batch_state: facts.batch_state,
+              batch_branch: facts.branch,
+              plan_digest: facts.plan_digest,
+              recorded_commits: facts.recorded_commits.length,
+              children: facts.children.map((child) => ({
+                task_id: child.task_id,
+                slice_id: child.slice_id,
+                state: child.state,
+                commit: child.commit,
+                lane_branch: child.lane_branch
+              }))
+            },
+            signal: meta.signal
+          });
+        } catch (err) {
+          if (meta.signal?.aborted)
+            return { kind: "host_rejection", value: batchReason("confirmation_cancelled") };
+          if (err instanceof NativeAuthorityError) {
+            if (err.reasonCode === "unsupported_host")
+              throw err;
+            if (err.reasonCode === "user_cancelled") {
+              return {
+                kind: "host_rejection",
+                value: { state: "cancelled", reason: err.message, recovery_action: err.recoveryAction }
+              };
+            }
+            return {
+              kind: "host_rejection",
+              value: { state: "rejected", reason: err.message, recovery_action: err.recoveryAction }
+            };
+          }
+          return {
+            kind: "host_rejection",
+            value: batchReason("confirmation_failed", err instanceof Error ? err.message : String(err))
+          };
+        }
+        if (confirmationResult.decision === "cancel" && meta.signal?.aborted)
+          return { kind: "host_rejection", value: batchReason("confirmation_cancelled") };
+        if (meta.signal?.aborted)
+          return { kind: "host_rejection", value: batchReason("cancelled_before_execution") };
+        if (confirmationResult.decision === "decline")
+          return { kind: "host_rejection", value: batchReason("confirmation_declined") };
+        if (confirmationResult.decision === "cancel")
+          return { kind: "host_rejection", value: batchReason("confirmation_cancelled") };
+        if (confirmationResult.decision !== "accept")
+          return { kind: "host_rejection", value: batchReason("confirmation_no_decision") };
+        return { kind: "confirmed", request_id: confirmationResult.requestId };
+      }
+    });
+    if (outcome.outcome === "host_rejection")
+      return outcome.value;
+    if (outcome.outcome === "rejected")
+      return outcome.rejection;
+    return { state: "retired", batch_id: outcome.batch_id, report: outcome.report };
+  }
 }
 
 // plugins/immune-brain/runtime/claude/mcp_server.ts
@@ -15169,12 +15581,13 @@ var TOOLS = [
   { name: "status", description: "Read the Kernel Assurance Projection for an exact task.", privileged: false },
   { name: "enroll", description: "Enroll a Git-tracked TaskIntent after native confirmation.", privileged: true },
   { name: "advance_assurance", description: "Advance frozen Assurance through deterministic QA and Review reservation.", privileged: false },
-  { name: "submit_review", description: "Submit the Parent-mediated Review verdict bound to the correlated receipt.", privileged: false },
+  { name: "submit_review", description: "Submit the Review verdict; omit the verdict to apply the correlated reviewer receipt, or relay the reviewer's structured verdict for fingerprint comparison.", privileged: false },
   { name: "request_authorization", description: "Apply exact literal-user authorization.", privileged: true },
   { name: "revise_intent", description: "Apply a compatible TaskIntent revision.", privileged: false },
   { name: "approve_breaking_intent_revision", description: "Approve a breaking TaskIntent revision.", privileged: true },
   { name: "stop", description: "Stop the active task with literal-user authority.", privileged: true },
   { name: "start_unattended_batch", description: "Start an unattended serial batch run for an Initiative after native confirmation.", privileged: true },
+  { name: "retire_stale_batch", description: "Retire an Initiative's parked or drifted batch record to the terminal superseded state after native confirmation.", privileged: true },
   { name: "repair_authority_state", description: "Repair a proven recoverable stale backend claim.", privileged: false },
   { name: "resolve_finding", description: "Resolve one open blocking or advisory finding whose cause is fixed and verified.", privileged: false },
   { name: "refute_finding", description: "Refute one open finding by binding the fresh passing QA attestation that contradicts it.", privileged: false }
@@ -15186,18 +15599,20 @@ function listMcpTools() {
     inputSchema: {
       type: "object",
       properties: {
-        ...tool.name === "start_unattended_batch" ? {
+        ...tool.name === "start_unattended_batch" || tool.name === "retire_stale_batch" ? {
           initiative_slug: { type: "string" },
-          max_parallel: { type: "integer", minimum: 1 },
-          lane_offers: {
-            type: "array",
-            items: {
-              type: "object",
-              properties: { task_id: { type: "string" }, path: { type: "string" } },
-              required: ["task_id", "path"],
-              additionalProperties: false
+          ...tool.name === "start_unattended_batch" ? {
+            max_parallel: { type: "integer", minimum: 1 },
+            lane_offers: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: { task_id: { type: "string" }, path: { type: "string" } },
+                required: ["task_id", "path"],
+                additionalProperties: false
+              }
             }
-          }
+          } : {}
         } : {
           task_id: { type: "string" },
           ...tool.name === "approve_breaking_intent_revision" || tool.name === "revise_intent" ? { next_intent: { type: "object" } } : {},
@@ -15207,7 +15622,7 @@ function listMcpTools() {
           ...tool.name === "refute_finding" ? { finding_id: { type: "string" }, attestation_id: { type: "string" } } : {}
         }
       },
-      required: tool.name === "start_unattended_batch" ? ["initiative_slug"] : tool.name === "submit_review" ? ["task_id", "verdict"] : tool.name === "resolve_finding" ? ["task_id", "finding_id"] : tool.name === "refute_finding" ? ["task_id", "finding_id", "attestation_id"] : tool.name === "revise_intent" ? ["task_id", "next_intent"] : ["task_id"]
+      required: tool.name === "start_unattended_batch" || tool.name === "retire_stale_batch" ? ["initiative_slug"] : tool.name === "resolve_finding" ? ["task_id", "finding_id"] : tool.name === "refute_finding" ? ["task_id", "finding_id", "attestation_id"] : tool.name === "revise_intent" ? ["task_id", "next_intent"] : ["task_id"]
     },
     annotations: tool.privileged ? privilegedAnnotations() : { readOnlyHint: tool.name === "status" }
   }));
@@ -15276,6 +15691,30 @@ function createMcpRuntime(options = {}) {
           ...laneOffers !== undefined ? { lane_offers: laneOffers } : {}
         });
       }
+      if (name === "retire_stale_batch") {
+        const initiativeSlug = String(args.initiative_slug ?? "");
+        if (!initiativeSlug)
+          throw new Error("initiative_slug is required");
+        if ("native_decision" in args)
+          throw new Error("native_decision cannot be supplied in tool arguments");
+        if (!negotiatedVersion)
+          throw new NativeAuthorityError("unsupported_host", "Claude Code version is unavailable");
+        if (!negotiatedInteractive) {
+          throw new NativeAuthorityError("unsupported_host", "interactive MCP elicitation is unavailable");
+        }
+        const probe = probeHost(options.env ?? process.env, process.platform, negotiatedVersion);
+        if (!probe.ok)
+          throw new NativeAuthorityError("unsupported_host", probe.reason);
+        const toolMeta = {
+          sessionId: meta.sessionId ?? connectionId,
+          toolCallId: meta.toolCallId ?? `call-${name}`,
+          taskId: initiativeSlug,
+          initiativeSlug,
+          interactive: meta.interactive ?? options.interactive ?? negotiatedInteractive,
+          signal: meta.signal
+        };
+        return runtime.retireStaleBatch(initiativeSlug, toolMeta);
+      }
       const taskId = String(args.task_id ?? "");
       if (!taskId)
         throw new Error("task_id is required");
@@ -15303,9 +15742,7 @@ function createMcpRuntime(options = {}) {
       if (name === "advance_assurance")
         return runtime.advance(taskId, toolMeta.signal, toolMeta);
       if (name === "submit_review") {
-        if (!Object.hasOwn(args, "verdict"))
-          throw new Error("verdict is required");
-        return runtime.submitReview(taskId, args.verdict, toolMeta);
+        return runtime.submitReview(taskId, Object.hasOwn(args, "verdict") ? args.verdict : undefined, toolMeta);
       }
       if (name === "revise_intent") {
         if (!Object.hasOwn(args, "next_intent"))
@@ -15488,6 +15925,32 @@ async function writeReply(output, reply) {
   });
 }
 function elicitationParams(input) {
+  if (input.operation === "retire_stale_batch") {
+    const d = input.batchDisposition;
+    const details = [
+      `Operation: retire_stale_batch`,
+      `Initiative: ${input.initiativeSlug}`,
+      d ? `Batch: ${d.batch_id}` : null,
+      d ? `Batch state: ${d.batch_state}` : null,
+      d ? `Batch branch: ${d.batch_branch}` : null,
+      d ? `Plan digest: ${d.plan_digest}` : null,
+      d ? `Recorded child commits: ${d.recorded_commits}` : null,
+      d ? `Children (${d.children.length}):
+${d.children.map((child) => `  - ${child.task_id} (${child.slice_id}) [state: ${child.state}]${child.commit ? ` [commit: ${child.commit}]` : " [no commit]"}${child.lane_branch ? ` [lane: ${child.lane_branch}]` : ""}`).join(`
+`)}` : null,
+      "Retiring writes this record to the terminal superseded state. Child states, recorded commits and the batch branch are preserved as evidence; nothing is deleted and no batch trailer or approval is manufactured.",
+      "A child without a commit was never executed by this batch: it carries no delivery evidence, and the retired authorization is never reused for a revised plan.",
+      "After retiring, run each remaining child with imm-run under its own authorization, or start a new batch for this Initiative."
+    ].filter(Boolean);
+    return {
+      mode: "form",
+      message: `Retire this stale batch record for ${input.initiativeSlug}?
+
+${details.join(`
+`)}`,
+      requestedSchema: { type: "object", properties: {} }
+    };
+  }
   if (input.operation === "start_unattended_batch") {
     const b = input.batchDetails;
     const details = [