immune-brain 2.8.3 → 3.0.2

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

@@ -15,6 +15,8 @@ import {
 	KernelStoreSecurityError,
 	appendJournalEntry,
 	readSecureProjectFile,
+	readTaskRecordRaw,
+	readWorkspaceStateRaw,
 	type JournalEntry,
 	type JournalReasonCode,
 	type TaskPhase,
@@ -23,7 +25,12 @@ import {
 	INTENT_MAX_BYTES,
 	canonicalIntentHash,
 	parseTaskIntentV1,
+	RISK_FLOOR_SCOPE_PREFIXES,
 } from "../kernel/intent";
+import { projectTask, resolveProjectedRisk } from "../kernel/completion";
+import { deriveAssuranceAuthorization } from "../kernel/assurance_projection";
+import { taskDiffIdentity, taskRevisionIdentity } from "../workspace_scope";
+import type { TaskIntentV1, TaskRisk } from "../kernel/types";
 import {
 	canonicalDescriptorBytes,
 	parseVerificationDescriptor,
@@ -152,6 +159,202 @@ function runStatus(root: string): KernelExecution {
 	}
 }
 
+const UNOBSERVABLE = {
+	capability: "unobservable",
+	rehearsal: "unobservable",
+	cas_holder: "unobservable",
+} as const;
+
+const RISK_ORDER: Record<TaskRisk, number> = {
+	routine: 0,
+	material: 1,
+	critical: 2,
+};
+
+function matchingFloorEntries(intent: TaskIntentV1): string[] {
+	return intent.scope_hint.filter((entry) => {
+		try {
+			const trial = parseTaskIntentV1({
+				contract: intent.contract,
+				task_id: intent.task_id,
+				goal: intent.goal,
+				acceptance: intent.acceptance,
+				scope_hint: [entry],
+				risk: "routine",
+				revision: intent.revision,
+				owner: "user",
+			});
+			return trial.risk !== "routine";
+		} catch {
+			return false;
+		}
+	});
+}
+
+function readWorkspaceOwner(root: string): string | null {
+	try {
+		const raw = JSON.parse(readSecureProjectFile(root, ".imm/state/workspace.json")) as {
+			current_working?: unknown;
+		};
+		return typeof raw.current_working === "string" ? raw.current_working : null;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * `inspect --json` is a read-only Inspect Projection. It never journals,
+ * never takes a Kernel store lock, and never becomes authority.
+ */
+function runInspect(root: string): KernelExecution {
+	try {
+		const layout = inspectStorageLayout(root);
+		const claim = readBackendClaim(root);
+		const workspace = readWorkspaceOwner(root);
+		const kernel = {
+			claim: claim
+				? {
+						task_id: claim.task_id,
+						lifecycle_status: claim.lifecycle_status,
+					}
+				: null,
+			workspace: { current_working: workspace },
+		};
+		const idleRisk = {
+			declared: null as TaskRisk | null,
+			resolved: null as TaskRisk | null,
+			floor_prefixes: [...RISK_FLOOR_SCOPE_PREFIXES],
+			floor_applied: false,
+			matching_scope_entries: [] as string[],
+		};
+		const ok = layout.layout === "ready" || layout.layout === "migration_uncommitted";
+		if (!claim || !ok || layout.layout !== "ready") {
+			return {
+				result: jsonResult({
+					contract: "assurance_kernel/inspect/v1",
+					layout,
+					kernel,
+					assurance: null,
+					risk: idleRisk,
+					unobservable: UNOBSERVABLE,
+				}),
+				journal: journalFor(
+					"inspect",
+					null,
+					ok ? "ok" : "escalated",
+					layout.layout === "ready" ? "command_ok" : "source_invalid",
+					null,
+					layout.reason,
+				),
+			};
+		}
+		let declared: TaskRisk;
+		let intent: TaskIntentV1;
+		try {
+			const raw = JSON.parse(
+				readSecureProjectFile(root, `docs/plans/${claim.task_id}.intent.json`),
+			) as { risk?: unknown };
+			if (raw.risk !== "routine" && raw.risk !== "material" && raw.risk !== "critical")
+				throw new Error(`intent.risk is unreadable for ${claim.task_id}`);
+			declared = raw.risk;
+			intent = parseTaskIntentV1(raw);
+		} catch (error) {
+			return sourceFailure("inspect", error);
+		}
+		let recordRead: ReturnType<typeof readTaskRecordRaw>;
+		try {
+			recordRead = readTaskRecordRaw(root, claim.task_id);
+		} catch (error) {
+			return sourceFailure("inspect", error);
+		}
+		if (!recordRead.record) {
+			return {
+				result: errorResult(
+					"source_read_failed",
+					`task ${claim.task_id} has no TaskRecord`,
+					1,
+				),
+				journal: journalFor(
+					"inspect",
+					null,
+					"rejected",
+					"source_read_failed",
+					claim.task_id,
+					"Resolve the claimed TaskRecord before retrying inspect.",
+				),
+			};
+		}
+		const record = recordRead.record;
+		const workspaceState = readWorkspaceStateRaw(root);
+		let identity;
+		try {
+			identity =
+				record.contract === "assurance_kernel/task_record/v4"
+					? taskRevisionIdentity(root, intent.scope_hint, record.git_base_head)
+					: taskDiffIdentity(root, intent.scope_hint);
+		} catch (error) {
+			return sourceFailure("inspect", error);
+		}
+		const diffHash = identity.diff_hash;
+		const changedPaths = identity.changed_paths;
+		const decision = projectTask(intent, record, diffHash, record.intent_ref.content_hash, changedPaths);
+		const openUserDecisionCount = record.findings.filter(
+			(finding) => finding.kind === "unresolved_user_decision" && finding.status === "open",
+		).length;
+		const resolved = resolveProjectedRisk(intent, changedPaths);
+		return {
+			result: jsonResult({
+				contract: "assurance_kernel/inspect/v1",
+				layout,
+				kernel,
+				assurance: {
+					contract: "assurance_kernel/assurance_projection/v1",
+					task_id: claim.task_id,
+					error: null,
+					claim: kernel.claim,
+					projection: {
+						record_revision: recordRead.revision,
+						workspace_revision: workspaceState.revision,
+						intent_revision: intent.revision,
+						intent_content_hash: record.intent_ref.content_hash,
+						diff_hash: diffHash,
+						lifecycle: record.lifecycle,
+						artifact_state: record.artifact_state,
+						risk: resolveProjectedRisk(intent, changedPaths),
+						next_obligation: decision.next_obligation,
+						fresh_acceptance_ids: decision.fresh_acceptance_ids,
+						missing_acceptance_ids: decision.missing_acceptance_ids,
+						stale_attestation_ids: decision.stale_attestation_ids,
+						fresh_approval_kinds: [],
+						missing_approval_kinds: decision.missing_approval_kinds,
+						blocking_finding_ids: decision.blocking_finding_ids,
+						unresolved_user_decision_ids: decision.unresolved_user_decision_ids,
+						replan_required_ids: decision.replan_required_ids,
+						independence_violations: decision.independence_violations,
+						open_user_decision_count: openUserDecisionCount,
+						completion_ready: decision.complete,
+						authorization: deriveAssuranceAuthorization({
+							next_obligation: decision.next_obligation,
+							open_user_decision_count: openUserDecisionCount,
+						}),
+					},
+				},
+				risk: {
+					declared,
+					resolved,
+					floor_prefixes: [...RISK_FLOOR_SCOPE_PREFIXES],
+					floor_applied: RISK_ORDER[resolved] > RISK_ORDER[declared],
+					matching_scope_entries: matchingFloorEntries(intent),
+				},
+				unobservable: UNOBSERVABLE,
+			}),
+			journal: journalFor("inspect", null, "ok", "command_ok", claim.task_id, null),
+		};
+	} catch (error) {
+		return sourceFailure("inspect", error);
+	}
+}
+
 const INTENT_SIDECAR_PREFIX = "docs/plans/";
 const TASK_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 
@@ -1024,6 +1227,21 @@ function executeKernelCommand(args: string[], root: string): KernelExecution {
 			};
 		return runStatus(root);
 	}
+	if (command === "inspect") {
+		if (flags.length !== 1 || flags[0] !== "--json")
+			return {
+				result: errorResult("invalid_command", "inspect accepts only --json", 2),
+				journal: journalFor(
+					command,
+					null,
+					"rejected",
+					"invalid_command",
+					null,
+					"Run imm-kernel inspect --json.",
+				),
+			};
+		return runInspect(root);
+	}
 	if (command === "audit") {
 		if (args.length !== 2 || args[1] !== "--legacy")
 			return {
@@ -1097,7 +1315,7 @@ function executeKernelCommand(args: string[], root: string): KernelExecution {
 		return {
 			result: {
 				stdout:
-					"usage: imm-kernel status --json\n       imm-kernel audit --legacy\n       imm-kernel intent author <path> --stdin --json\n       imm-kernel intent validate <path> --json\n",
+					"usage: imm-kernel status --json\n       imm-kernel inspect --json\n       imm-kernel audit --legacy\n       imm-kernel intent author <path> --stdin --json\n       imm-kernel intent validate <path> --json\n",
 				stderr: "",
 				returncode: 0,
 			},
@@ -1106,7 +1324,7 @@ function executeKernelCommand(args: string[], root: string): KernelExecution {
 	return {
 		result: errorResult(
 			"invalid_command",
-			"usage: imm-kernel status --json | audit --legacy | intent author <path> --stdin --json | intent validate <path> --json",
+			"usage: imm-kernel status --json | inspect --json | audit --legacy | intent author <path> --stdin --json | intent validate <path> --json",
 
 			2,
 		),
@@ -1130,7 +1348,7 @@ export function runKernelCommand(
 	// subcommands (migrate/readiness/journal) are no-journal: they never
 	// append the friction journal. Only the fallback unknown-command path
 	// keeps journaling.
-	if (["intent", "status", "audit", "migrate", "readiness", "journal"].includes(args[0] ?? ""))
+	if (["intent", "status", "inspect", "audit", "migrate", "readiness", "journal"].includes(args[0] ?? ""))
 		return execution.result;
 	let warning = "";
 	try {

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

@@ -313,7 +313,7 @@ function parseIssues(raw: string): GithubIssue[] {
 				|| !Number.isSafeInteger(item.number)
 				|| typeof item.html_url !== "string"
 				|| typeof item.title !== "string"
-				|| typeof item.body !== "string"
+				|| (typeof item.body !== "string" && item.body !== null)
 				|| (item.state !== "open" && item.state !== "closed")
 			) throw new Error("gh returned a malformed Issue");
 			return {
@@ -321,7 +321,7 @@ function parseIssues(raw: string): GithubIssue[] {
 				number: item.number as number,
 				url: item.html_url,
 				title: item.title,
-				body: item.body,
+				body: typeof item.body === "string" ? item.body : "",
 				state: item.state,
 				state_reason: typeof item.state_reason === "string" ? item.state_reason.toLowerCase() : null,
 			};

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

@@ -8,6 +8,7 @@ import {
 	type MutationAuthorityRegistry,
 	type ValidatedAuthorityV2,
 } from "./authority_port";
+import { asTaskDiffSnapshot } from "./completion";
 import { canonicalIntentHash, readTaskIntent } from "./intent";
 import {
 	inspectIntentTokenPair,
@@ -38,6 +39,7 @@ import type {
 	StoredTaskMutationV3,
 	TaskAction,
 	TaskIntentV1,
+	TaskRecord,
 } from "./types";
 import { TASK_TOMBSTONE_CONTRACT, type TaskTombstone } from "./backend_claim";
 import { KernelInvariantError, parseTaskAction } from "./validation";
@@ -51,7 +53,7 @@ export interface ApplyTaskActionInput {
 	registry: MutationAuthorityRegistry;
 	capability?: MutationAuthorityCapabilityV2;
 	/** Trusted injected diff provider; the action's diff_hash is only an expectation. */
-	diffProvider: (root: string, intent: TaskIntentV1) => string;
+	diffProvider: (root: string, record: TaskRecord) => string | { diff_hash: string; changed_paths?: readonly string[] };
 	now?: number;
 	/**
 	 * Terminal commit mode: record + workspace + active-claim removal + task
@@ -89,10 +91,10 @@ export function applyTaskAction(
 		// closed before any token or capability is consumed.
 
 		// Trusted diff provider is the only diff authority.
-		const diffHash = diffProvider(root, current.record.intent_snapshot);
-		if (diffHash !== action.diff_hash)
+		const trustedDiff = asTaskDiffSnapshot(diffProvider(root, current.record));
+		if (trustedDiff.diff_hash !== action.diff_hash)
 			throw new KernelInvariantError([
-				`action diff_hash ${action.diff_hash} does not match the trusted diff ${diffHash}`,
+				`action diff_hash ${action.diff_hash} does not match the trusted diff ${trustedDiff.diff_hash}`,
 			]);
 
 		// Fresh secure reread of the sidecar inside the same lock.
@@ -173,7 +175,7 @@ export function applyTaskAction(
 					intent_content_hash: isRevisionAction
 						? freshRead.content_hash
 						: current.record.intent_ref.content_hash,
-					diff_hash: diffHash,
+					diff_hash: trustedDiff.diff_hash,
 					...(action.type === "request_rework"
 						? { findings_digest: findingsDigestV2(action.findings) }
 						: {}),
@@ -191,6 +193,7 @@ export function applyTaskAction(
 			current.record,
 			action,
 			inspectedAudit ? (inspectedAudit.audit as AuthorityAuditDescriptor) : null,
+			trustedDiff.changed_paths,
 		);
 		if (!isReducedMutation(mutation))
 			throw new KernelInvariantError(["reducer returned an invalid mutation"]);

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

@@ -13,8 +13,13 @@
 
 import { readBackendClaim, readTaskTombstone } from "./backend_claim";
 import { readTaskRecord, readAuditTaskPair, readWorkspaceStateRaw, reconcileKernelAuthority } from "./storage";
-import { projectTask } from "./completion";
-import type { AssuranceObligation, TaskIntentV1, TaskRecordV2, TaskRecordV3 } from "./types";
+import { projectTask, resolveProjectedRisk } from "./completion";
+import type { AssuranceObligation, TaskIntentV1, TaskRecord, TaskRecordV2 } from "./types";
+
+export interface TaskDiffSnapshot {
+	diff_hash: string;
+	changed_paths: readonly string[];
+}
 
 export interface AssuranceAuthorizationReadiness {
 	/**
@@ -127,7 +132,7 @@ function projectHistoricalTerminal(
 }
 
 function freshApprovalKinds(
-	record: TaskRecordV3,
+	record: TaskRecord,
 	currentIntentContentHash: string,
 	diffHash: string,
 ): string[] {
@@ -148,14 +153,20 @@ function freshApprovalKinds(
 }
 
 function projectFromRecord(
-	record: TaskRecordV3,
+	record: TaskRecord,
 	recordRevision: string,
 	workspaceRevision: string,
-	diffHash: string,
+	snapshot: TaskDiffSnapshot,
 ): AssuranceProjection {
 	const intent: TaskIntentV1 = record.intent_snapshot;
-	const decision = projectTask(intent, record, diffHash, record.intent_ref.content_hash);
-	const approvalKinds = freshApprovalKinds(record, record.intent_ref.content_hash, diffHash);
+	const decision = projectTask(
+		intent,
+		record,
+		snapshot.diff_hash,
+		record.intent_ref.content_hash,
+		snapshot.changed_paths,
+	);
+	const approvalKinds = freshApprovalKinds(record, record.intent_ref.content_hash, snapshot.diff_hash);
 	const openUserDecisionCount = record.findings.filter(
 		(finding) => finding.kind === "unresolved_user_decision" && finding.status === "open",
 	).length;
@@ -164,10 +175,10 @@ function projectFromRecord(
 		workspace_revision: workspaceRevision,
 		intent_revision: record.intent_snapshot.revision,
 		intent_content_hash: record.intent_ref.content_hash,
-		diff_hash: diffHash,
+		diff_hash: snapshot.diff_hash,
 		lifecycle: record.lifecycle,
 		artifact_state: record.artifact_state,
-		risk: intent.risk,
+		risk: resolveProjectedRisk(intent, snapshot.changed_paths),
 		next_obligation: decision.next_obligation,
 		fresh_acceptance_ids: decision.fresh_acceptance_ids,
 		missing_acceptance_ids: decision.missing_acceptance_ids,
@@ -203,7 +214,7 @@ function projectFromRecord(
 export async function projectAssurance(
 	root: string,
 	taskId: string,
-	diffProvider: (root: string, intent: { scope_hint?: unknown }) => string,
+	diffProvider: (root: string, record: TaskRecord) => TaskDiffSnapshot,
 ): Promise<AssuranceProjectionResult> {
 	const fail = (
 		error: string,
@@ -262,7 +273,7 @@ export async function projectAssurance(
 				task_id: taskId,
 				error: null,
 				claim: null,
-				projection: projectFromRecord(auditPair.record, auditPair.recordRevision, workspace.revision, diffProvider(root, auditPair.record.intent_snapshot)),
+				projection: projectFromRecord(auditPair.record, auditPair.recordRevision, workspace.revision, diffProvider(root, auditPair.record)),
 			};
 		}
 		if (read.record.task_id !== taskId)
@@ -270,13 +281,13 @@ export async function projectAssurance(
 		if (claim && read.record.lifecycle !== "active")
 			return fail(`terminal task ${taskId} has no matching tombstone proof`, claim);
 		const workspace = await readWorkspaceStateRaw(root);
-		const diffHash = diffProvider(root, read.record.intent_snapshot);
+		const snapshot = diffProvider(root, read.record);
 		return {
 			contract: "assurance_kernel/assurance_projection/v1",
 			task_id: taskId,
 			error: null,
 			claim,
-			projection: projectFromRecord(read.record, read.revision, workspace.revision, diffHash),
+			projection: projectFromRecord(read.record, read.revision, workspace.revision, snapshot),
 		};
 	} catch (error) {
 		return fail(error instanceof Error ? error.message : String(error));

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

@@ -1,10 +1,7 @@
 // P2B2 mutation authority consumption port. NOT exported from kernel/index.ts.
-// Registry/application pairing: each registry owns its capability state in a
-// closure-private WeakMap, and capabilities are only recognized by the
-// registry that issued them. No module-level singleton and no test issuer
-// exist here; the production registry/application pair is created inside the
-// Pi lifecycle extension activation closure, and tests issue capabilities
-// through tests/fixtures/mutation-authority-test-seam.ts.
+// Uses the shared capability registry factory; mutation-specific binding
+// validation, action digest, findings digest enforcement, and projection
+// remain here.
 
 import { createHash } from "node:crypto";
 
@@ -15,6 +12,7 @@ import {
 	type MutationAuthorityKind,
 	type TaskAction,
 } from "./types";
+import { createCapabilityRegistry } from "./capability_registry";
 
 export interface CapabilityBindingV2 {
 	authority_kind: MutationAuthorityKind;
@@ -31,11 +29,6 @@ export interface CapabilityBindingV2 {
 	findings_digest: string | null;
 }
 
-interface CapabilityState extends CapabilityBindingV2 {
-	issued_at: string;
-	consumed: boolean;
-}
-
 export interface ValidatedAuthorityV2 {
 	audit: AuthorityAuditDescriptor;
 	action_digest: string;
@@ -84,125 +77,95 @@ export function digestOfAction(action: TaskAction): string {
 }
 
 export function createMutationAuthorityRegistry(): MutationAuthorityRegistry {
-	const states = new WeakMap<object, CapabilityState>();
-	const brand = Symbol("assurance-kernel-mutation-authority-registry");
-
-	function isCapability(value: unknown): value is MutationAuthorityCapabilityV2 {
-		return (
-			!!value &&
-			typeof value === "object" &&
-			(value as Record<symbol, unknown>)[MUTATION_AUTHORITY_CAPABILITY_BRAND] === true &&
-			(value as Record<symbol, unknown>)[brand] === true
-		);
-	}
-
-	function stateOf(capability: MutationAuthorityCapabilityV2): CapabilityState {
-		const state = states.get(capability);
-		if (!state) throw new Error("authority capability is not recognized by this registry");
-		return state;
-	}
-
-	function validateBinding(binding: CapabilityBindingV2, issuedAt: string): void {
-		const missing: string[] = [];
-		for (const [key, value] of Object.entries(binding)) {
-			if (key === "findings_digest") continue;
-			if (value === undefined || value === null || value === "") missing.push(key);
-		}
-		if (missing.length > 0)
-			throw new Error(`authority capability binding is incomplete: ${missing.join(", ")}`);
-		if (binding.findings_digest !== null && !/^sha256:[a-f0-9]{64}$/.test(binding.findings_digest))
-			throw new Error("authority capability findings_digest must be a canonical sha256 hash");
-		if (Number.isNaN(Date.parse(binding.expires_at)) || Date.parse(binding.expires_at) <= Date.parse(issuedAt))
-			throw new Error("authority capability must have a future expiry");
-	}
-
-	return {
-		brand,
-		issue(binding: CapabilityBindingV2, issuedAt = new Date().toISOString()): MutationAuthorityCapabilityV2 {
-			validateBinding(binding, issuedAt);
-			const capability = Object.freeze(
-				Object.defineProperties(
-					{},
-					{
-						[MUTATION_AUTHORITY_CAPABILITY_BRAND]: {
-							value: true,
-							enumerable: false,
-							writable: false,
-							configurable: false,
-						},
-						[brand]: {
-							value: true,
-							enumerable: false,
-							writable: false,
-							configurable: false,
-						},
+	const inner = createCapabilityRegistry<CapabilityBindingV2, MutationAuthorityInspection, ValidatedAuthorityV2, MutationAuthorityCapabilityV2>(
+		MUTATION_AUTHORITY_CAPABILITY_BRAND,
+		{
+			validateBinding(binding, issuedAt) {
+				const missing: string[] = [];
+				for (const [key, value] of Object.entries(binding)) {
+					if (key === "findings_digest") continue;
+					if (value === undefined || value === null || value === "") missing.push(key);
+				}
+				if (missing.length > 0)
+					throw new Error(`authority capability binding is incomplete: ${missing.join(", ")}`);
+				if (binding.findings_digest !== null && !/^sha256:[a-f0-9]{64}$/.test(binding.findings_digest))
+					throw new Error("authority capability findings_digest must be a canonical sha256 hash");
+				if (Number.isNaN(Date.parse(binding.expires_at)) || Date.parse(binding.expires_at) <= Date.parse(issuedAt))
+					throw new Error("authority capability must have a future expiry");
+			},
+			validateAndProject(state, expected, now) {
+				if (Date.parse(state.expires_at) <= now)
+					throw new Error("authority capability has expired");
+				const actionDigest = digestOfAction(expected.action);
+				if (state.action_digest !== actionDigest)
+					throw new Error("authority capability action digest mismatch");
+				if (state.task_id !== expected.task_id)
+					throw new Error("authority capability task mismatch");
+				if (state.expected_record_hash !== expected.expected_record_hash)
+					throw new Error("authority capability record hash mismatch");
+				if (state.intent_revision !== expected.intent_revision)
+					throw new Error("authority capability intent revision mismatch");
+				if (state.intent_content_hash !== expected.intent_content_hash)
+					throw new Error("authority capability intent hash mismatch");
+				if (state.diff_hash !== expected.diff_hash)
+					throw new Error("authority capability diff hash mismatch");
+				if (expected.findings_digest !== undefined) {
+					if (state.findings_digest === null)
+						throw new Error("authority capability is not bound to findings");
+					if (state.findings_digest !== expected.findings_digest)
+						throw new Error("authority capability findings digest mismatch");
+				}
+				return {
+					audit: {
+						authority_kind: state.authority_kind,
+						actor_id: state.actor_id,
+						confirmation_ref: state.confirmation_ref,
+						issued_at: state.issued_at,
+						expires_at: state.expires_at,
 					},
-				),
-			) as MutationAuthorityCapabilityV2;
-			states.set(capability, {
-				...binding,
-				issued_at: issuedAt,
-				consumed: false,
-			});
-			return capability;
+					action_digest: actionDigest,
+					expected_record_hash: state.expected_record_hash,
+					intent_revision: state.intent_revision,
+					intent_content_hash: state.intent_content_hash,
+					diff_hash: state.diff_hash,
+					task_id: state.task_id,
+				};
+			},
 		},
+		"authority",
+	);
+
+	return {
+		brand: inner.brand,
+		issue: inner.issue.bind(inner),
 		inspect(
 			capability: MutationAuthorityCapabilityV2 | undefined,
 			expected: MutationAuthorityInspection,
 			now = Date.now(),
 		): ValidatedAuthorityV2 {
-			if (!capability || !isCapability(capability))
+			if (!capability)
 				throw new Error("privileged action requires an opaque authority capability");
-			const state = stateOf(capability);
-			if (state.consumed) throw new Error("authority capability is already consumed");
-			if (Date.parse(state.expires_at) <= now)
-				throw new Error("authority capability has expired");
-			const actionDigest = digestOfAction(expected.action);
-			if (state.action_digest !== actionDigest)
-				throw new Error("authority capability action digest mismatch");
-			if (state.task_id !== expected.task_id)
-				throw new Error("authority capability task mismatch");
-			if (state.expected_record_hash !== expected.expected_record_hash)
-				throw new Error("authority capability record hash mismatch");
-			if (state.intent_revision !== expected.intent_revision)
-				throw new Error("authority capability intent revision mismatch");
-			if (state.intent_content_hash !== expected.intent_content_hash)
-				throw new Error("authority capability intent hash mismatch");
-			if (state.diff_hash !== expected.diff_hash)
-				throw new Error("authority capability diff hash mismatch");
-			if (expected.findings_digest !== undefined) {
-				if (state.findings_digest === null)
-					throw new Error("authority capability is not bound to findings");
-				if (state.findings_digest !== expected.findings_digest)
-					throw new Error("authority capability findings digest mismatch");
+			try {
+				return inner.inspect(capability, expected, now);
+			} catch (err) {
+				if (err instanceof Error && err.message.includes("not recognized by this registry"))
+					throw new Error("privileged action requires an opaque authority capability");
+				throw err;
 			}
-			return {
-				audit: {
-					authority_kind: state.authority_kind,
-					actor_id: state.actor_id,
-					confirmation_ref: state.confirmation_ref,
-					issued_at: state.issued_at,
-					expires_at: state.expires_at,
-				},
-				action_digest: actionDigest,
-				expected_record_hash: state.expected_record_hash,
-				intent_revision: state.intent_revision,
-				intent_content_hash: state.intent_content_hash,
-				diff_hash: state.diff_hash,
-				task_id: state.task_id,
-			};
 		},
 		consume(
 			capability: MutationAuthorityCapabilityV2,
 			expected: MutationAuthorityInspection,
 			now = Date.now(),
 		): ValidatedAuthorityV2 {
-			const validated = this.inspect(capability, expected, now);
-			stateOf(capability).consumed = true;
-			return validated;
-		},
-		isConsumed(capability: MutationAuthorityCapabilityV2): boolean {
-			return stateOf(capability).consumed;
+			try {
+				return inner.consume(capability, expected, now);
+			} catch (err) {
+				if (err instanceof Error && err.message.includes("not recognized by this registry"))
+					throw new Error("privileged action requires an opaque authority capability");
+				throw err;
+			}
 		},
+		isConsumed: inner.isConsumed.bind(inner),
 	};
 }