@iowarp/clio-coder 0.4.7 → 0.4.8

package/src/domains/prompts/extension.ts

@@ -205,7 +205,7 @@ export function createPromptsBundle(
 
 	let unsubscribeContextSources: (() => void) | null = null;
 	let unsubscribeHotReload: (() => void) | null = null;
-	let unsubscribeExtensionsReload: (() => void) | null = null;
+	let unsubscribePluginsReload: (() => void) | null = null;
 	const extension: DomainExtension = {
 		async start() {
 			try {
@@ -226,28 +226,15 @@ export function createPromptsBundle(
 				if (!diffTouchesFragments(paths)) return;
 				reload();
 			});
-			// Extension prompt and skill roots feed fragments through the
-			// resources domain; a committed generation with new content means
-			// the table must be rebuilt from the new roots.
-			const onResourceReload = (payload: unknown) => {
-				if ((payload as { changed?: unknown } | undefined)?.changed !== true) return;
-				reload();
-			};
-			const unsubscribe = [
-				context.bus.on(BusChannels.ExtensionsReloaded, onResourceReload),
-				context.bus.on(BusChannels.PluginsReloaded, () => reload()),
-			];
-			unsubscribeExtensionsReload = () => {
-				for (const stop of unsubscribe) stop();
-			};
+			unsubscribePluginsReload = context.bus.on(BusChannels.PluginsReloaded, () => reload());
 		},
 		async stop() {
 			unsubscribeContextSources?.();
 			unsubscribeContextSources = null;
 			unsubscribeHotReload?.();
 			unsubscribeHotReload = null;
-			unsubscribeExtensionsReload?.();
-			unsubscribeExtensionsReload = null;
+			unsubscribePluginsReload?.();
+			unsubscribePluginsReload = null;
 			sessionSourceSnapshots.clear();
 		},
 	};

package/src/domains/providers/cache-deployment.ts

@@ -0,0 +1,147 @@
+import { canonicalEndpointUrl } from "../../core/endpoint-key.js";
+import type { TargetDescriptor } from "./types/target-descriptor.js";
+
+/** Fresh observations, not a persisted cache handle or permission to administer a server. */
+export interface CacheDeploymentObservation {
+	observedAt: number;
+	backend: "llamacpp" | "vllm" | "unknown";
+	model: string;
+	build: string | null;
+	/** Absent server epoch stays unknown; Clio never invents one from a build number. */
+	epoch: string | null;
+	endpoint: string | null;
+	requestControls: ReadonlyArray<"cache_prompt">;
+	warm: "bounded" | "unsupported";
+	administration: "unsupported";
+	reason: string;
+}
+
+function record(value: unknown): Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : {};
+}
+
+/**
+ * Read-only admission evidence. Every invocation probes again, so an old route,
+ * build, resident state or process epoch is never reused to authorize a warm.
+ * Control-plane credentials are deliberately independent: this initial reader
+ * sends none. An authenticated/unknown control plane remains passive.
+ */
+export async function observeCacheDeployment(
+	target: TargetDescriptor,
+	wireModelId: string,
+	options: { signal?: AbortSignal; gatewayApiKey?: string; fetchImpl?: typeof fetch } = {},
+): Promise<CacheDeploymentObservation> {
+	const binding = target.cache?.deployment;
+	const observation: CacheDeploymentObservation = {
+		observedAt: Date.now(),
+		backend: binding?.backend ?? "unknown",
+		model: binding?.model ?? wireModelId,
+		build: null,
+		epoch: null,
+		endpoint: null,
+		requestControls: [],
+		warm: "unsupported",
+		administration: "unsupported",
+		reason: "deployment-unbound",
+	};
+	if (!binding) return observation;
+	try {
+		const control = new URL(binding.controlUrl);
+		if (
+			!["http:", "https:"].includes(control.protocol) ||
+			control.username ||
+			control.password ||
+			control.search ||
+			control.hash
+		) {
+			return { ...observation, reason: "deployment-invalid" };
+		}
+		const root = control.href.replace(/\/$/, "").replace(/\/v1$/, "");
+		observation.endpoint = canonicalEndpointUrl(root);
+		const signal = AbortSignal.any([AbortSignal.timeout(2000), ...(options.signal ? [options.signal] : [])]);
+		const get = async (url: string, headers?: Record<string, string>) => {
+			const response = await (options.fetchImpl ?? fetch)(url, {
+				method: "GET",
+				signal,
+				redirect: "error",
+				credentials: "omit",
+				...(headers ? { headers } : {}),
+			});
+			if (!response.ok) throw new Error("discovery unavailable");
+			return (await response.json()) as unknown;
+		};
+		const gateway = target.runtime === "litellm";
+		if (gateway) {
+			if (!binding.gatewayDeploymentId || !target.url) return { ...observation, reason: "gateway-unbound" };
+			const gatewayRoot = target.url.replace(/\/$/, "").replace(/\/v1$/, "");
+			const info = record(
+				await get(`${gatewayRoot}/v1/model/info`, {
+					...target.auth?.headers,
+					...(options.gatewayApiKey ? { authorization: `Bearer ${options.gatewayApiKey}` } : {}),
+				}),
+			);
+			const rows = Array.isArray(info.data) ? info.data.map(record).filter((row) => row.model_name === wireModelId) : [];
+			// Multiple replicas/fallback routes do not establish a single physical
+			// cache. A deployment response header arrives too late for admission.
+			const row = rows.length === 1 ? rows[0] : undefined;
+			const params = record(row?.litellm_params);
+			const modelInfo = record(row?.model_info);
+			if (
+				!row ||
+				modelInfo.id !== binding.gatewayDeploymentId ||
+				(params.model !== binding.model && params.model !== `openai/${binding.model}`) ||
+				canonicalEndpointUrl(typeof params.api_base === "string" ? params.api_base : undefined) !== observation.endpoint
+			) {
+				return { ...observation, reason: "gateway-route-mismatch" };
+			}
+		} else if (
+			target.runtime !== binding.backend ||
+			wireModelId !== binding.model ||
+			canonicalEndpointUrl(target.url) !== observation.endpoint
+		) {
+			return { ...observation, reason: "deployment-mismatch" };
+		}
+		if (binding.backend === "vllm") {
+			const version = record(await get(`${root}/version`));
+			observation.build = typeof version.version === "string" ? version.version : null;
+			// APC and queue/memory metrics vary by deployment. A version and an
+			// OpenAI schema alone establish neither APC nor safe speculative load.
+			return {
+				...observation,
+				reason: observation.build === binding.build ? "vllm-scheduler-unverified" : "deployment-build-mismatch",
+			};
+		}
+		let props = record(await get(`${root}/props`));
+		const router = props.role === "router";
+		if (router) {
+			const models = record(await get(`${root}/models`));
+			const selected = Array.isArray(models.data)
+				? models.data.map(record).find((row) => row.id === binding.model)
+				: undefined;
+			if (record(selected?.status).value !== "loaded") return { ...observation, reason: "model-not-loaded" };
+			// Never wake sleeping models or load an absent worker during discovery.
+			props = record(await get(`${root}/props?model=${encodeURIComponent(binding.model)}&autoload=false`));
+		}
+		observation.build = typeof props.build_info === "string" ? props.build_info : null;
+		if (observation.build !== binding.build) return { ...observation, reason: "deployment-build-mismatch" };
+		if (!observation.build.endsWith("-c841aee"))
+			return { ...observation, reason: "deployment-cache-protocol-unverified" };
+		if (props.is_sleeping !== false) return { ...observation, reason: "model-not-loaded" };
+		if (typeof props.model_alias === "string" && props.model_alias !== binding.model)
+			return { ...observation, reason: "deployment-model-mismatch" };
+		if (!router) {
+			const models = record(await get(`${root}/v1/models`));
+			if (!Array.isArray(models.data) || models.data.length !== 1 || record(models.data[0]).id !== binding.model)
+				return { ...observation, reason: "deployment-model-mismatch" };
+		}
+		if (typeof props.start_time === "string") observation.epoch = props.start_time;
+		const slots = await get(`${root}/slots?model=${encodeURIComponent(binding.model)}&autoload=false`);
+		if (!Array.isArray(slots) || slots.length === 0 || slots.some((slot) => record(slot).is_processing !== false)) {
+			return { ...observation, reason: "endpoint-busy-or-unknown" };
+		}
+		if (gateway) return { ...observation, reason: "gateway-cache-transport-unverified" };
+		return { ...observation, requestControls: ["cache_prompt"], warm: "bounded", reason: "loaded-idle-deployment" };
+	} catch {
+		return { ...observation, reason: options.signal?.aborted ? "superseded" : "deployment-unavailable" };
+	}
+}

