@bitkyc08/opencodex 2.64.0-preview.20260923 → 2.65.0-preview.20260925

package/src/claude/alias.ts

@@ -1,25 +1,26 @@
 /**
  * Gateway model-discovery aliases (devlog/260711_claude_inbound/020, 003 G1-G6).
  *
- * Claude Code's /model picker only lists discovery entries whose id literally
- * begins with `claude` or `anthropic`, so routed models are exposed as
- * `claude-ocx-<provider>--<model>` with an honest display_name. Aliases must be
- * deterministic, reversible, and STABLE across releases (picker selections
- * persist to Claude Code's settings.json `model` field).
+ * Claude Code's /model picker accepts discovery ids containing `claude` or
+ * `anthropic`. New routed models are exposed as `ocx-claude-<provider>--<model>`
+ * with an honest display_name. The id must contain `claude` so the picker keeps
+ * it, but must not START with `claude-`: Claude Code 2.1.278 treats an
+ * unrecognized `claude-` id as its own model and ignores
+ * CLAUDE_CODE_MAX_CONTEXT_TOKENS unless DISABLE_COMPACT=1. Starting with
+ * `ocx-claude-` keeps the real window and leaves compact enabled.
  *
- * Versioned prefixes:
- *  - `claude-ocx-` (v1) — legacy / plain model ids with no `/` or `~`. Decode
- *    is literal (no escape expansion), so a persisted model id that literally
- *    contained the two-char sequences `~s` / `~t` keeps resolving.
- *  - `claude-ocx2-` (v2) — used whenever the model id needs escape encoding
- *    (`/` → `~s`, `~` → `~t`). Decode expands those escapes. New slash/tilde
- *    models always mint v2 so they cannot collide with v1 literals.
+ * Persisted ids stay decodable:
+ *  - `ocx-claude-` — current plain ids. Decode is literal.
+ *  - `claude-ocx-` (v1) — legacy plain ids. Decode stays literal, so a persisted
+ *    model id that contained the two-char sequences `~s` / `~t` keeps resolving.
+ *  - `claude-ocx2-` (v2) — escape encoding (`/` → `~s`, `~` → `~t`). Decode
+ *    expands those escapes. New slash/tilde models still mint v2.
  *
  * Reversibility rules:
  *  - providers containing `--` or `/` are not aliased (split boundary safety);
  *  - model ids MAY contain `/` or `~` — minted under the v2 prefix with escapes
  *    (e.g. openrouter `anthropic/claude-opus-4-8` →
- *    `claude-ocx2-openrouter--anthropic~sclaude-opus-4-8`);
+ *    `ocx-claude2-openrouter--anthropic~sclaude-opus-4-8`);
  *  - model ids MAY contain `--` (resolve splits on the FIRST `--` only);
  *  - native OpenAI slugs use the pseudo-provider `native` and resolve back to
  *    the bare slug; a real provider named "native" is therefore never aliased.
@@ -27,15 +28,19 @@
 
 import { desktop3pAlias } from "./desktop-3p";
 
-/** Legacy / plain readable prefix (literal model portion on decode). */
+/** Current plain prefix. Contains "claude" but does not start with "claude-". */
+export const CLAUDE_ALIAS_PREFIX_CURRENT = "ocx-claude-";
+/** Current escape-encoded prefix (`~s`/`~t` expanded on decode). */
+export const CLAUDE_ALIAS_PREFIX_CURRENT_V2 = "ocx-claude2-";
+/** Legacy plain prefix. Still decoded; no longer minted. */
 export const CLAUDE_ALIAS_PREFIX_V1 = "claude-ocx-";
-/** Escape-encoded readable prefix (`~s`/`~t` expanded on decode). */
+/** Legacy escape-encoded prefix. Still decoded; no longer minted. */
 export const CLAUDE_ALIAS_PREFIX_V2 = "claude-ocx2-";
 /**
  * Current write prefix for plain (unescaped) model ids.
- * Escape-needing models mint {@link CLAUDE_ALIAS_PREFIX_V2} instead.
+ * Escape-needing models mint {@link CLAUDE_ALIAS_PREFIX_CURRENT_V2} instead.
  */
