@yansigit/opencodex 2.33.0 → 2.35.0

package/src/adapters/command-code.ts

@@ -7,6 +7,7 @@ import { isAllowedToolChoice, namespacedToolName, resolveToolChoiceWireName, too
 import type { AdapterFetchContext, AdapterRequest, ProviderAdapter } from "./base";
 import type { TranslatorBudget } from "../lib/translator-budget";
 import { readBoundedResponseBody } from "../lib/bounded-body";
+import { debugDroppedFrame } from "../lib/debug";
 import { configuredReasoningEfforts } from "../reasoning-effort";
 import { commandCodeReasoningEfforts, refreshCommandCodeReasoningEfforts } from "../providers/command-code-efforts";
 import { identifyRoutedModel } from "./identity";
@@ -33,9 +34,9 @@ export function formatCommandCodeErrorBody(_status: number, _headers: Headers, p
     const payload = JSON.parse(payloadText) as unknown;
     if (!payload || typeof payload !== "object" || Array.isArray(payload)) return "";
     const error = (payload as Record<string, unknown>).error;
-    const message = error && typeof error === "object" && !Array.isArray(error)
+    const message = (error && typeof error === "object" && !Array.isArray(error)
       ? (error as Record<string, unknown>).message
-      : undefined;
+      : undefined) ?? (payload as Record<string, unknown>).message;
     return typeof message === "string" && message.trim()
       ? redactSecretString(message.trim()).slice(0, 400)
       : "";
@@ -161,7 +162,8 @@ function wireMessages(messages: OcxMessage[]): Array<Record<string, unknown>> {
     if (typeof message.content === "string") content.push({ type: "text", text: message.content });
     else for (const part of message.content) {
       if (part.type === "text") content.push({ type: "text", text: part.text });
-      else content.push(wireImagePart(part.imageUrl));
+      else if (part.type === "image") content.push(wireImagePart(part.imageUrl));
+      else content.push({ type: "text", text: "[video]" });
     }
     out.push({ role: "user", content });
   }
@@ -174,13 +176,17 @@ function visibleTools(parsed: OcxParsedRequest): OcxTool[] {
   if (choice === "none") return [];
   const tools = parsed.context.tools ?? [];
   if (isAllowedToolChoice(choice)) {
-    return tools.filter(toolChoiceToolPredicate(choice, tools));
+    return tools
+      .filter(toolChoiceToolPredicate(choice, tools))
+      .sort((left, right) => namespacedToolName(left.namespace, left.name).localeCompare(namespacedToolName(right.namespace, right.name)));
   }
   if (choice && typeof choice !== "string") {
     const selected = resolveToolChoiceWireName(tools, choice.name);
-    return tools.filter(tool => namespacedToolName(tool.namespace, tool.name) === selected);
+    return tools
+      .filter(tool => namespacedToolName(tool.namespace, tool.name) === selected)
+      .sort((left, right) => namespacedToolName(left.namespace, left.name).localeCompare(namespacedToolName(right.namespace, right.name)));
   }
-  return tools;
+  return [...tools].sort((left, right) => namespacedToolName(left.namespace, left.name).localeCompare(namespacedToolName(right.namespace, right.name)));
 }
 
 function toolChoiceInstruction(parsed: OcxParsedRequest): string | undefined {
@@ -211,6 +217,9 @@ function currentWorkingDirectory(): string | undefined {
 
 /** Cap the workspace listing so a large directory does not ship every entry name upstream. */
 const MAX_WORKSPACE_STRUCTURE_ENTRIES = 64;
+/** Cap directory entries scanned while selecting the stable workspace prefix. */
+export const MAX_WORKSPACE_STRUCTURE_SCAN_ENTRIES = 4096;
+// ponytail: the bounded scan trades complete directory coverage for request latency; raise only with measured need.
 /** Cap how many recent commit subjects the config carries. */
 const MAX_RECENT_COMMITS = 8;
 /** Cap each recent commit entry to keep the request bounded even for long subjects. */
@@ -227,22 +236,44 @@ function projectSlug(cwd: string): string {
   return cwd.replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-|-$/g, "").toLowerCase().slice(0, 64) || "workspace";
 }
 
+function firstUserText(parsed: OcxParsedRequest): string | undefined {
+  for (const msg of parsed.context.messages) {
+    if (msg.role !== "user") continue;
+    if (typeof msg.content === "string") return msg.content;
+    const first = msg.content.find(part => part.type === "text" && typeof part.text === "string");
+    if (first && first.type === "text") return first.text;
+  }
+  return undefined;
+}
+
 export function commandCodeSessionId(parsed: OcxParsedRequest): string {
+  if (parsed._commandCodeSessionId) return parsed._commandCodeSessionId;
   // Shared prompt-cache cohorts intentionally do not identify one conversation. Keep them out
   // of upstream session affinity or unrelated conversations can pin to the same worker.
   const threadId = parsed._clientThreadId?.trim();
   const replayId = parsed._reasoningReplayScope?.clientThreadId?.trim();
+  const cursorId = parsed._cursorConversationId?.trim();
   const cacheKey = !parsed._promptCacheKeyIsSharedCohort ? parsed.options.promptCacheKey?.trim() : undefined;
+  const rootText = firstUserText(parsed);
   const identity = threadId
     ? ["thread", threadId]
     : replayId
       ? ["replay", replayId]
-      : cacheKey
-        ? ["cache", cacheKey]
-        : undefined;
-  if (!identity) return randomUUID();
-  const hex = createHash("sha256").update(`command-code:${identity[0]}\0${identity[1]}`).digest("hex");
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-8${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
+      : cursorId
+        ? ["cursor", cursorId]
+        : cacheKey
+          ? ["cache", cacheKey]
+          : rootText
+            ? ["root", rootText]
+            : undefined;
+  const sessionId = !identity
+    ? randomUUID()
+    : (() => {
+      const hex = createHash("sha256").update(`command-code:${identity[0]}\0${identity[1]}`).digest("hex");
+      return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-8${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
+    })();
+  parsed._commandCodeSessionId = sessionId;
+  return sessionId;
 }
 
 interface GitWorkspaceInfo {
@@ -254,6 +285,8 @@ interface GitWorkspaceInfo {
 }
 
 export const workspaceMetadataCache = new Map<string, { collectedAt: number; value: GitWorkspaceInfo }>();
+export const workspaceConfigCache = new Map<string, { collectedAt: number; value: Record<string, unknown>; sessionId?: string }>();
+export const SESSION_WORKSPACE_CONFIG_TTL_MS = 60 * 60_000;
 
 /**
  * Evict expired entries first, then the oldest live entry if at capacity.
@@ -280,6 +313,34 @@ export function pruneWorkspaceMetadataCache(now: number): void {
   }
 }
 
+export function pruneWorkspaceConfigCache(now: number): void {
+  for (const [key, entry] of workspaceConfigCache) {
+    if (!entry.sessionId && now - entry.collectedAt >= WORKSPACE_METADATA_TTL_MS) {
+      workspaceConfigCache.delete(key);
+    }
+  }
+  if (workspaceConfigCache.size >= MAX_WORKSPACE_METADATA_ENTRIES) {
+    let oldestKey: string | null = null;
+    let oldestAt = Infinity;
+    for (const [key, entry] of workspaceConfigCache) {
+      if (entry.sessionId) continue;
+      if (entry.collectedAt < oldestAt) {
+        oldestAt = entry.collectedAt;
+        oldestKey = key;
+      }
+    }
+    if (oldestKey === null) {
+      for (const [key, entry] of workspaceConfigCache) {
+        if (entry.collectedAt < oldestAt) {
+          oldestAt = entry.collectedAt;
+          oldestKey = key;
+        }
+      }
+    }
+    if (oldestKey !== null) workspaceConfigCache.delete(oldestKey);
+  }
+}
+
 const execFile = promisify(execFileCallback);
 
 /** Best-effort git metadata for the upstream config contract; every read fails safe and stays off the event loop. */
@@ -316,32 +377,53 @@ async function gitWorkspaceInfo(cwd: string | undefined): Promise<GitWorkspaceIn
   return value;
 }
 
-async function commandCodeConfig(cwd: string | undefined): Promise<Record<string, unknown>> {
+export async function commandCodeConfig(cwd: string | undefined, sessionId?: string): Promise<Record<string, unknown>> {
+  const cacheKey = sessionId ? `${sessionId}:${cwd ?? ""}` : (cwd ?? "");
+  const now = Date.now();
+  const cached = cacheKey ? workspaceConfigCache.get(cacheKey) : undefined;
+  if (cacheKey) {
+    if (cached && (sessionId || now - cached.collectedAt < WORKSPACE_METADATA_TTL_MS)) return cached.value;
+  }
   let structure: string[] = [];
   if (cwd) {
     try {
-      // Iterate and stop after the cap instead of materializing every entry: a directory with a
-      // huge number of names must not stall the request path for 64 metadata rows.
+      // Keep only the lexicographically smallest entries within the bounded scan so filesystem
+      // enumeration order cannot change the selected prefix for the scanned portion.
       const dir = await opendir(cwd);
       try {
-        for await (const entry of dir) {
+        const entries = dir[Symbol.asyncIterator]();
+        for (let scanned = 0; scanned < MAX_WORKSPACE_STRUCTURE_SCAN_ENTRIES; scanned += 1) {
+          const next = await entries.next();
+          if (next.done) break;
+          const entry = next.value;
           if (entry.name.startsWith(".")) continue;
           structure.push(entry.name);
-          if (structure.length >= MAX_WORKSPACE_STRUCTURE_ENTRIES) break;
+          if (structure.length > MAX_WORKSPACE_STRUCTURE_ENTRIES) {
+            structure.sort();
+            structure.pop();
+          }
         }
       } finally {
         await dir.close().catch(() => undefined);
       }
     } catch { /* workspace metadata is optional */ }
   }
+  structure.sort();
   const git = await gitWorkspaceInfo(cwd);
-  return {
+  const value = {
     ...(cwd ? { workingDir: cwd } : {}),
-    date: new Date().toISOString().slice(0, 10),
+    date: sessionId && typeof cached?.value.date === "string"
+      ? cached.value.date
+      : new Date(now).toISOString().slice(0, 10),
     environment: process.platform,
     structure,
     ...git,
   };
+  if (cacheKey) {
+    if (!workspaceConfigCache.has(cacheKey)) pruneWorkspaceConfigCache(now);
+    workspaceConfigCache.set(cacheKey, { collectedAt: now, value, ...(sessionId ? { sessionId } : {}) });
+  }
+  return value;
 }
 
 function usage(value: unknown): OcxUsage | undefined {
@@ -401,7 +483,7 @@ async function*ndjson(response: Response, budget: TranslatorBudget): AsyncGenera
       let newline = buffer.indexOf("\n");
       while (newline >= 0) {
         const line = buffer.slice(0, newline).trim(); buffer = buffer.slice(newline + 1);
-        if (line) { try { yield JSON.parse(stripEventFrame(line)) as Record<string, unknown>; } catch { /* ignore non-events */ } }
+        if (line) yield* decodeEventLine(line);
         newline = buffer.indexOf("\n");
       }
       const residualBytes = encoder.encode(buffer).byteLength;
@@ -412,7 +494,7 @@ async function*ndjson(response: Response, budget: TranslatorBudget): AsyncGenera
       if (done) break;
     }
     const final = buffer.trim();
-    if (final) { try { yield JSON.parse(stripEventFrame(final)) as Record<string, unknown>; } catch { /* ignore */ } }
+    if (final) yield* decodeEventLine(final);
   } finally {
     budget.releaseRetained(bufferBytes, { kind: "live_transient" });
     try { await reader.cancel(); } catch { /* already closed */ }
@@ -420,6 +502,41 @@ async function*ndjson(response: Response, budget: TranslatorBudget): AsyncGenera
   }
 }
 
+/**
+ * Yield one NDJSON line as an event record, or nothing.
+ *
+ * `JSON.parse("null")` returns `null` instead of throwing, so the `try/catch` around the parse
+ * cannot see it and the `event.type` read in parseStream crashed the turn — the #1219 defect, on
+ * the one streaming transport the #1240 audit did not cover because it is NDJSON rather than SSE.
+ *
+ * A frame that does not parse to a record is padding, not an event: drop it and continue exactly
+ * as an unparseable line is already dropped, so a stream whose only frames are junk ends in the
+ * same single terminal `done` as an empty body. Skipping is what preserves an answer whose deltas
+ * have already arrived — the observed #1219 case is `null` padding BETWEEN content deltas, where
+ * terminating would discard a complete response (#1240).
+ *
+ * Note this deliberately makes a junk-only stream a quiet `[done]` where it previously threw. That
+ * throw was an unguarded type assumption, not a designed failure signal, and `[done]` is already
+ * what an empty body, a blank-line-only body and an unparseable-only body all produce here. The
+ * broader question — whether this adapter should report *any* no-valid-event stream as a failure
+ * rather than an empty success — is pre-existing, applies to all four of those inputs equally, and
+ * is deliberately not decided by this change.
+ */
+function* decodeEventLine(line: string): Generator<Record<string, unknown>> {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(stripEventFrame(line));
+  } catch {
+    debugDroppedFrame("command-code", line);
+    return;
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    debugDroppedFrame("command-code", line);
+    return;
+  }
+  yield parsed as Record<string, unknown>;
+}
+
 /** The endpoint is newline-delimited JSON; defensively strip an SSE `data:` frame if the gateway ever switches shapes. */
 function stripEventFrame(line: string): string {
   return line.startsWith("data:") ? line.slice("data:".length).trim() : line;
@@ -490,6 +607,7 @@ export function createCommandCodeAdapter(provider: OcxProviderConfig): ProviderA
     async buildRequest(parsed: OcxParsedRequest): Promise<AdapterRequest> {
       if (!provider.apiKey) throw new Error("Command Code credential missing — run ocx login command-code");
       const cwd = currentWorkingDirectory();
+      const sessionId = commandCodeSessionId(parsed);
       const tools = visibleTools(parsed);
       const toolNudge = buildNonOpenAIToolCatalogNudgeForTools(tools, parsed.options.toolChoice);
       const choiceInstruction = toolChoiceInstruction(parsed);
@@ -500,7 +618,7 @@ export function createCommandCodeAdapter(provider: OcxProviderConfig): ProviderA
       ].join("\n\n"), parsed.modelId);
       const reasoningEffort = supportedCommandCodeEffort(provider, parsed.modelId, parsed.options.reasoning);
       const body = {
-        config: await commandCodeConfig(cwd), memory: "", taste: null, skills: null,
+        config: await commandCodeConfig(cwd, sessionId), memory: "", taste: null, skills: null,
         permissionMode: "standard", mode: "agent",
         params: {
           model: canonicalCommandCodeModelId(parsed.modelId),
@@ -523,7 +641,7 @@ export function createCommandCodeAdapter(provider: OcxProviderConfig): ProviderA
         "x-cli-environment": "production",
         "x-taste-learning": "false",
         "x-co-flag": "false",
-        "x-session-id": commandCodeSessionId(parsed),
+        "x-session-id": sessionId,
       };
       if (cwd) headers["x-project-slug"] = projectSlug(cwd);
       return {

package/src/adapters/cursor/call-id.ts

@@ -0,0 +1,44 @@
+/**
+ * Reversible single-line codec for Cursor composite tool-call ids.
+ *
+ * Cursor's wire delivers tool-call ids that can be two identifiers glued with a
+ * literal newline ("call-<uuid>-<n>\nfc_<uuid>_<n>"). OpenCodex forwards ids
+ * verbatim, so that newline leaked into Responses-visible `call_id` values,
+ * where line-oriented clients (logging, splitting, validation) break. The codec
+ * encodes only ids containing CR/LF into a versioned single-line form and
+ * decodes both that form and legacy raw multi-line ids back to the exact
+ * upstream bytes before anything is serialized toward Cursor.
+ */
+
+const CALL_ID_PREFIX = "ocxc1_";
+
+/** True when the id needs encoding to survive line-oriented consumers. */
+function needsEncoding(id: string): boolean {
+  return id.includes("\n") || id.includes("\r");
+}
+
+/** Encode a Cursor wire call id into a single-line Responses-safe id. */
+export function encodeCursorCallId(id: string): string {
+  if (!needsEncoding(id)) return id;
+  return CALL_ID_PREFIX + Buffer.from(id, "utf8").toString("base64url");
+}
+
+/**
+ * Decode a Responses-visible call id back to the exact Cursor wire id.
+ * Non-encoded ids (including legacy raw multi-line ids replayed by older
+ * clients) pass through unchanged; a malformed encoded payload also passes
+ * through rather than corrupting pairing.
+ */
+export function decodeCursorCallId(id: string): string {
+  if (!id.startsWith(CALL_ID_PREFIX)) return id;
+  const payload = id.slice(CALL_ID_PREFIX.length);
+  if (payload.length === 0) return id;
+  try {
+    const decoded = Buffer.from(payload, "base64url").toString("utf8");
+    // Round-trip guard: only trust payloads our encoder could have produced.
+    if (Buffer.from(decoded, "utf8").toString("base64url") !== payload) return id;
+    return decoded;
+  } catch {
+    return id;
+  }
+}

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

@@ -236,6 +236,7 @@ export function commitCursorCheckpoint(input: {
 }
 
 export function getCursorCheckpointForPrefix(input: {
+  conversationId: string;
   prefixDigest: string;
   systemDigest: string;
   coveredMessageCount: number;
@@ -244,17 +245,21 @@ export function getCursorCheckpointForPrefix(input: {
 }): CursorCheckpointSnapshot | undefined {
   prune();
   const refs = store.prefixIndex.get(input.prefixDigest);
-  if (!refs || refs.size !== 1) return undefined;
-  const [ref] = refs;
-  if (!ref) return undefined;
-  const snapshot = getCursorCheckpoint(ref);
-  if (!snapshot) return undefined;
+  if (!refs) return undefined;
   const identityScope = input.identityScope?.trim() || "local";
-  if (snapshot.systemDigest !== input.systemDigest) return undefined;
-  if (snapshot.coveredMessageCount !== input.coveredMessageCount) return undefined;
-  if (snapshot.identityScope !== identityScope) return undefined;
-  if (snapshot.modelId !== input.modelId) return undefined;
-  return snapshot;
+  let foundRef: string | undefined;
+  for (const ref of refs) {
+    const snapshot = store.snapshots.get(ref);
+    if (!snapshot) continue;
+    if (snapshot.conversationId !== input.conversationId) continue;
+    if (snapshot.systemDigest !== input.systemDigest) continue;
+    if (snapshot.coveredMessageCount !== input.coveredMessageCount) continue;
+    if (snapshot.identityScope !== identityScope) continue;
+    if (snapshot.modelId !== input.modelId) continue;
+    if (foundRef) return undefined;
+    foundRef = ref;
+  }
+  return getCursorCheckpoint(foundRef);
 }
 
 export function getLatestCursorCheckpoint(

package/src/adapters/cursor/discovery.ts

@@ -1,7 +1,9 @@
 import {
   CANONICAL_EFFORT_SUFFIXES,
   cursorModelEffortLadder,
+  cursorModelHasEffortTiers,
   cursorWireModelIdWithEffort,
+  CURSOR_THINKING_MODEL_IDS,
 } from "./effort-map";
 
 export interface CursorModelInfo {
@@ -152,6 +154,25 @@ export function cursorCodexToWireModelId(modelId: string): string {
   return cursorWireModelSelection(modelId).modelId;
 }
 
+/**
+ * Synthetic ultra/big-context picker marker (devlog 260826 070). A `cursor/<base>-1m` row is a
+ * picker-only variant: the wire request keeps `<base>` (plus effort suffix) and turns on Cursor
+ * Max Mode instead. Only ids listed here are treated as synthetic — a real upstream wire id that
+ * happens to end in `-1m` never collides because it will not be in this set.
+ */
+export const CURSOR_ULTRA_1M_MODEL_IDS: ReadonlySet<string> = new Set([
+  "kimi-k3-1m",
+]);
+
+const CURSOR_ULTRA_1M_SUFFIX = "-1m";
+
+/** Resolve a synthetic ultra marker id to its wire base, or undefined for ordinary ids. */
+export function cursorUltraBaseModelId(modelId: string): string | undefined {
+  const normalized = modelId.startsWith("cursor/") ? modelId.slice("cursor/".length) : modelId;
+  if (!CURSOR_ULTRA_1M_MODEL_IDS.has(normalized)) return undefined;
+  return normalized.slice(0, -CURSOR_ULTRA_1M_SUFFIX.length);
+}
+
 /**
  * Cursor-native wire models keep server-side conversation state reliably.
  * External models (gpt/claude/gemini/grok families and similar) are more brittle on resumeAction.
@@ -212,10 +233,27 @@ export function filterCursorConfiguredModelsByLiveDiscovery<T extends { id: stri
   liveIds: readonly string[],
 ): T[] {
   return configured.filter(model =>
-    isCursorRouterModelId(model.id) || isCursorModelAvailableForAccount(model.id, liveIds),
+    !CURSOR_KNOWN_UNCALLABLE_MODEL_IDS.has(model.id)
+    && (
+      isCursorRouterModelId(model.id)
+      // Synthetic ultra rows ride their base model's account availability.
+      || isCursorModelAvailableForAccount(cursorUltraBaseModelId(model.id) ?? model.id, liveIds)
+    ),
   );
 }
 
+/**
+ * Models GetUsableModels advertises but whose every Run returns not_found (catalog honesty,
+ * devlog 260826_cursor_responses_gap 060). Live probes 2026-08-26: cursor/claude-opus-5 failed
+ * 100% ("Cursor Connect error not_found") while its -fast and -thinking siblings — separate
+ * wire families — succeed. Quarantined here, in the shared filter, so live, cached, stale, and
+ * static serving paths all agree. Custom user provider overrides are not routed through this
+ * canonical seed and stay untouched.
+ */
+export const CURSOR_KNOWN_UNCALLABLE_MODEL_IDS: ReadonlySet<string> = new Set([
+  "claude-opus-5",
+]);
+
 export const CURSOR_STATIC_MODELS: readonly CursorModelInfo[] = normalizeCursorModels([
   // Context windows and the model lineup mirror Cursor's public models/pricing docs plus the jawcode
   // SOT (../jawcode/packages/ai/src/models.json, `cursor` provider), which mirrors the real
@@ -243,7 +281,8 @@ export const CURSOR_STATIC_MODELS: readonly CursorModelInfo[] = normalizeCursorM
   { id: "claude-opus-4-7-fast", contextWindow: CONTEXT_200K, supportsReasoningEffort: true },
   { id: "claude-opus-4-8-fast", contextWindow: CONTEXT_200K, supportsReasoningEffort: true },
   { id: "claude-opus-4-8", contextWindow: CONTEXT_200K, supportsReasoningEffort: true },
-  { id: "claude-opus-5", contextWindow: CONTEXT_200K, supportsReasoningEffort: true },
+  // claude-opus-5 (bare) removed from the seed: GetUsableModels lists it but every Run returns
+  // not_found (quarantined via CURSOR_KNOWN_UNCALLABLE_MODEL_IDS; -fast/-thinking families stay).
   { id: "claude-opus-5-fast", contextWindow: CONTEXT_200K, supportsReasoningEffort: true },
   { id: "claude-fable-5", contextWindow: CONTEXT_200K, supportsReasoningEffort: true },
 
@@ -257,6 +296,21 @@ export const CURSOR_STATIC_MODELS: readonly CursorModelInfo[] = normalizeCursorM
   { id: "gemini-3-pro-image-preview", contextWindow: CONTEXT_200K },
   { id: "gemini-3.1-pro", contextWindow: CONTEXT_GEMINI },
   { id: "gemini-3.5-flash", contextWindow: CONTEXT_200K },
+  // 260825 live GetUsableModels: both ship only as effort-suffixed ids, so each exposes a tier
+  // picker. 3.6 is the only Cursor model with a `minimal` rung.
+  { id: "gemini-3.6-flash", contextWindow: CONTEXT_GEMINI, supportsReasoningEffort: true },
+  { id: "gemini-3.7-flash", contextWindow: CONTEXT_GEMINI, supportsReasoningEffort: true },
+
+  // Explicit-thinking variants (260825 live roster). Exposed as first-class ids the same way the
+  // Opus Fast families were in 831810c13: `isCursorModelAvailableForAccount` matches a base id
+  // against `{base}`, `{base}-{effort}` and the family's wire form, and none of those ever
+  // matched a `-thinking` id, so every one of these was invisible in the routed catalog.
+  // Suffix ORDER differs per family; `cursorWireModelIdWithEffort` owns that mapping.
+  ...CURSOR_THINKING_MODEL_IDS.map(id => ({
+    id,
+    contextWindow: CONTEXT_200K,
+    supportsReasoningEffort: cursorModelHasEffortTiers(id),
+  })),
 
   { id: "gpt-5-codex", contextWindow: CONTEXT_272K },
   { id: "gpt-5-fast", contextWindow: CONTEXT_272K },
@@ -291,6 +345,10 @@ export const CURSOR_STATIC_MODELS: readonly CursorModelInfo[] = normalizeCursorM
   // kimi-k3: cursor.com/docs/models/kimi-k3; account-verified via GetUsableModels (2026-07-28) —
   // ships only as effort-suffixed kimi-k3-{low,high,max}, so the tier picker is exposed.
   { id: "kimi-k3", contextWindow: CONTEXT_262K, supportsReasoningEffort: true },
+  // kimi-k3-1m: synthetic ultra/Max-Mode picker variant (CURSOR_ULTRA_1M_MODEL_IDS) — wire sends
+  // kimi-k3-<effort> with maxMode=true; 1M context user-verified live on the Ultra plan
+  // (devlog 260826_cursor_responses_gap/025). inferCursorContextWindow maps "1m" ids to 1M.
+  { id: "kimi-k3-1m", contextWindow: CONTEXT_1M, supportsReasoningEffort: true },
 
   { id: "grok-4.5", contextWindow: 500_000, supportsReasoningEffort: true },
   { id: "grok-4.5-fast", contextWindow: 500_000, supportsReasoningEffort: true },

package/src/adapters/cursor/effort-map.ts

@@ -34,12 +34,33 @@ const CURSOR_MODEL_EFFORT_TIERS: Record<string, readonly string[]> = {
   "claude-opus-5-fast": ["low", "medium", "high"],
   "claude-sonnet-5": ["low", "medium", "high", "xhigh", "max"],
   "glm-5.2": ["high", "max"],
+  // 260825 live GetUsableModels. gemini-3.6-flash is the only Cursor model exposing `minimal`;
+  // listing it here is also what admits the suffix into CANONICAL_EFFORT_SUFFIXES below.
+  "gemini-3.6-flash": ["minimal", "low", "medium", "high"],
+  "gemini-3.7-flash": ["low", "medium", "high"],
+  // Explicit-thinking variants (260825 live roster). Tiers are the rungs the wire actually
+  // lists for each family, which is not always the same set the non-thinking id carries:
+  // 4.6-opus thinks only at high/max, 4.5-opus only at high, 4.6-sonnet only at medium.
+  "claude-opus-5-thinking": ["low", "medium", "high", "xhigh", "max"],
+  "claude-opus-5-thinking-fast": ["low", "medium", "high", "xhigh", "max"],
+  "claude-opus-4-8-thinking": ["low", "medium", "high", "xhigh", "max"],
+  "claude-opus-4-8-thinking-fast": ["low", "medium", "high", "xhigh", "max"],
+  "claude-opus-4-7-thinking": ["low", "medium", "high", "xhigh", "max"],
+  "claude-opus-4-7-thinking-fast": ["low", "medium", "high", "xhigh", "max"],
+  "claude-sonnet-5-thinking": ["low", "medium", "high", "xhigh", "max"],
+  "claude-fable-5-thinking": ["low", "medium", "high", "xhigh", "max"],
+  "claude-4.6-opus-thinking": ["high", "max"],
+  "claude-4.5-opus-thinking": ["high"],
+  "claude-4.6-sonnet-thinking": ["medium"],
   // 260814 preemptive: glm-5.3 seeded ahead of Cursor's lineup update. Unlike 5.2, Z.AI folds
   // 5.3 efforts into low/high/max (docs.z.ai/devpack/latest-model), so `low` is a real tier.
   "glm-5.3": ["low", "high", "max"],
   // GetUsableModels (2026-07-28) lists kimi-k3 only as effort-suffixed kimi-k3-{low,high,max};
   // the bare id returns not_found. Tiers mirror the native Kimi provider's K3 ladder.
   "kimi-k3": ["low", "high", "max"],
+  // Synthetic ultra picker variant (devlog 260826 070): same tier ladder as kimi-k3; the -1m
+  // marker is stripped before wire-id composition, so these tiers never form a wire suffix.
+  "kimi-k3-1m": ["low", "high", "max"],
   // Cursor renamed the Grok 4.5 slugs to cursor-grok-4.5-{low,medium,high} and
   // cursor-grok-4.5-{low,medium,high}-fast. The bare Fast id returns not_found.
   "grok-4.5": ["low", "medium", "high"],
@@ -71,6 +92,46 @@ export const CANONICAL_EFFORT_SUFFIXES: ReadonlySet<string> = new Set([
 
 const CANONICAL_CODEX_EFFORT_ORDER = ["low", "medium", "high", "xhigh", "max"] as const;
 
+/**
+ * Cursor's explicit-thinking variants, exposed as first-class Codex model ids the same way the
+ * `-fast` families were.
+ *
+ * `source` is the id whose wire name the variant is built from; `order` is where Cursor puts the
+ * thinking marker relative to the effort rung. All three shapes exist in the live roster
+ * (GetUsableModels, 260825), and using the wrong one is rejected with ERROR_BAD_MODEL_NAME:
+ *
+ *   thinking-then-effort  claude-opus-5-thinking-high, claude-opus-5-thinking-high-fast
+ *   effort-then-thinking  claude-4.6-opus-high-thinking
+ *   bare                  claude-4.5-sonnet-thinking (the model has no effort rung)
+ */
+const CURSOR_THINKING_FAMILIES: Readonly<Record<string, { source: string; order: "thinking-then-effort" | "effort-then-thinking" | "bare" }>> = {
+  "claude-opus-5-thinking": { source: "claude-opus-5", order: "thinking-then-effort" },
+  "claude-opus-5-thinking-fast": { source: "claude-opus-5-fast", order: "thinking-then-effort" },
+  "claude-opus-4-8-thinking": { source: "claude-opus-4-8", order: "thinking-then-effort" },
+  "claude-opus-4-8-thinking-fast": { source: "claude-opus-4-8-fast", order: "thinking-then-effort" },
+  "claude-opus-4-7-thinking": { source: "claude-opus-4-7", order: "thinking-then-effort" },
+  "claude-opus-4-7-thinking-fast": { source: "claude-opus-4-7-fast", order: "thinking-then-effort" },
+  "claude-sonnet-5-thinking": { source: "claude-sonnet-5", order: "thinking-then-effort" },
+  "claude-fable-5-thinking": { source: "claude-fable-5", order: "thinking-then-effort" },
+  "claude-4.6-opus-thinking": { source: "claude-4.6-opus", order: "effort-then-thinking" },
+  "claude-4.5-opus-thinking": { source: "claude-4.5-opus", order: "effort-then-thinking" },
+  "claude-4.6-sonnet-thinking": { source: "claude-4.6-sonnet", order: "effort-then-thinking" },
+  "claude-4.5-sonnet-thinking": { source: "claude-4.5-sonnet", order: "bare" },
+  "claude-4-sonnet-thinking": { source: "claude-4-sonnet", order: "bare" },
+};
+
+/** Codex-facing ids for Cursor's explicit-thinking variants. */
+export const CURSOR_THINKING_MODEL_IDS = Object.keys(CURSOR_THINKING_FAMILIES);
+
+/**
+ * Picker order, which is the canonical ladder plus the declared sentinels that rank below `low`.
+ *
+ * `cursorModelEffortLadder` filters against this, so a tier absent from it is silently dropped
+ * from the Codex picker even though `cursorEffortSuffix` would happily send it. That is what
+ * hid `gemini-3.6-flash-minimal`, the one Cursor model with a `minimal` rung.
+ */
+const CURSOR_PICKER_EFFORT_ORDER = ["minimal", ...CANONICAL_CODEX_EFFORT_ORDER] as const;
+
 function normalizeRequestedEffort(reasoning: string | undefined): string | undefined {
   const normalized = reasoning?.toLowerCase();
   return normalized === "ultra" ? "max" : normalized;
@@ -119,7 +180,7 @@ export function cursorModelEffortLadder(baseModelId: string): string[] | undefin
   const tiers = CURSOR_MODEL_EFFORT_TIERS[baseModelId];
   if (!tiers || tiers.length === 0) return undefined;
   const tierSet = new Set(tiers);
-  return CANONICAL_CODEX_EFFORT_ORDER.filter(effort => tierSet.has(effort));
+  return CURSOR_PICKER_EFFORT_ORDER.filter(effort => tierSet.has(effort));
 }
 
 /** Base models known to carry a reasoning-effort suffix (everything else is sent bare). */
@@ -133,6 +194,23 @@ export function cursorModelHasEffortTiers(baseModelId: string): boolean {
  * and send the base model plus requested_model parameters instead.
  */
 export function cursorWireModelIdWithEffort(baseModelId: string, effortSuffix: string): string {
+  const thinking = CURSOR_THINKING_FAMILIES[baseModelId];
+  if (thinking) {
+    const { source, order } = thinking;
+    // Cursor writes the thinking marker on either side of the effort depending on family
+    // (measured against GetUsableModels, 260825):
+    //   thinking-then-effort  claude-opus-5-thinking-high, ...-thinking-high-fast
+    //   effort-then-thinking  claude-4.6-opus-high-thinking
+    //   bare                  claude-4.5-sonnet-thinking (no effort rung at all)
+    // Sending the wrong order returns ERROR_BAD_MODEL_NAME, so this is not cosmetic.
+    if (order === "bare") return `${source}-thinking`;
+    if (order === "effort-then-thinking") return `${source}-${effortSuffix}-thinking`;
+    if (source.endsWith("-fast")) {
+      const stem = source.slice(0, -"-fast".length);
+      return `${stem}-thinking-${effortSuffix}-fast`;
+    }
+    return `${source}-thinking-${effortSuffix}`;
+  }
   if (baseModelId.endsWith("-fast")) {
     return `${baseModelId.slice(0, -"-fast".length)}-${effortSuffix}-fast`;
   }