@bitkyc08/opencodex 2.52.0-preview.20260911 → 2.52.0

package/gui/dist/provider-icons/omo.svg

@@ -0,0 +1,42 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1024 1024">
+  <path fill="#F4F4F4" d="M512.00 100.50 C591.13 100.50 697.66 102.37 749.39 106.27 C801.11 110.17 802.35 115.84 822.35 123.90 C842.34 131.96 856.40 141.68 869.36 154.64 C882.32 167.60 892.04 181.66 900.10 201.65 C908.16 221.65 913.83 222.89 917.73 274.61 C921.63 326.34 923.50 432.87 923.50 512.00 C923.50 591.13 921.63 697.66 917.73 749.39 C913.83 801.11 908.16 802.35 900.10 822.35 C892.04 842.34 882.32 856.40 869.36 869.36 C856.40 882.32 842.34 892.04 822.35 900.10 C802.35 908.16 801.11 913.83 749.39 917.73 C697.66 921.63 591.13 923.50 512.00 923.50 C432.87 923.50 326.34 921.63 274.61 917.73 C222.89 913.83 221.65 908.16 201.65 900.10 C181.66 892.04 167.60 882.32 154.64 869.36 C141.68 856.40 131.96 842.34 123.90 822.35 C115.84 802.35 110.17 801.11 106.27 749.39 C102.37 697.66 100.50 591.13 100.50 512.00 C100.50 432.87 102.37 326.34 106.27 274.61 C110.17 222.89 115.84 221.65 123.90 201.65 C131.96 181.66 141.68 167.60 154.64 154.64 C167.60 141.68 181.66 131.96 201.65 123.90 C221.65 115.84 222.89 110.17 274.61 106.27 C326.34 102.37 432.87 100.50 512.00 100.50Z"/>
+  <g transform="scale(0.5)">
+    <g transform="translate(0.000000,2048.000000) scale(0.050000,-0.050000)">
+      <path fill="#041617" fill-rule="evenodd" d="M9270 32167 c-309 -64 -456 -152 -621 -373 -562 -748 -776 -2689
+-547 -4984 118 -1187 325 -2600 570 -3890 143 -753 152 -653 -128 -1380 -403
+-1045 -643 -1873 -812 -2800 -853 -4689 1979 -7986 7858 -9148 1140 -225 2514
+-397 3202 -400 l361 -2 79 55 c264 182 210 642 -111 942 -387 362 -950 532
+-2801 845 -3004 507 -4249 965 -5520 2030 -1358 1138 -2012 2878 -1809 4810
+545 5195 6617 8726 13529 7866 5506 -684 9480 -4255 9480 -8518 0 -2607 -1462
+-4522 -4157 -5448 -927 -318 -1534 -459 -3203 -740 -1851 -313 -2414 -483
+-2801 -845 -321 -300 -375 -760 -111 -942 l79 -55 361 2 c688 3 2062 175 3202
+400 5879 1162 8711 4459 7858 9148 -169 927 -409 1755 -812 2800 -280 727
+-271 627 -128 1380 245 1290 452 2703 570 3890 271 2720 -77 4861 -855 5259
+-758 388 -2310 -238 -5021 -2024 -868 -571 -764 -557 -1489 -211 -3271 1558
+-6755 1558 -10026 0 -725 -346 -621 -360 -1489 211 -2371 1562 -3959 2278
+-4708 2122z m4132 -3345 c175 -175 124 -268 -409 -739 -1028 -910 -1995 -2053
+-2713 -3209 -97 -156 -200 -318 -228 -359 -221 -321 -646 -76 -469 270 153
+301 883 1334 1388 1965 578 723 1466 1614 2029 2035 191 142 288 151 402 37z
+m14507 -1 c496 -341 1482 -1323 2080 -2071 505 -631 1235 -1664 1388 -1965
+177 -346 -248 -591 -469 -270 -28 41 -131 203 -228 359 -718 1156 -1685 2299
+-2713 3209 -535 473 -585 564 -407 742 100 100 199 99 349 -4z M19910 25308 c-4039 -205 -7212 -1666 -9086 -4184 -1840 -2473 -1753
+-5794 196 -7540 1161 -1040 2447 -1518 5420 -2015 1374 -229 1998 -380 2456
+-591 754 -348 1163 -1000 1033 -1650 -10 -49 -1 -72 47 -124 l60 -64 444 0
+444 0 60 64 c48 52 57 75 47 124 -130 650 279 1302 1033 1650 458 211 1082
+362 2456 591 2973 497 4259 975 5420 2015 2084 1866 2026 5374 -131 7956
+-2063 2469 -5995 3966 -9899 3768z m-4644 -4374 c1356 -360 2272 -1909 1998
+-3378 -426 -2278 -2856 -3144 -4424 -1576 -1497 1496 -924 4218 1031 4899 393
+137 996 161 1395 55z m11480 35 c1491 -261 2504 -1921 2154 -3532 -487 -2247
+-3108 -3024 -4525 -1341 -1719 2042 -129 5310 2371 4873z m-6948 -2980 c172
+-40 341 -133 495 -273 95 -86 143 -116 187 -116 44 0 92 30 187 116 718 650
+1716 188 1854 -860 35 -267 18 -968 -25 -1048 -119 -219 -350 -251 -491 -68
+-68 89 -73 124 -85 670 -13 623 -25 675 -200 838 -212 198 -516 199 -735 2
+-180 -161 -192 -212 -205 -840 -12 -546 -17 -581 -85 -670 -122 -159 -308
+-159 -430 0 -68 89 -73 124 -85 670 -13 628 -25 679 -205 840 -219 197 -523
+196 -735 -2 -175 -163 -187 -215 -200 -838 -12 -546 -17 -581 -85 -670 -141
+-183 -372 -151 -491 68 -74 136 -54 1039 30 1332 170 594 758 978 1304 849z M14340 20290 c-1858 -372 -2230 -3228 -546 -4191 1280 -732 2786 338
+2786 1981 0 1391 -1068 2445 -2240 2210z M25990 20291 c-1733 -343 -2208 -2981 -732 -4069 1287 -949 2981 108
+2982 1860 0 1392 -1070 2443 -2250 2209z"/>
+    </g>
+  </g>
+</svg>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bitkyc08/opencodex",
-  "version": "2.52.0-preview.20260911",
+  "version": "2.52.0",
   "description": "Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code",
   "type": "module",
   "main": "./bin/package-main.mjs",
