@rynfar/meridian 1.61.0 → 1.62.1

package/dist/{cli-tbhba0cv.js → cli-fyhd8np7.js}

@@ -2020,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;
@@ -2028,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": {
@@ -2042,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;
@@ -2065,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;
           }
         }
       }
@@ -2091,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, PASSTHROUGH_CONTINUATION_LEAD_IN, 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"]);
@@ -2110,7 +2122,7 @@ var init_messages = __esm(() => {
   ]);
   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;
 });
 
@@ -2942,6 +2954,124 @@ var init_pi2 = __esm(() => {
   };
 });
 
+// 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();
+  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`
+  ];
+  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 extractPrimeCwd(body);
+    },
+    extractClientWorkingDirectory(body) {
+      return extractPrimeCwd(body);
+    },
+    normalizeContent(content) {
+      return normalizeContent(content);
+    },
+    getBlockedBuiltinTools() {
+      return BLOCKED_BUILTIN_TOOLS;
+    },
+    getAgentIncompatibleTools() {
+      return CLAUDE_CODE_ONLY_TOOLS;
+    },
+    getMcpServerName() {
+      return PRIME_MCP_SERVER_NAME;
+    },
+    getAllowedMcpTools() {
+      return PRIME_ALLOWED_MCP_TOOLS;
+    },
+    buildSdkAgents(_body, _mcpToolNames) {
+      return {};
+    },
+    supportsThinking() {
+      return true;
+    },
+    buildSdkHooks(_body, _sdkAgents) {
+      return;
+    },
+    buildSystemContextAddendum(_body, _sdkAgents) {
+      return "";
+    },
+    usesPassthrough() {
+      return resolvePassthrough(true);
+    },
+    extractFileChangesFromToolUse(toolName, toolInput) {
+      return extractPrimeFileChanges(toolName, toolInput);
+    }
+  };
+});
+
 // src/proxy/transforms/forgecode.ts
 var FORGECODE_MCP_SERVER_NAME = "forgecode", FORGECODE_ALLOWED_MCP_TOOLS, forgeCodeTransforms;
 var init_forgecode = __esm(() => {
@@ -3279,6 +3409,7 @@ var init_detect = __esm(() => {
   init_crush2();
   init_passthrough2();
   init_pi2();
+  init_prime();
   init_forgecode2();
   init_claudecode();
   init_openai();
@@ -3292,6 +3423,8 @@ var init_detect = __esm(() => {
     crush: crushAdapter,
     passthrough: passthroughAdapter,
     pi: piAdapter,
+    prime: primeAdapter,
+    "prime-agent": primeAdapter,
     forgecode: forgeCodeAdapter,
     "claude-code": claudeCodeAdapter,
     claudecode: claudeCodeAdapter,
@@ -3455,6 +3588,9 @@ var init_sdkFeatures = __esm(() => {
     cherry: {
       codeSystemPrompt: false
     },
+    prime: {
+      codeSystemPrompt: false
+    },
     codex: {
       codeSystemPrompt: false
     }
@@ -6201,6 +6337,7 @@ var serve = (options, listeningListener) => {
 };
 
 // src/proxy/server.ts
+import { AsyncLocalStorage } from "node:async_hooks";
 import { homedir as homedir7 } from "node:os";
 import { join as join8 } from "node:path";
 import { query } from "@anthropic-ai/claude-agent-sdk";
@@ -11768,7 +11905,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>'
@@ -11954,6 +12098,16 @@ 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();
@@ -11979,7 +12133,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",
@@ -12049,11 +12203,18 @@ function isExpiredTokenError(errMsg) {
     return true;
   return false;
 }
-function isStaleSessionError(error) {
+function classifyResumeRefusal(error, stderr) {
+  if (isBusySessionError(error, stderr))
+    return "busy";
   if (!(error instanceof Error))
-    return false;
+    return;
   const msg = error.message;
-  return msg.includes("No message found with message.uuid") || msg.includes("No conversation found with session ID") || msg.includes("No conversation found to continue") || msg.includes("No conversations found to resume");
+  if (msg.includes("No message found with message.uuid"))
+    return "missing-message";
+  if (msg.includes("No conversation found with session ID") || msg.includes("No conversation found to continue") || msg.includes("No conversations found to resume")) {
+    return "unresumable";
+  }
+  return;
 }
 function isBusySessionError(error, stderr) {
   const needle = "is currently running as a background agent";
@@ -12064,6 +12225,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");
@@ -12088,11 +12259,34 @@ function makeRawTail(errMsg) {
     return;
   return head.length > RAW_TAIL_MAX ? head.slice(0, RAW_TAIL_MAX) : head;
 }
+function canRecoverCapturedToolUses(input) {
+  if (!input.passthrough)
+    return false;
+  if (input.capturedToolUses <= 0)
+    return false;
+  switch (input.reason) {
+    case "max_turns":
+    case "upstream_idle":
+      return true;
+    case "aborted":
+      return input.abortIsOurs;
+    default:
+      return false;
+  }
+}
 function extractSdkTermination(errMsg) {
   const stderrTail = extractStderrTail(errMsg);
   const haystack = `${errMsg}
 ${stderrTail ?? ""}`;
   const lower = haystack.toLowerCase();
+  if (lower.includes("upstream idle for")) {
+    const m = haystack.match(/upstream idle for (\d+)ms/i);
+    return {
+      reason: "upstream_idle",
+      ...m ? { idleMs: Number(m[1]) } : {},
+      ...stderrTail ? { stderrTail } : {}
+    };
+  }
   if (lower.includes("reached maximum number of turns")) {
     const m = haystack.match(/Reached maximum number of turns \((\d+)\)/i);
     return {
@@ -19168,6 +19362,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();
 
@@ -19249,6 +19471,7 @@ var ADAPTER_TRANSFORMS = {
   crush: crushTransforms,
   droid: droidTransforms,
   pi: piTransforms,
+  prime: primeTransforms,
   forgecode: forgeCodeTransforms,
   passthrough: passthroughTransforms,
   cherry: cherryTransforms,
@@ -19267,7 +19490,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", "jcode", "crush", "droid", "pi", "forgecode", "passthrough"];
+init_detect();
 var KNOWN_HOOKS = ["onRequest", "onResponse", "onTelemetry", "onSession", "onToolUse", "onToolResult", "onError"];
 function validateTransform(exported) {
   if (exported == null || typeof exported !== "object") {
@@ -19288,8 +19511,9 @@ function validateTransform(exported) {
   }
   const warnings = [];
   if (Array.isArray(obj.adapters)) {
+    const known = listAdapterNames();
     for (const adapter of obj.adapters) {
-      if (typeof adapter === "string" && !KNOWN_ADAPTERS.includes(adapter)) {
+      if (typeof adapter === "string" && !known.includes(adapter)) {
         warnings.push(adapter);
       }
     }
@@ -19622,6 +19846,48 @@ 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 [];
@@ -19763,7 +20029,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 };
 }
@@ -20087,7 +20358,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);
   }
@@ -20422,8 +20695,8 @@ function createProxyServer(config = {}) {
   const sessionMcpCache = new LRUMap(getMaxSessionsLimit());
   const PENDING_STORE_WAIT_MS = 3000;
   const PENDING_STORE_AUTO_RESOLVE_MS = 1e4;
-  const BUSY_SESSION_MAX_RETRIES = 3;
-  const BUSY_SESSION_RETRY_DELAY_MS = parseInt(process.env.MERIDIAN_BUSY_RETRY_DELAY_MS ?? "500", 10);
+  const RESUME_REFUSAL_MAX_RETRIES = 3;
+  const RESUME_REFUSAL_RETRY_DELAY_MS = parseInt(process.env.MERIDIAN_BUSY_RETRY_DELAY_MS ?? "500", 10);
   const pendingSessionStores = new Map;
   const registerPendingStore = (key) => {
     let resolveFn = () => {};
@@ -20501,23 +20774,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)
@@ -20535,16 +20810,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) {
@@ -20562,33 +20838,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
@@ -20599,7 +20882,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) => {
@@ -20617,6 +20900,7 @@ data: ${JSON.stringify(lastError)}
   const MAX_CONCURRENT_SESSIONS = parseInt((process.env.MERIDIAN_MAX_CONCURRENT ?? process.env.CLAUDE_PROXY_MAX_CONCURRENT) || "10", 10);
   let activeSessions = 0;
   const sessionQueue = [];
+  const insideSessionSlot = new AsyncLocalStorage;
   async function acquireSession() {
     if (activeSessions < MAX_CONCURRENT_SESSIONS) {
       activeSessions++;
@@ -20797,6 +21081,25 @@ 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;
@@ -21110,8 +21413,9 @@ data: ${JSON.stringify(lastError)}
               }
               let tokenRefreshed = false;
               let didFreshBaseRetry = false;
-              let busySessionRetries = 0;
+              let resumeRefusalRetries = 0;
               let busySessionFork = false;
+              let sawUnresumableRefusal = false;
               while (true) {
                 let didYieldContent = false;
                 const attemptStderrStart = stderrLines.length;
@@ -21174,29 +21478,33 @@ data: ${JSON.stringify(lastError)}
                   releaseHeldDenies("non_stream_attempt_error");
                   if (didYieldContent)
                     throw error;
-                  if (resumeSessionId && isBusySessionError(error, stderrLines.slice(attemptStderrStart).join(`
-`))) {
-                    if (busySessionRetries < BUSY_SESSION_MAX_RETRIES) {
-                      busySessionRetries++;
-                      claudeLog("session.busy_retry", { mode: "non_stream", attempt: busySessionRetries, resumeSessionId });
-                      plog(`[PROXY] ${requestMeta.requestId} session busy (bg agent), retrying resume ${busySessionRetries}/${BUSY_SESSION_MAX_RETRIES}`);
-                      await new Promise((resolve3) => setTimeout(resolve3, BUSY_SESSION_RETRY_DELAY_MS * busySessionRetries));
+                  const refusal = classifyResumeRefusal(error, resumeSessionId ? stderrLines.slice(attemptStderrStart).join(`
+`) : undefined);
+                  if (refusal === "unresumable")
+                    sawUnresumableRefusal = true;
+                  if (resumeSessionId && (refusal === "busy" || refusal === "unresumable")) {
+                    if (resumeRefusalRetries < RESUME_REFUSAL_MAX_RETRIES) {
+                      resumeRefusalRetries++;
+                      claudeLog("session.resume_retry", { mode: "non_stream", refusal, attempt: resumeRefusalRetries, resumeSessionId });
+                      plog(`[PROXY] ${requestMeta.requestId} resume refused (${refusal}), retrying ${resumeRefusalRetries}/${RESUME_REFUSAL_MAX_RETRIES}`);
+                      await new Promise((resolve3) => setTimeout(resolve3, RESUME_REFUSAL_RETRY_DELAY_MS * resumeRefusalRetries));
                       continue;
                     }
-                    if (!busySessionFork) {
+                    if (refusal === "busy" && !busySessionFork) {
                       busySessionFork = true;
                       claudeLog("session.busy_fork", { mode: "non_stream", resumeSessionId });
-                      plog(`[PROXY] ${requestMeta.requestId} session still busy after ${BUSY_SESSION_MAX_RETRIES} retries — forking session`);
+                      plog(`[PROXY] ${requestMeta.requestId} session still busy after ${RESUME_REFUSAL_MAX_RETRIES} retries — forking session`);
                       continue;
                     }
                   }
-                  if (isStaleSessionError(error)) {
-                    claudeLog("session.stale_uuid_retry", {
+                  if (refusal === "missing-message" || sawUnresumableRefusal) {
+                    claudeLog("session.resume_replay", {
                       mode: "non_stream",
+                      refusal,
                       rollbackUuid: undoRollbackUuid,
                       resumeSessionId
                     });
-                    plog(`[PROXY] Stale session UUID, evicting and retrying as fresh session`);
+                    plog(`[PROXY] ${requestMeta.requestId} session unusable (${refusal}), evicting and replaying as fresh session`);
                     evictSession(profileSessionId, profileScopedCwd, allMessages);
                     sdkUuidMap.length = 0;
                     for (let i = 0;i < allMessages.length; i++)
@@ -21467,7 +21775,12 @@ data: ${JSON.stringify(lastError)}
 Subprocess stderr: ${stderrOutput}`;
             }
             const sdkTerm = extractSdkTermination(error instanceof Error ? error.message : String(error));
