@iowarp/clio-coder 0.4.3 → 0.4.5

package/src/engine/loop-guard.ts

@@ -441,6 +441,8 @@ export interface CreateLoopGuardRegistrationOptions {
 	 * operator who can intervene; workers do not).
 	 */
 	toolCallCap?: number;
+	/** Observe estimated work without disabling tools; fault-loop detection remains active. */
+	toolBudgetAdvisory?: boolean;
 	/**
 	 * Worker only: successful exploration attempts allowed before a graceful,
 	 * text-only synthesis phase. Unlike {@link toolCallCap}, crossing this soft
@@ -523,8 +525,10 @@ export interface LoopGuardRegistration extends MiddlewareHookRegistration {
 
 export function createLoopGuardRegistration(options: CreateLoopGuardRegistrationOptions): LoopGuardRegistration {
 	const budget = options.turnBlockBudget ?? INTERACTIVE_LOOP_BLOCK_BUDGET;
-	const cap = options.toolCallCap;
+	const cap = options.toolBudgetAdvisory ? undefined : options.toolCallCap;
+	let advisoryEmitted = false;
 	let softLimit =
+		!options.toolBudgetAdvisory &&
 		options.toolCallSoftLimit !== undefined &&
 		Number.isSafeInteger(options.toolCallSoftLimit) &&
 		options.toolCallSoftLimit > 0 &&
@@ -561,7 +565,8 @@ export function createLoopGuardRegistration(options: CreateLoopGuardRegistration
 	 * has no cap and no bound here; it has an operator instead.
 	 */
 	let deniedAttempts = 0;
