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

package/src/adapters/command-code-tool-text.ts

@@ -22,6 +22,12 @@ import { validatesRestoredValue } from "./command-code-restored-schema";
  * A text block that opens with `<tool_call>` is therefore held instead of streamed. It is dropped
  * when a native call proves it is a duplicate, or restored on an eligible clean MiMo finish when
  * it names a declared tool with arguments that fit its schema. Other markup is released unchanged.
+ * MiMo can also append the markup after ordinary prose inside one text block; the stream filter
+ * splits such a delta at the marker and holds the markup part the same way (#5698; a marker split
+ * across deltas after prose is still released as text).
+ * A malformed envelope that still opens and closes around a declared function name, but that the
+ * strict parser rejects, is dropped instead of released when the native call for that same function
+ * arrives, and on the clean-finish path, so the echo never reaches the client.
  * Later text waits behind unresolved markup within the same byte bound.
  */
 
@@ -81,6 +87,21 @@ function tryJson(value: string): unknown {
   try { return JSON.parse(value); } catch { return undefined; }
 }
 
+/**
+ * The declared function name of an envelope echo the strict parser rejected, or undefined when the
+ * text is anything else: malformed parameter tags, a missing `</function>`, garbage inside the body.
+ * Opening and closing as an envelope with a known function name is enough to keep it off the client
+ * once the native duplicate call for that same name — which carries the canonical execution —
+ * arrives; a native call for another tool says nothing about this envelope.
+ */
+function looseEnvelopeName(text: string, declared: CommandCodeDeclaredTools | undefined): string | undefined {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith(TOOL_CALL_MARKER) || !trimmed.endsWith("</tool_call>")) return undefined;
+  if (trimmed.slice(TOOL_CALL_MARKER.length).includes(TOOL_CALL_MARKER)) return undefined;
+  const fn = /<function=([^>\s]+)>/.exec(trimmed);
+  return fn !== null && (declared?.has(fn[1]!) ?? false) ? fn[1]! : undefined;
+}
+
 function deepEqual(left: unknown, right: unknown): boolean {
   if (Object.is(left, right)) return true;
   if (typeof left !== "object" || typeof right !== "object" || left === null || right === null) return false;
@@ -251,7 +272,10 @@ const encoder = new TextEncoder();
 export class CommandCodeToolTextFilter {
   private readonly openInputs = new Map<string, string>();
   private readonly blocks = new Map<string, TextBlock>();
-  /** Only nonempty blocks still deciding whether their text is markup need boundary visits. */
+  /**
+   * Only blocks still deciding whether their text is markup (state "probing") need boundary visits;
+   * a held block is deliberately absent, so no interleaved event can interrupt it.
+   */
   private readonly activeProbes = new Map<string, TextBlock>();
   /** Held blocks in arrival order, including ended ones awaiting a verdict. */
   private held: TextBlock[] = [];
@@ -283,6 +307,13 @@ export class CommandCodeToolTextFilter {
     for (const [key, block] of this.activeProbes) {
       this.queueOperations++;
       if (key === exceptKey) continue;
+      // Guard only: a held block is not tracked here (textDelta adds probing blocks and drops them
+      // from the map on the transition to held). It must stay held until settle, in arrival order —
+      // interrupting it on interleaved events (reasoning deltas, other blocks, the native call
+      // itself) cleared complete and malformed envelopes alike and released the echoed call as text.
+      // The queued-byte bound (makeRoom) still caps memory and wait, flushing everything as text if a
+      // held envelope never resolves while the stream keeps producing.
+      if (block.state !== "probing") continue;
       this.activeProbes.delete(key);
       block.interrupted = true;
       block.state = "queued";
@@ -310,8 +341,44 @@ export class CommandCodeToolTextFilter {
       block = { id: key, markupParts: [], probe: "", bytes: 0, state: "probing", ended: false, interrupted: false, candidates: new Set(this.openInputs.keys()) };
       this.blocks.set(key, block);
     }
-    if (block.state === "streaming" && this.head === this.pending.length) {
-      return [...boundaryEvents, { type: "text_delta", text }];
+    // MiMo can append tool-call markup after ordinary prose inside one text block. The probe below
+    // only recognizes a block that opens with the marker, so a marker arriving after prose would
+    // reach the client (captured 2026-09-23 from xiaomi/mimo-v2.6-pro: prose, then
+    // "<tool_call><function=exec>..." echoed by the gateway as one text delta). Split the delta at
+    // the marker: prose keeps its queued or streamed path, the markup starts a fresh probe block
+    // and follows the normal hold-and-restore route. A probing block that has consumed nothing but
+    // whitespace keeps its probe instead, because that probe already holds the marker.
+    if (block.state !== "held") {
+      const markerIndex = text.indexOf(TOOL_CALL_MARKER);
+      const whitespaceLead = markerIndex > 0 && block.state === "probing" && block.probe === ""
+        && text.slice(0, markerIndex).trim() === "";
+      // markerIndex === 0 on a probing block is the ordinary hold path; on any other state the
+      // block is ordinary text and the marker must still start a fresh probe block.
+      if (!whitespaceLead && (markerIndex > 0 || (markerIndex === 0 && block.state !== "probing"))) {
+        const prose = markerIndex > 0 ? text.slice(0, markerIndex) : "";
+        const marked = markerIndex > 0 ? text.slice(markerIndex) : text;
+        let proseEvents: AdapterEvent[] = [];
+        if (prose) {
+          if (block.state === "streaming" && this.head === this.pending.length) {
+            proseEvents = [{ type: "text_delta", text: prose }];
+          } else {
+            if (block.state === "dropped" || block.state === "streaming") {
+              block = { id: key, markupParts: [], probe: "", bytes: 0, state: "queued", ended: false, interrupted: true, candidates: new Set() };
+              this.blocks.set(key, block);
+            }
+            proseEvents = this.queueProseDelta(block, prose);
+            this.probeBlockText(block, prose);
+          }
+        }
+        if (block.state === "queued") block.state = "streaming";
+        this.activeProbes.delete(key);
+        const probeBlock: TextBlock = { id: key, markupParts: [], probe: "", bytes: 0, state: "probing", ended: false, interrupted: false, candidates: new Set(this.openInputs.keys()) };
+        this.blocks.set(key, probeBlock);
+        return [...boundaryEvents, ...proseEvents, ...this.textDelta(id, marked)];
+      }
+      if (markerIndex === -1 && block.state === "streaming" && this.head === this.pending.length) {
+        return [...boundaryEvents, { type: "text_delta", text }];
+      }
     }
     // Once a duplicate is dropped, later text is a new chunk at its own wire position.
     if (block.state === "dropped" || block.state === "streaming") {
@@ -320,7 +387,7 @@ export class CommandCodeToolTextFilter {
     }
     const preceding = this.makeRoom(encoder.encode(text).byteLength);
     this.retain(block, text);
-    if (block.state === "probing" || block.state === "held") this.activeProbes.set(key, block);
+    if (block.state === "probing") this.activeProbes.set(key, block);
     const bytes = encoder.encode(text).byteLength;
     const tail = this.pending.at(-1);
     if (tail?.kind === "chunk" && tail.block === block && this.head < this.pending.length) {
@@ -332,24 +399,8 @@ export class CommandCodeToolTextFilter {
       this.queueOperations++;
     }
     this.queuedBytes += bytes;
-    if (block.state === "probing") {
-      for (const char of text) {
-        if (!block.probe && char.trim() === "") continue;
-        block.probe += char;
-        if (!TOOL_CALL_MARKER.startsWith(block.probe)) {
-          block.state = "queued";
-          block.markupParts = [];
-          break;
-        }
-        if (block.probe === TOOL_CALL_MARKER) {
-          block.state = "held";
-          block.probe = "";
-          this.held.push(block);
-          break;
-        }
-      }
-    }
-    if (block.state !== "probing" && block.state !== "held") this.activeProbes.delete(key);
+    this.probeBlockText(block, text);
+    if (block.state !== "probing") this.activeProbes.delete(key);
     return [...boundaryEvents, ...preceding, ...this.limitPending()];
   }
 
@@ -411,7 +462,8 @@ export class CommandCodeToolTextFilter {
         remaining.push(block);
         continue;
       }
-      const markup = parseToolCallMarkup(block.markupParts.join(""));
+      const text = block.markupParts.join("");
+      const markup = parseToolCallMarkup(text);
       if (markup && markup.name === name && markupMatchesInput(markup, input)) {
         this.drop(block);
         block.state = "dropped";
@@ -420,6 +472,16 @@ export class CommandCodeToolTextFilter {
       }
       block.candidates.delete(id);
       if (block.candidates.size === 0) {
+        // A malformed envelope cannot match a native input, but it is still an envelope: when the
+        // native call is for the function it declares, that call carries the execution, so drop the
+        // echo rather than releasing it as text. A native call for any other tool proves nothing
+        // about this envelope, so it keeps the release-as-text path below.
+        if (markup === undefined && looseEnvelopeName(text, this.declared) === name) {
+          this.drop(block);
+          block.state = "dropped";
+          this.activeProbes.delete(block.id);
+          continue;
+        }
         block.state = "queued";
         block.markupParts = [];
         this.activeProbes.delete(block.id);
@@ -472,6 +534,16 @@ export class CommandCodeToolTextFilter {
           events.push({ type: "tool_call_end" });
           salvaged = true;
           lastTextBlock = undefined;
+        } else if (restore && !block.interrupted && markup === undefined
+          && looseEnvelopeName(block.markupParts.join(""), this.declared) !== undefined) {
+          // A malformed envelope is still an envelope: the native duplicate (observed in every
+          // capture) carries the call, so the echo is dropped rather than rendered as text.
+          // Releasing it would put the raw markup back on screen; restoring it could execute a
+          // second time alongside the native call. The parser must have rejected the text, so an
+          // envelope that parses but does not fit its schema keeps the release-as-text contract.
+          this.drop(block);
+          block.state = "dropped";
+          lastTextBlock = undefined;
         } else {
           block.state = "queued";
           block.markupParts = [];
@@ -501,6 +573,44 @@ export class CommandCodeToolTextFilter {
     block.bytes += bytes;
   }
 
+  /** The incremental open-of-block probe: decide whether the block's text is tool-call markup. */
+  private probeBlockText(block: TextBlock, text: string): void {
+    if (block.state !== "probing") return;
+    for (const char of text) {
+      if (!block.probe && char.trim() === "") continue;
+      block.probe += char;
+      if (!TOOL_CALL_MARKER.startsWith(block.probe)) {
+        block.state = "queued";
+        block.markupParts = [];
+        break;
+      }
+      if (block.probe === TOOL_CALL_MARKER) {
+        block.state = "held";
+        block.probe = "";
+        this.held.push(block);
+        break;
+      }
+    }
+  }
+
+  /** Route ordinary prose through the queued wire path (shared by the mid-stream marker split). */
+  private queueProseDelta(block: TextBlock, prose: string): AdapterEvent[] {
+    const preceding = this.makeRoom(encoder.encode(prose).byteLength);
+    this.retain(block, prose);
+    const bytes = encoder.encode(prose).byteLength;
+    const tail = this.pending.at(-1);
+    if (tail?.kind === "chunk" && tail.block === block && this.head < this.pending.length) {
+      tail.parts.push(prose);
+      tail.bytes += bytes;
+      this.queueOperations++;
+    } else {
+      this.pending.push({ kind: "chunk", block, parts: [prose], bytes });
+      this.queueOperations++;
+    }
+    this.queuedBytes += bytes;
+    return preceding;
+  }
+
   private drop(block: TextBlock): void {
     this.budget.releaseRetained(block.bytes, { kind: "live_transient" });
     this.queuedBytes = Math.max(0, this.queuedBytes - block.bytes);

package/src/adapters/cursor/catalog.ts

@@ -184,19 +184,15 @@ export const CURSOR_CAPABILITIES: Record<string, CursorCapability> = {
       thinkingFast: { levels: FULL, order: T },
     },
   },
-  // 260923 Claude Opus 5.5: cursor.com/docs/models/claude-opus-5-5 publishes the id
-  // `claude-opus-5-5`, a thinking variant, a `claude-opus-5-5-fast` tier and a 1M max context.
-  // The ladders mirror the measured claude-opus-5 rows (fast stops at high) until the live
-  // GetUsableModels roster is dumped; the live filter drops any id the account cannot use.
+  // 260923 Claude Opus 5.5: live GetUsableModels roster advertises flat effort-suffixed
+  // wire ids (claude-opus-5-5-{low..max} and -fast) rather than a thinking variant.
   "claude-opus-5-5": {
     displayName: "Claude Opus 5.5",
     window: CONTEXT_1M,
-    defaultVariant: "thinking",
+    defaultVariant: "regular",
     variants: {
       regular: { levels: FULL },
-      thinking: { levels: FULL, order: T },
-      fast: { levels: ["low", "medium", "high"] },
-      thinkingFast: { levels: FULL, order: T },
+      fast: { levels: FULL },
     },
   },
   "glm-5.2": {

package/src/adapters/cursor/discovery.ts

@@ -270,15 +270,20 @@ export function isCursorExternalWireModel(modelId: string): boolean {
  * Observed on live Cursor Connect traffic (2026-08-20): `composer-2.5` (the
  * standard, non-fast build) resumes a tool-result turn with server-side native
  * tool calls (read/grep/exec) instead of answering, or completes with zero text
- * (empty `content` + `stop`). `composer-2.5-fast` answers correctly on the same
- * resumeAction path, so only the affected id is listed here. Sending the same
- * continuation as an explicit user message (external path) makes the model
- * answer reliably.
+ * (empty `content` + `stop`). Sending the same continuation as an explicit user
+ * message (external path) makes the model answer reliably.
+ *
+ * `composer-2.5-fast` was left on resumeAction after that same capture because
+ * it answered on that path then. A later live proxy log (2026-09-21) shows
+ * `cursor/composer-2.5-fast completed with no output text and no tool call` on
+ * the Chat Completions → Responses bridge used by OpenAI-compatible clients
+ * (GJC executor). That is the same empty-stop shape, so the fast id uses the
+ * external continuation path too.
  */
 export function cursorNeedsExternalToolContinuation(modelId: string): boolean {
   if (isCursorExternalWireModel(modelId)) return true;
   const wire = cursorCodexToWireModelId(modelId).trim().toLowerCase();
-  return wire === "composer-2.5";
+  return wire === "composer-2.5" || wire === "composer-2.5-fast";
 }
 
 function stripCursorEffortSuffix(wireModelId: string): string {

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

@@ -36,9 +36,9 @@ const CURSOR_MODEL_EFFORT_TIERS: Record<string, readonly string[]> = {
   "claude-opus-4-8-fast": ["low", "medium", "high", "xhigh", "max"],
   "claude-opus-5": ["low", "medium", "high", "xhigh", "max"],
   "claude-opus-5-fast": ["low", "medium", "high"],
-  // 260923 Opus 5.5 (cursor.com/docs/models/claude-opus-5-5), mirroring the measured opus-5 rows.
+  // 260923 Opus 5.5: live GetUsableModels roster advertises low..max in both regular and fast forms.
   "claude-opus-5-5": ["low", "medium", "high", "xhigh", "max"],
-  "claude-opus-5-5-fast": ["low", "medium", "high"],
+  "claude-opus-5-5-fast": ["low", "medium", "high", "xhigh", "max"],
   "claude-sonnet-5": ["low", "medium", "high", "xhigh", "max"],
   "glm-5.2": ["high", "max"],
   // 260825 live GetUsableModels. gemini-3.6-flash was the first Cursor model exposing
@@ -56,8 +56,6 @@ const CURSOR_MODEL_EFFORT_TIERS: Record<string, readonly string[]> = {
   // 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-5-5-thinking": ["low", "medium", "high", "xhigh", "max"],
-  "claude-opus-5-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"],
@@ -139,8 +137,6 @@ const CANONICAL_CODEX_EFFORT_ORDER = ["low", "medium", "high", "xhigh", "max"] a
 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-5-5-thinking": { source: "claude-opus-5-5", order: "thinking-then-effort" },
-  "claude-opus-5-5-thinking-fast": { source: "claude-opus-5-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" },

package/src/adapters/cursor/envelope-echo.ts

@@ -12,11 +12,13 @@
  * cursor.ts to retry before any invalid text reaches the client.
  */
 
+import { closedFenceLines, isWholeLineEchoMarker } from "../../lib/tool-envelope-echo-filter";
+
 const ECHO_MARKERS = ["[Tool Result]", "[Tool Error]", "[tool_result]"] as const;
+const REPLAY_ECHO_PREFIXES = ["[Tool call:", "[Tool Call]", "[Tool Result", "[Tool Error", "[tool_result"] as const;
 
-function isEchoMarkerLine(line: string): boolean {
-  return (ECHO_MARKERS as readonly string[]).includes(line.replace(/^[ \t]+/, ""));
-}
+// Whole-line only, the same rule as the live filter: prose that starts with a marker survives.
+const isEchoMarkerLine = isWholeLineEchoMarker;
 
 /**
  * Drop echoed tool-result envelopes from assistant history before Cursor root replay.
@@ -42,15 +44,18 @@ function isEchoMarkerLine(line: string): boolean {
  * Only whole-line markers count, so prose such as "the string [Tool Result] appeared" survives.
  */
 export function stripAssistantEchoedToolEnvelope(text: string): string {
-  if (!text || !ECHO_MARKERS.some(marker => text.includes(marker))) return text;
+  if (!text || !REPLAY_ECHO_PREFIXES.some(marker => text.includes(marker))) return text;
   const newline = text.includes("\r\n") ? "\r\n" : "\n";
   const lines = text.split(/\r?\n/);
   const kept: string[] = [];
   let dropped = false;
   let index = 0;
+  // A marker inside a fenced code block that closes is an example the model showed, not an echo;
+  // the live filter releases it as code, so replay keeps it too. An unclosed block shields nothing.
+  const shielded = closedFenceLines(lines);
   while (index < lines.length) {
     const line = lines[index] ?? "";
-    if (!isEchoMarkerLine(line)) {
+    if (shielded[index] || !isEchoMarkerLine(line)) {
       kept.push(line);
       index += 1;
       continue;

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

@@ -26,7 +26,7 @@ import {
   isCursorExecutionPathTool,
   isCursorWaitTool,
 } from "./tool-definitions";
-import { lookupCursorThreadConversation } from "./thread-continuity";
+import { lookupCursorThreadConversation, resolveCursorConversationRewrite } from "./thread-continuity";
 import {
   getCursorCheckpoint,
   getCursorCheckpointForPrefix,
@@ -367,11 +367,16 @@ export function resolveCursorConversationId(
   // the override check has to exclude it explicitly rather than rely on that flag.
   if (threadId && parsed._compactionRequest !== true) {
     const recovered = lookupCursorThreadConversation(threadId, parsed._cursorIdentityScope);
-    if (recovered) return recovered;
+    if (recovered) return resolveCursorConversationRewrite(recovered, parsed._cursorIdentityScope);
+  }
+  if (parsed._cursorConversationId) {
+    return resolveCursorConversationRewrite(parsed._cursorConversationId, parsed._cursorIdentityScope);
   }
-  if (parsed._cursorConversationId) return parsed._cursorConversationId;
   if (threadId) {
-    return cursorConversationIdFromClientThread(`thread:${threadId}`, parsed._cursorIdentityScope);
+    return resolveCursorConversationRewrite(
+      cursorConversationIdFromClientThread(`thread:${threadId}`, parsed._cursorIdentityScope),
+      parsed._cursorIdentityScope,
+    );
   }
   return generatedCursorConversationId();
 }

package/src/adapters/cursor/thread-continuity.ts

@@ -6,10 +6,56 @@
  * recovered id instead of recomputing the stale deterministic thread hash.
  */
 
+import { createHash } from "node:crypto";
+
 const OVERRIDE_TTL_MS = 60 * 60 * 1000;
 const OVERRIDE_MAX_ENTRIES = 2048;
 
 const overrides = new Map<string, { conversationId: string; updatedAt: number }>();
+const conversationRewrites = new Map<string, { to: string; root: string; updatedAt: number }>();
+
+function rewriteKey(conversationId: string, identityScope?: string): string {
+  const identity = createHash("sha256").update(identityScope?.trim() || "local").digest("hex");
+  return `${identity}\0${conversationId}`;
+}
+
+function pruneRewrites(at: number): void {
+  for (const [key, entry] of conversationRewrites) {
+    if (at - entry.updatedAt > OVERRIDE_TTL_MS) conversationRewrites.delete(key);
+  }
+  while (conversationRewrites.size > OVERRIDE_MAX_ENTRIES) {
+    const oldest = conversationRewrites.keys().next().value;
+    if (oldest === undefined) break;
+    conversationRewrites.delete(oldest);
+  }
+}
+
+export function rememberCursorConversationRewrite(from: string, to: string, identityScope?: string): void {
+  if (!from || !to || from === to) return;
+  const at = now();
+  pruneRewrites(at);
+  const scope = rewriteKey("", identityScope);
+  const root = conversationRewrites.get(rewriteKey(from, identityScope))?.root ?? from;
+  const redirects = [...conversationRewrites].filter(([key, entry]) => key.startsWith(scope) && entry.root === root);
+  for (const [key] of redirects) {
+    conversationRewrites.delete(key);
+    conversationRewrites.set(key, { to, root, updatedAt: at });
+  }
+  conversationRewrites.set(rewriteKey(from, identityScope), { to, root, updatedAt: at });
+  conversationRewrites.set(rewriteKey(to, identityScope), { to, root, updatedAt: at });
+  pruneRewrites(at);
+}
+
+export function resolveCursorConversationRewrite(conversationId: string, identityScope?: string): string {
+  const at = now();
+  pruneRewrites(at);
+  const key = rewriteKey(conversationId, identityScope);
+  const entry = conversationRewrites.get(key);
+  if (!entry) return conversationId;
+  conversationRewrites.delete(key);
+  conversationRewrites.set(key, { ...entry, updatedAt: at });
+  return entry.to;
+}
 
 function now(): number {
   return Date.now();
@@ -64,6 +110,7 @@ export function lookupCursorThreadConversation(
 
 export function clearCursorThreadContinuityForTests(): void {
   overrides.clear();
+  conversationRewrites.clear();
 }
 
 /** Max conversation-id remints after the first surfaced overflow per retained scope. */
@@ -278,7 +325,13 @@ const envelopeEchoRemintBudget = createCursorRemintBudget(
 export function cursorEnvelopeEchoRemintScopeKey(
   threadOwner: string | undefined,
   identityScope?: string,
+  conversationId?: string,
 ): string | null {
+  if (conversationId) {
+    pruneRewrites(now());
+    const root = conversationRewrites.get(rewriteKey(conversationId, identityScope))?.root ?? conversationId;
+    return `echo\0${rewriteKey(root, identityScope)}`;
+  }
   return cursorOverflowRemintScopeKey(threadOwner, identityScope);
 }
 

package/src/adapters/cursor.ts

@@ -4,7 +4,7 @@ import type { ProviderAdapter } from "./base";
 import { isTranslatorBudgetExceededError } from "../lib/translator-budget";
 import { cursorExecDeniedMessage, cursorRequestDeclaresFullAccess } from "./cursor/exec-policy";
 import { isCursorBenignCancelError, isCursorIncompleteToolCallMessage, isCursorInvalidArgumentError, isCursorOverflowRemintCandidate, isCursorRootEnvelopeError, safeCursorErrorMessage, type CursorSizeContext } from "./cursor/cursor-errors";
-import { cursorCheckpointModelAffinityId, inferCursorContextWindow, isCursorExternalWireModel } from "./cursor/discovery";
+import { cursorCheckpointModelAffinityId, cursorNeedsExternalToolContinuation, inferCursorContextWindow, isCursorExternalWireModel } from "./cursor/discovery";
 import { createCursorKvStore, type CursorKvStore } from "./cursor/kv-store";
 import { mapCursorServerMessage } from "./cursor/message-mapper";
 import {
@@ -31,6 +31,7 @@ import { debugProviderDiagnostic } from "../lib/debug";
 import { isDebugEnabled } from "../lib/debug-settings";
 import { createAdapterTierMetadata } from "../providers/fastwire";
 import { estimateTokens } from "../lib/token-estimate";
+import { ToolEnvelopeEchoFilter } from "../lib/tool-envelope-echo-filter";
 import {
   clearCursorIncompleteToolRemint,
   cursorIncompleteToolRemintScopeKey,
@@ -41,6 +42,7 @@ import {
   recordCursorIncompleteToolRemint,
   recordCursorEnvelopeEchoRemint,
   recordCursorOverflowRemint,
+  rememberCursorConversationRewrite,
   rememberCursorThreadConversation,
   shouldSkipCursorOverflowRemint,
   shouldSurfaceCursorOverflowFirst,
@@ -299,13 +301,18 @@ export function createCursorAdapter(provider: OcxProviderConfig, deps: CursorAda
           // Armed for ANY external turn whose replayed history contains a tool result — echo
           // priming was observed live on user-action rounds too (the envelope lives in the
           // flattened history regardless of which role ends the input).
-          const armEchoSniffer =
-            isCursorExternalWireModel(activeRequest.modelId)
-            && (_parsed.context.messages ?? []).some(message => message.role === "toolResult");
+          const replaysToolResult = (_parsed.context.messages ?? []).some(message => message.role === "toolResult");
+          const armEchoSniffer = isCursorExternalWireModel(activeRequest.modelId) && replaysToolResult;
           const echoSniffer = armEchoSniffer ? new CursorEnvelopeEchoSniffer() : undefined;
           // Mid-stream observer (devlog 260828 F1/F2): diagnostic-only; armed with the
           // prefix sniffer because both fire on flattened tool-result replay priming.
-          const midstreamObserver = armEchoSniffer ? new CursorMidstreamEchoObserver() : undefined;
+          // The composer-2.5 builds are native-wire but also replay the tool result as root text
+          // (cursorNeedsExternalToolContinuation), so the client-visible strip and the next-turn
+          // remint follow that predicate. The prefix retry above stays external-only: its
+          // corrective continuation text is encoded for external wire models alone.
+          const armMidstreamEcho = cursorNeedsExternalToolContinuation(activeRequest.modelId) && replaysToolResult;
+          const midstreamObserver = armMidstreamEcho ? new CursorMidstreamEchoObserver() : undefined;
+          const midstreamFilter = armMidstreamEcho ? new ToolEnvelopeEchoFilter() : undefined;
           const armRoutingCommentarySniffer =
             isCursorExternalWireModel(activeRequest.modelId)
             && (
@@ -321,8 +328,11 @@ export function createCursorAdapter(provider: OcxProviderConfig, deps: CursorAda
           // Exactly-once observation: every client-bound text delta passes through here
           // exactly once — held deltas only on release, ordinary deltas at emit time.
           const emitTextObserved = (event: AdapterEvent): void => {
-            if (event.type === "text_delta") midstreamObserver?.feed(event.text);
-            emit(event);
+            if (event.type !== "text_delta") { emit(event); return; }
+            midstreamObserver?.feed(event.text);
+            const text = midstreamFilter?.feed(event.text) ?? event.text;
+            if (midstreamFilter?.matched) sawMidstreamEnvelopeEcho = true;
+            if (text) emit({ ...event, text });
           };
           const releaseGuardHeld = () => {
             for (const held of guardHeld) {
@@ -453,8 +463,13 @@ export function createCursorAdapter(provider: OcxProviderConfig, deps: CursorAda
                 }
                 if (event.type !== "heartbeat") emittedOutput = true;
                 if (event.type === "done") {
+                  const suffix = midstreamFilter?.finish();
+                  // A fenced marker released by hold overflow is unproven code: remint to be safe.
+                  if (midstreamFilter?.matched || midstreamFilter?.unverifiedMarker) sawMidstreamEnvelopeEcho = true;
+                  if (suffix) emit({ type: "text_delta", text: suffix });
+                  // The observer is diagnostic only: the fence-aware filter's verdict decides the
+                  // remint, so a quoted marker in a closed code block does not rotate the thread.
                   const midstreamFindings = midstreamObserver?.findings() ?? [];
-                  if (midstreamFindings.length > 0) sawMidstreamEnvelopeEcho = true;
                   for (const finding of midstreamFindings) {
                     debugProviderDiagnostic("cursor", "midstream-envelope-echo", {
                       wireModel: activeRequest.modelId,
@@ -507,6 +522,9 @@ export function createCursorAdapter(provider: OcxProviderConfig, deps: CursorAda
           // the next turn does not recompute the stale deterministic thread hash. Isolated helper /
           // compaction turns must not park their throwaway id under the parent or Desktop owner.
           const threadOwner = cursorClientThreadOwner(_parsed);
+          if (_parsed._cursorIsolateConversation !== true) {
+            rememberCursorConversationRewrite(failedConversationId, next.conversationId, _parsed._cursorIdentityScope);
+          }
           if (threadOwner && _parsed._cursorIsolateConversation !== true) {
             rememberCursorThreadConversation(
               threadOwner,
@@ -629,11 +647,8 @@ export function createCursorAdapter(provider: OcxProviderConfig, deps: CursorAda
         } else if (!sawIncompleteToolCall && completedNormally && incompleteToolRemintScopeKey) {
           clearCursorIncompleteToolRemint(incompleteToolRemintScopeKey);
         }
-        // A mid-stream envelope echo has ALREADY reached the client — the prefix sniffer only
-        // watches the first bytes of a turn, and grok-4.6 writes a real sentence before pasting
-        // the envelope. It cannot be quarantined, so the recovery is the same as the
-        // incomplete-tool case: leave this turn alone and rotate the next turn's id, otherwise
-        // the stored echo is replayed and primes the model to echo again.
+        // Strip a split mid-stream marker before it reaches the client, then rotate the next
+        // conversation because the upstream checkpoint may still contain the echoed envelope.
         //
         // Its own budget, not the incomplete-tool one: echoing is cheap and repeatable while an
         // incomplete client-tool stream is rare and structural, so a shared counter would let a
@@ -645,6 +660,7 @@ export function createCursorAdapter(provider: OcxProviderConfig, deps: CursorAda
             ? cursorEnvelopeEchoRemintScopeKey(
                 cursorClientThreadOwner(_parsed),
                 _parsed._cursorIdentityScope,
+                request.conversationId,
               )
             : null;
         if (sawMidstreamEnvelopeEcho && !sawIncompleteToolCall && envelopeEchoRemintScopeKey) {

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

@@ -1559,7 +1559,9 @@ export async function* streamChatEvents(req: CloudChatRequest): AsyncGenerator<C
     // trace id are the only upstream-controlled fields that reach the error.
     // The stated delay rides along in our own words so a client can still
     // tell how long to wait when local retry gives up, exceeds its cap, or
-    // is disabled; the `~` keeps it from re-parsing as a downstream hint.
+    // is disabled. The `~` marks the delay as approximate; the shared
+    // parser accepts it once after Retry-After, so the outer client cooldown
+    // reads this same delay back from the message.
     throw new CloudChatError(
       `Cognition chat failed${trailerError.code ? ` (${trailerError.code})` : ''} ` +
       `(cloud trace ID: ${trailerError.traceId ?? 'n/a'})` +

package/src/adapters/google-tool-schema.ts

@@ -604,6 +604,28 @@ function sanitizeProperties(
   return properties;
 }
 
+/**
+ * Gemini rejects an array declaration that carries no `items` (#5689), so no return from
+ * `sanitizeSchema` may leave an array incomplete. A string item keeps the declaration valid: it
+ * narrows an unconstrained item rather than widening a constraint, so the loss report, which counts
+ * widened or dropped constraints, does not record it. The synthesized node is part of the emitted
+ * tree and charges the node budget like any other, because a wide enough fan-out of `items`-less
+ * arrays otherwise pushed the output past MAX_SCHEMA_NODES. When the budget cannot pay for that
+ * item, the array is omitted (`BUDGET_EXHAUSTED`) for its caller to drop instead of being emitted
+ * bare, which Gemini would reject for the whole request. A parent whose own `items` came back
+ * exhausted reaches this same rule, so an incomplete array is never nested in a retained one.
+ */
+function completeArrayItems(out: Schema, state: SanitizeState): SanitizeResult {
+  if (out.type !== "array" || Object.hasOwn(out, "items")) return out;
+  if (state.remainingNodes <= 0) {
+    reportBudgetExhausted(state);
+    return BUDGET_EXHAUSTED;
+  }
+  state.remainingNodes -= 1;
+  out.items = { type: "string" };
+  return out;
+}
+
 function sanitizeSchema(
   node: unknown,
   defs: Map<string, unknown>,
@@ -725,7 +747,8 @@ function sanitizeSchema(
 
   if (state.remainingNodes <= 0) {
     if (Object.hasOwn(node, "items") || Object.hasOwn(node, "anyOf")) reportBudgetExhausted(state);
-    return out;
+    // An array that the budget stopped before its `items` traversal takes the same rule.
+    return completeArrayItems(out, state);
   }
 
   if (Array.isArray(node.items)) {
@@ -739,7 +762,7 @@ function sanitizeSchema(
 
   if (state.remainingNodes <= 0) {
     if (Object.hasOwn(node, "anyOf")) reportBudgetExhausted(state);
-    return out;
+    return completeArrayItems(out, state);
   }
   if (Object.hasOwn(node, "anyOf")) {
     const normalized = normalizeAnyOf(node.anyOf, defs, depth, refDepth, state);
@@ -753,7 +776,7 @@ function sanitizeSchema(
     }
     Object.assign(out, normalized);
   }
-  return out;
+  return completeArrayItems(out, state);
 }
 
 export function sanitizeGeminiToolParametersWithReport(