immune-brain 4.4.0 → 4.5.0

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 = "4.4.0";
+var PLUGIN_VERSION = "4.5.0";
 
 // plugins/immune-brain/runtime/claude/interaction.ts
 import { createHash, randomUUID } from "node:crypto";
@@ -1362,6 +1362,88 @@ function reviewAdvisoryRecords(verdict) {
     evidence: finding.evidence ?? null
   }));
 }
+var QA_STAGES = ["resolution", "prepare", "check", "integrity"];
+var QA_OUTCOMES = [
+  "running",
+  "passed",
+  "executable_or_cwd_unavailable",
+  "process_launch_failed",
+  "process_cleanup_failed",
+  "protected_input_or_output_drift",
+  "execution_metadata_limit_exceeded",
+  "timeout",
+  "output_limit",
+  "nonzero_exit",
+  "execution_failed",
+  "command_identity_changed",
+  "delivery_cleanup_failed",
+  "delivery_unavailable"
+];
+function qaDiagnosticMetadata(d) {
+  if (typeof d.acceptance_id !== "string" || !d.acceptance_id || !/^acceptance\/\d{1,6}\/verification\/(command|environment\/prepare)$/.test(d.descriptor_ref) || !/^sha256:[a-f0-9]{64}$/.test(d.descriptor_digest) || !QA_STAGES.includes(d.stage) || !QA_OUTCOMES.includes(d.outcome) || !Number.isFinite(d.elapsed_ms) || d.elapsed_ms < 0 || [d.stdout_bytes, d.stderr_bytes].some((n) => n !== null && (!Number.isSafeInteger(n) || n < 0)) || d.exit_code !== null && !Number.isSafeInteger(d.exit_code))
+    throw new Error("invalid QA diagnostic metadata");
+  const safe = {
+    acceptance_id: d.acceptance_id,
+    descriptor_ref: d.descriptor_ref,
+    descriptor_digest: d.descriptor_digest,
+    stage: d.stage,
+    outcome: d.outcome,
+    elapsed_ms: d.elapsed_ms,
+    exit_code: d.exit_code,
+    stdout_bytes: d.stdout_bytes,
+    stderr_bytes: d.stderr_bytes
+  };
+  if (Buffer.byteLength(JSON.stringify(safe)) > 16384)
+    throw new QaPreparationError("prepare", [], "execution_metadata_limit_exceeded");
+  return safe;
+}
+
+class QaPreparationError extends Error {
+  stage;
+  acceptance_ids;
+  reason;
+  diagnostics;
+  constructor(stage, acceptance_ids, reason, diagnostics = []) {
+    if (!QA_STAGES.includes(stage) || !QA_OUTCOMES.includes(reason))
+      throw new Error("invalid QA preparation classification");
+    const safe = diagnostics.map(qaDiagnosticMetadata);
+    if (Buffer.byteLength(JSON.stringify(safe)) > 16384)
+      throw new QaPreparationError("prepare", [], "execution_metadata_limit_exceeded");
+    super(`QA ${stage} failed (${reason}); affected checks=${acceptance_ids.length}`);
+    this.stage = stage;
+    this.acceptance_ids = acceptance_ids;
+    this.reason = reason;
+    this.diagnostics = diagnostics;
+    this.diagnostics = safe;
+    this.name = "QaPreparationError";
+  }
+}
+function deriveAssuranceRecovery(taskId, fresh, result, findings = []) {
+  if (fresh.error || fresh.claim?.task_id !== taskId || fresh.projection.lifecycle !== "active")
+    return null;
+  const p = fresh.projection;
+  const findingIds = [...p.blocking_finding_ids, ...p.unresolved_user_decision_ids, ...p.replan_required_ids];
+  const scope = result.reason?.includes("task delivery contains paths outside the authorization envelope");
+  const migration = result.reason?.includes("verification_contract_migration_required");
+  const unstaged = result.reason?.includes("task delivery has unstaged or untracked changes");
+  const reviewPreparation = result.state === "review_preparation_failed" && p.next_obligation === "run_review";
+  const authority = scope || migration || p.next_obligation === "resolve_user_decision" || p.next_obligation === "revise_intent" || p.unresolved_user_decision_ids.length > 0 || p.replan_required_ids.length > 0 || p.authorization.state !== "none";
+  const repair = unstaged || p.next_obligation === "resolve_findings" || p.blocking_finding_ids.length > 0;
+  if (!authority && !repair && !result.environment_failure && !reviewPreparation)
+    return null;
+  const affected = findings.filter((f) => f.status === "open" && f.id && findingIds.includes(f.id) && f.acceptance_id).map((f) => f.acceptance_id);
+  const category = authority ? "authorization" : repair ? "repair" : "environment";
+  return {
+    category,
+    task_id: taskId,
+    run_id: p.run_id ?? null,
+    record_revision: p.record_revision,
+    next_obligation: p.next_obligation,
+    finding_ids: findingIds,
+    acceptance_ids: [...new Set(affected.length ? affected : result.diagnostics?.length ? result.diagnostics.map((d) => d.acceptance_id) : reviewPreparation ? p.fresh_acceptance_ids : p.missing_acceptance_ids)],
+    next_action: scope ? "Reconcile the listed paths with the TaskIntent scope: unstage unrelated changes or submit the required native Intent revision." : migration ? "route Planner for the verification descriptor v2 Intent revision and native gate" : category === "authorization" ? p.authorization.blocked ? "inspect authority state" : p.next_obligation === "revise_intent" ? "route Planner for the required Intent revision and native gate" : "request_authorization" : unstaged ? "Stage only the scoped implementation changes, then call advance_assurance." : category === "repair" ? "Route foreground Executor to repair and verify the identified findings; dispose each by resolve_finding or evidence-bound refute_finding, then run fresh advance_assurance." : reviewPreparation ? "Repair the Review evidence environment, then call advance_assurance to resume run_review; retain fresh QA and do not re-confirm the batch." : "Repair the identified verification environment, then call advance_assurance; a local check is non-attesting."
+  };
+}
 var QA_MIN_JOB_TIMEOUT_SECONDS = 15 * 60;
 var QA_MAX_JOB_TIMEOUT_SECONDS = 60 * 60;
 var QA_JOB_OVERHEAD_SECONDS = 2 * 60;