-	const denialBudget = cap === undefined ? undefined : Math.max(cap, WIDE_BATCH_DENIAL_FLOOR);
+	const denialBudget =
+		options.toolCallCap === undefined ? undefined : Math.max(options.toolCallCap, WIDE_BATCH_DENIAL_FLOOR);
 	const boundRunDenials = (
 		effects: ReadonlyArray<MiddlewareEffect>,
 		input: MiddlewareHookInput,
@@ -948,6 +953,18 @@ export function createLoopGuardRegistration(options: CreateLoopGuardRegistration
 				recordSuccessfulResult(input);
 				recordResultForStagnation(input);
 				const effects = [...crossArgumentResultEffects(input)];
+				if (
+					options.toolBudgetAdvisory &&
+					!advisoryEmitted &&
+					count >= (options.toolCallSoftLimit ?? options.toolCallCap ?? Infinity)
+				) {
+					advisoryEmitted = true;
+					effects.push({
+						kind: "annotate_tool_result",
+						message: `Advisory tool estimate reached (${count} calls). Reassess remaining work and finish the assignment; tools remain available. Explicit task requirements still apply.`,
+						severity: "warn",
+					});
+				}
 				if (
 					softReadReserveEntered &&
 					softLockout === null &&

package/src/engine/provider-diagnostics.ts

@@ -0,0 +1,129 @@
+import { randomUUID } from "node:crypto";
+import { closeSync, constants, fstatSync, openSync, writeFileSync } from "node:fs";
+import { isAbsolute } from "node:path";
+import type { Api, AssistantMessageEventStream, Model, StreamOptions } from "@earendil-works/pi-ai";
+import { findEngineEnvKeys } from "./env-api-keys.js";
+
+/** Process-owned opt-in reaches every native engine call, including prewarm and workers. */
+export function instrumentProviderCall<T extends StreamOptions>(
+	model: Model<Api>,
+	options: T | undefined,
+	invoke: (options: T | undefined) => AssistantMessageEventStream,
+): AssistantMessageEventStream {
+	let effective = options;
+	if (model.api === "anthropic-messages" && options?.cacheRetention === undefined) {
+		const retention = process.env.CLIO_CODER_ANTHROPIC_CACHE_RETENTION;
+		if (retention !== undefined && retention !== "") {
+			if (retention !== "none" && retention !== "short" && retention !== "long") {
+				throw new Error("CLIO_CODER_ANTHROPIC_CACHE_RETENTION must be none, short, or long");
+			}
+			effective = { ...options, cacheRetention: retention } as T;
+		}
+	}
+	const path = process.env.CLIO_CODER_PROVIDER_DUMP_PATH;
+	if (!path) return invoke(effective);
+	const sink = openDump(path);
+	const payloads: unknown[] = [];
+	const redact = diagnosticSerializer(model, effective);
+	const callId = randomUUID();
+	const onPayload = effective?.onPayload;
+	const instrumented = {
+		...effective,
+		onPayload: async (payload: unknown, currentModel: Model<Api>) => {
+			// Caller-owned thinking/tool/schema patches finish first. Snapshot now:
+			// providers and callbacks can retain or mutate their objects afterward.
+			const replacement = await onPayload?.(payload, currentModel);
+			try {
+				payloads.push(JSON.parse(redact(replacement === undefined ? payload : replacement)));
+			} catch {
+				payloads.push({ diagnosticError: "payload could not be serialized" });
+			}
+			return replacement;
+		},
+	} as T;
+	const finish = (terminal: { response: unknown } | { error: string }) => {
+		try {
+			writeFileSync(sink, `${redact({ callId, api: model.api, model: model.id, payloads, ...terminal })}\n`, "utf8");
+		} catch {
+			// Diagnostics must not turn a completed provider call into a retry or
+			// inject content into the ledger. Report only the sink failure category.
+			process.emitWarning("Provider diagnostic dump could not be written", { code: "CLIO_CODER_PROVIDER_DUMP_FAILED" });
+		} finally {
+			try {
+				closeSync(sink);
+			} catch {
+				process.emitWarning("Provider diagnostic dump could not be closed", { code: "CLIO_CODER_PROVIDER_DUMP_FAILED" });
+			}
+		}
+	};
+	try {
+		const stream = invoke(instrumented);
+		// result() observes the existing terminal promise; it never consumes the
+		// event iterator that the agent and durable ledger projection own.
+		void stream.result().then(
+			(response) => finish({ response }),
+			(error) => finish({ error: String(error) }),
+		);
+		return stream;
+	} catch (error) {
+		finish({ error: error instanceof Error ? error.message : String(error) });
+		throw error;
+	}
+}
+
+/** Refuse insecure existing files instead of silently changing their permissions. */
+function openDump(path: string): number {
+	if (!isAbsolute(path)) throw new Error("CLIO_CODER_PROVIDER_DUMP_PATH must be an absolute file path");
+	const fd = openSync(
+		path,
+		constants.O_WRONLY | constants.O_CREAT | constants.O_APPEND | constants.O_NOFOLLOW | constants.O_NONBLOCK,
+		0o600,
+	);
+	try {
+		const stat = fstatSync(fd);
+		if (
+			!stat.isFile() ||
+			(stat.mode & 0o777) !== 0o600 ||
+			(process.getuid !== undefined && stat.uid !== process.getuid())
+		) {
+			throw new Error("CLIO_CODER_PROVIDER_DUMP_PATH must be an operator-owned regular file with mode 0600");
+		}
+		return fd;
+	} catch (error) {
+		closeSync(fd);
+		throw error;
+	}
+}
+
+function diagnosticSerializer(model: Model<Api>, options: StreamOptions | undefined): (value: unknown) => string {
+	const secrets = new Set<string>();
+	const ambientKeys = (findEngineEnvKeys(model.provider, options?.env) ?? []).map(
+		(name) => options?.env?.[name] || process.env[name],
+	);
+	for (const key of [options?.apiKey, ...ambientKeys]) {
+		if (key && key !== "<authenticated>") secrets.add(key);
+	}
+	for (const headers of [options?.headers, model.headers]) {
+		for (const [key, value] of Object.entries(headers ?? {})) {
+			if (typeof value === "string" && value.length > 0 && /auth|api[-_]?key|cookie|token|secret/iu.test(key)) {
+				secrets.add(value);
+				const token = value.match(/^(?:Bearer|Basic)\s+(.+)$/iu)?.[1];
+				if (token) secrets.add(token);
+			}
+		}
+	}
+	return (value) => {
+		// This is a body-level diagnostic, never an HTTP/auth/options dump. Keep
+		// nested tool schemas intact, including tools with a parameter named headers.
+		const body =
+			typeof value === "object" && value !== null && !Array.isArray(value)
+				? Object.fromEntries(
+						Object.entries(value).filter(([key]) => !/^(?:headers|env|apiKey|api_key|authorization)$/iu.test(key)),
+					)
+				: value;
+		let serialized = JSON.stringify(body);
+		if (serialized === undefined) serialized = "null";
+		for (const secret of secrets) serialized = serialized.replaceAll(JSON.stringify(secret).slice(1, -1), "[REDACTED]");
+		return serialized;
+	};
+}

package/src/engine/provider-payload.ts

@@ -150,7 +150,9 @@ export function patchToolChoiceNamedPayload(
 			if (Object.keys(outputConfig).length > 0) patched.output_config = outputConfig;
 			else delete patched.output_config;
 		}
-		return { ...patched, tools, tool_choice: { type: "tool", name: toolName } };
+		// Keep the cacheable schema prefix intact. The request-level choice
+		// already identifies the required tool; narrowing changes it twice.
+		return { ...patched, tool_choice: { type: "tool", name: toolName } };
 	}
 	if (model.api === "google-generative-ai" || model.api === "google-vertex") {
 		if (!isRecord(payload.config) || payload.config.tools === undefined || payload.config.tools === null)

package/src/engine/worker-runtime.ts

@@ -215,6 +215,14 @@ function assistantMessageText(message: AgentMessage | undefined): string | null
  */
 function isTerminalAssistantMessage(message: AgentMessage | undefined): boolean {
 	if (!isAssistantMessage(message)) return false;
+	// pi refuses truncated tool calls and continues with their error results.
+	// That turn has no final artifact/report to repair yet.
+	if (
+		message.stopReason === "length" &&
+		Array.isArray(message.content) &&
+		message.content.some((block) => block.type === "toolCall")
+	)
+		return false;
 	return message.stopReason !== "toolUse" && message.stopReason !== "error";
 }
 
@@ -442,6 +450,7 @@ export function startWorkerRun(input: WorkerRunInput, emit: WorkerEventEmit): Wo
 	const loopGuardRegistration = createLoopGuardRegistration({
 		safety,
 		toolCallCap: workerBudget.hardCap,
+		toolBudgetAdvisory: workerBudget.mode === "advisory",
 		toolCallSoftLimit: workerBudget.toolCalls,
 		// A worker's blocks all land in one run-long bucket, so the bound on
 		// them is a statement about this run's length, not about a turn.
@@ -600,6 +609,7 @@ export function startWorkerRun(input: WorkerRunInput, emit: WorkerEventEmit): Wo
 		invokeOptions: () => ({
 			correlationId: `worker-model-round-${workerModelRound}`,
 			toolResultMaxBytes: workerSettings.context.toolResultMaxBytes,
+			supportsImages: model.input.includes("image"),
 			...(agentSkillPolicy ? { pendingSkillPolicy: agentSkillPolicy } : {}),
 		}),
 	});
@@ -724,8 +734,9 @@ export function startWorkerRun(input: WorkerRunInput, emit: WorkerEventEmit): Wo
 							stopAfterToolResultCallId = null;
 						}
 					}
-					const revisionToolsAvailable = resultContractRevisionActive && !synthesisToolLock;
-					// A repair without preauthorized growth remains terminal and text-only.
+					const revisionToolsAvailable =
+						(workerBudget.mode === "advisory" || resultContractRevisionActive) && !synthesisToolLock;
+					// Legacy enforced budgets need preauthorized growth to retain repair tools.
 					if (!revisionToolsAvailable) synthesisToolLock = true;
 					// Delivered as a paired tool exchange, never a user turn. Templates
 					// that key history rendering off the last `user` message re-render

package/src/engine/worker-tools.ts

@@ -114,7 +114,11 @@ export function createWorkerSafety(options: WorkerSafetyOptions = {}): SafetyCon
 		},
 		scopes: { readonly: READONLY_SCOPE, workspace: WORKSPACE_SCOPE, confirmed: CONFIRMED_SCOPE },
 		isSubset,
