immune-brain 3.6.3 → 3.6.5

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

@@ -42,7 +42,7 @@ function probeHost(env = process.env, platform = process.platform, hostVersion)
 }
 
 // plugins/immune-brain/runtime/plugin_version.ts
-var PLUGIN_VERSION = "3.6.3";
+var PLUGIN_VERSION = "3.6.5";
 
 // plugins/immune-brain/runtime/claude/interaction.ts
 import { createHash, randomUUID } from "node:crypto";
@@ -1351,6 +1351,8 @@ class AssuranceCoordinator {
     return this.sessionGeneration;
   }
   async advance(taskId, ctx, signal, onUpdate) {
+    if (this.isInvocationOpen(taskId))
+      return { state: "blocked", reason: "an authority invocation is already open" };
     const active = this.active(taskId);
     if (active?.state === "review_ready") {
       const reservation = this.reviewReservations.get(taskId);
@@ -1728,6 +1730,17 @@ class AssuranceCoordinator {
     }
     return { state: "blocked", reason: `Kernel requires ${settled.projection.next_obligation} after Review` };
   }
+  isReviewVerdictValid(taskId, verdictInput) {
+    const reservation = this.reviewReservations.get(taskId);
+    if (!reservation)
+      return false;
+    try {
+      parseAssuranceVerdict(verdictInput, reservation.snapshot);
+      return true;
+    } catch {
+      return false;
+    }
+  }
   abandonReview(taskId, reason) {
     const reservation = this.reviewReservations.get(taskId);
     if (!reservation)
@@ -1743,6 +1756,12 @@ class AssuranceCoordinator {
       return { state: "blocked", code: "verdict_invalid", reason: "Review verdict correction is required before advancing" };
     return { state: "review_ready", operation: "review", operation_id: reservation.operationId, snapshot_digest: snapshotDigest(reservation.snapshot), review_bundle_digest: reservation.snapshot.review_bundle_digest ?? "", agent_params: reservation.hostReservation.dispatch };
   }
+  releaseStoppedReview(taskId) {
+    const reservation = this.reviewReservations.get(taskId);
+    if (reservation)
+      this.releaseReviewReservation(taskId, reservation);
+    this.rejectedReviewOperations.delete(taskId);
+  }
   releaseReviewReservation(taskId, reservation, rejectionReason) {
     if (this.reviewReservations.get(taskId) !== reservation)
       return;
@@ -2484,9 +2503,6 @@ function captureReviewManifest(root, input) {
     throw new Error("immutable review manifest metadata exceeds bounded output limit");
   return manifest;
 }
-function ensureReviewRevision(root, input) {
-  return publishInput(root, input).revision;
-}
 function writeNativeReviewEvidence(payload) {
   const rawDirectory = mkdtempSync(join4(tmpdir2(), "imm-canary-native-review-"));
   try {
@@ -2716,6 +2732,9 @@ var TASK_RECORD_CONTRACT_V2 = "assurance_kernel/task_record/v2";
 var TASK_RECORD_CONTRACT_V3 = "assurance_kernel/task_record/v3";
 var TASK_RECORD_CONTRACT_V4 = "assurance_kernel/task_record/v4";
 var REVIEW_REVISION_IDENTITY_CONTRACT = "assurance_kernel/review_revision_identity/v1";
+function isTaskRecordV4(record) {
+  return record.contract === TASK_RECORD_CONTRACT_V4;
+}
 var REDUCED_MUTATION_BRAND = Symbol("assurance-kernel-reduced-mutation-v2");
 var MUTATION_AUTHORITY_CAPABILITY_BRAND = Symbol("assurance-kernel-mutation-authority-capability");
 
@@ -3001,6 +3020,15 @@ function classifyIntentRevision(previous, next) {
     return "breaking";
   return next.revision > previous.revision ? "compatible" : "breaking";
 }
+
+class TaskIntentObservationError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "TaskIntentObservationError";
+    this.code = code;
+  }
+}
 var intentReaderTestHook = null;
 function validateTaskId3(taskId) {
   if (!TASK_ID_PATTERN.test(taskId))
@@ -3065,7 +3093,7 @@ function assertIdentitiesUnchanged(expected, canonicalRoot, relativePath) {
       throw new Error(`path component changed while being read: ${parts.slice(0, index + 1).join("/")}`);
   }
 }
-function readTaskIntent(root, taskId, requestedPath) {
+function readTaskIntentSource(root, taskId, requestedPath) {
   validateTaskId3(taskId);
   const canonicalRoot = resolveCanonicalRoot(root);
   const activePath = `${INTENT_SIDECAR_RELATIVE_PREFIX}${taskId}.intent.json`;
@@ -3077,17 +3105,19 @@ function readTaskIntent(root, taskId, requestedPath) {
   if (!target.startsWith(canonicalRoot + sep3))
     throw new Error("intent sidecar escapes project root");
   if (!sidecarPresent(canonicalRoot, sidecarPath))
-    throw new Error(`TaskIntent sidecar is missing at ${sidecarPath}`);
+    throw new TaskIntentObservationError("missing", `TaskIntent sidecar is missing at ${sidecarPath}`);
   const pathIdentities = collectPathIdentities(canonicalRoot, sidecarPath);
   const fileIdentity = pathIdentities[pathIdentities.length - 1];
   try {
     execFileSync3("git", ["ls-files", "--error-unmatch", "--", sidecarPath], { cwd: canonicalRoot, stdio: ["ignore", "pipe", "pipe"] });
-  } catch {
-    throw new Error("TaskIntent sidecar is not Git-tracked");
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "status" in error && error.status === 1)
+      throw new TaskIntentObservationError("invalid", "TaskIntent sidecar is not Git-tracked");
+    throw error;
   }
   const before = lstatSync4(target);
   if (!before.isFile() || before.size > INTENT_MAX_BYTES)
-    throw new Error("TaskIntent sidecar must be a regular file no larger than 64 KiB");
+    throw new TaskIntentObservationError("invalid", "TaskIntent sidecar must be a regular file no larger than 64 KiB");
   const fd = openSync2(target, fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW);
   let bytes;
   try {
@@ -3099,7 +3129,7 @@ function readTaskIntent(root, taskId, requestedPath) {
     closeSync2(fd);
   }
   if (bytes.byteLength > INTENT_MAX_BYTES)
-    throw new Error("TaskIntent sidecar exceeds 64 KiB");
+    throw new TaskIntentObservationError("invalid", "TaskIntent sidecar exceeds 64 KiB");
   const after = lstatSync4(target);
   assertSameIdentity(statIdentity(before), after, "intent sidecar");
   assertIdentitiesUnchanged(pathIdentities, canonicalRoot, sidecarPath);
@@ -3113,23 +3143,11 @@ function readTaskIntent(root, taskId, requestedPath) {
   try {
     intent = parseTaskIntentV1(JSON.parse(bytes.toString("utf8")));
   } catch (error) {
-    throw new Error(`TaskIntent sidecar is invalid: ${error instanceof Error ? error.message : String(error)}`);
+    throw new TaskIntentObservationError("invalid", `TaskIntent sidecar is invalid: ${error instanceof Error ? error.message : String(error)}`);
   }
   if (intent.task_id !== taskId)
-    throw new Error("intent.task_id does not match the sidecar filename task id");
+    throw new TaskIntentObservationError("invalid", "intent.task_id does not match the sidecar filename task id");
   const contentHash = canonicalIntentHash(intent);
-  const token = mintToken({
-    canonical_root: canonicalRoot,
-    sidecar_path: sidecarPath,
-    path_dev: fileIdentity.dev,
-    path_ino: fileIdentity.ino,
-    fd_dev: before.dev,
-    fd_ino: before.ino,
-    fd_size: before.size,
-    fd_mtime_ms: before.mtimeMs,
-    source_bytes_sha256: sourceBytesSha256,
-    intent_content_hash: contentHash
-  });
   return {
     intent,
     content_hash: contentHash,
@@ -3138,9 +3156,24 @@ function readTaskIntent(root, taskId, requestedPath) {
       revision: intent.revision,
       content_hash: contentHash
     },
-    token
+    identity: {
+      canonical_root: canonicalRoot,
+      sidecar_path: sidecarPath,
+      path_dev: fileIdentity.dev,
+      path_ino: fileIdentity.ino,
+      fd_dev: before.dev,
+      fd_ino: before.ino,
+      fd_size: before.size,
+      fd_mtime_ms: before.mtimeMs,
+      source_bytes_sha256: sourceBytesSha256,
+      intent_content_hash: contentHash
+    }
   };
 }
+function readTaskIntent(root, taskId, requestedPath) {
+  const { identity, ...observed } = readTaskIntentSource(root, taskId, requestedPath);
+  return { ...observed, token: mintToken(identity) };
+}
 
 // plugins/immune-brain/runtime/kernel/validation.ts
 var GIT_OBJECT_ID3 = /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/;
@@ -3645,6 +3678,7 @@ var ACTION_V2_TYPES = [
   "request_rework",
   "complete",
   "stop",
+  "authorize_rework",
   "resolve_user_decision"
 ];
 var ACTION_BASE_FIELDS = [
@@ -3740,7 +3774,8 @@ function parseTaskAction(raw) {
       };
       break;
     }
-    case "complete": {
+    case "complete":
+    case "authorize_rework": {
       rejectUnknown2(value, [...ACTION_BASE_FIELDS], "action", violations);
       action = { ...base, type: base.type };
       break;
@@ -3798,7 +3833,7 @@ function assertTaskRecordUpdateV3(previousRaw, nextRaw, action) {
       violations.push("non-intent action cannot change the intent snapshot");
     if (next.intent_ref.content_hash !== previous.intent_ref.content_hash)
       violations.push("non-intent action cannot change intent_ref content hash");
-    if (next.intent_ref.path !== previous.intent_ref.path && action.type !== "request_rework" && action.type !== "stop")
+    if (next.intent_ref.path !== previous.intent_ref.path && action.type !== "request_rework" && action.type !== "authorize_rework" && action.type !== "stop")
       violations.push("only artifact transitions may change intent_ref path");
   }
   if (next.attestations.length < previous.attestations.length)
@@ -3810,7 +3845,7 @@ function assertTaskRecordUpdateV3(previousRaw, nextRaw, action) {
     if (!current || JSON.stringify(current) !== JSON.stringify(prior))
       violations.push(`attestation ${prior.id} was rewritten`);
   }
-  const resolvingFindingIds = action.type === "resolve_finding" ? [action.finding_id] : action.type === "resolve_user_decision" ? [action.finding_id] : action.type === "approve_breaking_intent_revision" ? previous.findings.filter((item) => item.kind === "replan_required" && item.status === "open").map((item) => item.id) : [];
+  const resolvingFindingIds = action.type === "resolve_finding" ? [action.finding_id] : action.type === "resolve_user_decision" ? [action.finding_id] : action.type === "authorize_rework" || action.type === "approve_breaking_intent_revision" ? previous.findings.filter((item) => item.kind === "replan_required" && item.status === "open").map((item) => item.id) : [];
   const reworkFindingIds = action.type === "request_rework" ? new Set(action.findings.map((item) => item.id)) : new Set;
   for (const prior of previous.findings) {
     const current = next.findings.find((item) => item.id === prior.id);
@@ -5039,6 +5074,8 @@ function deriveAssuranceAuthorization(input) {
       state: "none",
       blocked: `resolve-user-decision requires exactly one open user decision; found ${input.open_user_decision_count}`
     };
+  if (input.next_obligation === "revise_intent")
+    return { state: "authorize_rework", blocked: null };
   return { state: "none", blocked: null };
 }
 function emptyProjection() {
@@ -5289,7 +5326,7 @@ function intentRefMatches(intent, ref) {
   return ref.path === `docs/plans/${intent.task_id}.intent.json` && ref.content_hash === canonicalIntentHash(intent);
 }
 function hasPrivilegedKind(action) {
-  return action.type === "record_approval" || action.type === "approve_breaking_intent_revision" || action.type === "request_rework" || action.type === "stop" || action.type === "resolve_user_decision";
+  return action.type === "record_approval" || action.type === "approve_breaking_intent_revision" || action.type === "request_rework" || action.type === "authorize_rework" || action.type === "stop" || action.type === "resolve_user_decision";
 }
 function findingsDigestV2(findings) {
   const normalized = findings.map((finding) => ({
@@ -5507,8 +5544,8 @@ function reduceTask(recordRaw, actionRaw, authorityAudit = null, changedPaths) {
           "request_rework requires review, qa, or user authority"
         ]);
       const round = reviewRound(record);
-      const reviewAuthorityReworks = record.history.filter((entry) => entry.type === "request_rework" && entry.authority?.authority_kind === "review").length;
-      const parkForReplan = authorityAudit.authority_kind === "review" && reviewAuthorityReworks >= 1;
+      const hasPriorBlockingReviewRework = record.findings.some((finding) => finding.source === "review" && finding.kind === "blocking" && finding.review_round !== null);
+      const parkForReplan = authorityAudit.authority_kind === "review" && hasPriorBlockingReviewRework && action.findings.some((finding) => finding.kind === "blocking");
       if (!parkForReplan) {
         record.artifact_state = "active";
         record.intent_ref.path = `docs/plans/${record.task_id}.intent.json`;
@@ -5523,8 +5560,8 @@ function reduceTask(recordRaw, actionRaw, authorityAudit = null, changedPaths) {
         record.findings.push({
           ...finding,
           status: "open",
-          source: "review",
-          review_round: round
+          source: authorityAudit.authority_kind === "review" ? "review" : "execution",
+          review_round: authorityAudit.authority_kind === "review" ? round : null
         });
       }
       if (parkForReplan && !record.findings.some((item) => item.status === "open" && item.kind === "replan_required")) {
@@ -5547,6 +5584,27 @@ function reduceTask(recordRaw, actionRaw, authorityAudit = null, changedPaths) {
       appendHistory(record, action, from, `review_round_${round}`, authorityAudit);
       break;
     }
+    case "authorize_rework": {
+      if (record.lifecycle !== "active")
+        throw new KernelInvariantError([
+          `cannot authorize rework while lifecycle is ${record.lifecycle}`
+        ]);
+      if (authorityAudit?.authority_kind !== "user")
+        throw new KernelInvariantError([
+          "authorize_rework requires literal-user authority"
+        ]);
+      const open = record.findings.filter((finding) => finding.kind === "replan_required" && finding.status === "open");
+      if (open.length === 0)
+        throw new KernelInvariantError([
+          "authorize_rework requires an open replan boundary"
+        ]);
+      for (const finding of open)
+        finding.status = "resolved";
+      record.artifact_state = "active";
+      record.intent_ref.path = `docs/plans/${record.task_id}.intent.json`;
+      appendHistory(record, action, from, open.map((finding) => finding.id).join(","), authorityAudit);
+      break;
+    }
     case "complete": {
       if (record.lifecycle !== "active" || record.artifact_state !== "frozen")
         throw new KernelInvariantError([
@@ -5677,7 +5735,7 @@ function applyTaskAction(input) {
           "intent token does not match the committed record intent"
         ]);
     }
-    const privileged = action.type === "record_approval" || action.type === "approve_breaking_intent_revision" || action.type === "request_rework" || action.type === "stop" || action.type === "resolve_user_decision";
+    const privileged = action.type === "record_approval" || action.type === "approve_breaking_intent_revision" || action.type === "request_rework" || action.type === "authorize_rework" || action.type === "stop" || action.type === "resolve_user_decision";
     const expectedAuthority = privileged ? {
       task_id,
       action,
@@ -5737,6 +5795,8 @@ function applyTaskAction(input) {
       };
     }
     if (input.terminal) {
+      if (nextRecord.lifecycle === "active")
+        throw new Error("terminal settlement requires a done or stopped TaskRecord lifecycle");
       const tombstone = {
         contract: TASK_TOMBSTONE_CONTRACT,
         task_id,
@@ -5801,6 +5861,8 @@ function capabilityActionFor(input) {
       return { ...base, approval: input.approval };
     case "request_rework":
       return { ...base, findings: input.findings };
+    case "authorize_rework":
+      return { ...base, type: "authorize_rework" };
     case "stop":
       return { ...base, reason: input.reason };
     case "approve_breaking_intent_revision":
@@ -5947,7 +6009,7 @@ function createCanaryApplication(registry) {
     const hasBoundSpec = snapshot.intent_snapshot.scope_hint.some((path) => /^docs\/specs\/(?!archive\/)[^/]+\.spec\.md$/.test(path) && snapshot.intent_snapshot.scope_hint.includes(archivePath(path)));
     if (operation.op === "complete" && hasBoundSpec && snapshot.record.artifact_state !== "frozen")
       throw new KernelInvariantError(["complete requires frozen planning artifacts"]);
-    const artifactTransition = snapshot.record.artifact_state === "frozen" && (operation.op === "request_rework" || operation.op === "approve_breaking_intent_revision") ? transitionFor(input.root, snapshot.record, "restore") : operation.op === "stop" && snapshot.record.artifact_state !== "frozen" ? transitionFor(input.root, snapshot.record, "freeze", true) : undefined;
+    const artifactTransition = snapshot.record.artifact_state === "frozen" && (operation.op === "request_rework" || operation.op === "authorize_rework" || operation.op === "approve_breaking_intent_revision") ? transitionFor(input.root, snapshot.record, "restore") : operation.op === "stop" && snapshot.record.artifact_state !== "frozen" ? transitionFor(input.root, snapshot.record, "freeze", true) : undefined;
     const event_id = `${operation.op}:${input.task_id}:${at}`;
     const base = {
       event_id,
@@ -6013,6 +6075,10 @@ function createCanaryApplication(registry) {
         capability = operation.capability;
         action = { ...base, type: "stop", reason: operation.reason };
         break;
+      case "authorize_rework":
+        capability = operation.capability;
+        action = { ...base, type: "authorize_rework" };
+        break;
       case "resolve_user_decision":
         capability = operation.capability;
         action = {
@@ -6475,7 +6541,18 @@ function enrollCanaryTask(root, input, registry) {
       throw new Error("intent content hash mismatch");
     if (checks.gitBaseHead !== gitBaseHead)
       throw new Error("Git HEAD moved after the enrollment confirmation");
+    if (input.batch) {
+      const batch = input.batch.registry.inspect(input.batch.capability, input.batch.binding, Date.parse(input.now));
+      if (input.batch.registry.consumedChildren(input.batch.capability).length === 0 && input.batch.expected_head !== batch.base_head)
+        throw new Error(`batch_head_lineage_broken: the first child must enroll on the confirmed base_head ${batch.base_head}, not ${input.batch.expected_head}`);
+      if (checks.gitBaseHead !== input.batch.expected_head)
+        throw new Error(`batch_head_lineage_broken: expected ${input.batch.expected_head}, found ${checks.gitBaseHead}`);
+    }
     registry.consume(input.capability, input.capability_binding);
+    if (input.batch)
+      input.batch.registry.consumeChild(input.batch.capability, input.batch.binding, input.task_id, Date.parse(input.now));
+    if (!gitBaseHead)
+      throw new Error("enrollment requires a committed Git HEAD");
     const record = buildTaskRecordV4(input, checks.intent, gitBaseHead);
     const nextWorkspace = {
       ...checks.workspace.state,
@@ -6492,16 +6569,23 @@ function enrollCanaryTask(root, input, registry) {
       created_at: input.now,
       updated_at: input.now
     };
-    const mutation = commitEnrollmentLocked(root, input.task_id, {
-      contract: "assurance_kernel/workspace_transaction/v2",
-      task_id: input.task_id,
-      expected_record_hash: checks.current.revision,
-      next_record_content: `${JSON.stringify(record, null, 2)}
+    let mutation;
+    try {
+      mutation = commitEnrollmentLocked(root, input.task_id, {
+        contract: "assurance_kernel/workspace_transaction/v2",
+        task_id: input.task_id,
+        expected_record_hash: checks.current.revision,
+        next_record_content: `${JSON.stringify(record, null, 2)}
 `,
-      expected_workspace_hash: checks.workspace.revision,
-      next_workspace_content: `${JSON.stringify(nextWorkspace, null, 2)}
+        expected_workspace_hash: checks.workspace.revision,
+        next_workspace_content: `${JSON.stringify(nextWorkspace, null, 2)}
 `
-    }, claim);
+      }, claim);
+    } catch (error) {
+      if (input.batch)
+        input.batch.registry.releaseChild(input.batch.capability, input.task_id);
+      throw error;
+    }
     return {
       record: mutation.record,
       backend_claim: claim,
@@ -6641,16 +6725,23 @@ async function submitClaudeReview(host, coordinator, ctx, taskId, verdictInput)
       return coordinator.abandonReview(taskId, observed.reason);
     return { state: "blocked", reason: observed.reason };
   }
+  const parentValid = coordinator.isReviewVerdictValid(taskId, verdictInput);
+  if (!parentValid)
+    return coordinator.submitReview(taskId, ctx, verdictInput);
+  const receiptValid = coordinator.isReviewVerdictValid(taskId, observed.receipt.result);
+  if (!receiptValid) {
+    return coordinator.abandonReview(taskId, "reviewer receipt is not a valid verdict");
+  }
   const parentJson = extractVerdictJson(verdictInput);
   const receiptJson = extractVerdictJson(observed.receipt.result);
-  if (parentJson && receiptJson && verdictFingerprint(parentJson) !== verdictFingerprint(receiptJson)) {
+  if (verdictFingerprint(parentJson) !== verdictFingerprint(receiptJson)) {
     return { state: "blocked", reason: "parent verdict does not match reviewer receipt" };
   }
-  if (parentJson && !receiptJson) {
-    return { state: "blocked", reason: "reviewer receipt is not a valid verdict" };
-  }
   return coordinator.submitReview(taskId, ctx, verdictInput);
 }
+function stopReason(value) {
+  return typeof value === "string" && value.length > 0 ? value : "user stop";
+}
 function assertProjectionBinding(before, after, allowDiffChange = false) {
   const fields = allowDiffChange ? ["record_revision", "workspace_revision", "intent_revision", "intent_content_hash"] : ["record_revision", "workspace_revision", "intent_revision", "intent_content_hash", "diff_hash"];
   if (before.error || !before.claim || after.error || !after.claim || before.claim.task_id !== after.claim.task_id || fields.some((field) => before.projection[field] !== after.projection[field])) {
@@ -6660,22 +6751,57 @@ function assertProjectionBinding(before, after, allowDiffChange = false) {
 function qaOutcomes(record) {
   return Object.fromEntries(record.attestations.filter((item) => item.kind === "qa").flatMap((item) => item.acceptance_results).map((result) => [result.acceptance_id, { status: result.status, summary: result.summary }]));
 }
+async function ensureClaudeReviewRevision(root, taskId, projection) {
+  const current = await readTaskRecord(root, taskId);
+  const record = current.record;
+  if (!record)
+    throw new Error(`task ${taskId} has no TaskRecord`);
+  if (current.revision !== projection.projection.record_revision)
+    throw new Error("TaskRecord changed before Review revision preparation");
+  if (record.contract !== "assurance_kernel/task_record/v4")
+    return null;
+  if (!record.git_base_head)
+    throw new Error("Review revision requires a TaskRecord v4 git_base_head");
+  const manifest = captureReviewManifest(root, {
+    taskId,
+    baseHead: record.git_base_head,
+    scopeHint: record.intent_snapshot.scope_hint,
+    expectedDiffHash: projection.projection.diff_hash,
+    intentRevision: projection.projection.intent_revision,
+    intentContentHash: projection.projection.intent_content_hash,
+    recordRevision: projection.projection.record_revision,
+    workspaceRevision: projection.projection.workspace_revision,
+    lifecycle: projection.projection.lifecycle,
+    artifactState: projection.projection.artifact_state,
+    risk: record.intent_snapshot.risk,
+    outcomes: qaOutcomes(record)
+  });
+  return {
+    contract: "assurance_kernel/review_revision/v1",
+    base_head: manifest.base_head,
+    review_tree: manifest.review_tree,
+    review_commit: manifest.review_commit,
+    review_ref: manifest.review_ref,
+    diff_hash: manifest.diff_hash,
+    manifest_digest: manifest.manifest_digest
+  };
+}
 async function buildAssuranceSnapshot(root, taskId, role, projection, runner) {
-  const record = await readTaskRecord(root, taskId);
-  if (!record.record || record.revision !== projection.projection.record_revision)
+  const read = await readTaskRecord(root, taskId);
+  const record = read.record;
+  if (!record || read.revision !== projection.projection.record_revision)
     throw new Error("TaskRecord changed before assurance snapshot capture");
-  const intent = record.record.intent_snapshot;
+  const intent = record.intent_snapshot;
   const descriptors = new Map;
   for (const item of intent.acceptance) {
     const descriptor = parseVerificationDescriptor(item.verification);
     assertRunnerCompatible(descriptor, runner);
     descriptors.set(item.id, descriptor);
   }
-  const v4 = record.record.contract === "assurance_kernel/task_record/v4";
-  const reviewBundle = role === "review" && !v4 ? captureReviewBundle(root, intent.scope_hint, projection.projection.diff_hash, qaOutcomes(record.record)) : null;
-  const reviewManifest = role === "review" && v4 ? captureReviewManifest(root, {
+  const reviewBundle = role === "review" && !isTaskRecordV4(record) ? captureReviewBundle(root, intent.scope_hint, projection.projection.diff_hash, qaOutcomes(record)) : null;
+  const reviewManifest = role === "review" && isTaskRecordV4(record) ? captureReviewManifest(root, {
     taskId,
-    baseHead: record.record.git_base_head,
+    baseHead: record.git_base_head,
     scopeHint: intent.scope_hint,
     expectedDiffHash: projection.projection.diff_hash,
     intentRevision: projection.projection.intent_revision,
@@ -6685,7 +6811,7 @@ async function buildAssuranceSnapshot(root, taskId, role, projection, runner) {
     lifecycle: projection.projection.lifecycle,
     artifactState: projection.projection.artifact_state,
     risk: intent.risk,
-    outcomes: qaOutcomes(record.record)
+    outcomes: qaOutcomes(record)
   }) : null;
   const dirtyFiles = reviewManifest ? Object.keys(reviewManifest.changed_paths) : reviewBundle ? Object.keys(reviewBundle.dirty_files) : [];
   const snapshot = {
@@ -6784,11 +6910,11 @@ class ClaudeRuntime {
     this.interactive = options.interactive ?? true;
     this.requestConfirmation = options.requestConfirmation;
     this.host = options.host ?? new ClaudeReviewHost(new FileHookEventLog);
-    if (options.ports) {
-      this.coordinator = new AssuranceCoordinator({ ...options.ports, host: this.host });
-      return;
-    }
-    this.coordinator = new AssuranceCoordinator(this.createKernelPorts());
+    this.coordinator = new AssuranceCoordinator({
+      ...this.createKernelPorts(),
+      ...options.ports,
+      host: this.host
+    });
   }
   observe(event) {
     this.host.observe(event);
@@ -6802,27 +6928,18 @@ class ClaudeRuntime {
   async shutdown() {
     await this.coordinator.onSessionShutdown();
   }
+  kernelPorts() {
+    return this.createKernelPorts();
+  }
   createKernelPorts() {
     return {
       host: this.host,
       projectTask: (root, taskId) => projectAssurance(root, taskId, diffSnapshotOf),
-      readTaskRecord: (root, taskId) => readTaskRecord(root, taskId),
-      readTaskIntent: (root, taskId) => readTaskIntentForRecord(root, taskId),
+      readTaskRecord: async (root, taskId) => readTaskRecord(root, taskId),
+      readTaskIntent: async (root, taskId) => readTaskIntentForRecord(root, taskId),
       frozenRunner: async () => resolveBunRunner(),
       buildAssurance: (root, taskId, role, projection, runner) => buildAssuranceSnapshot(root, taskId, role, projection, runner),
-      ensureReviewRevision: async (root, taskId, projection) => {
-        const current = await readTaskRecord(root, taskId);
-        if (!current.record)
-          throw new Error(`task ${taskId} has no TaskRecord`);
-        if (current.record.contract !== "assurance_kernel/task_record/v4")
-          return null;
-        return ensureReviewRevision(root, {
-          taskId,
-          baseHead: current.record.git_base_head,
-          scopeHint: current.record.intent_snapshot.scope_hint,
-          expectedDiffHash: projection.projection.diff_hash
-        });
-      },
+      ensureReviewRevision: (root, taskId, projection) => ensureClaudeReviewRevision(root, taskId, projection),
       runQa: (snapshot, descriptors, runner, options) => runDeterministicQa(snapshot, descriptors, runner, options),
       writeReviewEvidence: (input) => writeNativeReviewEvidence(input.evidence),
       applyVerdict: (ctx, input) => this.applyVerdict(ctx, input),
@@ -6915,6 +7032,12 @@ class ClaudeRuntime {
   async submitReview(taskId, verdictInput) {
     return submitClaudeReview(this.host, this.coordinator, { cwd: this.cwd }, taskId, verdictInput);
   }
+  async resolveFinding(taskId, findingId) {
+    return this.executeOrdinary({ cwd: this.cwd }, {
+      taskId,
+      operation: { op: "resolve_finding", finding_id: findingId, actor_id: "executor" }
+    });
+  }
   async authorize(taskId, operation, meta, extra = {}) {
     if (operation === "repair_authority_state") {
       const authority = reconcileKernelAuthority(this.cwd, taskId);
@@ -6939,6 +7062,8 @@ class ClaudeRuntime {
           throw new Error(`resolve-user-decision requires exactly one open user decision; found ${open.length}`);
         op = "resolve_user_decision";
         decisionOp = { finding_id: open[0].id, resolution: `resume after literal-user decision: ${open[0].summary}` };
+      } else if (readiness.state === "authorize_rework") {
+        op = "authorize_rework";
       } else {
         throw new Error(readiness.blocked ?? "no unique host-derived authorization operation");
       }
@@ -7037,7 +7162,7 @@ class ClaudeRuntime {
         confirmation_ref: confirmation,
         ...op === "approve_breaking_intent_revision" ? { next_intent: nextIntent, next_intent_ref: nextIntentRef } : {},
         ...op === "resolve_user_decision" && decisionOp ? decisionOp : {},
-        ...op === "stop" ? { reason: extra.reason ?? "user stop" } : {}
+        ...op === "stop" ? { reason: stopReason(extra.reason) } : {}
       });
       throwIfCancelled(meta.signal);
       const result = app.execute({
@@ -7049,13 +7174,13 @@ class ClaudeRuntime {
           actor_id: actorId,
           ...op === "approve_breaking_intent_revision" ? { next_intent: nextIntent, next_intent_ref: nextIntentRef } : {},
           ...op === "resolve_user_decision" && decisionOp ? decisionOp : {},
-          ...op === "stop" ? { reason: extra.reason ?? "user stop" } : {}
+          ...op === "stop" ? { reason: stopReason(extra.reason) } : {}
         },
         prior_intent_token: priorIntent.token,
         diffProvider: diffSnapshotOf,
         now
       });
-      if (op === "stop" || op === "approve_breaking_intent_revision")
+      if (op === "stop" || op === "authorize_rework" || op === "approve_breaking_intent_revision")
         stagePlanningArtifactTransition(this.cwd, result.record);
       return result;
     } catch (error) {
@@ -7191,7 +7316,8 @@ var TOOLS = [
   { name: "request_authorization", description: "Apply exact literal-user authorization.", privileged: true },
   { name: "approve_breaking_intent_revision", description: "Approve a breaking TaskIntent revision.", privileged: true },
   { name: "stop", description: "Stop the active task with literal-user authority.", privileged: true },
-  { name: "repair_authority_state", description: "Repair a proven recoverable stale backend claim.", privileged: false }
+  { name: "repair_authority_state", description: "Repair a proven recoverable stale backend claim.", privileged: false },
+  { name: "resolve_finding", description: "Resolve one open blocking or advisory finding whose cause is fixed and verified.", privileged: false }
 ];
 function listMcpTools() {
   return TOOLS.map((tool) => ({
@@ -7203,9 +7329,10 @@ function listMcpTools() {
         task_id: { type: "string" },
         ...tool.name === "approve_breaking_intent_revision" ? { next_intent: { type: "object" } } : {},
         ...tool.name === "stop" ? { reason: { type: "string" } } : {},
-        ...tool.name === "submit_review" ? { verdict: { type: "object" } } : {}
+        ...tool.name === "submit_review" ? { verdict: { type: "object" } } : {},
+        ...tool.name === "resolve_finding" ? { finding_id: { type: "string" } } : {}
       },
-      required: tool.name === "submit_review" ? ["task_id", "verdict"] : ["task_id"]
+      required: tool.name === "submit_review" ? ["task_id", "verdict"] : tool.name === "resolve_finding" ? ["task_id", "finding_id"] : ["task_id"]
     },
     annotations: tool.privileged ? privilegedAnnotations() : { readOnlyHint: tool.name === "status" }
   }));
@@ -7272,6 +7399,11 @@ function createMcpRuntime(options = {}) {
           throw new Error("verdict is required");
         return runtime.submitReview(taskId, args.verdict);
       }
+      if (name === "resolve_finding") {
+        if (typeof args.finding_id !== "string" || !args.finding_id)
+          throw new Error("finding_id is required");
+        return runtime.resolveFinding(taskId, args.finding_id);
+      }
       if (name === "request_authorization" || name === "approve_breaking_intent_revision" || name === "stop" || name === "repair_authority_state") {
         return runtime.authorize(taskId, name, toolMeta, args);
       }

package/plugins/immune-brain/dist/imm-loop.md

@@ -83,8 +83,14 @@ not bypass them. Do not poll or create detached jobs.
 - Invoke `approve_breaking_intent_revision` with the complete next intent
   directly; the native Host gate is the single user decision. Do not overwrite
   enrolled intent sidecars or ask for chat pre-confirmation.
-- On `awaiting_user`, invoke `request_authorization` directly. It is reserved
-  for a concrete unresolved decision or explicit stop, not risk tier alone.
+- On `awaiting_user`, invoke `request_authorization` directly for a concrete
+  unresolved decision or rework authorization, not risk tier alone.
+- When the user explicitly asks to stop a Pi task, invoke
+  `imm_kernel_canary({ task_id, action: { op: "request_stop" } })` directly.
+  Its single native confirmation authorizes existing Kernel stop settlement.
+  Cancellation is not task termination. A busy invocation must finish or be
+  cancelled through existing Host controls before requesting stop; never clear
+  claims manually or use this operation to force-kill QA.
 - Invoke `repair_authority_state` directly for a proven stale claim. Kernel
   revalidation removes only the redundant claim without user interaction.
 - A Managed native authority failure stays fail-closed. Report its stable reason

package/plugins/immune-brain/dist/imm-planner.md

@@ -163,18 +163,23 @@ After approval, author, stage, and validate every TaskIntent in the decompositio
 with `valid: true` and `enrollment_ready: true`. Resolve `../bin/imm-tracker` from this packaged contract; do not assume a bare command is on `PATH`. Submit the entire approved set once through
 `imm-tracker publish-initiative --stdin --json`. Its input contains the confirmed
 Initiative slug and goal, Parent projection, and every Child's `slice_id`,
-canonical TaskIntent path, and public projection. The Parent projection requires
+canonical TaskIntent path, bounded public `acceptance` summaries, and public
+projection. The Parent projection requires
 `problem`, `result`, and `design`, and may include `decisions`,
 `testing_strategy`, and `out_of_scope`. `design` records Initiative-level
 invariants, Slice boundaries and ordering, shared interfaces or state flow, and
 material compatibility decisions. Every Parent Slice must correspond to one
 published Child; future checklist-only Slices are not allowed in the batch.
 
-Each Child projection may contain `result`, `current_behavior`,
+Each Child must provide public `acceptance` entries with `id` and a 1-500
+character `summary`. Their IDs must match every canonical TaskIntent acceptance
+ID exactly once. Canonical assertion prose is authority evidence and must never
+be copied into public GitHub projection. Each Child projection may contain
+`result`, `current_behavior`,
 `desired_behavior`, `key_interfaces`, `verification`, `blocked_by` Task IDs,
 `out_of_scope`, and `agent_handoff`. The tracker rereads every canonical
-TaskIntent for identity, risk, and acceptance; projection fields never widen
-TaskIntent scope or authority. It validates the complete dependency graph before
+TaskIntent for identity, risk, and acceptance IDs; projection fields and public
+summaries never widen TaskIntent scope or authority. It validates the complete dependency graph before
 remote writes, creates the Parent once, creates all Children, attaches every
 Child as a native Sub-issue, creates native `blocked_by` relations, and rereads
 the complete topology. The Child Agent Brief includes a direct Parent Issue link.