@iowarp/clio-coder 0.4.9 → 0.5.0

package/src/domains/providers/runtimes/common/lmstudio-http.ts

@@ -46,6 +46,9 @@ interface LmStudioHostCatalog {
 	targetId: string;
 	rootUrl: string;
 	models: LmStudioModelInfo[];
+	catalog: LmStudioCatalog;
+	requestHeaders: string;
+	at: number;
 }
 
 const catalogsByHost = new Map<string, LmStudioHostCatalog>();
@@ -82,10 +85,10 @@ function lmStudioRequestHeaders(
 	base: Readonly<Record<string, string>> | undefined,
 	apiKey: string | undefined,
 ): Record<string, string> {
-	const headers: Record<string, string> = { ...(base ?? {}) };
+	const headers = new Headers(base);
 	const token = apiKey?.trim();
-	if (token) headers.authorization = `Bearer ${token}`;
-	return headers;
+	if (token && !headers.has("authorization")) headers.set("authorization", `Bearer ${token}`);
+	return Object.fromEntries(headers);
 }
 
 function lmStudioProbeHeaders(target: TargetDescriptor, ctx: ProbeContext): Record<string, string> {
@@ -124,6 +127,7 @@ export async function requestLmStudioJson(
 		try {
 			data = await response.json();
 		} catch {
+			bounded.signal.throwIfAborted();
 			data = undefined;
 		}
 		const result: LmStudioJsonResponse = {
@@ -133,11 +137,14 @@ export async function requestLmStudioJson(
 		};
 		if (data !== undefined) result.data = data;
 		if (!response.ok) {
-			const message = isRecord(data) ? nonEmptyString(data.error) : undefined;
-			result.error = message ?? `HTTP ${response.status}`;
+			const detail = isRecord(data) ? (data.error ?? data) : undefined;
+			const message = nonEmptyString(detail) ?? (isRecord(detail) ? nonEmptyString(detail.message) : undefined);
+			const code = isRecord(detail) ? nonEmptyString(detail.code) : undefined;
+			result.error = [code, message].filter(Boolean).join(": ") || `HTTP ${response.status}`;
 		}
 		return result;
 	} catch (error) {
+		signal?.throwIfAborted();
 		return {
 			ok: false,
 			status: 0,
@@ -226,10 +233,8 @@ export function foldLmStudioModels(models: ReadonlyArray<LmStudioModelInfo>): Lm
 	return [...byKey.values()];
 }
 
-function rememberHostCatalog(target: TargetDescriptor, models: ReadonlyArray<LmStudioModelInfo>): void {
-	const rootUrl = lmStudioRootUrl(target.url ?? "");
-	if (!rootUrl) return;
-	catalogsByHost.set(rootUrl, { targetId: target.id, rootUrl, models: foldLmStudioModels(models) });
+export function invalidateLmStudioCatalog(target: TargetDescriptor): void {
+	catalogsByHost.delete(lmStudioRootUrl(target.url ?? ""));
 }
 
 function peerTargetsFor(target: TargetDescriptor, instanceId: string): string[] {
@@ -362,43 +367,54 @@ function authFailure(result: LmStudioJsonResponse): LmStudioCatalog | null {
 	};
 }
 
-export async function listLmStudioModels(target: TargetDescriptor, ctx: ProbeContext): Promise<LmStudioCatalog> {
+export async function listLmStudioModels(
+	target: TargetDescriptor,
+	ctx: ProbeContext,
+	maxAgeMs = 0,
+): Promise<LmStudioCatalog> {
+	ctx.signal?.throwIfAborted();
 	if (!target.url) return { ok: false, models: [], error: "target has no url" };
 	const root = lmStudioRootUrl(target.url);
 	const headers = lmStudioProbeHeaders(target, ctx);
-	const init: RequestInit = { headers };
-	const v1 = await requestLmStudioJson(`${root}/api/v1/models`, init, ctx.httpTimeoutMs, ctx.signal);
-	const v1Auth = authFailure(v1);
-	if (v1Auth) return v1Auth;
-	const parsedV1 = parseLmStudioV1Models(v1.data);
-	if (v1.ok && parsedV1) {
-		rememberHostCatalog(target, parsedV1);
-		return { ok: true, models: parsedV1, tier: "0.4+", latencyMs: v1.latencyMs };
+	const requestHeaders = JSON.stringify(headers);
+	const cached = catalogsByHost.get(root);
+	if (cached && cached.requestHeaders === requestHeaders && performance.now() - cached.at < maxAgeMs) {
+		return cached.catalog;
 	}
-
-	const v0 = await requestLmStudioJson(`${root}/api/v0/models`, init, ctx.httpTimeoutMs, ctx.signal);
-	const v0Auth = authFailure(v0);
-	if (v0Auth) return v0Auth;
-	const parsedV0 = v0Models(v0.data);
-	if (v0.ok && parsedV0) {
-		rememberHostCatalog(target, parsedV0);
-		return { ok: true, models: parsedV0, tier: "0.3.x", latencyMs: v0.latencyMs };
-	}
-
-	const openAI = await requestLmStudioJson(`${root}/v1/models`, init, ctx.httpTimeoutMs, ctx.signal);
-	const openAIAuth = authFailure(openAI);
-	if (openAIAuth) return openAIAuth;
-	const parsedOpenAI = openAIModels(openAI.data);
-	if (openAI.ok && parsedOpenAI) {
-		rememberHostCatalog(target, parsedOpenAI);
-		return { ok: true, models: parsedOpenAI, tier: "openai-compat", latencyMs: openAI.latencyMs };
+	const endpoints: Array<[string, LmStudioApiTier, (data: unknown) => LmStudioModelInfo[] | null]> = [
+		["/api/v1/models", "0.4+", parseLmStudioV1Models],
+		["/api/v0/models", "0.3.x", v0Models],
+		["/v1/models", "openai-compat", openAIModels],
+	];
+	let latencyMs = 0;
+	let error = "LM Studio returned no recognized model catalog";
+	for (const [path, tier, parse] of endpoints) {
+		const response = await requestLmStudioJson(`${root}${path}`, { headers }, ctx.httpTimeoutMs, ctx.signal);
+		latencyMs += response.latencyMs;
+		const auth = authFailure(response);
+		if (auth) {
+			invalidateLmStudioCatalog(target);
+			return auth;
+		}
+		const models = response.ok ? parse(response.data) : null;
+		if (models) {
+			const catalog = { ok: true, models: foldLmStudioModels(models), tier, latencyMs };
+			catalogsByHost.set(root, {
+				targetId: target.id,
+				rootUrl: root,
+				models: catalog.models,
+				catalog,
+				requestHeaders,
+				at: performance.now(),
+			});
+			return catalog;
+		}
+		error = response.error ?? error;
+		// Try older API versions only when this endpoint is unavailable, not on a server outage.
+		if (response.status !== 404 && response.status !== 405) break;
 	}
-	return {
-		ok: false,
-		models: [],
-		latencyMs: v1.latencyMs + v0.latencyMs + openAI.latencyMs,
-		error: v1.error ?? v0.error ?? openAI.error ?? "LM Studio returned no recognized model catalog",
-	};
+	invalidateLmStudioCatalog(target);
+	return { ok: false, models: [], latencyMs, error };
 }
 
 export async function greetLmStudio(

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

@@ -25,6 +25,7 @@ export interface ClioLocalModelMetadata {
 		chatTemplateKwargsUnsupported?: boolean;
 		lmstudio?: TargetDescriptor["lmstudio"];
 		litellm?: TargetDescriptor["litellm"];
+		ollama?: TargetDescriptor["ollama"];
 		cache?: TargetDescriptor["cache"];
 	};
 }
@@ -64,7 +65,7 @@ function localOpenAICompat(caps: CapabilityFlags, runtimeId: string): OpenAIComp
 		supportsUsageInStreaming: true,
 		supportsFinishReason: false,
 		maxTokensField: "max_tokens",
-		supportsThinkingTokenBudget: runtimeId === "vllm",
+		...(runtimeId === "vllm" ? { thinkingTokenBudgetField: "thinking_token_budget" as const } : {}),
 		supportsStrictMode: false,
 		// Native and generic gateway schemas do not establish hosted 24h retention.
 		supportsLongCacheRetention: false,
@@ -114,6 +115,7 @@ export function synthLocalModel(input: LocalSynthesisInput): Model<Api> {
 			...(quirks ? { quirks } : {}),
 			...(target.lmstudio ? { lmstudio: target.lmstudio } : {}),
 			...(target.litellm ? { litellm: target.litellm } : {}),
+			...(target.ollama ? { ollama: target.ollama } : {}),
 			...(target.cache ? { cache: structuredClone(target.cache) } : {}),
 		},
 	};

package/src/domains/providers/runtimes/common/ollama-model-ids.ts

@@ -0,0 +1,11 @@
+// Ollama resolves an untagged name to :latest (registry ports are not tags).
+export function ollamaModelIds(...ids: string[]): string[] {
+	return [
+		...new Set(
+			ids.flatMap((id) => {
+				if (id.endsWith(":latest")) return [id, id.slice(0, -7)];
+				return id.slice(id.lastIndexOf("/") + 1).includes(":") ? [id] : [id, `${id}:latest`];
+			}),
+		),
+	];
+}

package/src/domains/providers/runtimes/common/probe-helpers.ts

@@ -257,6 +257,7 @@ function capabilitiesFromOpenAIModelEntry(row: Record<string, unknown>): Partial
 			"context_length",
 			"contextLength",
 			"max_context_length",
+			"max_context_window",
 			"maxContextLength",
 			"n_ctx",
 		]) ??
@@ -297,6 +298,18 @@ function capabilitiesFromOpenAIModelEntry(row: Record<string, unknown>): Partial
 		caps.vision = modalities.some((entry) => entry === "image" || entry === "vision");
 		if (modalities.some((entry) => entry === "audio")) caps.audio = true;
 	}
+	// Lemonade's catalog declares task and modality support as labels. Without
+	// these, embedding models inherit the runtime's chat/tool defaults and
+	// vision models lose their image input when no family catalog entry exists.
+	if (row.owned_by === "lemonade" && Array.isArray(row.labels)) {
+		const labels = new Set(row.labels.filter((label): label is string => typeof label === "string"));
+		caps.chat = labels.has("chat");
+		caps.tools = labels.has("tool-calling");
+		caps.reasoning = labels.has("reasoning");
+		caps.vision = labels.has("vision");
+		caps.embeddings = labels.has("embeddings");
+		caps.rerank = labels.has("reranking");
+	}
 	return caps;
 }
 
@@ -350,6 +363,10 @@ export interface LlamaCppServerFlags {
 	parallel?: number;
 	/** `--kv-unified` / `-kvu` true, `--no-kv-unified` false, absent when neither was given. */
 	kvUnified?: boolean;
+	/** `--cache-ram` / `-cram` in MiB; `0` disables the host-RAM prompt cache, `-1` lifts its limit. */
+	cacheRamMib?: number;
+	/** `--cache-idle-slots` true, `--no-cache-idle-slots` false, absent when neither was given. */
+	cacheIdleSlots?: boolean;
 	mmproj?: string;
 	chatTemplateKwargs?: string;
 }
@@ -385,11 +402,36 @@ function llamaCppRequestContextWindow(flags: LlamaCppServerFlags): LlamaCppReque
 	};
 }
 