-		policy: { metadata: (posture) => policyEngine.metadata(posture) },
+		policy: {
+			metadata: (posture) => policyEngine.metadata(posture),
+			allowsObservationPath: (path) =>
+				policyEngine.evaluate({ tool: "read", args: { path } }).reasonCode !== "path-policy:zeroAccessPaths",
+		},
 		audit: { recordCount: () => 0 },
 	};
 }

package/src/entry/extension-reload.ts

@@ -125,6 +125,7 @@ export function createExtensionReloadCoordinator(deps: ExtensionReloadCoordinato
 			workspaceRoot: workspace,
 			...(captured !== null ? { capturedSources: captured } : {}),
 			recordReceipt: deps.recordReceipt,
+			report: deps.report,
 			...(deps.runCommand !== undefined ? { runCommand: deps.runCommand } : {}),
 			...(deps.now !== undefined ? { now: deps.now } : {}),
 		});

package/src/entry/orchestrator.ts

@@ -12,7 +12,7 @@ import { DEFAULT_DELEGATION_PERMISSION_TIMEOUT_MS } from "../core/defaults.js";
 import { loadDomains } from "../core/domain-loader.js";
 import type { SafeEventBus } from "../core/event-bus.js";
 import { expandInlineFileReferencesAsync } from "../core/file-references.js";
