@iowarp/clio-coder 0.3.8 → 0.4.0

package/dist/{chunk-7RFXX52T.js → chunk-DQITNCXG.js}

@@ -5,24 +5,24 @@ import {
 } from "./chunk-CFGTUFWB.js";
 import {
   credentialsPresent
-} from "./chunk-LU7P4LHA.js";
+} from "./chunk-P3FOHJT4.js";
 import {
   ceilChars,
   estimateAgentMessageTokens,
   toolSchemaChars
-} from "./chunk-RWSI4YD7.js";
-import {
-  readSettings
-} from "./chunk-IJ7RPIYJ.js";
-import {
-  sleep
-} from "./chunk-FQ4SKYE4.js";
+} from "./chunk-UM7N4G5A.js";
 import {
   getSharedBus
 } from "./chunk-ZGVHUX3M.js";
 import {
   BusChannels
-} from "./chunk-TT36MB5S.js";
+} from "./chunk-HLW2MRKE.js";
+import {
+  readSettings
+} from "./chunk-VFA6GDY5.js";
+import {
+  sleep
+} from "./chunk-FQ4SKYE4.js";
 import {
   CLIO_CONTEXT_WINDOW_WARN_BELOW,
   CLIO_MIN_CONTEXT_WINDOW,
@@ -34,17 +34,17 @@ import {
   registerBuiltinRuntimes,
   requestLmStudioJson,
   resolveLmStudioInstance
-} from "./chunk-NMPKI6XL.js";
+} from "./chunk-6DB53AJS.js";
 import {
   listKnownModelsForRuntime
-} from "./chunk-IIZWH4XA.js";
+} from "./chunk-HI63TFOG.js";
 import {
   authNotRequiredStatus,
   openAuthStorage,
   registerClioOAuthProviders,
   resolveAuthTarget,
   targetRequiresAuth
-} from "./chunk-EQ63NRB7.js";
+} from "./chunk-BBVYXMFO.js";
 import {
   withStateFileLock
 } from "./chunk-IKCO5N3L.js";
@@ -52,10 +52,16 @@ import {
   require_dist
 } from "./chunk-APJ265NV.js";
 import {
+  clioCacheDir,
   clioConfigDir,
+  clioStateDir,
   clioStatePath,
-  resolveClioDirs
-} from "./chunk-BNAZZHFG.js";
+  resolveClioDirs,
+  stateRootRemoved
+} from "./chunk-BYP5D4HI.js";
+import {
+  safeResourceWrite
+} from "./chunk-WEPFGWHJ.js";
 import {
   getRuntimeRegistry
 } from "./chunk-NUGM5KR6.js";
