@iowarp/clio-coder 0.4.9 → 0.5.0

package/src/domains/lifecycle/migrations/2026-09-18-ollama-runtime-id.ts

@@ -0,0 +1,38 @@
+import { existsSync } from "node:fs";
+
+import { readSettings, settingsPath, updateSettings } from "../../../core/config.js";
+import { authStoragePath } from "../../providers/auth/backend-file.js";
+import { openAuthStorage } from "../../providers/auth/index.js";
+import type { Migration } from "./index.js";
+
+/**
+ * Rewrites targets persisted under the released `ollama-native` runtime id to
+ * the canonical `ollama` (#376). Until this runs, the registry still resolves
+ * the old id as an alias, so a home that never upgrades keeps booting.
+ */
+const migration: Migration = {
+	id: "2026-09-18-ollama-runtime-id",
+	async up(): Promise<void> {
+		let keepLegacyCredential = false;
+		if (existsSync(settingsPath())) {
+			const current = readSettings();
+			keepLegacyCredential = current.targets.some((target) => target.auth?.apiKeyRef === "ollama-native");
+			if (current.targets.some((target) => target.runtime === "ollama-native")) {
+				updateSettings((settings) => {
+					for (const target of settings.targets) {
+						if (target.runtime === "ollama-native") target.runtime = "ollama";
+					}
+				});
+			}
+		}
+		if (!existsSync(authStoragePath())) return;
+		// A credential stored under the runtime id resolved through that id, so it
+		// follows the rename. Skip the store entirely when none exists, as the
+		// LM Studio rename does, because touching it takes the credentials lock.
+		const storage = openAuthStorage();
+		if (!storage.hasStored("ollama-native")) return;
+		storage.renameProvider("ollama-native", "ollama", { keepSource: keepLegacyCredential });
+	},
+};
+
+export default migration;

package/src/domains/lifecycle/migrations/index.ts

@@ -36,6 +36,7 @@ import lmStudioRuntimeId from "./2026-08-18-lmstudio-runtime-id.js";
 import clioCoderNaming from "./2026-09-01-clio-coder-naming.js";
 import retirePanesKnobs from "./2026-09-01-retire-panes-knobs.js";
 import settingsV2 from "./2026-09-01-settings-v2.js";
