@rynfar/meridian 1.60.0 → 1.61.0

package/dist/{cli-k1djafvr.js → cli-tbhba0cv.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;
@@ -1957,7 +2091,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, 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 +2108,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"];
   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 +2159,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 +2333,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);
@@ -3008,16 +3061,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 +3245,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;
   }
@@ -3236,6 +3282,7 @@ var init_detect = __esm(() => {
   init_forgecode2();
   init_claudecode();
   init_openai();
+  init_jcode();
   init_codex();
   init_cherry();
   init_adapterInstances();
@@ -3251,6 +3298,7 @@ var init_detect = __esm(() => {
     cherry: cherryAdapter,
     cherrystudio: cherryAdapter,
     openai: openAiAdapter,
+    jcode: jcodeAdapter,
     codex: codexAdapter
   };
   envDefault = process.env.MERIDIAN_DEFAULT_AGENT || "";
@@ -3401,6 +3449,9 @@ var init_sdkFeatures = __esm(() => {
     openai: {
       codeSystemPrompt: false
     },
+    jcode: {
+      codeSystemPrompt: false
+    },
     cherry: {
       codeSystemPrompt: false
     },
@@ -6294,8 +6345,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 +6370,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 +6436,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 +6464,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 +6502,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 +10802,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 +10867,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();
 
@@ -11780,6 +11954,7 @@ function extendedContextHint(model) {
     return advise("MERIDIAN_SONNET_MODEL=sonnet");
   return advise("MERIDIAN_1M_CONTEXT_SUPPORT=0");
 }
+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 +11971,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,
@@ -12279,7 +12454,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 +12546,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 +12841,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 +19036,7 @@ function buildQueryOptions(ctx, abortController) {
     hasDeferredTools,
     resumeSessionId,
     isUndo,
-    undoRollbackUuid,
+    resumeSessionAtUuid,
     forkSession,
     sdkHooks,
     blockedTools,
@@ -18929,7 +19107,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 } : {},
@@ -19076,6 +19254,7 @@ var ADAPTER_TRANSFORMS = {
   cherry: cherryTransforms,
   "claude-code": claudeCodeTransforms,
   openai: openCodeTransforms,
+  jcode: openCodeTransforms,
   codex: [...openCodeTransforms, ...codexTransforms]
 };
 function getAdapterTransforms(adapterName) {
@@ -19088,7 +19267,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") {
@@ -19448,6 +19627,19 @@ function computeMessageHashes(messages) {
     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 +19722,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) {
@@ -19676,7 +19896,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 +19914,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 +20074,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);
@@ -19884,7 +20110,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 +20140,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 +20175,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 +20207,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;
@@ -20566,8 +20801,11 @@ data: ${JSON.stringify(lastError)}
         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 +20848,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 +20906,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 +20924,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 +21096,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 +21133,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 +21217,7 @@ data: ${JSON.stringify(lastError)}
                       hasDeferredTools,
                       resumeSessionId: undefined,
                       isUndo: false,
-                      undoRollbackUuid: undefined,
+                      resumeSessionAtUuid: undefined,
                       sdkHooks,
                       blockedTools: pipelineCtx.blockedTools,
                       incompatibleTools: pipelineCtx.incompatibleTools,
@@ -21031,7 +21286,7 @@ data: ${JSON.stringify(lastError)}
                       hasDeferredTools,
                       resumeSessionId: undefined,
                       isUndo: false,
-                      undoRollbackUuid: undefined,
+                      resumeSessionAtUuid: undefined,
                       sdkHooks,
                       blockedTools: pipelineCtx.blockedTools,
                       incompatibleTools: pipelineCtx.incompatibleTools,
@@ -21112,6 +21367,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 +21607,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 +21639,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 +21671,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 +21710,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 +21740,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 +21773,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 +21856,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 +21925,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 +22038,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 +22110,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 +22214,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 +22249,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 +22266,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 +22329,7 @@ data: ${JSON.stringify({
                 messageStartEmitted = true;
                 eventsForwarded += 5;
                 textEventsForwarded += 1;
+                textCharsForwarded += text.length;
               }
               if (passthrough) {
                 recordEnvelopeViolations(checkUndeliveredToolUses(capturedToolUses, streamedToolUseIds));
@@ -22065,9 +22355,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 +22505,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 +22542,7 @@ data: ${JSON.stringify({
                   }
                 }
                 if (messageStartEmitted) {
+                  sendTerminalDelta();
                   safeEnqueue(encoder.encode(`event: message_stop
 data: {"type":"message_stop"}
 
@@ -22208,13 +22608,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 +22632,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 +22800,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 +23092,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 +23175,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 +23214,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 +23460,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 +23468,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 +23487,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 +23498,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({