@bitkyc08/opencodex 2.81.0 → 2.82.0

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

@@ -10,9 +10,10 @@ import {
 } from "./desktop-3p-library";
 export { resolveDesktop3pConfigLibraryPath, type Desktop3pConfigLibraryOptions } from "./desktop-3p-library";
 import { createHash, randomUUID } from "node:crypto";
-import { copyFileSync, existsSync, mkdirSync, readFileSync, unlinkSync } from "node:fs";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, lstatSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { atomicWriteFile, readConfigDiagnostics, withConfigMutationLockSync } from "../config";
+import { atomicWriteFileNoFollow } from "../config/atomic-write";
 import { claudeDesktopIntegrationEnabled } from "../codex/desired-state";
 import type { OcxClaudeDesktopProfile } from "../types";
 import {
@@ -24,6 +25,7 @@ import {
 import { nativeOpenAiContextWindow, type NativeContextLimitsInput } from "../codex/catalog";
 import { localAdmissionToken, localInferenceDestination } from "../lib/local-destinations";
 import { assertDesktop3pModelsValid } from "./desktop-3p-guard";
+import { claudeSurfaceSupportsOneMillion, ONE_MILLION } from "./long-context";
 
 export interface Desktop3pModelEntry {
   name: string;
@@ -55,12 +57,12 @@ export interface Desktop3pRoutedModel {
 }
 
 /**
- * 1M-context eligibility, shared with the Desktop DTO so the dashboard's 1M chip can
- * never disagree with what the writer emits. The DTO imports this from here — keeping
- * the constant in this module avoids a cycle, since shared.ts already reads
- * claude/desktop-profile.
+ * The genuine-1M threshold real Anthropic rows still need. Every other row follows the
+ * long-window rule; the writer, the profile renderer and the dashboard DTO all decide through
+ * `claudeSurfaceSupportsOneMillion` (long-context.ts), so the 1M chip cannot disagree with the
+ * written config.
  */
-export const DESKTOP_SUPPORTS_1M_THRESHOLD = 1_000_000;
+export const DESKTOP_SUPPORTS_1M_THRESHOLD = ONE_MILLION;
 
 /** CLI arg parsing for `ocx claude desktop` mode flags (mutually exclusive). */
 export function parseDesktop3pModeArgs(flags: string[]): { mode: Desktop3pConfigMode } | { error: string } {
@@ -251,7 +253,7 @@ function collectDesktop3pModels(
   for (const { provider, id, contextWindow } of candidates) {
     const route = `${provider}/${id}`;
     const alias = desktop3pAlias(provider, id);
-    const supports1m = typeof contextWindow === "number" && contextWindow >= DESKTOP_SUPPORTS_1M_THRESHOLD
+    const supports1m = claudeSurfaceSupportsOneMillion(provider, id, contextWindow)
       ? { supports1m: true as const }
       : {};
     if (alias === id) {
@@ -317,16 +319,30 @@ export function buildDesktop3pRegistry(
 }
 
 /** Generate Claude Desktop 3P model entries from the proxy's available models. */
+export interface Desktop3pModelOptions {
+  /**
+   * false under claudeCode.contextAccounting "200k": a long-window model stays selectable at 1M
+   * (`supports1m`) but no longer defaults to it (`prefer1m` dropped).
+   */
+  preferOneMillion?: boolean;
+}
+
 export function generateDesktop3pModels(
   nativeSlugs: string[],
   routedModels: Array<Desktop3pRoutedModel>,
   profile?: OcxClaudeDesktopProfile,
   nativeContextCap?: NativeContextLimitsInput,
+  options: Desktop3pModelOptions = {},
 ): Desktop3pModelEntry[] {
   const { models, registry, realAnthropicIds } = collectDesktop3pModels(nativeSlugs, routedModels, profile, nativeContextCap);
   desktop3pRegistry = registry;
   desktop3pRealAnthropicIds = realAnthropicIds;
-  return models;
+  return options.preferOneMillion === false ? models.map(({ prefer1m: _prefer1m, ...model }) => model) : models;
+}
+
+/** The Desktop model options a config asks for (one place, so writer and export agree). */
+export function desktop3pModelOptions(claudeCode: { contextAccounting?: string } | undefined): Desktop3pModelOptions {
+  return { preferOneMillion: claudeCode?.contextAccounting !== "200k" };
 }
 
 /** Resolve an alias using the most recently generated Desktop model registry. */
@@ -382,6 +398,7 @@ export function generateDesktop3pConfig(
   mode: Desktop3pConfigMode = "static",
   profile?: OcxClaudeDesktopProfile,
   nativeContextCap?: NativeContextLimitsInput,
+  options: Desktop3pModelOptions = {},
 ): object {
   const base = {
     inferenceProvider: "gateway",
@@ -398,7 +415,7 @@ export function generateDesktop3pConfig(
     ...base,
     modelDiscoveryEnabled: mode === "hybrid",
     inferenceModels: (() => {
-      const models = generateDesktop3pModels(nativeSlugs, routedModels, profile, nativeContextCap);
+      const models = generateDesktop3pModels(nativeSlugs, routedModels, profile, nativeContextCap, options);
       // Fail loud at the write boundary rather than ship a config Desktop rejects:
       // the output counterpart of the request-path guards.
       assertDesktop3pModelsValid(models);
@@ -662,6 +679,7 @@ export function writeDesktop3pConfig(
   profile?: OcxClaudeDesktopProfile,
   nativeContextCap?: NativeContextLimitsInput,
   lifecycleLockDeps?: ClientLifecycleLockDeps,
+  refreshOnly?: { appliedFingerprint: string; admit: () => boolean },
 ): { written: boolean; path: string; reason?: string; fingerprint?: string } {
   try {
     return withClientLifecycleSync(() => withConfigMutationLockSync(() => {
@@ -674,9 +692,29 @@ export function writeDesktop3pConfig(
       if (!claudeDesktopIntegrationEnabled(latest.config)) {
         return { written: false, path: resolveDesktop3pConfigLibraryPath(), reason: "desired_state_changed" };
       }
+      if (refreshOnly && !desktopRefreshPathsSafe(resolveDesktop3pConfigLibraryPath())) {
+        return { written: false, path: resolveDesktop3pConfigLibraryPath(), reason: "desktop_refresh_only_skipped" };
+      }
       if (connection.kind === "connected" || inspectRemoteDesktopCleanup().kind !== "absent") {
         return { written: false, path: resolveDesktop3pConfigLibraryPath(), reason: "desktop_remote_store_active" };
       }
+      let requiredId: string | undefined;
+      if (refreshOnly) {
+        const refused = { written: false, path: resolveDesktop3pConfigLibraryPath(), reason: "desktop_refresh_only_skipped" };
+        // Ownership and bytes must still match under L→C; discovery outside these locks is not authority.
+        if (!refreshOnly.admit() || latest.config.claudeCode?.desktopProfile?.appliedFingerprint !== refreshOnly.appliedFingerprint) return refused;
+        const inspected = inspectDesktop3pConfigLibrary({ appliedFingerprint: refreshOnly.appliedFingerprint });
+        if (inspected.kind !== "gateway_ours" || !inspected.appliedId || !inspected.selectedProfilePath) return refused;
+        if (!desktopRefreshPathsSafe(inspected.libraryPath, inspected.selectedProfilePath)) return refused;
+        const metadata = parseMetadata(join(inspected.libraryPath, "_meta.json"));
+        if (!isOwnedDesktopGatewayEntry(metadata.entries.find(entry => entry.id === inspected.appliedId))) return refused;
+        try {
+          const selected = JSON.parse(readFileSync(inspected.selectedProfilePath, "utf8")) as Record<string, unknown>;
+          mode = selected.modelDiscoveryEnabled !== true ? "static"
+            : Array.isArray(selected.inferenceModels) ? "hybrid" : "discovery";
+        } catch { return refused; }
+        requiredId = inspected.appliedId;
+      }
       // Claude Desktop runs on this machine, so it dials the unauthenticated loopback listener
       // when one is enabled — on such a hub that is the only credential-free local socket
       // (#4236) — and otherwise the bind address, which answers but demands data-plane
@@ -700,8 +738,9 @@ export function writeDesktop3pConfig(
         );
       }
       return writeDesktop3pConfigWithGenerator(() => (
-        generateDesktop3pConfig(destination.origin, nativeSlugs, routedModels, gatewayKey, mode, profile, nativeContextCap)
-      ));
+        generateDesktop3pConfig(destination.origin, nativeSlugs, routedModels, gatewayKey, mode, profile, nativeContextCap,
+          desktop3pModelOptions(latest.config.claudeCode))
+      ), requiredId && refreshOnly ? { requiredId, expectedFingerprint: refreshOnly.appliedFingerprint, admit: refreshOnly.admit } : undefined);
     }), lifecycleLockDeps);
   } catch { return { written: false, path: resolveDesktop3pConfigLibraryPath(), reason: "desktop_lifecycle_busy_or_unsafe" }; }
 }
@@ -734,17 +773,38 @@ export function writeRemoteDesktop3pConfig(options: {
   } catch { return { written: false, path: "", reason: "desktop_lifecycle_busy_or_unsafe" }; }
 }
 
+/** Refresh-only writes never follow links, including a dangling backup link. */
+function desktopRefreshPathsSafe(libraryPath: string, configPath?: string): boolean {
+  try {
+    if (!lstatSync(libraryPath).isDirectory() || !lstatSync(join(libraryPath, "_meta.json")).isFile()) return false;
+    if (configPath) {
+      if (!lstatSync(configPath).isFile()) return false;
+      try { if (lstatSync(`${configPath}.bak`).isSymbolicLink()) return false; }
+      catch (error) { if ((error as NodeJS.ErrnoException).code !== "ENOENT") return false; }
+    }
+    return true;
+  } catch { return false; }
+}
+
 function writeDesktop3pConfigWithGenerator(
   generate: () => object,
+  refreshOnly?: { requiredId: string; expectedFingerprint: string; admit: () => boolean },
 ): { written: boolean; path: string; reason?: string; fingerprint?: string } {
   const libraryPath = resolveDesktop3pConfigLibraryPath();
   const metadataPath = join(libraryPath, "_meta.json");
   let configPath = libraryPath;
 
   try {
-    mkdirSync(libraryPath, { recursive: true, mode: 0o700 });
+    if (refreshOnly && !desktopRefreshPathsSafe(libraryPath)) {
+      return { written: false, path: libraryPath, reason: "desktop_refresh_only_skipped" };
+    }
+    if (!refreshOnly) mkdirSync(libraryPath, { recursive: true, mode: 0o700 });
     const metadata = parseMetadata(metadataPath);
     const selected = metadata.entries.find(entry => entry?.id === metadata.appliedId && isOwnedDesktopGatewayEntry(entry));
+    // A refresh may reuse only the applied entry; fallback allocation would silently enroll again.
+    if (refreshOnly && selected?.id !== refreshOnly.requiredId) {
+      return { written: false, path: libraryPath, reason: "desktop_refresh_only_skipped" };
+    }
     const existing = selected ?? metadata.entries.find(entry => isOwnedDesktopGatewayEntry(entry) && typeof entry.id === "string");
     const id = existing?.id ?? randomUUID();
     configPath = profilePath(libraryPath, id);
@@ -757,6 +817,22 @@ function writeDesktop3pConfigWithGenerator(
     const preserved = readDesktopProfileForeignKeys(configPath);
     const configJson = JSON.stringify({ ...preserved, ...generated }, null, 2) + "\n";
     const fingerprint = createHash("sha256").update(configJson).digest("hex").slice(0, 16);
+    if (refreshOnly) {
+      atomicWriteFileNoFollow(configPath, configJson, undefined, {
+        validateBeforeRename: () => {
+          try {
+            if (!refreshOnly.admit() || !desktopRefreshPathsSafe(libraryPath, configPath)) throw new Error();
+            const freshMetadata = parseMetadata(metadataPath);
+            if (freshMetadata.appliedId !== refreshOnly.requiredId
+              || !isOwnedDesktopGatewayEntry(freshMetadata.entries.find(entry => entry.id === refreshOnly.requiredId))
+              || createHash("sha256").update(readFileSync(configPath)).digest("hex").slice(0, 16) !== refreshOnly.expectedFingerprint) {
+              throw new Error();
+            }
+          } catch { throw new Error("desktop_refresh_only_skipped"); }
+        },
+      });
+      return { written: true, path: configPath, fingerprint };
+    }
     const { backupPath } = atomicReplaceDesktopConfig(configPath, configJson);
     try {
       atomicWriteFile(metadataPath, JSON.stringify({ ...metadata, appliedId: id, entries }, null, 2) + "\n");

package/src/claude/desktop-profile.ts

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { routeSupportsOneMillion } from "./long-context";
 import type {
   OcxClaudeDesktopAssignment,
   OcxClaudeDesktopFamily,
@@ -359,7 +360,7 @@ export function renderDesktopProfile(
       name: isRealAnthropicRoute(route) ? assignment.alias : desktopProfileWireAlias(assignment.alias),
       family: assignment.family,
       isFamilyDefault: effectiveDefaults[assignment.family] === route,
-      supports1m: typeof model.contextWindow === "number" && model.contextWindow >= 1_000_000,
+      supports1m: routeSupportsOneMillion(route, model.contextWindow),
     };
   });
 }

package/src/claude/gateway-cache.ts

@@ -17,6 +17,7 @@ import { mkdirSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { localAdmissionToken, localInferenceDestination } from "../lib/local-destinations";
+import { assertNotRealClaudeConfigUnderTest } from "../lib/test-home-guard";
 import type { OcxConfig } from "../types";
 
 export interface GatewayModelRow {
@@ -46,11 +47,27 @@ export interface GatewayModelTarget {
 /** Claude Code config dir (CLAUDE_CONFIG_DIR override honored, like the CLI). */
 export function claudeConfigDir(): string {
   const custom = process.env.CLAUDE_CONFIG_DIR;
-  return custom && custom.length > 0 ? custom : join(homedir(), ".claude");
+  return custom && custom.length > 0 ? custom : join(currentUserHome(), ".claude");
+}
+
+/**
+ * The home Claude Code itself resolves. Claude Code runs on Node, whose `os.homedir()`
+ * consults HOME (POSIX) or USERPROFILE (Windows) at call time when it is set; Bun's
+ * `os.homedir()` keeps the value it read at startup. In production the two agree. Under
+ * the test preload, which rewrites HOME after Bun has started, only this one follows the
+ * sandbox — the cached value is the developer's real home (#6775). Exported for tests.
+ */
+export function currentUserHome(env: NodeJS.ProcessEnv = process.env, platform: NodeJS.Platform = process.platform): string {
+  const fromEnv = platform === "win32" ? env.USERPROFILE : env.HOME;
+  return fromEnv !== undefined && fromEnv !== "" ? fromEnv : homedir();
 }
 
 /** Write the cache file; returns its path or null (best-effort, never throws). */
 export function writeGatewayModelCache(baseUrl: string, models: readonly GatewayModelRow[], configDir = claudeConfigDir()): string | null {
+  // Outside the best-effort catch: an armed test process must not write here, and must
+  // fail loudly rather than degrade to "returned null".
+  // The file itself too: writeFileSync follows a link at gateway-models.json.
+  assertNotRealClaudeConfigUnderTest(configDir, join(configDir, "cache"), join(configDir, "cache", "gateway-models.json"));
   try {
     // Mirror the CLI's usable-id filter so our file matches what it would cache.
     const usable = models.filter(m => /(claude|anthropic)/i.test(m.id));

package/src/claude/inbound.ts

@@ -281,7 +281,7 @@ function userMessageToItems(content: unknown, input: Rec[], elide: SkillElisionC
   pushUserMessage(input, pending);
 }
 
-function assistantMessageToItems(content: unknown, input: Rec[], budget: TranslatorBudget): void {
+function assistantMessageToItems(content: unknown, input: Rec[], budget: TranslatorBudget, requestedModel: string, nativeReasoningReplay: Map<string, string>): void {
   if (typeof content === "string") {
     if (content.length > 0) input.push({ type: "message", role: "assistant", content: [{ type: "output_text", text: content }] });
     return;
@@ -314,6 +314,24 @@ function assistantMessageToItems(content: unknown, input: Rec[], budget: Transla
           const owned = decodeReasoningEnvelope(signature, budget);
           if (!owned) throw new AnthropicRequestError("malformed ocxr1 reasoning signature");
           if (Object.hasOwn(owned, "sig")) throw new AnthropicRequestError("OpenCodex reasoning continuity cannot be replayed as an Anthropic signature");
+          if (owned.nat) {
+            // The provider's own blob goes back only to the model that minted it; any other
+            // model gets the visible text alone, as before this envelope field existed.
+            const nat = owned.nat.model === requestedModel ? owned.nat : undefined;
+            if (nat) {
+              const previous = nativeReasoningReplay.get(nat.enc);
+              nativeReasoningReplay.set(nat.enc, previous === undefined || previous === nat.tag ? nat.tag : "");
+            }
+            if (nat) budget.chargeRetained(2 * nat.enc.length, { kind: "reasoning" });
+            if (thinking.length === 0 && !nat) break;
+            input.push({
+              type: "reasoning",
+              id: nat?.id ?? `rs_${crypto.randomUUID().replace(/-/g, "")}`,
+              summary: thinking.length > 0 ? [{ type: "summary_text", text: thinking }] : [],
+              ...(nat ? { encrypted_content: nat.enc } : {}),
+            });
+            break;
+          }
         }
         const encrypted = signature.length === 0 ? undefined : signature.startsWith(OCX_REASONING_PREFIX) ? signature : encodeReasoningEnvelope({ sig: signature }, budget);
         if (encrypted) budget.chargeRetained(2 * encrypted.length, { kind: "reasoning" });
@@ -355,6 +373,7 @@ export type ClaudeCacheKeySource = "metadata" | "system" | null;
 export interface ClaudeInboundTranslation {
   body: Rec;
   cacheKeySource: ClaudeCacheKeySource;
+  nativeReasoningReplay: ReadonlyMap<string, string>;
 }
 
 /**
@@ -400,6 +419,7 @@ function translateAnthropicRequest(
   }
 
   const input: Rec[] = [];
+  const nativeReasoningReplay = new Map<string, string>();
   const systemParts: string[] = [];
   const topLevelSystem = systemToInstructions(raw.system);
   if (topLevelSystem !== undefined) systemParts.push(topLevelSystem);
@@ -411,7 +431,7 @@ function translateAnthropicRequest(
   for (const msg of raw.messages) {
     if (!isRec(msg)) throw new AnthropicRequestError("each message must be an object");
     if (msg.role === "user") userMessageToItems(msg.content, input, elide);
-    else if (msg.role === "assistant") assistantMessageToItems(msg.content, input, budget);
+    else if (msg.role === "assistant") assistantMessageToItems(msg.content, input, budget, raw.model, nativeReasoningReplay);
     else if (msg.role === "system") {
       const text = systemMessageText(msg.content);
       // Keep it where the client put it. `developer` is first-class in the Responses
@@ -531,7 +551,61 @@ function translateAnthropicRequest(
       reasoning.effort = effortForThinkingBudget(thinking.budget_tokens);
     }
     body.reasoning = reasoning;
+    // store:false returns a provider's encrypted reasoning only on request. The outbound
+    // envelope (`nat`) carries it to the client so the next turn can hand it back.
+    body.include = ["reasoning.encrypted_content"];
   }
 
-  return { body, cacheKeySource };
+  return { body, cacheKeySource, nativeReasoningReplay };
+}
+
+/**
+ * Remove proxy-owned native blobs before sending a Messages body to native Anthropic.
+ *
+ * Every decode, and every re-encode on top of it, is reserved against the request's translator
+ * budget first (eight bytes per code unit, as `decodeReasoningEnvelope` does), and every new
+ * signature is charged as a retained copy, so a body of near-limit envelopes cannot allocate past the per-turn bound.
+ * Throws TranslatorBudgetExceededError when it would; callers answer 413.
+ */
+export function nativeAnthropicProjection(body: Rec, budget: TranslatorBudget): Rec {
+  if (!Array.isArray(body.messages)) return body;
+  let changed = false;
+  const messages = body.messages.flatMap(message => {
+    if (!isRec(message) || message.role !== "assistant" || !Array.isArray(message.content)) return [message];
+    let localChanged = false;
+    const content = message.content.flatMap(block => {
+      if (!isRec(block) || block.type !== "thinking" || typeof block.signature !== "string"
+        || !block.signature.startsWith(OCX_REASONING_PREFIX)) return [block];
+      // The decoded object stays alive while it is re-encoded, so its reservation is held until
+      // the new signature exists; the encode copies get their own reservation on top of it.
+      const decodeReservation = budget.reserveTransient(8 * block.signature.length, { kind: "reasoning" });
+      try {
+        let decoded: unknown;
+        try { decoded = JSON.parse(Buffer.from(block.signature.slice(OCX_REASONING_PREFIX.length), "base64").toString("utf8")); }
+        catch { decoded = undefined; }
+        if (!isRec(decoded)) { localChanged = true; return []; }
+        if (!Object.hasOwn(decoded, "nat")) return [block];
+        localChanged = true;
+        const { nat: _nat, ...rest } = decoded;
+        if (!rest.sig && !rest.red && !rest.krc && !(typeof rest.txt === "string" && rest.txt.length > 0)) return [];
+        // The re-encoded envelope is never larger than the decoded one (a field was removed), so a
+        // decode-sized reservation bounds the stringify, buffer and base64 copies before they exist.
+        const encodeReservation = budget.reserveTransient(8 * block.signature.length, { kind: "reasoning" });
+        let signature: string;
+        try {
+          signature = OCX_REASONING_PREFIX + Buffer.from(JSON.stringify(rest), "utf8").toString("base64");
+        } finally {
+          encodeReservation.release();
+        }
+        budget.chargeRetained(2 * signature.length, { kind: "reasoning" });
+        return [{ ...block, signature }];
+      } finally {
+        decodeReservation.release();
+      }
+    });
+    if (!localChanged) return [message];
+    changed = true;
+    return content.length ? [{ ...message, content }] : [];
+  });
+  return changed ? { ...body, messages } : body;
 }

package/src/claude/intercept/cli-catalog.ts

@@ -14,6 +14,7 @@
  */
 import { readdirSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
+import { assertNotRealClaudeConfigUnderTest } from "../../lib/test-home-guard";
 import type { ClaudeFirstPartyDesired } from "../first-party-settings";
 import { classifyInterceptClient } from "./client-class";
 import { BOOTSTRAP_MAX_DECODED_BYTES, injectPickerModels, type PickerModelEntry } from "./picker-bootstrap";
@@ -150,6 +151,8 @@ export async function rewriteCliCatalogResponse(
  */
 export function invalidateClaudeCodeServedCatalog(claudeDir: string): number {
   const dir = join(claudeDir, "cache", "model-catalog");
+  // Outside the catch below: an armed test process must not prune the real Claude cache (#6775).
+  assertNotRealClaudeConfigUnderTest(claudeDir, dir);
   let names: string[];
   try { names = readdirSync(dir); } catch { return 0; } // no-excuse-ok: catch -- no cache directory means nothing to drop.
   let removed = 0;

package/src/claude/intercept/picker-ca-persistence.ts

@@ -1,5 +1,5 @@
 import { X509Certificate } from "node:crypto";
-import { constants, closeSync, fstatSync, lstatSync, openSync, readSync, realpathSync, rmSync, writeFileSync, type Stats } from "node:fs";
+import { constants, closeSync, fstatSync, lstatSync, openSync, readSync, realpathSync, rmSync, writeFileSync, type BigIntStats } from "node:fs";
 import { join } from "node:path";
 import {
   decodePickerCaCredential, openPickerCaCredential, pickerCaConfigId, readPickerCaCredential,
@@ -21,18 +21,19 @@ export function canonicalPickerConfigDir(configDir: string): string {
 
 /** Public records still cannot follow symlinks or accept oversized/malformed recovery data. */
 function readState(path: string, configId: string, initialization: boolean): Initialization | AuthorityMetadata | null {
-  let expected: Stats;
-  try { expected = lstatSync(path); }
+  // BigInt stats: a Windows file ID exceeds 2^53, so Number ino loses low bits and two files can compare equal.
+  let expected: BigIntStats;
+  try { expected = lstatSync(path, { bigint: true }); }
   catch (error) { if ((error as NodeJS.ErrnoException).code === "ENOENT") return null; throw new Error("picker_ca_metadata_unsafe"); }
   if (expected.isSymbolicLink()) throw new Error("picker_ca_metadata_unsafe");
   let fd: number;
   try { fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK); }
   catch (error) { if ((error as NodeJS.ErrnoException).code === "ENOENT") return null; throw new Error("picker_ca_metadata_unsafe"); }
   try {
-    const stat = fstatSync(fd);
+    const stat = fstatSync(fd, { bigint: true });
     if (stat.dev !== expected.dev || stat.ino !== expected.ino) throw new Error("picker_ca_metadata_unsafe");
-    if (!stat.isFile() || stat.nlink !== 1 || stat.size > MAX_PUBLIC_STATE_BYTES
-      || (process.platform !== "win32" && stat.uid !== process.getuid!())) throw new Error();
+    if (!stat.isFile() || stat.nlink !== 1n || stat.size > BigInt(MAX_PUBLIC_STATE_BYTES)
+      || (process.platform !== "win32" && stat.uid !== BigInt(process.getuid!()))) throw new Error();
     const bytes = Buffer.alloc(MAX_PUBLIC_STATE_BYTES + 1);
     let used = 0;
     while (used < bytes.length) {

package/src/claude/intercept/picker-models.ts

@@ -7,7 +7,8 @@ import { dirname } from "node:path";
 import { nativeOpenAiContextWindow, type NativeContextLimitsInput } from "../../codex/catalog";
 import type { OcxClaudeDesktopProfile } from "../../types";
 import { aliasForRoute, claudeCodeNativeAlias } from "../alias";
-import { AUTO_CONTEXT_OFF, stripOneMillionMarker, withOneMillionMarker } from "../context-windows";
+import { AUTO_CONTEXT_OFF, stripOneMillionMarker, UNPAIRED_AUTO_CONTEXT, withOneMillionMarker, type AutoContextMode } from "../context-windows";
+import { isAnthropicClaudeRoute } from "../long-context";
 import { activeDesktop3pAlias, displayModelId, resolveDesktop3pAlias, type Desktop3pRoutedModel } from "../desktop-3p";
 import { reconcileDesktopProfile, renderDesktopProfile, type DesktopProfileModel } from "../desktop-profile";
 import type { PickerModelEntry } from "./picker-bootstrap";
@@ -17,6 +18,8 @@ export interface PickerRouteInput {
   routedModels: Desktop3pRoutedModel[];
   profile?: OcxClaudeDesktopProfile;
   nativeContextCap?: NativeContextLimitsInput;
+  /** resolveAutoContext(config.claudeCode); only its contextAccounting "200k" opt-in matters here. */
+  auto?: AutoContextMode;
 }
 
 /** Candidate routes in the gateway profile's order and with its labels. */
@@ -46,9 +49,14 @@ function splitRoute(route: string): { provider: string; id: string } {
   return { provider: route.slice(0, slash), id: route.slice(slash + 1) };
 }
 
-/** Desktop runners do not inherit the proxy's compaction env: mark only real >=1M windows. */
-function pickerSelector(alias: string, contextWindow: number | undefined): string {
-  return withOneMillionMarker(alias, contextWindow === undefined ? {} : { [alias]: contextWindow }, AUTO_CONTEXT_OFF)!;
+/**
+ * Desktop runners do not inherit the proxy's compaction env, so a long window (>= the default
+ * compact window) is marked on the strength of the `prompt is too long` recovery instead
+ * (devlog/_plan/261009_claude_1m_default/020). Real Anthropic models need a genuine 1M.
+ */
+function pickerSelector(alias: string, contextWindow: number | undefined, provider: string, id: string, auto?: AutoContextMode): string {
+  const mode = auto?.accounting200k ? auto : isAnthropicClaudeRoute(provider, id) ? AUTO_CONTEXT_OFF : UNPAIRED_AUTO_CONTEXT;
+  return withOneMillionMarker(alias, contextWindow === undefined ? {} : { [alias]: contextWindow }, mode)!;
 }
 
 export function buildPickerModels(input: PickerRouteInput): PickerModelEntry[] {
@@ -61,7 +69,7 @@ export function buildPickerModels(input: PickerRouteInput): PickerModelEntry[] {
     const alias = provider === "native" ? claudeCodeNativeAlias(id) : aliasForRoute(provider, id);
     if (!alias || seen.has(alias)) continue;
     seen.add(alias);
-    out.push({ id: pickerSelector(alias, model.contextWindow), name: model.label,
+    out.push({ id: pickerSelector(alias, model.contextWindow, provider, id, input.auto), name: model.label,
       ...(model.contextWindow === undefined ? {} : { contextWindow: model.contextWindow }) });
   }
   return out;
@@ -81,7 +89,7 @@ export function buildCliPickerModels(input: PickerRouteInput): PickerModelEntry[
     const alias = activeDesktop3pAlias(provider, id);
     if (seen.has(alias) || resolveDesktop3pAlias(alias) !== model.route) continue;
     seen.add(alias);
-    out.push({ id: pickerSelector(alias, model.contextWindow), name: model.label,
+    out.push({ id: pickerSelector(alias, model.contextWindow, provider, id, input.auto), name: model.label,
       description: `opencodex · ${model.route}`, route: model.route,
       ...(model.contextWindow === undefined ? {} : { contextWindow: model.contextWindow }) });
   }

package/src/claude/intercept/settings.ts

@@ -1,6 +1,7 @@
 import { mkdirSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { atomicWriteFile } from "../../config/atomic-write";
+import { assertNotRealClaudeConfigUnderTest } from "../../lib/test-home-guard";
 import { claudeConfigDir } from "../auth-detect";
 import { invalidateClaudeCodeServedCatalog } from "./cli-catalog";
 
@@ -112,6 +113,8 @@ export function inspectClaudeInterceptSettings(
 }
 
 function writeSettings(path: string, doc: SettingsDoc): void {
+  // An armed test process must not rewrite the real Claude settings.json (#6775).
+  assertNotRealClaudeConfigUnderTest(dirname(path), path);
   mkdirSync(dirname(path), { recursive: true });
   // The managed env embeds the proxy token, so the file must stay owner-only:
   // atomicWriteFile applies the real NTFS ACL on Windows where chmod is a no-op.

package/src/claude/long-context.ts

@@ -0,0 +1,66 @@
+/**
+ * Long-context thresholds shared by every Claude surface
+ * (devlog/_plan/261009_claude_1m_default/020_long_context_eligibility.md).
+ *
+ * A leaf module: desktop-3p.ts and desktop-profile.ts need the predicate, and context-windows.ts
+ * already imports desktop-3p.ts, so the predicate cannot live there.
+ */
+import { isAnthropicInstanceId } from "../providers/anthropic-instance-id";
+
+export const ONE_MILLION = 1_000_000;
+
+/** A window at or below this is Claude Code's own default accounting; widening it gains nothing. */
+export const AUTO_CONTEXT_FLOOR = 200_000;
+
+/**
+ * Auto-context defaults (devlog 260712 020, user-approved).
+ *
+ * The compact window is the token count at which Claude Code starts compacting, and it is
+ * also the floor `shouldMarkOneMillion` uses — a model may only carry the marker if it can
+ * host this window. 350,000 was chosen when the widest native row advertised 372,000.
+ *
+ * It now matches the auto-compaction limit the Codex catalog ships for the same models
+ * (`nativeAutoCompactLimit`: 829,800 against the 922,000 native window). Leaving the two
+ * apart meant one model compacting at 350k under Claude Code and at 829,800 under Codex.
+ * The value stays clear of the measured 922,000 ceiling by ~92k, so compaction still has
+ * room to run before the upstream refuses.
+ */
+export const AUTO_COMPACT_WINDOW_DEFAULT = 829_800;
+
+/**
+ * Whether a window earns the 1M selection on a surface whose Claude Code runner may not inherit
+ * CLAUDE_CODE_AUTO_COMPACT_WINDOW (Desktop pickers, discovery, Desktop 3P, generated subagents).
+ * A window >= 1M always does. A smaller one does when it can host the default compact window, so
+ * a runner that has the variable compacts in time, and one that lacks it overflows into the
+ * `prompt is too long` envelope (anthropicErrorBody) and compacts reactively. The floor is fixed
+ * on purpose: a custom compact window must not re-admit a 372k route (#854).
+ */
+export function isLongContextWindow(window: number | undefined): boolean {
+  if (typeof window !== "number" || window <= 0) return false;
+  return window >= ONE_MILLION || (window > AUTO_CONTEXT_FLOOR && window >= AUTO_COMPACT_WINDOW_DEFAULT);
+}
+
+/**
+ * A Claude model on an Anthropic-named route. Claude windows are 200k or a genuine 1M and a bare
+ * id rides the native passthrough, so the long-window rule never widens one: a Claude row listed
+ * under 1M is a capped one, and on a runner without the compaction env it keeps the 200k
+ * accounting it had before long windows were widened. Keyed on the model id as well, so a
+ * configured gateway that only shares the name `anthropic2` and serves other models keeps the
+ * long-window rule. A custom `anthropic2` gateway serving Claude below 1M is treated like a pool
+ * row on these surfaces, which is the pre-existing (unwidened) behavior.
+ */
+export function isAnthropicClaudeRoute(provider: string, modelId: string): boolean {
+  return isAnthropicInstanceId(provider) && modelId.startsWith("claude-");
+}
+
+/** Desktop 3P / picker / discovery / dashboard 1M eligibility for one provider route. */
+export function claudeSurfaceSupportsOneMillion(provider: string, modelId: string, window: number | undefined): boolean {
+  if (isAnthropicClaudeRoute(provider, modelId)) return typeof window === "number" && window >= ONE_MILLION;
+  return isLongContextWindow(window);
+}
+
+/** Same, for a `provider/id` route string. */
+export function routeSupportsOneMillion(route: string, window: number | undefined): boolean {
+  const slash = route.indexOf("/");
+  return claudeSurfaceSupportsOneMillion(route.slice(0, slash), route.slice(slash + 1), window);
+}

package/src/claude/model-info.ts

@@ -19,7 +19,8 @@ import { orderForModelPicker, catalogModelEfforts, nativeEffortClamp, nativeOpen
 import { claudeCodeAlias, claudeCodeNativeAlias } from "./alias";
 import { cursorFastIdFor } from "../adapters/cursor/catalog";
 import { desktop3pAlias } from "./desktop-3p";
-import { AUTO_CONTEXT_OFF, type AutoContextMode } from "./context-windows";
+import { AUTO_CONTEXT_OFF, shouldMarkOneMillion, UNPAIRED_AUTO_CONTEXT, type AutoContextMode } from "./context-windows";
+import { isAnthropicClaudeRoute } from "./long-context";
 
 const MODEL_INFO_CREATED_AT = "2026-01-01T00:00:00Z";
 const ANTHROPIC_EFFORT_RUNGS = new Set(["low", "medium", "high", "xhigh", "max"]);
@@ -144,23 +145,25 @@ export function buildAnthropicModelInfos(
         : aliasForRoute(m.provider, m.id);
     }),
   ]);
-  // [1m] picker variant (devlog 260712 B1): Claude Code accounts exactly 1M for ids
-  // carrying the marker (2.1.207 binary: /\[1m\]/i → 1e6, compaction preserved), so
-  // ONLY models with an authoritative >=1M window get a second selectable row —
-  // the auto-context widening that let a 372K route carry the marker (and be
-  // over-filled) is the #854 defect and does not come back. Guards (audit R1#11):
-  // same dedupe set, never double-suffix.
+  // [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
+  // rule is the fixed unpaired one (long-context.ts), not the configurable launch compact window:
+  // a custom 350k window must not re-admit a 372k route (#854). The server's auto mode only turns
+  // widening off (autoContext: false / maxContextTokens), falling back to >= 1M. Base and Fast
+  // rows stay unmarked: this list is a choice list. Guards (audit R1#11): same dedupe set, never
+  // double-suffix.
+  const variantMode = auto.enabled ? UNPAIRED_AUTO_CONTEXT : AUTO_CONTEXT_OFF;
   const push1mVariant = (
     base: AnthropicModelInfo,
     contextWindow: number | undefined,
     maxInputTokens?: number,
     selectorId?: string,
+    mode: AutoContextMode = variantMode,
   ) => {
-    // The [1m] marker makes Claude Code account 1e6 tokens for the row, so it
-    // may only name models whose AUTHORITATIVE effective window is >= 1M —
-    // never the auto-context widening, which would mark a 372K route and have
-    // Claude Code over-fill it (the #854 defect).
-    if (contextWindow === undefined || contextWindow < ONE_MILLION) return;
+    // A window >= 1M always earns the row; a long window earns it under the unpaired rule,
+    // because an overflow is answered as `prompt is too long`, which Claude Code compacts on.
+    if (!shouldMarkOneMillion(contextWindow, mode)) return;
     if (base.id.includes("[1m]")) return;
     const id = selectorId ?? `${base.id}[1m]`;
     if (seen.has(id)) return;
@@ -170,9 +173,9 @@ export function buildAnthropicModelInfos(
     // (measured — see devlog/_plan/260817_native_gpt56_1m_context/001_measurement_evidence.md).
     // Advertising the flat 1e6 there would invite mid-session context_length_exceeded, so the
     // variant reports whichever of the two is smaller.
-    const advertised = typeof maxInputTokens === "number" && maxInputTokens > 0
-      ? Math.min(ONE_MILLION, maxInputTokens)
-      : ONE_MILLION;
+    // A long window under 1M must not be advertised as 1e6 input either.
+    const ceiling = typeof maxInputTokens === "number" && maxInputTokens > 0 ? maxInputTokens : contextWindow;
+    const advertised = typeof ceiling === "number" && ceiling > 0 ? Math.min(ONE_MILLION, ceiling) : ONE_MILLION;
     out.push({ ...base, id, display_name: `${base.display_name} · 1M`, max_input_tokens: advertised });
   };
   /**
@@ -251,7 +254,7 @@ export function buildAnthropicModelInfos(
       && listedModelId.startsWith("claude-fable-")
       ? `${claudeCodeNativeAlias(listedModelId)}[1m]`
       : undefined;
-    push1mVariant(info, m.contextWindow, routedMaxInput, oneMillionSelector);
+    push1mVariant(info, m.contextWindow, routedMaxInput, oneMillionSelector, isAnthropicClaudeRoute(m.provider, m.id) ? AUTO_CONTEXT_OFF : variantMode);
     // The whole model is passed, not a (provider, id) pair: a combo row lives in its own
     // namespace with no config.providers entry, so the caller classifies it from the
     // aggregated supportsServiceTier the row already carries.