@iowarp/clio-coder 0.4.2 → 0.4.4

package/src/entry/task-memory-lifecycle.ts

@@ -0,0 +1,35 @@
+import { BusChannels } from "../core/bus-events.js";
+import type { SafeEventBus } from "../core/event-bus.js";
+import type { TaskMemoryStepUsage } from "../domains/memory/task-memory-policy.js";
+import type { MemoryInterventionRegistration } from "../domains/middleware/memory-intervention.js";
+import {
+	type RecordBackgroundMemoryStepInput,
+	recordBackgroundMemoryStep,
+} from "../domains/observability/background-memory-usage.js";
+
+/** Explicit navigation owns memory lifetime; ordinary leaf advances and tree reads do not. */
+export function bindTaskMemoryLifecycle(
+	bus: SafeEventBus,
+	memory: Pick<MemoryInterventionRegistration, "reset" | "dispose">,
+): () => void {
+	const unsubscribe = [
+		bus.on(BusChannels.SessionParked, () => memory.reset()),
+		bus.on(BusChannels.SessionResumed, () => memory.reset()),
+		bus.on(BusChannels.SessionTurnSwitched, () => memory.reset()),
+		bus.on(BusChannels.SessionEnd, () => memory.dispose()),
+	];
+	return () => {
+		memory.dispose();
+		for (const off of unsubscribe) off();
+	};
+}
+
+/** The durable row keeps launch identity even when the live cost tracker has moved on. */
+export function captureTaskMemoryUsage(
+	input: Omit<RecordBackgroundMemoryStepInput, "usage">,
+): (usage: TaskMemoryStepUsage, isCurrent: boolean) => void {
+	const { observability, ...origin } = input;
+	return (usage, isCurrent) => {
+		recordBackgroundMemoryStep({ ...origin, usage, observability: isCurrent ? observability : undefined });
+	};
+}

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

@@ -471,11 +471,11 @@ export function backendCacheVerdict(
 	return classifyCacheUsage(input, cacheRead);
 }
 
-/** Per-API-call latency captured from the agent event stream (T3.2). */
+/** Native stream-invocation latency, measured on one monotonic clock. */
 export interface AssistantCallTiming {
-	/** message_start → first assistant delta; null when no delta arrived. */
+	/** Invocation to first assistant output; null when no output arrived. */
 	ttftMs: number | null;
-	/** message_start → message_end for the same assistant API call. */
+	/** Invocation to message_end for the same assistant API call. */
 	apiMs: number;
 }
 
