immune-brain 5.0.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.0.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;
@@ -6816,8 +6941,14 @@ var INTERNAL_ROLE_PROMPTS = {
     file: "compounder.md",
     authority: "compounder",
     tool_policy: "learning tools"
+  },
+  "lane-steward": {
+    file: "lane-steward.md",
+    authority: "lane-provision",
+    tool_policy: "workspace tools"
   }
 };
+var LANE_EXECUTOR_HOSTS = ["claude-code", "pi"];
 function roleSpec(role) {
   const spec = INTERNAL_ROLE_PROMPTS[role];
   if (!spec)
@@ -7163,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 {
@@ -7792,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 };
@@ -7836,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 {
@@ -7844,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);
@@ -8137,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 };
@@ -8192,9 +8329,9 @@ function createVerdictAuthority(options, registry = createMutationAuthorityRegis
 }
 
 // plugins/immune-brain/runtime/claude/kernel_ports.ts
-import { existsSync as existsSync11, readFileSync as readFileSync14, writeFileSync as writeFileSync8 } from "node:fs";
+import { existsSync as existsSync12, readFileSync as readFileSync15, writeFileSync as writeFileSync8 } from "node:fs";
 import { execFileSync as execFileSync8 } from "node:child_process";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 
 // plugins/immune-brain/runtime/kernel/enrollment_authority.ts
 var ENROLLMENT_CAPABILITY_BRAND = Symbol.for("assurance-kernel.enrollment-capability-brand");
@@ -9483,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 = "") {
@@ -10699,7 +10846,7 @@ async function runGithubTrackerOperation(root, input, gh = createGhTransport())
 }
 
 // plugins/immune-brain/runtime/unattended/batch_preflight.ts
-import { existsSync as existsSync8, readdirSync as readdirSync6, readFileSync as readFileSync13 } from "node:fs";
+import { existsSync as existsSync8, readdirSync as readdirSync6, readFileSync as readFileSync14 } from "node:fs";
 import { randomUUID as randomUUID8 } from "node:crypto";
 import { join as join13 } from "node:path";
 import { spawnSync as spawnSync7 } from "node:child_process";
@@ -10711,6 +10858,9 @@ import { spawnSync as spawnSync6 } from "node:child_process";
 import { existsSync as existsSync7, mkdirSync as mkdirSync6, openSync as openSync6, closeSync as closeSync6, writeFileSync as writeFileSync6, renameSync as renameSync3, lstatSync as lstatSync9, constants as constants5, rmSync as rmSync6 } from "node:fs";
 import { randomUUID as randomUUID7 } from "node:crypto";
 import { dirname as dirname7, join as join12 } from "node:path";
