@rynfar/meridian 1.58.1 → 1.58.3

package/dist/{cli-ndsqa67x.js → cli-deynz4ef.js}

@@ -4366,6 +4366,13 @@ import { join as join8 } from "node:path";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 
 // src/proxy/rateLimitStore.ts
+var MIN_EPOCH_MS = 100000000000;
+function toEpochMs(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0)
+    return;
+  return value < MIN_EPOCH_MS ? Math.round(value * 1000) : value;
+}
+
 class RateLimitStore {
   byProfile = new Map;
   record(profileId, info, observedAt = Date.now()) {
@@ -4377,7 +4384,12 @@ class RateLimitStore {
       buckets = new Map;
       this.byProfile.set(profileId, buckets);
     }
-    buckets.set(key, { ...info, observedAt });
+    buckets.set(key, {
+      ...info,
+      resetsAt: toEpochMs(info.resetsAt),
+      overageResetsAt: toEpochMs(info.overageResetsAt),
+      observedAt
+    });
   }
   getAll(profileId) {
     const buckets = this.byProfile.get(profileId);
@@ -10218,7 +10230,22 @@ var telemetryStore2 = stores.telemetry;
 var diagnosticLog2 = stores.diagnostics;
 
 // src/proxy/errors.ts
-function classifyError(errMsg) {
+function extendedContextHint(model) {
+  const advise = (v) => ` If you're frequently hitting this, set ${v} to use the 200k model instead.`;
+  if (!model)
+    return advise("MERIDIAN_1M_CONTEXT_SUPPORT=0");
+  const lower = model.toLowerCase();
+  if (!lower.includes("[1m]"))
+    return "";
+  if (lower.includes("fable") || lower.includes("mythos"))
+    return advise("MERIDIAN_FABLE_MODEL=fable");
+  if (lower.includes("opus"))
+    return advise("MERIDIAN_OPUS_MODEL=opus");
+  if (lower.includes("sonnet"))
+    return advise("MERIDIAN_SONNET_MODEL=sonnet");
+  return advise("MERIDIAN_1M_CONTEXT_SUPPORT=0");
+}
+function classifyError(errMsg, model) {
   const lower = errMsg.toLowerCase();
   if (lower.includes("oauth token has expired") || lower.includes("not logged in")) {
     return {
@@ -10235,7 +10262,7 @@ function classifyError(errMsg) {
     };
   }
   if (lower.includes("429") || lower.includes("rate limit") || lower.includes("too many requests") || lower.includes("hit your session limit") || lower.includes("usage limit reached")) {
-    const hint = lower.includes("1m") || lower.includes("context") ? " If you're frequently hitting this, set MERIDIAN_SONNET_MODEL=sonnet to use the 200k model instead." : "";
+    const hint = lower.includes("1m") || lower.includes("context") ? extendedContextHint(model) : "";
     return {
       status: 429,
       type: "rate_limit_error",
@@ -11484,11 +11511,26 @@ function stripCacheControlForHashing(obj) {
   const { cache_control, ...rest } = obj;
   return rest;
 }
+var HASH_IGNORED_BLOCK_TYPES = new Set(["thinking", "redacted_thinking"]);
+var HASH_HANDLED_BLOCK_TYPES = new Set(["text", "tool_use", "tool_result"]);
+var HASH_SERIALIZED_BLOCK_TYPES = new Set([
+  "image",
+  "document",
+  "search_result",
+  "server_tool_use",
+  "web_search_tool_result",
+  "web_fetch_tool_result",
+  "code_execution_tool_result",
+  "bash_code_execution_tool_result",
+  "text_editor_code_execution_tool_result",
+  "tool_search_tool_result",
+  "container_upload"
+]);
 function normalizeContent(content) {
   if (typeof content === "string")
     return content;
   if (Array.isArray(content)) {
-    return content.map((block) => {
+    return content.filter((block) => !HASH_IGNORED_BLOCK_TYPES.has(block?.type)).map((block) => {
       if (block.type === "text" && block.text)
         return block.text;
       if (block.type === "tool_use")
@@ -12195,8 +12237,8 @@ var CRUSH_ALLOWED_MCP_TOOLS2 = [
 ];
 var crushAdapter = {
   name: "crush",
-  getSessionId(_c) {
-    return;
+  getSessionId(c) {
+    return c.req.header("x-session-id") ?? c.req.header("x-session-affinity");
   },
   extractWorkingDirectory(_body) {
     return;
@@ -12354,6 +12396,96 @@ var passthroughAdapter = {
 // src/proxy/adapters/pi.ts
 init_env();
 
+// src/proxy/adapters/claudecode.ts
+init_env();
+function extractClaudeCodeClientCwd(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(/Primary working directory:\s*([^\n<]+)/i);
+  return match2?.[1]?.trim() || undefined;
+}
+function extractClaudeCodeSessionId(body) {
+  if (!body || typeof body !== "object")
+    return;
+  const metadata = body.metadata;
+  if (!metadata || typeof metadata !== "object")
+    return;
+  const rawUserId = metadata.user_id;
+  let userMetadata = rawUserId;
+  if (typeof rawUserId === "string") {
+    try {
+      userMetadata = JSON.parse(rawUserId);
+    } catch {
+      return;
+    }
+  }
+  if (!userMetadata || typeof userMetadata !== "object")
+    return;
+  const sessionId = userMetadata.session_id;
+  return typeof sessionId === "string" && sessionId.length > 0 ? sessionId : undefined;
+}
+var claudeCodeAdapter = {
+  name: "claude-code",
+  getSessionId(_c, body) {
+    return extractClaudeCodeSessionId(body);
+  },
+  extractWorkingDirectory(_body) {
+    return;
+  },
+  extractClientWorkingDirectory(body) {
+    return extractClaudeCodeClientCwd(body);
+  },
+  normalizeContent(content) {
+    return normalizeContent(content);
+  },
+  getBlockedBuiltinTools() {
+    return BLOCKED_BUILTIN_TOOLS;
+  },
+  getAgentIncompatibleTools() {
+    return CLAUDE_CODE_ONLY_TOOLS;
+  },
+  getMcpServerName() {
+    return MCP_SERVER_NAME;
+  },
+  getAllowedMcpTools() {
+    return ALLOWED_MCP_TOOLS;
+  },
+  getCoreToolNames() {
+    return ["Read", "Write", "Edit", "Bash", "Glob", "Grep"];
+  },
+  usesPassthrough() {
+    return resolvePassthrough(true);
+  },
+  supportsThinking() {
+    return true;
+  },
+  shouldTrackFileChanges() {
+    return false;
+  },
+  extractFileChangesFromToolUse(toolName, toolInput) {
+    const input = toolInput;
+    const filePath = input?.file_path ?? input?.filePath ?? input?.path;
+    const lowerName = toolName.toLowerCase();
+    if (lowerName === "write" && filePath) {
+      return [{ operation: "wrote", path: String(filePath) }];
+    }
+    if ((lowerName === "edit" || lowerName === "multiedit") && filePath) {
+      return [{ operation: "edited", path: String(filePath) }];
+    }
+    if (lowerName === "bash" && input?.command) {
+      return extractFileChangesFromBash(String(input.command));
+    }
+    return [];
+  }
+};
+
 // src/proxy/transforms/pi.ts
 init_env();
 var PI_MCP_SERVER_NAME = "pi";
@@ -12423,8 +12555,8 @@ function extractPiCwd(body) {
 }
 var piAdapter = {
   name: "pi",
-  getSessionId(c) {
-    return c.req.header("x-session-affinity");
+  getSessionId(c, body) {
+    return c.req.header("x-session-affinity") ?? extractClaudeCodeSessionId(body);
   },
   extractWorkingDirectory(body) {
     return extractPiCwd(body);
@@ -12587,96 +12719,6 @@ var forgeCodeAdapter = {
   }
 };
 
-// src/proxy/adapters/claudecode.ts
-init_env();
-function extractClaudeCodeClientCwd(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(/Primary working directory:\s*([^\n<]+)/i);
-  return match2?.[1]?.trim() || undefined;
-}
-function extractClaudeCodeSessionId(body) {
-  if (!body || typeof body !== "object")
-    return;
-  const metadata = body.metadata;
-  if (!metadata || typeof metadata !== "object")
-    return;
-  const rawUserId = metadata.user_id;
-  let userMetadata = rawUserId;
-  if (typeof rawUserId === "string") {
-    try {
-      userMetadata = JSON.parse(rawUserId);
-    } catch {
-      return;
-    }
-  }
-  if (!userMetadata || typeof userMetadata !== "object")
-    return;
-  const sessionId = userMetadata.session_id;
-  return typeof sessionId === "string" && sessionId.length > 0 ? sessionId : undefined;
-}
-var claudeCodeAdapter = {
-  name: "claude-code",
-  getSessionId(_c, body) {
-    return extractClaudeCodeSessionId(body);
-  },
-  extractWorkingDirectory(_body) {
-    return;
-  },
-  extractClientWorkingDirectory(body) {
-    return extractClaudeCodeClientCwd(body);
-  },
-  normalizeContent(content) {
-    return normalizeContent(content);
-  },
-  getBlockedBuiltinTools() {
-    return BLOCKED_BUILTIN_TOOLS;
-  },
-  getAgentIncompatibleTools() {
-    return CLAUDE_CODE_ONLY_TOOLS;
-  },
-  getMcpServerName() {
-    return MCP_SERVER_NAME;
-  },
-  getAllowedMcpTools() {
-    return ALLOWED_MCP_TOOLS;
-  },
-  getCoreToolNames() {
-    return ["Read", "Write", "Edit", "Bash", "Glob", "Grep"];
-  },
-  usesPassthrough() {
-    return resolvePassthrough(true);
-  },
-  supportsThinking() {
-    return true;
-  },
-  shouldTrackFileChanges() {
-    return false;
-  },
-  extractFileChangesFromToolUse(toolName, toolInput) {
-    const input = toolInput;
-    const filePath = input?.file_path ?? input?.filePath ?? input?.path;
-    const lowerName = toolName.toLowerCase();
-    if (lowerName === "write" && filePath) {
-      return [{ operation: "wrote", path: String(filePath) }];
-    }
-    if ((lowerName === "edit" || lowerName === "multiedit") && filePath) {
-      return [{ operation: "edited", path: String(filePath) }];
-    }
-    if (lowerName === "bash" && input?.command) {
-      return extractFileChangesFromBash(String(input.command));
-    }
-    return [];
-  }
-};
-
 // src/proxy/adapters/openai.ts
 var openAiAdapter = {
   ...openCodeAdapter,
@@ -12865,7 +12907,7 @@ function detectAdapter(c) {
       }
     }
   }
-  if (c.req.header("x-opencode-session") || c.req.header("x-session-affinity")) {
+  if (c.req.header("x-opencode-session")) {
     return openCodeAdapter;
   }
   const userAgent = c.req.header("user-agent") || "";
@@ -12878,6 +12920,9 @@ function detectAdapter(c) {
   if (userAgent.startsWith("Charm-Crush/")) {
     return crushAdapter;
   }
+  if (c.req.header("x-session-affinity")) {
+    return openCodeAdapter;
+  }
   if (userAgent.startsWith("claude-cli/")) {
     const claudeCliOverride = (process.env.MERIDIAN_DEFAULT_AGENT || "").toLowerCase();
     if (claudeCliOverride && ADAPTER_MAP[claudeCliOverride] && claudeCliOverride !== "claude-code" && claudeCliOverride !== "claudecode") {
@@ -18818,6 +18863,43 @@ var codexTransforms = [
   }
 ];
 
+// src/proxy/transforms/claudecode.ts
+init_env();
+var claudeCodeTransforms = [
+  {
+    name: "claudecode-core",
+    adapters: ["claude-code"],
+    onRequest(ctx) {
+      const extractFileChangesFromToolUse = (toolName, toolInput) => {
+        const input = toolInput;
+        const filePath = input?.file_path ?? input?.filePath ?? input?.path;
+        const lowerName = toolName.toLowerCase();
+        if (lowerName === "write" && filePath) {
+          return [{ operation: "wrote", path: String(filePath) }];
+        }
+        if ((lowerName === "edit" || lowerName === "multiedit") && filePath) {
+          return [{ operation: "edited", path: String(filePath) }];
+        }
+        if (lowerName === "bash" && input?.command) {
+          return extractFileChangesFromBash(String(input.command));
+        }
+        return [];
+      };
+      return {
+        ...ctx,
+        blockedTools: BLOCKED_BUILTIN_TOOLS,
+        incompatibleTools: CLAUDE_CODE_ONLY_TOOLS,
+        allowedMcpTools: ALLOWED_MCP_TOOLS,
+        coreToolNames: ["Read", "Write", "Edit", "Bash", "Glob", "Grep"],
+        passthrough: resolvePassthrough(true),
+        supportsThinking: true,
+        shouldTrackFileChanges: false,
+        extractFileChangesFromToolUse
+      };
+    }
+  }
+];
+
 // src/proxy/transforms/registry.ts
 var ADAPTER_TRANSFORMS = {
   opencode: openCodeTransforms,
@@ -18827,6 +18909,7 @@ var ADAPTER_TRANSFORMS = {
   forgecode: forgeCodeTransforms,
   passthrough: passthroughTransforms,
   cherry: cherryTransforms,
+  "claude-code": claudeCodeTransforms,
   openai: openCodeTransforms,
   codex: [...openCodeTransforms, ...codexTransforms]
 };
@@ -19128,7 +19211,7 @@ var ORCHESTRATION_TAGS = [
 ];
 function tagPatterns(tag) {
   return [
-    new RegExp(`<${tag}\\b[^>]*>[\\s\\S]*?<\\/${tag}>`, "gi"),
+    new RegExp(`<${tag}\\b[^>]*(?<!\\/)>[\\s\\S]*?<\\/${tag}>`, "gi"),
     new RegExp(`<${tag}\\b[^>]*\\/>`, "gi")
   ];
 }
@@ -19147,6 +19230,16 @@ var ALL_PATTERNS = [
 ];
 var SYSTEM_REMINDER_PATTERNS = tagPatterns("system-reminder");
 var THINKING_TAG_PATTERNS = tagPatterns("thinking");
+function sanitizeAssistantText(text) {
+  let result = text;
+  for (const pattern of NON_XML_PATTERNS) {
+    pattern.lastIndex = 0;
+    result = result.replace(pattern, "");
+  }
+  return result.replace(/\n{3,}/g, `
+
+`).trim();
+}
 function sanitizeTextContent(text, opts = {}) {
   let result = text;
   const patterns = [...ALL_PATTERNS];
@@ -19783,10 +19876,10 @@ function normalizeStructuredUserContent(content) {
 }
 function flattenAssistantContent(content) {
   if (typeof content === "string")
-    return content;
+    return sanitizeAssistantText(content);
   if (!Array.isArray(content))
     return String(content ?? "");
-  return content.map((b) => b?.type === "text" && b.text ? b.text : "").filter(Boolean).join(`
+  return content.map((b) => b?.type === "text" && b.text ? sanitizeAssistantText(b.text) : "").filter(Boolean).join(`
 `);
 }
 function flattenUserContent(content, sanitizeOpts = {}, toolIndex) {
@@ -19978,6 +20071,8 @@ function createProxyServer(config = {}) {
   }
   function refinePriorityCooldown(profileId) {
     const target = getEffectiveProfiles(finalConfig.profiles).find((p) => p.id === profileId);
+    if ((target?.type ?? "claude-max") !== "claude-max")
+      return;
     fetchOAuthUsage({ profileId, claudeConfigDir: target?.claudeConfigDir, force: true }).then((usage) => {
       if (!usage || usage.stale)
         return;
@@ -20194,7 +20289,7 @@ data: ${JSON.stringify(lastError)}
         const envOverrides = explicitModelPin(requestedModel);
         const cwdResolution = resolveSdkWorkingDirectory({
           envOverride: process.env.MERIDIAN_WORKDIR ?? process.env.CLAUDE_PROXY_WORKDIR,
-          adapterCwd: adapter.extractWorkingDirectory(body),
+          adapterCwd: adapter.extractWorkingDirectory(body) ?? adapter.extractClientWorkingDirectory?.(body),
           fallback: process.cwd()
         });
         const workingDirectory = cwdResolution.workingDirectory;
@@ -21151,6 +21246,36 @@ Subprocess stderr: ${stderrOutput}`;
             const streamedToolUseIds = new Set;
             const openClientBlocks = new Set;
             const resolvePendingStore = passthrough && earlyStopEnabled && !isIndependentSession && profileSessionId ? registerPendingStore(profileSessionId) : () => {};
+            let pendingEarlyStop = false;
+            let pendingEarlyStopAt = 0;
+            const fireEarlyStop = (reason) => {
+              earlyStopFired = true;
+              claudeLog("passthrough.early_stop", {
+                mode: "stream",
+                captured: capturedToolUses.length,
+                drained: awaitingEarlyStopDrain,
+                reason,
+                deferredMs: pendingEarlyStopAt ? Date.now() - pendingEarlyStopAt : 0
+              });
+              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");
+              safeEnqueue(encoder.encode(`event: message_stop
+data: ${JSON.stringify({ type: "message_stop" })}
+
+`), "early_stop");
+              requestAbort.abort("passthrough turn complete");
+              awaitingEarlyStopDrain = false;
+              if (!streamClosed) {
+                streamClosed = true;
+                try {
+                  controller.close();
+                } catch {}
+              }
+            };
             const flushOpenClientBlocks = (source) => {
               if (openClientBlocks.size === 0)
                 return;
@@ -21465,26 +21590,19 @@ data: ${JSON.stringify({ type: "content_block_stop", index: idx })}
                     } else if (message.type === "user") {
                       noteUserContent(earlyStop, message.message?.content);
                       if (shouldEarlyStop(earlyStop) && streamedToolUseIds.size > 0) {
-                        earlyStopFired = true;
-                        claudeLog("passthrough.early_stop", { mode: "stream", captured: capturedToolUses.length, drained: awaitingEarlyStopDrain });
-                        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");
-                        safeEnqueue(encoder.encode(`event: message_stop
-data: ${JSON.stringify({ type: "message_stop" })}
-
-`), "early_stop");
-                        requestAbort.abort("passthrough turn complete");
-                        awaitingEarlyStopDrain = false;
-                        if (!streamClosed) {
-                          streamClosed = true;
-                          try {
-                            controller.close();
-                          } catch {}
+                        if (openClientBlocks.size > 0) {
+                          if (!pendingEarlyStop) {
+                            pendingEarlyStop = true;
+                            pendingEarlyStopAt = Date.now();
+                            claudeLog("passthrough.early_stop_deferred", {
+                              openBlocks: openClientBlocks.size,
+                              captured: capturedToolUses.length
+                            });
+                          }
+                        } else {
+                          fireEarlyStop("immediate");
+                          break;
                         }
-                        break;
                       }
                     }
                   }
@@ -21661,6 +21779,10 @@ data: ${JSON.stringify(event)}
                       const idx = event.index;
                       if (typeof idx === "number")
                         openClientBlocks.delete(idx);
+                      if (pendingEarlyStop && openClientBlocks.size === 0) {
+                        fireEarlyStop("blocks_closed");
+                        break;
+                      }
                     }
                     if (passthrough && eventType === "message_delta" && event.delta?.stop_reason === "tool_use" && streamedToolUseIds.size > 0) {
                       flushOpenClientBlocks("drain_close");
@@ -21951,7 +22073,7 @@ Subprocess stderr: ${stderrOutput}`;
                 status: 504,
                 type: "upstream_timeout",
                 message: `Upstream stalled: no data for ${error.sinceLastMs}ms`
-              } : classifyError(errMsg);
+              } : 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;

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   startProxyServer
-} from "./cli-ndsqa67x.js";
+} from "./cli-deynz4ef.js";
 import"./cli-h6hfkg3s.js";
 import"./cli-sry5aqdj.js";
 import"./cli-xmweegb1.js";

package/dist/proxy/adapters/crush.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"crush.d.ts","sourceRoot":"","sources":["../../../src/proxy/adapters/crush.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAgB9C,eAAO,MAAM,YAAY,EAAE,YAyF1B,CAAA;AAED,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AACrD,OAAO,EAAE,eAAe,EAAE,CAAA"}
+{"version":3,"file":"crush.d.ts","sourceRoot":"","sources":["../../../src/proxy/adapters/crush.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAgB9C,eAAO,MAAM,YAAY,EAAE,YAiG1B,CAAA;AAED,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AACrD,OAAO,EAAE,eAAe,EAAE,CAAA"}

package/dist/proxy/adapters/detect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"detect.d.ts","sourceRoot":"","sources":["../../../src/proxy/adapters/detect.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AACnC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AA0F9C,wBAAgB,aAAa,CAAC,CAAC,EAAE,OAAO,GAAG,YAAY,CAsEtD"}
+{"version":3,"file":"detect.d.ts","sourceRoot":"","sources":["../../../src/proxy/adapters/detect.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AACnC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AA0F9C,wBAAgB,aAAa,CAAC,CAAC,EAAE,OAAO,GAAG,YAAY,CAkFtD"}

package/dist/proxy/adapters/pi.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pi.d.ts","sourceRoot":"","sources":["../../../src/proxy/adapters/pi.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAyC9C,eAAO,MAAM,SAAS,EAAE,YA+HvB,CAAA;AAED,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAC/C,OAAO,EAAE,YAAY,EAAE,CAAA"}
+{"version":3,"file":"pi.d.ts","sourceRoot":"","sources":["../../../src/proxy/adapters/pi.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AA0C9C,eAAO,MAAM,SAAS,EAAE,YAoJvB,CAAA;AAED,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAC/C,OAAO,EAAE,YAAY,EAAE,CAAA"}

package/dist/proxy/errors.d.ts

@@ -7,10 +7,32 @@ export interface ClassifiedError {
     type: string;
     message: string;
 }
+/**
+ * Remediation advice for a rate limit hit on an extended-context request.
+ *
+ * `model` is the resolved variant (`opus[1m]`, `fable`, `sonnet`, …). The advice
+ * has to name the tier that actually failed: the three per-tier variables have
+ * opposite polarity, because Sonnet 1M costs Extra Usage on every plan while
+ * Fable and Opus 1M are included on Max/Team (#717). So Sonnet opts *in* to 1M
+ * and the other two opt *out* of it.
+ *
+ * Returns "" rather than guessing when there is nothing useful to say:
+ *
+ *  - The request did not use extended context. Suggesting a 1M variable is
+ *    irrelevant, and for Sonnet — which is 200k by default — the old advice
+ *    was a literal no-op: the user set the variable to the value it already
+ *    had, saw no change, and reasonably concluded Meridian was broken (#716).
+ *  - The tier is unrecognized, where the global switch is the only safe advice.
+ */
+export declare function extendedContextHint(model?: string): string;
 /**
  * Detect specific SDK errors and return helpful messages to the client.
+ *
+ * `model` is the resolved variant for this request, used only to target the
+ * extended-context remediation hint. Optional because the outer error handler
+ * may not have assigned it yet when a request fails early.
  */
-export declare function classifyError(errMsg: string): ClassifiedError;
+export declare function classifyError(errMsg: string, model?: string): ClassifiedError;
 /**
  * Detect errors caused by an expired or missing OAuth access token.
  * Triggers an inline token refresh + retry in server.ts.

package/dist/proxy/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/proxy/errors.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,CAoH7D;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAM3D;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAO3D;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAI3E;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAGxD;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAGjE;AAED;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,WAAW,GAAG,cAAc,GAAG,SAAS,GAAG,SAAS,CAAA;IAC5D,sDAAsD;IACtD,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,wDAAwD;IACxD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,wDAAwD;IACxD,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB;;wCAEoC;IACpC,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAuBD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,CAuCpE;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,CAAC,EAAE,cAAc,EACjB,GAAG,EAAE;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB,GACA,MAAM,CAYR"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/proxy/errors.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAc1D;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,eAAe,CAoH7E;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAM3D;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAO3D;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAI3E;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAGxD;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAGjE;AAED;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,WAAW,GAAG,cAAc,GAAG,SAAS,GAAG,SAAS,CAAA;IAC5D,sDAAsD;IACtD,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,wDAAwD;IACxD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,wDAAwD;IACxD,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB;;wCAEoC;IACpC,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAuBD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,CAuCpE;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,CAAC,EAAE,cAAc,EACjB,GAAG,EAAE;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB,GACA,MAAM,CAYR"}

package/dist/proxy/messages.d.ts

@@ -1,11 +1,59 @@
 /**
  * Message parsing and normalization utilities.
  */
+/**
+ * Content block types that contribute nothing to the lineage hash.
+ *
+ * Thinking blocks are model-emitted reasoning. Their `signature` is an opaque,
+ * high-entropy, per-generation blob, and `redacted_thinking` carries only
+ * opaque `data` — none of it identifies the conversation prefix, which is the
+ * only question the hash exists to answer.
+ *
+ * They are dropped entirely rather than reduced to their text, because the
+ * failure mode is a client that stops echoing thinking blocks once a tool loop
+ * finishes — a common pattern, since only the active loop strictly needs them.
+ * Hashing `thinking:<text>` would still change that message's hash the moment
+ * the block disappears; contributing nothing is what makes the hash stable
+ * across its presence, absence, and any re-signature (#710).
+ *
+ * Deliberate trade-off: two prefixes differing ONLY in thinking now hash alike.
+ * That is correct — thinking always accompanies the same text and tool calls in
+ * its own turn, and those are still hashed, so it never distinguishes two
+ * genuinely different prefixes on its own.
+ */
+export declare const HASH_IGNORED_BLOCK_TYPES: Set<string>;
+/**
+ * Block types with an explicit case in {@link normalizeContent}, hashed on
+ * their semantic fields only.
+ */
+export declare const HASH_HANDLED_BLOCK_TYPES: Set<string>;
+/**
+ * Block types deliberately serialized whole by the fallback.
+ *
+ * Reviewed against `ContentBlockParam` and confirmed to carry no
+ * per-generation opaque field: their payloads (`source`, `content`, `title`,
+ * `file_id`) are stable for the same logical content, so serializing them is
+ * safe. `cache_control` is stripped separately.
+ *
+ * The `*_tool_use` / `*_tool_result` entries reference `id` / `tool_use_id`,
+ * which ARE per-generation — but that matches how `tool_use` and `tool_result`
+ * are already hashed, and clients echo the same ids back. Same accepted risk,
+ * not a new one.
+ *
+ * Membership here is a decision, not a default. `sdk-block-type-coverage`
+ * fails when the installed SDK adds a type absent from all three sets, so a
+ * new block type cannot silently land in the fallback the way `thinking` did
+ * (#710).
+ */
+export declare const HASH_SERIALIZED_BLOCK_TYPES: Set<string>;
 /**
  * Normalize message content to a string for hashing and comparison.
  * Handles both string content and array content (Anthropic content blocks).
  * Strips cache_control metadata to ensure hash stability across requests.
  *
+ * Used only for lineage hashing — see {@link HASH_IGNORED_BLOCK_TYPES}, which
+ * drops content a display-oriented normalizer would need to keep.
+ *
  * NOTE: OpenCode sends content as a string on the first request but as
  * an array on subsequent ones. This normalizer handles both formats.
  * Other agents may behave differently — this will move to the adapter pattern.

package/dist/proxy/messages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../src/proxy/messages.ts"],"names":[],"mappings":"AAAA;;GAEG;AAcH;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,GAAG,GAAG,MAAM,CAiBrD;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAUtE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,CAM7D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,GAAG,CAAA;CAAE,CAAC,GAAG,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,GAAG,CAAA;CAAE,CAAC,CAKzH;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,MAAM,CAerF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,4BAA4B,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAU3D;AAED,yEAAyE;AACzE,eAAO,MAAM,gBAAgB,aAAyC,CAAA;AAEtE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,iCAAiC,CAC/C,CAAC,SAAS;IAAE,OAAO,EAAE;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAA;CAAE,EAC3C,UAAU,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAyCtB;AAED,kEAAkE;AAClE,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,8EAA8E;IAC9E,MAAM,EAAE,MAAM,GAAG,SAAS,CAAA;IAC1B;;;;;;;OAOG;IACH,cAAc,EAAE,MAAM,GAAG,SAAS,CAAA;CACnC;AAyCD;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,GAAG,CAAA;CAAE,CAAC,GAC9C,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAyB3B;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAO3D"}
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../src/proxy/messages.ts"],"names":[],"mappings":"AAAA;;GAEG;AAcH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,wBAAwB,aAA6C,CAAA;AAElF;;;GAGG;AACH,eAAO,MAAM,wBAAwB,aAA+C,CAAA;AAEpF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,2BAA2B,aAYtC,CAAA;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,GAAG,GAAG,MAAM,CAmBrD;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAUtE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,CAM7D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,GAAG,CAAA;CAAE,CAAC,GAAG,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,GAAG,CAAA;CAAE,CAAC,CAKzH;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,MAAM,CAerF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,4BAA4B,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAU3D;AAED,yEAAyE;AACzE,eAAO,MAAM,gBAAgB,aAAyC,CAAA;AAEtE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,iCAAiC,CAC/C,CAAC,SAAS;IAAE,OAAO,EAAE;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAA;CAAE,EAC3C,UAAU,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAyCtB;AAED,kEAAkE;AAClE,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,8EAA8E;IAC9E,MAAM,EAAE,MAAM,GAAG,SAAS,CAAA;IAC1B;;;;;;;OAOG;IACH,cAAc,EAAE,MAAM,GAAG,SAAS,CAAA;CACnC;AAyCD;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,GAAG,CAAA;CAAE,CAAC,GAC9C,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAyB3B;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAO3D"}

package/dist/proxy/rateLimitStore.d.ts

@@ -9,7 +9,7 @@
  *     type: "rate_limit_event",
  *     rate_limit_info: {
  *       status: "allowed" | "allowed_warning" | "rejected",
- *       resetsAt?: number,                              // epoch ms
+ *       resetsAt?: number,                              // epoch SECONDS — see toEpochMs
  *       rateLimitType?: "five_hour" | "seven_day"
  *                     | "seven_day_opus" | "seven_day_sonnet"
  *                     | "overage",
@@ -39,6 +39,22 @@
  * used by tests.
  */
 import type { SDKRateLimitInfo } from "@anthropic-ai/claude-agent-sdk";
+/**
+ * Normalize an SDK reset timestamp to epoch milliseconds.
+ *
+ * The SDK reports these in epoch SECONDS while everything downstream —
+ * `Date.now()` comparisons in the priority-cooldown chain, the documented
+ * `/v1/usage/quota` contract, and consumers like the telemetry badge and Pylon
+ * — is epoch milliseconds. Proven by observing one profile's `five_hour` reset
+ * from both sources minutes apart: OAuth reported `1785234600292` and the SDK
+ * reported `1785234600` for the same instant (#708).
+ *
+ * Detects the unit rather than multiplying unconditionally, because
+ * `SDKRateLimitInfo.resetsAt` is typed `number` with no documented unit. An
+ * unconditional `* 1000` would silently corrupt every value if the SDK ever
+ * switched to milliseconds; this stays correct under either.
+ */
+export declare function toEpochMs(value: number | undefined): number | undefined;
 export interface RateLimitEntry extends SDKRateLimitInfo {
     /** When this entry was captured (epoch ms). */
     observedAt: number;

package/dist/proxy/rateLimitStore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rateLimitStore.d.ts","sourceRoot":"","sources":["../../src/proxy/rateLimitStore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AAEtE,MAAM,WAAW,cAAe,SAAQ,gBAAgB;IACtD,+CAA+C;IAC/C,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,qDAAqD;AACrD,MAAM,MAAM,kBAAkB,GAAG,WAAW,CAAC,gBAAgB,CAAC,eAAe,CAAC,CAAC,GAAG,SAAS,CAAA;AAE3F,cAAM,cAAc;IAClB,gFAAgF;IAChF,OAAO,CAAC,SAAS,CAA6D;IAE9E;;;;;;;;OAQG;IACH,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,gBAAgB,GAAG,SAAS,GAAG,IAAI,EAAE,UAAU,GAAE,MAAmB,GAAG,IAAI;IAW3G,kEAAkE;IAClE,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,cAAc,EAAE;IAM3C,8EAA8E;IAC9E,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,kBAAkB,GAAG,cAAc,GAAG,SAAS;IAI3E,yEAAyE;IACzE,IAAI,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM;IAOhC;;;;OAIG;IACH,KAAK,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI;CAIhC;AAED;;;GAGG;AACH,eAAO,MAAM,cAAc,gBAAuB,CAAA;AAElD,wCAAwC;AACxC,OAAO,EAAE,cAAc,IAAI,uBAAuB,EAAE,CAAA"}
+{"version":3,"file":"rateLimitStore.d.ts","sourceRoot":"","sources":["../../src/proxy/rateLimitStore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AAYtE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAGvE;AAED,MAAM,WAAW,cAAe,SAAQ,gBAAgB;IACtD,+CAA+C;IAC/C,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,qDAAqD;AACrD,MAAM,MAAM,kBAAkB,GAAG,WAAW,CAAC,gBAAgB,CAAC,eAAe,CAAC,CAAC,GAAG,SAAS,CAAA;AAE3F,cAAM,cAAc;IAClB,gFAAgF;IAChF,OAAO,CAAC,SAAS,CAA6D;IAE9E;;;;;;;;OAQG;IACH,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,gBAAgB,GAAG,SAAS,GAAG,IAAI,EAAE,UAAU,GAAE,MAAmB,GAAG,IAAI;IAkB3G,kEAAkE;IAClE,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,cAAc,EAAE;IAM3C,8EAA8E;IAC9E,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,kBAAkB,GAAG,cAAc,GAAG,SAAS;IAI3E,yEAAyE;IACzE,IAAI,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM;IAOhC;;;;OAIG;IACH,KAAK,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI;CAIhC;AAED;;;GAGG;AACH,eAAO,MAAM,cAAc,gBAAuB,CAAA;AAElD,wCAAwC;AACxC,OAAO,EAAE,cAAc,IAAI,uBAAuB,EAAE,CAAA"}

package/dist/proxy/sanitize.d.ts

@@ -31,5 +31,28 @@ export interface SanitizeOptions {
  * Designed to be called on individual content blocks (not concatenated
  * prompt strings) to eliminate cross-block regex matching risk.
  */
+/**
+ * Strip only the branded, harness-generated markers from ASSISTANT text.
+ *
+ * Assistant content is replayed into the prompt as `[Assistant: …]` context and
+ * has never been sanitized — the unimplemented half of #167 (see #724). The
+ * concrete leak is Meridian's own doing: `server.ts` appends its "Files
+ * changed:" summary onto the assistant's last text block, the client echoes
+ * that assistant turn back on the next turn, and the summary replays into the
+ * model's context verbatim. `NON_XML_PATTERNS` has carried a pattern for it all
+ * along, which could never fire because the sanitizer only ran on user text.
+ *
+ * Deliberately NOT the XML tag allowlist. Assistant text is model OUTPUT, and a
+ * model asked about configuration will legitimately write `<env>…</env>` — so
+ * stripping the allowlist here would delete the model's own answer, which is
+ * exactly the failure #720 was about. `NON_XML_PATTERNS` is safe because every
+ * entry is uniquely branded (Meridian's summary, oh-my-opencode's markers, the
+ * background-task marker): no model emits them by accident.
+ *
+ * `tool_result` content is deliberately left alone too — it is tool-generated
+ * and can legitimately contain anything, including text that merely looks like
+ * a marker. Corrupting real tool output is worse than replaying a wrapper.
+ */
+export declare function sanitizeAssistantText(text: string): string;
 export declare function sanitizeTextContent(text: string, opts?: SanitizeOptions): string;
 //# sourceMappingURL=sanitize.d.ts.map

package/dist/proxy/sanitize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../src/proxy/sanitize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAiGH,MAAM,WAAW,eAAe;IAC9B;oCACgC;IAChC,mBAAmB,CAAC,EAAE,OAAO,CAAA;IAC7B;;8CAE0C;IAC1C,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,eAAoB,GAAG,MAAM,CAapF"}
+{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../src/proxy/sanitize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AA4GH,MAAM,WAAW,eAAe;IAC9B;oCACgC;IAChC,mBAAmB,CAAC,EAAE,OAAO,CAAA;IAC7B;;8CAE0C;IAC1C,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB;AAED;;;;;GAKG;AACH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAO1D;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,eAAoB,GAAG,MAAM,CAapF"}

package/dist/proxy/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/proxy/server.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AACtE,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,WAAW,EAAE,CAAA;AAGvD,YAAY,EACV,SAAS,EACT,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,YAAY,EACZ,aAAa,EACb,WAAW,GACZ,MAAM,aAAa,CAAA;AAKpB,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AAkDnG,OAAO,EACL,kBAAkB,EAClB,WAAW,EACX,oBAAoB,EAEpB,KAAK,aAAa,EAGnB,MAAM,mBAAmB,CAAA;AAI1B,OAAO,EAA+B,iBAAiB,EAAE,mBAAmB,EAAsC,MAAM,iBAAiB,CAAA;AAGzI,OAAO,EAAE,kBAAkB,EAAE,WAAW,EAAE,oBAAoB,EAAE,CAAA;AAChE,OAAO,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,CAAA;AACjD,YAAY,EAAE,aAAa,EAAE,CAAA;AAgR7B,wBAAgB,iBAAiB,CAAC,MAAM,GAAE,OAAO,CAAC,WAAW,CAAM,GAAG,WAAW,CAggIhF;AAWD,wBAAgB,gCAAgC,IAAI,IAAI,CAavD;AAED,wBAAsB,gBAAgB,CAAC,MAAM,GAAE,OAAO,CAAC,WAAW,CAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAmGhG"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/proxy/server.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AACtE,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,WAAW,EAAE,CAAA;AAGvD,YAAY,EACV,SAAS,EACT,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,YAAY,EACZ,aAAa,EACb,WAAW,GACZ,MAAM,aAAa,CAAA;AAKpB,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AAkDnG,OAAO,EACL,kBAAkB,EAClB,WAAW,EACX,oBAAoB,EAEpB,KAAK,aAAa,EAGnB,MAAM,mBAAmB,CAAA;AAI1B,OAAO,EAA+B,iBAAiB,EAAE,mBAAmB,EAAsC,MAAM,iBAAiB,CAAA;AAGzI,OAAO,EAAE,kBAAkB,EAAE,WAAW,EAAE,oBAAoB,EAAE,CAAA;AAChE,OAAO,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,CAAA;AACjD,YAAY,EAAE,aAAa,EAAE,CAAA;AAqR7B,wBAAgB,iBAAiB,CAAC,MAAM,GAAE,OAAO,CAAC,WAAW,CAAM,GAAG,WAAW,CA8kIhF;AAWD,wBAAgB,gCAAgC,IAAI,IAAI,CAavD;AAED,wBAAsB,gBAAgB,CAAC,MAAM,GAAE,OAAO,CAAC,WAAW,CAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAmGhG"}

package/dist/proxy/transforms/claudecode.d.ts

@@ -0,0 +1,17 @@
+import type { Transform } from "../transform";
+/**
+ * Claude Code transform — supplies the SDK tool config at request time.
+ *
+ * server.ts reads `pipelineCtx.*`, never the adapter methods, so without an
+ * entry here a Claude Code client gets the createRequestContext defaults:
+ * `blockedTools: []` and `passthrough: undefined`. That means the SDK
+ * subprocess runs the client's task with its own built-in Read/Write/Bash on
+ * the proxy host while the client executes the same tool calls locally —
+ * every side effect happens twice (#546, same failure mode as OpenCode's).
+ *
+ * Values mirror claudeCodeAdapter (adapters/claudecode.ts); the parity tests
+ * hold the two in sync. Core tool names are PascalCase here — Claude Code's
+ * toolkit is Read/Write/Edit/Bash/Glob/Grep, not OpenCode's lowercase names.
+ */
+export declare const claudeCodeTransforms: Transform[];
+//# sourceMappingURL=claudecode.d.ts.map

package/dist/proxy/transforms/claudecode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claudecode.d.ts","sourceRoot":"","sources":["../../../src/proxy/transforms/claudecode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAkB,MAAM,cAAc,CAAA;AAK7D;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,oBAAoB,EAAE,SAAS,EAsC3C,CAAA"}

package/dist/proxy/transforms/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/proxy/transforms/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AA2B7C,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,SAAS,EAAE,CAE9E"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/proxy/transforms/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAgC7C,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,SAAS,EAAE,CAE9E"}

package/dist/server.js

@@ -11,7 +11,7 @@ import {
   runObserveHook,
   runTransformHook,
   startProxyServer
-} from "./cli-ndsqa67x.js";
+} from "./cli-deynz4ef.js";
 import"./cli-h6hfkg3s.js";
 import"./cli-sry5aqdj.js";
 import"./cli-xmweegb1.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rynfar/meridian",
-  "version": "1.58.1",
+  "version": "1.58.3",
   "description": "Local Anthropic API powered by your Claude Max subscription. One subscription, every agent.",
   "type": "module",
   "main": "./dist/server.js",