@bitkyc08/opencodex 2.40.0 → 2.42.0

package/src/adapters/cursor/catalog.ts

@@ -1,3 +1,9 @@
+import {
+  composeCursorClaudeWireId,
+  normalizeCursorClaudeId,
+  type NormalizedCursorClaudeId,
+} from "./claude-id";
+
 /**
  * Cursor umbrella catalog — the single source of truth for cursor model
  * identities (devlog 260828_cursor_umbrella_catalog).
@@ -120,12 +126,8 @@ export const CURSOR_CAPABILITIES: Record<string, CursorCapability> = {
       thinking: { levels: FULL, order: T },
     },
   },
-  // 260902 preemptive: Claude Fable 5.1 seeded ahead of Cursor's lineup update, mirroring
-  // claude-fable-5 (same 1M window and full effort ladder). Cursor has spelled Claude ids
-  // both Anthropic-style (`claude-opus-4-7`, thinking-then-effort) and version-first
-  // (`claude-4.6-opus`, effort-then-thinking), so all three plausible spellings are seeded;
-  // the live GetUsableModels filter drops whichever the roster does not expose. Collapse to
-  // the one real spelling once it is observed.
+  // Claude Fable 5.1 has one canonical capability row. Saved aliases and the live roster's
+  // exact spelling are normalized and round-tripped at the adapter boundary.
   "claude-fable-5-1": {
     displayName: "Claude Fable 5.1",
     window: CONTEXT_1M,
@@ -135,24 +137,6 @@ export const CURSOR_CAPABILITIES: Record<string, CursorCapability> = {
       thinking: { levels: FULL, order: T },
     },
   },
-  "claude-fable-5.1": {
-    displayName: "Claude Fable 5.1",
-    window: CONTEXT_1M,
-    defaultVariant: "thinking",
-    variants: {
-      regular: { levels: FULL },
-      thinking: { levels: FULL, order: T },
-    },
-  },
-  "claude-5.1-fable": {
-    displayName: "Claude Fable 5.1",
-    window: CONTEXT_1M,
-    defaultVariant: "thinking",
-    variants: {
-      regular: { levels: FULL },
-      thinking: { levels: FULL, order: E },
-    },
-  },
   "claude-sonnet-5": {
     displayName: "Claude Sonnet 5",
     window: CONTEXT_1M,
@@ -221,6 +205,12 @@ export const CURSOR_CAPABILITIES: Record<string, CursorCapability> = {
     defaultVariant: "regular",
     variants: { regular: { levels: ["low", "medium", "high"] } },
   },
+  "gemini-3.8-flash": {
+    displayName: "Gemini 3.8 Flash",
+    window: CONTEXT_GEMINI,
+    defaultVariant: "regular",
+    variants: { regular: { levels: ["low", "medium", "high"] } },
+  },
   "kimi-k3": {
     displayName: "Kimi K3",
     window: CONTEXT_1M,
@@ -382,13 +372,26 @@ const REAL_1M_WIRE_IDS: ReadonlySet<string> = new Set(["claude-4-sonnet-1m"]);
 
 export function parseCursorVariantId(rawId: string): ParsedCursorVariantId {
   const id = rawId.trim();
+  if (REAL_1M_WIRE_IDS.has(id)) {
+    return { baseId: id, kind: "regular", ultra: false, known: false };
+  }
+  const claude = normalizeCursorClaudeId(id);
+  if (claude && CURSOR_CAPABILITIES[claude.canonicalBaseId]) {
+    const explicitVariant = claude.thinking || claude.fast || claude.level !== undefined;
+    return {
+      baseId: claude.canonicalBaseId,
+      kind: explicitVariant
+        ? claude.thinking ? (claude.fast ? "thinkingFast" : "thinking") : claude.fast ? "fast" : "regular"
+        : defaultKindFor(claude.canonicalBaseId),
+      ...(claude.level ? { level: claude.level } : {}),
+      ultra: false,
+      known: true,
+    };
+  }
   // 1. Exact base identity.
   if (CURSOR_CAPABILITIES[id]) {
     return { baseId: id, kind: defaultKindFor(id), ultra: false, known: true };
   }
-  if (REAL_1M_WIRE_IDS.has(id)) {
-    return { baseId: id, kind: "regular", ultra: false, known: false };
-  }
   // 2. cursor- wire prefix (regular grok wire forms).
   if (id.startsWith("cursor-")) {
     const inner = parseCursorVariantId(id.slice("cursor-".length));
@@ -537,17 +540,32 @@ export interface CursorResolvedSelection {
   readonly known: boolean;
 }
 
+type CursorLiveClaudeWireIdentity = Pick<NormalizedCursorClaudeId, "sourceBaseId" | "spelling">;
+
 /**
  * Compose a variant's flattened wire id, reproducing the legacy effort-map
  * order rules exactly (thinking-then-effort / effort-then-thinking / bare;
  * fast marker terminal; wrong order is ERROR_BAD_MODEL_NAME on the wire).
  */
