@rynfar/meridian 1.68.0 → 1.70.0

package/dist/{cli-0zhb8ss4.js → cli-198xnjcn.js}

@@ -77,7 +77,7 @@ import {
   init_priorityAttestation,
   notePluginlessOpenCodeRequest,
   verifyPriorityAttestation
-} from "./cli-sh8bzdwe.js";
+} from "./cli-zdbv40d5.js";
 import {
   __commonJS,
   __esm,
@@ -633,7 +633,7 @@ __export(exports_pricingStore, {
   getPricingOverrides: () => getPricingOverrides,
   deletePricingOverride: () => deletePricingOverride
 });
-import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync, renameSync } from "node:fs";
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync, renameSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { homedir } from "node:os";
 function getConfigPath() {
@@ -651,7 +651,7 @@ function readOverrides() {
   }
   try {
     if (existsSync2(path)) {
-      const raw2 = JSON.parse(readFileSync(path, "utf-8"));
+      const raw2 = JSON.parse(readFileSync2(path, "utf-8"));
       const result = {};
       for (const [model, value] of Object.entries(raw2)) {
         try {
@@ -867,7 +867,7 @@ var require_process = __commonJS((exports, module) => {
 var require_filesystem = __commonJS((exports, module) => {
   var fs = __require("fs");
   var LDD_PATH = "/usr/bin/ldd";
-  var readFileSync3 = (path) => fs.readFileSync(path, "utf-8");
+  var readFileSync4 = (path) => fs.readFileSync(path, "utf-8");
   var readFile = (path) => new Promise((resolve3, reject) => {
     fs.readFile(path, "utf-8", (err, data) => {
       if (err) {
@@ -879,7 +879,7 @@ var require_filesystem = __commonJS((exports, module) => {
   });
   module.exports = {
     LDD_PATH,
-    readFileSync: readFileSync3,
+    readFileSync: readFileSync4,
     readFile
   };
 });
@@ -888,7 +888,7 @@ var require_filesystem = __commonJS((exports, module) => {
 var require_detect_libc = __commonJS((exports, module) => {
   var childProcess = __require("child_process");
   var { isLinux, getReport } = require_process();
-  var { LDD_PATH, readFile, readFileSync: readFileSync3 } = require_filesystem();
+  var { LDD_PATH, readFile, readFileSync: readFileSync4 } = require_filesystem();
   var cachedFamilyFilesystem;
   var cachedVersionFilesystem;
   var command = "getconf GNU_LIBC_VERSION 2>&1 || true; ldd --version 2>&1 || true";
@@ -968,7 +968,7 @@ var require_detect_libc = __commonJS((exports, module) => {
     }
     cachedFamilyFilesystem = null;
     try {
-      const lddContent = readFileSync3(LDD_PATH);
+      const lddContent = readFileSync4(LDD_PATH);
       cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
     } catch (e) {}
     return cachedFamilyFilesystem;
@@ -1023,7 +1023,7 @@ var require_detect_libc = __commonJS((exports, module) => {
     }
     cachedVersionFilesystem = null;
     try {
-      const lddContent = readFileSync3(LDD_PATH);
+      const lddContent = readFileSync4(LDD_PATH);
       const versionMatch = lddContent.match(RE_GLIBC_VERSION);
       if (versionMatch) {
         cachedVersionFilesystem = versionMatch[1];
@@ -2117,7 +2117,7 @@ var init_messages = __esm(() => {
 });
 
 // src/proxy/session/fingerprint.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 function extractClientCwd(body) {
   let systemText = "";
   if (typeof body.system === "string") {
@@ -2140,7 +2140,7 @@ function getConversationFingerprint(messages, workingDirectory) {
     return "";
   const seed = workingDirectory ? `${workingDirectory}
 ${text.slice(0, 2000)}` : text.slice(0, 2000);
-  return createHash2("sha256").update(seed).digest("hex").slice(0, 16);
+  return createHash3("sha256").update(seed).digest("hex").slice(0, 16);
 }
 function getPriorityAssignmentKey(sessionId, messages, workingDirectory) {
   if (sessionId)
@@ -2463,6 +2463,119 @@ var init_jcode = __esm(() => {
   };
 });
 
+// src/proxy/adapters/claudecode.ts
+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 extractClaudeCodeSessionIdentity(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;
+  if (typeof sessionId !== "string" || sessionId.length === 0)
+    return;
+  const parentSessionId = userMetadata.parent_session_id;
+  const parent = typeof parentSessionId === "string" && parentSessionId.length > 0 && parentSessionId !== sessionId ? parentSessionId : undefined;
+  return parent ? { sessionId, parentSessionId: parent } : { sessionId };
+}
+function extractClaudeCodeSessionId(body) {
+  return extractClaudeCodeSessionIdentity(body)?.sessionId;
+}
+function extractClaudeCodeParentSessionId(body) {
+  return extractClaudeCodeSessionIdentity(body)?.parentSessionId;
+}
+function isClaudeCodeClient(c) {
+  return Boolean(c.req.header("x-claude-code-session-id"));
+}
+var claudeCodeAdapter;
+var init_claudecode = __esm(() => {
+  init_fileChanges();
+  init_messages();
+  init_tools();
+  init_env();
+  claudeCodeAdapter = {
+    name: "claude-code",
+    clientEnvironmentMayDifferFromProxy: true,
+    getSessionId(_c, body) {
+      return extractClaudeCodeSessionId(body);
+    },
+    getParentSessionId(_c, body) {
+      return extractClaudeCodeParentSessionId(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/droid.ts
 function resolveDroidPassthrough() {
   return resolvePassthrough(false);
@@ -2774,6 +2887,9 @@ var init_passthrough2 = __esm(() => {
     getMcpServerName() {
       return MCP_SERVER_NAME3;
     },
+    getPassthroughMcpName() {
+      return MCP_SERVER_NAME3;
+    },
     getAllowedMcpTools() {
       return ALLOWED_MCP_TOOLS3;
     },
@@ -2795,116 +2911,6 @@ var init_passthrough2 = __esm(() => {
   };
 });
 
-// src/proxy/adapters/claudecode.ts
-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 extractClaudeCodeSessionIdentity(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;
-  if (typeof sessionId !== "string" || sessionId.length === 0)
-    return;
-  const parentSessionId = userMetadata.parent_session_id;
-  const parent = typeof parentSessionId === "string" && parentSessionId.length > 0 && parentSessionId !== sessionId ? parentSessionId : undefined;
-  return parent ? { sessionId, parentSessionId: parent } : { sessionId };
-}
-function extractClaudeCodeSessionId(body) {
-  return extractClaudeCodeSessionIdentity(body)?.sessionId;
-}
-function extractClaudeCodeParentSessionId(body) {
-  return extractClaudeCodeSessionIdentity(body)?.parentSessionId;
-}
-var claudeCodeAdapter;
-var init_claudecode = __esm(() => {
-  init_fileChanges();
-  init_messages();
-  init_tools();
-  init_env();
-  claudeCodeAdapter = {
-    name: "claude-code",
-    clientEnvironmentMayDifferFromProxy: true,
-    getSessionId(_c, body) {
-      return extractClaudeCodeSessionId(body);
-    },
-    getParentSessionId(_c, body) {
-      return extractClaudeCodeParentSessionId(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
 function resolvePiPassthrough() {
   return resolvePassthrough(true);
@@ -3332,8 +3338,95 @@ var init_cherry = __esm(() => {
   };
 });
 
+// src/proxy/transforms/polytoken.ts
+var polytokenTransforms;
+var init_polytoken = __esm(() => {
+  polytokenTransforms = [
+    {
+      name: "polytoken-core",
+      adapters: ["polytoken"],
+      onRequest(ctx) {
+        return {
+          ...ctx,
+          blockedTools: [],
+          incompatibleTools: [],
+          allowedMcpTools: [],
+          coreToolNames: [],
+          passthrough: true,
+          sdkAgents: {},
+          sdkHooks: undefined,
+          systemContext: ctx.systemContext,
+          supportsThinking: true,
+          shouldTrackFileChanges: false,
+          extractFileChangesFromToolUse: undefined
+        };
+      }
+    }
+  ];
+});
+
+// src/proxy/adapters/polytoken.ts
+function normalizePolytokenSessionId(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : undefined;
+}
+var POLYTOKEN_SESSION_HEADER = "x-polytoken-session", polytokenAdapter;
+var init_polytoken2 = __esm(() => {
+  init_messages();
+  init_polytoken();
+  polytokenAdapter = {
+    name: "polytoken",
+    clientEnvironmentMayDifferFromProxy: true,
+    getSessionId(c) {
+      return normalizePolytokenSessionId(c.req.header(POLYTOKEN_SESSION_HEADER));
+    },
+    extractWorkingDirectory(_body) {
+      return;
+    },
+    extractClientWorkingDirectory(_body) {
+      return;
+    },
+    normalizeContent(content) {
+      return normalizeContent(content);
+    },
+    getBlockedBuiltinTools() {
+      return [];
+    },
+    getAgentIncompatibleTools() {
+      return [];
+    },
+    getMcpServerName() {
+      return "polytoken";
+    },
+    getAllowedMcpTools() {
+      return [];
+    },
+    getCoreToolNames() {
+      return [];
+    },
+    usesPassthrough() {
+      return true;
+    },
+    supportsThinking() {
+      return true;
+    },
+    shouldTrackFileChanges() {
+      return false;
+    },
+    buildSdkAgents(_body, _mcpToolNames) {
+      return {};
+    },
+    buildSdkHooks(_body, _sdkAgents) {
+      return;
+    },
+    buildSystemContextAddendum(_body, _sdkAgents) {
+      return "";
+    }
+  };
+});
+
 // src/proxy/adapterInstances.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "node:fs";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
 import { join as join5 } from "node:path";
 import { homedir as homedir5 } from "node:os";
 function parseAdapterInstances(raw2) {
@@ -3379,7 +3472,7 @@ function loadAdapterInstances() {
   if (diskCacheAt > 0 && Date.now() - diskCacheAt < DISK_CACHE_TTL_MS)
     return diskCache;
   try {
-    diskCache = existsSync4(CONFIG_FILE) ? parseAdapterInstances(readFileSync3(CONFIG_FILE, "utf-8")) : {};
+    diskCache = existsSync4(CONFIG_FILE) ? parseAdapterInstances(readFileSync4(CONFIG_FILE, "utf-8")) : {};
   } catch (err) {
     console.warn(`[meridian] Failed to read ${CONFIG_FILE}: ${err instanceof Error ? err.message : err}`);
     diskCache = {};
@@ -3423,6 +3516,10 @@ __export(exports_detect, {
 function listAdapterNames() {
   return [...new Set(Object.values(ADAPTER_MAP).map((a) => a.name))];
 }
+function resolveDefaultAdapter() {
+  const current = (process.env.MERIDIAN_DEFAULT_AGENT || "").toLowerCase();
+  return ADAPTER_MAP[current] ?? openCodeAdapter;
+}
 function isLiteLLMRequest(c) {
   if ((c.req.header("user-agent") || "").startsWith("litellm/"))
     return true;
@@ -3450,19 +3547,20 @@ function detectAdapter(c) {
   }
   const instances = loadAdapterInstances();
   const instanceNames = Object.keys(instances);
-  if (instanceNames.length > 0) {
-    if (agentOverride && instances[agentOverride]) {
-      const inst = makeInstanceAdapter(agentOverride, instances[agentOverride]);
+  if (instanceNames.length > 0 && agentOverride && instances[agentOverride]) {
+    const inst = makeInstanceAdapter(agentOverride, instances[agentOverride]);
+    if (inst)
+      return inst;
+  }
+  if (normalizePolytokenSessionId(c.req.header("x-polytoken-session"))) {
+    return polytokenAdapter;
+  }
+  for (const name of instanceNames) {
+    if (matchesInstance(instances[name], (h) => c.req.header(h))) {
+      const inst = makeInstanceAdapter(name, instances[name]);
       if (inst)
         return inst;
     }
-    for (const name of instanceNames) {
-      if (matchesInstance(instances[name], (h) => c.req.header(h))) {
-        const inst = makeInstanceAdapter(name, instances[name]);
-        if (inst)
-          return inst;
-      }
-    }
   }
   if (c.req.header("x-opencode-session")) {
     return openCodeAdapter;
@@ -3480,6 +3578,9 @@ function detectAdapter(c) {
   if (userAgent.startsWith("Charm-Crush/")) {
     return crushAdapter;
   }
+  if (/^Polytoken(?:[\s/]|$)/.test(userAgent)) {
+    return polytokenAdapter;
+  }
   if (c.req.header("x-session-affinity")) {
     return openCodeAdapter;
   }
@@ -3493,9 +3594,9 @@ function detectAdapter(c) {
   if (isLiteLLMRequest(c)) {
     return passthroughAdapter;
   }
-  return defaultAdapter;
+  return resolveDefaultAdapter();
 }
-var ADAPTER_MAP, envDefault, defaultAdapter;
+var ADAPTER_MAP, envDefault;
 var init_detect = __esm(() => {
   init_opencode2();
   init_droid2();
@@ -3509,6 +3610,7 @@ var init_detect = __esm(() => {
   init_jcode();
   init_codex();
   init_cherry();
+  init_polytoken2();
   init_adapterInstances();
   ADAPTER_MAP = {
     opencode: openCodeAdapter,
@@ -3523,6 +3625,7 @@ var init_detect = __esm(() => {
     claudecode: claudeCodeAdapter,
     cherry: cherryAdapter,
     cherrystudio: cherryAdapter,
+    polytoken: polytokenAdapter,
     openai: openAiAdapter,
     jcode: jcodeAdapter,
     codex: codexAdapter
@@ -3531,7 +3634,6 @@ var init_detect = __esm(() => {
   if (envDefault && !ADAPTER_MAP[envDefault]) {
     console.warn(`[meridian] Unknown MERIDIAN_DEFAULT_AGENT="${envDefault}". ` + `Valid values: ${Object.keys(ADAPTER_MAP).join(", ")}. Falling back to opencode.`);
   }
-  defaultAdapter = ADAPTER_MAP[envDefault] ?? openCodeAdapter;
 });
 
 // src/proxy/sdkFeatures.ts
@@ -3687,6 +3789,14 @@ var init_sdkFeatures = __esm(() => {
     },
     codex: {
       codeSystemPrompt: false
+    },
+    polytoken: {
+      codeSystemPrompt: false,
+      clientSystemPrompt: true,
+      claudeMd: "off",
+      memory: false,
+      dreaming: false,
+      sharedMemory: false
     }
   };
   VALID_CLAUDE_MD_VALUES = new Set(["off", "project", "full"]);
@@ -21704,6 +21814,9 @@ config(en_default());
 // src/proxy/passthroughTools.ts
 var PASSTHROUGH_MCP_NAME = "oc";
 var PASSTHROUGH_MCP_PREFIX = `mcp__${PASSTHROUGH_MCP_NAME}__`;
+function passthroughMcpPrefix(serverName = PASSTHROUGH_MCP_NAME) {
+  return `mcp__${serverName}__`;
+}
 function repairTypeSlip(schema, value) {
   if (typeof value !== "string")
     return value;
@@ -21826,16 +21939,20 @@ function getAutoDeferThreshold() {
     return DEFAULT_DEFER_THRESHOLD;
   return parsed;
 }
-function createPassthroughMcpServer(tools, coreToolNames) {
+function autoDeferDecision(threshold, coreToolNames, toolCount) {
+  return !!(threshold > 0 && coreToolNames && coreToolNames.length > 0 && toolCount > threshold);
+}
+function createPassthroughMcpServer(tools, coreToolNames, serverName = PASSTHROUGH_MCP_NAME, pinnedAutoDefer) {
   const threshold = getAutoDeferThreshold();
-  const autoDefer = !!(threshold > 0 && coreToolNames && coreToolNames.length > 0 && tools.length > threshold);
-  const coreSet = autoDefer ? new Set(coreToolNames.map((n) => n.toLowerCase())) : undefined;
+  const autoDefer = pinnedAutoDefer ?? autoDeferDecision(threshold, coreToolNames, tools.length);
+  const coreSet = autoDefer && coreToolNames ? new Set(coreToolNames.map((n) => n.toLowerCase())) : undefined;
   const hasDeferredTools = tools.some((t) => t.defer_loading === true) || autoDefer;
   const sortedTools = [...tools].sort((a, b) => a.name.localeCompare(b.name));
+  const aliases = buildPassthroughToolAliases(sortedTools.map((tool) => tool.name), serverName);
   const definitions = sortedTools.map((passthroughTool) => {
     const alwaysLoad = hasDeferredTools && shouldAlwaysLoad(passthroughTool, coreSet);
     const defineTool = (shape) => ({
-      name: passthroughTool.name,
+      name: aliases.aliasByClientName.get(passthroughTool.name) ?? passthroughTool.name,
       description: passthroughTool.description || passthroughTool.name,
       inputSchema: shape,
       handler: async () => ({ content: [{ type: "text", text: "passthrough" }] }),
@@ -21849,11 +21966,15 @@ function createPassthroughMcpServer(tools, coreToolNames) {
       return defineTool(fallbackShape);
     }
   });
-  const server = createSdkMcpServer({ name: PASSTHROUGH_MCP_NAME, tools: definitions });
+  const server = createSdkMcpServer({ name: serverName, tools: definitions });
+  const prefix = passthroughMcpPrefix(serverName);
   return {
     server,
-    toolNames: sortedTools.map((tool) => `${PASSTHROUGH_MCP_PREFIX}${tool.name}`),
-    hasDeferredTools
+    serverName,
+    prefix,
+    toolNames: definitions.map((definition) => `${prefix}${definition.name}`),
+    hasDeferredTools,
+    clientNameByAlias: aliases.clientNameByAlias
   };
 }
 function shouldAlwaysLoad(tool, coreSet) {
@@ -21883,12 +22004,48 @@ function stableStringify(value) {
 function toolUseSignature(name, input) {
   return `${name}::${stableStringify(input ?? null)}`;
 }
-function stripMcpPrefix(toolName) {
-  if (toolName.startsWith(PASSTHROUGH_MCP_PREFIX)) {
-    return toolName.slice(PASSTHROUGH_MCP_PREFIX.length);
+function stripMcpPrefix(toolName, serverName = PASSTHROUGH_MCP_NAME) {
+  const prefix = passthroughMcpPrefix(serverName);
+  if (toolName.startsWith(prefix)) {
+    return toolName.slice(prefix.length);
   }
   return toolName;
 }
+function buildPassthroughToolAliases(names, serverName = PASSTHROUGH_MCP_NAME) {
+  const PREFIX = passthroughMcpPrefix(serverName);
+  const aliasByClientName = new Map;
+  const clientNameByAlias = new Map;
+  const ordered = [...names].sort((a, b) => a.localeCompare(b));
+  for (const name of ordered) {
+    if (name.startsWith(PREFIX))
+      continue;
+    aliasByClientName.set(name, name);
+    clientNameByAlias.set(name, name);
+  }
+  for (const name of ordered) {
+    if (!name.startsWith(PREFIX))
+      continue;
+    if (aliasByClientName.has(name))
+      continue;
+    let base = name;
+    while (base.startsWith(PREFIX)) {
+      base = base.slice(PREFIX.length);
+    }
+    if (!base)
+      base = "tool";
+    let alias = base;
+    let attempt = 2;
+    while (clientNameByAlias.has(alias))
+      alias = `${base}_${attempt++}`;
+    aliasByClientName.set(name, alias);
+    clientNameByAlias.set(alias, name);
+  }
+  return { aliasByClientName, clientNameByAlias };
+}
+function resolveClientToolName(sdkToolName, clientNameByAlias, serverName = PASSTHROUGH_MCP_NAME) {
+  const alias = stripMcpPrefix(sdkToolName, serverName);
+  return clientNameByAlias?.get(alias) ?? alias;
+}
 function toCamelCase(s) {
   return s.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
 }
@@ -21922,6 +22079,313 @@ function normalizeToolInput(input, clientSchema) {
   return repairCapturedObject(normalized, clientSchema.properties);
 }
 
+// src/proxy/session/processIncarnation.ts
+import { spawnSync } from "node:child_process";
+import { createHash as createHash2 } from "node:crypto";
+import { readFileSync, readlinkSync } from "node:fs";
+var PROCESS_INCARNATION_VERSION = 1;
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+var SHA256_PATTERN = /^[0-9a-f]{64}$/;
+var LINUX_START_PATTERN = /^[1-9][0-9]{0,31}$/;
+var WINDOWS_START_PATTERN = /^[1-9][0-9]{0,31}$/;
+var DARWIN_START_PATTERN = /^(Sun|Mon|Tue|Wed|Thu|Fri|Sat) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) [ 0-3][0-9] [0-2][0-9]:[0-5][0-9]:[0-6][0-9] [0-9]{4}$/;
+var PROBE_TIMEOUT_MS = 2000;
+var WINDOWS_PROBE_TIMEOUT_MS = 1e4;
+var cachedLocalBootIdentity;
+var cachedCurrentProcessIncarnation;
+function hashIdentity(value) {
+  return createHash2("sha256").update(value).digest("hex");
+}
+function isPositivePid(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+function validStartId(kind, value) {
+  if (typeof value !== "string")
+    return false;
+  if (kind === "linux-proc-start-ticks")
+    return LINUX_START_PATTERN.test(value);
+  if (kind === "darwin-ps-lstart")
+    return DARWIN_START_PATTERN.test(value);
+  if (kind === "windows-start-ticks")
+    return WINDOWS_START_PATTERN.test(value);
+  return false;
+}
+function parseProcessIncarnation(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return;
+  const identity = value;
+  if (identity.version !== PROCESS_INCARNATION_VERSION || !isPositivePid(identity.pid) || typeof identity.hostId !== "string" || !SHA256_PATTERN.test(identity.hostId) || typeof identity.bootId !== "string" || !UUID_PATTERN.test(identity.bootId) || typeof identity.startId !== "string" || !validStartId(identity.startIdKind, identity.startId))
+    return;
+  return {
+    version: PROCESS_INCARNATION_VERSION,
+    pid: identity.pid,
+    hostId: identity.hostId,
+    bootId: identity.bootId,
+    startId: identity.startId,
+    startIdKind: identity.startIdKind
+  };
+}
+function evaluateProcessIncarnation(owner, localBoot, observedStart) {
+  const parsedOwner = parseProcessIncarnation(owner);
+  if (!parsedOwner || !localBoot || !SHA256_PATTERN.test(localBoot.hostId) || !UUID_PATTERN.test(localBoot.bootId) || parsedOwner.hostId !== localBoot.hostId)
+    return "indeterminate";
+  if (parsedOwner.bootId !== localBoot.bootId)
+    return "dead";
+  if (!observedStart || observedStart.status === "indeterminate")
+    return "indeterminate";
+  if (observedStart.status === "missing")
+    return "dead";
+  if (!validStartId(observedStart.startIdKind, observedStart.startId) || observedStart.startIdKind !== parsedOwner.startIdKind)
+    return "indeterminate";
+  if (observedStart.startId !== parsedOwner.startId)
+    return "dead";
+  return parsedOwner.startIdKind === "linux-proc-start-ticks" ? "alive" : "indeterminate";
+}
+function normalizeUuid(raw2) {
+  const value = raw2.trim().toLowerCase();
+  return UUID_PATTERN.test(value) ? value : undefined;
+}
+function readFirst(paths) {
+  for (const path of paths) {
+    try {
+      const value = readFileSync(path, "utf8").trim();
+      if (value)
+        return value;
+    } catch {}
+  }
+  return;
+}
+function linuxLocalBootIdentity() {
+  const machineId = readFirst(["/etc/machine-id", "/var/lib/dbus/machine-id"]);
+  const bootId = normalizeUuid(readFileSync("/proc/sys/kernel/random/boot_id", "utf8"));
+  const pidNamespace = readlinkSync("/proc/self/ns/pid");
+  if (!machineId || !/^[0-9a-fA-F]{32}$/.test(machineId) || !bootId || !/^pid:\[[0-9]+\]$/.test(pidNamespace)) {
+    return;
+  }
+  return {
+    hostId: hashIdentity(`linux:${machineId.toLowerCase()}:${pidNamespace}`),
+    bootId
+  };
+}
+function runDarwin(command, args) {
+  const result = spawnSync(command, args, {
+    encoding: "utf8",
+    env: { ...process.env, LC_ALL: "C", LANG: "C", TZ: "UTC0" },
+    timeout: PROBE_TIMEOUT_MS,
+    maxBuffer: 1024 * 1024
+  });
+  if (result.error || result.status !== 0 || typeof result.stdout !== "string")
+    return;
+  return result.stdout;
+}
+function darwinLocalBootIdentity() {
+  const ioreg = runDarwin("/usr/sbin/ioreg", ["-rd1", "-c", "IOPlatformExpertDevice"]);
+  const boot = runDarwin("/usr/sbin/sysctl", ["-n", "kern.bootsessionuuid"]);
+  const machineMatch = ioreg?.match(/"IOPlatformUUID"\s*=\s*"([0-9A-Fa-f-]+)"/);
+  const machineId = machineMatch?.[1] ? normalizeUuid(machineMatch[1]) : undefined;
+  const bootId = boot ? normalizeUuid(boot) : undefined;
+  if (!machineId || !bootId)
+    return;
+  return {
+    hostId: hashIdentity(`darwin:${machineId}`),
+    bootId
+  };
+}
+function uuidFromIdentity(value) {
+  const hex3 = createHash2("sha256").update(value).digest("hex").slice(0, 32);
+  return `${hex3.slice(0, 8)}-${hex3.slice(8, 12)}-${hex3.slice(12, 16)}-${hex3.slice(16, 20)}-${hex3.slice(20)}`;
+}
+function runWindowsPowerShell(script) {
+  const result = spawnSync("powershell.exe", [
+    "-NoLogo",
+    "-NoProfile",
+    "-NonInteractive",
+    "-ExecutionPolicy",
+    "Bypass",
+    "-Command",
+    script
+  ], {
+    encoding: "utf8",
+    windowsHide: true,
+    timeout: WINDOWS_PROBE_TIMEOUT_MS,
+    maxBuffer: 1024 * 1024
+  });
+  return {
+    status: result.error ? null : result.status,
+    ...typeof result.stdout === "string" ? { stdout: result.stdout } : {}
+  };
+}
+function windowsLocalBootIdentity() {
+  const result = runWindowsPowerShell(String.raw`
+$ErrorActionPreference = 'Stop'
+$machine = (Get-ItemProperty -Path 'HKLM:\SOFTWARE\Microsoft\Cryptography' -Name MachineGuid).MachineGuid
+try { $boot = (Get-CimInstance Win32_OperatingSystem).LastBootUpTime }
+catch { $boot = (Get-WmiObject Win32_OperatingSystem).ConvertToDateTime((Get-WmiObject Win32_OperatingSystem).LastBootUpTime) }
+Write-Output $machine
+Write-Output $boot.ToUniversalTime().Ticks
+`);
+  if (result.status !== 0 || !result.stdout)
+    return;
+  const [machine, bootTicks] = result.stdout.trim().split(/\r?\n/).map((part) => part.trim());
+  if (!machine || !bootTicks || !WINDOWS_START_PATTERN.test(bootTicks))
+    return;
+  return {
+    hostId: hashIdentity(`windows:${machine.toLowerCase()}`),
+    bootId: uuidFromIdentity(`windows-boot:${machine.toLowerCase()}:${bootTicks}`)
+  };
+}
+function pinnedHostIdFor(pin) {
+  const trimmed = pin?.trim();
+  return trimmed ? hashIdentity(`pinned:${trimmed}`) : undefined;
+}
+function pinnedHostId() {
+  return pinnedHostIdFor(process.env.MERIDIAN_HOST_ID);
+}
+function getLocalBootIdentity() {
+  if (cachedLocalBootIdentity)
+    return cachedLocalBootIdentity;
+  try {
+    const identity = process.platform === "linux" ? linuxLocalBootIdentity() : process.platform === "darwin" ? darwinLocalBootIdentity() : process.platform === "win32" ? windowsLocalBootIdentity() : undefined;
+    const pinned = pinnedHostId();
+    const resolved = identity && pinned ? { ...identity, hostId: pinned } : identity;
+    if (resolved)
+      cachedLocalBootIdentity = resolved;
+    return resolved;
+  } catch {
+    return;
+  }
+}
+function bootIdentityHint(platform) {
+  if (platform === "linux") {
+    return "no readable /etc/machine-id or /var/lib/dbus/machine-id, or /proc is not mounted. " + "Distroless, scratch, chroot and gVisor images commonly lack machine-id: " + "generate one (`dbus-uuidgen > /etc/machine-id`) or bind-mount the host's.";
+  }
+  if (platform === "darwin") {
+    return "could not read the hardware UUID or boot time from the system profiler.";
+  }
+  if (platform === "win32") {
+    return "could not read the machine GUID or boot time from the registry.";
+  }
+  return `unsupported platform "${platform}" — boot identity is implemented for linux, darwin and win32 only.`;
+}
+function describeLocalBootIdentity() {
+  const platform = process.platform;
+  if (getLocalBootIdentity())
+    return { available: true, platform };
+  return { available: false, platform, hint: bootIdentityHint(platform) };
+}
+function pidPresence(pid) {
+  try {
+    process.kill(pid, 0);
+    return "present";
+  } catch (error51) {
+    const code = error51 instanceof Error && "code" in error51 ? error51.code : undefined;
+    return code === "ESRCH" ? "missing" : "indeterminate";
+  }
+}
+function parseLinuxProcStatStartId(raw2, expectedPid) {
+  const prefix = `${expectedPid} (`;
+  if (!raw2.startsWith(prefix))
+    return;
+  const commEnd = raw2.lastIndexOf(")");
+  if (commEnd < prefix.length || raw2[commEnd + 1] !== " ")
+    return;
+  const fieldsFromState = raw2.slice(commEnd + 2).trim().split(/\s+/);
+  const startId = fieldsFromState[19];
+  return startId && LINUX_START_PATTERN.test(startId) ? startId : undefined;
+}
+function linuxProcessStart(pid) {
+  let raw2;
+  try {
+    raw2 = readFileSync(`/proc/${pid}/stat`, "utf8");
+  } catch (error51) {
+    const code = error51 instanceof Error && "code" in error51 ? error51.code : undefined;
+    if (code === "ENOENT" || code === "ESRCH")
+      return { status: "missing" };
+    return { status: "indeterminate" };
+  }
+  const startId = parseLinuxProcStatStartId(raw2, pid);
+  if (startId)
+    return { status: "found", startId, startIdKind: "linux-proc-start-ticks" };
+  return pidPresence(pid) === "missing" ? { status: "missing" } : { status: "indeterminate" };
+}
+function darwinProcessStart(pid) {
+  const output = runDarwin("/bin/ps", ["-p", String(pid), "-o", "lstart="]);
+  if (output !== undefined) {
+    const startId = output.trimEnd().trimStart();
+    if (DARWIN_START_PATTERN.test(startId)) {
+      return { status: "found", startId, startIdKind: "darwin-ps-lstart" };
+    }
+  }
+  return pidPresence(pid) === "missing" ? { status: "missing" } : { status: "indeterminate" };
+}
+function windowsProcessStart(pid) {
+  const result = runWindowsPowerShell(String.raw`
+$ErrorActionPreference = 'Stop'
+try {
+  $process = Get-Process -Id ${pid} -ErrorAction Stop
+  Write-Output $process.StartTime.ToUniversalTime().Ticks
+} catch [Microsoft.PowerShell.Commands.ProcessCommandException] {
+  exit 3
+} catch {
+  exit 4
+}
+`);
+  const startId = result.stdout?.trim();
+  if (result.status === 0 && startId && WINDOWS_START_PATTERN.test(startId)) {
+    return { status: "found", startId, startIdKind: "windows-start-ticks" };
+  }
+  if (result.status === 3)
+    return { status: "missing" };
+  return pidPresence(pid) === "missing" ? { status: "missing" } : { status: "indeterminate" };
+}
+function observeProcessStart(pid) {
+  if (process.platform === "linux")
+    return linuxProcessStart(pid);
+  if (process.platform === "darwin")
+    return darwinProcessStart(pid);
+  if (process.platform === "win32")
+    return windowsProcessStart(pid);
+  return { status: "indeterminate" };
+}
+function captureProcessIncarnation(pid = process.pid) {
+  if (!isPositivePid(pid))
+    return;
+  if (pid === process.pid && cachedCurrentProcessIncarnation) {
+    return { ...cachedCurrentProcessIncarnation };
+  }
+  const localBoot = getLocalBootIdentity();
+  if (!localBoot)
+    return;
+  const start = observeProcessStart(pid);
+  if (start.status !== "found")
+    return;
+  const identity = {
+    version: PROCESS_INCARNATION_VERSION,
+    pid,
+    ...localBoot,
+    startId: start.startId,
+    startIdKind: start.startIdKind
+  };
+  if (pid === process.pid)
+    cachedCurrentProcessIncarnation = identity;
+  return { ...identity };
+}
+function probeProcessIncarnation(owner) {
+  const parsed = parseProcessIncarnation(owner);
+  if (!parsed)
+    return "indeterminate";
+  const localBoot = getLocalBootIdentity();
+  if (!localBoot || parsed.hostId !== localBoot.hostId)
+    return "indeterminate";
+  if (parsed.bootId !== localBoot.bootId) {
+    return evaluateProcessIncarnation(parsed, localBoot, undefined);
+  }
+  return evaluateProcessIncarnation(parsed, localBoot, observeProcessStart(parsed.pid));
+}
+function processIncarnationIsDead(owner) {
+  return probeProcessIncarnation(owner) === "dead";
+}
+
 // src/proxy/server.ts
 init_tools();
 
@@ -21931,7 +22395,7 @@ var INTERNAL_TOOLS = new Set(["ToolSearch", "StructuredOutput"]);
 function createEarlyStopTracker() {
   return { expected: new Set, resolved: new Set, fired: false };
 }
-function isClientForwardedToolUse(block) {
+function isClientForwardedToolUse(block, clientToolPrefix = CLIENT_TOOL_PREFIX) {
   const b = block;
   if (!b || b.type !== "tool_use")
     return false;
@@ -21941,26 +22405,26 @@ function isClientForwardedToolUse(block) {
     return false;
   if (INTERNAL_TOOLS.has(b.name))
     return false;
-  if (b.name.startsWith("mcp__") && !b.name.startsWith(CLIENT_TOOL_PREFIX))
+  if (b.name.startsWith("mcp__") && !b.name.startsWith(clientToolPrefix))
     return false;
   return true;
 }
-function noteAssistantContent(tracker, content) {
+function noteAssistantContent(tracker, content, clientToolPrefix = CLIENT_TOOL_PREFIX) {
   if (!Array.isArray(content))
     return;
   for (const block of content) {
-    if (isClientForwardedToolUse(block)) {
+    if (isClientForwardedToolUse(block, clientToolPrefix)) {
       tracker.expected.add(block.id);
     }
   }
 }
-function noteAssistantMessage(tracker, message) {
+function noteAssistantMessage(tracker, message, clientToolPrefix = CLIENT_TOOL_PREFIX) {
   const m = message;
   if (m?.type !== "assistant")
     return;
   const content = m.message?.content;
   const before = tracker.expected.size;
-  noteAssistantContent(tracker, content);
+  noteAssistantContent(tracker, content, clientToolPrefix);
   if (tracker.expected.size > before) {
     tracker.toolCallAssistantUuid = typeof m.uuid === "string" && m.uuid.length > 0 ? m.uuid : undefined;
   }
@@ -22342,7 +22806,7 @@ class MemoryDiagnosticLogStore {
 }
 var diagnosticLog = new MemoryDiagnosticLogStore;
 // src/telemetry/routes.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "node:fs";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
 import { resolve as resolve2, dirname as dirname2 } from "node:path";
 import { fileURLToPath } from "node:url";
 
@@ -22765,7 +23229,7 @@ timer = setInterval(refresh, 5000);
 
 // src/telemetry/routes.ts
 var _iconPath = resolve2(dirname2(fileURLToPath(import.meta.url)), "..", "..", "assets", "icon.svg");
-var _iconSvg = existsSync3(_iconPath) ? readFileSync2(_iconPath, "utf-8") : null;
+var _iconSvg = existsSync3(_iconPath) ? readFileSync3(_iconPath, "utf-8") : null;
 function createTelemetryRoutes(deps = {}) {
   const routes = new Hono2;
   routes.get("/", (c) => {
@@ -23159,7 +23623,9 @@ function createStores() {
     const dbPath = env("TELEMETRY_DB") ?? getDefaultDbPath();
     const retention = envInt("TELEMETRY_RETENTION_DAYS", 7);
     const stores = createSqliteStores2(dbPath, retention);
-    console.error(`[telemetry] SQLite persistence enabled: ${dbPath} (${retention}d retention)`);
+    if (!envBool("QUIET")) {
+      console.error(`[telemetry] SQLite persistence enabled: ${dbPath} (${retention}d retention)`);
+    }
     return { telemetry: stores.telemetry, diagnostics: stores.diagnostics };
   } catch {
     console.warn("[telemetry] MERIDIAN_TELEMETRY_PERSIST is set but libsql is not installed. Run: npm install libsql");
@@ -23201,9 +23667,14 @@ var BILLING_SIGNALS = [
   /^\s*(?:(?:error|api error|claude code returned an error result):\s*)*credit balance is too low[.!]?\s*$/m,
   /^\s*(?:(?:error|api error|claude code returned an error result|subprocess stderr):\s*)*your (?:group|organization|org)(?:'|’)s usage limit is set to \$\d/m
 ];
+var SUBSCRIPTION_ACCESS_DISABLED = /^\s*(?:(?:error|api error|claude code returned an error result|subprocess stderr):\s*|failed to authenticate\.\s*)*(?:\d{3} )?your (?:organization|org) has disabled claude subscription access/m;
 var HIT_YOUR_LIMIT = /hit your (?:[\w-]+ )?limit/;
 var HIT_YOUR_SPEND_LIMIT = /^\s*(?:(?:error|api error|claude code returned an error result|subprocess stderr):\s*)*you(?:'|’)ve hit your (?:[\w'’-]+ ){0,4}(?:spend|usage) limit/m;
-var REACHED_YOUR_TIER_LIMIT = /^[ \t]*(?:(?:error|api error|claude code returned an error result|subprocess stderr):[ \t]*)*you(?:'|’)ve reached your (?:claude )?(?:fable|mythos|opus|sonnet|haiku)(?: \d+(?:\.\d+)*)? limit(?:(?:[.!][ \t]+|[ \t]+)(?:(?:run[ \t]+)?\/usage-credits(?:[ \t]+to[ \t]+continue)?(?:[ \t]+or[ \t]+switch[ \t]+models[ \t]+with[ \t]+\/model)?|\/model[ \t]+to[ \t]+switch[ \t]+models)\.?|[.!]?)[ \t\r]*$/m;
+var REACHED_YOUR_TIER_LIMIT = /^[ \t]*(?:(?:error|api error|claude code returned an error result|subprocess stderr):[ \t]*)*(?:\d{3}[ \t]+)?you(?:'|’)ve reached your (?:claude )?(?:fable|mythos|opus|sonnet|haiku)(?: \d+(?:\.\d+)*)? limit(?:(?:[.!][ \t]+|[ \t]+)(?:(?:run[ \t]+)?\/usage-credits(?:[ \t]+to[ \t]+continue)?(?:[ \t]+or[ \t]+switch[ \t]+models[ \t]+with[ \t]+\/model)?|\/model[ \t]+to[ \t]+switch[ \t]+models|switch[ \t]+to[ \t]+another[ \t]+model(?:[ \t]+to[ \t]+continue)?)\.?|[.!]?)[ \t\r]*$/m;
+var OUTPUT_TOKEN_MAXIMUM = /response exceeded the \d+ output token maximum/i;
+function isOutputTokenCapExceeded(message) {
+  return typeof message === "string" && OUTPUT_TOKEN_MAXIMUM.test(message);
+}
 var OUT_OF_USAGE_CREDITS = /^\s*(?:(?:error|api error|claude code returned an error result):\s*)*you(?:'|’)re out of usage credits(?:[.!]\s*)?(?:\/model to switch models\.?)?\s*$/;
 var HTTP_401 = /(?:^|[^0-9a-f])401(?![0-9a-f]|:\d)/;
 var HTTP_429 = /(?:^|[^0-9a-f])429(?![0-9a-f]|:\d)/;
@@ -23225,6 +23696,13 @@ function classifyError(errMsg, model) {
       message: "Claude OAuth token has expired and could not be refreshed automatically. Run 'claude login' in your terminal to re-authenticate."
     };
   }
+  if (SUBSCRIPTION_ACCESS_DISABLED.test(lower)) {
+    return {
+      status: 402,
+      type: "billing_error",
+      message: "This account's organization has disabled Claude subscription access for Claude Code. Ask the organization admin to re-enable it, or serve this request from an API-key profile — an identical retry on this account fails the same way."
+    };
+  }
   if (HTTP_401.test(lower) || lower.includes("authentication") || lower.includes("invalid auth") || lower.includes("credentials")) {
     return {
       status: 401,
@@ -24413,8 +24891,146 @@ function buildModelList(extendedContextIncluded, now = Math.floor(Date.now() / 1
 
 // src/proxy/server.ts
 init_jcode();
+init_claudecode();
 
 // src/proxy/openaiResponses.ts
+import { createHash as createHash4 } from "node:crypto";
+var PASSTHROUGH_PREFIX_LENGTH = "mcp__oc__".length;
+var RESPONSES_TOOL_ALIAS_MAX = 64 - PASSTHROUGH_PREFIX_LENGTH;
+function responsesToolAlias(namespace, name) {
+  const raw2 = namespace ? `${namespace}__${name}` : name;
+  const safe = raw2.replace(/[^A-Za-z0-9_-]/g, "_");
+  if (safe.length <= RESPONSES_TOOL_ALIAS_MAX)
+    return safe;
+  const digest = createHash4("sha256").update(raw2).digest("hex").slice(0, 8);
+  return `${safe.slice(0, RESPONSES_TOOL_ALIAS_MAX - digest.length - 1)}_${digest}`;
+}
+function buildResponsesToolAliases(tools) {
+  const aliases = new Map;
+  for (const tool of tools ?? []) {
+    if (tool.type === "custom") {
+      aliases.set(responsesToolAlias(undefined, tool.name), { name: tool.name, kind: "custom" });
+    } else if (tool.type === "namespace") {
+      for (const nested of tool.tools ?? []) {
+        if (nested.type !== "function" && nested.type !== "custom")
+          continue;
+        aliases.set(responsesToolAlias(tool.name, nested.name), {
+          namespace: tool.name,
+          name: nested.name,
+          kind: nested.type
+        });
+      }
+    }
+  }
+  return aliases;
+}
+var CUSTOM_TOOL_INPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    input: { type: "string", description: "The complete freeform payload, exactly as the tool's format requires." }
+  },
+  required: ["input"],
+  additionalProperties: false
+};
+function customToolDescription(tool) {
+  const parts = [tool.description ?? "", "Freeform tool: put the entire payload in the `input` string; do not wrap it in JSON."];
+  const format = tool.format && typeof tool.format === "object" ? tool.format : undefined;
+  if (typeof format?.definition === "string") {
+    parts.push(`Input grammar${typeof format.syntax === "string" ? ` (${format.syntax})` : ""}:
+${format.definition}`);
+  }
+  return parts.filter((s) => s.length > 0).join(`
+
+`);
+}
+function translateResponsesTools(tools) {
+  const out = [];
+  const push = (namespace, tool) => {
+    if (tool.type === "function") {
+      out.push({
+        name: namespace ? responsesToolAlias(namespace, tool.name) : tool.name,
+        description: namespace ? `[${namespace}] ${tool.description ?? ""}`.trimEnd() : tool.description ?? "",
+        input_schema: tool.parameters ?? { type: "object", properties: {} }
+      });
+    } else if (tool.type === "custom") {
+      out.push({
+        name: responsesToolAlias(namespace, tool.name),
+        description: customToolDescription(tool),
+        input_schema: CUSTOM_TOOL_INPUT_SCHEMA
+      });
+    }
+  };
+  for (const tool of tools) {
+    if (tool.type === "namespace") {
+      for (const nested of tool.tools ?? [])
+        push(tool.name, nested);
+    } else {
+      push(undefined, tool);
+    }
+  }
+  return out;
+}
+function toolCallItem(ctx, id, callId, name, argsJson, status) {
+  const alias = ctx.toolAliases?.get(name);
+  const namespace = alias?.namespace ? { namespace: alias.namespace } : {};
+  if (alias?.kind === "custom") {
+    let input = argsJson;
+    try {
+      const parsed = JSON.parse(argsJson || "{}");
+      if (parsed && typeof parsed === "object" && typeof parsed.input === "string") {
+        input = parsed.input;
+      } else if (argsJson === "" || argsJson === "{}") {
+        input = "";
+      }
+    } catch {}
+    return { type: "custom_tool_call", id, call_id: callId, name: alias.name, ...namespace, input, status };
+  }
+  return { type: "function_call", id, call_id: callId, name: alias?.name ?? name, ...namespace, arguments: argsJson, status };
+}
+var CODEX_TURN_METADATA = "x-codex-turn-metadata";
+var CODEX_THREAD_SOURCE_MAX = 24;
+var CODEX_TURN_KIND = "turn";
+function nonEmptyString(value) {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function codexTag(value) {
+  const tag = value.toLowerCase().replace(/[^a-z0-9-]/g, "-").slice(0, CODEX_THREAD_SOURCE_MAX);
+  return tag.replace(/-/g, "") ? tag : undefined;
+}
+function parseCodexTurnMetadata(value) {
+  if (value && typeof value === "object")
+    return value;
+  const raw2 = nonEmptyString(value);
+  if (!raw2)
+    return;
+  try {
+    const parsed = JSON.parse(raw2);
+    return parsed && typeof parsed === "object" ? parsed : undefined;
+  } catch {
+    return;
+  }
+}
+function codexTurnMetadataFromBody(body) {
+  const metadata = body.client_metadata;
+  if (!metadata || typeof metadata !== "object")
+    return;
+  return metadata[CODEX_TURN_METADATA];
+}
+function resolveCodexThreadIdentity(body, metadataHeader) {
+  const metadata = parseCodexTurnMetadata(metadataHeader) ?? parseCodexTurnMetadata(codexTurnMetadataFromBody(body));
+  const identity = {};
+  const threadKey = nonEmptyString(metadata?.thread_id) ?? nonEmptyString(body.prompt_cache_key);
+  const kind = nonEmptyString(metadata?.request_kind);
+  const kindTag = kind && kind !== CODEX_TURN_KIND ? codexTag(kind) : undefined;
+  if (threadKey)
+    identity.sessionKey = kindTag ? `${threadKey}:${kindTag}` : threadKey;
+  const threadSource = nonEmptyString(metadata?.thread_source);
+  const sourceTag = threadSource && threadSource !== "user" ? codexTag(threadSource) : undefined;
+  const flow = kindTag ?? sourceTag;
+  if (flow)
+    identity.requestSource = `fork-codex-${flow}`;
+  return identity;
+}
 function itemDiscriminator(item) {
   if (typeof item !== "object" || item === null)
     return;
@@ -24449,6 +25065,28 @@ function partsToBlocks(content) {
   }
   return blocks;
 }
+function toolOutputToContent(output) {
+  if (output === undefined || output === null)
+    return "";
+  if (typeof output === "string")
+    return output;
+  if (!Array.isArray(output))
+    return typeof output === "object" ? JSON.stringify(output) : String(output);
+  const blocks = [];
+  for (const part of output) {
+    if (!part || typeof part !== "object")
+      continue;
+    if (typeof part.text === "string") {
+      blocks.push({ type: "text", text: part.text });
+    } else if (part.type === "input_image") {
+      const image = typeof part.image_url === "string" ? parseDataUrlImage(part.image_url) : null;
+      blocks.push(image ?? { type: "text", text: "[Unsupported input_image omitted: only data URLs are currently supported]" });
+    } else {
+      blocks.push({ type: "text", text: `[Unsupported ${String(part.type)} tool output part omitted]` });
+    }
+  }
+  return blocks.length > 0 ? blocks : "";
+}
 function mapToolChoice(tc) {
   if (tc === "auto")
     return { type: "auto" };
@@ -24476,21 +25114,36 @@ function translateResponsesToAnthropic(body) {
   const pushBlock = (role, block) => {
     const last = messages[messages.length - 1];
     if (last && last.role === role && Array.isArray(last.content)) {
-      last.content.push(block);
+      if (block.type === "tool_result") {
+        const firstText = last.content.findIndex((b) => b.type !== "tool_result");
+        if (firstText === -1)
+          last.content.push(block);
+        else
+          last.content.splice(firstText, 0, block);
+      } else {
+        last.content.push(block);
+      }
     } else {
       messages.push({ role, content: [block] });
     }
   };
+  let conversationStarted = false;
   for (const item of items) {
     switch (itemDiscriminator(item)) {
       case "message": {
         const msg = item;
         if (msg.role === "developer" || msg.role === "system") {
           const t = partsToText(msg.content);
-          if (t)
+          if (!t)
+            break;
+          if (!conversationStarted) {
             systemParts.push(t);
+            break;
+          }
+          pushBlock("user", { type: "text", text: t });
           break;
         }
+        conversationStarted = true;
         const role = msg.role === "assistant" ? "assistant" : "user";
         const imageBlocks = partsToBlocks(msg.content);
         if (imageBlocks) {
@@ -24504,6 +25157,7 @@ function translateResponsesToAnthropic(body) {
         break;
       }
       case "function_call": {
+        conversationStarted = true;
         const fc = item;
         let input = {};
         try {
@@ -24511,12 +25165,25 @@ function translateResponsesToAnthropic(body) {
         } catch {
           input = {};
         }
-        pushBlock("assistant", { type: "tool_use", id: fc.call_id, name: fc.name, input });
+        const name = fc.namespace ? responsesToolAlias(fc.namespace, fc.name) : fc.name;
+        pushBlock("assistant", { type: "tool_use", id: fc.call_id, name, input });
         break;
       }
       case "function_call_output": {
+        conversationStarted = true;
         const fo = item;
-        pushBlock("user", { type: "tool_result", tool_use_id: fo.call_id, content: fo.output });
+        pushBlock("user", { type: "tool_result", tool_use_id: fo.call_id, content: toolOutputToContent(fo.output) });
+        break;
+      }
+      case "custom_tool_call": {
+        const ct = item;
+        const name = responsesToolAlias(ct.namespace, ct.name);
+        pushBlock("assistant", { type: "tool_use", id: ct.call_id, name, input: { input: ct.input ?? "" } });
+        break;
+      }
+      case "custom_tool_call_output": {
+        const co = item;
+        pushBlock("user", { type: "tool_result", tool_use_id: co.call_id, content: toolOutputToContent(co.output) });
         break;
       }
       case "reasoning":
@@ -24536,11 +25203,7 @@ function translateResponsesToAnthropic(body) {
 
 `);
   if (Array.isArray(body.tools) && body.tools.length > 0) {
-    result.tools = body.tools.filter((t) => t.type === "function").map((t) => ({
-      name: t.name,
-      description: t.description ?? "",
-      input_schema: t.parameters ?? { type: "object", properties: {} }
-    }));
+    result.tools = translateResponsesTools(body.tools);
   }
   const tc = mapToolChoice(body.tool_choice);
   if (tc)
@@ -24582,14 +25245,8 @@ function translateAnthropicToResponses(res, ctx) {
     if (block.type === "text" && typeof block.text === "string") {
       textParts.push({ type: "output_text", text: block.text, annotations: [] });
     } else if (block.type === "tool_use") {
-      output.push({
-        type: "function_call",
-        id: `fc_${block.id}`,
-        call_id: block.id,
-        name: block.name,
-        arguments: JSON.stringify(block.input ?? {}),
-        status: "completed"
-      });
+      const callId = String(block.id);
+      output.push(toolCallItem(ctx, `fc_${callId}`, callId, String(block.name), JSON.stringify(block.input ?? {}), "completed"));
     }
   }
   if (textParts.length > 0) {
@@ -24686,10 +25343,13 @@ function createResponsesSseTranslator(ctx) {
         } else if (cb.type === "tool_use") {
           const oi = outputIndex++;
           const itemId = `fc_${cb.id}`;
-          blocks.set(idx, { kind: "tool", outputIndex: oi, itemId, text: "", args: "", callId: cb.id, name: cb.name });
+          const callId = String(cb.id ?? "");
+          const name = String(cb.name ?? "");
+          const custom2 = ctx.toolAliases?.get(name)?.kind === "custom";
+          blocks.set(idx, { kind: "tool", outputIndex: oi, itemId, text: "", args: "", callId, name, custom: custom2 });
           out.push(emit("response.output_item.added", {
             output_index: oi,
-            item: { type: "function_call", id: itemId, call_id: cb.id, name: cb.name, arguments: "", status: "in_progress" }
+            item: toolCallItem(ctx, itemId, callId, name, "", "in_progress")
           }));
         } else {
           blocks.set(idx, { kind: "skip", outputIndex: -1, itemId: "", text: "", args: "" });
@@ -24711,11 +25371,13 @@ function createResponsesSseTranslator(ctx) {
           }));
         } else if (st.kind === "tool" && event.delta?.type === "input_json_delta" && typeof event.delta.partial_json === "string") {
           st.args += event.delta.partial_json;
-          out.push(emit("response.function_call_arguments.delta", {
-            item_id: st.itemId,
-            output_index: st.outputIndex,
-            delta: event.delta.partial_json
-          }));
+          if (!st.custom) {
+            out.push(emit("response.function_call_arguments.delta", {
+              item_id: st.itemId,
+              output_index: st.outputIndex,
+              delta: event.delta.partial_json
+            }));
+          }
         }
         break;
       }
@@ -24747,19 +25409,14 @@ function createResponsesSseTranslator(ctx) {
           finalOutput.push(item);
           out.push(emit("response.output_item.done", { output_index: st.outputIndex, item }));
         } else if (st.kind === "tool") {
-          out.push(emit("response.function_call_arguments.done", {
-            item_id: st.itemId,
-            output_index: st.outputIndex,
-            arguments: st.args
-          }));
-          const item = {
-            type: "function_call",
-            id: st.itemId,
-            call_id: st.callId,
-            name: st.name,
-            arguments: st.args,
-            status: "completed"
-          };
+          if (!st.custom) {
+            out.push(emit("response.function_call_arguments.done", {
+              item_id: st.itemId,
+              output_index: st.outputIndex,
+              arguments: st.args
+            }));
+          }
+          const item = toolCallItem(ctx, st.itemId, st.callId ?? "", st.name ?? "", st.args, "completed");
           finalOutput.push(item);
           out.push(emit("response.output_item.done", { output_index: st.outputIndex, item }));
         }
@@ -27874,7 +28531,7 @@ class LRUCache {
 // node_modules/path-scurry/dist/esm/index.js
 import { posix, win32 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { lstatSync, readdir as readdirCB, readdirSync, readlinkSync, realpathSync as rps } from "fs";
+import { lstatSync, readdir as readdirCB, readdirSync, readlinkSync as readlinkSync2, realpathSync as rps } from "fs";
 import * as actualFS from "node:fs";
 import { lstat, readdir, readlink, realpath } from "node:fs/promises";
 
@@ -28545,7 +29202,7 @@ var defaultFS = {
   lstatSync,
   readdir: readdirCB,
   readdirSync,
-  readlinkSync,
+  readlinkSync: readlinkSync2,
   realpathSync,
   promises: {
     lstat,
@@ -31119,6 +31776,7 @@ function buildQueryOptions(ctx, abortController) {
     dreaming,
     sharedMemory,
     maxBudgetUsd,
+    maxOutputTokens,
     fallbackModel,
     sdkDebug,
     additionalDirectories
@@ -31146,7 +31804,7 @@ function buildQueryOptions(ctx, abortController) {
         disallowedTools: [...allBlockedTools],
         ...passthroughMcp ? {
           allowedTools: [...passthroughMcp.toolNames],
-          mcpServers: { [PASSTHROUGH_MCP_NAME]: passthroughMcp.server }
+          mcpServers: { [passthroughMcp.serverName]: passthroughMcp.server }
         } : {}
       } : {
         disallowedTools: [...allBlockedTools],
@@ -31165,6 +31823,7 @@ function buildQueryOptions(ctx, abortController) {
         ...QUIET_SUBPROCESS_ENV,
         ...sharedMemory ? stripConfigDir(cleanEnv) : cleanEnv,
         ENABLE_TOOL_SEARCH: hasDeferredTools ? "true" : "false",
+        ...maxOutputTokens && maxOutputTokens > 0 ? { CLAUDE_CODE_MAX_OUTPUT_TOKENS: String(Math.floor(maxOutputTokens)) } : {},
         ENABLE_CLAUDEAI_MCP_SERVERS: !passthrough && ctx.claudeAiConnectors === true ? "true" : "false",
         ...passthrough && process.env.MERIDIAN_SUPPRESS_SCRATCHPAD !== "0" ? { CLAUDE_CODE_SESSION_KIND: "bg" } : {},
         ...process.getuid?.() === 0 ? { IS_SANDBOX: "1" } : {},
@@ -31313,7 +31972,7 @@ var codexTransforms = [
     name: "codex-force-passthrough",
     adapters: ["codex"],
     onRequest(ctx) {
-      return { ...ctx, passthrough: true };
+      return { ...ctx, passthrough: true, coreToolNames: undefined };
     }
   }
 ];
@@ -31358,6 +32017,7 @@ var claudeCodeTransforms = [
 ];
 
 // src/proxy/transforms/registry.ts
+init_polytoken();
 var ADAPTER_TRANSFORMS = {
   opencode: openCodeTransforms,
   crush: crushTransforms,
@@ -31370,14 +32030,15 @@ var ADAPTER_TRANSFORMS = {
   "claude-code": claudeCodeTransforms,
   openai: openCodeTransforms,
   jcode: openCodeTransforms,
-  codex: [...openCodeTransforms, ...codexTransforms]
+  codex: [...openCodeTransforms, ...codexTransforms],
+  polytoken: polytokenTransforms
 };
 function getAdapterTransforms(adapterName) {
   return ADAPTER_TRANSFORMS[adapterName] ?? [];
 }
 
 // src/proxy/plugins/loader.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync4, existsSync as existsSync5 } from "fs";
+import { readdirSync as readdirSync2, readFileSync as readFileSync5, existsSync as existsSync5 } from "fs";
 import { join as join7, isAbsolute as isAbsolute3, extname } from "path";
 import { pathToFileURL } from "url";
 
@@ -31423,7 +32084,7 @@ function parsePluginConfig(configPath) {
   if (!existsSync5(configPath))
     return [];
   try {
-    const raw2 = readFileSync4(configPath, "utf-8");
+    const raw2 = readFileSync5(configPath, "utf-8");
     const parsed = JSON.parse(raw2);
     return Array.isArray(parsed.plugins) ? parsed.plugins : [];
   } catch {
@@ -31658,7 +32319,7 @@ function formatUsageSummary(usage) {
 
 // src/proxy/session/lineage.ts
 init_messages();
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 function normalizeContextUsage(usage) {
   const lastIteration = usage.iterations?.at(-1);
   return lastIteration ?? usage;
@@ -31712,7 +32373,7 @@ function semanticContent(content) {
   return hashableContentBlocks(content).map(semanticBlock);
 }
 function lineageDigest(domain2, value) {
-  return createHash3("sha256").update(JSON.stringify(["meridian-lineage-v2", domain2, value])).digest("hex").slice(0, 32);
+  return createHash5("sha256").update(JSON.stringify(["meridian-lineage-v2", domain2, value])).digest("hex").slice(0, 32);
 }
 function computeLineageHash(messages) {
   if (!messages || messages.length === 0)
@@ -31752,13 +32413,30 @@ function describeLineageMismatch(cached2, messages, precomputedIncomingHashes) {
   };
   if (index < 0)
     return base;
+  const storedBlocks = cached2.messageBlockHashes?.[index];
+  const incomingMessage = messages[index];
+  const incomingBlocks = incomingMessage ? computeMessageBlockHashes([incomingMessage])[0] : undefined;
   return {
     ...base,
     storedDigest: storedHashes[index],
     incomingDigest: incomingHashes[index],
-    incomingShape: messages[index] ? describeShape(messages[index]) : undefined,
-    previousDigest: index > 0 ? storedHashes[index - 1] : undefined
-  };
+    incomingShape: incomingMessage ? describeShape(incomingMessage) : undefined,
+    previousDigest: index > 0 ? storedHashes[index - 1] : undefined,
+    storedBlockCount: storedBlocks?.length,
+    incomingBlockCount: incomingBlocks?.length,
+    blockChange: classifyBlockChange(storedBlocks, incomingBlocks)
+  };
+}
+function classifyBlockChange(stored, incoming) {
+  if (!stored || !incoming)
+    return "unknown";
+  const isPrefix = (short, long) => short.every((hash2, i) => long[i] === hash2);
+  if (incoming.length > stored.length)
+    return isPrefix(stored, incoming) ? "appended" : "rewritten";
+  if (incoming.length < stored.length)
+    return isPrefix(incoming, stored) ? "dropped" : "rewritten";
+  const same = [...stored].sort().join() === [...incoming].sort().join();
+  return same ? "reordered" : "rewritten";
 }
 function formatLineageMismatch(mismatch) {
   if (mismatch.index < 0)
@@ -31766,7 +32444,24 @@ function formatLineageMismatch(mismatch) {
   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}`;
+  const blocks = mismatch.storedBlockCount !== undefined && mismatch.incomingBlockCount !== undefined ? `, stored ${mismatch.storedBlockCount} blocks -> incoming ${mismatch.incomingBlockCount} blocks` + (mismatch.blockChange && mismatch.blockChange !== "unknown" ? ` (${mismatch.blockChange})` : "") : ", stored block hashes unavailable (session cached before 1.61.0)";
+  return `first mismatch at index ${mismatch.index}${trailing}: ` + `stored=${short(mismatch.storedDigest)} incoming=${short(mismatch.incomingDigest)}, ` + `incoming now ${shape}${blocks}`;
+}
+function independentRequestCause(input) {
+  if (!input.hasSessionKey && input.forkSource)
+    return "fork-source";
+  if (!input.hasSessionKey && input.isSubagent)
+    return "subagent";
+  if (input.clientDrivenLoop)
+    return "headerless-tool-result";
+  if (!input.hasDurableKey)
+    return "no-cache-identity";
+  return;
+}
+function formatDivergence(result, cause) {
+  if (result.type !== "diverged")
+    return;
+  return result.reason === "independent-request" && cause ? `${result.reason}:${cause}` : result.reason;
 }
 function computeMessageHashes(messages) {
   if (!messages || messages.length === 0)
@@ -31941,7 +32636,7 @@ import {
   unlinkSync,
   writeFileSync as writeFileSync2
 } from "node:fs";
-import { createHash as createHash6, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash7, randomUUID as randomUUID2 } from "node:crypto";
 import { homedir as homedir7, hostname as hostname4 } from "node:os";
 import { basename, dirname as dirname6, isAbsolute as isAbsolute4, join as join8 } from "node:path";
 
@@ -32007,290 +32702,8 @@ function directoryRenameWasBlockedSync(error51, destination) {
 }
 
 // src/proxy/session/recoveryClaim.ts
-import { createHash as createHash5, randomUUID } from "node:crypto";
+import { createHash as createHash6, randomUUID } from "node:crypto";
 import { hostname as hostname3 } from "node:os";
-
-// src/proxy/session/processIncarnation.ts
-import { spawnSync } from "node:child_process";
-import { createHash as createHash4 } from "node:crypto";
-import { readFileSync as readFileSync5, readlinkSync as readlinkSync2 } from "node:fs";
-var PROCESS_INCARNATION_VERSION = 1;
-var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
-var SHA256_PATTERN = /^[0-9a-f]{64}$/;
-var LINUX_START_PATTERN = /^[1-9][0-9]{0,31}$/;
-var WINDOWS_START_PATTERN = /^[1-9][0-9]{0,31}$/;
-var DARWIN_START_PATTERN = /^(Sun|Mon|Tue|Wed|Thu|Fri|Sat) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) [ 0-3][0-9] [0-2][0-9]:[0-5][0-9]:[0-6][0-9] [0-9]{4}$/;
-var PROBE_TIMEOUT_MS = 2000;
-var WINDOWS_PROBE_TIMEOUT_MS = 1e4;
-var cachedLocalBootIdentity;
-var cachedCurrentProcessIncarnation;
-function hashIdentity(value) {
-  return createHash4("sha256").update(value).digest("hex");
-}
-function isPositivePid(value) {
-  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
-}
-function validStartId(kind, value) {
-  if (typeof value !== "string")
-    return false;
-  if (kind === "linux-proc-start-ticks")
-    return LINUX_START_PATTERN.test(value);
-  if (kind === "darwin-ps-lstart")
-    return DARWIN_START_PATTERN.test(value);
-  if (kind === "windows-start-ticks")
-    return WINDOWS_START_PATTERN.test(value);
-  return false;
-}
-function parseProcessIncarnation(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value))
-    return;
-  const identity = value;
-  if (identity.version !== PROCESS_INCARNATION_VERSION || !isPositivePid(identity.pid) || typeof identity.hostId !== "string" || !SHA256_PATTERN.test(identity.hostId) || typeof identity.bootId !== "string" || !UUID_PATTERN.test(identity.bootId) || typeof identity.startId !== "string" || !validStartId(identity.startIdKind, identity.startId))
-    return;
-  return {
-    version: PROCESS_INCARNATION_VERSION,
-    pid: identity.pid,
-    hostId: identity.hostId,
-    bootId: identity.bootId,
-    startId: identity.startId,
-    startIdKind: identity.startIdKind
-  };
-}
-function evaluateProcessIncarnation(owner, localBoot, observedStart) {
-  const parsedOwner = parseProcessIncarnation(owner);
-  if (!parsedOwner || !localBoot || !SHA256_PATTERN.test(localBoot.hostId) || !UUID_PATTERN.test(localBoot.bootId) || parsedOwner.hostId !== localBoot.hostId)
-    return "indeterminate";
-  if (parsedOwner.bootId !== localBoot.bootId)
-    return "dead";
-  if (!observedStart || observedStart.status === "indeterminate")
-    return "indeterminate";
-  if (observedStart.status === "missing")
-    return "dead";
-  if (!validStartId(observedStart.startIdKind, observedStart.startId) || observedStart.startIdKind !== parsedOwner.startIdKind)
-    return "indeterminate";
-  if (observedStart.startId !== parsedOwner.startId)
-    return "dead";
-  return parsedOwner.startIdKind === "linux-proc-start-ticks" ? "alive" : "indeterminate";
-}
-function normalizeUuid(raw2) {
-  const value = raw2.trim().toLowerCase();
-  return UUID_PATTERN.test(value) ? value : undefined;
-}
-function readFirst(paths) {
-  for (const path3 of paths) {
-    try {
-      const value = readFileSync5(path3, "utf8").trim();
-      if (value)
-        return value;
-    } catch {}
-  }
-  return;
-}
-function linuxLocalBootIdentity() {
-  const machineId = readFirst(["/etc/machine-id", "/var/lib/dbus/machine-id"]);
-  const bootId = normalizeUuid(readFileSync5("/proc/sys/kernel/random/boot_id", "utf8"));
-  const pidNamespace = readlinkSync2("/proc/self/ns/pid");
-  if (!machineId || !/^[0-9a-fA-F]{32}$/.test(machineId) || !bootId || !/^pid:\[[0-9]+\]$/.test(pidNamespace)) {
-    return;
-  }
-  return {
-    hostId: hashIdentity(`linux:${machineId.toLowerCase()}:${pidNamespace}`),
-    bootId
-  };
-}
-function runDarwin(command, args) {
-  const result = spawnSync(command, args, {
-    encoding: "utf8",
-    env: { ...process.env, LC_ALL: "C", LANG: "C", TZ: "UTC0" },
-    timeout: PROBE_TIMEOUT_MS,
-    maxBuffer: 1024 * 1024
-  });
-  if (result.error || result.status !== 0 || typeof result.stdout !== "string")
-    return;
-  return result.stdout;
-}
-function darwinLocalBootIdentity() {
-  const ioreg = runDarwin("/usr/sbin/ioreg", ["-rd1", "-c", "IOPlatformExpertDevice"]);
-  const boot = runDarwin("/usr/sbin/sysctl", ["-n", "kern.bootsessionuuid"]);
-  const machineMatch = ioreg?.match(/"IOPlatformUUID"\s*=\s*"([0-9A-Fa-f-]+)"/);
-  const machineId = machineMatch?.[1] ? normalizeUuid(machineMatch[1]) : undefined;
-  const bootId = boot ? normalizeUuid(boot) : undefined;
-  if (!machineId || !bootId)
-    return;
-  return {
-    hostId: hashIdentity(`darwin:${machineId}`),
-    bootId
-  };
-}
-function uuidFromIdentity(value) {
-  const hex3 = createHash4("sha256").update(value).digest("hex").slice(0, 32);
-  return `${hex3.slice(0, 8)}-${hex3.slice(8, 12)}-${hex3.slice(12, 16)}-${hex3.slice(16, 20)}-${hex3.slice(20)}`;
-}
-function runWindowsPowerShell(script) {
-  const result = spawnSync("powershell.exe", [
-    "-NoLogo",
-    "-NoProfile",
-    "-NonInteractive",
-    "-ExecutionPolicy",
-    "Bypass",
-    "-Command",
-    script
-  ], {
-    encoding: "utf8",
-    windowsHide: true,
-    timeout: WINDOWS_PROBE_TIMEOUT_MS,
-    maxBuffer: 1024 * 1024
-  });
-  return {
-    status: result.error ? null : result.status,
-    ...typeof result.stdout === "string" ? { stdout: result.stdout } : {}
-  };
-}
-function windowsLocalBootIdentity() {
-  const result = runWindowsPowerShell(String.raw`
-$ErrorActionPreference = 'Stop'
-$machine = (Get-ItemProperty -Path 'HKLM:\SOFTWARE\Microsoft\Cryptography' -Name MachineGuid).MachineGuid
-try { $boot = (Get-CimInstance Win32_OperatingSystem).LastBootUpTime }
-catch { $boot = (Get-WmiObject Win32_OperatingSystem).ConvertToDateTime((Get-WmiObject Win32_OperatingSystem).LastBootUpTime) }
-Write-Output $machine
-Write-Output $boot.ToUniversalTime().Ticks
-`);
-  if (result.status !== 0 || !result.stdout)
-    return;
-  const [machine, bootTicks] = result.stdout.trim().split(/\r?\n/).map((part) => part.trim());
-  if (!machine || !bootTicks || !WINDOWS_START_PATTERN.test(bootTicks))
-    return;
-  return {
-    hostId: hashIdentity(`windows:${machine.toLowerCase()}`),
-    bootId: uuidFromIdentity(`windows-boot:${machine.toLowerCase()}:${bootTicks}`)
-  };
-}
-function getLocalBootIdentity() {
-  if (cachedLocalBootIdentity)
-    return cachedLocalBootIdentity;
-  try {
-    const identity = process.platform === "linux" ? linuxLocalBootIdentity() : process.platform === "darwin" ? darwinLocalBootIdentity() : process.platform === "win32" ? windowsLocalBootIdentity() : undefined;
-    if (identity)
-      cachedLocalBootIdentity = identity;
-    return identity;
-  } catch {
-    return;
-  }
-}
-function pidPresence(pid) {
-  try {
-    process.kill(pid, 0);
-    return "present";
-  } catch (error51) {
-    const code = error51 instanceof Error && "code" in error51 ? error51.code : undefined;
-    return code === "ESRCH" ? "missing" : "indeterminate";
-  }
-}
-function parseLinuxProcStatStartId(raw2, expectedPid) {
-  const prefix = `${expectedPid} (`;
-  if (!raw2.startsWith(prefix))
-    return;
-  const commEnd = raw2.lastIndexOf(")");
-  if (commEnd < prefix.length || raw2[commEnd + 1] !== " ")
-    return;
-  const fieldsFromState = raw2.slice(commEnd + 2).trim().split(/\s+/);
-  const startId = fieldsFromState[19];
-  return startId && LINUX_START_PATTERN.test(startId) ? startId : undefined;
-}
-function linuxProcessStart(pid) {
-  let raw2;
-  try {
-    raw2 = readFileSync5(`/proc/${pid}/stat`, "utf8");
-  } catch (error51) {
-    const code = error51 instanceof Error && "code" in error51 ? error51.code : undefined;
-    if (code === "ENOENT" || code === "ESRCH")
-      return { status: "missing" };
-    return { status: "indeterminate" };
-  }
-  const startId = parseLinuxProcStatStartId(raw2, pid);
-  if (startId)
-    return { status: "found", startId, startIdKind: "linux-proc-start-ticks" };
-  return pidPresence(pid) === "missing" ? { status: "missing" } : { status: "indeterminate" };
-}
-function darwinProcessStart(pid) {
-  const output = runDarwin("/bin/ps", ["-p", String(pid), "-o", "lstart="]);
-  if (output !== undefined) {
-    const startId = output.trimEnd().trimStart();
-    if (DARWIN_START_PATTERN.test(startId)) {
-      return { status: "found", startId, startIdKind: "darwin-ps-lstart" };
-    }
-  }
-  return pidPresence(pid) === "missing" ? { status: "missing" } : { status: "indeterminate" };
-}
-function windowsProcessStart(pid) {
-  const result = runWindowsPowerShell(String.raw`
-$ErrorActionPreference = 'Stop'
-try {
-  $process = Get-Process -Id ${pid} -ErrorAction Stop
-  Write-Output $process.StartTime.ToUniversalTime().Ticks
-} catch [Microsoft.PowerShell.Commands.ProcessCommandException] {
-  exit 3
-} catch {
-  exit 4
-}
-`);
-  const startId = result.stdout?.trim();
-  if (result.status === 0 && startId && WINDOWS_START_PATTERN.test(startId)) {
-    return { status: "found", startId, startIdKind: "windows-start-ticks" };
-  }
-  if (result.status === 3)
-    return { status: "missing" };
-  return pidPresence(pid) === "missing" ? { status: "missing" } : { status: "indeterminate" };
-}
-function observeProcessStart(pid) {
-  if (process.platform === "linux")
-    return linuxProcessStart(pid);
-  if (process.platform === "darwin")
-    return darwinProcessStart(pid);
-  if (process.platform === "win32")
-    return windowsProcessStart(pid);
-  return { status: "indeterminate" };
-}
-function captureProcessIncarnation(pid = process.pid) {
-  if (!isPositivePid(pid))
-    return;
-  if (pid === process.pid && cachedCurrentProcessIncarnation) {
-    return { ...cachedCurrentProcessIncarnation };
-  }
-  const localBoot = getLocalBootIdentity();
-  if (!localBoot)
-    return;
-  const start = observeProcessStart(pid);
-  if (start.status !== "found")
-    return;
-  const identity = {
-    version: PROCESS_INCARNATION_VERSION,
-    pid,
-    ...localBoot,
-    startId: start.startId,
-    startIdKind: start.startIdKind
-  };
-  if (pid === process.pid)
-    cachedCurrentProcessIncarnation = identity;
-  return { ...identity };
-}
-function probeProcessIncarnation(owner) {
-  const parsed = parseProcessIncarnation(owner);
-  if (!parsed)
-    return "indeterminate";
-  const localBoot = getLocalBootIdentity();
-  if (!localBoot || parsed.hostId !== localBoot.hostId)
-    return "indeterminate";
-  if (parsed.bootId !== localBoot.bootId) {
-    return evaluateProcessIncarnation(parsed, localBoot, undefined);
-  }
-  return evaluateProcessIncarnation(parsed, localBoot, observeProcessStart(parsed.pid));
-}
-function processIncarnationIsDead(owner) {
-  return probeProcessIncarnation(owner) === "dead";
-}
-
-// src/proxy/session/recoveryClaim.ts
 var RECOVERY_CLAIM_VERSION = 2;
 function createRecoveryClaimOwner(generation) {
   if (!generation)
@@ -32336,11 +32749,11 @@ function recoveryClaimOwnerIsDead(owner, probe = processIncarnationIsDead) {
   return probe(owner.incarnation);
 }
 function getRecoveryClaimPath(lockPath, generation) {
-  const digest = createHash5("sha256").update(generation).digest("hex");
+  const digest = createHash6("sha256").update(generation).digest("hex");
   return `${lockPath}.recover-${digest}`;
 }
 function getRecoveryClaimTombstonePath(claimPath, claimToken) {
-  const digest = createHash5("sha256").update(claimToken).digest("hex");
+  const digest = createHash6("sha256").update(claimToken).digest("hex");
   return `${claimPath}.orphan-${digest}`;
 }
 
@@ -32349,7 +32762,7 @@ var STORE_META_KEY = "\x00meridian-session-store";
 var STORE_META_VERSION = 1;
 var PRIORITY_STORE_META_VERSION = 3;
 function keyDigest(key) {
-  return createHash6("sha256").update(key).digest("hex");
+  return createHash7("sha256").update(key).digest("hex");
 }
 function keySlot(key) {
   return keyDigest(key).slice(0, 4);
@@ -32358,7 +32771,7 @@ function absenceGeneration(key, meta3) {
   return `a:${keyDigest(key)}:${meta3.slots[keySlot(key)] ?? 0}`;
 }
 function getStoredSessionGeneration(session, key) {
-  const generationId = session.generationId ?? `legacy-${createHash6("sha256").update(JSON.stringify(session)).digest("hex")}`;
+  const generationId = session.generationId ?? `legacy-${createHash7("sha256").update(JSON.stringify(session)).digest("hex")}`;
   return `p:${keyDigest(key)}:${generationId}`;
 }
 function keyGeneration(key, session, meta3) {
@@ -33878,9 +34291,31 @@ function classifyLineage(state, messages, cacheKey2) {
   ${detail}` : "");
     console.error(`[PROXY] ${msg}`);
     diagnosticLog2.lineage(msg);
+  } else if (result.type === "diverged") {
+    const msg = `Session not resumable (key=${cacheKey2.slice(0, 8)}…): reason=${result.reason}, prefix overlap ${result.prefixOverlap || 0}/${state.messageCount}, incoming ${messages.length} msgs. Starting fresh replay.`;
+    console.error(`[PROXY] ${msg}`);
+    diagnosticLog2.lineage(msg);
   }
   return result;
 }
+var warnedDegradedFingerprint = false;
+function warnDegradedFingerprintOnce() {
+  if (warnedDegradedFingerprint)
+    return;
+  warnedDegradedFingerprint = true;
+  const msg = "[PROXY] Session fingerprint has no working directory, so it hashes only the opening " + "user message — two conversations in different directories that start with the same text " + "will share a session. The directory is read from the <env> block of the system prompt; a " + "plugin implementing experimental.chat.system.transform (for example opencode-scrub) may " + "have removed it. Send a session header (meridian setup) to key conversations explicitly.";
+  console.warn(msg);
+  diagnosticLog2.lineage(msg);
+}
+var warnedHeaderlessToolLoop = false;
+function warnHeaderlessToolLoopOnce(adapterName) {
+  if (warnedHeaderlessToolLoop)
+    return;
+  warnedHeaderlessToolLoop = true;
+  const msg = `[PROXY] Client-driven tool loop with no session identity (adapter=${adapterName}): ` + "the request ends in a tool_result and carries no session key, so this and every " + "following tool round starts a fresh SDK session. The conversation does not resume, " + "and the model sees none of its own earlier turns. This is correct for concurrent " + "headless workflow loops, which must not share one conversation fingerprint; an " + 'interactive client should send a session header instead — see "Session identity" ' + "in docs/configuration.md.";
+  console.warn(msg);
+  diagnosticLog2.lineage(msg);
+}
 function lookupSession(sessionId, messages, workingDirectory) {
   if (sessionId) {
     const shared = lookupSharedSessionResult(sessionId);
@@ -33901,6 +34336,8 @@ function lookupSession(sessionId, messages, workingDirectory) {
     }
     return result;
   }
+  if (!workingDirectory)
+    warnDegradedFingerprintOnce();
   const fp = getConversationFingerprint(messages, workingDirectory);
   if (fp) {
     const shared = lookupSharedSessionResult(fp);
@@ -34115,7 +34552,7 @@ class SessionTurnCoordinator {
 var processSessionTurns = new SessionTurnCoordinator;
 
 // src/proxy/session/crossProcessTurnCoordinator.ts
-import { createHash as createHash7, randomUUID as randomUUID3 } from "node:crypto";
+import { createHash as createHash8, randomUUID as randomUUID3 } from "node:crypto";
 import { hostname as hostname5 } from "node:os";
 import { basename as basename2, dirname as dirname7, join as join9 } from "node:path";
 import {
@@ -34167,7 +34604,7 @@ function heartbeatName(token) {
   return `heartbeat-${token}`;
 }
 function lockName(key) {
-  return `${createHash7("sha256").update(key).digest("hex")}.lock`;
+  return `${createHash8("sha256").update(key).digest("hex")}.lock`;
 }
 async function readOwner(lockPath) {
   let raw2;
@@ -34592,7 +35029,7 @@ class CrossProcessTurnCoordinator {
 }
 
 // src/proxy/sessionLifecycle.ts
-import { createHash as createHash8, randomUUID as randomUUID4 } from "node:crypto";
+import { createHash as createHash9, randomUUID as randomUUID4 } from "node:crypto";
 import { spawn } from "node:child_process";
 import { realpathSync as realpathSync2 } from "node:fs";
 import {
@@ -34637,7 +35074,7 @@ class SessionLifecycleBacklogError extends SessionLifecycleError {
 }
 function getTranscriptResourceKey(locator) {
   validateLocator(locator);
-  return createHash8("sha256").update(locator.configDir).update("\x00").update(locator.sessionId).digest("hex");
+  return createHash9("sha256").update(locator.configDir).update("\x00").update(locator.sessionId).digest("hex");
 }
 function physicalLocator(locator) {
   const { lifecycleGeneration: _generation, ...physical } = locator;
@@ -36400,6 +36837,7 @@ function createProxyServer(config2 = {}) {
   const sessionDiscoveredTools = new LRUMap(getMaxSessionsLimit());
   const sessionToolCache = new LRUMap(getMaxSessionsLimit());
   const sessionMcpCache = new LRUMap(getMaxSessionsLimit());
+  const sessionDeferPin = new LRUMap(getMaxSessionsLimit());
   const idleStalls = new IdleStallTracker(UPSTREAM_IDLE_MAX_CONSECUTIVE, getMaxSessionsLimit());
   const RESUME_REFUSAL_MAX_RETRIES = 3;
   const RESUME_REFUSAL_RETRY_DELAY_MS = parseInt(process.env.MERIDIAN_BUSY_RETRY_DELAY_MS ?? "500", 10);
@@ -37033,6 +37471,8 @@ data: ${JSON.stringify(lastError)}
           return textPrompt;
         };
         const body = options.body;
+        const rawMaxTokens = Number(body?.max_tokens);
+        const clientMaxOutputTokens = envBool("ENFORCE_MAX_TOKENS") && Number.isFinite(rawMaxTokens) && rawMaxTokens > 0 ? Math.floor(rawMaxTokens) : undefined;
         const idleRequestKey = idleStallRequestKey(body);
         const markPriorityAttemptExposure = (reason) => {
           const exposure = options.priorityAttemptExposure;
@@ -37199,7 +37639,7 @@ data: ${JSON.stringify(lastError)}
         resolvedProfileId = profile.id;
         const authStatus = await getClaudeAuthStatusAsync(profile.id !== "default" ? profile.id : undefined, Object.keys(profile.env).length > 0 ? profile.env : undefined);
         const requestSource = c.req.header("x-meridian-source")?.slice(0, 64) || undefined;
-        const declaredAgentMode = adapter.getAgentMode?.(c, body) ?? c.req.header("x-opencode-agent-mode") ?? null;
+        const declaredAgentMode = adapter.getAgentMode?.(c, body) ?? (adapter.baseName === "polytoken" || adapter.name === "polytoken" ? undefined : c.req.header("x-opencode-agent-mode")) ?? null;
         const isSubagentRequest = declaredAgentMode === "subagent" || requestSource?.startsWith("subagent-") === true;
         const agentMode = isSubagentRequest ? "subagent" : declaredAgentMode;
         const requestedModel = typeof body.model === "string" ? body.model : "sonnet";
@@ -37250,9 +37690,10 @@ data: ${JSON.stringify(lastError)}
           workingDirectory
         }), adapterBase);
         const stream3 = pipelineCtx.prefersStreaming !== undefined ? pipelineCtx.prefersStreaming : body.stream ?? false;
-        const effortHeader = c.req.header("x-opencode-effort");
-        const thinkingHeader = c.req.header("x-opencode-thinking");
-        const taskBudgetHeader = c.req.header("x-opencode-task-budget");
+        const isPolytokenBase = adapterBase === "polytoken";
+        const effortHeader = isPolytokenBase ? undefined : c.req.header("x-opencode-effort");
+        const thinkingHeader = isPolytokenBase ? undefined : c.req.header("x-opencode-thinking");
+        const taskBudgetHeader = isPolytokenBase ? undefined : c.req.header("x-opencode-task-budget");
         const rawBetaHeader = c.req.header("anthropic-beta");
         const betaFilter = filterBetasForProfile(rawBetaHeader, profile.type, getBetaPolicyFromEnv());
         if (betaFilter.stripped.length > 0) {
@@ -37361,11 +37802,19 @@ data: ${JSON.stringify(lastError)}
         const profileScopedCwd = profile.id !== "default" ? `${clientWorkingDirectory}::profile=${profile.id}` : clientWorkingDirectory;
         const lastMessage = Array.isArray(body.messages) ? body.messages[body.messages.length - 1] : undefined;
         const lastIsToolResult = Array.isArray(lastMessage?.content) && lastMessage.content.some((b) => b?.type === "tool_result");
-        const isClientDrivenLoop = adapterBase !== "claude-code" && !agentSessionId && lastIsToolResult;
-        let isIndependentSession = !agentSessionId && (requestSource?.startsWith("fork-") || isSubagentRequest) || isClientDrivenLoop || false;
+        const ownsToolLoopWithResume = adapterBase === "claude-code" || isClaudeCodeClient(c);
+        const isClientDrivenLoop = !ownsToolLoopWithResume && !agentSessionId && lastIsToolResult;
         const durableMappingKey = profileSessionId || getConversationFingerprint(lineageMessages, profileScopedCwd);
-        if (!durableMappingKey)
-          isIndependentSession = true;
+        const independentCause = independentRequestCause({
+          hasSessionKey: Boolean(agentSessionId),
+          forkSource: Boolean(requestSource?.startsWith("fork-")),
+          isSubagent: isSubagentRequest,
+          clientDrivenLoop: isClientDrivenLoop,
+          hasDurableKey: Boolean(durableMappingKey)
+        });
+        const isIndependentSession = independentCause !== undefined;
+        if (independentCause === "headerless-tool-result")
+          warnHeaderlessToolLoopOnce(adapter.name);
         const durableMappingAtTurn = durableMappingKey ? lookupSharedSessionResult(durableMappingKey) : { status: "missing" };
         if (durableMappingAtTurn.status === "error") {
           throw new Error(`Shared session store is unavailable: ${durableMappingAtTurn.error.message}`);
@@ -37399,7 +37848,7 @@ data: ${JSON.stringify(lastError)}
         const trailingSystemReminderOptions = adapterBase === "claude-code" ? { allowTrailingSystemReminder: true } : undefined;
         const durableCheckpointContinuation = durableCheckpointIds?.length && durableMappingAtTurn.status === "found" && matchesStoredLineagePrefix(durableMappingAtTurn.session, lineageMessages) ? coalesceCompleteToolResultContinuation((body.messages || []).slice(durableMappingAtTurn.session.messageCount), durableCheckpointIds, trailingSystemReminderOptions) : undefined;
         const advancesDurableCheckpoint = Boolean(durableCheckpointContinuation);
-        const passthrough = adapter.instancePassthrough !== undefined ? adapter.instancePassthrough : pipelineCtx.passthrough !== undefined ? pipelineCtx.passthrough : envBool("PASSTHROUGH");
+        const passthrough = adapterBase === "polytoken" ? true : adapter.instancePassthrough !== undefined ? adapter.instancePassthrough : pipelineCtx.passthrough !== undefined ? pipelineCtx.passthrough : envBool("PASSTHROUGH");
         if (advancesDurableCheckpoint && lineageResult.type !== "continuation" && lineageResult.type !== "compaction" && durableMappingAtTurn.status === "found") {
           const checkpointSession = getSessionByClaudeId(durableMappingAtTurn.session.claudeSessionId);
           if (checkpointSession) {
@@ -37525,10 +37974,11 @@ data: ${JSON.stringify(lastError)}
           return `${m.role}[${contentTypes}]`;
         }).join(" → ");
         const lineageType = lineageResult.type === "diverged" && !cachedSession ? "new" : lineageResult.type;
+        const divergedReason = formatDivergence(lineageResult, independentCause);
         const msgCount = Array.isArray(body.messages) ? body.messages.length : 0;
         const toolCount = body.tools?.length ?? 0;
         const sdkSnapshot = sdkSemaphore.snapshot;
-        const requestLogLine = `${requestMeta.requestId} adapter=${adapter.name}${requestSource ? ` source=${requestSource}` : ""}${profile.id !== "default" ? ` profile=${profile.id}${routingMode === "sticky" ? "(sticky)" : options.forcedProfileId ? "(priority)" : ""}` : ""} model=${model} stream=${stream3} tools=${toolCount} lineage=${lineageType} session=${resumeSessionId?.slice(0, 8) || "new"}${isUndo && undoRollbackUuid ? ` rollback=${undoRollbackUuid.slice(0, 8)}` : ""}${agentMode ? ` agent=${agentMode}` : ""} sdkActive=${sdkSnapshot.active}/${sdkSnapshot.limit} sdkQueued=${sdkSnapshot.queued} sessionWait=${requestMeta.sessionQueueWaitMs}ms msgCount=${msgCount}`;
+        const requestLogLine = `${requestMeta.requestId} adapter=${adapter.name}${requestSource ? ` source=${requestSource}` : ""}${profile.id !== "default" ? ` profile=${profile.id}${routingMode === "sticky" ? "(sticky)" : options.forcedProfileId ? "(priority)" : ""}` : ""} model=${model} stream=${stream3} tools=${toolCount} lineage=${lineageType} session=${resumeSessionId?.slice(0, 8) || "new"}${isUndo && undoRollbackUuid ? ` rollback=${undoRollbackUuid.slice(0, 8)}` : ""}${divergedReason ? ` diverged=${divergedReason}` : ""}${agentMode ? ` agent=${agentMode}` : ""} sdkActive=${sdkSnapshot.active}/${sdkSnapshot.limit} sdkQueued=${sdkSnapshot.queued} sessionWait=${requestMeta.sessionQueueWaitMs}ms msgCount=${msgCount}`;
         plog(`[PROXY] ${requestLogLine} msgs=${msgSummary}`);
         diagnosticLog2.session(`${requestLogLine}`, requestMeta.requestId);
         if (lineageResult.type === "diverged" && profileSessionId && !isIndependentSession) {
@@ -37775,13 +38225,22 @@ data: ${JSON.stringify(lastError)}
             plog(`[PROXY] ${requestMeta.requestId} tools_restored: client sent 0 tools but continued branch had ${cached2.tools.length} — reusing cached tools to preserve prompt cache`);
           }
         }
+        const passthroughMcpName = adapter.getPassthroughMcpName?.() ?? PASSTHROUGH_MCP_NAME;
+        const clientToolPrefix = passthroughMcpPrefix(passthroughMcpName);
         if (passthrough && requestTools.length > 0) {
           const toolSetKey = computeToolSetKey(requestTools);
           const cachedMcp = profileSessionId ? sessionMcpCache.get(profileSessionId) : undefined;
+          const coreNamesForDefer = pipelineCtx.coreToolNames ? [...pipelineCtx.coreToolNames] : undefined;
+          const pinnedDefer = profileSessionId ? sessionDeferPin.get(profileSessionId) : undefined;
+          const liveDefer = autoDeferDecision(getAutoDeferThreshold(), coreNamesForDefer, requestTools.length);
+          if (pinnedDefer !== undefined && pinnedDefer !== liveDefer) {
+            plog(`[PROXY] ${requestMeta.requestId} defer_flip suppressed: session pinned autoDefer=${pinnedDefer}, live tool count ${requestTools.length} would give ${liveDefer}`);
+            claudeLog("passthrough.defer_flip_suppressed", { pinned: pinnedDefer, live: liveDefer, toolCount: requestTools.length });
+          }
           if (cachedMcp && cachedMcp.key === toolSetKey) {
             passthroughMcp = cachedMcp.mcp;
           } else {
-            passthroughMcp = createPassthroughMcpServer(requestTools, pipelineCtx.coreToolNames ? [...pipelineCtx.coreToolNames] : undefined);
+            passthroughMcp = createPassthroughMcpServer(requestTools, coreNamesForDefer, passthroughMcpName, pinnedDefer);
             if (profileSessionId) {
               sessionMcpCache.set(profileSessionId, { key: toolSetKey, mcp: passthroughMcp });
               if (cachedMcp) {
@@ -37789,6 +38248,9 @@ data: ${JSON.stringify(lastError)}
               }
             }
           }
+          if (profileSessionId && !sessionDeferPin.has(profileSessionId)) {
+            sessionDeferPin.set(profileSessionId, passthroughMcp.hasDeferredTools);
+          }
         }
         const hasDeferredTools = passthroughMcp?.hasDeferredTools ?? false;
         const coreNames = pipelineCtx.coreToolNames ? [...pipelineCtx.coreToolNames] : undefined;
@@ -37821,13 +38283,13 @@ data: ${JSON.stringify(lastError)}
                 return {};
               }
               markPriorityAttemptExposure("tool_use");
-              const toolName = stripMcpPrefix(input.tool_name);
+              const toolName = resolveClientToolName(input.tool_name, passthroughMcp?.clientNameByAlias, passthroughMcpName);
               if (hasDeferredTools && coreSet && !coreSet.has(toolName.toLowerCase())) {
                 discoveredTools.add(toolName);
               }
               const clientTool = requestTools.find((t) => t.name === toolName);
               let toolInput = normalizeToolInput(input.tool_input, clientTool?.input_schema);
-              if (toolName.toLowerCase() === "task" && toolInput?.subagent_type && typeof toolInput.subagent_type === "string") {
+              if (adapterBase !== "polytoken" && toolName.toLowerCase() === "task" && toolInput?.subagent_type && typeof toolInput.subagent_type === "string") {
                 toolInput = { ...toolInput, subagent_type: resolveAgentAlias(toolInput.subagent_type, validAgentNames) };
               }
               const signature = toolUseSignature(toolName, toolInput);
@@ -38003,6 +38465,7 @@ data: ${JSON.stringify(lastError)}
                     webFetchPreflight: sdkFeatures.webFetchPreflight,
                     claudeAiConnectors: sdkFeatures.claudeAiConnectors,
                     maxBudgetUsd: sdkFeatures.maxBudgetUsd,
+                    maxOutputTokens: clientMaxOutputTokens,
                     fallbackModel: sdkFeatures.fallbackModel,
                     sdkDebug: sdkFeatures.sdkDebug,
                     additionalDirectories: sdkFeatures.additionalDirectories ? sdkFeatures.additionalDirectories.split(",").map((d) => d.trim()).filter(Boolean) : undefined,
@@ -38102,6 +38565,7 @@ data: ${JSON.stringify(lastError)}
                       webFetchPreflight: sdkFeatures.webFetchPreflight,
                       claudeAiConnectors: sdkFeatures.claudeAiConnectors,
                       maxBudgetUsd: sdkFeatures.maxBudgetUsd,
+                      maxOutputTokens: clientMaxOutputTokens,
                       fallbackModel: sdkFeatures.fallbackModel,
                       sdkDebug: sdkFeatures.sdkDebug,
                       additionalDirectories: sdkFeatures.additionalDirectories ? sdkFeatures.additionalDirectories.split(",").map((d) => d.trim()).filter(Boolean) : undefined,
@@ -38180,6 +38644,7 @@ data: ${JSON.stringify(lastError)}
                       webFetchPreflight: sdkFeatures.webFetchPreflight,
                       claudeAiConnectors: sdkFeatures.claudeAiConnectors,
                       maxBudgetUsd: sdkFeatures.maxBudgetUsd,
+                      maxOutputTokens: clientMaxOutputTokens,
                       fallbackModel: sdkFeatures.fallbackModel,
                       sdkDebug: sdkFeatures.sdkDebug,
                       additionalDirectories: sdkFeatures.additionalDirectories ? sdkFeatures.additionalDirectories.split(",").map((d) => d.trim()).filter(Boolean) : undefined,
@@ -38251,7 +38716,7 @@ data: ${JSON.stringify(lastError)}
               let assistantAddedForwardedCall = false;
               if (passthrough && message.type === "assistant" && !earlyStopFired) {
                 const expectedBefore = earlyStop.expected.size;
-                noteAssistantMessage(earlyStop, message);
+                noteAssistantMessage(earlyStop, message, clientToolPrefix);
                 assistantAddedForwardedCall = earlyStop.expected.size > expectedBefore;
               } else if (passthrough && message.type === "user" && !earlyStopFired) {
                 noteUserContent(earlyStop, message.message?.content);
@@ -38284,7 +38749,7 @@ data: ${JSON.stringify(lastError)}
                   turnGenerating = true;
                 } else if (passthrough && eventType === "content_block_start") {
                   const block = event.content_block;
-                  if (isClientForwardedToolUse(block))
+                  if (isClientForwardedToolUse(block, clientToolPrefix))
                     streamedToolUseIds.add(block.id);
                 }
               }
@@ -38330,7 +38795,7 @@ data: ${JSON.stringify(lastError)}
                       continue;
                     }
                     if (passthrough && b.type === "tool_use" && typeof b.name === "string") {
-                      b.name = stripMcpPrefix(b.name);
+                      b.name = resolveClientToolName(b.name, passthroughMcp?.clientNameByAlias, passthroughMcpName);
                     }
                     contentBlocks.push(b);
                   }
@@ -38424,6 +38889,16 @@ Subprocess stderr: ${stderrOutput}`;
               });
               if (lastUsage)
                 logUsage(requestMeta.requestId, lastUsage);
+            } else if (clientMaxOutputTokens && isOutputTokenCapExceeded(error51 instanceof Error ? error51.message : String(error51 ?? ""))) {
+              lastStopReason = "max_tokens";
+              claudeLog("upstream.output_cap_truncated", {
+                mode: "non_stream",
+                cap: clientMaxOutputTokens,
+                blocks: contentBlocks.length
+              });
+              plog(`[PROXY] ${requestMeta.requestId} output capped at client max_tokens=${clientMaxOutputTokens} — reporting stop_reason=max_tokens`);
+              if (lastUsage)
+                logUsage(requestMeta.requestId, lastUsage);
             } else if (passthrough && sdkTerm.reason === "max_turns" && hasTruncatableText(contentBlocks)) {
               lastStopReason = "max_tokens";
               claudeLog("passthrough.capped_turn_truncated", {
@@ -38726,7 +39201,7 @@ data: ${JSON.stringify({
                 try {
                   const clientTool = requestTools.find((tool2) => tool2.name === buffered.name);
                   const parsed = normalizeToolInput(JSON.parse(buffered.json), clientTool?.input_schema);
-                  if (buffered.name.toLowerCase() === "task" && typeof parsed?.subagent_type === "string") {
+                  if (adapterBase !== "polytoken" && buffered.name.toLowerCase() === "task" && typeof parsed?.subagent_type === "string") {
                     parsed.subagent_type = resolveAgentAlias(parsed.subagent_type, validAgentNames);
                   }
                   fixed = JSON.stringify(parsed);
@@ -38831,6 +39306,7 @@ data: ${JSON.stringify({ type: "content_block_stop", index: idx })}
                         webFetchPreflight: sdkFeatures.webFetchPreflight,
                         claudeAiConnectors: sdkFeatures.claudeAiConnectors,
                         maxBudgetUsd: sdkFeatures.maxBudgetUsd,
+                        maxOutputTokens: clientMaxOutputTokens,
                         fallbackModel: sdkFeatures.fallbackModel,
                         sdkDebug: sdkFeatures.sdkDebug,
                         additionalDirectories: sdkFeatures.additionalDirectories ? sdkFeatures.additionalDirectories.split(",").map((d) => d.trim()).filter(Boolean) : undefined,
@@ -38929,6 +39405,7 @@ data: ${JSON.stringify({ type: "content_block_stop", index: idx })}
                           webFetchPreflight: sdkFeatures.webFetchPreflight,
                           claudeAiConnectors: sdkFeatures.claudeAiConnectors,
                           maxBudgetUsd: sdkFeatures.maxBudgetUsd,
+                          maxOutputTokens: clientMaxOutputTokens,
                           fallbackModel: sdkFeatures.fallbackModel,
                           sdkDebug: sdkFeatures.sdkDebug,
                           additionalDirectories: sdkFeatures.additionalDirectories ? sdkFeatures.additionalDirectories.split(",").map((d) => d.trim()).filter(Boolean) : undefined,
@@ -39007,6 +39484,7 @@ data: ${JSON.stringify({ type: "content_block_stop", index: idx })}
                           webFetchPreflight: sdkFeatures.webFetchPreflight,
                           claudeAiConnectors: sdkFeatures.claudeAiConnectors,
                           maxBudgetUsd: sdkFeatures.maxBudgetUsd,
+                          maxOutputTokens: clientMaxOutputTokens,
                           fallbackModel: sdkFeatures.fallbackModel,
                           sdkDebug: sdkFeatures.sdkDebug,
                           additionalDirectories: sdkFeatures.additionalDirectories ? sdkFeatures.additionalDirectories.split(",").map((d) => d.trim()).filter(Boolean) : undefined,
@@ -39111,7 +39589,7 @@ data: ${JSON.stringify({ type: "content_block_stop", index: idx })}
                     let assistantAddedForwardedCall = false;
                     if (earlyStopEnabled && message.type === "assistant" && !earlyStopFired) {
                       const expectedBefore = earlyStop.expected.size;
-                      noteAssistantMessage(earlyStop, message);
+                      noteAssistantMessage(earlyStop, message, clientToolPrefix);
                       assistantAddedForwardedCall = earlyStop.expected.size > expectedBefore;
                     } else if (earlyStopEnabled && message.type === "user" && !earlyStopFired) {
                       noteUserContent(earlyStop, message.message?.content);
@@ -39227,8 +39705,8 @@ data: ${JSON.stringify({ type: "content_block_stop", index: idx })}
                               skipBlockIndices.add(eventIndex);
                             continue;
                           }
-                          if (passthrough && block.name.startsWith(PASSTHROUGH_MCP_PREFIX)) {
-                            block.name = stripMcpPrefix(block.name);
+                          if (passthrough && block.name.startsWith(clientToolPrefix)) {
+                            block.name = resolveClientToolName(block.name, passthroughMcp?.clientNameByAlias, passthroughMcpName);
                             if (block.id)
                               streamedToolUseIds.add(block.id);
                           } else if (block.name.startsWith("mcp__")) {
@@ -39236,6 +39714,7 @@ data: ${JSON.stringify({ type: "content_block_stop", index: idx })}
                               skipBlockIndices.add(eventIndex);
                             continue;
                           } else if (passthrough && block.id) {
+                            block.name = resolveClientToolName(block.name, passthroughMcp?.clientNameByAlias, passthroughMcpName);
                             streamedToolUseIds.add(block.id);
                           }
                           if (passthrough && eventIndex !== undefined) {
@@ -39606,7 +40085,7 @@ data: ${JSON.stringify({
                           recoverySessionId = recoveryMessage.session_id;
                         }
                         if (recoveryMessage.type === "assistant") {
-                          noteAssistantMessage(recoveryEarlyStop, recoveryMessage);
+                          noteAssistantMessage(recoveryEarlyStop, recoveryMessage, clientToolPrefix);
                         } else if (recoveryMessage.type === "user") {
                           noteUserContent(recoveryEarlyStop, recoveryMessage.message?.content);
                         }
@@ -39619,7 +40098,7 @@ data: ${JSON.stringify({
                           releaseHeldDenies(`silent_recovery_${recoveryEvent.type}`);
                         if (recoveryEvent.type === "message_start")
                           turnGenerating = true;
-                        if (recoveryEvent.type === "content_block_start" && isClientForwardedToolUse(recoveryEvent.content_block)) {
+                        if (recoveryEvent.type === "content_block_start" && isClientForwardedToolUse(recoveryEvent.content_block, clientToolPrefix)) {
                           recoveryStreamedToolUseIds.add(recoveryEvent.content_block.id);
                         }
                         const lifted = recoveryLifter.lift(event.event);
@@ -40140,7 +40619,8 @@ data: {"type":"message_stop"}
                   }
                   return;
                 }
-                if (passthrough && sdkTerm.reason === "max_turns" && capturedToolUses.length === 0 && streamedToolUseIds.size === 0 && messageStartEmitted && textCharsForwarded > 0) {
+                const outputCapTruncated = Boolean(clientMaxOutputTokens) && isOutputTokenCapExceeded(errMsg);
+                if ((passthrough && sdkTerm.reason === "max_turns" || outputCapTruncated) && capturedToolUses.length === 0 && streamedToolUseIds.size === 0 && messageStartEmitted && (outputCapTruncated || textCharsForwarded > 0)) {
                   flushOpenClientBlocks("capped_turn");
                   diagnosticLog2.session(`${requestMeta.requestId} sdk_termination_truncated ${formatSdkTermination(sdkTerm, {
                     model,
@@ -40739,6 +41219,15 @@ data: ${JSON.stringify({
         message: "Meridian is shutting down; route new requests to another instance."
       }, 503);
     }
+    const bootIdentity = describeLocalBootIdentity();
+    if (!bootIdentity.available) {
+      return c.json({
+        status: "unhealthy",
+        version: serverVersion,
+        error: "Cannot capture a process incarnation, so no request that touches a session can be served.",
+        bootIdentity
+      }, 503);
+    }
     try {
       const healthProfile = resolveProfile(finalConfig.profiles, finalConfig.defaultProfile);
       const profileEnvOverrides = Object.keys(healthProfile.env).length > 0 ? healthProfile.env : undefined;
@@ -41057,10 +41546,11 @@ data: ${JSON.stringify({
       "Content-Type": "application/json",
       "x-meridian-agent": "codex"
     };
-    const promptCacheKey = rawBody.prompt_cache_key;
-    if (typeof promptCacheKey === "string" && promptCacheKey.length > 0) {
-      internalHeaders["x-codex-session"] = promptCacheKey;
-    }
+    const codexThread = resolveCodexThreadIdentity(rawBody, c.req.header("x-codex-turn-metadata"));
+    if (codexThread.sessionKey)
+      internalHeaders["x-codex-session"] = codexThread.sessionKey;
+    if (codexThread.requestSource)
+      internalHeaders["x-meridian-source"] = codexThread.requestSource;
     const xApiKey = c.req.header("x-api-key");
     if (xApiKey)
       internalHeaders["x-api-key"] = xApiKey;
@@ -41083,7 +41573,8 @@ data: ${JSON.stringify({
     const responseId = `resp_${randomUUID6().replace(/-/g, "")}`;
     const created = Math.floor(Date.now() / 1000);
     const model = typeof rawBody.model === "string" && rawBody.model ? rawBody.model : CANONICAL_SONNET_MODEL;
-    const ctx = { responseId, model, created, reasoningRequested: reasoningRequested(rawBody) };
+    const toolAliases = buildResponsesToolAliases(rawBody.tools);
+    const ctx = { responseId, model, created, reasoningRequested: reasoningRequested(rawBody), toolAliases };
     if (!anthropicBody.stream) {
       const anthropicRes = await internalRes.json();
       return c.json(translateAnthropicToResponses(anthropicRes, ctx));
@@ -41431,6 +41922,23 @@ function installProxyProcessErrorHandlers() {
   });
 }
 async function startProxyServer(config2 = {}) {
+  let bootIdentity = describeLocalBootIdentity();
+  for (let attempt = 1;!bootIdentity.available && attempt <= 3; attempt++) {
+    await new Promise((resolve6) => setTimeout(resolve6, 250 * attempt));
+    bootIdentity = describeLocalBootIdentity();
+    if (bootIdentity.available) {
+      console.error(`[PROXY] Boot identity captured on attempt ${attempt + 1} (the first probe failed).`);
+    }
+  }
+  if (!bootIdentity.available && !envBool("ALLOW_MISSING_BOOT_IDENTITY")) {
+    throw new Error("[PROXY] Refusing to start: cannot capture a process incarnation on this host, " + `so no request that touches a session could be served.
+` + `  platform: ${bootIdentity.platform}
+` + `  cause: ${bootIdentity.hint}
+` + "  Set MERIDIAN_ALLOW_MISSING_BOOT_IDENTITY=1 to start anyway (requests will still fail).");
+  }
+  if (!bootIdentity.available) {
+    console.error("[PROXY] Starting WITHOUT a boot identity because MERIDIAN_ALLOW_MISSING_BOOT_IDENTITY is set. " + `Requests that touch a session will fail with 500. Cause: ${bootIdentity.hint}`);
+  }
   claudeExecutable = await resolveClaudeExecutableAsync();
   const {
     app,