@iowarp/clio-coder 0.3.0 → 0.3.1

package/dist/{chunk-TKHQ4DGZ.js → chunk-H6F6BYOH.js}

@@ -1,30 +1,38 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   BusChannels,
   getSharedBus
-} from "./chunk-D5YD55AR.js";
+} from "./chunk-Q5WJOSJ7.js";
 import {
   readSettings,
   sleep
-} from "./chunk-JWHCJDCI.js";
+} from "./chunk-KY56HMHH.js";
 import {
   authNotRequiredStatus,
   openAuthStorage,
   registerClioOAuthProviders,
+  require_dist,
   resolveAuthTarget,
   resolveRuntimeAuthTarget,
-  targetRequiresAuth
-} from "./chunk-5LDRNKX2.js";
+  targetRequiresAuth,
+  withStateFileLock
+} from "./chunk-GB6QRBXN.js";
 import {
   cwdHash,
   sessionPaths
-} from "./chunk-UGYAX5YI.js";
+} from "./chunk-HQQID6OA.js";
 import {
   clioConfigDir,
   clioStatePath,
   resolveClioDirs
-} from "./chunk-X3NE4WVW.js";
+} from "./chunk-BNAZZHFG.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
 
 // src/core/run-overrides.ts
+init_esm_shims();
 var RUN_OVERRIDES_ENV = "CLIO_CODER_RUN_OVERRIDES";
 function runOverrides(env = process.env) {
   const raw = env[RUN_OVERRIDES_ENV]?.trim();
@@ -68,7 +76,11 @@ async function withRunOverrides(overrides, fn) {
   }
 }
 
+// src/domains/providers/catalog.ts
+init_esm_shims();
+
 // src/engine/ai.ts