-            const canRecoverAsToolUse = passthrough && capturedToolUses.length > 0 && (sdkTerm.reason === "max_turns" || sdkTerm.reason === "aborted");
+            const canRecoverAsToolUse = canRecoverCapturedToolUses({
+              reason: sdkTerm.reason,
+              passthrough,
+              capturedToolUses: capturedToolUses.length,
+              abortIsOurs: true
+            });
             if (canRecoverAsToolUse) {
               diagnosticLog2.session(`${requestMeta.requestId} sdk_termination_recovered ${formatSdkTermination(sdkTerm, {
                 model,
@@ -21751,8 +22064,9 @@ data: ${JSON.stringify({ type: "content_block_stop", index: idx })}
                 }
                 let tokenRefreshed = false;
                 let didFreshBaseRetry = false;
-                let busySessionRetries = 0;
+                let resumeRefusalRetries = 0;
                 let busySessionFork = false;
+                let sawUnresumableRefusal = false;
                 while (true) {
                   let didYieldClientEvent = false;
                   const attemptStderrStart = stderrLines.length;
@@ -21813,29 +22127,33 @@ data: ${JSON.stringify({ type: "content_block_stop", index: idx })}
                     const errMsg = error instanceof Error ? error.message : String(error);
                     if (didYieldClientEvent)
                       throw error;
-                    if (resumeSessionId && isBusySessionError(error, stderrLines.slice(attemptStderrStart).join(`
-`))) {
-                      if (busySessionRetries < BUSY_SESSION_MAX_RETRIES) {
-                        busySessionRetries++;
-                        claudeLog("session.busy_retry", { mode: "stream", attempt: busySessionRetries, resumeSessionId });
-                        plog(`[PROXY] ${requestMeta.requestId} session busy (bg agent), retrying resume ${busySessionRetries}/${BUSY_SESSION_MAX_RETRIES}`);
-                        await new Promise((resolve3) => setTimeout(resolve3, BUSY_SESSION_RETRY_DELAY_MS * busySessionRetries));
+                    const refusal = classifyResumeRefusal(error, resumeSessionId ? stderrLines.slice(attemptStderrStart).join(`
+`) : undefined);
+                    if (refusal === "unresumable")
+                      sawUnresumableRefusal = true;
+                    if (resumeSessionId && (refusal === "busy" || refusal === "unresumable")) {
+                      if (resumeRefusalRetries < RESUME_REFUSAL_MAX_RETRIES) {
+                        resumeRefusalRetries++;
+                        claudeLog("session.resume_retry", { mode: "stream", refusal, attempt: resumeRefusalRetries, resumeSessionId });
+                        plog(`[PROXY] ${requestMeta.requestId} resume refused (${refusal}), retrying ${resumeRefusalRetries}/${RESUME_REFUSAL_MAX_RETRIES}`);
+                        await new Promise((resolve3) => setTimeout(resolve3, RESUME_REFUSAL_RETRY_DELAY_MS * resumeRefusalRetries));
                         continue;
                       }
-                      if (!busySessionFork) {
+                      if (refusal === "busy" && !busySessionFork) {
                         busySessionFork = true;
                         claudeLog("session.busy_fork", { mode: "stream", resumeSessionId });
-                        plog(`[PROXY] ${requestMeta.requestId} session still busy after ${BUSY_SESSION_MAX_RETRIES} retries — forking session`);
+                        plog(`[PROXY] ${requestMeta.requestId} session still busy after ${RESUME_REFUSAL_MAX_RETRIES} retries — forking session`);
                         continue;
                       }
                     }
-                    if (isStaleSessionError(error)) {
-                      claudeLog("session.stale_uuid_retry", {
+                    if (refusal === "missing-message" || sawUnresumableRefusal) {
+                      claudeLog("session.resume_replay", {
                         mode: "stream",
+                        refusal,
                         rollbackUuid: undoRollbackUuid,
                         resumeSessionId
                       });
-                      plog(`[PROXY] Stale session UUID, evicting and retrying as fresh session`);
+                      plog(`[PROXY] ${requestMeta.requestId} session unusable (${refusal}), evicting and replaying as fresh session`);
                       evictSession(profileSessionId, profileScopedCwd, allMessages);
                       sdkUuidMap.length = 0;
                       for (let i = 0;i < allMessages.length; i++)
@@ -22673,7 +22991,12 @@ Subprocess stderr: ${stderrOutput}`;
               } : classifyError(errMsg, model);
               claudeLog("proxy.anthropic.error", { error: errMsg, classified: streamErr.type });
               const sdkTerm = extractSdkTermination(errMsg);
-              const canRecoverAsToolUse = (sdkTerm.reason === "max_turns" || sdkTerm.reason === "aborted" && (sawDuplicateToolUse || earlyStopFired)) && passthrough && capturedToolUses.length > 0 && messageStartEmitted;
+              const canRecoverAsToolUse = canRecoverCapturedToolUses({
+                reason: sdkTerm.reason,
+                passthrough,
+                capturedToolUses: capturedToolUses.length,
+                abortIsOurs: sawDuplicateToolUse || earlyStopFired
+              }) && messageStartEmitted;
               if (canRecoverAsToolUse) {
                 diagnosticLog2.session(`${requestMeta.requestId} sdk_termination_recovered ${formatSdkTermination(sdkTerm, {
                   model,
@@ -22800,7 +23123,7 @@ data: {"type":"message_stop"}
                 error: streamErr.type
               });
               if (messageStartEmitted) {
-                const errorStopReason = textEventsForwarded > 0 ? "end_turn" : "max_tokens";
+                const errorStopReason = "max_tokens";
                 claudeLog("response.error_envelope", {
                   mode: "stream",
                   stopReason: errorStopReason,
@@ -22909,10 +23232,14 @@ data: ${JSON.stringify({
     const requestId = c.req.header("x-request-id") || randomUUID();
     const queueEnteredAt = Date.now();
     claudeLog("request.enter", { requestId, endpoint });
+    const held = insideSessionSlot.getStore();
+    if (held) {
+      return handleMessages(c, { requestId, endpoint, ...held });
+    }
     await acquireSession();
     const queueStartedAt = Date.now();
     try {
-      return await handleMessages(c, { requestId, endpoint, queueEnteredAt, queueStartedAt });
+      return await insideSessionSlot.run({ queueEnteredAt, queueStartedAt }, () => handleMessages(c, { requestId, endpoint, queueEnteredAt, queueStartedAt }));
     } finally {
       releaseSession();
     }