@@ -65,27 +71,241 @@ import {
   getCatalogModelForRuntime,
   mergeCapabilities,
   resolveCostProvenance
-} from "./chunk-PT7HYKEM.js";
+} from "./chunk-VO2LKSTM.js";
 import {
   activateExternalPluginApiBridge,
   calculateEngineCost,
   ensurePiAiRegistered,
   registerEngineApiProvider
-} from "./chunk-FCSXB6T2.js";
+} from "./chunk-UOSL25KY.js";
 import {
   __toESM,
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
 
+// src/domains/providers/endpoint-capacity.ts
+init_esm_shims();
+
+// src/core/endpoint-key.ts
+init_esm_shims();
+function canonicalEndpointUrl(raw) {
+  if (!raw?.trim()) return null;
+  try {
+    const url = new URL(raw.trim().replace(/^ws:/u, "http:").replace(/^wss:/u, "https:"));
+    url.protocol = url.protocol.toLowerCase();
+    if (url.protocol !== "http:" && url.protocol !== "https:") return null;
+    url.hostname = url.hostname.toLowerCase();
+    url.username = "";
+    url.password = "";
+    url.hash = "";
+    url.search = "";
+    let path = url.pathname.replace(/\/{2,}/gu, "/").replace(/\/$/u, "");
+    if (path.endsWith("/v1")) path = path.slice(0, -3);
+    url.pathname = path || "/";
+    return url.toString().replace(/\/$/u, "");
+  } catch {
+    return null;
+  }
+}
+
+// src/domains/providers/endpoint-slots-store.ts
+init_esm_shims();
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+var DEFAULT_ENDPOINT_SLOTS_TTL_MS = 24 * 60 * 60 * 1e3;
+var ENDPOINT_SLOTS_TTL_ENV_VAR = "CLIO_CODER_ENDPOINT_SLOTS_TTL_MS";
+var MAX_ENDPOINT_SLOT_RECORDS = 64;
+function endpointSlotsPath() {
+  return join(clioStateDir(), "endpoint-slots.json");
+}
+function endpointSlotsTtlMs(env = process.env) {
+  const raw = env[ENDPOINT_SLOTS_TTL_ENV_VAR]?.trim();
+  if (raw !== void 0 && /^[1-9]\d*$/.test(raw)) {
+    const parsed = Number(raw);
+    if (Number.isSafeInteger(parsed)) return parsed;
+  }
+  return DEFAULT_ENDPOINT_SLOTS_TTL_MS;
+}
+function validRecord(key, value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const record = value;
+  return record.endpointKey === key && typeof record.runtimeId === "string" && record.runtimeId.length > 0 && typeof record.slots === "number" && Number.isInteger(record.slots) && record.slots > 0 && typeof record.observedAt === "string" && Number.isFinite(Date.parse(record.observedAt));
+}
+function readRecords() {
+  const path = endpointSlotsPath();
+  if (!existsSync(path)) return [];
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (parsed?.version !== 1 || typeof parsed.endpoints !== "object" || parsed.endpoints === null) return [];
+    return Object.entries(parsed.endpoints).filter(([key, value]) => validRecord(key, value)).map(([, value]) => ({ ...value }));
+  } catch {
+    return [];
+  }
+}
+function fresh(record, nowMs, ttlMs) {
+  const observedMs = Date.parse(record.observedAt);
+  return observedMs <= nowMs && nowMs - observedMs < ttlMs;
+}
+function readDiscoveredEndpointSlots(options) {
+  const nowMs = options?.nowMs ?? Date.now();
+  const ttlMs = options?.ttlMs ?? endpointSlotsTtlMs();
+  const out = {};
+  for (const record of readRecords()) {
+    if (!fresh(record, nowMs, ttlMs)) continue;
+    out[record.endpointKey] = record;
+  }
+  return Object.freeze(out);
+}
+function writeRecords(records) {
+  const kept = [...records].sort((a, b) => Date.parse(b.observedAt) - Date.parse(a.observedAt)).slice(0, MAX_ENDPOINT_SLOT_RECORDS);
+  const file = {
+    version: 1,
+    endpoints: Object.fromEntries(kept.map((record) => [record.endpointKey, { ...record }]))
+  };
+  safeResourceWrite(endpointSlotsPath(), `${JSON.stringify(file, null, 2)}
+`, { encoding: "utf8" });
+}
+async function recordDiscoveredEndpointSlots(entry, options) {
+  if (!Number.isInteger(entry.slots) || entry.slots <= 0) return;
+  if (entry.endpointKey.length === 0 || entry.runtimeId.length === 0) return;
+  if (stateRootRemoved()) return;
+  const nowMs = options?.nowMs ?? Date.now();
+  const ttlMs = options?.ttlMs ?? endpointSlotsTtlMs();
+  try {
+    await withStateFileLock(endpointSlotsPath(), () => {
+      if (stateRootRemoved()) return;
+      const kept = readRecords().filter(
+        (record) => record.endpointKey !== entry.endpointKey && fresh(record, nowMs, ttlMs)
+      );
+      kept.push({
+        endpointKey: entry.endpointKey,
+        runtimeId: entry.runtimeId,
+        slots: entry.slots,
+        observedAt: new Date(nowMs).toISOString()
+      });
+      writeRecords(kept);
+    });
+  } catch (error) {
+    options?.onError?.(error);
+  }
+}
+
+// src/domains/providers/endpoint-capacity.ts
+var UNBOUNDED_LOCAL_NATIVE_RUNTIMES = /* @__PURE__ */ new Set(["vllm", "sglang"]);
+function canonicalEndpointKey(value) {
+  return canonicalEndpointUrl(typeof value === "string" ? value : value.url);
+}
+function endpointLabel(endpointKey) {
+  try {
+    const url = new URL(endpointKey);
+    return `${url.host}${url.pathname === "/" ? "" : url.pathname}`;
+  } catch {
+    return endpointKey;
+  }
+}
+function positiveInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : void 0;
+}
+function endpointCapacityFor(input, priors = readDiscoveredEndpointSlots()) {
+  const key = canonicalEndpointKey(input.target);
+  if (key === null) return null;
+  const label = endpointLabel(key);
+  const override = positiveInteger(input.target.maxConcurrentRequests);
+  if (override !== void 0) return { key, label, limit: override, source: "override" };
+  const discovered = positiveInteger(input.discoveredSlots);
+  if (discovered !== void 0) return { key, label, limit: discovered, source: "discovered" };
+  const prior = priors[key];
+  if (prior !== void 0 && prior.runtimeId === (input.runtime?.id ?? input.target.runtime)) {
+    return { key, label, limit: prior.slots, source: "discovered-prior" };
+  }
+  if (input.runtime?.tier !== "local-native" || UNBOUNDED_LOCAL_NATIVE_RUNTIMES.has(input.runtime.id)) return null;
+  return { key, label, limit: 1, source: "local-native-default" };
+}
+function endpointCapacityForStatus(status, priors = readDiscoveredEndpointSlots()) {
+  return endpointCapacityFor(
+    {
+      target: status.target,
+      runtime: status.runtime ?? null,
+      discoveredSlots: status.probeCapabilities?.parallelSlots
+    },
+    priors
+  );
+}
+function sourceRank(source) {
+  switch (source) {
+    case "override":
+      return 3;
+    case "discovered":
+      return 2;
+    case "discovered-prior":
+      return 1;
+    default:
+      return 0;
+  }
+}
+function foldCapacity(capacities, candidate) {
+  if (candidate === null) return;
+  const current = capacities[candidate.key];
+  if (current === void 0 || sourceRank(candidate.source) > sourceRank(current.source) || sourceRank(candidate.source) === sourceRank(current.source) && candidate.limit < current.limit) {
+    capacities[candidate.key] = candidate;
+  }
+}
+function endpointCapacitiesForStatuses(statuses) {
+  const priors = readDiscoveredEndpointSlots();
+  const capacities = {};
+  for (const status of statuses) foldCapacity(capacities, endpointCapacityForStatus(status, priors));
+  return capacities;
+}
+function resolveEndpointCapacities(input) {
+  const priors = readDiscoveredEndpointSlots();
+  const capacities = {};
+  const covered = /* @__PURE__ */ new Set();
+  for (const status of input.statuses) {
+    covered.add(status.target.id);
+    foldCapacity(capacities, endpointCapacityForStatus(status, priors));
+  }
+  for (const target of input.targets ?? []) {
+    if (covered.has(target.id)) continue;
+    foldCapacity(
+      capacities,
+      endpointCapacityFor({ target, runtime: input.runtimeFor?.(target.runtime) ?? null }, priors)
+    );
+  }
+  return capacities;
+}
+function recordEndpointSlotsFromStatus(status, options) {
+  const key = canonicalEndpointKey(status.target);
+  const slots = positiveInteger(status.probeCapabilities?.parallelSlots);
+  const runtimeId = status.runtime?.id ?? status.target.runtime;
+  if (key === null || slots === void 0 || runtimeId === void 0) return Promise.resolve();
+  return recordDiscoveredEndpointSlots({ endpointKey: key, runtimeId, slots }, options);
+}
+var foregroundStreams = /* @__PURE__ */ new Map();
+function registerForegroundStream(endpointKey) {
+  foregroundStreams.set(endpointKey, (foregroundStreams.get(endpointKey) ?? 0) + 1);
+  let held = true;
+  return () => {
+    if (!held) return;
+    held = false;
+    const next = (foregroundStreams.get(endpointKey) ?? 1) - 1;
+    if (next <= 0) foregroundStreams.delete(endpointKey);
+    else foregroundStreams.set(endpointKey, next);
+  };
+}
+function foregroundStreamUsage() {
+  return Object.fromEntries(foregroundStreams);
+}
+
 // src/engine/apis/residency.ts
 init_esm_shims();
 
 // src/engine/apis/residency-lock.ts
 init_esm_shims();
