@iowarp/clio-coder 0.4.4 → 0.4.6

package/src/entry/orchestrator.ts

@@ -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,10 +158,9 @@ 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 { activeDecisionRefs, createDecisionBoardStore } from "../domains/session/decision-board.js";
 import type { CompactionSummaryEntry, CompactionTrigger, SessionEntry } from "../domains/session/entries.js";
@@ -615,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;
@@ -635,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");
@@ -674,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",
@@ -795,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) {
@@ -806,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");
 	}
@@ -842,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 } : {}),
@@ -859,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");
@@ -877,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,
@@ -940,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 } : {}),
+	});
 }
 
 /**
@@ -973,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);
@@ -1042,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");
 
@@ -1500,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,
@@ -1507,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.

package/src/interactive/application-controller.ts

@@ -6,16 +6,12 @@ import { isEscapeKey, type OverlayState, overlayOwnsInput } from "./overlay-life
 export const APPLICATION_DOUBLE_TAP_MS = 500;
 
 const CLOSED_ACTION_ORDER = [
+	"clio-coder.output.cycle",
 	"clio-coder.notifications.dismiss",
-	"clio-coder.tool.expand",
-	"clio-coder.tool.expandAll",
-	"clio-coder.tool.liveOutput",
 	"clio-coder.editor.external",
 	"clio-coder.message.followUp",
 	"clio-coder.message.interrupt",
 	"clio-coder.message.dequeue",
-	"clio-coder.thinking.expand",
-	"clio-coder.thinking.expandAll",
 ] as const satisfies ReadonlyArray<ClioKeybinding>;
 
 export const GLOBAL_ACTION_ORDER = [
@@ -108,10 +104,6 @@ export interface ApplicationControllerDeps {
 	listNotifications: () => ReadonlyArray<{ id: string }>;
 	dismissNotification: (id: string) => void;
 	dismissAllNotifications: () => void;
-	toggleLastToolExpanded: () => boolean;
-	toggleAllToolsExpanded: () => boolean;
-	toggleLastThinking: () => boolean;
-	toggleAllThinking: () => boolean;
 	shutdownDisposers: ReadonlyArray<() => void>;
 	/** Settle the last presentation mutation into an accepted/drained frame. */
 	beforeStopUi?: () => Promise<void>;
@@ -145,8 +137,6 @@ export interface ApplicationController {
 	handleInput(data: string): ApplicationInputResult;
 	handleCtrlC(): void;
 	dismissNotifications(): void;
-	toggleToolExpansion(): void;
-	toggleThinkingExpansion(): void;
 	shutdown(): Promise<void>;
 }
 
@@ -163,8 +153,6 @@ export function createApplicationController(deps: ApplicationControllerDeps): Ap
 	let shuttingDown = false;
 	let lastCtrlCAt = 0;
 	let lastNotificationDismissAt = 0;
-	let lastToolExpandAt = 0;
-	let lastThinkingExpandAt = 0;
 
 	const isDoubleTap = (lastAt: number, now: number): boolean => lastAt > 0 && now - lastAt <= APPLICATION_DOUBLE_TAP_MS;
 
@@ -346,22 +334,6 @@ export function createApplicationController(deps: ApplicationControllerDeps): Ap
 		if (first) deps.dismissNotification(first.id);
 	};
 
