@iowarp/clio-coder 0.3.4 → 0.3.6

package/src/interactive/session-usage-reseed.ts

@@ -14,6 +14,11 @@
  * only the sink wiring between that fold and the observability projection.
  */
 
+import {
+	addResponseModelIdObservationCount,
+	emptyResponseModelIdObservationCounts,
+	type ResponseModelIdObservationCounts,
+} from "../core/response-model-id.js";
 import { ledgerUsageCalls, type SessionEntry, type SessionUsageDefaults } from "../domains/session/index.js";
 import { filterEntriesToActivePath } from "../domains/session/tree/active-path.js";
 
@@ -22,7 +27,7 @@ export interface SessionUsageSink {
 	resetSession(): void;
 	recordTokens(
 		providerId: string,
-		modelId: string,
+		attributedModelId: string,
 		tokens: number,
 		costUsd?: number,
 		breakdown?: {
@@ -35,6 +40,10 @@ export interface SessionUsageSink {
 			apiCalls?: number;
 		},
 		costProvenance?: never,
+		modelIdFacts?: {
+			requestedModelIds: ReadonlyArray<string>;
+			responseModelIdObservationCounts: Readonly<ResponseModelIdObservationCounts>;
+		},
 	): void;
 }
 
@@ -61,14 +70,31 @@ export function reseedSessionUsageFromLedger(
 	sink.resetSession();
 	const scoped = filterEntriesToActivePath(entries, activeLeafTurnId ?? undefined);
 	for (const call of ledgerUsageCalls(scoped, defaults)) {
-		sink.recordTokens(call.providerId, call.modelId, call.totalTokens, call.costUsd, {
-			input: call.input,
-			output: call.output,
-			cacheRead: call.cacheRead,
-			cacheWrite: call.cacheWrite,
-			reasoningTokens: call.reasoningTokens,
-			totalTokens: call.totalTokens,
-			apiCalls: call.apiCalls ?? 1,
-		});
+		const responseModelIdObservationCounts = emptyResponseModelIdObservationCounts();
+		addResponseModelIdObservationCount(
+			responseModelIdObservationCounts,
+			call.responseModelIdObservation,
+			call.apiCalls ?? 1,
+		);
+		sink.recordTokens(
+			call.providerId,
+			call.attributedModelId,
+			call.totalTokens,
+			call.costUsd,
+			{
+				input: call.input,
+				output: call.output,
+				cacheRead: call.cacheRead,
+				cacheWrite: call.cacheWrite,
+				reasoningTokens: call.reasoningTokens,
+				totalTokens: call.totalTokens,
+				apiCalls: call.apiCalls ?? 1,
+			},
+			undefined,
+			{
+				requestedModelIds: [call.requestedModelId],
+				responseModelIdObservationCounts,
+			},
+		);
 	}
 }

package/src/interactive/slash-commands.ts

@@ -393,7 +393,7 @@ export interface SlashCommandContext {
 		done(id: string): UserTask;
 		drop(id: string): UserTask;
 	};
-	/** Open the read-only `/memory` overlay: approved lessons and the live task bank. */
+	/** Open `/memory` for approved lessons, the live task bank, and reviewed promotion. */
 	openMemory: () => void;
 	/** Opt-in import from the newest structured handoff; absent when the host has no task bank. */
 	seedTaskMemory?: () => TaskMemorySeedCommandResult;
@@ -1036,7 +1036,7 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 	},
 	{
 		name: "memory",
-		description: "Inspect task memory or seed it from the newest handoff",
+		description: "Inspect, promote, or seed task memory",
 		group: "Inspect",
 		kinds: ["memory", "memory-seed"],
 		subcommandDescriptions: { seed: "Seed the task bank from the newest handoff" },

package/src/interactive/status/summary.ts

@@ -1,3 +1,4 @@
+import { responseModelIdObservationFromRecord } from "../../core/response-model-id.js";
 import { estimateReasoningTextTokens, extractReasoningTokens } from "../../domains/session/context-accounting.js";
 import type { AgentMessage } from "../../engine/types.js";
 import type { ReasoningTokenProvenance, RunTally, TurnStopReason, TurnSummary, WatchdogTier } from "./types.js";
@@ -65,6 +66,7 @@ export function emptyRunTally(): RunTally {
 		hadEstimatedReasoning: false,
 		toolCount: 0,
 		toolErrorCount: 0,
+		responseModelIdObservation: { state: "not-observed" },
 	};
 }
 