@@ -48,6 +48,8 @@
     "privacy:scan": "bun scripts/privacy-scan.ts",
     "skill:surface": "bun scripts/generate-ocx-skill-surface.ts",
     "skill:surface:check": "bun scripts/generate-ocx-skill-surface.ts --check",
+    "structure:index": "bun scripts/structure-ssot.ts --fix",
+    "structure:check": "bun scripts/structure-ssot.ts",
     "generate:model-metadata": "bun scripts/generate-model-metadata.ts",
     "build:gui": "cd gui && bun install --frozen-lockfile && bun run build && cd .. && bun run prepare:package",
     "prepare:package": "bun scripts/prepare-package.ts",

package/src/AGENTS.md

@@ -8,7 +8,7 @@ This file applies to `src/` and inherits the repository-wide rules in `/AGENTS.m
 - Do not assume a separate server compilation step.
 - Prefer Bun and Web-platform APIs. Introduce a Node-only runtime dependency only when the task explicitly requires compatibility code and the owning module already has that role.
 - Preserve existing public exports and configuration compatibility unless the task explicitly changes them.
-- Read the applicable documents in `structure/` before changing shared routing, adapters, transports, sidecars, authentication, configuration, or server architecture.
+- Read the applicable documents in `structure/` before changing shared routing, adapters, transports, sidecars, authentication, configuration, or server architecture. [`structure/INDEX.md`](../structure/INDEX.md) maps each source area to the docs that describe it — usually more than one, because those docs are organised by topic while `src/` is organised by module — and every doc listed for an area is updated in the same change that changes the area.
 
 ## Implementation rules
 

package/src/adapters/cline-pass-deepseek-v4-tool-replay.ts

@@ -2,7 +2,6 @@ import type { ProviderAdapter } from "./base";
 
 const CLINE_PASS_DEEPSEEK_V4_MODELS = new Set([
   "cline-pass/deepseek-v4-flash",
-  "cline-pass/deepseek-v4-pro",
 ]);
 
 function isRecord(value: unknown): value is Record<string, unknown> {

package/src/adapters/command-code.ts

@@ -495,7 +495,6 @@ function supportedCommandCodeEffort(provider: OcxProviderConfig, modelId: string
   let wire = requested;
   const lower = canonicalId.toLowerCase();
   const needsAlias =
-    lower === "deepseek/deepseek-v4-pro" ||
     lower === "deepseek/deepseek-v4-flash" ||
     lower === "zai-org/glm-5.2";
   if (requested === "xhigh" && !supported.includes("xhigh") && supported.includes("max")) {

package/src/adapters/cursor/checkpoint-store.ts

@@ -184,6 +184,43 @@ export function cursorCheckpointRefHash(ref: string): string {
   return createHash("sha256").update("ocx:cursor:ckpt-ref:").update(ref).digest("hex").slice(0, 16);
 }
 
+/**
+ * Counts only — never content. Diagnostics about a checkpoint have so far reported its size in
+ * bytes, which says nothing about what is in it, and that gap is exactly what left #4245's native
+ * half undecidable: `capturedAfterClientTool` proves a snapshot ARRIVED after the tool call, and
+ * only `pendingToolCalls` says whether the snapshot actually knows about one.
+ *
+ * `pendingToolCalls` is documented upstream as raw JSON tool-call parts awaiting execution, so a
+ * non-zero count on a suspended turn is the coverage evidence. The strings themselves are request
+ * content and are never read here.
+ *
+ * If you extend this, keep it counts-only. `ConversationStateStructure` also carries
+ * `readPaths`, `previousWorkspaceUris`, and the `fileStates`/`fileStatesV2` keys — all of which
+ * are user paths or workspace identity, and all of which would turn a diagnostic into a privacy
+ * leak the moment someone returns them as values instead of lengths.
+ */
+export function cursorCheckpointShape(checkpointBytes: Uint8Array | undefined): {
+  turns: number;
+  turnsOld: number;
+  rootPromptMessages: number;
+  todos: number;
+  pendingToolCalls: number;
+} | undefined {
+  if (!checkpointBytes || checkpointBytes.byteLength === 0) return undefined;
+  try {
+    const state = fromBinary(ConversationStateStructureSchema, checkpointBytes);
+    return {
+      turns: state.turns.length,
+      turnsOld: state.turnsOld.length,
+      rootPromptMessages: state.rootPromptMessagesJson.length,
+      todos: state.todos.length,
+      pendingToolCalls: state.pendingToolCalls.length,
+    };
+  } catch {
+    return undefined;
+  }
+}
+
 export function commitCursorCheckpoint(input: {
   conversationId: string;
   identityScope?: string;

package/src/adapters/cursor/live-transport.ts

@@ -115,6 +115,15 @@ const CLIENT_TOOL_FINALIZE_GRACE_MS = 50;
 const GENERIC_TOOL_COUNT_MIN_FINALIZE_GRACE_MS = 750;
 const GENERIC_TOOL_COUNT_MAX_FINALIZE_GRACE_MS = 1_800;
 const GENERIC_TOOL_COUNT_PER_TOOL_GRACE_MS = 125;
+/**
+ * A client-tool turn suspends before `turnEnded`, and upstream sends that turn's conversation
+ * checkpoint right after `toolCallStarted` — after the 50 ms drain grace, so it used to be
+ * cancelled away and every such turn full-replayed with `cached_tokens: 0`. Measured on a live
+ * account with the tool catalog held constant: 50 ms captures nothing, 1500 ms captures 3036
+ * bytes (#4245, devlog 260911_cursor_checkpoint_capture). This window is paid only by a turn
+ * that never sends one; `handleServerMessage` finalizes early as soon as the frame lands.
+ */
+const CHECKPOINT_CAPTURE_GRACE_MS = 1_500;
 const cursorContextUsageTracker = createCursorContextUsageTracker();
 
 /**
@@ -413,6 +422,28 @@ export function finalizeAfterDrain(state: ReturnType<typeof createCursorProtobuf
   return finalizeTurnEvents(state);
 }
 
+/**
+ * Whether a drained client-tool turn should wait one more bounded window for the conversation
+ * checkpoint instead of cancelling now.
+ *
+ * This mirrors `finalizeAfterDrain`'s two guards rather than calling it, and that is load-bearing:
+ * `finalizeAfterDrain` reaches `finalizeTurnEvents`, which sets `state.terminated`, and then returns
+ * `[]` for a terminated state. Draining first and re-arming would make the retry return early at the
+ * length check and leave the stream uncancelled. Pure for unit testing.
+ */
+export function shouldExtendForCheckpointCapture(input: {
+  /** Optional on the event state, so accept its real shape rather than forcing a cast at the call site. */
+  terminated: boolean | undefined;
+  openToolCallCount: number;
+  wantsCheckpointCapture: boolean;
+  hasCapturedCheckpoint: boolean;
+  alreadyExtended: boolean;
+}): boolean {
+  if (input.terminated || input.openToolCallCount > 0) return false;
+  if (!input.wantsCheckpointCapture || input.hasCapturedCheckpoint) return false;
+  return !input.alreadyExtended;
+}
+
 export function clientToolFinalizeGraceMsForRequest(request: CursorRunRequest, baseGraceMs = CLIENT_TOOL_FINALIZE_GRACE_MS): number {
   if (request.rawMessages?.at(-1)?.role === "toolResult") return baseGraceMs;
   const text = activePromptText(request);
@@ -468,6 +499,10 @@ class LiveCursorTransport implements CursorTransport {
    */
   private emittedTerminal = false;
   private pendingFinalize?: ReturnType<typeof setTimeout>;
+  /** The armed finalize body, so the checkpoint frame can run it early instead of waiting out the window. */
+  private pendingFinalizeRun?: () => void;
+  private checkpointGraceExtended = false;
+  private wantsCheckpointCapture = false;
   private readonly clientToolFinalizeGraceMs: number;
   private activeClientToolFinalizeGraceMs: number;
   private readonly token: string;
@@ -641,6 +676,7 @@ class LiveCursorTransport implements CursorTransport {
     };
     const activeText = activePromptText(activeRequest);
     this.activeClientToolFinalizeGraceMs = clientToolFinalizeGraceMsForRequest(activeRequest, this.clientToolFinalizeGraceMs);
+    this.wantsCheckpointCapture = activeRequest.contextUsageStoreCheckpoints !== false;
     const cursorVisibleTools = cursorToolsForActivePrompt(activeRequest.tools, activeText, activeRequest.toolChoice);
     const clientToolDefs = buildCursorToolDefinitions(cursorVisibleTools, activeRequest.toolChoice);
     // `request.tools` is the catalog already filtered and budgeted by request-builder. Derive
@@ -981,6 +1017,7 @@ class LiveCursorTransport implements CursorTransport {
       clearTimeout(this.pendingFinalize);
       this.pendingFinalize = undefined;
     }
+    this.pendingFinalizeRun = undefined;
   }
 
   /**
@@ -1001,11 +1038,26 @@ class LiveCursorTransport implements CursorTransport {
   private scheduleClientToolFinalize(
     state: ReturnType<typeof createCursorProtobufEventState>,
     push: (message: CursorServerMessage) => void,
+    graceMsOverride?: number,
   ): void {
     this.clearPendingFinalize();
-    this.pendingFinalize = setTimeout(() => {
+    const run = (): void => {
       this.pendingFinalize = undefined;
+      this.pendingFinalizeRun = undefined;
       if (this.expectedClose) return;
+      // The checkpoint for THIS turn is the one we most want and the one we used to throw
+      // away. Extend once, bounded, before draining (#4245).
+      if (shouldExtendForCheckpointCapture({
+        terminated: state.terminated,
+        openToolCallCount: state.openToolCalls.size,
+        wantsCheckpointCapture: this.wantsCheckpointCapture,
+        hasCapturedCheckpoint: this.capturedCheckpointBytes !== undefined,
+        alreadyExtended: this.checkpointGraceExtended,
+      })) {
+        this.checkpointGraceExtended = true;
+        this.scheduleClientToolFinalize(state, push, CHECKPOINT_CAPTURE_GRACE_MS);
+        return;
+      }
       const terminal = finalizeAfterDrain(state);
       if (terminal.length === 0) return;
       for (const event of terminal) push(event);
@@ -1013,9 +1065,13 @@ class LiveCursorTransport implements CursorTransport {
         reason: "Responses bridge owns client tools; ending turn without fake mcpResult",
         framesReceived: this.framesReceived,
         elapsedMs: Date.now() - this.turnStartedAt,
+        graceMs: graceMsOverride ?? this.activeClientToolFinalizeGraceMs,
+        checkpointGraceExtended: this.checkpointGraceExtended,
       });
       this.cancelCursorRun();
-    }, this.activeClientToolFinalizeGraceMs);
+    };
+    this.pendingFinalizeRun = run;
+    this.pendingFinalize = setTimeout(run, graceMsOverride ?? this.activeClientToolFinalizeGraceMs);
   }
 
   private open(
@@ -1032,6 +1088,10 @@ class LiveCursorTransport implements CursorTransport {
     }
     this.turnStartedAt = Date.now();
     this.framesReceived = 0;
+    this.checkpointGraceExtended = false;
+    // A turn must not inherit the previous one's snapshot: a stale capture would make
+    // shouldExtendForCheckpointCapture skip the wait this turn actually needs.
+    this.capturedCheckpointBytes = undefined;
     this.sawAssistantText = false;
     this.emittedTerminal = false;
     this.firstFrameAt = undefined;
@@ -1450,6 +1510,18 @@ class LiveCursorTransport implements CursorTransport {
       } catch {
         this.capturedCheckpointBytes = undefined;
       }
+      // We are only still open because the grace was extended waiting for exactly this frame.
+      // Stop waiting, so a turn that does send a checkpoint pays arrival latency rather than the
+      // whole window. Deferred one tick so this frame finishes being mapped and pushed first;
+      // finalizing inline would emit the terminal events ahead of it.
+      if (this.checkpointGraceExtended && this.pendingFinalizeRun && this.capturedCheckpointBytes) {
+        const run = this.pendingFinalizeRun;
+        this.clearPendingFinalize();
+        this.pendingFinalize = setTimeout(run, 0);
+        // Keep the pair in step: clearPendingFinalize() drops the callback, and every other
+        // owner of pendingFinalize expects pendingFinalizeRun to describe it.
+        this.pendingFinalizeRun = run;
+      }
     }
     if (message.message.case === "kvServerMessage") {
       this.writeConnectFrame(encodeConnectFrame(handleCursorNativeKv(message.message.value, this.blobRequestScope)));

package/src/adapters/cursor.ts

@@ -24,9 +24,11 @@ import {
 import {
   commitCursorCheckpoint,
   cursorCheckpointRefHash,
+  cursorCheckpointShape,
   invalidateCursorCheckpoint,
 } from "./cursor/checkpoint-store";
 import { debugProviderDiagnostic } from "../lib/debug";
+import { isDebugEnabled } from "../lib/debug-settings";
 import { createAdapterTierMetadata } from "../providers/fastwire";
 import { estimateTokens } from "../lib/token-estimate";
 import { rememberCursorThreadConversation } from "./cursor/thread-continuity";
@@ -208,6 +210,10 @@ export function createCursorAdapter(provider: OcxProviderConfig, deps: CursorAda
               externalModel: isCursorExternalWireModel(activeRequest.modelId),
               storeCheckpoints: activeRequest.contextUsageStoreCheckpoints !== false,
               capturedBytes: lastTransport?.captured?.byteLength ?? 0,
+              // Byte length says nothing about coverage. `pendingToolCalls` does: it is what
+              // distinguishes a snapshot that knows about the suspended call from one that merely
+              // arrived after it (#4245). Counts only; the decode is skipped unless debug is on.
+              capturedShape: isDebugEnabled() ? cursorCheckpointShape(lastTransport?.captured) : undefined,
             });
             return;
           }

package/src/adapters/devin/cloud-direct/auth.ts

@@ -0,0 +1,264 @@
+/*
+ * Derived from rsvedant/opencode-windsurf-auth (src/cloud-direct/), MIT licensed,
+ * Copyright (c) 2026 Vedant. The full notice is in ./index.ts.
+ */
+/**
+ * Mint the short-lived `user_jwt` that accompanies the persistent OAuth-issued
+ * `api_key`. The catalog RPC uses it. The hosted chat path does not need it and
+ * only sends it when an operator opts in, so a mint failure here cannot take
+ * down a turn.
+ *
+ *   POST https://server.codeium.com/exa.auth_pb.AuthService/GetUserJwt
+ *   Content-Type: application/proto             ← unary, NOT streaming
+ *   Body: GetUserJwtRequest { metadata: Metadata }
+ *   Response: GetUserJwtResponse { user_jwt: string }  (field 1)
+ *
+ * The returned JWT has a payload like:
+ *   {
+ *     "api_key": "devin-synthetic-apikey$account-…$user-…",
+ *     "auth_uid": "devin-auth-uid$…",
+ *     "email": "user@example.com",
+ *     "exp": <unix-seconds>,         ← ~24 minute TTL
+ *     "pro": true,
+ *     "teams_tier": "TEAMS_TIER_DEVIN_PRO",
+ *     ...
+ *   }
+ *
+ * The JWT is signed HS256 by the server — can't be forged client-side. We
+ * cache it and refresh shortly before `exp`.
+ */
+
+import * as crypto from 'crypto';
+import { encodeMessage, iterFields } from './wire.js';
+import { buildMetadata } from './metadata.js';
+import { anySignal } from '../../../lib/abort.js';
+import { validateDevinApiBaseUrl } from '../../../oauth/devin/api-base.js';
+
+const DEFAULT_HOST = 'https://server.codeium.com';
+
+export interface MintedUserJwt {
+  jwt: string;
+  /** Unix epoch seconds when the JWT expires. */
+  expiresAt: number;
+}
+
+export class CloudAuthError extends Error {
+  constructor(message: string, public readonly status?: number) {
+    super(message);
+    this.name = 'CloudAuthError';
+  }
+}
+
+/**
+ * Default mint timeout — 30s is generous (the endpoint responds in ~200ms
+ * in steady state) but enough headroom for slow networks. Callers can pass
+ * a tighter `signal` to override.
+ */
+const MINT_TIMEOUT_MS = 30_000;
+
+/**
+ * Mint a fresh user_jwt by calling exa.auth_pb.AuthService/GetUserJwt.
+ * `host` defaults to https://server.codeium.com — pass your tenant URL if your
+ * RegisterUser response gave a different host.
+ *
+ * Always applies an internal 30s timeout so a network stall here can't
+ * deadlock every concurrent chat request. If the caller passes a `signal`,
+ * we honor whichever fires first via AbortSignal.any.
+ */
+export async function mintUserJwt(
+  apiKey: string,
+  host: string = DEFAULT_HOST,
+  signal?: AbortSignal,
+): Promise<MintedUserJwt> {
+  const metadata = buildMetadata({
+    apiKey,
+    sessionId: crypto.randomUUID(),
+    requestId: BigInt(Date.now()),
+    triggerId: crypto.randomUUID(),
+  });
+  // GetUserJwtRequest { metadata: Metadata }   — Metadata is field 1
+  const req = encodeMessage(1, metadata);
+
+  // Compose caller signal with our internal timeout via `anySignal` — a
+  // small polyfill of `AbortSignal.any` for runtimes (Node 18 / older
+  // Bun) that lack the built-in. The previous fallback silently dropped
+  // the CALLER's signal on those runtimes, so a chat-cancel during a
+  // GetUserJwt mint would keep the network request alive for up to the
+  // full 30s timeout.
+  const timeoutSignal = AbortSignal.timeout(MINT_TIMEOUT_MS);
+  const composed = signal ? anySignal([signal, timeoutSignal]) : undefined;
+  const combinedSignal: AbortSignal = composed?.signal ?? timeoutSignal;
+
+  // The host arrives from RegisterUser via the credential store. It is checked
+  // again here because this request carries the long-lived api_key inside the
+  // protobuf body, and a host that slipped past persistence would exfiltrate it.
+  const base = validateDevinApiBaseUrl(host);
+  if (!base) {
+    throw new CloudAuthError(`Refusing to mint a user_jwt against a non-Cognition host.`);
+  }
+  let resp: Response;
+  try {
+    resp = await fetch(`${base}/exa.auth_pb.AuthService/GetUserJwt`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/proto',
+      'Connect-Protocol-Version': '1',
+    },
+    body: new Uint8Array(req),
+    // A redirect would replay this POST - whose body holds the api_key - at
+    // whatever host Location names.
+    redirect: 'error',
+    signal: combinedSignal,
+    });
+  } finally {
+    // The caller's signal belongs to a whole turn; do not keep a listener on it.
+    composed?.cleanup();
+  }
+  const buf = Buffer.from(await resp.arrayBuffer());
+
+  if (!resp.ok) {
+    // The body is not echoed. A Connect error here can quote the request, and
+    // the request contains the api_key; this message reaches CLI output, the
+    // adapter's error event, and /api/logs.
+    throw new CloudAuthError(`GetUserJwt failed (HTTP ${resp.status})`, resp.status);
+  }
+
+  // Response is GetUserJwtResponse { user_jwt: string } where user_jwt is
+  // field 1, length-delimited. Decode the field properly instead of
+  // regex-scanning the whole buffer — the previous regex would pick up
+  // any JWT-shaped substring in the response (trace IDs, signature
+  // headers, any cached token inadvertently logged) and could even land
+  // on a non-user_jwt if Cognition ever embeds another JWT in a sibling
+  // field.
+  let jwt: string | null = null;
+  for (const f of iterFields(buf)) {
+    if (f.num === 1 && f.wire === 2 && Buffer.isBuffer(f.value)) {
+      const s = (f.value as Buffer).toString('utf8');
+      // Sanity-check the shape — defensive: if the cloud ever moves user_jwt
+      // out from field 1 we want a clean error, not silently wrong creds.
+      // base64url with OPTIONAL `=` padding on each segment. Most modern
+      // JWTs omit the `=`, but the spec allows it and a future server-side
+      // change could re-introduce it; either way it's still a valid token.
+      if (/^eyJ[A-Za-z0-9_-]{10,}={0,2}\.[A-Za-z0-9_-]+={0,2}\.[A-Za-z0-9_-]+={0,2}$/.test(s)) {
+        jwt = s;
+        break;
+      }
+    }
+  }
+  if (!jwt) {
+    throw new CloudAuthError(
+      // Same reason: a 200 whose field-1 value failed the shape check may still
+      // be a live token, so only the size is reported.
+      `GetUserJwt returned 200 without a usable field-1 JWT (${buf.length} bytes)`,
+    );
+  }
+
+  // Decode the payload to get the expiry.
+  let expiresAt = Math.floor(Date.now() / 1000) + 600;   // fallback: 10 min
+  try {
+    const parts = jwt.split('.');
+    const pad = (s: string) => s + '='.repeat((4 - (s.length % 4)) % 4);
+    const payload = JSON.parse(
+      Buffer.from(pad(parts[1]).replace(/-/g, '+').replace(/_/g, '/'), 'base64').toString('utf8'),
+    );
+    if (typeof payload.exp === 'number') expiresAt = payload.exp;
+  } catch { /* fall back to default */ }
+
+  return { jwt, expiresAt };
+}
+
+// ----------------------------------------------------------------------------
+// In-memory cache — refresh ~60s before expiry
+// ----------------------------------------------------------------------------
+
+interface CacheEntry {
+  jwt: string;
+  expiresAt: number;
+  apiKey: string;
+  host: string;
+}
+
+/**
+ * Cache is keyed by (apiKey, host). A single shared `cache` slot only holds
+ * the MOST RECENTLY USED entry — common case is one account at a time, so
+ * a single slot is enough. inFlight is a per-key map so a JWT mint for
+ * account A doesn't get returned to a concurrent request for account B.
+ *
+ * Previously `inFlight` was a singleton — if account A's mint was in flight
+ * and a request for account B arrived, B got A's JWT. That's the M1
+ * "concurrent requests after account switch get wrong JWT" bug.
+ */
+let cache: CacheEntry | null = null;
+const inFlight = new Map<string, Promise<MintedUserJwt>>();
+/**
+ * Monotonic epoch counter. Incremented on every `clearCachedUserJwt()`
+ * call so an in-flight mint that started BEFORE the clear can't
+ * repopulate the cache after-the-fact. Without this, a logout that
+ * happened concurrently with a mint would silently get its just-
+ * invalidated JWT cached and served for the next ~24 minutes.
+ */
+let cacheEpoch = 0;
+
+function flightKey(apiKey: string, host: string): string {
+  return `${host}\x1f${apiKey}`;
+}
+
+/**
+ * Get a cached user_jwt or mint a new one. Refreshes when the cached JWT is
+ * within 60s of expiry. Multiple concurrent callers for the SAME (apiKey, host)
+ * share the same in-flight mint; concurrent callers for DIFFERENT keys each
+ * get their own mint.
+ */
+export async function getCachedUserJwt(apiKey: string, host: string = DEFAULT_HOST, signal?: AbortSignal): Promise<string> {
+  const now = Math.floor(Date.now() / 1000);
+  if (cache && cache.apiKey === apiKey && cache.host === host && cache.expiresAt > now + 60) {
+    return cache.jwt;
+  }
+  // Race the caller's signal against the shared promise so one caller's
+  // cancellation doesn't propagate to unrelated callers sharing the mint.
+  // mintUserJwt has its own MINT_TIMEOUT_MS guard for the shared lifetime.
+  const raceSignal = <T>(p: Promise<T>): Promise<T> =>
+    signal
+      ? Promise.race([
+          p,
+          new Promise<T>((_, reject) => {
+            if (signal.aborted) reject(signal.reason);
+            else signal.addEventListener('abort', () => reject(signal.reason), { once: true });
+          }),
+        ])
+      : p;
+  const key = flightKey(apiKey, host);
+  const existing = inFlight.get(key);
+  if (existing) {
+    const minted = await raceSignal(existing);
+    return minted.jwt;
+  }
+  const promise = mintUserJwt(apiKey, host);
+  inFlight.set(key, promise);
+  // Snapshot the epoch BEFORE awaiting the mint. If clearCachedUserJwt()
+  // fires while we're awaiting (logout-during-mint), the epoch changes
+  // and we won't repopulate the cache with the just-invalidated JWT.
+  const epochAtStart = cacheEpoch;
+  try {
+    const minted = await raceSignal(promise);
+    if (cacheEpoch === epochAtStart) {
+      cache = { jwt: minted.jwt, expiresAt: minted.expiresAt, apiKey, host };
+    }
+    return minted.jwt;
+  } finally {
+    inFlight.delete(key);
+  }
+}
+
+/**
+ * Drop the in-memory JWT cache. Call after credential changes (logout,
+ * account switch) so long-running opencode processes don't keep using a
+ * JWT minted from a now-invalid api_key. Also bumps the cache epoch so
+ * any in-flight mint racing with this clear can't repopulate cache
+ * with the stale JWT after-the-fact.
+ */
+export function clearCachedUserJwt(): void {
+  cache = null;
+  inFlight.clear();
+  cacheEpoch++;
+}