+/**
+ * The server configuration that keeps parallel slots from holding their own
+ * prefix cache, or undefined when the argv does not show it.
+ *
+ * llama-server defaults to a host-RAM prompt cache (`--cache-ram 8192`) and to
+ * `--cache-idle-slots`. With `--kv-unified`, every task launch saves each idle
+ * slot to host RAM and clears it from the KV pool, so similarity-based slot
+ * selection never finds a resident prefix and the next request restores its
+ * prompt from RAM. At commit c841aee that restore runs on the server's single
+ * task thread, and when the cells it lands on are not contiguous it copies one
+ * row per cell per layer. On mini (Qwen3.8-27B hybrid, four slots, 12k-token
+ * prompts) it stalled every slot for 9 to 10 s while the prompt itself
+ * reported a 4-token, 270 ms re-evaluation. Only the router's argv shows these
+ * flags; a fixed-model server's `/props` reports neither, and an environment
+ * variable such as `LLAMA_ARG_CACHE_IDLE_SLOTS` is invisible here.
+ */
+function llamaCppIdleSlotEvictionNote(id: string, flags: LlamaCppServerFlags): string | undefined {
+	const parallel = positiveNumber(flags.parallel);
+	if (parallel === undefined || !Number.isInteger(parallel) || parallel <= 1) return undefined;
+	if (flags.kvUnified !== true || flags.cacheRamMib === 0 || flags.cacheIdleSlots === false) return undefined;
+	return `${id} clears idle slots from its unified KV cache on every new request (--kv-unified, --parallel ${parallel}, idle-slot caching on): a returning prompt is restored from host RAM and can stall every slot for seconds; start it with --no-cache-idle-slots (preset: cache-idle-slots = false)`;
+}
+
 export interface LlamaCppStatusEnrichment {
 	discoveredCapabilities?: Partial<CapabilityFlags>;
 	modelId?: string;
 	serverFlags?: LlamaCppServerFlags;
 	notes?: string[];
+	/** Server settings that defeat prefix-cache reuse; each is also one of `notes`. */
+	cacheAdvisories?: string[];
 	/** The router's own load state for the selected model, when it reports one. */
 	loadState?: ProbeModelStatus["state"];
 }