-export const CLAUDE_ALIAS_PREFIX = CLAUDE_ALIAS_PREFIX_V1;
+export const CLAUDE_ALIAS_PREFIX = CLAUDE_ALIAS_PREFIX_CURRENT;
 
 /** Encoded `/` inside the model portion of a v2 Claude Code alias. */
 const CLAUDE_ALIAS_SLASH_ENC = "~s";
@@ -90,9 +95,42 @@ export function aliasForRoute(provider: string, modelId: string): string | null
   if (!provider || provider.includes("--") || provider.includes("/") || provider === NATIVE_PSEUDO_PROVIDER) return null;
   if (!modelId) return null;
   if (modelNeedsEscapeEncoding(modelId)) {
-    return `${CLAUDE_ALIAS_PREFIX_V2}${provider}--${encodeModelId(modelId)}`;
+    return `${CLAUDE_ALIAS_PREFIX_CURRENT_V2}${provider}--${encodeModelId(modelId)}`;
   }
-  return `${CLAUDE_ALIAS_PREFIX_V1}${provider}--${modelId}`;
+  return `${CLAUDE_ALIAS_PREFIX_CURRENT}${provider}--${modelId}`;
+}
+
+/**
+ * The spelling a release before `ocx-claude-` minted for the same route. Nothing
+ * is minted with it any more; it exists so a selector already saved in Claude
+ * Code's settings.json keeps its context-window lookup (context-windows.ts).
+ */
+function toLegacyAlias(alias: string | null): string | null {
+  if (!alias) return null;
+  if (alias.startsWith(CLAUDE_ALIAS_PREFIX_CURRENT_V2)) return CLAUDE_ALIAS_PREFIX_V2 + alias.slice(CLAUDE_ALIAS_PREFIX_CURRENT_V2.length);
+  if (alias.startsWith(CLAUDE_ALIAS_PREFIX_CURRENT)) return CLAUDE_ALIAS_PREFIX_V1 + alias.slice(CLAUDE_ALIAS_PREFIX_CURRENT.length);
+  return null;
+}
+
+/**
+ * The current spelling of a selector that may still use a legacy prefix. Legacy and
+ * current prefixes decode to the same route (plain stays literal, v2 expands escapes), so
+ * swapping the prefix is safe. Only the prefix changes: a trailing `[1m]` marker survives.
+ */
+export function currentClaudeAliasSpelling(selector: string): string {
+  if (selector.startsWith(CLAUDE_ALIAS_PREFIX_V2)) return CLAUDE_ALIAS_PREFIX_CURRENT_V2 + selector.slice(CLAUDE_ALIAS_PREFIX_V2.length);
+  if (selector.startsWith(CLAUDE_ALIAS_PREFIX_V1)) return CLAUDE_ALIAS_PREFIX_CURRENT + selector.slice(CLAUDE_ALIAS_PREFIX_V1.length);
+  return selector;
+}
+
+/** Legacy `claude-ocx-`/`claude-ocx2-` spelling of {@link aliasForRoute}. */
+export function legacyAliasForRoute(provider: string, modelId: string): string | null {
+  return toLegacyAlias(aliasForRoute(provider, modelId));
+}
+
+/** Legacy `claude-ocx-`/`claude-ocx2-` spelling of {@link aliasForNative}. */
+export function legacyAliasForNative(slug: string): string | null {
+  return toLegacyAlias(aliasForNative(slug));
 }
 
 /** Alias for a native OpenAI slug (bare model id, no provider namespace). */
