immune-brain 3.5.0 → 3.6.1

package/plugins/immune-brain/runtime/claude/kernel_ports.ts

@@ -4,7 +4,6 @@ import { execFileSync } from "node:child_process";
 import { join } from "node:path";
 import {
 	AssuranceCoordinator,
-	snapshotDigest,
 	type AssuranceCoordinatorPorts,
 	type AssuranceSubmitReviewResult,
 	type AssuranceVerdict,
@@ -15,8 +14,6 @@ import {
 	assertRunnerCompatible,
 	findingsDigest,
 	resolveBunRunner,
-	runFixedVerification,
-	VerificationAbortedError,
 	type FrozenRunner,
 	type VerificationDescriptor,
 } from "../assurance/verification";
@@ -29,7 +26,7 @@ import {
 import { parseVerificationDescriptor } from "../verification_descriptor";
 import { projectAssurance, type AssuranceProjectionResult } from "../kernel/assurance_projection";
 import type { TaskRecord } from "../kernel/types";
-import { readTaskRecord } from "../kernel/storage";
+import { readTaskRecord, readTaskRecordRaw } from "../kernel/storage";
 import { canonicalIntentHash, parseTaskIntentV1, readTaskIntent } from "../kernel/intent";
 import { capabilityActionFor, createCanaryApplication } from "../kernel/canary_application";
 import {
@@ -45,7 +42,7 @@ import {
 import { enrollCanaryTask, runEnrollmentRehearsal } from "../kernel/enrollment";
 import { reconcileKernelAuthority, repairKernelAuthority } from "../kernel/storage";
 import { preparePiCanary, revalidatePiCanary } from "../kernel/pi_canary_prepare";
-import { qaFindingId } from "../assurance/qa_findings";
+import { runDeterministicQa } from "../assurance/qa";
 import { taskDiffIdentity, taskRevisionIdentity } from "../workspace_scope";
 import {
 	confirmationRef,
@@ -73,6 +70,19 @@ export function diffHashOf(root: string, record: TaskRecord): string {
 	return diffSnapshotOf(root, record).diff_hash;
 }
 
+/**
+ * Read the TaskIntent through the TaskRecord's `intent_ref.path`.
+ *
+ * `freeze_artifacts` relocates the sidecar from `docs/plans/<task-id>.intent.json`
+ * into `docs/plans/archive/`, so every post-freeze read — QA settlement included —
+ * must follow the record instead of the pre-freeze default path. The Pi adapter
+ * resolves the same way in its own runtime stub; both Hosts must stay in step.
+ */
+function readTaskIntentForRecord(root: string, taskId: string) {
+	const currentPath = readTaskRecordRaw(root, taskId).record?.intent_ref?.path;
+	return readTaskIntent(root, taskId, currentPath);
+}
+
 function extractVerdictJson(input: unknown): Record<string, unknown> | null {
 	if (typeof input === "string") {
 		const cleaned = input.split("\n").map((line) => line.trim()).filter((line) => line.startsWith("{") && line.endsWith("}")).join("");
@@ -129,47 +139,6 @@ function assertProjectionBinding(before: AssuranceProjectionResult, after: Assur
 	}
 }
 
-export async function runDeterministicQa(
-	snapshot: SnapshotDescriptor,
-	descriptors: Map<string, VerificationDescriptor>,
-	runner: FrozenRunner,
-	options: { signal?: AbortSignal; onProgress?: (progress: { index: number; total: number; acceptance_id: string; phase: "running" | "passed" | "failed"; elapsed_ms: number }) => void } = {},
-): Promise<AssuranceVerdict> {
-	if (snapshot.role !== "qa") throw new Error("deterministic QA requires qa role");
-	if (options.signal?.aborted) throw new VerificationAbortedError();
-	const findings: NonNullable<AssuranceVerdict["findings"]> = [];
-	for (const [offset, item] of snapshot.acceptance.entries()) {
-		if (options.signal?.aborted) throw new VerificationAbortedError();
-		const descriptor = descriptors.get(item.id);
-		if (!descriptor) throw new Error(`verification descriptor missing for ${item.id}`);
-		const startedAt = Date.now();
-		options.onProgress?.({ index: offset + 1, total: snapshot.acceptance.length, acceptance_id: item.id, phase: "running", elapsed_ms: 0 });
-		const result = await runFixedVerification(snapshot.root, descriptor, runner, { signal: options.signal });
-		const failed = result.exit_code !== 0 || result.timed_out;
-		options.onProgress?.({ index: offset + 1, total: snapshot.acceptance.length, acceptance_id: item.id, phase: failed ? "failed" : "passed", elapsed_ms: Date.now() - startedAt });
-		if (failed) {
-			findings.push({
-				id: qaFindingId(item.id, snapshotDigest(snapshot)),
-				kind: "blocking",
-				acceptance_id: item.id,
-				summary: `verification failed (exit ${result.exit_code}${result.timed_out ? ", timed out" : ""})`,
-				findings_digest: "",
-			});
-		}
-	}
-	if (findings.length > 0) {
-		return { contract: "assurance_kernel/assurance_verdict/v2", role: "qa", task_id: snapshot.task_id, snapshot_digest: snapshotDigest(snapshot), decision: "rework", findings };
-	}
-	return {
-		contract: "assurance_kernel/assurance_verdict/v2",
-		role: "qa",
-		task_id: snapshot.task_id,
-		snapshot_digest: snapshotDigest(snapshot),
-		decision: "pass",
-		approval: { kind: "qa", authority_role: "qa", summary: `all ${snapshot.acceptance.length} fixed verification descriptor(s) passed` },
-	};
-}
-
 function qaOutcomes(record: { attestations: Array<{ kind: string; acceptance_results: Array<{ acceptance_id: string; status: "passed" | "failed" | "blocked"; summary: string }> }> }) {
 	return Object.fromEntries(
 		record.attestations.filter((item) => item.kind === "qa").flatMap((item) => item.acceptance_results)
@@ -379,7 +348,7 @@ export class ClaudeRuntime {
 			host: this.host,
 			projectTask: (root, taskId) => projectAssurance(root, taskId, diffSnapshotOf),
 			readTaskRecord: (root, taskId) => readTaskRecord(root, taskId),
-			readTaskIntent: (root, taskId) => readTaskIntent(root, taskId),
+			readTaskIntent: (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) => {
@@ -442,7 +411,7 @@ export class ClaudeRuntime {
 	async enroll(taskId: string, meta: ToolMeta) {
 		const now = new Date().toISOString();
 		const preparation = await preparePiCanary(this.cwd, { task_id: taskId, now });
-		const intent = await readTaskIntent(this.cwd, taskId);
+		const intent = await readTaskIntentForRecord(this.cwd, taskId);
 		const gate = await this.gate("enroll", { ...meta, taskId }, {
 			risk: intent.intent.risk,
 			intentRevision: preparation.intent?.revision,
@@ -520,7 +489,7 @@ export class ClaudeRuntime {
 				throw new Error(readiness.blocked ?? "no unique host-derived authorization operation");
 			}
 		}
-		const priorIntent = await readTaskIntent(this.cwd, taskId);
+		const priorIntent = await readTaskIntentForRecord(this.cwd, taskId);
 		const now = new Date().toISOString();
 		const actorId = "user";
 		const nextIntent = extra.next_intent ? await parseTaskIntentV1(extra.next_intent) : undefined;
@@ -658,7 +627,7 @@ export class ClaudeRuntime {
 		},
 	): Promise<void> {
 		const { registry, app } = await this.authority();
-		const priorIntentToken = (await readTaskIntent(ctx.cwd, input.taskId)).token;
+		const priorIntentToken = (await readTaskIntentForRecord(ctx.cwd, input.taskId)).token;
 		const now = new Date().toISOString();
 		const commitAndApply = async <T>(apply: () => Promise<T>): Promise<T> => {
 			this.coordinator.commitInvocation(input.invocation as never);
@@ -743,7 +712,7 @@ export class ClaudeRuntime {
 		const operation = input.operation.op === "revise_intent"
 			? { ...input.operation, next_intent: await parseTaskIntentV1(input.operation.next_intent) }
 			: input.operation;
-		const priorIntent = await readTaskIntent(ctx.cwd, input.taskId);
+		const priorIntent = await readTaskIntentForRecord(ctx.cwd, input.taskId);
 		const sidecar = join(ctx.cwd, priorIntent.intent_ref.path);
 		const priorBytes = operation.op === "revise_intent" ? readFileSync(sidecar) : null;
 		try {

package/plugins/immune-brain/runtime/kernel/intent.ts

@@ -43,6 +43,12 @@ export const INTENT_SIDECAR_RELATIVE_PREFIX = "docs/plans/";
 export const RISK_FLOOR_SCOPE_PREFIXES = [
 	"plugins/immune-brain/runtime/kernel",
 	"plugins/immune-brain/runtime/authority_commit_receipts.ts",
+	"plugins/immune-brain/runtime/assurance",
+	"plugins/immune-brain/runtime/claude/interaction.ts",
+	"plugins/immune-brain/runtime/claude/capability.ts",
+	"plugins/immune-brain/runtime/claude/review_host.ts",
+	"plugins/immune-brain/runtime/claude/kernel_ports.ts",
+	"plugins/immune-brain/runtime/claude/mcp_server.ts",
 	"plugins/immune-brain/.pi-extension",
 ] as const;
 
@@ -50,8 +56,7 @@ export const RISK_FLOOR_SCOPE_PREFIXES = [
 // separate from the glob-aware scope_hint policy above: the two inputs have
 // different contracts and docs-only scope remains routine today.
 export const CHANGED_PATH_RISK_FLOOR_PREFIXES = [
-	"plugins/immune-brain/runtime/kernel",
-	"plugins/immune-brain/.pi-extension",
+	...RISK_FLOOR_SCOPE_PREFIXES,
 	"docs/specs",
 	"docs/plans",
 ] as const;
@@ -458,6 +463,35 @@ function resolveCanonicalRoot(root: string): string {
 	return realpathSync(resolved);
 }
 
+// Resolve a path-less read to the sidecar that actually exists.
+//
+// The active path stays authoritative whenever it is present: that is the
+// pre-freeze layout every path-less caller assumes, and a leftover archived
+// sidecar from an earlier task reusing the same id must never shadow it. Only
+// when the active path is gone — the post-`freeze_artifacts` layout — does the
+// archive answer, which is exactly the case that used to fail with a raw ENOENT.
+function resolveSidecarPath(
+	canonicalRoot: string,
+	activePath: string,
+	archivedPath: string,
+): string {
+	if (sidecarPresent(canonicalRoot, activePath)) return activePath;
+	if (sidecarPresent(canonicalRoot, archivedPath)) return archivedPath;
+	return activePath;
+}
+
+// Existence only. A symlink counts as present so `collectPathIdentities` still
+// rejects it as a symlink; reporting it as missing would turn a security
+// rejection into a lookup failure.
+function sidecarPresent(canonicalRoot: string, relativePath: string): boolean {
+	try {
+		lstatSync(join(canonicalRoot, relativePath));
+		return true;
+	} catch {
+		return false;
+	}
+}
+
 function collectPathIdentities(
 	canonicalRoot: string,
 	relativePath: string,
@@ -499,12 +533,19 @@ export function readTaskIntent(
 	const canonicalRoot = resolveCanonicalRoot(root);
 	const activePath = `${INTENT_SIDECAR_RELATIVE_PREFIX}${taskId}.intent.json`;
 	const archivedPath = `${INTENT_SIDECAR_RELATIVE_PREFIX}archive/${taskId}.intent.json`;
-	const sidecarPath = requestedPath ?? activePath;
+	// `freeze_artifacts` relocates the sidecar from the active path to the archive
+	// path, so the caller's TaskRecord `intent_ref.path` is the authority. When no
+	// path is requested, resolve the single sidecar that exists rather than
+	// assuming the pre-freeze layout; a missing or ambiguous sidecar is a stable
+	// contract failure, not a raw `lstat` ENOENT.
+	const sidecarPath = requestedPath ?? resolveSidecarPath(canonicalRoot, activePath, archivedPath);
 	if (sidecarPath !== activePath && sidecarPath !== archivedPath)
 		throw new Error("intent sidecar path is not the active or archived task path");
 	const target = join(canonicalRoot, sidecarPath);
 	if (!target.startsWith(canonicalRoot + sep))
 		throw new Error("intent sidecar escapes project root");
+	if (!sidecarPresent(canonicalRoot, sidecarPath))
+		throw new Error(`TaskIntent sidecar is missing at ${sidecarPath}`);
 
 	const pathIdentities = collectPathIdentities(canonicalRoot, sidecarPath);
 	const fileIdentity = pathIdentities[pathIdentities.length - 1];

package/plugins/immune-brain/runtime/plugin_version.ts

@@ -1,2 +1,2 @@
 // Generated by scripts/plugin_versioning.ts from the root package.json.
-export const PLUGIN_VERSION = "3.5.0" as const;
+export const PLUGIN_VERSION = "3.6.1" as const;