-import { setGitCommitAttributionEnabled } from "../core/git-commit-attribution.js";
+import { setCommitDecisionRefsProvider, setGitCommitAttributionEnabled } from "../core/git-commit-attribution.js";
 import { configureGuardrails, guardrailValuesFromSettings } from "../core/guardrails.js";
 import { HEADLESS_PERMISSION_DENIED_REASON } from "../core/headless-permission.js";
 import { rememberRecentModel } from "../core/recent-models.js";
@@ -37,6 +37,7 @@ import { getSharedBus } from "../core/shared-bus.js";
 import { isSkillActivation } from "../core/skill-activation.js";
 import { StartupTimer } from "../core/startup-timer.js";
 import { getTerminationCoordinator } from "../core/termination.js";
+import { captureProjectSurface, projectSurfaceTrustNotice } from "../core/workspace-trust.js";
 import { clioDataDir, clioStateDir } from "../core/xdg.js";
 import { renderAgentCatalogSectionsFromSpecs } from "../domains/agents/catalog.js";
 import type { AgentsContract } from "../domains/agents/contract.js";
@@ -157,12 +158,11 @@ import {
 import type { SchedulingContract } from "../domains/scheduling/contract.js";
 import { SchedulingDomainModule } from "../domains/scheduling/index.js";
 import type { CompactionCallObservation } from "../domains/session/compaction/compact.js";
-import { type CompactResult, compact } from "../domains/session/compaction/compact.js";
+import { type CompactInput, type CompactResult, compact } from "../domains/session/compaction/compact.js";
 import { collectSessionEntries } from "../domains/session/compaction/session-entries.js";
 import { estimateTokens } from "../domains/session/compaction/tokens.js";
-import { ceilChars } from "../domains/session/context-accounting.js";
 import type { SessionContract, SessionMeta } from "../domains/session/contract.js";
-import { createDecisionBoardStore } from "../domains/session/decision-board.js";
+import { activeDecisionRefs, createDecisionBoardStore } from "../domains/session/decision-board.js";
 import type { CompactionSummaryEntry, CompactionTrigger, SessionEntry } from "../domains/session/entries.js";
 import { SessionDomainModule } from "../domains/session/index.js";
 import {
@@ -178,6 +178,7 @@ import { createTaskBoardStore } from "../domains/session/task-board.js";
 import { filterEntriesToActivePath } from "../domains/session/tree/active-path.js";
 import { type ShareContract, ShareDomainModule } from "../domains/share/index.js";
 import { ToolchainDomainModule } from "../domains/toolchain/index.js";
+import { activeUserTaskAcceptance } from "../domains/user-tasks/active-acceptance.js";
 import { createUserTasksStore } from "../domains/user-tasks/store.js";
 import { type AcpSafeSettingsPatch, type AcpSafeSettingsSnapshot, serveClioAcpAgent } from "../engine/acp/server.js";
 import { createStdioServerTransport } from "../engine/acp/transport.js";
@@ -614,6 +615,7 @@ function agentRoleToolWarnings(providers: ProvidersContract, settings: Readonly<
 async function resolveCompactionModel(
 	settings: ClioSettings,
 	providers: ProvidersContract,
+	signal?: AbortSignal,
 ): Promise<CompactionResolution | null> {
 	const override = settings.context.compaction.model;
 	let targetId = settings.chat.target;
@@ -634,7 +636,7 @@ async function resolveCompactionModel(
 		wireModelId = selected.ref.model;
 	}
 	if (!targetId || !wireModelId) return null;
-	await prepareBackgroundModelMetadata(providers, targetId);
+	await prepareBackgroundModelMetadata(providers, targetId, signal);
 	const status = providers.list().find((entry) => entry.target.id === targetId);
 	if (!status?.available) {
 		throw new Error("context.compaction.model target is unavailable; check the selected target with clio-coder targets");
@@ -673,7 +675,7 @@ async function resolveCompactionModel(
 	applyModelCapabilityPatch(model, refined.capabilities);
 	let apiKey: string | undefined = LOCAL_API_KEY_FALLBACK;
 	if (targetRequiresAuth(route.target, route.runtime)) {
-		const auth = await providers.auth.resolveForTarget(route.target, route.runtime);
+		const auth = await providers.auth.resolveForTarget(route.target, route.runtime, signal ? { signal } : undefined);
 		if (!auth.available || !auth.apiKey) {
 			throw new Error(
 				"context.compaction.model authentication is unavailable; authenticate the selected target with clio-coder auth",
@@ -794,6 +796,8 @@ async function runCompactionFlow(
 	instructions?: string,
 	trigger?: CompactionTrigger,
 	observability?: BackgroundMemoryUsageSink,
+	budget?: Pick<CompactInput, "keepRecentTokens" | "preserveUserTurnId" | "skillContextState" | "signal">,
+	summarize?: CompactInput["summarize"],
 ): Promise<CompactResult | null> {
 	const meta = session.current();
 	if (!meta) {
@@ -805,8 +809,11 @@ async function runCompactionFlow(
 		session.current()?.id === meta.id && (session.tree(meta.id).leafId ?? undefined) === activeLeafTurnId;
 	const entries = filterEntriesToActivePath(readSessionEntriesForCompact(meta.id), activeLeafTurnId);
 	if (entries.length === 0) return null;
+	budget?.signal?.throwIfAborted();
 	const systemPrompt = await readCompactionSystemPrompt(settings.context.compaction.systemPrompt, meta.cwd);
-	const resolved = await resolveCompactionModel(settings, providers);
+	budget?.signal?.throwIfAborted();
+	const resolved = await resolveCompactionModel(settings, providers, budget?.signal);
+	budget?.signal?.throwIfAborted();
 	if (!resolved) {
 		throw new Error("no model configured; set chat.target + chat.model");
 	}
@@ -841,6 +848,8 @@ async function runCompactionFlow(
 	try {
 		result = await compact({
 			entries,
+			...budget,
+			...(summarize ? { summarize } : {}),
 			onCall: (call) => calls.push(call),
 			model: resolved.model,
 			...(systemPrompt !== undefined ? { systemPrompt } : {}),
@@ -858,6 +867,10 @@ async function runCompactionFlow(
 	} finally {
 		releaseEndpointSlot();
 	}
+	if (budget?.signal?.aborted) {
+		preserveCalls();
+		budget.signal.throwIfAborted();
+	}
 	if (!isOriginCurrent()) {
 		preserveCalls();
 		throw new Error("compaction session or branch changed; summary discarded and originating usage retained");
@@ -876,6 +889,8 @@ async function runCompactionFlow(
 		turnId: randomUUID(),
 		parentTurnId: result.firstKeptTurnId ?? null,
 		summary: result.summary,
+		...(result.skillContext ? { skillContext: result.skillContext } : {}),
+		...(result.userContext ? { userContext: result.userContext } : {}),
 		tokensBefore: result.tokensBefore,
 		firstKeptTurnId: result.firstKeptTurnId ?? "",
 		messagesSummarized: result.messagesSummarized,
@@ -939,17 +954,28 @@ export function createProductionAutoCompact(
 	getSettings: () => ClioSettings,
 	providers: ProvidersContract,
 	observability?: BackgroundMemoryUsageSink,
-): (instructions?: string, trigger?: CompactionTrigger) => Promise<CompactResult | null> {
-	return (instructions, trigger) =>
-		runCompactionFlow(session, getSettings(), providers, instructions, trigger, observability);
+	summarize?: CompactInput["summarize"],
+): (
+	instructions?: string,
+	trigger?: CompactionTrigger,
+	budget?: Pick<CompactInput, "keepRecentTokens" | "preserveUserTurnId" | "skillContextState" | "signal">,
+) => Promise<CompactResult | null> {
+	return (instructions, trigger, budget) =>
+		runCompactionFlow(session, getSettings(), providers, instructions, trigger, observability, budget, summarize);
 }
 
-function estimateTokensFromSummary(summary: string): number {
-	// Mirrors the rough byte/4 heuristic the rest of the compaction stack
-	// uses for unmeasured payloads. Kept inline because this is the only
-	// caller; pi-mono's token estimator is provider-specific and we do not
-	// have a model handle at the persistence layer.
-	return Math.max(1, ceilChars(summary.length));
+function estimateTokensFromSummary(result: CompactResult): number {
+	return estimateTokens({
+		kind: "compactionSummary",
+		turnId: "estimate",
+		parentTurnId: null,
+		timestamp: "",
+		summary: result.summary,
+		firstKeptTurnId: result.firstKeptTurnId ?? "",
+		tokensBefore: result.tokensBefore,
+		...(result.skillContext ? { skillContext: result.skillContext } : {}),
+		...(result.userContext ? { userContext: result.userContext } : {}),
+	});
 }
 
 /**
@@ -972,7 +998,7 @@ function estimateTokensFromSummary(summary: string): number {
 function estimateTokensAfterCompaction(entries: ReadonlyArray<SessionEntry>, result: CompactResult): number {
 	let droppedTokens = 0;
 	for (const entry of entries.slice(0, result.firstKeptEntryIndex)) droppedTokens += estimateTokens(entry);
-	const summaryTokens = estimateTokensFromSummary(result.summary);
+	const summaryTokens = estimateTokensFromSummary(result);
 	// The summary alone is the floor: a session whose dropped estimate exceeds
 	// the measured anchor must not report a negative or sub-summary context.
 	return Math.max(summaryTokens, result.tokensBefore - droppedTokens + summaryTokens);
@@ -1041,6 +1067,15 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 	termination.installSignalHandlers();
 
 	ensureClioState();
+	for (const surface of ["safety", "settings"] as const) {
+		const snapshot = captureProjectSurface(process.cwd(), surface);
+		if (snapshot.verdict === "trusted") continue;
+		for (const file of snapshot.files) {
+			if (file.text !== null || file.error !== undefined) {
+				bootStderr(`[clio-coder:trust] ${projectSurfaceTrustNotice(snapshot, file.path)}\n`);
+			}
+		}
+	}
 	sweepExpiredToolOffloads();
 	timer.mark("install check");
 
@@ -1499,6 +1534,7 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 	// different generation. The owner slot is anchored here, so user hooks
 	// keep evaluating after the guards and before the assessors below.
 	const hookReceiptLog = createHookReceiptLog({ persistPath: join(clioStateDir(), "hook-receipts.json") });
+	let bootHookNotices = true;
 	const extensionReload = createExtensionReloadCoordinator({
 		extensions,
 		middleware,
@@ -1506,10 +1542,13 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 		recordReceipt: (receipt) => hookReceiptLog.record(receipt),
 		report: (line) => {
 			if (!interactive) process.stderr.write(`${line}\n`);
+			else if (bootHookNotices) initialNotices.push(line);
+			else bus.emit(BusChannels.ExtensionsLoadIssue, { message: line });
 		},
 		onCommitted: (event) => bus.emit(BusChannels.ExtensionsReloaded, event),
 	});
 	extensionReload.applyBoot();
+	bootHookNotices = false;
 	termination.onDrain(() => hookReceiptLog.flush());
 	// Autonomy is hot-reloaded for interactive and headless admissions. ACP
 	// server prompts use the snapshot captured at session/new.
@@ -1550,6 +1589,7 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 	if (resources) {
 		middleware.registerHook(
 			createMarketplaceOfferRegistration({
+				interactive,
 				listInstalledSkillNames: () => resources.skills(process.cwd()).items.map((skill) => skill.name),
 				listMarketplaceEntries: () => discoverMarketplaceSkills({ cwd: process.cwd() }).skills,
 				installEntry: (entry, scope) => {
@@ -1627,6 +1667,9 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 			session.appendEntry(entry);
 		},
 	});
+	// Every Clio-spawned commit from this session is stamped with the decisions
+	// active on the board at spawn time, the same way it is stamped as assisted.
+	setCommitDecisionRefsProvider(() => activeDecisionRefs(decisionBoard.snapshot()));
 	// getSessionId alone never notices a /tree switch: it moves the active
 	// append point inside the same session, so the id-keyed cache above kept
 	// showing the abandoned branch's board (issue #94). SessionTurnSwitched is
@@ -1686,6 +1729,8 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 				}
 			: {}),
 		taskBoard,
+		decisionBoard,
+		getDecisionBoard: () => decisionBoard.snapshot(),
 		userTasks,
 		dispatch,
 		bus,
@@ -2016,6 +2061,8 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 				},
 				resolveRigor: () =>
 					resolveRigor({ cwd: process.cwd(), override: parseRigorOverride(process.env.CLIO_CODER_RIGOR) }),
+				readActiveAcceptance: (window) =>
+					activeUserTaskAcceptance(userTasks.snapshot(), taskBoard.snapshot(), session.current()?.id ?? null, window),
 				recordDecision: (record) => safety.audit.recordCompletionContract?.(record),
 			}),
 		);

package/src/interactive/chat-loop-messages.ts

@@ -162,10 +162,9 @@ export function isLengthStopAssistantMessage(message: AgentMessage | undefined):
 }
 
 /**
- * An aborted assistant message with no rendered content: empty text and no
- * structured tool call. This is what `agent.abort()` leaves behind when the
- * model is interrupted between deltas. The chat loop suppresses it after a
- * loop-guard interrupt has already written a durable closing turn.
+ * An aborted assistant message with no text, thinking, or structured tool
+ * call. Only a hollow abort needs a synthetic closing record; streamed
+ * thinking belongs to the same durable assistant as any partial answer.
  */
 export function isEmptyAbortedAssistantMessage(message: AgentMessage | undefined): boolean {
 	if (
@@ -179,9 +178,17 @@ export function isEmptyAbortedAssistantMessage(message: AgentMessage | undefined
 	}
 	if ((message as { stopReason?: unknown }).stopReason !== "aborted") return false;
 	if (extractText(message).trim().length > 0) return false;
+	if (extractThinking(message).trim().length > 0) return false;
 	return !hasStructuredToolCall(message);
 }
 
+/** Apply host cancellation provenance only to a structurally aborted message. */
+export function explainInterruptedAssistant(message: AgentMessage, reason: string | null): boolean {
+	if (reason === null || message.role !== "assistant" || message.stopReason !== "aborted") return false;
+	message.errorMessage = reason;
+	return true;
+}
+
 function lengthStopMetadata(message: AgentMessage): Record<string, unknown> {
 	const usage = (message as { usage?: unknown }).usage;
 	const metadata: Record<string, unknown> = {
@@ -497,6 +504,7 @@ export function assistantSessionPayload(
 		"model",
 		"responseModel",
 		"responseId",
+		"providerThinkingLevel",
 		"gatewayRouting",
 		"diagnostics",
 	]) {