@iowarp/clio-coder 0.4.9 → 0.5.0

package/src/domains/providers/extension.ts

@@ -1,20 +1,30 @@
 import { BusChannels } from "../../core/bus-events.js";
 import { type ClioSettings, readSettings } from "../../core/config.js";
+import { writeDiagnostic } from "../../core/diagnostics.js";
 import type { DomainBundle, DomainContext, DomainExtension } from "../../core/domain-loader.js";
 import { ensurePiAiRegistered } from "../../engine/ai.js";
 import { registerClioApiProviders, setGlobalDefaultMaxOutputTokens } from "../../engine/apis/index.js";
+import { releaseModelsLoadedDuring, releaseScopeFor } from "../../engine/apis/residency.js";
 import { registerClioOAuthProviders } from "../../engine/oauth.js";
 import type { ConfigContract } from "../config/contract.js";
 
 import { authNotRequiredStatus, openAuthStorage, resolveAuthTarget, targetRequiresAuth } from "./auth/index.js";
 import { mergeCapabilities } from "./capabilities.js";
 import { capabilitiesFromCatalogModel, getCatalogModelForRuntime } from "./catalog.js";
-import type { ContextWindowProvenance, ProvidersContract, TargetHealth, TargetStatus } from "./contract.js";
+import type {
+	ContextWindowProvenance,
+	LiveProbeOptions,
+	ProvidersContract,
+	TargetHealth,
+	TargetStatus,
+	ToolCallVerification,
+} from "./contract.js";
 import { credentialsPresent } from "./credentials.js";
 import { recordEndpointSlotsFromStatus } from "./endpoint-capacity.js";
 import { resolveProviderKnowledgeBaseRoots } from "./knowledge-base-path.js";
 import { probeCapabilitiesForModel } from "./model-capabilities.js";
 import { loadPluginRuntimes } from "./plugins.js";
+import { probeToolCall } from "./probe/tool-call.js";
 import { getRuntimeRegistry } from "./registry.js";
 import { registerBuiltinRuntimes } from "./runtimes/builtins.js";
 import { listKnownModelsForRuntime } from "./support.js";
@@ -31,6 +41,10 @@ import type { ProbeContext, ProbeResult, RuntimeDescriptor } from "./types/runti
 import type { TargetDescriptor } from "./types/target-descriptor.js";
 
 const DEFAULT_PROBE_TIMEOUT_MS = 5_000;
