@iowarp/clio-coder 0.4.0 → 0.4.2

package/src/engine/acp/server.ts

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import { realpathSync } from "node:fs";
 import { isAbsolute, resolve as resolvePath } from "node:path";
 import {
+	type AccountabilityEvidenceReadyPayload,
 	BusChannels,
 	type DispatchCompletedPayload,
 	type DispatchEnqueuedPayload,
@@ -77,10 +78,10 @@ export interface AcpSafeSettingsSnapshot extends AcpRoutingSnapshot {
 }
 
 export type AcpSafeSettingsPatch = Partial<{
-	"orchestrator.target": string | null;
-	"orchestrator.model": string | null;
-	"orchestrator.thinkingLevel": AcpThinkingLevel;
-	autonomy: AutonomyLevel;
+	"chat.target": string | null;
+	"chat.model": string | null;
+	"chat.thinkingLevel": AcpThinkingLevel;
+	"safety.autonomy": AutonomyLevel;
 }>;
 
 export interface AcpSettingsControl {
@@ -209,6 +210,8 @@ interface AcpServerUsage {
 	cacheRead: number;
 	cacheWrite: number;
 	reasoning: number;
+	totalTokens: number;
+	costUsd: number;
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {
@@ -333,7 +336,10 @@ const ACP_MAX_REPLAY_TOOL_CALLS = 8192;
  * the list is the allowlist, and a client's requested kinds are intersected
  * with it rather than trusted. `safety.loopBlocked` was the first member; the
  * dispatch lifecycle joined it so a client can draw a live fleet board from
- * reported facts instead of inferring one from tool titles or timing.
+ * reported facts instead of inferring one from tool titles or timing;
+ * `accountability.evidenceReady` follows a run's terminal event once its
+ * evidence bundle has landed, so the board can show first-pass success and a
+ * finding count without reading Clio's state tree.
  */
 const ACP_FORWARDABLE_EVENT_KINDS = [
 	"safety.loopBlocked",
@@ -342,6 +348,7 @@ const ACP_FORWARDABLE_EVENT_KINDS = [
 	"dispatch.progress",
 	"dispatch.completed",
 	"dispatch.failed",
+	"accountability.evidenceReady",
 ] as const;
 
 type AcpForwardableEventKind = (typeof ACP_FORWARDABLE_EVENT_KINDS)[number];
@@ -359,6 +366,9 @@ const ACP_MAX_DISPATCH_TASK_PREVIEW_BYTES = 160;
 
 /** Wire bound for the short identifiers a dispatch event carries. */
 const ACP_MAX_DISPATCH_ID_BYTES = 128;
+/** Evidence tags are a closed vocabulary of short identifiers; anything wider is not a tag. */
+const ACP_MAX_EVIDENCE_TAGS = 32;
+const ACP_MAX_EVIDENCE_TAG_BYTES = 64;
 
 /**
  * Progress events forwarded per run before the stream is capped. One run
@@ -521,8 +531,8 @@ function utf8Bytes(value: string): number {
 	return Buffer.byteLength(value, "utf8");
 }
 
-function emptyUsage(): AcpServerUsage {
-	return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0 };
+export function emptyUsage(): AcpServerUsage {
+	return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0, totalTokens: 0, costUsd: 0 };
 }
 
 function createActivePromptState(): ActivePrompt {
@@ -552,15 +562,33 @@ function finite(value: unknown): number {
 	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
 }
 
-function mergeUsage(into: AcpServerUsage, usage: unknown): void {
+/** Only field `sumRunUsage` (chat-loop-messages.ts) reads for a dollar figure; matched here so ACP never re-derives cost through a separate path. */
+function costTotal(usage: Record<string, unknown>): number {
+	const cost = usage.cost;
+	return isRecord(cost) ? finite(cost.total) : 0;
+}
+
+export function mergeUsage(into: AcpServerUsage, usage: unknown): void {
 	if (!isRecord(usage)) return;
-	into.input +=
+	const input =
 		finite(usage.input) + finite(usage.inputTokens) + finite(usage.input_tokens) + finite(usage.prompt_tokens);
-	into.output +=
+	const output =
 		finite(usage.output) + finite(usage.outputTokens) + finite(usage.output_tokens) + finite(usage.completion_tokens);
-	into.cacheRead += finite(usage.cacheRead) + finite(usage.cacheReadTokens) + finite(usage.cache_read_tokens);
-	into.cacheWrite += finite(usage.cacheWrite) + finite(usage.cacheWriteTokens) + finite(usage.cache_write_tokens);
-	into.reasoning += finite(usage.reasoning) + finite(usage.reasoningTokens) + finite(usage.reasoning_tokens);
+	const cacheRead = finite(usage.cacheRead) + finite(usage.cacheReadTokens) + finite(usage.cache_read_tokens);
+	const cacheWrite = finite(usage.cacheWrite) + finite(usage.cacheWriteTokens) + finite(usage.cache_write_tokens);
+	const reasoning = finite(usage.reasoning) + finite(usage.reasoningTokens) + finite(usage.reasoning_tokens);
+	into.input += input;
+	into.output += output;
+	into.cacheRead += cacheRead;
+	into.cacheWrite += cacheWrite;
+	into.reasoning += reasoning;
+	// Same fallback sumRunUsage uses: prefer the provider's own total, otherwise
+	// sum the four merged categories for this message (reasoning excluded,
+	// matching sumRunUsage, since a provider that reports reasoning separately
+	// still counts it inside output for billing).
+	const explicitTotal = finite(usage.totalTokens) + finite(usage.total_tokens);
+	into.totalTokens += explicitTotal > 0 ? explicitTotal : input + output + cacheRead + cacheWrite;
+	into.costUsd += costTotal(usage);
 }
 
 function mergeMessageUsage(into: AcpServerUsage, message: unknown, seen?: WeakSet<object>): void {
@@ -676,21 +704,26 @@ function eventTextDelta(event: AcpEventRecord): string {
 }
 
 /**
- * The next unused `clio-tool-<n>`. The counter alone is not enough: an engine
- * that names its own calls `clio-tool-1` would otherwise collide with an alias
+ * The next unused `clio-coder-tool-<n>`. The counter alone is not enough: an engine
+ * that names its own calls `clio-coder-tool-1` would otherwise collide with an alias
  * this server minted, and two different calls sharing one wire id is the exact
  * failure aliasing exists to prevent.
  */
 function nextAliasToolCallId(active: ActivePrompt): string {
 	for (;;) {
 		active.toolCallSequence += 1;
-		const alias = `clio-tool-${active.toolCallSequence}`;
+		const alias = `clio-coder-tool-${active.toolCallSequence}`;
 		if (active.usedWireIds.has(alias)) continue;
 		active.usedWireIds.add(alias);
 		return alias;
 	}
 }
 
+function normalizeReleasedAliasToolCallId(engineId: string): string {
+	const legacy = /^clio-tool-([1-9]\d*)$/u.exec(engineId);
+	return legacy === null ? engineId : `clio-coder-tool-${legacy[1]}`;
+}
+
 /** Records `wireId` as the newest wire id this engine id speaks under. */
 function pushWireId(active: ActivePrompt, engineId: string, wireId: string): string {
 	const existing = active.toolCallWireIds.get(engineId);
@@ -705,9 +738,10 @@ function pushWireId(active: ActivePrompt, engineId: string, wireId: string): str
  * call travels under a per-prompt alias.
  */
 function mintWireId(active: ActivePrompt, engineId: string): string {
-	const usable = utf8Bytes(engineId) <= ACP_MAX_TOOL_CALL_ID_BYTES && !active.usedWireIds.has(engineId);
-	if (usable) active.usedWireIds.add(engineId);
-	return pushWireId(active, engineId, usable ? engineId : nextAliasToolCallId(active));
+	const candidate = normalizeReleasedAliasToolCallId(engineId);
+	const usable = utf8Bytes(candidate) <= ACP_MAX_TOOL_CALL_ID_BYTES && !active.usedWireIds.has(candidate);
+	if (usable) active.usedWireIds.add(candidate);
+	return pushWireId(active, engineId, usable ? candidate : nextAliasToolCallId(active));
 }
 
 /**
@@ -975,14 +1009,14 @@ function handleChatEvent(
 		if (last !== undefined) applyStopReason(active, last);
 		return;
 	}
-	// Clio lifecycle events (agent_start, retry_status, clio_plan_update) have
+	// Clio lifecycle events (agent_start, retry_status, clio_coder_plan_update) have
 	// no ACP v1 SessionUpdate equivalent. The prompt turn is bounded by the
 	// session/prompt response, so emitting non-spec `progress` updates would
 	// break strict clients. They are intentionally dropped. The same protocol
 	// gap applies to routing advisories (external settings divergence, active
 	// target removed): ACP v1 has no agent-initiated advisory channel, so the
 	// orchestrator records those as `custom` session-ledger entries
-	// (customType "clio.routing-notice") instead of inventing update kinds.
+	// (customType "clio-coder.routing-notice") instead of inventing update kinds.
 }
 
 const ACP_MAX_SESSION_ID_BYTES = 128;
@@ -1259,12 +1293,7 @@ function sessionResultMeta(
 	};
 }
 
-const ACP_SAFE_SETTINGS_KEYS = [
-	"orchestrator.target",
-	"orchestrator.model",
-	"orchestrator.thinkingLevel",
-	"autonomy",
-] as const;
+const ACP_SAFE_SETTINGS_KEYS = ["chat.target", "chat.model", "chat.thinkingLevel", "safety.autonomy"] as const;
 const ACP_THINKING_LEVELS = new Set<AcpThinkingLevel>(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
 const ACP_AUTONOMY_LEVELS = new Set<AutonomyLevel>(["read-only", "suggest", "auto-edit", "full-auto"]);
 const ACP_MAX_TARGETS = 64;
@@ -1288,12 +1317,12 @@ function safeSettingsProjection(snapshot: AcpSafeSettingsSnapshot): Record<strin
 	const autonomy = ACP_AUTONOMY_LEVELS.has(snapshot.autonomy) ? snapshot.autonomy : DEFAULT_AUTONOMY_LEVEL;
 	return {
 		settings: {
-			orchestrator: {
+			chat: {
 				target: safeConfiguredIdentifier(snapshot.target, ACP_MAX_TARGET_ID_BYTES),
 				model: safeConfiguredIdentifier(snapshot.model, ACP_MAX_MODEL_ID_BYTES),
 				thinkingLevel,
 			},
-			autonomy,
+			safety: { autonomy },
 		},
 		editable: [...ACP_SAFE_SETTINGS_KEYS],
 	};
@@ -1856,6 +1885,29 @@ export async function serveClioAcpAgent(options: ClioAcpServerOptions): Promise<
 				});
 			}),
 		);
+		unsubscribeEvents.push(
+			bus.on(BusChannels.AccountabilityEvidenceReady, (payload: AccountabilityEvidenceReadyPayload) => {
+				// Arrives after dispatch.completed or dispatch.failed for the same run,
+				// so it is terminal too: nothing about that run follows it. The
+				// bundle's prose (findings, overview) stays behind; only the summary
+				// counters the projection itself carries cross, and the tags are
+				// filtered to bounded identifiers rather than truncated into new ones.
+				const runId = safeStoredIdentifier(payload.runId, ACP_MAX_DISPATCH_ID_BYTES);
+				const evidenceId = safeStoredIdentifier(payload.evidenceId, ACP_MAX_DISPATCH_ID_BYTES);
+				if (runId === null || evidenceId === null) return;
+				const tags = (Array.isArray(payload.tags) ? payload.tags : [])
+					.map((tag) => safeStoredIdentifier(tag, ACP_MAX_EVIDENCE_TAG_BYTES))
+					.filter((tag): tag is string => tag !== null)
+					.slice(0, ACP_MAX_EVIDENCE_TAGS);
+				forwardEvent("accountability.evidenceReady", null, true, {
+					runId,
+					evidenceId,
+					firstPassSuccess: payload.firstPassSuccess === true,
+					findingCount: safeCount(payload.findingCount),
+					tags,
+				});
+			}),
+		);
 	}
 	const unsubscribeEventStream = (): void => {
 		for (const unsubscribe of unsubscribeEvents) unsubscribe();
@@ -2318,7 +2370,7 @@ export async function serveClioAcpAgent(options: ClioAcpServerOptions): Promise<
 				throw new AcpRequestError(-32602, "patch contains an unknown setting", { code: "invalid_params" });
 			}
 			switch (key) {
-				case "orchestrator.target": {
+				case "chat.target": {
 					if (value === null) {
 						patch[key] = null;
 						break;
@@ -2333,16 +2385,16 @@ export async function serveClioAcpAgent(options: ClioAcpServerOptions): Promise<
 					patch[key] = target;
 					break;
 				}
-				case "orchestrator.model":
+				case "chat.model":
 					patch[key] = value === null ? null : requireBoundedClientString(value, key, ACP_MAX_MODEL_ID_BYTES);
 					break;
-				case "orchestrator.thinkingLevel":
+				case "chat.thinkingLevel":
 					if (typeof value !== "string" || !ACP_THINKING_LEVELS.has(value as AcpThinkingLevel)) {
 						throw new AcpRequestError(-32602, "invalid thinking level", { code: "invalid_params" });
 					}
 					patch[key] = value as AcpThinkingLevel;
 					break;
-				case "autonomy":
+				case "safety.autonomy":
 					if (typeof value !== "string" || !ACP_AUTONOMY_LEVELS.has(value as AutonomyLevel)) {
 						throw new AcpRequestError(-32602, "invalid autonomy level", { code: "invalid_params" });
 					}
@@ -2351,8 +2403,8 @@ export async function serveClioAcpAgent(options: ClioAcpServerOptions): Promise<
 			}
 		}
 		const current = options.settings.read();
-		const nextTarget = patch["orchestrator.target"] === undefined ? current.target : patch["orchestrator.target"];
-		const nextModel = patch["orchestrator.model"] === undefined ? current.model : patch["orchestrator.model"];
+		const nextTarget = patch["chat.target"] === undefined ? current.target : patch["chat.target"];
+		const nextModel = patch["chat.model"] === undefined ? current.model : patch["chat.model"];
 		if (nextTarget === null && nextModel !== null) {
 			throw new AcpRequestError(-32602, "model requires a configured target", { code: "invalid_params" });
 		}
@@ -2606,6 +2658,8 @@ function promptResponse(stopReason: string, active: ActivePrompt): AcpPromptResp
 				cacheRead: active.usage.cacheRead,
 				cacheWrite: active.usage.cacheWrite,
 				reasoning: active.usage.reasoning,
+				totalTokens: active.usage.totalTokens,
+				costUsd: active.usage.costUsd,
 			},
 		},
 	};

package/src/engine/acp/tool-mediator.ts

@@ -27,7 +27,7 @@ interface MediatorInput {
 	toolGovernance: DelegationToolGovernance;
 	/**
 	 * Session autonomy level (sd-01 §2.5). Applied after the safety net under
-	 * clio-policy governance; `ask` dispositions resolve as non-stall denials
+	 * clio-coder-policy governance; `ask` dispositions resolve as non-stall denials
 	 * because a delegation has no operator to answer a prompt.
 	 */
 	autonomy?: AutonomyLevel;
@@ -579,7 +579,7 @@ export class AcpToolMediator {
 		let safetyDecision: SafetyDecision | undefined;
 
 		if (mapped.validationError !== undefined) {
-			if (this.input.toolGovernance === "clio-policy") {
+			if (this.input.toolGovernance === "clio-coder-policy") {
 				const invalidSafetyDecisions = mapped.evaluations.map((evaluation) =>
 					this.input.safety.evaluate({ tool: evaluation.tool, args: evaluation.args }),
 				);

package/src/engine/acp/types.ts

@@ -34,7 +34,7 @@ export const ACP_MAX_CHUNK_BYTES = 16384;
  * Upper bound on a `toolCallId` this server puts on the wire, in UTF-8 bytes
  * (CONTRACT C001 §3). Identity is one call per id in both directions: an engine
  * id over this bound, missing, or already claimed by another call this turn
- * travels under a `clio-tool-<n>` alias, and an engine id starting a second call
+ * travels under a `clio-coder-tool-<n>` alias, and an engine id starting a second call
  * mints a fresh alias rather than reusing the first call's wire id. A permission
  * request binds only to an id the client already received a `tool_call` for and
  * has not yet seen finish; nothing is minted on that path.

package/src/engine/alcf-oauth.ts

@@ -40,7 +40,7 @@ function randomState(): string {
 	return base64Url(bytes);
 }
 
-export function buildAuthorizeUrl(params: { challenge: string; state: string }): string {
+function buildAuthorizeUrl(params: { challenge: string; state: string }): string {
 	const query = new URLSearchParams({
 		client_id: AUTH_CLIENT_ID,
 		response_type: "code",
@@ -55,7 +55,7 @@ export function buildAuthorizeUrl(params: { challenge: string; state: string }):
 	return `${AUTHORIZE_URL}?${query.toString()}`;
 }
 
-export function parseAuthorizationInput(input: string): string {
+function parseAuthorizationInput(input: string): string {
 	const value = input.trim();
 	if (!value) return "";
 	try {
@@ -89,7 +89,7 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null;
 }
 
-export function selectGatewayGrant(payload: GlobusTokenResponse): GlobusTokenGrant {
+function selectGatewayGrant(payload: GlobusTokenResponse): GlobusTokenGrant {
 	const grants: GlobusTokenGrant[] = [payload, ...(Array.isArray(payload.other_tokens) ? payload.other_tokens : [])];
 	const byResourceServer = grants.find((grant) => grant.resource_server === GATEWAY_CLIENT_ID);
 	if (byResourceServer) return byResourceServer;
@@ -103,7 +103,7 @@ export function selectGatewayGrant(payload: GlobusTokenResponse): GlobusTokenGra
 	);
 }
 
-export function grantToCredentials(grant: GlobusTokenGrant, previousRefresh?: string): OAuthCredentials {
+function grantToCredentials(grant: GlobusTokenGrant, previousRefresh?: string): OAuthCredentials {
 	const access = grant.access_token;
 	if (typeof access !== "string" || access.length === 0) {
 		throw new Error("Globus token response is missing an access token for the ALCF gateway.");
@@ -172,7 +172,7 @@ async function refreshGatewayToken(refreshToken: string, signal: AbortSignal): P
 	return grantToCredentials(selectGatewayGrant(payload), refreshToken);
 }
 
-export async function loginAlcf(callbacks: OAuthLoginCallbacks): Promise<OAuthCredentials> {
+async function loginAlcf(callbacks: OAuthLoginCallbacks): Promise<OAuthCredentials> {
 	const { verifier, challenge } = await generatePkce();
 	const url = buildAuthorizeUrl({ challenge, state: randomState() });
 	callbacks.onAuth({

package/src/engine/antigravity/subprocess-runtime.ts

@@ -63,7 +63,7 @@ export function antigravitySubprocessConfigForAutonomy(
 	return { extraArgs: [], dangerousBypass: false, externalMode: "agy-settings-default" };
 }
 
-export function buildAntigravityPrompt(input: WorkerRunInput): string {
+function buildAntigravityPrompt(input: WorkerRunInput): string {
 	const parts: string[] = [];
 	const systemPrompt = input.systemPrompt.trim();
 	if (systemPrompt.length > 0) parts.push(systemPrompt);
@@ -75,7 +75,7 @@ export function buildAntigravityPrompt(input: WorkerRunInput): string {
 	return parts.join("\n\n");
 }
 
-export function buildAgyArgs(input: WorkerRunInput): string[] {
+function buildAgyArgs(input: WorkerRunInput): string[] {
 	assertToolProfileEnforceable(input.toolProfile, "antigravity-code");
 	const permission = antigravitySubprocessConfigForAutonomy(input.autonomy);
 	const args = ["--print", ...permission.extraArgs];

package/src/engine/api-registry.ts

@@ -78,7 +78,7 @@ function unregisterEngineApiProviders(sourceId: string): void {
 	compatUniverse?.unregisterApiProviders(sourceId);
 }
 
-export function getEngineApiProvider(api: Api): EngineRegisteredApiProvider | undefined {
+function getEngineApiProvider(api: Api): EngineRegisteredApiProvider | undefined {
 	return registry.get(api)?.provider;
 }
 

package/src/engine/apis/llamacpp-residency.ts

@@ -5,8 +5,6 @@ import {
 	type ResidencyAdapter,
 	ResidencyPreconditionError,
 	reconcileResidency,
-	resetResidencyState,
-	residencyManaged,
 	residentTagProtected,
 } from "./residency.js";
 
@@ -28,8 +26,8 @@ export interface LlamaCppResidencyInput {
 	runtimeId: string;
 	keepModelId: string;
 	/**
-	 * Combined env + target lifecycle opt-out verdict from the caller
-	 * (residencyManagedFor). Defaults to the env-only switch.
+	 * Target lifecycle verdict from the caller (residencyManagedFor). Defaults
+	 * to managed for direct adapter callers.
 	 */
 	managed?: boolean;
 	fetchImpl?: typeof fetch;
@@ -72,11 +70,6 @@ interface LlamaCppRouterProps {
 	maxInstances?: number;
 }
 
-/** Test-only: clear the reconciler's TTL cache and Clio-loaded registry. */
-export function resetLlamaCppResidencyState(): void {
-	resetResidencyState();
-}
-
 function isRecord(value: unknown): value is Record<string, unknown> {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -107,19 +100,7 @@ function residentModel(model: LlamaCppRouterModel): boolean {
 	return isResidentState(model.state);
 }
 
-/** Extract resident (loaded, loading, or sleeping) model records from a /v1/models payload. */
-export function parseLlamaCppResidentModels(payload: unknown): LlamaCppResidentModel[] {
-	return parseRouterModels(payload)
-		.filter(residentModel)
-		.map((entry) => ({ id: entry.id, tags: entry.tags }));
-}
-
-/** Extract resident (loaded or loading) model ids from a /v1/models payload. */
-export function parseLlamaCppResident(payload: unknown): string[] {
-	return parseLlamaCppResidentModels(payload).map((entry) => entry.id);
-}
-
-export function parseLlamaCppRouterProps(payload: unknown): LlamaCppRouterProps {
+function parseLlamaCppRouterProps(payload: unknown): LlamaCppRouterProps {
 	if (!isRecord(payload)) return {};
 	const maxInstances = payload.max_instances;
 	return typeof maxInstances === "number" && Number.isFinite(maxInstances) && maxInstances > 0
@@ -302,7 +283,7 @@ export async function ensureLlamaCppResidency(input: LlamaCppResidencyInput): Pr
 		targetId: input.targetId,
 		runtimeId: input.runtimeId,
 		keepModelId: input.keepModelId,
-		managed: input.managed ?? residencyManaged(),
+		managed: input.managed ?? true,
 		strategy: "router",
 		listResident: async () => {
 			const models = await fetchRouterModels(input, fetchImpl);

package/src/engine/apis/lmstudio.ts

@@ -16,10 +16,10 @@ import { emitResidencyMutation, emitResidencyNotice, reconcileResidency, residen
 import { withResidencyLock } from "./residency-lock.js";
 
 interface LmStudioModelMetadata {
-	clio?: {
+	clioCoder?: {
 		targetId: string;
 		runtimeId: string;
-		lifecycle?: "user-managed" | "clio-managed";
+		lifecycle?: "user-managed" | "clio-coder-managed";
 		lmstudio?: TargetDescriptor["lmstudio"];
 		lmstudioDefaultModel?: string;
 	};
@@ -42,8 +42,8 @@ function responseInstanceId(data: unknown): string | undefined {
 	return typeof id === "string" && id.trim().length > 0 ? id.trim() : undefined;
 }
 
-function metadata(model: Model<Api>): NonNullable<LmStudioModelMetadata["clio"]> | undefined {
-	return (model as Model<Api> & LmStudioModelMetadata).clio;
+function metadata(model: Model<Api>): NonNullable<LmStudioModelMetadata["clioCoder"]> | undefined {
+	return (model as Model<Api> & LmStudioModelMetadata).clioCoder;
 }
 
 function targetForModel(model: Model<"openai-completions">): TargetDescriptor | null {
@@ -145,11 +145,6 @@ function emitResidencyNoticeOnce(key: string, notice: Parameters<typeof emitResi
 	emitResidencyNotice(notice);
 }
 
-/** Test seam: forget which residency facts were announced. */
-export function resetAnnouncedResidencyFacts(): void {
-	announcedResidencyFacts.clear();
-}
-
 export async function ensureLmStudioResidency(
 	model: Model<"openai-completions">,
 	options: { apiKey?: string; signal?: AbortSignal } = {},

package/src/engine/apis/ollama-native.ts

@@ -32,7 +32,7 @@ import {
 } from "../../domains/providers/index.js";
 import type { LocalModelQuirks, SamplingProfile } from "../../domains/providers/types/local-model-quirks.js";
 import { calculateEngineCost } from "../ai.js";
-import { createGemmaChannelFilter } from "../gemma-channel-filter.js";
+import { createGemmaChannelFilter, usesGemmaChannelMarkers } from "../gemma-channel-filter.js";
 import { createSentinelStripper } from "../strip-tokenizer-sentinels.js";
 import { remainingContextMaxTokens } from "./output-budget.js";
 import { type ResidencyAdapter, reconcileResidency, residencyManagedFor } from "./residency.js";
@@ -43,11 +43,11 @@ import type { EngineApiProvider } from "./types.js";
 const REASONING_CHARS_PER_TOKEN = 4;
 
 interface ClioRuntimeMetadata {
-	clio?: {
+	clioCoder?: {
 		targetId: string;
 		runtimeId: string;
 		/** Present only when settings set the target lifecycle explicitly. */
-		lifecycle?: "user-managed" | "clio-managed";
+		lifecycle?: "user-managed" | "clio-coder-managed";
 		gateway?: boolean;
 		family?: string;
 		quirks?: LocalModelQuirks;
@@ -55,11 +55,11 @@ interface ClioRuntimeMetadata {
 }
 
 function clioQuirks(model: Model<"ollama-native">): LocalModelQuirks | undefined {
-	return (model as Model<"ollama-native"> & ClioRuntimeMetadata).clio?.quirks;
+	return (model as Model<"ollama-native"> & ClioRuntimeMetadata).clioCoder?.quirks;
 }
 
 function ollamaTargetId(model: Model<"ollama-native">): string {
-	return (model as Model<"ollama-native"> & ClioRuntimeMetadata).clio?.targetId ?? model.provider;
+	return (model as Model<"ollama-native"> & ClioRuntimeMetadata).clioCoder?.targetId ?? model.provider;
 }
 
 /**
@@ -74,7 +74,7 @@ function ollamaTargetId(model: Model<"ollama-native">): string {
 async function reconcileOllamaResidency(model: Model<"ollama-native">, headers: Record<string, string>): Promise<void> {
 	const baseUrl = model.baseUrl;
 	if (!baseUrl) return;
-	const metadata = (model as Model<"ollama-native"> & ClioRuntimeMetadata).clio;
+	const metadata = (model as Model<"ollama-native"> & ClioRuntimeMetadata).clioCoder;
 	const adapter: ResidencyAdapter = {
 		targetKey: residencyTargetKey("ollama-native", baseUrl),
 		targetId: ollamaTargetId(model),
@@ -159,7 +159,7 @@ function userToOllama(content: string | (TextContent | ImageContent)[]): OllamaM
 	return out;
 }
 
-export function assistantToOllama(content: AssistantMessage["content"]): OllamaMessage {
+function assistantToOllama(content: AssistantMessage["content"]): OllamaMessage {
 	const textParts: string[] = [];
 	const toolCalls: OllamaToolCall[] = [];
 	const thinkingParts: string[] = [];
@@ -270,7 +270,7 @@ function ollamaEvictClient(baseUrl: string, headers?: Record<string, string>): O
  * Map an Ollama `/api/ps` response to the runtime-agnostic resident shape,
  * preserving the GPU/total footprint when the server reports it.
  */
-export async function listResidentOllamaModels(client: OllamaEvictClient): Promise<ResidentModelInfo[]> {
+async function listResidentOllamaModels(client: OllamaEvictClient): Promise<ResidentModelInfo[]> {
 	const resident = await client.ps();
 	return resident.models.map((entry) => {
 		const primary = entry.model || entry.name;
@@ -384,7 +384,7 @@ function runStream(
 			let doneReason: string | undefined;
 			const sentinelStripper = createSentinelStripper();
 			const resolved = resolveModelRuntimeCapabilitiesForModel(model, thinkingLevel);
-			const channelFilter = resolved.family === "gemma-4" ? createGemmaChannelFilter() : null;
+			const channelFilter = usesGemmaChannelMarkers(resolved.modelId) ? createGemmaChannelFilter() : null;
 			const closeActiveThinking = () => {
 				if (!activeThinking) return;
 				stream.push({