@polderlabs/bizar 10.23.6 → 10.23.7

package/cli/commands/models.mjs

@@ -189,7 +189,7 @@ export async function fetchProviderCatalog({
   return fetchModelsDevCatalog({ fetchFn, timeoutMs, url });
 }
 
-function flattenModelsDevCatalog(catalog) {
+function flattenModelsDevCatalog(catalog, { providerCatalog = false } = {}) {
   const entries = new Map();
   const add = (id, value) => {
     if (typeof id !== 'string' || !id.trim() || !value || typeof value !== 'object' || Array.isArray(value)) return;
@@ -213,15 +213,48 @@ function flattenModelsDevCatalog(catalog) {
       for (const [modelId, model] of Object.entries(value)) add(modelId, model);
     }
     if (key === 'providers') {
-      for (const provider of Object.values(value)) {
+      for (const [providerId, provider] of Object.entries(value)) {
         if (!provider || typeof provider !== 'object' || Array.isArray(provider)) continue;
-        for (const [modelId, model] of Object.entries(provider.models || {})) add(modelId, model);
+        for (const [modelId, model] of Object.entries(provider.models || {})) {
+          // catalog.json commonly uses the same bare model id under several
+          // providers. Keep that identity in the key: a bare-id map would be
+          // last-writer-wins and could attach one provider's serving facts to
+          // another provider's model.
+          const qualifiedId = providerCatalog && !modelId.includes('/')
+            ? `${providerId}/${modelId}`
+            : modelId;
+          add(qualifiedId, { provider: providerId, ...model });
+        }
       }
     }
   }
   return entries;
 }
 
+function uniqueCatalogMatch(entries, gatewayId, { requireProvider = false } = {}) {
+  const raw = String(gatewayId || '').trim().toLowerCase();
+  if (!raw) return null;
+  const exact = entries.get(raw);
+  if (exact) return exact;
+
+  const wanted = normalizedModelIdentity(raw);
+  const values = [...entries.values()];
+  const providerMatches = wanted.provider
+    ? values.filter((entry) => {
+      const found = normalizedModelIdentity(entry.id);
+      return found.model === wanted.model && found.provider === wanted.provider;
+    })
+    : [];
+  if (providerMatches.length === 1) return providerMatches[0];
+  if (requireProvider) return null;
+
+  // Wrapper namespaces (for example cx/ or a gateway-specific prefix) are
+  // not canonical providers. A canonical suffix is still safe when exactly
+  // one catalog entry owns it; collisions deliberately remain unmatched.
+  const suffixMatches = values.filter((entry) => normalizedModelIdentity(entry.id).model === wanted.model);
+  return suffixMatches.length === 1 ? suffixMatches[0] : null;
+}
+
 function normalizedModelIdentity(id) {
   const raw = String(id || '').trim().toLowerCase();
   const slash = raw.indexOf('/');
@@ -276,6 +309,7 @@ export function toCapabilityProfile(gatewayId, match, matchType, confidence) {
     weights: Array.isArray(match.weights) ? match.weights : [],
     benchmarks: Array.isArray(match.benchmarks) ? match.benchmarks : [],
     cost: match.cost && typeof match.cost === 'object' ? match.cost : null,
+    serving: match.serving && typeof match.serving === 'object' ? match.serving : null,
     metadata: {
       source: 'models.dev',
       sourceUrl: MODELS_DEV_CATALOG_URL,
@@ -302,7 +336,6 @@ export function toCapabilityProfile(gatewayId, match, matchType, confidence) {
  */
 export function enrichModelsWithCapabilities(candidates, catalog) {
   const entries = flattenModelsDevCatalog(catalog);
-  const all = [...entries.values()];
   return (Array.isArray(candidates) ? candidates : []).map((candidate) => {
     const gatewayId = candidate.id;
     const exact = entries.get(String(gatewayId).toLowerCase());
@@ -310,14 +343,9 @@ export function enrichModelsWithCapabilities(candidates, catalog) {
       const profile = toCapabilityProfile(gatewayId, exact, 'exact-id', 0.9);
       return { ...candidate, profile, contextWindow: profile.limits.contextTokens };
     }
-    const wanted = normalizedModelIdentity(gatewayId);
-    const matches = all.filter((entry) => {
-      const found = normalizedModelIdentity(entry.id);
-      if (!wanted.model || found.model !== wanted.model) return false;
-      return !wanted.provider || !found.provider || found.provider === wanted.provider;
-    });
-    if (matches.length === 1) {
-      const profile = toCapabilityProfile(gatewayId, matches[0], 'unique-normalized-id', 0.7);
+    const match = uniqueCatalogMatch(entries, gatewayId);
+    if (match) {
+      const profile = toCapabilityProfile(gatewayId, match, 'unique-normalized-id', 0.7);
       return { ...candidate, profile, contextWindow: profile.limits.contextTokens };
     }
     // Models.dev miss: if the candidate carries gateway-supplied label /
@@ -364,37 +392,47 @@ export function enrichModelsWithCapabilities(candidates, catalog) {
   });
 }
 
-/**
- * Strip a `<provider>/` prefix from a model id. Used as a last-ditch catalog
- * lookup key when the gateway reports the model under a wrapper namespace
- * (e.g. `claude-minimax/MiniMax-M3`) and the models.dev catalog uses the bare
- * form (`minimax/MiniMax-M3`).
- *
- * @param {string} id
- * @returns {string}
- */
-function stripProvider(id) {
-  const raw = String(id || '').trim();
-  const slash = raw.indexOf('/');
-  return slash >= 0 ? raw.slice(slash + 1) : raw;
+function gatewayFallbackProfile(candidate) {
+  if (!candidate?._gateway) return null;
+  return {
+    gatewayId: candidate.id,
+    baseModel: candidate.id,
+    name: candidate._gateway.name ?? candidate._gateway.display_name ?? null,
+    family: null,
+    description: candidate._gateway.description ?? null,
+    summary: null,
+    capabilities: {
+      attachment: false,
+      reasoning: false,
+      toolCall: false,
+      structuredOutput: false,
+      temperature: true,
+      inputModalities: ['text'],
+      outputModalities: ['text'],
+    },
+    limits: { contextTokens: null, inputTokens: null, outputTokens: null },
+    metadata: { source: 'gateway-fallback', matchType: 'gateway-fallback', confidence: 0 },
+  };
+}
+
+function withClearedTimeout(work, timeoutMs, label) {
+  let timer;
+  return Promise.race([
+    Promise.resolve().then(work),
+    new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new Error(`${label} timeout`)), timeoutMs);
+    }),
+  ]).finally(() => clearTimeout(timer));
 }
 
 /**
- * Phase 2 lazy enrichment. The interactive picker path used to call
- * `fetchModelsDevCatalog` BEFORE the picker opened, paying the round-trip
- * on every `--list`/`--set` (which never even consulted the catalog) and
- * on every interactive session that the user then aborted.
+ * Best-effort metadata enrichment. Interactive callers pass the complete
+ * candidate set before rendering; non-interactive callers may pass only the
+ * IDs they need. Empty input is returned without contacting Models.dev.
  *
- * After Phase 2 the catalog fetch moves to AFTER picker confirmation:
- *   - `--list` and `--set` skip the fetch entirely.
- *   - The interactive path only fetches when the user actually picked
- *     one or more models, and only the picked IDs are enriched.
- *
- * Concurrency: per-id lookups run in parallel with a bounded worker pool
- * (`concurrency`, default 8) and a per-id timeout (`timeoutMs`, default
- * 3000ms). On per-id timeout or lookup failure, we fall back to the
- * candidate's Phase 1 `_gateway.name` contract (when present); when no
- * `_gateway` block is attached, the profile is `null`.
+ * The base and provider catalogs are fetched concurrently exactly once. Their
+ * timeout handles are cleared as soon as each request settles. Catalog misses
+ * fall back to the gateway's renderer-safe profile shape.
  *
  * @param {{
  *   candidates: Array<{ id: string, owned_by?: string|null, _gateway?: { name?: string|null, display_name?: string|null, description?: string|null } }>,
@@ -414,29 +452,29 @@ export async function enrichPicksByMetadata({
   timeoutMs = 3000,
   concurrency = 8,
 } = {}) {
+  const out = new Map();
+  const ids = Array.isArray(pickedIds) ? pickedIds.filter((id) => typeof id === 'string' && id) : [];
+  if (ids.length === 0) return { profiles: out, modelsDev: {}, providerCatalog: {} };
+
   // Wholesale catalog fetch — best-effort. A network failure on the
   // initial fetch degrades to an empty map; per-id timeouts on the
   // downstream enrichment path fall back to `_gateway.name`.
   // The wholesale fetch inherits `timeoutMs` so a hung stub does not
   // block the picker-confirmation step indefinitely.
-  const fetchWithTimeout = (fn, label) => Promise.race([
-    fn({}),
-    new Promise((_, reject) => setTimeout(() => reject(new Error(`enrichPicksByMetadata: ${label} fetch timeout`)), timeoutMs)),
-  ]).catch(() => ({}));
+  const fetchWithTimeout = (fn, label) => withClearedTimeout(
+    () => fn({ timeoutMs }),
+    timeoutMs,
+    `enrichPicksByMetadata: ${label} fetch`,
+  ).catch(() => ({}));
   const [catalog, providerCatalog] = await Promise.all([
     fetchWithTimeout(fetchFn, 'base catalog'),
     typeof providerFetchFn === 'function' ? fetchWithTimeout(providerFetchFn, 'provider catalog') : Promise.resolve({}),
   ]);
   const catalogMap = flattenModelsDevCatalog(catalog);
-  const providerMap = flattenModelsDevCatalog(providerCatalog);
-
-  const out = new Map();
-  const ids = Array.isArray(pickedIds) ? pickedIds.filter((id) => typeof id === 'string' && id) : [];
+  const providerMap = flattenModelsDevCatalog(providerCatalog, { providerCatalog: true });
   // Stable order so the work array indexes are predictable for the
   // bounded runner below.
   const work = ids.map((id, index) => ({ id, index }));
-  if (work.length === 0) return { profiles: out, modelsDev: catalog };
-
   const findCandidate = (id) => (Array.isArray(candidates) ? candidates.find((c) => c && c.id === id) : null);
 
   // Bounded-concurrency worker pool. Each worker pulls jobs off the
@@ -456,19 +494,15 @@ export async function enrichPicksByMetadata({
         continue;
       }
       try {
-        await Promise.race([
-          // Each "job" resolves immediately with the profile lookup; the
-          // race is a defense-in-depth measure so a misbehaving fetchFn
-          // cannot stall the worker past `timeoutMs`.
-          Promise.resolve().then(() => {
-            const lower = String(id).toLowerCase();
-            const baseMatch = catalogMap.get(lower)
-              || catalogMap.get(stripProvider(id).toLowerCase());
-            const providerMatch = providerMap.get(lower)
-              || providerMap.get(stripProvider(id).toLowerCase());
-            const match = baseMatch && providerMatch
-              ? { ...baseMatch, ...providerMatch }
-              : (baseMatch || providerMatch);
+        await Promise.resolve().then(() => {
+            const baseMatch = uniqueCatalogMatch(catalogMap, id);
+            // Serving metadata is provider-specific. It is eligible only
+            // for an exact or normalized explicit provider match; suffix-only
+            // matching here would reintroduce cross-provider collisions.
+            const providerMatch = uniqueCatalogMatch(providerMap, id, { requireProvider: true });
+            const match = baseMatch
+              ? { ...baseMatch, ...(providerMatch ? { serving: providerMatch, cost: providerMatch.cost ?? baseMatch.cost } : {}) }
+              : providerMatch;
             let profile;
             if (match) {
               // Re-use the existing capability-profile shape; the new
@@ -477,42 +511,18 @@ export async function enrichPicksByMetadata({
               // enriched (confirmed picks only).
               profile = toCapabilityProfile(id, match, 'exact-id', 0.9);
             } else if (candidate._gateway) {
-              profile = {
-                name: candidate._gateway.name ?? candidate._gateway.display_name ?? null,
-                description: candidate._gateway.description ?? null,
-                summary: null,
-                ownedBy: candidate.owned_by ?? null,
-                supportsTools: null,
-                supportsVision: null,
-                contextWindow: null,
-                costTier: null,
-                confidence: 0,
-                metadata: { source: 'gateway-fallback' },
-              };
+              profile = gatewayFallbackProfile(candidate);
             } else {
               profile = null;
             }
             out.set(id, profile);
-          }),
-          new Promise((_, reject) => setTimeout(() => reject(new Error('enrichPicksByMetadata: per-id timeout')), timeoutMs)),
-        ]);
+          });
       } catch {
         // Per-id failure (timeout or thrown). Fall back to `_gateway.name`
         // when present so the Phase 1 contract still surfaces a name;
         // otherwise the profile is null.
         if (candidate._gateway) {
-          out.set(id, {
-            name: candidate._gateway.name ?? candidate._gateway.display_name ?? null,
-            description: candidate._gateway.description ?? null,
-            summary: null,
-            ownedBy: candidate.owned_by ?? null,
-            supportsTools: null,
-            supportsVision: null,
-            contextWindow: null,
-            costTier: null,
-            confidence: 0,
-            metadata: { source: 'gateway-fallback' },
-          });
+          out.set(id, gatewayFallbackProfile(candidate));
         } else {
           out.set(id, null);
         }
@@ -520,17 +530,20 @@ export async function enrichPicksByMetadata({
     }
   });
   await Promise.all(workers);
-  return { profiles: out, modelsDev: catalog };
+  return { profiles: out, modelsDev: catalog, providerCatalog };
 }
 
 function capabilityLabel(profile) {
   if (!profile) return 'metadata unavailable';
+  const capabilities = profile.capabilities || {};
+  const modalities = Array.isArray(capabilities.inputModalities) ? capabilities.inputModalities : [];
+  const limits = profile.limits || {};
   const caps = [];
-  if (profile.capabilities.reasoning) caps.push('reasoning');
-  if (profile.capabilities.toolCall) caps.push('tools');
-  if (profile.capabilities.structuredOutput) caps.push('structured');
-  if (profile.capabilities.inputModalities.some((m) => m !== 'text')) caps.push('multimodal');
-  if (profile.limits.contextTokens) caps.push(formatContextTokens(profile.limits.contextTokens));
+  if (capabilities.reasoning) caps.push('reasoning');
+  if (capabilities.toolCall) caps.push('tools');
+  if (capabilities.structuredOutput) caps.push('structured');
+  if (modalities.some((m) => m !== 'text')) caps.push('multimodal');
+  if (limits.contextTokens) caps.push(formatContextTokens(limits.contextTokens));
   return caps.length > 0 ? caps.join(', ') : 'basic text';
 }
 
@@ -858,16 +871,19 @@ export function applyModels({ routerPath, models, tierHints = {}, profiles = {},
   const { kept: list } = filterCandidatesByDisabledProviders(incoming, disabled);
   const hints = { ...(tierHints || {}) };
   for (const id of list) if (!hints[id]) hints[id] = defaultTierHint(id);
+  const router = existsSync(routerPath)
+    ? JSON.parse(readFileSync(routerPath, 'utf8'))
+    : {};
+  const previousProfiles = router?.userSelected?.profiles || {};
   const block = {
     models: list,
     lastUpdated: new Date().toISOString(),
     source,
     tierHints: hints,
-    profiles: Object.fromEntries(list.filter((id) => profiles[id]).map((id) => [id, profiles[id]])),
+    profiles: Object.fromEntries(list
+      .filter((id) => profiles[id] || previousProfiles[id])
+      .map((id) => [id, profiles[id] || previousProfiles[id]])),
   };
-  const router = existsSync(routerPath)
-    ? JSON.parse(readFileSync(routerPath, 'utf8'))
-    : {};
   router.userSelected = block;
   if (!router.version) router.version = '13.0.0';
   // Do NOT auto-inject a default endpoint here. Operators configure the
@@ -1490,10 +1506,12 @@ export function explainSelection({ routerPath, role, requirements = {} } = {}) {
  * Interactive multi-select picker. Pure function over streams — testable.
  *
  * Branching: when stdin is a TTY with raw-mode support, the picker drives a
- * keypress-driven checklist (arrow keys / j-k / space / a / n / enter / q /
- * esc / ?).  When stdin is not a TTY (pipes, CI, tests) the picker falls
+ * keypress-driven checklist with direct type-to-search (arrow keys / space /
+ * Ctrl+A / Ctrl+N / enter / esc / backspace / ?). When stdin is not a TTY (pipes, CI,
+ * tests) the picker falls
  * through to a line-mode loop that accepts a space-separated index list,
- * `all`, `none`, `toggle <i>`, an empty line (confirm), or `q` (quit). Both
+ * `all`, `none`, `toggle <i>`, `/query`, `search query`, an empty line
+ * (confirm), or `q` (quit). Both
  * branches return the chosen IDs in the user's most-recent selection order,
  * so external callers and existing tests see a single `Promise<string[]>`.
  *
@@ -1537,10 +1555,112 @@ export async function pickModels({ candidates, current = [], stdin, stdout, prom
   }
 }
 
+function normalizeSearchText(value) {
+  return String(value || '')
+    .toLowerCase()
+    .replace(/[^\p{L}\p{N}]+/gu, ' ')
+    .trim()
+    .replace(/\s+/g, ' ');
+}
+
+/**
+ * Score a fuzzy query against one text field. Exact, prefix, token-prefix,
+ * and substring matches lead; ordered subsequences remain useful for compact
+ * queries such as `gpt56l`. A negative score means no match.
+ */
+function fuzzyTextScore(value, query, allowSubsequence = true) {
+  const text = normalizeSearchText(value);
+  const needle = normalizeSearchText(query);
+  if (!needle) return 0;
+  if (!text) return -1;
+  if (text === needle) return 10_000;
+  if (text.startsWith(needle)) return 9_000 - (text.length - needle.length);
+
+  const tokenIndex = text.split(' ').findIndex((token) => token.startsWith(needle));
+  if (tokenIndex >= 0) return 8_000 - tokenIndex * 10;
+
+  const substringIndex = text.indexOf(needle);
+  if (substringIndex >= 0) return 7_000 - substringIndex;
+
+  // One- and two-character subsequences are too permissive across model
+  // descriptions. Short searches must be contiguous.
+  if (!allowSubsequence || needle.replace(/\s/g, '').length < 3) return -1;
+
+  let textIndex = 0;
+  let first = -1;
+  let previous = -1;
+  let gaps = 0;
+  let boundaries = 0;
+  for (const char of needle) {
+    if (char === ' ') continue;
+    const found = text.indexOf(char, textIndex);
+    if (found < 0) return -1;
+    if (first < 0) first = found;
+    if (previous >= 0) gaps += found - previous - 1;
+    if (found === 0 || text[found - 1] === ' ') boundaries++;
+    previous = found;
+    textIndex = found + 1;
+  }
+  const compactNeedleLength = needle.replace(/\s/g, '').length;
+  if (gaps > Math.max(8, compactNeedleLength * 2)) return -1;
+  return 4_000 + boundaries * 25 - first * 2 - gaps;
+}
+
+/**
+ * Pure fuzzy filter used by both picker modes. Match quality determines
+ * inclusion while gateway order remains stable as the query changes.
+ *
+ * @param {Array<{id: string, profile?: object, _gateway?: object}>} candidates
+ * @param {string} query
+ * @returns {Array<{id: string, profile?: object, _gateway?: object}>}
+ */
+export function filterModelCandidates(candidates, query) {
+  if (!Array.isArray(candidates)) return [];
+  const needle = normalizeSearchText(query);
+  if (!needle) return [...candidates];
+
+  return candidates
+    .map((candidate, index) => {
+      const profile = candidate?.profile || {};
+      const gateway = candidate?._gateway || {};
+      const fields = [
+        [candidate?.id, 300, true],
+        [profile.baseModel, 275, true],
+        [profile.name, 200, true],
+        [gateway.name, 200, true],
+        [profile.displayName, 200, true],
+        [gateway.display_name, 200, true],
+        [profile.family, 175, true],
+        [gateway.family, 175, true],
+        [profile.description, 100, false],
+        [gateway.description, 100, false],
+        [profile.summary, 50, false],
+        [gateway.summary, 50, false],
+      ];
+      const score = Math.max(...fields.map(([value, bonus, allowSubsequence]) => {
+        const fieldScore = fuzzyTextScore(value, needle, allowSubsequence);
+        return fieldScore < 0 ? -1 : fieldScore + bonus;
+      }));
+      return { candidate, index, score };
+    })
+    .filter((entry) => entry.score >= 0)
+    // Gateway order is the stable picker contract. Fuzzy scoring decides
+    // inclusion; it deliberately does not reshuffle rows while the operator
+    // types, which keeps cursor movement predictable.
+    .sort((a, b) => a.index - b.index)
+    .map((entry) => entry.candidate);
+}
+
 async function pickModelsLineMode({ ordered, candidates, selected, lastOrder, stdin, stdout, prompt }) {
   const lines = makeLineReader(stdin);
+  let query = '';
   for (;;) {
-    renderPicker(stdout, ordered, selected, prompt, candidates);
+    const visibleCandidates = filterModelCandidates(candidates, query);
+    const visibleIds = visibleCandidates.map((candidate) => candidate.id);
+    renderPicker(stdout, visibleIds, selected, prompt, visibleCandidates, {
+      query,
+      total: ordered.length,
+    });
     const line = await readPrompt(lines, stdout, stdin.isTTY === true, '> ');
     if (line === null) break; // EOF on non-TTY
     const cmd = String(line || '').trim();
@@ -1556,13 +1676,25 @@ async function pickModelsLineMode({ ordered, candidates, selected, lastOrder, st
       continue;
     }
     if (cmd === 'q' || cmd === 'quit' || cmd === ':wq') break;
+    if (cmd === '/' || cmd === 'search' || cmd === 'clear search') {
+      query = '';
+      continue;
+    }
+    if (cmd.startsWith('/')) {
+      query = cmd.slice(1).trim();
+      continue;
+    }
+    if (cmd.startsWith('search ')) {
+      query = cmd.slice('search '.length).trim();
+      continue;
+    }
     if (cmd.startsWith('toggle ')) {
       const idx = Number(cmd.slice('toggle '.length).trim());
-      if (!Number.isInteger(idx) || idx < 1 || idx > ordered.length) {
+      if (!Number.isInteger(idx) || idx < 1 || idx > visibleIds.length) {
         stdout.write(chalk.red(`  x index out of range\n`));
         continue;
       }
-      const id = ordered[idx - 1];
+      const id = visibleIds[idx - 1];
       if (selected.has(id)) {
         selected.delete(id);
         lastOrder = lastOrder.filter((x) => x !== id);
@@ -1575,8 +1707,8 @@ async function pickModelsLineMode({ ordered, candidates, selected, lastOrder, st
     const indices = cmd.split(/\s+/).map((s) => Number(s)).filter((n) => Number.isInteger(n));
     let changed = false;
     for (const n of indices) {
-      if (n < 1 || n > ordered.length) continue;
-      const id = ordered[n - 1];
+      if (n < 1 || n > visibleIds.length) continue;
+      const id = visibleIds[n - 1];
       if (selected.has(id)) {
         selected.delete(id);
         lastOrder = lastOrder.filter((x) => x !== id);
@@ -1586,7 +1718,7 @@ async function pickModelsLineMode({ ordered, candidates, selected, lastOrder, st
       }
       changed = true;
     }
-    if (!changed) stdout.write(chalk.yellow(`  ! unrecognised input - try 'all', 'none', 'toggle <i>', or '1 3 5'\n`));
+    if (!changed) stdout.write(chalk.yellow(`  ! unrecognised input - try '/query', 'search query', 'all', 'none', 'toggle <i>', or '1 3 5'\n`));
   }
   const seen = new Set();
   return lastOrder.filter((id) => {
@@ -1621,6 +1753,9 @@ async function pickModelsInteractive({ ordered, candidates, selected, lastOrder,
   let scrollTop = 0;
   let lastRenderHeight = 0;
   let showHelp = false;
+  let query = '';
+  let visibleCandidates = [...candidates];
+  const originalIndices = new Map(candidates.map((candidate, index) => [candidate, index]));
 
   readline.emitKeypressEvents(stdin);
   if (typeof stdin.resume === 'function') stdin.resume();
@@ -1629,8 +1764,18 @@ async function pickModelsInteractive({ ordered, candidates, selected, lastOrder,
   const exitState = await new Promise((resolve) => {
     const onKey = (str, key) => {
       if (!key) return;
-      // Resolve confirmation
-      if (key.name === 'return' || str === 'q' || key.name === 'escape') {
+      // Resolve confirmation. Escape clears an active search first so a
+      // typo never accidentally exits the picker.
+      if (key.name === 'return') {
+        return finish();
+      }
+      if (key.name === 'escape') {
+        if (query) {
+          query = '';
+          refreshFilter();
+          render();
+          return;
+        }
         return finish();
       }
       if (key.ctrl && key.name === 'c') {
@@ -1639,27 +1784,36 @@ async function pickModelsInteractive({ ordered, candidates, selected, lastOrder,
         lastOrder.length = 0;
         return finish();
       }
-      if (key.name === 'up' || str === 'k') {
-        cursor = (cursor - 1 + ordered.length) % ordered.length;
-      } else if (key.name === 'down' || str === 'j') {
-        cursor = (cursor + 1) % ordered.length;
-      } else if (key.name === 'space' || str === 'x') {
-        const id = ordered[cursor];
-        if (selected.has(id)) {
-          selected.delete(id);
-          lastOrder = lastOrder.filter((x) => x !== id);
-        } else {
-          selected.add(id);
-          lastOrder.push(id);
+      if (key.name === 'up' && visibleCandidates.length > 0) {
+        cursor = (cursor - 1 + visibleCandidates.length) % visibleCandidates.length;
+      } else if (key.name === 'down' && visibleCandidates.length > 0) {
+        cursor = (cursor + 1) % visibleCandidates.length;
+      } else if (key.name === 'space') {
+        if (visibleCandidates.length > 0) {
+          const id = visibleCandidates[cursor].id;
+          if (selected.has(id)) {
+            selected.delete(id);
+            lastOrder = lastOrder.filter((x) => x !== id);
+          } else {
+            selected.add(id);
+            lastOrder.push(id);
+          }
         }
-      } else if (str === 'a') {
+      } else if (key.ctrl && key.name === 'a') {
         for (const id of ordered) selected.add(id);
         lastOrder = [...ordered];
-      } else if (str === 'n') {
+      } else if (key.ctrl && key.name === 'n') {
         selected.clear();
         lastOrder = [];
       } else if (str === '?') {
         showHelp = !showHelp;
+      } else if (key.name === 'backspace' || key.name === 'delete') {
+        if (!query) return;
+        query = query.slice(0, -1);
+        refreshFilter();
+      } else if (typeof str === 'string' && str.length === 1 && !key.ctrl && !key.meta && str >= ' ') {
+        query += str;
+        refreshFilter();
       } else {
         return;
       }
@@ -1688,51 +1842,62 @@ async function pickModelsInteractive({ ordered, candidates, selected, lastOrder,
   });
 
   function adjustScroll() {
-    if (ordered.length <= VIEWPORT_SIZE) {
+    if (visibleCandidates.length === 0 || visibleCandidates.length <= VIEWPORT_SIZE) {
       scrollTop = 0;
       return;
     }
     if (cursor < scrollTop) scrollTop = cursor;
     else if (cursor >= scrollTop + VIEWPORT_SIZE) scrollTop = cursor - VIEWPORT_SIZE + 1;
     if (scrollTop < 0) scrollTop = 0;
-    if (scrollTop > Math.max(0, ordered.length - VIEWPORT_SIZE)) {
-      scrollTop = Math.max(0, ordered.length - VIEWPORT_SIZE);
+    if (scrollTop > Math.max(0, visibleCandidates.length - VIEWPORT_SIZE)) {
+      scrollTop = Math.max(0, visibleCandidates.length - VIEWPORT_SIZE);
     }
   }
 
+  function refreshFilter() {
+    visibleCandidates = filterModelCandidates(candidates, query);
+    cursor = 0;
+    scrollTop = 0;
+  }
+
   function render() {
     const width = String(ordered.length).length;
     const columns = typeof stdout.columns === 'number' ? stdout.columns : 80;
     const lines = [];
     lines.push(`\x1b[K${chalk.bold(`-- ${prompt} --`)}`);
+    lines.push(`\x1b[K${query ? `  Search: ${chalk.bold(query)}` : chalk.dim('  Search: type a model name or ID')}`);
     const start = scrollTop;
-    const end = Math.min(ordered.length, start + VIEWPORT_SIZE);
+    const end = Math.min(visibleCandidates.length, start + VIEWPORT_SIZE);
     const above = start;
-    const below = ordered.length - end;
+    const below = visibleCandidates.length - end;
     if (above > 0) lines.push(`\x1b[K${chalk.dim(`  ⋮ ${above} more above`)}`);
     for (let i = start; i < end; i++) {
-      const profile = candidates.find((candidate) => candidate.id === ordered[i])?.profile;
+      const candidate = visibleCandidates[i];
+      const originalIndex = originalIndices.get(candidate) ?? i;
       const row = fitRow({
-        i,
-        id: ordered[i],
-        profile,
+        i: originalIndex,
+        id: candidate.id,
+        profile: candidate.profile,
         width,
         isCursor: i === cursor,
-        isSelected: selected.has(ordered[i]),
+        isSelected: selected.has(candidate.id),
         columns,
       });
       lines.push(`\x1b[K${row}`);
     }
+    if (visibleCandidates.length === 0) lines.push(`\x1b[K${chalk.yellow('  No models match your search.')}`);
     if (below > 0) lines.push(`\x1b[K${chalk.dim(`  ⋮ ${below} more below`)}`);
-    lines.push(`\x1b[K${chalk.dim(`  ${selected.size}/${ordered.length} selected. ↑/↓ move · space toggle · a all · n none · enter confirm.`)}`);
-    if (showHelp) lines.push(`\x1b[K${chalk.dim(`  Extra: j/k · x toggle · q/esc confirm · ? help.`)}`);
+    lines.push(`\x1b[K${chalk.dim(`  ${selected.size}/${ordered.length} selected · ${visibleCandidates.length}/${ordered.length} shown. ↑/↓ move · space toggle · enter confirm.`)}`);
+    if (showHelp) lines.push(`\x1b[K${chalk.dim(`  Extra: type to search · backspace edit · esc clear/confirm · ctrl+a all · ctrl+n none · ? help.`)}`);
     lines.push(`\x1b[K`);
 
+    const contentHeight = lines.length;
+    while (lines.length < lastRenderHeight) lines.push('\x1b[K');
     if (lastRenderHeight > 0) {
       stdout.write(cursorUp(lastRenderHeight));
     }
     stdout.write(lines.join('\n'));
-    lastRenderHeight = lines.length;
+    lastRenderHeight = Math.max(lastRenderHeight, contentHeight);
   }
 }
 
@@ -1968,17 +2133,22 @@ async function readPrompt(lineReader, out$, isTTY, prefix) {
   return r.value;
 }
 
-function renderPicker(out, ordered, selected, prompt, candidates = []) {
+function renderPicker(out, ordered, selected, prompt, candidates = [], { query = '', total = ordered.length } = {}) {
   out.write('\n' + chalk.bold(`-- ${prompt} --`) + '\n');
-  const width = String(ordered.length).length;
+  out.write(query
+    ? `  Search: ${chalk.bold(query)}  ${chalk.dim(`(${ordered.length}/${total} shown)`)}\n`
+    : chalk.dim(`  Search: /query or search query  (${ordered.length}/${total} shown)\n`));
+  const width = String(Math.max(ordered.length, 1)).length;
+  const candidatesById = new Map(candidates.map((candidate) => [candidate.id, candidate]));
   for (let i = 0; i < ordered.length; i++) {
     const id = ordered[i];
     const mark = selected.has(id) ? chalk.green('[x]') : '[ ]';
     const idx = String(i + 1).padStart(width, ' ');
-    const profile = candidates.find((candidate) => candidate.id === id)?.profile;
+    const profile = candidatesById.get(id)?.profile;
     out.write(`  ${mark} ${chalk.dim(idx + '.')} ${id}${chalk.dim(`  [${capabilityLabel(profile)}]`)}\n`);
   }
-  out.write(chalk.dim(`\n  ${selected.size}/${ordered.length} selected. Type numbers to toggle, 'all', 'none', or Enter to confirm.\n`));
+  if (ordered.length === 0) out.write(chalk.yellow('  No models match your search.\n'));
+  out.write(chalk.dim(`\n  ${selected.size}/${total} selected. Numbers target shown rows; '/', 'all', 'none', or Enter to confirm.\n`));
 }
 
 function askLine(rl, prefix) {
@@ -1994,7 +2164,7 @@ function showHelp() {
   bizar models - User-controlled model picker
 
   Usage:
-    bizar models                    Interactive picker (TTY: arrow keys / space / enter; pipe: line-mode)
+    bizar models                    Interactive searchable picker
     bizar models --list             Print candidate IDs, one per line
     bizar models --set a,b,c        Persist the comma-separated IDs to userSelected
     bizar models --clear            Remove userSelected; use the first enabled configured-tier model
@@ -2007,6 +2177,12 @@ function showHelp() {
   configured-tier candidates. Every dispatch receives an explicit model;
   Bizar never inherits an unconfigured provider default.
 
+  Picker search: in a TTY, type a model ID or name to fuzzy-filter, use
+  Backspace to edit, and Escape to clear the query (or confirm when clear).
+  Arrow keys move, Space toggles, Enter confirms, and Ctrl+A/Ctrl+N select
+  all or none. In line mode, use /query or "search query"; / clears search,
+  and numeric choices target the currently shown rows.
+
   Post-confirm status screen (interactive only): after the picker saves a
   selection, every confirmed id is reported on its own row with one of:
 
@@ -2234,12 +2410,9 @@ export async function run(name, args, isHelpRequest, deps = {}) {
   // We do not short-circuit here — the code below falls into the
   // `wantList || isDeprecatedAlias` branch and prints candidate IDs.
 
-  // Phase 2 (10.19.8): the Models.dev catalog fetch used to happen HERE,
-  // before any flag was inspected. That paid the round-trip on every
-  // `--list`, every `--set`, every aborted picker, and every CI run that
-  // never looked at the result. Move the fetch to AFTER picker
-  // confirmation (see the interactive branch below); `--list` and
-  // `bizar model` now skip the fetch entirely.
+  // Catalog metadata is an interactive presentation dependency. `--list`,
+  // `--set`, and the deprecated list alias remain gateway-only and never
+  // contact Models.dev.
   let candidates;
   let modelsDev = { status: 'skipped', matched: 0, total: 0, source: MODELS_DEV_CATALOG_URL, note: 'lazy fetch — --list does not contact models.dev' };
   try {
@@ -2301,37 +2474,38 @@ export async function run(name, args, isHelpRequest, deps = {}) {
 
   const router = loadRouter(routerPath);
   const { models: current } = currentSelection(router);
+  const previousProfiles = router?.userSelected?.profiles || {};
   // 10.19.9 Phase 3: capture a snapshot of userSelected.models BEFORE
   // applyModels overwrites the block, so the post-confirm status screen
   // can classify re-confirmed picks as `preexisting` (⤳) instead of
   // `fresh` (✔). `current` is read once and shared with pickModelsFn;
   // we wrap it in a Set so classifyPickStatus can use `.has(id)`.
   const preExisting = new Set(current);
-  const picked = await pickModelsFn({ candidates, current });
-
-  // Phase 2 (10.19.8): the Models.dev catalog fetch moves HERE — only
-  // AFTER the operator has actually confirmed picks. Per-id enrichment
-  // runs in parallel with bounded concurrency (8 workers) and a per-id
-  // timeout (3000ms); per-id failures fall back to the Phase 1
-  // `_gateway.name` contract.
   const fetchModelsDevCatalogFn = deps.fetchModelsDevCatalog || fetchModelsDevCatalog;
-  // Test callers that inject the base fetch intentionally stay offline; the
-  // production path fetches both Models.dev datasets concurrently.
   const fetchProviderCatalogFn = deps.fetchProviderCatalog
     || (deps.fetchModelsDevCatalog ? undefined : fetchProviderCatalog);
+  // Fetch both catalogs once, concurrently, before rendering. Reuse this map
+  // after confirmation so the picker and persisted settings see identical
+  // metadata and confirmation never causes a second network round trip.
   const enrichment = await enrichPicksByMetadata({
     candidates,
-    pickedIds: picked,
+    pickedIds: candidates.map((candidate) => candidate.id),
     fetchFn: fetchModelsDevCatalogFn,
     providerFetchFn: fetchProviderCatalogFn,
   });
   const profilesMap = enrichment.profiles;
+  const enrichedCandidates = candidates.map((candidate) => {
+    const fresh = profilesMap.get(candidate.id);
+    const cached = previousProfiles[candidate.id];
+    const profile = fresh?.metadata?.source === 'models.dev' ? fresh : (cached || fresh || null);
+    return { ...candidate, profile, contextWindow: profile?.limits?.contextTokens ?? null };
+  });
+  const picked = await pickModelsFn({ candidates: enrichedCandidates, current });
   const modelsDevStatus = enrichment.modelsDev && Object.keys(enrichment.modelsDev).length > 0
-    ? { status: 'ok', source: MODELS_DEV_CATALOG_URL, matched: [...profilesMap.values()].filter((p) => p && p.metadata && p.metadata.source === 'models.dev').length, total: picked.length }
+    ? { status: 'ok', source: MODELS_DEV_CATALOG_URL, matched: picked.filter((id) => profilesMap.get(id)?.metadata?.source === 'models.dev').length, total: picked.length }
     : { status: 'unavailable', source: MODELS_DEV_CATALOG_URL, matched: 0, total: picked.length, note: 'wholesale fetch failed; per-id enrichment degraded to _gateway.name fallback' };
 
   if (picked.length === 0) {
-    const previousProfiles = loadRouter(routerPath)?.userSelected?.profiles || {};
     const block = applyModels({ routerPath, models: [], source: 'live-pick' });
     // Clear Claude Code modelOverrides + modelPicker when the picker is
     // emptied so the session no longer claims to recognise removed IDs.
@@ -2356,7 +2530,13 @@ export async function run(name, args, isHelpRequest, deps = {}) {
   const profiles = {};
   for (const id of picked) {
     tierHints[id] = defaultTierHint(id);
-    const profile = profilesMap.get(id);
+    const fresh = profilesMap.get(id);
+    // A transient catalog miss must not erase a previously good profile.
+    // Gateway fallback data remains useful for new models, but cached
+    // Models.dev/operator facts take precedence when already present.
+    const profile = fresh?.metadata?.source === 'models.dev'
+      ? fresh
+      : (previousProfiles[id] || fresh);
     if (profile) profiles[id] = profile;
   }
   // F-191 / 10.19.2 — stale-ID detection: the picker shows candidates
@@ -2366,7 +2546,6 @@ export async function run(name, args, isHelpRequest, deps = {}) {
   // Code still surfaces the unrecognized_model diagnostic.
   const liveIds = candidates.map((c) => c.id);
   const partition = partitionStalePicks({ liveIds, pickedIds: picked });
-  const previousProfiles = loadRouter(routerPath)?.userSelected?.profiles || {};
   const block = applyModels({ routerPath, models: picked, tierHints, profiles, source: 'live-pick' });
   if (partition.staleIds.length > 0) {
     block.staleIds = partition.staleIds;
@@ -2388,7 +2567,7 @@ export async function run(name, args, isHelpRequest, deps = {}) {
     // equivalent data shape.
     const statusResult = renderPickStatusScreen({
       picked,
-      profiles: profilesMap,
+      profiles,
       preExisting,
       out: { write: () => true },
       isTTY: false,
@@ -2426,7 +2605,7 @@ export async function run(name, args, isHelpRequest, deps = {}) {
     // operator feedback there.
     const statusResult = renderPickStatusScreen({
       picked,
-      profiles: profilesMap,
+      profiles,
       preExisting,
       out: process.stdout,
       isTTY: !!process.stdout.isTTY,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polderlabs/bizar",
-  "version": "10.23.6",
+  "version": "10.23.7",
   "description": "Autonomous, human-in-the-loop multi-agent harness for Claude Code with guarded workflows, typed SDK primitives, and MCP tools.",
   "type": "module",
   "bin": {

package/packages/sdk/dist/version.d.ts

@@ -1,5 +1,5 @@
 /**
  * SDK version constant. Keep synchronized with the workspace package versions.
  */
-export declare const SDK_VERSION: "10.23.6";
+export declare const SDK_VERSION: "10.23.7";
 //# sourceMappingURL=version.d.ts.map

package/packages/sdk/dist/version.js

@@ -1,5 +1,5 @@
 /**
  * SDK version constant. Keep synchronized with the workspace package versions.
  */
-export const SDK_VERSION = "10.23.6";
+export const SDK_VERSION = "10.23.7";
 //# sourceMappingURL=version.js.map

package/packages/sdk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polderlabs/bizar-sdk",
-  "version": "10.23.6",
+  "version": "10.23.7",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",