@@ -471,6 +513,12 @@ function parseLlamaCppServerFlags(args: ReadonlyArray<string>): LlamaCppServerFl
 	const noKvUnifiedAt = args.lastIndexOf("--no-kv-unified");
 	if (noKvUnifiedAt > kvUnifiedAt) flags.kvUnified = false;
 	else if (kvUnifiedAt >= 0) flags.kvUnified = booleanFlag(args, "--kv-unified", "-kvu") ?? true;
+	const cacheRamMib = numberFlag(args, "--cache-ram", "-cram");
+	if (cacheRamMib !== undefined) flags.cacheRamMib = cacheRamMib;
+	const cacheIdleSlotsAt = args.lastIndexOf("--cache-idle-slots");
+	const noCacheIdleSlotsAt = args.lastIndexOf("--no-cache-idle-slots");
+	if (noCacheIdleSlotsAt > cacheIdleSlotsAt) flags.cacheIdleSlots = false;
+	else if (cacheIdleSlotsAt >= 0) flags.cacheIdleSlots = booleanFlag(args, "--cache-idle-slots") ?? true;
 	const cacheTypeK = valueAfter(args, "--cache-type-k");
 	if (cacheTypeK) flags.cacheTypeK = cacheTypeK;
 	const cacheTypeV = valueAfter(args, "--cache-type-v");