-	const toggleToolExpansion = (): void => {
-		const now = deps.clock.now();
-		const doubleTap = isDoubleTap(lastToolExpandAt, now);
-		lastToolExpandAt = now;
-		const changed = doubleTap ? deps.toggleAllToolsExpanded() : deps.toggleLastToolExpanded();
-		if (changed) deps.requestRender();
-	};
-
-	const toggleThinkingExpansion = (): void => {
-		const now = deps.clock.now();
-		const doubleTap = isDoubleTap(lastThinkingExpandAt, now);
-		lastThinkingExpandAt = now;
-		const changed = doubleTap ? deps.toggleAllThinking() : deps.toggleLastThinking();
-		if (changed) deps.requestRender();
-	};
-
 	const handleInput = (data: string): ApplicationInputResult => {
 		const initialOverlayState = deps.getOverlayState();
 		if (overlayOwnsInput(initialOverlayState) && deps.leaderKeys.isPending()) deps.leaderKeys.reset();
@@ -427,8 +399,6 @@ export function createApplicationController(deps: ApplicationControllerDeps): Ap
 		handleInput,
 		handleCtrlC,
 		dismissNotifications,
-		toggleToolExpansion,
-		toggleThinkingExpansion,
 		shutdown,
 	};
 }

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",
 	]) {

package/src/interactive/chat-loop.ts

@@ -13,6 +13,7 @@
  * machine, and the shared ChatTurnState the modules coordinate through.
  */
 
+import { AsyncLocalStorage } from "node:async_hooks";
 import { BusChannels, type RunAbortSource } from "../core/bus-events.js";
 import type { ClioSettings } from "../core/config.js";
 import type { SafeEventBus } from "../core/event-bus.js";
@@ -45,14 +46,21 @@ import {
 } from "../domains/providers/index.js";
 import { type AutonomyLevel, modelMayActivateSkills } from "../domains/safety/autonomy.js";
 import type { ProtectedArtifactState } from "../domains/safety/protected-artifacts.js";
-import type { CompactResult } from "../domains/session/compaction/compact.js";
+import type { CompactInput, CompactResult } from "../domains/session/compaction/compact.js";
 import type { ContextSnapshot, ContextUsageSnapshot } from "../domains/session/context-accounting.js";
 import { ceilChars, snapshotInputTokens } from "../domains/session/context-accounting.js";
 import type { ContextLedger } from "../domains/session/context-ledger.js";
 import type { SessionContract } from "../domains/session/contract.js";
-import type { CompactionTrigger, SessionEntry } from "../domains/session/entries.js";
+import {
+	type CompactionTrigger,
+	latestSkillContextState,
+	mainSkillContextState,
+	type SessionEntry,
+	SKILL_CONTEXT_STATE,
+} from "../domains/session/entries.js";
 import { protectedArtifactStateFromSessionEntries } from "../domains/session/protected-artifacts.js";
 import { isRetryableErrorMessage, type RetrySettings } from "../domains/session/retry.js";
+import { filterEntriesToActivePath } from "../domains/session/tree/active-path.js";
 import { createEngineAgent } from "../engine/agent.js";
 import { resolveReservedOutputTokens } from "../engine/apis/output-budget.js";
 import { cwdHash } from "../engine/session.js";
@@ -65,6 +73,7 @@ import {
 	createPendingSkillToolPolicy,
 	detectOverflowFromState,
 	detectTerminalFailureFromState,
+	explainInterruptedAssistant,
 	notConfiguredNotice,
 	noticeMessage,
 	pendingSkillRequestPreamble,
@@ -189,6 +198,8 @@ export type ChatLoopEvent =
 	| ToolApprovalStateEvent;
 
 export interface ChatSubmitOptions {
+	/** Host-owned run identity, scoped to this submit and its internal continuations. */
+	hostRun?: ToolInvokeOptions["hostRun"];
 	images?: ReadonlyArray<ImageContent>;
 	/** Files already expanded into this session's working context. */
 	workingContextPaths?: ReadonlyArray<string>;
@@ -443,7 +454,11 @@ export interface CreateChatLoopDeps {
 	 * Both sites share an AutoCompactionTrigger so two fires in the same tick
 	 * coalesce onto one summarization call.
 	 */
-	autoCompact?: (instructions?: string, trigger?: CompactionTrigger) => Promise<CompactResult | null>;
+	autoCompact?: (
+		instructions?: string,
+		trigger?: CompactionTrigger,
+		budget?: Pick<CompactInput, "keepRecentTokens" | "preserveUserTurnId" | "skillContextState" | "signal">,
+	) => Promise<CompactResult | null>;
 	/** Optional observability sink for orchestrator chat token usage. */
 	observability?: ObservabilityContract;
 	/**
@@ -649,10 +664,33 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 	 * line back when it lifts; the skill-activation ledger entry already
 	 * records provenance, so this is the notice, not a second UI.
 	 */
-	const armSkillSurface = (policy: PendingSkillToolPolicy | undefined, loadedBefore?: ReadonlySet<string>): void => {
+	const armSkillSurface = (
+		policy: PendingSkillToolPolicy | undefined,
+		loadedBefore?: ReadonlySet<string>,
+		explicitOff = false,
+	): void => {
 		const previous = skillSurfaceNames(state.activeSkillSurface).join(", ");
 		const next = armedSkillSurface(policy);
 		const current = skillSurfaceNames(next).join(", ");
+		if (
+			deps.session?.current() &&
+			(explicitOff ||
+				previous.length > 0 ||
+				(policy?.loadedSkillNames.size ?? 0) > 0 ||
+				(policy?.requests.length ?? 0) > 0)
+		) {
+			const entries = filterEntriesToActivePath(deps.readSessionEntries?.() ?? [], state.lastTurnId ?? undefined);
+			const selection = next
+				? mainSkillContextState(entries, next)
+				: (policy?.loadedSkillNames.size ?? 0) > 0
+					? null
+					: { version: 1 as const, activationRefs: [] };
+			const data = selection ?? { version: 1 as const, activationRefs: [], unknown: true as const };
+			if (JSON.stringify(data) !== JSON.stringify(latestSkillContextState(entries))) {
+				// Persist before changing live state: restart must not resurrect a cleared/replaced skill.
+				deps.session.appendEntry({ kind: "custom", customType: SKILL_CONTEXT_STATE, parentTurnId: state.lastTurnId, data });
+			}
+		}
 		state.activeSkillSurface = next;
 		const activated = skillSurfaceLabels(policy).filter((label) => !loadedBefore?.has(label.split(" ")[0] ?? label));
 		if (activated.length > 0) {
@@ -692,10 +730,13 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 
 	const retrySettings = (): RetrySettings => normalizeRetrySettings(deps.getSettings().chat.retry);
 
+	const hostRunContext = new AsyncLocalStorage<ToolInvokeOptions["hostRun"]>();
 	const currentToolInvokeOptions = (): Partial<ToolInvokeOptions> => {
 		const options: Partial<ToolInvokeOptions> = {
 			toolResultMaxBytes: deps.getSettings().context.toolResultMaxBytes,
 		};
+		const hostRun = hostRunContext.getStore();
+		if (hostRun !== undefined) options.hostRun = hostRun;
 		const sessionId = deps.session?.current()?.id ?? null;
 		if (sessionId) options.sessionId = sessionId;
 		const turnId = state.activeUserTurnId ?? state.lastTurnId;
@@ -774,7 +815,10 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 		emitNotice,
 	});
 	const emitRuntimeEvent = (event: AgentEvent | AssistantDeltaEvent): void => {
-		if (event.type === "message_end") rewriteStallAbortMessage(state, event.message);
+		if (event.type === "message_end") {
+			rewriteStallAbortMessage(state, event.message);
+			explainInterruptedAssistant(event.message, state.activeInterruptReason);
+		}
 		emit(event as ChatLoopEvent);
 	};
 
@@ -1007,7 +1051,7 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 		interruptRefusal: () => (state.streaming ? interruptRefusalReason() : null),
 		clearSkillSurface: () => {
 			const cleared = skillSurfaceNames(state.activeSkillSurface);
-			armSkillSurface(undefined);
+			armSkillSurface(undefined, undefined, true);
 			return cleared;
 		},
 		clearQueuedFollowUps: () => queues.clearQueuedMirror().map((entry) => entry.text),
@@ -1145,9 +1189,10 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 			const forceNow = process.env.CLIO_CODER_FORCE_COMPACT === "1";
 			try {
 				setTurnPreparation("compacting");
-				await context.runAutoCompact(agentRuntime, forceNow, undefined, undefined, submittedText);
+				await context.runAutoCompact(agentRuntime, forceNow, undefined, undefined, submittedText, pendingSkillPolicy);
 			} catch (err) {
 				emitNotice(`[Clio Coder] auto-compaction failed: ${err instanceof Error ? err.message : String(err)}`);
+				if (err instanceof Error && err.name === "AbortError") return;
 			} finally {
 				endPreparationCompaction();
 			}
@@ -1170,8 +1215,13 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 					toolSignature,
 				});
 
-			const reservedOutput = resolveReservedOutputTokens(agentRuntime.runtimeResolution.capabilityDecisions.maxTokens);
 			const effectiveWindow = agentRuntime.runtimeResolution.contextWindowDetails.effectiveContextWindow;
+			const outputForInput = (inputTokens: number): number =>
+				resolveReservedOutputTokens(agentRuntime.runtimeResolution.capabilityDecisions.maxTokens, {
+					api: agentRuntime.agent.state.model?.api ?? "",
+					contextWindow: effectiveWindow,
+					inputTokens,
+				});
 			const pendingInputTokens = ceilChars(submittedText.length);
 			let turnSnapshot = captureTurnSnapshot("pending");
 			// The snapshot prices the prompt at chars/4. When the provider has
@@ -1184,28 +1234,38 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 					snapshotInputTokens(snapshot) + pendingInputTokens,
 					context.liveContextEstimate(agentRuntime, submittedText).tokens,
 				);
-			const totalEstimate = budgetedPromptTokens(turnSnapshot) + reservedOutput;
+			const inputEstimate = budgetedPromptTokens(turnSnapshot);
+			const reservedOutput = outputForInput(inputEstimate);
+			const totalEstimate = inputEstimate + reservedOutput;
 
 			if (effectiveWindow > 0 && totalEstimate > effectiveWindow) {
 				emitNotice(
 					`[Clio Coder] Estimated request size ${totalEstimate} tokens (input ${totalEstimate - reservedOutput} + output budget ${reservedOutput}) exceeds the effective context window of ${effectiveWindow} tokens. Running compaction before sending...`,
 				);
 				setTurnPreparation("compacting");
+				let compactionFailure: string | undefined;
 				const compacted = await context
-					.runAutoCompact(agentRuntime, true, undefined, undefined, submittedText)
+					.runAutoCompact(agentRuntime, true, undefined, "overflow", submittedText, pendingSkillPolicy)
+					.catch((error: unknown) => {
+						compactionFailure = error instanceof Error ? error.message : String(error);
+						return false;
+					})
 					.finally(endPreparationCompaction);
 				if (!compacted) {
-					emitNotice(
-						"[Clio Coder] Compaction could not reclaim enough space. Request blocked; trim the prompt, reduce active tools, or start a fresh session.",
+					emitAdmissionNotice(
+						`[Clio Coder] Request exceeds the context window and compaction could not reclaim enough space.${compactionFailure ? ` ${compactionFailure}.` : ""} Trim the prompt or reduce active tools.`,
+						"context-window-exceeded",
 					);
 					return;
 				}
 				context.refreshAgentMessagesFromSession(agentRuntime);
 				turnSnapshot = captureTurnSnapshot("pending");
-				const postTotalEstimate = budgetedPromptTokens(turnSnapshot) + reservedOutput;
+				const postInputEstimate = budgetedPromptTokens(turnSnapshot);
+				const postTotalEstimate = postInputEstimate + outputForInput(postInputEstimate);
 				if (postTotalEstimate > effectiveWindow) {
-					emitNotice(
+					emitAdmissionNotice(
 						`[Clio Coder] Request still exceeds the effective window after compaction (${postTotalEstimate} > ${effectiveWindow}). Request blocked.`,
+						"context-window-exceeded",
 					);
 					return;
 				}
@@ -1264,6 +1324,7 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 			state.toolProseAbortReason = null;
 			state.toolProseAssessedChars = 0;
 			state.activeInterruptReason = null;
+			state.interruptedAssistantMessage = null;
 			state.interruptedUsage = null;
 
 			// 6. Cache-disturbance honesty (T3.3)
@@ -1355,19 +1416,21 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 				}
 				state.streaming = false;
 				if (state.activeInterruptReason !== null) {
-					// The loop-guard cancel showed its closing message live; persist
-					// the durable closing turn only now, after the aborted run's
-					// in-flight tool results have all landed, so the ledger replays
-					// as tool_calls → tool_results → closing text.
-					// A thinking-only abort never reaches the ledger, so its estimated
-					// spend rides on the closing turn; persistence computes nothing
-					// further for a message that already reports positive usage.
-					const closing = noticeMessage(state.activeInterruptReason);
-					if (state.interruptedUsage !== null) {
-						(closing as { usage?: unknown }).usage = state.interruptedUsage;
-					}
-					persistence.appendAssistantTurn(closing);
+					const reason = state.activeInterruptReason;
 					state.activeInterruptReason = null;
+					// A partial response already closed with the cancellation reason.
+					// Only a hollow abort needs a synthetic assistant, after all tool
+					// results have landed. Publish its notice after settlement too, so
+					// it cannot split the entry the provider's message_end finalizes.
+					if (state.interruptedAssistantMessage === null) {
+						const closing = noticeMessage(reason);
+						if (state.interruptedUsage !== null) {
+							(closing as { usage?: unknown }).usage = state.interruptedUsage;
+						}
+						persistence.appendAssistantTurn(closing);
+						emitNotice(reason, "warning", "turn.interrupted");
+					}
+					state.interruptedAssistantMessage = null;
 					state.interruptedUsage = null;
 				}
 				state.currentPendingSkillPolicy = priorPendingSkillPolicy;
@@ -1385,6 +1448,7 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 
 		cancel(options?: ChatCancelOptions): void {
 			const wasStreaming = state.streaming;
+			context.cancelCompaction();
 			recovery.cancelRetryCountdown();
 			// Clear both queues before the abort settles the in-flight prompt:
 			// a cancelled run must not deliver queued steers or follow-ups, and
@@ -1392,19 +1456,13 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 			queues.clearQueuedMirror();
 			const requestedReason = options?.reason?.trim();
 			if (wasStreaming) {
-				// Show the stop reason immediately, but persist the durable closing
-				// turn only when the run settles (submit's finally). The abort below
-				// still lets the in-flight tool results land; persisting here would
-				// interleave an assistant turn between a tool-call message and its
-				// results, which strict chat templates reject on replay.
-				// `activeInterruptReason` meanwhile suppresses the empty aborted
-				// messages the abort leaves behind, in both the ledger and the live
-				// transcript. Operator cancels take the same path with the default
-				// text, so they no longer render a redundant "[aborted] Request was
-				// aborted" turn on top of the cancellation notice.
+				// Keep immediate feedback in the footer. A transcript notice here
+				// would split the streamed entry before message_end can finalize it.
+				// The reason is carried by the provider's aborted assistant, or by
+				// one synthetic closing record after an empty abort settles.
 				state.activeInterruptReason =
 					requestedReason && requestedReason.length > 0 ? requestedReason : "[Clio Coder] active response cancelled.";
-				emitNotice(state.activeInterruptReason, "warning", "turn.interrupted");
+				emitFooterNotice("warning", state.activeInterruptReason, "turn.interrupted");
 			}
 			state.runtime?.agent.abort();
 			if (wasStreaming && deps.bus) {
@@ -1595,11 +1653,16 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 				return;
 			}
 			let compacted = false;
+			enterPreparation();
+			setTurnPreparation("compacting");
 			try {
 				compacted = await context.runAutoCompact(agentRuntime, true, instructions, "force");
 			} catch (err) {
 				emitNotice(`[/context compact] ${err instanceof Error ? err.message : String(err)}`);
 				return;
+			} finally {
+				leavePreparation();
+				endPreparationCompaction();
 			}
 			if (!compacted) {
 				emitNotice("[/context compact] nothing to compact; session is empty or no cut crossed");
@@ -1633,6 +1696,9 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 	// released at admission, not settlement, so steering stays immediate.
 	let admissionTail: Promise<void> | null = null;
 	api.submit = (text, options = {}) => {
+		// Capture before admission can await. Internal resubmits inherit the
+		// async scope; every independent public submit explicitly starts its own.
+		const hostRun = options.hostRun === undefined ? undefined : structuredClone(options.hostRun);
 		// The operator owns the slot from the keystroke, not from admission. The
 		// prefix the pre-warm already pushed through stays in it either way, so
 		// aborting here costs nothing and stops the real turn from queueing behind
@@ -1669,14 +1735,18 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 				// A presentation observer cannot refuse a turn after the editor has
 				// consumed it. The ordinary render path can recover on its next tick.
 			}
-			return submitTracked(text, {
-				...submitOptions,
-				onAdmitted: () => {
-					releaseTicket();
-					leaveOnce();
-					options.onAdmitted?.();
-				},
-			}).finally(releaseTicket);
+			return hostRunContext
+				.run(hostRun, () =>
+					submitTracked(text, {
+						...submitOptions,
+						onAdmitted: () => {
+							releaseTicket();
+							leaveOnce();
+							options.onAdmitted?.();
+						},
+					}),
+				)
+				.finally(releaseTicket);
 		};
 		const run = previous ? previous.then(start) : start();
 		return run.finally(leaveOnce);