immune-brain 2.8.3 → 3.0.2

package/plugins/immune-brain/runtime/assurance/enrollment.ts

@@ -0,0 +1,6 @@
+export {
+	preparePiCanary,
+	revalidatePiCanary,
+	type PiCanaryPreparation,
+	type PiCanaryPrepareInput,
+} from "../kernel/pi_canary_prepare";

package/plugins/immune-brain/runtime/assurance/host_port.ts

@@ -0,0 +1,18 @@
+export interface ReviewRequest {
+	taskId: string;
+	operationId: string;
+	prompt: string;
+	evidencePath: string;
+	maxTurns: number;
+}
+
+export interface HostReviewReservation {
+	id: string;
+	dispatch: unknown;
+}
+
+export interface AssuranceHostPort {
+	readonly host: "pi" | "claude-code" | "fake";
+	prepareReview(request: ReviewRequest): HostReviewReservation;
+	releaseReview(reservation: HostReviewReservation): void;
+}

package/plugins/immune-brain/runtime/assurance/invocations.ts

@@ -0,0 +1,90 @@
+// P2B2 task-scoped invocation registry. NOT part of the Kernel runtime graph.
+// One linear state transition per task: `open -> committed | cancelled`.
+// Concurrent assure/authorize operations for the same task are rejected;
+// timeout/cancel wins `open -> cancelled` first; a successful continuation
+// must win `open -> committed` immediately before mint/apply; application
+// failure leaves the invocation closed so retry requires a new invocation.
+// No memory/file cross-transaction atomicity is claimed.
+
+export type InvocationState = "open" | "committed" | "cancelled";
+
+export interface InvocationToken {
+	readonly task_id: string;
+	readonly nonce: string;
+}
+
+export interface InvocationRegistry {
+	/** Open a new invocation for one task; rejects if one is already open. */
+	open(taskId: string): InvocationToken;
+	/**
+	 * Linearization point: wins `open -> committed` for exactly this token.
+	 * Throws for a foreign token or a token whose invocation already ended.
+	 * Only the winner may mint/apply a capability.
+	 */
+	commit(token: InvocationToken): void;
+	/** Wins `open -> cancelled` (timeout/cancel/abort path). */
+	cancel(token: InvocationToken): void;
+	/** Inspect the current state of the caller's token. */
+	stateOf(token: InvocationToken): InvocationState;
+	/** Whether any invocation for the task is currently open. */
+	isOpen(taskId: string): boolean;
+	/** Internal task state (for tests). */
+	states(): Record<string, InvocationState>;
+}
+
+export function createInvocationRegistry(): InvocationRegistry {
+	const states = new Map<string, { token: InvocationToken; state: InvocationState }>();
+
+	function tokenOf(taskId: string, nonce: string): InvocationToken {
+		return Object.freeze({ task_id: taskId, nonce });
+	}
+
+	function entryOf(token: InvocationToken): { token: InvocationToken; state: InvocationState } {
+		const entry = states.get(token.task_id);
+		if (!entry || entry.token.nonce !== token.nonce)
+			throw new Error("invocation token is not recognized for this task");
+		return entry;
+	}
+
+	return {
+		open(taskId: string): InvocationToken {
+			if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(taskId))
+				throw new Error("task id is not a safe file identity");
+			const existing = states.get(taskId);
+			if (existing && existing.state === "open") {
+				throw new Error(
+					`task ${taskId} already has an open invocation; concurrent assure/authorize is rejected`,
+				);
+			}
+			// A closed (committed/cancelled) invocation is replaced by a fresh
+			// one: retry requires a new invocation.
+			const token = tokenOf(taskId, `${taskId}:${Date.now()}:${Math.random().toString(36).slice(2, 10)}`);
+			states.set(taskId, { token, state: "open" });
+			return token;
+		},
+		commit(token: InvocationToken): void {
+			const entry = entryOf(token);
+			if (entry.state !== "open")
+				throw new Error(
+					`invocation for task ${token.task_id} is already ${entry.state}; a new invocation is required`,
+				);
+			entry.state = "committed";
+		},
+		cancel(token: InvocationToken): void {
+			const entry = entryOf(token);
+			if (entry.state === "open") entry.state = "cancelled";
+			// Cancel on an already-closed invocation is a no-op (idempotent).
+		},
+		stateOf(token: InvocationToken): InvocationState {
+			return entryOf(token).state;
+		},
+		isOpen(taskId: string): boolean {
+			return states.get(taskId)?.state === "open";
+		},
+		states(): Record<string, InvocationState> {
+			const out: Record<string, InvocationState> = {};
+			for (const [taskId, entry] of states) out[taskId] = entry.state;
+			return out;
+		},
+	};
+}

package/plugins/immune-brain/runtime/assurance/qa_findings.ts

@@ -0,0 +1,50 @@
+import { randomUUID } from "node:crypto";
+
+/**
+ * QA finding ids must stay globally unique for the lifetime of a task: the
+ * Kernel reducer rejects any finding id that was ever recorded, including
+ * resolved ones. Scoping each id to the snapshot digest plus a per-invocation
+ * suffix guarantees repeated rework attempts (even on an identical snapshot)
+ * never collide, while keeping the acceptance id traceable in the id itself.
+ */
+
+/** Digest-scoped id for a per-acceptance QA rework finding. */
+export function qaFindingId(acceptanceId: string, snapshotDigest: string): string {
+	return `qa-${acceptanceId}-${attemptRef(snapshotDigest)}`;
+}
+
+/** Digest-scoped id for an evidence-freshness QA rework finding. */
+export function qaEvidenceFreshnessId(snapshotDigest: string): string {
+	const digest16 = snapshotDigest.slice("sha256:".length, "sha256:".length + 16);
+	return `qa-evidence-freshness-${digest16}-${attemptRef(snapshotDigest)}`;
+}
+
+function attemptRef(snapshotDigest: string): string {
+	const digest8 = snapshotDigest.slice("sha256:".length, "sha256:".length + 8);
+	return `${digest8}-${randomUUID().slice(0, 6)}`;
+}
+
+/**
+ * Preserve the original QA verdict details (which acceptance failed and why)
+ * when applying an authority verdict fails. The raw reducer error alone masks
+ * the failure reason that matters; append the verdict findings when present.
+ */
+export function describeQaFailure(
+	boundedBase: string,
+	findings?: Array<{ id: string; summary: string }>,
+): string {
+	if (!findings?.length) return boundedBase;
+	const detail = findings.map((finding) => `${finding.id}: ${finding.summary}`).join(" | ");
+	const marker = "; verdict: ";
+	const totalBudget = 300;
+	// Reserve room for at least the first 160 chars of verdict detail.
+	const baseBudget = Math.max(0, totalBudget - marker.length - Math.min(detail.length, 160));
+	const trimmedBase =
+		boundedBase.length <= baseBudget
+			? boundedBase
+			: `${boundedBase.slice(0, Math.max(0, baseBudget - 1))}…`;
+	const detailBudget = Math.max(0, totalBudget - trimmedBase.length - marker.length);
+	const bounded =
+		detail.length <= detailBudget ? detail : `${detail.slice(0, Math.max(0, detailBudget - 3))}...`;
+	return `${trimmedBase}${marker}${bounded}`;
+}