+init_esm_shims();
 import {
   fauxAssistantMessage,
   fauxToolCall,
@@ -192,6 +204,7 @@ function registerFauxFromEnv() {
 }
 
 // src/domains/providers/capabilities.ts
+init_esm_shims();
 function mergeCapabilities(base, kb, probe, userOverride) {
   const merged = { ...base };
   applyLayer(merged, probe);
@@ -325,7 +338,11 @@ function synthesizeCatalogBackedModel(input) {
   return model;
 }
 
+// src/domains/providers/types/capability-flags.ts
+init_esm_shims();
+
 // src/domains/providers/model-family.ts
+init_esm_shims();
 function normalizeModelIdForFamily(modelId) {
   return (modelId ?? "").trim().toLowerCase().replace(/_/g, "-");
 }
@@ -412,7 +429,11 @@ function availableThinkingLevels(caps, options) {
   return THINKING_LEVELS_WITHOUT_XHIGH;
 }
 
+// src/domains/providers/model-capabilities.ts
+init_esm_shims();
+
 // src/domains/providers/types/local-model-quirks.ts
+init_esm_shims();
 var KV_CACHE_QUANTS = ["f32", "f16", "q8_0", "q4_0", "q4_1", "iq4_nl", "q5_0", "q5_1"];
 function isRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -597,61 +618,25 @@ function resolveModelCapabilities(status, wireModelId, knowledgeBase, options) {
   );
 }
 
+// src/engine/apis/residency.ts
+init_esm_shims();
+
 // src/engine/apis/residency-lock.ts
-import { mkdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+init_esm_shims();
 import { join } from "node:path";
-var LOCK_STALE_MS = 13e4;
 var LOCK_WAIT_MS = 12e4;
-var LOCK_POLL_MS = 200;
-function lockPathFor(targetKey) {
-  const name = targetKey.replace(/[^a-zA-Z0-9._-]+/g, "_");
-  return join(clioStatePath(), "residency-locks", `${name}.lock`);
-}
-function tryAcquire(lockPath) {
-  try {
-    writeFileSync(lockPath, `${JSON.stringify({ pid: process.pid, at: (/* @__PURE__ */ new Date()).toISOString() })}
-`, {
-      encoding: "utf8",
-      flag: "wx",
-      mode: 420
-    });
-    return true;
-  } catch (err) {
-    if (err.code !== "EEXIST") throw err;
-  }
-  try {
-    if (Date.now() - statSync(lockPath).mtimeMs > LOCK_STALE_MS) rmSync(lockPath, { force: true });
-  } catch {
-  }
-  return false;
+function lockTargetFor(targetKey) {
+  return join(clioStatePath(), "residency-locks", targetKey.replace(/[^a-zA-Z0-9._-]+/g, "_"));
 }
 async function withResidencyLock(targetKey, fn) {
-  const lockPath = lockPathFor(targetKey);
-  let held = false;
-  try {
-    mkdirSync(join(clioStatePath(), "residency-locks"), { recursive: true });
-    const deadline = Date.now() + LOCK_WAIT_MS;
-    held = tryAcquire(lockPath);
-    while (!held && Date.now() < deadline) {
-      await sleep(LOCK_POLL_MS);
-      held = tryAcquire(lockPath);
-    }
-  } catch {
-    held = false;
-  }
-  try {
-    return await fn();
-  } finally {
-    if (held) {
-      try {
-        rmSync(lockPath, { force: true });
-      } catch {
-      }
-    }
-  }
+  return withStateFileLock(lockTargetFor(targetKey), fn, {
+    timeoutMs: LOCK_WAIT_MS,
+    onAcquireFailure: "run-unlocked"
+  });
 }
 
 // src/engine/apis/resident-models.ts
+init_esm_shims();
 function residentMatchesKeep(entry, keepModelId) {
   return entry.modelId === keepModelId || (entry.aliasIds?.includes(keepModelId) ?? false);
 }
@@ -674,13 +659,19 @@ var protectedModelsProvider = null;
 function setProtectedModelsProvider(provider) {
   protectedModelsProvider = provider;
 }
-function configProtectedIds() {
+function configProtectedRoles() {
+  const roles = /* @__PURE__ */ new Map();
   try {
-    const ids = protectedModelsProvider?.() ?? [];
-    return new Set(ids.map((id) => id.trim()).filter((id) => id.length > 0));
+    for (const entry of protectedModelsProvider?.() ?? []) {
+      const modelId = (typeof entry === "string" ? entry : entry.modelId).trim();
+      if (modelId.length === 0) continue;
+      const role = typeof entry === "string" ? void 0 : entry.role;
+      if (!roles.has(modelId) || roles.get(modelId) === void 0) roles.set(modelId, role);
+    }
   } catch {
-    return /* @__PURE__ */ new Set();
+    return /* @__PURE__ */ new Map();
   }
+  return roles;
 }
 function residentTagProtected(tags) {
   if (!tags) return false;
@@ -724,14 +715,21 @@ function makeNotice(facts, kind, level, message, detail) {
 function clioLoadedFirst(entries) {
   return [...entries.filter((entry) => entry.loadedByClio), ...entries.filter((entry) => !entry.loadedByClio)];
 }
+function describeRole(role) {
+  if (role === "chat") return "the chat model";
+  if (role === "memory") return "the memory model";
+  if (role === "worker") return "a worker model";
+  if (role === "target-default") return "a target default model";
+  return "a configured model";
+}
 function evictionNotice(facts, entry) {
   if (entry.protection === "config") {
     return makeNotice(
       facts,
       "swap",
       "warning",
-      `evicting '${entry.modelId}' from '${facts.targetId}' to make room for '${facts.keepModelId}' even though settings still reference it: every slot is taken and no unprotected resident is left. Another profile pointed at it will reload it.`,
-      { swappedOut: entry.modelId, configProtected: true }
+      `evicting '${entry.modelId}' from '${facts.targetId}' to make room for '${facts.keepModelId}' even though settings still reference it as ${describeRole(entry.role)}: every slot is taken and no unprotected resident is left. Another profile pointed at it will reload it.`,
+      { swappedOut: entry.modelId, configProtected: true, ...entry.role ? { role: entry.role } : {} }
     );
   }
   if (entry.loadedByClio) {
@@ -787,7 +785,7 @@ function decideResidency(facts) {
   }
   if (keepResident) {
     if (others.length > 0) {
-      const names = others.map((entry) => entry.modelId).join(", ");
+      const names = others.map((entry) => entry.role ? `${entry.modelId} (${entry.role})` : entry.modelId).join(", ");
       if (facts.capacity !== void 0 && facts.resident.length > facts.capacity) {
         notices.push(
           makeNotice(
@@ -814,10 +812,11 @@ function decideResidency(facts) {
   }
   const tierUnprotected = clioLoadedFirst(others.filter((entry) => entry.protection === void 0));
   const tierConfig = clioLoadedFirst(others.filter((entry) => entry.protection === "config"));
+  const configEvictable = facts.keepTagProtected !== true;
   let evict = [];
   let fallbackEvict = [];
   if (facts.strategy === "jit") {
-    fallbackEvict = [...tierUnprotected, ...tierConfig];
+    fallbackEvict = configEvictable ? [...tierUnprotected, ...tierConfig] : tierUnprotected;
   } else if (facts.strategy === "scheduler") {
     evict = tierUnprotected.filter((entry) => entry.loadedByClio);
   } else if (facts.capacity === void 0) {
@@ -825,7 +824,26 @@ function decideResidency(facts) {
   } else {
     const slotsNeeded = facts.resident.length + 1 - facts.capacity;
     if (slotsNeeded > 0) {
-      const candidates = [...tierUnprotected, ...tierConfig];
+      const candidates = configEvictable ? [...tierUnprotected, ...tierConfig] : tierUnprotected;
+      if (candidates.length < slotsNeeded && !configEvictable && tierUnprotected.length + tierConfig.length >= slotsNeeded) {
+        const blocked = tierConfig.slice(0, slotsNeeded - tierUnprotected.length);
+        const names = blocked.map((entry) => `'${entry.modelId}' (${describeRole(entry.role)})`).join(", ");
+        notices.push(
+          makeNotice(
+            facts,
+            "will-not-fit",
+            "error",
+            `cannot load pinned '${facts.keepModelId}' on '${facts.targetId}': it would evict ${names} that settings still reference, and a pinned model is never evicted, so the configured model could not return. Unload one manually, unpin '${facts.keepModelId}' on the server, or raise the server's max instances.`,
+            {
+              residentCount: facts.resident.length,
+              maxInstances: facts.capacity,
+              configProtected: true,
+              ...blocked[0]?.role ? { role: blocked[0].role } : {}
+            }
+          )
+        );
+        return { decision: "decline", evict: [], fallbackEvict: [], keepResident, notices };
+      }
       if (candidates.length < slotsNeeded) {
         notices.push(
           makeNotice(
@@ -881,14 +899,24 @@ async function reconcileResidency(adapter) {
       capacity = void 0;
     }
   }
-  const protectedIds = configProtectedIds();
+  let keepTagProtected = false;
+  if (adapter.keepModelTags) {
+    try {
+      keepTagProtected = residentTagProtected(await adapter.keepModelTags());
+    } catch {
+      keepTagProtected = false;
+    }
+  }
+  const protectedRoles = configProtectedRoles();
   const classified = resident.map((entry) => {
-    const configProtected = protectedIds.has(entry.modelId) || (entry.aliasIds ?? []).some((id) => protectedIds.has(id));
-    const protection = residentTagProtected(entry.tags) ? "tag" : configProtected ? "config" : void 0;
+    const configId = [entry.modelId, ...entry.aliasIds ?? []].find((id) => protectedRoles.has(id));
+    const protection = residentTagProtected(entry.tags) ? "tag" : configId !== void 0 ? "config" : void 0;
+    const role = configId === void 0 ? void 0 : protectedRoles.get(configId);
     return {
       ...entry,
       loadedByClio: isClioLoaded(adapter.targetKey, entry),
-      ...protection ? { protection } : {}
+      ...protection ? { protection } : {},
+      ...role ? { role } : {}
     };
   });
   const facts = {
@@ -899,6 +927,7 @@ async function reconcileResidency(adapter) {
     managed: adapter.managed,
     strategy: adapter.strategy,
     ...capacity !== void 0 ? { capacity } : {},
+    ...keepTagProtected ? { keepTagProtected } : {},
     ...adapter.contextLength !== void 0 ? { contextLength: adapter.contextLength } : {},
     ...adapter.modelMaxContext !== void 0 ? { modelMaxContext: adapter.modelMaxContext } : {}
   };
@@ -941,13 +970,18 @@ function residencyManagedFor(lifecycle, env = process.env) {
 }
 
 // src/engine/apis/lmstudio-native.ts
+init_esm_shims();
 import { randomUUID } from "node:crypto";
 import { createAssistantMessageEventStream as createAssistantMessageEventStream2 } from "@earendil-works/pi-ai";
 import {
   LMStudioClient
 } from "@lmstudio/sdk";
 
+// src/domains/providers/model-runtime-capabilities.ts
+init_esm_shims();
+
 // src/domains/providers/thinking-control-policy.ts
+init_esm_shims();
 var ANTHROPIC_MIN_THINKING_BUDGET = 1024;
 var ANTHROPIC_VISIBLE_OUTPUT_RESERVE = 1024;
 var ANTHROPIC_DEFAULT_THINKING_BUDGETS = {
@@ -1426,6 +1460,7 @@ function resolveTargetRuntimeCapabilities(target, runtime, wireModelId, capabili
 }
 
 // src/domains/providers/runtimes/common/lmstudio-logger.ts
+init_esm_shims();
 function formatMessage(message) {
   if (message instanceof Error) return message.stack ?? message.message;
   if (typeof message === "string") return message;
@@ -1448,10 +1483,12 @@ var lmStudioQuietLogger = {
 };
 
 // src/domains/session/context-accounting.ts
+init_esm_shims();
 import { appendFileSync, existsSync, readFileSync } from "node:fs";
 import { dirname, join as join2 } from "node:path";
 
 // src/domains/session/compaction/auto.ts
+init_esm_shims();
 var DEFAULT_COMPACTION_THRESHOLD = 0.8;
 function shouldCompact(contextTokens, threshold, contextWindow) {
   const base = {
@@ -1496,6 +1533,7 @@ var AutoCompactionTrigger = class {
 };
 
 // src/domains/session/context-ledger.ts
+init_esm_shims();
 var SEGMENT_CATEGORY = {
   identity: "system",
   "operating-contract": "system",
@@ -1625,6 +1663,7 @@ function buildContextLedger(input) {
     provider: input.provider ?? null,
     model: input.model ?? null,
     contextWindow: window,
+    contextWindowSource: input.contextWindowSource ?? null,
     usedTokens,
     reserveTokens,
     freeTokens,
@@ -2023,6 +2062,7 @@ function reconcileSnapshot(snapshot, usage) {
 }
 
 // src/engine/harmony-response.ts
+init_esm_shims();
 var START = "<|start|>";
 var CHANNEL = "<|channel|>";
 var CONSTRAIN = "<|constrain|>";
@@ -2141,6 +2181,7 @@ function harmonyPrefixTailLength(value) {
 }
 
 // src/engine/strip-tokenizer-sentinels.ts
+init_esm_shims();
 var KNOWN_SENTINELS = [
   "<|endoftext|>",
   "<|im_start|>",
@@ -2196,13 +2237,85 @@ function createSentinelStripper() {
   };
 }
 
+// src/engine/apis/degraded-inference.ts
+init_esm_shims();
+var DEGRADED_GRACE_MS = 3e4;
+var DEGRADED_FLOOR_TOKENS_PER_SECOND = 2;
+function defaultTimer(fn, ms) {
+  const handle = setInterval(fn, ms);
+  handle.unref?.();
+  return { cancel: () => clearInterval(handle) };
+}
+function startDegradedInferenceWatchdog(options) {
+  const now = options.now ?? Date.now;
+  const graceMs = options.graceMs ?? DEGRADED_GRACE_MS;
+  const floor = options.floorTokensPerSecond ?? DEGRADED_FLOOR_TOKENS_PER_SECOND;
+  const pollMs = options.pollMs ?? 5e3;
+  const startedAt = now();
+  let tokens = 0;
+  let reported = false;
+  let stopped = false;
+  const check = () => {
+    if (reported || stopped) return;
+    const elapsedMs = now() - startedAt;
+    if (elapsedMs < graceMs) return;
+    const tokensPerSecond = tokens / (elapsedMs / 1e3);
+    if (tokensPerSecond >= floor) return;
+    reported = true;
+    timer.cancel();
+    try {
+      options.onDegraded({ elapsedMs, tokens, tokensPerSecond });
+    } catch {
+    }
+  };
+  const timer = (options.setTimer ?? defaultTimer)(check, pollMs);
+  return {
+    addTokens: (count) => {
+      if (Number.isFinite(count) && count > 0) tokens += count;
+    },
+    check,
+    stop: () => {
+      if (stopped) return;
+      stopped = true;
+      timer.cancel();
+    }
+  };
+}
+
+// src/engine/apis/lmstudio-residency.ts
+init_esm_shims();
+var CO_RESIDENT_CONTEXT_CEILING = 131072;
+function coResidentContextCeiling(env = process.env) {
+  const raw = (env.CLIO_CODER_LMSTUDIO_CORESIDENT_CONTEXT ?? "").trim().toLowerCase();
+  if (raw.length === 0) return CO_RESIDENT_CONTEXT_CEILING;
+  if (raw === "off" || raw === "0" || raw === "false") return void 0;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) return CO_RESIDENT_CONTEXT_CEILING;
+  return parsed;
+}
+function fitLoadContextLength(input) {
+  const neighbours = [...new Set(input.resident.filter((e) => e.modelKey !== input.keepModelId).map((e) => e.modelKey))];
+  const ceiling = input.ceiling;
+  if (neighbours.length === 0 || ceiling === void 0 || input.requested <= ceiling) {
+    return { contextLength: input.requested, neighbours };
+  }
+  return { contextLength: ceiling, clampedFrom: input.requested, neighbours };
+}
+function duplicateInstances(resident, keepModelId) {
+  const instances = resident.filter((entry) => entry.modelKey === keepModelId);
+  return instances.slice(1);
+}
+
 // src/engine/apis/openai-completions.ts
+init_esm_shims();
 import {
   createAssistantMessageEventStream
 } from "@earendil-works/pi-ai";
 import { streamOpenAICompletions, streamSimpleOpenAICompletions } from "@earendil-works/pi-ai/compat";
 
 // src/engine/apis/llamacpp-residency.ts
+init_esm_shims();
+import { performance } from "node:perf_hooks";
 var LOAD_TIMEOUT_MS = 12e4;
 var POLL_INTERVAL_MS = 500;
 function isRecord3(value) {
@@ -2278,8 +2391,8 @@ async function postRouterModel(fetchImpl, url2, modelId) {
   throw new Error(`llama.cpp router rejected ${url2}: HTTP ${response.status}`);
 }
 async function waitForLoaded(input, fetchImpl, modelId) {
-  const started = Date.now();
-  while (Date.now() - started < LOAD_TIMEOUT_MS) {
+  const started = performance.now();
+  while (performance.now() - started < LOAD_TIMEOUT_MS) {
     const models = await fetchRouterModels(input, fetchImpl);
     const model = models.find((entry) => entry.id === modelId);
     if (model?.state === "loaded") return;
@@ -2330,6 +2443,7 @@ async function ensureLlamaCppResidency(input) {
       return models.filter(residentModel).map((entry) => ({ modelId: entry.id, tags: entry.tags }));
     },
     capacity: async () => (await fetchRouterProps(input, fetchImpl)).maxInstances,
+    keepModelTags: async () => snapshot.find((entry) => entry.id === input.keepModelId)?.tags,
     unload: (modelId) => postRouterModel(fetchImpl, unloadUrl(input.baseUrl), modelId),
     load: async (modelId) => {
       const state = snapshot.find((entry) => entry.id === modelId)?.state;
@@ -2344,7 +2458,11 @@ async function ensureLlamaCppResidency(input) {
   await reconcileResidency(adapter);
 }
 
+// src/engine/apis/output-budget.ts
+init_esm_shims();
+
 // src/core/context-floor.ts
+init_esm_shims();
 var CLIO_MIN_CONTEXT_WINDOW = 131072;
 var CLIO_MIN_MAX_OUTPUT_TOKENS = 32768;
 var CLIO_CONTEXT_WINDOW_WARN_BELOW = 128e3;
@@ -2382,6 +2500,7 @@ function remainingContextMaxTokens(model, context, options, limits) {
 }
 
 // src/engine/apis/sampling-overrides.ts
+init_esm_shims();
 function numberField(record, key) {
   const value = record[key];
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
@@ -2907,6 +3026,7 @@ var openAICompletionsApiProvider = {
 };
 
 // src/engine/apis/thinking-replay.ts
+init_esm_shims();
 function formatThinkingForReplay(thinking, opts) {
   if (opts.harmony) {
     return `<think>
@@ -2934,6 +3054,17 @@ function normalizeHttpBaseUrl(url2) {
   if (trimmed.startsWith("wss://")) return `https://${trimmed.slice("wss://".length)}`;
   return `http://${trimmed}`;
 }
+function residentModelInfos(entries) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (byKey.has(entry.modelKey)) continue;
+    byKey.set(entry.modelKey, {
+      modelId: entry.modelKey,
+      ...entry.sizeBytes !== void 0 ? { sizeBytes: entry.sizeBytes } : {}
+    });
+  }
+  return [...byKey.values()];
+}
 function toolToLmStudio(tool) {
   const fn = {
     name: tool.name,
@@ -3117,9 +3248,9 @@ function thinkingLevelFromHintOrModel(hints, model) {
   return model.reasoning === true ? "medium" : "off";
 }
 var VALID_ENV_KV_CACHE_QUANTS = new Set(KV_CACHE_QUANTS);
-function loadModelConfig(model) {
+function loadModelConfig(model, overrides) {
   const config = {
-    contextLength: automaticLoadContextLength(model),
+    contextLength: overrides?.contextLength ?? automaticLoadContextLength(model),
     flashAttention: true,
     gpu: { ratio: "max" },
     gpuStrictVramCap: true,
@@ -3227,9 +3358,23 @@ function runtimeMetadata2(model) {
     gateway: metadata?.gateway ?? false
   };
 }
+var CONNECT_FAILURE_RE = /\b(ENETUNREACH|EHOSTUNREACH|ECONNREFUSED|ETIMEDOUT|ENOTFOUND|ECONNRESET|EAI_AGAIN)\b/;
+function isConnectFailure(err, cause) {
+  const code = typeof err === "object" && err !== null ? err.code : void 0;
+  if (typeof code === "string" && CONNECT_FAILURE_RE.test(code)) return true;
+  return CONNECT_FAILURE_RE.test(cause);
+}
 function describeLoadFailure(baseUrl, model, loadConfig, requestedMaxTokens, err) {
   const metadata = runtimeMetadata2(model);
   const cause = err instanceof Error ? err.message : String(err);
+  if (isConnectFailure(err, cause)) {
+    return [
+      `LM Studio at ${baseUrl} did not answer for target '${metadata.targetId}' model '${model.id}'.`,
+      "The connection failed before a load was attempted, so this is reachability rather than model sizing.",
+      "Check that the server is running and that this host can reach it, then retry.",
+      `SDK error: ${cause}`
+    ].join(" ");
+  }
   const context = loadConfig?.contextLength ?? model.contextWindow;
   const output = requestedMaxTokens === false || requestedMaxTokens === void 0 ? model.maxTokens : requestedMaxTokens;
   return [
@@ -3263,7 +3408,7 @@ function toOpenAICompletionsModel(model) {
   };
   return projected;
 }
-async function pumpOpenAICompletions(stream2, model, context, options, hints, maxTokens) {
+async function pumpOpenAICompletions(stream2, model, context, options, hints, maxTokens, onGeneratedChars) {
   const simple = {
     ...options ?? {},
     maxTokens,
@@ -3278,6 +3423,9 @@ async function pumpOpenAICompletions(stream2, model, context, options, hints, ma
     context,
     simple
   )) {
+    if (onGeneratedChars && (event.type === "text_delta" || event.type === "thinking_delta")) {
+      onGeneratedChars(event.delta.length);
+    }
     stream2.push(event);
   }
   stream2.end();
@@ -3290,10 +3438,16 @@ function runStream(model, context, options, deps = defaultRunDeps, hints = {}) {
     api: model.api,
     provider: model.provider,
     model: model.id,
+    // `cacheRead` is deliberately absent. LM Studio reports no cached-token
+    // stat on either surface: the SDK's PredictionStats has no such field and
+    // its OpenAI-compat `usage` carries no `prompt_tokens_details`. Reporting 0
+    // reads as "measured no reuse" when the truth is "not measured", which is
+    // how #55 mistook a working prompt cache for a broken one. Undefined until
+    // a response actually carries the stat; consumers already treat it as
+    // optional.
     usage: {
       input: 0,
       output: 0,
-      cacheRead: 0,
       cacheWrite: 0,
       totalTokens: 0,
       cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
@@ -3318,6 +3472,7 @@ function runStream(model, context, options, deps = defaultRunDeps, hints = {}) {
   };
   if (signal && !signal.aborted) signal.addEventListener("abort", onAbort, { once: true });
   else if (aborted) abortControllerOnce();
+  let degradedWatchdog = null;
   (async () => {
     try {
       if (aborted) throw new Error("Request was aborted");
@@ -3331,11 +3486,11 @@ function runStream(model, context, options, deps = defaultRunDeps, hints = {}) {
       const loadedContextWindow = await deps.discoverLoadedContext(baseUrl, model.id, controller.signal);
       const budgetLimits = loadedContextWindow !== void 0 ? { contextWindow: loadedContextWindow } : void 0;
       const requestedMaxTokens = remainingContextMaxTokens(model, context, options, budgetLimits);
-      const loadConfig = loadModelConfig(model);
-      const requestedLoadContext = loadConfig.contextLength ?? model.contextWindow;
+      const requestedLoadContext = loadModelConfig(model).contextLength ?? model.contextWindow;
+      const targetKey = `lmstudio-native|${baseUrl}`;
       let loadedEntries = [];
       const plan = await deps.reconcile({
-        targetKey: `lmstudio-native|${baseUrl}`,
+        targetKey,
         targetId: metadata.targetId,
         runtimeId: "lmstudio-native",
         keepModelId: model.id,
@@ -3345,17 +3500,69 @@ function runStream(model, context, options, deps = defaultRunDeps, hints = {}) {
         ...model.contextWindow > 0 ? { modelMaxContext: model.contextWindow } : {},
         listResident: async () => {
           loadedEntries = await client.llm.listLoaded();
-          return loadedEntries.map((entry) => ({ modelId: entry.modelKey }));
+          return residentModelInfos(loadedEntries);
         },
         unload: async (id) => {
-          await loadedEntries.find((entry) => entry.modelKey === id)?.unload();
+          for (const entry of loadedEntries.filter((handle) => handle.modelKey === id)) await entry.unload();
         }
       });
       const observeOnly = plan.decision === "observe";
-      const residentModelLoaded = plan.keepResident;
-      const loadedUnknownContext = residentModelLoaded && loadedContextWindow === void 0;
-      const loadedWithEnoughContext = loadedContextWindow !== void 0 && loadedContextWindow >= requestedLoadContext;
-      const modelOpenConfig = observeOnly || loadedUnknownContext || loadedWithEnoughContext ? void 0 : loadConfig;
+      const residencyLock = deps.lock ?? withResidencyLock;
+      const duplicates = observeOnly ? [] : duplicateInstances(loadedEntries, model.id);
+      if (duplicates.length > 0) {
+        emitResidencyNotice({
+          kind: "co-resident",
+          level: "warning",
+          targetId: metadata.targetId,
+          runtimeId: "lmstudio-native",
+          model: model.id,
+          message: `'${metadata.targetId}' holds ${duplicates.length + 1} instances of '${model.id}'; releasing ${duplicates.length} duplicate instance(s) so one copy serves every request.`,
+          detail: { duplicateInstances: duplicates.length }
+        });
+        await residencyLock(targetKey, async () => {
+          for (const duplicate of duplicates) {
+            try {
+              await duplicate.unload();
+            } catch {
+            }
+          }
+        });
+        loadedEntries = loadedEntries.filter((entry) => !duplicates.includes(entry));
+      }
+      const fit = fitLoadContextLength({
+        requested: requestedLoadContext,
+        resident: loadedEntries,
+        keepModelId: model.id,
+        ceiling: coResidentContextCeiling()
+      });
+      if (!observeOnly && !plan.keepResident && fit.clampedFrom !== void 0) {
+        emitResidencyNotice({
+          kind: "stress",
+          level: "warning",
+          targetId: metadata.targetId,
+          runtimeId: "lmstudio-native",
+          model: model.id,
+          message: `loading '${model.id}' on '${metadata.targetId}' alongside ${fit.neighbours.join(", ")}: context clamped ${fit.clampedFrom} -> ${fit.contextLength} tokens to keep the KV cache in GPU memory. Unload the co-resident model or raise CLIO_CODER_LMSTUDIO_CORESIDENT_CONTEXT for the full window.`,
+          detail: {
+            requestedContext: fit.clampedFrom,
+            loadContext: fit.contextLength,
+            residentCount: fit.neighbours.length + 1
+          }
+        });
+      }
+      const loadConfig = loadModelConfig(model, { contextLength: fit.contextLength });
+      const modelOpenConfig = observeOnly || plan.keepResident ? void 0 : loadConfig;
+      if (plan.keepResident && loadedEntries.length > 0 && loadedContextWindow !== void 0 && loadedContextWindow < requestedLoadContext) {
+        emitResidencyNotice({
+          kind: "co-resident",
+          level: "info",
+          targetId: metadata.targetId,
+          runtimeId: "lmstudio-native",
+          model: model.id,
+          message: `'${model.id}' is resident on '${metadata.targetId}' with a ${loadedContextWindow}-token window, below the ${requestedLoadContext} Clio would load; reusing the loaded instance and budgeting against ${loadedContextWindow}. Unload it in LM Studio to have Clio reload it larger.`,
+          detail: { loadedContext: loadedContextWindow, requestedContext: requestedLoadContext }
+        });
+      }
       const modelOpenOpts = {
         signal: controller.signal,
         verbose
@@ -3378,9 +3585,8 @@ function runStream(model, context, options, deps = defaultRunDeps, hints = {}) {
         llm = await client.llm.model(model.id, modelOpenOpts);
       } catch (err) {
         if (observeOnly || plan.fallbackEvict.length === 0) failWillNotFit(err);
-        const lock = deps.lock ?? withResidencyLock;
         try {
-          llm = await lock(`lmstudio-native|${baseUrl}`, async () => {
+          llm = await residencyLock(targetKey, async () => {
             for (const entry of plan.fallbackEvict) {
               emitResidencyNotice({
                 kind: "swap",
@@ -3392,7 +3598,9 @@ function runStream(model, context, options, deps = defaultRunDeps, hints = {}) {
                 detail: { swappedOut: entry.modelId }
               });
               try {
-                await loadedEntries.find((handle) => handle.modelKey === entry.modelId)?.unload();
+                for (const handle of loadedEntries.filter((held) => held.modelKey === entry.modelId)) {
+                  await handle.unload();
+                }
               } catch {
               }
             }
@@ -3402,9 +3610,36 @@ function runStream(model, context, options, deps = defaultRunDeps, hints = {}) {
           failWillNotFit(retryErr);
         }
       }
+      const residentList = [.../* @__PURE__ */ new Set([model.id, ...loadedEntries.map((entry) => entry.modelKey)])].join(", ");
+      degradedWatchdog = startDegradedInferenceWatchdog({
+        onDegraded: (report) => {
+          emitResidencyNotice({
+            kind: "degraded",
+            level: "warning",
+            targetId: metadata.targetId,
+            runtimeId: "lmstudio-native",
+            model: model.id,
+            message: `'${model.id}' on '${metadata.targetId}' has generated ${report.tokens} tokens in ${Math.round(report.elapsedMs / 1e3)}s (${report.tokensPerSecond.toFixed(2)} tok/s); inference is running far below GPU speed, which is what a spill to CPU looks like. Resident there: ${residentList}. Unload a co-resident model or lower the context window.`,
+            detail: {
+              tokens: report.tokens,
+              elapsedMs: report.elapsedMs,
+              tokensPerSecond: Number(report.tokensPerSecond.toFixed(2)),
+              residents: residentList
+            }
+          });
+        }
+      });
       if (!sdkPredictionEnabled()) {
         predictionDone = true;
-        await pumpOpenAICompletions(stream2, model, context, options, hints, requestedMaxTokens);
+        await pumpOpenAICompletions(
+          stream2,
+          model,
+          context,
+          options,
+          hints,
+          requestedMaxTokens,
+          (chars) => degradedWatchdog?.addTokens(ceilChars(chars))
+        );
         return;
       }
       stream2.push({ type: "start", partial: output });
@@ -3585,6 +3820,7 @@ function runStream(model, context, options, deps = defaultRunDeps, hints = {}) {
         signal: controller.signal,
         onPredictionFragment: (fragment) => {
           if (!fragment.content) return;
+          degradedWatchdog?.addTokens(fragment.tokensCount ?? ceilChars(fragment.content.length));
           if (fragment.reasoningType === "reasoningStartTag" || fragment.reasoningType === "reasoningEndTag") {
             reasoningTokensAccum += fragment.tokensCount ?? 0;
             return;
@@ -3678,13 +3914,16 @@ function runStream(model, context, options, deps = defaultRunDeps, hints = {}) {
       flushNonReasoningPending();
       closeActiveText();
       closeActiveThinking();
-      output.usage.input = result.stats.promptTokensCount ?? 0;
+      const reportedCache = asRecord(result.stats).cachedTokensCount;
+      const cacheRead = typeof reportedCache === "number" && reportedCache >= 0 ? reportedCache : void 0;
+      output.usage.input = Math.max(0, (result.stats.promptTokensCount ?? 0) - (cacheRead ?? 0));
       output.usage.output = result.stats.predictedTokensCount ?? 0;
+      output.usage.cacheRead = cacheRead;
       output.usage.totalTokens = result.stats.totalTokensCount ?? output.usage.input + output.usage.output;
       if (reasoningTokensAccum > 0) {
         output.usage.reasoningTokens = reasoningTokensAccum;
       }
-      calculateEngineCost(model, output.usage);
+      output.usage.cost = calculateEngineCost(model, { ...output.usage, cacheRead: cacheRead ?? 0 });
       if (aborted) throw new Error("Request was aborted");
       if (toolExtractionError) throw toolExtractionError;
       const hadToolCall = output.content.some((block) => block.type === "toolCall");
@@ -3702,6 +3941,7 @@ function runStream(model, context, options, deps = defaultRunDeps, hints = {}) {
       stream2.push({ type: "error", reason: output.stopReason, error: output });
       stream2.end();
     } finally {
+      degradedWatchdog?.stop();
       if (signal) signal.removeEventListener("abort", onAbort);
     }
   })();
@@ -3745,7 +3985,8 @@ var lmstudioNativeApiProvider = {
 };
 
 // src/domains/providers/registry.ts
-import { readdirSync, statSync as statSync2 } from "node:fs";
+init_esm_shims();
+import { readdirSync, statSync } from "node:fs";
 import { join as join3 } from "node:path";
 import { pathToFileURL } from "node:url";
 var RUNTIME_KINDS = ["http", "sdk", "subprocess"];
@@ -3766,7 +4007,7 @@ function createRuntimeRegistry() {
   const loadFromDir = async (dir) => {
     let entries;
     try {
-      const stat = statSync2(dir);
+      const stat = statSync(dir);
       if (!stat.isDirectory()) return [];
       entries = readdirSync(dir);
     } catch {
@@ -3889,6 +4130,7 @@ function describeError(err) {
 }
 
 // src/domains/providers/credentials.ts
+init_esm_shims();
 function credentialsPresent() {
   const present = /* @__PURE__ */ new Set();
   const registry = getRuntimeRegistry();
@@ -3905,7 +4147,11 @@ function credentialsPresent() {
   return present;
 }
 
+// src/domains/providers/runtimes/builtins.ts
+init_esm_shims();
+
 // src/domains/providers/runtimes/antigravity/antigravity-code.ts
+init_esm_shims();
 var ANTIGRAVITY_AUTH_NOTICE = "Uses your existing Antigravity (`agy`) login. Clio stores no Antigravity credentials. agy runs its own agent harness as a subprocess; Clio maps autonomy levels onto its CLI flags but cannot mediate individual agy tool calls.";
 var ANTIGRAVITY_MODELS = [
   "Gemini 3.5 Flash (High)",
@@ -3962,7 +4208,11 @@ var antigravityCodeRuntime = {
 };
 var antigravity_code_default = antigravityCodeRuntime;
 
+// src/domains/providers/runtimes/claude/claude-code.ts
+init_esm_shims();
+
 // src/domains/providers/runtimes/claude/common.ts
+init_esm_shims();
 var CLAUDE_CODE_AUTH_NOTICE = "Uses your existing Claude Code login from the installed `claude` command. Clio stores no Claude Code credentials.";
 var CLAUDE_CODE_MODELS = [
   "sonnet",
@@ -4028,6 +4278,7 @@ var claudeCodeRuntime = {
 var claude_code_default = claudeCodeRuntime;
 
 // src/domains/providers/runtimes/claude/claude-sdk.ts
+init_esm_shims();
 var claudeSdkRuntime = {
   id: "claude-sdk",
   displayName: "Claude Agent SDK",
@@ -4054,8 +4305,12 @@ var claudeSdkRuntime = {
 };
 var claude_sdk_default = claudeSdkRuntime;
 
+// src/domains/providers/runtimes/cloud/alcf.ts
+init_esm_shims();
+
 // src/domains/providers/probe/http.ts
-import { performance } from "node:perf_hooks";
+init_esm_shims();
+import { performance as performance2 } from "node:perf_hooks";
 async function probeHttp(opts) {
   const { response, latencyMs, error } = await runFetch(opts);
   if (response === null) return { ok: false, error: error ?? "unknown transport error", latencyMs };
@@ -4105,12 +4360,12 @@ async function runFetch(opts) {
   };
   if (opts.headers) init.headers = opts.headers;
   if (opts.body !== void 0) init.body = opts.body;
-  const started = performance.now();
+  const started = performance2.now();
   try {
     const response = await fetch(opts.url, init);
-    return { response, latencyMs: Math.round(performance.now() - started) };
+    return { response, latencyMs: Math.round(performance2.now() - started) };
   } catch (err) {
-    const latencyMs = Math.round(performance.now() - started);
+    const latencyMs = Math.round(performance2.now() - started);
     if (timedOut) {
       return { response: null, latencyMs, error: `timeout after ${opts.timeoutMs}ms` };
     }
@@ -4134,6 +4389,7 @@ function describeError2(err) {
 }
 
 // src/domains/providers/runtimes/common/local-synth.ts
+init_esm_shims();
 function targetLifecycle(target) {
   return target.lifecycle;
 }
@@ -4227,8 +4483,12 @@ function targetRootUrl(target) {
   return target.url ? stripRedundantV1(stripTrailingSlash(target.url)) : null;
 }
 
+// src/domains/providers/runtimes/protocol/openai-compat.ts
+init_esm_shims();
+
 // src/domains/providers/probe/reasoning.ts
-import { performance as performance2 } from "node:perf_hooks";
+init_esm_shims();
+import { performance as performance3 } from "node:perf_hooks";
 var PROMPT = "What is 2+2? Think briefly, then answer.";
 function nonEmptyString(value) {
   return typeof value === "string" && value.trim().length > 0;
@@ -4267,7 +4527,7 @@ async function probeOpenAICompatReasoning(opts) {
     reasoning_effort: "low"
   });
   const url2 = `${trimTrailingSlash(opts.baseUrl)}/v1/chat/completions`;
-  const started = performance2.now();
+  const started = performance3.now();
   try {
     const response = await fetch(url2, {
       method: "POST",
@@ -4275,7 +4535,7 @@ async function probeOpenAICompatReasoning(opts) {
       body,
       signal: controller.signal
     });
-    const latencyMs = Math.round(performance2.now() - started);
+    const latencyMs = Math.round(performance3.now() - started);
     if (!response.ok) {
       return { reasoning: false, latencyMs, error: `HTTP ${response.status}: ${response.statusText}` };
     }
@@ -4284,7 +4544,7 @@ async function probeOpenAICompatReasoning(opts) {
     if (field) return { reasoning: true, field, latencyMs };
     return { reasoning: false, latencyMs };
   } catch (err) {
-    const latencyMs = Math.round(performance2.now() - started);
+    const latencyMs = Math.round(performance3.now() - started);
     if (timedOut) return { reasoning: false, latencyMs, error: `timeout after ${opts.timeoutMs}ms` };
     if (opts.signal?.aborted) return { reasoning: false, latencyMs, error: "aborted by caller" };
     return { reasoning: false, latencyMs, error: err instanceof Error ? err.message : String(err) };
@@ -4295,6 +4555,7 @@ async function probeOpenAICompatReasoning(opts) {
 }
 
 // src/domains/providers/runtimes/common/probe-helpers.ts
+init_esm_shims();
 async function probeUrl(url2, ctx, method = "GET") {
   const base = { url: url2, timeoutMs: ctx.httpTimeoutMs, method };
   return ctx.signal ? probeHttp({ ...base, signal: ctx.signal }) : probeHttp(base);
@@ -4335,8 +4596,11 @@ async function probeOpenAIModelCatalog(base, ctx, modelsPath = "/v1/models") {
       ...capabilitiesFromOpenAIModelEntry(row)
     };
     if (Object.keys(caps).length > 0) modelCapabilities[row.id] = caps;
-    const state = modelStateFromOpenAIModelEntry(row) ?? (detailRow ? modelStateFromOpenAIModelEntry(detailRow) : void 0);
-    if (state) modelStates[row.id] = state;
+    const loadedContext = loadedContextFromEntry(row) ?? (detailRow ? loadedContextFromEntry(detailRow) : void 0);
+    const state = modelStateFromOpenAIModelEntry(row) ?? (detailRow ? modelStateFromOpenAIModelEntry(detailRow) : void 0) ?? // A reported loaded context is itself the residency answer: nothing
+    // serves a window for a model it has not loaded.
+    (loadedContext !== void 0 ? { state: "loaded" } : void 0);
+    if (state) modelStates[row.id] = loadedContext === void 0 ? state : { ...state, contextLength: loadedContext };
   }
   return { models, modelCapabilities, modelStates };
 }
@@ -4413,6 +4677,10 @@ function modelStateFromOpenAIModelEntry(row) {
   if (loaded === false) return { state: "unloaded" };
   return void 0;
 }
+function loadedContextFromEntry(row) {
+  const reported = firstPositiveNumber(row, ["loaded_context_length", "loadedContextLength"]);
+  return reported === void 0 ? void 0 : Math.floor(reported);
+}
 function statusArgsFromEntry(row) {
   const status = nestedRecord(row, "status");
   return argsFromStatus(status);
@@ -4835,7 +5103,11 @@ var alcfRuntime = {
 };
 var alcf_default = alcfRuntime;
 
+// src/domains/providers/runtimes/cloud/anthropic.ts
+init_esm_shims();
+
 // src/domains/providers/runtimes/protocol/anthropic-messages.ts
+init_esm_shims();
 function synthesizeAnthropicMessagesModel(input) {
   return synthesizeCatalogBackedModel({
     target: input.target,
@@ -4887,6 +5159,7 @@ var anthropicRuntime = {
 var anthropic_default = anthropicRuntime;
 
 // src/domains/providers/runtimes/cloud/anthropic-max.ts
+init_esm_shims();
 var defaultCapabilities4 = {
   chat: true,
   tools: true,
@@ -4929,7 +5202,11 @@ var anthropicMaxRuntime = {
 };
 var anthropic_max_default = anthropicMaxRuntime;
 
+// src/domains/providers/runtimes/cloud/bedrock.ts
+init_esm_shims();
+
 // src/domains/providers/runtimes/protocol/bedrock.ts
+init_esm_shims();
 function synthesizeBedrockModel(input) {
   return synthesizeCatalogBackedModel({
     target: input.target,
@@ -4973,6 +5250,7 @@ var bedrockRuntime = {
 var bedrock_default = bedrockRuntime;
 
 // src/domains/providers/runtimes/cloud/deepseek.ts
+init_esm_shims();
 var defaultCapabilities6 = {
   chat: true,
   tools: true,
@@ -5014,7 +5292,11 @@ var deepseekRuntime = {
 };
 var deepseek_default = deepseekRuntime;
 
+// src/domains/providers/runtimes/cloud/google.ts
+init_esm_shims();
+
 // src/domains/providers/runtimes/protocol/google.ts
+init_esm_shims();
 function synthesizeGoogleModel(input) {
   return synthesizeCatalogBackedModel({
     target: input.target,
@@ -5064,6 +5346,7 @@ var googleRuntime = {
 var google_default = googleRuntime;
 
 // src/domains/providers/runtimes/cloud/groq.ts
+init_esm_shims();
 var defaultCapabilities8 = {
   chat: true,
   tools: true,
@@ -5102,6 +5385,7 @@ var groqRuntime = {
 var groq_default = groqRuntime;
 
 // src/domains/providers/runtimes/cloud/mistral.ts
+init_esm_shims();
 var defaultCapabilities9 = {
   chat: true,
   tools: true,
@@ -5140,6 +5424,7 @@ var mistralRuntime = {
 var mistral_default = mistralRuntime;
 
 // src/domains/providers/runtimes/cloud/openai.ts
+init_esm_shims();
 var defaultCapabilities10 = {
   chat: true,
   tools: true,
@@ -5178,6 +5463,7 @@ var openaiRuntime = {
 var openai_default = openaiRuntime;
 
 // src/domains/providers/runtimes/cloud/openai-codex.ts
+init_esm_shims();
 var defaultCapabilities11 = {
   chat: true,
   tools: true,
@@ -5219,6 +5505,7 @@ var openaiCodexRuntime = {
 var openai_codex_default = openaiCodexRuntime;
 
 // src/domains/providers/runtimes/cloud/openrouter.ts
+init_esm_shims();
 var OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1";
 var OPENROUTER_HEADERS = {
   "HTTP-Referer": "https://github.com/iowarp/clio-coder",
@@ -5306,7 +5593,11 @@ var openrouterRuntime = {
 };
 var openrouter_default = openrouterRuntime;
 
+// src/domains/providers/runtimes/local-native/lemonade-anthropic.ts
+init_esm_shims();
+
 // src/domains/providers/runtimes/protocol/anthropic-compat.ts
+init_esm_shims();
 function synthesizeAnthropicCompatModel(input) {
   return synthLocalModel({
     target: input.target,
@@ -5398,6 +5689,7 @@ var lemonade_anthropic_default = makeAnthropicCompatRuntime({
 });
 
 // src/domains/providers/runtimes/local-native/lemonade-openai.ts
+init_esm_shims();
 var defaultCapabilities15 = {
   chat: true,
   tools: true,
@@ -5421,6 +5713,7 @@ var lemonade_openai_default = makeOpenAICompatRuntime({
 });
 
 // src/domains/providers/runtimes/local-native/llamacpp.ts
+init_esm_shims();
 var defaultCapabilities16 = {
   chat: true,
   tools: true,
@@ -5494,6 +5787,7 @@ var llamacppRuntime = {
 var llamacpp_default = llamacppRuntime;
 
 // src/domains/providers/runtimes/local-native/llamacpp-anthropic.ts
+init_esm_shims();
 var defaultCapabilities17 = {
   chat: true,
   tools: true,
@@ -5563,6 +5857,7 @@ var llamacppAnthropicRuntime = {
 var llamacpp_anthropic_default = llamacppAnthropicRuntime;
 
 // src/domains/providers/runtimes/local-native/llamacpp-completion.ts
+init_esm_shims();
 var defaultCapabilities18 = {
   chat: false,
   tools: false,
@@ -5732,6 +6027,7 @@ var llamacppCompletionRuntime = {
 var llamacpp_completion_default = llamacppCompletionRuntime;
 
 // src/domains/providers/runtimes/local-native/llamacpp-embed.ts
+init_esm_shims();
 var defaultCapabilities19 = {
   chat: false,
   tools: false,
@@ -5880,6 +6176,7 @@ var llamacppEmbedRuntime = {
 var llamacpp_embed_default = llamacppEmbedRuntime;
 
 // src/domains/providers/runtimes/local-native/llamacpp-rerank.ts
+init_esm_shims();
 var defaultCapabilities20 = {
   chat: false,
   tools: false,
@@ -5978,6 +6275,8 @@ var llamacppRerankRuntime = {
 var llamacpp_rerank_default = llamacppRerankRuntime;
 
 // src/domains/providers/runtimes/local-native/lmstudio-native.ts
+init_esm_shims();
+import { performance as performance4 } from "node:perf_hooks";
 import { LMStudioClient as LMStudioClient2 } from "@lmstudio/sdk";
 var defaultCapabilities21 = {
   ...EMPTY_CAPABILITIES,
@@ -6125,6 +6424,31 @@ function summaryFromV0(entry) {
   }
   return summary;
 }
+function foldDuplicateSummaries(entries) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const previous = byId.get(entry.id);
+    byId.set(entry.id, previous ? mergeSummaries(previous, entry) : entry);
+  }
+  return [...byId.values()];
+}
+function mergeSummaries(first, second) {
+  const [primary, secondary] = second.loaded === true && first.loaded !== true ? [second, first] : [first, second];
+  const merged = { id: primary.id };
+  const loaded = primary.loaded ?? secondary.loaded;
+  if (loaded !== void 0) merged.loaded = loaded;
+  const loadedContextLength = primary.loadedContextLength ?? secondary.loadedContextLength;
+  if (loadedContextLength !== void 0) merged.loadedContextLength = loadedContextLength;
+  const maxContextLength = primary.maxContextLength ?? secondary.maxContextLength;
+  if (maxContextLength !== void 0) merged.maxContextLength = maxContextLength;
+  const vision = primary.vision ?? secondary.vision;
+  if (vision !== void 0) merged.vision = vision;
+  const tools = primary.tools ?? secondary.tools;
+  if (tools !== void 0) merged.tools = tools;
+  const reasoning = primary.reasoning ?? secondary.reasoning;
+  if (reasoning !== void 0) merged.reasoning = reasoning;
+  return merged;
+}
 function selectCapabilityEntry(entries, target) {
   const configured = target.defaultModel?.trim();
   if (configured) {
@@ -6155,7 +6479,9 @@ function modelStatesFromSummaries(entries) {
   const out = {};
   for (const entry of entries) {
     if (entry.loaded === void 0) continue;
-    out[entry.id] = { state: entry.loaded ? "loaded" : "unloaded" };
+    const status = { state: entry.loaded ? "loaded" : "unloaded" };
+    if (entry.loaded && entry.loadedContextLength !== void 0) status.contextLength = entry.loadedContextLength;
+    out[entry.id] = status;
   }
   return Object.keys(out).length > 0 ? out : void 0;
 }
@@ -6184,8 +6510,11 @@ async function probeApiV1Models(target, ctx, headers) {
   if (headers) opts.headers = headers;
   const result = await (ctx.signal ? probeJson({ ...opts, signal: ctx.signal }) : probeJson(opts));
   if (!result.ok) return result;
-  const entries = v1ModelEntries(result.data).map(summaryFromV1).filter((entry) => entry !== null);
-  return probeResultFromSummaries(entries, target, result.latencyMs);
+  return probeResultFromV1Models(result.data, target, result.latencyMs);
+}
+function probeResultFromV1Models(data, target, latencyMs) {
+  const entries = v1ModelEntries(data).map(summaryFromV1).filter((entry) => entry !== null);
+  return probeResultFromSummaries(entries, target, latencyMs);
 }
 async function probeApiV0Models(target, ctx, headers) {
   const opts = {
@@ -6198,7 +6527,8 @@ async function probeApiV0Models(target, ctx, headers) {
   const entries = v0ModelEntries(result.data).map(summaryFromV0).filter((entry) => entry !== null);
   return probeResultFromSummaries(entries, target, result.latencyMs);
 }
-function probeResultFromSummaries(entries, target, latencyMs) {
+function probeResultFromSummaries(rows, target, latencyMs) {
+  const entries = foldDuplicateSummaries(rows);
   const models = entries.map((entry) => entry.id);
   const capabilityEntry = selectCapabilityEntry(entries, target);
   const discoveredCapabilities = capabilitiesFromModelEntry(capabilityEntry);
@@ -6226,13 +6556,13 @@ var lmstudioNativeRuntime = {
     const built = buildClient(target, ctx);
     if ("error" in built) return { ok: false, error: built.error };
     const client = built;
-    const started = Date.now();
+    const started = performance4.now();
     try {
       const [version, apiModels] = await Promise.all([
         withTimeout(client.system.getLMStudioVersion(), ctx.httpTimeoutMs, ctx.signal),
         probeApiModels(target, ctx)
       ]);
-      const latencyMs = Date.now() - started;
+      const latencyMs = Math.round(performance4.now() - started);
       const result = { ok: true, latencyMs, serverVersion: version.version };
       if (apiModels.ok) {
         if (apiModels.models) result.models = apiModels.models;
@@ -6245,7 +6575,7 @@ var lmstudioNativeRuntime = {
     } catch (err) {
       return {
         ok: false,
-        latencyMs: Date.now() - started,
+        latencyMs: Math.round(performance4.now() - started),
         error: err instanceof Error ? err.message : String(err)
       };
     }
@@ -6311,6 +6641,7 @@ var lmstudioNativeRuntime = {
 var lmstudio_native_default = lmstudioNativeRuntime;
 
 // src/domains/providers/runtimes/local-native/ollama-native.ts
+init_esm_shims();
 var defaultCapabilities22 = {
   chat: true,
   tools: true,
@@ -6392,6 +6723,7 @@ var ollamaNativeRuntime = {
 var ollama_native_default = ollamaNativeRuntime;
 
 // src/domains/providers/runtimes/local-native/sglang.ts
+init_esm_shims();
 var defaultCapabilities23 = {
   chat: true,
   tools: true,
@@ -6415,6 +6747,7 @@ var sglang_default = makeOpenAICompatRuntime({
 });
 
 // src/domains/providers/runtimes/local-native/vllm.ts
+init_esm_shims();
 var defaultCapabilities24 = {
   chat: true,
   tools: true,
@@ -6476,6 +6809,7 @@ function registerBuiltinRuntimes(registry) {
 }
 
 // src/domains/providers/eligibility.ts
+init_esm_shims();
 function isTargetEligibleRuntime(runtime) {
   return runtime.kind === "http" || runtime.id === "claude-sdk" || runtime.id === "claude-code" || runtime.id === "antigravity-code";
 }
@@ -6487,6 +6821,7 @@ function isDispatchEligibleRuntime(runtime) {
 }
 
 // src/domains/providers/support.ts
+init_esm_shims();
 var SUMMARY_BY_RUNTIME_ID = {
   alcf: "ALCF inference gateway (Sophia/Metis) via Globus",
   anthropic: "Anthropic API",
@@ -6617,6 +6952,7 @@ function resolveProviderReference(input, settings, getRuntime) {
 }
 
 // src/domains/providers/model-discovery.ts
+init_esm_shims();
 function uniqueModels(ids) {
   const seen = /* @__PURE__ */ new Set();
   const out = [];
@@ -6628,8 +6964,22 @@ function uniqueModels(ids) {
   }
   return out;
 }
-function modelLoadStateLabel(status, modelId) {
-  return status.discoveredModelStates?.[modelId]?.state ?? "-";
+function loadedContextWindowForModel(status, modelId) {
+  const reported = status?.discoveredModelStates?.[modelId]?.contextLength;
+  return typeof reported === "number" && Number.isFinite(reported) && reported > 0 ? reported : null;
+}
+function modelResidencyForStatus(status, modelId) {
+  if (loadedContextWindowForModel(status, modelId) !== null) return "resident";
+  switch (status?.discoveredModelStates?.[modelId]?.state) {
+    case "loaded":
+      return "resident";
+    case "loading":
+      return "loading";
+    case "unloaded":
+      return "absent";
+    default:
+      return "unknown";
+  }
 }
 function hasLiveModelCatalog(status) {
   if (status.discoveredModelsSource === "probe" || status.discoveredModelsSource === "cache") return true;
@@ -6691,10 +7041,18 @@ function canonicalizeWireModelId(status, requested) {
   return matches.length === 1 ? matches[0] ?? requested : requested;
 }
 
+// src/domains/providers/index.ts
+init_esm_shims();
+
+// src/domains/providers/extension.ts
+init_esm_shims();
+
 // src/engine/apis/index.ts
+init_esm_shims();
 import { registerApiProvider } from "@earendil-works/pi-ai/compat";
 
 // src/engine/apis/ollama-native.ts
+init_esm_shims();
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { createAssistantMessageEventStream as createAssistantMessageEventStream3 } from "@earendil-works/pi-ai";
 import {
@@ -7072,14 +7430,15 @@ function registerClioApiProviders() {
 }
 
 // src/domains/providers/knowledge-base-path.ts
-import { existsSync as existsSync2, statSync as statSync3 } from "node:fs";
+init_esm_shims();
+import { existsSync as existsSync2, statSync as statSync2 } from "node:fs";
 import { delimiter, dirname as dirname2, join as join4 } from "node:path";
 import { fileURLToPath } from "node:url";
 var MODEL_CATALOG_OVERLAY_DIR = "model-catalog.d";
 var MODEL_CATALOG_DIRS_ENV = "CLIO_CODER_MODEL_CATALOG_DIRS";
 function isDirectory(path) {
   try {
-    return statSync3(path).isDirectory();
+    return statSync2(path).isDirectory();
   } catch {
     return false;
   }
@@ -7148,6 +7507,7 @@ function resolveProviderKnowledgeBaseRoots(importMetaUrl, options = {}) {
 }
 
 // src/domains/providers/plugins.ts
+init_esm_shims();
 import { join as join5 } from "node:path";
 function extractPluginPackages(settings) {
   if (!settings || typeof settings !== "object") return [];
@@ -7182,9 +7542,10 @@ async function loadPluginRuntimes(registry, settings) {
 }
 
 // src/domains/providers/types/knowledge-base.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync2, statSync as statSync4 } from "node:fs";
+init_esm_shims();
+var import_yaml = __toESM(require_dist(), 1);
+import { readdirSync as readdirSync2, readFileSync as readFileSync2, statSync as statSync3 } from "node:fs";
 import { join as join6 } from "node:path";
-import { parse as parseYaml } from "yaml";
 var FileKnowledgeBase = class {
   roots;
   loaded = [];
@@ -7199,7 +7560,7 @@ var FileKnowledgeBase = class {
       for (const file of files) {
         const name = root.label ? `${root.label}:${file.name}` : file.name;
         const raw = readFileSync2(file.path, "utf8");
-        const parsed = parseYaml(raw);
+        const parsed = (0, import_yaml.parse)(raw);
         if (!Array.isArray(parsed)) {
           throw new Error(`knowledge base file ${name} must be a YAML list of KnowledgeBaseEntry`);
         }
@@ -7238,7 +7599,7 @@ function normalizeRoots(root) {
     if (dir.length === 0 || seen.has(dir)) continue;
     let isRootDir = false;
     try {
-      isRootDir = statSync4(dir).isDirectory();
+      isRootDir = statSync3(dir).isDirectory();
     } catch (err) {
       if (raw.optional === true) continue;
       throw err;
@@ -7705,12 +8066,14 @@ function createProvidersBundle(context) {
 }
 
 // src/domains/providers/manifest.ts
+init_esm_shims();
 var ProvidersManifest = {
   name: "providers",
   dependsOn: ["config"]
 };
 
 // src/domains/providers/resolver.ts
+init_esm_shims();
 var GLOB_CHARS = /[*?[]/;
 function isThinkingLevel(token) {
   return VALID_THINKING_LEVELS.includes(token);
@@ -7809,6 +8172,7 @@ function resolveModelReference(rawPattern, providers) {
 }
 
 // src/domains/providers/runtime-resolution.ts
+init_esm_shims();
 function diagnostic(severity, code, message) {
   return { severity, code, message };
 }
@@ -7993,12 +8357,14 @@ function resolveRuntimeTarget(providers, input) {
   const capabilityResolution = modelCapabilitiesFor(providers, status, wireModelId);
   const capabilities = { ...capabilityResolution.capabilities };
   const probedContextWindow = probeCapabilitiesForModel(status, wireModelId)?.contextWindow ?? null;
+  const loadedContextWindow = loadedContextWindowForModel(status, wireModelId);
   const contextWindowDetails = resolveContextWindowDetails(
     target,
     runtime,
     wireModelId,
     providers.knowledgeBase,
-    probedContextWindow
+    probedContextWindow,
+    loadedContextWindow
   );
   capabilities.contextWindow = contextWindowDetails.effectiveContextWindow;
   if (contextWindowDetails.warning) {
@@ -8075,6 +8441,10 @@ function refineRuntimeTargetWithModelHints(target, model, knowledgeBase) {
     target.wireModelId,
     knowledgeBase ?? null,
     target.contextWindowDetails.probedContextWindow,
+    // A synthesized model hint carries the model's declared window, never the
+    // one the backend has open. Re-resolving without the loaded number would
+    // hand the planner the declared window back on the first refinement.
+    target.contextWindowDetails.loadedContextWindow,
     modelHintContextWindow
   );
   capabilities.contextWindow = contextWindowDetails.effectiveContextWindow;
@@ -8139,7 +8509,7 @@ var FALLBACK_CONTEXT_WINDOW = CLIO_MIN_CONTEXT_WINDOW;
 function positiveWindow2(value) {
   return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
 }
-function resolveContextWindowDetails(target, runtime, wireModelId, knowledgeBase, probedContextWindow, modelHintContextWindow) {
+function resolveContextWindowDetails(target, runtime, wireModelId, knowledgeBase, probedContextWindow, loadedContextWindow = null, modelHintContextWindow) {
   const catalogModel = getCatalogModelForRuntime(runtime.id, wireModelId);
   const kbHit = knowledgeBase?.lookup(wireModelId) ?? null;
   let modelDeclared;
@@ -8160,13 +8530,17 @@ function resolveContextWindowDetails(target, runtime, wireModelId, knowledgeBase
   const runtimeDefault = positiveWindow2(runtime.defaultCapabilities?.contextWindow);
   const declaredContextWindow = modelDeclared ?? runtimeDefault ?? FALLBACK_CONTEXT_WINDOW;
   const desired = Math.max(declaredContextWindow, DESIRED_CONTEXT_WINDOW);
+  const loadedWindow = positiveWindow2(loadedContextWindow);
   const probeWindow = positiveWindow2(probedContextWindow);
   const overrideWindow = positiveWindow2(target.capabilities?.contextWindow);
   let effective;
   let source;
-  if (probeWindow !== void 0) {
+  if (loadedWindow !== void 0) {
+    effective = loadedWindow;
+    source = "loaded";
+  } else if (probeWindow !== void 0) {
     effective = probeWindow;
-    source = runtime.id === "lmstudio-native" ? "loaded" : "probe";
+    source = "probe";
   } else if (overrideWindow !== void 0) {
     effective = overrideWindow;
     source = "target-override";
@@ -8193,7 +8567,7 @@ function resolveContextWindowDetails(target, runtime, wireModelId, knowledgeBase
   return {
     declaredContextWindow,
     probedContextWindow,
-    loadedContextWindow: runtime.id === "lmstudio-native" ? probedContextWindow : null,
+    loadedContextWindow: loadedWindow ?? null,
     desiredContextWindow: desired,
     effectiveContextWindow: effective,
     contextWindowSource: source,
@@ -8203,6 +8577,7 @@ function resolveContextWindowDetails(target, runtime, wireModelId, knowledgeBase
 }
 
 // src/domains/providers/types/cost-provenance.ts
+init_esm_shims();
 function normalizeCostProvenance(value) {
   return value ?? "unknown";
 }
@@ -8274,7 +8649,7 @@ export {
   listProviderSupportEntries,
   configuredTargetsForRuntime,
   resolveProviderReference,
-  modelLoadStateLabel,
+  modelResidencyForStatus,
   modelCandidatesForStatus,
   modelIdsForStatus,
   canonicalizeWireModelId,
@@ -8287,4 +8662,4 @@ export {
   normalizeCostProvenance,
   ProvidersDomainModule
 };
-//# sourceMappingURL=chunk-TKHQ4DGZ.js.map
+//# sourceMappingURL=chunk-H6F6BYOH.js.map