immune-brain 3.6.3 → 3.6.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "immune-brain",
-  "version": "3.6.3",
+  "version": "3.6.5",
   "description": "Immune-Brain agent skill system",
   "publishConfig": {
     "access": "public",
@@ -30,13 +30,16 @@
   "scripts": {
     "changeset": "changeset",
     "changeset:version": "changeset version && bun scripts/build-claude-plugin.ts && bun scripts/plugin_versioning.ts validate",
-    "verify:release": "bun scripts/plugin_versioning.ts validate && bun scripts/build-claude-plugin.ts --check && bun scripts/sync-dist-docs.ts --check && bun test && npm pack --dry-run --ignore-scripts",
+    "verify:release": "bun scripts/plugin_versioning.ts validate && bun scripts/build-claude-plugin.ts --check && bun scripts/sync-dist-docs.ts --check && bun run typecheck && bun test && npm pack --dry-run --ignore-scripts",
     "changeset:publish": "bun run verify:release && changeset publish",
-    "release": "bun run changeset:publish"
+    "release": "bun run changeset:publish",
+    "typecheck": "tsc -p tsconfig.json"
   },
   "devDependencies": {
     "@changesets/changelog-github": "^0.5.2",
     "@changesets/cli": "^2.29.8",
+    "@types/bun": "^1.4.1",
+    "typescript": "5.7",
     "zod": "^4.1.8"
   },
   "peerDependencies": {

package/plugins/immune-brain/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "immune-brain",
-  "version": "3.6.3",
+  "version": "3.6.5",
   "description": "Immune-Brain Claude Code Host: native Enrollment, QA, Review, and Kernel settlement.",
   "author": {
     "name": "Immune-Brain Team"

package/plugins/immune-brain/.pi-extension/imm-canary-work.ts

@@ -56,6 +56,7 @@ import {
 	clearTerminalTaskRailOnInput,
 	loopResultDetails,
 	notifyOnce,
+	type UiContext,
 	presentTaskOverviewOverlay,
 	presentTaskRail,
 	presentTaskRailResult,
@@ -68,7 +69,7 @@ import {
 	type UserAttentionEventV1,
 	type UserAttentionReason,
 } from "./pi-canary-interaction";
-import { isToolFailureState, throwToolFailure } from "./pi-canary-tool-failure";
+import { isToolFailureState, throwToolFailure, type ToolFailureV1 } from "./pi-canary-tool-failure";
 import { taskDiffIdentity, taskRevisionIdentity, captureGitTaskSnapshot } from "../runtime/workspace_scope";
 import {
 	AssuranceProgression,
@@ -87,6 +88,7 @@ import {
 	type AssuranceProgressionPorts,
 	type AssuranceSubmitReviewResult,
 	type AssuranceVerdict,
+	type HostContext,
 	type QaVerificationProgress,
 	type SnapshotDescriptor,
 } from "./pi-canary-assurance-progression";
@@ -175,6 +177,7 @@ export type { AssuranceRole } from "./pi-canary-assurance";
 export type AuthorizeOperation =
 	| "approve-breaking-intent-revision"
 	| "resolve-user-decision"
+	| "authorize-rework"
 	| "stop";
 
 export interface SnapshotDescriptorInput {
@@ -262,11 +265,18 @@ type LoopToolAction =
 		context: Record<string, unknown>;
 	};
 
-export default function (
-	pi: ExtensionAPI,
+/**
+ * The exact ports object the Pi Assurance progression runs on.
+ *
+ * This lived as an inline literal inside the anonymous default export, so no
+ * test could ever obtain what production wires; every host adapter defect that
+ * reached a published plugin lived in this object. Exporting the factory lets
+ * the dual-host conformance suite drive the real thing.
+ */
+export function createPiAssuranceProgressionPorts(
 	dependencies: CanaryWorkExtensionDependencies = {},
-) {
-	const progression = new AssuranceProgression({
+): AssuranceProgressionPorts {
+	return {
 		projectTask: (root, taskId) => projectAssuranceState(root, taskId),
 		readTaskRecord: (root, taskId) => readTaskRecord(root, taskId),
 		readTaskIntent: (root, taskId) => readTaskIntent(root, taskId),
@@ -294,7 +304,14 @@ export default function (
 		qaOnAuthorityCommit: dependencies.qaOnAuthorityCommit,
 		qaAfterAuthorityCommit: dependencies.qaAfterAuthorityCommit,
 		qaJobTimeoutMs: dependencies.qaJobTimeoutMs,
-	} satisfies AssuranceProgressionPorts);
+	} satisfies AssuranceProgressionPorts;
+}
+
+export default function (
+	pi: ExtensionAPI,
+	dependencies: CanaryWorkExtensionDependencies = {},
+) {
+	const progression = new AssuranceProgression(createPiAssuranceProgressionPorts(dependencies));
 
 	let railContext: ExtensionContext | undefined;
 	const refreshTaskRail = async (ctx: ExtensionContext) => {
@@ -419,6 +436,7 @@ export default function (
 				Type.Object({ op: Type.Literal("advance_assurance") }),
 				Type.Object({ op: Type.Literal("submit_review"), verdict: Type.Unknown() }),
 				Type.Object({ op: Type.Literal("request_authorization") }),
+				Type.Object({ op: Type.Literal("request_stop") }),
 				Type.Object({ op: Type.Literal("repair_authority_state") }),
 				Type.Object({ op: Type.Literal("freeze_artifacts") }),
 				Type.Object({
@@ -514,8 +532,8 @@ export default function (
 					return failCanaryTool(taskId, action.op, "authority_conflict", "authority_repair_failed", message, blocked.next_action);
 				}
 			}
-			if (action.op === "advance_assurance" || action.op === "request_authorization" || action.op === "submit_review" || action.op === "approve_breaking_intent_revision") {
-				if ((action.op === "request_authorization" || action.op === "approve_breaking_intent_revision") && ctx.mode !== "tui")
+			if (action.op === "advance_assurance" || action.op === "request_stop" || action.op === "request_authorization" || action.op === "submit_review" || action.op === "approve_breaking_intent_revision") {
+				if ((action.op === "request_stop" || action.op === "request_authorization" || action.op === "approve_breaking_intent_revision") && ctx.mode !== "tui")
 					return failCanaryTool(taskId, action.op, "blocked", "tui_required", "literal-user authorization is TUI-only", "invoke the TUI Tool");
 				const result = action.op === "advance_assurance"
 					? await progression.advance(taskId, ctx, signal, (update) => {
@@ -531,7 +549,9 @@ export default function (
 								ctx,
 								(action as { next_intent?: unknown }).next_intent,
 							)
-							: await requestAuthorization(taskId, ctx);
+							: action.op === "request_stop"
+								? await authorizeExactOperation(taskId, "stop", { ...ctx, signal: signal && ctx.signal ? AbortSignal.any([signal, ctx.signal]) : signal ?? ctx.signal })
+								: await requestAuthorization(taskId, ctx);
 				const enriched = await enrichAssuranceResult(ctx, taskId, result as unknown as Record<string, unknown>);
 				presentTaskRailResult(ctx, taskId, enriched);
 				throwIfCanaryToolFailure(taskId, action.op, enriched);
@@ -680,7 +700,7 @@ export default function (
 	});
 
 	type AuthorizationOutcome =
-		| { state: "applied"; operation: AuthorizeOperation; lifecycle?: string }
+		| { state: "applied"; operation: AuthorizeOperation; lifecycle?: string; delivery_error?: string }
 		| { state: "cancelled"; operation: AuthorizeOperation; reason: string }
 		| { state: "blocked"; reason: string };
 
@@ -710,12 +730,15 @@ export default function (
 			let invocation: InvocationToken;
 			const authorizationGeneration = progression.sessionGenerationValue();
 			try {
+				if (operation === "stop" && progression.active(taskId)?.state === "running")
+					throw new Error("assurance operation is already running");
 				invocation = progression.openInvocation(taskId);
 		} catch (error) {
 			const reason = error instanceof Error ? error.message : String(error);
 			notifyOnce(ctx, `authorization-open:${taskId}:${reason}`, `cannot authorize ${taskId}: ${reason}`, "error");
 			return { state: "blocked", reason };
 		}
+		try {
 		const projection = await projectAssuranceState(ctx.cwd, taskId);
 		if (projection.error || !projection.claim) {
 			const reason = projection.error ?? "no active backend claim";
@@ -825,6 +848,9 @@ export default function (
 						`Resolution: ${userDecisionOperation.resolution}`,
 					]
 				: []),
+			...(operation === "authorize-rework"
+				? [`Replan boundaries: ${projection.projection.replan_required_ids.join(", ")}`]
+				: []),
 			...(nextIntent
 				? [
 						`Next Intent: rev ${nextIntent.revision} (${nextIntentHash})`,
@@ -872,16 +898,27 @@ export default function (
 			if (nextIntent) {
 				restoreStagedIntent();
 			}
-			if (operation !== "stop" && operation !== "approve-breaking-intent-revision")
+			if (
+				operation !== "stop" &&
+				operation !== "approve-breaking-intent-revision" &&
+				operation !== "authorize-rework"
+			)
 				await recordCancelledUserDecision(ctx, taskId, operation, snapshotDigestRef).catch(() => undefined);
 			progression.closeInvocation(invocation);
+			if (operation === "stop" && !ctx.signal?.aborted && !(error instanceof Error && error.name === "AbortError")) {
+				return { state: "blocked", reason: "native stop confirmation failed; retry request_stop in this Host" };
+			}
 			return { state: "cancelled", operation, reason: "confirmation aborted" };
 		}
-		if (!confirmed) {
+		if (!confirmed || ctx.signal?.aborted) {
 			if (nextIntent) {
 				restoreStagedIntent();
 			}
-			if (operation !== "stop" && operation !== "approve-breaking-intent-revision")
+			if (
+				operation !== "stop" &&
+				operation !== "approve-breaking-intent-revision" &&
+				operation !== "authorize-rework"
+			)
 				await recordCancelledUserDecision(ctx, taskId, operation, snapshotDigestRef).catch(() => undefined);
 			progression.closeInvocation(invocation);
 			return { state: "cancelled", operation, reason: "cancelled" };
@@ -894,7 +931,6 @@ export default function (
 			progression.closeInvocation(invocation);
 			return { state: "blocked", reason: "session changed; confirmation discarded" };
 		}
-		try {
 			// Linearization point: only this fresh affirmative continuation
 			// may mint/apply; timeout/cancel already won open -> cancelled.
 			try {
@@ -916,14 +952,16 @@ export default function (
 				};
 			}
 			const exactOperation = operation === "stop"
-				? { op: "stop" as const, reason: "literal user stopped task parked for replan" }
+				? { op: "stop" as const, reason: "literal user requested task stop" }
 				: operation === "approve-breaking-intent-revision"
 					? {
 							op: "approve_breaking_intent_revision" as const,
 							next_intent: nextIntent!,
 							next_intent_ref: nextIntentRef!,
 						}
-					: userDecisionOperation!;
+					: operation === "authorize-rework"
+						? { op: "authorize_rework" as const }
+						: userDecisionOperation!;
 				// The exact host-built operation is shared by capability digest and
 				// application payload; command arguments cannot inject authority fields.
 				try {
@@ -964,9 +1002,11 @@ export default function (
 						diffProvider: (root: string, record: NonNullable<TaskRecordRead["record"]>) => diffSnapshotOf(root, record),
 						now,
 					})) as unknown as { record: { lifecycle: string; artifact_state: string; intent_ref: { path: string }; intent_snapshot: { scope_hint: string[] } } };
+					if (exactOperation.op === "stop") progression.releaseStoppedReview(taskId);
 					if (
-						exactOperation.op === "stop"
-						|| exactOperation.op === "approve_breaking_intent_revision"
+						exactOperation.op === "stop" ||
+						exactOperation.op === "authorize_rework" ||
+						exactOperation.op === "approve_breaking_intent_revision"
 					) stagePlanningArtifactTransition(ctx.cwd, result.record);
 					return { state: "applied", operation, lifecycle: result.record.lifecycle };
 			} catch (error) {
@@ -978,6 +1018,13 @@ export default function (
 			}
 			} catch (error) {
 				const reason = error instanceof Error ? error.message : String(error);
+				if (operation === "stop") {
+					const terminal = await projectAssuranceState(ctx.cwd, taskId).catch(() => null);
+					if (terminal && !terminal.error && terminal.projection.lifecycle === "stopped") {
+						progression.releaseStoppedReview(taskId);
+						return { state: "applied", operation, lifecycle: "stopped", delivery_error: reason };
+					}
+				}
 				notifyOnce(ctx, `authorization-apply:${taskId}:${operation}:${reason}`, `authorize failed: ${reason}`, "error");
 				return { state: "blocked", reason };
 			} finally {
@@ -999,9 +1046,6 @@ export default function (
 			return { state: "blocked", reason: "TaskRecord changed while deriving authorization operation" };
 		const derived = deriveAuthorizationOperation({
 			readiness: projection.projection.authorization,
-			hasOpenReplanRequired: read.record.findings.some(
-				(finding) => finding.kind === "replan_required" && finding.status === "open",
-			),
 		});
 		if ("blocked" in derived) return { state: "blocked", reason: derived.blocked };
 		return authorizeExactOperation(taskId, derived.operation, ctx);
@@ -1014,15 +1058,14 @@ export default function (
 
 export type DerivedAuthorizationOperation =
 	| "resolve-user-decision"
-	| "stop";
+	| "authorize-rework";
 
 // Kernel projection is the sole source of authorization readiness.
 export function deriveAuthorizationOperation(input: {
 	readiness: AssuranceAuthorizationReadiness;
-	hasOpenReplanRequired?: boolean;
 }): { operation: DerivedAuthorizationOperation } | { blocked: string } {
-	if (input.hasOpenReplanRequired) return { operation: "stop" };
 	if (input.readiness.state === "resolve_user_decision") return { operation: "resolve-user-decision" };
+	if (input.readiness.state === "authorize_rework") return { operation: "authorize-rework" };
 	if (input.readiness.blocked) return { blocked: input.readiness.blocked };
 	return { blocked: "no unique host-derived authorization operation" };
 }
@@ -1196,7 +1239,7 @@ async function projectAssuranceState(root: string, taskId: string): Promise<Assu
  * Publish and prove the task-scoped synthetic revision for a v4 record. v3
  * records keep the legacy full-source bundle and return null here.
  */
-async function ensureTaskReviewRevision(
+export async function ensureTaskReviewRevision(
 	root: string,
 	taskId: string,
 	projection: AssuranceProjectionResult,
@@ -1221,7 +1264,11 @@ async function ensureTaskReviewRevision(
 		lifecycle: projection.projection.lifecycle,
 		artifactState: projection.projection.artifact_state,
 		risk: record.intent_snapshot.risk,
-		outcomes: reviewPreflightOutcomes(record.intent_snapshot.acceptance),
+		// The same outcomes the Review snapshot is built from. A preflight stand-in
+		// only matched the settled QA attestation because deterministic QA happens to
+		// write that exact summary, so the submit-time digest comparison held by
+		// coincidence rather than by construction.
+		outcomes: qaOutcomes(record),
 	});
 	return {
 		contract: "assurance_kernel/review_revision/v1",
@@ -1266,8 +1313,22 @@ async function reconcileReviewRevisionRefs(root: string): Promise<{ removed: str
 	return reconcileReviewRefs(root, live);
 }
 
+/**
+ * The coordinator port supplies a `HostContext`, which carries no UI. Pi hands
+ * its full `ExtensionContext` through at runtime, so the notice still reaches
+ * the user; a host that does not is left un-notified rather than throwing from
+ * inside an authority commit, where a notification has no authority anyway.
+ */
+function notifyHost(ctx: HostContext, key: string, message: string, level: "warning" | "error"): void {
+	const ui = (ctx as Partial<UiContext>).ui;
+	if (ui) notifyOnce({ ui }, key, message, level);
+}
+
 async function applyAssuranceVerdict(
-	ctx: ExtensionContext,
+	// The coordinator port hands these a `HostContext`, not the Pi
+	// `ExtensionContext`. Both functions only ever read `cwd`; declaring the
+	// wider host type made the port assignment unsound.
+	ctx: HostContext,
 	snapshot: SnapshotDescriptor,
 	verdict: AssuranceVerdict,
 	invocation: InvocationToken,
@@ -1352,7 +1413,7 @@ async function applyAssuranceVerdict(
 		const parked = (result.record as { findings?: Array<{ kind: string; status: string }> }).findings?.some(
 			(finding) => finding.kind === "replan_required" && finding.status === "open",
 		);
-		if (parked) notifyOnce(
+		if (parked) notifyHost(
 			ctx,
 			`rework-parked:${snapshot.task_id}`,
 			`rework applied: review parked for replan with ${findings.length} finding(s)`,
@@ -1431,10 +1492,17 @@ async function buildAssuranceSnapshot(
 		assertRunnerCompatible(descriptor, runner);
 		descriptors.set(item.id, descriptor);
 	}
-	const reviewRevision = record.record.contract === "assurance_kernel/task_record/v4"
+	// `git_base_head` is optional on the read shape because v3 records carry
+	// none, so the contract test alone does not prove it is present.
+	const baseHead = record.record.contract === "assurance_kernel/task_record/v4"
+		? record.record.git_base_head
+		: undefined;
+	if (record.record.contract === "assurance_kernel/task_record/v4" && !baseHead)
+		throw new Error("TaskRecord v4 is missing its Enrollment git_base_head");
+	const reviewRevision = baseHead
 		? {
 			contract: "assurance_kernel/review_revision_identity/v1" as const,
-			base_head: record.record.git_base_head,
+			base_head: baseHead,
 			review_commit: "",
 			review_tree: "",
 			manifest_digest: "",
@@ -1507,15 +1575,6 @@ async function buildAssuranceSnapshot(
 	};
 }
 
-function reviewPreflightOutcomes(
-	acceptance: Array<{ id: string }>,
-): Record<string, { status: "passed"; summary: string }> {
-	const summary = `host-attested QA: all ${acceptance.length} fixed verification descriptor(s) passed`;
-	return Object.fromEntries(
-		acceptance.map((item) => [item.id, { status: "passed" as const, summary }]),
-	);
-}
-
 function qaOutcomes(
 	record: NonNullable<TaskRecordRead["record"]>,
 ): Record<string, { status: "passed" | "failed" | "blocked"; summary: string }> {
@@ -1617,7 +1676,7 @@ function authorityPair(): Promise<{ registry: MutationAuthorityRegistry; app: Ca
 }
 
 async function executeOrdinaryOperation(
-	ctx: ExtensionContext,
+	ctx: HostContext,
 	input: { taskId: string; operation: { op: string; actor_id: string; next_intent?: unknown } },
 ): Promise<unknown> {
 	const { app } = await authorityPair();
@@ -1638,7 +1697,10 @@ async function executeOrdinaryOperation(
 			now: new Date().toISOString(),
 		});
 		if (operation.op === "freeze_artifacts" || operation.op === "stop")
-			stagePlanningArtifactTransition(ctx.cwd, result.record);
+			stagePlanningArtifactTransition(
+				ctx.cwd,
+				(result as { record: Parameters<typeof stagePlanningArtifactTransition>[1] }).record,
+			);
 		return result;
 	} catch (error) {
 		if (priorBytes) {
@@ -1741,18 +1803,24 @@ function toolResult(text: string, details?: Record<string, unknown>) {
  * Pi or Hyper adapter upgrade cycles pass a live nested-object Tool-call
  * probe at least 30 days apart.
  */
-function prepareActionArgs(args: unknown): unknown {
-	if (args === null || typeof args !== "object" || Array.isArray(args)) return args;
+/**
+ * Pre-schema normalizer: some hosts deliver `action` as a JSON string. The Pi
+ * runtime validates the returned value against the Tool schema immediately
+ * after this shim, so the parameter type is the schema's, not a claim this
+ * function makes about unvalidated input.
+ */
+function prepareActionArgs<Params>(args: unknown): Params {
+	if (args === null || typeof args !== "object" || Array.isArray(args)) return args as Params;
 	const input = args as Record<string, unknown>;
-	if (typeof input.action !== "string") return input;
+	if (typeof input.action !== "string") return input as Params;
 	try {
 		const parsed: unknown = JSON.parse(input.action);
 		if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed))
-			return { ...input, action: parsed };
+			return { ...input, action: parsed } as Params;
 	} catch {
 		// Unchanged input keeps the normal host schema error authoritative.
 	}
-	return input;
+	return input as Params;
 }
 
 function stagePlanningArtifactTransition(root: string, record: {
@@ -1785,7 +1853,9 @@ function stagePlanningArtifactTransition(root: string, record: {
 function failCanaryTool(
 	taskId: string,
 	operation: string,
-	state: "blocked" | "failed" | "authority_conflict" | "settlement_unknown",
+	// `review_preparation_failed` is a declared ToolFailureV1 state and a
+	// documented Loop recovery path; omitting it here made it unreportable.
+	state: ToolFailureV1["state"],
 	code: string,
 	message: string,
 	nextAction: string,

package/plugins/immune-brain/.pi-extension/pi-canary-interaction.ts

@@ -1,4 +1,4 @@
-import { DynamicBorder, type ExtensionAPI, type ExtensionContext, type Theme } from "@earendil-works/pi-coding-agent";
+import { DynamicBorder, type ExtensionAPI, type ExtensionContext, type Theme, type ThemeColor } from "@earendil-works/pi-coding-agent";
 import { Container, SelectList, Text, type Component, type SelectItem } from "@earendil-works/pi-tui";
 
 export const USER_ATTENTION_EVENT = "immune-brain:user-attention.v1" as const;
@@ -75,7 +75,7 @@ export interface AuthorityDialogOptions<T extends string> {
 }
 
 type EventPublisher = Pick<ExtensionAPI, "events">;
-type UiContext = Pick<ExtensionContext, "ui">;
+export type UiContext = Pick<ExtensionContext, "ui">;
 
 const terminalRailUis = new WeakSet<object>();
 const deliveredNotifications = new WeakMap<object, Set<string>>();
@@ -373,7 +373,9 @@ function emitAttention(pi: EventPublisher, event: UserAttentionEventV1): void {
 }
 
 function formatTaskRailState(state: TaskRailState, theme?: Theme): string {
-	const symbolAndColor: Record<TaskRailState, { symbol: string; color: string }> = {
+	// Typed as the theme's own colour union: a plain `string` here silently
+	// accepted a name the theme cannot resolve.
+	const symbolAndColor: Record<TaskRailState, { symbol: string; color: ThemeColor }> = {
 		Planning: { symbol: "●", color: "muted" },
 		"Approval required": { symbol: "▲", color: "accent" },
 		Working: { symbol: "●", color: "accent" },
@@ -383,7 +385,7 @@ function formatTaskRailState(state: TaskRailState, theme?: Theme): string {
 		Completed: { symbol: "✓", color: "success" },
 		Stopped: { symbol: "■", color: "muted" },
 	};
-	const cfg = symbolAndColor[state] ?? { symbol: "●", color: "dim" };
+	const cfg: { symbol: string; color: ThemeColor } = symbolAndColor[state] ?? { symbol: "●", color: "dim" };
 	if (!theme) return `${cfg.symbol} ${state}`;
 	return `${theme.fg(cfg.color, cfg.symbol)} ${theme.fg(cfg.color, state)}`;
 }

package/plugins/immune-brain/.pi-extension/runtime-stub.ts

@@ -1,8 +1,10 @@
 // Extension-local runtime adapter: type-isolated, executable stub.
 // Extensions import this file directly (relative path, resolvable by the Pi
 // extension loader); it forwards to the real Kernel modules via dynamic
-// import. The runtime source graph (with its pre-existing type debt) is never
-// type-checked from the extension.
+// import. Shared contracts are re-exported as types from the real Kernel
+// modules: `export type` is erased at compile time, so the extension still
+// carries no static runtime import, but a Kernel contract change now breaks
+// the extension's build instead of silently drifting from it.
 
 // --- Types (structural contracts, no runtime import) ---
 export interface EnrollmentCapabilityBinding {
@@ -178,40 +180,15 @@ export interface TaskRecordRead {
 
 // --- Assurance projection (host-neutral Kernel facts, not exported from the
 // public Kernel index) ---
-export interface AssuranceAuthorizationReadiness {
-	state: "resolve_user_decision" | "none";
-	blocked: string | null;
-}
-export interface AssuranceProjection {
-	record_revision: string;
-	workspace_revision: string;
-	intent_revision: number;
-	intent_content_hash: string;
-	diff_hash: string;
-	lifecycle: "active" | "done" | "stopped" | "";
-	artifact_state: "active" | "frozen" | "";
-	risk: "routine" | "material" | "critical" | "";
-	next_obligation: "resolve_findings" | "resolve_user_decision" | "revise_intent" | "submit_assurance" | "run_qa" | "run_review" | "complete" | "none";
-	fresh_acceptance_ids: string[];
-	missing_acceptance_ids: string[];
-	stale_attestation_ids: string[];
-	fresh_approval_kinds: string[];
-	missing_approval_kinds: string[];
-	blocking_finding_ids: string[];
-	unresolved_user_decision_ids: string[];
-	replan_required_ids: string[];
-	independence_violations: string[];
-	open_user_decision_count: number;
-	completion_ready: boolean;
-	authorization: AssuranceAuthorizationReadiness;
-}
-export interface AssuranceProjectionResult {
-	contract: "assurance_kernel/assurance_projection/v1";
-	task_id: string;
-	error: string | null;
-	claim: { task_id: string; lifecycle_status: string } | null;
-	projection: AssuranceProjection;
-}
+export type {
+	AssuranceAuthorizationReadiness,
+	AssuranceProjection,
+	AssuranceProjectionResult,
+} from "../runtime/kernel/assurance_projection";
+import type {
+	AssuranceAuthorizationReadiness,
+	AssuranceProjectionResult,
+} from "../runtime/kernel/assurance_projection";
 
 // --- Runtime forwarding (dynamic import keeps the graph out of tsc) ---
 function kernelPath(module: string): string {
@@ -349,12 +326,8 @@ export interface TaskIntentV1 {
 	acceptance: Array<{ id: string; assertion: string; verification: string }>;
 	scope_hint: string[];
 }
-export interface TaskIntentRead {
-	token: object;
-	content_hash: string;
-	intent: TaskIntentV1;
-	intent_ref: { path: string; revision: number; content_hash: string };
-}
+export type { ReadTaskIntentResult as TaskIntentRead } from "../runtime/kernel/intent";
+import type { ReadTaskIntentResult as TaskIntentRead } from "../runtime/kernel/intent";
 export interface WorkspaceRead {
 	revision: string;
 	state: { contract: string; current_working: string | null };
@@ -420,7 +393,7 @@ export async function projectAssurance(
 	},
 ): Promise<AssuranceProjectionResult> {
 	const mod = await import(/* @vite-ignore */ kernelPath("assurance_projection"));
-	return mod.projectAssurance(root, taskId, diffProvider) as unknown as AssuranceProjectionResult;
+	return mod.projectAssurance(root, taskId, diffProvider) as AssuranceProjectionResult;
 }
 
 export async function deriveAssuranceAuthorization(input: {
@@ -428,5 +401,5 @@ export async function deriveAssuranceAuthorization(input: {
 	open_user_decision_count: number;
 }): Promise<AssuranceAuthorizationReadiness> {
 	const mod = await import(/* @vite-ignore */ kernelPath("assurance_projection"));
-	return mod.deriveAssuranceAuthorization(input) as unknown as AssuranceAuthorizationReadiness;
+	return mod.deriveAssuranceAuthorization(input) as AssuranceAuthorizationReadiness;
 }