-function composeWireId(baseId: string, kind: CursorVariantKind, effort: string | undefined): string {
+function composeWireId(
+  baseId: string,
+  kind: CursorVariantKind,
+  effort: string | undefined,
+  claudeIdentity?: CursorLiveClaudeWireIdentity,
+): string {
   const capability = CURSOR_CAPABILITIES[baseId];
   const spec = capability?.variants[kind];
   if (!capability || !spec) return baseId;
   const thinking = kind === "thinking" || kind === "thinkingFast";
   const fast = kind === "fast" || kind === "thinkingFast";
+  if (claudeIdentity) {
+    return composeCursorClaudeWireId(claudeIdentity, {
+      thinking,
+      fast,
+      effort,
+      bareThinking: spec.order === "bare",
+    });
+  }
   if (thinking) {
     const order = spec.order ?? "thinking-then-effort";
     if (order === "bare" || effort === undefined) return `${baseId}-thinking`;
@@ -587,7 +605,12 @@ export function resolveCursorSelection(
   }
   const requested = parsed.level ?? reasoning;
   const effort = cursorVariantEffort(spec, requested);
-  const canonicalId = composeWireId(parsed.baseId, kind, effort);
+  const requestedClaude = normalizeCursorClaudeId(pickedId);
+  const claudeIdentity = liveCursorClaudeWireIdentities.get(parsed.baseId)
+    ?? (requestedClaude
+      ? { sourceBaseId: requestedClaude.sourceBaseId, spelling: requestedClaude.spelling }
+      : undefined);
+  const canonicalId = composeWireId(parsed.baseId, kind, effort, claudeIdentity);
   const wireId = capability.wirePrefix && kind === "regular"
     ? `${capability.wirePrefix}${canonicalId}`
     : canonicalId;
@@ -604,6 +627,25 @@ export function resolveCursorSelection(
  * arrives — never from window size (devlog 260828 blocker-4 fold).
  */
 let liveCursorMaxModeBases: ReadonlySet<string> = new Set();
+let liveCursorClaudeWireIdentities: ReadonlyMap<string, CursorLiveClaudeWireIdentity> = new Map();
+
+export function recordLiveCursorClaudeModels(liveIds: readonly string[]): void {
+  const next = new Map<string, CursorLiveClaudeWireIdentity>();
+  for (const rawId of liveIds) {
+    const n = normalizeCursorClaudeId(rawId.startsWith("cursor-") ? rawId.slice(7) : rawId);
+    if (!n || !CURSOR_CAPABILITIES[n.canonicalBaseId]) continue;
+    if (!next.has(n.canonicalBaseId)) next.set(n.canonicalBaseId, { sourceBaseId: n.sourceBaseId, spelling: n.spelling });
+  }
+  liveCursorClaudeWireIdentities = next;
+}
+
+export function liveCursorClaudeWireIdentitiesForTests(): ReadonlyMap<string, CursorLiveClaudeWireIdentity> {
+  return liveCursorClaudeWireIdentities;
+}
+
+export function resetLiveCursorClaudeWireIdentitiesForTests(): void {
+  liveCursorClaudeWireIdentities = new Map();
+}
 
 export function recordLiveCursorMaxModeModels(liveIds: readonly string[]): void {
   const bases = new Set<string>();

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

@@ -0,0 +1,76 @@
+export type CursorClaudeSpelling = "anthropic" | "version-first";
+
+export interface NormalizedCursorClaudeId {
+  /** The sole key used by CURSOR_CAPABILITIES and pricing metadata. */
+  canonicalBaseId: string;
+  /** Exact input stem, preserving `5-1` versus `5.1` for wire round-trips. */
+  sourceBaseId: string;
+  spelling: CursorClaudeSpelling;
+  thinking: boolean;
+  fast: boolean;
+  level?: string;
+}
+
+const CLAUDE_LEVELS = new Set(["none", "minimal", "low", "medium", "high", "xhigh", "max", "extra-high"]);
+
+/** Existing picker bases whose canonical key stays version-first (saved configs). */
+const VERSION_FIRST_CANONICAL_BASES = new Set([
+  "claude-4.5-haiku", "claude-4.5-opus", "claude-4.6-opus", "claude-4.5-sonnet", "claude-4.6-sonnet", "claude-4-sonnet",
+]);
+
+function parseClaudeBase(raw: string): { canonicalBaseId: string; sourceBaseId: string; spelling: CursorClaudeSpelling } | undefined {
+  const anthropic = /^claude-(fable|haiku|opus|sonnet)-(\d+(?:[.-]\d+)*)$/.exec(raw);
+  if (anthropic) {
+    const family = anthropic[1]!;
+    const version = anthropic[2]!.replaceAll(".", "-");
+    const versionFirst = `claude-${version.replaceAll("-", ".")}-${family}`;
+    return {
+      canonicalBaseId: VERSION_FIRST_CANONICAL_BASES.has(versionFirst) ? versionFirst : `claude-${family}-${version}`,
+      sourceBaseId: raw,
+      spelling: "anthropic",
+    };
+  }
+  const versionFirst = /^claude-(\d+(?:\.\d+)*)-(fable|haiku|opus|sonnet)$/.exec(raw);
+  if (!versionFirst) return undefined;
+  const sourceBaseId = `claude-${versionFirst[1]!}-${versionFirst[2]!}`;
+  return {
+    canonicalBaseId: VERSION_FIRST_CANONICAL_BASES.has(sourceBaseId) ? sourceBaseId : `claude-${versionFirst[2]!}-${versionFirst[1]!.replaceAll(".", "-")}`,
+    sourceBaseId,
+    spelling: "version-first",
+  };
+}
+
+export function normalizeCursorClaudeId(raw: string): NormalizedCursorClaudeId | undefined {
+  const id = raw.trim().toLowerCase();
+  const patterns: ReadonlyArray<readonly [RegExp, (m: RegExpExecArray) => { base: string; thinking: boolean; fast: boolean; level?: string }]> = [
+    [/^(.*)-thinking-([a-z-]+)-fast$/, m => ({ base: m[1]!, thinking: true, fast: true, level: m[2]! })],
+    [/^(.*)-([a-z-]+)-thinking-fast$/, m => ({ base: m[1]!, thinking: true, fast: true, level: m[2]! })],
+    [/^(.*)-thinking-([a-z-]+)$/, m => ({ base: m[1]!, thinking: true, fast: false, level: m[2]! })],
+    [/^(.*)-([a-z-]+)-thinking$/, m => ({ base: m[1]!, thinking: true, fast: false, level: m[2]! })],
+    [/^(.*)-([a-z-]+)-fast$/, m => ({ base: m[1]!, thinking: false, fast: true, level: m[2]! })],
+    [/^(.*)-thinking-fast$/, m => ({ base: m[1]!, thinking: true, fast: true })],
+    [/^(.*)-thinking$/, m => ({ base: m[1]!, thinking: true, fast: false })],
+    [/^(.*)-fast$/, m => ({ base: m[1]!, thinking: false, fast: true })],
+  ];
+  for (const [pattern, dims] of patterns) {
+    const match = pattern.exec(id);
+    if (!match) continue;
+    const parsed = dims(match);
+    if (parsed.level && !CLAUDE_LEVELS.has(parsed.level)) continue;
+    const base = parseClaudeBase(parsed.base);
+    if (base) return { ...base, ...parsed, sourceBaseId: base.sourceBaseId };
+  }
+  const base = parseClaudeBase(id);
+  return base ? { ...base, thinking: false, fast: false } : undefined;
+}
+
+export function composeCursorClaudeWireId(
+  identity: Pick<NormalizedCursorClaudeId, "sourceBaseId" | "spelling">,
+  options: { thinking: boolean; fast: boolean; effort?: string; bareThinking?: boolean },
+): string {
+  const { sourceBaseId: base, spelling } = identity;
+  const fast = options.fast ? "-fast" : "";
+  if (!options.thinking) return options.effort ? `${base}-${options.effort}${fast}` : `${base}${fast}`;
+  if (options.bareThinking || !options.effort) return `${base}-thinking${fast}`;
+  return spelling === "version-first" ? `${base}-${options.effort}-thinking${fast}` : `${base}-thinking-${options.effort}${fast}`;
+}

package/src/adapters/cursor/discovery.ts

@@ -332,14 +332,27 @@ export const CURSOR_STATIC_MODELS: readonly CursorModelInfo[] = normalizeCursorM
   ...CURSOR_REAL_ID_EXCEPTIONS,
 ]);
 
-/** Picker labels for every seeded row, for providers.cursor.modelDisplayNames. */
+/**
+ * Picker labels for providers.cursor.modelDisplayNames.
+ *
+ * Only labels that carry Cursor's own product name ("Cursor Grok 4.6") are published. Every
+ * other row keeps the routed `cursor/<id>` slug that the rest of the picker uses, so a Cursor
+ * row reads like its siblings from other providers instead of an unprefixed marketing name.
+ * #3222 labeled every row and that dropped the `cursor/` prefix from the picker.
+ */
 export function cursorModelDisplayNames(): Record<string, string> {
-  return Object.fromEntries([
+  const labels: (readonly [string, string])[] = [
     ...CURSOR_ROUTER_MODEL_IDS.map(id => [id, CURSOR_ROUTER_DISPLAY_NAMES[id] ?? id] as const),
     ...cursorUmbrellaRows().map(row => [row.id, row.displayName] as const),
     ...CURSOR_PRODUCT_MODELS.map(model => [model.id, model.displayName] as const),
     ...CURSOR_REAL_ID_EXCEPTIONS.map(model => [model.id, model.displayName] as const),
-  ]);
+  ];
+  return Object.fromEntries(labels.filter(([, label]) => isCursorBrandedLabel(label)));
+}
+
+/** A label Cursor itself brands with its name, e.g. "Cursor Grok 4.6". */
+export function isCursorBrandedLabel(label: string): boolean {
+  return /^cursor\b/i.test(label.trim());
 }
 
 export function cursorModelIds(models: readonly CursorModelInfo[] = CURSOR_STATIC_MODELS): string[] {

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

@@ -1,3 +1,5 @@
+import { composeCursorClaudeWireId, normalizeCursorClaudeId } from "./claude-id";
+
 /**
  * Per-model Cursor reasoning-effort mapping.
  *
@@ -23,11 +25,8 @@ const CURSOR_MODEL_EFFORT_TIERS: Record<string, readonly string[]> = {
   // max is always the top tier (canonical order: low < medium < high < xhigh < max), confirmed
   // against Anthropic's effort ladder docs and Cursor's live model lineup.
   "claude-fable-5": ["low", "medium", "high", "xhigh", "max"],
-  // 260902 preemptive: Fable 5.1 seeded ahead of Cursor's lineup update (mirrors fable-5) under
-  // the three spellings Cursor has used for Claude ids.
+  // Fable 5.1 aliases normalize onto this sole capability ladder.
   "claude-fable-5-1": ["low", "medium", "high", "xhigh", "max"],
-  "claude-fable-5.1": ["low", "medium", "high", "xhigh", "max"],
-  "claude-5.1-fable": ["low", "medium", "high", "xhigh", "max"],
   "claude-opus-4-7": ["low", "medium", "high", "xhigh", "max"],
   // Opus Fast tiers from the 260822 GetUsableModels dump (devlog .../300): the wire
   // exposes {base-without-fast}-{effort}-fast only; suffix derivation at the bottom of
@@ -43,6 +42,10 @@ const CURSOR_MODEL_EFFORT_TIERS: Record<string, readonly string[]> = {
   // 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"],
+  // 260903 preemptive: gemini-3.8-flash seeded ahead of Cursor's lineup update, the same way
+  // glm-5.3 was. Google documents low/medium/high with no `minimal` for this generation,
+  // unlike 3.6. The seed is inert until Cursor's live roster lists the id.
+  "gemini-3.8-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.
@@ -55,8 +58,6 @@ const CURSOR_MODEL_EFFORT_TIERS: Record<string, readonly string[]> = {
   "claude-sonnet-5-thinking": ["low", "medium", "high", "xhigh", "max"],
   "claude-fable-5-thinking": ["low", "medium", "high", "xhigh", "max"],
   "claude-fable-5-1-thinking": ["low", "medium", "high", "xhigh", "max"],
-  "claude-fable-5.1-thinking": ["low", "medium", "high", "xhigh", "max"],
-  "claude-5.1-fable-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"],
@@ -122,8 +123,6 @@ const CURSOR_THINKING_FAMILIES: Readonly<Record<string, { source: string; order:
   "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-fable-5-1-thinking": { source: "claude-fable-5-1", order: "thinking-then-effort" },
-  "claude-fable-5.1-thinking": { source: "claude-fable-5.1", order: "thinking-then-effort" },
-  "claude-5.1-fable-thinking": { source: "claude-5.1-fable", order: "effort-then-thinking" },
   "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" },
@@ -148,6 +147,12 @@ function normalizeRequestedEffort(reasoning: string | undefined): string | undef
   return normalized === "ultra" ? "max" : normalized;
 }
 
+function cursorEffortLookupId(modelId: string): string {
+  const claude = normalizeCursorClaudeId(modelId);
+  if (!claude) return modelId;
+  return `${claude.canonicalBaseId}${claude.thinking ? "-thinking" : ""}${claude.fast ? "-fast" : ""}`;
+}
+
 /** Collapse a Codex reasoning-effort label to a low/medium/high rank for clamping onto a model's tiers. */
 function codexEffortRank(reasoning: string | undefined): "low" | "medium" | "high" {
   switch (normalizeRequestedEffort(reasoning) ?? "") {
@@ -172,7 +177,7 @@ function codexEffortRank(reasoning: string | undefined): "low" | "medium" | "hig
  * the model takes no suffix (bare). Literal model tiers pass through; unknown efforts clamp by rank.
  */
 export function cursorEffortSuffix(baseModelId: string, reasoning: string | undefined): string | undefined {
-  const tiers = CURSOR_MODEL_EFFORT_TIERS[baseModelId];
+  const tiers = CURSOR_MODEL_EFFORT_TIERS[cursorEffortLookupId(baseModelId)];
   if (!tiers || tiers.length === 0) return undefined;
   const requested = normalizeRequestedEffort(reasoning);
   if (requested && tiers.includes(requested)) return requested;
@@ -188,7 +193,7 @@ export function cursorEffortSuffix(baseModelId: string, reasoning: string | unde
 
 /** The Codex-facing picker ladder for a Cursor model, sorted in canonical Codex effort order. */
 export function cursorModelEffortLadder(baseModelId: string): string[] | undefined {
-  const tiers = CURSOR_MODEL_EFFORT_TIERS[baseModelId];
+  const tiers = CURSOR_MODEL_EFFORT_TIERS[cursorEffortLookupId(baseModelId)];
   if (!tiers || tiers.length === 0) return undefined;
   const tierSet = new Set(tiers);
   return CURSOR_PICKER_EFFORT_ORDER.filter(effort => tierSet.has(effort));
@@ -196,7 +201,7 @@ export function cursorModelEffortLadder(baseModelId: string): string[] | undefin
 
 /** Base models known to carry a reasoning-effort suffix (everything else is sent bare). */
 export function cursorModelHasEffortTiers(baseModelId: string): boolean {
-  return (CURSOR_MODEL_EFFORT_TIERS[baseModelId]?.length ?? 0) > 0;
+  return (CURSOR_MODEL_EFFORT_TIERS[cursorEffortLookupId(baseModelId)]?.length ?? 0) > 0;
 }
 
 /**
@@ -205,7 +210,17 @@ 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];
+  const lookupId = cursorEffortLookupId(baseModelId);
+  const thinking = CURSOR_THINKING_FAMILIES[lookupId];
+  const claude = normalizeCursorClaudeId(baseModelId);
+  if (claude) {
+    return composeCursorClaudeWireId(claude, {
+      thinking: claude.thinking,
+      fast: claude.fast,
+      effort: effortSuffix,
+      bareThinking: thinking?.order === "bare",
+    });
+  }
   if (thinking) {
     const { source, order } = thinking;
     // Cursor writes the thinking marker on either side of the effort depending on family

package/src/adapters/cursor/protobuf-request.ts

@@ -298,38 +298,40 @@ function rootPromptMessages(
   // Repetition breaker (devlog 260826 gap-9): external full-replay flattens history to text,
   // so N identical assistant/tool-result rounds replay as N identical lines and PRIME the model
   // to emit the same line again (self-reinforcing loop: S2a 180x, identical-probe repetition).
-  // Collapse consecutive duplicates into one entry + a count marker, and count collapses so a
-  // strategy-change note can be appended when the pattern is severe.
-  let lastReplayText: string | undefined;
-  let lastReplayEntry: RootBlobCandidate | undefined;
-  let collapsedRepeats = 0;
+  // Collapse consecutive same-role duplicates within one user turn into one entry + a count marker.
+  // Track assistant narration separately from tool results so a real narration→tool→result cycle
+  // cannot reset the breaker before the next identical narration arrives.
+  const replayRuns = new Map<RootBlobCandidate["role"], {
+    text: string;
+    entry: RootBlobCandidate;
+    length: number;
+  }>();
+  const toolCallCounts = new Map<string, number>();
   let maxRunLength = 1;
-  let currentRun = 1;
+  let maxToolCallCount = 1;
   const pushDeduped = (
     payload: { role: string; content: [{ type: "text"; text: string }] },
     role: RootBlobCandidate["role"],
     opts: { messageIndex: number; text?: string },
     normalized: string,
   ): void => {
-    if (externalModel && lastReplayText !== undefined && normalized === lastReplayText && lastReplayEntry) {
-      collapsedRepeats++;
-      currentRun++;
-      if (currentRun > maxRunLength) maxRunLength = currentRun;
-      const marked = `${normalized}\n[note: this exact output was produced ${currentRun} times in a row]`;
+    const previous = replayRuns.get(role);
+    if (externalModel && previous?.text === normalized) {
+      const runLength = previous.length + 1;
+      if (runLength > maxRunLength) maxRunLength = runLength;
+      const marked = `${normalized}\n[note: this exact output was produced ${runLength} times in a row]`;
       const replacement = rootBlobCandidate(
         { role: payload.role, content: [{ type: "text", text: marked }] },
         role,
-        opts,
+        { ...opts, messageIndex: previous.entry.messageIndex ?? opts.messageIndex },
       );
-      entries[entries.indexOf(lastReplayEntry)] = replacement;
-      lastReplayEntry = replacement;
+      entries[entries.indexOf(previous.entry)] = replacement;
+      replayRuns.set(role, { text: normalized, entry: replacement, length: runLength });
       return;
     }
-    currentRun = 1;
     const entry = rootBlobCandidate(payload, role, opts);
     entries.push(entry);
-    lastReplayText = normalized;
-    lastReplayEntry = entry;
+    replayRuns.set(role, { text: normalized, entry, length: 1 });
   };
 
   for (let i = 0; i < messages.length; i++) {
@@ -337,14 +339,13 @@ function rootPromptMessages(
     const message = messages[i];
     if (!message) continue;
     if (message.role === "user" || message.role === "developer") {
+      replayRuns.clear();
+      toolCallCounts.clear();
       const text = historyContentText(message).trim();
       // Cursor root replay expects OpenAI-style content parts for historical user messages.
       // A bare string survives blob hydration but external workers reject the completed replay
       // before tokenization (`usedTokens: 0`, then invalid_argument).
       if (text.length > 0) {
-        lastReplayText = undefined;
-        lastReplayEntry = undefined;
-        currentRun = 1;
         entries.push(rootBlobCandidate({
           role: "user",
           content: [{ type: "text", text }],
@@ -362,6 +363,20 @@ function rootPromptMessages(
           text,
         );
       }
+      if (externalModel && Array.isArray(message.content)) {
+        const callsInMessage = new Set<string>();
+        for (const part of message.content) {
+          if (part.type !== "toolCall") continue;
+          const args = serializeToolCallArguments(part.arguments);
+          if (args === undefined) continue;
+          callsInMessage.add(JSON.stringify([namespacedToolName(part.namespace, part.name), args]));
+        }
+        for (const call of callsInMessage) {
+          const count = (toolCallCounts.get(call) ?? 0) + 1;
+          toolCallCounts.set(call, count);
+          if (count > maxToolCallCount) maxToolCallCount = count;
+        }
+      }
       // Assistant tool CALLS are NOT replayed as a separate visible "[Tool Call]" entry: a model
        // few-shot-mimics that marker and emits later tool calls as inert text (363-B guard in
       // tests/cursor-tool-continuation.test.ts). The invocation is instead named INSIDE the paired
@@ -382,7 +397,12 @@ function rootPromptMessages(
     }
   }
   // Severe repetition: tell the model ONCE, imperatively, to change strategy.
-  if (externalModel && maxRunLength >= 3) {
+  if (externalModel && maxToolCallCount >= 3) {
+    entries.push(rootBlobCandidate({
+      role: "user",
+      content: [{ type: "text", text: `[context note] The transcript above contains the same tool call repeated ${maxToolCallCount} times in this user turn. Repeating it again is a failure. Take a DIFFERENT action now, or state plainly what is blocking progress.` }],
+    }, "user", {}));
+  } else if (externalModel && maxRunLength >= 3) {
     entries.push(rootBlobCandidate({
       role: "user",
       content: [{ type: "text", text: `[context note] The transcript above contains the same output repeated ${maxRunLength} times in a row. Repeating it again is a failure. Take a DIFFERENT action now, or state plainly what is blocking progress.` }],

package/src/adapters/google.ts

@@ -30,7 +30,7 @@ import {
   clearAntigravityReplay,
   observeAntigravityReplay,
 } from "./google-antigravity-replay";
-import { resolveAntigravityEffortWireModel } from "../providers/antigravity-models";
+import { canonicalAntigravityUsageModel, resolveAntigravityEffortWireModel } from "../providers/antigravity-models";
 import { googleVertexLocationConfigError } from "../providers/google-vertex-location";
 import { forgetThoughtSignatureForReplay, lookupReplayThoughtSignature } from "../responses/thought-signature-replay";
 import {
@@ -57,6 +57,43 @@ const GOOGLE_BREVITY_INSTRUCTION = [
 const ANTIGRAVITY_REJECTED_CLAUDE_SDK_PARAGRAPH =
   "You are a Claude agent, built on Anthropic's Claude Agent SDK.";
 
+/**
+ * CCA Flash generations that reject the Claude-Agent identity paragraph.
+ *
+ * Membership is probe-established per generation, never assumed: 3.7 and 3.8 both answer
+ * 429 RESOURCE_EXHAUSTED when this paragraph survives into `systemInstruction`, and 200 with
+ * it stripped — same account, seconds apart. A policy rejection wearing a quota error's
+ * clothing sends users hunting a quota problem that does not exist, so a new generation is
+ * added here only after the probe, and never dropped on the assumption that Google fixed it.
+ */
+const ANTIGRAVITY_CLAUDE_SDK_PARAGRAPH_REJECTORS = new Set([
+  "gemini-3.7-flash",
+  "gemini-3.8-flash",
+]);
+
+/**
+ * Whether CCA rejects the Claude-Agent identity paragraph for this request.
+ *
+ * Judged on the ROUTED WIRE id, not the selector, because three different selectors reach the
+ * same rejecting generation:
+ *
+ * - the collapsed base (`gemini-3.8-flash`);
+ * - a raw suffix id (`gemini-3.8-flash-high`), which the picker publishes whenever discovery
+ *   returns a PARTIAL ladder;
+ * - a RETIRED id (`gemini-3.6-flash`), which rule 0 redirects onto `gemini-3.7-flash-tiered`.
+ *
+ * That last one is why a selector-keyed test is not enough: retired ids deliberately keep their
+ * own identity for usage accounting, so they never canonicalize into the generation they
+ * actually call. A saved 3.6 selection was probed at 429 with the paragraph intact for exactly
+ * this reason. Matching on the wire id also means a future generation is covered by naming its
+ * wire spelling once, rather than every selector that can reach it.
+ */
+function rejectsClaudeSdkParagraph(modelId: string, wireModelId: string): boolean {
+  const canonicalWire = canonicalAntigravityUsageModel(wireModelId.replace(/-tiered$/, ""));
+  return ANTIGRAVITY_CLAUDE_SDK_PARAGRAPH_REJECTORS.has(canonicalWire)
+    || ANTIGRAVITY_CLAUDE_SDK_PARAGRAPH_REJECTORS.has(canonicalAntigravityUsageModel(modelId));
+}
+
 function stripAntigravityRejectedClaudeSdkParagraph(systemText: string): string {
   return systemText
     .split("\n\n")
@@ -748,7 +785,7 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
       // AI Studio's `-tiered` spelling is wire-only; CCA aliases may migrate to another generation.
       const identityModelId = provider.googleMode === "cloud-code-assist" ? routedModelId : parsed.modelId;
       const stripRejectedClaudeSdkParagraph = provider.googleMode === "cloud-code-assist"
-        && parsed.modelId === "gemini-3.7-flash";
+        && rejectsClaudeSdkParagraph(parsed.modelId, routedModelId);
       const { systemInstruction, contents, replayedCallIds } = messagesToGeminiFormat(
         parsed,
         identityModelId,

package/src/adapters/identity.ts

@@ -22,11 +22,17 @@ export const CODEX_GPT5_IDENTITY_LINE = "You are Codex, a coding agent based on
 export const CODEX_GPT5_IDENTITY_LINE_AGENT = "You are Codex, an agent based on GPT-5.";
 
 /**
- * Known Codex GPT-5 identity sentences. Narrow: only "coding agent" / "an agent" + GPT-5(.x)?
+ * Known Codex identity sentences. Narrow: only "coding agent" / "an agent" + GPT-<major>(.minor)*.
  * Avoid a broad `You are Codex.*` rewrite that could touch unrelated content.
+ *
+ * The major version is a wildcard because Codex writes the CURRENT generation into this line and
+ * bumps it: `gpt-6-astra` (upstream #42607) ships "You are Codex, an agent based on GPT-6.".
+ * Pinning `GPT-5` meant a GPT-6-era prompt routed to a third-party provider kept telling that
+ * model it was Codex-on-GPT-6 — the exact misattribution this chokepoint exists to remove, silently
+ * reintroduced by a version bump.
  */
 const CODEX_GPT5_IDENTITY_RE =
-  /You are Codex, (?:a coding agent|an agent) based on GPT-5(?:\.[0-9]+)*\./g;
+  /You are Codex, (?:a coding agent|an agent) based on GPT-[0-9]+(?:\.[0-9]+)*\./g;
 
 /** Proxy-neutral replacement: no "opencodex proxy" mention, just the GPT-5/OpenAI disclaimer. */
 export const NEUTRAL_IDENTITY_LINE = "You are a coding agent. Do not claim to be GPT-5 or to be made by OpenAI.";