+/** The tool probe generates, so it can pay for a cold load of a large local model. */
+const DEFAULT_TOOL_PROBE_TIMEOUT_MS = 120_000;
+/** The key a turn sends to a target that needs none, matched so the probe request is the turn's. */
+const LOCAL_API_KEY_FALLBACK = "clio-coder-local-target";
 
 class NullKnowledgeBase implements KnowledgeBase {
 	lookup(_modelId: string): KnowledgeBaseHit | null {
@@ -47,7 +61,7 @@ function loadKnowledgeBase(): KnowledgeBase {
 		if (roots.length === 0) return new NullKnowledgeBase();
 		return new FileKnowledgeBase(roots);
 	} catch (err) {
-		process.stderr.write(`[providers] knowledge base disabled: ${err instanceof Error ? err.message : String(err)}\n`);
+		writeDiagnostic(`[providers] knowledge base disabled: ${err instanceof Error ? err.message : String(err)}\n`);
 		return new NullKnowledgeBase();
 	}
 }
@@ -138,8 +152,10 @@ function discoveredModelsSource(
 	cachedModels: ReadonlyArray<string>,
 	desc: RuntimeDescriptor,
 ): "probe" | "cache" | "runtime" | "none" {
-	if (probe?.models !== undefined) return "probe";
-	if (preservePreviousProbe && previous?.discoveredModels && previous.discoveredModels.length > 0) return "cache";
+	if (probe?.ok && probe.models !== undefined) return "probe";
+	if (preservePreviousProbe && previous?.discoveredModels && previous.discoveredModels.length > 0) {
+		return previous.discoveredModelsSource === "runtime" ? "runtime" : "cache";
+	}
 	if (cachedModels.length > 0) return "cache";
 	if (desc.knownModels && desc.knownModels.length > 0) return "runtime";
 	return "none";
@@ -169,10 +185,10 @@ export interface ProbeMerge {
 /**
  * Merge a fresh probe result with the previous known status. A probe that was
  * not attempted (`probe === null`) or that failed (`probe.ok === false`) must
- * not discard the last successful catalog and load states for an unchanged
- * target: a transient outage keeps the known models selectable, sourced from
+ * not discard the last successful catalog for an unchanged target. Failed
+ * probes clear resident state; a transient outage keeps models selectable from
  * `cache`, while health and availability (decided by the caller from `probe`)
- * reflect the failure. Only a successful probe replaces the catalog.
+ * reflect the failure. Only a successful nonempty catalog replaces the cached candidates.
  */
 function mergeProbeResult(
 	desc: RuntimeDescriptor,
@@ -183,35 +199,65 @@ function mergeProbeResult(
 	cachedModelLabels: Readonly<Record<string, string>> = {},
 ): ProbeMerge {
 	const probeSucceeded = probe?.ok ?? false;
-	const preservePrevious = !probeSucceeded && previous !== undefined && sameProbeIdentity(previous.target, target);
+	const preserveCatalog = previous !== undefined && sameProbeIdentity(previous.target, target);
+	// Successful metadata replaces the factual snapshot, including absent fields.
+	// Only catalog candidates may survive a successful but empty metadata read.
+	const preservePrevious = !probeSucceeded && preserveCatalog;
+	// Several catalog adapters return [] when metadata cannot be read. It is
+	// not sufficient evidence to erase the last useful catalog.
+	const catalogProbe = probeSucceeded && probe?.models && probe.models.length > 0 ? probe : null;
 	const probeCapabilities =
 		probe?.discoveredCapabilities ?? (preservePrevious ? previous.probeCapabilities : null) ?? null;
-	const probeModelCapabilities =
+	let probeModelCapabilities =
 		probe?.modelCapabilities ?? (preservePrevious ? previous.probeModelCapabilities : null) ?? null;
 	const probeModelId =
 		probe?.discoveredCapabilities !== undefined
 			? (probe.capabilityModelId ?? null)
 			: ((preservePrevious ? previous.probeModelId : null) ?? null);
-	const probeNotes =
+	let probeNotes =
 		probe?.notes && probe.notes.length > 0 ? probe.notes : preservePrevious ? previous.probeNotes : undefined;
 	const probeSurfaces = probe?.surfaces ?? (preservePrevious ? previous.probeSurfaces : undefined);
 	const discoveredModels = uniqueModels(
-		probe?.models ??
-			(preservePrevious ? previous.discoveredModels : undefined) ??
+		catalogProbe?.models ??
+			(preserveCatalog ? previous.discoveredModels : undefined) ??
 			(cachedModels.length > 0 ? cachedModels : undefined) ??
 			desc.knownModels ??
 			[],
 	);
-	const discoveredModelStates = probe?.modelStates ?? (preservePrevious ? previous.discoveredModelStates : null) ?? null;
+	const discoveredModelStates =
+		probe === null
+			? ((preservePrevious ? previous.discoveredModelStates : null) ?? null)
+			: probe.ok
+				? (probe.modelStates ?? null)
+				: null;
+	if (probe?.ok === false && preservePrevious && previous.discoveredModelStates) {
+		// Keep only conservative context bounds from the last observation, not
+		// a claim that its model, instance, load config or slots are still live.
+		for (const [modelId, state] of Object.entries(previous.discoveredModelStates)) {
+			const window = positiveWindow(state.contextLength);
+			if (window === undefined) continue;
+			const caps = probeModelCapabilities?.[modelId] ?? probeCapabilitiesForModel(previous, modelId);
+			probeModelCapabilities = {
+				...probeModelCapabilities,
+				[modelId]: { ...caps, contextWindow: Math.min(window, positiveWindow(caps?.contextWindow) ?? window) },
+			};
+		}
+		probeNotes = [
+			...new Set([
+				...(probeNotes ?? []),
+				"Current model residency is unknown after the failed probe; last observed context limits are retained conservatively.",
+			]),
+		];
+	}
 	const discoveredModelLabels =
-		probe?.modelLabels ??
-		(preservePrevious ? previous.discoveredModelLabels : undefined) ??
-		(cachedModels.length > 0 ? cachedModelLabels : undefined) ??
+		catalogProbe?.modelLabels ??
+		(catalogProbe === null && preserveCatalog ? previous.discoveredModelLabels : undefined) ??
+		(catalogProbe === null && cachedModels.length > 0 ? cachedModelLabels : undefined) ??
 		{};
 	const merge: ProbeMerge = {
 		discoveredModels,
 		discoveredModelLabels,
-		discoveredModelsSource: discoveredModelsSource(probe, preservePrevious, previous, cachedModels, desc),
+		discoveredModelsSource: discoveredModelsSource(catalogProbe, preserveCatalog, previous, cachedModels, desc),
 		discoveredModelStates,
 		probeCapabilities,
 		probeModelCapabilities,
@@ -255,7 +301,7 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 	const authStore = openAuthStorage();
 	const kb = loadKnowledgeBase();
 	const statuses = new Map<string, TargetStatus>();
-	const reasoningCache = new Map<string, boolean>();
+	const reasoningCache = new Map<string, true>();
 	const unsubscribeConfigListeners: Array<() => void> = [];
 	let stopped = false;
 
@@ -347,6 +393,7 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 			};
 			if (previous?.probeNotes && previous.probeNotes.length > 0) out.probeNotes = previous.probeNotes;
 			if (previous?.probeSurfaces) out.probeSurfaces = previous.probeSurfaces;
+			if (previous?.toolProbe) out.toolProbe = previous.toolProbe;
 			return out;
 		}
 		const availability = availabilityFor(desc, target, authStatusFor);
@@ -356,16 +403,25 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 		const { capabilities, contextWindowProvenance } = capabilitiesFor(desc, target, merge, kb);
 		const healthy = probe !== null ? probe.ok : null;
 		const unservedDefault = probe?.ok ? unservedDefaultModelReason(desc, target, merge) : null;
+		// A failed probe is still failed health evidence. Separately, permit a
+		// configured HTTP inference attempt; the inference endpoint can differ.
+		const allowHttpInferenceAttempt =
+			desc.kind === "http" &&
+			Boolean(target.url?.trim()) &&
+			!probe?.authFailed &&
+			probe?.failureKind !== "authentication" &&
+			probe?.failureKind !== "missing";
+		const catalogOnlyFailure = probe?.failureKind === "catalog-unavailable";
 		const health: TargetHealth =
 			probe === null
 				? (previous?.health ?? emptyHealth())
 				: {
-						status: healthy ? (unservedDefault === null ? "healthy" : "degraded") : "down",
+						status: healthy ? (unservedDefault === null ? "healthy" : "degraded") : catalogOnlyFailure ? "degraded" : "down",
 						lastCheckAt: new Date().toISOString(),
 						lastError: probe.error ?? unservedDefault,
 						latencyMs: probe.latencyMs ?? null,
 					};
-		const available = availability.available && (probe === null || probe.ok);
+		const available = availability.available && (probe === null || probe.ok || allowHttpInferenceAttempt);
 		const reason = probe !== null && !probe.ok ? (probe.error ?? "probe failed") : availability.reason;
 		const out: TargetStatus = {
 			target,
@@ -385,13 +441,14 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 		};
 		if (merge.probeNotes && merge.probeNotes.length > 0) out.probeNotes = merge.probeNotes;
 		if (merge.probeSurfaces) out.probeSurfaces = merge.probeSurfaces;
+		if (previous?.toolProbe) out.toolProbe = previous.toolProbe;
 		return out;
 	}
 
 	async function probeTargetInternal(
 		target: TargetDescriptor,
 		live: boolean,
-		options?: { reasoning?: boolean; signal?: AbortSignal },
+		options?: LiveProbeOptions,
 	): Promise<TargetStatus | null> {
 		options?.signal?.throwIfAborted();
 		if (stopped) return null;
@@ -431,43 +488,81 @@ 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;
-			const candidateModelId = orchestratorTarget ?? target.defaultModel ?? null;
-			if (candidateModelId) {
+		if (options?.reasoning === true) {
+			const note = (outcome: string): void => {
+				probeResult = { ...probeResult, notes: [...(probeResult.notes ?? []), outcome] };
+			};
+			const candidateModelId = probeCandidateModelId(target);
+			if (!probeResult.ok) {
+				note("Reasoning qualification not run: metadata probe failed.");
+			} else if (typeof desc.probeReasoning !== "function") {
+				note("Reasoning qualification not run: runtime has no reasoning qualification probe.");
+			} else if (!candidateModelId) {
+				note("Reasoning qualification not run: no chat or default model is configured.");
+			} else {
 				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) {
-						probeResult = {
-							...probeResult,
-							discoveredCapabilities: { ...(probeResult.discoveredCapabilities ?? {}), reasoning: result.reasoning },
-							modelCapabilities: {
-								...(probeResult.modelCapabilities ?? {}),
-								[candidateModelId]: {
-									...(probeResult.modelCapabilities?.[candidateModelId] ?? {}),
-									reasoning: result.reasoning,
+					if (result.reasoning === true && !result.error) {
+						note(`Reasoning qualification observed reasoning output for '${candidateModelId}'.`);
+						reasoningCache.set(reasoningCacheKey(target.id, candidateModelId), true);
+						const capabilityModelId = probeResult.capabilityModelId ?? null;
+						if (capabilityModelId === null || capabilityModelId === candidateModelId) {
+							probeResult = {
+								...probeResult,
+								discoveredCapabilities: { ...(probeResult.discoveredCapabilities ?? {}), reasoning: result.reasoning },
+								modelCapabilities: {
+									...(probeResult.modelCapabilities ?? {}),
+									[candidateModelId]: {
+										...(probeResult.modelCapabilities?.[candidateModelId] ?? {}),
+										reasoning: result.reasoning,
+									},
 								},
-							},
-							capabilityModelId: capabilityModelId ?? candidateModelId,
-						};
+								capabilityModelId: capabilityModelId ?? candidateModelId,
+							};
+						}
+					} else {
+						note(
+							result.error
+								? `Reasoning qualification error for '${candidateModelId}': ${result.error}; support remains unqualified by this check.`
+								: `Reasoning qualification inconclusive for '${candidateModelId}': no reasoning output observed; this does not establish lack of support.`,
+						);
 					}
-				} catch {
-					// reasoning detection is best-effort; missing/timeout leaves the cache cold.
+				} catch (err) {
+					note(
+						`Reasoning qualification error for '${candidateModelId}': ${err instanceof Error ? err.message : String(err)}; support remains unqualified by this check.`,
+					);
 				}
 			}
 		}
+		let toolProbe: ToolCallVerification | null = null;
+		if (probeResult.ok && options?.tools === true) {
+			toolProbe = await runToolProbe(target, desc, probeCtx, options.toolsTimeoutMs ?? DEFAULT_TOOL_PROBE_TIMEOUT_MS);
+			options.signal?.throwIfAborted();
+			if (!currentProbeTarget(target)) return null;
+			const modelId = toolProbe.modelId;
+			const capabilityModelId = probeResult.capabilityModelId ?? null;
+			if (toolProbe.status === "verified" && modelId && (capabilityModelId === null || capabilityModelId === modelId)) {
+				probeResult = {
+					...probeResult,
+					discoveredCapabilities: { ...(probeResult.discoveredCapabilities ?? {}), tools: true },
+					modelCapabilities: {
+						...(probeResult.modelCapabilities ?? {}),
+						[modelId]: { ...(probeResult.modelCapabilities?.[modelId] ?? {}), tools: true },
+					},
+					capabilityModelId: capabilityModelId ?? modelId,
+				};
+			}
+		}
 		// Cancellation, target edits/removal, and shutdown revoke publication.
 		options?.signal?.throwIfAborted();
 		const current = currentProbeTarget(target);
 		if (!current) return null;
 		const status = buildStatus(current, desc, probeResult, previous);
+		if (toolProbe) status.toolProbe = toolProbe;
 		statuses.set(target.id, status);
-		if (probeResult.ok && probeResult.models !== undefined) {
+		if (probeResult.ok && probeResult.models !== undefined && probeResult.models.length > 0) {
 			recordTargetModelSnapshot(
 				target,
 				probeResult.models,
@@ -482,7 +577,76 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 		return status;
 	}
 
-	async function probeReasoningForModelInternal(targetId: string, modelId: string): Promise<boolean | null> {
+	/** The only models an inference probe may touch: the chat model on this target, else its default. */
+	function probeCandidateModelId(target: TargetDescriptor): string | null {
+		const settings = readConfig();
+		const orchestratorModel = settings.chat.target === target.id ? settings.chat.model : null;
+		return orchestratorModel ?? target.defaultModel ?? null;
+	}
+
+	async function runToolProbe(
+		target: TargetDescriptor,
+		desc: RuntimeDescriptor,
+		probeCtx: ProbeContext,
+		timeoutMs: number,
+	): Promise<ToolCallVerification> {
+		const modelId = probeCandidateModelId(target);
+		const skipped = (error: string): ToolCallVerification => ({
+			status: "skipped",
+			modelId,
+			streamed: false,
+			frames: null,
+			toolCall: false,
+			argumentsValid: false,
+			latencyMs: null,
+			checkedAt: Date.now(),
+			error,
+		});
+		if (!modelId) return skipped("no chat or default model is set for this target");
+		// SDK and subprocess runtimes stream through their own worker runners,
+		// not the engine request path this probe exercises.
+		if (desc.kind !== "http") return skipped(`runtime kind '${desc.kind}' does not stream through the engine`);
+		let model: ReturnType<RuntimeDescriptor["synthesizeModel"]>;
+		try {
+			model = desc.synthesizeModel(target, modelId, kb.lookup(modelId));
+		} catch (err) {
+			return skipped(`model synthesis failed: ${err instanceof Error ? err.message : String(err)}`);
+		}
+		const apiKey = targetRequiresAuth(target, desc) ? probeCtx.authToken : LOCAL_API_KEY_FALLBACK;
+		// The probe can load and pin a cold model, and `targets` never runs the
+		// orchestrator's release on exit, so the release happens here for every
+		// caller, on success, failure, and abort. It is scoped to this server and
+		// this model: in-session `/doctor deep` shares the process with chat turns,
+		// and a model a concurrent turn loaded belongs to that turn.
+		const result = await releaseModelsLoadedDuring(
+			() =>
+				probeToolCall({
+					model,
+					timeoutMs,
+					...(apiKey !== undefined ? { apiKey } : {}),
+					...(probeCtx.signal ? { signal: probeCtx.signal } : {}),
+				}),
+			releaseScopeFor([target.url, model.baseUrl], [modelId, model.id]),
+		);
+		const out: ToolCallVerification = {
+			status: result.ok ? "verified" : "failed",
+			modelId,
+			streamed: result.streamed,
+			frames: result.frames,
+			toolCall: result.toolCall,
+			argumentsValid: result.argumentsValid,
+			latencyMs: result.latencyMs,
+			checkedAt: Date.now(),
+		};
+		if (result.error !== undefined) out.error = result.error;
+		return out;
+	}
+
+	async function probeReasoningForModelInternal(
+		targetId: string,
+		modelId: string,
+		options?: { active?: boolean; signal?: AbortSignal },
+	): Promise<boolean | null> {
 		if (stopped) return null;
 		const settings = readConfig();
 		const configuredTarget = settings.targets.find((ep) => ep.id === targetId);
@@ -490,13 +654,19 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 		const target = structuredClone(configuredTarget);
 		const desc = registry.get(target.runtime);
 		if (!desc || typeof desc.probeReasoning !== "function") return null;
-		const probeCtx = await buildProbeContextForTarget(target, desc);
+		const cached = reasoningCache.get(reasoningCacheKey(targetId, modelId)) ?? null;
+		if (options?.active !== true) return cached;
+		options.signal?.throwIfAborted();
+		const probeCtx = await buildProbeContextForTarget(target, desc, options.signal);
 		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;
+			if (!currentProbeTarget(target) || options.signal?.aborted) return null;
+			if (result.reasoning === true && !result.error) {
+				reasoningCache.set(reasoningCacheKey(targetId, modelId), true);
+				return true;
+			}
+			return cached;
 		} catch {
 			return null;
 		}
@@ -505,7 +675,14 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 	async function probeAll(): Promise<void> {
 		const settings = readConfig();
 		const next = new Map<string, TargetStatus>();
-		reasoningCache.clear();
+		for (const previous of statuses.values()) {
+			const current = settings.targets.find((target) => target.id === previous.target.id);
+			if (!current || !sameProbeIdentity(previous.target, current)) {
+				for (const key of reasoningCache.keys()) {
+					if (key.startsWith(`${previous.target.id}:`)) reasoningCache.delete(key);
+				}
+			}
+		}
 		for (const target of settings.targets) {
 			const desc = registry.get(target.runtime);
 			const status = buildStatus(target, desc, null, statuses.get(target.id));
@@ -517,13 +694,13 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 		}
 	}
 
-	async function probeAllLive(): Promise<void> {
+	async function probeAllLive(options?: LiveProbeOptions): Promise<void> {
 		const settings = readConfig();
 		const activeIds = new Set(settings.targets.map((ep) => ep.id));
 		for (const id of Array.from(statuses.keys())) {
 			if (!activeIds.has(id)) statuses.delete(id);
 		}
-		await Promise.all(settings.targets.map((ep) => probeTargetInternal(ep, true)));
+		await Promise.all(settings.targets.map((ep) => probeTargetInternal(ep, true, options)));
 	}
 
 	const extension: DomainExtension = {
@@ -589,8 +766,8 @@ export function createProvidersBundle(context: DomainContext): DomainBundle<Prov
 			const cached = reasoningCache.get(reasoningCacheKey(targetId, modelId));
 			return cached ?? null;
 		},
-		probeReasoningForModel(targetId, modelId) {
-			return probeReasoningForModelInternal(targetId, modelId);
+		probeReasoningForModel(targetId, modelId, options) {
+			return probeReasoningForModelInternal(targetId, modelId, options);
 		},
 		auth: {
 			statusForTarget(target, runtime) {

package/src/domains/providers/model-discovery.ts

@@ -76,14 +76,14 @@ export function modelResidencyForStatus(status: DiscoveryStatus | null | undefin
 }
 
 export function hasLiveModelCatalog(status: TargetStatus): boolean {
-	return status.discoveredModelsSource === "probe" || status.discoveredModelsSource === "cache";
+	return status.discoveredModelsSource === "probe";
 }
 
 /**
  * Enumerate selectable wire model ids for a target. Before a live catalog is
  * known, Clio keeps useful configured/default/catalog hints. Once the target
- * returns a live catalog, that catalog is authoritative: configured and default
- * model ids that the provider no longer returns stop resolving.
+ * returns a live catalog, it supplies the current selectable candidates. Cached
+ * catalogs remain useful hints alongside configured/default ids, never live proof.
  */
 export function modelCandidatesForStatus(status: TargetStatus): ProviderModelCandidate[] {
 	const configured = uniqueModels(status.target.wireModels ?? []);
@@ -95,7 +95,7 @@ export function modelCandidatesForStatus(status: TargetStatus): ProviderModelCan
 		const trimmed = id.trim();
 		if (trimmed.length === 0 || seen.has(trimmed)) return;
 		seen.add(trimmed);
-		const state = status.discoveredModelStates?.[trimmed];
+		const state = hasLiveModelCatalog(status) ? status.discoveredModelStates?.[trimmed] : undefined;
 		out.push({
 			id: trimmed,
 			...(status.discoveredModelLabels?.[trimmed] ? { label: status.discoveredModelLabels[trimmed] } : {}),
@@ -105,11 +105,20 @@ export function modelCandidatesForStatus(status: TargetStatus): ProviderModelCan
 		});
 	};
 
-	if (hasLiveModelCatalog(status)) {
+	if (hasLiveModelCatalog(status) && discovered.length > 0) {
 		for (const id of discovered) add(id, "live");
 		return out;
 	}
 
+	// A cached catalog is still useful for selection, but it cannot exclude an
+	// explicitly configured model or claim that an instance is currently loaded.
+	if (status.discoveredModelsSource === "cache") {
+		for (const id of configured) add(id, "configured");
+		if (defaultModel) add(defaultModel, "default");
+		for (const id of discovered) add(id, "catalog");
+		if (out.length > 0) return out;
+	}
+
 	if (configured.length > 0) {
 		for (const id of configured) add(id, "configured");
 		if (defaultModel) add(defaultModel, "default");
@@ -136,10 +145,15 @@ export function modelIdsForStatus(status: TargetStatus): string[] {
 export function canonicalizeWireModelId(status: TargetStatus, requested: string): string {
 	const trimmedRequested = requested.trim();
 	if (trimmedRequested.length === 0) return requested;
-	// Canonicalize against the authoritative wire ids: the live catalog when one
-	// exists, otherwise the configured wire models.
+	// Prefer live wire ids; otherwise retain configured ids and cached hints.
 	const candidates = uniqueModels(
-		hasLiveModelCatalog(status) ? status.discoveredModels : (status.target.wireModels ?? []),
+		hasLiveModelCatalog(status)
+			? status.discoveredModels
+			: [
+					...(status.target.wireModels ?? []),
+					status.target.defaultModel ?? "",
+					...(status.discoveredModelsSource === "cache" ? status.discoveredModels : []),
+				],
 	);
 	if (candidates.includes(trimmedRequested)) return trimmedRequested;
 

package/src/domains/providers/models/local-models/clio-coder-local-coding-targets.yaml

@@ -133,7 +133,6 @@
         temperature: 0.5
         topP: 0.9
         topK: 20
-        reasoningBudget: 4096
       instruct:
         temperature: 0.5
         topP: 0.9
@@ -399,7 +398,6 @@
         temperature: 0.6
         topP: 0.95
         topK: 20
-        reasoningBudget: 4096
       instruct:
         temperature: 0.7
         topP: 0.80
@@ -469,7 +467,6 @@
         temperature: 0.6
         topP: 0.95
         topK: 20
-        reasoningBudget: 4096
       instruct:
         temperature: 0.6
         topP: 0.95
@@ -550,7 +547,6 @@
         temperature: 0.6
         topP: 0.95
         topK: 20
-        reasoningBudget: 4096
       instruct:
         temperature: 0.6
         topP: 0.95
@@ -655,6 +651,11 @@
         These effort levels come from that server diagnostic, not from
         Qwen or Qwopus name similarity. Other capabilities remain supplied
         by the route probe; no sampler, hardware, or context size is inherited.
+        Since 2026-09-18 the mini/qwopus3.8-27b-dense route is mini's default
+        and serves Qwopus3.8-27B-Flash-MTP IQ4_XS, four slots sharing one
+        262144-token pool with q8_0 KV (dotfiles 1cc3773). Its preset sets
+        reasoning-effort high. The effort levels below were measured on the
+        -q6 route only and have not been re-measured on this deployment.
     thinking:
       mechanism: effort-levels
       effortByLevel:
@@ -1462,7 +1463,6 @@
         temperature: 0.3
         topP: 0.9
         topK: 20
-        reasoningBudget: 4096
       instruct:
         temperature: 0.7  # 0.7 keeps tool-call JSON parseable; gemma card's 1.0 is for chat
         topP: 0.95
@@ -1599,7 +1599,6 @@
         temperature: 0.6
         topP: 0.95
         topK: 20
-        reasoningBudget: 4096
       instruct:
         temperature: 0.2
         topP: 0.9
@@ -1668,7 +1667,6 @@
         temperature: 0.6
         topP: 0.95
         topK: 20
-        reasoningBudget: 2048
     gpuTiers:
       "16gb": "Use this as the local 16GB emulation target. It keeps the output cap below the 32GB-class MoE defaults."
     runtimePreference:

package/src/domains/providers/plugins.ts

@@ -1,3 +1,4 @@
+import { writeDiagnostic } from "../../core/diagnostics.js";
 /**
  * Loads out-of-tree runtime descriptors into the registry. Two surfaces:
  *
@@ -31,9 +32,7 @@ export async function loadPluginRuntimes(
 		const ids = await registry.loadFromDir(pluginDir, activateExternalPluginApiBridge);
 		loaded.push(...ids);
 	} catch (err) {
-		process.stderr.write(
-			`[providers] loadFromDir ${pluginDir} failed: ${err instanceof Error ? err.message : String(err)}\n`,
-		);
+		writeDiagnostic(`[providers] loadFromDir ${pluginDir} failed: ${err instanceof Error ? err.message : String(err)}\n`);
 	}
 
 	for (const packageName of packages) {
@@ -41,7 +40,7 @@ export async function loadPluginRuntimes(
 			const ids = await registry.loadFromPackage(packageName, activateExternalPluginApiBridge);
 			loaded.push(...ids);
 		} catch (err) {
-			process.stderr.write(
+			writeDiagnostic(
 				`[providers] loadFromPackage ${packageName} failed: ${err instanceof Error ? err.message : String(err)}\n`,
 			);
 		}

package/src/domains/providers/probe/fingerprint.ts

@@ -1,5 +1,5 @@
 export interface NativeRuntimeFingerprint {
-	runtimeId: "lmstudio" | "ollama-native";
+	runtimeId: "lmstudio" | "ollama";
 	displayName: string;
 }
 
@@ -60,7 +60,7 @@ export async function fingerprintNativeRuntime(
 		try {
 			const data = (await ollama.json()) as { version?: unknown };
 			if (typeof data.version === "string") {
-				return { runtimeId: "ollama-native", displayName: "Ollama" };
+				return { runtimeId: "ollama", displayName: "Ollama" };
 			}
 		} catch {
 			// A reachable endpoint with a non-JSON version reply fingerprints as