@@ -85,8 +87,10 @@ export function foldMessageIntoRunTally(tally: RunTally, message: AgentMessage):
 	}
 	if (message.role !== "assistant") return tally;
 	const usage = (message as { usage?: UsageLike }).usage;
+	const record = message as unknown as Record<string, unknown>;
 	const next: RunTally = {
 		...tally,
+		responseModelIdObservation: responseModelIdObservationFromRecord(record, "not-observed"),
 		inputTokens: tally.inputTokens + (usage ? finite(usage.input) : 0),
 		outputTokens: tally.outputTokens + (usage ? finite(usage.output) : 0),
 		cacheReadTokens: tally.cacheReadTokens + (usage ? finite(usage.cacheRead) : 0),
@@ -145,6 +149,7 @@ export function summaryFromRunTally(tally: RunTally, input: SummaryFromTallyInpu
 		...(input.stopDetail !== undefined ? { stopDetail: input.stopDetail } : {}),
 		watchdogPeak: input.watchdogPeak,
 		truncated: input.truncated === true,
+		responseModelIdObservation: tally.responseModelIdObservation,
 	};
 	if (tally.hadProviderReasoning || tally.hadEstimatedReasoning) {
 		summary.reasoningTokens = tally.reasoningTokens;

package/src/interactive/status/types.ts

@@ -1,4 +1,5 @@
 import type { StatusPhase, WatchdogTier } from "../../core/bus-events.js";
+import type { ResponseModelIdObservation } from "../../core/response-model-id.js";
 
 // StatusPhase, WatchdogTier, and AgentStatusChangedPayload moved to
 // src/core/bus-events.ts (the phase taxonomy rides the agent.status.changed
@@ -29,6 +30,8 @@ export interface DispatchOverlay {
 export interface TurnSummary {
 	elapsedMs: number;
 	modelId: string;
+	/** Direct response model-id observation for the last API call in the turn. */
+	responseModelIdObservation: ResponseModelIdObservation;
 	targetId: string;
 	inputTokens: number;
 	outputTokens: number;
@@ -70,6 +73,8 @@ export interface RunTally {
 	hadEstimatedReasoning: boolean;
 	toolCount: number;
 	toolErrorCount: number;
+	/** Direct response model-id observation for the last assistant call folded. */
+	responseModelIdObservation: ResponseModelIdObservation;
 }
 
 export interface OverlayFrame {

package/src/interactive/terminal-lease.ts

@@ -189,6 +189,7 @@ export function createProcessTerminalLease(options: CreateProcessTerminalLeaseOp
 		getModelLabel: () => editorChrome.getModelLabel(),
 		getThinkingLabel: () => editorChrome.getThinkingLabel(),
 		isStreaming: () => editorChrome.isStreaming?.() ?? false,
+		isAwaitingApproval: () => editorChrome.isAwaitingApproval?.() ?? false,
 		willEnterSteer: (text) => editorChrome.willEnterSteer?.(text) ?? false,
 		getSubmitKeyLabel: () => editorChrome.getSubmitKeyLabel?.() ?? "Enter",
 		getNewlineKeyLabel: () => editorChrome.getNewlineKeyLabel?.() ?? "Shift+Enter",

package/src/interactive/turn-context.ts

@@ -23,7 +23,12 @@ import { selectVisibleEntries } from "../domains/context/working-set/visible.js"
 import type { ObservabilityContract } from "../domains/observability/contract.js";
 import type { CompiledSessionPrompt, SessionPromptInputs } from "../domains/prompts/compiler.js";
 import type { PromptsContract } from "../domains/prompts/contract.js";
-import type { ProvidersContract } from "../domains/providers/index.js";
+import {
+	type ContextWindowDetails,
+	type ContextWindowSource,
+	type ProvidersContract,
+	resolveRuntimeTarget,
+} from "../domains/providers/index.js";
 import type { LocalModelQuirks } from "../domains/providers/types/local-model-quirks.js";
 import {
 	AutoCompactionTrigger,
@@ -309,6 +314,75 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 		return ceilChars(snapshot.pendingUserInput.length);
 	};
 
+	/**
+	 * The window the next turn will resolve to, read the way ensureRuntime
+	 * reads it but without building an agent. Before the first turn of a
+	 * process, /resume included, state.runtime is null, and the ledger and the
+	 * footer meter said `context window unknown · 0 tokens` until a turn ran
+	 * (issue #189). Null when no target is configured or it does not resolve,
+	 * and the overlay's "unknown" is then true.
+	 */
+	const resolveWindowWithoutRuntime = (): ContextWindowDetails | null => {
+		const settings = deps.getSettings();
+		const targetId = settings.orchestrator?.target?.trim();
+		const wireModelId = settings.orchestrator?.model?.trim();
+		if (!targetId || !wireModelId) return null;
+		const resolved = resolveRuntimeTarget(deps.providers, {
+			targetId,
+			wireModelId,
+			requestedThinkingLevel: settings.orchestrator?.thinkingLevel ?? "off",
+			use: "orchestrator",
+			requireTools: false,
+			requireOutputBudget: true,
+		});
+		return resolved.ok ? resolved.target.contextWindowDetails : null;
+	};
+
+	const CONTEXT_WINDOW_SOURCES: ReadonlySet<string> = new Set<ContextWindowSource>([
+		"catalog",
+		"probe",
+		"loaded",
+		"target-override",
+		"model-hint",
+		"descriptor-default",
+		"unknown",
+	]);
+
+	/** The snapshot stores its source as a plain string; only a known label is worth repeating. */
+	const snapshotWindowSource = (snapshot: ContextSnapshot): ContextWindowSource | null =>
+		CONTEXT_WINDOW_SOURCES.has(snapshot.contextWindowSource)
+			? (snapshot.contextWindowSource as ContextWindowSource)
+			: null;
+
+	/**
+	 * Window facts while no runtime exists: the live resolution first, then the
+	 * resumed snapshot's recorded window, which is what the previous process
+	 * measured the same messages against.
+	 */
+	const windowWithoutRuntime = (): {
+		contextWindow: number;
+		contextWindowSource: ContextWindowSource | null;
+		contextWindowSlots: ContextWindowDetails["contextWindowSlots"];
+	} => {
+		const details = resolveWindowWithoutRuntime();
+		if (details) {
+			return {
+				contextWindow: details.effectiveContextWindow,
+				contextWindowSource: details.contextWindowSource,
+				contextWindowSlots: details.contextWindowSlots,
+			};
+		}
+		const snapshot = currentContextSnapshot;
+		if (snapshot && snapshot.effectiveContextWindow > 0) {
+			return {
+				contextWindow: snapshot.effectiveContextWindow,
+				contextWindowSource: snapshotWindowSource(snapshot),
+				contextWindowSlots: null,
+			};
+		}
+		return { contextWindow: 0, contextWindowSource: null, contextWindowSlots: null };
+	};
+
 	const liveContextEstimate = (agentRuntime: AgentRuntime, pendingUserText?: string): LiveContextEstimate => {
 		const contextWindow = agentRuntime.runtimeResolution.contextWindowDetails.effectiveContextWindow;
 		const estimateInput = {
@@ -846,8 +920,9 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 		},
 
 		contextUsage(): ContextUsageSnapshot {
-			if (!state.runtime) return contextUsageSnapshot(null, 0);
-			const effectiveWindow = state.runtime.runtimeResolution.contextWindowDetails.effectiveContextWindow;
+			const effectiveWindow = state.runtime
+				? state.runtime.runtimeResolution.contextWindowDetails.effectiveContextWindow
+				: windowWithoutRuntime().contextWindow;
 			if (!currentContextSnapshot) {
 				return contextUsageSnapshot(null, effectiveWindow);
 			}
@@ -867,28 +942,27 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 			const settings = deps.getSettings();
 			const compactionThreshold = settings.compaction?.threshold ?? null;
 			const compactionAuto = settings.compaction?.auto !== false;
-			if (!state.runtime) {
-				return buildContextLedger({
-					provider: settings.orchestrator?.target ?? null,
-					model: settings.orchestrator?.model ?? null,
-					contextWindow: 0,
-					compactionThreshold,
-					compactionAuto,
-				});
-			}
-			const windowDetails = state.runtime.runtimeResolution.contextWindowDetails;
-			const effectiveWindow = windowDetails.effectiveContextWindow;
-
-			const provider = state.runtime.targetId ?? settings.orchestrator?.target ?? null;
-			const model = state.runtime.wireModelId ?? settings.orchestrator?.model ?? null;
+			// Without a runtime (before the first turn of this process, /resume
+			// included) the window comes from the live resolution or the resumed
+			// snapshot, and the token facts from the snapshot: the resumed
+			// messages are the ones it measured.
+			const window = state.runtime
+				? {
+						contextWindow: state.runtime.runtimeResolution.contextWindowDetails.effectiveContextWindow,
+						contextWindowSource: state.runtime.runtimeResolution.contextWindowDetails.contextWindowSource,
+						contextWindowSlots: state.runtime.runtimeResolution.contextWindowDetails.contextWindowSlots,
+					}
+				: windowWithoutRuntime();
+			const provider = state.runtime?.targetId ?? settings.orchestrator?.target ?? null;
+			const model = state.runtime?.wireModelId ?? settings.orchestrator?.model ?? null;
+			const liveToolCount = state.runtime?.agent.state.tools.length ?? 0;
 
 			if (!currentContextSnapshot) {
 				return buildContextLedger({
 					provider,
 					model,
-					contextWindow: effectiveWindow,
-					contextWindowSource: windowDetails.contextWindowSource,
-					toolCount: state.runtime.agent.state.tools.length,
+					...window,
+					toolCount: liveToolCount,
 					compactionThreshold,
 					compactionAuto,
 					promptCache: lastPromptCache,
@@ -903,15 +977,14 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 			return buildContextLedger({
 				provider,
 				model,
-				contextWindow: effectiveWindow,
-				contextWindowSource: windowDetails.contextWindowSource,
+				...window,
 				compactionThreshold,
 				compactionAuto,
 				systemPromptTokens: currentContextSnapshot.categories.system,
 				toolSchemaTokens: currentContextSnapshot.categories.tools,
 				// Persisted snapshots strip the captured schemas; fall back to
 				// the live agent state after a session resume.
-				toolCount: currentContextSnapshot.activeToolSchemas?.length ?? state.runtime.agent.state.tools.length,
+				toolCount: currentContextSnapshot.activeToolSchemas?.length ?? liveToolCount,
 				messageTokens: currentContextSnapshot.categories.messages,
 				agentsTokens: currentContextSnapshot.categories.agents,
 				skillsTokens: currentContextSnapshot.categories.skills,

package/src/interactive/turn-middleware.ts

@@ -205,6 +205,7 @@ export function createTurnMiddleware(deps: TurnMiddlewareDeps): TurnMiddleware {
 				runtimeTier: agentRuntime.runtimeResolution.runtimeTier ?? "",
 				activeToolNames: toolNamesFromAgentState(agentRuntime.agent.state.tools).join(","),
 				turnToolCalls: state.turnToolCalls,
+				turnToolNames: state.turnToolNames.join(","),
 				sharedWorkerNote: state.turnSharedWorkerNote,
 			};
 			if (terminalToolResult !== undefined) {

package/src/interactive/turn-runtime.ts

@@ -7,6 +7,7 @@
 
 import { performance } from "node:perf_hooks";
 import type { ClioSettings } from "../core/config.js";
+import { attributedModelId } from "../core/response-model-id.js";
 import type { MiddlewareToolChoiceControl } from "../domains/middleware/index.js";
 import type { ObservabilityContract } from "../domains/observability/contract.js";
 import {
@@ -15,7 +16,7 @@ import {
 	type ProvidersContract,
 	refineRuntimeTargetWithModelHints,
 	resolveRuntimeTarget,
-	runtimeResolutionWarnings,
+	runtimeResolutionWarningsBesideThinkingNotice,
 	type TargetStatus,
 	targetRequiresAuth,
 } from "../domains/providers/index.js";
@@ -199,7 +200,12 @@ export function createTurnRuntime(deps: TurnRuntimeDeps): TurnRuntime {
 				failure?.code ?? "admission-failed",
 			);
 		}
-		for (const message of runtimeResolutionWarnings(resolved.diagnostics)) {
+		// emitThinkingClampNotice prints the one combined thinking line when the
+		// dial takes effect; the thinking diagnostics are its two halves.
+		for (const message of runtimeResolutionWarningsBesideThinkingNotice(
+			resolved.diagnostics,
+			resolved.target.modelRuntime.thinking.notice,
+		)) {
 			const key = `${targetId}|${wireModelId}|${message}`;
 			if (announcedResolutionWarnings.has(key)) continue;
 			announcedResolutionWarnings.add(key);
@@ -229,6 +235,7 @@ export function createTurnRuntime(deps: TurnRuntimeDeps): TurnRuntime {
 	 */
 	const TARGET_PROBE_TTL_MS = 5 * 60 * 1000;
 	let lastTargetProbe: { key: string; at: number } | null = null;
+	const targetProbesInFlight = new Map<string, Promise<void>>();
 	const ensureLiveCapabilitiesForSelectedModel = async (): Promise<void> => {
 		const settings = deps.getSettings();
 		const targetId = settings.orchestrator.target?.trim();
@@ -239,16 +246,29 @@ export function createTurnRuntime(deps: TurnRuntimeDeps): TurnRuntime {
 		const runtimeDesc = deps.providers.getRuntime(target.runtime);
 		if (!runtimeDesc || runtimeDesc.tier === "cloud") return;
 		const key = `${targetId}|${wireModelId}`;
+		const inFlight = targetProbesInFlight.get(key);
+		if (inFlight) {
+			await inFlight;
+			return;
+		}
 		const now = Date.now();
 		if (lastTargetProbe?.key === key && now - lastTargetProbe.at < TARGET_PROBE_TTL_MS) return;
 		lastTargetProbe = { key, at: now };
-		let status: Awaited<ReturnType<ProvidersContract["probeTarget"]>> = null;
+		const probe = (async (): Promise<void> => {
+			let status: Awaited<ReturnType<ProvidersContract["probeTarget"]>> = null;
+			try {
+				status = await deps.providers.probeTarget(targetId);
+			} catch {
+				// Fall back to the last known target state.
+			}
+			announceColdModel(status, targetId, wireModelId);
+		})();
+		targetProbesInFlight.set(key, probe);
 		try {
-			status = await deps.providers.probeTarget(targetId);
-		} catch {
-			// Fall back to the last known target state.
+			await probe;
+		} finally {
+			if (targetProbesInFlight.get(key) === probe) targetProbesInFlight.delete(key);
 		}
-		announceColdModel(status, targetId, wireModelId);
 	};
 
 	/** One notice per target+model+state, so a repeated probe stays quiet. */
@@ -589,6 +609,7 @@ export function createTurnRuntime(deps: TurnRuntimeDeps): TurnRuntime {
 				middlewareToolChoice.toolStarted(event.toolName);
 				deps.toolStartTimes.set(event.toolCallId, eventClock);
 				state.turnToolCalls += 1;
+				state.turnToolNames.push(event.toolName);
 			} else if (event.type === "tool_execution_end") {
 				toolsInFlight = Math.max(0, toolsInFlight - 1);
 				const startedAt = deps.toolStartTimes.get(event.toolCallId);
@@ -713,7 +734,11 @@ export function createTurnRuntime(deps: TurnRuntimeDeps): TurnRuntime {
 				if (summary.hadUsage && (summary.tokens > 0 || summary.costUsd > 0)) {
 					deps.observability.recordTokens(
 						localRuntime.targetId,
-						localRuntime.wireModelId,
+						attributedModelId(
+							summary.lastResponseModelIdObservation,
+							localRuntime.wireModelId,
+							summary.lastDifferingResponseModelId,
+						),
 						summary.tokens,
 						summary.costUsd,
 						{
@@ -726,6 +751,10 @@ export function createTurnRuntime(deps: TurnRuntimeDeps): TurnRuntime {
 							apiCalls: summary.apiCalls,
 						},
 						localRuntime.runtimeResolution.costProvenance,
+						{
+							requestedModelIds: [localRuntime.wireModelId],
+							responseModelIdObservationCounts: summary.responseModelIdObservationCounts,
+						},
 					);
 				}
 				if (summary.output > 0 && firstAssistantDeltaAt !== null) {

package/src/interactive/turn-state.ts

@@ -97,6 +97,8 @@ export interface ChatTurnState {
 	toolProseAssessedChars: number;
 	/** Tool calls observed in the current turn; feeds turn_end metadata. */
 	turnToolCalls: number;
+	/** Names of those calls, in order, so turn_end can tell a listing-only turn from a working one. */
+	turnToolNames: string[];
 	/** A `[worker result]` note the operator shared entered this turn, as the prompt or as a steer; feeds turn_end metadata. */
 	turnSharedWorkerNote: boolean;
 	/** One stalled-turn nudge per user prompt; reset when a real prompt arrives. */
@@ -123,6 +125,7 @@ export function createTurnState(initialThinkingLevel: ThinkingLevel): ChatTurnSt
 		streamStallReason: null,
 		toolProseAssessedChars: 0,
 		turnToolCalls: 0,
+		turnToolNames: [],
 		turnSharedWorkerNote: false,
 		stalledTurnNudgeSpent: false,
 		pendingRequestContinuation: false,