immune-brain 2.8.2

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

@@ -0,0 +1,160 @@
+import type {
+	ApprovalKind,
+	CompletionDecision,
+	TaskAttestationV3,
+	TaskIntentV1,
+	TaskProjectionV3,
+	TaskRecordV3,
+} from "./types";
+import { assertKernelInvariantsV3 } from "./validation";
+
+const REQUIRED_ATTESTATIONS: Record<TaskIntentV1["risk"], ApprovalKind[]> = {
+	routine: ["qa"],
+	material: ["qa", "review"],
+	critical: ["qa", "review", "user"],
+};
+
+function hasDistinctAuthorityAssignment(
+	required: ApprovalKind[],
+	candidates: TaskAttestationV3[],
+	index = 0,
+	usedActors = new Set<string>(),
+): boolean {
+	if (index >= required.length) return true;
+	for (const attestation of candidates.filter((item) => item.kind === required[index])) {
+		if (usedActors.has(attestation.actor_id)) continue;
+		const nextActors = new Set(usedActors);
+		nextActors.add(attestation.actor_id);
+		if (hasDistinctAuthorityAssignment(required, candidates, index + 1, nextActors)) return true;
+	}
+	return false;
+}
+
+export function completionDecision(
+	intent: TaskIntentV1,
+	record: TaskRecordV3,
+	currentDiffHash: string,
+	currentIntentContentHash: string,
+): CompletionDecision {
+	assertKernelInvariantsV3(intent, record);
+	const freshAttestations = record.attestations.filter(
+		(item) =>
+			item.task_revision === intent.revision &&
+			item.intent_content_hash === currentIntentContentHash &&
+			item.diff_hash === currentDiffHash,
+	);
+	const freshQaResults = freshAttestations
+		.filter((item) => item.kind === "qa")
+		.flatMap((item) => item.acceptance_results)
+		.filter((item) => item.status === "passed");
+	const freshAcceptanceIds = intent.acceptance
+		.map((item) => item.id)
+		.filter((id) => freshQaResults.some((result) => result.acceptance_id === id));
+	const freshAcceptanceSet = new Set(freshAcceptanceIds);
+	const missingAcceptanceIds = intent.acceptance
+		.map((item) => item.id)
+		.filter((id) => !freshAcceptanceSet.has(id));
+	const staleAttestationIds = record.attestations
+		.filter(
+			(item) =>
+				item.task_revision !== intent.revision ||
+				item.intent_content_hash !== currentIntentContentHash ||
+				item.diff_hash !== currentDiffHash,
+		)
+		.map((item) => item.id);
+
+	const requiredKinds = REQUIRED_ATTESTATIONS[intent.risk];
+	const candidates = freshAttestations.filter((item) => requiredKinds.includes(item.kind));
+	const missingApprovalKinds = requiredKinds.filter(
+		(kind) => !candidates.some((attestation) => attestation.kind === kind),
+	);
+	const separationFailure =
+		missingApprovalKinds.length === 0 &&
+		!hasDistinctAuthorityAssignment(requiredKinds, candidates);
+	const repeatedActors = new Set<string>();
+	if (separationFailure) {
+		for (const attestation of candidates) {
+			const kinds = new Set(
+				candidates
+					.filter((candidate) => candidate.actor_id === attestation.actor_id)
+					.map((candidate) => candidate.kind),
+			);
+			if (kinds.size > 1) repeatedActors.add(attestation.actor_id);
+		}
+	}
+	const independenceViolations = candidates
+		.filter((item) => repeatedActors.has(item.actor_id))
+		.map((item) => item.id);
+
+	const blockingFindingIds = record.findings
+		.filter((item) => item.status === "open" && item.kind === "blocking")
+		.map((item) => item.id);
+	const unresolvedUserDecisionIds = record.findings
+		.filter((item) => item.status === "open" && item.kind === "unresolved_user_decision")
+		.map((item) => item.id);
+	const replanRequiredIds = record.findings
+		.filter((item) => item.status === "open" && item.kind === "replan_required")
+		.map((item) => item.id);
+
+	return {
+		complete:
+			missingAcceptanceIds.length === 0 &&
+			missingApprovalKinds.length === 0 &&
+			blockingFindingIds.length === 0 &&
+			unresolvedUserDecisionIds.length === 0 &&
+			replanRequiredIds.length === 0 &&
+			independenceViolations.length === 0,
+		fresh_acceptance_ids: freshAcceptanceIds,
+		missing_acceptance_ids: missingAcceptanceIds,
+		stale_attestation_ids: staleAttestationIds,
+		missing_approval_kinds: missingApprovalKinds,
+		blocking_finding_ids: blockingFindingIds,
+		unresolved_user_decision_ids: unresolvedUserDecisionIds,
+		replan_required_ids: replanRequiredIds,
+		independence_violations: independenceViolations,
+	};
+}
+
+export function projectTask(
+	intent: TaskIntentV1,
+	record: TaskRecordV3,
+	currentDiffHash: string,
+	currentIntentContentHash: string,
+): TaskProjectionV3 {
+	const decision = completionDecision(intent, record, currentDiffHash, currentIntentContentHash);
+	const blocked =
+		decision.blocking_finding_ids.length > 0 ||
+		decision.unresolved_user_decision_ids.length > 0 ||
+		decision.replan_required_ids.length > 0 ||
+		decision.independence_violations.length > 0;
+	let nextObligation: TaskProjectionV3["next_obligation"] = "none";
+	if (record.lifecycle === "active") {
+		if (decision.unresolved_user_decision_ids.length > 0) {
+			nextObligation = "resolve_user_decision";
+		} else if (decision.replan_required_ids.length > 0) {
+			nextObligation = "revise_intent";
+		} else if (decision.blocking_finding_ids.length > 0 || decision.independence_violations.length > 0) {
+			nextObligation = "resolve_findings";
+		} else if (record.artifact_state === "active") {
+			nextObligation = "submit_assurance";
+		} else if (decision.missing_acceptance_ids.length > 0 || decision.missing_approval_kinds.includes("qa")) {
+			nextObligation = "run_qa";
+		} else if (decision.missing_approval_kinds.includes("review")) {
+			nextObligation = "run_review";
+		} else if (decision.missing_approval_kinds.includes("user")) {
+			nextObligation = "authorize_user";
+		} else if (decision.complete) {
+			nextObligation = "complete";
+		}
+	}
+	return {
+		contract: "assurance_kernel/projection/v3",
+		task_id: record.task_id,
+		intent_revision: record.intent_snapshot.revision,
+		lifecycle: record.lifecycle,
+		artifact_state: record.artifact_state,
+		blocked,
+		next_obligation: nextObligation,
+		...decision,
+	};
+}

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