package/src/domains/providers/catalog.ts

@@ -148,7 +148,7 @@ export function synthesizeCatalogBackedModel(input: CatalogBackedSynthesisInput)
 	}
 	const pricing = input.target.pricing;
 	const targetHeaders = input.target.auth?.headers;
-	const model: Model<Api> = {
+	const model: Model<Api> & { clioCoder?: { cache: NonNullable<TargetDescriptor["cache"]> } } = {
 		...catalogFields,
 		id: input.wireModelId,
 		name: `${input.wireModelId} (${input.target.id})`,
@@ -160,14 +160,19 @@ export function synthesizeCatalogBackedModel(input: CatalogBackedSynthesisInput)
 			input.defaultBaseUrl,
 		reasoning: caps.reasoning,
 		input: caps.vision ? (builtin?.input.includes("image") ? builtin.input : ["text", "image"]) : ["text"],
-		cost: {
-			input: pricing?.input ?? builtin?.cost.input ?? 0,
-			output: pricing?.output ?? builtin?.cost.output ?? 0,
-			cacheRead: pricing?.cacheRead ?? builtin?.cost.cacheRead ?? 0,
-			cacheWrite: pricing?.cacheWrite ?? builtin?.cost.cacheWrite ?? 0,
-		},
+		// Catalog tiers belong to the catalog rates. An explicit target price
+		// replaces that schedule, using the same defaults as resolveEffectivePricing.
+		cost: pricing
+			? {
+					input: pricing.input,
+					output: pricing.output,
+					cacheRead: pricing.cacheRead ?? 0,
+					cacheWrite: pricing.cacheWrite ?? 0,
+				}
+			: structuredClone(builtin?.cost ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }),
 		contextWindow: caps.contextWindow,
 		maxTokens: caps.maxTokens,
+		...(input.target.cache === undefined ? {} : { clioCoder: { cache: structuredClone(input.target.cache) } }),
 	};
 	const headers = { ...(input.defaultHeaders ?? {}), ...(builtin?.headers ?? {}), ...(targetHeaders ?? {}) };
 	if (Object.keys(headers).length > 0) {

package/src/domains/providers/extension.ts

@@ -257,6 +257,7 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 	const statuses = new Map<string, TargetStatus>();
 	const reasoningCache = new Map<string, boolean>();
 	const unsubscribeConfigListeners: Array<() => void> = [];
+	let stopped = false;
 
 	function reasoningCacheKey(targetId: string, modelId: string): string {
 		return `${targetId}:${modelId}`;
@@ -268,6 +269,11 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 		return readSettings();
 	}
 
+	function currentProbeTarget(probed: TargetDescriptor): TargetDescriptor | undefined {
+		if (stopped) return undefined;
+		return readConfig().targets.find((target) => sameProbeIdentity(probed, target));
+	}
+
 	async function buildProbeContextForTarget(
 		target: TargetDescriptor,
 		desc: RuntimeDescriptor,
@@ -323,6 +329,7 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 		probe: ProbeResult | null,
 		previous?: TargetStatus,
 	): TargetStatus {
+		if (previous && !sameProbeIdentity(previous.target, target)) previous = undefined;
 		if (!desc) {
 			const out: TargetStatus = {
 				target,
@@ -385,8 +392,11 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 		target: TargetDescriptor,
 		live: boolean,
 		options?: { reasoning?: boolean; signal?: AbortSignal },
-	): Promise<TargetStatus> {
+	): Promise<TargetStatus | null> {
 		options?.signal?.throwIfAborted();
+		if (stopped) return null;
+		// A probe owns the descriptor it started with across asynchronous I/O.
+		target = structuredClone(target);
 		const previous = statuses.get(target.id);
 		const desc = registry.get(target.runtime);
 		if (!desc) {
@@ -402,6 +412,7 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 		}
 		const probeCtx = await buildProbeContextForTarget(target, desc, options?.signal);
 		options?.signal?.throwIfAborted();
+		if (!currentProbeTarget(target)) return null;
 		let probeResult: ProbeResult;
 		try {
 			probeResult = await desc.probe(target, probeCtx);
@@ -409,6 +420,7 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 			probeResult = { ok: false, error: err instanceof Error ? err.message : String(err) };
 		}
 		options?.signal?.throwIfAborted();
+		if (!currentProbeTarget(target)) return null;
 		if (probeResult.ok && typeof desc.probeModels === "function" && !probeResult.models) {
 			try {
 				const ids = await desc.probeModels(target, probeCtx);
@@ -418,6 +430,7 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 			}
 		}
 		options?.signal?.throwIfAborted();
+		if (!currentProbeTarget(target)) return null;
 		if (probeResult.ok && options?.reasoning !== false && typeof desc.probeReasoning === "function") {
 			const settings = readConfig();
 			const orchestratorTarget = settings.chat.target === target.id ? settings.chat.model : null;
@@ -426,6 +439,7 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 				try {
 					const result = await desc.probeReasoning(target, candidateModelId, probeCtx);
 					options?.signal?.throwIfAborted();
+					if (!currentProbeTarget(target)) return null;
 					reasoningCache.set(reasoningCacheKey(target.id, candidateModelId), result.reasoning);
 					const capabilityModelId = probeResult.capabilityModelId ?? null;
 					if (capabilityModelId === null || capabilityModelId === candidateModelId) {
@@ -447,9 +461,11 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 				}
 			}
 		}
-		// A cancelled role preparation must not publish failed/stale target state.
+		// Cancellation, target edits/removal, and shutdown revoke publication.
 		options?.signal?.throwIfAborted();
-		const status = buildStatus(target, desc, probeResult, previous);
+		const current = currentProbeTarget(target);
+		if (!current) return null;
+		const status = buildStatus(current, desc, probeResult, previous);
 		statuses.set(target.id, status);
 		if (probeResult.ok && probeResult.models !== undefined) {
 			recordTargetModelSnapshot(
@@ -467,14 +483,18 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 	}
 
 	async function probeReasoningForModelInternal(targetId: string, modelId: string): Promise<boolean | null> {
+		if (stopped) return null;
 		const settings = readConfig();
-		const target = settings.targets.find((ep) => ep.id === targetId);
-		if (!target) return null;
+		const configuredTarget = settings.targets.find((ep) => ep.id === targetId);
+		if (!configuredTarget) return null;
+		const target = structuredClone(configuredTarget);
 		const desc = registry.get(target.runtime);
 		if (!desc || typeof desc.probeReasoning !== "function") return null;
 		const probeCtx = await buildProbeContextForTarget(target, desc);
+		if (!currentProbeTarget(target)) return null;
 		try {
 			const result = await desc.probeReasoning(target, modelId, probeCtx);
+			if (!currentProbeTarget(target)) return null;
 			reasoningCache.set(reasoningCacheKey(targetId, modelId), result.reasoning);
 			return result.reasoning;
 		} catch {
@@ -508,6 +528,7 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 
 	const extension: DomainExtension = {
 		async start() {
+			stopped = false;
 			ensurePiAiRegistered();
 			registerClioApiProviders();
 			registerClioOAuthProviders();
@@ -528,6 +549,7 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 			}
 		},
 		async stop() {
+			stopped = true;
 			for (const unsubscribe of unsubscribeConfigListeners.splice(0)) unsubscribe();
 		},
 	};

package/src/domains/providers/index.ts

@@ -24,6 +24,7 @@ export {
 	resolveRuntimeAuthTarget,
 	targetRequiresAuth,
 } from "./auth/index.js";
+export { type CacheDeploymentObservation, observeCacheDeployment } from "./cache-deployment.js";
 export { AGENT_ROLE_TOOLS_REQUIRED_REASON, mergeCapabilities, supportsAgentRoleTools } from "./capabilities.js";
 export type { ProvidersContract, TargetHealth, TargetStatus } from "./contract.js";
 export { isDispatchEligibleRuntime, isOrchestratorEligibleRuntime, isTargetEligibleRuntime } from "./eligibility.js";

package/src/domains/providers/plugins.ts

@@ -14,29 +14,19 @@
 
 import { join } from "node:path";
 
+import type { ClioSettings } from "../../core/config.js";
 import { clioConfigDir } from "../../core/xdg.js";
 import { activateExternalPluginApiBridge } from "../../engine/api-registry.js";
 import type { RuntimeRegistry } from "./registry.js";
 
-interface PluginSettings {
-	runtimePlugins?: unknown;
-}
-
-function extractPluginPackages(settings: unknown): string[] {
-	if (!settings || typeof settings !== "object") return [];
-	const raw = (settings as PluginSettings).runtimePlugins;
-	if (!Array.isArray(raw)) return [];
-	return raw.filter((entry): entry is string => typeof entry === "string" && entry.length > 0);
-}
-
 export async function loadPluginRuntimes(
 	registry: RuntimeRegistry,
-	settings?: unknown,
+	settings?: Pick<ClioSettings, "integrations">,
 ): Promise<ReadonlyArray<string>> {
 	const loaded: string[] = [];
 
 	const pluginDir = join(clioConfigDir(), "runtimes");
-	const packages = extractPluginPackages(settings);
+	const packages = settings?.integrations.runtimePlugins ?? [];
 	try {
 		const ids = await registry.loadFromDir(pluginDir, activateExternalPluginApiBridge);
 		loaded.push(...ids);

package/src/domains/providers/runtimes/common/local-synth.ts

@@ -25,6 +25,7 @@ export interface ClioLocalModelMetadata {
 		chatTemplateKwargsUnsupported?: boolean;
 		lmstudio?: TargetDescriptor["lmstudio"];
 		litellm?: TargetDescriptor["litellm"];
+		cache?: TargetDescriptor["cache"];
 	};
 }
 
@@ -65,6 +66,8 @@ function localOpenAICompat(caps: CapabilityFlags, runtimeId: string): OpenAIComp
 		maxTokensField: "max_tokens",
 		supportsThinkingTokenBudget: runtimeId === "vllm",
 		supportsStrictMode: false,
+		// Native and generic gateway schemas do not establish hosted 24h retention.
+		supportsLongCacheRetention: false,
 	};
 	const thinkingFormat = openAIThinkingFormat(caps);
 	if (thinkingFormat) (compat as unknown as { thinkingFormat?: string }).thinkingFormat = thinkingFormat;
@@ -111,6 +114,7 @@ export function synthLocalModel(input: LocalSynthesisInput): Model<Api> {
 			...(quirks ? { quirks } : {}),
 			...(target.lmstudio ? { lmstudio: target.lmstudio } : {}),
 			...(target.litellm ? { litellm: target.litellm } : {}),
+			...(target.cache ? { cache: structuredClone(target.cache) } : {}),
 		},
 	};
 	if (headers) model.headers = headers;

package/src/domains/providers/types/target-descriptor.ts

@@ -14,6 +14,22 @@ export interface TargetPricing {
 	cacheWrite?: number;
 }
 
+/** Request policy interpreted by the selected Pi API; it does not authorize cache administration or paid warming. */
+export interface TargetCacheSettings {
+	retention?: "none" | "short" | "long";
+	/** Explicit read-only deployment binding; never grants administrative authority. */
+	deployment?: {
+		backend: "llamacpp" | "vllm";
+		controlUrl: string;
+		model: string;
+		build: string;
+		/** Required for a gateway binding; compared with its current route inventory. */
+		gatewayDeploymentId?: string;
+	};
+	/** Local warm bounds. Paid routes remain ineligible. */
+	warm?: { maxInputTokens?: number; maxDurationMs?: number; cooldownMs?: number };
+}
+
 // Canonical persisted lifecycle name. Readers temporarily normalize the
 // released `clio-managed` spelling at the settings boundary.
 export type TargetLifecycle = "user-managed" | "clio-coder-managed";
@@ -74,6 +90,7 @@ export interface TargetDescriptor {
 	lifecycle?: TargetLifecycle;
 	gateway?: boolean;
 	pricing?: TargetPricing;
+	cache?: TargetCacheSettings;
 	lmstudio?: LmStudioTargetSettings;
 	litellm?: LiteLLMTargetSettings;
 	/** Explicit request-slot limit for this inference endpoint. It overrides live discovery. */

package/src/domains/session/compaction/compact.ts

@@ -593,6 +593,9 @@ function addCompactionUsage(total: CompactionUsage | undefined, raw: unknown): C
 		output: base.output + output,
 		cacheRead: base.cacheRead + cacheRead,
 		cacheWrite: base.cacheWrite + cacheWrite,
+		...(base.cacheWrite1h === undefined && usage.cacheWrite1h === undefined
+			? {}
+			: { cacheWrite1h: (base.cacheWrite1h ?? 0) + numberOrZero(usage.cacheWrite1h) }),
 		reasoning: base.reasoning + numberOrZero(usage.reasoning),
 		totalTokens: base.totalTokens + totalTokens,
 		cost: { total: base.cost.total + numberOrZero(usage.cost?.total) },
@@ -605,7 +608,7 @@ function retainReportedUsage(previous: Record<string, unknown>, raw: unknown): R
 	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return previous;
 	const usage = raw as Record<string, unknown>;
 	const known = { ...previous };
-	for (const field of ["input", "output", "cacheRead", "cacheWrite", "totalTokens"]) {
+	for (const field of ["input", "output", "cacheRead", "cacheWrite", "cacheWrite1h", "totalTokens"]) {
 		const value = numberOrZero(usage[field]);
 		if (value > 0) known[field] = value;
 	}

package/src/domains/session/entries.ts

@@ -114,6 +114,7 @@ export interface CompactionUsage {
 	output: number;
 	cacheRead: number;
 	cacheWrite: number;
+	cacheWrite1h?: number;
 	reasoning: number;
 	totalTokens: number;
 	cost: { total: number };

package/src/domains/session/usage.ts

@@ -13,10 +13,8 @@
  * every surface's accounting, which is the same thing the tools/interactive
  * boundary rule exists to prevent.
  *
- * Assistant turns marked aborted or error are skipped for the same reason the
- * context estimator skips them: their usage is not a completed call. A
- * cancelled partial persists a fully populated all-zero usage object, so
- * counting it would add an API call worth nothing.
+ * Failed/aborted calls with reported usage still consumed resources. Skip
+ * only all-zero SDK placeholders, whose accounting was never observed.
  */
 
 import {
@@ -39,6 +37,7 @@ export interface LedgerUsageCall {
 	output: number;
 	cacheRead: number;
 	cacheWrite: number;
+	cacheWrite1h?: number;
 	reasoningTokens: number;
 	totalTokens: number;
 	costUsd: number;
@@ -58,7 +57,7 @@ function numberAt(source: Record<string, unknown>, key: string): number {
 }
 
 function reasoningTokensOf(usage: Record<string, unknown>): number {
-	const direct = numberAt(usage, "reasoningTokens");
+	const direct = numberAt(usage, "reasoning") || numberAt(usage, "reasoningTokens");
 	if (direct > 0) return direct;
 	const details = usage.outputTokensDetails ?? usage.completionTokensDetails;
 	if (details && typeof details === "object") return numberAt(details as Record<string, unknown>, "reasoningTokens");
@@ -109,6 +108,7 @@ export function ledgerUsageCalls(
 				output: usage.output,
 				cacheRead: usage.cacheRead,
 				cacheWrite: usage.cacheWrite,
+				...(usage.cacheWrite1h === undefined ? {} : { cacheWrite1h: usage.cacheWrite1h }),
 				reasoningTokens: usage.reasoning,
 				totalTokens: usage.totalTokens,
 				costUsd: usage.cost.total,
@@ -129,8 +129,6 @@ export function ledgerUsageCalls(
 		const payload = entry.payload;
 		if (!payload || typeof payload !== "object" || Array.isArray(payload)) continue;
 		const record = payload as Record<string, unknown>;
-		const stopReason = record.stopReason;
-		if (stopReason === "aborted" || stopReason === "error") continue;
 		const rawUsage = record.usage;
 		if (!rawUsage || typeof rawUsage !== "object" || Array.isArray(rawUsage)) continue;
 		const usage = rawUsage as Record<string, unknown>;
@@ -156,6 +154,7 @@ export function ledgerUsageCalls(
 			output,
 			cacheRead,
 			cacheWrite,
+			...(typeof usage.cacheWrite1h === "number" ? { cacheWrite1h: numberAt(usage, "cacheWrite1h") } : {}),
 			reasoningTokens: reasoningTokensOf(usage),
 			totalTokens,
 			costUsd,

package/src/engine/acp/server.ts

@@ -2559,6 +2559,17 @@ export async function serveClioAcpAgent(options: ClioAcpServerOptions): Promise<
 		}
 		const text = promptText(params);
 		if (text.length === 0) throw new AcpRequestError(-32602, "prompt text is required", { code: "invalid_params" });
+		// Check the same credential authority as the runtime, without resolving or
+		// echoing a secret. Desktop services do not inherit a terminal's API keys.
+		const targetId = routingSnapshot().target;
+		const target = targetId ? options.providers?.getTarget(targetId) : undefined;
+		const runtime = target ? options.providers?.getRuntime(target.runtime) : undefined;
+		if (target && runtime && options.providers && !options.providers.auth.statusForTarget(target, runtime).available) {
+			throw new AcpRequestError(-32000, "credentials for the selected target are unavailable", {
+				code: "prompt_not_admitted",
+				reason: "authentication-required",
+			});
+		}
 		if (options.session?.current()?.id !== session.id && options.session) options.session.resume(session.id);
 		const active = createActivePromptState();
 		session.activePrompt = active;

package/src/engine/ai.ts

@@ -76,6 +76,7 @@ export interface EngineTextCompletionResult {
 		output: number;
 		cacheRead: number;
 		cacheWrite: number;
+		cacheWrite1h?: number;
 		reasoning: number;
 		totalTokens: number;
 		costUsd: number;
@@ -110,6 +111,7 @@ export async function completeEngineText(input: EngineTextCompletionInput): Prom
 			output: response.usage.output,
 			cacheRead: response.usage.cacheRead,
 			cacheWrite: response.usage.cacheWrite,
+			...(response.usage.cacheWrite1h === undefined ? {} : { cacheWrite1h: response.usage.cacheWrite1h }),
 			reasoning: response.usage.reasoning ?? 0,
 			totalTokens: response.usage.totalTokens,
 			costUsd: response.usage.cost.total,

package/src/engine/apis/openai-completions.ts

@@ -546,11 +546,15 @@ function applyLmStudioPayload(
 	return next;
 }
 
-function applyLlamaCppPromptCachePayload(payload: Record<string, unknown>, model: Model<Api>): Record<string, unknown> {
+function applyLlamaCppPromptCachePayload(
+	payload: Record<string, unknown>,
+	model: Model<Api>,
+	retention: StreamOptions["cacheRetention"],
+): Record<string, unknown> {
 	const metadata = runtimeMetadata(model);
 	if (model.provider !== "llamacpp" || metadata?.runtimeId !== "llamacpp") return payload;
 	if (payload.cache_prompt !== undefined) return payload;
-	return { ...payload, cache_prompt: true };
+	return { ...payload, cache_prompt: retention !== "none" };
 }
 
 function shouldApplyLlamaCppPromptCache(model: Model<"openai-completions">): boolean {
@@ -562,13 +566,14 @@ function shouldApplyLlamaCppPromptCache(model: Model<"openai-completions">): boo
 function composeThinkingOnPayload(
 	resolved: ResolvedModelRuntimeCapabilities,
 	base: AnyOnPayload | undefined,
+	retention: StreamOptions["cacheRetention"],
 ): AnyOnPayload {
 	return async (payload, model) => {
 		if (!isPlainRecord(payload)) {
 			return base ? await base(payload, model) : undefined;
 		}
 		const next = applyLmStudioPayload(
-			applyThinkingPayload(applyLlamaCppPromptCachePayload(payload, model), resolved.thinking, resolved, model),
+			applyThinkingPayload(applyLlamaCppPromptCachePayload(payload, model, retention), resolved.thinking, resolved, model),
 			model,
 			resolved,
 		);
@@ -625,7 +630,7 @@ function withSamplingOverrides<TOptions extends StreamOptions>(
 		applied.mechanism === "on-off" ||
 		applied.mechanism === "none"
 	) {
-		merged.onPayload = composeThinkingOnPayload(resolved, options?.onPayload);
+		merged.onPayload = composeThinkingOnPayload(resolved, options?.onPayload, options?.cacheRetention);
 	}
 	return merged as TOptions;
 }