+function isLaneBatchRecord(record) {
+  return record.contract === "assurance_kernel/batch_run_state/v2";
+}
 var BATCH_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 var CHILD_RUN_STATES = new Set([
   "pending",
@@ -10727,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) {
@@ -10808,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`);
@@ -10902,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);
@@ -10918,6 +11084,162 @@ function writeBatchRunState(root, record) {
     return stored;
   });
 }
+var LANE_CHILD_STATES = new Set([
+  "pending",
+  "lane_admitted",
+  "enrolled",
+  "settled",
+  "lane_committed",
+  "integrated",
+  "released",
+  "needs_human",
+  "skipped_blocked"
+]);
+var LANE_BOUND_STATES = new Set([
+  "lane_admitted",
+  "enrolled",
+  "settled",
+  "lane_committed",
+  "integrated",
+  "released"
+]);
+function validateLaneRecordShape(value, batchId) {
+  if (typeof value !== "object" || value === null)
+    throw new Error(`batch run state ${batchId} is not an object`);
+  const record = value;
+  if (record.contract !== "assurance_kernel/batch_run_state/v2")
+    throw new Error(`batch run state ${batchId} has an unknown contract`);
+  if (record.batch_id !== batchId)
+    throw new Error(`batch run state ${batchId} carries batch_id ${String(record.batch_id)}`);
+  if (typeof record.plan_digest !== "string" || !record.plan_digest)
+    throw new Error(`batch run state ${batchId} has an invalid plan_digest`);
+  if (typeof record.base_head !== "string" || !record.base_head)
+    throw new Error(`batch run state ${batchId} has an invalid base_head`);
+  if (record.branch !== undefined && (typeof record.branch !== "string" || !record.branch))
+    throw new Error(`batch run state ${batchId} has an invalid branch`);
+  if (!isCanonicalTimestamp(record.confirmation_time))
+    throw new Error(`batch run state ${batchId} has an invalid confirmation_time`);
+  if (!isCanonicalTimestamp(record.created_at) || !isCanonicalTimestamp(record.updated_at))
+    throw new Error(`batch run state ${batchId} has invalid state timestamps`);
+  if (!Array.isArray(record.children) || record.children.length === 0)
+    throw new Error(`batch run state ${batchId} has no children`);
+  if (!BATCH_RUN_STATES.has(String(record.batch_state)))
+    throw new Error(`batch run state ${batchId} has an invalid batch_state`);
+  if (typeof record.max_parallel !== "number" || !Number.isSafeInteger(record.max_parallel) || record.max_parallel <= 0)
+    throw new Error(`batch run state ${batchId} has an invalid max_parallel`);
+  const budget = record.budget;
+  if (typeof record.budget !== "object" || record.budget === null || typeof budget.max_children !== "number" || !Number.isInteger(budget.max_children) || budget.max_children <= 0 || typeof budget.qa_failure_limit !== "number" || !Number.isInteger(budget.qa_failure_limit) || budget.qa_failure_limit <= 0)
+    throw new Error(`batch run state ${batchId} has an invalid budget`);
+  if (!Array.isArray(record.commits) || record.commits.some((c) => typeof c !== "string"))
+    throw new Error(`batch run state ${batchId} has an invalid commits list`);
+  if (record.adopted_heads !== undefined && (!Array.isArray(record.adopted_heads) || record.adopted_heads.some((a) => typeof a !== "object" || a === null || typeof a.from !== "string" || !a.from || typeof a.to !== "string" || !a.to)))
+    throw new Error(`batch run state ${batchId} has an invalid adopted_heads list`);
+  const seenTaskIds = new Set;
+  for (const child of record.children) {
+    if (typeof child !== "object" || child === null || typeof child.task_id !== "string" || !child.task_id || typeof child.slice_id !== "string" || !child.slice_id)
+      throw new Error(`batch run state ${batchId} has an invalid child entry`);
+    if (!LANE_CHILD_STATES.has(String(child.state)))
+      throw new Error(`batch run state ${batchId} child ${child.task_id} has an invalid state`);
+    if (!Array.isArray(child.blocked_by) || child.blocked_by.some((b) => typeof b !== "string"))
+      throw new Error(`batch run state ${batchId} child ${child.task_id} has an invalid blocked_by`);
+    if (child.reason !== null && typeof child.reason !== "string" || child.commit !== null && typeof child.commit !== "string")
+      throw new Error(`batch run state ${batchId} child ${child.task_id} has invalid terminal fields`);
+    if (typeof child.qa_failures !== "number" || !Number.isInteger(child.qa_failures) || child.qa_failures < 0)
+      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" || 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)
+      throw new Error(`batch run state ${batchId} child ${child.task_id} is ${child.state} without a lane`);
+    if ((child.state === "pending" || child.state === "skipped_blocked") && lane !== null)
+      throw new Error(`batch run state ${batchId} child ${child.task_id} is ${child.state} but holds a lane`);
+    const integrated = child.state === "integrated" || child.state === "released";
+    if (integrated && child.commit === null)
+      throw new Error(`batch run state ${batchId} child ${child.task_id} is ${child.state} without a commit`);
+    if (!integrated && child.commit !== null)
+      throw new Error(`batch run state ${batchId} child ${child.task_id} has a commit but is not integrated`);
+    if (integrated && lane?.lane_commit === null)
+      throw new Error(`batch run state ${batchId} child ${child.task_id} is ${child.state} without a lane commit`);
+    if (child.state === "lane_committed" && lane?.lane_commit === null)
+      throw new Error(`batch run state ${batchId} child ${child.task_id} is lane_committed without a lane commit`);
+    if ((child.state === "needs_human" || child.state === "skipped_blocked") && child.reason === null)
+      throw new Error(`batch run state ${batchId} child ${child.task_id} needs a terminal reason`);
+    if (seenTaskIds.has(child.task_id))
+      throw new Error(`batch run state ${batchId} has a duplicate child ${child.task_id}`);
+    seenTaskIds.add(child.task_id);
+  }
+  for (const child of record.children) {
+    if (child.commit !== null && !record.commits.includes(child.commit))
+      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.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`);
+}
+function prepareBatchLaneRunState(input) {
+  validateBatchId(input.batch_id);
+  return {
+    contract: "assurance_kernel/batch_run_state/v2",
+    batch_id: input.batch_id,
+    initiative_slug: input.initiative_slug,
+    plan_digest: input.plan_digest,
+    base_head: input.base_head,
+    branch: input.branch ?? `imm/${input.initiative_slug}`,
+    confirmation_time: input.confirmation_time,
+    budget: input.budget,
+    max_parallel: input.max_parallel,
+    batch_state: "prepared",
+    children: input.children.map((child) => ({
+      task_id: child.task_id,
+      slice_id: child.slice_id,
+      blocked_by: [...child.blocked_by],
+      state: "pending",
+      reason: null,
+      commit: null,
+      lane: null,
+      qa_failures: 0
+    })),
+    commits: [],
+    created_at: input.now,
+    updated_at: input.now
+  };
+}
+function parseBatchLaneRunState(raw, batchId) {
+  validateBatchId(batchId);
+  const parsed = JSON.parse(raw);
+  validateLaneRecordShape(parsed, batchId);
+  return withoutRetiredClock(parsed);
+}
+function parseAnyBatchRunState(raw, batchId) {
+  validateBatchId(batchId);
+  const parsed = JSON.parse(raw);
+  if (typeof parsed === "object" && parsed !== null && parsed.contract === "assurance_kernel/batch_run_state/v2")
+    return parseBatchLaneRunState(raw, batchId);
+  return parseBatchRunState(raw, batchId);
+}
+function readAnyBatchRunState(root, batchId) {
+  const path = statePath(batchId);
+  if (!existsSync7(join12(root, path)))
+    return null;
+  return parseAnyBatchRunState(readSecureProjectFile(root, path), batchId);
+}
+function writeBatchLaneRunState(root, record) {
+  const path = statePath(record.batch_id);
+  validateLaneRecordShape(record, record.batch_id);
+  return withKernelStoreLock(root, () => {
+    const existing = existsSync7(join12(root, path)) ? readSecureProjectFile(root, path) : null;
+    if (existing !== null && existing === canonicalBytes(record))
+      return record;
+    const stored = withoutRetiredClock({ ...record, updated_at: new Date().toISOString() });
+    ensureSecureDirectory2(root, join12(".imm", "state", "batches"));
+    writeFileAtomically(root, path, canonicalBytes(stored));
+    return stored;
+  });
+}
 function reportPath(batchId) {
   validateBatchId(batchId);
   return join12(".imm", "state", "batches", `${batchId}.report.json`);
@@ -10946,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
@@ -11173,7 +11495,186 @@ async function captureBatchReconfirmation(root, record, children) {
 
 // plugins/immune-brain/runtime/unattended/batch_plan.ts
 import { createHash as createHash19 } from "node:crypto";
+
+// plugins/immune-brain/runtime/local_initiative.ts
+import { lstatSync as lstatSync10, readFileSync as readFileSync13 } from "node:fs";
+import { resolve as resolve12 } from "node:path";
 var ID_PATTERN2 = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+var SLICE_HEADING = /^##\s+([^\s:]+)\s*:/;
+var BLOCKED_BY = /^blocked by\s*:(.*)$/i;
+var TASKS = /^tasks\s*:\s*$/i;
+var BULLET = /^[-*]\s+(.*)$/;
+function localInitiativePath(initiativeSlug) {
+  return `docs/initiatives/${initiativeSlug}.md`;
+}
+function hasLocalInitiative(root, initiativeSlug) {
+  const stat = lstatSync10(resolve12(root, localInitiativePath(initiativeSlug)), { throwIfNoEntry: false });
+  if (!stat)
+    return false;
+  if (!stat.isFile())
+    throw new Error(`${localInitiativePath(initiativeSlug)} must be a regular file`);
+  return true;
+}
+function unquote(value) {
+  return value.trim().replace(/^`(.*)`$/, "$1");
+}
+function observeLocalInitiative(root, initiativeSlug) {
+  if (!ID_PATTERN2.test(initiativeSlug))
+    throw new Error("initiative_slug is invalid");
+  const path = localInitiativePath(initiativeSlug);
+  if (!hasLocalInitiative(root, initiativeSlug))
+    throw new Error(`Local Initiative ${path} does not exist`);
+  const slices = [];
+  let inTasks = false;
+  let fence = false;
+  for (const raw of readFileSync13(resolve12(root, path), "utf8").split(/\r?\n/)) {
+    const line = raw.trim();
+    if (line.startsWith("```")) {
+      fence = !fence;
+      continue;
+    }
+    if (fence)
+      continue;
+    const heading = SLICE_HEADING.exec(line);
+    if (heading) {
+      slices.push({ slice_id: heading[1], tasks: [], blocked_by: [] });
+      inTasks = false;
+      continue;
+    }
+    const slice = slices.at(-1);
+    if (!slice)
+      continue;
+    if (TASKS.test(line)) {
+      inTasks = true;
+      continue;
+    }
+    const blocked = BLOCKED_BY.exec(line);
+    if (blocked) {
+      slice.blocked_by.push(...blocked[1].split(",").map(unquote).filter(Boolean));
+      inTasks = false;
+      continue;
+    }
+    const bullet = BULLET.exec(line);
+    if (inTasks && bullet)
+      slice.tasks.push(unquote(bullet[1]));
+    else if (line)
+      inTasks = false;
+  }
+  if (!slices.length)
+    throw new Error(`Local Initiative ${path} declares no Slice`);
+  return {
+    contract: "immune_brain/local_initiative_observation/v1",
+    initiative_id: initiativeSlug,
+    path,
+    tasks: slices.map((slice) => {
+      if (slice.tasks.length !== 1)
+        throw new Error(`Local Initiative Slice ${slice.slice_id} must name exactly one Task to run as a batch child`);
+      return { task_id: slice.tasks[0], slice_id: slice.slice_id, blocked_by: slice.blocked_by };
+    })
+  };
+}
+
+// plugins/immune-brain/runtime/unattended/batch_schedule.ts
+var IN_FLIGHT_STATES = new Set([
+  "lane_admitted",
+  "enrolled",
+  "settled",
+  "lane_committed"
+]);
+var DONE_STATES = new Set(["committed", "integrated", "released"]);
+var WILDCARD = /[*?[\]{}!]/;
+function scopePrefix(entry) {
+  if (typeof entry !== "string")
+    return [];
+  let value = entry.trim().toLowerCase();
+  while (value.startsWith("./"))
+    value = value.slice(2);
+  if (!value || value.startsWith("/") || value.includes("\\"))
+    return [];
+  const wildcard = value.search(WILDCARD);
+  const literal = wildcard === -1 ? value : value.slice(0, value.lastIndexOf("/", wildcard) + 1);
+  const segments = literal.split("/").filter((segment) => segment.length > 0);
+  if (segments.some((segment) => segment === "." || segment === ".."))
+    return [];
+  return segments;
+}
+function prefixOverlaps(left, right) {
+  if (!left.length || !right.length)
+    return true;
+  const shared = Math.min(left.length, right.length);
+  for (let index = 0;index < shared; index += 1)
+    if (left[index] !== right[index])
+      return false;
+  return true;
+}
+function scopesOverlap(left, right) {
+  if (!left.length || !right.length)
+    return true;
+  const rightPrefixes = right.map(scopePrefix);
+  return left.some((entry) => {
+    const prefix = scopePrefix(entry);
+    return rightPrefixes.some((other) => prefixOverlaps(prefix, other));
+  });
+}
+function positiveLimit(maxParallel) {
+  if (maxParallel === Number.POSITIVE_INFINITY)
+    return maxParallel;
+  if (!Number.isSafeInteger(maxParallel) || maxParallel <= 0)
+    throw new Error("max_parallel must be a positive safe integer");
+  return maxParallel;
+}
+function startableChildren(children, maxParallel) {
+  const limit = positiveLimit(maxParallel);
+  const done = new Set(children.filter((child) => DONE_STATES.has(child.state)).map((child) => child.task_id));
+  const occupied = children.filter((child) => IN_FLIGHT_STATES.has(child.state));
+  const startable = [];
+  for (const child of children) {
+    if (occupied.length >= limit)
+      break;
+    if (child.state !== "pending")
+      continue;
+    if (!child.blocked_by.every((id) => done.has(id)))
+      continue;
+    if (occupied.some((other) => scopesOverlap(child.scope_hint, other.scope_hint)))
+      continue;
+    startable.push(child.task_id);
+    occupied.push(child);
+  }
+  return startable;
+}
+function projectParallelGroups(children) {
+  const remaining = [...children];
+  const placed = new Set;
+  const groups = [];
+  const conflicts = new Map;
+  while (remaining.length) {
+    const ready = remaining.filter((child) => child.blocked_by.every((id) => placed.has(id)));
+    if (!ready.length)
+      throw new Error("Initiative Task dependencies must form an acyclic graph");
+    const wave = [];
+    for (const child of ready) {
+      const overlapped = wave.filter((member) => scopesOverlap(child.scope_hint, member.scope_hint));
+      if (overlapped.length) {
+        const known = conflicts.get(child.task_id) ?? new Set;
+        for (const member of overlapped)
+          known.add(member.task_id);
+        conflicts.set(child.task_id, known);
+        continue;
+      }
+      wave.push(child);
+    }
+    groups.push(wave.map((child) => child.task_id));
+    for (const child of wave) {
+      placed.add(child.task_id);
+      remaining.splice(remaining.indexOf(child), 1);
+    }
+  }
+  const scopeConflicts = children.filter((child) => conflicts.has(child.task_id)).map((child) => ({ task_id: child.task_id, overlaps_with: [...conflicts.get(child.task_id)].sort() }));
+  return { parallel_groups: groups, scope_conflicts: scopeConflicts };
+}
+
+// plugins/immune-brain/runtime/unattended/batch_plan.ts
+var ID_PATTERN3 = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 var DEFAULT_QA_FAILURE_LIMIT = 2;
 function specBindingReason(inspection) {
   if (inspection.missing.length > 0)
@@ -11197,12 +11698,14 @@ function timestamp(value, name) {
     throw new Error(`${name} must be an ISO timestamp`);
   return { milliseconds, iso: new Date(milliseconds).toISOString() };
 }
+var observeInitiative = async (root, initiativeSlug) => hasLocalInitiative(root, initiativeSlug) ? observeLocalInitiative(root, initiativeSlug) : observeGithubInitiative(root, initiativeSlug);
 function normalizeObservation(value, initiativeSlug) {
-  if (!value || value.contract !== "immune_brain/github_initiative_observation/v1")
+  const local = value?.contract === "immune_brain/local_initiative_observation/v1";
+  if (!value || !local && value.contract !== "immune_brain/github_initiative_observation/v1")
     throw new Error("tracker returned an invalid Initiative observation contract");
   if (value.initiative_id !== initiativeSlug)
     throw new Error("tracker returned an observation for another Initiative");
-  if (!Number.isSafeInteger(value.issue_number) || value.issue_number <= 0)
+  if (!local && (!Number.isSafeInteger(value.issue_number) || value.issue_number <= 0))
     throw new Error("tracker returned an invalid Initiative Issue number");
   if (!Array.isArray(value.tasks))
     throw new Error("tracker returned an invalid Initiative Task list");
@@ -11211,13 +11714,14 @@ function normalizeObservation(value, initiativeSlug) {
   const tasks = value.tasks.map((task, index) => {
     if (!task || typeof task !== "object")
       throw new Error(`tracker Task ${index} is invalid`);
-    if (!ID_PATTERN2.test(task.task_id))
+    if (!ID_PATTERN3.test(task.task_id))
       throw new Error(`tracker Task ${index} has an invalid task_id`);
-    if (!ID_PATTERN2.test(task.slice_id))
+    if (!ID_PATTERN3.test(task.slice_id))
       throw new Error(`tracker Task ${index} has an invalid slice_id`);
-    if (!Number.isSafeInteger(task.issue_number) || task.issue_number <= 0)
+    const issueNumber = task.issue_number;
+    if (!local && (!Number.isSafeInteger(issueNumber) || issueNumber <= 0))
       throw new Error(`tracker Task ${task.task_id} has an invalid Issue number`);
-    if (!Array.isArray(task.blocked_by) || task.blocked_by.some((id) => typeof id !== "string" || !ID_PATTERN2.test(id)))
+    if (!Array.isArray(task.blocked_by) || task.blocked_by.some((id) => typeof id !== "string" || !ID_PATTERN3.test(id)))
       throw new Error(`tracker Task ${task.task_id} has invalid blocked_by dependencies`);
     if (taskIds.has(task.task_id))
       throw new Error(`tracker returned duplicate Task ${task.task_id}`);
@@ -11273,8 +11777,8 @@ function budget(input, enrollableCount) {
   const qaFailureLimit = input.budget?.qa_failure_limit === undefined ? DEFAULT_QA_FAILURE_LIMIT : positiveSafeInteger(input.budget.qa_failure_limit, "budget.qa_failure_limit");
   return { max_children: maxChildren, qa_failure_limit: qaFailureLimit };
 }
-async function projectBatchPlan(root, initiativeSlug, input, readInitiative = observeGithubInitiative) {
-  if (!ID_PATTERN2.test(initiativeSlug))
+async function projectBatchPlan(root, initiativeSlug, input, readInitiative = observeInitiative) {
+  if (!ID_PATTERN3.test(initiativeSlug))
     throw new Error("initiative_slug is invalid");
   if (!input || typeof input !== "object")
     throw new Error("batch plan input is required");
@@ -11283,6 +11787,7 @@ async function projectBatchPlan(root, initiativeSlug, input, readInitiative = ob
   const order = dependencyOrder(trackerObservation);
   const closures = dependencyClosures(order);
   const children = [];
+  const scopeHints = new Map;
   for (const task of order) {
     const blockedBy = closures.get(task.task_id);
     const child = { task_id: task.task_id, slice_id: task.slice_id, blocked_by: blockedBy };
@@ -11324,6 +11829,7 @@ async function projectBatchPlan(root, initiativeSlug, input, readInitiative = ob
         });
         continue;
       }
+      scopeHints.set(task.task_id, [...read.intent.scope_hint]);
       children.push({
         ...child,
         status: "enrollable",
@@ -11369,7 +11875,12 @@ async function projectBatchPlan(root, initiativeSlug, input, readInitiative = ob
     children,
     enrollable,
     plan_digest: planDigest,
-    budget: budget(input, enrollable.length)
+    budget: budget(input, enrollable.length),
+    ...projectParallelGroups(enrollable.map((child) => ({
+      task_id: child.task_id,
+      blocked_by: child.blocked_by,
+      scope_hint: scopeHints.get(child.task_id)
+    })))
   };
 }
 
@@ -11399,8 +11910,8 @@ function findResumableBatchSlugForTask(root, taskId) {
     if (!file.endsWith(".json"))
       continue;
     try {
-      const record = JSON.parse(readFileSync13(join13(batchesDir, file), "utf8"));
-      if (record?.contract !== "assurance_kernel/batch_run_state/v1")
+      const record = JSON.parse(readFileSync14(join13(batchesDir, file), "utf8"));
+      if (record?.contract !== "assurance_kernel/batch_run_state/v1" && record?.contract !== "assurance_kernel/batch_run_state/v2")
         continue;
       if (record.batch_state !== "running" && record.batch_state !== "needs_human")
         continue;
@@ -11421,31 +11932,23 @@ function findExistingActiveBatch(root, initiativeSlug) {
       continue;
     let record;
     try {
-      record = JSON.parse(readFileSync13(join13(batchesDir, file), "utf8"));
+      record = JSON.parse(readFileSync14(join13(batchesDir, file), "utf8"));
     } catch {
       return { corrupt: true, path: file };
     }
     const candidate = record;
-    if (candidate?.contract !== "assurance_kernel/batch_run_state/v1")
+    if (candidate?.contract !== "assurance_kernel/batch_run_state/v1" && candidate?.contract !== "assurance_kernel/batch_run_state/v2")
       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 };
     }
     if (isTerminalBatchState(candidate.batch_state))
       continue;
     try {
-      const record = readBatchRunState(root, file.slice(0, -5));
+      const record = readAnyBatchRunState(root, file.slice(0, -5));
       if (record)
         return { corrupt: false, record };
     } catch {}
@@ -11463,12 +11966,12 @@ function findSettledBatchRecord(root, initiativeSlug) {
       continue;
     let record;
     try {
-      record = JSON.parse(readFileSync13(join13(batchesDir, file), "utf8"));
+      record = JSON.parse(readFileSync14(join13(batchesDir, file), "utf8"));
     } catch {
       continue;
     }
     const candidate = record;
-    if (candidate?.contract !== "assurance_kernel/batch_run_state/v1")
+    if (candidate?.contract !== "assurance_kernel/batch_run_state/v1" && candidate?.contract !== "assurance_kernel/batch_run_state/v2")
       continue;
     if (candidate.initiative_slug !== initiativeSlug)
       continue;
@@ -11612,6 +12115,8 @@ async function projectPlanSurface(input) {
   let recoveryChildren = [];
   let planDigest;
   let excluded = [];
+  let parallelGroups = [];
+  let scopeConflicts = [];
   const riskByTask = new Map;
   let budget;
   if (isResuming && existingBatch) {
@@ -11645,7 +12150,7 @@ async function projectPlanSurface(input) {
           }
         }
         riskByTask.set(c.task_id, read.intent?.risk ?? "material");
-        const isDone = c.state === "committed" || c.state === "settled";
+        const isDone = ["committed", "settled", "integrated", "released"].includes(c.state);
         return {
           task_id: c.task_id,
           slice_id: c.slice_id,
@@ -11680,6 +12185,8 @@ async function projectPlanSurface(input) {
     if (!plan.enrollable.length)
       return { ok: false, key: "empty_enrollable_set", detail: "" };
     budget = plan.budget;
+    parallelGroups = plan.parallel_groups;
+    scopeConflicts = plan.scope_conflicts;
     const enrollableChildById = new Map(plan.enrollable.map((c) => [c.task_id, c]));
     recoveryChildren = plan.children.filter((c) => c.status === "enrollable").map((c) => {
       const digestChild = enrollableChildById.get(c.task_id);
@@ -11705,7 +12212,9 @@ async function projectPlanSurface(input) {
       plan_digest: planDigest,
       recovery_children: recoveryChildren,
       risk_by_task: Object.fromEntries([...riskByTask.entries()].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)),
-      excluded
+      excluded,
+      parallel_groups: parallelGroups,
+      scope_conflicts: scopeConflicts
     }
   };
 }
@@ -11785,11 +12294,11 @@ async function projectBatchPreflight(options) {
   if (!planSurface.ok)
     return reject(planSurface.key, planSurface.detail);
   let reconfirmation;
-  if (activeRecord && activeRecord.plan_digest !== planSurface.surface.plan_digest) {
+  if (activeRecord && !isLaneBatchRecord(activeRecord) && activeRecord.plan_digest !== planSurface.surface.plan_digest) {
     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 = {
@@ -11802,7 +12311,9 @@ async function projectBatchPreflight(options) {
     plan_digest: planSurface.surface.plan_digest,
     recovery_children: planSurface.surface.recovery_children,
     risk_by_task: planSurface.surface.risk_by_task,
-    excluded: planSurface.surface.excluded
+    excluded: planSurface.surface.excluded,
+    parallel_groups: planSurface.surface.parallel_groups,
+    scope_conflicts: planSurface.surface.scope_conflicts
   };
   if (reconfirmation)
     Object.defineProperty(projection, "reconfirmation", { value: reconfirmation });
@@ -11849,7 +12360,7 @@ async function authorizeBatch(options) {
   const branchBefore = spawnSync7("git", ["-C", root, "branch", "--show-current"], { encoding: "utf8" });
   if (branchBefore.status !== 0)
     return { outcome: "rejected", rejection: batchRejection("repository_became_unreadable") };
-  const ownsUnpersistedHead = isResuming && existingBatch !== null && existingBatch.plan_digest === planDigest && expectedBatchHead(existingBatch) !== baseHead && ownUnpersistedBatchHead(root, existingBatch, baseHead);
+  const ownsUnpersistedHead = isResuming && existingBatch !== null && !isLaneBatchRecord(existingBatch) && existingBatch.plan_digest === planDigest && expectedBatchHead(existingBatch) !== baseHead && ownUnpersistedBatchHead(root, existingBatch, baseHead);
   const fastForwardsRecordedHead = isResuming && existingBatch !== null && existingBatch.branch === batchBranch && expectedBatchHead(existingBatch) !== baseHead && !ownsUnpersistedHead && classifyBatchLineage({
     root,
     branch: batchBranch,
@@ -11884,7 +12395,9 @@ async function authorizeBatch(options) {
       risk: projection.risk_by_task[child.task_id] ?? "material",
       status: child.status
     })),
-    excluded: projection.excluded
+    excluded: projection.excluded,
+    parallel_groups: projection.parallel_groups,
+    scope_conflicts: projection.scope_conflicts
   };
   let requestId = null;
   if (!reuseAuthorization) {
@@ -11951,9 +12464,9 @@ async function authorizeBatch(options) {
 }
 
 // plugins/immune-brain/runtime/unattended/batch_runner.ts
-import { spawnSync as spawnSync9 } from "node:child_process";
-import { existsSync as existsSync10 } from "node:fs";
-import { join as join15 } from "node:path";
+import { spawnSync as spawnSync11 } from "node:child_process";
+import { existsSync as existsSync11 } from "node:fs";
+import { join as join16 } from "node:path";
 
 // plugins/immune-brain/runtime/unattended/batch_git.ts
 import { spawnSync as spawnSync8 } from "node:child_process";
@@ -11962,7 +12475,7 @@ import {
   constants as constants6,
   closeSync as closeSync7,
   existsSync as existsSync9,
-  lstatSync as lstatSync10,
+  lstatSync as lstatSync11,
   mkdirSync as mkdirSync7,
   openSync as openSync7,
   realpathSync as realpathSync11,
@@ -12190,7 +12703,7 @@ function ensureSecureDirectory3(root, relativePath) {
   for (const segment of segments) {
     current = join14(current, segment);
     if (existsSync9(current)) {
-      const stats = lstatSync10(current);
+      const stats = lstatSync11(current);
       if (stats.isSymbolicLink() || !stats.isDirectory()) {
         throw new Error(`${segment} exists but is not a real directory`);
       }
@@ -12204,12 +12717,12 @@ function writeFileAtomically2(root, relativePath, bytes) {
   const target = join14(root, relativePath);
   const targetDir = dirname8(target);
   ensureSecureDirectory3(root, dirname8(relativePath));
-  const stats = lstatSync10(targetDir);
+  const stats = lstatSync11(targetDir);
   if (stats.isSymbolicLink() || !stats.isDirectory()) {
     throw new Error(`${dirname8(relativePath)} is not a real directory`);
   }
   if (existsSync9(target)) {
-    const targetStats = lstatSync10(target);
+    const targetStats = lstatSync11(target);
     if (targetStats.isSymbolicLink()) {
       throw new Error(`${relativePath} is a symlink`);
     }
@@ -12518,40 +13031,958 @@ function createDefaultBatchGitPort() {
   };
 }
 
-// plugins/immune-brain/runtime/unattended/batch_runner.ts
-function batchQaFailureFacts(record) {
-  const failed = record.history.filter((event) => event.type === "request_rework" && event.authority?.authority_kind === "qa");
-  return {
-    qa_failure_count: failed.length,
-    last_qa_failure_at: failed.at(-1)?.at ?? null,
-    recovery_findings: record.findings.filter((f) => f.status === "open").map((f) => ({ id: f.id, kind: f.kind, status: f.status, acceptance_id: f.acceptance_id }))
-  };
+// plugins/immune-brain/runtime/unattended/batch_lanes.ts
+import { spawnSync as spawnSync10 } from "node:child_process";
+import { existsSync as existsSync10, realpathSync as realpathSync12 } from "node:fs";
+import { isAbsolute as isAbsolute6, join as join15 } from "node:path";
+
+// plugins/immune-brain/runtime/unattended/batch_integration.ts
+import { spawnSync as spawnSync9 } from "node:child_process";
+class BatchIntegrationError extends Error {
+  reason;
+  constructor(reason, message) {
+    super(message);
+    this.reason = reason;
+    this.name = "BatchIntegrationError";
+  }
 }
-function batchGitPortOf(input) {
-  return input.git ?? createDefaultBatchGitPort();
+var COMMITTER_ENV = {
+  GIT_COMMITTER_NAME: process.env.GIT_COMMITTER_NAME || "Immune-Brain Batch",
+  GIT_COMMITTER_EMAIL: process.env.GIT_COMMITTER_EMAIL || "immune-brain@local"
+};
+function git5(root, args, extra = {}) {
+  const result = spawnSync9("git", ["-C", root, "-c", "core.hooksPath=/dev/null", "-c", "commit.gpgsign=false", ...args], {
+    encoding: "utf8",
+    stdio: ["pipe", "pipe", "pipe"],
+    input: extra.input,
+    env: { ...process.env, ...COMMITTER_ENV, ...extra.env ?? {} }
+  });
+  return { status: result.status, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
 }
-function dependentsOf(record, taskId) {
-  return record.children.filter((child) => child.blocked_by.includes(taskId));
+function gitOut(root, args, what) {
+  const result = git5(root, args);
+  if (result.status !== 0)
+    throw new Error(`${what}: ${result.stderr.trim() || "git failed"}`);
+  return result.stdout;
 }
-function skipDependents(record, taskId, reason) {
-  const skip = new Set([taskId]);
-  const queue = [taskId];
-  while (queue.length > 0) {
-    const current = queue.shift();
-    for (const dependent of dependentsOf(record, current)) {
-      if (skip.has(dependent.task_id))
-        continue;
-      skip.add(dependent.task_id);
-      queue.push(dependent.task_id);
-    }
+function changeIdentity(root, from, to) {
+  const raw = gitOut(root, ["diff-tree", "-r", "-z", "--raw", "--no-renames", "--no-ext-diff", "--no-commit-id", from, to], `failed to inspect change ${from}..${to}`);
+  const tokens = raw.split("\x00");
+  const identity = new Map;
+  for (let index = 0;index < tokens.length; index += 1) {
+    const meta = tokens[index];
+    if (!meta.startsWith(":"))
+      continue;
+    const [, newMode, , newSha] = meta.slice(1).split(" ");
+    const path = tokens[index + 1];
+    if (path === undefined || !newMode || !newSha)
+      throw new Error(`unreadable change record for ${from}..${to}`);
+    identity.set(path, `${newMode} ${newSha}`);
+    index += 1;
   }
-  record.children = record.children.map((child) => skip.has(child.task_id) && child.state === "pending" ? { ...child, state: "skipped_blocked", reason } : child);
+  return identity;
 }
-function budgetStopReason(record) {
-  const enrolledCount = record.children.filter((child) => child.state !== "pending" && child.state !== "skipped_blocked").length;
-  if (enrolledCount >= record.budget.max_children)
-    return `max_children budget exhausted (${record.budget.max_children})`;
-  return null;
+function identitiesEqual(left, right) {
+  if (left.size !== right.size)
+    return false;
+  for (const [path, value] of left)
+    if (right.get(path) !== value)
+      return false;
+  return true;
+}
+function singleParent(root, commit) {
+  const parents = gitOut(root, ["rev-parse", `${commit}^@`], `failed to read parents of ${commit}`).split(/\s+/).filter(Boolean);
+  if (parents.length !== 1)
+    throw new BatchIntegrationError("batch_head_lineage_broken", `batch_head_lineage_broken: lane commit ${commit} has ${parents.length} parents, expected exactly one`);
+  return parents[0];
+}
+function isAncestor(root, ancestor, descendant) {
+  return git5(root, ["merge-base", "--is-ancestor", ancestor, descendant]).status === 0;
+}
+function buildCandidate(input) {
+  const { root, batch_head: head, lane_base: base, lane_commit: laneCommit } = input;
+  if (head === base)
+    return laneCommit;
+  const merged = git5(root, ["merge-tree", "--write-tree", `--merge-base=${base}`, head, laneCommit]);
+  if (merged.status === 1)
+    throw new BatchIntegrationError("batch_integration_conflict", `batch_integration_conflict: lane commit ${laneCommit} does not apply cleanly onto batch head ${head}`);
+  if (merged.status !== 0)
+    throw new Error(`failed to build integration candidate: ${merged.stderr.trim() || "git merge-tree failed"}`);
+  const tree = merged.stdout.split(`
+`)[0]?.trim();
+  if (!tree)
+    throw new Error("failed to build integration candidate: no tree produced");
+  const message = gitOut(root, ["log", "-n", "1", "--format=%B", laneCommit], "failed to read lane commit message");
+  const author = gitOut(root, ["log", "-n", "1", "--format=%an%x00%ae%x00%aI", laneCommit], "failed to read lane commit author").trim().split("\x00");
+  const created = git5(root, ["commit-tree", tree, "-p", head, "-F", "-"], {
+    input: message,
+    env: {
+      GIT_AUTHOR_NAME: author[0] ?? COMMITTER_ENV.GIT_COMMITTER_NAME,
+      GIT_AUTHOR_EMAIL: author[1] ?? COMMITTER_ENV.GIT_COMMITTER_EMAIL,
+      ...author[2] ? { GIT_AUTHOR_DATE: author[2] } : {}
+    }
+  });
+  const candidate = created.stdout.trim();
+  if (created.status !== 0 || !candidate)
+    throw new Error(`failed to build integration candidate: ${created.stderr.trim() || "git commit-tree failed"}`);
+  return candidate;
+}
+function prepareLaneCandidate(input) {
+  const { root, branch, batch_head: head, lane_base: base, lane_commit: laneCommit } = input;
+  const currentBranch = git5(root, ["symbolic-ref", "--short", "HEAD"]);
+  if (currentBranch.status !== 0 || currentBranch.stdout.trim() !== branch)
+    throw new BatchIntegrationError("batch_head_lineage_broken", `batch_head_lineage_broken: current branch ${currentBranch.stdout.trim()} does not match expected branch ${branch}`);
+  const currentHead = git5(root, ["rev-parse", "HEAD"]).stdout.trim();
+  if (currentHead !== head)
+    throw new BatchIntegrationError("batch_head_lineage_broken", `batch_head_lineage_broken: current HEAD ${currentHead} does not match expected batch head ${head}`);
+  if (singleParent(root, laneCommit) !== base)
+    throw new BatchIntegrationError("batch_head_lineage_broken", `batch_head_lineage_broken: lane commit ${laneCommit} does not descend from lane base ${base}`);
+  if (!isAncestor(root, base, head))
+    throw new BatchIntegrationError("batch_head_lineage_broken", `batch_head_lineage_broken: lane base ${base} is not an ancestor of batch head ${head}`);
+  const candidate = buildCandidate({ root, batch_head: head, lane_base: base, lane_commit: laneCommit });
+  if (!identitiesEqual(changeIdentity(root, base, laneCommit), changeIdentity(root, head, candidate)))
+    throw new BatchIntegrationError("batch_integration_conflict", `batch_integration_conflict: candidate ${candidate} does not carry the lane commit ${laneCommit} change`);
+  return candidate;
+}
+function fastForwardToCandidate(root, candidate) {
+  const moved = git5(root, ["merge", "--ff-only", "--quiet", candidate]);
+  if (moved.status !== 0)
+    throw new BatchIntegrationError("batch_integration_conflict", `batch_integration_conflict: batch branch could not fast-forward to ${candidate}: ${moved.stderr.trim() || "git merge failed"}`);
+  const landed = git5(root, ["rev-parse", "HEAD"]).stdout.trim();
+  if (landed !== candidate)
+    throw new Error(`batch branch landed on ${landed}, expected ${candidate}`);
+  return { commit: candidate };
+}
+function commitsBetween(root, from, to) {
+  return new Set(gitOut(root, ["rev-list", `${from}..${to}`], `failed to list commits ${from}..${to}`).split(/\s+/).filter(Boolean));
+}
+function readCandidateAcceptance(root, candidate, check) {
+  if (!check.intent_path)
+    throw new BatchIntegrationError("batch_integration_check_failed", `batch_integration_check_failed: ${check.task_id} has no intent to rerun`);
+  const shown = git5(root, ["show", `${candidate}:${check.intent_path}`]);
+  if (shown.status !== 0)
+    throw new BatchIntegrationError("batch_integration_check_failed", `batch_integration_check_failed: intent ${check.intent_path} of ${check.task_id} is absent from candidate ${candidate}`);
+  try {
+    const intent = parseTaskIntentV1(JSON.parse(shown.stdout));
+    return intent.acceptance.map((item) => ({ id: `${check.task_id}:${item.id}`, assertion: item.assertion, verification: item.verification }));
+  } catch (error) {
+    throw new BatchIntegrationError("batch_integration_check_failed", `batch_integration_check_failed: intent of ${check.task_id} is unreadable in candidate ${candidate}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function verifyCandidateDescriptors(input) {
+  const { root, candidate } = input;
+  const since = commitsBetween(root, input.lane_base, input.batch_head);
+  const checks = [input.child, ...input.siblings.filter((sibling) => sibling.commit !== null && since.has(sibling.commit))];
+  const acceptance = checks.flatMap((check) => readCandidateAcceptance(root, candidate, check));
+  const descriptors = new Map;
+  try {
+    for (const item of acceptance)
+      descriptors.set(item.id, parseVerificationDescriptor(item.verification));
+  } catch (error) {
+    throw new BatchIntegrationError("batch_integration_check_failed", `batch_integration_check_failed: a verification descriptor is invalid: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (acceptance.length === 0)
+    throw new BatchIntegrationError("batch_integration_check_failed", "batch_integration_check_failed: no descriptor to rerun");
+  const tree = gitOut(root, ["rev-parse", `${candidate}^{tree}`], `failed to read the tree of ${candidate}`).trim();
+  const snapshot = {
+    contract: "assurance_kernel/assurance_snapshot/v2",
+    task_id: input.child.task_id,
+    run_id: null,
+    role: "qa",
+    record_revision: "",
+    workspace_revision: "",
+    intent_revision: 0,
+    intent_content_hash: "",
+    diff_hash: "",
+    lifecycle: "active",
+    artifact_state: "frozen",
+    risk: "material",
+    fresh_acceptance_ids: [],
+    missing_acceptance_ids: [],
+    stale_attestation_ids: [],
+    acceptance,
+    dirty_files: [],
+    review_bundle_digest: null,
+    review_revision: {
+      contract: "assurance_kernel/review_revision_identity/v1",
+      base_head: input.lane_base,
+      review_commit: candidate,
+      review_tree: tree,
+      manifest_digest: ""
+    },
+    root
+  };
+  let verdict;
+  try {
+    verdict = await runDeterministicQa(snapshot, descriptors, { signal: input.signal });
+  } catch (error) {
+    if (error instanceof VerificationAbortedError)
+      throw error;
+    throw new BatchIntegrationError("batch_integration_check_failed", `batch_integration_check_failed: the descriptor rerun could not complete: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (verdict.decision !== "pass")
+    throw new BatchIntegrationError("batch_integration_check_failed", `batch_integration_check_failed: ${(verdict.findings ?? []).map((finding) => finding.acceptance_id).join(", ") || "a descriptor"} failed on candidate ${candidate}`);
+}
+async function integrateGuardedLaneCommit(input) {
+  const candidate = prepareLaneCandidate(input);
+  await verifyCandidateDescriptors({
+    root: input.root,
+    candidate,
+    lane_base: input.lane_base,
+    batch_head: input.batch_head,
+    child: input.child,
+    siblings: input.siblings,
+    signal: input.signal
+  });
+  return fastForwardToCandidate(input.root, candidate);
+}
+function findIntegratedCandidate(input) {
+  const { root, task_id: taskId, batch_id: batchId, from_head: from, lane_base: base, lane_commit: laneCommit } = input;
+  const listed = git5(root, [
+    "log",
+    "--fixed-strings",
+    `--grep=imm(${taskId}):`,
+    "--format=%x01%H%x00%(trailers:key=Immune-Brain-Batch,valueonly)%x00%s",
+    `${from}..HEAD`
+  ]);
+  if (listed.status !== 0)
+    throw new Error(`failed to search for integrated ${taskId}: ${listed.stderr.trim()}`);
+  const lane = changeIdentity(root, base, laneCommit);
+  for (const record of listed.stdout.split("\x01")) {
+    const [commit, trailer, subject] = record.split("\x00");
+    if (!commit || trailer?.trim() !== batchId || !subject?.trim().startsWith(`imm(${taskId}):`))
+      continue;
+    const parent = git5(root, ["rev-parse", `${commit}^`]).stdout.trim();
+    if (parent && identitiesEqual(lane, changeIdentity(root, parent, commit)))
+      return commit;
+  }
+  return null;
+}
+
+// plugins/immune-brain/runtime/unattended/batch_lanes.ts
+var PARALLEL_MISMATCH = "batch_parallel_mismatch";
+var TASK_ID_PATTERN2 = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+var MAX_LANE_OFFERS = 64;
+var MAX_PATH_LENGTH = 4096;
+function resolveLaneParallel(root, initiativeSlug, maxParallel, laneOffers) {
+  if (maxParallel !== undefined || laneOffers === undefined)
+    return maxParallel;
+  const lookup = findExistingActiveBatch(root, initiativeSlug);
+  if (lookup === null || lookup.corrupt || !isLaneBatchRecord(lookup.record))
+    throw new Error("lane_offers requires max_parallel unless a recorded lane batch is being resumed");
+  return lookup.record.max_parallel;
+}
+function parseMaxParallel(value) {
+  if (value === undefined || value === null)
+    return;
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0)
+    throw new Error("invalid max_parallel: expected a positive integer");
+  return value;
+}
+function parseLaneOffers(value) {
+  if (value === undefined || value === null)
+    return;
+  if (!Array.isArray(value))
+    throw new Error("invalid lane_offers: expected an array");
+  if (value.length > MAX_LANE_OFFERS)
+    throw new Error(`invalid lane_offers: at most ${MAX_LANE_OFFERS} offers`);
+  const seen = new Set;
+  return value.map((entry) => {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry))
+      throw new Error("invalid lane_offers: each offer must be an object");
+    const { task_id: taskId, path, ...rest } = entry;
+    if (Object.keys(rest).length > 0)
+      throw new Error("invalid lane_offers: unknown offer field");
+    if (typeof taskId !== "string" || !TASK_ID_PATTERN2.test(taskId))
+      throw new Error("invalid lane_offers: task_id is not a valid task id");
+    if (typeof path !== "string" || !path || path.length > MAX_PATH_LENGTH || path.includes("\x00") || !isAbsolute6(path))
+      throw new Error("invalid lane_offers: path must be an absolute path");
+    if (seen.has(taskId))
+      throw new Error(`invalid lane_offers: duplicate offer for ${taskId}`);
+    seen.add(taskId);
+    return { task_id: taskId, path };
+  });
+}
+function laneBranchName(initiativeSlug, taskId) {
+  return `imm-lane/${initiativeSlug}/${taskId}`;
+}
+function gitRead(root, args) {
+  const result = spawnSync10("git", ["-C", root, ...args], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+  return { status: result.status, stdout: (result.stdout ?? "").trim() };
+}
+function commonDir(root) {
+  const result = gitRead(root, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
+  if (result.status !== 0 || !result.stdout)
+    return null;
+  try {
+    return realpathSync12(result.stdout);
+  } catch {
+    return null;
+  }
+}
+function resolveRealPath(path) {
+  try {
+    return realpathSync12(path);
+  } catch {
+    return null;
+  }
+}
+function createDefaultLaneGitPort() {
+  return {
+    resolveRoot: (root) => resolveRealPath(root) ?? root,
+    inspectLane(coordinatorRoot, lanePath) {
+      const real = existsSync10(lanePath) ? resolveRealPath(lanePath) : null;
+      const absent = {
+        exists: real !== null,
+        real_path: real,
+        same_repository: false,
+        is_worktree_root: false,
+        branch: null,
+        head: null,
+        clean: false,
+        active_claim_task_id: null
+      };
+      if (!real)
+        return absent;
+      const laneCommon = commonDir(real);
+      const coordinatorCommon = commonDir(coordinatorRoot);
+      if (!laneCommon || !coordinatorCommon || laneCommon !== coordinatorCommon)
+        return absent;
+      const top = gitRead(real, ["rev-parse", "--show-toplevel"]);
+      const topReal = top.status === 0 ? resolveRealPath(top.stdout) : null;
+      const branch = gitRead(real, ["symbolic-ref", "--short", "HEAD"]);
+      const head = gitRead(real, ["rev-parse", "HEAD"]);
+      const status = gitRead(real, ["status", "--porcelain", "--untracked-files=all", "--ignore-submodules=none"]);
+      let activeClaim = null;
+      try {
+        activeClaim = readActiveClaimTaskId(real);
+      } catch {
+        activeClaim = "unreadable";
+      }
+      return {
+        exists: true,
+        real_path: real,
+        same_repository: true,
+        is_worktree_root: topReal === real,
+        branch: branch.status === 0 ? branch.stdout : null,
+        head: head.status === 0 ? head.stdout : null,
+        clean: status.status === 0 && status.stdout === "",
+        active_claim_task_id: activeClaim
+      };
+    },
+    integrate: integrateGuardedLaneCommit,
+    findIntegrated: findIntegratedCandidate,
+    auditReachable({ root, head, task_id }) {
+      const listing = gitRead(root, ["ls-tree", "-r", "--name-only", head, "--", `.imm/audit/${task_id}`]);
+      if (listing.status !== 0)
+        return false;
+      const files = listing.stdout.split(`
+`);
+      const runDirs = new Set(files.map((file) => file.slice(0, file.lastIndexOf("/"))));
+      return [...runDirs].some((dir) => files.includes(`${dir}/task-record.json`) && files.includes(`${dir}/terminal-proof.json`));
+    }
+  };
+}
+function decideLaneAdmission(input) {
+  const { facts } = input;
+  if (!facts.exists || !facts.real_path || !facts.same_repository || !facts.is_worktree_root)
+    return "batch_lane_foreign_repository";
+  if (facts.real_path === input.coordinator_real_path)
+    return "batch_lane_is_coordinator";
+  if (facts.branch !== input.expected_branch)
+    return "batch_lane_branch_mismatch";
+  if (facts.head !== input.batch_head)
+    return "batch_lane_base_mismatch";
+  if (!facts.clean)
+    return "batch_lane_dirty";
+  if (facts.active_claim_task_id !== null || input.bound_paths.includes(facts.real_path))
+    return "batch_lane_occupied";
+  return null;
+}
+function laneGitOf(input) {
+  return input.git?.lane ?? createDefaultLaneGitPort();
+}
+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.is_worktree_root || !facts.clean || facts.branch !== child.lane.branch || facts.active_claim_task_id !== null)
+      continue;
+    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 });
+  }
+  return handoffs;
+}
+function defaultSerialGit() {
+  return createDefaultBatchGitPort();
+}
+var IN_FLIGHT = new Set(["lane_admitted", "enrolled", "settled", "lane_committed"]);
+function dependentsOf(record, taskId) {
+  return record.children.filter((child) => child.blocked_by.includes(taskId));
+}
+function skipDependents(record, taskId, reason) {
+  const skip = new Set([taskId]);
+  const queue = [taskId];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    for (const dependent of dependentsOf(record, current)) {
+      if (skip.has(dependent.task_id))
+        continue;
+      skip.add(dependent.task_id);
+      queue.push(dependent.task_id);
+    }
+  }
+  record.children = record.children.map((child) => skip.has(child.task_id) && child.state === "pending" ? { ...child, state: "skipped_blocked", reason } : child);
+}
+function consumedSlots(record) {
+  return record.children.filter((child) => child.state !== "pending" && child.state !== "skipped_blocked").length;
+}
+function scopeOfChild(root, child) {
+  try {
+    return [...readTaskIntent(root, child.task_id, child.intent_path ?? undefined).intent.scope_hint];
+  } catch {
+    return ["**"];
+  }
+}
+function scheduleView(input, record) {
+  return record.children.map((child) => ({
+    task_id: child.task_id,
+    state: child.state,
+    blocked_by: child.blocked_by,
+    scope_hint: scopeOfChild(input.root, input.children.find((c) => c.task_id === child.task_id) ?? { task_id: child.task_id, intent_path: null })
+  }));
+}
+var LANE_NEEDS_HUMAN_NEXT_ACTION = "The lane batch has stopped on a parked child and its Lane is kept. Resolve the child by hand; continuing needs a new Batch Authorization.";
+var TERMINAL_NEXT_ACTIONS = {
+  completed: "The batch integrated every enrollable child; review the commits and the tracker.",
+  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."
+};
+function laneReport(record, reason, nextAction, extra = {}) {
+  return {
+    contract: "assurance_kernel/batch_run_report/v1",
+    batch_id: record.batch_id,
+    initiative_slug: record.initiative_slug,
+    batch_state: record.batch_state,
+    max_parallel: record.max_parallel,
+    children: record.children,
+    commits: record.commits,
+    reason,
+    handoffs: extra.handoffs ?? [],
+    ...extra.refusals?.length ? { lane_refusals: extra.refusals } : {},
+    next_action: nextAction || (TERMINAL_NEXT_ACTIONS[record.batch_state] ?? "Inspect the batch run state."),
+    created_at: record.updated_at
+  };
+}
+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);
+  if (isTerminalBatchState(record.batch_state) || record.batch_state === "needs_human")
+    writeBatchRunReport(root, report);
+  return report;
+}
+function refuse2(input, persisted, code, detail) {
+  const base = persisted && isLaneBatchRecord(persisted) ? persisted : prepareBatchLaneRunState({
+    batch_id: input.batch_id,
+    initiative_slug: input.initiative_slug,
+    children: persisted ? [] : input.children,
+    plan_digest: input.plan_digest,
+    base_head: input.base_head,
+    confirmation_time: input.confirmation_time,
+    budget: input.budget,
+    max_parallel: input.max_parallel ?? 1,
+    now: input.now
+  });
+  return laneReport({ ...base, batch_state: "rejected" }, `${code}: ${detail}`, "Correct the lane-mode parameters and call start_unattended_batch again.");
+}
+function assertPlanMatches(input, record) {
+  const plan = input.registry.children(input.capability);
+  if (record.plan_digest !== computeBatchPlanDigest(plan) || record.children.length !== plan.length || record.children.some((child, index) => {
+    const expected = plan[index];
+    return child.task_id !== expected.task_id || JSON.stringify(child.blocked_by) !== JSON.stringify(expected.blocked_by);
+  }))
+    throw new Error("plan_digest mismatch: persisted children do not match the authorized plan");
+}
+function validateNewAuthorization(input) {
+  try {
+    const authorized = input.kernel.validateBatchAuthorization({
+      registry: input.registry,
+      capability: input.capability,
+      binding: {
+        batch_id: input.batch_id,
+        plan_digest: input.plan_digest,
+        base_head: input.base_head,
+        initiative_slug: input.initiative_slug,
+        budget: input.budget
+      }
+    });
+    if (authorized.issued_at !== input.confirmation_time)
+      return "the parked batch requires a fresh literal-user confirmation";
+    const children = input.children.map((child) => {
+      const { intent_path, intent_revision, intent_content_hash } = child;
+      if (intent_path === null || intent_revision === null || intent_content_hash === null)
+        throw new Error(`batch child ${child.task_id} has no complete intent identity`);
+      return { ...child, intent_path, intent_revision, intent_content_hash };
+    });
+    if (computeBatchPlanDigest(children) !== authorized.plan_digest || input.plan_digest !== authorized.plan_digest || input.base_head !== authorized.base_head)
+      return "batch run input does not match the authorized plan or base_head";
+    return null;
+  } catch (error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+}
+function rehydrateConsumption(input, record) {
+  const { issued_at: _issuedAt, ...binding } = input.kernel.validateBatchAuthorization({
+    registry: input.registry,
+    capability: input.capability,
+    binding: {
+      batch_id: record.batch_id,
+      plan_digest: record.plan_digest,
+      base_head: record.base_head,
+      initiative_slug: record.initiative_slug,
+      budget: record.budget
+    }
+  });
+  for (const child of record.children) {
+    if (child.state === "pending" || child.state === "skipped_blocked" || child.state === "lane_admitted")
+      continue;
+    if (!input.registry.isChildConsumed(input.capability, child.task_id))
+      input.registry.consumeChild(input.capability, binding, child.task_id);
+  }
+}
+function failLineage(root, record, message) {
+  const next = {
+    ...record,
+    batch_state: "failed",
+    children: record.children.map((child) => IN_FLIGHT.has(child.state) ? { ...child, state: "needs_human", reason: message } : child)
+  };
+  for (const child of next.children)
+    if (child.state === "needs_human")
+      skipDependents(next, child.task_id, `dependency ${child.task_id} parked`);
+  return finalizeLane(root, writeBatchLaneRunState(root, next), message, "");
+}
+function park(record, taskId, reason) {
+  record.children = record.children.map((child) => child.task_id === taskId ? { ...child, state: "needs_human", reason } : child);
+  skipDependents(record, taskId, `dependency ${taskId} parked`);
+}
+function isLineageBreak(message) {
+  return message.includes("batch_head_lineage_broken");
+}
+async function runLaneBatch(input, persisted) {
+  if (persisted && !isLaneBatchRecord(persisted))
+    return refuse2(input, persisted, PARALLEL_MISMATCH, "the recorded batch runs serially; max_parallel cannot be added on a resume");
+  if (persisted && input.max_parallel !== undefined && input.max_parallel !== persisted.max_parallel)
+    return refuse2(input, persisted, PARALLEL_MISMATCH, `the recorded batch runs with max_parallel ${persisted.max_parallel}`);
+  const limit = persisted?.max_parallel ?? input.max_parallel ?? 1;
+  if (!input.children.length)
+    return refuse2(input, persisted, "batch_plan_empty", "batch plan is empty");
+  const git = serialGitOf(input);
+  const lanes = laneGitOf(input);
+  let record;
+  if (persisted) {
+    record = persisted;
+    assertPlanMatches(input, record);
+    if (isTerminalBatchState(record.batch_state))
+      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") {
+      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)
+      return refuse2(input, null, "batch_authorization_invalid", invalid);
+    const preflight = await git.preflight({
+      root: input.root,
+      initiative_slug: input.initiative_slug,
+      base_head: input.base_head
+    });
+    if (!preflight.ok)
+      return refuse2(input, null, preflight.reason, preflight.message || "Correct the preflight condition and re-confirm.");
+    record = prepareBatchLaneRunState({
+      batch_id: input.batch_id,
+      initiative_slug: input.initiative_slug,
+      children: input.children,
+      plan_digest: input.plan_digest,
+      base_head: input.base_head,
+      confirmation_time: input.confirmation_time,
+      budget: input.budget,
+      max_parallel: limit,
+      now: input.now
+    });
+  }
+  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();
+  }
+  for (const child of record.children) {
+    if (child.state !== "lane_committed" || !child.lane?.lane_commit)
+      continue;
+    const found = lanes.findIntegrated({
+      root: input.root,
+      task_id: child.task_id,
+      batch_id: record.batch_id,
+      from_head: expectedBatchHead(record),
+      lane_base: child.lane.base_head,
+      lane_commit: child.lane.lane_commit
+    });
+    if (!found)
+      continue;
+    record.children = record.children.map((c) => c.task_id === child.task_id ? { ...c, state: "integrated", commit: found } : c);
+    record.commits = [...record.commits, found];
+    persist();
+  }
+  for (const child of record.children) {
+    if (child.state !== "integrated" || !child.lane)
+      continue;
+    if (lanes.inspectLane(input.root, child.lane.path).exists)
+      continue;
+    record.children = record.children.map((c) => c.task_id === child.task_id ? { ...c, state: "released" } : c);
+    persist();
+  }
+  const lineage = existsSync10(join15(input.root, ".git")) ? classifyBatchLineage({
+    root: input.root,
+    branch: record.branch ?? "",
+    expectedHead: expectedBatchHead(record),
+    childCommits: record.commits,
+    batchId: record.batch_id
+  }) : { kind: "equal", head: expectedBatchHead(record) };
+  if (lineage.kind === "broken")
+    return failLineage(input.root, record, lineage.message);
+  if (lineage.kind === "fast_forward") {
+    record = writeBatchLaneRunState(input.root, {
+      ...record,
+      adopted_heads: [...record.adopted_heads ?? [], { from: expectedBatchHead(record), to: lineage.head }]
+    });
+  }
+  try {
+    rehydrateConsumption(input, record);
+  } catch (error) {
+    return failLineage(input.root, record, error instanceof Error ? error.message : String(error));
+  }
+  if (resumedPark)
+    persist();
+  const refusals = [];
+  let parkedMessage = null;
+  const reviewOpen = [];
+  const parkChild = (taskId, reason) => {
+    park(record, taskId, reason);
+    parkedMessage ??= reason;
+    persist();
+  };
+  const enrollInLane = async (taskId) => {
+    const lane = record.children.find((c) => c.task_id === taskId).lane;
+    try {
+      await input.kernel.enrollTask({
+        root: lane.path,
+        task_id: taskId,
+        batch: { registry: input.registry, capability: input.capability, binding: { batch_id: record.batch_id, expected_head: lane.base_head } }
+      });
+      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) {
+      const message = error instanceof Error ? error.message : String(error);
+      parkChild(taskId, message);
+      if (!isLineageBreak(message))
+        return null;
+      record.batch_state = "failed";
+      persist();
+      return finalizeLane(input.root, record, message, "", { refusals });
+    }
+  };
+  for (const child of [...record.children]) {
+    if (child.state !== "lane_admitted" && child.state !== "enrolled" || !child.lane)
+      continue;
+    let fresh;
+    try {
+      fresh = await input.kernel.projectTask(child.lane.path, child.task_id);
+    } catch {
+      fresh = { error: "unreadable" };
+    }
+    if (fresh.error !== null) {
+      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", lane: { ...child.lane, run_id: fresh.projection.run_id } } : c);
+        persist();
+      } else {
+        const failed = await enrollInLane(child.task_id);
+        if (failed)
+          return failed;
+      }
+      continue;
+    }
+    if (fresh.projection.lifecycle === "done" && fresh.projection.completion_ready) {
+      record.children = record.children.map((c) => c.task_id === child.task_id ? { ...c, state: "settled", reason: null } : c);
+      persist();
+      continue;
+    }
+    if (!holdsClaim) {
+      parkChild(child.task_id, "batch_lane_lost");
+      continue;
+    }
+    if (!input.kernel.ownsTaskClaim(child.task_id)) {
+      parkChild(child.task_id, "claim held by another batch");
+      continue;
+    }
+    if (fresh.projection.next_obligation === "run_qa" || fresh.projection.artifact_state !== "frozen")
+      continue;
+    const terminal = await input.kernel.advanceTask(child.lane.path, child.task_id);
+    if (terminal.state === "completed") {
+      record.children = record.children.map((c) => c.task_id === child.task_id ? { ...c, state: "settled", reason: null, qa_failures: 0 } : c);
+      persist();
+    } else if (terminal.state === "review_ready") {
+      record.children = record.children.map((c) => c.task_id === child.task_id ? { ...c, reason: `review reservation ${terminal.operation_id} open` } : c);
+      persist();
+      reviewOpen.push(child.task_id);
+    } else if (terminal.state === "rework" && terminal.operation === "qa") {
+      const failures = child.qa_failures + 1;
+      if (failures >= record.budget.qa_failure_limit) {
+        const reason = "QA failure limit reached";
+        record.children = record.children.map((c) => c.task_id === child.task_id ? { ...c, state: "needs_human", reason, qa_failures: failures } : c);
+        skipDependents(record, child.task_id, `dependency ${child.task_id} parked`);
+        parkedMessage ??= reason;
+        persist();
+        continue;
+      }
+      record.children = record.children.map((c) => c.task_id === child.task_id ? { ...c, qa_failures: failures } : c);
+      persist();
+    } else if (terminal.state === "rework" || terminal.environment_failure || terminal.state === "review_preparation_failed" || terminal.recovery?.category === "repair") {
+      continue;
+    } else {
+      const reason = terminal.state === "stopped" ? "Kernel reported the child stopped" : terminal.reason;
+      parkChild(child.task_id, reason);
+    }
+  }
+  for (const child of [...record.children]) {
+    if (child.state !== "settled" || !child.lane)
+      continue;
+    const planChild = input.children.find((c) => c.task_id === child.task_id);
+    let laneCommit;
+    try {
+      const existing = await git.lookupBatchCommit(child.lane.path, child.task_id, record.batch_id, child.lane.base_head, child.lane.branch);
+      laneCommit = existing?.commit ?? (await git.commitChild(child.lane.path, child.task_id, record.batch_id, child.lane.base_head, child.lane.branch, planChild?.intent_path ?? undefined)).commit;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      parkChild(child.task_id, message);
+      if (!isLineageBreak(message))
+        continue;
+      record.batch_state = "failed";
+      persist();
+      return finalizeLane(input.root, record, message, "");
+    }
+    record.children = record.children.map((c) => c.task_id === child.task_id && c.lane ? { ...c, state: "lane_committed", lane: { ...c.lane, lane_commit: laneCommit } } : c);
+    persist();
+  }
+  for (const child of [...record.children]) {
+    if (child.state !== "lane_committed" || !child.lane?.lane_commit)
+      continue;
+    const intentPathOf = (taskId) => input.children.find((c) => c.task_id === taskId)?.intent_path ?? null;
+    try {
+      const { commit } = await lanes.integrate({
+        root: input.root,
+        branch: record.branch ?? "",
+        batch_head: expectedBatchHead(record),
+        lane_base: child.lane.base_head,
+        lane_commit: child.lane.lane_commit,
+        child: { task_id: child.task_id, intent_path: intentPathOf(child.task_id) },
+        siblings: record.children.filter((c) => c.state === "integrated" && c.task_id !== child.task_id).map((c) => ({ task_id: c.task_id, intent_path: intentPathOf(c.task_id), commit: c.commit }))
+      });
+      record.children = record.children.map((c) => c.task_id === child.task_id ? { ...c, state: "integrated", commit, reason: null } : c);
+      record.commits = [...record.commits, commit];
+      persist();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const reason = error instanceof BatchIntegrationError ? error.reason : "batch_integration_conflict";
+      parkChild(child.task_id, isLineageBreak(message) || message.startsWith(`${reason}:`) ? message : `${reason}: ${message}`);
+      if (isLineageBreak(message)) {
+        record.batch_state = "failed";
+        persist();
+        return finalizeLane(input.root, record, message, "");
+      }
+    }
+  }
+  const coordinatorReal = lanes.resolveRoot(input.root);
+  for (const offer of input.lane_offers ?? []) {
+    const startable = new Set(startableChildren(scheduleView(input, record), limit));
+    const child = record.children.find((c) => c.task_id === offer.task_id);
+    if (!child || child.state !== "pending" || !startable.has(child.task_id)) {
+      refusals.push({ ...offer, reason: "batch_lane_unknown_child" });
+      continue;
+    }
+    const head = expectedBatchHead(record);
+    const facts = lanes.inspectLane(input.root, offer.path);
+    const reason = decideLaneAdmission({
+      facts,
+      coordinator_real_path: coordinatorReal,
+      expected_branch: laneBranchName(record.initiative_slug, child.task_id),
+      batch_head: head,
+      bound_paths: record.children.flatMap((c) => c.lane && c.state !== "released" ? [c.lane.path] : [])
+    });
+    if (reason) {
+      refusals.push({ ...offer, reason });
+      continue;
+    }
+    if (consumedSlots(record) >= record.budget.max_children)
+      break;
+    const lane = { path: facts.real_path, branch: laneBranchName(record.initiative_slug, child.task_id), base_head: head, lane_commit: null };
+    record.children = record.children.map((c) => c.task_id === child.task_id ? { ...c, state: "lane_admitted", lane } : c);
+    persist();
+    const failed = await enrollInLane(child.task_id);
+    if (failed)
+      return failed;
+  }
+  if (record.children.every((c) => c.state === "integrated" || c.state === "released")) {
+    record.batch_state = "completed";
+    persist();
+    return finalizeLane(input.root, record, "all enrollable children integrated", "", {
+      handoffs: releaseHandoffs(input, record, lanes),
+      refusals
+    });
+  }
+  const handoffs = [];
+  for (const child of record.children) {
+    if (child.state !== "enrolled" || !child.lane)
+      continue;
+    const fresh = await input.kernel.projectTask(child.lane.path, child.task_id);
+    if (fresh.error !== null)
+      continue;
+    handoffs.push({
+      role: "executor",
+      task_id: child.task_id,
+      run_id: fresh.projection.run_id ?? null,
+      record_revision: fresh.projection.record_revision,
+      next_obligation: fresh.projection.next_obligation,
+      lane_branch: child.lane.branch,
+      lane_path: child.lane.path
+    });
+  }
+  handoffs.push(...releaseHandoffs(input, record, lanes));
+  const inFlight = record.children.filter((c) => IN_FLIGHT.has(c.state));
+  const startable = startableChildren(scheduleView(input, record), limit);
+  const overBudget = consumedSlots(record) >= record.budget.max_children;
+  if (!inFlight.length && (!startable.length || overBudget)) {
+    const parked = record.children.some((c) => c.state === "needs_human" || c.state === "skipped_blocked");
+    record.batch_state = parked ? "needs_human" : overBudget ? "budget_stopped" : "needs_human";
+    persist();
+    return finalizeLane(input.root, record, parkedMessage ?? (parked ? "a parked child needs a human decision" : overBudget ? `max_children budget exhausted (${record.budget.max_children})` : "no child can start"), "", { refusals });
+  }
+  if (!overBudget) {
+    for (const taskId of startable) {
+      handoffs.push({
+        role: "lane-steward",
+        action: "provision",
+        task_id: taskId,
+        lane_branch: laneBranchName(record.initiative_slug, taskId),
+        base_head: expectedBatchHead(record),
+        executor_hosts: LANE_EXECUTOR_HOSTS
+      });
+    }
+  }
+  if (reviewOpen.length > 0) {
+    return laneReport(record, reviewOpen.length === 1 ? `child ${reviewOpen[0]} holds an open Review reservation` : `children ${reviewOpen.join(", ")} hold open Review reservations`, "Submit each reserved foreground Review verdict in its own Lane, then call start_unattended_batch again to continue.", { handoffs, refusals });
+  }
+  return laneReport(record, null, handoffs.some((h) => h.role === "lane-steward" && h.action === "provision") ? "Provide a Lane for each provision handoff, then call start_unattended_batch again with lane_offers." : "Run each executor handoff in its Lane. When a Lane finishes, call start_unattended_batch again with the same Initiative.", { handoffs, refusals });
+}
+
+// plugins/immune-brain/runtime/unattended/batch_runner.ts
+function batchQaFailureFacts(record) {
+  const failed = record.history.filter((event) => event.type === "request_rework" && event.authority?.authority_kind === "qa");
+  return {
+    qa_failure_count: failed.length,
+    last_qa_failure_at: failed.at(-1)?.at ?? null,
+    recovery_findings: record.findings.filter((f) => f.status === "open").map((f) => ({ id: f.id, kind: f.kind, status: f.status, acceptance_id: f.acceptance_id }))
+  };
+}
+function batchGitPortOf(input) {
+  return input.git ?? createDefaultBatchGitPort();
+}
+function dependentsOf2(record, taskId) {
+  return record.children.filter((child) => child.blocked_by.includes(taskId));
+}
+function skipDependents2(record, taskId, reason) {
+  const skip = new Set([taskId]);
+  const queue = [taskId];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    for (const dependent of dependentsOf2(record, current)) {
+      if (skip.has(dependent.task_id))
+        continue;
+      skip.add(dependent.task_id);
+      queue.push(dependent.task_id);
+    }
+  }
+  record.children = record.children.map((child) => skip.has(child.task_id) && child.state === "pending" ? { ...child, state: "skipped_blocked", reason } : child);
+}
+function budgetStopReason(record) {
+  const enrolledCount = record.children.filter((child) => child.state !== "pending" && child.state !== "skipped_blocked").length;
+  if (enrolledCount >= record.budget.max_children)
+    return `max_children budget exhausted (${record.budget.max_children})`;
+  return null;
 }
 function requireFreshProjection(result, taskId) {
   if (result.error !== null)
@@ -12561,11 +13992,12 @@ function requireFreshProjection(result, taskId) {
 function nextEnrollableChild(record) {
   return record.children.find((child) => child.state === "pending" && record.children.every((other) => !child.blocked_by.includes(other.task_id) || other.state === "committed")) ?? null;
 }
-var TERMINAL_NEXT_ACTIONS = {
+var TERMINAL_NEXT_ACTIONS2 = {
   completed: "The batch settled every enrollable child; review the commits and the tracker.",
   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."
@@ -12579,7 +14011,7 @@ function reportFor(record, reason, nextAction) {
     children: record.children,
     commits: record.commits,
     reason,
-    next_action: nextAction || (TERMINAL_NEXT_ACTIONS[record.batch_state] ?? "Inspect the batch run state."),
+    next_action: nextAction || (TERMINAL_NEXT_ACTIONS2[record.batch_state] ?? "Inspect the batch run state."),
     created_at: record.updated_at
   };
 }
@@ -12613,13 +14045,13 @@ function failPersistedLineage(root, existing, message) {
   const record = { ...existing, batch_state: "failed", children };
   for (const child of record.children) {
     if (child.state === "needs_human") {
-      skipDependents(record, child.task_id, `dependency ${child.task_id} parked`);
+      skipDependents2(record, child.task_id, `dependency ${child.task_id} parked`);
     }
   }
   return writeBatchRunState(root, record);
 }
 function reconcileLineage(root, record) {
-  if (!existsSync10(join15(root, ".git")))
+  if (!existsSync11(join16(root, ".git")))
     return { record, failure: null };
   const expected = expectedBatchHead(record);
   const lineage = classifyBatchLineage({
@@ -12642,8 +14074,8 @@ function reconcileLineage(root, record) {
   };
 }
 async function validatePersistedRun(input, record) {
-  if (!record.commits.length && record.children[0]?.state === "settled" && existsSync10(join15(input.root, ".git"))) {
-    const head = spawnSync9("git", ["-C", input.root, "rev-parse", "HEAD"], { encoding: "utf8" });
+  if (!record.commits.length && record.children[0]?.state === "settled" && existsSync11(join16(input.root, ".git"))) {
+    const head = spawnSync11("git", ["-C", input.root, "rev-parse", "HEAD"], { encoding: "utf8" });
     const live = head.stdout.trim();
     const expected = expectedBatchHead(record);
     const adoptable = () => classifyBatchLineage({
@@ -12672,8 +14104,8 @@ async function validatePersistedRun(input, record) {
     const git = batchGitPortOf(input);
     const evidence = await git.lookupBatchCommit(input.root, child.task_id, record.batch_id, undefined, record.branch);
     if (!evidence || evidence.commit !== child.commit) {
-      if (evidence === null && typeof child.commit === "string" && child.commit.length > 0 && existsSync10(join15(input.root, ".git"))) {
-        const reach = spawnSync9("git", ["-C", input.root, "merge-base", "--is-ancestor", child.commit, "HEAD"], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+      if (evidence === null && typeof child.commit === "string" && child.commit.length > 0 && existsSync11(join16(input.root, ".git"))) {
+        const reach = spawnSync11("git", ["-C", input.root, "merge-base", "--is-ancestor", child.commit, "HEAD"], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
         if (reach.status !== 0) {
           throw new Error(`batch_head_lineage_broken: recorded commit ${child.commit} for ${child.task_id} is no longer reachable from HEAD`);
         }
@@ -12758,17 +14190,22 @@ async function startBatch(input) {
 function rejectionReport(input, reason) {
   const persisted = (() => {
     try {
-      return readBatchRunState(input.root, input.batch_id);
+      return readAnyBatchRunState(input.root, input.batch_id);
     } catch {
       return null;
     }
   })();
+  if (persisted !== null && isLaneBatchRecord(persisted))
+    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"
   }, reason, "settle the reported kernel store condition and retry in the current Host");
 }
 async function startBatchLocked(input) {
+  const recorded = readAnyBatchRunState(input.root, input.batch_id);
+  if (input.max_parallel !== undefined || recorded !== null && isLaneBatchRecord(recorded))
+    return await runLaneBatch(input, recorded);
   if (!input.children.length) {
     const rejected = prepareBatchRunState({ ...input, children: [], now: input.now });
     return reportFor({ ...rejected, batch_state: "rejected" }, "batch plan is empty", "Provide a non-empty enrollable child plan.");
@@ -12818,7 +14255,7 @@ async function startBatchLocked(input) {
       const reparked = { ...existing, children: remapped };
       for (const parked of remapped) {
         if (parked.state === "needs_human")
-          skipDependents(reparked, parked.task_id, `dependency ${parked.task_id} parked`);
+          skipDependents2(reparked, parked.task_id, `dependency ${parked.task_id} parked`);
       }
       existing = writeBatchRunState(input.root, {
         ...reparked,
@@ -12901,7 +14338,7 @@ async function startBatchLocked(input) {
       adoptedClaim = true;
     } else if (claimState === "foreign") {
       record.children = record.children.map((c) => c.task_id === child.task_id ? { ...c, state: "needs_human", reason: "claim held by another batch" } : c);
-      skipDependents(record, child.task_id, `dependency ${child.task_id} parked`);
+      skipDependents2(record, child.task_id, `dependency ${child.task_id} parked`);
       record.batch_state = "needs_human";
       persist();
       return finalize(input.root, record, "claim held by another batch", "needs-human-attention");
@@ -12947,13 +14384,13 @@ async function startBatchLocked(input) {
         const message = error instanceof Error ? error.message : String(error);
         if (isLineageBreakError(message)) {
           record.children = record.children.map((c) => c.task_id === child.task_id ? { ...c, state: "needs_human", reason: message } : c);
-          skipDependents(record, child.task_id, `dependency ${child.task_id} parked`);
+          skipDependents2(record, child.task_id, `dependency ${child.task_id} parked`);
           record.batch_state = "failed";
           persist();
           break;
         }
         record.children = record.children.map((c) => c.task_id === child.task_id ? { ...c, state: "needs_human", reason: message } : c);
-        skipDependents(record, child.task_id, `dependency ${child.task_id} parked`);
+        skipDependents2(record, child.task_id, `dependency ${child.task_id} parked`);
         record.batch_state = "needs_human";
         persist();
         break;
@@ -13011,7 +14448,7 @@ async function resumeBatch(input, projection) {
       const fresh = requireFreshProjection(await input.kernel.projectTask(input.root, driven.task_id), driven.task_id);
       const holdsClaim = fresh.claim !== null && fresh.claim.task_id === driven.task_id && input.kernel.ownsTaskClaim(driven.task_id);
       if (holdsClaim === false && fresh.claim !== null && fresh.claim.task_id === driven.task_id && !input.kernel.ownsTaskClaim(driven.task_id)) {
-        skipDependents(existing, driven.task_id, `dependency ${driven.task_id} parked`);
+        skipDependents2(existing, driven.task_id, `dependency ${driven.task_id} parked`);
         existing = writeBatchRunState(input.root, {
           ...existing,
           batch_state: "needs_human",
@@ -13023,7 +14460,7 @@ async function resumeBatch(input, projection) {
         const failures = Math.max(existing.consecutive_qa_failures, fresh.qa_failure_count ?? 0);
         if (failures >= existing.budget.qa_failure_limit && fresh.last_qa_failure_at && Date.parse(fresh.last_qa_failure_at) > Date.parse(existing.confirmation_time)) {
           const reason = "QA failure limit reached; repair and settle the own child through Kernel before resuming the batch";
-          skipDependents(existing, driven.task_id, `dependency ${driven.task_id} parked`);
+          skipDependents2(existing, driven.task_id, `dependency ${driven.task_id} parked`);
           existing = writeBatchRunState(input.root, {
             ...existing,
             batch_state: "needs_human",
@@ -13094,7 +14531,7 @@ async function driveInterruptedChild(input, child) {
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         record.children = record.children.map((c) => c.task_id === child.task_id ? { ...c, state: "needs_human", reason: `commit lookup failed: ${message}` } : c);
-        skipDependents(record, child.task_id, `dependency ${child.task_id} failed to commit`);
+        skipDependents2(record, child.task_id, `dependency ${child.task_id} failed to commit`);
         const isLineageError = message.includes("batch_head_lineage_broken") || message.includes("lineage");
         record.batch_state = isLineageError ? "failed" : "needs_human";
         persist();
@@ -13107,12 +14544,12 @@ async function driveInterruptedChild(input, child) {
       const planChild = input.children.find((c) => c.task_id === child.task_id);
       const intentPath = planChild?.intent_path ?? undefined;
       const doCommit = async () => batchGitPortOf(input).commitChild(input.root, child.task_id, input.batch_id, head, record.branch, intentPath);
-      if (existing && !record.commits.length && existsSync10(join15(input.root, ".git")) && !ownUnpersistedBatchHead(input.root, record, existing.commit))
+      if (existing && !record.commits.length && existsSync11(join16(input.root, ".git")) && !ownUnpersistedBatchHead(input.root, record, existing.commit))
         throw new Error("first unpersisted batch commit provenance is invalid");
       const adopted = existing ?? await doCommit().catch((error) => {
         const message = error instanceof Error ? error.message : String(error);
         record.children = record.children.map((c) => c.task_id === child.task_id ? { ...c, state: "needs_human", reason: message } : c);
-        skipDependents(record, child.task_id, `dependency ${child.task_id} failed to commit`);
+        skipDependents2(record, child.task_id, `dependency ${child.task_id} failed to commit`);
         record.batch_state = "failed";
         persist();
         throw new BatchCommitAbortError(message);
@@ -13142,7 +14579,7 @@ async function driveInterruptedChild(input, child) {
         const reason = "QA failure limit reached";
         record.children = record.children.map((c) => c.task_id === child.task_id ? { ...c, state: "needs_human", reason } : c);
         record.batch_state = "needs_human";
-        skipDependents(record, child.task_id, `dependency ${child.task_id} parked`);
+        skipDependents2(record, child.task_id, `dependency ${child.task_id} parked`);
         persist();
         const fresh = requireFreshProjection(await input.kernel.projectTask(input.root, child.task_id), child.task_id);
         return finalize(input.root, record, reason, "Repair and settle the own child through Kernel, then re-confirm the batch.", { recovery: deriveAssuranceRecovery(child.task_id, fresh, terminal, fresh.recovery_findings) ?? undefined, diagnostics: terminal.diagnostics });
@@ -13157,7 +14594,7 @@ async function driveInterruptedChild(input, child) {
       const reason = terminal.state === "stopped" ? "Kernel reported the child stopped" : terminal.reason;
       record.children = record.children.map((c) => c.task_id === child.task_id ? { ...c, state: "needs_human", reason } : c);
       record.batch_state = "needs_human";
-      skipDependents(record, child.task_id, `dependency ${child.task_id} parked`);
+      skipDependents2(record, child.task_id, `dependency ${child.task_id} parked`);
       persist();
       return finalize(input.root, record, reason, "");
     }
@@ -13220,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 {
@@ -13259,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;
@@ -13496,7 +15073,7 @@ class ClaudeRuntime {
     if (!slug)
       return result;
     try {
-      if (existsSync11(join16(this.cwd, ".imm", "audit", taskId)))
+      if (existsSync12(join17(this.cwd, ".imm", "audit", taskId)))
         execFileSync8("git", ["-C", this.cwd, "add", "--", `.imm/audit/${taskId}`], { stdio: "ignore" });
       const batch = await this.startUnattendedBatch(slug, meta, { reuseOnly: true });
       return { ...result, batch };
@@ -13593,7 +15170,7 @@ class ClaudeRuntime {
       throw new Error("approve_breaking_intent_revision requires next_intent");
     const nextIntentHash = nextIntent ? canonicalIntentHash(nextIntent) : undefined;
     const nextIntentRef = nextIntent ? { path: `docs/plans/${nextIntent.task_id}.intent.json`, content_hash: nextIntentHash } : undefined;
-    const sidecar = nextIntent ? join16(this.cwd, priorIntent.intent_ref.path) : undefined;
+    const sidecar = nextIntent ? join17(this.cwd, priorIntent.intent_ref.path) : undefined;
     const stagedSnapshot = sidecar ? captureStagedIntent(this.cwd, priorIntent.intent_ref.path) : undefined;
     const restoreStagedIntent2 = () => {
       if (!stagedSnapshot)
@@ -13702,8 +15279,8 @@ class ClaudeRuntime {
     const { app } = await this.authority();
     const operation = input.operation.op === "revise_intent" ? { ...input.operation, next_intent: await parseTaskIntentV1(input.operation.next_intent) } : input.operation;
     const priorIntent = await readTaskIntentForRecord(ctx.cwd, input.taskId);
-    const sidecar = join16(ctx.cwd, priorIntent.intent_ref.path);
-    const priorBytes = operation.op === "revise_intent" ? readFileSync14(sidecar) : null;
+    const sidecar = join17(ctx.cwd, priorIntent.intent_ref.path);
+    const priorBytes = operation.op === "revise_intent" ? readFileSync15(sidecar) : null;
     const priorStaged = priorBytes !== null ? captureStagedIntent(ctx.cwd, priorIntent.intent_ref.path) : null;
     try {
       if (priorBytes) {
@@ -13750,7 +15327,7 @@ class ClaudeRuntime {
       root: this.cwd,
       initiative_slug: initiativeSlug,
       now,
-      readInitiative: this.readInitiative ?? observeGithubInitiative
+      readInitiative: this.readInitiative ?? observeInitiative
     });
     if (!preflight.ok) {
       return {
@@ -13770,7 +15347,7 @@ class ClaudeRuntime {
       initiative_slug: initiativeSlug,
       now,
       projection: preflight.projection,
-      readInitiative: this.readInitiative ?? observeGithubInitiative,
+      readInitiative: this.readInitiative ?? observeInitiative,
       nonce: enrollmentNonce(),
       gate: async (facts) => {
         if (reuseOnly)
@@ -13803,6 +15380,13 @@ class ClaudeRuntime {
                 reason: child.reason
               })),
               budget: facts.budget,
+              ...options.max_parallel !== undefined ? {
+                lane_mode: {
+                  max_parallel: options.max_parallel,
+                  parallel_groups: facts.parallel_groups,
+                  serialized: facts.scope_conflicts
+                }
+              } : {},
               ...facts.reuse_blockers.length > 0 ? {
                 re_confirmation_required: facts.reuse_blockers,
                 recovery: "confirm to issue a fresh authorization bound to the current plan and HEAD"
@@ -13902,7 +15486,9 @@ class ClaudeRuntime {
       budget,
       now,
       kernel: kernelPort,
-      git: this.batchGit
+      git: this.batchGit,
+      ...options.max_parallel !== undefined ? { max_parallel: options.max_parallel } : {},
+      ...options.lane_offers !== undefined ? { lane_offers: options.lane_offers } : {}
     });
     if (report.batch_state === "rejected")
       return batchReason("batch_run_rejected", report.reason ?? "");
@@ -13912,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
@@ -13920,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 }
@@ -13937,7 +15599,21 @@ function listMcpTools() {
     inputSchema: {
       type: "object",
       properties: {
-        ...tool.name === "start_unattended_batch" ? { initiative_slug: { type: "string" } } : {
+        ...tool.name === "start_unattended_batch" || tool.name === "retire_stale_batch" ? {
+          initiative_slug: { type: "string" },
+          ...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" } } : {},
           ...tool.name === "stop" ? { reason: { type: "string" } } : {},
@@ -13946,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" }
   }));
@@ -14008,7 +15684,36 @@ function createMcpRuntime(options = {}) {
           interactive: meta.interactive ?? options.interactive ?? negotiatedInteractive,
           signal: meta.signal
         };
-        return runtime.startUnattendedBatch(initiativeSlug, toolMeta);
+        const laneOffers = parseLaneOffers(args.lane_offers);
+        const maxParallel = resolveLaneParallel(options.cwd ?? process.cwd(), initiativeSlug, parseMaxParallel(args.max_parallel), laneOffers);
+        return runtime.startUnattendedBatch(initiativeSlug, toolMeta, {
+          ...maxParallel !== undefined ? { max_parallel: maxParallel } : {},
+          ...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)
@@ -14037,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"))
@@ -14222,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 = [
@@ -14235,7 +15964,14 @@ ${b.children.map((c) => `  - ${c.task_id} (${c.slice_id}) [risk: ${c.risk ?? "un
       b?.excluded && b.excluded.length > 0 ? `Excluded children (${b.excluded.length}):
 ${b.excluded.map((e) => `  - ${e.task_id} (${e.slice_id}): ${e.reason}`).join(`
 `)}` : null,
-      b?.budget ? `Budget: max_children=${b.budget.max_children}, qa_failure_limit=${b.budget.qa_failure_limit}` : null
+      b?.budget ? `Budget: max_children=${b.budget.max_children}, qa_failure_limit=${b.budget.qa_failure_limit}` : null,
+      b?.lane_mode ? `Lane mode: max_parallel=${b.lane_mode.max_parallel}` : null,
+      b?.lane_mode ? `Parallel groups (${b.lane_mode.parallel_groups.length}):
+${b.lane_mode.parallel_groups.map((group) => `  - ${group.join(", ")}`).join(`
+`)}` : null,
+      b?.lane_mode && b.lane_mode.serialized.length > 0 ? `Serialized by overlapping scope (${b.lane_mode.serialized.length}):
+${b.lane_mode.serialized.map((c) => `  - ${c.task_id} after ${c.overlaps_with.join(", ")}`).join(`
+`)}` : null
     ].filter(Boolean);
     return {
       mode: "form",