@@ -100,9 +138,9 @@ export function aliasForNative(slug: string): string | null {
   // Reject "/" — native ids are bare slugs. Literal `~` is fine via v2 + ~t.
   if (!slug || slug.includes("/") || slug.includes("--")) return null;
   if (modelNeedsEscapeEncoding(slug)) {
-    return `${CLAUDE_ALIAS_PREFIX_V2}${NATIVE_PSEUDO_PROVIDER}--${encodeModelId(slug)}`;
+    return `${CLAUDE_ALIAS_PREFIX_CURRENT_V2}${NATIVE_PSEUDO_PROVIDER}--${encodeModelId(slug)}`;
   }
-  return `${CLAUDE_ALIAS_PREFIX_V1}${NATIVE_PSEUDO_PROVIDER}--${slug}`;
+  return `${CLAUDE_ALIAS_PREFIX_CURRENT}${NATIVE_PSEUDO_PROVIDER}--${slug}`;
 }
 
 /**
@@ -110,7 +148,15 @@ export function aliasForNative(slug: string): string | null {
  * routed -> "<provider>/<model>", native -> bare slug. Null when not an alias.
  */
 export function resolveAlias(id: string): string | null {
-  // Check v2 before v1 for clarity (prefixes are disjoint: ocx2 vs ocx-).
+  // Current v2 before legacy v2, then plain prefixes. `ocx-claude2-` and
+  // `claude-ocx2-` are disjoint from their plain siblings.
+  if (id.startsWith(CLAUDE_ALIAS_PREFIX_CURRENT_V2)) {
+    const parts = splitAlias(id, CLAUDE_ALIAS_PREFIX_CURRENT_V2);
+    if (!parts) return null;
+    const model = decodeEscapedModelId(parts.model);
+    if (!model) return null;
+    return parts.provider === NATIVE_PSEUDO_PROVIDER ? model : `${parts.provider}/${model}`;
+  }
   if (id.startsWith(CLAUDE_ALIAS_PREFIX_V2)) {
     const parts = splitAlias(id, CLAUDE_ALIAS_PREFIX_V2);
     if (!parts) return null;
@@ -118,8 +164,9 @@ export function resolveAlias(id: string): string | null {
     if (!model) return null;
     return parts.provider === NATIVE_PSEUDO_PROVIDER ? model : `${parts.provider}/${model}`;
   }
-  if (id.startsWith(CLAUDE_ALIAS_PREFIX_V1)) {
-    const parts = splitAlias(id, CLAUDE_ALIAS_PREFIX_V1);
+  for (const prefix of [CLAUDE_ALIAS_PREFIX_CURRENT, CLAUDE_ALIAS_PREFIX_V1]) {
+    if (!id.startsWith(prefix)) continue;
+    const parts = splitAlias(id, prefix);
     if (!parts) return null;
     // Literal decode — preserves pre-escape aliases whose model id contained
     // the two-char sequences ~s / ~t.
@@ -131,11 +178,11 @@ export function resolveAlias(id: string): string | null {
 /**
  * Claude Code (CLI) surface alias — devlog 050 + audit 051 #2.
  *
- * The readable `claude-ocx*` form when representable; otherwise the desktop-3p
+ * The readable `ocx-claude*` form when representable; otherwise the desktop-3p
  * hash so the model still appears in discovery (collisions follow the same
  * first-wins policy as the desktop registry — audit 051 #1). Real Anthropic
  * models pass through unchanged (they must keep hitting the sk-ant passthrough).
- * Both families keep decoding forever in resolveInboundModel, so ids persisted
+ * Old `claude-ocx*` ids keep decoding forever in resolveInboundModel, so ids persisted
  * in Claude Code's settings.json never break when the surface style changes.
  */
 export function claudeCodeAlias(provider: string, modelId: string): string {

package/src/claude/context-windows.ts

@@ -3,12 +3,13 @@
  * (devlog/260712_cli_context_cache/010 B2, audit R2#1/R3#1/R3#4/R4#3).
  *
  * The map registers EVERY selector form a Claude Code model slot might store —
- * bare native slug, provider/id, desktop3p alias, legacy claude-ocx-* alias —
+ * bare native slug, provider/id, desktop3p alias, current ocx-claude-* alias and
+ * the legacy claude-ocx-* spelling a saved selector may still carry —
  * with first-wins dedupe (mirrors the desktop3p registry collision policy).
  * Values are authoritative context windows only (native override table /
  * adapter-reported CatalogModel.contextWindow); nothing is guessed.
  */
-import { aliasForNative, aliasForRoute } from "./alias";
+import { aliasForNative, aliasForRoute, currentClaudeAliasSpelling, legacyAliasForNative, legacyAliasForRoute } from "./alias";
 import { desktop3pAlias } from "./desktop-3p";
 import { nativeOpenAiContextWindow, type CatalogModel, type NativeContextLimitsInput } from "../codex/catalog";
 
@@ -62,9 +63,12 @@ function inAutoCompactRange(value: number): boolean {
 
 /**
  * Resolve the auto-context mode from claudeCode config. Disabled when the user
- * turned it off OR when the legacy maxContextTokens override is set — that pair
- * (MAX_CONTEXT_TOKENS + DISABLE_COMPACT) takes rule-1 precedence inside the CLI,
- * making both AUTO_COMPACT_WINDOW and [1m] accounting inert.
+ * turned it off OR when maxContextTokens is set. That override injects only
+ * CLAUDE_CODE_MAX_CONTEXT_TOKENS: compact stays enabled (no DISABLE_COMPACT) and
+ * Claude Code compacts against that window for ocx-claude-* ids, so no
+ * CLAUDE_CODE_AUTO_COMPACT_WINDOW is injected beside it and [1m] auto-marking stays
+ * off. maxContextTokens accepts values outside the compact variable's 100k–1M
+ * range, so deriving that variable from it could only produce ignored values.
  *
  * `envOverride` is the raw CLAUDE_CODE_AUTO_COMPACT_WINDOW the USER already
  * exported (user-wins injection keeps it): a valid value drives the marking
@@ -139,6 +143,7 @@ export function buildClaudeContextWindows(
     put(slug, window);
     put(desktop3pAlias("native", slug), window);
     put(aliasForNative(slug), window);
+    put(legacyAliasForNative(slug), window);
   }
   // Anthropic passthrough guard (audit 021 #3): canonical claude ids ride the
   // subscription passthrough — marking a sub-1M one would strap [1m]/1M-beta onto
@@ -161,6 +166,7 @@ export function buildClaudeContextWindows(
     put(`${m.provider}/${m.id}`, window);
     put(desktop3pAlias(m.provider, m.id), window);
     put(aliasForRoute(m.provider, m.id), window);
+    put(legacyAliasForRoute(m.provider, m.id), window);
     if (bareCounts.get(m.id) === 1) put(m.id, window);
   }
   return out;
@@ -204,8 +210,11 @@ export function effectiveModelEnv(
 ): Record<string, string> {
   const out: Record<string, string> = {};
   const auto = autoOverride ?? resolveAutoContext(claudeCode);
+  // A slot still configured with a legacy claude-ocx selector is emitted in its current
+  // ocx-claude spelling. The route is identical, but Claude Code applies the context window
+  // (and keeps compact) only for ids that do not start with "claude-".
   const set = (name: string, value: string | undefined) => {
-    const marked = withOneMillionMarker(value, windows, auto);
+    const marked = withOneMillionMarker(value === undefined ? undefined : currentClaudeAliasSpelling(value), windows, auto);
     if (marked) out[name] = marked;
   };
   set("ANTHROPIC_MODEL", claudeCode?.model);

package/src/claude/desktop-3p-library.ts

@@ -42,6 +42,8 @@ export interface Desktop3pMetadata {
   [key: string]: unknown;
 }
 
+export const DESKTOP_PICKER_ENTRY_NAME = "opencodex-picker";
+
 export function parseMetadata(path: string): Desktop3pMetadata {
   if (!existsSync(path)) return { entries: [] };
   const parsed = JSON.parse(readFileSync(path, "utf8")) as Partial<Desktop3pMetadata>;
@@ -56,7 +58,7 @@ export function isRecord(value: unknown): value is Record<string, unknown> {
 }
 
 export function isOwnedDesktopEntry(entry: Desktop3pMetadataEntry | undefined): boolean {
-  return entry?.name === "opencodex" || entry?.name === "opencodex-standard";
+  return entry?.name === "opencodex" || entry?.name === "opencodex-standard" || entry?.name === DESKTOP_PICKER_ENTRY_NAME;
 }
 
 /** A gateway row is removable; the selected standard row must always remain. */
@@ -86,4 +88,3 @@ export function readDesktopProfileForeignKeys(path: string): Record<string, unkn
     Object.entries(parsed).filter(([key]) => !OPENCODEX_DESKTOP_PROFILE_KEYS.has(key)),
   );
 }
-

package/src/claude/desktop-3p.ts

@@ -146,7 +146,7 @@ export function legacyDesktop3pAlias(provider: string, modelId: string): string
   return `claude-opus-4-${deriveDesktop3pCode(`${provider}/${modelId}`)}`;
 }
 
-function displayModelId(modelId: string): string {
+export function displayModelId(modelId: string): string {
   return modelId
     // Capability markers like [1m] are not name text: strip the brackets so the label
     // reads "K3 1M", never "K3[1m]".

package/src/claude/desktop-first-party.ts

@@ -3,21 +3,25 @@
  *
  * Desktop has two ways to reach opencodex:
  *
- *   - `first-party` (default): the app keeps its ordinary claude.ai login, Chat tab, connectors
- *     and remote control. Only the Claude Code process it spawns for the Code tab (and that
- *     process's subagents) is redirected, through the `HTTPS_PROXY`/`NODE_EXTRA_CA_CERTS` env
- *     in `~/.claude/settings.json` (src/claude/intercept/settings.ts) and the server's intercept
- *     pair (src/claude/intercept/runtime.ts). Nothing is written under Desktop's config library.
- *   - `gateway`: the historical third-party deployment profile (src/claude/desktop-3p.ts). The
+ *   - `gateway` (default): the third-party deployment profile (src/claude/desktop-3p.ts). The
  *     whole app is switched to a gateway build; picker entries are opencodex aliases.
+ *   - `first-party`: the app keeps its ordinary claude.ai login, Chat tab, connectors and remote
+ *     control. Only the Claude Code process it spawns for the Code tab (and that process's
+ *     subagents) is redirected, through the `HTTPS_PROXY`/`NODE_EXTRA_CA_CERTS` env in
+ *     `~/.claude/settings.json` (src/claude/intercept/settings.ts) and the server's intercept pair
+ *     (src/claude/intercept/runtime.ts). It sends Claude subscription traffic through a local
+ *     interception proxy, so every first-party surface carries the account-risk notice in
+ *     src/claude/desktop-risk.ts.
  *
  * The two are mutually exclusive on disk: applying one removes the other. The mode is persisted
- * in `claudeCode.desktopMode`; installs that predate the field but already carry an applied
- * gateway profile keep `gateway` until they explicitly re-apply, so an update never flips a
- * working Desktop under the operator.
+ * in `claudeCode.desktopMode`. Installs that predate the field keep what they run: a selected
+ * gateway row or a gateway apply marker keeps `gateway`, and first-party env that opencodex wrote
+ * into Claude Code's settings keeps `first-party` (observeClaudeDesktopMode), so moving the default
+ * to gateway never flips a working Desktop under the operator.
  */
 import { getConfigDir } from "../config/paths";
 import type { OcxConfig } from "../types";
+import { inspectDesktop3pConfigLibrary } from "./desktop-3p";
 import { claudeInterceptCaCertPath, ensureLocalInterceptCa } from "./intercept/local-ca";
 import { claudeInterceptEnabled, claudeInterceptProxyPort } from "./intercept/runtime";
 import {
@@ -33,7 +37,7 @@ import {
 
 export const CLAUDE_DESKTOP_MODES = ["first-party", "gateway"] as const;
 export type ClaudeDesktopMode = typeof CLAUDE_DESKTOP_MODES[number];
-export const DEFAULT_CLAUDE_DESKTOP_MODE: ClaudeDesktopMode = "first-party";
+export const DEFAULT_CLAUDE_DESKTOP_MODE: ClaudeDesktopMode = "gateway";
 
 export function isClaudeDesktopMode(value: unknown): value is ClaudeDesktopMode {
   return typeof value === "string" && (CLAUDE_DESKTOP_MODES as readonly string[]).includes(value);
@@ -41,15 +45,30 @@ export function isClaudeDesktopMode(value: unknown): value is ClaudeDesktopMode
 
 type DesktopModeConfig = Pick<OcxConfig, "claudeCode">;
 
+/** What the resolver may learn from disk. Only rows and settings opencodex owns count. */
+export interface ClaudeDesktopModeObservation {
+  /** Desktop's selected config-library row is our gateway (current or drifted). */
+  ownedGatewaySelected?: boolean;
+  /** Claude Code's settings carry first-party env that opencodex wrote (applied or stale). */
+  ownedFirstPartySettings?: boolean;
+}
+
 /**
- * Effective Desktop mode. An explicit `claudeCode.desktopMode` wins; otherwise a persisted
- * gateway apply marker (`desktopProfile.appliedFingerprint`) means a pre-existing gateway
- * install and keeps `gateway`; everything else is the first-party default.
+ * Effective Desktop mode. An explicit `claudeCode.desktopMode` wins. Without one, what is on disk
+ * decides for installs that predate the field: a selected owned gateway row or a persisted gateway
+ * apply marker keeps `gateway`, owned first-party settings keep `first-party`. Everything else is
+ * the gateway default. Pure: callers that decide an apply or a write pass
+ * `observeClaudeDesktopMode(config)`.
  */
-export function resolveClaudeDesktopMode(config: DesktopModeConfig): ClaudeDesktopMode {
+export function resolveClaudeDesktopMode(
+  config: DesktopModeConfig,
+  observed: ClaudeDesktopModeObservation = {},
+): ClaudeDesktopMode {
   const explicit = config.claudeCode?.desktopMode;
   if (isClaudeDesktopMode(explicit)) return explicit;
+  if (observed.ownedGatewaySelected) return "gateway";
   if (config.claudeCode?.desktopProfile?.appliedFingerprint) return "gateway";
+  if (observed.ownedFirstPartySettings) return "first-party";
   return DEFAULT_CLAUDE_DESKTOP_MODE;
 }
 
@@ -78,18 +97,16 @@ export function recordClaudeDesktopMode(
 }
 
 /**
- * Mode an *apply* without an explicit choice should use. The first-party default only holds
- * where the intercept proxy actually runs; with it disabled (or on a client role) an implied
- * first-party apply would point Claude Code at a proxy that never starts, so fall back to the
- * gateway profile. An explicit `desktopMode: "first-party"` is still honoured (and refused
- * later with `intercept_disabled`, which names the fix).
+ * Mode an *apply* without an explicit choice should use. With gateway as the default, first-party
+ * only comes from an explicit choice or an observed first-party install; both are honoured even
+ * when the intercept is disabled, and the apply is then refused with `intercept_disabled`, which
+ * names the fix, instead of silently replacing the operator's mode.
  */
 export function resolveClaudeDesktopApplyMode(
   config: Pick<OcxConfig, "claudeCode" | "runtimeRole">,
+  observed: ClaudeDesktopModeObservation = {},
 ): ClaudeDesktopMode {
-  const resolved = resolveClaudeDesktopMode(config);
-  if (resolved === "gateway" || isClaudeDesktopMode(config.claudeCode?.desktopMode)) return resolved;
-  return claudeInterceptEnabled(config) ? "first-party" : "gateway";
+  return resolveClaudeDesktopMode(config, observed);
 }
 
 export interface DesktopFirstPartyTarget {
@@ -151,6 +168,30 @@ export function inspectDesktopFirstParty(
   };
 }
 
+/**
+ * Observe what Desktop runs today for the resolver. Never throws: an unreadable library or
+ * settings file is no evidence, and a foreign proxy env is never mistaken for ours.
+ */
+export function observeClaudeDesktopMode(
+  config: Pick<OcxConfig, "claudeCode" | "port" | "runtimeRole">,
+  options: DesktopFirstPartyOptions = {},
+): ClaudeDesktopModeObservation {
+  const observed: ClaudeDesktopModeObservation = {};
+  try {
+    const library = inspectDesktop3pConfigLibrary({ appliedFingerprint: config.claudeCode?.desktopProfile?.appliedFingerprint ?? null });
+    observed.ownedGatewaySelected = library.kind === "gateway_ours" || library.kind === "gateway_drifted";
+  } catch { // no-excuse-ok: catch -- an unreadable library is no gateway evidence.
+    observed.ownedGatewaySelected = false;
+  }
+  try {
+    const kind = inspectDesktopFirstParty(config, options).settings.kind;
+    observed.ownedFirstPartySettings = kind === "applied" || kind === "stale";
+  } catch { // no-excuse-ok: catch -- unreadable settings are no first-party evidence.
+    observed.ownedFirstPartySettings = false;
+  }
+  return observed;
+}
+
 export type DesktopFirstPartyApplyResult =
   | { ok: true; changed: boolean; path: string; env: ClaudeInterceptEnv; proxyPort: number }
   | { ok: false; reason: "intercept_disabled" | "ca_unavailable" | "unreadable" | "foreign_env"; path: string };