@@ -490,7 +490,16 @@ export function assistantSessionPayload(
 	if (Array.isArray(raw.content)) payload.content = raw.content;
 	if (thinking.length > 0) payload.thinking = thinking;
 	payload.responseModelIdObservation = responseModelIdObservationFromRecord(raw, "not-observed");
-	for (const key of ["usage", "api", "provider", "model", "responseModel", "responseId", "diagnostics"]) {
+	for (const key of [
+		"usage",
+		"api",
+		"provider",
+		"model",
+		"responseModel",
+		"responseId",
+		"gatewayRouting",
+		"diagnostics",
+	]) {
 		if (raw[key] !== undefined) payload[key] = raw[key];
 	}
 	if (failure && !isSelfExplainingAbort({ stopReason: raw.stopReason, errorMessage: raw.errorMessage, text })) {

package/src/interactive/chat-loop.ts

@@ -16,7 +16,14 @@
 import { BusChannels, type RunAbortSource } from "../core/bus-events.js";
 import type { ClioSettings } from "../core/config.js";
 import type { SafeEventBus } from "../core/event-bus.js";
-import type { PendingSkillRequest } from "../core/skill-activation.js";
+import {
+	armedSkillSurface,
+	type PendingSkillRequest,
+	type PendingSkillToolPolicy,
+	skillSurfaceLabels,
+	skillSurfaceNames,
+	withModelSkillActivation,
+} from "../core/skill-activation.js";
 import { clioStateDir } from "../core/xdg.js";
 import {
 	createMiddlewareToolChoiceControl,
@@ -36,6 +43,7 @@ import {
 	runtimeTargetSnapshot,
 	targetRequiresAuth,
 } 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 { ContextSnapshot, ContextUsageSnapshot } from "../domains/session/context-accounting.js";
@@ -285,6 +293,12 @@ export interface ChatLoop {
 	 * queues the text for the next slot instead.
 	 */
 	interruptRefusal(): string | null;
+	/**
+	 * `/skill off`: drop the tool surface an activated skill armed, so the next
+	 * turn runs with the full surface again. Returns the skill names that were
+	 * armed, or an empty list when nothing was.
+	 */
+	clearSkillSurface(): ReadonlyArray<string>;
 	clearQueuedFollowUps(): string[];
 	queuedMessages(): QueuedMessagesSnapshot;
 	cancel(options?: ChatCancelOptions): void;
@@ -368,6 +382,12 @@ export interface ChatLoop {
 
 export interface CreateChatLoopDeps {
 	getSettings: () => Readonly<ClioSettings>;
+	/**
+	 * The same effective autonomy level registry admission resolves, so the
+	 * skill-activation gate and the tool gate can never disagree. Absent falls
+	 * back to the settings value.
+	 */
+	getAutonomy?: () => AutonomyLevel;
 	providers: ProvidersContract;
 	/**
 	 * Whitelist of target ids that the chat-loop is allowed to drive. The
@@ -622,6 +642,31 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 		emit({ type: "notice", level, surface: "transcript", text, ...(key === undefined ? {} : { key }) });
 	};
 
+	/**
+	 * Carry (or drop) the tool surface a skill declared once the turn that
+	 * loaded it settles, and say so once on the transcript. The operator needs
+	 * to know a narrowing is armed across their next messages, and needs one
+	 * 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 previous = skillSurfaceNames(state.activeSkillSurface).join(", ");
+		const next = armedSkillSurface(policy);
+		const current = skillSurfaceNames(next).join(", ");
+		state.activeSkillSurface = next;
+		const activated = skillSurfaceLabels(policy).filter((label) => !loadedBefore?.has(label.split(" ")[0] ?? label));
+		if (activated.length > 0) {
+			emitNotice(
+				current.length > 0
+					? `[Clio Coder] Skill activated: ${activated.join(", ")}. Its tool surface stays armed across your next turns until another skill replaces it or you run /skill off.`
+					: `[Clio Coder] Skill activated: ${activated.join(", ")}. It declares no tool narrowing.`,
+			);
+		}
+		if (current !== previous && current.length === 0 && previous.length > 0) {
+			emitNotice(`[Clio Coder] Skill tool surface cleared: ${previous}. The full tool surface is back.`);
+		}
+	};
+
 	/**
 	 * The same transcript notice every admission exit already emitted, carrying
 	 * the reason the turn never started. Text, level, and surface are unchanged,
@@ -745,6 +790,7 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 		context,
 		middleware,
 		retrySettings,
+		sessionId: () => deps.session?.current()?.id,
 		emit: emitRuntimeEvent,
 		emitNotice,
 		toolStartTimes,
@@ -959,6 +1005,11 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 		steer: (text) => queues.steer(text),
 		queueFollowUp: (text) => queues.queueFollowUp(text),
 		interruptRefusal: () => (state.streaming ? interruptRefusalReason() : null),
+		clearSkillSurface: () => {
+			const cleared = skillSurfaceNames(state.activeSkillSurface);
+			armSkillSurface(undefined);
+			return cleared;
+		},
 		clearQueuedFollowUps: () => queues.clearQueuedMirror().map((entry) => entry.text),
 		queuedMessages: () => queues.queuedMessages(),
 
@@ -1043,7 +1094,18 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 			const images = options.images && options.images.length > 0 ? [...options.images] : undefined;
 			const pendingSkillRequests = options.pendingSkillRequests ?? [];
 			context.addWorkingContextPaths(options.workingContextPaths ?? []);
-			const pendingSkillPolicy = createPendingSkillToolPolicy(pendingSkillRequests);
+			// A skill the operator activated narrows the tools for the workflow
+			// it started, and that workflow outlives the turn it began in. A
+			// fresh /skill this turn replaces the armed surface; otherwise the
+			// armed surface is what this turn runs under.
+			const pendingSkillPolicy = withModelSkillActivation(
+				createPendingSkillToolPolicy(pendingSkillRequests) ?? state.activeSkillSurface,
+				modelMayActivateSkills(deps.getAutonomy?.() ?? deps.getSettings().safety.autonomy),
+			);
+			// What was already loaded when this turn started, so the settle-time
+			// notice names the skills this turn activated and not the ones a
+			// carried surface has been holding since an earlier message.
+			const skillsLoadedBeforeTurn = new Set(pendingSkillPolicy?.loadedSkillNames ?? []);
 			// Resolve the frozen session tool surface before turn_start so intent
 			// middleware sees the exact tools this request can actually call.
 			agentRuntime.agent.state.tools = resolveSessionTools(
@@ -1310,6 +1372,7 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 				}
 				state.currentPendingSkillPolicy = priorPendingSkillPolicy;
 				state.currentAskUserPolicy = priorAskUserPolicy;
+				armSkillSurface(pendingSkillPolicy, skillsLoadedBeforeTurn);
 				state.activeUserTurnId = null;
 				// Safety net for thrown paths where agent_end never delivered;
 				// no-op when the agent_end flush already ran.

package/src/interactive/chat-renderer.ts

@@ -451,6 +451,7 @@ function richMessageFromEntry(entry: MessageEntry, maxTextChars?: number): Agent
 			"responseModelIdObservation",
 			"responseModel",
 			"responseId",
+			"gatewayRouting",
 			"diagnostics",
 			"contextUsageInvalidated",
 		]) {

package/src/interactive/cost-overlay.ts

@@ -46,6 +46,7 @@ export interface CostRow {
 	prewarms: number;
 	/** Calls in this row that were proactive-memory steps on the background target. */
 	backgroundMemory: number;
+	failedCompaction: number;
 	cost: CostAggregate;
 }
 
@@ -79,6 +80,7 @@ export function aggregateCostEntries(entries: ReadonlyArray<CostEntry>): CostRow
 			if (entry.label === "handoff") existing.row.handoffs += 1;
 			if (entry.label === "prewarm") existing.row.prewarms += 1;
 			if (entry.label === "background-memory") existing.row.backgroundMemory += 1;
+			if (entry.label === "failed-compaction") existing.row.failedCompaction += 1;
 			for (const requestedModelId of entry.requestedModelIds) existing.requestedModelIds.add(requestedModelId);
 			addResponseModelIdObservationCounts(
 				existing.responseModelIdObservationCounts,
@@ -103,6 +105,7 @@ export function aggregateCostEntries(entries: ReadonlyArray<CostEntry>): CostRow
 				handoffs: entry.label === "handoff" ? 1 : 0,
 				prewarms: entry.label === "prewarm" ? 1 : 0,
 				backgroundMemory: entry.label === "background-memory" ? 1 : 0,
+				failedCompaction: entry.label === "failed-compaction" ? 1 : 0,
 			},
 			requestedModelIds: new Set(entry.requestedModelIds),
 			responseModelIdObservationCounts: { ...entry.responseModelIdObservationCounts },
@@ -143,6 +146,7 @@ function sumRows(
 			handoffs: acc.handoffs + row.handoffs,
 			prewarms: acc.prewarms + row.prewarms,
 			backgroundMemory: acc.backgroundMemory + row.backgroundMemory,
+			failedCompaction: acc.failedCompaction + row.failedCompaction,
 		}),
 		{
 			runs: 0,
@@ -157,6 +161,7 @@ function sumRows(
 			handoffs: 0,
 			prewarms: 0,
 			backgroundMemory: 0,
+			failedCompaction: 0,
 		},
 	);
 }
@@ -229,13 +234,26 @@ function summaryBlock(
 	return kvBlock([
 		[
 			"turns",
-			formatTokens(totals.runs - totals.sideQuestions - totals.handoffs - totals.prewarms - totals.backgroundMemory),
+			formatTokens(
+				totals.runs -
+					totals.sideQuestions -
+					totals.handoffs -
+					totals.prewarms -
+					totals.backgroundMemory -
+					totals.failedCompaction,
+			),
 		],
 		["model calls", formatTokens(totals.apiCalls)],
 		...(totals.sideQuestions > 0 ? [["side questions", formatTokens(totals.sideQuestions)] as const] : []),
 		...(totals.handoffs > 0 ? [["handoffs", formatTokens(totals.handoffs)] as const] : []),
 		...(totals.prewarms > 0 ? [["pre-warms", formatTokens(totals.prewarms)] as const] : []),
 		...(totals.backgroundMemory > 0 ? [["memory steps", formatTokens(totals.backgroundMemory)] as const] : []),
+		...(totals.failedCompaction > 0
+			? [
+					["failed compaction calls", formatTokens(totals.failedCompaction)] as const,
+					["compaction usage", "known subtotals; missing usage is unknown"] as const,
+				]
+			: []),
 		...(cost === null ? [] : [["cost", cost] as const]),
 		["input", formatTokens(totals.input)],
 		["output", formatTokens(totals.output)],
@@ -255,12 +273,18 @@ function modelBlock(row: CostRow): string[] {
 	return kvBlock([
 		["requested model ids", row.requestedModelIds.join(", ")],
 		["response model id observation", responseModelIdObservationCountsLabel(row.responseModelIdObservationCounts)],
-		["turns", formatTokens(row.runs - row.sideQuestions - row.handoffs - row.prewarms - row.backgroundMemory)],
+		[
+			"turns",
+			formatTokens(
+				row.runs - row.sideQuestions - row.handoffs - row.prewarms - row.backgroundMemory - row.failedCompaction,
+			),
+		],
 		["model calls", formatTokens(row.apiCalls)],
 		...(row.sideQuestions > 0 ? [["side questions", formatTokens(row.sideQuestions)] as const] : []),
 		...(row.handoffs > 0 ? [["handoffs", formatTokens(row.handoffs)] as const] : []),
 		...(row.prewarms > 0 ? [["pre-warms", formatTokens(row.prewarms)] as const] : []),
 		...(row.backgroundMemory > 0 ? [["memory steps", formatTokens(row.backgroundMemory)] as const] : []),
+		...(row.failedCompaction > 0 ? [["failed compaction calls", formatTokens(row.failedCompaction)] as const] : []),
 		...(cost === null ? [] : [["cost", cost] as const]),
 		["input", formatTokens(row.input)],
 		["output", formatTokens(row.output)],