+import ollamaRuntimeId from "./2026-09-18-ollama-runtime-id.js";
 
 export interface Migration {
 	id: string;
@@ -64,6 +65,7 @@ const REGISTRY: ReadonlyArray<Migration> = Object.freeze([
 	clioCoderNaming,
 	retirePanesKnobs,
 	lmStudioRuntimeId,
+	ollamaRuntimeId,
 ]);
 
 export function listMigrations(): ReadonlyArray<Migration> {

package/src/domains/middleware/demo-guidance.ts

@@ -0,0 +1,36 @@
+import type { MiddlewareHookRegistration } from "./runtime.js";
+
+/** One contextual reminder during substantive interactive work; never a continuation. */
+export function createDemoGuidanceRegistration(enabled: () => boolean): MiddlewareHookRegistration {
+	let active = false;
+	let observations = 0;
+	const investigationTools = new Set(["read", "grep", "find", "ls", "code_nav"]);
+	return {
+		id: "observer.demo-guidance",
+		description: "connect an investigation's findings to one useful project capability",
+		hooks: ["turn_start", "after_tool", "turn_end"],
+		evaluate(input) {
+			if (input.hook === "turn_start") {
+				active = true;
+				observations = 0;
+				return [];
+			}
+			if (input.hook === "turn_end") {
+				active = false;
+				return [];
+			}
+			if (!active || !enabled() || input.metadata?.resultKind !== "ok" || !investigationTools.has(input.toolName ?? ""))
+				return [];
+			if (++observations !== 3) return [];
+			active = false;
+			return [
+				{
+					kind: "annotate_tool_result",
+					severity: "info",
+					message:
+						"Demo guidance: use the evidence you are gathering to identify one useful next capability for this actual task. At your next meaningful finding, include a brief concrete offer (for example, checking a change with the relevant tests or assigning an independent question to an available helper). If the action is already requested and authorized, do it. Skip the offer if the user declined suggestions or required a strict output format such as JSON-only. Do not invent an opportunity, repeat a declined offer, or perform extra work solely to demonstrate a feature.",
+				},
+			];
+		},
+	};
+}

package/src/domains/middleware/dispatch-nudge.ts

@@ -50,7 +50,7 @@ interface ExplorationTurnState {
 }
 
 export function buildReadOnlyExplorationMessage(): string {
-	return `[Clio Coder] This turn used ${READ_ONLY_EXPLORATION_NUDGE_CALL_THRESHOLD}+ read-only exploration calls without a successful Scout dispatch; delegate broad repository reconnaissance to Scout.`;
+	return `[Clio Coder] This turn used ${READ_ONLY_EXPLORATION_NUDGE_CALL_THRESHOLD}+ read-only exploration calls without a successful Scout dispatch; delegate broad repository reconnaissance to Scout when more exploration is needed. If Scout already failed, confirm its useful leads with focused reads and synthesize; do not repeat its entire search.`;
 }
 
 function stringValue(value: unknown): string | null {

package/src/domains/middleware/memory-intervention.ts

@@ -1,4 +1,8 @@
 import { createHash } from "node:crypto";
+import {
+	DISPATCH_PLAN_PREPARATION_ERROR_ARGUMENT,
+	RESOLVED_DISPATCH_PLAN_ARGUMENT,
+} from "../../tools/dispatch-plan.js";
 import {
 	legacyToolResultDigest,
 	sanitizeToolResultDigest,
@@ -222,6 +226,10 @@ export function createMemoryInterventionRegistration(deps: MemoryInterventionDep
 					case "after_tool":
 						return observeAfterTool(input);
 					case "turn_end": {
+						if (input.metadata?.stopReason === "aborted") {
+							cancelStoppedTurn();
+							return NO_EFFECTS;
+						}
 						// Middleware continuations can evaluate turn_end again without any
 						// completed tools. They are not new memory boundaries and must not
 						// replace the prior operator-visible outcome or emit telemetry.
@@ -285,12 +293,17 @@ export function createMemoryInterventionRegistration(deps: MemoryInterventionDep
 		 * full latency. Small local models measure in tens of seconds, which is far
 		 * past any tolerable end-of-turn pause and past the policy timeout itself.
 		 * The reminder is delivered through `onDeferredReminder` instead, landing
-		 * in the next submitted turn, which is where an awaited turn_end reminder
-		 * would have been buffered anyway.
+		 * at the next native tool-batch boundary or the next submitted turn.
 		 */
 		async evaluateAsync(input, context): Promise<ReadonlyArray<MiddlewareEffect>> {
 			observeSession(input);
-			if (disposed || !settings().enabled || input.hook !== "turn_end" || pendingTriggers.size === 0) return NO_EFFECTS;
+			if (input.hook === "turn_end" && input.metadata?.stopReason === "aborted") {
+				cancelStoppedTurn();
+				return NO_EFFECTS;
+			}
+			const boundaryHook =
+				input.hook === "turn_end" || (input.hook === "after_tool" && input.metadata?.stage === "tool_batch_end");
+			if (disposed || !settings().enabled || !boundaryHook || pendingTriggers.size === 0) return NO_EFFECTS;
 			const boundary = input.turnId ?? input.metadata?.userTurnId?.toString() ?? `tool-step:${toolStep}`;
 			if (boundary === lastPromptedBoundary) return NO_EFFECTS;
 			// One row rather than none, so a headless operator reading the log sees
@@ -374,6 +387,26 @@ export function createMemoryInterventionRegistration(deps: MemoryInterventionDep
 		observedSessionId = input.sessionId;
 	}
 
+	function cancelStoppedTurn(): void {
+		if (!promptedStepInFlight && pendingTriggers.size === 0 && toolStep <= lastTurnEndStep) return;
+		const tier = promptedStepInFlight ? promptedStepTier : "rules";
+		// Retain completed bank entries, but revoke pending content and delivery
+		// authority. Late provider usage still belongs to its captured origin.
+		generation += 1;
+		generationController.abort();
+		generationController = new AbortController();
+		promptedStepInFlight = false;
+		outstandingStep = Promise.resolve();
+		pendingTriggers.clear();
+		toolsSinceMemoryStep = 0;
+		consecutiveErrors = 0;
+		lastTurnEndStep = toolStep;
+		rulesInjectedSincePromptedStep = false;
+		annotatedSinceTurnEnd = false;
+		lastDecision = "silent";
+		emitTelemetry(["turn_end"], tier, "silent", "scope_changed", 0, 0, 0, process.hrtime.bigint());
+	}
+
 	function reset(): void {
 		generation += 1;
 		generationController.abort();
@@ -799,10 +832,24 @@ function prepareToolStep(input: MiddlewareHookInput): PendingToolStep | null {
 	const toolName = input.toolName?.trim();
 	if (!toolName) return null;
 	const canonical = hashToolCall(toolName, input.toolArgs ?? {});
+	// Host preparation artifacts belong to exact identity, not descriptive
+	// context. Keep public arguments so memory can explain what was attempted.
+	const publicArgs = Object.fromEntries(
+		Object.entries(input.toolArgs ?? {}).filter(
+			([key]) => key !== RESOLVED_DISPATCH_PLAN_ARGUMENT && key !== DISPATCH_PLAN_PREPARATION_ERROR_ARGUMENT,
+		),
+	);
 	return {
 		toolName,
 		operationFingerprint: createHash("sha256").update(canonical).digest("hex").slice(0, 16),
-		callDescription: shortText(canonical, CALL_DESCRIPTION_MAX_CHARS),
+		callDescription: shortText(
+			Object.keys(publicArgs).length > 0
+				? `${toolName} ${hashToolCall("", publicArgs)}`
+				: toolName === "dispatch"
+					? "dispatch plan preparation"
+					: toolName,
+			CALL_DESCRIPTION_MAX_CHARS,
+		),
 	};
 }
 

package/src/domains/middleware/runtime.ts

@@ -1,3 +1,4 @@
+import { writeDiagnostic } from "../../core/diagnostics.js";
 import { createHookBudgetTracker, type HookBudgetStats, type HookBudgetTracker } from "./budget.js";
 import type { MiddlewareRegistrationConflictTier, MiddlewareRegistrationOwner } from "./registrations.js";
 import { listMiddlewareRuleDefinitions } from "./rules.js";
@@ -111,7 +112,7 @@ export type MiddlewareDiagnosticSink = (diagnostic: MiddlewareDiagnostic) => voi
 
 /**
  * Default diagnostic sink, and the one the domain loader constructs the
- * bundle with. It writes to stderr only. The composition root
+ * bundle with. It uses the active terminal diagnostic sink, or stderr headlessly. The composition root
  * (src/entry/orchestrator.ts) replaces it through setDiagnosticSink with a
  * sink that publishes every diagnostic on the typed bus as
  * `middleware.hookFailed`, which the interactive warn notice consumes, and
@@ -120,13 +121,13 @@ export type MiddlewareDiagnosticSink = (diagnostic: MiddlewareDiagnostic) => voi
  */
 export function writeMiddlewareDiagnosticToStderr(diagnostic: MiddlewareDiagnostic): void {
 	if (diagnostic.kind === "hook_failed") {
-		process.stderr.write(
+		writeDiagnostic(
 			`[clio-coder:middleware] registration '${diagnostic.registrationId}' failed on '${diagnostic.hook}': ${diagnostic.message}\n`,
 		);
 		return;
 	}
 	if (diagnostic.kind === "registration_conflict") {
-		process.stderr.write(`[clio-coder:middleware] ${formatRegistrationConflict(diagnostic)}\n`);
+		writeDiagnostic(`[clio-coder:middleware] ${formatRegistrationConflict(diagnostic)}\n`);
 		return;
 	}
 	// A single post-warmup spike is telemetry, not operator-facing noise: only
@@ -137,7 +138,7 @@ export function writeMiddlewareDiagnosticToStderr(diagnostic: MiddlewareDiagnost
 		stats.window > 0
 			? ` (slow on ${stats.overCount}/${stats.window} recent ${diagnostic.hook} calls, p95 ${stats.p95Ms.toFixed(1)}ms)`
 			: "";
-	process.stderr.write(
+	writeDiagnostic(
 		`[clio-coder:middleware] registration '${diagnostic.registrationId}' exceeded budget on '${diagnostic.hook}': ` +
 			`${diagnostic.elapsedMs.toFixed(1)}ms > ${diagnostic.budgetMs}ms${trend}\n`,
 	);

package/src/domains/middleware/skills-reminder.ts

@@ -1,69 +1,34 @@
 import { SKILL_SUGGESTION_ANCHOR } from "../../core/skill-activation.js";
+import { type TurnConstraints, turnAllowsTool } from "../../core/turn-constraints.js";
 import type { MiddlewareHookRegistration } from "./runtime.js";
 import { isSkillSuggestionWait, SKILL_SUGGESTION_WAIT_CONTINUATION_MESSAGE } from "./stalled-turn.js";
 import { type MiddlewareEffect, metadataNumber } from "./types.js";
 
-/**
- * First-turn skills reminder. The skill-mastery batteries proved local
- * models read and ignore every ambient prompt channel but comply with the
- * identical instruction when it is visible user-message text, and
- * middleware reminders are the sanctioned mechanism for that text. Once
- * per session, on the first substantive task turn, when model-visible or
- * installable skills exist, this registration injects one compact line
- * teaching the same reply protocol as the context(scope="skills") listing
- * footer. Installable skills count because a fresh install has none
- * installed and a marketplace full of them: gating on installed alone meant
- * the one channel these models act on never fired for the operator who
- * needed it most. Reminder text only: loading stays operator-gated
- * (`pendingSkillPolicy` untouched), and a turn that already carries a
- * pending skill request gets no reminder because the operator has already
- * chosen.
- */
+/** Once per fresh session, offer ready workflows without making discovery a task prerequisite. */
 
 export const SKILLS_REMINDER_REGISTRATION_ID = "observer.skills-reminder";
 
 export { SKILL_SUGGESTION_ANCHOR };
 
 export function skillsReminderMessage(installed: number, installable = 0, modelActivation = false): string {
-	// Unconditional imperative, deliberately: the skill-mastery batteries
-	// showed literal local models comply with "list and check" but never act
-	// on wording that first asks them to classify the task as skill-shaped.
-	// One listing call on the session's first turn is the accepted price.
-	const counts =
-		installable > 0
-			? `${installed} installed, ${installable} installable from the marketplace`
-			: `${installed} installed`;
-	// Inline and non-blocking (issue #184): a 27B model read "and wait for the
-	// operator" as the whole job, spent a 40-second turn deliberating over the
-	// suggestion, and ended without one repository read. The suggestion is one
-	// line, the task continues in the same turn, and only the operator loads.
-	// At auto-edit and full-auto the model activates installed skills itself,
-	// so the reminder must not repeat "only the operator loads a skill": the
-	// literal models this line exists for act on it over the listing footer.
-	if (modelActivation) {
-		return (
-			`[Skills] ${counts}. Start this task by listing them with context(scope="skills") ` +
-			'and checking for a match; if one matches, load it with context(scope="skills", name="<name>") and ' +
-			"continue the task in the same turn. A marketplace skill is not installed and is offered for install " +
-			"when the operator runs it. If none match, do not mention skills and continue with the task."
-		);
-	}
-	return (
-		`[Skills] ${counts}. Start this task by listing them with context(scope="skills") ` +
-		"and checking for a match; if one matches, open your reply with the line " +
-		`\`${SKILL_SUGGESTION_ANCHOR}\` (a comma-separated sequence, in order, when several compose) ` +
-		"and then continue the task in the same turn without the skill. Only the operator loads a skill, and a " +
-		"marketplace skill is offered for install when the operator runs it. If none match, do not mention skills " +
-		"and continue with the task."
-	);
+	if (installed <= 0) return "";
+	const counts = `${installed} ready Clio skill${installed === 1 ? "" : "s"}`;
+	const discovery =
+		'If a workflow would help the requested work, inspect context(scope="skills"). Skip discovery for self-contained answers and respect tool and task restrictions. ';
+	const activation = modelActivation
+		? 'For a matching ready skill, load it with context(scope="skills", name="<name>") and continue the task in the same turn.'
+		: `For a match, suggest \`${SKILL_SUGGESTION_ANCHOR}\` and continue the task in the same turn without it; only the operator loads a skill.`;
+	return `[Skills] ${counts}. ${discovery}${activation}${installable > 0 ? " Marketplace installation requires operator approval." : ""}`;
 }
 
 export interface SkillsReminderDeps {
+	/** Same host-owned scope used by tool admission and prompt composition. */
+	getTurnConstraints?(): TurnConstraints | undefined;
 	/** Count of installed skills the model may see and suggest. */
 	countModelVisibleSkills(): number;
 	/**
 	 * Count of marketplace skills not yet installed. Optional; absent reads as
-	 * zero. Either count above zero arms the reminder.
+	 * zero. Marketplace entries alone never arm the reminder.
 	 */
 	countInstallableSkills?(): number;
 	/**
@@ -162,13 +127,24 @@ export function createSkillsReminderRegistration(deps: SkillsReminderDeps): Midd
 			"once per session, on the first substantive turn, teaches the skill-suggestion reply protocol; keeps a turn going that stopped on the suggestion",
 		hooks: ["turn_start", "turn_end"],
 		evaluate(input): ReadonlyArray<MiddlewareEffect> {
+			const constraints = deps.getTurnConstraints?.();
+			const suppressed =
+				constraints?.mode === "answer" ||
+				constraints?.mode === "proposal" ||
+				constraints?.skills === "disabled" ||
+				!turnAllowsTool(constraints, "context");
 			// The registration that teaches "suggest, then continue" owns the
 			// consequence when a model suggests and stops. The generic stalled-turn
 			// rule cannot see this case: the listing call counts as a tool call.
 			if (input.hook === "turn_end") {
-				return isSkillSuggestionWait(input)
-					? [{ kind: "request_continuation", message: SKILL_SUGGESTION_WAIT_CONTINUATION_MESSAGE }]
-					: NO_EFFECTS;
+				if (suppressed || !isSkillSuggestionWait(input)) return NO_EFFECTS;
+				try {
+					return deps.countModelVisibleSkills() > 0
+						? [{ kind: "request_continuation", message: SKILL_SUGGESTION_WAIT_CONTINUATION_MESSAGE }]
+						: NO_EFFECTS;
+				} catch {
+					return NO_EFFECTS;
+				}
 			}
 			const sessionId = input.sessionId ?? null;
 			if (lastSeenSessionId === undefined) {
@@ -214,6 +190,7 @@ export function createSkillsReminderRegistration(deps: SkillsReminderDeps): Midd
 			// task turn. Everything from here consumes the session's one chance.
 			if (!isSubstantiveUserTurn(input.text)) return NO_EFFECTS;
 			spentForActiveSession = true;
+			if (suppressed) return NO_EFFECTS;
 
 			// The operator already chose a skill for this turn; a reminder about
 			// suggesting one would only add noise.
@@ -223,11 +200,11 @@ export function createSkillsReminderRegistration(deps: SkillsReminderDeps): Midd
 			let installable = 0;
 			try {
 				installed = deps.countModelVisibleSkills();
+				if (installed <= 0) return NO_EFFECTS;
 				installable = deps.countInstallableSkills?.() ?? 0;
 			} catch {
 				return NO_EFFECTS;
 			}
-			if (installed <= 0 && installable <= 0) return NO_EFFECTS;
 			let modelActivation = false;
 			try {
 				modelActivation = deps.modelMayActivateSkills?.() ?? false;

package/src/domains/middleware/task-nudge.ts

@@ -52,6 +52,7 @@ export function createTaskNudgeRegistration(options: CreateTaskNudgeRegistration
 		hooks: ["turn_end"],
 		evaluate(input: MiddlewareHookInput): ReadonlyArray<MiddlewareEffect> {
 			if (input.hook !== "turn_end") return [];
+			if (input.metadata?.turnMode === "proposal" || input.metadata?.turnMode === "answer") return [];
 			// Only settled stop turns are candidates; aborted and errored turns
 			// already carry their own recovery path. Absent stopReason is "stop",
 			// mirroring the finish contract.

package/src/domains/middleware/watchdog.ts

@@ -257,6 +257,10 @@ export function createWatchdogRegistration(deps: WatchdogDeps): WatchdogRegistra
 				return NO_EFFECTS;
 			}
 			if (input.hook !== "turn_end") return NO_EFFECTS;
+			if (input.metadata?.stopReason === "error" || input.metadata?.stopReason === "aborted") {
+				resetTurn();
+				return NO_EFFECTS;
+			}
 			// A turn with no file mutations never fires. A middleware continuation
 			// re-evaluates turn_end with the accumulator already cleared, so it
 			// cannot fire a second run for the same change either.

package/src/domains/observability/extension.ts

@@ -1,3 +1,4 @@
+import { writeDiagnostic } from "../../core/diagnostics.js";
 /**
  * Observability domain wire-up. Listens to dispatch + safety bus channels and
  * folds payloads into telemetry/cost trackers. Other domains read the snapshot
@@ -103,7 +104,7 @@ async function buildAndIndexEvidence(
 		});
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
-		process.stderr.write(`[clio-coder:evidence] auto-build failed for run ${runId}: ${message}\n`);
+		writeDiagnostic(`[clio-coder:evidence] auto-build failed for run ${runId}: ${message}\n`);
 		hooks.onFailed(runId, message);
 	}
 }

package/src/domains/observability/out-of-turn-usage.ts

@@ -1,3 +1,4 @@
+import { writeDiagnostic } from "../../core/diagnostics.js";
 /**
  * Durable record of the model calls that were billed beside a session rather
  * than inside it: `/btw` side questions, `/handoff` extraction rounds, and the
@@ -143,7 +144,7 @@ export function appendOutOfTurnUsageRow(
 		}
 	} catch (error) {
 		if (options.required) throw new Error(`compaction usage row not written: ${messageOf(error)}`, { cause: error });
-		process.stderr.write(`[clio-coder:usage] out-of-turn usage row not written: ${messageOf(error)}\n`);
+		writeDiagnostic(`[clio-coder:usage] out-of-turn usage row not written: ${messageOf(error)}\n`);
 		return;
 	}
 	appendsSinceBoundCheck += 1;
@@ -152,7 +153,7 @@ export function appendOutOfTurnUsageRow(
 	try {
 		boundOutOfTurnUsageFile(path);
 	} catch (error) {
-		process.stderr.write(`[clio-coder:usage] out-of-turn usage ring not bounded: ${messageOf(error)}\n`);
+		writeDiagnostic(`[clio-coder:usage] out-of-turn usage ring not bounded: ${messageOf(error)}\n`);
 	}
 }
 

package/src/domains/observability/projection.ts

@@ -1,3 +1,4 @@
+import { writeDiagnostic } from "../../core/diagnostics.js";
 /**
  * Reactive observability projection. Folds the dispatch, provider, and
  * diagnostic bus channels plus the session cost/telemetry trackers into a
@@ -338,7 +339,7 @@ export function createObservabilityProjection(bus: SafeEventBus, deps: Projectio
 				listener(snapshot);
 			} catch (error) {
 				const message = error instanceof Error ? (error.stack ?? error.message) : String(error);
-				console.error(`[clio-coder:observability] projection listener crashed: ${message}`);
+				writeDiagnostic(`[clio-coder:observability] projection listener crashed: ${message}`, "error");
 			}
 		}
 	}
@@ -648,7 +649,7 @@ export function createObservabilityProjection(bus: SafeEventBus, deps: Projectio
 					summary.tokens.input += input;
 					summary.tokens.output += output;
 					summary.tokens.total += input + output + num(message.usage.cacheWrite, 0);
-					summary.lastContextTokens = input + output;
+					summary.lastContextTokens = input + output + num(message.usage.cacheWrite, 0);
 				}
 			}
 			// A worker's agent_end settles its displayed progress; only a terminal

package/src/domains/observability/worker-progress.ts

@@ -88,6 +88,13 @@ export interface WorkerAction {
  * renderer can skip a repaint by identity rather than by diffing text.
  */
 export interface WorkerProgressSnapshot {
+	/** Measured totals for the current attempt, absent until the producer reports them. */
+	inputTokens?: number;
+	outputTokens?: number;
+	processedTokens?: number;
+	/** Occupancy from the last completed model call, never cumulative usage. */
+	contextTokens?: number;
+	toolCalls?: number;
 	revision: number;
 	phase: WorkerProgressPhase;
 	/** Bounded worker prose: the live tail while running, the sealed answer once settled. */
@@ -252,6 +259,11 @@ const EMPTY_SNAPSHOT: WorkerProgressSnapshot = {
 
 export function createWorkerProgressFold(): WorkerProgressFold {
 	let revision = 0;
+	let inputTokens: number | undefined;
+	let outputTokens: number | undefined;
+	let processedTokens: number | undefined;
+	let contextTokens: number | undefined;
+	let toolCalls: number | undefined;
 	let phase: WorkerProgressPhase = "starting";
 	let tailText = "";
 	let droppedLines = 0;
@@ -339,6 +351,31 @@ export function createWorkerProgressFold(): WorkerProgressFold {
 		observe(event: unknown, nowMs = Date.now()): boolean {
 			if (!isRecord(event) || settled) return false;
 			let changed = false;
+			if (
+				event.type === "message_end" &&
+				isRecord(event.message) &&
+				event.message.role === "assistant" &&
+				isRecord(event.message.usage)
+			) {
+				const usage = event.message.usage;
+				const count = (value: unknown) => (typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0);
+				if (
+					typeof usage.input === "number" &&
+					Number.isFinite(usage.input) &&
+					usage.input >= 0 &&
+					typeof usage.output === "number" &&
+					Number.isFinite(usage.output) &&
+					usage.output >= 0
+				) {
+					const input = count(usage.input) + count(usage.cacheRead);
+					const output = count(usage.output);
+					inputTokens = (inputTokens ?? 0) + input;
+					outputTokens = (outputTokens ?? 0) + output;
+					processedTokens = (processedTokens ?? 0) + input + output + count(usage.cacheWrite);
+					contextTokens = input + output + count(usage.cacheWrite);
+					changed = touch();
+				}
+			}
 
 			const delta = workerTextDelta(event);
 			if (delta.length > 0) {
@@ -364,6 +401,7 @@ export function createWorkerProgressFold(): WorkerProgressFold {
 
 			const action = toolEventAction(event);
 			if (action !== null && event.type === "clio_coder_tool_start") {
+				if (action.toolCallId === undefined || !pendingActionsById.has(action.toolCallId)) toolCalls = (toolCalls ?? 0) + 1;
 				if (action.toolCallId !== undefined) {
 					const duplicate = pendingActionsById.get(action.toolCallId);
 					if (duplicate !== undefined) removePendingAction(duplicate);
@@ -413,6 +451,7 @@ export function createWorkerProgressFold(): WorkerProgressFold {
 		},
 
 		restart(): void {
+			inputTokens = outputTokens = processedTokens = contextTokens = toolCalls = undefined;
 			currentAction = null;
 			pendingActions.length = 0;
 			pendingActionsById.clear();
@@ -426,6 +465,15 @@ export function createWorkerProgressFold(): WorkerProgressFold {
 		snapshot(): WorkerProgressSnapshot {
 			if (cached !== null) return cached;
 			cached = {
+				...(inputTokens === undefined
+					? {}
+					: {
+							inputTokens,
+							outputTokens: outputTokens ?? 0,
+							processedTokens: processedTokens ?? 0,
+							contextTokens: contextTokens ?? 0,
+						}),
+				...(toolCalls === undefined ? {} : { toolCalls }),
 				revision,
 				phase,
 				tailText,