@@ -532,6 +580,11 @@ export async function probeLlamaCppModelStatus(
 			`${selected.id} context window ${formatContextWindowSlots(window.contextWindow, window.slots)}: --ctx-size is split across --parallel slots without --kv-unified`,
 		);
 	}
+	const idleSlotEviction = llamaCppIdleSlotEvictionNote(selected.id, flags);
+	if (idleSlotEviction) {
+		notes.push(idleSlotEviction);
+		enrichment.cacheAdvisories = [idleSlotEviction];
+	}
 	if (notes.length > 0) enrichment.notes = notes;
 	return withState(enrichment);
 }

package/src/domains/providers/runtimes/local-native/llamacpp-completion.ts

@@ -1,3 +1,4 @@
+import { writeDiagnostic } from "../../../../core/diagnostics.js";
 import type { Api, Model } from "../../../../engine/types.js";
 
 import { probeHttp } from "../../probe/http.js";
@@ -100,7 +101,7 @@ async function* streamSse(body: ReadableStream<Uint8Array>): AsyncGenerator<Comp
 		}
 	} finally {
 		if (droppedFrames > 0) {
-			process.stderr.write(`[clio-coder:llamacpp] dropped ${droppedFrames} malformed stream frame(s)\n`);
+			writeDiagnostic(`[clio-coder:llamacpp] dropped ${droppedFrames} malformed stream frame(s)\n`);
 		}
 		reader.releaseLock();
 	}
