@bitkyc08/opencodex 2.84.0 → 2.87.0

package/src/claude/intercept/runtime.ts

@@ -1,4 +1,5 @@
 import type { Server } from "bun";
+import { supportsDesktopPicker } from "../desktop-picker-platform";
 import type { OcxConfig } from "../../types";
 import { getConfigDir } from "../../config/paths";
 import type { DesktopPickerController } from "../desktop-picker";
@@ -12,6 +13,7 @@ import { discardPickerCaKey } from "./picker-ca";
 import { preparePersistentPickerAuthority } from "./picker-ca-startup";
 import type { PickerCaStore } from "./picker-ca-store";
 import type { PickerRouteInput } from "./picker-models";
+import { CLAUDE_INTERCEPT_PORT_OFFSET, claudeInterceptEnabled, claudeInterceptProxyPort, claudePickerProxyPort } from "./port-policy";
 import { createPickerRuntime, pickerDesired, type CreatePickerRuntimeOptions, type PickerRuntime } from "./picker-runtime";
 import type { SecurityRunner } from "./picker-trust";
 import { ensureClaudeInterceptProxyToken, readClaudeInterceptProxyToken } from "./proxy-auth";
@@ -28,7 +30,7 @@ import { buildClaudeInterceptEnv, migrateClaudeInterceptSettings } from "./setti
  * proxy. Desktop also hands that proxy to the Claude Code processes it spawns, so the choice is per
  * client: Claude Code (no User-Agent on CONNECT) trusts only the intercept CA and gets the
  * api.anthropic.com intercept and nothing else; the app itself (a browser User-Agent) trusts only
- * the login keychain and never meets the api.anthropic.com intercept, and only its claude.ai
+ * the OS root store and never meets the api.anthropic.com intercept, and only its claude.ai
  * tunnels may be terminated by the picker runtime (src/claude/intercept/picker-runtime.ts).
  */
 
@@ -41,25 +43,7 @@ const PICKER_AUTHORITY_ERROR_CODES = new Set([
   "picker_ca_unsupported_platform",
 ]);
 
-export const CLAUDE_INTERCEPT_PORT_OFFSET = 100;
-
-export function claudeInterceptEnabled(config: Pick<OcxConfig, "claudeCode" | "runtimeRole">): boolean {
-  if (config.runtimeRole === "client") return false;
-  if (config.claudeCode?.enabled === false) return false;
-  return config.claudeCode?.intercept?.enabled !== false;
-}
-
-export function claudeInterceptProxyPort(config: Pick<OcxConfig, "claudeCode">, publicPort: number): number {
-  const configured = config.claudeCode?.intercept?.port;
-  if (typeof configured === "number" && Number.isInteger(configured) && configured >= 1 && configured <= 65535) return configured;
-  return publicPort + CLAUDE_INTERCEPT_PORT_OFFSET;
-}
-
-/** Desktop's egress proxy for picker mode: the port after the intercept proxy (before it at 65535). */
-export function claudePickerProxyPort(config: Pick<OcxConfig, "claudeCode">, publicPort: number): number {
-  const interceptPort = claudeInterceptProxyPort(config, publicPort);
-  return interceptPort < 65535 ? interceptPort + 1 : interceptPort - 1;
-}
+export { CLAUDE_INTERCEPT_PORT_OFFSET, claudeInterceptEnabled, claudeInterceptProxyPort, claudePickerProxyPort } from "./port-policy";
 
 export type ClaudeInterceptOutcome = { ok: true; state: ClaudeInterceptState } | { ok: false; reason: "disabled" | "client_role" | "ephemeral_port" | "port_in_use" | "stopped" | "failed"; port?: number; message?: string };
 