@@ -1673,6 +1755,36 @@ class AssuranceCoordinator {
     return this.sessionGeneration;
   }
   async advance(taskId, ctx, signal, onUpdate) {
+    const checks = new Map;
+    const result = await this.advanceOnce(taskId, ctx, signal, (update) => {
+      const diagnostic = update.details.diagnostic;
+      if (diagnostic) {
+        checks.set(diagnostic.descriptor_ref, diagnostic);
+        if (Buffer.byteLength(JSON.stringify([...checks.values()])) > 16384)
+          throw new QaPreparationError("prepare", [diagnostic.acceptance_id], "execution_metadata_limit_exceeded", [{ ...diagnostic, stage: "prepare", outcome: "execution_metadata_limit_exceeded" }]);
+      }
+      onUpdate?.(update);
+    });
+    const diagnostics = result.diagnostics ?? [...checks.values()];
+    return this.withRecovery(taskId, ctx, diagnostics.length ? { ...result, diagnostics } : result);
+  }
+  async withRecovery(taskId, ctx, enriched) {
+    if (enriched.recovery_error || !["failed", "blocked", "rework", "review_preparation_failed"].includes(enriched.state))
+      return enriched;
+    try {
+      const fresh = await this.ports.projectTask(ctx.cwd, taskId);
+      if (fresh.error || fresh.claim?.task_id !== taskId || fresh.projection.lifecycle !== "active")
+        return { ...enriched, recovery_error: "fresh_kernel_projection_unavailable" };
+      const record = await this.ports.readTaskRecord(ctx.cwd, taskId);
+      if (!record.record || record.revision !== fresh.projection.record_revision)
+        return { ...enriched, recovery_error: "fresh_kernel_projection_unavailable" };
+      const recovery = deriveAssuranceRecovery(taskId, fresh, enriched, record.record?.findings);
+      return recovery ? { ...enriched, recovery } : enriched;
+    } catch {
+      return { ...enriched, recovery_error: "fresh_kernel_projection_unavailable" };
+    }
+  }
+  async advanceOnce(taskId, ctx, signal, onUpdate) {
     if (this.isInvocationOpen(taskId))
       return { state: "blocked", reason: "an authority invocation is already open" };
     const active = this.active(taskId);
@@ -1682,7 +1794,7 @@ class AssuranceCoordinator {
       try {
         projection = await this.ports.projectTask(ctx.cwd, taskId);
       } catch (error) {
-        return { state: "blocked", reason: `cannot validate Review reservation: ${boundedAssuranceError(error)}` };
+        return { state: "blocked", reason: `cannot validate Review reservation: ${boundedAssuranceError(error)}`, recovery_error: "fresh_kernel_projection_unavailable" };
       }
       const matches = reservationStillValid(reservation, projection, taskId);
       if (matches)
@@ -1690,6 +1802,8 @@ class AssuranceCoordinator {
       if (reservation)
         this.releaseReviewReservation(taskId, reservation);
       this.rejectedReviewOperations.delete(taskId);
+      if (projection.error || projection.projection.lifecycle !== "done" && projection.projection.lifecycle !== "stopped" && (!projection.claim || projection.claim.task_id !== taskId))
+        return { state: "blocked", reason: projection.error ?? "no active backend claim for this task", recovery_error: "fresh_kernel_projection_unavailable" };
     }
     const refreshed = this.active(taskId);
     if (refreshed?.state === "running")
@@ -1708,6 +1822,7 @@ class AssuranceCoordinator {
     let authorityBoundaryStarted = false;
     let boundaryBaseline = null;
     let reviewPreparationStarted = false;
+    let initialProjectionAvailable = false;
     let qaJobBudgetExceeded = false;
     let phase = "preparing";
     const operationLive = () => this.sessionActive && this.sessionGeneration === operationGeneration && this.activeOperations.get(taskId) === operationId && !operationController.signal.aborted;
@@ -1744,15 +1859,16 @@ class AssuranceCoordinator {
       }
       ensureOperationLive();
       if (projection.error)
-        return { state: "blocked", reason: projection.error };
+        return { state: "blocked", reason: projection.error, recovery_error: "fresh_kernel_projection_unavailable" };
       if (projection.projection.lifecycle === "done" || projection.projection.lifecycle === "stopped") {
         this.unknownOperations.delete(taskId);
         return { state: projection.projection.lifecycle === "done" ? "completed" : "stopped" };
       }
       if (!projection.claim)
-        return { state: "blocked", reason: "no active backend claim" };
+        return { state: "blocked", reason: "no active backend claim", recovery_error: "fresh_kernel_projection_unavailable" };
       if (projection.claim.task_id !== taskId)
-        return { state: "blocked", reason: `backend claim belongs to ${projection.claim.task_id}, not ${taskId}` };
+        return { state: "blocked", reason: `backend claim belongs to ${projection.claim.task_id}, not ${taskId}`, recovery_error: "fresh_kernel_projection_unavailable" };
+      initialProjectionAvailable = true;
       if (projection.projection.lifecycle === "active")
         this.unknownOperations.delete(taskId);
       const parked = await this.ports.readTaskRecord(ctx.cwd, taskId);
@@ -1824,6 +1940,7 @@ class AssuranceCoordinator {
           operationController.abort(new Error(`deterministic QA exceeded its declared ${Math.ceil(qaJobTimeoutMs / 60000)} minute job budget`));
         }, qaJobTimeoutMs);
         try {
+          phase = "verifying";
           qaVerdict = await this.ports.runQa(assurance.snapshot, assurance.descriptors, {
             signal: operationController.signal,
             onProgress: (item) => progress("verifying", `QA ${item.index}/${item.total} ${item.acceptance_id} ${item.phase}`, {
@@ -1831,7 +1948,8 @@ class AssuranceCoordinator {
               total: item.total,
               acceptance_id: item.acceptance_id,
               acceptance_phase: item.phase,
-              elapsed_ms: item.elapsed_ms
+              elapsed_ms: item.elapsed_ms,
+              ...item.diagnostic ? { diagnostic: qaDiagnosticMetadata(item.diagnostic) } : {}
             })
           });
         } finally {
@@ -1964,6 +2082,31 @@ class AssuranceCoordinator {
       progress("review_ready", "QA passed; invoke the reserved foreground Agent, then call submit_review", { snapshot_digest: snapshotDigest(review.snapshot), review_bundle_digest: review.snapshot.review_bundle_digest ?? "", agent_params: hostReservation.dispatch });
       return { state: "review_ready", operation: "review", operation_id: operationId, snapshot_digest: snapshotDigest(review.snapshot), review_bundle_digest: review.snapshot.review_bundle_digest ?? "", agent_params: hostReservation.dispatch };
     } catch (error) {
+      if (!initialProjectionAvailable && !aborted() && !(error instanceof VerificationAbortedError))
+        return {
+          state: "failed",
+          operation: "qa",
+          operation_id: operationId,
+          reason: `${phase}: ${boundedAssuranceError(error)}`,
+          recovery_error: "fresh_kernel_projection_unavailable"
+        };
+      if (error instanceof QaPreparationError && !authorityCommitted && !authorityBoundaryStarted && !aborted())
+        return {
+          state: "failed",
+          operation: "qa",
+          operation_id: operationId,
+          reason: error.message,
+          environment_failure: true,
+          diagnostics: error.diagnostics.map(qaDiagnosticMetadata)
+        };
+      if (phase === "verifying" && !authorityCommitted && !authorityBoundaryStarted && !aborted() && !(error instanceof VerificationAbortedError))
+        return {
+          state: "failed",
+          operation: "qa",
+          operation_id: operationId,
+          reason: "QA execution failed before attestation (execution_failed)",
+          environment_failure: true
+        };
       if (reviewPreparationStarted) {
         const reason = aborted() || error instanceof VerificationAbortedError ? `${phase}: host cancellation` : `${phase}: ${boundedAssuranceError(error)}`;
         return this.reviewPreparationFailed(taskId, operationId, reason);
@@ -1989,6 +2132,9 @@ class AssuranceCoordinator {
     }
   }
   async submitReview(taskId, ctx, verdictInput) {
+    return this.withRecovery(taskId, ctx, await this.submitReviewOnce(taskId, ctx, verdictInput));
+  }
+  async submitReviewOnce(taskId, ctx, verdictInput) {
     const unknown = this.unknownOperations.get(taskId);
     if (unknown)
       return { state: "settlement_unknown", operation: unknown.operation, operation_id: unknown.operationId, reason: unknown.reason };
@@ -2004,12 +2150,12 @@ class AssuranceCoordinator {
     } catch (error) {
       const reason = boundedAssuranceError(error);
       this.releaseReviewReservation(taskId, reservation, reason);
-      return { state: "blocked", reason };
+      return { state: "blocked", reason, recovery_error: "fresh_kernel_projection_unavailable" };
     }
     if (fresh.error || !fresh.claim || fresh.claim.task_id !== taskId || compareReservationSnapshot(reservation.snapshot, fresh.projection).length > 0 || fresh.projection.lifecycle !== reservation.snapshot.lifecycle || fresh.projection.artifact_state !== reservation.snapshot.artifact_state) {
       const reason = fresh.error ?? "assurance snapshot changed before Review submission";
       this.releaseReviewReservation(taskId, reservation, reason);
-      return { state: "blocked", reason };
+      return { state: "blocked", reason, ...fresh.error || !fresh.claim || fresh.claim.task_id !== taskId ? { recovery_error: "fresh_kernel_projection_unavailable" } : {} };
     }
     if (reservation.snapshot.review_revision) {
       try {
@@ -2177,11 +2323,13 @@ import {
 } from "node:fs";
 import { dirname as dirname3, join as join4, resolve as resolve2 } from "node:path";
 function git(root, args) {
-  const result = spawnSync("git", ["-C", root, ...args], {
+  const diff = args[0] === "diff";
+  const command = diff ? ["diff", "--exit-code", ...args.slice(1)] : args;
+  const result = spawnSync("git", ["--no-optional-locks", "-c", "diff.autoRefreshIndex=false", "-C", root, ...command], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"]
   });
-  return result.status === 0 ? result.stdout : null;
+  return result.status === 0 || diff && result.status === 1 ? result.stdout : null;
 }
 function splitNull(value) {
   return value.split("\x00").filter((entry) => entry.length > 0);
@@ -2300,12 +2448,14 @@ var portablePathCollator = new Intl.Collator("und", {
 });
 var gitTaskSnapshotTestHook;
 function gitBytes(root, args) {
-  const result = spawnSync("git", ["-C", root, ...args], {
+  const diff = args[0] === "diff";
+  const command = diff ? ["diff", "--exit-code", ...args.slice(1)] : args;
+  const result = spawnSync("git", ["--no-optional-locks", "-c", "diff.autoRefreshIndex=false", "-C", root, ...command], {
     encoding: null,
     stdio: ["ignore", "pipe", "pipe"],
     maxBuffer: 8 * 1024 * 1024
   });
-  if (result.status !== 0 || !Buffer.isBuffer(result.stdout)) {
+  if (result.status !== 0 && !(diff && result.status === 1) || !Buffer.isBuffer(result.stdout)) {
     throw new Error(`Git task snapshot command failed: git ${args.join(" ")}`);
   }
   return result.stdout;
@@ -2595,6 +2745,38 @@ function taskRevisionIdentity(projectRoot, scopeHint, baseHead, taskId) {
     changed_paths: Object.keys(snapshot.changed_paths).sort(comparePaths)
   };
 }
+function taskCommitRevisionIdentity(projectRoot, scopeHint, baseHead, commit) {
+  const requested = resolve2(projectRoot);
+  if (lstatSync2(requested).isSymbolicLink())
+    throw new Error("task commit root must be a real directory");
+  const root = realpathSync3(requested), scope = assertCanonicalTaskScope(scopeHint);
+  if (!GIT_OBJECT_ID.test(baseHead) || !GIT_OBJECT_ID.test(commit))
+    throw new Error("invalid task commit identity");
+  if (gitRequired(root, ["cat-file", "-t", baseHead], "unreadable task base") !== "commit" || gitRequired(root, ["cat-file", "-t", commit], "unreadable task commit") !== "commit" || git(root, ["merge-base", "--is-ancestor", baseHead, commit]) === null)
+    throw new Error("invalid task commit ancestry");
+  const paths = decodeNullPaths(gitBytes(root, ["diff", "--no-renames", "--name-only", "-z", baseHead, commit, "--"]), "task commit paths").filter((path) => !isNonDeliveryPath(path) && taskPathMatchesScope(path, scope)).sort(comparePaths);
+  assertNoCaseFoldCollisions(paths, "task commit paths");
+  const changed_paths = {};
+  for (const path of paths) {
+    const current = headEntry(root, commit, path), base = headEntry(root, baseHead, path);
+    changed_paths[path] = {
+      status: !base ? "added" : !current ? "deleted" : "modified",
+      mode: current?.mode ?? null,
+      oid: current?.oid ?? null,
+      base_mode: base?.mode ?? null,
+      base_oid: base?.oid ?? null
+    };
+  }
+  const snapshot = {
+    kind: "git-task-revision-v1",
+    repository_root: root,
+    base_head: baseHead,
+    base_tree: gitRequired(root, ["rev-parse", `${baseHead}^{tree}`], "unreadable task base tree"),
+    scope,
+    changed_paths
+  };
+  return { diff_hash: hashTaskSnapshot(snapshot), changed_paths: paths };
+}
 function isGitWorkspaceSnapshot(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) && value.kind === "git-workspace-v1" && typeof value.repository_root === "string" && typeof value.head === "string" && typeof value.dirty_files === "object" && value.dirty_files !== null;
 }
@@ -5582,6 +5764,9 @@ function ensureSecureDirectory(root, relativePath) {
   return target.path;
 }
 function readSecureProjectFile(root, relativePath) {
+  return readSecureProjectBytes(root, relativePath).toString("utf8");
+}
+function readSecureProjectBytes(root, relativePath) {
   const candidate = safeCandidate(root, relativePath);
   assertNoSymlinkSegments(candidate.root, candidate.path);
   const before = pathStatOrNull(candidate.path);
@@ -5597,7 +5782,7 @@ function readSecureProjectFile(root, relativePath) {
     const opened = fstatSync4(fd);
     if (opened.dev !== before.dev || opened.ino !== before.ino)
       throw new KernelStoreSecurityError(`source identity changed: ${relativePath}`);
-    const content = readFileSync8(fd, "utf8");
+    const content = readFileSync8(fd);
     const after = lstatSync7(candidate.path);
     if (after.dev !== opened.dev || after.ino !== opened.ino)
       throw new KernelStoreSecurityError(`source identity changed: ${relativePath}`);
@@ -7857,7 +8042,6 @@ function initializeEnrollmentGitBase(root, input, previous, base, signal) {
 
 // plugins/immune-brain/runtime/assurance/qa.ts
 import { createHash as createHash17 } from "node:crypto";
-
 // plugins/immune-brain/runtime/assurance/delivery_workspace.ts
 import { execFileSync as execFileSync5 } from "node:child_process";
 import { createHash as createHash16 } from "node:crypto";
@@ -8117,19 +8301,6 @@ function deliveryTreeForSnapshot(snapshot, writeTree) {
     throw new Error("QA delivery identity does not match the frozen snapshot");
   return writeDeliveryTree(snapshot.root, captured);
 }
-
-class QaPreparationError extends Error {
-  stage;
-  acceptance_ids;
-  reason;
-  constructor(stage, acceptance_ids, reason) {
-    super(`QA ${stage} failed (${reason}); affected checks=${acceptance_ids.join(",")}`);
-    this.stage = stage;
-    this.acceptance_ids = acceptance_ids;
-    this.reason = reason;
-    this.name = "QaPreparationError";
-  }
-}
 async function runDeterministicQa(snapshot, descriptors, options = {}) {
   if (snapshot.role !== "qa")
     throw new Error("deterministic QA requires qa role");
@@ -8157,46 +8328,80 @@ async function runDeterministicQa(snapshot, descriptors, options = {}) {
     live();
     const ids = group.map((item) => item.id);
     const environment = group[0].descriptor.environment;
-    const delivery = (options._materializeDeliveryWorkspace ?? materializeDeliveryWorkspace)(snapshot.root, tree);
-    const home = mkdtempSync3(join9(tmpdir4(), "imm-qa-home-"));
+    const diagnostics = (stage, outcome, affected = group, commandStage = "check", elapsed = 0, result) => affected.map((item) => ({
+      acceptance_id: item.id,
+      descriptor_ref: `acceptance/${item.index}/verification/${commandStage === "prepare" ? "environment/prepare" : "command"}`,
+      descriptor_digest: `sha256:${createHash17("sha256").update(JSON.stringify(item.descriptor)).digest("hex")}`,
+      stage,
+      outcome,
+      elapsed_ms: elapsed,
+      exit_code: result?.exit_code ?? null,
+      stdout_bytes: result ? Buffer.byteLength(result.stdout) : null,
+      stderr_bytes: result ? Buffer.byteLength(result.stderr) : null
+    }));
+    const { delivery, home, deliveryPrefix } = (() => {
+      let delivery, home;
+      try {
+        delivery = (options._materializeDeliveryWorkspace ?? materializeDeliveryWorkspace)(snapshot.root, tree);
+        home = mkdtempSync3(join9(tmpdir4(), "imm-qa-home-"));
+        return { delivery, home, deliveryPrefix: `${realpathSync10(delivery.root)}${sep6}` };
+      } catch {
+        let reason = "delivery_unavailable";
+        try {
+          try {
+            delivery?.cleanup();
+          } finally {
+            if (home)
+              removeTaskOwnedTree(home);
+          }
+        } catch {
+          reason = "delivery_cleanup_failed";
+        }
+        throw new QaPreparationError("prepare", ids, reason, diagnostics("prepare", reason));
+      }
+    })();
     const clean = () => {
       if (options._materializeDeliveryWorkspace)
         return;
       try {
         assertDeliveryClean(delivery.root, tree, delivery.seal, environment.writable_paths);
       } catch {
-        throw new QaPreparationError("integrity", ids, "protected_input_or_output_drift");
+        throw new QaPreparationError("integrity", ids, "protected_input_or_output_drift", diagnostics("integrity", "protected_input_or_output_drift"));
       }
     };
     const groupCommands = [];
-    const deliveryPrefix = `${realpathSync10(delivery.root)}${sep6}`;
-    const execute = async (command, stage) => {
+    const execute = async (command, stage, affected = group) => {
+      const started = performance.now();
+      const fail = (errorStage, reason) => new QaPreparationError(errorStage, affected.map((item) => item.id), reason, diagnostics(errorStage, reason, affected, stage, Math.round(performance.now() - started)));
       live();
       clean();
       let frozen;
       try {
         frozen = (options._resolveVerificationCommand ?? resolveVerificationCommand)(delivery.root, command, path);
       } catch {
-        throw new QaPreparationError("resolution", ids, "executable_or_cwd_unavailable");
+        throw fail("resolution", "executable_or_cwd_unavailable");
       }
       let result;
       try {
         result = await (options._runFixedVerification ?? runFixedVerification)(delivery.root, command, frozen, { signal: options.signal, home, path });
       } catch (error) {
+        if (error instanceof VerificationAbortedError)
+          throw error;
         if (error instanceof VerificationLaunchError)
-          throw new QaPreparationError("resolution", ids, "process_launch_failed");
+          throw fail("resolution", "process_launch_failed");
         if (error instanceof VerificationCleanupError)
-          throw new QaPreparationError("resolution", ids, "process_cleanup_failed");
-        throw error;
+          throw fail("resolution", "process_cleanup_failed");
+        throw fail(stage, "execution_failed");
       }
       live();
       clean();
       groupCommands.push(frozen);
       if (frozen?.entry) {
+        const identityDiagnostics = diagnostics("integrity", "command_identity_changed", affected, stage, Math.round(performance.now() - started), result);
         if (!command.executable.startsWith("./"))
-          allCommands.push(frozen);
+          allCommands.push({ frozen, diagnostics: identityDiagnostics });
         else if (frozen.interpreter && !frozen.interpreter.path.startsWith(deliveryPrefix))
-          allCommands.push({ entry: frozen.interpreter, interpreter: null, interpreter_args: [] });
+          allCommands.push({ frozen: { entry: frozen.interpreter, interpreter: null, interpreter_args: [] }, diagnostics: identityDiagnostics });
       }
       evidence.push({
         stage,
@@ -8209,29 +8414,31 @@ async function runDeterministicQa(snapshot, descriptors, options = {}) {
         output_limited: result.output_limited
       });
       if (Buffer.byteLength(JSON.stringify(evidence)) > 16384)
-        throw new QaPreparationError("prepare", ids, "execution_metadata_limit_exceeded");
+        throw fail("prepare", "execution_metadata_limit_exceeded");
       return result;
     };
     try {
       clean();
       if (environment.prepare) {
+        const prepareStarted = performance.now();
         const result = await execute(environment.prepare, "prepare");
         if (result.exit_code !== 0 || result.timed_out || result.output_limited)
-          throw new QaPreparationError("prepare", ids, result.timed_out ? "timeout" : result.output_limited ? "output_limit" : "nonzero_exit");
+          throw new QaPreparationError("prepare", ids, result.timed_out ? "timeout" : result.output_limited ? "output_limit" : "nonzero_exit", diagnostics("prepare", result.timed_out ? "timeout" : result.output_limited ? "output_limit" : "nonzero_exit", group, "prepare", Math.round(performance.now() - prepareStarted), result));
       }
       for (const item of group) {
-        const started = Date.now();
-        const progress = (phase) => options.onProgress?.({
+        const started = performance.now();
+        const progress = (phase, outcome, result) => options.onProgress?.({
           index: item.index + 1,
           total: snapshot.acceptance.length,
           acceptance_id: item.id,
           phase,
-          elapsed_ms: Date.now() - started
+          elapsed_ms: Math.round(performance.now() - started),
+          diagnostic: diagnostics("check", outcome, [item], "check", Math.round(performance.now() - started), result)[0]
         });
-        progress("running");
-        const result = await execute(item.descriptor.command, "check");
+        progress("running", "running");
+        const result = await execute(item.descriptor.command, "check", [item]);
         const failed = result.exit_code !== 0 || result.timed_out || result.output_limited;
-        progress(failed ? "failed" : "passed");
+        progress(failed ? "failed" : "passed", result.timed_out ? "timeout" : result.output_limited ? "output_limit" : failed ? "nonzero_exit" : "passed", result);
         if (failed)
           findings.push({
             id: qaFindingId(item.id, snapshotDigest(snapshot)),
@@ -8241,22 +8448,33 @@ async function runDeterministicQa(snapshot, descriptors, options = {}) {
             findings_digest: ""
           });
       }
-      for (const frozen of groupCommands) {
-        if (frozen?.entry)
-          assertCommandIdentity(frozen);
+      try {
+        for (const frozen of groupCommands)
+          if (frozen?.entry)
+            assertCommandIdentity(frozen);
+      } catch {
+        throw new QaPreparationError("integrity", ids, "command_identity_changed", diagnostics("integrity", "command_identity_changed"));
       }
     } finally {
       try {
-        delivery.cleanup();
-      } finally {
-        removeTaskOwnedTree(home);
+        try {
+          delivery.cleanup();
+        } finally {
+          removeTaskOwnedTree(home);
+        }
+      } catch {
+        throw new QaPreparationError("integrity", ids, "delivery_cleanup_failed", diagnostics("integrity", "delivery_cleanup_failed"));
       }
     }
   }
   live();
-  for (const frozen of allCommands) {
-    if (frozen?.entry)
-      assertCommandIdentity(frozen);
+  for (const entry of allCommands) {
+    try {
+      if (entry.frozen?.entry)
+        assertCommandIdentity(entry.frozen);
+    } catch {
+      throw new QaPreparationError("integrity", entry.diagnostics.map((item) => item.acceptance_id), "command_identity_changed", entry.diagnostics);
+    }
   }
   const base = {
     contract: "assurance_kernel/assurance_verdict/v2",
@@ -8296,6 +8514,11 @@ var BATCH_REASONS = Object.freeze({
     reason: (detail) => `an active workspace claim already exists for task: ${detail}`,
     recovery_action: "resolve or stop the active task before starting a batch in the current Host"
   },
+  kernel_authority_conflict: {
+    state: "rejected",
+    reason: (detail) => `Kernel authority conflict: ${detail}`,
+    recovery_action: "resolve the Kernel storage conflict before resuming in the current Host"
+  },
   git_head_unreadable: {
     state: "rejected",
     reason: (detail) => detail,
@@ -8662,6 +8885,17 @@ function createGhTransport(binary = "gh") {
       return new Promise((complete) => {
         let stdout = Buffer.alloc(0);
         let stderr = Buffer.alloc(0);
+        const remaining = options.budget === undefined ? GH_TIMEOUT_MS : Math.min(GH_TIMEOUT_MS, options.budget.deadline_ms - Date.now());
+        if (options.budget && (options.budget.signal?.aborted || remaining <= 0)) {
+          complete({
+            exit_code: 1,
+            stdout: "",
+            stderr: options.budget.signal?.aborted ? "operation cancelled by the caller" : "publication deadline exceeded before the next remote call",
+            timed_out: true,
+            output_exceeded: false
+          });
+          return;
+        }
         let timedOut = false;
         let outputExceeded = false;
         let timer;
@@ -8719,7 +8953,7 @@ function createGhTransport(binary = "gh") {
         timer = setTimeout(() => {
           timedOut = true;
           child.kill("SIGKILL");
-        }, GH_TIMEOUT_MS);
+        }, remaining);
         child.once("close", (code) => {
           finish(code ?? 1);
         });
@@ -8823,6 +9057,33 @@ function initiativeLookup(issues, repositoryId, initiativeId) {
   const initiative = marker("initiative-id", initiativeId);
   return findIssue(issues, [initiative, KIND_INITIATIVE_MARKER], [marker("repo-id", repositoryId), initiative]);
 }
+function publishedIntentHashMarkers(body) {
+  return [...body.matchAll(/<!-- immune-brain:intent-hash=([A-Za-z0-9][A-Za-z0-9._:-]{0,127}) -->/g)].map((match) => match[1]);
+}
+function publishedIntentIdentity(body) {
+  const hashes = publishedIntentHashMarkers(body);
+  if (hashes.length === 0)
+    return { kind: "absent" };
+  if (hashes.length === 1)
+    return { kind: "bound", hash: hashes[0] };
+  return { kind: "ambiguous", hashes };
+}
+function publishedIntentMismatch(body, taskId, expected) {
+  const identity = publishedIntentIdentity(body);
+  if (identity.kind === "ambiguous")
+    return `published Task ${taskId} carries ${identity.hashes.length} conflicting intent-hash markers; its published Intent identity is ambiguous`;
+  if (identity.kind === "absent" || expected === undefined)
+    return null;
+  if (identity.hash !== expected)
+    return `published Task ${taskId} was published from a different TaskIntent revision; the published identity no longer matches the Intent being published`;
+  return null;
+}
+function sameTrackedBody(current, expected) {
+  return stripPublishedIntentHash(current) === stripPublishedIntentHash(expected);
+}
+function stripPublishedIntentHash(body) {
+  return body.replace(/<!-- immune-brain:intent-hash=[A-Za-z0-9][A-Za-z0-9._:-]{0,127} -->\n?/g, "");
+}
 function ownershipMarkerValue(body, name) {
   const values = [...body.matchAll(new RegExp(`<!-- immune-brain:${name}=([A-Za-z0-9][A-Za-z0-9._-]{0,127}) -->`, "g"))];
   return values.length === 1 ? values[0][1] : null;
@@ -9123,7 +9384,8 @@ function childBody(repository, operation, parent) {
     marker("repo-id", repository.id),
     marker("initiative-id", operation.initiative_id),
     marker("slice-id", operation.slice_id),
-    marker("task-id", operation.task_id)
+    marker("task-id", operation.task_id),
+    ...operation.intent_hash ? [marker("intent-hash", operation.intent_hash)] : []
   ].join(`
 `)}
 
@@ -9292,8 +9554,11 @@ async function upsertTask(root, gh, operation, source, pendingBinding = null, am
         return result(operation.op, "ambiguous_remote_state", `new pending Task ${operation.task_id} is unbound but Issue #${child.number} already exists with divergent content; bind it to amend`, found.issue);
       return updatePendingChild(root, gh, source, operation, child, undefined, blockers, approvedFinal, amendmentContext);
     }
-    if (found.issue.body !== body || found.issue.title !== title)
+    if (!sameTrackedBody(found.issue.body, body) || found.issue.title !== title)
       return result(operation.op, "permanent_failure", "Task Issue already exists with a different title or Agent Brief; edit the GitHub source or retry the original projection before changing native relations", found.issue);
+    const intentMismatch = publishedIntentMismatch(found.issue.body, operation.task_id, operation.intent_hash);
+    if (intentMismatch)
+      return result(operation.op, "ambiguous_remote_state", intentMismatch, found.issue);
     const observedLabelArgs = labelMutationArgs(child.labels, desiredTaskLabels(operation));
     if (observedLabelArgs.length) {
       const edited = await gh.run([
@@ -9329,8 +9594,11 @@ async function upsertTask(root, gh, operation, source, pendingBinding = null, am
   if ("contract" in finalSource)
     return finalSource;
   const finalChild = ownedTaskLookup(finalSource.issues, finalSource.repository.id, operation.task_id, operation.initiative_id, operation.slice_id);
-  if (finalChild.kind !== "found" || finalChild.issue.id !== child.id || finalChild.issue.title !== title || finalChild.issue.body !== body)
+  if (finalChild.kind !== "found" || finalChild.issue.id !== child.id || finalChild.issue.title !== title || !sameTrackedBody(finalChild.issue.body, body))
     return result(operation.op, "ambiguous_remote_state", "Task Issue changed identity, title, or body during dependency publication", child);
+  const finalIdentityMismatch = publishedIntentMismatch(finalChild.issue.body, operation.task_id, operation.intent_hash);
+  if (finalIdentityMismatch)
+    return result(operation.op, "ambiguous_remote_state", finalIdentityMismatch, child);
   const finalChildOwnership = await confirmTerminalOwnership(root, gh, operation.op, finalSource, finalChild.issue);
   if (!("owned" in finalChildOwnership))
     return finalChildOwnership;
@@ -9782,7 +10050,7 @@ async function revalidatePendingChildBeforeWrite(root, gh, childNumber, childTas
 import { existsSync as existsSync7, readdirSync as readdirSync6, readFileSync as readFileSync13 } from "node:fs";
 import { randomUUID as randomUUID7 } from "node:crypto";
 import { join as join12 } from "node:path";
-import { spawnSync as spawnSync5 } from "node:child_process";
+import { spawnSync as spawnSync6 } from "node:child_process";
 
 // plugins/immune-brain/runtime/kernel/batch_authority.ts
 import { createHash as createHash18 } from "node:crypto";
@@ -10031,252 +10299,49 @@ function deriveChildEnrollment(root, registry, input) {
   };
 }
 
-// plugins/immune-brain/runtime/unattended/batch_plan.ts
-import { createHash as createHash19 } from "node:crypto";
-var ID_PATTERN2 = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
-var DEFAULT_DEADLINE_MS = 8 * 60 * 60 * 1000;
-var DEFAULT_QA_FAILURE_LIMIT = 2;
-function specBindingReason(inspection) {
-  if (inspection.missing.length > 0)
-    return `spec_binding_incomplete: ${inspection.missing.join(", ")}`;
-  return inspection.code === "binding_ambiguous" ? "spec_binding_ambiguous" : "spec_binding_missing";
-}
-function compareIds(left, right) {
-  return left < right ? -1 : left > right ? 1 : 0;
-}
-function positiveSafeInteger(value, name) {
-  if (!Number.isSafeInteger(value) || value <= 0)
-    throw new Error(`${name} must be a positive safe integer`);
-  return value;
-}
-var ISO_TIMESTAMP_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/;
-function timestamp(value, name) {
+// plugins/immune-brain/runtime/unattended/batch_reconfirmation.ts
+import { spawnSync as spawnSync5 } from "node:child_process";
+
+// plugins/immune-brain/runtime/unattended/batch_state.ts
+import { existsSync as existsSync6, 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 randomUUID6 } from "node:crypto";
+import { dirname as dirname7, join as join11 } from "node:path";
+var BATCH_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+var CHILD_RUN_STATES = new Set([
+  "pending",
+  "enrolled",
+  "settled",
+  "committed",
+  "needs_human",
+  "skipped_blocked"
+]);
+var BATCH_RUN_STATES = new Set([
+  "prepared",
+  "running",
+  "needs_human",
+  "completed",
+  "budget_stopped",
+  "failed",
+  "rejected"
+]);
+var ISO_TIMESTAMP_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+function isCanonicalTimestamp(value) {
   if (typeof value !== "string" || !ISO_TIMESTAMP_PATTERN.test(value))
-    throw new Error(`${name} must be an ISO timestamp`);
+    return false;
   const milliseconds = Date.parse(value);
-  if (!Number.isFinite(milliseconds))
-    throw new Error(`${name} must be an ISO timestamp`);
-  return { milliseconds, iso: new Date(milliseconds).toISOString() };
-}
-function normalizeObservation(value, initiativeSlug) {
-  if (!value || 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)
-    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");
-  const taskIds = new Set;
-  const sliceIds = new Set;
-  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))
-      throw new Error(`tracker Task ${index} has an invalid task_id`);
-    if (!ID_PATTERN2.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)
-      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)))
-      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}`);
-    if (sliceIds.has(task.slice_id))
-      throw new Error(`tracker returned duplicate Slice ${task.slice_id}`);
-    taskIds.add(task.task_id);
-    sliceIds.add(task.slice_id);
-    const blockedBy = [...task.blocked_by].sort();
-    if (new Set(blockedBy).size !== blockedBy.length || blockedBy.includes(task.task_id))
-      throw new Error(`tracker Task ${task.task_id} has invalid blocked_by dependencies`);
-    return { ...task, blocked_by: blockedBy };
-  });
-  for (const task of tasks) {
-    const unknown = task.blocked_by.find((id) => !taskIds.has(id));
-    if (unknown)
-      throw new Error(`tracker Task ${task.task_id} depends on unknown Task ${unknown}`);
-  }
-  return { ...value, tasks: tasks.sort((left, right) => compareIds(left.task_id, right.task_id)) };
+  return Number.isFinite(milliseconds) && new Date(milliseconds).toISOString() === value;
 }
-function dependencyOrder(observation) {
-  const remaining = new Map(observation.tasks.map((task) => [task.task_id, task]));
-  const done = new Set;
-  const order = [];
-  while (remaining.size) {
-    const ready = [...remaining.values()].filter((task) => task.blocked_by.every((id) => done.has(id))).sort((left, right) => compareIds(left.task_id, right.task_id));
-    if (!ready.length)
-      throw new Error("Initiative Task dependencies must form an acyclic graph");
-    for (const task of ready) {
-      remaining.delete(task.task_id);
-      done.add(task.task_id);
-      order.push(task);
-    }
-  }
-  return order;
+function validateBatchId(batchId) {
+  if (typeof batchId !== "string" || !BATCH_ID_PATTERN.test(batchId))
+    throw new Error("batch id is not a safe file identity");
 }
-function dependencyClosures(order) {
-  const closures = new Map;
-  for (const task of order) {
-    const closure = new Set;
-    for (const dependency of task.blocked_by) {
-      closure.add(dependency);
-      for (const transitive of closures.get(dependency) ?? [])
-        closure.add(transitive);
-    }
-    closures.set(task.task_id, [...closure].sort());
-  }
-  return closures;
+function statePath(batchId) {
+  validateBatchId(batchId);
+  return join11(".imm", "state", "batches", `${batchId}.json`);
 }
-function budget(input, enrollableCount, confirmationTime) {
-  const maxChildren = input.budget?.max_children === undefined ? positiveSafeInteger(enrollableCount, "budget.max_children") : positiveSafeInteger(input.budget.max_children, "budget.max_children");
-  if (maxChildren > enrollableCount)
-    throw new Error("budget.max_children exceeds the enrollable Child count");
-  const qaFailureLimit = input.budget?.qa_failure_limit === undefined ? DEFAULT_QA_FAILURE_LIMIT : positiveSafeInteger(input.budget.qa_failure_limit, "budget.qa_failure_limit");
-  const deadline = input.budget?.deadline_at === undefined ? new Date(confirmationTime.milliseconds + DEFAULT_DEADLINE_MS).toISOString() : timestamp(input.budget.deadline_at, "budget.deadline_at").iso;
-  if (Date.parse(deadline) <= confirmationTime.milliseconds)
-    throw new Error("budget.deadline_at must be later than confirmation_time");
-  return { max_children: maxChildren, deadline_at: deadline, qa_failure_limit: qaFailureLimit };
-}
-async function projectBatchPlan(root, initiativeSlug, input, readInitiative = observeGithubInitiative) {
-  if (!ID_PATTERN2.test(initiativeSlug))
-    throw new Error("initiative_slug is invalid");
-  if (!input || typeof input !== "object")
-    throw new Error("batch plan input is required");
-  const confirmationTime = timestamp(input.confirmation_time, "confirmation_time");
-  const trackerObservation = normalizeObservation(await readInitiative(root, initiativeSlug), initiativeSlug);
-  const order = dependencyOrder(trackerObservation);
-  const closures = dependencyClosures(order);
-  const children = [];
-  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 };
-    const tombstone = readTaskTombstone(root, task.task_id);
-    const record = readTaskRecordRaw(root, task.task_id).record;
-    if (tombstone && record)
-      throw new Error(`Task ${task.task_id} has conflicting settled and active state`);
-    if (tombstone) {
-      children.push({ ...child, status: "already_settled", reason: null, intent_path: null, intent_revision: null, intent_content_hash: null });
-      continue;
-    }
-    if (record) {
-      children.push({ ...child, status: "already_owned", reason: null, intent_path: null, intent_revision: null, intent_content_hash: null });
-      continue;
-    }
-    const intentPath = `docs/plans/${task.task_id}.intent.json`;
-    try {
-      const read = observeTaskIntent(root, task.task_id, intentPath);
-      if (read.intent.risk === "critical") {
-        children.push({
-          ...child,
-          status: "needs_human",
-          reason: "critical",
-          intent_path: read.intent_ref.path,
-          intent_revision: read.intent_ref.revision,
-          intent_content_hash: read.content_hash
-        });
-        continue;
-      }
-      const binding = inspectSpecBinding(read.intent);
-      if (!binding.ok) {
-        children.push({
-          ...child,
-          status: "needs_human",
-          reason: specBindingReason(binding),
-          intent_path: read.intent_ref.path,
-          intent_revision: read.intent_ref.revision,
-          intent_content_hash: read.content_hash
-        });
-        continue;
-      }
-      children.push({
-        ...child,
-        status: "enrollable",
-        reason: null,
-        intent_path: read.intent_ref.path,
-        intent_revision: read.intent_ref.revision,
-        intent_content_hash: read.content_hash
-      });
-    } catch (error) {
-      if (!(error instanceof TaskIntentObservationError))
-        throw error;
-      children.push({ ...child, status: "needs_human", reason: "invalid_intent", intent_path: null, intent_revision: null, intent_content_hash: null });
-    }
-  }
-  const directDependencies = new Map(order.map((task) => [task.task_id, task.blocked_by]));
-  const childById = new Map(children.map((child) => [child.task_id, child]));
-  for (const child of children) {
-    if (child.status !== "enrollable")
-      continue;
-    if (directDependencies.get(child.task_id).some((id) => {
-      const status = childById.get(id).status;
-      return status === "already_owned" || status === "needs_human" || status === "blocked";
-    })) {
-      child.status = "blocked";
-      child.reason = "dependency_unavailable";
-    }
-  }
-  const enrollable = children.filter((child) => child.status === "enrollable").map((child) => ({
-    task_id: child.task_id,
-    intent_path: child.intent_path,
-    intent_revision: child.intent_revision,
-    intent_content_hash: child.intent_content_hash,
-    blocked_by: child.blocked_by.filter((id) => childById.get(id)?.status === "enrollable")
-  }));
-  if (!enrollable.length)
-    throw new Error("batch plan has no enrollable children; nothing to confirm");
-  const planDigest = `sha256:${createHash19("sha256").update(stableStringify(enrollable)).digest("hex")}`;
-  return {
-    contract: "assurance_kernel/batch_plan/v1",
-    initiative_slug: initiativeSlug,
-    confirmation_time: confirmationTime.iso,
-    tracker_observation: trackerObservation,
-    children,
-    enrollable,
-    plan_digest: planDigest,
-    budget: budget(input, enrollable.length, confirmationTime)
-  };
-}
-
-// plugins/immune-brain/runtime/unattended/batch_state.ts
-import { existsSync as existsSync6, 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 randomUUID6 } from "node:crypto";
-import { dirname as dirname7, join as join11 } from "node:path";
-var BATCH_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
-var CHILD_RUN_STATES = new Set([
-  "pending",
-  "enrolled",
-  "settled",
-  "committed",
-  "needs_human",
-  "skipped_blocked"
-]);
-var BATCH_RUN_STATES = new Set([
-  "prepared",
-  "running",
-  "needs_human",
-  "completed",
-  "budget_stopped",
-  "failed",
-  "rejected"
-]);
-var ISO_TIMESTAMP_PATTERN2 = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
-function isCanonicalTimestamp(value) {
-  if (typeof value !== "string" || !ISO_TIMESTAMP_PATTERN2.test(value))
-    return false;
-  const milliseconds = Date.parse(value);
-  return Number.isFinite(milliseconds) && new Date(milliseconds).toISOString() === value;
-}
-function validateBatchId(batchId) {
-  if (typeof batchId !== "string" || !BATCH_ID_PATTERN.test(batchId))
-    throw new Error("batch id is not a safe file identity");
-}
-function statePath(batchId) {
-  validateBatchId(batchId);
-  return join11(".imm", "state", "batches", `${batchId}.json`);
-}
-function canonicalBytes(record) {
-  return `${JSON.stringify(record, null, 2)}
-`;
+function canonicalBytes(record) {
+  return `${JSON.stringify(record, null, 2)}
+`;
 }
 function validateRecordShape(value, batchId) {
   if (typeof value !== "object" || value === null)
@@ -10366,13 +10431,17 @@ function prepareBatchRunState(input) {
   };
   return prepared;
 }
+function parseBatchRunState(raw, batchId) {
+  validateBatchId(batchId);
+  const parsed = JSON.parse(raw);
+  validateRecordShape(parsed, batchId);
+  return parsed;
+}
 function readBatchRunState(root, batchId) {
   const path = statePath(batchId);
   if (!existsSync6(join11(root, path)))
     return null;
-  const parsed = JSON.parse(readSecureProjectFile(root, path));
-  validateRecordShape(parsed, batchId);
-  return parsed;
+  return parseBatchRunState(readSecureProjectFile(root, path), batchId);
 }
 function ensureSecureDirectory2(root, relative) {
   const target = join11(root, relative);
@@ -10412,6 +10481,18 @@ function writeFileAtomically(root, relative, bytes) {
     }
   }
 }
+function replaceBatchRunState(root, expected, next, validate) {
+  const path = statePath(next.batch_id);
+  validateRecordShape(next, next.batch_id);
+  return withKernelStoreLock(root, () => {
+    if (!readSecureProjectBytes(root, path).equals(expected))
+      throw new Error("batch state CAS mismatch");
+    validate();
+    const stored = { ...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);
@@ -10459,6 +10540,428 @@ function isTerminalBatchState(state) {
   return state === "completed" || state === "budget_stopped" || state === "failed" || state === "rejected";
 }
 
+// plugins/immune-brain/runtime/unattended/batch_reconfirmation.ts
+var oid = /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/;
+var id = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+var batchAuthor = process.env.GIT_AUTHOR_NAME || "Immune-Brain Batch";
+var decode = (bytes) => new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+function refuse() {
+  throw new Error("plan_digest mismatch: batch plan reconfirmation is not eligible");
+}
+function matchesLocalProof(localJson, exported) {
+  return localJson !== null && JSON.stringify(Object.entries(JSON.parse(localJson)).sort()) === JSON.stringify(Object.entries(exported).sort());
+}
+function git4(root, args) {
+  const r = spawnSync5("git", ["-C", root, ...args], { encoding: "buffer", maxBuffer: 262144, env: { ...process.env, GIT_OPTIONAL_LOCKS: "0" } });
+  if (r.status !== 0)
+    refuse();
+  return decode(r.stdout);
+}
+function ownUnpersistedBatchHead(root, record, head) {
+  try {
+    if (!oid.test(head) || !oid.test(record.base_head) || !id.test(record.batch_id) || record.commits.length || record.children[0]?.state !== "settled" || record.children.some((c) => c.commit !== null))
+      return false;
+    const task = record.children[0].task_id;
+    if (!id.test(task))
+      return false;
+    const evidence = JSON.parse(decode(readSecureProjectBytes(root, `.imm/state/batches/commits/${record.batch_id}-${task}.json`)));
+    if (evidence.contract !== "assurance_kernel/batch_commit_evidence/v1" || evidence.batch_id !== record.batch_id || evidence.task_id !== task || evidence.commit !== head || evidence.parent_head !== record.base_head)
+      return false;
+    if (git4(root, ["symbolic-ref", "--short", "HEAD"]).trim() !== record.branch)
+      return false;
+    const parents = git4(root, ["rev-list", "--parents", "-n", "1", head]).trim().split(/\s+/).slice(1);
+    if (parents.length !== 1 || parents[0] !== record.base_head)
+      return false;
+    const metadata = git4(root, ["show", "-s", "--format=%an%x00%s%x00%(trailers:key=Immune-Brain-Batch,valueonly)", head]).split("\x00");
+    if (metadata[0] !== batchAuthor || !metadata[1]?.startsWith(`imm(${task}):`) || metadata[2]?.trim() !== record.batch_id)
+      return false;
+    const run = localRunId(root, task);
+    if (!run || !id.test(run))
+      return false;
+    const pair = readAuditTaskPair(root, task, run);
+    if (!pair || pair.record.contract !== "assurance_kernel/task_record/v4" || pair.record.lifecycle !== "done" || pair.proof.terminal_lifecycle !== "done")
+      return false;
+    const local = withKernelRead(root, (db) => readRunRowByTask(db, task));
+    if (!local || local.run_id !== run || local.state !== "done" || !matchesLocalProof(local.terminal_proof_json, pair.proof))
+      return false;
+    for (const file of ["task-record.json", "terminal-proof.json"]) {
+      const path = `.imm/audit/${task}/${run}/${file}`;
+      if (!readSecureProjectBytes(root, path).equals(Buffer.from(git4(root, ["show", `${head}:${path}`]))))
+        return false;
+    }
+    const paths = git4(root, ["diff-tree", "--no-commit-id", "--name-only", "--no-renames", "-z", "-r", head]).split("\x00").filter(Boolean);
+    if (!paths.length || paths.some((path) => !path.startsWith(`.imm/audit/${task}/${run}/`) && !pair.record.intent_snapshot.scope_hint.some((s) => pathMatchesScope(path, s))))
+      return false;
+    const identity = taskCommitRevisionIdentity(root, pair.record.intent_snapshot.scope_hint, pair.record.git_base_head, head);
+    if (!projectTask(pair.record.intent_snapshot, pair.record, identity.diff_hash, pair.record.intent_ref.content_hash, identity.changed_paths).complete)
+      return false;
+    return git4(root, ["rev-parse", "HEAD"]).trim() === head;
+  } catch {
+    return false;
+  }
+}
+var confirmations = new Map;
+function retainReconfirmation(nonce, expires, snapshot) {
+  for (const [key, value] of confirmations)
+    if (value.expires <= Date.now())
+      confirmations.delete(key);
+  if (confirmations.has(nonce))
+    refuse();
+  confirmations.set(nonce, { snapshot, expires: Date.parse(expires) });
+}
+function takeReconfirmation(nonce) {
+  const found = confirmations.get(nonce);
+  confirmations.delete(nonce);
+  if (!found || found.expires <= Date.now())
+    refuse();
+  return found.snapshot;
+}
+async function captureBatchReconfirmation(root, record, children) {
+  if (!id.test(record.batch_id) || !oid.test(record.base_head) || isTerminalBatchState(record.batch_state) || record.commits.length || record.children.some((c) => c.commit !== null || c.state === "committed") || record.children.length !== children.length || !children.length)
+    refuse();
+  const assertNoCommitEvidence = () => {
+    for (const child of record.children) {
+      if (!id.test(child.task_id))
+        refuse();
+      const path = `.imm/state/batches/commits/${record.batch_id}-${child.task_id}.json`;
+      let missing = false;
+      try {
+        readSecureProjectBytes(root, path);
+      } catch (error) {
+        if (error instanceof Error && error.message === `source_missing: ${path}`)
+          missing = true;
+        else
+          refuse();
+      }
+      if (!missing)
+        refuse();
+    }
+  };
+  assertNoCommitEvidence();
+  const statePath = `.imm/state/batches/${record.batch_id}.json`;
+  const stateBytes = readSecureProjectBytes(root, statePath);
+  if (JSON.stringify(JSON.parse(decode(stateBytes))) !== JSON.stringify(record))
+    refuse();
+  const files = new Map;
+  const capture = (path) => {
+    const bytes = readSecureProjectBytes(root, path);
+    files.set(path, bytes);
+    return bytes;
+  };
+  const oldChildren = [];
+  const changed = [];
+  let scope = null;
+  const workspace = readWorkspaceStateRaw(root);
+  if (workspace.state.current_working !== null)
+    refuse();
+  for (const [index, child] of children.entries()) {
+    const previous = record.children[index];
+    if (!id.test(child.task_id) || child.task_id !== previous.task_id || child.slice_id !== previous.slice_id || JSON.stringify(child.blocked_by) !== JSON.stringify(previous.blocked_by) || child.intent_path !== `docs/plans/${child.task_id}.intent.json`)
+      refuse();
+    const old = parseTaskIntentV1(JSON.parse(git4(root, ["show", `${record.base_head}:${child.intent_path}`])));
+    if (old.task_id !== child.task_id)
+      refuse();
+    const oldHash = canonicalIntentHash(old);
+    oldChildren.push({ task_id: child.task_id, blocked_by: [...child.blocked_by], intent_path: child.intent_path, intent_revision: old.revision, intent_content_hash: oldHash });
+    const currentBytes = capture(child.intent_path);
+    const current = parseTaskIntentV1(JSON.parse(decode(currentBytes)));
+    const currentHash = canonicalIntentHash(current);
+    const tracked = readTaskIntent(root, child.task_id, child.intent_path);
+    if (currentHash !== tracked.content_hash || currentHash !== child.intent_content_hash || current.revision !== child.intent_revision)
+      refuse();
+    if (currentHash === oldHash)
+      continue;
+    if (scope !== null || previous.state === "pending" || previous.state === "skipped_blocked" || current.revision <= old.revision || current.goal !== old.goal || current.owner !== old.owner)
+      refuse();
+    const run = localRunId(root, child.task_id);
+    if (!run || !id.test(run))
+      refuse();
+    const local = withKernelRead(root, (db) => readRunRowByTask(db, child.task_id));
+    if (!local || local.run_id !== run || local.state !== "done" || local.enrollment_event_id !== `enroll-${child.task_id}-${local.created_at}` || Date.parse(local.created_at) > Date.parse(record.updated_at))
+      refuse();
+    const pair = readAuditTaskPair(root, child.task_id, run);
+    if (!pair || pair.record.contract !== "assurance_kernel/task_record/v4")
+      refuse();
+    const r = pair.record;
+    if (r.lifecycle !== "done" || r.intent_ref.content_hash !== currentHash || canonicalIntentHash(r.intent_snapshot) !== currentHash || r.git_base_head !== record.base_head || pair.proof.terminal_lifecycle !== "done")
+      refuse();
+    const terminal = r.history.at(-1);
+    if (terminal?.type !== "complete" || terminal.from_state !== "active:frozen" || terminal.to_state !== "done:frozen" || terminal.id !== pair.proof.terminal_event_id)
+      refuse();
+    const recordPath = `.imm/audit/${child.task_id}/${run}/task-record.json`;
+    const proofPath = `.imm/audit/${child.task_id}/${run}/terminal-proof.json`;
+    if (!capture(recordPath).equals(Buffer.from(local.record_json)))
+      refuse();
+    const capturedProof = JSON.parse(decode(capture(proofPath)));
+    if (!matchesLocalProof(local.terminal_proof_json, capturedProof) || !matchesLocalProof(local.terminal_proof_json, pair.proof))
+      refuse();
+    const identity = taskRevisionIdentity(root, r.intent_snapshot.scope_hint, r.git_base_head, r.task_id);
+    const projection = await projectAssurance(root, child.task_id, (cwd, task) => {
+      if (task.contract !== "assurance_kernel/task_record/v4" || !task.git_base_head)
+        refuse();
+      return taskRevisionIdentity(cwd, task.intent_snapshot.scope_hint, task.git_base_head, task.task_id);
+    });
+    if (projection.error || projection.claim || projection.projection.run_id !== run || projection.projection.lifecycle !== "done" || !projection.projection.completion_ready || projection.projection.intent_content_hash !== currentHash || projection.projection.diff_hash !== identity.diff_hash || !projection.projection.fresh_approval_kinds.includes("qa") || projection.projection.risk !== "routine" && !projection.projection.fresh_approval_kinds.includes("review"))
+      refuse();
+    scope = r.intent_snapshot.scope_hint;
+    changed.push({ task: child.task_id, run, identity: JSON.stringify(identity), local: JSON.stringify(local) });
+  }
+  if (computeBatchPlanDigest(oldChildren) !== record.plan_digest || changed.length !== 1 || scope === null)
+    refuse();
+  const confirmedScope = scope;
+  const owner = changed[0];
+  const status = () => git4(root, ["status", "--porcelain=v1", "-z", "--untracked-files=all", "--ignore-submodules=none"]);
+  const statusBytes = status();
+  const entries = statusBytes.split("\x00").filter(Boolean);
+  for (const entry of entries) {
+    const code = entry.slice(0, 2), path = entry.slice(3);
+    if (code[1] !== " " || !["A", "M", "D"].includes(code[0]) || !path.startsWith(`.imm/audit/${owner.task}/${owner.run}/`) && !confirmedScope.some((s) => pathMatchesScope(path, s)))
+      refuse();
+  }
+  const flagsBytes = git4(root, ["ls-files", "-v"]);
+  const flags = flagsBytes.split(`
+`).filter(Boolean);
+  if (flags.some((line) => line[0] === "S" || line[0] !== line[0]?.toUpperCase()))
+    refuse();
+  const head = () => git4(root, ["rev-parse", "HEAD"]).trim();
+  const branch = () => git4(root, ["symbolic-ref", "--short", "HEAD"]).trim();
+  if (head() !== record.base_head || branch() !== record.branch)
+    refuse();
+  const assertDeliveryUnchanged = () => {
+    for (const c of changed) {
+      const pair = readAuditTaskPair(root, c.task, c.run);
+      if (!pair || pair.record.contract !== "assurance_kernel/task_record/v4" || !pair.record.git_base_head)
+        refuse();
+      const local = withKernelRead(root, (db) => readRunRowByTask(db, c.task));
+      const diff = taskRevisionIdentity(root, pair.record.intent_snapshot.scope_hint, pair.record.git_base_head, c.task);
+      if (localRunId(root, c.task) !== c.run || JSON.stringify(local) !== c.local || JSON.stringify(diff) !== c.identity)
+        refuse();
+    }
+  };
+  const assertUnchanged = () => {
+    assertNoCommitEvidence();
+    if (!readSecureProjectBytes(root, statePath).equals(stateBytes) || head() !== record.base_head || branch() !== record.branch || status() !== statusBytes || git4(root, ["ls-files", "-v"]) !== flagsBytes || readWorkspaceStateRaw(root).revision !== workspace.revision)
+      refuse();
+    for (const [path, bytes] of files)
+      if (!readSecureProjectBytes(root, path).equals(bytes))
+        refuse();
+    assertDeliveryUnchanged();
+  };
+  assertUnchanged();
+  const plan_digest = computeBatchPlanDigest(oldChildren.map((old, index) => ({
+    ...old,
+    intent_revision: children[index].intent_revision,
+    intent_content_hash: children[index].intent_content_hash
+  })));
+  return { root, plan_digest, stateBytes, assertUnchanged };
+}
+
+// plugins/immune-brain/runtime/unattended/batch_plan.ts
+import { createHash as createHash19 } from "node:crypto";
+var ID_PATTERN2 = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+var DEFAULT_DEADLINE_MS = 8 * 60 * 60 * 1000;
+var DEFAULT_QA_FAILURE_LIMIT = 2;
+function specBindingReason(inspection) {
+  if (inspection.missing.length > 0)
+    return `spec_binding_incomplete: ${inspection.missing.join(", ")}`;
+  return inspection.code === "binding_ambiguous" ? "spec_binding_ambiguous" : "spec_binding_missing";
+}
+function compareIds(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function positiveSafeInteger(value, name) {
+  if (!Number.isSafeInteger(value) || value <= 0)
+    throw new Error(`${name} must be a positive safe integer`);
+  return value;
+}
+var ISO_TIMESTAMP_PATTERN2 = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/;
+function timestamp(value, name) {
+  if (typeof value !== "string" || !ISO_TIMESTAMP_PATTERN2.test(value))
+    throw new Error(`${name} must be an ISO timestamp`);
+  const milliseconds = Date.parse(value);
+  if (!Number.isFinite(milliseconds))
+    throw new Error(`${name} must be an ISO timestamp`);
+  return { milliseconds, iso: new Date(milliseconds).toISOString() };
+}
+function normalizeObservation(value, initiativeSlug) {
+  if (!value || 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)
+    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");
+  const taskIds = new Set;
+  const sliceIds = new Set;
+  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))
+      throw new Error(`tracker Task ${index} has an invalid task_id`);
+    if (!ID_PATTERN2.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)
+      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)))
+      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}`);
+    if (sliceIds.has(task.slice_id))
+      throw new Error(`tracker returned duplicate Slice ${task.slice_id}`);
+    taskIds.add(task.task_id);
+    sliceIds.add(task.slice_id);
+    const blockedBy = [...task.blocked_by].sort();
+    if (new Set(blockedBy).size !== blockedBy.length || blockedBy.includes(task.task_id))
+      throw new Error(`tracker Task ${task.task_id} has invalid blocked_by dependencies`);
+    return { ...task, blocked_by: blockedBy };
+  });
+  for (const task of tasks) {
+    const unknown = task.blocked_by.find((id) => !taskIds.has(id));
+    if (unknown)
+      throw new Error(`tracker Task ${task.task_id} depends on unknown Task ${unknown}`);
+  }
+  return { ...value, tasks: tasks.sort((left, right) => compareIds(left.task_id, right.task_id)) };
+}
+function dependencyOrder(observation) {
+  const remaining = new Map(observation.tasks.map((task) => [task.task_id, task]));
+  const done = new Set;
+  const order = [];
+  while (remaining.size) {
+    const ready = [...remaining.values()].filter((task) => task.blocked_by.every((id) => done.has(id))).sort((left, right) => compareIds(left.task_id, right.task_id));
+    if (!ready.length)
+      throw new Error("Initiative Task dependencies must form an acyclic graph");
+    for (const task of ready) {
+      remaining.delete(task.task_id);
+      done.add(task.task_id);
+      order.push(task);
+    }
+  }
+  return order;
+}
+function dependencyClosures(order) {
+  const closures = new Map;
+  for (const task of order) {
+    const closure = new Set;
+    for (const dependency of task.blocked_by) {
+      closure.add(dependency);
+      for (const transitive of closures.get(dependency) ?? [])
+        closure.add(transitive);
+    }
+    closures.set(task.task_id, [...closure].sort());
+  }
+  return closures;
+}
+function budget(input, enrollableCount, confirmationTime) {
+  const maxChildren = input.budget?.max_children === undefined ? positiveSafeInteger(enrollableCount, "budget.max_children") : positiveSafeInteger(input.budget.max_children, "budget.max_children");
+  if (maxChildren > enrollableCount)
+    throw new Error("budget.max_children exceeds the enrollable Child count");
+  const qaFailureLimit = input.budget?.qa_failure_limit === undefined ? DEFAULT_QA_FAILURE_LIMIT : positiveSafeInteger(input.budget.qa_failure_limit, "budget.qa_failure_limit");
+  const deadline = input.budget?.deadline_at === undefined ? new Date(confirmationTime.milliseconds + DEFAULT_DEADLINE_MS).toISOString() : timestamp(input.budget.deadline_at, "budget.deadline_at").iso;
+  if (Date.parse(deadline) <= confirmationTime.milliseconds)
+    throw new Error("budget.deadline_at must be later than confirmation_time");
+  return { max_children: maxChildren, deadline_at: deadline, qa_failure_limit: qaFailureLimit };
+}
+async function projectBatchPlan(root, initiativeSlug, input, readInitiative = observeGithubInitiative) {
+  if (!ID_PATTERN2.test(initiativeSlug))
+    throw new Error("initiative_slug is invalid");
+  if (!input || typeof input !== "object")
+    throw new Error("batch plan input is required");
+  const confirmationTime = timestamp(input.confirmation_time, "confirmation_time");
+  const trackerObservation = normalizeObservation(await readInitiative(root, initiativeSlug), initiativeSlug);
+  const order = dependencyOrder(trackerObservation);
+  const closures = dependencyClosures(order);
+  const children = [];
+  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 };
+    const tombstone = readTaskTombstone(root, task.task_id);
+    const record = readTaskRecordRaw(root, task.task_id).record;
+    if (tombstone && record)
+      throw new Error(`Task ${task.task_id} has conflicting settled and active state`);
+    if (tombstone) {
+      children.push({ ...child, status: "already_settled", reason: null, intent_path: null, intent_revision: null, intent_content_hash: null });
+      continue;
+    }
+    if (record) {
+      children.push({ ...child, status: "already_owned", reason: null, intent_path: null, intent_revision: null, intent_content_hash: null });
+      continue;
+    }
+    const intentPath = `docs/plans/${task.task_id}.intent.json`;
+    try {
+      const read = observeTaskIntent(root, task.task_id, intentPath);
+      if (read.intent.risk === "critical") {
+        children.push({
+          ...child,
+          status: "needs_human",
+          reason: "critical",
+          intent_path: read.intent_ref.path,
+          intent_revision: read.intent_ref.revision,
+          intent_content_hash: read.content_hash
+        });
+        continue;
+      }
+      const binding = inspectSpecBinding(read.intent);
+      if (!binding.ok) {
+        children.push({
+          ...child,
+          status: "needs_human",
+          reason: specBindingReason(binding),
+          intent_path: read.intent_ref.path,
+          intent_revision: read.intent_ref.revision,
+          intent_content_hash: read.content_hash
+        });
+        continue;
+      }
+      children.push({
+        ...child,
+        status: "enrollable",
+        reason: null,
+        intent_path: read.intent_ref.path,
+        intent_revision: read.intent_ref.revision,
+        intent_content_hash: read.content_hash
+      });
+    } catch (error) {
+      if (!(error instanceof TaskIntentObservationError))
+        throw error;
+      children.push({ ...child, status: "needs_human", reason: "invalid_intent", intent_path: null, intent_revision: null, intent_content_hash: null });
+    }
+  }
+  const directDependencies = new Map(order.map((task) => [task.task_id, task.blocked_by]));
+  const childById = new Map(children.map((child) => [child.task_id, child]));
+  for (const child of children) {
+    if (child.status !== "enrollable")
+      continue;
+    if (directDependencies.get(child.task_id).some((id) => {
+      const status = childById.get(id).status;
+      return status === "already_owned" || status === "needs_human" || status === "blocked";
+    })) {
+      child.status = "blocked";
+      child.reason = "dependency_unavailable";
+    }
+  }
+  const enrollable = children.filter((child) => child.status === "enrollable").map((child) => ({
+    task_id: child.task_id,
+    intent_path: child.intent_path,
+    intent_revision: child.intent_revision,
+    intent_content_hash: child.intent_content_hash,
+    blocked_by: child.blocked_by.filter((id) => childById.get(id)?.status === "enrollable")
+  }));
+  if (!enrollable.length)
+    throw new Error("batch plan has no enrollable children; nothing to confirm");
+  const planDigest = `sha256:${createHash19("sha256").update(stableStringify(enrollable)).digest("hex")}`;
+  return {
+    contract: "assurance_kernel/batch_plan/v1",
+    initiative_slug: initiativeSlug,
+    confirmation_time: confirmationTime.iso,
+    tracker_observation: trackerObservation,
+    children,
+    enrollable,
+    plan_digest: planDigest,
+    budget: budget(input, enrollable.length, confirmationTime)
+  };
+}
+
 // plugins/immune-brain/runtime/unattended/batch_preflight.ts
 var INITIATIVE_SLUG_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 function batchRejection(key, detail = "") {
@@ -10509,7 +11012,12 @@ function findExistingActiveBatch(root, initiativeSlug) {
     }
     if (isTerminalBatchState(candidate.batch_state))
       continue;
-    return { corrupt: false, record: candidate };
+    try {
+      const record = readBatchRunState(root, file.slice(0, -5));
+      if (record)
+        return { corrupt: false, record };
+    } catch {}
+    return { corrupt: true, path: file };
   }
   return null;
 }
@@ -10559,7 +11067,7 @@ function isOwnBatchClaim(root, existingBatch, taskId, batchBranch) {
   const currentTaskId = workspaceOwner || (claim?.lifecycle_status === "active" ? claim?.task_id : null);
   if (currentTaskId !== taskId || !claim)
     return false;
-  const branch = spawnSync5("git", ["-C", root, "branch", "--show-current"], { encoding: "utf8" }).stdout.trim();
+  const branch = spawnSync6("git", ["-C", root, "branch", "--show-current"], { encoding: "utf8" }).stdout.trim();
   if (branch !== batchBranch)
     return false;
   const childInBatch = existingBatch.children.find((c) => c.task_id === taskId);
@@ -10616,7 +11124,7 @@ function authorizedScopeOf(root, taskId, state) {
   return scope;
 }
 function porcelainEntries(root) {
-  const statusProc = spawnSync5("git", ["-C", root, "status", "--porcelain=v1", "-z", "--no-renames", "--untracked-files=all"], { encoding: "utf8" });
+  const statusProc = spawnSync6("git", ["-C", root, "status", "--porcelain=v1", "-z", "--no-renames", "--untracked-files=all", "--ignore-submodules=none"], { encoding: "utf8", env: { ...process.env, GIT_OPTIONAL_LOCKS: "0" } });
   if (statusProc.status !== 0)
     return null;
   const entries = [];
@@ -10635,7 +11143,9 @@ async function projectPlanSurface(input) {
   const riskByTask = new Map;
   let budget;
   if (isResuming && existingBatch) {
-    budget = existingBatch.budget;
+    budget = { ...existingBatch.budget };
+    if (Date.parse(budget.deadline_at) <= Date.parse(now))
+      budget.deadline_at = new Date(Date.parse(now) + DEFAULT_DEADLINE_MS).toISOString();
     try {
       recoveryChildren = existingBatch.children.map((c) => {
         const intentPath = `docs/plans/${c.task_id}.intent.json`;
@@ -10738,6 +11248,11 @@ async function projectBatchPreflight(options) {
   const isResuming = activeRecord !== null;
   const batchBranch = `imm/${initiativeSlug}`;
   const activeTaskId = readActiveClaimTaskId(root);
+  if (activeTaskId) {
+    const authority = reconcileKernelAuthority(root, activeTaskId);
+    if (authority.state === "authority_conflict")
+      return reject("kernel_authority_conflict", authority.diagnostic ?? "unverifiable workspace authority");
+  }
   const ownClaim = isResuming && activeTaskId !== null && isOwnBatchClaim(root, activeRecord, activeTaskId, batchBranch);
   if (activeTaskId && !ownClaim)
     return reject("claim_already_active", activeTaskId);
@@ -10747,7 +11262,7 @@ async function projectBatchPreflight(options) {
   } catch (err) {
     return reject("git_head_unreadable", err instanceof Error ? err.message : String(err));
   }
-  const branchExists = spawnSync5("git", ["-C", root, "show-ref", "--verify", "--quiet", `refs/heads/${batchBranch}`]);
+  const branchExists = spawnSync6("git", ["-C", root, "show-ref", "--verify", "--quiet", `refs/heads/${batchBranch}`]);
   if (branchExists.status === 0 && !existingBatch)
     return reject("branch_already_exists", batchBranch);
   const statusEntries = porcelainEntries(root);
@@ -10796,21 +11311,29 @@ async function projectBatchPreflight(options) {
   });
   if (!planSurface.ok)
     return reject(planSurface.key, planSurface.detail);
-  return {
-    ok: true,
-    projection: {
-      initiative_slug: initiativeSlug,
-      batch_branch: batchBranch,
-      is_resuming: isResuming,
-      existing_batch: existingBatch,
-      base_head: baseHead,
-      budget: planSurface.surface.budget,
-      plan_digest: planSurface.surface.plan_digest,
-      recovery_children: planSurface.surface.recovery_children,
-      risk_by_task: planSurface.surface.risk_by_task,
-      excluded: planSurface.surface.excluded
+  let reconfirmation;
+  if (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");
     }
+  }
+  const projection = {
+    initiative_slug: initiativeSlug,
+    batch_branch: batchBranch,
+    is_resuming: isResuming,
+    existing_batch: existingBatch,
+    base_head: baseHead,
+    budget: planSurface.surface.budget,
+    plan_digest: planSurface.surface.plan_digest,
+    recovery_children: planSurface.surface.recovery_children,
+    risk_by_task: planSurface.surface.risk_by_task,
+    excluded: planSurface.surface.excluded
   };
+  if (reconfirmation)
+    Object.defineProperty(projection, "reconfirmation", { value: reconfirmation });
+  return { ok: true, projection };
 }
 async function projectBatchDrift(options) {
   const { root, initiative_slug: initiativeSlug, readInitiative } = options;
@@ -10851,21 +11374,29 @@ async function authorizeBatch(options) {
   } = projection;
   const existingBatch = projection.existing_batch;
   const isExistingExpired = isResuming && Date.parse(existingBatch.authorization_expires_at) <= Date.now();
-  const expiresAt = isResuming && !isExistingExpired && existingBatch.batch_state === "running" ? existingBatch.authorization_expires_at : budget.deadline_at;
+  const branchBefore = spawnSync6("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);
+  if (isResuming && existingBatch && !existingBatch.commits.length && existingBatch.children[0]?.state === "settled" && expectedBatchHead(existingBatch) !== baseHead && !ownsUnpersistedHead)
+    return { outcome: "rejected", rejection: batchRejection("head_moved", "first unpersisted commit provenance is invalid") };
   const reuseBlockers = [];
   if (isResuming && existingBatch) {
     if (isExistingExpired)
       reuseBlockers.push("batch_authorization_expired");
+    if (Date.parse(existingBatch.budget.deadline_at) <= Date.now())
+      reuseBlockers.push("batch_budget_expired");
     if (existingBatch.batch_state !== "running")
       reuseBlockers.push("batch_not_running");
     if (existingBatch.plan_digest !== planDigest)
       reuseBlockers.push("batch_plan_digest_changed");
     if (existingBatch.branch !== batchBranch)
       reuseBlockers.push("batch_branch_changed");
-    if (expectedBatchHead(existingBatch) !== baseHead)
+    if (expectedBatchHead(existingBatch) !== baseHead && !ownsUnpersistedHead)
       reuseBlockers.push("batch_head_lineage_moved");
   }
   const reuseAuthorization = isResuming && reuseBlockers.length === 0;
+  const expiresAt = reuseAuthorization ? existingBatch.authorization_expires_at : budget.deadline_at;
   const batchId = isResuming && existingBatch ? existingBatch.batch_id : `batch-${initiativeSlug}-${randomUUID7()}`;
   const facts = {
     initiative_slug: initiativeSlug,
@@ -10903,12 +11434,29 @@ async function authorizeBatch(options) {
     return { outcome: "rejected", rejection: batchRejection("plan_changed", drift.plan_digest) };
   if (drift.base_head === null)
     return { outcome: "rejected", rejection: batchRejection("repository_became_unreadable") };
-  if (drift.base_head !== baseHead)
+  if (drift.base_head !== baseHead || ownsUnpersistedHead && !ownUnpersistedBatchHead(root, existingBatch, baseHead))
     return { outcome: "rejected", rejection: batchRejection("head_moved", drift.base_head) };
   const finalClaimTaskId = readActiveClaimTaskId(root);
   const finalOwnClaim = isResuming && finalClaimTaskId !== null && isOwnBatchClaim(root, existingBatch, finalClaimTaskId, batchBranch);
   if (finalClaimTaskId && !finalOwnClaim)
     return { outcome: "rejected", rejection: batchRejection("claim_appeared_during_confirmation", finalClaimTaskId) };
+  if (isResuming) {
+    const current = findExistingActiveBatch(root, initiativeSlug);
+    if (!current || current.corrupt || JSON.stringify(current.record) !== JSON.stringify(existingBatch))
+      return { outcome: "rejected", rejection: batchRejection("plan_changed") };
+  }
+  const branchAfter = spawnSync6("git", ["-C", root, "branch", "--show-current"], { encoding: "utf8" });
+  if (branchAfter.status !== 0 || branchAfter.stdout !== branchBefore.stdout)
+    return { outcome: "rejected", rejection: batchRejection("confirmation_failed", "Git branch moved after native confirmation") };
+  if (Date.parse(expiresAt) <= Date.now())
+    return { outcome: "rejected", rejection: batchRejection("confirmation_failed", "confirmed batch deadline expired before authorization issuance") };
+  if (projection.reconfirmation) {
+    try {
+      projection.reconfirmation.assertUnchanged();
+    } catch {
+      return { outcome: "rejected", rejection: batchRejection("plan_changed") };
+    }
+  }
   const binding = {
     batch_id: batchId,
     initiative_slug: initiativeSlug,
@@ -10921,6 +11469,8 @@ async function authorizeBatch(options) {
     expires_at: expiresAt,
     nonce: options.nonce
   };
+  if (projection.reconfirmation)
+    retainReconfirmation(binding.nonce, binding.expires_at, projection.reconfirmation);
   return {
     outcome: "authorized",
     batch_id: batchId,
@@ -10932,12 +11482,12 @@ async function authorizeBatch(options) {
 }
 
 // plugins/immune-brain/runtime/unattended/batch_runner.ts
-import { spawnSync as spawnSync7 } from "node:child_process";
+import { spawnSync as spawnSync8 } from "node:child_process";
 import { existsSync as existsSync9 } from "node:fs";
 import { join as join14 } from "node:path";
 
 // plugins/immune-brain/runtime/unattended/batch_git.ts
-import { spawnSync as spawnSync6 } from "node:child_process";
+import { spawnSync as spawnSync7 } from "node:child_process";
 import { createHash as createHash20, randomUUID as randomUUID8 } from "node:crypto";
 import {
   constants as constants6,
@@ -10962,7 +11512,7 @@ var DEFAULT_GIT_ENV = {
 function runBatchGitPreflight(input) {
   const { root, initiative_slug: initiativeSlug, base_head: baseHead } = input;
   const branch = `imm/${initiativeSlug}`;
-  const toplevelResult = spawnSync6("git", ["-C", root, "rev-parse", "--show-toplevel"], {
+  const toplevelResult = spawnSync7("git", ["-C", root, "rev-parse", "--show-toplevel"], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"]
   });
@@ -11000,7 +11550,7 @@ function runBatchGitPreflight(input) {
       message: `unsupported index flags (assume-unchanged/skip-worktree) detected: ${flaggedPreflight.join(", ")}`
     };
   }
-  const statusResult = spawnSync6("git", ["-C", root, "status", "--porcelain", "--untracked-files=all", "--ignore-submodules=none"], {
+  const statusResult = spawnSync7("git", ["-C", root, "status", "--porcelain", "--untracked-files=all", "--ignore-submodules=none"], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"]
   });
@@ -11018,7 +11568,7 @@ function runBatchGitPreflight(input) {
       message: "working tree is dirty before batch preflight"
     };
   }
-  const headResult = spawnSync6("git", ["-C", root, "rev-parse", "--verify", "HEAD^{commit}"], {
+  const headResult = spawnSync7("git", ["-C", root, "rev-parse", "--verify", "HEAD^{commit}"], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"]
   });
@@ -11029,11 +11579,11 @@ function runBatchGitPreflight(input) {
       message: "HEAD is uncommitted or not a valid commit"
     };
   }
-  const branchCheck = spawnSync6("git", ["-C", root, "show-ref", "--verify", "--quiet", `refs/heads/${branch}`], { stdio: ["ignore", "ignore", "ignore"] });
+  const branchCheck = spawnSync7("git", ["-C", root, "show-ref", "--verify", "--quiet", `refs/heads/${branch}`], { stdio: ["ignore", "ignore", "ignore"] });
   if (branchCheck.status === 0) {
     const settled = findSettledBatchRecord(root, initiativeSlug);
-    const currentBranch = spawnSync6("git", ["-C", root, "symbolic-ref", "--short", "HEAD"], { encoding: "utf8" });
-    if (findExistingActiveBatch(root, initiativeSlug) === null && settled?.branch === branch && currentBranch.status === 0 && currentBranch.stdout.trim() === branch && headResult.stdout.trim() === baseHead && spawnSync6("git", ["-C", root, "merge-base", "--is-ancestor", expectedBatchHead(settled), baseHead]).status === 0)
+    const currentBranch = spawnSync7("git", ["-C", root, "symbolic-ref", "--short", "HEAD"], { encoding: "utf8" });
+    if (findExistingActiveBatch(root, initiativeSlug) === null && settled?.branch === branch && currentBranch.status === 0 && currentBranch.stdout.trim() === branch && headResult.stdout.trim() === baseHead && spawnSync7("git", ["-C", root, "merge-base", "--is-ancestor", expectedBatchHead(settled), baseHead]).status === 0)
       return { ok: true, branch };
     return {
       ok: false,
@@ -11041,25 +11591,25 @@ function runBatchGitPreflight(input) {
       message: `branch refs/heads/${branch} already exists`
     };
   }
-  const originalBranchResult = spawnSync6("git", ["-C", root, "symbolic-ref", "--short", "HEAD"], {
+  const originalBranchResult = spawnSync7("git", ["-C", root, "symbolic-ref", "--short", "HEAD"], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"]
   });
   const originalBranch = originalBranchResult.stdout.trim();
-  const checkoutResult = spawnSync6("git", ["-C", root, "-c", "core.hooksPath=/dev/null", "checkout", "-b", branch, baseHead], {
+  const checkoutResult = spawnSync7("git", ["-C", root, "-c", "core.hooksPath=/dev/null", "checkout", "-b", branch, baseHead], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"],
     env: DEFAULT_GIT_ENV
   });
   if (checkoutResult.status !== 0) {
     const stderr = checkoutResult.stderr?.trim() || "";
-    const branchExists = stderr.includes("already exists") || spawnSync6("git", ["-C", root, "show-ref", "--verify", "--quiet", `refs/heads/${branch}`]).status === 0;
-    const currentBranchCheck = spawnSync6("git", ["-C", root, "symbolic-ref", "--short", "HEAD"], {
+    const branchExists = stderr.includes("already exists") || spawnSync7("git", ["-C", root, "show-ref", "--verify", "--quiet", `refs/heads/${branch}`]).status === 0;
+    const currentBranchCheck = spawnSync7("git", ["-C", root, "symbolic-ref", "--short", "HEAD"], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"]
     }).stdout.trim();
     if (currentBranchCheck === branch && originalBranch && originalBranch !== branch) {
-      spawnSync6("git", ["-C", root, "-c", "core.hooksPath=/dev/null", "checkout", originalBranch], {
+      spawnSync7("git", ["-C", root, "-c", "core.hooksPath=/dev/null", "checkout", originalBranch], {
         stdio: ["ignore", "ignore", "ignore"]
       });
     }
@@ -11082,7 +11632,7 @@ function hasBoundaryWhitespace(path) {
   return path.split("/").some((segment) => segment.trim() !== segment || segment.length === 0);
 }
 function getUnsupportedIndexFlags(root) {
-  const result = spawnSync6("git", ["-C", root, "ls-files", "-v", "-z", "--"], {
+  const result = spawnSync7("git", ["-C", root, "ls-files", "-v", "-z", "--"], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"]
   });
@@ -11116,13 +11666,13 @@ function isPathAllowedForChild(path, taskId, scopeHint) {
   });
 }
 function getChangedProjectPaths(root) {
-  const tracked = spawnSync6("git", ["-C", root, "diff-index", "--name-only", "-z", "--ignore-submodules=none", "HEAD", "--"], {
+  const tracked = spawnSync7("git", ["-C", root, "diff-index", "--name-only", "-z", "--ignore-submodules=none", "HEAD", "--"], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"]
   });
   if (tracked.status !== 0)
     throw new Error("failed to inspect tracked diff vs HEAD");
-  const untracked = spawnSync6("git", ["-C", root, "ls-files", "--others", "--exclude-standard", "-z", "--"], {
+  const untracked = spawnSync7("git", ["-C", root, "ls-files", "--others", "--exclude-standard", "-z", "--"], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"]
   });
@@ -11132,7 +11682,7 @@ function getChangedProjectPaths(root) {
   return [...new Set([...splitZ(tracked.stdout), ...splitZ(untracked.stdout)])];
 }
 function getStagedProjectPaths(root) {
-  const staged = spawnSync6("git", ["-C", root, "diff-index", "--cached", "--name-only", "-z", "--ignore-submodules=none", "HEAD", "--"], {
+  const staged = spawnSync7("git", ["-C", root, "diff-index", "--cached", "--name-only", "-z", "--ignore-submodules=none", "HEAD", "--"], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"]
   });
@@ -11141,13 +11691,13 @@ function getStagedProjectPaths(root) {
   return staged.stdout.split("\x00").filter((p) => p.length > 0);
 }
 function getUnstagedProjectPaths(root) {
-  const diffFiles = spawnSync6("git", ["-C", root, "diff-files", "--name-only", "-z", "--ignore-submodules=none", "--"], {
+  const diffFiles = spawnSync7("git", ["-C", root, "diff-files", "--name-only", "-z", "--ignore-submodules=none", "--"], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"]
   });
   if (diffFiles.status !== 0)
     throw new Error("failed to inspect unstaged tracked changes");
-  const untracked = spawnSync6("git", ["-C", root, "ls-files", "--others", "--exclude-standard", "-z", "--"], {
+  const untracked = spawnSync7("git", ["-C", root, "ls-files", "--others", "--exclude-standard", "-z", "--"], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"]
   });
@@ -11157,7 +11707,7 @@ function getUnstagedProjectPaths(root) {
   return [...new Set([...splitZ(diffFiles.stdout), ...splitZ(untracked.stdout)])];
 }
 function getCommittedDeltaPaths(root) {
-  const delta = spawnSync6("git", ["-C", root, "diff-tree", "--no-commit-id", "--name-only", "-z", "-r", "HEAD~1", "HEAD"], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+  const delta = spawnSync7("git", ["-C", root, "diff-tree", "--no-commit-id", "--name-only", "-z", "-r", "HEAD~1", "HEAD"], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
   if (delta.status !== 0)
     throw new Error("failed to inspect committed tree delta");
   return delta.stdout.split("\x00").filter((p) => p.length > 0);
@@ -11263,7 +11813,7 @@ async function commitBatchChild(input) {
   const goal = typeof intentSnapshot.goal === "string" ? intentSnapshot.goal : "";
   const scopeHint = Array.isArray(intentSnapshot.scope_hint) ? intentSnapshot.scope_hint.filter((s) => typeof s === "string") : [];
   if (expectedBranch !== undefined) {
-    const currentBranchResult = spawnSync6("git", ["-C", root, "symbolic-ref", "--short", "HEAD"], {
+    const currentBranchResult = spawnSync7("git", ["-C", root, "symbolic-ref", "--short", "HEAD"], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -11272,7 +11822,7 @@ async function commitBatchChild(input) {
       throw new Error(`batch_head_lineage_broken: current branch ${currentBranch} does not match expected branch ${expectedBranch}`);
     }
   }
-  const currentHeadResult = spawnSync6("git", ["-C", root, "rev-parse", "HEAD"], {
+  const currentHeadResult = spawnSync7("git", ["-C", root, "rev-parse", "HEAD"], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"]
   });
@@ -11291,7 +11841,7 @@ async function commitBatchChild(input) {
   }
   const pathsToStage = getUnstagedProjectPaths(root);
   if (pathsToStage.length > 0) {
-    const addResult = spawnSync6("git", ["-C", root, "--literal-pathspecs", "add", "-A", "--", ...pathsToStage], {
+    const addResult = spawnSync7("git", ["-C", root, "--literal-pathspecs", "add", "-A", "--", ...pathsToStage], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -11306,7 +11856,7 @@ async function commitBatchChild(input) {
   const staged = getStagedProjectPaths(root);
   const stagedOutside = staged.filter((p) => !isPathAllowedForChild(p, taskId, scopeHint));
   if (stagedOutside.length > 0) {
-    spawnSync6("git", ["-C", root, "reset", "--quiet"], { stdio: ["ignore", "ignore", "ignore"] });
+    spawnSync7("git", ["-C", root, "reset", "--quiet"], { stdio: ["ignore", "ignore", "ignore"] });
     throw new Error("dirty_outside_scope");
   }
   const record = auditPair.record;
@@ -11324,7 +11874,7 @@ async function commitBatchChild(input) {
 
 Immune-Brain-Batch: ${batchId}
 `;
-  const commitResult = spawnSync6("git", ["-C", root, "-c", "core.hooksPath=/dev/null", "commit", "--no-verify", "-F", "-"], {
+  const commitResult = spawnSync7("git", ["-C", root, "-c", "core.hooksPath=/dev/null", "commit", "--no-verify", "-F", "-"], {
     input: commitMessage,
     encoding: "utf8",
     stdio: ["pipe", "pipe", "pipe"],
@@ -11333,7 +11883,7 @@ Immune-Brain-Batch: ${batchId}
   if (commitResult.status !== 0) {
     throw new Error(`commit failed for child ${taskId}: ${commitResult.stderr?.trim() || "git commit failed"}`);
   }
-  const newHeadResult = spawnSync6("git", ["-C", root, "rev-parse", "HEAD"], {
+  const newHeadResult = spawnSync7("git", ["-C", root, "rev-parse", "HEAD"], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"]
   });
@@ -11341,7 +11891,7 @@ Immune-Brain-Batch: ${batchId}
   if (newHeadResult.status !== 0 || !newHead || newHead === expectedHead) {
     throw new Error("commit_failed");
   }
-  const parentsResult = spawnSync6("git", ["-C", root, "rev-parse", "HEAD^@"], {
+  const parentsResult = spawnSync7("git", ["-C", root, "rev-parse", "HEAD^@"], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"]
   });
@@ -11374,7 +11924,7 @@ async function lookupBatchCommit(input) {
   let candidates = [];
   let evidenceBacked = false;
   if (evidence && evidence.commit) {
-    const direct = spawnSync6("git", ["-C", root, "log", "-n", "1", `--format=${FORMAT}`, evidence.commit, "--"], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+    const direct = spawnSync7("git", ["-C", root, "log", "-n", "1", `--format=${FORMAT}`, evidence.commit, "--"], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
     if (direct.status !== 0) {
       throw new Error(`failed to inspect batch commit for ${taskId}: ${direct.stderr?.trim() || "git log failed"}`);
     }
@@ -11387,7 +11937,7 @@ async function lookupBatchCommit(input) {
     }
   }
   if (!candidates.length) {
-    const result = spawnSync6("git", [
+    const result = spawnSync7("git", [
       "-C",
       root,
       "log",
@@ -11424,7 +11974,7 @@ async function lookupBatchCommit(input) {
     throw new Error(`batch_head_lineage_broken: adopted commit author ${match.authorName} does not match batch authority ${DEFAULT_GIT_ENV.GIT_AUTHOR_NAME}`);
   }
   if (expectedBranch !== undefined) {
-    const currentBranchResult = spawnSync6("git", ["-C", root, "symbolic-ref", "--short", "HEAD"], {
+    const currentBranchResult = spawnSync7("git", ["-C", root, "symbolic-ref", "--short", "HEAD"], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -11434,7 +11984,7 @@ async function lookupBatchCommit(input) {
     }
   }
   if (expectedHead !== undefined) {
-    const currentHeadResult = spawnSync6("git", ["-C", root, "rev-parse", "HEAD"], {
+    const currentHeadResult = spawnSync7("git", ["-C", root, "rev-parse", "HEAD"], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -11442,7 +11992,7 @@ async function lookupBatchCommit(input) {
     if (currentHead !== commit) {
       throw new Error(`batch_head_lineage_broken: current HEAD ${currentHead} diverged from adopted commit ${commit}`);
     }
-    const parentsResult = spawnSync6("git", ["-C", root, "rev-parse", `${commit}^@`], {
+    const parentsResult = spawnSync7("git", ["-C", root, "rev-parse", `${commit}^@`], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -11460,7 +12010,7 @@ async function lookupBatchCommit(input) {
       throw new Error(`batch_head_lineage_broken: adopted commit task lifecycle is not done: ${lifecycle}`);
     }
     const scopeHint = Array.isArray(auditPair.record.intent_snapshot.scope_hint) ? auditPair.record.intent_snapshot.scope_hint.filter((s) => typeof s === "string") : [];
-    const deltaResult = spawnSync6("git", ["-C", root, "diff-tree", "--no-commit-id", "--name-only", "-z", "-r", expectedHead, commit], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+    const deltaResult = spawnSync7("git", ["-C", root, "diff-tree", "--no-commit-id", "--name-only", "-z", "-r", expectedHead, commit], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
     if (deltaResult.status !== 0) {
       throw new Error("batch_head_lineage_broken: failed to inspect adopted commit delta");
     }
@@ -11474,6 +12024,14 @@ async function lookupBatchCommit(input) {
 }
 
 // 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 dependentsOf(record, taskId) {
   return record.children.filter((child) => child.blocked_by.includes(taskId));
 }
@@ -11533,8 +12091,23 @@ function reportFor(record, reason, nextAction) {
     created_at: record.updated_at
   };
 }
-function finalize(root, record, reason, nextAction) {
-  const report = reportFor(record, reason, nextAction);
+function executorHandoff(record, taskId, fresh, failure = {}) {
+  const recovery = deriveAssuranceRecovery(taskId, fresh, failure, fresh.recovery_findings);
+  return {
+    ...reportFor(record, null, recovery?.next_action ?? (fresh.projection.artifact_state === "frozen" ? "The child is frozen with pending QA. Call advance_assurance once; follow its diagnostics before retrying, then submit any reserved Review before batch continuation." : "Route the enrolled child to foreground Executor, implement and stage its scoped work, then call Kernel advance_assurance. Submit any reserved Review verdict before continuing start_unattended_batch with the same Initiative.")),
+    ...recovery ? { recovery } : {},
+    ...failure.diagnostics?.length ? { diagnostics: failure.diagnostics } : {},
+    handoff: recovery?.category === "authorization" ? undefined : {
+      role: "executor",
+      task_id: taskId,
+      run_id: fresh.projection.run_id ?? null,
+      record_revision: fresh.projection.record_revision,
+      next_obligation: fresh.projection.next_obligation
+    }
+  };
+}
+function finalize(root, record, reason, nextAction, details = {}) {
+  const report = { ...reportFor(record, reason, nextAction), ...details };
   if (isTerminalBatchState(record.batch_state) || record.batch_state === "needs_human") {
     writeBatchRunReport(root, report);
   }
@@ -11557,14 +12130,14 @@ function externalHeadDriftMessage(root, record) {
   if (!existsSync9(join14(root, ".git")))
     return null;
   const head = record.commits.length ? record.commits[record.commits.length - 1] : record.base_head;
-  const headCheck = spawnSync7("git", ["-C", root, "rev-parse", "HEAD"], {
+  const headCheck = spawnSync8("git", ["-C", root, "rev-parse", "HEAD"], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"]
   });
   if (headCheck.status === 0 && headCheck.stdout.trim() && headCheck.stdout.trim() !== head) {
     return `batch_head_lineage_broken: current HEAD ${headCheck.stdout.trim()} does not match expected batch head ${head}`;
   }
-  const branchCheck = spawnSync7("git", ["-C", root, "symbolic-ref", "--short", "HEAD"], {
+  const branchCheck = spawnSync8("git", ["-C", root, "symbolic-ref", "--short", "HEAD"], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"]
   });
@@ -11575,6 +12148,11 @@ function externalHeadDriftMessage(root, record) {
   return null;
 }
 async function validatePersistedRun(input, record) {
+  if (!record.commits.length && record.children[0]?.state === "settled" && existsSync9(join14(input.root, ".git"))) {
+    const head = spawnSync8("git", ["-C", input.root, "rev-parse", "HEAD"], { encoding: "utf8" });
+    if (head.status !== 0 || head.stdout.trim() !== record.base_head && !ownUnpersistedBatchHead(input.root, record, head.stdout.trim()))
+      throw new Error("first unpersisted batch commit provenance is invalid");
+  }
   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];
@@ -11596,7 +12174,7 @@ async function validatePersistedRun(input, record) {
     });
     if (!evidence || evidence.commit !== child.commit) {
       if (evidence === null && typeof child.commit === "string" && child.commit.length > 0 && existsSync9(join14(input.root, ".git"))) {
-        const reach = spawnSync7("git", ["-C", input.root, "merge-base", "--is-ancestor", child.commit, "HEAD"], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+        const reach = spawnSync8("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`);
         }
@@ -11634,6 +12212,41 @@ function validateRunAuthorization(input, existing) {
   });
   if (computeBatchPlanDigest(children) !== authorized.plan_digest || input.plan_digest !== authorized.plan_digest || input.base_head !== authorized.base_head)
     throw new Error("batch run input does not match the authorized plan or base_head");
+  return authorized;
+}
+function applyPlanReconfirmation(input, existing) {
+  if (existing.plan_digest === input.plan_digest)
+    return existing;
+  const next = {
+    ...existing,
+    plan_digest: input.plan_digest,
+    confirmation_time: input.confirmation_time,
+    authorization_expires_at: input.authorization_expires_at,
+    budget: input.budget
+  };
+  if (!existing.branch || input.batch_id !== existing.batch_id || input.initiative_slug !== existing.initiative_slug || input.base_head !== existing.base_head || input.budget.max_children !== existing.budget.max_children || input.budget.qa_failure_limit !== existing.budget.qa_failure_limit)
+    throw new Error("plan_digest mismatch: reconfirmation binding changed");
+  const validate = () => {
+    const plan = input.registry.children(input.capability);
+    if (existing.children.length !== plan.length || plan.some((child, index) => {
+      const old = existing.children[index], nextChild = input.children[index];
+      return !nextChild || old.task_id !== child.task_id || old.slice_id !== nextChild.slice_id || JSON.stringify(old.blocked_by) !== JSON.stringify(child.blocked_by) || JSON.stringify(nextChild.blocked_by) !== JSON.stringify(child.blocked_by);
+    }))
+      throw new Error("plan_digest mismatch: reconfirmation topology changed");
+    const { issued_at: _issuedAt, ...binding } = validateRunAuthorization(input, { ...existing, plan_digest: input.plan_digest });
+    if (binding.branch !== existing.branch)
+      throw new Error("plan_digest mismatch: reconfirmation branch changed");
+    prepareBatchRunState(input);
+    return input.registry.inspect(input.capability, binding);
+  };
+  const authority = validate();
+  const captured = takeReconfirmation(authority.nonce);
+  if (captured.root !== input.root || captured.plan_digest !== input.plan_digest)
+    throw new Error("plan_digest mismatch: captured reconfirmation does not match run input");
+  return replaceBatchRunState(input.root, captured.stateBytes, next, () => {
+    captured.assertUnchanged();
+    validate();
+  });
 }
 async function startBatch(input) {
   try {
@@ -11664,7 +12277,9 @@ async function startBatchLocked(input) {
     return reportFor({ ...rejected, batch_state: "rejected" }, "batch plan is empty", "Provide a non-empty enrollable child plan.");
   }
   let existing = readBatchRunState(input.root, input.batch_id);
+  const reconfirmed = existing !== null && existing.plan_digest !== input.plan_digest;
   if (existing) {
+    existing = applyPlanReconfirmation(input, existing);
     try {
       await validatePersistedRun(input, existing);
     } catch (error) {
@@ -11686,10 +12301,11 @@ async function startBatchLocked(input) {
     const nextConfirmation = Date.parse(input.confirmation_time);
     const nextExpiry = Date.parse(input.authorization_expires_at);
     const freshAuthorization = Number.isFinite(nextConfirmation) && nextConfirmation > priorConfirmation && Number.isFinite(nextExpiry) && nextExpiry > Date.now();
-    if (!freshAuthorization) {
+    if (!freshAuthorization && !reconfirmed) {
       return finalize(input.root, existing, "the parked batch requires a fresh literal-user confirmation", "Resolve the parked child, then re-confirm the batch to continue.");
     }
-    validateRunAuthorization(input, existing);
+    if (!reconfirmed)
+      validateRunAuthorization(input, existing);
     prepareBatchRunState({ ...input, now: input.now });
     const remapped = await Promise.all(existing.children.map(async (child) => {
       if (child.state !== "needs_human")
@@ -11724,7 +12340,6 @@ async function startBatchLocked(input) {
       authorization_expires_at: input.authorization_expires_at,
       budget: input.budget,
       batch_state: "running",
-      consecutive_qa_failures: 0,
       children: resumedChildren
     });
   }
@@ -11882,67 +12497,8 @@ async function startBatchLocked(input) {
         break;
       }
     }
-    let childTerminal = false;
-    while (!childTerminal) {
-      const terminal = await input.kernel.advanceTask(input.root, child.task_id);
-      if (terminal.state === "completed") {
-        childTerminal = true;
-        record.consecutive_qa_failures = 0;
-        record.children = record.children.map((c) => c.task_id === child.task_id ? { ...c, state: "settled", reason: null } : c);
-        persist();
-        try {
-          const planChild = input.children.find((c) => c.task_id === child.task_id);
-          const intentPath = planChild?.intent_path ?? undefined;
-          const { commit } = input.git?.commitChild ? await input.git.commitChild(input.root, child.task_id, input.batch_id, head, record.branch, intentPath) : input.kernel.commitChild ? await input.kernel.commitChild(input.root, child.task_id, input.batch_id, head, record.branch, intentPath) : await commitBatchChild({
-            root: input.root,
-            taskId: child.task_id,
-            batchId: input.batch_id,
-            expectedHead: head,
-            branch: record.branch,
-            intentPath
-          });
-          record.children = record.children.map((c) => c.task_id === child.task_id ? { ...c, state: "committed", commit } : c);
-          record.commits.push(commit);
-          head = commit;
-          persist();
-        } 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`);
-          record.batch_state = "failed";
-          persist();
-          break;
-        }
-      } else if (terminal.state === "stopped") {
-        record.children = record.children.map((c) => c.task_id === child.task_id ? { ...c, state: "needs_human", reason: "Kernel reported the child stopped" } : c);
-        childTerminal = true;
-        skipDependents(record, child.task_id, `dependency ${child.task_id} parked`);
-        record.batch_state = "needs_human";
-        persist();
-      } else if (terminal.state === "rework" && terminal.operation === "qa") {
-        record.consecutive_qa_failures += 1;
-        if (record.consecutive_qa_failures >= record.budget.qa_failure_limit) {
-          record.children = record.children.map((c) => c.task_id === child.task_id ? { ...c, state: "needs_human", reason: `QA failure limit reached: ${terminal.summary}` } : c);
-          record.batch_state = "needs_human";
-          childTerminal = true;
-          skipDependents(record, child.task_id, `dependency ${child.task_id} parked`);
-          persist();
-        } else {
-          persist();
-        }
-      } else if (terminal.state === "failed" || terminal.state === "blocked" || terminal.state === "rework") {
-        const reason = terminal.state === "rework" ? terminal.summary : terminal.reason;
-        childTerminal = true;
-        record.children = record.children.map((c) => c.task_id === child.task_id ? { ...c, state: "needs_human", reason } : c);
-        skipDependents(record, child.task_id, `dependency ${child.task_id} parked`);
-        record.batch_state = "needs_human";
-        persist();
-      } else if (terminal.state === "review_ready") {
-        record.children = record.children.map((c) => c.task_id === child.task_id ? { ...c, state: "enrolled", reason: `review reservation ${terminal.operation_id} open` } : c);
-        persist();
-        return reportFor(record, `child ${child.task_id} holds an open Review reservation`, "Submit the reserved foreground Review verdict, then call startBatch again to continue.");
-      }
-    }
+    const enrolled = requireFreshProjection(await input.kernel.projectTask(input.root, child.task_id), child.task_id);
+    return executorHandoff(record, child.task_id, enrolled);
   }
   return finalize(input.root, record, stopReasonFor(record), "");
 }
@@ -11964,8 +12520,9 @@ function stopReasonFor(record) {
 }
 async function resumeBatch(input, projection) {
   let existing = readBatchRunState(input.root, input.batch_id);
-  if (!existing)
+  if (!existing || existing.batch_state === "needs_human")
     return startBatch(input);
+  existing = applyPlanReconfirmation(input, existing);
   try {
     await validatePersistedRun(input, existing);
   } catch (error) {
@@ -11980,8 +12537,6 @@ async function resumeBatch(input, projection) {
   }
   if (isTerminalBatchState(existing.batch_state))
     return replayTerminal(input.root, existing);
-  if (existing.batch_state === "needs_human")
-    return startBatch(input);
   const driven = existing.children.find((child) => child.state === "enrolled" || child.state === "settled");
   if (driven) {
     if (driven.state === "enrolled") {
@@ -12001,11 +12556,30 @@ async function resumeBatch(input, projection) {
         });
         return finalize(input.root, existing, "claim held by another batch", "needs-human-attention");
       }
+      if (holdsClaim) {
+        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`);
+          existing = writeBatchRunState(input.root, {
+            ...existing,
+            batch_state: "needs_human",
+            consecutive_qa_failures: failures,
+            children: existing.children.map((c) => c.task_id === driven.task_id ? { ...c, state: "needs_human", reason } : c)
+          });
+          return finalize(input.root, existing, reason, "Repair and settle the own child through Kernel, then re-confirm the batch.", { recovery: deriveAssuranceRecovery(driven.task_id, fresh, {}, fresh.recovery_findings) ?? undefined });
+        }
+        if (failures !== existing.consecutive_qa_failures)
+          existing = writeBatchRunState(input.root, { ...existing, consecutive_qa_failures: failures });
+        if (fresh.projection.next_obligation === "run_qa" || fresh.projection.artifact_state !== "frozen")
+          return executorHandoff(existing, driven.task_id, fresh);
+      }
       if (!holdsClaim) {
         const settledRemotely = fresh.projection.lifecycle === "done" && fresh.projection.completion_ready === true;
         if (settledRemotely) {
           existing = writeBatchRunState(input.root, {
             ...existing,
+            consecutive_qa_failures: 0,
             children: existing.children.map((c) => c.task_id === driven.task_id ? { ...c, state: "settled", reason: "crash after settlement; resuming at commit" } : c)
           });
         } else {
@@ -12087,6 +12661,8 @@ async function driveInterruptedChild(input, child) {
           intentPath
         });
       };
+      if (existing && !record.commits.length && existsSync9(join14(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);
@@ -12108,30 +12684,8 @@ async function driveInterruptedChild(input, child) {
       record.children = record.children.map((c) => c.task_id === child.task_id ? { ...c, state: "settled", reason: null } : c);
       record.consecutive_qa_failures = 0;
       persist();
-      try {
-        const planChild = input.children.find((c) => c.task_id === child.task_id);
-        const intentPath = planChild?.intent_path ?? undefined;
-        const { commit } = input.git?.commitChild ? await input.git.commitChild(input.root, child.task_id, input.batch_id, head, record.branch, intentPath) : input.kernel.commitChild ? await input.kernel.commitChild(input.root, child.task_id, input.batch_id, head, record.branch, intentPath) : await commitBatchChild({
-          root: input.root,
-          taskId: child.task_id,
-          batchId: input.batch_id,
-          expectedHead: head,
-          branch: record.branch,
-          intentPath
-        });
-        record.children = record.children.map((c) => c.task_id === child.task_id ? { ...c, state: "committed", commit } : c);
-        record.commits.push(commit);
-        head = commit;
-        persist();
-        child = { ...child, state: "committed", commit };
-      } 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`);
-        record.batch_state = "failed";
-        persist();
-        return finalize(input.root, record, message, "");
-      }
+      child = { ...child, state: "settled", reason: null };
+      continue;
     } 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();
@@ -12139,16 +12693,22 @@ async function driveInterruptedChild(input, child) {
     } else if (terminal.state === "rework" && terminal.operation === "qa") {
       record.consecutive_qa_failures += 1;
       if (record.consecutive_qa_failures >= record.budget.qa_failure_limit) {
-        const reason = `QA failure limit reached: ${terminal.summary}`;
+        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`);
         persist();
-        return finalize(input.root, record, reason, "");
+        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 });
       }
       persist();
+      const fresh = requireFreshProjection(await input.kernel.projectTask(input.root, child.task_id), child.task_id);
+      return executorHandoff(record, child.task_id, fresh, terminal);
+    } else if (terminal.state === "rework" || terminal.environment_failure || terminal.state === "review_preparation_failed" || terminal.recovery?.category === "repair") {
+      const fresh = requireFreshProjection(await input.kernel.projectTask(input.root, child.task_id), child.task_id);
+      return executorHandoff(record, child.task_id, fresh, terminal);
     } else {
-      const reason = terminal.state === "stopped" ? "Kernel reported the child stopped" : terminal.state === "rework" ? terminal.summary : terminal.reason;
+      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`);
@@ -12855,7 +13415,7 @@ class ClaudeRuntime {
       throw new NativeAuthorityError("unsupported_host", "interactive MCP elicitation is unavailable");
     if (!this.requestConfirmation)
       throw new NativeAuthorityError("interaction_not_opened", batchReason("confirmation_port_unavailable").reason);
-    const now = new Date().toISOString();
+    let now = new Date().toISOString();
     const preflight = await projectBatchPreflight({
       root: this.cwd,
       initiative_slug: initiativeSlug,
@@ -12969,6 +13529,9 @@ class ClaudeRuntime {
     const { binding, batch_id: batchId, expires_at: expiresAt } = authorization;
     if (meta.signal?.aborted)
       return batchReason("cancelled_before_execution");
+    now = new Date().toISOString();
+    if (Date.parse(expiresAt) <= Date.parse(now))
+      return batchReason("confirmation_failed", "confirmed batch deadline expired before authorization issuance");
     const capability = this.batchRegistry.issue(binding, recoveryChildren, now);
     const basePort = this.createBatchKernelPort(this.batchRegistry, capability, binding);
     const kernelPort = {
@@ -13041,19 +13604,30 @@ class ClaudeRuntime {
       },
       advanceTask: async (root, taskId) => {
         const result = await this.coordinator.advance(taskId, { cwd: root });
+        const facts = { diagnostics: result.diagnostics, environment_failure: result.environment_failure, recovery: result.recovery };
         if (result.state === "completed")
-          return { state: "completed" };
+          return { state: "completed", ...facts };
         if (result.state === "stopped")
-          return { state: "stopped" };
+          return { state: "stopped", ...facts };
         if (result.state === "rework")
-          return { state: "rework", operation: result.operation, summary: result.summary };
+          return { state: "rework", operation: result.operation, summary: result.summary, ...facts };
         if (result.state === "review_ready")
-          return { state: "review_ready", operation_id: result.operation_id };
+          return { state: "review_ready", operation_id: result.operation_id, ...facts };
+        if (result.state === "review_preparation_failed")
+          return { state: result.state, operation: result.operation, operation_id: result.operation_id, reason: result.reason, ...facts };
         if (result.state === "blocked")
-          return { state: "blocked", reason: result.reason };
-        return { state: "failed", reason: result.reason ?? "advance failed" };
+          return { state: "blocked", reason: result.reason, ...facts };
+        return { state: "failed", reason: result.reason ?? "advance failed", ...facts };
+      },
+      projectTask: async (root, taskId) => {
+        const fresh = await projectAssurance(root, taskId, diffSnapshotOf);
+        if (!fresh.claim || fresh.projection.lifecycle !== "active" || fresh.error !== null)
+          return fresh;
+        const { record, revision } = readTaskRecordRaw(root, taskId);
+        if (!record || revision !== fresh.projection.record_revision)
+          throw new Error(`Kernel recovery projection changed for ${taskId}`);
+        return { ...fresh, ...batchQaFailureFacts(record) };
       },
-      projectTask: async (root, taskId) => projectAssurance(root, taskId, diffSnapshotOf),
       ownsTaskClaim: (taskId) => {
         return registry.isChildConsumed(capability, taskId);
       },