@@ -172,6 +173,7 @@ const llamacppCompletionRuntime: RuntimeDescriptor = {
 		const note = await detectModelMismatch(base, target, ctx);
 		const notes = [...(status.notes ?? []), ...(note ? [note] : [])];
 		if (notes.length > 0) enriched.notes = notes;
+		if (status.cacheAdvisories && status.cacheAdvisories.length > 0) enriched.cacheAdvisories = status.cacheAdvisories;
 		return enriched;
 	},
 	async probeModels(target: TargetDescriptor, ctx: ProbeContext): Promise<string[]> {

package/src/domains/providers/runtimes/local-native/llamacpp-embed.ts

@@ -69,19 +69,13 @@ const llamacppEmbedRuntime: RuntimeDescriptor = {
 		const healthOpts = { url: `${base}/health`, timeoutMs: ctx.httpTimeoutMs } as const;
 		const health = await (ctx.signal ? probeHttp({ ...healthOpts, signal: ctx.signal }) : probeHttp(healthOpts));
 		if (!health.ok) return health;
-		const probeResponse = await probeHttp({
-			url: `${base}/embedding`,
-			method: "POST",
-			timeoutMs: ctx.httpTimeoutMs,
-			headers: { "content-type": "application/json" },
-			body: JSON.stringify({ content: "probe" }),
-			...(ctx.signal ? { signal: ctx.signal } : {}),
-		});
-		if (!probeResponse.ok) {
-			return { ok: false, error: `/embedding not available: ${probeResponse.error}` };
-		}
-		const props = await probeLlamaCppProps(base, ctx, target.defaultModel);
-		const result: ProbeResult = { ok: true };
+		// Inference POSTs can load a model. Even /props?model=<id> can load a
+		// router worker, so ordinary discovery reads only the root metadata.
+		const props = await probeLlamaCppProps(base, ctx);
+		const result: ProbeResult = {
+			ok: true,
+			notes: ["Embedding inference not qualified: discovery read health and metadata only."],
+		};
 		if (health.latencyMs !== undefined) result.latencyMs = health.latencyMs;
 		if (props.discoveredCapabilities) result.discoveredCapabilities = props.discoveredCapabilities;
 		if (props.serverVersion) result.serverVersion = props.serverVersion;

package/src/domains/providers/runtimes/local-native/llamacpp-rerank.ts

@@ -50,23 +50,13 @@ const llamacppRerankRuntime: RuntimeDescriptor = {
 		const healthOpts = { url: `${base}/health`, timeoutMs: ctx.httpTimeoutMs } as const;
 		const health = await (ctx.signal ? probeHttp({ ...healthOpts, signal: ctx.signal }) : probeHttp(healthOpts));
 		if (!health.ok) return health;
-		const modelId = target.defaultModel ?? "default";
-		const probeResponse = await probeHttp({
-			url: `${base}/reranking`,
-			method: "POST",
-			timeoutMs: ctx.httpTimeoutMs,
-			headers: { "content-type": "application/json" },
-			body: JSON.stringify({ query: "probe", documents: ["a"], model: modelId }),
-			...(ctx.signal ? { signal: ctx.signal } : {}),
-		});
-		if (!probeResponse.ok || !(probeResponse.status === 200 || probeResponse.status === 202)) {
-			return {
-				ok: false,
-				error: `/reranking not available: ${probeResponse.error ?? `HTTP ${probeResponse.status}`}`,
-			};
-		}
-		const props = await probeLlamaCppProps(base, ctx, target.defaultModel);
-		const result: ProbeResult = { ok: true };
+		// Inference POSTs can load a model. Even /props?model=<id> can load a
+		// router worker, so ordinary discovery reads only the root metadata.
+		const props = await probeLlamaCppProps(base, ctx);
+		const result: ProbeResult = {
+			ok: true,
+			notes: ["Reranking inference not qualified: discovery read health and metadata only."],
+		};
 		if (health.latencyMs !== undefined) result.latencyMs = health.latencyMs;
 		if (props.discoveredCapabilities) result.discoveredCapabilities = props.discoveredCapabilities;
 		if (props.serverVersion) result.serverVersion = props.serverVersion;

package/src/domains/providers/runtimes/local-native/llamacpp.ts

@@ -86,6 +86,7 @@ const llamacppRuntime: RuntimeDescriptor = {
 		const note = await detectModelMismatch(base, target, ctx);
 		const notes = [...(status.notes ?? []), ...(note ? [note] : [])];
 		if (notes.length > 0) result.notes = notes;
+		if (status.cacheAdvisories && status.cacheAdvisories.length > 0) result.cacheAdvisories = status.cacheAdvisories;
 		return result;
 	},
 	async probeModels(target: TargetDescriptor, ctx: ProbeContext): Promise<string[]> {

package/src/domains/providers/runtimes/local-native/ollama.ts

@@ -0,0 +1,211 @@
+import { CLIO_MIN_CONTEXT_WINDOW, CLIO_MIN_MAX_OUTPUT_TOKENS } from "../../../../core/context-floor.js";
+import type { Api, Model } from "../../../../engine/types.js";
+import { probeJson } from "../../probe/http.js";
+import type { CapabilityFlags } from "../../types/capability-flags.js";
+import type { KnowledgeBaseHit } from "../../types/knowledge-base.js";
+import type { ProbeContext, ProbeModelStatus, ProbeResult, RuntimeDescriptor } from "../../types/runtime-descriptor.js";
+import type { TargetDescriptor } from "../../types/target-descriptor.js";
+import { synthLocalModel, targetRootUrl, withAsIs } from "../common/local-synth.js";
+import { ollamaModelIds } from "../common/ollama-model-ids.js";
+
+const defaultCapabilities: CapabilityFlags = {
+	chat: true,
+	tools: true,
+	toolCallFormat: "openai",
+	reasoning: false,
+	vision: false,
+	audio: false,
+	embeddings: false,
+	rerank: false,
+	fim: false,
+	contextWindow: CLIO_MIN_CONTEXT_WINDOW,
+	maxTokens: CLIO_MIN_MAX_OUTPUT_TOKENS,
+};
+
+interface OllamaTagsResponse {
+	models?: Array<{ name?: unknown; details?: { context_length?: unknown } }>;
+}
+
+interface OllamaShowResponse {
+	model_info?: Record<string, unknown>;
+	parameters?: unknown;
+}
+
+interface OllamaPsResponse {
+	models?: Array<{
+		name?: unknown;
+		model?: unknown;
+		size?: unknown;
+		size_vram?: unknown;
+		context_length?: unknown;
+	}>;
+}
+
+function positiveNumber(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
+}
+
+function probeHeaders(target: TargetDescriptor, ctx: ProbeContext): Record<string, string> {
+	const headers = new Headers(target.auth?.headers);
+	const envName = target.auth?.apiKeyEnvVar;
+	const token = ctx.authToken ?? (envName && ctx.credentialsPresent.has(envName) ? process.env[envName] : undefined);
+	if (token && !headers.has("authorization")) headers.set("authorization", `Bearer ${token}`);
+	return Object.fromEntries(headers);
+}
+
+/**
+ * Resident models reported by `/api/ps`, keyed by wire id. Best-effort: the
+ * probe still succeeds on `/api/tags` alone, so an `/api/ps` failure (older
+ * server, transient error) simply omits load state rather than failing
+ * discovery. Captures the VRAM/total footprint Ollama reports for each, and the
+ * window the model is actually loaded at: Ollama serves a resident model at
+ * `context_length`, which is routinely far below the model's own maximum
+ * (`OLLAMA_CONTEXT_LENGTH`, or the server default), and that smaller number is
+ * the one a run has to be planned against.
+ */
+async function probeResidentModelStates(
+	base: string,
+	ctx: ProbeContext,
+	headers: Record<string, string>,
+): Promise<Record<string, ProbeModelStatus> | undefined> {
+	const opts = { url: `${base}/api/ps`, headers, timeoutMs: ctx.httpTimeoutMs } as const;
+	const result = await (ctx.signal
+		? probeJson<OllamaPsResponse>({ ...opts, signal: ctx.signal })
+		: probeJson<OllamaPsResponse>(opts));
+	if (!result.ok || !result.data?.models) return undefined;
+	const states: Record<string, ProbeModelStatus> = {};
+	for (const row of result.data.models) {
+		const id = typeof row?.model === "string" ? row.model : typeof row?.name === "string" ? row.name : null;
+		if (!id) continue;
+		const status: ProbeModelStatus = { state: "loaded" };
+		const sizeVram = positiveNumber(row?.size_vram);
+		if (sizeVram !== undefined) status.sizeVramBytes = sizeVram;
+		const size = positiveNumber(row?.size);
+		if (size !== undefined) status.sizeBytes = size;
+		const contextLength = positiveNumber(row?.context_length);
+		if (contextLength !== undefined) status.contextLength = contextLength;
+		for (const alias of ollamaModelIds(id, ...(typeof row.name === "string" ? [row.name] : []))) {
+			states[alias] = status;
+		}
+	}
+	return Object.keys(states).length > 0 ? states : undefined;
+}
+
+/**
+ * The window a model can be opened at, from `/api/show`. `model_info` carries
+ * the trained maximum as `<architecture>.context_length`; a `num_ctx` baked
+ * into the Modelfile `parameters` caps what Ollama loads it at when a request
+ * does not ask for more, so the smaller of the two is the model's window.
+ * A target that sends its own `num_ctx` replaces the baked one, so `baked`
+ * is false there and only the trained maximum bounds it. Undefined when the
+ * server does not report the maximum.
+ */
+async function probeModelContextWindow(
+	base: string,
+	model: string,
+	ctx: ProbeContext,
+	baked: boolean,
+	headers: Record<string, string>,
+): Promise<number | undefined> {
+	const opts = {
+		url: `${base}/api/show`,
+		method: "POST",
+		headers: { ...headers, "content-type": "application/json" },
+		body: JSON.stringify({ model }),
+		timeoutMs: ctx.httpTimeoutMs,
+	} as const;
+	const result = await (ctx.signal
+		? probeJson<OllamaShowResponse>({ ...opts, signal: ctx.signal })
+		: probeJson<OllamaShowResponse>(opts));
+	const info = result.ok ? result.data?.model_info : undefined;
+	if (!info || typeof info !== "object") return undefined;
+	const arch = info["general.architecture"];
+	const maximum =
+		typeof arch === "string"
+			? positiveNumber(info[`${arch}.context_length`])
+			: positiveNumber(Object.entries(info).find(([key]) => key.endsWith(".context_length"))?.[1]);
+	if (maximum === undefined || !baked) return maximum;
+	const params = result.data?.parameters;
+	const bakedNumCtx = typeof params === "string" ? /^num_ctx\s+(\d+)\s*$/m.exec(params)?.[1] : undefined;
+	const bakedWindow = bakedNumCtx !== undefined ? positiveNumber(Number(bakedNumCtx)) : undefined;
+	return bakedWindow !== undefined ? Math.min(maximum, bakedWindow) : maximum;
+}
+
+const ollamaRuntime: RuntimeDescriptor = {
+	id: "ollama",
+	aliases: ["ollama-native"],
+	displayName: "Ollama (native)",
+	kind: "http",
+	tier: "local-native",
+	apiFamily: "ollama-native",
+	auth: "none",
+	defaultCapabilities,
+	requestedContextWindow(target: TargetDescriptor): number | undefined {
+		return target.ollama?.numCtx;
+	},
+	coldContextWindowCap: CLIO_MIN_CONTEXT_WINDOW,
+	async probe(target: TargetDescriptor, ctx: ProbeContext): Promise<ProbeResult> {
+		const base = targetRootUrl(target);
+		if (!base) return { ok: false, error: "target has no url" };
+		const headers = probeHeaders(target, ctx);
+		const opts = { url: `${base}/api/tags`, headers, timeoutMs: ctx.httpTimeoutMs } as const;
+		const result = await (ctx.signal
+			? probeJson<OllamaTagsResponse>({ ...opts, signal: ctx.signal })
+			: probeJson<OllamaTagsResponse>(opts));
+		if (!result.ok) {
+			const failed: ProbeResult = { ok: false };
+			if (result.error) failed.error = result.error;
+			if (result.latencyMs !== undefined) failed.latencyMs = result.latencyMs;
+			return failed;
+		}
+		// The client environment does not describe the daemon's OLLAMA_NUM_PARALLEL.
+		// Its API exposes no slot count; maxConcurrentRequests supplies an explicit override.
+		const out: ProbeResult = { ok: true, discoveredCapabilities: { parallelSlots: 1 } };
+		if (result.latencyMs !== undefined) out.latencyMs = result.latencyMs;
+		// The model maximum, which bounds planning when the model is not
+		// resident. Newer servers put it on every `/api/tags` row; older ones
+		// (0.18.x) do not, so the default model is asked `/api/show` directly.
+		const modelCapabilities: Record<string, Partial<CapabilityFlags>> = {};
+		for (const row of result.data?.models ?? []) {
+			const window = positiveNumber(row?.details?.context_length);
+			if (typeof row?.name === "string" && window !== undefined) modelCapabilities[row.name] = { contextWindow: window };
+		}
+		const defaultModel = target.defaultModel?.trim();
+		const [window, modelStates] = await Promise.all([
+			defaultModel
+				? probeModelContextWindow(base, defaultModel, ctx, target.ollama?.numCtx === undefined, headers)
+				: undefined,
+			probeResidentModelStates(base, ctx, headers),
+		]);
+		if (defaultModel && window !== undefined) modelCapabilities[defaultModel] = { contextWindow: window };
+		if (Object.keys(modelCapabilities).length > 0) out.modelCapabilities = modelCapabilities;
+		if (modelStates) out.modelStates = modelStates;
+		return out;
+	},
+	async probeModels(target: TargetDescriptor, ctx: ProbeContext): Promise<string[]> {
+		const base = targetRootUrl(target);
+		if (!base) return [];
+		const opts = { url: `${base}/api/tags`, headers: probeHeaders(target, ctx), timeoutMs: ctx.httpTimeoutMs } as const;
+		const result = await (ctx.signal
+			? probeJson<OllamaTagsResponse>({ ...opts, signal: ctx.signal })
+			: probeJson<OllamaTagsResponse>(opts));
+		if (!result.ok || !result.data?.models) return [];
+		return result.data.models
+			.map((row) => (typeof row?.name === "string" ? row.name : null))
+			.filter((name): name is string => name !== null);
+	},
+	synthesizeModel(target: TargetDescriptor, wireModelId: string, kb: KnowledgeBaseHit | null): Model<Api> {
+		const canonicalTarget = target.runtime === "ollama" ? target : { ...target, runtime: "ollama" };
+		return synthLocalModel({
+			target: canonicalTarget,
+			wireModelId,
+			kb,
+			defaultCapabilities,
+			apiFamily: "ollama-native",
+			provider: "ollama",
+			baseUrlForTarget: withAsIs,
+		});
+	},
+};
+
+export default ollamaRuntime;