@@ -144,7 +128,7 @@ export interface StartClaudeInterceptOptions<T> {
   createPicker?: (options: CreatePickerRuntimeOptions) => PickerRuntime;
   /** Test seam: bind real CONNECT handlers on kernel-assigned ports without probe-and-release races. */
   startProxy?: typeof startConnectProxy;
-  /** Test seams: the macOS `security` runner and platform for the picker runtime and controller. */
+  /** Test seams: the platform trust runner and platform for the picker runtime and controller. */
   pickerCaStore?: PickerCaStore;
   pickerSecurity?: SecurityRunner;
   pickerPlatform?: NodeJS.Platform;
@@ -167,18 +151,6 @@ export async function startClaudeIntercept<T>(options: StartClaudeInterceptOptio
   const startProxy = options.startProxy ?? startConnectProxy;
   const authToken = ensureClaudeInterceptProxyToken(configDir);
   const leaf = issueLocalInterceptLeaf(ca, CLAUDE_INTERCEPT_HOSTS);
-  // Refresh an env we already own (e.g. a pre-auth proxy URL left by an upgrade) before the
-  // authenticated proxy takes over the port — a plain `ocx start` after an update would
-  // otherwise 407 every CONNECT until the next `ocx ensure` or apply. Only `stale` state is
-  // rewritten, so installs that never applied first-party are untouched.
-  try {
-    const proxyPort = claudeInterceptProxyPort(options.config, options.publicPort);
-    migrateClaudeInterceptSettings(buildClaudeInterceptEnv(proxyPort, claudeInterceptCaCertPath(configDir), authToken));
-  } catch (error) {
-    // A skipped rewrite degrades to the pre-migration behaviour and ensure/apply retries it,
-    // but silence here leaves upgraded clients hitting 407 with no recorded cause.
-    console.warn(`[claude-intercept] settings migration skipped: ${error instanceof Error ? error.message : String(error)}`);
-  }
   const listener = startClaudeInterceptListener<T>({
     leaf,
     dispatch: options.dispatch,
@@ -203,15 +175,25 @@ export async function startClaudeIntercept<T>(options: StartClaudeInterceptOptio
     await listener.stop(true);
     throw new ClaudeInterceptProxyBindError(error, claudeInterceptProxyPort(options.config, options.publicPort));
   }
+  // Publish only a successfully bound endpoint, using the handle's actual port. A failed
+  // fixed-port bind leaves settings untouched; an ephemeral test binder never publishes :0
+  // or a probed port another process can steal. Only stale, owned env blocks are rewritten.
+  try {
+    migrateClaudeInterceptSettings(buildClaudeInterceptEnv(proxy.port, claudeInterceptCaCertPath(configDir), authToken));
+  } catch (error) {
+    // Ensure/apply retries a skipped migration; upgraded clients otherwise keep hitting 407.
+    console.warn(`[claude-intercept] settings migration skipped: ${error instanceof Error ? error.message : String(error)}`);
+  }
   // Widened on purpose: assignments happen in nested awaits the catch below must still see.
   let picker = null as PickerRuntime | null;
   let pickerProxy = null as ConnectProxyHandle | null;
   let controller = null as DesktopPickerController | null;
   let pickerProxyLive = false;
+  let stopped = false;
   let pickerReason: ClaudeInterceptState["pickerReason"] = null;
   let pickerFailurePort: number | undefined;
   try {
-    if (options.loadPickerRoutes && (options.pickerPlatform ?? process.platform) === "darwin") {
+    if (options.loadPickerRoutes && supportsDesktopPicker(options.pickerPlatform ?? process.platform)) {
       // Remove any legacy plaintext key before inspecting or activating picker state.
       discardPickerCaKey(configDir);
       const { inspectDesktopPickerProfile } = await import("../desktop-picker-profile");
@@ -225,11 +207,15 @@ export async function startClaudeIntercept<T>(options: StartClaudeInterceptOptio
       });
       const pickerProfileApplied = pickerProfile.kind === "applied";
       let pickerBlocked = false;
+      let pickerWired = false;
       try {
         const { observeClaudeDesktopMode, resolveClaudeDesktopMode } = await import("../desktop-first-party");
         const fresh = options.config;
         const platform = options.pickerPlatform ?? process.platform;
-        if (pickerProfileApplied || pickerDesired(fresh, resolveClaudeDesktopMode(fresh, observeClaudeDesktopMode(fresh)), platform)) {
+        const pickerRequired = pickerProfileApplied || pickerDesired(fresh, resolveClaudeDesktopMode(fresh, observeClaudeDesktopMode(fresh)), platform);
+        // Preserve macOS's dormant relay; Windows defers binding until enable or profile recovery.
+        pickerWired = platform !== "win32" || pickerRequired;
+        if (pickerRequired) {
           await preparePersistentPickerAuthority({ configDir, store: options.pickerCaStore, security: options.pickerSecurity, platform });
         }
       } catch (error) {
@@ -276,63 +262,76 @@ export async function startClaudeIntercept<T>(options: StartClaudeInterceptOptio
         const runtime = picker;
         const interceptPort = listener.port!;
         const pickerPort = claudePickerProxyPort(options.config, options.publicPort);
-        try {
-          pickerProxy = await startProxy(pickerPort, {
-            interceptPort,
-            // No authToken: Desktop's egressProxyUrl cannot present proxy credentials, so this
-            // listener stays an unauthenticated loopback relay until the profile format can carry
-            // one. The intercept proxy above is the credential-bearing hop.
-            // No host list here: the choice below depends on which client opened the tunnel.
-            interceptHosts: [],
-            selectTunnel: (host, port, request) => {
-              // Desktop hands its pinned egress proxy to the Claude Code processes it spawns, so their
-              // api.anthropic.com traffic arrives here too and gets the same intercept as on the Claude
-              // Code proxy. Those processes trust only the intercept CA, so the picker never terminates
-              // their claude.ai tunnels; only the app's own (browser) CONNECTs reach the picker.
-              if (!isBrowserConnect(request)) {
-                return port === 443 && (CLAUDE_INTERCEPT_HOSTS as readonly string[]).includes(host.toLowerCase())
-                  ? { kind: "intercept", port: interceptPort }
-                  : { kind: "blind" };
-              }
-              return runtime.selectTunnel(host, port);
+        const bindPickerProxy = async (): Promise<void> => {
+          if (stopped || pickerProxyLive) return;
+          try {
+            pickerProxy = await startProxy(pickerPort, {
+              interceptPort,
+              // No authToken: Desktop's egressProxyUrl cannot present proxy credentials, so this
+              // listener stays an unauthenticated loopback relay until the profile format can carry
+              // one. The intercept proxy above is the credential-bearing hop.
+              // No host list here: the choice below depends on which client opened the tunnel.
+              interceptHosts: [],
+              selectTunnel: (host, port, request) => {
+                // Desktop hands its pinned egress proxy to the Claude Code processes it spawns, so their
+                // api.anthropic.com traffic arrives here too and gets the same intercept as on the Claude
+                // Code proxy. Those processes trust only the intercept CA, so the picker never terminates
+                // their claude.ai tunnels; only the app's own (browser) CONNECTs reach the picker.
+                if (!isBrowserConnect(request)) {
+                  return port === 443 && (CLAUDE_INTERCEPT_HOSTS as readonly string[]).includes(host.toLowerCase())
+                    ? { kind: "intercept", port: interceptPort }
+                    : { kind: "blind" };
+                }
+                return runtime.selectTunnel(host, port);
+              },
+            });
+            if (stopped) { await pickerProxy.close(); return; }
+            pickerProxyLive = true;
+            pickerReason = null;
+            pickerFailurePort = undefined;
+          } catch (error) {
+            // Picker mode is optional: a busy port leaves the intercept pair running without it.
+            // The selected profile row survives; a dormant enable can retry after the port is free.
+            pickerReason = error && typeof error === "object" && "code" in error && error.code === "EADDRINUSE" ? "port_in_use" : "failed";
+            if (pickerReason === "port_in_use") pickerFailurePort = pickerPort;
+            console.warn(`⚠ Claude Desktop picker proxy could not start: ${error instanceof Error ? error.message : String(error)}`);
+            throw error;
+          }
+        };
+        if (pickerWired) {
+          try { await bindPickerProxy(); }
+          catch { await runtime.stop(); picker = null; }
+        }
+        if (picker) {
+          // Dynamic: the controller reaches desktop-first-party, which imports this module.
+          const [{ createDesktopPickerController }, { loadConfig }, persistPreference] = await Promise.all([
+            import("../desktop-picker"),
+            import("../../config"),
+            createPickerPreferenceWriter(options.config),
+          ]);
+          controller = createDesktopPickerController({
+            runtime: picker,
+            readConfig: loadConfig,
+            persistPreference,
+            proxyPort: () => (pickerProxyLive ? pickerProxy?.port ?? null : null),
+            ensureProxy: async () => {
+              await bindPickerProxy();
+              if (!pickerProxyLive) return;
+              await runtime.start();
+              if (!stopped && activeController === controller) activePicker = runtime;
             },
+            configDir,
+            persistentAuthority: { store: options.pickerCaStore },
+            ...(options.pickerSecurity ? { security: options.pickerSecurity } : {}),
+            ...(options.pickerPlatform ? { platform: options.pickerPlatform } : {}),
           });
-          pickerProxyLive = true;
-        } catch (error) {
-          // Picker mode is optional: a busy port leaves the intercept pair running without it.
-          // The selected profile row survives, so the next startup retries the restore once the
-          // port is free again.
-          pickerReason = error && typeof error === "object" && "code" in error && error.code === "EADDRINUSE" ? "port_in_use" : "failed";
-          if (pickerReason === "port_in_use") pickerFailurePort = pickerPort;
-          console.warn(`⚠ Claude Desktop picker proxy could not start: ${error instanceof Error ? error.message : String(error)}`);
-          await runtime.stop();
-          picker = null;
-        }
-      }
-      if (picker) {
-        // Dynamic: the controller reaches desktop-first-party, which imports this module.
-        const [{ createDesktopPickerController }, { loadConfig }, persistPreference] = await Promise.all([
-          import("../desktop-picker"),
-          import("../../config"),
-          createPickerPreferenceWriter(options.config),
-        ]);
-        const boundProxy = pickerProxy;
-        controller = createDesktopPickerController({
-          runtime: picker,
-          readConfig: loadConfig,
-          persistPreference,
-          proxyPort: () => (pickerProxyLive && boundProxy ? boundProxy.port : null),
-          configDir,
-          persistentAuthority: { store: options.pickerCaStore },
-          ...(options.pickerSecurity ? { security: options.pickerSecurity } : {}),
-          ...(options.pickerPlatform ? { platform: options.pickerPlatform } : {}),
-        });
-        await picker.start();
-        // Restore inspects the retained identity without installing trust. Explicit enable/trust
-        // owns consent when trust was revoked or legacy migration introduced a new authority.
-        if (pickerProfileApplied && controller) {
-          void controller.enable({ persist: false, context: "server", allowTrustPrompt: false })
-            .catch(error => console.warn(`⚠ Claude Desktop picker restore failed: ${error instanceof Error ? error.message : String(error)}`));
+          if (pickerWired) await picker.start();
+          // Restore inspects the retained identity without installing trust. Explicit enable/trust
+          // owns consent when trust was revoked or legacy migration introduced a new authority.
+          if (pickerProfileApplied && controller) {
+            void controller.enable({ persist: false, context: "server", allowTrustPrompt: false })
+              .catch(error => console.warn(`⚠ Claude Desktop picker restore failed: ${error instanceof Error ? error.message : String(error)}`));
+          }
         }
       }
     }
@@ -348,21 +347,25 @@ export async function startClaudeIntercept<T>(options: StartClaudeInterceptOptio
     throw error;
   }
   const state: ClaudeInterceptState = {
-    pickerReason,
-    pickerFailurePort,
+    get pickerReason() { return pickerReason; },
+    get pickerFailurePort() { return pickerFailurePort; },
     proxyPort: proxy.port,
     caCertPath: claudeInterceptCaCertPath(configDir),
-    pickerProxyPort: pickerProxy?.port ?? null,
+    get pickerProxyPort() { return pickerProxyLive ? pickerProxy?.port ?? null : null; },
   };
   activeState = state;
-  activePicker = picker;
+  activePicker = pickerProxyLive ? picker : null;
   activeController = controller;
   const ownPicker = picker;
   const ownController = controller;
   return {
     ...state,
+    get pickerProxyPort() { return state.pickerProxyPort; },
+    get pickerReason() { return state.pickerReason; },
+    get pickerFailurePort() { return state.pickerFailurePort; },
     listener,
     stop: async () => {
+      stopped = true;
       if (activeState === state) activeState = null;
       if (activePicker === ownPicker) activePicker = null;
       if (activeController === ownController) activeController = null;

package/src/claude/model-default-settings.ts

@@ -0,0 +1,154 @@
+import { createHash, randomUUID } from "node:crypto";
+import { linkSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, renameSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { atomicWriteFileNoFollow } from "../config/atomic-write";
+import { hardenSecretDir, hardenSecretPath } from "../lib/windows-secret-acl";
+import { assertNotRealClaudeConfigUnderTest } from "../lib/test-home-guard";
+import { claudeConfigDir } from "./auth-detect";
+import { claudeTierDisplayName, type ClaudeTierModels } from "./context-windows";
+
+const tiers = ["opus", "sonnet", "haiku", "fable"] as const;
+
+function readSettings(path: string): { raw: string; exists: boolean; doc: Record<string, unknown>; env: Record<string, unknown> } {
+  let raw = "";
+  let exists = false;
+  try {
+    const stat = lstatSync(path);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 1024 * 1024) throw new Error("settings_unreadable");
+    raw = readFileSync(path, "utf8");
+    exists = true;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw new Error("settings_unreadable");
+  }
+  let doc: Record<string, unknown>;
+  try {
+    const parsed: unknown = exists ? JSON.parse(raw) : {};
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error();
+    doc = parsed as Record<string, unknown>;
+    if (doc.env !== undefined && (!doc.env || typeof doc.env !== "object" || Array.isArray(doc.env))) throw new Error();
+  } catch { throw new Error("settings_unreadable"); }
+  return { raw, exists, doc, env: (doc.env ?? {}) as Record<string, unknown> };
+}
+
+function snapshotFingerprint(current: ReturnType<typeof readSettings>, models: ClaudeTierModels | undefined) {
+  const target = selectedEnv(models, current.env);
+  return createHash("sha256").update(JSON.stringify([current.exists, current.raw, target])).digest("hex");
+}
+
+/** Test seams for edits at publication boundaries; never configured through the API. */
+export interface ModelDefaultWriteHooks {
+  beforeCapture?: () => void;
+  beforePublish?: () => void;
+}
+
+export class ModelDefaultsRecoveryError extends Error {
+  constructor(readonly backupPath: string, options?: ErrorOptions) {
+    super("settings_recovery_required", options);
+  }
+}
+
+/** Unset tiers stay untouched; only a label matching its current alias is managed. */
+function selectedEnv(models: ClaudeTierModels | undefined, current: Record<string, unknown>): Record<string, string | null> {
+  const env: Record<string, string | null> = {};
+  for (const tier of tiers) {
+    const slot = `ANTHROPIC_DEFAULT_${tier.toUpperCase()}_MODEL`;
+    const name = `${slot}_NAME`;
+    const value = models?.[tier]?.trim();
+    if (!value) continue;
+    env[slot] = value;
+    const previous = typeof current[slot] === "string" ? claudeTierDisplayName(current[slot]) : undefined;
+    const managed = previous !== undefined && current[name] === previous;
+    // Custom (including empty/non-string) labels are user-owned. Exact pairing
+    // follows the launcher label convention; the name alone proves no ownership.
+    if (!Object.hasOwn(current, name) || managed) {
+      const label = claudeTierDisplayName(value);
+      if (label !== undefined) env[name] = label;
+      else if (managed) env[name] = null;
+    }
+  }
+  return env;
+}
+
+export function previewClaudeModelDefaults(models: ClaudeTierModels | undefined, configDir = claudeConfigDir()) {
+  const path = join(configDir, "settings.json");
+  const current = readSettings(path);
+  const target = selectedEnv(models, current.env);
+  const changes = Object.entries(target).filter(([key, value]) => current.env[key] !== value)
+    // The existing preview wire shape uses an empty replacement for label removal.
+    .map(([key, value]) => ({ key, before: typeof current.env[key] === "string" ? current.env[key] as string : null, after: value ?? "" }));
+  const fingerprint = snapshotFingerprint(current, models);
+  return { path, fingerprint, changes };
+}
+
+export function applyClaudeModelDefaults(
+  models: ClaudeTierModels | undefined,
+  fingerprint: string,
+  configDir = claudeConfigDir(),
+  backupDir = join(configDir, "model-default-backups"),
+  hooks: ModelDefaultWriteHooks = {},
+) {
+  const preview = previewClaudeModelDefaults(models, configDir);
+  if (preview.fingerprint !== fingerprint) throw new Error("settings_changed");
+  if (!preview.changes.length) return { changed: false, path: preview.path };
+  assertNotRealClaudeConfigUnderTest(configDir, preview.path);
+  const current = readSettings(preview.path);
+  const check = snapshotFingerprint(current, models);
+  if (check !== fingerprint) throw new Error("settings_changed");
+  mkdirSync(configDir, { recursive: true });
+  mkdirSync(backupDir, { recursive: true, mode: 0o700 });
+  const recoveryDir = mkdtempSync(join(backupDir, "apply-"));
+  if (process.platform === "win32") hardenSecretDir(recoveryDir, { required: true });
+  const backupPath = join(recoveryDir, "settings.json");
+  const staged = join(configDir, `.model-defaults-${randomUUID()}.tmp`);
+  let captured = false;
+  let published = false;
+  try {
+    const env = { ...current.env };
+    for (const [key, value] of Object.entries(selectedEnv(models, current.env))) {
+      if (value === null) delete env[key];
+      else env[key] = value;
+    }
+    current.doc.env = env;
+    atomicWriteFileNoFollow(staged, `${JSON.stringify(current.doc, null, 2)}\n`);
+    // Verify same-volume exclusive publication before moving the shared file.
+    const probe = join(recoveryDir, "link-probe");
+    linkSync(staged, probe);
+    unlinkSync(probe);
+    hooks.beforeCapture?.();
+    if (current.exists) {
+      // Move the actual destination, not a stale in-memory copy. A same-filesystem
+      // move captures late edits; cross-device failures leave the original alone.
+      try { renameSync(preview.path, backupPath); } catch (error) {
+        if ((error as NodeJS.ErrnoException).code === "ENOENT") throw new Error("settings_changed");
+        throw error;
+      }
+      captured = true;
+      const capturedEntry = lstatSync(backupPath);
+      if (!capturedEntry.isFile() || capturedEntry.isSymbolicLink()) throw new Error("settings_changed");
+      if (process.platform === "win32") hardenSecretPath(backupPath, { required: true });
+      if (snapshotFingerprint(readSettings(backupPath), models) !== fingerprint) throw new Error("settings_changed");
+    }
+    hooks.beforePublish?.();
+    // A hard-link publish is exclusive on POSIX and Windows: never replace a
+    // document created by another writer during the brief move-aside interval.
+    try { linkSync(staged, preview.path); } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "EEXIST") throw new Error("settings_changed");
+      throw error;
+    }
+    published = true;
+    return { changed: true, path: preview.path, ...(captured ? { backupPath } : {}) };
+  } catch (error) {
+    if (captured && !published) {
+      try { linkSync(backupPath, preview.path); } catch (restoreError) {
+        // A newer destination wins. Retain the captured document privately;
+        // never delete the winner or overwrite it as an automatic rollback.
+        throw new ModelDefaultsRecoveryError(backupPath, { cause: restoreError });
+      }
+    }
+    throw error;
+  } finally {
+    // The private stage is also present at the destination after successful
+    // linking; cleanup failure must not turn a committed apply into failure.
+    try { unlinkSync(staged); } catch { /* private residue, no shared-file cleanup */ }
+  }
+}

package/src/claude/model-info.ts

@@ -103,19 +103,19 @@ function modelInfo(id: string, displayName: string, ladder: readonly string[], i
 
 /**
  * Which id family the discovery list carries (devlog 050): Claude Code (CLI)
- * gets readable `claude-ocx-*` ids; Claude Desktop keeps the hashed
- * `claude-opus-4-8-<code>` family its 3P config was written with. Both families
+ * gets readable `ocx-claude-*` ids; Claude Desktop keeps its profile's
+ * `claude-fable-5-p<code>` ids (legacy no-profile callers use hash aliases). Both families
  * decode in resolveInboundModel regardless of the style served here.
  */
 export type AnthropicIdStyle = "desktop3p" | "readable";
 
-/** Build the full anthropic-flavor discovery list (ids are Desktop 3P aliases). */
+/** Build discovery rows; a Desktop resolver can return undefined to withhold an unbound ID. */
 export function buildAnthropicModelInfos(
   nativeSlugs: readonly string[],
   routedModels: readonly CatalogModel[],
   auto: AutoContextMode = AUTO_CONTEXT_OFF,
   idStyle: AnthropicIdStyle = "desktop3p",
-  aliasForRoute: (provider: string, modelId: string) => string = desktop3pAlias,
+  aliasForRoute: (provider: string, modelId: string) => string | undefined = desktop3pAlias,
   nativeContextCap?: NativeContextLimitsInput,
   fastMode?: boolean,
   // Presence is the feature gate: the caller passes undefined when `fastRows` is off, so a
@@ -144,7 +144,7 @@ export function buildAnthropicModelInfos(
         ? claudeCodeAlias(m.provider, listed)
         : aliasForRoute(m.provider, m.id);
     }),
-  ]);
+  ].filter((id): id is string => typeof id === "string" && id.length > 0));
   // [1m] picker variant (devlog 260712 B1; widened in devlog/_plan/261009_claude_1m_default/020):
   // Claude Code accounts exactly 1M for ids carrying the marker (2.1.207 binary: /\[1m\]/i -> 1e6,
   // compaction preserved). A discovery client may lack CLAUDE_CODE_AUTO_COMPACT_WINDOW, so the
@@ -201,7 +201,7 @@ export function buildAnthropicModelInfos(
   };
   for (const slug of nativeSlugs) {
     const id = idStyle === "readable" ? claudeCodeNativeAlias(slug) : aliasForRoute("native", slug);
-    if (seen.has(id)) continue;
+    if (!id || seen.has(id)) continue;
     seen.add(id);
     const nativeWindow = nativeOpenAiContextWindow(slug, nativeContextCap);
     const nativeMaxInput = nativeOpenAiMaxInputTokens(slug, nativeContextCap);
@@ -228,7 +228,7 @@ export function buildAnthropicModelInfos(
     const id = idStyle === "readable"
       ? claudeCodeAlias(m.provider, listedModelId)
       : aliasForRoute(m.provider, m.id);
-    if (seen.has(id)) continue;
+    if (!id || seen.has(id)) continue;
     seen.add(id);
     const groupStart = out.length;
     const ladder = Array.isArray(m.reasoningEfforts) ? m.reasoningEfforts : [];