-import { join } from "node:path";
+import { join as join2 } from "node:path";
 var LOCK_WAIT_MS = 12e4;
 function lockTargetFor(targetKey) {
-  return join(clioStatePath(), "residency-locks", targetKey.replace(/[^a-zA-Z0-9._-]+/g, "_"));
+  const key = canonicalEndpointKey(targetKey) ?? targetKey;
+  return join2(clioStatePath(), "residency-locks", key.replace(/[^a-zA-Z0-9._-]+/g, "_"));
 }
 async function withResidencyLock(targetKey, fn) {
   return withStateFileLock(lockTargetFor(targetKey), fn, {
@@ -114,6 +334,9 @@ function emitResidencyNotice(notice) {
   } catch {
   }
 }
+function emitResidencyMutation(mutation) {
+  getSharedBus().emit(BusChannels.ResidencyMutation, { ...mutation, at: Date.now() });
+}
 var protectedModelsProvider = null;
 function setProtectedModelsProvider(provider) {
   protectedModelsProvider = provider;
@@ -344,6 +567,13 @@ async function restoreEvictedModels(adapter, evicted, loadError) {
     try {
       await adapter.reloadEvicted(entry.modelId);
       restored.push(entry.modelId);
+      emitResidencyMutation({
+        targetKey: adapter.targetKey,
+        targetId: adapter.targetId,
+        runtimeId: adapter.runtimeId,
+        model: entry.modelId,
+        operation: "load"
+      });
     } catch {
       failed.push(entry.modelId);
     }
@@ -460,12 +690,28 @@ async function reconcileResidency(adapter) {
           await adapter.unload(entry.modelId);
           forgetClioLoaded(adapter.targetKey, entry.modelId);
           evicted.push(entry);
+          emitResidencyMutation({
+            targetKey: adapter.targetKey,
+            targetId: adapter.targetId,
+            runtimeId: adapter.runtimeId,
+            model: entry.modelId,
+            operation: "evict"
+          });
         } catch {
         }
       }
       if (!adapter.load) return;
       try {
         await adapter.load(adapter.keepModelId);
+        if (!plan.keepResident) {
+          emitResidencyMutation({
+            targetKey: adapter.targetKey,
+            targetId: adapter.targetId,
+            runtimeId: adapter.runtimeId,
+            model: adapter.keepModelId,
+            operation: "load"
+          });
+        }
       } catch (error) {
         await restoreEvictedModels(adapter, evicted, error);
         throw error;
@@ -796,6 +1042,13 @@ function harmonyReasoningEffort(level) {
   if (level === "medium") return "medium";
   return "low";
 }
+var MEMORY_ALWAYS_ON_MODEL_MIN_OUTPUT_TOKENS = 4e3;
+function memoryInterventionModelMaxTokens(input) {
+  const configured = Number.isSafeInteger(input.configuredMaxTokens) && input.configuredMaxTokens > 0 ? input.configuredMaxTokens : 1;
+  const requested = input.thinkingMechanism === "always-on" ? Math.max(configured * 2, MEMORY_ALWAYS_ON_MODEL_MIN_OUTPUT_TOKENS) : configured;
+  const modelCap = input.modelMaxTokens;
+  return typeof modelCap === "number" && Number.isSafeInteger(modelCap) && modelCap > 0 ? Math.min(requested, modelCap) : requested;
+}
 function reasoningClassForMechanism(mechanism) {
   if (mechanism === "none") return "never";
   if (mechanism === "always-on") return "always";
@@ -1186,6 +1439,91 @@ function resolveTargetRuntimeCapabilities(target, runtime, wireModelId, capabili
   });
 }
 
+// src/domains/providers/target-model-cache.ts
+init_esm_shims();
+import { createHash } from "node:crypto";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+var TARGET_MODEL_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var TARGET_MODEL_CACHE_VERSION = 1;
+var TARGET_MODEL_CACHE_MAX_MODELS = 4096;
+var TARGET_MODEL_CACHE_MAX_MODEL_ID_CHARS = 1024;
+function targetCacheKey(targetId) {
+  return createHash("sha256").update(targetId).digest("hex").slice(0, 24);
+}
+function targetModelSnapshotPath(targetId, cacheDir = clioCacheDir()) {
+  return join3(cacheDir, "provider-target-models", `${targetCacheKey(targetId)}.json`);
+}
+function normalizedModels(models) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const raw of models) {
+    const model = raw.trim();
+    if (model.length === 0 || model.length > TARGET_MODEL_CACHE_MAX_MODEL_ID_CHARS || seen.has(model)) continue;
+    seen.add(model);
+    out.push(model);
+    if (out.length >= TARGET_MODEL_CACHE_MAX_MODELS) break;
+  }
+  return out;
+}
+function parseSnapshot(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const row = value;
+  if (row.version !== TARGET_MODEL_CACHE_VERSION) return null;
+  if (typeof row.targetId !== "string" || row.targetId.length === 0) return null;
+  if (typeof row.runtimeId !== "string" || row.runtimeId.length === 0) return null;
+  if (row.url !== null && typeof row.url !== "string") return null;
+  if (!Array.isArray(row.models) || row.models.some((model) => typeof model !== "string")) return null;
+  if (typeof row.observedAt !== "string" || !Number.isFinite(Date.parse(row.observedAt))) return null;
+  const models = normalizedModels(row.models);
+  if (models.length !== row.models.length) return null;
+  return {
+    version: TARGET_MODEL_CACHE_VERSION,
+    targetId: row.targetId,
+    runtimeId: row.runtimeId,
+    url: row.url,
+    models,
+    observedAt: row.observedAt
+  };
+}
+function readTargetModelSnapshot(target, options = {}) {
+  const path = targetModelSnapshotPath(target.id, options.cacheDir);
+  if (!existsSync2(path)) return null;
+  try {
+    const snapshot = parseSnapshot(JSON.parse(readFileSync2(path, "utf8")));
+    if (snapshot === null) return null;
+    if (snapshot.targetId !== target.id || snapshot.runtimeId !== target.runtime) return null;
+    if (snapshot.url !== (target.url ?? null)) return null;
+    const observedMs = Date.parse(snapshot.observedAt);
+    const nowMs = options.nowMs ?? Date.now();
+    const ttlMs = options.ttlMs ?? TARGET_MODEL_CACHE_TTL_MS;
+    if (observedMs > nowMs || nowMs - observedMs >= ttlMs) return null;
+    return snapshot;
+  } catch {
+    return null;
+  }
+}
+function recordTargetModelSnapshot(target, models, options = {}) {
+  if (target.id.length === 0 || target.runtime.length === 0) return false;
+  const snapshot = {
+    version: TARGET_MODEL_CACHE_VERSION,
+    targetId: target.id,
+    runtimeId: target.runtime,
+    url: target.url ?? null,
+    models: normalizedModels(models),
+    observedAt: new Date(options.nowMs ?? Date.now()).toISOString()
+  };
+  try {
+    safeResourceWrite(targetModelSnapshotPath(target.id, options.cacheDir), `${JSON.stringify(snapshot, null, 2)}
+`, {
+      encoding: "utf8"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // src/domains/providers/eligibility.ts
 init_esm_shims();
 function isTargetEligibleRuntime(runtime) {
@@ -1291,6 +1629,105 @@ function canonicalizeWireModelId(status, requested) {
   return matches.length === 1 ? matches[0] ?? requested : requested;
 }
 
+// src/domains/providers/resolver.ts
+init_esm_shims();
+var GLOB_CHARS = /[*?[]/;
+function isThinkingLevel(token) {
+  return VALID_THINKING_LEVELS.includes(token);
+}
+function splitThinkingSuffix(pattern) {
+  const idx = pattern.lastIndexOf(":");
+  if (idx === -1) return { base: pattern };
+  const suffix = pattern.slice(idx + 1).trim();
+  if (!isThinkingLevel(suffix)) return { base: pattern };
+  const base = pattern.slice(0, idx).trim();
+  return base ? { base, thinkingLevel: suffix } : { base: pattern };
+}
+function globToRegExp(glob) {
+  let body = "^";
+  for (let i = 0; i < glob.length; i++) {
+    const ch = glob[i] ?? "";
+    if (ch === "*") {
+      body += ".*";
+    } else if (ch === "?") {
+      body += ".";
+    } else if (ch === "[") {
+      const close = glob.indexOf("]", i + 1);
+      if (close === -1) {
+        body += "\\[";
+        continue;
+      }
+      body += `[${glob.slice(i + 1, close)}]`;
+      i = close;
+    } else if (/[.+^${}()|\\]/.test(ch)) {
+      body += `\\${ch}`;
+    } else {
+      body += ch;
+    }
+  }
+  body += "$";
+  return new RegExp(body, "i");
+}
+function collectCandidates(providers) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const status of providers.list()) {
+    for (const model of modelIdsForStatus(status)) {
+      const key = `${status.target.id}/${model}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push({ target: status.target.id, model, full: key });
+    }
+  }
+  return out;
+}
+function pickFirst(candidates) {
+  if (candidates.length === 0) return null;
+  const head = candidates[0];
+  if (!head) return null;
+  return { ref: head, ambiguous: candidates.length > 1 };
+}
+function buildResult(pattern, pick, thinkingLevel) {
+  if (!pick) {
+    return { ref: null, error: `no models match pattern "${pattern}"` };
+  }
+  const ref = { target: pick.ref.target, model: pick.ref.model };
+  if (thinkingLevel) ref.thinkingLevel = thinkingLevel;
+  const result = { ref };
+  if (pick.ambiguous) {
+    result.warning = `pattern "${pattern}" matched multiple models; using ${pick.ref.full}`;
+  }
+  return result;
+}
+function resolveModelReference(rawPattern, providers) {
+  const trimmed = rawPattern.trim();
+  if (!trimmed) return { ref: null, error: "empty pattern" };
+  const { base, thinkingLevel } = splitThinkingSuffix(trimmed);
+  const candidates = collectCandidates(providers);
+  if (candidates.length === 0) {
+    return { ref: null, error: "no targets configured; add one with `clio-coder configure` or `clio-coder targets add`" };
+  }
+  const lower = base.toLowerCase();
+  const exactFull = candidates.filter((c) => c.full.toLowerCase() === lower);
+  if (exactFull.length > 0) return buildResult(base, pickFirst(exactFull), thinkingLevel);
+  if (GLOB_CHARS.test(base)) {
+    const re = globToRegExp(base);
+    const globMatches = candidates.filter((c) => re.test(c.full) || re.test(c.model));
+    return buildResult(base, pickFirst(globMatches), thinkingLevel);
+  }
+  const slashIdx = base.indexOf("/");
+  if (slashIdx !== -1) {
+    const ep = base.slice(0, slashIdx).toLowerCase();
+    const mdl = base.slice(slashIdx + 1).toLowerCase();
+    const epModel = candidates.filter((c) => c.target.toLowerCase() === ep && c.model.toLowerCase() === mdl);
+    if (epModel.length > 0) return buildResult(base, pickFirst(epModel), thinkingLevel);
+  }
+  const exactModel = candidates.filter((c) => c.model.toLowerCase() === lower);
+  if (exactModel.length > 0) return buildResult(base, pickFirst(exactModel), thinkingLevel);
+  const partial = candidates.filter((c) => c.model.toLowerCase().includes(lower));
+  return buildResult(base, pickFirst(partial), thinkingLevel);
+}
+
 // src/domains/providers/runtime-resolution.ts
 init_esm_shims();
 function diagnostic(severity, code, message) {
@@ -1477,7 +1914,7 @@ 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 loadedContextWindow = loadedContextWindowForModel(status, wireModelId) ?? input.knownLoadedContextWindow ?? null;
   const contextWindowDetails = resolveContextWindowDetails(
     target,
     runtime,
@@ -1705,6 +2142,12 @@ function resolveContextWindowDetails(target, runtime, wireModelId, knowledgeBase
   };
 }
 
+// src/domains/providers/types/cost-provenance.ts
+init_esm_shims();
+function normalizeCostProvenance(value) {
+  return value ?? "unknown";
+}
+
 // src/domains/providers/index.ts
 init_esm_shims();
 
@@ -1722,6 +2165,18 @@ import {
   Ollama
 } from "ollama";
 
+// src/core/residency-target-key.ts
+init_esm_shims();
+var RESIDENCY_RUNTIME_IDS = /* @__PURE__ */ new Set([
+  "llamacpp",
+  "lmstudio",
+  "ollama-native"
+]);
+function residencyTargetKey(runtimeId, baseUrl) {
+  if (!RESIDENCY_RUNTIME_IDS.has(runtimeId) || typeof baseUrl !== "string") return null;
+  return canonicalEndpointUrl(baseUrl) ?? baseUrl;
+}
+
 // src/engine/gemma-channel-filter.ts
 init_esm_shims();
 import { createAssistantMessageEventStream } from "@earendil-works/pi-ai";
@@ -1991,7 +2446,7 @@ async function reconcileOllamaResidency(model, headers) {
   if (!baseUrl) return;
   const metadata2 = model.clio;
   const adapter = {
-    targetKey: `ollama-native|${baseUrl}`,
+    targetKey: residencyTargetKey("ollama-native", baseUrl),
     targetId: ollamaTargetId(model),
     runtimeId: "ollama-native",
     keepModelId: model.id,
@@ -2559,6 +3014,26 @@ async function fetchRouterModels(input, fetchImpl) {
   if (!response.ok) throw new Error(`HTTP ${response.status}`);
   return parseRouterModels(await response.json());
 }
+var RouterModelPostError = class extends Error {
+  constructor(url, status, responseBody) {
+    super(`llama.cpp router rejected ${url}: HTTP ${status}; response: ${responseBody}`);
+    this.url = url;
+    this.status = status;
+    this.responseBody = responseBody;
+    this.name = "RouterModelPostError";
+  }
+  url;
+  status;
+  responseBody;
+};
+async function routerErrorBody(response) {
+  try {
+    const body = (await response.text()).trim();
+    return body.length > 0 ? body : "<empty body>";
+  } catch (error) {
+    return `<unreadable body: ${error instanceof Error ? error.message : String(error)}>`;
+  }
+}
 async function postRouterModel(fetchImpl, url, modelId) {
   const response = await fetchImpl(url, {
     method: "POST",
@@ -2567,7 +3042,27 @@ async function postRouterModel(fetchImpl, url, modelId) {
     signal: AbortSignal.timeout(LOAD_TIMEOUT_MS)
   });
   if (response.ok) return;
-  throw new Error(`llama.cpp router rejected ${url}: HTTP ${response.status}`);
+  throw new RouterModelPostError(url, response.status, await routerErrorBody(response));
+}
+function alreadyRunningResponse(body) {
+  return body.toLowerCase().includes("already running");
+}
+async function postRouterLoad(input, fetchImpl, modelId) {
+  try {
+    await postRouterModel(fetchImpl, loadUrl(input.baseUrl), modelId);
+  } catch (error) {
+    if (!(error instanceof RouterModelPostError)) throw error;
+    let model;
+    try {
+      model = (await fetchRouterModels(input, fetchImpl)).find((entry) => entry.id === modelId);
+    } catch {
+      if (alreadyRunningResponse(error.responseBody)) return;
+      throw error;
+    }
+    if (alreadyRunningResponse(error.responseBody)) return;
+    if (model !== void 0 && model.state !== "unloaded" && model.state !== "failed") return;
+    throw error;
+  }
 }
 async function waitForLoaded(input, fetchImpl, modelId) {
   const started = performance.now();
@@ -2582,7 +3077,7 @@ async function waitForLoaded(input, fetchImpl, modelId) {
 }
 async function ensureModelLoaded(input, fetchImpl, modelId, knownState) {
   if (knownState === "loaded" || knownState === "sleeping") return;
-  if (knownState !== "loading") await postRouterModel(fetchImpl, loadUrl(input.baseUrl), modelId);
+  if (knownState !== "loading") await postRouterLoad(input, fetchImpl, modelId);
   await waitForLoaded(input, fetchImpl, modelId);
 }
 async function restoreDisplacedPinned(input, fetchImpl, before) {
@@ -2609,7 +3104,7 @@ async function ensureLlamaCppResidency(input) {
   const fetchImpl = input.fetchImpl ?? fetch;
   let snapshot = [];
   const adapter = {
-    targetKey: `llamacpp|${input.baseUrl}`,
+    targetKey: residencyTargetKey("llamacpp", input.baseUrl),
     targetId: input.targetId,
     runtimeId: input.runtimeId,
     keepModelId: input.keepModelId,
@@ -2809,7 +3304,7 @@ async function ensureLmStudioResidency(model, options = {}) {
     (entry) => entry.loadedInstances.map((instance) => ({ modelKey: entry.key, identifier: instance.id, instance }))
   );
   const managed = residencyManagedFor(info.lifecycle);
-  const targetKey = `lmstudio|${lmStudioRootUrl(target.url ?? model.baseUrl)}`;
+  const targetKey = residencyTargetKey("lmstudio", target.url ?? model.baseUrl);
   const contextLength = target.lmstudio?.load?.contextLength;
   const plan = await reconcileResidency({
     targetKey,
@@ -2852,17 +3347,36 @@ async function ensureLmStudioResidency(model, options = {}) {
       });
     }
   }
+  const loadAndReport = async () => {
+    const instanceId = await loadOwnedInstance(target, targetKey, body, options.apiKey, options.signal);
+    emitResidencyMutation({
+      targetKey,
+      targetId: info.targetId,
+      runtimeId: "lmstudio",
+      model: modelKey,
+      operation: "load"
+    });
+    return instanceId ?? model.id;
+  };
   try {
-    return await loadOwnedInstance(target, targetKey, body, options.apiKey, options.signal) ?? model.id;
+    return await loadAndReport();
   } catch (error) {
     if (plan.decision === "observe" || plan.fallbackEvict.length === 0) throw error;
     return withResidencyLock(targetKey, async () => {
       for (const candidate of plan.fallbackEvict) {
         for (const entry of instances.filter((resident) => resident.modelKey === candidate.modelId)) {
-          await unloadOwnedInstance(target, targetKey, entry.identifier, options.apiKey, options.signal);
+          if (await unloadOwnedInstance(target, targetKey, entry.identifier, options.apiKey, options.signal)) {
+            emitResidencyMutation({
+              targetKey,
+              targetId: info.targetId,
+              runtimeId: "lmstudio",
+              model: candidate.modelId,
+              operation: "evict"
+            });
+          }
         }
       }
-      return await loadOwnedInstance(target, targetKey, body, options.apiKey, options.signal) ?? model.id;
+      return loadAndReport();
     });
   }
 }
@@ -2884,8 +3398,36 @@ function pickSamplingProfile2(quirks, thinkingActive) {
 function isPlainRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function observeResponseModelIdLine(line, capture) {
-  if (capture.done) return;
+function nonnegativeFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+}
+function backendCompletionTimings(value, source) {
+  if (!isPlainRecord(value)) return null;
+  const promptN = nonnegativeFiniteNumber(value.prompt_n);
+  const predictedN = nonnegativeFiniteNumber(value.predicted_n);
+  const promptMs = nonnegativeFiniteNumber(value.prompt_ms);
+  const predictedMs = nonnegativeFiniteNumber(value.predicted_ms);
+  if (promptN === null || predictedN === null || promptMs === null || predictedMs === null) return null;
+  const cacheN = nonnegativeFiniteNumber(value.cache_n);
+  return {
+    promptTokens: promptN + (cacheN ?? 0),
+    cachedTokens: cacheN,
+    predictedTokens: predictedN,
+    promptMs,
+    predictedMs,
+    source
+  };
+}
+function backendTimingsSourceForModel(model) {
+  const metadata2 = model.clio;
+  if (model.provider === "llamacpp" && metadata2?.runtimeId === "llamacpp") return "llamacpp-timings";
+  if (model.provider === "lmstudio" && metadata2?.runtimeId === "lmstudio") return "lmstudio-timings";
+  return null;
+}
+function captureCanStopEarly(capture) {
+  return capture.modelIdDone && capture.backendTimingsSource === null;
+}
+function observeResponseMetadataLine(line, capture) {
   const normalized = line.endsWith("\r") ? line.slice(0, -1) : line;
   if (!normalized.startsWith("data:")) return;
   const data = normalized.slice("data:".length).trimStart();
@@ -2893,23 +3435,29 @@ function observeResponseModelIdLine(line, capture) {
   try {
     const payload = JSON.parse(data);
     if (!isPlainRecord(payload)) return;
-    const model = payload.model;
-    if (typeof model === "string" && model.trim().length > 0) {
-      capture.reportedModelId = model.trim();
-      capture.done = true;
+    if (!capture.modelIdDone) {
+      const model = payload.model;
+      if (typeof model === "string" && model.trim().length > 0) {
+        capture.reportedModelId = model.trim();
+        capture.modelIdDone = true;
+      }
+    }
+    if (capture.backendTimingsSource !== null) {
+      const timings = backendCompletionTimings(payload.timings, capture.backendTimingsSource);
+      if (timings !== null) capture.backendTimings = timings;
     }
   } catch {
   }
 }
 function observeResponseModelIdBytes(chunk, capture, flush = false) {
-  if (capture.done || !capture.decoder) return;
+  if (!capture.decoder) return;
   capture.buffer += chunk ? capture.decoder.decode(chunk, { stream: !flush }) : capture.decoder.decode();
   let newline = capture.buffer.indexOf("\n");
   while (newline >= 0) {
     const line = capture.buffer.slice(0, newline);
     capture.buffer = capture.buffer.slice(newline + 1);
-    observeResponseModelIdLine(line, capture);
-    if (capture.done) {
+    observeResponseMetadataLine(line, capture);
+    if (captureCanStopEarly(capture)) {
       capture.buffer = "";
       capture.decoder = null;
       return;
@@ -2917,10 +3465,10 @@ function observeResponseModelIdBytes(chunk, capture, flush = false) {
     newline = capture.buffer.indexOf("\n");
   }
   if (flush && capture.buffer.length > 0) {
-    observeResponseModelIdLine(capture.buffer, capture);
+    observeResponseMetadataLine(capture.buffer, capture);
     capture.buffer = "";
   }
-  if (capture.done || flush) capture.decoder = null;
+  if (captureCanStopEarly(capture) || flush) capture.decoder = null;
 }
 function captureResponseModelId(response, capture) {
   if (!response.body || !response.headers.get("content-type")?.toLowerCase().includes("text/event-stream")) {
@@ -2930,12 +3478,12 @@ function captureResponseModelId(response, capture) {
     new TransformStream({
       transform(chunk, controller) {
         capture.observed = true;
-        if (!capture.done) observeResponseModelIdBytes(chunk, capture);
+        observeResponseModelIdBytes(chunk, capture);
         controller.enqueue(chunk);
       },
       flush() {
         capture.observed = true;
-        if (!capture.done) observeResponseModelIdBytes(void 0, capture, true);
+        observeResponseModelIdBytes(void 0, capture, true);
       }
     })
   );
@@ -2945,11 +3493,13 @@ function captureResponseModelId(response, capture) {
     headers: response.headers
   });
 }
-function withResponseModelIdCapture(options, sourceFactory) {
+function withResponseModelIdCapture(model, options, sourceFactory) {
   const capture = {
     reportedModelId: null,
     observed: false,
-    done: false,
+    modelIdDone: false,
+    backendTimings: null,
+    backendTimingsSource: backendTimingsSourceForModel(model),
     buffer: "",
     decoder: new TextDecoder()
   };
@@ -2964,8 +3514,13 @@ function withResponseModelIdCapture(options, sourceFactory) {
     try {
       for await (const event of source) {
         const observation = capture.observed ? capture.reportedModelId === null ? { state: "not-reported" } : { state: "reported", reportedModelId: capture.reportedModelId } : { state: "not-observed" };
-        if (event.type === "done") event.message.responseModelIdObservation = observation;
-        else if (event.type === "error") event.error.responseModelIdObservation = observation;
+        if (event.type === "done") {
+          event.message.responseModelIdObservation = observation;
+          if (capture.backendTimings !== null) event.message.backendTimings = capture.backendTimings;
+        } else if (event.type === "error") {
+          event.error.responseModelIdObservation = observation;
+          if (capture.backendTimings !== null) event.error.backendTimings = capture.backendTimings;
+        }
         annotated.push(event);
       }
       annotated.end();
@@ -3460,6 +4015,7 @@ var openAICompletionsApiProvider = {
           stripNeverReasoningFromStream(
             filterGemmaChannelStream(
               withResponseModelIdCapture(
+                model,
                 withRemainingContextBudget(model, effectiveContext, withSamplers),
                 (capturedOptions) => withLocalResidency(
                   model,
@@ -3491,6 +4047,7 @@ var openAICompletionsApiProvider = {
           stripNeverReasoningFromStream(
             filterGemmaChannelStream(
               withResponseModelIdCapture(
+                model,
                 withRemainingContextBudget(model, effectiveContext, withSamplers),
                 (capturedOptions) => withLocalResidency(
                   model,
@@ -3525,8 +4082,8 @@ function registerClioApiProviders() {
 
 // src/domains/providers/knowledge-base-path.ts
 init_esm_shims();
-import { existsSync, statSync } from "node:fs";
-import { delimiter, dirname, join as join2 } from "node:path";
+import { existsSync as existsSync3, statSync } from "node:fs";
+import { delimiter, dirname, 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";
@@ -3540,19 +4097,19 @@ function isDirectory(path) {
 function resolveProvidersModelsDir(importMetaUrl) {
   const start = dirname(fileURLToPath(importMetaUrl));
   const directCandidates = [
-    join2(start, "models"),
-    join2(start, "..", "domains", "providers", "models"),
-    join2(start, "..", "providers-models")
+    join4(start, "models"),
+    join4(start, "..", "domains", "providers", "models"),
+    join4(start, "..", "providers-models")
   ];
   for (const candidate of directCandidates) {
     if (isDirectory(candidate)) return candidate;
   }
   let cursor = start;
   for (let i = 0; i < 8; i++) {
-    const packageJson = join2(cursor, "package.json");
-    const sourceModels = join2(cursor, "src", "domains", "providers", "models");
-    const distModels = join2(cursor, "dist", "providers-models");
-    if (existsSync(packageJson)) {
+    const packageJson = join4(cursor, "package.json");
+    const sourceModels = join4(cursor, "src", "domains", "providers", "models");
+    const distModels = join4(cursor, "dist", "providers-models");
+    if (existsSync3(packageJson)) {
       if (isDirectory(sourceModels)) return sourceModels;
       if (isDirectory(distModels)) return distModels;
     }
@@ -3582,8 +4139,8 @@ function resolveProviderModelCatalogDirs(importMetaUrl, options = {}) {
   const bundled = resolveProvidersModelsDir(importMetaUrl);
   const cwd = options.cwd ?? process.cwd();
   const overlays = uniqueExistingDirs([
-    join2(resolveClioDirs().config, MODEL_CATALOG_OVERLAY_DIR),
-    join2(cwd, ".clio-coder", MODEL_CATALOG_OVERLAY_DIR),
+    join4(resolveClioDirs().config, MODEL_CATALOG_OVERLAY_DIR),
+    join4(cwd, ".clio-coder", MODEL_CATALOG_OVERLAY_DIR),
     ...envOverlayDirs()
   ]);
   return {
@@ -3602,7 +4159,7 @@ function resolveProviderKnowledgeBaseRoots(importMetaUrl, options = {}) {
 
 // src/domains/providers/plugins.ts
 init_esm_shims();
-import { join as join3 } from "node:path";
+import { join as join5 } from "node:path";
 function extractPluginPackages(settings) {
   if (!settings || typeof settings !== "object") return [];
   const raw = settings.runtimePlugins;
@@ -3611,7 +4168,7 @@ function extractPluginPackages(settings) {
 }
 async function loadPluginRuntimes(registry, settings) {
   const loaded = [];
-  const pluginDir = join3(clioConfigDir(), "runtimes");
+  const pluginDir = join5(clioConfigDir(), "runtimes");
   const packages = extractPluginPackages(settings);
   try {
     const ids = await registry.loadFromDir(pluginDir, activateExternalPluginApiBridge);
@@ -3639,8 +4196,8 @@ async function loadPluginRuntimes(registry, settings) {
 // src/domains/providers/types/knowledge-base.ts
 init_esm_shims();
 var import_yaml = __toESM(require_dist(), 1);
-import { readdirSync, readFileSync, statSync as statSync2 } from "node:fs";
-import { join as join4 } from "node:path";
+import { readdirSync, readFileSync as readFileSync3, statSync as statSync2 } from "node:fs";
+import { join as join6 } from "node:path";
 var FileKnowledgeBase = class {
   roots;
   loaded = [];
@@ -3654,7 +4211,7 @@ var FileKnowledgeBase = class {
       const files = collectYamlFiles(root.dir);
       for (const file of files) {
         const name = root.label ? `${root.label}:${file.name}` : file.name;
-        const raw = readFileSync(file.path, "utf8");
+        const raw = readFileSync3(file.path, "utf8");
         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`);
@@ -3712,7 +4269,7 @@ function collectYamlFiles(dir, prefix = "") {
   const out = [];
   const entries = readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
   for (const entry of entries) {
-    const path = join4(dir, entry.name);
+    const path = join6(dir, entry.name);
     const name = prefix ? `${prefix}/${entry.name}` : entry.name;
     if (entry.isDirectory()) {
       out.push(...collectYamlFiles(path, name));
@@ -3818,16 +4375,17 @@ function uniqueModels2(ids) {
   }
   return out;
 }
-function discoveredModelsSource(probe, preservePreviousProbe, previous, desc) {
+function discoveredModelsSource(probe, preservePreviousProbe, previous, cachedModels, desc) {
   if (probe?.models !== void 0) return "probe";
   if (preservePreviousProbe && previous?.discoveredModels && previous.discoveredModels.length > 0) return "cache";
+  if (cachedModels.length > 0) return "cache";
   if (desc.knownModels && desc.knownModels.length > 0) return "runtime";
   return "none";
 }
 function sameProbeIdentity(previous, next) {
   return previous.id === next.id && previous.runtime === next.runtime && (previous.url ?? "") === (next.url ?? "") && (previous.defaultModel ?? "") === (next.defaultModel ?? "");
 }
-function mergeProbeResult(desc, target, probe, previous) {
+function mergeProbeResult(desc, target, probe, previous, cachedModels = []) {
   const probeSucceeded = probe?.ok ?? false;
   const preservePrevious = !probeSucceeded && previous !== void 0 && sameProbeIdentity(previous.target, target);
   const probeCapabilities = probe?.discoveredCapabilities ?? (preservePrevious ? previous.probeCapabilities : null) ?? null;
@@ -3836,12 +4394,12 @@ function mergeProbeResult(desc, target, probe, previous) {
   const probeNotes = probe?.notes && probe.notes.length > 0 ? probe.notes : preservePrevious ? previous.probeNotes : void 0;
   const probeSurfaces = probe?.surfaces ?? (preservePrevious ? previous.probeSurfaces : void 0);
   const discoveredModels = uniqueModels2(
-    probe?.models ?? (preservePrevious ? previous.discoveredModels : void 0) ?? desc.knownModels ?? []
+    probe?.models ?? (preservePrevious ? previous.discoveredModels : void 0) ?? (cachedModels.length > 0 ? cachedModels : void 0) ?? desc.knownModels ?? []
   );
   const discoveredModelStates = probe?.modelStates ?? (preservePrevious ? previous.discoveredModelStates : null) ?? null;
   const merge = {
     discoveredModels,
-    discoveredModelsSource: discoveredModelsSource(probe, preservePrevious, previous, desc),
+    discoveredModelsSource: discoveredModelsSource(probe, preservePrevious, previous, cachedModels, desc),
     discoveredModelStates,
     probeCapabilities,
     probeModelCapabilities,
@@ -3934,7 +4492,8 @@ function createProvidersBundle(context) {
       return out2;
     }
     const availability = availabilityFor(desc, target, authStatusFor);
-    const merge = mergeProbeResult(desc, target, probe, previous);
+    const cachedModels = readTargetModelSnapshot(target)?.models ?? [];
+    const merge = mergeProbeResult(desc, target, probe, previous, cachedModels);
     const { capabilities, contextWindowProvenance } = capabilitiesFor(desc, target, merge, kb);
     const healthy = probe !== null ? probe.ok : null;
     const unservedDefault = probe?.ok ? unservedDefaultModelReason(desc, target, merge) : null;
@@ -4022,6 +4581,10 @@ function createProvidersBundle(context) {
     }
     const status = buildStatus(target, desc, probeResult, previous);
     statuses.set(target.id, status);
+    if (probeResult.ok && probeResult.models !== void 0) {
+      recordTargetModelSnapshot(target, probeResult.models);
+    }
+    void recordEndpointSlotsFromStatus(status);
     context.bus.emit(BusChannels.ProviderHealth, { id: target.id, status });
     return status;
   }
@@ -4184,111 +4747,6 @@ var ProvidersManifest = {
   dependsOn: ["config"]
 };
 
-// src/domains/providers/resolver.ts
-init_esm_shims();
-var GLOB_CHARS = /[*?[]/;
-function isThinkingLevel(token) {
-  return VALID_THINKING_LEVELS.includes(token);
-}
-function splitThinkingSuffix(pattern) {
-  const idx = pattern.lastIndexOf(":");
-  if (idx === -1) return { base: pattern };
-  const suffix = pattern.slice(idx + 1).trim();
-  if (!isThinkingLevel(suffix)) return { base: pattern };
-  const base = pattern.slice(0, idx).trim();
-  return base ? { base, thinkingLevel: suffix } : { base: pattern };
-}
-function globToRegExp(glob) {
-  let body = "^";
-  for (let i = 0; i < glob.length; i++) {
-    const ch = glob[i] ?? "";
-    if (ch === "*") {
-      body += ".*";
-    } else if (ch === "?") {
-      body += ".";
-    } else if (ch === "[") {
-      const close = glob.indexOf("]", i + 1);
-      if (close === -1) {
-        body += "\\[";
-        continue;
-      }
-      body += `[${glob.slice(i + 1, close)}]`;
-      i = close;
-    } else if (/[.+^${}()|\\]/.test(ch)) {
-      body += `\\${ch}`;
-    } else {
-      body += ch;
-    }
-  }
-  body += "$";
-  return new RegExp(body, "i");
-}
-function collectCandidates(providers) {
-  const out = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const status of providers.list()) {
-    for (const model of modelIdsForStatus(status)) {
-      const key = `${status.target.id}/${model}`;
-      if (seen.has(key)) continue;
-      seen.add(key);
-      out.push({ target: status.target.id, model, full: key });
-    }
-  }
-  return out;
-}
-function pickFirst(candidates) {
-  if (candidates.length === 0) return null;
-  const head = candidates[0];
-  if (!head) return null;
-  return { ref: head, ambiguous: candidates.length > 1 };
-}
-function buildResult(pattern, pick, thinkingLevel) {
-  if (!pick) {
-    return { ref: null, error: `no models match pattern "${pattern}"` };
-  }
-  const ref = { target: pick.ref.target, model: pick.ref.model };
-  if (thinkingLevel) ref.thinkingLevel = thinkingLevel;
-  const result = { ref };
-  if (pick.ambiguous) {
-    result.warning = `pattern "${pattern}" matched multiple models; using ${pick.ref.full}`;
-  }
-  return result;
-}
-function resolveModelReference(rawPattern, providers) {
-  const trimmed = rawPattern.trim();
-  if (!trimmed) return { ref: null, error: "empty pattern" };
-  const { base, thinkingLevel } = splitThinkingSuffix(trimmed);
-  const candidates = collectCandidates(providers);
-  if (candidates.length === 0) {
-    return { ref: null, error: "no targets configured; add one with `clio-coder configure` or `clio-coder targets add`" };
-  }
-  const lower = base.toLowerCase();
-  const exactFull = candidates.filter((c) => c.full.toLowerCase() === lower);
-  if (exactFull.length > 0) return buildResult(base, pickFirst(exactFull), thinkingLevel);
-  if (GLOB_CHARS.test(base)) {
-    const re = globToRegExp(base);
-    const globMatches = candidates.filter((c) => re.test(c.full) || re.test(c.model));
-    return buildResult(base, pickFirst(globMatches), thinkingLevel);
-  }
-  const slashIdx = base.indexOf("/");
-  if (slashIdx !== -1) {
-    const ep = base.slice(0, slashIdx).toLowerCase();
-    const mdl = base.slice(slashIdx + 1).toLowerCase();
-    const epModel = candidates.filter((c) => c.target.toLowerCase() === ep && c.model.toLowerCase() === mdl);
-    if (epModel.length > 0) return buildResult(base, pickFirst(epModel), thinkingLevel);
-  }
-  const exactModel = candidates.filter((c) => c.model.toLowerCase() === lower);
-  if (exactModel.length > 0) return buildResult(base, pickFirst(exactModel), thinkingLevel);
-  const partial = candidates.filter((c) => c.model.toLowerCase().includes(lower));
-  return buildResult(base, pickFirst(partial), thinkingLevel);
-}
-
-// src/domains/providers/types/cost-provenance.ts
-init_esm_shims();
-function normalizeCostProvenance(value) {
-  return value ?? "unknown";
-}
-
 // src/domains/providers/index.ts
 var ProvidersDomainModule = {
   manifest: ProvidersManifest,
@@ -4296,8 +4754,17 @@ var ProvidersDomainModule = {
 };
 
 export {
+  residencyTargetKey,
   setGlobalDefaultMaxOutputTokens,
   resolveReservedOutputTokens,
+  canonicalEndpointKey,
+  endpointLabel,
+  endpointCapacityFor,
+  endpointCapacityForStatus,
+  endpointCapacitiesForStatuses,
+  resolveEndpointCapacities,
+  registerForegroundStream,
+  foregroundStreamUsage,
   setResidencyNoticeSink,
   setProtectedModelsProvider,
   withRunOverrides,
@@ -4306,6 +4773,7 @@ export {
   applyModelCapabilityPatch,
   probeCapabilitiesForModel,
   resolveModelCapabilities,
+  memoryInterventionModelMaxTokens,
   thinkingLevelChoiceLabel,
   thinkingLevelFromChoiceLabel,
   resolveModelRuntimeCapabilitiesForProviders,
@@ -4313,6 +4781,8 @@ export {
   registerClioApiProviders,
   resolveProviderKnowledgeBaseRoots,
   loadPluginRuntimes,
+  readTargetModelSnapshot,
+  recordTargetModelSnapshot,
   FileKnowledgeBase,
   isOrchestratorEligibleRuntime,
   isDispatchEligibleRuntime,
@@ -4330,4 +4800,4 @@ export {
   normalizeCostProvenance,
   ProvidersDomainModule
 };
-//# sourceMappingURL=chunk-7RFXX52T.js.map
+//# sourceMappingURL=chunk-DQITNCXG.js.map