@@ -0,0 +1,194 @@
+// P2B0 canary enrollment core. NOT exported from kernel/index.ts.
+// Atomically creates TaskRecord v3 + workspace working claim + backend claim
+// for one confirmed canary task. Requires a valid EnrollmentCapability.
+// No CLI, runtime route, or production issuer exists in P2B0.
+
+import { canonicalIntentHash, readTaskIntent } from "./intent";
+import {
+	type EnrollmentAuthorityRegistry,
+	type EnrollmentCapabilityBinding,
+} from "./enrollment_authority";
+import { readTaskTombstone, type BackendClaim } from "./backend_claim";
+import { preparePiCanary } from "./pi_canary_prepare";
+import {
+	commitEnrollmentLocked,
+	readTaskRecordRaw,
+	readWorkspaceStateRaw,
+	withKernelStoreLock,
+} from "./storage";
+import type { TaskRecordV3, WorkspaceStateLike } from "./types";
+
+export interface EnrollCanaryInput {
+	task_id: string;
+	intent_path: string;
+	intent_revision: number;
+	preparation_digest: string;
+	capability: object;
+	capability_binding: EnrollmentCapabilityBinding;
+	now: string;
+}
+
+export interface EnrollCanaryResult {
+	record: TaskRecordV3;
+	backend_claim: BackendClaim;
+	workspace: { revision: string; state: WorkspaceStateLike };
+}
+
+function buildTaskRecordV3(
+	input: EnrollCanaryInput,
+	intent: Awaited<ReturnType<typeof readTaskIntent>>,
+): TaskRecordV3 {
+	return {
+		contract: "assurance_kernel/task_record/v3",
+		task_id: input.task_id,
+		intent_snapshot: intent.intent,
+		intent_ref: {
+			path: input.intent_path,
+			content_hash: intent.content_hash,
+		},
+		lifecycle: "active",
+		artifact_state: "active",
+		baseline: intent.content_hash,
+		attestations: [],
+		findings: [],
+		history: [],
+	};
+}
+
+/**
+ * Rehearsal: validates every precondition and returns evidence, but writes
+ * nothing and never consumes the capability.
+ */
+export function runEnrollmentRehearsal(
+	root: string,
+	input: EnrollCanaryInput,
+	capability: object,
+	registry: EnrollmentAuthorityRegistry,
+): {
+	rehearsed: boolean;
+	writes_performed: boolean;
+	evidence: {
+		contract: "assurance_kernel/enrollment_rehearsal/v1";
+		task_id: string;
+		outcome: "ready" | "not_ready";
+		blockers: string[];
+		generated_at: string;
+	};
+} {
+	const blockers: string[] = [];
+	const result = {
+		rehearsed: true,
+		writes_performed: false,
+		evidence: {
+			contract: "assurance_kernel/enrollment_rehearsal/v1" as const,
+			task_id: input.task_id,
+			outcome: "ready" as "ready" | "not_ready",
+			blockers,
+			generated_at: input.now,
+		},
+	};
+	try {
+		// capability inspect (does not consume)
+		registry.inspect(capability, input.capability_binding);
+	} catch (error) {
+		blockers.push(`capability: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	withKernelStoreLock(root, () => {
+		const tombstone = readTaskTombstone(root, input.task_id);
+		if (tombstone) {
+			blockers.push("task tombstone exists; same-task re-enrollment is forbidden");
+		} else {
+			const current = readTaskRecordRaw(root, input.task_id);
+			if (current.record) blockers.push("task record already exists");
+		}
+		const workspace = readWorkspaceStateRaw(root);
+		if (workspace.state.current_working !== null)
+			blockers.push(`workspace already owned by ${workspace.state.current_working}`);
+	});
+	try {
+		readTaskIntent(root, input.task_id);
+	} catch (error) {
+		blockers.push(`intent: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	result.evidence.outcome = blockers.length === 0 ? "ready" : "not_ready";
+	return result;
+}
+
+/**
+ * Atomic canary enrollment. Runs inside the same store lock as v1/v2
+ * transactions; consumes the capability only after every precondition
+ * passes, immediately before writing the enrollment marker.
+ */
+export function enrollCanaryTask(
+	root: string,
+	input: EnrollCanaryInput,
+	registry: EnrollmentAuthorityRegistry,
+): EnrollCanaryResult {
+	const validated = registry.inspect(input.capability, input.capability_binding);
+	if (validated.task_id !== input.task_id)
+		throw new Error("enrollment capability task mismatch");
+
+	// v4 storage retirement: the capability is bound to the preparation
+	// digest computed from Kernel owners only. Recompute it inside the store
+	// lock and reject if the owner set changed since the confirmation.
+	const recomputed = preparePiCanary(root, { task_id: input.task_id, now: input.now });
+	if (recomputed.digest !== input.preparation_digest)
+		throw new Error("enrollment preparation digest mismatch");
+
+	return withKernelStoreLock(root, () => {
+		const tombstone = readTaskTombstone(root, input.task_id);
+		if (tombstone)
+			throw new Error(
+				`task ${input.task_id} is terminal; same-task re-enrollment is forbidden`,
+			);
+		const current = readTaskRecordRaw(root, input.task_id);
+		if (current.record)
+			throw new Error(`task ${input.task_id} already has a TaskRecord`);
+		const workspace = readWorkspaceStateRaw(root);
+		if (workspace.state.current_working !== null)
+			throw new Error(`workspace is already owned by ${workspace.state.current_working}`);
+
+		// fresh secure intent reread inside the lock
+		const intent = readTaskIntent(root, input.task_id);
+		if (intent.intent.revision !== input.intent_revision)
+			throw new Error("intent revision mismatch");
+
+		// consume immediately before the marker write
+		registry.consume(input.capability, input.capability_binding);
+
+		const record = buildTaskRecordV3(input, intent);
+		const nextWorkspace: WorkspaceStateLike = {
+			...workspace.state,
+			current_working: input.task_id,
+		};
+		const claim: BackendClaim = {
+			contract: "assurance_kernel/backend_claim/v2",
+			backend: "kernel",
+			task_id: input.task_id,
+			intent_revision: input.intent_revision,
+			intent_content_hash: intent.content_hash,
+			enrollment_event_id: `enroll-${input.task_id}-${input.now}`,
+			lifecycle_status: "active",
+			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: current.revision,
+				next_record_content: `${JSON.stringify(record, null, 2)}\n`,
+				expected_workspace_hash: workspace.revision,
+				next_workspace_content: `${JSON.stringify(nextWorkspace, null, 2)}\n`,
+			},
+			claim as unknown as Record<string, unknown>,
+		);
+		return {
+			record: mutation.record,
+			backend_claim: claim,
+			workspace: { revision: "", state: mutation.workspace },
+		};
+	});
+}

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

@@ -0,0 +1,123 @@
+// P2B1 enrollment authority. NOT exported from kernel/index.ts.
+// Explicit registry factory: each registry owns its WeakMap; capabilities are
+// only recognized by the registry that issued them. No module-level singleton.
+// The production registry is created only inside the Pi extension activation
+// closure; tests create isolated registries via the fixture seam.
+
+import { MUTATION_AUTHORITY_CAPABILITY_BRAND } from "./types";
+
+export const ENROLLMENT_CAPABILITY_BRAND = Symbol.for("assurance-kernel.enrollment-capability-brand");
+
+export interface EnrollmentCapabilityBinding {
+	task_id: string;
+	intent_path: string;
+	intent_revision: number;
+	intent_content_hash: string;
+	preparation_digest: string;
+	actor_id: string;
+	confirmation_ref: string;
+	expires_at: string;
+	nonce: string;
+}
+
+interface EnrollmentCapabilityState extends EnrollmentCapabilityBinding {
+	issued_at: string;
+	consumed: boolean;
+}
+
+export interface ValidatedEnrollment {
+	task_id: string;
+	intent_path: string;
+	intent_revision: number;
+	intent_content_hash: string;
+	preparation_digest: string;
+	actor_id: string;
+	confirmation_ref: string;
+	issued_at: string;
+	expires_at: string;
+	nonce: string;
+}
+
+export interface EnrollmentAuthorityRegistry {
+	readonly brand: symbol;
+	/** Issue one capability bound to an exact binding. Library primitive. */
+	issue(binding: EnrollmentCapabilityBinding, issuedAt?: string): object;
+	inspect(capability: object, expected: EnrollmentCapabilityBinding, now?: number): ValidatedEnrollment;
+	consume(capability: object, expected: EnrollmentCapabilityBinding, now?: number): ValidatedEnrollment;
+	isConsumed(capability: object): boolean;
+}
+
+export function createEnrollmentAuthorityRegistry(): EnrollmentAuthorityRegistry {
+	const states = new WeakMap<object, EnrollmentCapabilityState>();
+	const brand = Symbol.for("assurance-kernel.enrollment-capability-registry");
+
+	function isEnrollmentCapability(value: unknown): value is object {
+		return (
+			!!value &&
+			typeof value === "object" &&
+			(value as Record<symbol, unknown>)[ENROLLMENT_CAPABILITY_BRAND] === true &&
+			(value as Record<symbol, unknown>)[brand] === true
+		);
+	}
+
+	function stateOf(capability: object): EnrollmentCapabilityState {
+		const state = states.get(capability);
+		if (!state) throw new Error("enrollment capability is not recognized by this registry");
+		return state;
+	}
+
+	return {
+		brand,
+		issue(binding: EnrollmentCapabilityBinding, issuedAt = new Date().toISOString()): object {
+			const missing: string[] = [];
+			for (const [key, value] of Object.entries(binding)) {
+				if (value === undefined || value === null || value === "") missing.push(key);
+			}
+			if (missing.length > 0)
+				throw new Error(`enrollment capability binding is incomplete: ${missing.join(", ")}`);
+			if (Number.isNaN(Date.parse(binding.expires_at)) || Date.parse(binding.expires_at) <= Date.parse(issuedAt))
+				throw new Error("enrollment capability must have a future expiry");
+			const capability = Object.freeze(
+				Object.defineProperties(
+					{},
+					{
+						[ENROLLMENT_CAPABILITY_BRAND]: { value: true, enumerable: false, writable: false, configurable: false },
+						[brand]: { value: true, enumerable: false, writable: false, configurable: false },
+					},
+				),
+			);
+			states.set(capability, { ...binding, issued_at: issuedAt, consumed: false });
+			return capability;
+		},
+		inspect(capability: object, expected: EnrollmentCapabilityBinding, now = Date.now()): ValidatedEnrollment {
+			if (!isEnrollmentCapability(capability)) throw new Error("enrollment capability required");
+			const state = stateOf(capability);
+			if (state.consumed) throw new Error("enrollment capability already consumed");
+			if (Date.parse(state.expires_at) <= now) throw new Error("enrollment capability has expired");
+			for (const key of Object.keys(expected) as Array<keyof EnrollmentCapabilityBinding>) {
+				if (state[key] !== expected[key])
+					throw new Error(`enrollment capability ${key} mismatch`);
+			}
+			return {
+				task_id: state.task_id,
+				intent_path: state.intent_path,
+				intent_revision: state.intent_revision,
+				intent_content_hash: state.intent_content_hash,
+				preparation_digest: state.preparation_digest,
+				actor_id: state.actor_id,
+				confirmation_ref: state.confirmation_ref,
+				issued_at: state.issued_at,
+				expires_at: state.expires_at,
+				nonce: state.nonce,
+			};
+		},
+		consume(capability: object, expected: EnrollmentCapabilityBinding, now = Date.now()): ValidatedEnrollment {
+			const validated = this.inspect(capability, expected, now);
+			stateOf(capability).consumed = true;
+			return validated;
+		},
+		isConsumed(capability: object): boolean {
+			return stateOf(capability).consumed;
+		},
+	};
+}

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

@@ -0,0 +1,29 @@
+export * from "./types";
+export * from "./intent";
+export * from "./validation";
+export * from "./completion";
+export * from "./legacy";
+// v4 storage retirement: the v1 TaskRecord storage entry points are no
+// longer part of the production kernel surface. Only the v2 store read/commit
+// primitives (used by enrollment/rehearsal/audit) remain exported from
+// ./storage; the v1 writer/reader names are absent.
+export {
+	readWorkspaceStateRaw,
+	readTaskRecordRaw,
+	readTaskRecord,
+	readSecureProjectFile,
+	commitTaskRecordLocked,
+	withKernelStoreLock,
+	serializeWorkspace,
+	revisionForContent,
+	appendJournalEntry,
+	KernelStoreSecurityError,
+	setAfterTaskTransactionWriteForTest,
+} from "./storage";
+export {
+	reduceTask,
+	canonicalRecordHash,
+	actionFingerprint,
+	recordedActionFingerprint,
+	isReducedMutation,
+} from "./reducer";