@iowarp/clio-coder 0.4.4 → 0.4.5

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/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);

package/src/interactive/chat-renderer.ts

@@ -17,6 +17,7 @@ import { existsSync } from "node:fs";
 import { ToolNames } from "../core/tool-names.js";
 import { foldWorkingSet } from "../domains/context/working-set/fold.js";
 import { compactionCut } from "../domains/context/working-set/visible.js";
+import { captureSkillContext } from "../domains/session/compaction/compact.js";
 import type {
 	BashExecutionEntry,
 	BranchSummaryEntry,
@@ -25,12 +26,14 @@ import type {
 	FileEntryEntry,
 	MessageEntry,
 	ModelChangeEntry,
+	PreservedSkillContext,
 	ProtectedArtifactEntry,
 	SessionEntry,
 	SessionInfoEntry,
 	ThinkingLevelChangeEntry,
 	WorkerRunEntry,
 } from "../domains/session/entries.js";
+import { latestSkillContextState, verifiedSkillContextCheckpoint } from "../domains/session/entries.js";
 import {
 	HANDOFF_NOTE_CUSTOM_TYPE,
 	HANDOFF_SEED_CUSTOM_TYPE,
@@ -334,6 +337,8 @@ export function createCoalescingChatRenderer(deps: CreateCoalescingChatRendererD
  * Options for the rehydrate helper used by /resume and /fork.
  */
 export interface RehydrateChatPanelOptions {
+	/** Unprojected ledger for verifying historical skill receipts after eviction projection. */
+	skillContextEntries?: ReadonlyArray<SessionEntry>;
 	/**
 	 * Select the active branch ancestry without truncating later sidecars.
 	 * Live compaction replay uses this so a summary appended after the current
@@ -451,6 +456,7 @@ function richMessageFromEntry(entry: MessageEntry, maxTextChars?: number): Agent
 			"responseModelIdObservation",
 			"responseModel",
 			"responseId",
+			"providerThinkingLevel",
 			"gatewayRouting",
 			"diagnostics",
 			"contextUsageInvalidated",
@@ -1068,6 +1074,15 @@ function appendContextMessage(
 	out.push(makeTextMessage(role, truncateReplayText(trimmed), timestamp));
 }
 
+const UNVERIFIED_SKILL_CHECKPOINT_TEXT =
+	"Preserved skill instructions on this checkpoint failed integrity verification and were not replayed. If a skill still applies, ask the operator to run /skill <name> again.";
+
+/** Selected but unverifiable: name the skill and the exact ledger ref instead of dropping it. */
+function unverifiedSkillContextText(skill: PreservedSkillContext): string {
+	const activation = skill.activation;
+	return `Preserved skill instructions for ${activation.name} (source=${activation.source} hash=${activation.hash} path=${activation.filePath}) could not be re-verified against this session's ledger and were not replayed. If the skill still applies, recall the original load with context(scope="recall", ref="${skill.resultRef}") or ask the operator to run /skill ${activation.name} again.`;
+}
+
 function skillActivationContextText(entry: Extract<SessionEntry, { kind: "skillActivation" }>): string {
 	const activation = entry.activation;
 	const turn = activation.turnId ? ` turn=${activation.turnId}` : "";
@@ -1080,6 +1095,16 @@ export function buildReplayAgentMessagesFromTurns(
 ): AgentMessage[] {
 	const out = createOrderedReplaySink();
 	const seenToolCalls = new Set<string>();
+	const activeEntries = truncateAtTurn(
+		filterEntriesToActivePath(turns, options.activeLeafTurnId ?? options.uptoTurnId),
+		options.uptoTurnId,
+	);
+	const skillState = latestSkillContextState(activeEntries);
+	const evidence = truncateAtTurn(
+		filterEntriesToActivePath(options.skillContextEntries ?? turns, options.activeLeafTurnId ?? options.uptoTurnId),
+		options.uptoTurnId,
+	);
+	const verified = captureSkillContext(evidence, skillState);
 	for (const entry of selectReplayEntries(turns, options)) {
 		switch (entry.kind) {
 			case "message": {
@@ -1113,8 +1138,43 @@ export function buildReplayAgentMessagesFromTurns(
 				break;
 			case "compactionSummary":
 				appendContextMessage(out, "user", compactionContextText(entry), entry.timestamp);
+				if (entry.userContext)
+					out.push(
+						makeTextMessage("user", `Active user instructions (verbatim):\n${entry.userContext.text}`, entry.timestamp),
+					);
+				if (entry.skillContext !== undefined) {
+					const retainedSkills = entry.skillContext.skills.length;
+					if (!verifiedSkillContextCheckpoint(entry.skillContext)) {
+						// The raw pairs behind a tampered checkpoint are already outside the
+						// replay window. Say so rather than dropping the skill without a trace.
+						if (retainedSkills > 0) {
+							out.push(makeTextMessage("user", UNVERIFIED_SKILL_CHECKPOINT_TEXT, entry.timestamp));
+						}
+						break;
+					}
+					for (const skill of entry.skillContext.skills) {
+						// An explicit later state that no longer names this activation is a
+						// deliberate off or replacement; it leaves no trace, by design.
+						if (skillState && !skillState.unknown && !skillState.activationRefs.includes(skill.activationRef)) continue;
+						const receipt = verified?.skills.find((candidate) => candidate.activationRef === skill.activationRef);
+						if (!receipt || JSON.stringify(receipt) !== JSON.stringify(skill)) {
+							// Still selected, but its original receipt cannot be re-verified
+							// (masked, rewritten, or unknown state). Never inject unverified
+							// bytes, and never lose the skill silently either.
+							out.push(makeTextMessage("user", unverifiedSkillContextText(skill), entry.timestamp));
+							continue;
+						}
+						// This is historical instruction context, not a generated summary or a tool result.
+						// Keep the exact captured blocks outside summary replay's text cap.
+						out.push(makeTextMessage("user", `Preserved skill request (verbatim):\n${skill.requestText}`, entry.timestamp));
+						out.push(makeTextMessage("user", `Verified loaded skill: ${JSON.stringify(skill.activation)}`, entry.timestamp));
+						for (const block of skill.content) out.push(makeTextMessage("user", block.text, entry.timestamp));
+					}
+				}
 				break;
 			case "skillActivation":
+				if (entry.activation.runId !== undefined || (skillState && !skillState.activationRefs.includes(entry.turnId)))
+					break;
 				appendContextMessage(out, "user", skillActivationContextText(entry), entry.timestamp);
 				break;
 			// The one custom entry that becomes a model message. `/handoff` seeds a