@rynfar/meridian 1.60.0 → 1.62.0

package/dist/{cli-k1djafvr.js → cli-k36dddkm.js}

@@ -1752,6 +1752,133 @@ var init_sqlite = __esm(() => {
   ];
 });
 
+// src/proxy/fileChanges.ts
+function extractFileChange(toolName, toolInput, mcpPrefix) {
+  if (!toolName.startsWith(mcpPrefix))
+    return;
+  const shortName = toolName.slice(mcpPrefix.length);
+  const input = toolInput;
+  if (shortName === "write" && input?.path) {
+    return { operation: "wrote", path: String(input.path) };
+  }
+  if (shortName === "edit" && input?.path) {
+    return { operation: "edited", path: String(input.path) };
+  }
+  return;
+}
+function createFileChangeHook(changes, mcpPrefix) {
+  return {
+    matcher: "",
+    hooks: [async (input) => {
+      const change = extractFileChange(input.tool_name, input.tool_input, mcpPrefix);
+      if (change) {
+        changes.push(change);
+        return {};
+      }
+      if (input.tool_name === `${mcpPrefix}bash`) {
+        const toolInput = input.tool_input;
+        if (toolInput?.command) {
+          const bashChanges = extractFileChangesFromBash(String(toolInput.command));
+          changes.push(...bashChanges);
+        }
+      }
+      return {};
+    }]
+  };
+}
+function isLikelyFilePath(s) {
+  if (s.length > 4096)
+    return false;
+  if (/[<>$`\\()[\]{}=]/.test(s))
+    return false;
+  if (/^-?\d+$/.test(s))
+    return false;
+  if (s.includes("/"))
+    return true;
+  if (/\.[A-Za-z0-9]{1,16}$/.test(s))
+    return true;
+  return false;
+}
+function extractFileChangesFromBash(command) {
+  const changes = [];
+  const seen = new Set;
+  const addChange = (operation, path) => {
+    if (path === "/dev/null" || path === "/dev/stderr" || path === "/dev/stdout")
+      return;
+    if (!path.trim())
+      return;
+    const key = `${operation}:${path}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      changes.push({ operation, path });
+    }
+  };
+  const redirectRegex = /(?<![0-9=])>{1,2}\s*['"]?([^\s'";&|)]+)['"]?/g;
+  let match2;
+  while ((match2 = redirectRegex.exec(command)) !== null) {
+    if (isLikelyFilePath(match2[1])) {
+      addChange("wrote", match2[1]);
+    }
+  }
+  const teeRegex = /\btee\s+(?:-[a-zA-Z]\s+)*['"]?([^\s'";&|)]+)['"]?/g;
+  while ((match2 = teeRegex.exec(command)) !== null) {
+    addChange("wrote", match2[1]);
+  }
+  const sedRegex = /\bsed\s+(?:-[a-zA-Z]*i[a-zA-Z]*|-i)\b.*?['"]?([^\s'";&|)]+)['"]?\s*$/gm;
+  while ((match2 = sedRegex.exec(command)) !== null) {
+    addChange("edited", match2[1]);
+  }
+  return changes;
+}
+function extractFileChangesFromMessages(messages, extractFn) {
+  const changes = [];
+  const executedToolIds = new Set;
+  for (const msg of messages) {
+    if (msg.role !== "user")
+      continue;
+    const content = Array.isArray(msg.content) ? msg.content : [];
+    for (const block of content) {
+      if (block?.type === "tool_result" && block.tool_use_id) {
+        executedToolIds.add(block.tool_use_id);
+      }
+    }
+  }
+  for (const msg of messages) {
+    if (msg.role !== "assistant")
+      continue;
+    const content = Array.isArray(msg.content) ? msg.content : [];
+    for (const block of content) {
+      if (block?.type !== "tool_use")
+        continue;
+      if (!executedToolIds.has(block.id))
+        continue;
+      const blockChanges = extractFn(block.name, block.input);
+      changes.push(...blockChanges);
+    }
+  }
+  return changes;
+}
+function formatFileChangeSummary(changes) {
+  if (changes.length === 0)
+    return;
+  const seen = new Set;
+  const unique = [];
+  for (const c of changes) {
+    const key = `${c.operation}:${c.path}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      unique.push(c);
+    }
+  }
+  const lines = unique.map((c) => `- ${c.operation} ${c.path}`);
+  return `
+
+Files changed:
+${lines.join(`
+`)}`;
+}
+var init_fileChanges = () => {};
+
 // src/proxy/messages.ts
 function stripCacheControlForHashing(obj) {
   if (!obj || typeof obj !== "object")
@@ -1831,6 +1958,13 @@ ${history}
 
 ` + last.text;
 }
+function framePassthroughContinuation(delta) {
+  if (!delta)
+    return delta;
+  return `${PASSTHROUGH_CONTINUATION_LEAD_IN}
+
+${delta}`;
+}
 function stripNonStandardStreamFields(event) {
   if (event && typeof event === "object") {
     const e = event;
@@ -1886,6 +2020,12 @@ function consolidateMultimodalOntoLastUser(structured) {
   };
   return result;
 }
+function normalizeTarget(value) {
+  const collapsed = value.replace(/\s+/g, " ").trim();
+  if (!collapsed)
+    return;
+  return collapsed.length > TOOL_TARGET_MAX ? collapsed.slice(0, TOOL_TARGET_MAX - 3) + "..." : collapsed;
+}
 function summarizeContent(value) {
   if (typeof value !== "string" || value.length === 0)
     return;
@@ -1894,13 +2034,18 @@ function summarizeContent(value) {
     return;
   return collapsed.length > CONTENT_SUMMARY_MAX ? collapsed.slice(0, CONTENT_SUMMARY_MAX) + "..." : collapsed;
 }
+function editReplacementText(rec) {
+  if (!rec)
+    return;
+  return rec.new_string ?? rec.newString ?? rec.new_text ?? rec.newText;
+}
 function extractContentSummary(name, input) {
   if (!input || typeof input !== "object")
     return;
   const rec = input;
   switch (name.toLowerCase()) {
     case "edit":
-      return summarizeContent(rec.newString ?? rec.new_string);
+      return summarizeContent(editReplacementText(rec));
     case "write":
       return summarizeContent(rec.content);
     case "multiedit": {
@@ -1908,7 +2053,7 @@ function extractContentSummary(name, input) {
       if (!Array.isArray(edits) || edits.length === 0)
         return;
       const first = edits[0];
-      const firstSummary = summarizeContent(first?.newString ?? first?.new_string);
+      const firstSummary = summarizeContent(editReplacementText(first));
       if (!firstSummary)
         return;
       return edits.length > 1 ? `${edits.length} edits; first: ${firstSummary}` : firstSummary;
@@ -1931,8 +2076,9 @@ function buildToolUseIndex(messages) {
         for (const key of TOOL_TARGET_KEYS) {
           const v = input[key];
           if (typeof v === "string" && v) {
-            target = v.length > 80 ? v.slice(0, 77) + "..." : v;
-            break;
+            target = normalizeTarget(v);
+            if (target)
+              break;
           }
         }
       }
@@ -1957,7 +2103,7 @@ function extractSystemText(system) {
   return system.filter((b) => b?.type === "text" && typeof b.text === "string" && b.text).map((b) => b.text).filter((text) => !TRANSPORT_HEADER_BLOCK.test(text)).join(`
 `);
 }
-var HASH_IGNORED_BLOCK_TYPES, HASH_HANDLED_BLOCK_TYPES, HASH_SERIALIZED_BLOCK_TYPES, MULTIMODAL_TYPES, TOOL_TARGET_KEYS, CONTENT_SUMMARY_MAX = 120, TRANSPORT_HEADER_BLOCK;
+var HASH_IGNORED_BLOCK_TYPES, HASH_HANDLED_BLOCK_TYPES, HASH_SERIALIZED_BLOCK_TYPES, PASSTHROUGH_CONTINUATION_LEAD_IN, MULTIMODAL_TYPES, TOOL_TARGET_KEYS, TOOL_TARGET_MAX = 80, CONTENT_SUMMARY_MAX = 120, TRANSPORT_HEADER_BLOCK;
 var init_messages = __esm(() => {
   HASH_IGNORED_BLOCK_TYPES = new Set(["thinking", "redacted_thinking"]);
   HASH_HANDLED_BLOCK_TYPES = new Set(["text", "tool_use", "tool_result"]);
@@ -1974,138 +2120,12 @@ var init_messages = __esm(() => {
     "tool_search_tool_result",
     "container_upload"
   ]);
+  PASSTHROUGH_CONTINUATION_LEAD_IN = "The tool calls from your previous turn were forwarded to the client, which has now executed them — " + "their results follow. The instruction to end that turn without further text applied to it alone and " + "is now discharged: continue the work and respond.";
   MULTIMODAL_TYPES = new Set(["image", "document", "file"]);
-  TOOL_TARGET_KEYS = ["filePath", "file_path", "path", "command", "pattern", "query", "url"];
+  TOOL_TARGET_KEYS = ["filePath", "file_path", "path", "command", "code", "pattern", "query", "url"];
   TRANSPORT_HEADER_BLOCK = /^\s*x-anthropic-[a-z0-9-]*header\s*:/i;
 });
 
-// src/proxy/fileChanges.ts
-function extractFileChange(toolName, toolInput, mcpPrefix) {
-  if (!toolName.startsWith(mcpPrefix))
-    return;
-  const shortName = toolName.slice(mcpPrefix.length);
-  const input = toolInput;
-  if (shortName === "write" && input?.path) {
-    return { operation: "wrote", path: String(input.path) };
-  }
-  if (shortName === "edit" && input?.path) {
-    return { operation: "edited", path: String(input.path) };
-  }
-  return;
-}
-function createFileChangeHook(changes, mcpPrefix) {
-  return {
-    matcher: "",
-    hooks: [async (input) => {
-      const change = extractFileChange(input.tool_name, input.tool_input, mcpPrefix);
-      if (change) {
-        changes.push(change);
-        return {};
-      }
-      if (input.tool_name === `${mcpPrefix}bash`) {
-        const toolInput = input.tool_input;
-        if (toolInput?.command) {
-          const bashChanges = extractFileChangesFromBash(String(toolInput.command));
-          changes.push(...bashChanges);
-        }
-      }
-      return {};
-    }]
-  };
-}
-function isLikelyFilePath(s) {
-  if (s.length > 4096)
-    return false;
-  if (/[<>$`\\()[\]{}=]/.test(s))
-    return false;
-  if (/^-?\d+$/.test(s))
-    return false;
-  if (s.includes("/"))
-    return true;
-  if (/\.[A-Za-z0-9]{1,16}$/.test(s))
-    return true;
-  return false;
-}
-function extractFileChangesFromBash(command) {
-  const changes = [];
-  const seen = new Set;
-  const addChange = (operation, path) => {
-    if (path === "/dev/null" || path === "/dev/stderr" || path === "/dev/stdout")
-      return;
-    if (!path.trim())
-      return;
-    const key = `${operation}:${path}`;
-    if (!seen.has(key)) {
-      seen.add(key);
-      changes.push({ operation, path });
-    }
-  };
-  const redirectRegex = /(?<![0-9=])>{1,2}\s*['"]?([^\s'";&|)]+)['"]?/g;
-  let match2;
-  while ((match2 = redirectRegex.exec(command)) !== null) {
-    if (isLikelyFilePath(match2[1])) {
-      addChange("wrote", match2[1]);
-    }
-  }
-  const teeRegex = /\btee\s+(?:-[a-zA-Z]\s+)*['"]?([^\s'";&|)]+)['"]?/g;
-  while ((match2 = teeRegex.exec(command)) !== null) {
-    addChange("wrote", match2[1]);
-  }
-  const sedRegex = /\bsed\s+(?:-[a-zA-Z]*i[a-zA-Z]*|-i)\b.*?['"]?([^\s'";&|)]+)['"]?\s*$/gm;
-  while ((match2 = sedRegex.exec(command)) !== null) {
-    addChange("edited", match2[1]);
-  }
-  return changes;
-}
-function extractFileChangesFromMessages(messages, extractFn) {
-  const changes = [];
-  const executedToolIds = new Set;
-  for (const msg of messages) {
-    if (msg.role !== "user")
-      continue;
-    const content = Array.isArray(msg.content) ? msg.content : [];
-    for (const block of content) {
-      if (block?.type === "tool_result" && block.tool_use_id) {
-        executedToolIds.add(block.tool_use_id);
-      }
-    }
-  }
-  for (const msg of messages) {
-    if (msg.role !== "assistant")
-      continue;
-    const content = Array.isArray(msg.content) ? msg.content : [];
-    for (const block of content) {
-      if (block?.type !== "tool_use")
-        continue;
-      if (!executedToolIds.has(block.id))
-        continue;
-      const blockChanges = extractFn(block.name, block.input);
-      changes.push(...blockChanges);
-    }
-  }
-  return changes;
-}
-function formatFileChangeSummary(changes) {
-  if (changes.length === 0)
-    return;
-  const seen = new Set;
-  const unique = [];
-  for (const c of changes) {
-    const key = `${c.operation}:${c.path}`;
-    if (!seen.has(key)) {
-      seen.add(key);
-      unique.push(c);
-    }
-  }
-  const lines = unique.map((c) => `- ${c.operation} ${c.path}`);
-  return `
-
-Files changed:
-${lines.join(`
-`)}`;
-}
-var init_fileChanges = () => {};
-
 // src/proxy/session/fingerprint.ts
 import { createHash } from "crypto";
 function extractClientCwd(body) {
@@ -2151,7 +2171,7 @@ var init_opencode = __esm(() => {
   openCodeTransforms = [
     {
       name: "opencode-core",
-      adapters: ["opencode", "openai", "codex"],
+      adapters: ["opencode", "openai", "jcode", "codex"],
       onRequest(ctx) {
         const body = ctx.body;
         const blockedTools = BLOCKED_BUILTIN_TOOLS;
@@ -2325,6 +2345,51 @@ IMPORTANT: When using the task/Task tool, the subagent_type parameter must be on
   };
 });
 
+// src/proxy/adapters/openai.ts
+var openAiAdapter;
+var init_openai = __esm(() => {
+  init_opencode2();
+  openAiAdapter = {
+    ...openCodeAdapter,
+    name: "openai"
+  };
+});
+
+// src/proxy/adapters/jcode.ts
+function normalizeJcodeSessionId(value) {
+  const trimmed = value?.trim();
+  return trimmed && JCODE_SESSION_ID.test(trimmed) ? trimmed : undefined;
+}
+function isTextSystemBlock(value) {
+  if (value === null || typeof value !== "object")
+    return false;
+  const part = value;
+  return part.type === "text" && typeof part.text === "string";
+}
+function extractJcodeWorkingDirectory(body) {
+  if (body === null || typeof body !== "object")
+    return;
+  const system = body.system;
+  const text = typeof system === "string" ? system : Array.isArray(system) ? system.filter(isTextSystemBlock).map((part) => part.text).join(`
+`) : "";
+  return text.match(/(?:^|\n)Working directory:[^\S\n]*([^\n]+)/)?.[1]?.trim() || undefined;
+}
+var JCODE_SESSION_ID, jcodeAdapter;
+var init_jcode = __esm(() => {
+  init_openai();
+  JCODE_SESSION_ID = /^[A-Za-z0-9._:-]{1,256}$/;
+  jcodeAdapter = {
+    ...openAiAdapter,
+    name: "jcode",
+    getSessionId(c) {
+      return normalizeJcodeSessionId(c.req.header("x-jcode-session"));
+    },
+    extractWorkingDirectory(body) {
+      return extractJcodeWorkingDirectory(body);
+    }
+  };
+});
+
 // src/proxy/transforms/droid.ts
 function resolveDroidPassthrough() {
   return resolvePassthrough(false);
@@ -2815,32 +2880,161 @@ function extractPiCwd(body) {
   const match2 = systemText.match(/Current working directory:\s*([^\n]+)/i);
   return match2?.[1]?.trim() || undefined;
 }
-var PI_MCP_SERVER_NAME2 = "pi", PI_ALLOWED_MCP_TOOLS2, piAdapter;
-var init_pi2 = __esm(() => {
+var PI_MCP_SERVER_NAME2 = "pi", PI_ALLOWED_MCP_TOOLS2, piAdapter;
+var init_pi2 = __esm(() => {
+  init_fileChanges();
+  init_messages();
+  init_tools();
+  init_env();
+  init_claudecode();
+  init_pi();
+  PI_ALLOWED_MCP_TOOLS2 = [
+    `mcp__${PI_MCP_SERVER_NAME2}__read`,
+    `mcp__${PI_MCP_SERVER_NAME2}__write`,
+    `mcp__${PI_MCP_SERVER_NAME2}__edit`,
+    `mcp__${PI_MCP_SERVER_NAME2}__bash`,
+    `mcp__${PI_MCP_SERVER_NAME2}__glob`,
+    `mcp__${PI_MCP_SERVER_NAME2}__grep`
+  ];
+  piAdapter = {
+    name: "pi",
+    getSessionId(c, body) {
+      return c.req.header("x-session-affinity") ?? extractClaudeCodeSessionId(body);
+    },
+    extractWorkingDirectory(body) {
+      return extractPiCwd(body);
+    },
+    extractClientWorkingDirectory(body) {
+      return extractPiCwd(body);
+    },
+    normalizeContent(content) {
+      return normalizeContent(content);
+    },
+    getBlockedBuiltinTools() {
+      return BLOCKED_BUILTIN_TOOLS;
+    },
+    getAgentIncompatibleTools() {
+      return CLAUDE_CODE_ONLY_TOOLS;
+    },
+    getMcpServerName() {
+      return PI_MCP_SERVER_NAME2;
+    },
+    getAllowedMcpTools() {
+      return PI_ALLOWED_MCP_TOOLS2;
+    },
+    buildSdkAgents(_body, _mcpToolNames) {
+      return {};
+    },
+    supportsThinking() {
+      return true;
+    },
+    buildSdkHooks(_body, _sdkAgents) {
+      return;
+    },
+    buildSystemContextAddendum(_body, _sdkAgents) {
+      return "";
+    },
+    usesPassthrough() {
+      return resolvePassthrough(true);
+    },
+    extractFileChangesFromToolUse(toolName, toolInput) {
+      const input = toolInput;
+      const filePath = input?.filePath ?? input?.file_path ?? input?.path;
+      if (toolName === "write" && filePath) {
+        return [{ operation: "wrote", path: String(filePath) }];
+      }
+      if (toolName === "edit" && filePath) {
+        return [{ operation: "edited", path: String(filePath) }];
+      }
+      if (toolName === "bash" && input?.command) {
+        return extractFileChangesFromBash(String(input.command));
+      }
+      return [];
+    }
+  };
+});
+
+// src/proxy/adapters/prime.ts
+function extractPrimeCwd(body) {
+  let systemText = "";
+  if (typeof body?.system === "string") {
+    systemText = body.system;
+  } else if (Array.isArray(body?.system)) {
+    systemText = body.system.filter((b) => b?.type === "text" && b.text).map((b) => b.text).join(`
+`);
+  }
+  if (!systemText)
+    return;
+  const match2 = systemText.match(RLM_CWD_LINE) ?? systemText.match(CUSTOM_PROMPT_CWD_LINE);
+  return match2?.[1]?.trim() || undefined;
+}
+function extractFileChangesFromIpythonCell(code) {
+  const lines = code.split(`
+`);
+  const firstMeaningful = lines.find((l) => l.trim().length > 0) ?? "";
+  if (/^[ \t]*%%bash\b/.test(firstMeaningful)) {
+    const bodyStart = lines.indexOf(firstMeaningful) + 1;
+    return extractFileChangesFromBash(lines.slice(bodyStart).join(`
+`));
+  }
+  const changes = [];
+  for (const line of lines) {
+    const escaped = line.match(SHELL_ESCAPE_LINE);
+    if (escaped?.[1])
+      changes.push(...extractFileChangesFromBash(escaped[1]));
+  }
+  for (const m of code.matchAll(EDIT_SKILL_CALL)) {
+    if (m[2])
+      changes.push({ operation: "edited", path: m[2] });
+  }
+  return changes;
+}
+function extractPrimeFileChanges(toolName, toolInput) {
+  const input = toolInput;
+  if (toolName === "ipython" && typeof input?.code === "string") {
+    return extractFileChangesFromIpythonCell(input.code);
+  }
+  const filePath = input?.path ?? input?.file_path ?? input?.filePath;
+  if (toolName === "edit" && filePath) {
+    return [{ operation: "edited", path: String(filePath) }];
+  }
+  if (toolName === "write" && filePath) {
+    return [{ operation: "wrote", path: String(filePath) }];
+  }
+  if (toolName === "bash" && input?.command) {
+    return extractFileChangesFromBash(String(input.command));
+  }
+  return [];
+}
+var PRIME_MCP_SERVER_NAME = "prime", PRIME_ALLOWED_MCP_TOOLS, RLM_CWD_LINE, CUSTOM_PROMPT_CWD_LINE, EDIT_SKILL_CALL, SHELL_ESCAPE_LINE, primeAdapter;
+var init_prime = __esm(() => {
   init_fileChanges();
   init_messages();
   init_tools();
   init_env();
   init_claudecode();
-  init_pi();
-  PI_ALLOWED_MCP_TOOLS2 = [
-    `mcp__${PI_MCP_SERVER_NAME2}__read`,
-    `mcp__${PI_MCP_SERVER_NAME2}__write`,
-    `mcp__${PI_MCP_SERVER_NAME2}__edit`,
-    `mcp__${PI_MCP_SERVER_NAME2}__bash`,
-    `mcp__${PI_MCP_SERVER_NAME2}__glob`,
-    `mcp__${PI_MCP_SERVER_NAME2}__grep`
+  PRIME_ALLOWED_MCP_TOOLS = [
+    `mcp__${PRIME_MCP_SERVER_NAME}__read`,
+    `mcp__${PRIME_MCP_SERVER_NAME}__write`,
+    `mcp__${PRIME_MCP_SERVER_NAME}__edit`,
+    `mcp__${PRIME_MCP_SERVER_NAME}__bash`,
+    `mcp__${PRIME_MCP_SERVER_NAME}__glob`,
+    `mcp__${PRIME_MCP_SERVER_NAME}__grep`
   ];
-  piAdapter = {
-    name: "pi",
+  RLM_CWD_LINE = /^Working directory:[ \t]*(.+)$/m;
+  CUSTOM_PROMPT_CWD_LINE = /^Current working directory:[ \t]*(.+)$/m;
+  EDIT_SKILL_CALL = /\bedit\s*\(\s*path\s*=\s*(['"])(.+?)\1/g;
+  SHELL_ESCAPE_LINE = /^[ \t]*!(.+)$/;
+  primeAdapter = {
+    name: "prime",
     getSessionId(c, body) {
       return c.req.header("x-session-affinity") ?? extractClaudeCodeSessionId(body);
     },
     extractWorkingDirectory(body) {
-      return extractPiCwd(body);
+      return extractPrimeCwd(body);
     },
     extractClientWorkingDirectory(body) {
-      return extractPiCwd(body);
+      return extractPrimeCwd(body);
     },
     normalizeContent(content) {
       return normalizeContent(content);
@@ -2852,10 +3046,10 @@ var init_pi2 = __esm(() => {
       return CLAUDE_CODE_ONLY_TOOLS;
     },
     getMcpServerName() {
-      return PI_MCP_SERVER_NAME2;
+      return PRIME_MCP_SERVER_NAME;
     },
     getAllowedMcpTools() {
-      return PI_ALLOWED_MCP_TOOLS2;
+      return PRIME_ALLOWED_MCP_TOOLS;
     },
     buildSdkAgents(_body, _mcpToolNames) {
       return {};
@@ -2873,18 +3067,7 @@ var init_pi2 = __esm(() => {
       return resolvePassthrough(true);
     },
     extractFileChangesFromToolUse(toolName, toolInput) {
-      const input = toolInput;
-      const filePath = input?.filePath ?? input?.file_path ?? input?.path;
-      if (toolName === "write" && filePath) {
-        return [{ operation: "wrote", path: String(filePath) }];
-      }
-      if (toolName === "edit" && filePath) {
-        return [{ operation: "edited", path: String(filePath) }];
-      }
-      if (toolName === "bash" && input?.command) {
-        return extractFileChangesFromBash(String(input.command));
-      }
-      return [];
+      return extractPrimeFileChanges(toolName, toolInput);
     }
   };
 });
@@ -3008,16 +3191,6 @@ var init_forgecode2 = __esm(() => {
   };
 });
 
-// src/proxy/adapters/openai.ts
-var openAiAdapter;
-var init_openai = __esm(() => {
-  init_opencode2();
-  openAiAdapter = {
-    ...openCodeAdapter,
-    name: "openai"
-  };
-});
-
 // src/proxy/adapters/codex.ts
 var codexAdapter;
 var init_codex = __esm(() => {
@@ -3202,6 +3375,9 @@ function detectAdapter(c) {
     return openCodeAdapter;
   }
   const userAgent = c.req.header("user-agent") || "";
+  if (userAgent.startsWith("jcode/") && normalizeJcodeSessionId(c.req.header("x-jcode-session"))) {
+    return jcodeAdapter;
+  }
   if (userAgent.startsWith("opencode/")) {
     return openCodeAdapter;
   }
@@ -3233,9 +3409,11 @@ var init_detect = __esm(() => {
   init_crush2();
   init_passthrough2();
   init_pi2();
+  init_prime();
   init_forgecode2();
   init_claudecode();
   init_openai();
+  init_jcode();
   init_codex();
   init_cherry();
   init_adapterInstances();
@@ -3245,12 +3423,15 @@ var init_detect = __esm(() => {
     crush: crushAdapter,
     passthrough: passthroughAdapter,
     pi: piAdapter,
+    prime: primeAdapter,
+    "prime-agent": primeAdapter,
     forgecode: forgeCodeAdapter,
     "claude-code": claudeCodeAdapter,
     claudecode: claudeCodeAdapter,
     cherry: cherryAdapter,
     cherrystudio: cherryAdapter,
     openai: openAiAdapter,
+    jcode: jcodeAdapter,
     codex: codexAdapter
   };
   envDefault = process.env.MERIDIAN_DEFAULT_AGENT || "";
@@ -3401,9 +3582,15 @@ var init_sdkFeatures = __esm(() => {
     openai: {
       codeSystemPrompt: false
     },
+    jcode: {
+      codeSystemPrompt: false
+    },
     cherry: {
       codeSystemPrompt: false
     },
+    prime: {
+      codeSystemPrompt: false
+    },
     codex: {
       codeSystemPrompt: false
     }
@@ -6294,8 +6481,10 @@ var OAUTH_USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
 var OAUTH_BETA_HEADER = "oauth-2025-04-20";
 var CACHE_TTL_MS_DEFAULT = 30000;
 var STALE_MAX_MS_DEFAULT = 15 * 60000;
+var RATE_LIMIT_BACKOFF_MS_DEFAULT = 60000;
 var cacheByProfile = new Map;
 var inflightByProfile = new Map;
+var rateLimitedUntilByProfile = new Map;
 var DEFAULT_KEY = "__default__";
 var WINDOW_TYPES = [
   "five_hour",
@@ -6317,6 +6506,15 @@ function normalizeUtilization(raw2) {
     return null;
   return Math.max(0, raw2 / 100);
 }
+function parseRetryAfterMs(raw2) {
+  if (!raw2)
+    return null;
+  const seconds = Number(raw2);
+  if (Number.isFinite(seconds))
+    return Math.max(0, seconds * 1000);
+  const retryAt = Date.parse(raw2);
+  return Number.isFinite(retryAt) ? Math.max(0, retryAt - Date.now()) : null;
+}
 function modelScopedWindowType(limit) {
   if (limit.kind !== "weekly_scoped")
     return null;
@@ -6374,14 +6572,27 @@ async function callAnthropic(token, fetchImpl, signal) {
     },
     signal: signal ?? AbortSignal.timeout(1e4)
   });
-  if (!res.ok)
-    return { __status: res.status };
+  if (!res.ok) {
+    return {
+      __status: res.status,
+      retryAfterMs: parseRetryAfterMs(res.headers.get("retry-after"))
+    };
+  }
   return await res.json();
 }
 var _testOverride = null;
 async function fetchOAuthUsage(opts) {
+  return (await fetchOAuthUsageResult(opts)).snapshot;
+}
+function missingReason(cacheKey2) {
+  const until = rateLimitedUntilByProfile.get(cacheKey2);
+  return until !== undefined && Date.now() < until ? "rate_limited" : "no_token";
+}
+async function fetchOAuthUsageResult(opts) {
   if (_testOverride && !opts?.fetchImpl && !opts?.store) {
-    return _testOverride(opts);
+    const snapshot = await _testOverride(opts);
+    const error = snapshot ? null : missingReason(opts?.profileId ?? DEFAULT_KEY);
+    return { snapshot, error };
   }
   return fetchOAuthUsageImpl(opts);
 }
@@ -6389,30 +6600,37 @@ async function fetchOAuthUsageImpl(opts) {
   const ttl = opts?.ttlMs ?? CACHE_TTL_MS_DEFAULT;
   const cacheKey2 = opts?.profileId ?? DEFAULT_KEY;
   const fetchImpl = opts?.fetchImpl ?? globalThis.fetch;
+  const staleMaxMs = opts?.staleMaxMs ?? STALE_MAX_MS_DEFAULT;
+  const staleOr = (reason, error) => {
+    const last = cacheByProfile.get(cacheKey2);
+    if (last && Date.now() - last.fetchedAt < staleMaxMs) {
+      claudeLog("oauth_usage.serving_stale", { profile: cacheKey2, reason, ageMs: Date.now() - last.fetchedAt });
+      return { snapshot: { ...last, stale: true }, error: null };
+    }
+    return { snapshot: null, error };
+  };
   if (!opts?.force) {
     const cached = cacheByProfile.get(cacheKey2);
     if (cached && Date.now() - cached.fetchedAt < ttl)
-      return cached;
+      return { snapshot: cached, error: null };
   }
   const existing = inflightByProfile.get(cacheKey2);
   if (existing)
     return existing;
+  const rateLimitedUntil = rateLimitedUntilByProfile.get(cacheKey2);
+  if (rateLimitedUntil !== undefined) {
+    if (Date.now() < rateLimitedUntil)
+      return staleOr("rate_limited", "rate_limited");
+    rateLimitedUntilByProfile.delete(cacheKey2);
+  }
   const store = opts?.store ?? createPlatformCredentialStore({ claudeConfigDir: opts?.claudeConfigDir });
-  const staleMaxMs = opts?.staleMaxMs ?? STALE_MAX_MS_DEFAULT;
-  const staleOr = (reason) => {
-    const last = cacheByProfile.get(cacheKey2);
-    if (last && Date.now() - last.fetchedAt < staleMaxMs) {
-      claudeLog("oauth_usage.serving_stale", { profile: cacheKey2, reason, ageMs: Date.now() - last.fetchedAt });
-      return { ...last, stale: true };
-    }
-    return null;
-  };
+  const rateLimitBackoffMs = opts?.rateLimitBackoffMs ?? RATE_LIMIT_BACKOFF_MS_DEFAULT;
   const promise = (async () => {
     try {
       const token = await readAccessToken(store);
       if (!token) {
         claudeLog("oauth_usage.no_token", { profile: cacheKey2 });
-        return staleOr("no_token");
+        return staleOr("no_token", "no_token");
       }
       let result = await callAnthropic(token, fetchImpl);
       if ("__status" in result && result.__status === 401) {
@@ -6420,23 +6638,28 @@ async function fetchOAuthUsageImpl(opts) {
         const refreshed = await refreshOAuthToken(store);
         if (!refreshed) {
           claudeLog("oauth_usage.refresh_failed", { profile: cacheKey2 });
-          return staleOr("refresh_failed");
+          return staleOr("refresh_failed", "upstream_error");
         }
         const newToken = await readAccessToken(store);
         if (!newToken)
-          return staleOr("no_token_after_refresh");
+          return staleOr("no_token_after_refresh", "no_token");
         result = await callAnthropic(newToken, fetchImpl);
       }
       if ("__status" in result) {
+        if (result.__status === 429) {
+          const retryAfterMs = Math.min(Math.max(rateLimitBackoffMs, result.retryAfterMs ?? 0), Math.max(staleMaxMs, rateLimitBackoffMs));
+          rateLimitedUntilByProfile.set(cacheKey2, Date.now() + retryAfterMs);
+        }
         claudeLog("oauth_usage.upstream_error", { profile: cacheKey2, status: result.__status });
-        return staleOr(`upstream_${result.__status}`);
+        return staleOr(`upstream_${result.__status}`, result.__status === 429 ? "rate_limited" : "upstream_error");
       }
+      rateLimitedUntilByProfile.delete(cacheKey2);
       const snapshot = buildSnapshot(result);
       cacheByProfile.set(cacheKey2, snapshot);
-      return snapshot;
+      return { snapshot, error: null };
     } catch (err) {
       claudeLog("oauth_usage.fetch_failed", { profile: cacheKey2, error: err instanceof Error ? err.message : String(err) });
-      return staleOr("exception");
+      return staleOr("exception", "upstream_error");
     } finally {
       inflightByProfile.delete(cacheKey2);
     }
@@ -10715,6 +10938,31 @@ function shouldEarlyStop(tracker) {
   tracker.fired = true;
   return true;
 }
+function clientAbortDisposition(input) {
+  if (input.isIndependentSession || !input.profileSessionId)
+    return { action: "none" };
+  if (!input.passthrough)
+    return { action: "evict" };
+  if (input.currentSessionId && !input.sawDuplicateToolUse && input.resumeBoundaryUuid) {
+    return { action: "store", resumeUuid: input.resumeBoundaryUuid };
+  }
+  return { action: "evict" };
+}
+function resumeBoundaryUuid(message) {
+  const m = message;
+  if (m?.type !== "user")
+    return;
+  if (typeof m.uuid !== "string" || m.uuid.length === 0)
+    return;
+  const content = m.message?.content;
+  if (!Array.isArray(content))
+    return;
+  const hasResult = content.some((block) => {
+    const b = block;
+    return b?.type === "tool_result";
+  });
+  return hasResult ? m.uuid : undefined;
+}
 
 // src/proxy/envelopeIntegrity.ts
 function checkEmptyToolInputs(contentBlocks, tools) {
@@ -10755,6 +11003,68 @@ function checkUndeliveredToolUses(captured, deliveredIds) {
   return violations;
 }
 
+// src/proxy/turnOutcome.ts
+function classifyTurnOutcome(input) {
+  if (input.toolUses > 0)
+    return { kind: "productive" };
+  if (input.textEvents > 0)
+    return { kind: "productive" };
+  return {
+    kind: "silent",
+    reason: input.blocksForwarded > 0 ? "no_actionable_content" : "no_blocks"
+  };
+}
+var SILENT_TURN_NUDGE = "Your previous turn produced no visible output — no text and no tool call — so the client received " + "nothing to act on. Any earlier instruction to end your turn without further text applied only to " + "that turn and is now discharged. Answer now, in text, addressing the most recent request and any " + "tool results above it. If a tool call is still required, make it.";
+function shouldInjectSilentTurn(input) {
+  if (!input.raw)
+    return false;
+  if (input.raw === "1")
+    return true;
+  return Boolean(input.sessionId && input.raw === input.sessionId);
+}
+function createRecoveryLifter(allocateBlockIndex) {
+  let blockIndex;
+  return {
+    lift(innerEvent) {
+      const inner = innerEvent;
+      if (!inner)
+        return;
+      if (inner.type === "content_block_start" && inner.content_block?.type === "text") {
+        blockIndex = allocateBlockIndex();
+        return {
+          kind: "block_start",
+          frame: { type: "content_block_start", index: blockIndex, content_block: { type: "text", text: "" } }
+        };
+      }
+      if (inner.type === "content_block_delta" && inner.delta?.type === "text_delta" && blockIndex !== undefined) {
+        const text = inner.delta.text;
+        return {
+          kind: "text_delta",
+          frame: { type: "content_block_delta", index: blockIndex, delta: { type: "text_delta", text } },
+          textChars: typeof text === "string" ? text.length : 0
+        };
+      }
+      if (inner.type === "content_block_stop" && blockIndex !== undefined) {
+        const index = blockIndex;
+        blockIndex = undefined;
+        return { kind: "block_stop", frame: { type: "content_block_stop", index } };
+      }
+      return;
+    }
+  };
+}
+function shouldAttemptRecovery(input) {
+  if (!input.enabled)
+    return false;
+  if (input.outcome.kind === "productive")
+    return false;
+  if (input.alreadyAttempted)
+    return false;
+  if (input.clientGone)
+    return false;
+  return Boolean(input.sessionId);
+}
+
 // src/proxy/server.ts
 init_agentMatch();
 
@@ -11594,7 +11904,14 @@ function profileSection(q,s,pl,h){
       var orderIdx=(pl.profileOrder||[]).indexOf(p.id);
       if(orderIdx>=0)badge+='<span class="pool-chip">#'+(orderIdx+1)+' in pool</span>';
       var exh=(pl.exhausted||[]).filter(function(e){return e.id===p.id})[0];
-      if(exh)badge+=' <span class="pool-chip exhausted">exhausted · resets '+resetIn(exh.until)+'</span>';
+      if(exh){
+        // A billing refusal has no reset to wait for — the pool re-probes on the
+        // same timer, but nothing changes until a human fixes the account.
+        // Showing it as 'resets in 9m' promises a recovery that never comes.
+        badge+=exh.reason==='billing_error'
+          ?' <span class="pool-chip exhausted" title="Subscription or payment refused — this does not clear on its own">subscription refused</span>'
+          :' <span class="pool-chip exhausted">exhausted · resets '+resetIn(exh.until)+'</span>';
+      }
     }
     cards+='<div class="profile-card'+(p.isActive?' active':'')+(switchable?' switchable':'')+'"'+(switchable?' data-profile="'+esc(p.id)+'" role="button" tabindex="0"':'')+'>'
       +'<div class="profile-head"><span class="profile-name"><span class="prof-dot"></span>'+esc(p.label||p.id)+' '+badge+'</span>'
@@ -11780,6 +12097,17 @@ function extendedContextHint(model) {
     return advise("MERIDIAN_SONNET_MODEL=sonnet");
   return advise("MERIDIAN_1M_CONTEXT_SUPPORT=0");
 }
+var BILLING_SIGNALS = [
+  /\b402\b(?!:\d)/,
+  /billing[_ ](?:error|issue|problem|failure)/,
+  /subscription (?:is |has )?(?:inactive|expired|lapsed|cancell?ed|ended|invalid|not active)/,
+  /(?:expired|inactive|lapsed|invalid|no active|cancell?ed) subscription/,
+  /payment (?:method|required|failed|declined|details|info)/,
+  /update your payment/,
+  /(?:out of|draw from|draws from) extra usage/,
+  /insufficient (?:credit|funds|balance)/
+];
+var HIT_YOUR_LIMIT = /hit your (?:[\w-]+ )?limit/;
 function classifyError(errMsg, model) {
   const lower = errMsg.toLowerCase();
   if (lower.includes("oauth token has expired") || lower.includes("not logged in")) {
@@ -11796,7 +12124,7 @@ function classifyError(errMsg, model) {
       message: "Claude authentication expired or invalid. Run 'claude login' in your terminal to re-authenticate, then restart the proxy."
     };
   }
-  if (lower.includes("429") || lower.includes("rate limit") || lower.includes("too many requests") || lower.includes("hit your session limit") || lower.includes("usage limit reached")) {
+  if (lower.includes("429") || lower.includes("rate limit") || lower.includes("too many requests") || HIT_YOUR_LIMIT.test(lower) || lower.includes("usage limit reached")) {
     const hint = lower.includes("1m") || lower.includes("context") ? extendedContextHint(model) : "";
     return {
       status: 429,
@@ -11804,7 +12132,7 @@ function classifyError(errMsg, model) {
       message: `Claude Max rate limit reached. Wait a moment and try again.${hint}`
     };
   }
-  if (lower.includes("402") || lower.includes("billing") || lower.includes("subscription") || lower.includes("payment")) {
+  if (BILLING_SIGNALS.some((rx) => rx.test(lower))) {
     return {
       status: 402,
       type: "billing_error",
@@ -11889,6 +12217,16 @@ function isRateLimitError(errMsg) {
   const lower = errMsg.toLowerCase();
   return lower.includes("429") || lower.includes("rate limit") || lower.includes("too many requests");
 }
+var ACCOUNT_FAILOVER_ERROR_TYPES = new Set([
+  "rate_limit_error",
+  "billing_error"
+]);
+function isAccountFailoverError(errorType) {
+  return typeof errorType === "string" && ACCOUNT_FAILOVER_ERROR_TYPES.has(errorType);
+}
+function isQuotaRefusal(errorType) {
+  return errorType === "rate_limit_error";
+}
 function isExtraUsageRequiredError(errMsg) {
   const lower = errMsg.toLowerCase();
   return lower.includes("extra usage") && lower.includes("1m") || lower.includes("out of extra usage");
@@ -12279,7 +12617,7 @@ ${c.text}
     return "";
   }).filter(Boolean).join("");
 }
-function translateOpenAiToAnthropic(body) {
+function translateOpenAiToAnthropic(body, options = {}) {
   const messages = body.messages ?? [];
   if (messages.length === 0)
     return null;
@@ -12371,7 +12709,7 @@ function translateOpenAiToAnthropic(body) {
   let systemPrompt = systemParts.join(`
 `);
   let messagesToSend = turns;
-  if (turns.length > 1) {
+  if (turns.length > 1 && !options.preserveConversationHistory) {
     const history = turns.slice(0, -1).map((m) => `${m.role}: ${summarizeAnthropicContent(m.content)}`).join(`
 `);
     const historyBlock = `<conversation_history>
@@ -12666,6 +13004,9 @@ function buildModelList(isMaxSubscription, now = Math.floor(Date.now() / 1000))
   ];
 }
 
+// src/proxy/server.ts
+init_jcode();
+
 // src/proxy/openaiResponses.ts
 function itemDiscriminator(item) {
   if (typeof item !== "object" || item === null)
@@ -18858,7 +19199,7 @@ function buildQueryOptions(ctx, abortController) {
     hasDeferredTools,
     resumeSessionId,
     isUndo,
-    undoRollbackUuid,
+    resumeSessionAtUuid,
     forkSession,
     sdkHooks,
     blockedTools,
@@ -18929,7 +19270,7 @@ function buildQueryOptions(ctx, abortController) {
       ...Object.keys(sdkAgents).length > 0 ? { agents: sdkAgents } : {},
       ...resumeSessionId ? { resume: resumeSessionId } : {},
       ...isUndo || forkSession ? { forkSession: true } : {},
-      ...isUndo && undoRollbackUuid ? { resumeSessionAt: undoRollbackUuid } : {},
+      ...resumeSessionAtUuid ? { resumeSessionAt: resumeSessionAtUuid } : {},
       ...sdkHooks ? { hooks: sdkHooks } : {},
       ...effort ? { effort } : {},
       ...thinking ? { thinking } : {},
@@ -18990,6 +19331,34 @@ init_opencode();
 init_crush();
 init_droid();
 init_pi();
+
+// src/proxy/transforms/prime.ts
+init_tools();
+init_env();
+init_prime();
+function resolvePrimePassthrough() {
+  return resolvePassthrough(true);
+}
+var primeTransforms = [
+  {
+    name: "prime-core",
+    adapters: ["prime"],
+    onRequest(ctx) {
+      return {
+        ...ctx,
+        blockedTools: BLOCKED_BUILTIN_TOOLS,
+        incompatibleTools: CLAUDE_CODE_ONLY_TOOLS,
+        allowedMcpTools: PRIME_ALLOWED_MCP_TOOLS,
+        sdkAgents: {},
+        passthrough: resolvePrimePassthrough(),
+        supportsThinking: true,
+        extractFileChangesFromToolUse: extractPrimeFileChanges
+      };
+    }
+  }
+];
+
+// src/proxy/transforms/registry.ts
 init_forgecode();
 init_passthrough();
 
@@ -19071,11 +19440,13 @@ var ADAPTER_TRANSFORMS = {
   crush: crushTransforms,
   droid: droidTransforms,
   pi: piTransforms,
+  prime: primeTransforms,
   forgecode: forgeCodeTransforms,
   passthrough: passthroughTransforms,
   cherry: cherryTransforms,
   "claude-code": claudeCodeTransforms,
   openai: openCodeTransforms,
+  jcode: openCodeTransforms,
   codex: [...openCodeTransforms, ...codexTransforms]
 };
 function getAdapterTransforms(adapterName) {
@@ -19088,7 +19459,7 @@ import { join as join5, isAbsolute as isAbsolute2, extname } from "path";
 import { pathToFileURL } from "url";
 
 // src/proxy/plugins/validation.ts
-var KNOWN_ADAPTERS = ["opencode", "openai", "crush", "droid", "pi", "forgecode", "passthrough"];
+var KNOWN_ADAPTERS = ["opencode", "openai", "jcode", "crush", "droid", "pi", "forgecode", "passthrough"];
 var KNOWN_HOOKS = ["onRequest", "onResponse", "onTelemetry", "onSession", "onToolUse", "onToolResult", "onError"];
 function validateTransform(exported) {
   if (exported == null || typeof exported !== "object") {
@@ -19443,11 +19814,66 @@ function computeLineageHash(messages) {
 function hashMessage(message) {
   return createHash2("sha256").update(`${message.role}:${normalizeContent(message.content)}`).digest("hex").slice(0, 32);
 }
+function describeShape(message) {
+  const normalized = normalizeContent(message.content);
+  return {
+    role: message.role,
+    blocks: Array.isArray(message.content) ? message.content.map((b) => String(b?.type ?? "unknown")).join(",") : typeof message.content === "string" ? "string" : "unknown",
+    bytes: Buffer.byteLength(normalized, "utf8")
+  };
+}
+function describeLineageMismatch(cached, messages, precomputedIncomingHashes) {
+  const storedHashes = cached.messageHashes ?? [];
+  const incomingHashes = precomputedIncomingHashes ?? computeMessageHashes(messages);
+  const limit = Math.min(storedHashes.length, incomingHashes.length);
+  let index = -1;
+  for (let i = 0;i < limit; i++) {
+    if (storedHashes[i] !== incomingHashes[i]) {
+      index = i;
+      break;
+    }
+  }
+  const base = {
+    index,
+    storedCount: cached.messageCount,
+    incomingCount: messages.length
+  };
+  if (index < 0)
+    return base;
+  return {
+    ...base,
+    storedDigest: storedHashes[index],
+    incomingDigest: incomingHashes[index],
+    incomingShape: messages[index] ? describeShape(messages[index]) : undefined,
+    previousDigest: index > 0 ? storedHashes[index - 1] : undefined
+  };
+}
+function formatLineageMismatch(mismatch) {
+  if (mismatch.index < 0)
+    return;
+  const short = (digest) => digest ? digest.slice(0, 12) : "—";
+  const trailing = mismatch.index === mismatch.storedCount - 1 ? " (trailing message only — the rest of the history matched)" : "";
+  const shape = mismatch.incomingShape ? `${mismatch.incomingShape.role}[${mismatch.incomingShape.blocks}] ${mismatch.incomingShape.bytes}B` : "unknown";
+  return `first mismatch at index ${mismatch.index}${trailing}: ` + `stored=${short(mismatch.storedDigest)} incoming=${short(mismatch.incomingDigest)}, ` + `incoming now ${shape}`;
+}
 function computeMessageHashes(messages) {
   if (!messages || messages.length === 0)
     return [];
   return messages.map(hashMessage);
 }
+function hashNormalizedContent(content) {
+  return createHash2("sha256").update(normalizeContent(content)).digest("hex").slice(0, 32);
+}
+function hashableContentBlocks(content) {
+  if (!Array.isArray(content))
+    return [content];
+  return content.filter((block) => !HASH_IGNORED_BLOCK_TYPES.has(block?.type));
+}
+function computeMessageBlockHashes(messages) {
+  if (!messages || messages.length === 0)
+    return [];
+  return messages.map((message) => hashableContentBlocks(message.content).map((block) => hashNormalizedContent(Array.isArray(message.content) ? [block] : block)));
+}
 function measurePrefixOverlap(storedHashes, incomingHashes) {
   let overlap = 0;
   const minLen = Math.min(storedHashes.length, incomingHashes.length);
@@ -19530,6 +19956,34 @@ function verifyLineage(cached, messages) {
       suffixOverlap
     };
   }
+  const boundary = cached.messageCount - 1;
+  if (boundary >= 0 && prefixOverlap === boundary && messages.length >= cached.messageCount && cached.messageBlockHashes?.length === cached.messageCount) {
+    const incomingBoundary = messages[boundary];
+    const storedBlocks = cached.messageBlockHashes[boundary];
+    if (incomingBoundary?.role === "user" && storedBlocks && Array.isArray(incomingBoundary.content)) {
+      const incomingBlocks = hashableContentBlocks(incomingBoundary.content);
+      const incomingBlockHashes = incomingBlocks.map((block) => hashNormalizedContent([block]));
+      const preservesStoredBlocks = incomingBlocks.length === incomingBoundary.content.length && incomingBlockHashes.length > storedBlocks.length && storedBlocks.every((hash, index) => incomingBlockHashes[index] === hash);
+      const appendedBlocks = incomingBlocks.slice(storedBlocks.length);
+      const seenToolResultIds = new Set(incomingBlocks.slice(0, storedBlocks.length).filter((block) => block?.type === "tool_result" && typeof block.tool_use_id === "string").map((block) => block.tool_use_id));
+      const hasOnlyNewToolResults = appendedBlocks.every((block) => {
+        if (block?.type !== "tool_result" || typeof block.tool_use_id !== "string")
+          return false;
+        if (seenToolResultIds.has(block.tool_use_id))
+          return false;
+        seenToolResultIds.add(block.tool_use_id);
+        return true;
+      });
+      if (preservesStoredBlocks && hasOnlyNewToolResults) {
+        return {
+          type: "continuation",
+          session: cached,
+          resumeFrom: boundary,
+          resumeContentFrom: storedBlocks.length
+        };
+      }
+    }
+  }
   if (prefixOverlap > 0 && suffixOverlap === 0 && messages.length <= cached.messageCount) {
     let rollbackUuid;
     if (cached.sdkMessageUuids) {
@@ -19543,7 +19997,12 @@ function verifyLineage(cached, messages) {
     return { type: "undo", session: cached, prefixOverlap, rollbackUuid };
   }
   if (prefixOverlap > 0 && messages.length > cached.messageCount) {
-    return { type: "diverged", reason: "modified-history", prefixOverlap };
+    return {
+      type: "diverged",
+      reason: "modified-history",
+      prefixOverlap,
+      mismatch: describeLineageMismatch(cached, messages, incomingHashes)
+    };
   }
   return { type: "diverged", reason: "unrelated-history", prefixOverlap };
 }
@@ -19676,7 +20135,7 @@ function lookupSharedSessionByClaudeId(claudeSessionId) {
   }
   return newest;
 }
-function storeSharedSession(key, claudeSessionId, messageCount, lineageHash, messageHashes, sdkMessageUuids, contextUsage) {
+function storeSharedSession(key, claudeSessionId, messageCount, lineageHash, messageHashes, sdkMessageUuids, contextUsage, messageBlockHashes, passthroughResumeUuid) {
   const path3 = getStorePath();
   const lockPath = `${path3}.lock`;
   const hasLock = skipLocking ? false : acquireLock(lockPath);
@@ -19694,7 +20153,9 @@ function storeSharedSession(key, claudeSessionId, messageCount, lineageHash, mes
       messageCount: messageCount ?? existing?.messageCount ?? 0,
       lineageHash: lineageHash ?? existing?.lineageHash,
       messageHashes: messageHashes ?? existing?.messageHashes,
+      messageBlockHashes: messageBlockHashes ?? existing?.messageBlockHashes,
       sdkMessageUuids: sdkMessageUuids ?? existing?.sdkMessageUuids,
+      passthroughResumeUuid: passthroughResumeUuid === undefined ? existing?.passthroughResumeUuid : passthroughResumeUuid ?? undefined,
       contextUsage: contextUsage ?? existing?.contextUsage,
       ...previousClaudeSessionId ? { previousClaudeSessionId } : {}
     };
@@ -19852,7 +20313,11 @@ function touchSession(state) {
 }
 function classifyLineage(state, messages, cacheKey2) {
   const result = verifyLineage(state, messages);
-  if (result.type === "compaction") {
+  if (result.type === "continuation" && result.resumeContentFrom !== undefined) {
+    const msg = `Parallel tool-result continuation (key=${cacheKey2.slice(0, 8)}…): resume from message ${result.resumeFrom}, content block ${result.resumeContentFrom}.`;
+    console.error(`[PROXY] ${msg}`);
+    diagnosticLog2.lineage(msg);
+  } else if (result.type === "compaction") {
     const msg = `Compaction detected (key=${cacheKey2.slice(0, 8)}…): suffix overlap ${result.suffixOverlap}/${state.messageCount}, resume from incoming message ${result.resumeFrom}.`;
     console.error(`[PROXY] ${msg}`);
     diagnosticLog2.lineage(msg);
@@ -19861,7 +20326,9 @@ function classifyLineage(state, messages, cacheKey2) {
     console.error(`[PROXY] ${msg}`);
     diagnosticLog2.lineage(msg);
   } else if (result.type === "diverged" && result.reason === "modified-history") {
-    const msg = `Stale session detected (key=${cacheKey2.slice(0, 8)}…): prefix overlap ${result.prefixOverlap || 0}/${state.messageCount}, incoming ${messages.length} msgs. Starting fresh replay.`;
+    const detail = result.mismatch ? formatLineageMismatch(result.mismatch) : undefined;
+    const msg = `Stale session detected (key=${cacheKey2.slice(0, 8)}…): prefix overlap ${result.prefixOverlap || 0}/${state.messageCount}, incoming ${messages.length} msgs. Starting fresh replay.` + (detail ? `
+  ${detail}` : "");
     console.error(`[PROXY] ${msg}`);
     diagnosticLog2.lineage(msg);
   }
@@ -19884,7 +20351,9 @@ function lookupSession(sessionId, messages, workingDirectory) {
         messageCount: shared.messageCount || 0,
         lineageHash: shared.lineageHash || "",
         messageHashes: shared.messageHashes,
+        messageBlockHashes: shared.messageBlockHashes,
         sdkMessageUuids: shared.sdkMessageUuids,
+        passthroughResumeUuid: shared.passthroughResumeUuid,
         contextUsage: shared.contextUsage
       };
       const result = classifyLineage(state, messages, sessionId);
@@ -19912,7 +20381,9 @@ function lookupSession(sessionId, messages, workingDirectory) {
         messageCount: shared.messageCount || 0,
         lineageHash: shared.lineageHash || "",
         messageHashes: shared.messageHashes,
+        messageBlockHashes: shared.messageBlockHashes,
         sdkMessageUuids: shared.sdkMessageUuids,
+        passthroughResumeUuid: shared.passthroughResumeUuid,
         contextUsage: shared.contextUsage
       };
       const result = classifyLineage(state, messages, fp);
@@ -19945,24 +20416,29 @@ function getSessionByClaudeId(claudeSessionId) {
       messageCount: shared.messageCount || 0,
       lineageHash: shared.lineageHash || "",
       messageHashes: shared.messageHashes,
+      messageBlockHashes: shared.messageBlockHashes,
       sdkMessageUuids: shared.sdkMessageUuids,
+      passthroughResumeUuid: shared.passthroughResumeUuid,
       contextUsage: shared.contextUsage
     });
   }
   return newest;
 }
-function storeSession(sessionId, messages, claudeSessionId, workingDirectory, sdkMessageUuids, contextUsage) {
+function storeSession(sessionId, messages, claudeSessionId, workingDirectory, sdkMessageUuids, contextUsage, passthroughResumeUuid) {
   if (!claudeSessionId)
     return;
   const lineageHash = computeLineageHash(messages);
   const messageHashes = computeMessageHashes(messages);
+  const messageBlockHashes = computeMessageBlockHashes(messages);
   const state = {
     claudeSessionId,
     lastAccess: Date.now(),
     messageCount: messages?.length || 0,
     lineageHash,
     messageHashes,
+    messageBlockHashes,
     sdkMessageUuids,
+    ...passthroughResumeUuid ? { passthroughResumeUuid } : {},
     ...contextUsage ? { contextUsage } : {}
   };
   if (sessionId)
@@ -19972,14 +20448,14 @@ function storeSession(sessionId, messages, claudeSessionId, workingDirectory, sd
     fingerprintCache.set(fp, state);
   const key = sessionId || fp;
   if (key) {
-    storeSharedSession(key, claudeSessionId, state.messageCount, lineageHash, messageHashes, sdkMessageUuids, contextUsage);
+    storeSharedSession(key, claudeSessionId, state.messageCount, lineageHash, messageHashes, sdkMessageUuids, contextUsage, messageBlockHashes, passthroughResumeUuid ?? null);
   }
 }
 
 // src/proxy/server.ts
 var exec2 = promisify3(execCallback);
 var claudeExecutable = "";
-var UPSTREAM_IDLE_MS = 90000;
+var UPSTREAM_IDLE_MS = envInt("UPSTREAM_IDLE_MS", 90000);
 function credentialStoreForProfile(profile) {
   if (profile.type !== "claude-max")
     return;
@@ -20266,23 +20742,25 @@ function createProxyServer(config = {}) {
       });
     });
   }
-  async function sniffQuotaFailure(res) {
+  async function sniffAccountFailure(res) {
     const contentType = res.headers.get("content-type") ?? "";
     if (!contentType.includes("text/event-stream")) {
-      if (res.status === 429) {
+      if (!res.ok) {
         const body = await res.clone().json().catch(() => null);
-        if (body?.error?.type === "rate_limit_error")
-          return { failed: true, errorPayload: body, response: res };
+        const errorType = body?.error?.type;
+        if (isAccountFailoverError(errorType)) {
+          return { failed: true, errorPayload: body, errorType, response: res };
+        }
       }
-      return { failed: false, errorPayload: null, response: res };
+      return { failed: false, errorPayload: null, errorType: null, response: res };
     }
     const reader = res.body?.getReader();
     if (!reader)
-      return { failed: false, errorPayload: null, response: res };
+      return { failed: false, errorPayload: null, errorType: null, response: res };
     const decoder = new TextDecoder;
     const consumed = [];
     let text = "";
-    let failedPayload = null;
+    let failure = null;
     while (true) {
       const { done, value } = await reader.read();
       if (done)
@@ -20300,16 +20778,17 @@ function createProxyServer(config = {}) {
 `).find((l) => l.startsWith("data: "));
         try {
           const parsed = dataLine ? JSON.parse(dataLine.slice(6)) : null;
-          if (parsed?.error?.type === "rate_limit_error") {
-            failedPayload = parsed;
+          const parsedType = parsed?.error?.type;
+          if (isAccountFailoverError(parsedType)) {
+            failure = { payload: parsed, type: parsedType };
           }
         } catch {}
       }
       break;
     }
-    if (failedPayload) {
+    if (failure) {
       await reader.cancel().catch(() => {});
-      return { failed: true, errorPayload: failedPayload, response: res };
+      return { failed: true, errorPayload: failure.payload, errorType: failure.type, response: res };
     }
     const rest = new ReadableStream({
       start(ctrl) {
@@ -20327,33 +20806,40 @@ function createProxyServer(config = {}) {
         reader.cancel(reason).catch(() => {});
       }
     });
-    return { failed: false, errorPayload: null, response: new Response(rest, { status: res.status, headers: res.headers }) };
+    return { failed: false, errorPayload: null, errorType: null, response: new Response(rest, { status: res.status, headers: res.headers }) };
   }
   async function dispatchPriority(c, orderedCandidateIds, sessionKey, wantsStream) {
     const bodyBuf = await c.req.arrayBuffer();
     let lastError = null;
+    let lastStatus = 429;
     let previous = null;
+    let previousReason = "rate_limit_error";
     for (const candidate of orderedCandidateIds) {
       const headers = new Headers(c.req.raw.headers);
       headers.set("x-meridian-profile", candidate);
       headers.set("x-meridian-priority-dispatch", "1");
       const inner = await app.fetch(new Request(c.req.url, { method: "POST", headers, body: bodyBuf }));
-      const { failed, errorPayload, response } = await sniffQuotaFailure(inner);
-      if (!failed) {
+      const sniffed = await sniffAccountFailure(inner);
+      if (!sniffed.failed) {
         if (sessionKey)
           priorityAssignments.set(sessionKey, candidate);
         if (previous) {
-          claudeLog("profile.failover", { from: previous, to: candidate, reason: "rate_limit_error", sessionKey });
-          plog(`[PROXY] PRIORITY failover ${previous} -> ${candidate}`);
-        }
-        return response;
-      }
-      const cooldownUntil = priorityCooldownUntil(candidate, Date.now());
-      priorityExhaustion.mark(candidate, cooldownUntil, "rate_limit_error");
-      claudeLog("priority.exhausted", { profile: candidate, until: cooldownUntil });
-      refinePriorityCooldown(candidate);
-      lastError = errorPayload;
+          claudeLog("profile.failover", { from: previous, to: candidate, reason: previousReason, sessionKey });
+          plog(`[PROXY] PRIORITY failover ${previous} -> ${candidate} (${previousReason})`);
+        }
+        return sniffed.response;
+      }
+      const reason = sniffed.errorType;
+      const quotaRefusal = isQuotaRefusal(reason);
+      const cooldownUntil = quotaRefusal ? priorityCooldownUntil(candidate, Date.now()) : Date.now() + PRIORITY_DEFAULT_COOLDOWN_MS;
+      priorityExhaustion.mark(candidate, cooldownUntil, reason);
+      claudeLog("priority.exhausted", { profile: candidate, until: cooldownUntil, reason });
+      if (quotaRefusal)
+        refinePriorityCooldown(candidate);
+      lastError = sniffed.errorPayload;
+      lastStatus = inner.status;
       previous = candidate;
+      previousReason = reason;
     }
     if (wantsStream) {
       return new Response(`event: error
@@ -20364,7 +20850,7 @@ data: ${JSON.stringify(lastError)}
         headers: { "content-type": "text/event-stream; charset=utf-8", "cache-control": "no-cache" }
       });
     }
-    return new Response(JSON.stringify(lastError), { status: 429, headers: { "content-type": "application/json" } });
+    return new Response(JSON.stringify(lastError), { status: lastStatus, headers: { "content-type": "application/json" } });
   }
   app.use("/auth/*", requireAuth);
   app.get("/", (c) => {
@@ -20562,12 +21048,34 @@ data: ${JSON.stringify(lastError)}
         if (lineageResult.type === "undo" && adapterBase === "opencode" && !agentSessionId) {
           lineageResult = { type: "diverged", reason: "missing-session-header" };
         }
+        if (pipeline.some((t) => t.onSession)) {
+          const mismatch = lineageResult.type === "diverged" ? lineageResult.mismatch : undefined;
+          runTransformHook(pipeline, "onSession", {
+            adapter: adapterBase,
+            lineage: lineageResult.type,
+            reason: lineageResult.type === "diverged" ? lineageResult.reason : undefined,
+            sessionKey: profileSessionId,
+            storedCount: mismatch?.storedCount,
+            incomingCount: (body.messages || []).length,
+            prefixOverlap: lineageResult.type === "diverged" ? lineageResult.prefixOverlap : undefined,
+            mismatch: mismatch && mismatch.index >= 0 ? {
+              index: mismatch.index,
+              storedDigest: mismatch.storedDigest,
+              incomingDigest: mismatch.incomingDigest,
+              previousDigest: mismatch.previousDigest,
+              incomingShape: mismatch.incomingShape
+            } : undefined
+          }, adapterBase);
+        }
         const isResume = lineageResult.type === "continuation" || lineageResult.type === "compaction";
         const isUndo = lineageResult.type === "undo";
         const cachedSession = lineageResult.type !== "diverged" ? lineageResult.session : undefined;
         const resumeSessionId = cachedSession?.claudeSessionId;
+        const passthrough = adapter.instancePassthrough !== undefined ? adapter.instancePassthrough : pipelineCtx.passthrough !== undefined ? pipelineCtx.passthrough : envBool("PASSTHROUGH");
         const resumeFrom = lineageResult.type === "continuation" || lineageResult.type === "compaction" ? lineageResult.resumeFrom : undefined;
+        const resumeContentFrom = lineageResult.type === "continuation" ? lineageResult.resumeContentFrom : undefined;
         const undoRollbackUuid = isUndo && lineageResult.type === "undo" ? lineageResult.rollbackUuid : undefined;
+        const passthroughResumeUuid = passthrough && isResume ? cachedSession?.passthroughResumeUuid : undefined;
         const msgSummary = body.messages?.map((m) => {
           const contentTypes = Array.isArray(m.content) ? m.content.map((b) => b.type).join(",") : "string";
           return `${m.role}[${contentTypes}]`;
@@ -20610,7 +21118,16 @@ data: ${JSON.stringify(lastError)}
           if (isUndo && undoRollbackUuid) {
             messagesToConvert = getLastUserMessage(allMessages);
           } else if (isResume) {
-            if (resumeFrom !== undefined && resumeFrom < allMessages.length) {
+            if (resumeFrom !== undefined && resumeContentFrom !== undefined && resumeFrom < allMessages.length && Array.isArray(allMessages[resumeFrom]?.content)) {
+              const boundaryMessage = allMessages[resumeFrom];
+              messagesToConvert = [
+                {
+                  ...boundaryMessage,
+                  content: boundaryMessage.content.slice(resumeContentFrom)
+                },
+                ...allMessages.slice(resumeFrom + 1)
+              ];
+            } else if (resumeFrom !== undefined && resumeFrom < allMessages.length) {
               messagesToConvert = allMessages.slice(resumeFrom);
             } else {
               messagesToConvert = getLastUserMessage(allMessages);
@@ -20659,6 +21176,13 @@ data: ${JSON.stringify(lastError)}
           if (structuredMessages.length > 1) {
             structuredMessages = consolidateMultimodalOntoLastUser(structuredMessages);
           }
+          if (passthroughResumeUuid && structuredMessages.length > 0) {
+            structuredMessages.unshift({
+              type: "user",
+              message: { role: "user", content: PASSTHROUGH_CONTINUATION_LEAD_IN },
+              parent_tool_use_id: null
+            });
+          }
         } else {
           const toolIndex = buildToolUseIndex(allMessages ?? messagesToConvert ?? []);
           const promptTurns = (messagesToConvert ?? []).map((m) => {
@@ -20670,11 +21194,11 @@ data: ${JSON.stringify(lastError)}
             }
             return { role: "user", text: flattenUserContent(m.content, sanitizeOpts, toolIndex) };
           });
-          textPrompt = isResume ? promptTurns.map((t) => t.text).filter(Boolean).join(`
+          const resumeDelta = promptTurns.map((t) => t.text).filter(Boolean).join(`
 
-`) || "" : frameReplayTurns(promptTurns);
+`) || "";
+          textPrompt = isResume ? passthroughResumeUuid ? framePassthroughContinuation(resumeDelta) : resumeDelta : frameReplayTurns(promptTurns);
         }
-        const passthrough = adapter.instancePassthrough !== undefined ? adapter.instancePassthrough : pipelineCtx.passthrough !== undefined ? pipelineCtx.passthrough : envBool("PASSTHROUGH");
         const settingSources = envBool("LOAD_CONTEXT") || sdkFeatures.claudeMd === "full" ? ["user", "project"] : sdkFeatures.claudeMd === "project" ? ["project"] : pipelineCtx.settingSources ?? [];
         const capturedToolUses = [];
         const capturedSignatures = new Set;
@@ -20842,6 +21366,7 @@ data: ${JSON.stringify(lastError)}
           claudeLog("upstream.start", { mode: "non_stream", model });
           let lastUsage;
           let lastStopReason;
+          let nextPassthroughResumeUuid;
           try {
             if (!claudeExecutable) {
               claudeExecutable = await resolveClaudeExecutableAsync();
@@ -20878,8 +21403,8 @@ data: ${JSON.stringify(lastError)}
                     hasDeferredTools,
                     resumeSessionId,
                     isUndo,
-                    undoRollbackUuid,
-                    forkSession: busySessionFork || undefined,
+                    resumeSessionAtUuid: undoRollbackUuid ?? passthroughResumeUuid,
+                    forkSession: busySessionFork || Boolean(passthroughResumeUuid) || undefined,
                     sdkHooks,
                     blockedTools: pipelineCtx.blockedTools,
                     incompatibleTools: pipelineCtx.incompatibleTools,
@@ -20962,7 +21487,7 @@ data: ${JSON.stringify(lastError)}
                       hasDeferredTools,
                       resumeSessionId: undefined,
                       isUndo: false,
-                      undoRollbackUuid: undefined,
+                      resumeSessionAtUuid: undefined,
                       sdkHooks,
                       blockedTools: pipelineCtx.blockedTools,
                       incompatibleTools: pipelineCtx.incompatibleTools,
@@ -21031,7 +21556,7 @@ data: ${JSON.stringify(lastError)}
                       hasDeferredTools,
                       resumeSessionId: undefined,
                       isUndo: false,
-                      undoRollbackUuid: undefined,
+                      resumeSessionAtUuid: undefined,
                       sdkHooks,
                       blockedTools: pipelineCtx.blockedTools,
                       incompatibleTools: pipelineCtx.incompatibleTools,
@@ -21112,6 +21637,7 @@ data: ${JSON.stringify(lastError)}
                 if (message.type === "assistant") {
                   noteAssistantContent(earlyStop, message.message?.content);
                 } else if (message.type === "user") {
+                  nextPassthroughResumeUuid = resumeBoundaryUuid(message) ?? nextPassthroughResumeUuid;
                   noteUserContent(earlyStop, message.message?.content);
                   if (shouldEarlyStop(earlyStop)) {
                     earlyStopFired = true;
@@ -21351,7 +21877,7 @@ Subprocess stderr: ${stderrOutput}`;
             ]);
           }
           if (currentSessionId && !isIndependentSession && !sawDuplicateToolUse) {
-            storeSession(profileSessionId, body.messages || [], currentSessionId, profileScopedCwd, sdkUuidMap, lastUsage);
+            storeSession(profileSessionId, body.messages || [], currentSessionId, profileScopedCwd, sdkUuidMap, lastUsage, earlyStopFired ? nextPassthroughResumeUuid : null);
           }
           const responseSessionId = currentSessionId || resumeSessionId || `session_${Date.now()}`;
           return new Response(JSON.stringify({
@@ -21383,6 +21909,7 @@ Subprocess stderr: ${stderrOutput}`;
             let streamEventsSeen = 0;
             let eventsForwarded = 0;
             let textEventsForwarded = 0;
+            let textCharsForwarded = 0;
             let bytesSent = 0;
             let streamClosed = false;
             let awaitingEarlyStopDrain = false;
@@ -21414,7 +21941,30 @@ Subprocess stderr: ${stderrOutput}`;
             let lastUsage;
             let hasStructuredOutput = false;
             let structuredOutput;
+            let nextPassthroughResumeUuid;
+            const silentTurnRecoveryEnabled = env("SILENT_TURN_RECOVERY") !== "0";
+            let silentTurnRecoveryAttempted = false;
+            let silentTurnRecovered = false;
             const streamedToolUseIds = new Set;
+            let pendingTerminalDelta = null;
+            let terminalDeltaSent = false;
+            const sendTerminalDelta = (stopReasonOverride) => {
+              if (terminalDeltaSent)
+                return;
+              const payload = stopReasonOverride ? encoder.encode(`event: message_delta
+data: ${JSON.stringify({
+                type: "message_delta",
+                delta: { stop_reason: stopReasonOverride, stop_sequence: null },
+                usage: { output_tokens: lastUsage?.output_tokens ?? 0 }
+              })}
+
+`) : pendingTerminalDelta;
+              if (!payload)
+                return;
+              terminalDeltaSent = true;
+              if (safeEnqueue(payload, "terminal_message_delta"))
+                eventsForwarded += 1;
+            };
             const openClientBlocks = new Set;
             const resolvePendingStore = passthrough && earlyStopEnabled && !isIndependentSession && profileSessionId ? registerPendingStore(profileSessionId) : () => {};
             let pendingEarlyStop = false;
@@ -21430,10 +21980,7 @@ Subprocess stderr: ${stderrOutput}`;
               });
               pendingEarlyStop = false;
               flushOpenClientBlocks("early_stop");
-              safeEnqueue(encoder.encode(`event: message_delta
-data: ${JSON.stringify({ type: "message_delta", delta: { stop_reason: "tool_use", stop_sequence: null }, usage: { output_tokens: lastUsage?.output_tokens ?? 0 } })}
-
-`), "early_stop");
+              sendTerminalDelta("tool_use");
               safeEnqueue(encoder.encode(`event: message_stop
 data: ${JSON.stringify({ type: "message_stop" })}
 
@@ -21463,8 +22010,8 @@ data: ${JSON.stringify({ type: "content_block_stop", index: idx })}
               }
               openClientBlocks.clear();
             };
+            let currentSessionId;
             try {
-              let currentSessionId;
               const MAX_RATE_LIMIT_RETRIES = 2;
               const RATE_LIMIT_BASE_DELAY_MS = 1000;
               const response = async function* () {
@@ -21496,8 +22043,8 @@ data: ${JSON.stringify({ type: "content_block_stop", index: idx })}
                       hasDeferredTools,
                       resumeSessionId,
                       isUndo,
-                      undoRollbackUuid,
-                      forkSession: busySessionFork || undefined,
+                      resumeSessionAtUuid: undoRollbackUuid ?? passthroughResumeUuid,
+                      forkSession: busySessionFork || Boolean(passthroughResumeUuid) || undefined,
                       sdkHooks,
                       blockedTools: pipelineCtx.blockedTools,
                       incompatibleTools: pipelineCtx.incompatibleTools,
@@ -21579,7 +22126,7 @@ data: ${JSON.stringify({ type: "content_block_stop", index: idx })}
                         hasDeferredTools,
                         resumeSessionId: undefined,
                         isUndo: false,
-                        undoRollbackUuid: undefined,
+                        resumeSessionAtUuid: undefined,
                         sdkHooks,
                         blockedTools: pipelineCtx.blockedTools,
                         incompatibleTools: pipelineCtx.incompatibleTools,
@@ -21648,7 +22195,7 @@ data: ${JSON.stringify({ type: "content_block_stop", index: idx })}
                         hasDeferredTools,
                         resumeSessionId: undefined,
                         isUndo: false,
-                        undoRollbackUuid: undefined,
+                        resumeSessionAtUuid: undefined,
                         sdkHooks,
                         blockedTools: pipelineCtx.blockedTools,
                         incompatibleTools: pipelineCtx.incompatibleTools,
@@ -21761,6 +22308,7 @@ data: ${JSON.stringify({ type: "content_block_stop", index: idx })}
                   if (message.type === "assistant" && message.uuid) {
                     sdkUuidMap.push(message.uuid);
                   }
+                  nextPassthroughResumeUuid = resumeBoundaryUuid(message) ?? nextPassthroughResumeUuid;
                   if (earlyStopEnabled) {
                     if (message.type === "assistant") {
                       noteAssistantContent(earlyStop, message.message?.content);
@@ -21832,10 +22380,7 @@ data: ${JSON.stringify({ type: "content_block_stop", index: idx })}
                       if (messageStartEmitted) {
                         if (passthrough && streamedToolUseIds.size > 0) {
                           flushOpenClientBlocks("turn2_suppression");
-                          safeEnqueue(encoder.encode(`event: message_delta
-data: ${JSON.stringify({ type: "message_delta", delta: { stop_reason: "tool_use", stop_sequence: null }, usage: { output_tokens: lastUsage?.output_tokens ?? 0 } })}
-
-`), "passthrough_turn2_stop");
+                          sendTerminalDelta("tool_use");
                           safeEnqueue(encoder.encode(`event: message_stop
 data: ${JSON.stringify({ type: "message_stop" })}
 
@@ -21939,15 +22484,26 @@ data: ${JSON.stringify({
                         }
                       }
                     }
+                    if (eventType === "content_block_delta" && event.delta?.type === "text_delta" && shouldInjectSilentTurn({
+                      raw: env("DEBUG_FORCE_SILENT_TURN"),
+                      sessionId: agentSessionId
+                    })) {
+                      claudeLog("debug.silent_turn_injected", { sessionId: agentSessionId });
+                      continue;
+                    }
                     stripNonStandardStreamFields(event);
                     const payload = encoder.encode(`event: ${eventType}
 data: ${JSON.stringify(event)}
 
 `);
-                    if (!safeEnqueue(payload, `stream_event:${eventType}`)) {
-                      break;
+                    if (eventType === "message_delta") {
+                      pendingTerminalDelta = payload;
+                    } else {
+                      if (!safeEnqueue(payload, `stream_event:${eventType}`)) {
+                        break;
+                      }
+                      eventsForwarded += 1;
                     }
-                    eventsForwarded += 1;
                     if (eventType === "content_block_start") {
                       const idx = event.index;
                       if (typeof idx === "number")
@@ -21963,6 +22519,7 @@ data: ${JSON.stringify(event)}
                     }
                     if (passthrough && eventType === "message_delta" && event.delta?.stop_reason === "tool_use" && streamedToolUseIds.size > 0) {
                       flushOpenClientBlocks("drain_close");
+                      sendTerminalDelta();
                       safeEnqueue(encoder.encode(`event: message_stop
 data: ${JSON.stringify({ type: "message_stop" })}
 
@@ -21979,6 +22536,8 @@ data: ${JSON.stringify({ type: "message_stop" })}
                       const delta = event.delta;
                       if (delta?.type === "text_delta") {
                         textEventsForwarded += 1;
+                        if (typeof delta.text === "string")
+                          textCharsForwarded += delta.text.length;
                       }
                     }
                   }
@@ -22040,6 +22599,7 @@ data: ${JSON.stringify({
                 messageStartEmitted = true;
                 eventsForwarded += 5;
                 textEventsForwarded += 1;
+                textCharsForwarded += text.length;
               }
               if (passthrough) {
                 recordEnvelopeViolations(checkUndeliveredToolUses(capturedToolUses, streamedToolUseIds));
@@ -22065,9 +22625,125 @@ data: ${JSON.stringify({
                 plog(`[PROXY] ${requestMeta.requestId} discovered=${discoveredTools.size} (${newNames}) session_total=${allNames.length}`);
               }
               if (currentSessionId && !isIndependentSession && !sawDuplicateToolUse) {
-                storeSession(profileSessionId, body.messages || [], currentSessionId, profileScopedCwd, sdkUuidMap, lastUsage);
+                storeSession(profileSessionId, body.messages || [], currentSessionId, profileScopedCwd, sdkUuidMap, lastUsage, earlyStopFired ? nextPassthroughResumeUuid : null);
               }
               resolvePendingStore();
+              const classifyNow = () => classifyTurnOutcome({
+                textEvents: textEventsForwarded,
+                toolUses: streamedToolUseIds.size,
+                blocksForwarded: eventsForwarded
+              });
+              const preRecoveryOutcome = classifyNow();
+              if (!streamClosed && messageStartEmitted && shouldAttemptRecovery({
+                outcome: preRecoveryOutcome,
+                alreadyAttempted: silentTurnRecoveryAttempted,
+                clientGone: streamClosed,
+                sessionId: currentSessionId || resumeSessionId,
+                enabled: silentTurnRecoveryEnabled
+              })) {
+                silentTurnRecoveryAttempted = true;
+                const capturedBeforeRecovery = capturedToolUses.length;
+                claudeLog("response.silent_turn_recovery", {
+                  mode: "stream",
+                  kind: preRecoveryOutcome.kind,
+                  reason: preRecoveryOutcome.kind === "silent" ? preRecoveryOutcome.reason : undefined,
+                  sdkSessionId: currentSessionId || resumeSessionId
+                });
+                const recoveryLifter = createRecoveryLifter(() => nextClientBlockIndex++);
+                let recoverySessionId;
+                let recoveryBoundaryUuid;
+                try {
+                  for await (const event of guardUpstreamIdle(query(buildQueryOptions({
+                    prompt: SILENT_TURN_NUDGE,
+                    model,
+                    workingDirectory,
+                    clientWorkingDirectory,
+                    systemContext,
+                    claudeExecutable,
+                    passthrough,
+                    stream: true,
+                    sdkAgents,
+                    passthroughMcp,
+                    cleanEnv: profileEnv,
+                    envOverrides,
+                    hasDeferredTools,
+                    resumeSessionId: currentSessionId || resumeSessionId,
+                    isUndo: false,
+                    resumeSessionAtUuid: nextPassthroughResumeUuid,
+                    forkSession: true,
+                    sdkHooks,
+                    blockedTools: pipelineCtx.blockedTools,
+                    incompatibleTools: pipelineCtx.incompatibleTools,
+                    mcpServerName: adapter.getMcpServerName(),
+                    allowedMcpTools: pipelineCtx.allowedMcpTools,
+                    onStderr,
+                    effort,
+                    thinking,
+                    taskBudget,
+                    outputFormat,
+                    betas,
+                    settingSources,
+                    codeSystemPrompt: sdkFeatures.codeSystemPrompt,
+                    clientSystemPrompt: sdkFeatures.clientSystemPrompt === false ? false : undefined,
+                    memory: sdkFeatures.memory,
+                    dreaming: sdkFeatures.dreaming,
+                    sharedMemory: sdkFeatures.sharedMemory,
+                    webFetchPreflight: sdkFeatures.webFetchPreflight,
+                    claudeAiConnectors: sdkFeatures.claudeAiConnectors,
+                    maxBudgetUsd: sdkFeatures.maxBudgetUsd,
+                    fallbackModel: sdkFeatures.fallbackModel,
+                    sdkDebug: sdkFeatures.sdkDebug,
+                    additionalDirectories: sdkFeatures.additionalDirectories ? sdkFeatures.additionalDirectories.split(",").map((d) => d.trim()).filter(Boolean) : undefined,
+                    advisorModel
+                  }, requestAbort.controller)), UPSTREAM_IDLE_MS, (sinceLastMs) => claudeLog("upstream.stalled", { mode: "silent_recovery", model, sinceLastMs }))) {
+                    const recoveryMessage = event;
+                    if (recoveryMessage.session_id)
+                      recoverySessionId = recoveryMessage.session_id;
+                    recoveryBoundaryUuid = resumeBoundaryUuid(recoveryMessage) ?? recoveryBoundaryUuid;
+                    if (recoveryMessage.type !== "stream_event")
+                      continue;
+                    const lifted = recoveryLifter.lift(event.event);
+                    if (!lifted)
+                      continue;
+                    safeEnqueue(encoder.encode(`event: ${lifted.frame.type}
+data: ${JSON.stringify(lifted.frame)}
+
+`), `silent_recovery_${lifted.kind}`);
+                    if (lifted.kind === "block_start") {
+                      eventsForwarded += 1;
+                    } else if (lifted.kind === "text_delta") {
+                      textEventsForwarded += 1;
+                      textCharsForwarded += lifted.textChars;
+                      silentTurnRecovered = true;
+                    }
+                  }
+                } catch (recoveryError) {
+                  claudeLog("response.silent_turn_recovery_failed", {
+                    mode: "stream",
+                    error: recoveryError instanceof Error ? recoveryError.message : String(recoveryError)
+                  });
+                }
+                if (capturedToolUses.length > capturedBeforeRecovery) {
+                  silentTurnRecovered = true;
+                }
+                if (silentTurnRecovered && recoverySessionId && !isIndependentSession && !sawDuplicateToolUse) {
+                  currentSessionId = recoverySessionId;
+                  nextPassthroughResumeUuid = recoveryBoundaryUuid;
+                  sdkUuidMap.length = 0;
+                  for (let i = 0;i < allMessages.length; i++)
+                    sdkUuidMap.push(null);
+                  storeSession(profileSessionId, body.messages || [], recoverySessionId, profileScopedCwd, sdkUuidMap, lastUsage, recoveryBoundaryUuid ?? null);
+                }
+                claudeLog("response.silent_turn_recovery_result", {
+                  mode: "stream",
+                  recovered: silentTurnRecovered,
+                  textEvents: textEventsForwarded,
+                  forkedSession: recoverySessionId ?? null
+                });
+                if (silentTurnRecovered && preRecoveryOutcome.kind === "silent") {
+                  diagnosticLog2.session(`${requestMeta.requestId} silent_turn reason=${preRecoveryOutcome.reason} ` + `blocks=${eventsForwarded} out=${lastUsage?.output_tokens ?? 0} ` + `recovery=succeeded`, requestMeta.requestId);
+                }
+              }
               if (!streamClosed) {
                 const unseenToolUses = capturedToolUses.filter((tu) => !streamedToolUseIds.has(tu.id));
                 if (passthrough && unseenToolUses.length > 0 && messageStartEmitted) {
@@ -22099,14 +22775,7 @@ data: ${JSON.stringify({
 
 `), "passthrough_tool_block_stop");
                   }
-                  safeEnqueue(encoder.encode(`event: message_delta
-data: ${JSON.stringify({
-                    type: "message_delta",
-                    delta: { stop_reason: "tool_use", stop_sequence: null },
-                    usage: { output_tokens: 0 }
-                  })}
-
-`), "passthrough_message_delta");
+                  sendTerminalDelta("tool_use");
                 }
                 if (trackFileChanges && passthrough && pipelineCtx.extractFileChangesFromToolUse) {
                   const passthroughChanges = extractFileChangesFromMessages(body.messages || [], pipelineCtx.extractFileChangesFromToolUse);
@@ -22143,6 +22812,7 @@ data: ${JSON.stringify({
                   }
                 }
                 if (messageStartEmitted) {
+                  sendTerminalDelta();
                   safeEnqueue(encoder.encode(`event: message_stop
 data: {"type":"message_stop"}
 
@@ -22208,13 +22878,18 @@ data: {"type":"message_stop"}
                   cacheHitRate: computeCacheHitRate(lastUsage),
                   ...envelopeViolations.length > 0 ? { envelopeViolations: [...envelopeViolations] } : {}
                 });
-                if (textEventsForwarded === 0) {
-                  claudeLog("response.empty_stream", {
+                const turnOutcome = classifyNow();
+                if (turnOutcome.kind === "silent") {
+                  claudeLog("response.silent_turn", {
                     model,
+                    reason: turnOutcome.reason,
                     streamEventsSeen,
                     eventsForwarded,
-                    reason: "no_text_deltas_forwarded"
+                    outputTokens: lastUsage?.output_tokens,
+                    recovered: silentTurnRecovered,
+                    recoveryAttempted: silentTurnRecoveryAttempted
                   });
+                  diagnosticLog2.session(`${requestMeta.requestId} silent_turn reason=${turnOutcome.reason} ` + `blocks=${eventsForwarded} out=${lastUsage?.output_tokens ?? 0} ` + `recovery=${silentTurnRecoveryAttempted ? silentTurnRecovered ? "succeeded" : "failed" : "off"}`, requestMeta.requestId);
                 }
               }
             } catch (error) {
@@ -22227,6 +22902,21 @@ data: {"type":"message_stop"}
                   textEventsForwarded,
                   durationMs: Date.now() - requestStartAt
                 });
+                const disposition = clientAbortDisposition({
+                  isIndependentSession,
+                  profileSessionId,
+                  currentSessionId,
+                  sawDuplicateToolUse,
+                  resumeBoundaryUuid: nextPassthroughResumeUuid,
+                  passthrough
+                });
+                if (disposition.action === "store" && currentSessionId) {
+                  storeSession(profileSessionId, body.messages || [], currentSessionId, profileScopedCwd, sdkUuidMap, lastUsage, disposition.resumeUuid);
+                } else if (disposition.action === "evict") {
+                  evictSession(profileSessionId, profileScopedCwd, body.messages || []);
+                }
+                claudeLog("passthrough.client_abort_settled", { action: disposition.action });
+                resolvePendingStore();
                 return;
               }
               resolvePendingStore();
@@ -22380,26 +23070,41 @@ data: {"type":"message_stop"}
                 error: streamErr.type
               });
               if (messageStartEmitted) {
+                const errorStopReason = textEventsForwarded > 0 ? "end_turn" : "max_tokens";
+                claudeLog("response.error_envelope", {
+                  mode: "stream",
+                  stopReason: errorStopReason,
+                  textEvents: textEventsForwarded,
+                  classified: streamErr.type
+                });
                 safeEnqueue(encoder.encode(`event: message_delta
 data: ${JSON.stringify({
                   type: "message_delta",
-                  delta: { stop_reason: "end_turn", stop_sequence: null },
+                  delta: { stop_reason: errorStopReason, stop_sequence: null },
                   usage: { output_tokens: 0 }
                 })}
 
 `), "error_message_delta");
+                safeEnqueue(encoder.encode(`event: error
+data: ${JSON.stringify({
+                  type: "error",
+                  error: { type: streamErr.type, message: streamErr.message }
+                })}
+
+`), "error_event_before_stop");
                 safeEnqueue(encoder.encode(`event: message_stop
 data: {"type":"message_stop"}
 
 `), "error_message_stop");
-              }
-              safeEnqueue(encoder.encode(`event: error
+              } else {
+                safeEnqueue(encoder.encode(`event: error
 data: ${JSON.stringify({
-                type: "error",
-                error: { type: streamErr.type, message: streamErr.message }
-              })}
+                  type: "error",
+                  error: { type: streamErr.type, message: streamErr.message }
+                })}
 
 `), "error_event");
+              }
               if (!streamClosed) {
                 try {
                   controller.close();
@@ -22657,7 +23362,7 @@ data: ${JSON.stringify({
     });
   });
   app.get("/profiles", async (c) => {
-    const { profilePageHtml } = await import("./profilePage-naychnb8.js");
+    const { profilePageHtml } = await import("./profilePage-gtazq15d.js");
     return c.html(profilePageHtml);
   });
   app.post("/profiles/active", async (c) => {
@@ -22740,14 +23445,25 @@ data: ${JSON.stringify({
   });
   app.post("/v1/chat/completions", async (c) => {
     const rawBody = await c.req.json();
-    const anthropicBody = translateOpenAiToAnthropic(rawBody);
+    const userAgent = c.req.header("user-agent") ?? "";
+    const jcodeSessionId = userAgent.startsWith("jcode/") ? normalizeJcodeSessionId(c.req.header("x-jcode-session")) : undefined;
+    const isJcode = jcodeSessionId !== undefined;
+    const adapterName = isJcode ? "jcode" : "openai";
+    const anthropicBody = translateOpenAiToAnthropic(rawBody, {
+      preserveConversationHistory: isJcode
+    });
     if (!anthropicBody) {
       return c.json({ type: "error", error: { type: "invalid_request_error", message: "messages: Field required" } }, 400);
     }
     const internalHeaders = {
       "Content-Type": "application/json",
-      "x-meridian-agent": "openai"
+      "x-meridian-agent": adapterName
     };
+    if (jcodeSessionId)
+      internalHeaders["x-jcode-session"] = jcodeSessionId;
+    const requestedProfile = c.req.header("x-meridian-profile");
+    if (requestedProfile)
+      internalHeaders["x-meridian-profile"] = requestedProfile;
     const xApiKey = c.req.header("x-api-key");
     if (xApiKey)
       internalHeaders["x-api-key"] = xApiKey;
@@ -22768,7 +23484,7 @@ data: ${JSON.stringify({
     const created = Math.floor(Date.now() / 1000);
     const model = typeof rawBody.model === "string" && rawBody.model ? rawBody.model : CANONICAL_SONNET_MODEL;
     const { getFeaturesForAdapter: getFeaturesForAdapter2 } = (init_sdkFeatures(), __toCommonJS(exports_sdkFeatures));
-    const sdkFeatures = getFeaturesForAdapter2("openai");
+    const sdkFeatures = getFeaturesForAdapter2(adapterName);
     if (!anthropicBody.stream) {
       const anthropicRes = await internalRes.json();
       return c.json(translateAnthropicToOpenAi(anthropicRes, completionId, model, created, {
@@ -23014,7 +23730,7 @@ data: ${JSON.stringify({ response: { id: responseId, status: "failed", error: {
     const profilesList = getEffectiveProfiles(finalConfig.profiles);
     const activeId = getActiveProfileId() || finalConfig.defaultProfile || profilesList[0]?.id || null;
     if (profilesList.length === 0) {
-      const oauth = await fetchOAuthUsage({});
+      const { snapshot: oauth, error } = await fetchOAuthUsageResult({});
       return c.json({
         profiles: [{
           id: "default",
@@ -23022,7 +23738,7 @@ data: ${JSON.stringify({ response: { id: responseId, status: "failed", error: {
           windows: oauth?.windows ?? [],
           extraUsage: oauth?.extraUsage ?? null,
           fetchedAt: oauth?.fetchedAt ?? null,
-          error: oauth ? null : "no_token"
+          error
         }],
         activeProfile: "default",
         asOf: Date.now()
@@ -23041,7 +23757,7 @@ data: ${JSON.stringify({ response: { id: responseId, status: "failed", error: {
           error: "not_oauth"
         };
       }
-      const oauth = await fetchOAuthUsage({
+      const { snapshot: oauth, error } = await fetchOAuthUsageResult({
         profileId: p.id,
         claudeConfigDir: p.claudeConfigDir
       });
@@ -23052,7 +23768,7 @@ data: ${JSON.stringify({ response: { id: responseId, status: "failed", error: {
         windows: oauth?.windows ?? [],
         extraUsage: oauth?.extraUsage ?? null,
         fetchedAt: oauth?.fetchedAt ?? null,
-        error: oauth ? null : "no_token"
+        error
       };
     }));
     return c.json({