@vanillagreen/pi-claude-bridge 2.0.0 → 3.2.2

package/bundle/index.js

@@ -26941,12 +26941,116 @@ function splitPrefixSuffix(input, options = {}) {
 // src/config.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { homedir } from "os";
-import { dirname, join as join2, resolve as resolve2 } from "path";
+import { dirname as dirname2, join as join3, resolve as resolve2, sep as sep2 } from "path";
+
+// src/debug.ts
+import { appendFileSync as appendFileSync2, chmodSync, mkdirSync as mkdirSync2 } from "fs";
+import { dirname, join as join2 } from "path";
+var DEBUG = process.env.CLAUDE_BRIDGE_DEBUG === "1";
+var DEBUG_LOG_PATH = process.env.CLAUDE_BRIDGE_DEBUG_PATH || join2(piUserDir(), "claude-bridge.log");
+function diagLogPath() {
+  return process.env.CLAUDE_BRIDGE_DIAG_PATH || join2(piUserDir(), "claude-bridge-diag.log");
+}
+function diagGuidance() {
+  return DEBUG ? `see ${diagLogPath()}` : "re-run with CLAUDE_BRIDGE_DEBUG=1 to capture a diagnostic dump";
+}
+if (DEBUG) {
+  try {
+    mkdirSync2(dirname(DEBUG_LOG_PATH), { recursive: true, mode: 448 });
+    mkdirSync2(dirname(diagLogPath()), { recursive: true, mode: 448 });
+    chmodSync(dirname(DEBUG_LOG_PATH), 448);
+    chmodSync(DEBUG_LOG_PATH, 384);
+  } catch {
+  }
+}
+var moduleInstanceId = Math.random().toString(36).slice(2, 8);
+function debug(...args) {
+  if (!DEBUG) return;
+  const ts2 = (/* @__PURE__ */ new Date()).toISOString();
+  const fmt = (a) => {
+    if (typeof a === "string") return a;
+    if (a instanceof Error) return `${a.name}: ${a.message}${a.stack ? "\n" + a.stack : ""}`;
+    if (typeof a === "function") return fmt(a());
+    return JSON.stringify(a);
+  };
+  const safeFmt = (a) => {
+    let out;
+    try {
+      out = fmt(a);
+    } catch (error51) {
+      let reason = "formatting failed";
+      try {
+        reason = String(error51 instanceof Error ? error51.message : error51);
+      } catch {
+      }
+      return `[unprintable: ${reason}]`;
+    }
+    if (out !== void 0) return out;
+    if (typeof a === "function") return "undefined";
+    try {
+      return String(a);
+    } catch {
+      return "[unprintable: formatting failed]";
+    }
+  };
+  const msg = args.map(safeFmt).join(" ");
+  try {
+    appendFileSync2(DEBUG_LOG_PATH, `[${ts2}] [${moduleInstanceId}] ${msg}
+`, { mode: 384 });
+  } catch {
+  }
+}
+var nextCliDebugSeq = 1;
+function makeCliDebugOptions(tag) {
+  if (!DEBUG) return {};
+  const seq = nextCliDebugSeq++;
+  const ts2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const logDir = join2(dirname(DEBUG_LOG_PATH), "cc-cli-logs");
+  try {
+    mkdirSync2(logDir, { recursive: true, mode: 448 });
+    chmodSync(logDir, 448);
+  } catch {
+  }
+  const debugFile = join2(logDir, `${ts2}-${tag}-${seq}.log`);
+  debug(`cli-debug: ${tag} #${seq} \u2192 ${debugFile}`);
+  return {
+    debug: true,
+    debugFile,
+    stderr: (data) => {
+      for (const line of data.split(/\r?\n/)) {
+        if (line) debug(`[cli-stderr ${tag}#${seq}] ${line}`);
+      }
+    }
+  };
+}
+function diagDump(label, data) {
+  if (!DEBUG) return;
+  try {
+    const ts2 = (/* @__PURE__ */ new Date()).toISOString();
+    const entry = { ts: ts2, moduleInstanceId, label, ...data };
+    const path = diagLogPath();
+    try {
+      mkdirSync2(dirname(path), { recursive: true, mode: 448 });
+    } catch {
+    }
+    appendFileSync2(path, JSON.stringify(entry) + "\n", { mode: 384 });
+    try {
+      chmodSync(path, 384);
+    } catch {
+    }
+    debug(`DIAG: ${label} (see ${path})`);
+  } catch (error51) {
+    debug(`DIAG FAILED: ${label}`, error51);
+  }
+}
+
+// src/config.ts
 var PACKAGE_ID = "@vanillagreen/pi-claude-bridge";
+var EXTERNAL_CONFIG_RESOLVER_SYMBOL = /* @__PURE__ */ Symbol.for("vstack.pi.extension-config-resolver");
 var VALID_EFFORT_LEVELS = /* @__PURE__ */ new Set(["low", "medium", "high", "xhigh", "max"]);
 function expandHome(input) {
   if (input === "~") return homedir();
-  if (input.startsWith("~/")) return join2(homedir(), input.slice(2));
+  if (input.startsWith("~/")) return join3(homedir(), input.slice(2));
   return input;
 }
 function piUserDir() {
@@ -26971,11 +27075,11 @@ function mergeDeep(target, source) {
 function projectSettingsPath(cwd) {
   let current = resolve2(cwd);
   while (true) {
-    const candidate = join2(current, ".pi", "settings.json");
+    const candidate = join3(current, ".pi", "settings.json");
     if (existsSync2(candidate)) return candidate;
-    if (existsSync2(join2(current, ".pi")) || existsSync2(join2(current, ".git")) || existsSync2(join2(current, ".vstack-lock.json"))) return candidate;
-    const parent = dirname(current);
-    if (parent === current) return join2(resolve2(cwd), ".pi", "settings.json");
+    if (existsSync2(join3(current, ".pi")) || existsSync2(join3(current, ".git")) || existsSync2(join3(current, ".vstack-lock.json"))) return candidate;
+    const parent = dirname2(current);
+    if (parent === current) return join3(resolve2(cwd), ".pi", "settings.json");
     current = parent;
   }
 }
@@ -27005,7 +27109,7 @@ function projectSettingsTrusted(settingsPath) {
   return projectTrustRegistry().projectSettings?.get(settingsPath) === true;
 }
 function settingsPaths(cwd) {
-  const user = join2(piUserDir(), "settings.json");
+  const user = join3(piUserDir(), "settings.json");
   if (isolatedFromEnv()) return [];
   const project = projectSettingsPath(cwd);
   return projectSettingsTrusted(project) ? [user, project] : [user];
@@ -27014,24 +27118,39 @@ function tryParseJson(path) {
   if (!existsSync2(path)) return {};
   try {
     return JSON.parse(readFileSync2(path, "utf-8"));
-  } catch {
+  } catch (error51) {
+    debug(`config: ignoring malformed ${path}:`, error51 instanceof Error ? error51.message : String(error51));
     return {};
   }
 }
 function readManagerConfig(cwd) {
   const merged = {};
+  const userPath = join3(piUserDir(), "settings.json");
   for (const path of settingsPaths(cwd)) {
     if (!existsSync2(path)) continue;
     try {
       const parsed = JSON.parse(readFileSync2(path, "utf8"));
       const configRoot = asRecord(asRecord(asRecord(parsed?.vstack)?.extensionManager)?.config);
       const config2 = asRecord(configRoot?.[PACKAGE_ID]);
-      if (config2) mergeDeep(merged, config2);
-    } catch {
+      if (config2) mergeDeep(merged, path === userPath ? config2 : withoutUserScopeOnlyKeys(config2));
+    } catch (error51) {
+      debug(`config: ignoring malformed manager config ${path}:`, error51 instanceof Error ? error51.message : String(error51));
     }
   }
   return merged;
 }
+var USER_SCOPE_ONLY_PROVIDER_KEYS = ["enableConnectors", "connectorWriteMode"];
+function withoutUserScopeOnlyKeys(raw) {
+  const out = { ...raw };
+  for (const key of USER_SCOPE_ONLY_PROVIDER_KEYS) delete out[key];
+  return out;
+}
+function stripUserScopeOnlyProviderKeys(config2) {
+  if (!config2.provider) return config2;
+  const provider = { ...config2.provider };
+  for (const key of USER_SCOPE_ONLY_PROVIDER_KEYS) delete provider[key];
+  return { ...config2, provider };
+}
 function boolFrom(raw, key) {
   return typeof raw[key] === "boolean" ? raw[key] : void 0;
 }
@@ -27095,8 +27214,6 @@ function managerToConfig(raw) {
   const promptContext = {};
   const appendSystemPrompt = boolFrom(raw, "appendSystemPrompt");
   if (appendSystemPrompt !== void 0) provider.appendSystemPrompt = appendSystemPrompt;
-  const allowExtraUsage = boolFrom(raw, "allowExtraUsage");
-  if (allowExtraUsage !== void 0) provider.allowExtraUsage = allowExtraUsage;
   const fastMode = boolFrom(raw, "fastMode");
   if (fastMode !== void 0) provider.fastMode = fastMode;
   if (hasOwn(raw, "forceEffort")) {
@@ -27127,19 +27244,84 @@ function managerToConfig(raw) {
     ...Object.keys(promptContext).length ? { promptContext } : {}
   };
 }
+function legacyFileConfig(path) {
+  const raw = asRecord(tryParseJson(path)) ?? {};
+  const flat = managerToConfig(raw);
+  const provider = { ...flat.provider, ...asRecord(raw.provider) };
+  const promptContext = { ...flat.promptContext, ...asRecord(raw.promptContext) };
+  return {
+    ...flat.enabled !== void 0 ? { enabled: flat.enabled } : {},
+    ...Object.keys(provider ?? {}).length ? { provider } : {},
+    ...Object.keys(promptContext ?? {}).length ? { promptContext } : {}
+  };
+}
+function legacyLayers(cwd) {
+  const globalPath = join3(piUserDir(), "claude-bridge.json");
+  const layers = [{ path: globalPath, config: legacyFileConfig(globalPath) }];
+  if (isolatedFromEnv()) return layers;
+  const projectSettings = projectSettingsPath(cwd);
+  if (!projectSettingsTrusted(projectSettings)) return layers;
+  const projectPath = join3(dirname2(projectSettings), "claude-bridge.json");
+  return [...layers, { path: projectPath, config: stripUserScopeOnlyProviderKeys(legacyFileConfig(projectPath)) }];
+}
+function mergeLayers(layers) {
+  const merged = { provider: {}, promptContext: {} };
+  for (const layer of layers) {
+    if (layer.config.enabled !== void 0) merged.enabled = layer.config.enabled;
+    merged.provider = { ...merged.provider, ...layer.config.provider };
+    merged.promptContext = { ...merged.promptContext, ...layer.config.promptContext };
+  }
+  return merged;
+}
 function loadConfig(cwd) {
-  const global2 = tryParseJson(join2(piUserDir(), "claude-bridge.json"));
-  const isolated = isolatedFromEnv();
-  const projectSettings = isolated ? void 0 : projectSettingsPath(cwd);
-  const trustedProject = projectSettings !== void 0 && projectSettingsTrusted(projectSettings);
-  const project = trustedProject ? tryParseJson(join2(dirname(projectSettings), "claude-bridge.json")) : {};
-  const manager = isolated ? {} : managerToConfig(readManagerConfig(cwd));
-  const provider = normalizeProviderConfig({ ...global2.provider, ...project.provider, ...manager.provider });
+  const legacy = mergeLayers(legacyLayers(cwd));
+  const manager = isolatedFromEnv() ? {} : managerToConfig(readManagerConfig(cwd));
+  const provider = normalizeProviderConfig({ ...legacy.provider, ...manager.provider });
   return {
-    enabled: manager.enabled ?? project.enabled ?? global2.enabled ?? true,
+    enabled: manager.enabled ?? legacy.enabled ?? true,
     provider,
-    promptContext: { ...global2.promptContext, ...project.promptContext, ...manager.promptContext }
-  };
+    promptContext: { ...legacy.promptContext, ...manager.promptContext }
+  };
+}
+var PROVIDER_KEYS = /* @__PURE__ */ new Set([
+  "appendSystemPrompt",
+  "connectorWriteMode",
+  "enableConnectors",
+  "fastMode",
+  "forceEffort",
+  "modelEffortOverrides",
+  "pathToClaudeCodeExecutable",
+  "strictMcpConfig"
+]);
+var PROMPT_CONTEXT_KEYS = /* @__PURE__ */ new Set([
+  "includeAppendSystemPromptMd",
+  "includeCavemanHook",
+  "includeProjectAgentsHook",
+  "includeTaskPanelHook"
+]);
+function configValueForKey(config2, key) {
+  if (key === "enabled") return config2.enabled;
+  if (PROVIDER_KEYS.has(key)) return normalizeProviderConfig(config2.provider)?.[key];
+  if (PROMPT_CONTEXT_KEYS.has(key)) return config2.promptContext?.[key];
+  return void 0;
+}
+function displayPath(path) {
+  const home = homedir();
+  return home && path.startsWith(home + sep2) ? `~${path.slice(home.length)}` : path;
+}
+function resolveExternalConfigValue(key, cwd) {
+  const layers = legacyLayers(cwd);
+  const value = configValueForKey(mergeLayers(layers), key);
+  if (value === void 0) return { explicit: false, value: void 0 };
+  const source = [...layers].reverse().find((layer) => configValueForKey(layer.config, key) !== void 0)?.path;
+  return { explicit: true, value, ...source ? { source: displayPath(source) } : {} };
+}
+function registerExternalConfigResolver() {
+  const host = globalThis;
+  const existing = asRecord(host[EXTERNAL_CONFIG_RESOLVER_SYMBOL]);
+  const registry2 = existing ?? {};
+  if (!existing) host[EXTERNAL_CONFIG_RESOLVER_SYMBOL] = registry2;
+  registry2[PACKAGE_ID] = (key, cwd) => resolveExternalConfigValue(key, cwd);
 }
 
 // src/skills.ts
@@ -27179,9 +27361,12 @@ function connectorServerNamespace(connectorName) {
 function credentialCandidatePaths(env = process.env) {
   const roots = [];
   const configDir = env.CLAUDE_CONFIG_DIR?.trim();
-  if (configDir) roots.push(configDir);
-  const home = env.HOME?.trim();
-  if (home) roots.push(`${home}/.claude`, home);
+  if (configDir) {
+    roots.push(configDir);
+  } else {
+    const home = env.HOME?.trim();
+    if (home) roots.push(`${home}/.claude`, home);
+  }
   const seen = /* @__PURE__ */ new Set();
   const paths = [];
   for (const root of roots) {
@@ -27348,6 +27533,10 @@ function connectorsEnabledFromEnv() {
 function connectorsEnabledFor(config2) {
   return connectorsEnabledFromEnv() || config2?.provider?.enableConnectors === true;
 }
+function settingSourcesForQuery(connectorsEnabled, appendSystemPrompt, configured) {
+  if (connectorsEnabled) return configured ?? ["user"];
+  return appendSystemPrompt ? void 0 : configured ?? ["user", "project"];
+}
 var CLAUDE_AI_CONNECTOR_TOOL_PATTERNS = [
   "mcp__claude_ai_Gmail__*",
   "mcp__claude_ai_Google_Calendar__*",
@@ -27355,7 +27544,16 @@ var CLAUDE_AI_CONNECTOR_TOOL_PATTERNS = [
   "mcp__claude_ai_Slack__*",
   "mcp__claude_ai_Atlassian__*"
 ];
+var SDK_TOOL_ALIASES = {
+  ListMcpResources: "ListMcpResourcesTool",
+  ReadMcpResource: "ReadMcpResourceTool"
+};
+function deliveredSpellings(name) {
+  const canonical = SDK_TOOL_ALIASES[name];
+  return canonical ? [name, canonical] : [name];
+}
 var CONNECTOR_DISCOVERY_TOOLS = ["ToolSearch", "ListMcpResources", "ReadMcpResource"];
+var CONNECTOR_DISCOVERY_TOOL_NAMES = new Set(CONNECTOR_DISCOVERY_TOOLS.flatMap(deliveredSpellings));
 var CONNECTOR_NS_PREFIX2 = "mcp__claude_ai_";
 var CONNECTOR_NS_GMAIL = `${CONNECTOR_NS_PREFIX2}Gmail__`;
 var CONNECTOR_NS_CALENDAR = `${CONNECTOR_NS_PREFIX2}Google_Calendar__`;
@@ -27512,15 +27710,22 @@ var CONNECTOR_WRITE_TOOLS = [
   `${CONNECTOR_NS_ATLASSIAN}createCompassComponentRelationship`,
   `${CONNECTOR_NS_ATLASSIAN}createCompassCustomFieldDefinition`
 ];
-function isChildExecutedTool(name) {
+function isConnectorTool(name) {
   return typeof name === "string" && name.startsWith(CONNECTOR_NS_PREFIX2);
 }
+var CHILD_INTERNAL_TOOLS = /* @__PURE__ */ new Set(["ToolSearch", "ScheduleWakeup"]);
+function isChildInternalTool(name) {
+  return typeof name === "string" && CHILD_INTERNAL_TOOLS.has(name);
+}
+function isChildExecutedTool(name) {
+  return isConnectorTool(name) || isChildInternalTool(name);
+}
 function isConnectorWriteTool(name) {
-  if (!name.startsWith(CONNECTOR_NS_PREFIX2)) return false;
-  const sep2 = name.indexOf("__", CONNECTOR_NS_PREFIX2.length);
-  if (sep2 <= CONNECTOR_NS_PREFIX2.length) return true;
-  const server = name.slice(CONNECTOR_NS_PREFIX2.length, sep2);
-  const words = connectorNameWords(name.slice(sep2 + "__".length));
+  if (!isConnectorTool(name)) return false;
+  const sep3 = name.indexOf("__", CONNECTOR_NS_PREFIX2.length);
+  if (sep3 <= CONNECTOR_NS_PREFIX2.length) return true;
+  const server = name.slice(CONNECTOR_NS_PREFIX2.length, sep3);
+  const words = connectorNameWords(name.slice(sep3 + "__".length));
   const serverWords = connectorNameWords(server);
   let skipped = 0;
   while (skipped < serverWords.length && words[skipped] === serverWords[skipped] && !CONNECTOR_MUTATION_WORDS.has(words[skipped])) skipped++;
@@ -27543,11 +27748,11 @@ function connectorWriteDenyHook() {
   return async (input) => {
     try {
       if (input.hook_event_name !== "PreToolUse") return { continue: true };
+      if (typeof input.tool_name !== "string") return connectorWriteDenyOutput("<unknown>");
       if (!isConnectorWriteTool(input.tool_name)) return { continue: true };
-      return connectorWriteDenyOutput(String(input.tool_name));
+      return connectorWriteDenyOutput(input.tool_name);
     } catch {
-      const toolName = typeof input?.tool_name === "string" ? input.tool_name : "<unknown>";
-      return connectorWriteDenyOutput(toolName);
+      return connectorWriteDenyOutput(safeToolNameFrom(input));
     }
   };
 }
@@ -27560,14 +27765,66 @@ function connectorWriteDenyOutput(toolName) {
     }
   };
 }
+function isAllowlistedConnectorSessionTool(name) {
+  return name.startsWith(MCP_TOOL_PREFIX) || name.startsWith(CONNECTOR_NS_PREFIX2) || CONNECTOR_DISCOVERY_TOOL_NAMES.has(name);
+}
+function connectorBuiltinAllowlistHook() {
+  return async (input) => {
+    try {
+      if (input.hook_event_name !== "PreToolUse") return { continue: true };
+      if (typeof input.tool_name !== "string") return allowlistDenyOutput("<unknown>");
+      if (isAllowlistedConnectorSessionTool(input.tool_name)) return { continue: true };
+      return allowlistDenyOutput(input.tool_name);
+    } catch {
+      return allowlistDenyOutput(safeToolNameFrom(input));
+    }
+  };
+}
+function safeToolNameFrom(input) {
+  try {
+    const candidate = input?.tool_name;
+    return typeof candidate === "string" ? candidate : "<unknown>";
+  } catch {
+    return "<unknown>";
+  }
+}
+function allowlistDenyOutput(toolName) {
+  return {
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      permissionDecision: "deny",
+      permissionDecisionReason: `Tool "${toolName}" is not available in this connector session. Only bridged custom tools, claude.ai connector tools, and tool discovery are permitted here.`
+    }
+  };
+}
+function denyAllToolsHook() {
+  return async (input) => {
+    try {
+      if (input.hook_event_name !== "PreToolUse") return { continue: true };
+      return denyAllOutput(typeof input.tool_name === "string" ? input.tool_name : "<unknown>");
+    } catch {
+      return denyAllOutput("<unknown>");
+    }
+  };
+}
+function denyAllOutput(toolName) {
+  return {
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      permissionDecision: "deny",
+      permissionDecisionReason: `Tool "${toolName}" is not available: this session executes no tools.`
+    }
+  };
+}
 function connectorQueryOptions(connectorsEnabled, writeMode = "deny") {
   const isolation = toolIsolationForQuery(connectorsEnabled, writeMode);
-  if (!connectorsEnabled || writeMode === "allow") return isolation;
-  return { ...isolation, hooks: { PreToolUse: [{ hooks: [connectorWriteDenyHook()] }] } };
+  if (!connectorsEnabled) return isolation;
+  const hooks = writeMode === "allow" ? [connectorBuiltinAllowlistHook()] : [connectorBuiltinAllowlistHook(), connectorWriteDenyHook()];
+  return { ...isolation, hooks: { PreToolUse: [{ hooks }] } };
 }
 function toolIsolationForQuery(connectorsEnabled, writeMode = "deny") {
   if (!connectorsEnabled) return CLAUDE_BRIDGE_TOOL_ISOLATION;
-  const disallowedTools = DISALLOWED_BUILTIN_TOOLS.filter((t) => !CONNECTOR_DISCOVERY_TOOLS.includes(t));
+  const disallowedTools = DISALLOWED_BUILTIN_TOOLS.filter((t) => !CONNECTOR_DISCOVERY_TOOL_NAMES.has(t));
   if (writeMode !== "allow") disallowedTools.push(...CONNECTOR_WRITE_TOOLS);
   return {
     disallowedTools,
@@ -27596,7 +27853,7 @@ function connectorDeclarationsDisabled(env = process.env) {
 }
 
 // src/convert.ts
-var PROVIDER_ID = "claude-bridge";
+var PROVIDER_ID = "pi-claude";
 var PI_TO_SDK_TOOL_NAME = {
   read: "Read",
   write: "Write",
@@ -27700,15 +27957,7 @@ function convertPiMessages(messages, customToolNameToSdk) {
     if (toolMessages.length === 0) return;
     anthropicMessages.push({
       role: "user",
-      content: toolMessages.map((toolMsg) => {
-        const content = toolResultContentToAnthropic(toolMsg.content);
-        return {
-          type: "tool_result",
-          tool_use_id: sanitizeToolId(toolMsg.toolCallId, sanitizedIds),
-          content: content || "",
-          is_error: toolMsg.isError
-        };
-      })
+      content: toolMessages.map((toolMsg) => toolResultToAnthropicBlock(toolMsg, sanitizedIds))
     });
   };
   for (let i = 0; i < messages.length; i++) {
@@ -27867,7 +28116,36 @@ function extractAllToolResults(messages) {
   return { results, stopIdx };
 }
 
+// src/request-lane.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var REQUEST_LANE_SYMBOL = /* @__PURE__ */ Symbol.for("vstack.pi.claude-bridge.request-lane.v1");
+function requestLaneStorage() {
+  const host = globalThis;
+  let storage = host[REQUEST_LANE_SYMBOL];
+  if (!storage) {
+    storage = new AsyncLocalStorage();
+    host[REQUEST_LANE_SYMBOL] = storage;
+  }
+  return storage;
+}
+function runInRequestLane(sessionId, callback) {
+  const storage = requestLaneStorage();
+  if (sessionId !== void 0) return storage.run(sessionId, callback);
+  return storage.getStore() === void 0 ? callback() : storage.exit(callback);
+}
+function currentRequestLaneId() {
+  return requestLaneStorage().getStore();
+}
+
 // src/query-state.ts
+function summarizeDroppedUserMessages(site, dropped) {
+  return {
+    site,
+    count: dropped.length,
+    textLengths: dropped.map((message) => message.text.length),
+    imageOnlyCount: dropped.filter((message) => !message.text && message.blocks?.length).length
+  };
+}
 var DRAIN_CAUSE_TEXT = {
   "abort": "the turn was aborted",
   "stream-idle-timeout": "the Claude Code stream went idle and the turn timed out",
@@ -27892,6 +28170,49 @@ function drainPendingToolCalls(queryCtx, cause) {
   queryCtx.pendingToolCalls.clear();
   return drained;
 }
+function strandedToolCallResult() {
+  return {
+    content: [{ type: "text", text: "Claude bridge: this tool call was never forwarded to Pi before its turn ended, so it did not execute and no result can arrive. Re-run the tool." }],
+    isError: true
+  };
+}
+function failStrandedToolCall(queryCtx, id) {
+  if (queryCtx.forwardedToolCallIds.has(id)) return false;
+  const pending = queryCtx.pendingToolCalls.get(id);
+  if (!pending) return false;
+  queryCtx.pendingToolCalls.delete(id);
+  queryCtx.deadToolCallIds.add(id);
+  pending.resolve(strandedToolCallResult());
+  return true;
+}
+function drainStrandedToolCalls(queryCtx) {
+  const stranded = [];
+  for (const [id, pending] of queryCtx.pendingToolCalls) {
+    if (pending.generation >= queryCtx.callbackGeneration) continue;
+    if (queryCtx.forwardedToolCallIds.has(id)) continue;
+    stranded.push({ id, toolName: pending.toolName });
+  }
+  for (const { id } of stranded) {
+    const pending = queryCtx.pendingToolCalls.get(id);
+    queryCtx.pendingToolCalls.delete(id);
+    queryCtx.deadToolCallIds.add(id);
+    pending.resolve(strandedToolCallResult());
+  }
+  return stranded;
+}
+function takeQueuedOrParkedResult(queryCtx, id) {
+  const queued = queryCtx.pendingResults.get(id);
+  if (queued !== void 0) {
+    queryCtx.pendingResults.delete(id);
+    return queued;
+  }
+  const parked = queryCtx.reapedResults.get(id);
+  if (parked !== void 0) {
+    queryCtx.reapedResults.delete(id);
+    return parked;
+  }
+  return void 0;
+}
 function normalizeForCompare(value) {
   if (Array.isArray(value)) return value.map(normalizeForCompare);
   if (value && typeof value === "object") {
@@ -27930,6 +28251,33 @@ var QueryContext = class {
   latestCursor = 0;
   pendingToolCalls = /* @__PURE__ */ new Map();
   pendingResults = /* @__PURE__ */ new Map();
+  /** Results a message-boundary reap moved OUT of pendingResults so they stop
+   *  poisoning mismatch reports, kept CONSUMABLE for a handler that fires later.
+   *  The 2026-08-17 deadlock session showed the reap's "no consumer will ever
+   *  come" assumption failing routinely: Pi delivers a turn's results in one
+   *  callback while the SDK staggers handler invocations past the next message
+   *  boundary. Query-scoped, bounded by the query's tool-call count. */
+  reapedResults = /* @__PURE__ */ new Map();
+  /** Every tool-call id this query has handed to Pi inside an ENDED turn — the
+   *  set endToolUseTurn stamps from the turn's content. A forwarded id is one Pi
+   *  will execute and answer; it must never be emitted again (a lagging stream
+   *  replays the same tool_use into the NEXT turn, and per-message turnBlocks
+   *  dedup cannot see across turns — vstack#1469's duplicate executions), and a
+   *  handler waiting on it must be left waiting at the stranded-handler drains.
+   *  Query-scoped, never reset per message. */
+  forwardedToolCallIds = /* @__PURE__ */ new Set();
+  /** Ids whose waiting handler was resolved with strandedToolCallResult. The
+   *  model has been told these calls failed; forwarding one later would execute
+   *  it behind the model's back, so every forward path skips them. */
+  deadToolCallIds = /* @__PURE__ */ new Set();
+  /** Streamed block indexes suppressed as duplicate or dead tool_use blocks —
+   *  their deltas and stops must be ignored the same way child-executed indexes
+   *  are. Per message; reset by resetToolTracking. */
+  suppressedStreamIndexes = /* @__PURE__ */ new Set();
+  /** Bumped at every provider callback for this query. Stamped onto handlers at
+   *  registration so the stranded-handler drain can tell "registered before this
+   *  callback, provably settled" from "racing this callback's own stream". */
+  callbackGeneration = 0;
   turnToolCallIds = [];
   turnToolCalls = [];
   /**
@@ -27942,6 +28290,12 @@ var QueryContext = class {
    * showed. Bounded by the number of tool calls in one query.
    */
   queryToolNames = /* @__PURE__ */ new Map();
+  /** id → last-known arguments, query-scoped like queryToolNames and for the
+   *  same reason: a late handler firing after resetToolTracking wiped the
+   *  per-message records must still be able to exact-match the parked/queued
+   *  result of ITS OWN call — without stored args the only fallback is
+   *  sole-same-name, which can hand it a LIVE sibling's id (vstack#1469). */
+  queryToolArgs = /* @__PURE__ */ new Map();
   claimedToolCallIds = /* @__PURE__ */ new Set();
   deliveredToolResultIds = /* @__PURE__ */ new Set();
   resolvedToolResultIds = /* @__PURE__ */ new Set();
@@ -27949,18 +28303,33 @@ var QueryContext = class {
   reportedToolResultMismatch = false;
   deferredUserMessages = [];
   handledTerminalError = false;
+  // Once visible text/thinking, a complete tool call, or a child-executed
+  // CONNECTOR dispatch reaches Pi, the request must never be replayed on
+  // another account (duplicate side effects). Query-scoped, not per-turn:
+  // resetTurnState must not clear it.
+  committedOutput = false;
+  /** True when this query holds NO claim on the module-level shared session
+   *  record: a reentrant (subagent) query, or a foreign-conversation one-shot
+   *  (vstack#1001). Every shared-record mutation reachable from this context —
+   *  reportToolResultMismatch's needsRebuild/forceRotate mark, the cursor
+   *  advances on the tool-result-delivery and orphaned-result paths — must
+   *  no-op so the PARENT's record stays untouched. Assigned at fresh-query
+   *  setup; deliberately NOT cleared at query end, so a late orphaned tool
+   *  result arriving after this query settled is still attributed to it. */
+  detachedFromSharedSession = false;
   /** Armed grace timer for ending a tool_use turn whose terminal stream events
    *  (message_delta/message_stop) never arrive. The normal path ends the turn at
    *  message_stop, AFTER message_delta delivered the real output-token count;
    *  this is the deadlock backstop for streams that go silent instead. Managed
    *  by schedule/cancelToolUseTurnEnd in assistant-stream.ts. */
   scheduledToolUseEnd = null;
-  // Tool calls the CHILD executes itself (claude.ai connectors — see
-  // isChildExecutedTool). Deliberately NOT in turnToolCalls/turnToolCallIds:
-  // those track calls Pi owes a result for, and Pi owes nothing here. Kept only
-  // so the child's real result can be recognized when it comes back on the SDK's
-  // `user` message, and so the streamed block's deltas can be skipped silently
-  // instead of logging as "unmatched" (which reads like a bug).
+  // Tool calls the CHILD executes itself (see isChildExecutedTool).
+  // Deliberately NOT in turnToolCalls/turnToolCallIds: those track calls Pi
+  // owes a result for, and Pi owes nothing here. CONNECTORS ONLY — kept so the
+  // child's real result can be recognized when it comes back on the SDK's
+  // `user` message and audited. A child-internal built-in (ToolSearch et al.)
+  // never enters this map: its result needs no recognition and no audit, only
+  // its streamed deltas need skipping (childExecutedStreamIndexes below).
   /** tool_use id → raw SDK tool name. */
   childExecutedToolCalls = /* @__PURE__ */ new Map();
   /**
@@ -28072,11 +28441,19 @@ var QueryContext = class {
     this.reportedToolResultMismatch = false;
     this.childExecutedToolCalls.clear();
     this.childExecutedStreamIndexes.clear();
+    this.suppressedStreamIndexes.clear();
   }
   /** Note a tool_use the child runs itself. `streamIndex` is present only on the
-   *  streamed path, where later deltas/stops for that block must be skipped. */
+   *  streamed path, where later deltas/stops for that block must be skipped —
+   *  that skip applies to every child-executed call. Result recognition and the
+   *  connector-call audit apply to CONNECTORS only: a child-internal built-in
+   *  (ToolSearch et al.) is tool plumbing, not account-data access, so nothing
+   *  about it belongs in the audit trail and no result needs matching. */
   noteChildExecutedToolCall(id, rawName, streamIndex) {
-    if (id) {
+    if (isConnectorTool(rawName)) {
+      this.markOutputCommitted();
+    }
+    if (id && isConnectorTool(rawName)) {
       this.childExecutedToolCalls.set(id, rawName);
       if (!this.connectorCallAudit.has(id)) {
         this.connectorCallAudit.set(id, {
@@ -28091,6 +28468,7 @@ var QueryContext = class {
   recordToolCall(id, toolName, args = {}) {
     if (!id) return;
     this.queryToolNames.set(id, toolName);
+    this.queryToolArgs.set(id, args);
     if (!this.turnToolCallIds.includes(id)) this.turnToolCallIds.push(id);
     const existing = this.turnToolCalls.find((call) => call.id === id);
     if (existing) {
@@ -28102,16 +28480,32 @@ var QueryContext = class {
   }
   updateToolCallArgs(id, args) {
     if (!id) return;
+    this.queryToolArgs.set(id, args);
     const existing = this.turnToolCalls.find((call) => call.id === id);
     if (existing) existing.arguments = args;
   }
   hasRecordedToolCall(id) {
     return Boolean(id && (this.turnToolCallIds.includes(id) || this.turnToolCalls.some((call) => call.id === id)));
   }
+  markOutputCommitted() {
+    this.committedOutput = true;
+  }
   claimToolCall(toolName, args = {}) {
     const unclaimed = this.turnToolCalls.filter((call) => !this.claimedToolCallIds.has(call.id));
     const byName = unclaimed.filter((call) => call.toolName === toolName);
     const exact = byName.filter((call) => sameArgs(call.arguments, args));
+    const resultBacked = [.../* @__PURE__ */ new Set([...this.pendingResults.keys(), ...this.reapedResults.keys()])].filter((id) => !this.claimedToolCallIds.has(id) && this.queryToolNames.get(id) === toolName);
+    const backedExact = resultBacked.filter((id) => sameArgs(this.queryToolArgs.get(id), args));
+    const claimBacked = (id, viaExact) => {
+      this.claimedToolCallIds.add(id);
+      return {
+        toolCallId: id,
+        match: viaExact ? "tool-args" : "tool-name",
+        ambiguous: viaExact && backedExact.length > 1,
+        available: unclaimed.length,
+        ...!viaExact && hasRecordedArgs(this.queryToolArgs.get(id)) ? { argsMismatch: true } : {}
+      };
+    };
     let chosen;
     let match = "none";
     let ambiguous = false;
@@ -28120,33 +28514,38 @@ var QueryContext = class {
       chosen = exact[0];
       match = "tool-args";
       ambiguous = exact.length > 1;
+    } else if (backedExact.length > 0) {
+      return claimBacked(backedExact[0], true);
     } else if (byName.length === 1) {
       chosen = byName[0];
       match = "tool-name";
       argsMismatch = hasRecordedArgs(byName[0].arguments);
     }
+    if (!chosen && resultBacked.length === 1) return claimBacked(resultBacked[0], false);
     if (!chosen) return { match: "none", ambiguous: false, available: unclaimed.length };
     this.claimedToolCallIds.add(chosen.id);
     return { toolCallId: chosen.id, match, ambiguous, available: unclaimed.length, ...argsMismatch ? { argsMismatch } : {} };
   }
   /**
-   * Drain results still queued in `pendingResults` and report what was dropped.
+   * Move results still queued in `pendingResults` into the parked store and
+   * report what moved.
    *
    * Called at a child MESSAGE boundary (message_start / the no-stream-events
-   * assistant fallback): by then the child has necessarily received every tool
-   * result for the previous message — a handler that matched resolved its result
-   * directly or from this queue, and one that never matched already returned an
-   * error. Whatever is still queued therefore belongs to a call whose handler
-   * gave up, and no consumer will ever come for it. Left in place, each entry
-   * poisons every later mismatch report for the whole query (queued>0 with 0/0
-   * counters and no tool names) and forces a session rebuild per turn.
+   * assistant fallback). Left in pendingResults, each entry poisons every later
+   * mismatch report for the whole query (queued>0 with 0/0 counters and no tool
+   * names) and forces a session rebuild per turn. But the boundary does NOT
+   * prove the handler gave up — the SDK staggers handler invocations, and the
+   * 2026-08-17 deadlock session (vstack#1469) had three of five parallel
+   * handlers fire after this reap destroyed their results. So the reap parks
+   * instead of dropping: reports stay clean, and a late handler still gets its
+   * real result through takeQueuedOrParkedResult.
    */
   takeStaleQueuedResults() {
     if (this.pendingResults.size === 0) return [];
-    const stale = [...this.pendingResults.keys()].map((id) => ({
-      id,
-      toolName: this.queryToolNames.get(id) ?? "unknown"
-    }));
+    const stale = [...this.pendingResults.entries()].map(([id, result]) => {
+      this.reapedResults.set(id, result);
+      return { id, toolName: this.queryToolNames.get(id) ?? "unknown" };
+    });
     this.pendingResults.clear();
     return stale;
   }
@@ -28202,109 +28601,68 @@ var QueryContext = class {
     };
   }
 };
-var _ctx = new QueryContext();
-var contextStack = [];
+var QUERY_LANES_SYMBOL = /* @__PURE__ */ Symbol.for("vstack.pi.claude-bridge.query-lanes.v1");
+function queryLaneStore() {
+  const host = globalThis;
+  let store = host[QUERY_LANES_SYMBOL];
+  if (!store) {
+    store = {
+      defaultLane: { current: new QueryContext(), stack: [] },
+      sessionLanes: /* @__PURE__ */ new Map()
+    };
+    host[QUERY_LANES_SYMBOL] = store;
+  }
+  return store;
+}
+function lane() {
+  const store = queryLaneStore();
+  const sessionId = currentRequestLaneId();
+  if (sessionId === void 0) return store.defaultLane;
+  let state = store.sessionLanes.get(sessionId);
+  if (!state) {
+    state = { current: new QueryContext(), stack: [] };
+    store.sessionLanes.set(sessionId, state);
+  }
+  return state;
+}
 function ctx() {
-  return _ctx;
+  return lane().current;
 }
 function stackDepth() {
-  return contextStack.length;
+  return lane().stack.length;
 }
 function pushContext() {
-  if (!_ctx.activeQuery) throw new Error("pushContext() called with no active query");
-  contextStack.push(_ctx);
-  _ctx = new QueryContext();
+  const state = lane();
+  if (!state.current.activeQuery) throw new Error("pushContext() called with no active query");
+  state.stack.push(state.current);
+  state.current = new QueryContext();
 }
 function popContext() {
-  if (contextStack.length === 0) throw new Error("popContext() called with empty stack");
-  const parent = contextStack[contextStack.length - 1];
-  parent.deferredUserMessages.push(..._ctx.deferredUserMessages);
-  _ctx = contextStack.pop();
+  const state = lane();
+  if (state.stack.length === 0) throw new Error("popContext() called with empty stack");
+  const parent = state.stack[state.stack.length - 1];
+  parent.deferredUserMessages.push(...state.current.deferredUserMessages);
+  state.current = state.stack.pop();
 }
 function popContextFor(target) {
-  if (_ctx === target) {
+  const state = lane();
+  if (state.current === target) {
     popContext();
     return true;
   }
-  const idx = contextStack.indexOf(target);
+  const idx = state.stack.indexOf(target);
   if (idx < 0) return false;
-  const parent = idx > 0 ? contextStack[idx - 1] : void 0;
+  const parent = idx > 0 ? state.stack[idx - 1] : void 0;
   parent?.deferredUserMessages.push(...target.deferredUserMessages);
-  contextStack.splice(idx, 1);
+  state.stack.splice(idx, 1);
   return true;
 }
-
-// src/debug.ts
-import { appendFileSync as appendFileSync2, chmodSync, mkdirSync as mkdirSync2 } from "fs";
-import { dirname as dirname2, join as join3 } from "path";
-var DEBUG = process.env.CLAUDE_BRIDGE_DEBUG === "1";
-var DEBUG_LOG_PATH = process.env.CLAUDE_BRIDGE_DEBUG_PATH || join3(piUserDir(), "claude-bridge.log");
-function diagLogPath() {
-  return process.env.CLAUDE_BRIDGE_DIAG_PATH || join3(piUserDir(), "claude-bridge-diag.log");
-}
-if (DEBUG) {
-  try {
-    mkdirSync2(dirname2(DEBUG_LOG_PATH), { recursive: true });
-    mkdirSync2(dirname2(diagLogPath()), { recursive: true, mode: 448 });
-  } catch {
-  }
-}
-var moduleInstanceId = Math.random().toString(36).slice(2, 8);
-function debug(...args) {
-  if (!DEBUG) return;
-  const ts2 = (/* @__PURE__ */ new Date()).toISOString();
-  const fmt = (a) => {
-    if (typeof a === "string") return a;
-    if (a instanceof Error) return `${a.name}: ${a.message}${a.stack ? "\n" + a.stack : ""}`;
-    return JSON.stringify(a);
-  };
-  const msg = args.map(fmt).join(" ");
-  try {
-    appendFileSync2(DEBUG_LOG_PATH, `[${ts2}] [${moduleInstanceId}] ${msg}
-`);
-  } catch {
-  }
-}
-var nextCliDebugSeq = 1;
-function makeCliDebugOptions(tag) {
-  if (!DEBUG) return {};
-  const seq = nextCliDebugSeq++;
-  const ts2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const logDir = join3(dirname2(DEBUG_LOG_PATH), "cc-cli-logs");
-  try {
-    mkdirSync2(logDir, { recursive: true });
-  } catch {
-  }
-  const debugFile = join3(logDir, `${ts2}-${tag}-${seq}.log`);
-  debug(`cli-debug: ${tag} #${seq} \u2192 ${debugFile}`);
-  return {
-    debug: true,
-    debugFile,
-    stderr: (data) => {
-      for (const line of data.split(/\r?\n/)) {
-        if (line) debug(`[cli-stderr ${tag}#${seq}] ${line}`);
-      }
-    }
-  };
-}
-function diagDump(label, data) {
-  try {
-    const ts2 = (/* @__PURE__ */ new Date()).toISOString();
-    const entry = { ts: ts2, moduleInstanceId, label, ...data };
-    const path = diagLogPath();
-    try {
-      mkdirSync2(dirname2(path), { recursive: true, mode: 448 });
-    } catch {
-    }
-    appendFileSync2(path, JSON.stringify(entry) + "\n", { mode: 384 });
-    try {
-      chmodSync(path, 384);
-    } catch {
-    }
-    debug(`DIAG: ${label} (see ${path})`);
-  } catch (error51) {
-    debug(`DIAG FAILED: ${label}`, error51);
-  }
+function deleteQueryLane(sessionId) {
+  const store = queryLaneStore();
+  if (sessionId === void 0) {
+    store.defaultLane.current = new QueryContext();
+    store.defaultLane.stack.length = 0;
+  } else store.sessionLanes.delete(sessionId);
 }
 
 // src/tool-pairing-audit.ts
@@ -28321,6 +28679,44 @@ function toolResultIds(content) {
   }
   return ids;
 }
+function recoverLaterToolResults(messages) {
+  const recovered = [];
+  for (let i = 0; i < messages.length; i++) {
+    const assistant = messages[i];
+    if (assistant?.role !== "assistant") continue;
+    const uses = toolUses(assistant.content);
+    if (uses.length === 0) continue;
+    const target = messages[i + 1];
+    if (target?.role !== "user") continue;
+    const present = toolResultIds(target.content);
+    const missing = uses.filter((use2) => !present.has(use2.id));
+    if (missing.length === 0) continue;
+    for (const use2 of missing) {
+      let sourceBlock;
+      let sourceUserIndex = -1;
+      for (let j2 = i + 2; j2 < messages.length; j2++) {
+        const candidate = messages[j2];
+        if (candidate?.role !== "user") continue;
+        sourceBlock = contentBlocks(candidate.content).find(
+          (block) => block.type === "tool_result" && block.tool_use_id === use2.id
+        );
+        if (sourceBlock) {
+          sourceUserIndex = j2;
+          break;
+        }
+      }
+      if (!sourceBlock) continue;
+      const targetBlocks = Array.isArray(target.content) ? target.content : typeof target.content === "string" && target.content ? [{ type: "text", text: target.content }] : [];
+      let insertAt = 0;
+      while (insertAt < targetBlocks.length && targetBlocks[insertAt]?.type === "tool_result") insertAt++;
+      targetBlocks.splice(insertAt, 0, { ...sourceBlock });
+      target.content = targetBlocks;
+      present.add(use2.id);
+      recovered.push({ id: use2.id, assistantIndex: i, sourceUserIndex, targetUserIndex: i + 1 });
+    }
+  }
+  return recovered;
+}
 function findUnpairedToolUses(messages) {
   const missing = [];
   for (let i = 0; i < messages.length; i++) {
@@ -28368,11 +28764,62 @@ function summarizeMissingToolNames(missing) {
 }
 
 // src/bridge-state.ts
-var sharedSession = null;
+var SHARED_SESSION_LANES_SYMBOL = /* @__PURE__ */ Symbol.for("vstack.pi.claude-bridge.shared-session-lanes.v1");
+function sharedSessionLaneStore() {
+  const host = globalThis;
+  let store = host[SHARED_SESSION_LANES_SYMBOL];
+  if (!store) {
+    store = { defaultSession: null, sessions: /* @__PURE__ */ new Map() };
+    host[SHARED_SESSION_LANES_SYMBOL] = store;
+  }
+  return store;
+}
 var extensionApi;
 var piUI;
+function getSharedSession() {
+  const store = sharedSessionLaneStore();
+  const sessionId = currentRequestLaneId();
+  return sessionId === void 0 ? store.defaultSession : store.sessions.get(sessionId) ?? null;
+}
 function setSharedSession(next) {
-  sharedSession = next;
+  const store = sharedSessionLaneStore();
+  const sessionId = currentRequestLaneId();
+  if (sessionId === void 0) store.defaultSession = next;
+  else store.sessions.set(sessionId, next);
+}
+function deleteSharedSessionLane(sessionId) {
+  const store = sharedSessionLaneStore();
+  if (sessionId === void 0) store.defaultSession = null;
+  else store.sessions.delete(sessionId);
+}
+function clearSharedSessionLanes() {
+  const store = sharedSessionLaneStore();
+  store.sessions.clear();
+  store.defaultSession = null;
+}
+var STARTED_LANES_SYMBOL = /* @__PURE__ */ Symbol.for("vstack.pi.claude-bridge.started-lanes.v1");
+function startedLaneStore() {
+  const host = globalThis;
+  let store = host[STARTED_LANES_SYMBOL];
+  if (!store) {
+    store = /* @__PURE__ */ new WeakMap();
+    host[STARTED_LANES_SYMBOL] = store;
+  }
+  return store;
+}
+function recordStartedLane(sessionManager, sessionId) {
+  startedLaneStore().set(sessionManager, sessionId);
+}
+function takeStartedLane(sessionManager) {
+  const store = startedLaneStore();
+  const sessionId = store.get(sessionManager);
+  store.delete(sessionManager);
+  return sessionId;
+}
+function markSessionForRebuild(opts = {}) {
+  const sharedSession = getSharedSession();
+  if (!sharedSession) return;
+  setSharedSession({ ...sharedSession, needsRebuild: true, ...opts.forceRotate ? { forceRotate: true } : {} });
 }
 function setExtensionApi(next) {
   extensionApi = next;
@@ -28428,7 +28875,7 @@ function reportSyntheticToolResultRepair(missing, context) {
       sampledToolCallIds: sampledToolCallIds.slice(0, 12)
     });
     safeNotify(
-      `Claude bridge: ${missing.length} missing tool result(s) repaired with an explicit error placeholder${toolNameSummary.length ? ` for ${toolNameSummary.join(", ")}` : ""}. Real tool output was lost before Claude session import; see ${diagLogPath()}.`,
+      `Claude bridge: ${missing.length} missing tool result(s) repaired with an explicit error placeholder${toolNameSummary.length ? ` for ${toolNameSummary.join(", ")}` : ""}. Real tool output was lost before Claude session import; ${diagGuidance()}.`,
       "error"
     );
   } catch (error51) {
@@ -28442,15 +28889,21 @@ function reportToolResultMismatch(queryCtx, reason, cwd, opts = {}) {
     const hasMismatch = progress.expectedCount > 0 ? progress.unresolvedIds.length > 0 || progress.waitingCount > 0 || progress.queuedCount > 0 || progress.unmatchedResultCount > 0 : progress.waitingCount > 0 || progress.queuedCount > 0 || progress.unmatchedResultCount > 0;
     if (!hasMismatch) return false;
     queryCtx.reportedToolResultMismatch = true;
-    if (sharedSession) {
-      sharedSession = { ...sharedSession, needsRebuild: true, ...opts.forceRotate ? { forceRotate: true } : {} };
-    }
+    if (!queryCtx.detachedFromSharedSession) markSessionForRebuild(opts);
+    if (opts.expectedInterruption) {
+      debug(
+        `tool result delivery interrupted as expected during ${reason}; delivered=${progress.deliveredCount}/${progress.expectedCount} resolved=${progress.resolvedCount}/${progress.expectedCount} waiting=${progress.waitingCount} queued=${progress.queuedCount}`
+      );
+      return true;
+    }
     const toolNameSummary = compactToolNameSummary(progress.toolNames);
+    const sharedSession = getSharedSession();
     diagDump("tool_result_delivery_mismatch", {
       reason,
       cwd,
       progress,
       activeQueryExists: queryCtx.activeQuery !== null,
+      detachedFromSharedSession: queryCtx.detachedFromSharedSession,
       sharedSession: sharedSession ? {
         sessionId: sharedSession.sessionId.slice(0, 8),
         cursor: sharedSession.cursor,
@@ -28469,7 +28922,7 @@ function reportToolResultMismatch(queryCtx, reason, cwd, opts = {}) {
       unmatchedResultIds: progress.unmatchedResultIds
     });
     safeNotify(
-      `Claude bridge: tool result delivery interrupted during ${reason}; delivered ${progress.deliveredCount}/${progress.expectedCount}, resolved ${progress.resolvedCount}/${progress.expectedCount}, waiting=${progress.waitingCount}, queued=${progress.queuedCount}, unmatched=${progress.unmatchedResultCount}${toolNameSummary.length ? `, tools=${toolNameSummary.join(", ")}` : ""}. Claude session will rebuild before the next turn; see ${diagLogPath()}.`,
+      `Claude bridge: tool result delivery interrupted during ${reason}; delivered ${progress.deliveredCount}/${progress.expectedCount}, resolved ${progress.resolvedCount}/${progress.expectedCount}, waiting=${progress.waitingCount}, queued=${progress.queuedCount}, unmatched=${progress.unmatchedResultCount}${toolNameSummary.length ? `, tools=${toolNameSummary.join(", ")}` : ""}. ` + (queryCtx.detachedFromSharedSession ? `Detached one-shot query \u2014 shared Claude session record left untouched; ${diagGuidance()}.` : `Claude session will rebuild before the next turn; ${diagGuidance()}.`),
       "error"
     );
     return true;
@@ -28480,10 +28933,16 @@ function reportToolResultMismatch(queryCtx, reason, cwd, opts = {}) {
 }
 function __testSetBridgeIntegrityState(state) {
   if ("ui" in state) piUI = state.ui;
-  if ("sharedSession" in state) sharedSession = state.sharedSession ?? null;
+  if ("sharedSession" in state) {
+    if (currentRequestLaneId() !== void 0) setSharedSession(state.sharedSession ?? null);
+    else {
+      clearSharedSessionLanes();
+      sharedSessionLaneStore().defaultSession = state.sharedSession ?? null;
+    }
+  }
 }
 function __testGetBridgeIntegrityState() {
-  return { sharedSession };
+  return { sharedSession: getSharedSession() };
 }
 
 // src/connector-audit.ts
@@ -28622,16 +29081,16 @@ function claudeAuthSourceLabel(env = process.env) {
   if (env.ANTHROPIC_AUTH_TOKEN?.trim()) return "ANTHROPIC_AUTH_TOKEN";
   return "Claude Code login";
 }
-function buildNativeProvider(piAi2, models, streamSimple, env = process.env) {
+function buildNativeProvider(piAi2, models, streamSimple, env = process.env, hasCredentials = () => hasClaudeCredentials(env)) {
   if (!supportsNativeProvider(piAi2)) throw new Error(NATIVE_PROVIDER_UNSUPPORTED_MESSAGE);
-  const stamped = models.map((model) => ({ api: "claude-bridge", baseUrl: "claude-bridge", provider: PROVIDER_ID, ...model }));
+  const stamped = models.map((model) => ({ ...model, api: "claude-bridge", baseUrl: "claude-bridge", provider: PROVIDER_ID }));
   const streams = {
     stream: streamSimple,
     streamSimple
   };
   return piAi2.createProvider({
     id: PROVIDER_ID,
-    name: "Claude (Claude Code)",
+    name: "Pi Claude",
     baseUrl: "claude-bridge",
     auth: {
       apiKey: {
@@ -28639,8 +29098,8 @@ function buildNativeProvider(piAi2, models, streamSimple, env = process.env) {
         // check() exists so pi's availability pass never has to call
         // resolve(): both are existence-only, but check is the documented
         // side-effect-free probe.
-        check: async () => hasClaudeCredentials(env) ? { type: "api_key", source: claudeAuthSourceLabel(env) } : void 0,
-        resolve: async () => hasClaudeCredentials(env) ? { auth: { apiKey: "not-used" }, source: claudeAuthSourceLabel(env) } : void 0
+        check: async () => hasCredentials() ? { type: "api_key", source: claudeAuthSourceLabel(env) } : void 0,
+        resolve: async () => hasCredentials() ? { auth: { apiKey: "not-used" }, source: claudeAuthSourceLabel(env) } : void 0
       }
     },
     models: stamped,
@@ -28648,177 +29107,6 @@ function buildNativeProvider(piAi2, models, streamSimple, env = process.env) {
   });
 }
 
-// src/agents-md.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
-import { dirname as dirname3, join as join5, resolve as resolve3 } from "path";
-function globalAgentsPath() {
-  return join5(piUserDir(), "AGENTS.md");
-}
-function resolveAgentsMdPath() {
-  if (isolatedFromEnv()) return void 0;
-  const fromCwd = findAgentsMdInParents(process.cwd());
-  if (fromCwd) return fromCwd;
-  const globalPath = globalAgentsPath();
-  if (existsSync4(globalPath)) return globalPath;
-  return void 0;
-}
-function findAgentsMdInParents(startDir) {
-  let current = resolve3(startDir);
-  while (true) {
-    const candidate = join5(current, "AGENTS.md");
-    if (existsSync4(candidate)) return candidate;
-    const parent = dirname3(current);
-    if (parent === current) break;
-    current = parent;
-  }
-  return void 0;
-}
-function extractAgentsAppend() {
-  const agentsPath = resolveAgentsMdPath();
-  if (!agentsPath) return void 0;
-  try {
-    const content = readFileSync4(agentsPath, "utf-8").trim();
-    if (!content) return void 0;
-    const sanitized = sanitizeAgentsContent(content);
-    return sanitized.length > 0 ? `# CLAUDE.md
-
-${sanitized}` : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function sanitizeAgentsContent(content) {
-  let sanitized = content;
-  sanitized = sanitized.replace(/~\/\.pi\b/gi, "~/.claude");
-  sanitized = sanitized.replace(/(^|[\s'"`])\.pi\//g, "$1.claude/");
-  sanitized = sanitized.replace(/\b\.pi\b/gi, ".claude");
-  sanitized = sanitized.replace(/\bpi\b/gi, "environment");
-  return sanitized;
-}
-
-// src/prompt-context.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
-import { dirname as dirname4, join as join6, resolve as resolve4 } from "path";
-function readTrimmed(path) {
-  try {
-    if (!existsSync5(path)) return void 0;
-    const content = readFileSync5(path, "utf8").trim();
-    return content.length > 0 ? content : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function findProjectAppendSystem(startDir) {
-  let current = resolve4(startDir);
-  while (true) {
-    const candidate = join6(current, ".pi", "APPEND_SYSTEM.md");
-    if (existsSync5(candidate)) return candidate;
-    const parent = dirname4(current);
-    if (parent === current) break;
-    current = parent;
-  }
-  return void 0;
-}
-function readAppendSystemPromptFiles(cwd) {
-  const files = [
-    { label: "global APPEND_SYSTEM.md", path: join6(piUserDir(), "APPEND_SYSTEM.md") }
-  ];
-  const projectPath = isolatedFromEnv() ? void 0 : findProjectAppendSystem(cwd);
-  if (projectPath) files.push({ label: "project .pi/APPEND_SYSTEM.md", path: projectPath });
-  const seen = /* @__PURE__ */ new Set();
-  const output = [];
-  for (const file2 of files) {
-    if (seen.has(file2.path)) continue;
-    seen.add(file2.path);
-    const content = readTrimmed(file2.path);
-    if (content) output.push({ label: file2.label, content });
-  }
-  return output;
-}
-function splitPromptBlocks(systemPrompt) {
-  return (systemPrompt ?? "").split(/\n{2,}/).map((block) => block.trim()).filter(Boolean);
-}
-function extractHeadingSection(systemPrompt, headings) {
-  if (!systemPrompt) return void 0;
-  let start = -1;
-  for (const heading of headings) {
-    const index = systemPrompt.indexOf(heading);
-    if (index >= 0 && (start < 0 || index < start)) start = index;
-  }
-  if (start < 0) return void 0;
-  const rest = systemPrompt.slice(start).trim();
-  const endCandidates = [
-    rest.slice(1).search(/\n##\s+/),
-    rest.search(/\n<\/project_instructions>/),
-    rest.search(/\n<\/project_context>/)
-  ].map((index, offset) => index >= 0 && offset === 0 ? index + 1 : index).filter((index) => index >= 0);
-  const end = endCandidates.length > 0 ? Math.min(...endCandidates) : -1;
-  return (end >= 0 ? rest.slice(0, end) : rest).trim();
-}
-function extractBlockByMarkers(systemPrompt, markers) {
-  for (const block of splitPromptBlocks(systemPrompt)) {
-    if (markers.some((marker) => marker.test(block))) return block;
-  }
-  return void 0;
-}
-function buildPromptContextAppend(systemPrompt, cwd, settings) {
-  const parts = [];
-  const labels = [];
-  if (settings.includeAppendSystemPromptMd) {
-    for (const file2 of readAppendSystemPromptFiles(cwd)) {
-      parts.push(xmlBlock("append_system_prompt", { label: file2.label }, file2.content));
-      labels.push(file2.label);
-    }
-  }
-  if (settings.includeProjectAgentsHook) {
-    const projectAgents = extractHeadingSection(systemPrompt, ["## Project Agents", "## Project Subagents"]);
-    if (projectAgents) {
-      parts.push(xmlBlock("before_agent_start", { source: "project-agents" }, projectAgents));
-      labels.push("project agents hook");
-    }
-  }
-  if (settings.includeTaskPanelHook) {
-    const taskReminder = extractBlockByMarkers(systemPrompt, [/^Task workflow reminder:/]);
-    if (taskReminder) {
-      parts.push(xmlBlock("before_agent_start", { source: "task-panel" }, taskReminder));
-      labels.push("task panel hook");
-    }
-  }
-  if (settings.includeCavemanHook) {
-    const caveman = extractBlockByMarkers(systemPrompt, [/^You MUST respond in caveman /m]);
-    if (caveman) {
-      parts.push(xmlBlock("before_agent_start", { source: "caveman" }, caveman));
-      labels.push("caveman hook");
-    }
-  }
-  if (parts.length === 0) return { labels };
-  return {
-    labels,
-    text: xmlBlock(
-      "forwarded_pi_context",
-      {},
-      [
-        "The following content was explicitly enabled in pi-claude-bridge settings and comes from Pi prompt files or before_agent_start prompt hooks.",
-        ...parts
-      ].join("\n\n"),
-      false
-    )
-  };
-}
-function escapeXmlAttr(value) {
-  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function escapeXmlText(value) {
-  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function xmlBlock(tag, attrs, content, escapeContent = true) {
-  const attrText = Object.entries(attrs).map(([key, value]) => ` ${key}="${escapeXmlAttr(value)}"`).join("");
-  const body = escapeContent ? escapeXmlText(content.trim()) : content.trim();
-  return `<${tag}${attrText}>
-${body}
-</${tag}>`;
-}
-
 // node_modules/zod/v4/classic/external.js
 var external_exports = {};
 __export(external_exports, {
@@ -30254,8 +30542,8 @@ function prettifyError(error51) {
 }
 
 // node_modules/zod/v4/core/parse.js
-var _parse = (_Err) => (schema, value, _ctx2, _params) => {
-  const ctx2 = _ctx2 ? { ..._ctx2, async: false } : { async: false };
+var _parse = (_Err) => (schema, value, _ctx, _params) => {
+  const ctx2 = _ctx ? { ..._ctx, async: false } : { async: false };
   const result = schema._zod.run({ value, issues: [] }, ctx2);
   if (result instanceof Promise) {
     throw new $ZodAsyncError();
@@ -30268,8 +30556,8 @@ var _parse = (_Err) => (schema, value, _ctx2, _params) => {
   return result.value;
 };
 var parse2 = /* @__PURE__ */ _parse($ZodRealError);
-var _parseAsync = (_Err) => async (schema, value, _ctx2, params) => {
-  const ctx2 = _ctx2 ? { ..._ctx2, async: true } : { async: true };
+var _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
+  const ctx2 = _ctx ? { ..._ctx, async: true } : { async: true };
   let result = schema._zod.run({ value, issues: [] }, ctx2);
   if (result instanceof Promise)
     result = await result;
@@ -30281,8 +30569,8 @@ var _parseAsync = (_Err) => async (schema, value, _ctx2, params) => {
   return result.value;
 };
 var parseAsync = /* @__PURE__ */ _parseAsync($ZodRealError);
-var _safeParse = (_Err) => (schema, value, _ctx2) => {
-  const ctx2 = _ctx2 ? { ..._ctx2, async: false } : { async: false };
+var _safeParse = (_Err) => (schema, value, _ctx) => {
+  const ctx2 = _ctx ? { ..._ctx, async: false } : { async: false };
   const result = schema._zod.run({ value, issues: [] }, ctx2);
   if (result instanceof Promise) {
     throw new $ZodAsyncError();
@@ -30293,8 +30581,8 @@ var _safeParse = (_Err) => (schema, value, _ctx2) => {
   } : { success: true, data: result.value };
 };
 var safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
-var _safeParseAsync = (_Err) => async (schema, value, _ctx2) => {
-  const ctx2 = _ctx2 ? { ..._ctx2, async: true } : { async: true };
+var _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
+  const ctx2 = _ctx ? { ..._ctx, async: true } : { async: true };
   let result = schema._zod.run({ value, issues: [] }, ctx2);
   if (result instanceof Promise)
     result = await result;
@@ -30304,40 +30592,40 @@ var _safeParseAsync = (_Err) => async (schema, value, _ctx2) => {
   } : { success: true, data: result.value };
 };
 var safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
-var _encode = (_Err) => (schema, value, _ctx2) => {
-  const ctx2 = _ctx2 ? { ..._ctx2, direction: "backward" } : { direction: "backward" };
+var _encode = (_Err) => (schema, value, _ctx) => {
+  const ctx2 = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
   return _parse(_Err)(schema, value, ctx2);
 };
 var encode = /* @__PURE__ */ _encode($ZodRealError);
-var _decode = (_Err) => (schema, value, _ctx2) => {
-  return _parse(_Err)(schema, value, _ctx2);
+var _decode = (_Err) => (schema, value, _ctx) => {
+  return _parse(_Err)(schema, value, _ctx);
 };
 var decode = /* @__PURE__ */ _decode($ZodRealError);
-var _encodeAsync = (_Err) => async (schema, value, _ctx2) => {
-  const ctx2 = _ctx2 ? { ..._ctx2, direction: "backward" } : { direction: "backward" };
+var _encodeAsync = (_Err) => async (schema, value, _ctx) => {
+  const ctx2 = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
   return _parseAsync(_Err)(schema, value, ctx2);
 };
 var encodeAsync = /* @__PURE__ */ _encodeAsync($ZodRealError);
-var _decodeAsync = (_Err) => async (schema, value, _ctx2) => {
-  return _parseAsync(_Err)(schema, value, _ctx2);
+var _decodeAsync = (_Err) => async (schema, value, _ctx) => {
+  return _parseAsync(_Err)(schema, value, _ctx);
 };
 var decodeAsync = /* @__PURE__ */ _decodeAsync($ZodRealError);
-var _safeEncode = (_Err) => (schema, value, _ctx2) => {
-  const ctx2 = _ctx2 ? { ..._ctx2, direction: "backward" } : { direction: "backward" };
+var _safeEncode = (_Err) => (schema, value, _ctx) => {
+  const ctx2 = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
   return _safeParse(_Err)(schema, value, ctx2);
 };
 var safeEncode = /* @__PURE__ */ _safeEncode($ZodRealError);
-var _safeDecode = (_Err) => (schema, value, _ctx2) => {
-  return _safeParse(_Err)(schema, value, _ctx2);
+var _safeDecode = (_Err) => (schema, value, _ctx) => {
+  return _safeParse(_Err)(schema, value, _ctx);
 };
 var safeDecode = /* @__PURE__ */ _safeDecode($ZodRealError);
-var _safeEncodeAsync = (_Err) => async (schema, value, _ctx2) => {
-  const ctx2 = _ctx2 ? { ..._ctx2, direction: "backward" } : { direction: "backward" };
+var _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
+  const ctx2 = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
   return _safeParseAsync(_Err)(schema, value, ctx2);
 };
 var safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync($ZodRealError);
-var _safeDecodeAsync = (_Err) => async (schema, value, _ctx2) => {
-  return _safeParseAsync(_Err)(schema, value, _ctx2);
+var _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
+  return _safeParseAsync(_Err)(schema, value, _ctx);
 };
 var safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync($ZodRealError);
 
@@ -31531,7 +31819,7 @@ var $ZodCustomStringFormat = /* @__PURE__ */ $constructor("$ZodCustomStringForma
 var $ZodNumber = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => {
   $ZodType.init(inst, def);
   inst._zod.pattern = inst._zod.bag.pattern ?? number;
-  inst._zod.parse = (payload, _ctx2) => {
+  inst._zod.parse = (payload, _ctx) => {
     if (def.coerce)
       try {
         payload.value = Number(payload.value);
@@ -31559,7 +31847,7 @@ var $ZodNumberFormat = /* @__PURE__ */ $constructor("$ZodNumberFormat", (inst, d
 var $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => {
   $ZodType.init(inst, def);
   inst._zod.pattern = boolean;
-  inst._zod.parse = (payload, _ctx2) => {
+  inst._zod.parse = (payload, _ctx) => {
     if (def.coerce)
       try {
         payload.value = Boolean(payload.value);
@@ -31580,7 +31868,7 @@ var $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => {
 var $ZodBigInt = /* @__PURE__ */ $constructor("$ZodBigInt", (inst, def) => {
   $ZodType.init(inst, def);
   inst._zod.pattern = bigint;
-  inst._zod.parse = (payload, _ctx2) => {
+  inst._zod.parse = (payload, _ctx) => {
     if (def.coerce)
       try {
         payload.value = BigInt(payload.value);
@@ -31603,7 +31891,7 @@ var $ZodBigIntFormat = /* @__PURE__ */ $constructor("$ZodBigIntFormat", (inst, d
 });
 var $ZodSymbol = /* @__PURE__ */ $constructor("$ZodSymbol", (inst, def) => {
   $ZodType.init(inst, def);
-  inst._zod.parse = (payload, _ctx2) => {
+  inst._zod.parse = (payload, _ctx) => {
     const input = payload.value;
     if (typeof input === "symbol")
       return payload;
@@ -31620,7 +31908,7 @@ var $ZodUndefined = /* @__PURE__ */ $constructor("$ZodUndefined", (inst, def) =>
   $ZodType.init(inst, def);
   inst._zod.pattern = _undefined;
   inst._zod.values = /* @__PURE__ */ new Set([void 0]);
-  inst._zod.parse = (payload, _ctx2) => {
+  inst._zod.parse = (payload, _ctx) => {
     const input = payload.value;
     if (typeof input === "undefined")
       return payload;
@@ -31637,7 +31925,7 @@ var $ZodNull = /* @__PURE__ */ $constructor("$ZodNull", (inst, def) => {
   $ZodType.init(inst, def);
   inst._zod.pattern = _null;
   inst._zod.values = /* @__PURE__ */ new Set([null]);
-  inst._zod.parse = (payload, _ctx2) => {
+  inst._zod.parse = (payload, _ctx) => {
     const input = payload.value;
     if (input === null)
       return payload;
@@ -31660,7 +31948,7 @@ var $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (inst, def) => {
 });
 var $ZodNever = /* @__PURE__ */ $constructor("$ZodNever", (inst, def) => {
   $ZodType.init(inst, def);
-  inst._zod.parse = (payload, _ctx2) => {
+  inst._zod.parse = (payload, _ctx) => {
     payload.issues.push({
       expected: "never",
       code: "invalid_type",
@@ -31672,7 +31960,7 @@ var $ZodNever = /* @__PURE__ */ $constructor("$ZodNever", (inst, def) => {
 });
 var $ZodVoid = /* @__PURE__ */ $constructor("$ZodVoid", (inst, def) => {
   $ZodType.init(inst, def);
-  inst._zod.parse = (payload, _ctx2) => {
+  inst._zod.parse = (payload, _ctx) => {
     const input = payload.value;
     if (typeof input === "undefined")
       return payload;
@@ -31687,7 +31975,7 @@ var $ZodVoid = /* @__PURE__ */ $constructor("$ZodVoid", (inst, def) => {
 });
 var $ZodDate = /* @__PURE__ */ $constructor("$ZodDate", (inst, def) => {
   $ZodType.init(inst, def);
-  inst._zod.parse = (payload, _ctx2) => {
+  inst._zod.parse = (payload, _ctx) => {
     if (def.coerce) {
       try {
         payload.value = new Date(payload.value);
@@ -32634,7 +32922,7 @@ var $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
   const valuesSet = new Set(values);
   inst._zod.values = valuesSet;
   inst._zod.pattern = new RegExp(`^(${values.filter((k) => propertyKeyTypes.has(typeof k)).map((o) => typeof o === "string" ? escapeRegex(o) : o.toString()).join("|")})$`);
-  inst._zod.parse = (payload, _ctx2) => {
+  inst._zod.parse = (payload, _ctx) => {
     const input = payload.value;
     if (valuesSet.has(input)) {
       return payload;
@@ -32656,7 +32944,7 @@ var $ZodLiteral = /* @__PURE__ */ $constructor("$ZodLiteral", (inst, def) => {
   const values = new Set(def.values);
   inst._zod.values = values;
   inst._zod.pattern = new RegExp(`^(${def.values.map((o) => typeof o === "string" ? escapeRegex(o) : o ? escapeRegex(o.toString()) : String(o)).join("|")})$`);
-  inst._zod.parse = (payload, _ctx2) => {
+  inst._zod.parse = (payload, _ctx) => {
     const input = payload.value;
     if (values.has(input)) {
       return payload;
@@ -32672,7 +32960,7 @@ var $ZodLiteral = /* @__PURE__ */ $constructor("$ZodLiteral", (inst, def) => {
 });
 var $ZodFile = /* @__PURE__ */ $constructor("$ZodFile", (inst, def) => {
   $ZodType.init(inst, def);
-  inst._zod.parse = (payload, _ctx2) => {
+  inst._zod.parse = (payload, _ctx) => {
     const input = payload.value;
     if (input instanceof File)
       return payload;
@@ -32890,7 +33178,7 @@ var $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (inst, def) => {
 });
 var $ZodNaN = /* @__PURE__ */ $constructor("$ZodNaN", (inst, def) => {
   $ZodType.init(inst, def);
-  inst._zod.parse = (payload, _ctx2) => {
+  inst._zod.parse = (payload, _ctx) => {
     if (typeof payload.value !== "number" || !Number.isNaN(payload.value)) {
       payload.issues.push({
         input: payload.value,
@@ -33026,7 +33314,7 @@ var $ZodTemplateLiteral = /* @__PURE__ */ $constructor("$ZodTemplateLiteral", (i
     }
   }
   inst._zod.pattern = new RegExp(`^${regexParts.join("")}$`);
-  inst._zod.parse = (payload, _ctx2) => {
+  inst._zod.parse = (payload, _ctx) => {
     if (typeof payload.value !== "string") {
       payload.issues.push({
         input: payload.value,
@@ -33080,7 +33368,7 @@ var $ZodFunction = /* @__PURE__ */ $constructor("$ZodFunction", (inst, def) => {
       return result;
     };
   };
-  inst._zod.parse = (payload, _ctx2) => {
+  inst._zod.parse = (payload, _ctx) => {
     if (typeof payload.value !== "function") {
       payload.issues.push({
         code: "invalid_type",
@@ -40520,8 +40808,8 @@ function finalize(ctx2, schema) {
     throw new Error("Error converting schema to JSON.");
   }
 }
-function isTransforming(_schema, _ctx2) {
-  const ctx2 = _ctx2 ?? { seen: /* @__PURE__ */ new Set() };
+function isTransforming(_schema, _ctx) {
+  const ctx2 = _ctx ?? { seen: /* @__PURE__ */ new Set() };
   if (ctx2.seen.has(_schema))
     return false;
   ctx2.seen.add(_schema);
@@ -40661,7 +40949,7 @@ var numberProcessor = (schema, ctx2, _json, _params) => {
   if (typeof multipleOf === "number")
     json2.multipleOf = multipleOf;
 };
-var booleanProcessor = (_schema, _ctx2, json2, _params) => {
+var booleanProcessor = (_schema, _ctx, json2, _params) => {
   json2.type = "boolean";
 };
 var bigintProcessor = (_schema, ctx2, _json, _params) => {
@@ -40693,19 +40981,19 @@ var voidProcessor = (_schema, ctx2, _json, _params) => {
     throw new Error("Void cannot be represented in JSON Schema");
   }
 };
-var neverProcessor = (_schema, _ctx2, json2, _params) => {
+var neverProcessor = (_schema, _ctx, json2, _params) => {
   json2.not = {};
 };
-var anyProcessor = (_schema, _ctx2, _json, _params) => {
+var anyProcessor = (_schema, _ctx, _json, _params) => {
 };
-var unknownProcessor = (_schema, _ctx2, _json, _params) => {
+var unknownProcessor = (_schema, _ctx, _json, _params) => {
 };
 var dateProcessor = (_schema, ctx2, _json, _params) => {
   if (ctx2.unrepresentable === "throw") {
     throw new Error("Date cannot be represented in JSON Schema");
   }
 };
-var enumProcessor = (schema, _ctx2, json2, _params) => {
+var enumProcessor = (schema, _ctx, json2, _params) => {
   const def = schema._zod.def;
   const values = getEnumValues(def.entries);
   if (values.every((v2) => typeof v2 === "number"))
@@ -40759,7 +41047,7 @@ var nanProcessor = (_schema, ctx2, _json, _params) => {
     throw new Error("NaN cannot be represented in JSON Schema");
   }
 };
-var templateLiteralProcessor = (schema, _ctx2, json2, _params) => {
+var templateLiteralProcessor = (schema, _ctx, json2, _params) => {
   const _json = json2;
   const pattern = schema._zod.pattern;
   if (!pattern)
@@ -40767,7 +41055,7 @@ var templateLiteralProcessor = (schema, _ctx2, json2, _params) => {
   _json.type = "string";
   _json.pattern = pattern.source;
 };
-var fileProcessor = (schema, _ctx2, json2, _params) => {
+var fileProcessor = (schema, _ctx, json2, _params) => {
   const _json = json2;
   const file2 = {
     type: "string",
@@ -40791,7 +41079,7 @@ var fileProcessor = (schema, _ctx2, json2, _params) => {
     Object.assign(_json, file2);
   }
 };
-var successProcessor = (_schema, _ctx2, json2, _params) => {
+var successProcessor = (_schema, _ctx, json2, _params) => {
   json2.type = "boolean";
 };
 var customProcessor = (_schema, ctx2, _json, _params) => {
@@ -42479,8 +42767,8 @@ var ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
   $ZodTransform.init(inst, def);
   ZodType.init(inst, def);
   inst._zod.processJSONSchema = (ctx2, json2, params) => transformProcessor(inst, ctx2, json2, params);
-  inst._zod.parse = (payload, _ctx2) => {
-    if (_ctx2.direction === "backward") {
+  inst._zod.parse = (payload, _ctx) => {
+    if (_ctx.direction === "backward") {
       throw new $ZodEncodeError(inst.constructor.name);
     }
     payload.addIssue = (issue2) => {
@@ -43382,9 +43670,6 @@ function jsonSchemaToZodShape(schema) {
   return shape;
 }
 
-// src/index.ts
-import { readFileSync as nodeReadFileSync } from "node:fs";
-
 // src/pi-ai-compat.ts
 var dynamicImport = (specifier) => import(specifier);
 async function resolveGetModels(root, loadCompat = () => dynamicImport("@earendil-works/pi-ai/compat")) {
@@ -43396,32 +43681,39 @@ async function resolveGetModels(root, loadCompat = () => dynamicImport("@earendi
 
 // src/connector-cache.ts
 import { createHash } from "node:crypto";
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync } from "node:fs";
-import { dirname as dirname5, join as join7 } from "node:path";
-var CACHE_VERSION = 1;
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync } from "node:fs";
+import { dirname as dirname3, join as join5 } from "node:path";
+var CACHE_VERSION = 2;
 var MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+function scopeKeyFor(claudeConfigDir) {
+  return claudeConfigDir?.trim() || "<default>";
+}
 function connectorCacheScopeKey(env = process.env) {
-  return env.CLAUDE_CONFIG_DIR?.trim() || "<default>";
+  return scopeKeyFor(env.CLAUDE_CONFIG_DIR);
+}
+function connectorCacheScopeDigest(scopeKey) {
+  return createHash("sha256").update(scopeKey).digest("hex");
 }
 function connectorCachePath(scopeKey = connectorCacheScopeKey()) {
-  const digest = createHash("sha256").update(scopeKey).digest("hex").slice(0, 16);
-  return join7(piUserDir(), "connector-cache", `${digest}.json`);
+  const digest = connectorCacheScopeDigest(scopeKey).slice(0, 16);
+  return join5(piUserDir(), "connector-cache", `${digest}.json`);
 }
 function readCachedConnectors(scopeKey = connectorCacheScopeKey(), now = Date.now()) {
   let raw;
   try {
-    raw = readFileSync6(connectorCachePath(scopeKey), "utf8");
+    raw = readFileSync4(connectorCachePath(scopeKey), "utf8");
   } catch {
     return void 0;
   }
   let parsed;
   try {
     parsed = JSON.parse(raw);
-  } catch {
+  } catch (error51) {
+    debug(`connector-cache: corrupt cache ${connectorCachePath(scopeKey)}:`, error51 instanceof Error ? error51.message : String(error51));
     return void 0;
   }
   if (parsed?.version !== CACHE_VERSION) return void 0;
-  if (parsed?.scope !== scopeKey) return void 0;
+  if (parsed?.scope !== connectorCacheScopeDigest(scopeKey)) return void 0;
   const savedAt = typeof parsed?.savedAt === "number" ? parsed.savedAt : 0;
   if (!savedAt || now - savedAt > MAX_AGE_MS || savedAt > now) return void 0;
   if (!Array.isArray(parsed?.connectors)) return void 0;
@@ -43434,26 +43726,112 @@ function writeCachedConnectors(connectors, scopeKey = connectorCacheScopeKey(),
   if (!Array.isArray(connectors) || connectors.length === 0) return false;
   const path = connectorCachePath(scopeKey);
   try {
-    mkdirSync3(dirname5(path), { recursive: true, mode: 448 });
+    mkdirSync3(dirname3(path), { recursive: true, mode: 448 });
     writeFileSync(
       path,
-      JSON.stringify({ version: CACHE_VERSION, scope: scopeKey, savedAt: now, connectors }),
+      JSON.stringify({ version: CACHE_VERSION, scope: connectorCacheScopeDigest(scopeKey), savedAt: now, connectors }),
       { mode: 384 }
     );
     return true;
-  } catch {
+  } catch (error51) {
+    debug(`connector-cache: write failed ${path}:`, error51 instanceof Error ? error51.message : String(error51));
     return false;
   }
 }
 
+// src/connector-runtime.ts
+import { readFileSync as nodeReadFileSync } from "node:fs";
+function readCredentialFile(path) {
+  try {
+    return nodeReadFileSync(path, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+var connectorServerCache = /* @__PURE__ */ new Map();
+var connectorServerPending = /* @__PURE__ */ new Set();
+var connectorServerFailureAt = /* @__PURE__ */ new Map();
+var CONNECTOR_PRIME_TIMEOUT_MS = 1e4;
+var CONNECTOR_PRIME_FAILURE_COOLDOWN_MS = 6e4;
+function connectorScopeKey(claudeConfigDir = process.env.CLAUDE_CONFIG_DIR) {
+  return scopeKeyFor(claudeConfigDir);
+}
+function connectorCredentialEnv(claudeConfigDir = process.env.CLAUDE_CONFIG_DIR) {
+  const env = { ...process.env };
+  if (claudeConfigDir?.trim()) env.CLAUDE_CONFIG_DIR = claudeConfigDir.trim();
+  else delete env.CLAUDE_CONFIG_DIR;
+  return env;
+}
+function primeConnectorServers(claudeConfigDir, overrides = {}) {
+  const key = connectorScopeKey(claudeConfigDir);
+  if (connectorServerCache.has(key) || connectorServerPending.has(key)) return;
+  const now = overrides.now ?? Date.now;
+  const cooldownMs = overrides.failureCooldownMs ?? CONNECTOR_PRIME_FAILURE_COOLDOWN_MS;
+  const failedAt = connectorServerFailureAt.get(key);
+  if (failedAt !== void 0 && now() - failedAt < cooldownMs) {
+    debug("connectors: prime cooling down after failure; declaring none until retry window opens");
+    return;
+  }
+  connectorServerPending.add(key);
+  void (async () => {
+    let failed = false;
+    try {
+      const credentials = resolveClaudeOAuth(readCredentialFile, connectorCredentialEnv(claudeConfigDir));
+      if (!credentials) {
+        debug("connectors: no OAuth credentials; declaring none (will retry)");
+        return;
+      }
+      const inventory = await listAccountConnectors({
+        credentials,
+        // A hung inventory request must not outlive the deadline: the abort
+        // surfaces as `ok: false` and takes the cooldown path below.
+        signal: AbortSignal.timeout(overrides.timeoutMs ?? CONNECTOR_PRIME_TIMEOUT_MS)
+      });
+      if (!inventory.ok) {
+        failed = true;
+        debug(`connectors: inventory failed (${inventory.reason}); declaring none (will retry after cooldown)`);
+        return;
+      }
+      const servers = connectorMcpServers(inventory);
+      debug(
+        `connectors: declaring ${Object.keys(servers).length} of ${inventory.connectors.length} installed`,
+        Object.keys(servers).join(", ") || "none"
+      );
+      connectorServerCache.set(key, servers);
+      connectorServerFailureAt.delete(key);
+      if (writeCachedConnectors(inventory.connectors, key)) {
+        debug(`connectors: cached ${inventory.connectors.length} entries`);
+      }
+    } catch (error51) {
+      failed = true;
+      debug("connectors: declaration lookup threw; declaring none (will retry after cooldown)", error51);
+    } finally {
+      if (failed) connectorServerFailureAt.set(key, now());
+      connectorServerPending.delete(key);
+    }
+  })();
+}
+function connectorServersSnapshot(claudeConfigDir) {
+  const key = connectorScopeKey(claudeConfigDir);
+  const ready = connectorServerCache.get(key);
+  if (ready) return ready;
+  primeConnectorServers(claudeConfigDir);
+  const cached2 = readCachedConnectors(key);
+  if (!cached2) return {};
+  const servers = connectorMcpServers({ ok: true, complete: true, connectors: cached2 });
+  if (Object.keys(servers).length === 0) return {};
+  debug(`connectors: turn-1 declarations from cache \u2014 ${Object.keys(servers).join(", ")}`);
+  return servers;
+}
+
 // src/claude-executable.ts
 import { spawn as spawnProcess } from "child_process";
-import { accessSync, constants as fsConstants, readFileSync as readFileSync7, realpathSync as realpathSync2, statSync as statSync2 } from "fs";
-import { delimiter, join as join8 } from "path";
+import { accessSync, constants as fsConstants, readFileSync as readFileSync5, realpathSync as realpathSync2, statSync as statSync2 } from "fs";
+import { delimiter, join as join6 } from "path";
 function executableFromPath(name) {
   const paths = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
   for (const dir of paths) {
-    const candidate = join8(dir, name);
+    const candidate = join6(dir, name);
     try {
       accessSync(candidate, fsConstants.X_OK);
       return candidate;
@@ -43569,7 +43947,7 @@ function preflightClaudeExecutable(path, cwd) {
   }
   let fileType;
   try {
-    fileType = classifyClaudeExecutableBytes(readFileSync7(realPath).subarray(0, 16));
+    fileType = classifyClaudeExecutableBytes(readFileSync5(realPath).subarray(0, 16));
   } catch (err) {
     throw makeClaudePreflightError("Claude Code executable preflight failed: cannot read executable header before spawning Claude Code.", {
       code: codeValue(err, "EACCES"),
@@ -43662,19 +44040,19 @@ function spawnClaudeCodeWithDiagnostics(options) {
   };
 }
 
-// node_modules/cc-session-io/dist/chunk-D6EZBJOC.js
+// node_modules/cc-session-io/dist/chunk-7RWUSC7F.js
 import { randomUUID } from "crypto";
-import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync2, appendFileSync as appendFileSync3, existsSync as existsSync6, rmSync as rmSync2 } from "fs";
-import { dirname as dirname6 } from "path";
-import { readFileSync as readFileSync8 } from "fs";
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync2, appendFileSync as appendFileSync3, existsSync as existsSync4, rmSync as rmSync2 } from "fs";
+import { dirname as dirname4 } from "path";
+import { readFileSync as readFileSync6 } from "fs";
 import { realpathSync as realpathSync3 } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join9 } from "path";
+import { join as join7 } from "path";
 function parseJsonl(content) {
   return content.split("\n").filter((line) => line.trim()).map(parseRecord);
 }
 function parseJsonlFile(path) {
-  return parseJsonl(readFileSync8(path, "utf-8"));
+  return parseJsonl(readFileSync6(path, "utf-8"));
 }
 function parseRecord(line) {
   const raw = JSON.parse(line);
@@ -43687,7 +44065,7 @@ function serializeRecord(record2) {
 }
 var MAX_SANITIZED_LENGTH = 200;
 function getClaudeDir(claudeDir) {
-  return claudeDir ?? process.env.CLAUDE_CONFIG_DIR ?? join9(homedir3(), ".claude");
+  return claudeDir ?? process.env.CLAUDE_CONFIG_DIR ?? join7(homedir3(), ".claude");
 }
 function normalizeProjectPath(projectPath) {
   try {
@@ -43705,10 +44083,10 @@ function projectPathToHash(projectPath) {
   return `${sanitized.slice(0, MAX_SANITIZED_LENGTH)}-${Math.abs(h).toString(36)}`;
 }
 function getProjectDir(projectPath, claudeDir) {
-  return join9(getClaudeDir(claudeDir), "projects", projectPathToHash(normalizeProjectPath(projectPath)));
+  return join7(getClaudeDir(claudeDir), "projects", projectPathToHash(normalizeProjectPath(projectPath)));
 }
 function getSessionPath(sessionId, projectPath, claudeDir) {
-  return join9(getProjectDir(projectPath, claudeDir), `${sessionId}.jsonl`);
+  return join7(getProjectDir(projectPath, claudeDir), `${sessionId}.jsonl`);
 }
 function repairToolPairing(messages) {
   const result = [];
@@ -43920,13 +44298,16 @@ var Session = class {
     this._lastUuid = uuid3;
     return record2;
   }
-  /** Add a user text message. Returns its uuid. */
-  addUserMessage(text) {
+  /** Add a user message, as plain text or content blocks. Returns its uuid. */
+  addUserMessage(content) {
+    if (Array.isArray(content) && content.length === 0) {
+      throw new Error("addUserMessage: content array is empty; Anthropic rejects empty message content");
+    }
     const base = this.baseFields();
     const record2 = {
       type: "user",
       ...base,
-      message: { role: "user", content: text }
+      message: { role: "user", content }
     };
     this._pendingRecords.push(record2);
     return base.uuid;
@@ -44014,16 +44395,17 @@ var Session = class {
           const toolResults = msg.content.filter(
             (b) => b.type === "tool_result"
           );
+          const rest = msg.content.filter(
+            (b) => b.type !== "tool_result"
+          );
           if (toolResults.length > 0) {
             this.addToolResults(toolResults.map((r) => ({
               toolUseId: r.tool_use_id,
               content: r.content,
               isError: r.is_error
             })));
-          } else {
-            const text = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
-            this.addUserMessage(text || JSON.stringify(msg.content));
           }
+          if (rest.length > 0) this.addUserMessage(rest);
         }
       }
     }
@@ -44043,8 +44425,8 @@ var Session = class {
   /** Write pending records to disk. Creates the file/directory if needed. */
   save() {
     if (this._pendingRecords.length === 0) return;
-    const dir = dirname6(this.jsonlPath);
-    if (!existsSync6(dir)) {
+    const dir = dirname4(this.jsonlPath);
+    if (!existsSync4(dir)) {
       mkdirSync4(dir, { recursive: true });
     }
     const data = this._pendingRecords.map((r) => serializeRecord(r) + "\n").join("");
@@ -44183,25 +44565,286 @@ function verifyWrittenSession(jsonlPath, expectedSessionId, expectedRecordCount)
   return warnings;
 }
 
-// src/session-persistence.ts
-var BRIDGE_SESSION_CUSTOM_TYPE = "claude-bridge-session";
-function fingerprintMessages(messages) {
-  const normalized = messages.map((message) => {
-    if (message.role === "assistant") {
-      return {
-        role: message.role,
-        provider: message.provider,
-        model: message.model,
-        content: message.content
-      };
-    }
-    return message;
-  });
-  return createHash2("sha256").update(JSON.stringify(normalized)).digest("hex");
+// src/account-router.ts
+import { homedir as homedir4 } from "node:os";
+import { join as join8 } from "node:path";
+
+// src/rate-limit.ts
+var RATE_LIMIT_AUTO_RESUME_EVENT = "vstack:rate-limit";
+var RATE_LIMIT_TOKEN = "\x1B[31m[rate-limit]\x1B[39m";
+var USAGE_LIMIT_PREFIXES = Array.isArray(qO) ? qO : [];
+function coerceMessageText(value) {
+  if (typeof value === "string") return value;
+  if (value instanceof Error) return value.message;
+  try {
+    return JSON.stringify(value ?? "");
+  } catch {
+    return String(value);
+  }
 }
-function readBuiltSessionContext(sessionManager) {
-  const built = typeof sessionManager?.buildSessionContext === "function" ? sessionManager.buildSessionContext() : void 0;
-  return Array.isArray(built?.messages) ? built : void 0;
+function isUsageLimitMessage(value) {
+  const text = coerceMessageText(value);
+  return USAGE_LIMIT_PREFIXES.some((prefix) => text.includes(prefix));
+}
+function uniqueNonEmptyLines(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const value of values) {
+    const text = typeof value === "string" ? value.trim() : value == null ? "" : String(value).trim();
+    if (!text || seen.has(text)) continue;
+    seen.add(text);
+    out.push(text);
+  }
+  return out;
+}
+function resetTimestampMs(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return Math.abs(value) < 1e12 ? value * 1e3 : value;
+  }
+  if (typeof value !== "string" || !value.trim()) return void 0;
+  const numeric = Number(value);
+  if (Number.isFinite(numeric)) return Math.abs(numeric) < 1e12 ? numeric * 1e3 : numeric;
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function formatResetTimestamp(value) {
+  const parsed = resetTimestampMs(value);
+  if (parsed === void 0) return "unknown";
+  return new Date(parsed).toLocaleString(void 0, {
+    day: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+    month: "short",
+    second: "2-digit",
+    timeZoneName: "short",
+    year: "numeric"
+  });
+}
+var ALLOWED_RATE_LIMIT_WARNING_UTILIZATION_THRESHOLD = 80;
+function normalizeRateLimitUtilization(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return void 0;
+  if (value === 0) return 0;
+  if (value > 0 && value <= 1) return value * 100;
+  if (value > 1 && value <= 100) return value;
+  return void 0;
+}
+function rateLimitTypeLabel(value) {
+  const text = typeof value === "string" ? value.trim() : "";
+  return text || "unknown";
+}
+function formatAllowedRateLimitWarning(info) {
+  if (info?.status !== "allowed_warning") return void 0;
+  const utilization = normalizeRateLimitUtilization(info.utilization);
+  if (utilization === void 0 || utilization < ALLOWED_RATE_LIMIT_WARNING_UTILIZATION_THRESHOLD) return void 0;
+  return `Claude rate limit warning: nearing ${rateLimitTypeLabel(info.rateLimitType)} limit; check Claude Code /usage for exact utilization.`;
+}
+
+// src/account-router.ts
+var CLAUDE_ACCOUNT_ROUTER_SYMBOL = /* @__PURE__ */ Symbol.for("vstack.pi.claude-account-router.v1");
+var CLAUDE_BRIDGE_ACCOUNT_HOST_SYMBOL = /* @__PURE__ */ Symbol.for("vstack.pi.claude-bridge.account-host.v1");
+function resolveClaudeAccountRouter() {
+  const host = globalThis;
+  const candidate = host[CLAUDE_ACCOUNT_ROUTER_SYMBOL];
+  return candidate?.version === 1 ? candidate : void 0;
+}
+function safeRouterCall(label, call) {
+  try {
+    call();
+  } catch (error51) {
+    debug(`router callback ${label} threw:`, error51);
+  }
+}
+function subscriberProfileEnv(profile, base = process.env) {
+  const env = { ...base };
+  const directOverrides = /* @__PURE__ */ new Set([
+    "ANTHROPIC_API_KEY",
+    "ANTHROPIC_AUTH_TOKEN",
+    "ANTHROPIC_OAUTH_TOKEN",
+    "CLAUDE_CODE_OAUTH_TOKEN",
+    "ANTHROPIC_BASE_URL",
+    "ANTHROPIC_CUSTOM_HEADERS",
+    "ANTHROPIC_AWS_API_KEY",
+    "ANTHROPIC_FOUNDRY_AUTH_TOKEN",
+    "ANTHROPIC_BEDROCK_BASE_URL",
+    "ANTHROPIC_VERTEX_BASE_URL",
+    "ANTHROPIC_FOUNDRY_BASE_URL",
+    "AWS_BEARER_TOKEN_BEDROCK"
+  ]);
+  for (const key of Object.keys(env)) {
+    if (directOverrides.has(key) || key.startsWith("CLAUDE_CODE_USE_")) delete env[key];
+  }
+  if (profile.configDir) env.CLAUDE_CONFIG_DIR = profile.configDir;
+  else delete env.CLAUDE_CONFIG_DIR;
+  return env;
+}
+function claudeDirForProfile(profile) {
+  return profile.configDir?.trim() || join8(homedir4(), ".claude");
+}
+function accountSessionScope(profile) {
+  return profile ? { accountProfileId: profile.profileId, claudeConfigDir: claudeDirForProfile(profile) } : {};
+}
+function commitsVisibleOutput(event) {
+  if (event.type === "text_delta" || event.type === "thinking_delta" || event.type === "toolcall_delta") {
+    return event.delta.length > 0;
+  }
+  if (event.type === "text_end" || event.type === "thinking_end") return event.content.length > 0;
+  return event.type === "toolcall_end";
+}
+var RetryEventBuffer = class {
+  pending = [];
+  committed = false;
+  ended = false;
+  discarded = false;
+  target;
+  onCommit;
+  constructor(target, onCommit) {
+    this.target = target;
+    this.onCommit = onCommit;
+  }
+  push(event) {
+    if (this.discarded) return;
+    if (this.committed) {
+      this.target.push(event);
+      return;
+    }
+    this.pending.push(event);
+    if (commitsVisibleOutput(event) || event.type === "done" || event.type === "error") this.commit();
+  }
+  end() {
+    if (this.discarded) return;
+    this.ended = true;
+    if (this.committed) this.target.end();
+  }
+  commit() {
+    if (this.discarded || this.committed) return;
+    this.committed = true;
+    this.onCommit?.();
+    for (const event of this.pending) this.target.push(event);
+    this.pending.length = 0;
+    if (this.ended) this.target.end();
+  }
+  discard() {
+    if (this.committed) return;
+    this.discarded = true;
+    this.pending.length = 0;
+  }
+  get hasCommittedOutput() {
+    return this.committed;
+  }
+};
+function rateLimitTypeFromInfo(info) {
+  return info?.rateLimitType ?? info?.rate_limit_type ?? info?.type;
+}
+function rateLimitResetFromInfo(info) {
+  return info?.resetsAt ?? info?.resets_at ?? info?.resetAt ?? info?.reset_at;
+}
+function rateLimitResetMs(info) {
+  return resetTimestampMs(rateLimitResetFromInfo(info));
+}
+function httpStatusInText(normalized) {
+  const match = /\b(?:http|https|status(?: code)?|error|code)\b[^a-z0-9]{0,4}([45]\d\d)\b/.exec(normalized);
+  return match ? Number(match[1]) : void 0;
+}
+function classifyStatusCode(status) {
+  if (status === 401) return "auth";
+  if (status === 403) return "auth";
+  if (status === 402) return "billing";
+  if (status === 429) return "rate-limit";
+  if (status === 529) return "overloaded";
+  if (status >= 500 && status <= 599) return "server";
+  return void 0;
+}
+function classifyClaudeFailure(value) {
+  const details = [value];
+  let numericStatus;
+  if (value && typeof value === "object") {
+    const record2 = value;
+    details.push(record2.name, record2.type, record2.message, record2.code, record2.status, record2.statusCode, record2.body, record2.error);
+    for (const field of [record2.status, record2.statusCode]) {
+      if (typeof field === "number" && Number.isInteger(field)) {
+        numericStatus = field;
+        break;
+      }
+    }
+  }
+  const text = details.map((detail) => {
+    if (typeof detail === "string" || typeof detail === "number") return String(detail);
+    try {
+      return JSON.stringify(detail ?? "");
+    } catch {
+      return String(detail);
+    }
+  }).join(" ");
+  const normalized = text.toLowerCase().replace(/[_-]+/g, " ");
+  const statusKind = numericStatus !== void 0 ? classifyStatusCode(numericStatus) : void 0;
+  if (statusKind) return statusKind;
+  if (/authentication (?:failed|error)|permission error|oauth org not allowed|oauth token.*expired|token.*expired|unauthorized|invalid token|login required|please run .*login|not logged in/.test(normalized) || httpStatusInText(normalized) === 401 || httpStatusInText(normalized) === 403) return "auth";
+  if (/extra usage|overage/.test(normalized)) return "rate-limit";
+  if (/billing error|payment|required.*billing|credit balance.*(?:low|insufficient|empty)|insufficient credits/.test(normalized)) return "billing";
+  const quotaInUsageContext = /\bquota\b/.test(normalized) && /\b(?:rate|usage|limits?|requests?|tokens?|messages?|api)\b/.test(normalized);
+  if (/\brate limit|usage limit|session limit|weekly limit|monthly limit|limit reached|you(?:'|’)ve hit your .* limit|too many requests|resets? (?:at )?\d/.test(normalized) || quotaInUsageContext || httpStatusInText(normalized) === 429) return "rate-limit";
+  if (/overloaded|capacity/.test(normalized) || httpStatusInText(normalized) === 529) return "overloaded";
+  const statusInText = httpStatusInText(normalized);
+  if (/server error|internal server/.test(normalized) || statusInText !== void 0 && statusInText >= 500) return "server";
+  if (/network|timeout|timed out|socket|econn|connection closed|fetch failed|unexpected end|\beof\b/.test(normalized)) return "network";
+  return void 0;
+}
+
+// src/session-persistence.ts
+var BRIDGE_SESSION_CUSTOM_TYPE = "claude-bridge-session";
+function normalizedMessageText(message) {
+  const content = message.content;
+  const text = typeof content === "string" ? content : Array.isArray(content) ? content.map((block) => block.type === "text" ? block.text ?? "" : "").join("\n") : "";
+  return text.trim();
+}
+function shortHash(text) {
+  return createHash2("sha256").update(text).digest("hex").slice(0, 12);
+}
+function conversationFingerprint(messages) {
+  const firstUser = messages.find((message) => message.role === "user");
+  if (!firstUser) return void 0;
+  const userText = normalizedMessageText(firstUser);
+  if (!userText) return void 0;
+  const firstAssistant = messages.find((message) => message.role === "assistant");
+  const assistantText = firstAssistant ? normalizedMessageText(firstAssistant) : "";
+  return assistantText ? `u:${shortHash(userText)}|a:${shortHash(assistantText)}` : `u:${shortHash(userText)}`;
+}
+function parseConversationFingerprint(fp2) {
+  const match = /^u:([0-9a-f]+)(?:\|a:([0-9a-f]+))?$/.exec(fp2);
+  if (!match) return void 0;
+  return { user: match[1], ...match[2] ? { assistant: match[2] } : {} };
+}
+function conversationFingerprintsMatch(recorded, incoming) {
+  const rec = parseConversationFingerprint(recorded);
+  const inc = parseConversationFingerprint(incoming);
+  if (!rec || !inc) return true;
+  if (rec.user !== inc.user) return false;
+  return !(rec.assistant && inc.assistant && rec.assistant !== inc.assistant);
+}
+function conversationFingerprintUpgrade(recorded, incoming) {
+  if (!incoming) return void 0;
+  if (!recorded) return incoming;
+  const rec = parseConversationFingerprint(recorded);
+  const inc = parseConversationFingerprint(incoming);
+  return rec && inc && !rec.assistant && inc.assistant && rec.user === inc.user ? incoming : void 0;
+}
+function fingerprintMessages(messages) {
+  const normalized = messages.map((message) => {
+    if (message.role === "assistant") {
+      return {
+        role: message.role,
+        provider: message.provider,
+        model: message.model,
+        content: message.content
+      };
+    }
+    return message;
+  });
+  return createHash2("sha256").update(JSON.stringify(normalized)).digest("hex");
+}
+function readBuiltSessionContext(sessionManager) {
+  const built = typeof sessionManager?.buildSessionContext === "function" ? sessionManager.buildSessionContext() : void 0;
+  return Array.isArray(built?.messages) ? built : void 0;
 }
 function latestPersistedBridgeSession(sessionManager) {
   const entries = typeof sessionManager?.getEntries === "function" ? sessionManager.getEntries() : [];
@@ -44215,9 +44858,9 @@ function latestPersistedBridgeSession(sessionManager) {
   }
   return void 0;
 }
-function claudeSessionExists(sessionId, cwd) {
+function claudeSessionExists(sessionId, cwd, claudeDir) {
   try {
-    const session = openSession({ sessionId, projectPath: cwd, claudeDir: process.env.CLAUDE_CONFIG_DIR });
+    const session = openSession({ sessionId, projectPath: cwd, claudeDir });
     statSync4(session.jsonlPath);
     return true;
   } catch {
@@ -44260,34 +44903,72 @@ function restoreSharedSessionFromPi(ctx2) {
     debug(`restoreSharedSession: fingerprint mismatch for ${persisted.sessionId.slice(0, 8)}`);
     return;
   }
-  if (!claudeSessionExists(persisted.sessionId, persisted.cwd)) {
+  const accountProfileId = typeof persisted.accountProfileId === "string" ? persisted.accountProfileId : void 0;
+  const claudeConfigDir = accountProfileId ? claudeDirForProfile(resolveClaudeAccountRouter()?.resolveProfile?.(accountProfileId) ?? {}) : void 0;
+  if (!claudeSessionExists(persisted.sessionId, persisted.cwd, claudeConfigDir ?? process.env.CLAUDE_CONFIG_DIR)) {
     debug(`restoreSharedSession: Claude session missing for ${persisted.sessionId.slice(0, 8)}`);
     return;
   }
-  setSharedSession({ sessionId: persisted.sessionId, cursor, cwd: persisted.cwd });
-  debug(`restoreSharedSession: restored ${persisted.sessionId.slice(0, 8)}, cursor=${cursor}`);
+  setSharedSession({
+    sessionId: persisted.sessionId,
+    cursor,
+    cwd: persisted.cwd,
+    // Absent on pre-3.1.1 markers: restore as identity-unknown (the foreign
+    // guard fails open) rather than rejecting the entry.
+    ...typeof persisted.conversationFingerprint === "string" ? { conversationFingerprint: persisted.conversationFingerprint } : {},
+    ...accountProfileId ? { accountProfileId, claudeConfigDir } : {}
+  });
+  debug(`restoreSharedSession: restored ${persisted.sessionId.slice(0, 8)}, cursor=${cursor}, account=${accountProfileId ?? "default"}`);
+}
+var SCHEDULED_PERSISTENCE_SYMBOL = /* @__PURE__ */ Symbol.for("vstack.pi.claude-bridge.scheduled-persistence.v1");
+function scheduledPersistenceTimers() {
+  const host = globalThis;
+  let store = host[SCHEDULED_PERSISTENCE_SYMBOL];
+  if (!store) {
+    store = /* @__PURE__ */ new Map();
+    host[SCHEDULED_PERSISTENCE_SYMBOL] = store;
+  }
+  return store;
+}
+function cancelScheduledSessionPersistence(sessionManager) {
+  const timers = scheduledPersistenceTimers();
+  const timer = timers.get(sessionManager);
+  if (timer === void 0) return;
+  clearTimeout(timer);
+  timers.delete(sessionManager);
 }
 function schedulePersistSharedSession(ctxLike) {
+  const sharedSession = getSharedSession();
   if (!extensionApi || !sharedSession || !ctxLike?.sessionManager) return;
-  const snapshot = { ...sharedSession };
+  const sessionManager = ctxLike.sessionManager;
+  const { claudeConfigDir: _omitted, ...snapshot } = sharedSession;
+  const timers = scheduledPersistenceTimers();
+  const superseded = timers.get(sessionManager);
+  if (superseded !== void 0) clearTimeout(superseded);
   const timer = setTimeout(() => {
+    if (timers.get(sessionManager) === timer) timers.delete(sessionManager);
     try {
-      const built = readBuiltSessionContext(ctxLike.sessionManager);
+      const built = readBuiltSessionContext(sessionManager);
       if (!built) return;
       const cursor = Math.max(0, Math.min(snapshot.cursor, built.messages.length));
       const data = {
         ...snapshot,
         cursor,
         fingerprint: fingerprintMessages(built.messages.slice(0, cursor)),
-        piSessionId: typeof ctxLike.sessionManager?.getSessionId === "function" ? ctxLike.sessionManager.getSessionId() : void 0,
+        piSessionId: typeof sessionManager?.getSessionId === "function" ? sessionManager.getSessionId() : void 0,
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       };
       extensionApi?.appendEntry(BRIDGE_SESSION_CUSTOM_TYPE, data);
       debug(`persistSharedSession: saved ${data.sessionId.slice(0, 8)}, cursor=${data.cursor}`);
     } catch (error51) {
-      debug("persistSharedSession failed:", error51);
+      diagDump("persist_shared_session_failed", {
+        sessionId: snapshot.sessionId.slice(0, 8),
+        cursor: snapshot.cursor,
+        error: error51 instanceof Error ? `${error51.name}: ${error51.message}` : String(error51)
+      });
     }
   }, 0);
+  timers.set(sessionManager, timer);
   timer.unref?.();
 }
 function convertAndImportMessages(session, messages, customToolNameToSdk, cwd) {
@@ -44305,6 +44986,13 @@ function convertAndImportMessages(session, messages, customToolNameToSdk, cwd) {
       [...sanitizedIds.entries()].map(([orig, clean]) => orig === clean ? orig : `${orig}\u2192${clean}`).join(", ")
     );
   }
+  const recoveredToolResults = recoverLaterToolResults(anthropicMessages);
+  if (recoveredToolResults.length > 0) {
+    debug(
+      `convertAndImportMessages: recovered ${recoveredToolResults.length} later tool result(s) for original parallel batch`,
+      recoveredToolResults.map((item) => item.id).join(", ")
+    );
+  }
   const missingToolResults = findUnpairedToolUses(anthropicMessages);
   if (missingToolResults.length > 0) insertLostToolResultPlaceholders(anthropicMessages, missingToolResults);
   const repaired = repairToolPairing(anthropicMessages);
@@ -44322,17 +45010,37 @@ function convertAndImportMessages(session, messages, customToolNameToSdk, cwd) {
   }
   if (repaired.length) session.importMessages(repaired);
 }
-function verifyWrittenSession2(jsonlPath, expectedSessionId, expectedRecordCount, cwd) {
+function planIncrementalPromptBatch(messages, cursor) {
+  const lastIndex = messages.length - 1;
+  if (lastIndex < 0 || messages[lastIndex].role !== "user") return void 0;
+  if (cursor > lastIndex) {
+    debug(`planIncrementalPromptBatch: rejected \u2014 cursor=${cursor} beyond last index ${lastIndex}; messages are not the conversation this cursor describes`);
+    return void 0;
+  }
+  const boundedCursor = Math.max(0, cursor);
+  let promptStart = boundedCursor;
+  if (messages[promptStart]?.role === "assistant") promptStart++;
+  const pendingPrompts = messages.slice(promptStart);
+  if (pendingPrompts.length === 0 || pendingPrompts.some((message) => message.role !== "user")) {
+    debug(`planIncrementalPromptBatch: rejected \u2014 cursor=${cursor} promptStart=${promptStart} tail roles=[${messages.slice(boundedCursor).map((m) => m.role).join(", ")}]`);
+    return void 0;
+  }
+  return {
+    promptStart,
+    userMessageCount: pendingPrompts.length
+  };
+}
+function verifyWrittenSession2(jsonlPath, expectedSessionId, expectedRecordCount, cwd, claudeDir) {
   const warnings = verifyWrittenSession(jsonlPath, expectedSessionId, expectedRecordCount);
   for (const msg of warnings) {
     debug(`WARNING session verify: ${msg}`);
-    piUI?.notify(
+    safeNotify(
       `Session file issue: ${msg}
-cwd=${cwd} realpath=${safeRealpath(cwd)} CLAUDE_CONFIG_DIR=${process.env.CLAUDE_CONFIG_DIR ?? "(unset)"}
-Please copy and paste this message into a new issue at https://github.com/elidickinson/pi-claude-bridge/issues/new` + (DEBUG ? ` and attach ${DEBUG_LOG_PATH}` : ` (rerun with CLAUDE_BRIDGE_DEBUG=1 to capture a debug log)`),
+cwd=${displayPath(cwd)} realpath=${displayPath(safeRealpath(cwd))}
+Please copy and paste this message into a new issue at https://github.com/vanillagreencom/vstack/issues/new` + (DEBUG ? ` and attach ${DEBUG_LOG_PATH}` : ` (rerun with CLAUDE_BRIDGE_DEBUG=1 to capture a debug log)`),
       "warning"
     );
-    diagDump("session_verify_fail", { msg, jsonlPath, cwd, realpath: safeRealpath(cwd), claudeConfigDir: process.env.CLAUDE_CONFIG_DIR ?? null });
+    diagDump("session_verify_fail", { msg, jsonlPath, cwd, realpath: safeRealpath(cwd), claudeConfigDir: claudeDir ?? null });
   }
 }
 function safeRealpath(p2) {
@@ -44342,7 +45050,7 @@ function safeRealpath(p2) {
     return `<failed: ${e.message}>`;
   }
 }
-function debugSessionPaths(label, cwd, jsonlPath) {
+function debugSessionPaths(label, cwd, jsonlPath, claudeDir) {
   const realCwd = safeRealpath(cwd);
   let fileSize = null;
   let fileExists = false;
@@ -44356,54 +45064,89 @@ function debugSessionPaths(label, cwd, jsonlPath) {
   if (realCwd !== cwd) debug(`${label}: realpath(cwd)=${realCwd} (DIFFERS \u2014 symlink-resolved path is what CC SDK uses)`);
   debug(`${label}: jsonlPath=${jsonlPath}`);
   debug(`${label}: fileExists=${fileExists}${fileSize != null ? ` size=${fileSize}` : ""}`);
-  debug(`${label}: env.CLAUDE_CONFIG_DIR=${process.env.CLAUDE_CONFIG_DIR ?? "(unset)"} HOME=${process.env.HOME ?? "(unset)"}`);
+  debug(`${label}: selected.CLAUDE_CONFIG_DIR=${claudeDir ?? "(unset)"} HOME=${process.env.HOME ?? "(unset)"}`);
 }
-function syncSharedSession(messages, cwd, customToolNameToSdk, modelId) {
+function syncSharedSession(messages, cwd, customToolNameToSdk, modelId, account) {
+  const sharedSession = getSharedSession();
   const priorMessages = messages.slice(0, -1);
-  if (sharedSession && !sharedSession.needsRebuild) {
-    const missed = priorMessages.slice(sharedSession.cursor);
-    const trailingAssistantOnly = missed.length === 1 && missed[0].role === "assistant";
-    if (missed.length === 0 || trailingAssistantOnly) {
-      if (trailingAssistantOnly) {
-        setSharedSession({ ...sharedSession, cursor: priorMessages.length, cwd });
-      }
-      debug(`Case 3: ${trailingAssistantOnly ? "advanced cursor past trailing assistant, " : ""}resuming session ${sharedSession.sessionId.slice(0, 8)}, cursor=${sharedSession.cursor}`);
-      debug(`syncResult: path=reuse sessionId=${sharedSession.sessionId} cursor=${sharedSession.cursor}`);
-      return { sessionId: sharedSession.sessionId };
+  const accountProfileId = account?.accountProfileId;
+  const scopeConfigDir = account?.claudeConfigDir;
+  const claudeDir = scopeConfigDir ?? process.env.CLAUDE_CONFIG_DIR;
+  const sameAccount = Boolean(
+    sharedSession && sharedSession.accountProfileId === accountProfileId && sharedSession.claudeConfigDir === scopeConfigDir
+  );
+  const incomingFingerprint = conversationFingerprint(messages);
+  if (sharedSession && !sharedSession.needsRebuild && sharedSession.conversationFingerprint && incomingFingerprint && !conversationFingerprintsMatch(sharedSession.conversationFingerprint, incomingFingerprint) && priorMessages.length <= sharedSession.cursor) {
+    debug(
+      `Case 6 foreign-conversation: fingerprint ${incomingFingerprint.slice(0, 8)} != record ${sharedSession.conversationFingerprint.slice(0, 8)} (cursor=${sharedSession.cursor}, priors=${priorMessages.length}) \u2014 clean one-shot, record untouched`
+    );
+    debug(`syncResult: path=foreign-one-shot`);
+    return { sessionId: null, promptStart: messages.length - 1, foreignContext: true };
+  }
+  if (sharedSession && sameAccount && !sharedSession.needsRebuild) {
+    const batch = planIncrementalPromptBatch(messages, sharedSession.cursor);
+    if (batch) {
+      const cursorBeforeUpdate = sharedSession.cursor;
+      const upgradedFingerprint = conversationFingerprintUpgrade(sharedSession.conversationFingerprint, incomingFingerprint);
+      setSharedSession({
+        ...sharedSession,
+        cursor: batch.promptStart,
+        cwd,
+        ...upgradedFingerprint ? { conversationFingerprint: upgradedFingerprint } : {}
+      });
+      const batching = batch.userMessageCount > 1 ? `batched ${batch.userMessageCount} consecutive user messages, ` : batch.promptStart > cursorBeforeUpdate ? "advanced cursor past trailing assistant, " : "";
+      debug(`Case 3: ${batching}resuming session ${sharedSession.sessionId.slice(0, 8)}, cursor=${batch.promptStart}, account=${accountProfileId ?? "default"}`);
+      debug(`syncResult: path=reuse sessionId=${sharedSession.sessionId} cursor=${batch.promptStart} promptUsers=${batch.userMessageCount}`);
+      return {
+        sessionId: sharedSession.sessionId,
+        promptStart: batch.promptStart
+      };
     }
   }
   if (priorMessages.length === 0) {
-    debug(`Case 1: clean start, ${messages.length} total messages`);
+    debug(`Case 1: clean start, ${messages.length} total messages, account=${accountProfileId ?? "default"}`);
     debug(`syncResult: path=clean-start`);
-    return { sessionId: null };
+    return { sessionId: null, promptStart: messages.length - 1 };
   }
-  const previousSessionId = sharedSession?.sessionId;
-  const previousCursor = sharedSession?.cursor ?? 0;
+  const replacedSessionId = sharedSession?.sessionId;
+  const previousSessionId = sameAccount ? sharedSession?.sessionId : void 0;
+  const previousCursor = sameAccount ? sharedSession?.cursor ?? 0 : 0;
   const preserveId = previousSessionId !== void 0 && !sharedSession?.forceRotate;
   if (preserveId) {
-    deleteSession(previousSessionId, cwd, process.env.CLAUDE_CONFIG_DIR);
+    deleteSession(previousSessionId, cwd, claudeDir);
   }
   const session = createSession({
     projectPath: cwd,
-    claudeDir: process.env.CLAUDE_CONFIG_DIR,
+    claudeDir,
     ...preserveId ? { sessionId: previousSessionId } : {},
     ...modelId ? { model: modelId } : {}
   });
   convertAndImportMessages(session, priorMessages, customToolNameToSdk, cwd);
   session.save();
-  verifyWrittenSession2(session.jsonlPath, session.sessionId, session.messages.length, cwd);
-  setSharedSession({ sessionId: session.sessionId, cursor: priorMessages.length, cwd });
-  if (previousSessionId === void 0) {
+  verifyWrittenSession2(session.jsonlPath, session.sessionId, session.messages.length, cwd, claudeDir);
+  setSharedSession({
+    sessionId: session.sessionId,
+    cursor: priorMessages.length,
+    cwd,
+    // The rebuilt file's content IS this context, so its anchor is the
+    // record's identity — including after a compact/tree-nav that moved it.
+    ...incomingFingerprint ? { conversationFingerprint: incomingFingerprint } : {},
+    ...accountProfileId ? { accountProfileId } : {},
+    ...scopeConfigDir ? { claudeConfigDir: scopeConfigDir } : {}
+  });
+  if (replacedSessionId === void 0) {
     debug(`Case 2: first turn with ${priorMessages.length} prior messages \u2192 session ${session.sessionId.slice(0, 8)}, ${session.messages.length} records`);
+  } else if (!sameAccount) {
+    debug(`Case 5 account-rotation: ${priorMessages.length} prior messages \u2192 new session ${session.sessionId.slice(0, 8)} for account ${accountProfileId ?? "default"} (replaced ${replacedSessionId.slice(0, 8)})`);
   } else if (preserveId) {
     const missedCount = priorMessages.length - previousCursor;
     debug(`Case 4: ${missedCount} missed messages, ${priorMessages.length} total \u2192 rewrote session ${session.sessionId.slice(0, 8)} (same id), ${session.messages.length} records`);
   } else {
     debug(`Case 4 post-abort: ${priorMessages.length} total \u2192 new session ${session.sessionId.slice(0, 8)} (was ${previousSessionId.slice(0, 8)}, rotated to avoid race with orphan writer), ${session.messages.length} records`);
   }
-  debugSessionPaths(`${session.sessionId.slice(0, 8)}`, cwd, session.jsonlPath);
-  debug(`syncResult: path=rebuild sessionId=${session.sessionId} priors=${priorMessages.length} ${previousSessionId === void 0 ? "first" : preserveId ? "preserved" : "rotated-post-abort"}`);
-  return { sessionId: session.sessionId };
+  debugSessionPaths(`${session.sessionId.slice(0, 8)}`, cwd, session.jsonlPath, claudeDir);
+  debug(`syncResult: path=rebuild sessionId=${session.sessionId} priors=${priorMessages.length} ${replacedSessionId === void 0 ? "first" : !sameAccount ? "account-rotated" : preserveId ? "preserved" : "rotated-post-abort"}`);
+  return { sessionId: session.sessionId, promptStart: messages.length - 1 };
 }
 
 // src/stream-idle-watchdog.ts
@@ -44492,75 +45235,6 @@ function createStreamIdleWatchdog({
   };
 }
 
-// src/rate-limit.ts
-var RATE_LIMIT_AUTO_RESUME_EVENT = "vstack:rate-limit";
-var RATE_LIMIT_TOKEN = "\x1B[31m[rate-limit]\x1B[39m";
-var USAGE_LIMIT_PREFIXES = Array.isArray(qO) ? qO : [];
-function coerceMessageText(value) {
-  if (typeof value === "string") return value;
-  if (value instanceof Error) return value.message;
-  try {
-    return JSON.stringify(value ?? "");
-  } catch {
-    return String(value);
-  }
-}
-function isExtraUsageRequiredMessage(value) {
-  return /extra[-\s]?usage|overage|extra usage billing|extra usage credits|1M context/i.test(coerceMessageText(value));
-}
-function isUsageLimitMessage(value) {
-  const text = coerceMessageText(value);
-  return USAGE_LIMIT_PREFIXES.some((prefix) => text.includes(prefix));
-}
-function uniqueNonEmptyLines(values) {
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  for (const value of values) {
-    const text = typeof value === "string" ? value.trim() : value == null ? "" : String(value).trim();
-    if (!text || seen.has(text)) continue;
-    seen.add(text);
-    out.push(text);
-  }
-  return out;
-}
-function resetTimestampMs(value) {
-  let parsed = typeof value === "number" ? value : typeof value === "string" ? Date.parse(value) : Number.NaN;
-  if (!Number.isFinite(parsed)) return void 0;
-  if (typeof value === "number" && Math.abs(parsed) < 1e12) parsed *= 1e3;
-  return parsed;
-}
-function formatResetTimestamp(value) {
-  const parsed = resetTimestampMs(value);
-  if (parsed === void 0) return "unknown";
-  return new Date(parsed).toLocaleString(void 0, {
-    day: "numeric",
-    hour: "numeric",
-    minute: "2-digit",
-    month: "short",
-    second: "2-digit",
-    timeZoneName: "short",
-    year: "numeric"
-  });
-}
-var ALLOWED_RATE_LIMIT_WARNING_UTILIZATION_THRESHOLD = 80;
-function normalizeRateLimitUtilization(value) {
-  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return void 0;
-  if (value === 0) return 0;
-  if (value > 0 && value < 1) return value * 100;
-  if (value > 1 && value <= 100) return value;
-  return void 0;
-}
-function rateLimitTypeLabel(value) {
-  const text = typeof value === "string" ? value.trim() : "";
-  return text || "unknown";
-}
-function formatAllowedRateLimitWarning(info) {
-  if (info?.status !== "allowed_warning") return void 0;
-  const utilization = normalizeRateLimitUtilization(info.utilization);
-  if (utilization === void 0 || utilization < ALLOWED_RATE_LIMIT_WARNING_UTILIZATION_THRESHOLD) return void 0;
-  return `Claude rate limit warning: nearing ${rateLimitTypeLabel(info.rateLimitType)} limit; check Claude Code /usage for exact utilization.`;
-}
-
 // src/tool-mapping.ts
 var SDK_TO_PI_TOOL_NAME = {
   read: "read",
@@ -44607,8 +45281,7 @@ function mapToolArgs(toolName, args) {
 
 // src/assistant-stream.ts
 import { calculateCost } from "@earendil-works/pi-ai";
-function updateUsage(output, usage, model) {
-  const c = ctx();
+function updateUsage(output, usage, model, c) {
   const current = c.currentMessageUsage;
   const carry = c.turnUsageCarry;
   if (usage.input_tokens != null) current.input = usage.input_tokens;
@@ -44663,6 +45336,17 @@ var TOOL_USE_END_GRACE_MS = 1500;
 function endToolUseTurn(c) {
   if (!c.currentPiStream || !c.turnOutput) return;
   cancelScheduledToolUseEnd(c);
+  const partial2 = c.turnOutput.content.filter((b) => b?.type === "toolCall" && "partialJson" in b);
+  if (partial2.length > 0) {
+    const calls = partial2.map((b) => ({ id: b.id, name: b.name }));
+    debug(`endToolUseTurn: pruning ${partial2.length} still-partial tool call(s) \u2014 truncated arguments never execute:`, calls.map((entry) => `${entry.name} [${entry.id}]`).join(", "));
+    diagDump("partial_tool_calls_pruned", { count: partial2.length, calls });
+    appendIntegrityEntry("partial_tool_calls_pruned", { count: partial2.length, calls });
+    c.turnOutput.content = c.turnOutput.content.filter((b) => !(b?.type === "toolCall" && "partialJson" in b));
+  }
+  for (const block of c.turnOutput.content) {
+    if (block?.type === "toolCall" && typeof block.id === "string") c.forwardedToolCallIds.add(block.id);
+  }
   c.turnOutput.stopReason = "toolUse";
   c.currentPiStream.push({ type: "done", reason: "toolUse", message: c.turnOutput });
   c.currentPiStream.end();
@@ -44691,33 +45375,42 @@ function reapStaleQueuedResults(c) {
   const stale = c.takeStaleQueuedResults();
   if (stale.length === 0) return;
   const names = stale.map((entry) => entry.toolName);
-  debug(`reapStaleQueuedResults: dropping ${stale.length} queued tool result(s) with no possible consumer:`, names.join(", "));
-  diagDump("stale_queued_tool_results_dropped", { count: stale.length, stale });
-  appendIntegrityEntry("stale_queued_tool_results_dropped", { count: stale.length, stale });
+  debug(`reapStaleQueuedResults: parked ${stale.length} early tool result(s) awaiting a late handler:`, names.join(", "));
+  diagDump("stale_queued_tool_results_parked", { count: stale.length, stale });
+  appendIntegrityEntry("stale_queued_tool_results_parked", { count: stale.length, stale });
   safeNotify(
-    `Claude bridge: dropped ${stale.length} tool result(s) whose handler never matched (${names.slice(0, 6).join(", ")}${names.length > 6 ? ", \u2026" : ""}). The model saw an error for these calls and may retry them.`,
+    `Claude bridge: parked ${stale.length} early tool result(s) whose handler has not arrived (${names.slice(0, 6).join(", ")}${names.length > 6 ? ", \u2026" : ""}). A late handler can still consume them.`,
     "warning"
   );
 }
-function updateTurnOutputModel(modelId) {
-  const c = ctx();
+function updateTurnOutputModel(modelId, c = ctx()) {
   if (typeof modelId !== "string" || !modelId || !c.turnOutput) return;
   if (c.turnOutput.model === modelId) return;
   debug(`provider: active Claude model changed ${c.turnOutput.model} -> ${modelId}`);
   c.turnOutput.model = modelId;
 }
-function finalizeToolUseTurnFromMcpInvocation(queryCtx, toolCallId, toolName, mappedArgs) {
-  if (!queryCtx.currentPiStream || !queryCtx.turnOutput) return;
+var FINALIZE_MAX_REARMS = 3;
+function finalizeToolUseTurnFromMcpInvocation(queryCtx, toolCallId, toolName, mappedArgs, rearmCount = 0) {
+  if (!queryCtx.currentPiStream || !queryCtx.turnOutput) {
+    if (failStrandedToolCall(queryCtx, toolCallId)) {
+      debug(`mcp handler: ${toolName} [${toolCallId}] stranded \u2014 turn ended before its call reached Pi; resolved with error`);
+      diagDump("tool_handler_stranded", { toolCallId, toolName, site: "finalize-no-stream" });
+      appendIntegrityEntry("tool_handler_stranded", { toolCallId, toolName, site: "finalize-no-stream" });
+    }
+    return;
+  }
   let idx = queryCtx.turnBlocks.findIndex((b) => b.type === "toolCall" && b.id === toolCallId);
   if (idx >= 0) {
     const block = queryCtx.turnBlocks[idx];
     if ("partialJson" in block) {
-      block.arguments = mapToolArgs(block.name, parsePartialJson(block.partialJson, block.arguments));
+      block.arguments = mappedArgs;
       queryCtx.updateToolCallArgs(block.id, block.arguments);
       delete block.partialJson;
       delete block.index;
       queryCtx.currentPiStream.push({ type: "toolcall_end", contentIndex: idx, toolCall: block, partial: queryCtx.turnOutput });
     }
+  } else if (queryCtx.forwardedToolCallIds.has(toolCallId) || queryCtx.deadToolCallIds.has(toolCallId)) {
+    debug(`mcp handler: ${toolName} [${toolCallId}] already ${queryCtx.forwardedToolCallIds.has(toolCallId) ? "forwarded" : "dead"} \u2014 not re-emitting`);
   } else {
     queryCtx.turnBlocks.push({ type: "toolCall", id: toolCallId, name: toolName, arguments: mappedArgs });
     idx = queryCtx.turnBlocks.length - 1;
@@ -44725,12 +45418,37 @@ function finalizeToolUseTurnFromMcpInvocation(queryCtx, toolCallId, toolName, ma
     queryCtx.currentPiStream.push({ type: "toolcall_start", contentIndex: idx, partial: queryCtx.turnOutput });
     queryCtx.currentPiStream.push({ type: "toolcall_end", contentIndex: idx, toolCall: block, partial: queryCtx.turnOutput });
   }
+  for (let i = 0; i < queryCtx.turnBlocks.length; i++) {
+    const sibling = queryCtx.turnBlocks[i];
+    if (sibling.type !== "toolCall" || !("partialJson" in sibling)) continue;
+    const waiting = queryCtx.pendingToolCalls.get(sibling.id);
+    if (!waiting) continue;
+    sibling.arguments = waiting.args;
+    queryCtx.updateToolCallArgs(sibling.id, sibling.arguments);
+    delete sibling.partialJson;
+    delete sibling.index;
+    queryCtx.currentPiStream.push({ type: "toolcall_end", contentIndex: i, toolCall: sibling, partial: queryCtx.turnOutput });
+  }
+  const unsettled = queryCtx.turnBlocks.filter((b) => b.type === "toolCall" && "partialJson" in b);
+  if (unsettled.length > 0 && rearmCount < FINALIZE_MAX_REARMS) {
+    debug(`mcp handler: ${unsettled.length} sibling tool call(s) still streaming \u2014 re-arming grace (${rearmCount + 1}/${FINALIZE_MAX_REARMS})`);
+    scheduleToolUseTurnEnd(
+      queryCtx,
+      () => finalizeToolUseTurnFromMcpInvocation(queryCtx, toolCallId, toolName, mappedArgs, rearmCount + 1),
+      `finalize-rearm:${toolName}`
+    );
+    return;
+  }
+  const executable = queryCtx.turnBlocks.some((b) => b.type === "toolCall" && !("partialJson" in b));
+  if (!executable) {
+    debug(`mcp handler: nothing executable in this turn after suppression \u2014 leaving the stream to its own terminal events (${toolName} [${toolCallId}])`);
+    return;
+  }
   queryCtx.turnSawToolCall = true;
   debug(`mcp handler: finalizing tool_use turn from MCP invocation [${toolCallId}] (${toolName}) \u2014 terminal stream events never arrived`);
   endToolUseTurn(queryCtx);
 }
-function processStreamEvent(message, customToolNameToPi, model) {
-  const c = ctx();
+function processStreamEvent(message, customToolNameToPi, model, c = ctx()) {
   if (!c.currentPiStream || !c.turnOutput) return;
   const event = message.event;
   if (event?.type === "ping") return;
@@ -44742,14 +45460,15 @@ function processStreamEvent(message, customToolNameToPi, model) {
     reapStaleQueuedResults(c);
     c.resetToolTracking();
     c.beginChildMessage(event.message?.id);
-    updateTurnOutputModel(event.message?.model);
-    if (event.message?.usage) updateUsage(c.turnOutput, event.message.usage, model);
+    updateTurnOutputModel(event.message?.model, c);
+    if (event.message?.usage) updateUsage(c.turnOutput, event.message.usage, model, c);
     return;
   }
   if (event?.type === "content_block_start") {
     c.turnSawStreamEvent = true;
-    ensureTurnStarted();
+    ensureTurnStarted(c);
     c.childExecutedStreamIndexes.delete(event.index);
+    c.suppressedStreamIndexes.delete(event.index);
     if (event.content_block?.type === "tool_use" && isChildExecutedTool(event.content_block.name)) {
       c.noteChildExecutedToolCall(event.content_block.id, event.content_block.name, event.index);
       debug(`processStreamEvent: child-executed tool ${event.content_block.name} [${event.content_block.id}] \u2014 not mirrored as a Pi tool call`);
@@ -44762,6 +45481,17 @@ function processStreamEvent(message, customToolNameToPi, model) {
       c.turnBlocks.push({ type: "thinking", thinking: "", thinkingSignature: "", index: event.index });
       c.currentPiStream.push({ type: "thinking_start", contentIndex: c.turnBlocks.length - 1, partial: c.turnOutput });
     } else if (event.content_block?.type === "tool_use") {
+      const streamedId = event.content_block.id;
+      if (typeof streamedId === "string" && (c.forwardedToolCallIds.has(streamedId) || c.deadToolCallIds.has(streamedId))) {
+        c.suppressedStreamIndexes.add(event.index);
+        debug(`processStreamEvent: tool_use ${streamedId} already ${c.forwardedToolCallIds.has(streamedId) ? "forwarded" : "dead"} \u2014 suppressing duplicate stream block`);
+        return;
+      }
+      if (typeof streamedId === "string" && c.turnBlocks.some((b) => b.type === "toolCall" && b.id === streamedId)) {
+        c.suppressedStreamIndexes.add(event.index);
+        debug(`processStreamEvent: tool_use ${streamedId} already recorded in this turn \u2014 suppressing duplicate stream block`);
+        return;
+      }
       c.turnSawToolCall = true;
       const mappedName = mapToolName(event.content_block.name, customToolNameToPi);
       c.recordToolCall(event.content_block.id, mappedName, {});
@@ -44780,7 +45510,7 @@ function processStreamEvent(message, customToolNameToPi, model) {
     return;
   }
   if (event?.type === "content_block_delta") {
-    if (c.childExecutedStreamIndexes.has(event.index)) {
+    if (c.childExecutedStreamIndexes.has(event.index) || c.suppressedStreamIndexes.has(event.index)) {
       c.turnSawStreamEvent = true;
       return;
     }
@@ -44809,7 +45539,7 @@ function processStreamEvent(message, customToolNameToPi, model) {
     return;
   }
   if (event?.type === "content_block_stop") {
-    if (c.childExecutedStreamIndexes.has(event.index)) {
+    if (c.childExecutedStreamIndexes.has(event.index) || c.suppressedStreamIndexes.has(event.index)) {
       c.turnSawStreamEvent = true;
       return;
     }
@@ -44839,7 +45569,7 @@ function processStreamEvent(message, customToolNameToPi, model) {
   }
   if (event?.type === "message_delta") {
     c.turnOutput.stopReason = mapStopReason(event.delta?.stop_reason);
-    if (event.usage) updateUsage(c.turnOutput, event.usage, model);
+    if (event.usage) updateUsage(c.turnOutput, event.usage, model, c);
     return;
   }
   if (event?.type === "message_stop" && c.turnSawToolCall) {
@@ -44850,9 +45580,9 @@ function processStreamEvent(message, customToolNameToPi, model) {
     debug("processStreamEvent: unhandled event type", event?.type);
   }
 }
-function appendMissingToolUsesFromAssistant(assistantMsg, model, customToolNameToPi) {
-  const c = ctx();
+function appendMissingToolUsesFromAssistant(assistantMsg, model, customToolNameToPi, c) {
   if (!assistantMsg?.content) return false;
+  const streamLive = Boolean(c.currentPiStream && c.turnOutput);
   let sawToolUse = false;
   for (const block of assistantMsg.content) {
     if (block.type !== "tool_use") continue;
@@ -44861,11 +45591,16 @@ function appendMissingToolUsesFromAssistant(assistantMsg, model, customToolNameT
       debug(`assistant message: child-executed tool ${block.name} [${block.id}] \u2014 not mirrored as a Pi tool call`);
       continue;
     }
-    sawToolUse = true;
     const existingIdx = c.turnBlocks.findIndex((b) => b.type === "toolCall" && b.id === block.id);
+    if (existingIdx < 0 && (c.forwardedToolCallIds.has(block.id) || c.deadToolCallIds.has(block.id))) {
+      debug(`assistant message: tool_use ${block.id} already ${c.forwardedToolCallIds.has(block.id) ? "forwarded" : "dead"} \u2014 skipping duplicate`);
+      continue;
+    }
+    sawToolUse = true;
     const name = mapToolName(block.name, customToolNameToPi);
     const mappedArgs = mapToolArgs(name, block.input);
     c.recordToolCall(block.id, name, mappedArgs);
+    if (!streamLive) continue;
     if (existingIdx >= 0) {
       const existing = c.turnBlocks[existingIdx];
       existing.name = name;
@@ -44878,7 +45613,7 @@ function appendMissingToolUsesFromAssistant(assistantMsg, model, customToolNameT
       }
       continue;
     }
-    ensureTurnStarted();
+    ensureTurnStarted(c);
     c.turnBlocks.push({
       type: "toolCall",
       id: block.id,
@@ -44890,11 +45625,10 @@ function appendMissingToolUsesFromAssistant(assistantMsg, model, customToolNameT
     c.currentPiStream?.push({ type: "toolcall_start", contentIndex: idx, partial: c.turnOutput });
     c.currentPiStream?.push({ type: "toolcall_end", contentIndex: idx, toolCall: toolBlock, partial: c.turnOutput });
   }
-  if (assistantMsg.usage && c.turnOutput && c.currentPiStream) updateUsage(c.turnOutput, assistantMsg.usage, model);
+  if (assistantMsg.usage && c.turnOutput && c.currentPiStream) updateUsage(c.turnOutput, assistantMsg.usage, model, c);
   return sawToolUse;
 }
-function noteChildExecutedToolResults(message) {
-  const c = ctx();
+function noteChildExecutedToolResults(message, c = ctx()) {
   if (c.childExecutedToolCalls.size === 0) return;
   const content = message.message?.content;
   if (!Array.isArray(content)) return;
@@ -44908,13 +45642,12 @@ function noteChildExecutedToolResults(message) {
     debug(`child-executed tool result: ${name} [${block.tool_use_id}] isError=${isError} byteSize=${byteSize ?? "unknown"} audited=${audited}`);
   }
 }
-function processAssistantMessage(message, model, customToolNameToPi) {
-  const c = ctx();
+function processAssistantMessage(message, model, customToolNameToPi, c = ctx()) {
   const assistantMsg = message.message;
   if (!assistantMsg?.content) return;
-  updateTurnOutputModel(assistantMsg.model);
+  updateTurnOutputModel(assistantMsg.model, c);
   if (c.turnSawStreamEvent) {
-    if (appendMissingToolUsesFromAssistant(assistantMsg, model, customToolNameToPi)) {
+    if (appendMissingToolUsesFromAssistant(assistantMsg, model, customToolNameToPi, c)) {
       c.turnSawToolCall = true;
       scheduleToolUseTurnEnd(c, () => endToolUseTurn(c), "assistant-boundary");
     }
@@ -44931,7 +45664,7 @@ function processAssistantMessage(message, model, customToolNameToPi) {
   for (const block of assistantMsg.content) {
     if (block.type === "text" && block.text) {
       if (alreadyRendered("text", block.text)) continue;
-      ensureTurnStarted();
+      ensureTurnStarted(c);
       c.turnBlocks.push({ type: "text", text: block.text });
       const idx = c.turnBlocks.length - 1;
       c.currentPiStream?.push({ type: "text_start", contentIndex: idx, partial: c.turnOutput });
@@ -44939,7 +45672,7 @@ function processAssistantMessage(message, model, customToolNameToPi) {
       c.currentPiStream?.push({ type: "text_end", contentIndex: idx, content: block.text, partial: c.turnOutput });
     } else if (block.type === "thinking") {
       if (alreadyRendered("thinking", block.thinking ?? "")) continue;
-      ensureTurnStarted();
+      ensureTurnStarted(c);
       c.turnBlocks.push({ type: "thinking", thinking: block.thinking ?? "", thinkingSignature: block.signature ?? "" });
       const idx = c.turnBlocks.length - 1;
       c.currentPiStream?.push({ type: "thinking_start", contentIndex: idx, partial: c.turnOutput });
@@ -44951,7 +45684,11 @@ function processAssistantMessage(message, model, customToolNameToPi) {
         debug(`processAssistantMessage fallback: child-executed tool ${block.name} [${block.id}] \u2014 not mirrored as a Pi tool call`);
         continue;
       }
-      ensureTurnStarted();
+      if (!c.turnBlocks.some((b) => b.type === "toolCall" && b.id === block.id) && (c.forwardedToolCallIds.has(block.id) || c.deadToolCallIds.has(block.id))) {
+        debug(`processAssistantMessage fallback: tool_use ${block.id} already ${c.forwardedToolCallIds.has(block.id) ? "forwarded" : "dead"} \u2014 skipping duplicate`);
+        continue;
+      }
+      ensureTurnStarted(c);
       c.turnSawToolCall = true;
       const mappedName = mapToolName(block.name, customToolNameToPi);
       const mappedArgs = mapToolArgs(mappedName, block.input);
@@ -44975,108 +45712,641 @@ function processAssistantMessage(message, model, customToolNameToPi) {
       c.currentPiStream?.push({ type: "toolcall_start", contentIndex: idx, partial: c.turnOutput });
       c.currentPiStream?.push({ type: "toolcall_end", contentIndex: idx, toolCall: toolBlock, partial: c.turnOutput });
     } else if (block.type === "fallback") {
-      updateTurnOutputModel(block.to?.model);
+      updateTurnOutputModel(block.to?.model, c);
     } else {
       debug("processAssistantMessage: unhandled block type", block.type);
     }
   }
-  if (assistantMsg.usage && c.turnOutput) updateUsage(c.turnOutput, assistantMsg.usage, model);
+  if (assistantMsg.usage && c.turnOutput) updateUsage(c.turnOutput, assistantMsg.usage, model, c);
   if (c.turnSawToolCall && c.currentPiStream && c.turnOutput) {
     endToolUseTurn(c);
   }
 }
 
-// src/index.ts
-var _piAi = piAi;
-var getModels = await resolveGetModels(_piAi);
-var newAssistantMessageEventStream = typeof _piAi.createAssistantMessageEventStream === "function" ? _piAi.createAssistantMessageEventStream : () => new _piAi.AssistantMessageEventStream();
-var PRIMARY_INSTANCE_KEY = /* @__PURE__ */ Symbol.for("claude-bridge:primaryInstance");
-var ACTIVE_STREAM_SIMPLE_KEY = /* @__PURE__ */ Symbol.for("claude-bridge:activeStreamSimple");
-var COMMANDS_REGISTERED_KEY = /* @__PURE__ */ Symbol.for("claude-bridge:commandsRegistered");
-var MODELS = buildModels(getModels("anthropic"));
-var extraUsageHelperInFlight = null;
-function emitRateLimitEvent(payload) {
-  try {
-    extensionApi?.events?.emit?.(RATE_LIMIT_AUTO_RESUME_EVENT, payload);
-  } catch {
-  }
-}
-function extraUsageAllowed(config2) {
-  return config2.provider?.allowExtraUsage === true;
-}
-var lastFastModeDisabledNoticeReason = null;
-var FAST_MODE_DISABLED_REASON_TEXT = {
-  disabled_by_env: "disabled by an environment variable",
-  extra_usage_disabled: "extra usage is disabled for this account",
-  free: "not available on the free plan",
-  model_not_allowed: "not available for this model",
-  network_error: "the eligibility check hit a network error",
-  not_first_party: "not available for this account type",
-  preference: "disabled by a Claude Code preference",
-  sdk_opt_in_required: "the SDK opt-in is missing",
-  unknown: "unavailable for an unknown reason"
-};
-function noteFastModeDisabledReason(message, bridgeConfig) {
-  if (bridgeConfig.provider?.fastMode !== true) return;
-  const reason = message.fast_mode_disabled_reason;
-  if (typeof reason !== "string" || reason === "pending") return;
-  if (reason === lastFastModeDisabledNoticeReason) return;
-  lastFastModeDisabledNoticeReason = reason;
-  const text = FAST_MODE_DISABLED_REASON_TEXT[reason] ?? `unavailable (${reason})`;
-  safeNotify(`Claude bridge: fast mode is enabled in settings but Claude Code declined it \u2014 ${text}.`, "warning");
-}
-function sdkTextFromMessage(message) {
-  if (message.type === "result") return message.result;
-  if (message.type === "assistant") {
-    const content = message.message?.content;
-    if (!Array.isArray(content)) return void 0;
-    return content.map((block) => block?.type === "text" && typeof block.text === "string" ? block.text : "").filter(Boolean).join("\n");
-  }
-  return void 0;
+// src/sdk-query.ts
+var sdkQueryFactory = Okt;
+function __testSetSdkQueryFactory(factory) {
+  sdkQueryFactory = factory ?? Okt;
 }
-async function runExtraUsageHelper(cwd, config2 = loadConfig(cwd)) {
-  const providerSettings = config2.provider ?? {};
-  const claudeExecutable = resolveClaudeExecutable(providerSettings.pathToClaudeCodeExecutable);
-  if (claudeExecutable) preflightClaudeExecutable(claudeExecutable, cwd);
-  const helperQuery = Okt({
-    prompt: "/extra-usage",
+
+// src/account-host.ts
+var ACCOUNT_PROBE_DEADLINE_MS = 1e4;
+async function probeClaudeAccountProfile(input) {
+  const config2 = loadConfig(input.cwd);
+  const claudeExecutable = resolveClaudeExecutable(config2.provider?.pathToClaudeCodeExecutable);
+  if (claudeExecutable) preflightClaudeExecutable(claudeExecutable, input.cwd);
+  const probe = sdkQueryFactory({
+    prompt: "/usage",
     options: {
-      cwd,
-      env: { ...process.env, ENABLE_CLAUDEAI_MCP_SERVERS: "0", DISABLE_AUTO_COMPACT: "1" },
+      cwd: input.cwd,
+      env: {
+        ...subscriberProfileEnv(input.profile),
+        ENABLE_CLAUDEAI_MCP_SERVERS: "0",
+        DISABLE_AUTO_COMPACT: "1"
+      },
       maxTurns: 1,
+      // bypassPermissions makes tool containment the only gate, so the probe
+      // gets BOTH layers: the standard bridge isolation lists AND a deny-all
+      // PreToolUse hook — a /usage probe has no business executing anything.
+      permissionMode: "bypassPermissions",
+      ...CLAUDE_BRIDGE_TOOL_ISOLATION,
+      hooks: { PreToolUse: [{ hooks: [denyAllToolsHook()] }] },
       ...claudeExecutable ? { pathToClaudeCodeExecutable: claudeExecutable } : {},
       spawnClaudeCodeProcess: spawnClaudeCodeWithDiagnostics,
-      ...makeCliDebugOptions("extra-usage")
+      ...makeCliDebugOptions("account-probe")
     }
   });
-  const outputs = [];
-  try {
-    for await (const message of helperQuery) {
-      const text = sdkTextFromMessage(message)?.trim();
-      if (text && outputs[outputs.length - 1] !== text) outputs.push(text);
+  const onAbort = () => {
+    void probe.interrupt().catch(() => {
+    });
+    try {
+      probe.close();
+    } catch {
+    }
+  };
+  if (input.signal?.aborted) onAbort();
+  else input.signal?.addEventListener("abort", onAbort, { once: true });
+  let controls;
+  let deadlineTimer;
+  const deadline = new Promise((resolveDeadline) => {
+    deadlineTimer = setTimeout(() => {
+      debug(`account-probe: deadline expired for ${input.profile.label}; killing probe child`);
+      onAbort();
+      resolveDeadline("deadline");
+    }, input.deadlineMs ?? ACCOUNT_PROBE_DEADLINE_MS);
+    deadlineTimer.unref?.();
+  });
+  const consume = (async () => {
+    for await (const message of probe) {
+      if (message.type === "system" && message.subtype === "init" && !controls) {
+        controls = Promise.allSettled([
+          probe.accountInfo(),
+          probe.usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET()
+        ]).then(([identityResult, usageResult]) => ({
+          ...identityResult.status === "fulfilled" ? { identity: {
+            email: identityResult.value.email,
+            organization: identityResult.value.organization,
+            subscriptionType: identityResult.value.subscriptionType
+          } } : {},
+          ...usageResult.status === "fulfilled" ? { usage: usageResult.value } : {}
+        }));
+      }
     }
+    return controls ? await controls : {};
+  })();
+  try {
+    const result = await Promise.race([consume, deadline]);
+    return result === "deadline" ? {} : result;
   } finally {
-    helperQuery.close();
+    clearTimeout(deadlineTimer);
+    input.signal?.removeEventListener("abort", onAbort);
+    probe.close();
+    void consume.catch(() => {
+    });
   }
-  return outputs.join("\n").trim() || "Claude Code /extra-usage completed.";
 }
-function launchExtraUsageHelperIfAllowed(cwd, config2, reason) {
-  if (!extraUsageAllowed(config2)) return false;
-  if (extraUsageHelperInFlight) return true;
-  extraUsageHelperInFlight = runExtraUsageHelper(cwd, config2).then((message) => {
-    piUI?.notify(`Claude extra usage helper: ${message}`, "info");
-    return message;
-  }).catch((error51) => {
-    const message = error51 instanceof Error ? error51.message : String(error51);
-    piUI?.notify(`Claude extra usage helper failed after ${reason}: ${message}`, "error");
-    throw error51;
-  }).finally(() => {
-    extraUsageHelperInFlight = null;
+var BRIDGE_ACCOUNT_HOST = {
+  version: 1,
+  probeProfile: probeClaudeAccountProfile
+};
+
+// src/bridge-commands.ts
+var COMMANDS_REGISTERED_KEY = /* @__PURE__ */ Symbol.for("claude-bridge:commandsRegistered");
+function commandCwd(ctx2) {
+  const value = ctx2?.cwd;
+  return typeof value === "string" && value.length > 0 ? value : process.cwd();
+}
+async function tryOpenExtensionManagerSettings(ctx2) {
+  const host = globalThis;
+  const openQuickSettings = host[/* @__PURE__ */ Symbol.for("vstack.pi.extension-manager.open-quick-settings")];
+  if (typeof openQuickSettings !== "function") return false;
+  try {
+    await openQuickSettings(ctx2, "@vanillagreen/pi-claude-bridge");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function showBridgeStatus(ctx2) {
+  const config2 = loadConfig(commandCwd(ctx2));
+  ctx2.ui.notify([
+    `Pi Claude: ${config2.enabled === false ? "disabled" : "enabled"}`,
+    "Claude account billing settings (including Extra Usage) are managed in Claude."
+  ].join("\n"), "info");
+}
+async function reportConnectorInventory(ctx2) {
+  const account = ctx2.model ? resolveClaudeAccountRouter()?.current(ctx2.model.id, ctx2.sessionManager?.getSessionId?.()) : void 0;
+  const credentials = resolveClaudeOAuth(readCredentialFile, connectorCredentialEnv(account ? accountSessionScope(account).claudeConfigDir : void 0));
+  if (!credentials) {
+    ctx2.ui.notify("Pi Claude: no Claude OAuth credentials found \u2014 cannot enumerate connectors.", "error");
+    return;
+  }
+  const inventory = await listAccountConnectors({ credentials });
+  if (!inventory.ok) {
+    ctx2.ui.notify(`Pi Claude: connector enumeration failed \u2014 ${inventory.reason}`, "error");
+    return;
+  }
+  if (inventory.connectors.length === 0) {
+    ctx2.ui.notify("Pi Claude: this account has no connectors installed.", "info");
+    return;
+  }
+  const names = inventory.connectors.map((c) => c.name).join(", ");
+  ctx2.ui.notify(`Pi Claude: ${inventory.connectors.length} connector(s) installed \u2014 ${names}`, "info");
+}
+function registerBridgeCommands(pi) {
+  const guard = pi;
+  if (guard[COMMANDS_REGISTERED_KEY]) return;
+  guard[COMMANDS_REGISTERED_KEY] = true;
+  pi.registerCommand("pi-claude", {
+    description: "Open Pi Claude settings/status",
+    handler: async (args, ctx2) => {
+      if (args.trim()) ctx2.ui.notify("Unknown /pi-claude argument.", "warning");
+      if (await tryOpenExtensionManagerSettings(ctx2)) return;
+      showBridgeStatus(ctx2);
+    }
   });
-  void extraUsageHelperInFlight.catch(() => {
+  pi.registerCommand("pi-claude:connectors", {
+    description: "List the Claude account's installed claude.ai connectors",
+    handler: async (_args, ctx2) => reportConnectorInventory(ctx2)
   });
-  return true;
 }
+
+// src/consume-query.ts
+function emitRateLimitEvent(payload) {
+  try {
+    extensionApi?.events?.emit?.(RATE_LIMIT_AUTO_RESUME_EVENT, payload);
+  } catch {
+  }
+}
+var lastFastModeDisabledNoticeReason = null;
+var FAST_MODE_DISABLED_REASON_TEXT = {
+  disabled_by_env: "disabled by an environment variable",
+  extra_usage_disabled: "extra usage is disabled for this account",
+  free: "not available on the free plan",
+  model_not_allowed: "not available for this model",
+  network_error: "the eligibility check hit a network error",
+  not_first_party: "not available for this account type",
+  preference: "disabled by a Claude Code preference",
+  sdk_opt_in_required: "the SDK opt-in is missing",
+  unknown: "unavailable for an unknown reason"
+};
+function noteFastModeDisabledReason(message, bridgeConfig) {
+  if (bridgeConfig.provider?.fastMode !== true) return;
+  const reason = message.fast_mode_disabled_reason;
+  if (typeof reason !== "string" || reason === "pending") return;
+  if (reason === lastFastModeDisabledNoticeReason) return;
+  lastFastModeDisabledNoticeReason = reason;
+  const text = FAST_MODE_DISABLED_REASON_TEXT[reason] ?? `unavailable (${reason})`;
+  safeNotify(`Pi Claude: fast mode is enabled in settings but Claude Code declined it \u2014 ${text}.`, "warning");
+}
+async function consumeQuery(sdkQuery, queryCtx, customToolNameToPi, model, bridgeConfig, wasAborted, account, router, attemptFailureBox) {
+  let capturedSessionId;
+  let failure;
+  let accountProbe;
+  const holdFailure = (next) => {
+    failure = next;
+    if (attemptFailureBox) attemptFailureBox.failure = next;
+  };
+  for await (const message of sdkQuery) {
+    if (wasAborted()) break;
+    activeStreamIdleWatchdogs.get(queryCtx)?.noteChunk();
+    if (account) {
+      debug("consumeQuery: managed message", () => JSON.stringify({
+        type: message.type,
+        subtype: message.subtype,
+        error: message.error,
+        eventType: message.event?.type,
+        deltaType: message.event?.delta?.type,
+        contentType: message.event?.content_block?.type
+      }));
+    }
+    if (!queryCtx.turnOutput) continue;
+    const streamLive = Boolean(queryCtx.currentPiStream);
+    switch (message.type) {
+      case "stream_event":
+        if (!streamLive) break;
+        processStreamEvent(message, customToolNameToPi, model, queryCtx);
+        break;
+      case "assistant": {
+        const sdkError = message.error;
+        if (sdkError && account) {
+          if (!failure) holdFailure({ kind: classifyClaudeFailure(sdkError), message: String(sdkError) });
+          break;
+        }
+        if (!streamLive && !queryCtx.turnSawToolCall) break;
+        processAssistantMessage(message, model, customToolNameToPi, queryCtx);
+        break;
+      }
+      case "result":
+        if (failure && message.subtype === "success" && queryCtx.committedOutput) {
+          debug(`consumeQuery: clearing informational ${failure.kind ?? "unclassified"} failure \u2014 query recovered with committed output`);
+          holdFailure(void 0);
+        }
+        if (account && failure) break;
+        if (!queryCtx.turnSawStreamEvent && message.subtype === "success") {
+          if (!streamLive) break;
+          const text = message.result || "";
+          if (queryCtx.turnBlocks.some((b) => b.type === "text" && b.text === text)) {
+            debug("consumeQuery: result text already rendered by assistant fallback; skipping duplicate");
+            break;
+          }
+          ensureTurnStarted(queryCtx);
+          queryCtx.turnBlocks.push({ type: "text", text });
+          const idx = queryCtx.turnBlocks.length - 1;
+          queryCtx.currentPiStream?.push({ type: "text_start", contentIndex: idx, partial: queryCtx.turnOutput });
+          queryCtx.currentPiStream?.push({ type: "text_delta", contentIndex: idx, delta: text, partial: queryCtx.turnOutput });
+          queryCtx.currentPiStream?.push({ type: "text_end", contentIndex: idx, content: text, partial: queryCtx.turnOutput });
+        } else if (message.subtype !== "success") {
+          const errorLines = Array.isArray(message.errors) ? uniqueNonEmptyLines(message.errors) : [];
+          const errors = errorLines.length > 0 ? errorLines.join("\n") : String(message.result || message.subtype || "Claude Code request failed");
+          const usageLimit = isUsageLimitMessage(message);
+          if (!failure || !failure.rateLimitInfo) {
+            holdFailure({ kind: usageLimit ? "rate-limit" : classifyClaudeFailure(errors), message: errors });
+          }
+          if (account) break;
+          if (usageLimit) {
+            queryCtx.handledTerminalError = true;
+            queryCtx.turnOutput.stopReason = "error";
+            queryCtx.turnOutput.errorMessage = errors;
+            queryCtx.currentPiStream?.push({ type: "error", reason: "error", error: queryCtx.turnOutput });
+            queryCtx.currentPiStream?.end();
+            queryCtx.currentPiStream = null;
+          }
+        }
+        break;
+      case "system":
+        if (!streamLive) break;
+        if (message.subtype === "init" && message.session_id) {
+          capturedSessionId = message.session_id;
+          queryCtx.childSessionId = capturedSessionId;
+          noteFastModeDisabledReason(message, bridgeConfig);
+          if (account && router && !accountProbe) {
+            accountProbe = Promise.allSettled([
+              sdkQuery.accountInfo().then((info) => router.recordIdentity(account.profileId, {
+                email: info.email,
+                organization: info.organization,
+                subscriptionType: info.subscriptionType
+              })),
+              sdkQuery.usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET().then((usage) => router.recordUsage(account.profileId, usage))
+            ]).then((results) => {
+              const labels = ["recordIdentity", "recordUsage"];
+              results.forEach((result, i) => {
+                if (result.status === "rejected") debug(`consumeQuery: account probe ${labels[i]} rejected:`, result.reason);
+              });
+            });
+          }
+        } else if (message.subtype === "model_refusal_fallback") {
+          const originalModel = message.original_model;
+          const fallbackModel = message.fallback_model;
+          updateTurnOutputModel(fallbackModel, queryCtx);
+          debug("consumeQuery: model_refusal_fallback", JSON.stringify({ originalModel, fallbackModel }));
+          if (typeof fallbackModel === "string" && typeof originalModel === "string" && fallbackModelForPrimaryModel(originalModel) === fallbackModel) {
+            safeNotify(
+              `Pi Claude switched ${modelDisplayName(originalModel)} to ${modelDisplayName(fallbackModel)} after Claude Code safety fallback.`,
+              "info"
+            );
+          }
+        }
+        break;
+      case "user":
+        noteChildExecutedToolResults(message, queryCtx);
+        break;
+      case "rate_limit_event": {
+        if (!streamLive) break;
+        const info = message.rate_limit_info;
+        debug("consumeQuery: rate_limit_event", JSON.stringify(info).slice(0, 300));
+        if (info?.status === "rejected") {
+          const rateLimitType = rateLimitTypeFromInfo(info);
+          const resetAt = rateLimitResetFromInfo(info);
+          const resetAtMs = rateLimitResetMs(info);
+          const reason = `${rateLimitType ?? "unknown"} rate limit`;
+          if (account && router) {
+            holdFailure({ kind: "rate-limit", message: reason, rateLimitInfo: info });
+            safeRouterCall("recordRateLimit", () => router.recordRateLimit(account.profileId, info, model.id));
+          } else {
+            const resetsAt = formatResetTimestamp(resetAtMs ?? resetAt);
+            emitRateLimitEvent({
+              model: model.id,
+              provider: model.provider,
+              rateLimitType,
+              reason,
+              resetAt,
+              ...Number.isFinite(resetAtMs) ? { resetAtMs } : {},
+              source: "claude-bridge",
+              status: "rejected"
+            });
+            safeNotify(`${RATE_LIMIT_TOKEN} Claude ${reason} hit \u2014 resets ${resetsAt}`, "warning");
+          }
+        } else if (info?.status === "allowed_warning") {
+          const warning = formatAllowedRateLimitWarning(info);
+          if (warning) safeNotify(warning, "warning");
+          else debug("consumeQuery: suppressed low/ambiguous allowed_warning rate_limit_event", JSON.stringify(info).slice(0, 300));
+        }
+        break;
+      }
+      default:
+        debug("consumeQuery: unhandled SDK message type", message.type);
+        break;
+    }
+  }
+  if (accountProbe) {
+    await Promise.race([
+      accountProbe,
+      new Promise((resolve5) => setTimeout(resolve5, 1500))
+    ]);
+  }
+  debug(`consumeQuery: for-await loop exited, wasAborted=${wasAborted()}, capturedSessionId=${capturedSessionId?.slice(0, 8) ?? "none"}, failure=${failure?.kind ?? "none"}`);
+  return { capturedSessionId, failure };
+}
+
+// src/agents-md.ts
+import { lstatSync as lstatSync2, readFileSync as readFileSync7, statSync as statSync5 } from "fs";
+import { dirname as dirname5, join as join9, resolve as resolve3 } from "path";
+var CONTEXT_FILE_CANDIDATES = ["AGENTS.override.md", "AGENTS.md", "AGENTS.MD"];
+function contextFileInDir(dir) {
+  for (const filename of CONTEXT_FILE_CANDIDATES) {
+    const candidate = join9(dir, filename);
+    try {
+      if (statSync5(candidate).isFile()) return candidate;
+    } catch (error51) {
+      let lstatCode;
+      let entryExists = false;
+      try {
+        lstatSync2(candidate);
+        entryExists = true;
+      } catch (lstatError) {
+        lstatCode = lstatError.code;
+      }
+      if (entryExists || lstatCode !== "ENOENT") {
+        const detail = error51.code ?? String(error51);
+        const suffix = entryExists ? "" : ` (lstat: ${lstatCode ?? "unknown"})`;
+        debug(`agents-md: skipping unusable ${candidate}: ${detail}${suffix}`);
+      }
+    }
+  }
+  return void 0;
+}
+function resolveAgentsMdPath() {
+  if (isolatedFromEnv()) return void 0;
+  const fromCwd = findAgentsMdInParents(process.cwd());
+  if (fromCwd) return fromCwd;
+  return contextFileInDir(piUserDir());
+}
+function findAgentsMdInParents(startDir) {
+  let current = resolve3(startDir);
+  while (true) {
+    const candidate = contextFileInDir(current);
+    if (candidate) return candidate;
+    const parent = dirname5(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return void 0;
+}
+function extractAgentsAppend() {
+  const agentsPath = resolveAgentsMdPath();
+  if (!agentsPath) return void 0;
+  try {
+    const content = readFileSync7(agentsPath, "utf-8").trim();
+    if (!content) return void 0;
+    const sanitized = sanitizeAgentsContent(content);
+    return sanitized.length > 0 ? `# CLAUDE.md
+
+${sanitized}` : void 0;
+  } catch (error51) {
+    debug(`agents-md: failed to read ${agentsPath}:`, error51 instanceof Error ? error51.message : String(error51));
+    return void 0;
+  }
+}
+function sanitizeAgentsContent(content) {
+  let sanitized = content;
+  sanitized = sanitized.replace(/~\/\.pi\b/gi, "~/.claude");
+  sanitized = sanitized.replace(/(^|[\s'"`])\.pi\//g, "$1.claude/");
+  sanitized = sanitized.replace(/\b\.pi\b/gi, ".claude");
+  sanitized = sanitized.replace(/\bpi\b/gi, "environment");
+  return sanitized;
+}
+
+// src/prompt-context.ts
+import { existsSync as existsSync5, readFileSync as readFileSync8 } from "fs";
+import { dirname as dirname6, join as join10, resolve as resolve4 } from "path";
+function readTrimmed(path) {
+  try {
+    if (!existsSync5(path)) return void 0;
+    const content = readFileSync8(path, "utf8").trim();
+    return content.length > 0 ? content : void 0;
+  } catch (error51) {
+    debug(`prompt-context: failed to read ${path}:`, error51 instanceof Error ? error51.message : String(error51));
+    return void 0;
+  }
+}
+function findProjectAppendSystem(startDir) {
+  let current = resolve4(startDir);
+  while (true) {
+    const candidate = join10(current, ".pi", "APPEND_SYSTEM.md");
+    if (existsSync5(candidate)) return candidate;
+    const parent = dirname6(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return void 0;
+}
+function readAppendSystemPromptFiles(cwd) {
+  const files = [
+    { label: "global APPEND_SYSTEM.md", path: join10(piUserDir(), "APPEND_SYSTEM.md") }
+  ];
+  const projectPath = isolatedFromEnv() ? void 0 : findProjectAppendSystem(cwd);
+  if (projectPath) files.push({ label: "project .pi/APPEND_SYSTEM.md", path: projectPath });
+  const seen = /* @__PURE__ */ new Set();
+  const output = [];
+  for (const file2 of files) {
+    if (seen.has(file2.path)) continue;
+    seen.add(file2.path);
+    const content = readTrimmed(file2.path);
+    if (content) output.push({ label: file2.label, content });
+  }
+  return output;
+}
+function splitPromptBlocks(systemPrompt) {
+  return (systemPrompt ?? "").split(/\n{2,}/).map((block) => block.trim()).filter(Boolean);
+}
+function extractHeadingSection(systemPrompt, headings) {
+  if (!systemPrompt) return void 0;
+  let start = -1;
+  for (const heading of headings) {
+    const index = systemPrompt.indexOf(heading);
+    if (index >= 0 && (start < 0 || index < start)) start = index;
+  }
+  if (start < 0) return void 0;
+  const rest = systemPrompt.slice(start).trim();
+  const endCandidates = [
+    rest.slice(1).search(/\n##\s+/),
+    rest.search(/\n<\/project_instructions>/),
+    rest.search(/\n<\/project_context>/)
+  ].map((index, offset) => index >= 0 && offset === 0 ? index + 1 : index).filter((index) => index >= 0);
+  const end = endCandidates.length > 0 ? Math.min(...endCandidates) : -1;
+  return (end >= 0 ? rest.slice(0, end) : rest).trim();
+}
+function extractBlockByMarkers(systemPrompt, markers) {
+  for (const block of splitPromptBlocks(systemPrompt)) {
+    if (markers.some((marker) => marker.test(block))) return block;
+  }
+  return void 0;
+}
+function buildPromptContextAppend(systemPrompt, cwd, settings) {
+  const parts = [];
+  const labels = [];
+  if (settings.includeAppendSystemPromptMd) {
+    for (const file2 of readAppendSystemPromptFiles(cwd)) {
+      parts.push(xmlBlock("append_system_prompt", { label: file2.label }, file2.content));
+      labels.push(file2.label);
+    }
+  }
+  if (settings.includeProjectAgentsHook) {
+    const projectAgents = extractHeadingSection(systemPrompt, ["## Project Agents", "## Project Subagents"]);
+    if (projectAgents) {
+      parts.push(xmlBlock("before_agent_start", { source: "project-agents" }, projectAgents));
+      labels.push("project agents hook");
+    }
+  }
+  if (settings.includeTaskPanelHook) {
+    const taskReminder = extractBlockByMarkers(systemPrompt, [/^Task workflow reminder:/]);
+    if (taskReminder) {
+      parts.push(xmlBlock("before_agent_start", { source: "task-panel" }, taskReminder));
+      labels.push("task panel hook");
+    }
+  }
+  if (settings.includeCavemanHook) {
+    const caveman = extractBlockByMarkers(systemPrompt, [/^You MUST respond in caveman /m]);
+    if (caveman) {
+      parts.push(xmlBlock("before_agent_start", { source: "caveman" }, caveman));
+      labels.push("caveman hook");
+    }
+  }
+  if (parts.length === 0) return { labels };
+  return {
+    labels,
+    text: xmlBlock(
+      "forwarded_pi_context",
+      {},
+      [
+        "The following content was explicitly enabled in pi-claude-bridge settings and comes from Pi prompt files or before_agent_start prompt hooks.",
+        ...parts
+      ].join("\n\n"),
+      false
+    )
+  };
+}
+function escapeXmlAttr(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeXmlText(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function xmlBlock(tag, attrs, content, escapeContent = true) {
+  const attrText = Object.entries(attrs).map(([key, value]) => ` ${key}="${escapeXmlAttr(value)}"`).join("");
+  const body = escapeContent ? escapeXmlText(content.trim()) : content.trim();
+  return `<${tag}${attrText}>
+${body}
+</${tag}>`;
+}
+
+// src/query-options.ts
+var REASONING_TO_EFFORT = {
+  minimal: "low",
+  low: "low",
+  medium: "medium",
+  high: "high",
+  xhigh: "max",
+  max: "max"
+};
+function normalizeEffortOverrideModelKey(value) {
+  const key = value.trim().toLowerCase();
+  return key.startsWith(`${PROVIDER_ID}/`) ? key.slice(PROVIDER_ID.length + 1) : key;
+}
+function resolveConfiguredEffort(modelId, reasoningEffort, providerConfig) {
+  const target = normalizeEffortOverrideModelKey(modelId);
+  for (const [key, rawEffort] of Object.entries(providerConfig?.modelEffortOverrides ?? {})) {
+    const normalizedKey = normalizeEffortOverrideModelKey(key);
+    if (normalizedKey !== "*" && normalizedKey !== target) continue;
+    const effort = normalizeEffortLevel(rawEffort);
+    if (effort) return effort;
+  }
+  return normalizeEffortLevel(providerConfig?.forceEffort) ?? reasoningEffort;
+}
+function buildClaudeQueryOptions(input) {
+  const { cwd, requestedModel, queryModel, account, bridgeConfig, systemPrompt, reasoning, resumeSessionId, mcpServers, claudeExecutable } = input;
+  const providerSettings = bridgeConfig.provider ?? {};
+  const accountScope = accountSessionScope(account);
+  const enableCloudMcp = connectorsEnabledFor(bridgeConfig);
+  const connectorWriteMode = connectorWriteModeFor(bridgeConfig);
+  const connectorServers = enableCloudMcp ? connectorServersSnapshot(accountScope.claudeConfigDir) : {};
+  const appendSystemPrompt = providerSettings.appendSystemPrompt !== false;
+  const agentsAppend = appendSystemPrompt ? extractAgentsAppend() : void 0;
+  const skillsAppend = appendSystemPrompt ? extractSkillsBlock(systemPrompt) : void 0;
+  const promptContextAppend = buildPromptContextAppend(systemPrompt, cwd, bridgeConfig.promptContext ?? {});
+  const appendParts = [agentsAppend, skillsAppend, promptContextAppend.text].filter((part) => Boolean(part));
+  const systemPromptAppend = appendParts.length > 0 ? appendParts.join("\n\n") : void 0;
+  const settingSources = settingSourcesForQuery(
+    enableCloudMcp,
+    appendSystemPrompt,
+    providerSettings.settingSources
+  );
+  const strictMcpConfigEnabled = !appendSystemPrompt && providerSettings.strictMcpConfig !== false;
+  const requestedEffort = reasoning ? queryModel.thinkingLevelMap?.[reasoning] ?? REASONING_TO_EFFORT[reasoning] : void 0;
+  const effort = resolveConfiguredEffort(queryModel.id, requestedEffort, providerSettings);
+  const extraArgs = {};
+  if (effort) extraArgs["thinking-display"] = "summarized";
+  const fallbackModel = account && requestedModel.id === FABLE_MODEL_ID && queryModel.id === requestedModel.id ? void 0 : fallbackModelForPrimaryModel(queryModel.id);
+  const childEnv = {
+    ...account ? subscriberProfileEnv(account) : process.env,
+    ENABLE_CLAUDEAI_MCP_SERVERS: enableCloudMcp ? "1" : "0",
+    DISABLE_AUTO_COMPACT: "1"
+  };
+  const queryOptions = {
+    cwd,
+    model: queryModel.id,
+    env: childEnv,
+    ...connectorQueryOptions(enableCloudMcp, connectorWriteMode),
+    permissionMode: "bypassPermissions",
+    includePartialMessages: true,
+    ...fallbackModel ? { fallbackModel } : {},
+    ...providerSettings.fastMode ? { settings: { fastMode: true } } : {},
+    systemPrompt: {
+      type: "preset",
+      preset: "claude_code",
+      append: systemPromptAppend ? systemPromptAppend : void 0
+    },
+    extraArgs,
+    ...strictMcpConfigEnabled ? { strictMcpConfig: true } : {},
+    ...effort ? { effort } : {},
+    ...settingSources ? { settingSources } : {},
+    ...mcpServers || Object.keys(connectorServers).length > 0 ? { mcpServers: { ...mcpServers ?? {}, ...connectorServers } } : {},
+    ...resumeSessionId ? { resume: resumeSessionId } : {},
+    ...claudeExecutable ? { pathToClaudeCodeExecutable: claudeExecutable } : {},
+    spawnClaudeCodeProcess: spawnClaudeCodeWithDiagnostics,
+    ...makeCliDebugOptions("provider")
+  };
+  return {
+    queryOptions,
+    enableCloudMcp,
+    appendSystemPrompt,
+    promptContextLabels: promptContextAppend.labels,
+    strictMcpConfigEnabled,
+    ...effort ? { effort } : {},
+    ...fallbackModel ? { fallbackModel } : {}
+  };
+}
+
+// src/index.ts
+var _piAi = piAi;
+var getModels = await resolveGetModels(_piAi);
+var newAssistantMessageEventStream = typeof _piAi.createAssistantMessageEventStream === "function" ? _piAi.createAssistantMessageEventStream : () => new _piAi.AssistantMessageEventStream();
+var PRIMARY_INSTANCE_KEY = /* @__PURE__ */ Symbol.for("claude-bridge:primaryInstance");
+var ACTIVE_STREAM_SIMPLE_KEY = /* @__PURE__ */ Symbol.for("claude-bridge:activeStreamSimple");
+var ROTATION_STATE_KEY = /* @__PURE__ */ Symbol("claude-bridge:rotationState");
+var MAX_ROTATION_ATTEMPTS = 16;
+var MODELS = buildModels(getModels("anthropic"));
 function extractAllToolResults2(context) {
   const { results, stopIdx } = extractAllToolResults(context.messages);
   debug(`extractAllToolResults: ${results.length} results from ${context.messages.length} msgs, stopped at index ${stopIdx}`);
@@ -45087,43 +46357,59 @@ function extractAllToolResults2(context) {
   return results;
 }
 function extractUserPrompt(messages) {
-  const last = messages[messages.length - 1];
-  if (!last || last.role !== "user") return null;
-  if (typeof last.content === "string") return last.content;
-  return messageContentToText(last.content) || "";
+  if (messages.length === 0 || messages.some((message) => message.role !== "user")) return null;
+  return messages.map(
+    (message) => typeof message.content === "string" ? message.content : messageContentToText(message.content) || ""
+  ).join("\n\n");
 }
 function extractUserPromptBlocks(messages) {
-  const last = messages[messages.length - 1];
-  if (!last || last.role !== "user") return null;
-  if (typeof last.content === "string") {
-    debug(`extractUserPromptBlocks: content is string (length=${last.content.length})`);
-    return null;
-  }
-  if (!Array.isArray(last.content)) {
-    debug(`extractUserPromptBlocks: content is ${typeof last.content}`);
-    return null;
-  }
-  debug(`extractUserPromptBlocks: ${last.content.length} blocks, types=${last.content.map((b) => b.type).join(",")}`);
+  if (messages.length === 0 || messages.some((message) => message.role !== "user")) return null;
   let hasImage = false;
   const blocks = [];
-  for (const block of last.content) {
-    if (block.type === "text" && block.text) {
-      blocks.push({ type: "text", text: block.text });
-    } else if (block.type === "image") {
-      debug(`image block: mimeType=${block.mimeType}, data length=${(block.data ?? "").length}, keys=${Object.keys(block).join(",")}`);
-      if (!block.data || !block.mimeType) {
-        debug(`image block missing data or mimeType, skipping`);
-        continue;
+  for (let messageIndex = 0; messageIndex < messages.length; messageIndex++) {
+    const content = messages[messageIndex].content;
+    if (messageIndex > 0) blocks.push({ type: "text", text: "\n\n" });
+    if (typeof content === "string") {
+      if (content) blocks.push({ type: "text", text: content });
+      continue;
+    }
+    if (!Array.isArray(content)) {
+      debug(`extractUserPromptBlocks: content is ${typeof content}`);
+      continue;
+    }
+    debug(`extractUserPromptBlocks: ${content.length} blocks, types=${content.map((b) => b.type).join(",")}`);
+    for (const block of content) {
+      if (block.type === "text" && block.text) {
+        blocks.push({ type: "text", text: block.text });
+      } else if (block.type === "image") {
+        debug(`image block: mimeType=${block.mimeType}, data length=${(block.data ?? "").length}, keys=${Object.keys(block).join(",")}`);
+        if (!block.data || !block.mimeType) {
+          debug(`image block missing data or mimeType, skipping`);
+          continue;
+        }
+        hasImage = true;
+        blocks.push({
+          type: "image",
+          source: { type: "base64", media_type: block.mimeType, data: block.data }
+        });
       }
-      hasImage = true;
-      blocks.push({
-        type: "image",
-        source: { type: "base64", media_type: block.mimeType, data: block.data }
-      });
     }
   }
   return hasImage ? blocks : null;
 }
+function planDeferredUserReplay(messages, capturedThrough = 0) {
+  let runStart = messages.length;
+  while (runStart > capturedThrough && messages[runStart - 1]?.role === "user") runStart--;
+  const trailingUsers = messages.slice(runStart);
+  const prompt = trailingUsers.length > 0 ? extractUserPrompt(trailingUsers) : null;
+  const blocks = trailingUsers.length > 0 ? extractUserPromptBlocks(trailingUsers) : null;
+  return {
+    runStart,
+    userMessageCount: trailingUsers.length,
+    prompt: prompt?.trim() ? prompt : null,
+    blocks
+  };
+}
 async function* wrapPromptStream(blocks) {
   yield {
     type: "user",
@@ -45183,162 +46469,44 @@ function buildMcpServers(tools, queryCtx) {
         });
         return { content: [{ type: "text", text: `Claude bridge internal error: no matching tool_call id for ${tool.name}` }], isError: true };
       }
-      if (claim.argsMismatch) {
-        debug(`mcp handler: ${tool.name} [${toolCallId}] claimed sole same-name call despite args mismatch`);
-        diagDump("tool_claim_args_mismatch", {
-          toolName: tool.name,
-          toolCallId,
-          handlerArgKeys: argKeys(mappedArgs),
-          recordedArgKeys: argKeys(queryCtx.turnToolCalls.find((call) => call.id === toolCallId)?.arguments)
-        });
-      } else if (claim.match !== "tool-args" || claim.ambiguous) {
-        debug(`mcp handler: ${tool.name} [${toolCallId}] claimed by ${claim.match}${claim.ambiguous ? " (ambiguous)" : ""}`);
-      }
-      if (toolCallId && queryCtx.pendingResults.has(toolCallId)) {
-        const result = queryCtx.pendingResults.get(toolCallId);
-        queryCtx.pendingResults.delete(toolCallId);
-        queryCtx.markToolResultResolved(toolCallId);
-        debug(`mcp handler: ${tool.name} [${toolCallId}] \u2192 resolved from queue (${queryCtx.pendingResults.size} remaining)`);
-        return result;
-      }
-      debug(`mcp handler: ${tool.name} [${toolCallId}] \u2192 waiting`);
-      scheduleToolUseTurnEnd(
-        queryCtx,
-        () => finalizeToolUseTurnFromMcpInvocation(queryCtx, toolCallId, tool.name, mappedArgs),
-        `mcp-invocation:${tool.name}`
-      );
-      return new Promise((resolve5) => {
-        queryCtx.pendingToolCalls.set(toolCallId, {
-          toolName: tool.name,
-          resolve: (result) => {
-            queryCtx.markToolResultResolved(toolCallId);
-            resolve5(result);
-          }
-        });
-      });
-    }
-  }));
-  const server = f0e({ name: MCP_SERVER_NAME, version: "1.0.0", tools: mcpTools });
-  return { [MCP_SERVER_NAME]: server };
-}
-var REASONING_TO_EFFORT = {
-  minimal: "low",
-  low: "low",
-  medium: "medium",
-  high: "high",
-  xhigh: "max",
-  max: "max"
-};
-function normalizeEffortOverrideModelKey(value) {
-  const key = value.trim().toLowerCase();
-  return key.startsWith(`${PROVIDER_ID}/`) ? key.slice(PROVIDER_ID.length + 1) : key;
-}
-function resolveConfiguredEffort(modelId, reasoningEffort, providerConfig) {
-  const target = normalizeEffortOverrideModelKey(modelId);
-  for (const [key, rawEffort] of Object.entries(providerConfig?.modelEffortOverrides ?? {})) {
-    const normalizedKey = normalizeEffortOverrideModelKey(key);
-    if (normalizedKey !== "*" && normalizedKey !== target) continue;
-    const effort = normalizeEffortLevel(rawEffort);
-    if (effort) return effort;
-  }
-  return normalizeEffortLevel(providerConfig?.forceEffort) ?? reasoningEffort;
-}
-async function consumeQuery(sdkQuery, customToolNameToPi, model, cwd, bridgeConfig, wasAborted) {
-  let capturedSessionId;
-  for await (const message of sdkQuery) {
-    if (wasAborted()) break;
-    const queryCtx = ctx();
-    activeStreamIdleWatchdogs.get(queryCtx)?.noteChunk();
-    if (!queryCtx.turnOutput) continue;
-    if (!queryCtx.currentPiStream && !(message.type === "assistant" && queryCtx.turnSawToolCall)) continue;
-    switch (message.type) {
-      case "stream_event":
-        processStreamEvent(message, customToolNameToPi, model);
-        break;
-      case "assistant":
-        processAssistantMessage(message, model, customToolNameToPi);
-        break;
-      case "result":
-        if (!ctx().turnSawStreamEvent && message.subtype === "success") {
-          const text = message.result || "";
-          if (ctx().turnBlocks.some((b) => b.type === "text" && b.text === text)) {
-            debug("consumeQuery: result text already rendered by assistant fallback; skipping duplicate");
-            break;
-          }
-          ensureTurnStarted();
-          ctx().turnBlocks.push({ type: "text", text });
-          const idx = ctx().turnBlocks.length - 1;
-          ctx().currentPiStream?.push({ type: "text_start", contentIndex: idx, partial: ctx().turnOutput });
-          ctx().currentPiStream?.push({ type: "text_delta", contentIndex: idx, delta: text, partial: ctx().turnOutput });
-          ctx().currentPiStream?.push({ type: "text_end", contentIndex: idx, content: text, partial: ctx().turnOutput });
-        } else if (message.subtype !== "success" && (isExtraUsageRequiredMessage(message) || isUsageLimitMessage(message))) {
-          const errorLines = Array.isArray(message.errors) ? uniqueNonEmptyLines(message.errors) : [];
-          const errors = errorLines.length > 0 ? errorLines.join("\n") : String(message.subtype ?? "Claude Code rate limit");
-          const extraUsage = isExtraUsageRequiredMessage(message);
-          const openedExtraUsage = extraUsage && launchExtraUsageHelperIfAllowed(cwd, bridgeConfig, "result error");
-          ctx().handledTerminalError = true;
-          ctx().turnOutput.stopReason = "error";
-          const extraUsageHint = openedExtraUsage ? "\n\nOpened Claude Code /extra-usage helper. Complete billing/admin flow in the browser, then retry the prompt." : extraUsage ? "\n\nRun /claude-bridge:extra, or enable Allow extra usage helper in settings." : "";
-          ctx().turnOutput.errorMessage = `${errors}${extraUsageHint}`;
-          ctx().currentPiStream?.push({ type: "error", reason: "error", error: ctx().turnOutput });
-          ctx().currentPiStream?.end();
-          ctx().currentPiStream = null;
-        }
-        break;
-      case "system":
-        if (message.subtype === "init" && message.session_id) {
-          capturedSessionId = message.session_id;
-          queryCtx.childSessionId = capturedSessionId;
-          noteFastModeDisabledReason(message, bridgeConfig);
-        } else if (message.subtype === "model_refusal_fallback") {
-          const originalModel = message.original_model;
-          const fallbackModel = message.fallback_model;
-          updateTurnOutputModel(fallbackModel);
-          debug("consumeQuery: model_refusal_fallback", JSON.stringify({ originalModel, fallbackModel }));
-          if (typeof fallbackModel === "string" && typeof originalModel === "string" && fallbackModelForPrimaryModel(originalModel) === fallbackModel) {
-            safeNotify(
-              `Claude bridge switched ${modelDisplayName(originalModel)} to ${modelDisplayName(fallbackModel)} after Claude Code safety fallback.`,
-              "info"
-            );
-          }
-        }
-        break;
-      case "user":
-        noteChildExecutedToolResults(message);
-        break;
-      case "rate_limit_event": {
-        const info = message.rate_limit_info;
-        debug("consumeQuery: rate_limit_event", JSON.stringify(info).slice(0, 300));
-        if (info?.status === "rejected") {
-          const resetsAt = formatResetTimestamp(info.resetsAt);
-          const resetAtMs = resetTimestampMs(info.resetsAt);
-          const reason = `${info.rateLimitType ?? "unknown"} rate limit`;
-          const launchedExtraUsage = isExtraUsageRequiredMessage(info) && launchExtraUsageHelperIfAllowed(cwd, bridgeConfig, reason);
-          emitRateLimitEvent({
-            model: model.id,
-            provider: PROVIDER_ID,
-            rateLimitType: info.rateLimitType,
-            reason,
-            resetAt: info.resetsAt,
-            ...Number.isFinite(resetAtMs) ? { resetAtMs } : {},
-            source: "claude-bridge",
-            status: "rejected"
-          });
-          piUI?.notify(`${RATE_LIMIT_TOKEN} Claude ${reason} hit \u2014 resets ${resetsAt}${launchedExtraUsage ? "; opened /extra-usage helper" : ""}`, "warning");
-        } else if (info?.status === "allowed_warning") {
-          const warning = formatAllowedRateLimitWarning(info);
-          if (warning) piUI?.notify(warning, "warning");
-          else debug("consumeQuery: suppressed low/ambiguous allowed_warning rate_limit_event", JSON.stringify(info).slice(0, 300));
-        }
-        break;
-      }
-      default:
-        debug("consumeQuery: unhandled SDK message type", message.type);
-        break;
+      if (claim.argsMismatch) {
+        debug(`mcp handler: ${tool.name} [${toolCallId}] claimed sole same-name call despite args mismatch`);
+        diagDump("tool_claim_args_mismatch", {
+          toolName: tool.name,
+          toolCallId,
+          handlerArgKeys: argKeys(mappedArgs),
+          recordedArgKeys: argKeys(queryCtx.turnToolCalls.find((call) => call.id === toolCallId)?.arguments)
+        });
+      } else if (claim.match !== "tool-args" || claim.ambiguous) {
+        debug(`mcp handler: ${tool.name} [${toolCallId}] claimed by ${claim.match}${claim.ambiguous ? " (ambiguous)" : ""}`);
+      }
+      const earlyResult = toolCallId ? takeQueuedOrParkedResult(queryCtx, toolCallId) : void 0;
+      if (earlyResult !== void 0) {
+        queryCtx.markToolResultResolved(toolCallId);
+        debug(`mcp handler: ${tool.name} [${toolCallId}] \u2192 resolved from queue/parked (${queryCtx.pendingResults.size} queued, ${queryCtx.reapedResults.size} parked remaining)`);
+        return earlyResult;
+      }
+      debug(`mcp handler: ${tool.name} [${toolCallId}] \u2192 waiting`);
+      scheduleToolUseTurnEnd(
+        queryCtx,
+        () => finalizeToolUseTurnFromMcpInvocation(queryCtx, toolCallId, tool.name, mappedArgs),
+        `mcp-invocation:${tool.name}`
+      );
+      return new Promise((resolve5) => {
+        queryCtx.pendingToolCalls.set(toolCallId, {
+          toolName: tool.name,
+          args: mappedArgs,
+          generation: queryCtx.callbackGeneration,
+          resolve: (result) => {
+            queryCtx.markToolResultResolved(toolCallId);
+            resolve5(result);
+          }
+        });
+      });
     }
-  }
-  debug(`consumeQuery: for-await loop exited, wasAborted=${wasAborted()}, capturedSessionId=${capturedSessionId?.slice(0, 8) ?? "none"}`);
-  return { capturedSessionId };
+  }));
+  const server = f0e({ name: MCP_SERVER_NAME, version: "1.0.0", tools: mcpTools });
+  return { [MCP_SERVER_NAME]: server };
 }
 function claimPrimaryInstance() {
   const g = globalThis;
@@ -45347,6 +46515,9 @@ function claimPrimaryInstance() {
 }
 function releaseProviderTokens(event) {
   const g = globalThis;
+  if (g[CLAUDE_BRIDGE_ACCOUNT_HOST_SYMBOL] === BRIDGE_ACCOUNT_HOST) {
+    g[CLAUDE_BRIDGE_ACCOUNT_HOST_SYMBOL] = void 0;
+  }
   if (g[ACTIVE_STREAM_SIMPLE_KEY] === streamClaudeAgentSdk) {
     debug(`${event}: clearing ACTIVE_STREAM_SIMPLE_KEY`);
     g[ACTIVE_STREAM_SIMPLE_KEY] = void 0;
@@ -45378,12 +46549,20 @@ function applyProviderRegistration(trigger) {
     }
     return;
   }
-  const credentialed = hasClaudeCredentials();
+  const credentialed = hasClaudeCredentials() || Boolean(resolveClaudeAccountRouter());
   debug(`${trigger}: native registration upsert, credentialed=${credentialed} (module=${moduleInstanceId})`);
-  if (credentialed && connectorsEnabledFor(loadConfig(process.cwd()))) primeConnectorServers();
+  if (hasClaudeCredentials() && connectorsEnabledFor(loadConfig(process.cwd()))) primeConnectorServers();
   g[ACTIVE_STREAM_SIMPLE_KEY] = streamClaudeAgentSdk;
   try {
-    nativeProviderInstance ??= buildNativeProvider(_piAi, MODELS, streamClaudeAgentSdk);
+    nativeProviderInstance ??= buildNativeProvider(
+      _piAi,
+      MODELS,
+      streamClaudeAgentSdk,
+      process.env,
+      // Availability includes a companion account pool: the router owns
+      // credentials the direct existence probes cannot see.
+      () => hasClaudeCredentials() || Boolean(resolveClaudeAccountRouter())
+    );
     pi.registerProvider(nativeProviderInstance);
   } catch (err) {
     if (g[ACTIVE_STREAM_SIMPLE_KEY] === streamClaudeAgentSdk) g[ACTIVE_STREAM_SIMPLE_KEY] = void 0;
@@ -45391,7 +46570,17 @@ function applyProviderRegistration(trigger) {
   }
 }
 function streamClaudeAgentSdk(model, context, options) {
+  return runInRequestLane(options?.sessionId, () => streamClaudeAgentSdkInLane(model, context, options));
+}
+function streamClaudeAgentSdkInLane(model, context, options) {
   const stream = newAssistantMessageEventStream();
+  const laneId = currentRequestLaneId();
+  const ephemeralLane = laneId !== void 0 && options?.cacheRetention === "none";
+  const releaseEphemeralLane = () => {
+    if (!ephemeralLane) return;
+    deleteSharedSessionLane(laneId);
+    deleteQueryLane(laneId);
+  };
   const lastMsgRole = context.messages[context.messages.length - 1]?.role;
   const cwd = options?.cwd ?? process.cwd();
   debug(`provider: streamClaudeAgentSdk called, activeQuery=${!!ctx().activeQuery}, lastMsgRole=${lastMsgRole}, isReentrant=${ctx().activeQuery !== null}`);
@@ -45399,13 +46588,14 @@ function streamClaudeAgentSdk(model, context, options) {
     const queryCtx = ctx();
     queryCtx.currentPiStream = stream;
     queryCtx.resetTurnState(model);
+    queryCtx.callbackGeneration += 1;
     activeStreamIdleWatchdogs.get(queryCtx)?.refresh();
     const allResults = extractAllToolResults2(context);
     debug(`provider: tool results, ${allResults.length} results, ${queryCtx.pendingToolCalls.size} waiting handlers, ctx.msgs=${context.messages.length}`);
     const unmatchedResultIds = [];
     for (const result of allResults) {
       const id = result.toolCallId;
-      if (id && !queryCtx.hasRecordedToolCall(id)) {
+      if (id && !queryCtx.hasRecordedToolCall(id) && !queryCtx.forwardedToolCallIds.has(id)) {
         queryCtx.markToolResultUnmatched(id);
         unmatchedResultIds.push(id);
         debug(`ERROR: tool result [${id}] has no registered tool_call id; refusing to queue or deliver`);
@@ -45424,7 +46614,7 @@ function streamClaudeAgentSdk(model, context, options) {
         debug(`WARNING: tool result without toolCallId, cannot match`);
       }
       if (queryCtx.pendingToolCalls.size > 0 && queryCtx.pendingResults.size > 0) {
-        debug(`BUG: both maps non-empty! handlers=${queryCtx.pendingToolCalls.size} results=${queryCtx.pendingResults.size}`);
+        debug(`note: handlers and queued results coexist: handlers=${queryCtx.pendingToolCalls.size} results=${queryCtx.pendingResults.size}`);
       }
     }
     if (unmatchedResultIds.length > 0) {
@@ -45432,38 +46622,65 @@ function streamClaudeAgentSdk(model, context, options) {
         content: [{ type: "text", text: `Claude bridge internal error: ${unmatchedResultIds.length} tool result(s) did not match any registered tool_call id. The turn was stopped to avoid delivering tool output to the wrong call. Unmatched ids: ${unmatchedResultIds.slice(0, 8).join(", ")}${unmatchedResultIds.length > 8 ? ", ..." : ""}` }],
         isError: true
       };
-      for (const pending of queryCtx.pendingToolCalls.values()) pending.resolve(errorResult);
+      for (const [pendingId, pending] of queryCtx.pendingToolCalls) {
+        if (!queryCtx.forwardedToolCallIds.has(pendingId)) queryCtx.deadToolCallIds.add(pendingId);
+        pending.resolve(errorResult);
+      }
       queryCtx.pendingToolCalls.clear();
       reportToolResultMismatch(queryCtx, "unmatched tool result", cwd);
     }
     if (queryCtx.pendingToolCalls.size > 0) {
-      debug(`WARNING: ${queryCtx.pendingToolCalls.size} MCP handlers still waiting after delivering ${allResults.length} results`);
-      piUI?.notify(`Claude bridge: ${queryCtx.pendingToolCalls.size} tool handler(s) still waiting \u2014 provider may be stuck`, "warning");
+      const stranded = drainStrandedToolCalls(queryCtx);
+      if (stranded.length > 0) {
+        const names = stranded.map((entry) => entry.toolName).join(", ");
+        debug(`provider: failed ${stranded.length} stranded MCP handler(s) never forwarded to Pi: ${names}`);
+        diagDump("tool_handlers_stranded", { count: stranded.length, stranded });
+        appendIntegrityEntry("tool_handlers_stranded", { count: stranded.length, stranded });
+        safeNotify(`Claude bridge: failed ${stranded.length} tool call(s) that never reached Pi before their turn ended (${names}). The model saw a retryable error.`, "warning");
+      }
+      if (queryCtx.pendingToolCalls.size > 0) {
+        debug(`WARNING: ${queryCtx.pendingToolCalls.size} MCP handlers still waiting after delivering ${allResults.length} results`);
+        safeNotify(`Claude bridge: ${queryCtx.pendingToolCalls.size} tool handler(s) still waiting \u2014 provider may be stuck`, "warning");
+      }
     }
+    let capturedThrough = context.messages.length;
     if (lastMsgRole === "user") {
-      const userPrompt = extractUserPrompt(context.messages);
-      if (userPrompt) {
-        ctx().deferredUserMessages.push(userPrompt);
-        debug(`provider: deferred user message for replay after query: ${userPrompt.slice(0, 60)}`);
+      const replay = planDeferredUserReplay(context.messages, queryCtx.latestCursor);
+      if (replay.prompt || replay.blocks) {
+        ctx().deferredUserMessages.push({ text: replay.prompt ?? "", blocks: replay.blocks ?? void 0 });
+        debug(`provider: deferred ${replay.userMessageCount} user message(s) for replay after query${replay.blocks ? ` (${replay.blocks.length} blocks incl. images)` : ""}: ${(replay.prompt ?? "[image-only]").slice(0, 60)}`);
+      } else {
+        capturedThrough = replay.runStart;
+        diagDump("deferred_user_replay_skipped", {
+          contextLength: context.messages.length,
+          runStart: replay.runStart,
+          userMessageCount: replay.userMessageCount,
+          messageRoles: context.messages.map((m, i) => `[${i}]${m.role}`).join(" ")
+        });
       }
     }
-    if (sharedSession) sharedSession.cursor = context.messages.length;
-    queryCtx.latestCursor = Math.max(queryCtx.latestCursor, context.messages.length);
+    const activeSession = getSharedSession();
+    if (activeSession && stackDepth() === 0 && !queryCtx.detachedFromSharedSession) {
+      setSharedSession({ ...activeSession, cursor: Math.max(activeSession.cursor, capturedThrough) });
+    }
+    queryCtx.latestCursor = Math.max(queryCtx.latestCursor, capturedThrough);
     return stream;
   }
   const lastMsg = context.messages[context.messages.length - 1];
   if (lastMsg?.role === "toolResult") {
     debug(`provider: orphaned tool result after abort, emitting end_turn`);
-    if (sharedSession) sharedSession.cursor = context.messages.length;
+    const activeSession = getSharedSession();
+    if (activeSession && stackDepth() === 0 && !ctx().detachedFromSharedSession) setSharedSession({ ...activeSession, cursor: context.messages.length });
     const c = ctx();
     queueMicrotask(() => {
       c.resetTurnState(model);
       stream.push({ type: "done", reason: "stop", message: c.turnOutput });
       stream.end();
+      releaseEphemeralLane();
     });
     return stream;
   }
-  if (!hasClaudeCredentials()) {
+  if (!hasClaudeCredentials() && !resolveClaudeAccountRouter()) {
     try {
       applyProviderRegistration("pre-spawn");
     } catch {
@@ -45491,6 +46708,7 @@ function streamClaudeAgentSdk(model, context, options) {
     queueMicrotask(() => {
       stream.push({ type: "error", reason: "error", error: errorOutput });
       stream.end();
+      releaseEphemeralLane();
     });
     return stream;
   }
@@ -45500,87 +46718,167 @@ function streamClaudeAgentSdk(model, context, options) {
   ctx().currentPiStream = stream;
   ctx().pendingToolCalls.clear();
   ctx().pendingResults.clear();
+  ctx().reapedResults.clear();
+  ctx().forwardedToolCallIds.clear();
+  ctx().deadToolCallIds.clear();
+  ctx().callbackGeneration = 0;
   ctx().deferredUserMessages = [];
   ctx().resetTurnState(model);
   ctx().resetToolTracking();
   ctx().latestCursor = 0;
+  ctx().committedOutput = false;
+  ctx().detachedFromSharedSession = isReentrant;
+  const router = resolveClaudeAccountRouter();
+  const rotationOptions = options;
+  const rotationState = rotationOptions?.[ROTATION_STATE_KEY] ?? {
+    excludedProfileIds: /* @__PURE__ */ new Set(),
+    attempts: 0
+  };
+  let account;
+  if (router) {
+    try {
+      account = router.acquire({
+        modelId: model.id,
+        sessionId: options?.sessionId,
+        excludedProfileIds: [...rotationState.excludedProfileIds],
+        forceRerank: rotationState.attempts > 0,
+        reason: rotationState.attempts > 0 ? "automatic-failover" : void 0
+      });
+      rotationState.attempts += 1;
+    } catch (error51) {
+      const message = error51 instanceof Error ? error51.message : String(error51);
+      const resetAtMs = Number(error51?.resetAtMs);
+      const rateLimitType = error51?.rateLimitType;
+      if (ctx().turnOutput) {
+        ctx().turnOutput.stopReason = "error";
+        ctx().turnOutput.errorMessage = message;
+        if (Number.isFinite(resetAtMs)) {
+          Object.assign(ctx().turnOutput, { resetAtMs, rateLimitType });
+        }
+      }
+      if (Number.isFinite(resetAtMs)) {
+        emitRateLimitEvent({
+          model: model.id,
+          provider: model.provider,
+          rateLimitType: rateLimitType ?? "all_accounts",
+          reason: message,
+          resetAt: new Date(resetAtMs).toISOString(),
+          resetAtMs,
+          source: "claude-bridge",
+          status: "rejected"
+        });
+      }
+      const errorOutput = ctx().turnOutput;
+      if (isReentrant) popContext();
+      queueMicrotask(() => {
+        stream.push({ type: "error", reason: "error", error: errorOutput });
+        stream.end();
+        releaseEphemeralLane();
+      });
+      return stream;
+    }
+  }
+  const queryModel = account?.modelId && account.modelId !== model.id ? { ...model, id: account.modelId, name: modelDisplayName(account.modelId) } : model;
+  if (queryModel.id !== model.id) {
+    updateTurnOutputModel(queryModel.id);
+    if (rotationState.announcedModelId !== queryModel.id) {
+      rotationState.announcedModelId = queryModel.id;
+      safeNotify(
+        account?.fallbackReason === "fable-quota" ? `Every ready account rejected Claude Fable; using ${modelDisplayName(queryModel.id)}.` : `Pi Claude switched to ${modelDisplayName(queryModel.id)}.`,
+        "info"
+      );
+    }
+  }
+  const attemptCtx = ctx();
+  const attemptBuffer = account ? new RetryEventBuffer(stream, () => attemptCtx.markOutputCommitted()) : void 0;
+  if (attemptBuffer) attemptCtx.currentPiStream = attemptBuffer;
   const { mcpTools, customToolNameToSdk, customToolNameToPi } = resolveMcpTools(context);
-  const promptBlocks = extractUserPromptBlocks(context.messages);
-  let promptText = extractUserPrompt(context.messages) ?? "";
-  if (!promptText && !promptBlocks) {
+  const bridgeConfig = loadConfig(cwd);
+  const providerSettings = bridgeConfig.provider ?? {};
+  const claudeExecutable = resolveClaudeExecutable(providerSettings.pathToClaudeCodeExecutable);
+  const claudeExecutablePreflight = claudeExecutable ? preflightClaudeExecutable(claudeExecutable, cwd) : void 0;
+  const accountScope = accountSessionScope(account);
+  const cursorBeforeSync = getSharedSession()?.cursor ?? null;
+  const syncResult = isReentrant ? { sessionId: null, promptStart: context.messages.length - 1 } : syncSharedSession(context.messages, cwd, customToolNameToSdk, queryModel.id, accountScope);
+  const { sessionId: resumeSessionId, promptStart } = syncResult;
+  const foreignContext = syncResult.foreignContext === true;
+  if (foreignContext) ctx().detachedFromSharedSession = true;
+  const conversationFp = isReentrant || foreignContext ? void 0 : conversationFingerprint(context.messages);
+  const promptMessages = context.messages.slice(promptStart);
+  const promptBlocks = extractUserPromptBlocks(promptMessages);
+  let promptText = extractUserPrompt(promptMessages) ?? "";
+  if (!promptText.trim() && !promptBlocks) {
     diagDump("empty_prompt", {
       contextLength: context.messages.length,
       lastMsgRole: lastMsg?.role,
       isReentrant,
       stackDepth: stackDepth(),
       activeQueryExists: ctx().activeQuery !== null,
-      sharedSession: sharedSession ? { sessionId: sharedSession.sessionId.slice(0, 8), cursor: sharedSession.cursor } : null,
+      cursorBeforeSync,
+      promptStart,
+      promptRoles: promptMessages.map((m) => m.role).join(" "),
+      sharedSession: (() => {
+        const activeSession = getSharedSession();
+        return activeSession ? { sessionId: activeSession.sessionId.slice(0, 8), cursor: activeSession.cursor } : null;
+      })(),
       messageRoles: context.messages.map((m, i) => `[${i}]${m.role}`).join(" ")
     });
     promptText = "[continue]";
   }
   const prompt = promptBlocks ? wrapPromptStream(promptBlocks) : promptText;
   const mcpServers = buildMcpServers(mcpTools, ctx());
-  const bridgeConfig = loadConfig(cwd);
-  const providerSettings = bridgeConfig.provider ?? {};
-  const enableCloudMcp = connectorsEnabledFor(bridgeConfig);
-  const connectorWriteMode = connectorWriteModeFor(bridgeConfig);
-  const connectorServers = enableCloudMcp ? connectorServersSnapshot() : {};
-  const appendSystemPrompt = providerSettings.appendSystemPrompt !== false;
-  const agentsAppend = appendSystemPrompt ? extractAgentsAppend() : void 0;
-  const skillsAppend = appendSystemPrompt ? extractSkillsBlock(context.systemPrompt) : void 0;
-  const promptContextAppend = buildPromptContextAppend(context.systemPrompt, cwd, bridgeConfig.promptContext ?? {});
-  const appendParts = [agentsAppend, skillsAppend, promptContextAppend.text].filter((part) => Boolean(part));
-  const systemPromptAppend = appendParts.length > 0 ? appendParts.join("\n\n") : void 0;
-  const settingSources = enableCloudMcp ? providerSettings.settingSources ?? ["user", "project", "local"] : appendSystemPrompt ? void 0 : providerSettings.settingSources ?? ["user", "project"];
-  const strictMcpConfigEnabled = !appendSystemPrompt && providerSettings.strictMcpConfig !== false;
-  const claudeExecutable = resolveClaudeExecutable(providerSettings.pathToClaudeCodeExecutable);
-  const claudeExecutablePreflight = claudeExecutable ? preflightClaudeExecutable(claudeExecutable, cwd) : void 0;
-  const { sessionId: resumeSessionId } = syncSharedSession(context.messages, cwd, customToolNameToSdk, model.id);
-  const requestedEffort = options?.reasoning ? model.thinkingLevelMap?.[options.reasoning] ?? REASONING_TO_EFFORT[options.reasoning] : void 0;
-  const effort = resolveConfiguredEffort(model.id, requestedEffort, providerSettings);
-  const extraArgs = {};
-  if (effort) extraArgs["thinking-display"] = "summarized";
-  const fallbackModel = fallbackModelForPrimaryModel(model.id);
-  const childEnv = { ...process.env, ENABLE_CLAUDEAI_MCP_SERVERS: enableCloudMcp ? "1" : "0", DISABLE_AUTO_COMPACT: "1" };
-  const queryOptions = {
+  const built = buildClaudeQueryOptions({
     cwd,
-    model: model.id,
-    env: childEnv,
-    ...connectorQueryOptions(enableCloudMcp, connectorWriteMode),
-    permissionMode: "bypassPermissions",
-    includePartialMessages: true,
-    ...fallbackModel ? { fallbackModel } : {},
-    ...providerSettings.fastMode ? { settings: { fastMode: true } } : {},
-    systemPrompt: {
-      type: "preset",
-      preset: "claude_code",
-      append: systemPromptAppend ? systemPromptAppend : void 0
-    },
-    extraArgs,
-    ...strictMcpConfigEnabled ? { strictMcpConfig: true } : {},
-    ...effort ? { effort } : {},
-    ...settingSources ? { settingSources } : {},
-    ...mcpServers || Object.keys(connectorServers).length > 0 ? { mcpServers: { ...mcpServers ?? {}, ...connectorServers } } : {},
-    ...resumeSessionId ? { resume: resumeSessionId } : {},
-    ...claudeExecutable ? { pathToClaudeCodeExecutable: claudeExecutable } : {},
-    spawnClaudeCodeProcess: spawnClaudeCodeWithDiagnostics,
-    ...makeCliDebugOptions("provider")
-  };
+    requestedModel: model,
+    queryModel,
+    account,
+    bridgeConfig,
+    systemPrompt: context.systemPrompt,
+    reasoning: options?.reasoning,
+    resumeSessionId,
+    mcpServers,
+    claudeExecutable
+  });
+  const { queryOptions } = built;
   debug(
     "provider: fresh query",
-    `model=${model.id} msgs=${context.messages.length} tools=${mcpTools.length}`,
-    `resume=${resumeSessionId?.slice(0, 8) ?? "none"} effort=${effort ?? "default"}`,
-    `fallback=${fallbackModel ?? "none"}`,
-    `appendSys=${appendSystemPrompt} promptCtx=${promptContextAppend.labels.join(",") || "none"} strictMcp=${strictMcpConfigEnabled} fastMode=${providerSettings.fastMode === true} connectors=${enableCloudMcp}`,
+    `model=${queryModel.id} requested=${model.id} msgs=${context.messages.length} tools=${mcpTools.length}`,
+    `resume=${resumeSessionId?.slice(0, 8) ?? "none"} effort=${built.effort ?? "default"} account=${account?.label ?? "legacy"}`,
+    `fallback=${built.fallbackModel ?? "none"}`,
+    `appendSys=${built.appendSystemPrompt} promptCtx=${built.promptContextLabels.join(",") || "none"} strictMcp=${built.strictMcpConfigEnabled} fastMode=${providerSettings.fastMode === true} connectors=${built.enableCloudMcp}`,
     `claudeExec=${claudeExecutablePreflight ? `${claudeExecutablePreflight.fileType}:${claudeExecutablePreflight.path}` : "sdk-default"}`,
     `prompt=${promptText.slice(0, 60)}${promptBlocks ? " [+images]" : ""}`
   );
   let wasAborted = false;
   let streamIdleTimedOut = false;
-  const sdkQuery = Okt({ prompt, options: queryOptions });
+  let retryRequested = false;
+  let retryFailure;
+  const sdkQuery = sdkQueryFactory({ prompt, options: queryOptions });
   ctx().activeQuery = sdkQuery;
   const abortCtx = ctx();
+  const attemptFailure = {};
+  const persistSession = (next) => {
+    if (isReentrant || foreignContext) return;
+    setSharedSession(next && conversationFp ? { conversationFingerprint: conversationFp, ...next } : next);
+  };
+  const markRebuildForThisQuery = (opts = {}) => {
+    if (isReentrant || foreignContext) return;
+    markSessionForRebuild(opts);
+  };
+  const dropDeferredUserMessages = (site, undelivered) => {
+    const dropped = [...undelivered !== void 0 ? [undelivered] : [], ...abortCtx.deferredUserMessages];
+    abortCtx.deferredUserMessages = [];
+    if (dropped.length > 0) {
+      diagDump("deferred_user_messages_dropped", summarizeDroppedUserMessages(site, dropped));
+    }
+    return dropped;
+  };
+  let accountFailureRecorded = false;
+  const recordAttemptFailure = (failure) => {
+    if (accountFailureRecorded || !account || !router || !failure.kind || failure.rateLimitInfo || wasAborted || options?.signal?.aborted) return;
+    safeRouterCall("recordFailure", () => router.recordFailure(account.profileId, failure.kind, queryModel.id));
+    accountFailureRecorded = true;
+  };
   const requestAbort = () => {
     void sdkQuery.interrupt().catch(() => {
     });
@@ -45589,6 +46887,28 @@ function streamClaudeAgentSdk(model, context, options) {
     } catch {
     }
   };
+  const requestRotation = (failure) => {
+    recordAttemptFailure(failure);
+    const committed = abortCtx.committedOutput || attemptBuffer?.hasCommittedOutput === true;
+    const eligible = Boolean(!isReentrant && account && router && failure.kind && !committed && !wasAborted && !options?.signal?.aborted && rotationState.attempts < MAX_ROTATION_ATTEMPTS);
+    debug("provider: account rotation decision", JSON.stringify({
+      eligible,
+      account: account?.label,
+      kind: failure.kind,
+      committedOutput: committed,
+      wasAborted,
+      signalAborted: options?.signal?.aborted === true,
+      attempts: rotationState.attempts
+    }));
+    if (!eligible || !account || !router || !failure.kind) return false;
+    rotationState.excludedProfileIds.add(account.profileId);
+    retryRequested = true;
+    retryFailure = failure;
+    attemptBuffer?.discard();
+    abortCtx.currentPiStream = null;
+    debug(`provider: rotating account after ${failure.kind}, from=${account.label}, attempt=${rotationState.attempts}`);
+    return true;
+  };
   const streamIdleTimeoutMs = streamIdleTimeoutMsFromEnv();
   const streamIdleWatchdog = streamIdleTimeoutMs > 0 ? createStreamIdleWatchdog({
     getState: () => ({
@@ -45601,15 +46921,20 @@ function streamClaudeAgentSdk(model, context, options) {
     onTimeout: ({ idleMs, timeoutMs }) => {
       if (streamIdleTimedOut || wasAborted || options?.signal?.aborted || abortCtx.activeQuery !== sdkQuery) return;
       streamIdleTimedOut = true;
-      abortCtx.deferredUserMessages = [];
-      abortCtx.handledTerminalError = true;
-      if (sharedSession) setSharedSession({ ...sharedSession, needsRebuild: true, forceRotate: true });
+      dropDeferredUserMessages("stream-idle-timeout");
+      markRebuildForThisQuery({ forceRotate: true });
       const errorMessage = buildStreamIdleTimeoutErrorMessage(timeoutMs);
-      debug("provider: stream idle timeout", `model=${model.id}`, `timeout=${timeoutMs}`, `idle=${idleMs}`);
+      debug("provider: stream idle timeout", `model=${queryModel.id}`, `timeout=${timeoutMs}`, `idle=${idleMs}`);
+      const idleFailure = { kind: "network", message: errorMessage };
+      if (requestRotation(idleFailure)) {
+        requestAbort();
+        return;
+      }
+      abortCtx.handledTerminalError = true;
       emitRateLimitEvent({
         idleMs,
-        model: model.id,
-        provider: PROVIDER_ID,
+        model: queryModel.id,
+        provider: queryModel.provider,
         rateLimitType: "stream_idle",
         reason: "Claude Code stream idle timeout",
         retryAfterMs: STREAM_IDLE_BACKOFF_HINT_MS,
@@ -45617,7 +46942,7 @@ function streamClaudeAgentSdk(model, context, options) {
         status: "rejected",
         timeoutMs
       });
-      piUI?.notify(`${RATE_LIMIT_TOKEN} Claude stream idle timeout after ${formatDurationShort(timeoutMs)} \u2014 retrying via rate-limit backoff`, "warning");
+      safeNotify(`${RATE_LIMIT_TOKEN} Claude stream idle timeout after ${formatDurationShort(timeoutMs)} \u2014 retrying via rate-limit backoff`, "warning");
       if (abortCtx.turnOutput) {
         abortCtx.turnOutput.stopReason = "error";
         abortCtx.turnOutput.errorMessage = errorMessage;
@@ -45638,68 +46963,126 @@ function streamClaudeAgentSdk(model, context, options) {
     activeStreamIdleWatchdogs.set(abortCtx, streamIdleWatchdog);
     streamIdleWatchdog.refresh();
   }
-  const onAbort = () => {
+  const onAbort = () => runInRequestLane(laneId, () => {
     wasAborted = true;
-    abortCtx.deferredUserMessages = [];
-    reportToolResultMismatch(abortCtx, "abort", cwd, { forceRotate: true });
+    dropDeferredUserMessages("abort");
+    reportToolResultMismatch(abortCtx, "abort", cwd, {
+      expectedInterruption: true,
+      forceRotate: true
+    });
     const drained = drainPendingToolCalls(abortCtx, "abort");
     if (drained > 0) debug(`provider: abort drained ${drained} waiting MCP handler(s) as errors`);
     abortCtx.pendingResults.clear();
     requestAbort();
-  };
+  });
   if (options?.signal) {
     if (options.signal.aborted) onAbort();
     else options.signal.addEventListener("abort", onAbort, { once: true });
   }
-  consumeQuery(sdkQuery, customToolNameToPi, model, cwd, bridgeConfig, () => wasAborted).then(async ({ capturedSessionId }) => {
-    debug(`provider: consumeQuery completed, stopReason=${abortCtx.turnOutput?.stopReason}, error=${abortCtx.turnOutput?.errorMessage}, aborted=${wasAborted}`);
+  const surfaceFailure = (failure, aborted2 = false) => {
+    attemptBuffer?.commit();
+    if (failure.rateLimitInfo) {
+      const info = failure.rateLimitInfo;
+      const resetAt = rateLimitResetFromInfo(info);
+      const resetAtMs = rateLimitResetMs(info);
+      emitRateLimitEvent({
+        model: queryModel.id,
+        provider: queryModel.provider,
+        rateLimitType: rateLimitTypeFromInfo(info),
+        reason: failure.message,
+        resetAt,
+        ...Number.isFinite(resetAtMs) ? { resetAtMs } : {},
+        source: "claude-bridge",
+        status: "rejected"
+      });
+      safeNotify(`${RATE_LIMIT_TOKEN} Claude ${failure.message} \u2014 resets ${formatResetTimestamp(resetAtMs ?? resetAt)}`, "warning");
+    }
+    if (abortCtx.turnOutput) {
+      abortCtx.turnOutput.stopReason = aborted2 ? "aborted" : "error";
+      abortCtx.turnOutput.errorMessage = failure.message;
+    }
+    abortCtx.currentPiStream?.push({ type: "error", reason: aborted2 ? "aborted" : "error", error: abortCtx.turnOutput });
+    abortCtx.currentPiStream?.end();
+    abortCtx.currentPiStream = null;
+  };
+  consumeQuery(sdkQuery, abortCtx, customToolNameToPi, queryModel, bridgeConfig, () => wasAborted, account, router, attemptFailure).then(async ({ capturedSessionId, failure }) => {
+    debug(`provider: consumeQuery completed, stopReason=${abortCtx.turnOutput?.stopReason}, failure=${failure?.kind ?? "none"}, aborted=${wasAborted}`);
     if (streamIdleTimedOut) {
-      abortCtx.deferredUserMessages = [];
-      debug("provider: stream idle timeout already surfaced; skipping normal completion");
+      dropDeferredUserMessages("stream-idle-timeout-completion");
+      debug(`provider: stream idle timeout ${retryRequested ? "queued account rotation" : "already surfaced"}; skipping normal completion`);
       return;
     }
     if (wasAborted || options?.signal?.aborted) {
-      if (sharedSession) setSharedSession({ ...sharedSession, needsRebuild: true, forceRotate: true });
-      abortCtx.deferredUserMessages = [];
+      markRebuildForThisQuery({ forceRotate: true });
+      dropDeferredUserMessages("abort-completion");
       debug(`provider: abort detected, marked sharedSession needsRebuild + forceRotate`);
-      if (abortCtx.turnOutput) {
-        abortCtx.turnOutput.stopReason = "aborted";
-        abortCtx.turnOutput.errorMessage = "Operation aborted";
+      surfaceFailure({ message: "Operation aborted" }, true);
+      return;
+    }
+    if (failure) {
+      if (requestRotation(failure)) return;
+      if (!abortCtx.handledTerminalError) surfaceFailure(failure);
+      const droppedSteers = dropDeferredUserMessages("terminal-failure");
+      const activeSession2 = getSharedSession();
+      const failedSessionId = capturedSessionId ?? activeSession2?.sessionId;
+      if (failedSessionId) {
+        const cursor = Math.max(context.messages.length, abortCtx.latestCursor, activeSession2?.cursor ?? 0);
+        debug(`provider: terminal failure, persisting session=${failedSessionId.slice(0, 8)}, cursor=${cursor}, account=${account?.label ?? "legacy"}, droppedSteers=${droppedSteers.length}`);
+        persistSession({ sessionId: failedSessionId, cursor, cwd, ...accountScope, ...droppedSteers.length > 0 ? { needsRebuild: true } : {} });
       }
-      abortCtx.currentPiStream?.push({ type: "error", reason: "aborted", error: abortCtx.turnOutput });
-      abortCtx.currentPiStream?.end();
-      abortCtx.currentPiStream = null;
       return;
     }
-    const sessionId = capturedSessionId ?? sharedSession?.sessionId;
+    const activeSession = getSharedSession();
+    const sessionId = capturedSessionId ?? activeSession?.sessionId;
     if (sessionId) {
-      const cursor = Math.max(context.messages.length, abortCtx.latestCursor, sharedSession?.cursor ?? 0);
-      debug(`provider: query done, session=${sessionId.slice(0, 8)}, cursor=${cursor}`);
-      setSharedSession({ sessionId, cursor, cwd });
+      const cursor = Math.max(context.messages.length, abortCtx.latestCursor, activeSession?.cursor ?? 0);
+      debug(`provider: query done, session=${sessionId.slice(0, 8)}, cursor=${cursor}, account=${account?.label ?? "legacy"}`);
+      persistSession({ sessionId, cursor, cwd, ...accountScope });
     }
+    if (account && router) safeRouterCall("recordSuccess", () => router.recordSuccess(account.profileId, options?.sessionId));
     try {
       while (abortCtx.deferredUserMessages.length > 0 && !isReentrant && !wasAborted) {
-        const steerPrompt = abortCtx.deferredUserMessages.shift();
-        debug(`provider: replaying deferred user message: ${steerPrompt.slice(0, 60)}`);
-        abortCtx.resetTurnState(model);
+        const steer = abortCtx.deferredUserMessages.shift();
+        const steerPreview = (steer.text || "[image-only]").slice(0, 60);
+        debug(`provider: replaying deferred user message: ${steerPreview}`);
+        abortCtx.resetTurnState(queryModel);
         abortCtx.resetToolTracking();
-        const resumeId = sharedSession?.sessionId;
+        const resumeId = foreignContext ? capturedSessionId : getSharedSession()?.sessionId;
         if (!resumeId) {
           debug(`WARNING: no session to resume for deferred message, dropping`);
+          dropDeferredUserMessages("continuation-no-resume-id", steer);
           break;
         }
         const contOptions = { ...queryOptions, resume: resumeId, ...makeCliDebugOptions("continuation") };
-        const contQuery = Okt({ prompt: steerPrompt, options: contOptions });
+        const contQuery = sdkQueryFactory({ prompt: steer.blocks ? wrapPromptStream(steer.blocks) : steer.text, options: contOptions });
         abortCtx.activeQuery = contQuery;
-        debug(`provider: continuation query, model=${model.id}, resume=${resumeId.slice(0, 8)}, prompt=${steerPrompt.slice(0, 60)}`);
+        debug(`provider: continuation query, model=${queryModel.id}, resume=${resumeId.slice(0, 8)}, account=${account?.label ?? "legacy"}, prompt=${steerPreview}`);
         try {
-          const { capturedSessionId: contSid } = await consumeQuery(contQuery, customToolNameToPi, model, cwd, bridgeConfig, () => wasAborted);
-          const sid = contSid ?? sharedSession?.sessionId;
+          const continuation = await consumeQuery(contQuery, abortCtx, customToolNameToPi, queryModel, bridgeConfig, () => wasAborted, account, router);
+          if (continuation.failure) {
+            recordAttemptFailure(continuation.failure);
+            if (!abortCtx.handledTerminalError) surfaceFailure(continuation.failure);
+            if (dropDeferredUserMessages("continuation-failure", steer).length > 0) {
+              markRebuildForThisQuery();
+            }
+            break;
+          }
+          const activeSession2 = getSharedSession();
+          const sid = continuation.capturedSessionId ?? activeSession2?.sessionId;
           if (sid) {
-            setSharedSession({ sessionId: sid, cursor: sharedSession?.cursor ?? 0, cwd });
+            persistSession({ sessionId: sid, cursor: activeSession2?.cursor ?? 0, cwd, ...accountScope });
           }
         } catch (contError) {
           debug(`provider: continuation query error:`, contError);
+          const continuationFailure = {
+            kind: classifyClaudeFailure(contError),
+            message: contError instanceof Error ? contError.message : String(contError)
+          };
+          recordAttemptFailure(continuationFailure);
+          if (!abortCtx.handledTerminalError) surfaceFailure(continuationFailure);
+          if (dropDeferredUserMessages("continuation-error", steer).length > 0) {
+            markRebuildForThisQuery();
+          }
           break;
         } finally {
           contQuery.close();
@@ -45710,26 +47093,25 @@ function streamClaudeAgentSdk(model, context, options) {
     }
     finalizeCurrentStream(abortCtx.turnOutput?.stopReason, abortCtx);
   }).catch((error51) => {
-    debug(`provider: query error, model=${model.id}, aborted=${Boolean(options?.signal?.aborted)}, error=`, error51);
-    const suppressDuplicateError = abortCtx.handledTerminalError || streamIdleTimedOut;
-    const openedExtraUsage = !suppressDuplicateError && isExtraUsageRequiredMessage(error51) && launchExtraUsageHelperIfAllowed(cwd, bridgeConfig, "query error");
-    if ((wasAborted || options?.signal?.aborted) && sharedSession) {
-      setSharedSession({ ...sharedSession, needsRebuild: true, forceRotate: true });
-    } else {
-      setSharedSession(null);
+    debug(`provider: query error, model=${queryModel.id}, aborted=${Boolean(options?.signal?.aborted)}, error=`, error51);
+    const suppressDuplicateError = abortCtx.handledTerminalError || streamIdleTimedOut && !retryRequested;
+    if (wasAborted || options?.signal?.aborted) {
+      markRebuildForThisQuery({ forceRotate: true });
     }
-    abortCtx.deferredUserMessages = [];
-    if (suppressDuplicateError) {
-      debug("provider: suppressing duplicate query error after terminal error was already emitted");
-      return;
+    if (dropDeferredUserMessages("query-error").length > 0) {
+      markRebuildForThisQuery();
     }
-    if (abortCtx.turnOutput) {
-      abortCtx.turnOutput.stopReason = options?.signal?.aborted ? "aborted" : "error";
-      abortCtx.turnOutput.errorMessage = `${error51 instanceof Error ? error51.message : String(error51)}${openedExtraUsage ? "\n\nOpened Claude Code /extra-usage helper. Complete billing/admin flow in the browser, then retry the prompt." : ""}`;
+    if (suppressDuplicateError || retryRequested) {
+      debug("provider: suppressing duplicate query error after terminal handling");
+      return;
     }
-    abortCtx.currentPiStream?.push({ type: "error", reason: abortCtx.turnOutput?.stopReason ?? "error", error: abortCtx.turnOutput });
-    abortCtx.currentPiStream?.end();
-    abortCtx.currentPiStream = null;
+    const failure = attemptFailure.failure?.rateLimitInfo ? attemptFailure.failure : {
+      kind: classifyClaudeFailure(error51),
+      message: error51 instanceof Error ? error51.message : String(error51)
+    };
+    if (requestRotation(failure)) return;
+    if (!wasAborted && !options?.signal?.aborted) persistSession(null);
+    surfaceFailure(failure, Boolean(options?.signal?.aborted));
   }).finally(() => {
     streamIdleWatchdog?.dispose();
     activeStreamIdleWatchdogs.delete(abortCtx);
@@ -45737,164 +47119,58 @@ function streamClaudeAgentSdk(model, context, options) {
     const cause = toolCallDrainCause({ wasAborted, signalAborted: options?.signal?.aborted, streamIdleTimedOut });
     teardownQuery(abortCtx, sdkQuery, cause, cwd, isReentrant);
     sdkQuery.close();
-  });
-  return stream;
-}
-function commandCwd(ctx2) {
-  const value = ctx2?.cwd;
-  return typeof value === "string" && value.length > 0 ? value : process.cwd();
-}
-async function tryOpenExtensionManagerSettings(ctx2) {
-  const host = globalThis;
-  const openQuickSettings = host[/* @__PURE__ */ Symbol.for("vstack.pi.extension-manager.open-quick-settings")];
-  if (typeof openQuickSettings !== "function") return false;
-  try {
-    await openQuickSettings(ctx2, "@vanillagreen/pi-claude-bridge");
-    return true;
-  } catch {
-    return false;
-  }
-}
-function showBridgeStatus(ctx2) {
-  const config2 = loadConfig(commandCwd(ctx2));
-  ctx2.ui.notify([
-    `Claude bridge: ${config2.enabled === false ? "disabled" : "enabled"}`,
-    `Extra usage auto-helper: ${extraUsageAllowed(config2) ? "on" : "off"} (settings)`,
-    `Use /claude-bridge:extra to run Claude Code /extra-usage now.`
-  ].join("\n"), "info");
-}
-function readCredentialFile(path) {
-  try {
-    return nodeReadFileSync(path, "utf8");
-  } catch {
-    return void 0;
-  }
-}
-var connectorServerCache = /* @__PURE__ */ new Map();
-var connectorServerPending = /* @__PURE__ */ new Set();
-function connectorScopeKey() {
-  return process.env.CLAUDE_CONFIG_DIR?.trim() || "<default>";
-}
-function primeConnectorServers() {
-  const key = connectorScopeKey();
-  if (connectorServerCache.has(key) || connectorServerPending.has(key)) return;
-  connectorServerPending.add(key);
-  void (async () => {
-    try {
-      const credentials = resolveClaudeOAuth(readCredentialFile);
-      if (!credentials) {
-        debug("connectors: no OAuth credentials; declaring none");
-        connectorServerCache.set(key, {});
-        return;
-      }
-      const inventory = await listAccountConnectors({ credentials });
-      if (!inventory.ok) {
-        debug(`connectors: inventory failed (${inventory.reason}); declaring none`);
-        connectorServerCache.set(key, {});
-        return;
-      }
-      const servers = connectorMcpServers(inventory);
-      debug(
-        `connectors: declaring ${Object.keys(servers).length} of ${inventory.connectors.length} installed`,
-        Object.keys(servers).join(", ") || "none"
-      );
-      connectorServerCache.set(key, servers);
-      if (writeCachedConnectors(inventory.connectors, key)) {
-        debug(`connectors: cached ${inventory.connectors.length} entries`);
+  }).then(async () => {
+    if (!retryRequested) return;
+    if (wasAborted || options?.signal?.aborted) {
+      debug("provider: abort after queued account retry \u2014 terminating stream without retrying");
+      if (abortCtx.turnOutput) {
+        abortCtx.turnOutput.stopReason = "aborted";
+        abortCtx.turnOutput.errorMessage = "Operation aborted";
       }
-    } catch (error51) {
-      debug("connectors: declaration lookup threw; declaring none", error51);
-      connectorServerCache.set(key, {});
-    } finally {
-      connectorServerPending.delete(key);
-    }
-  })();
-}
-function connectorServersSnapshot() {
-  const key = connectorScopeKey();
-  const ready = connectorServerCache.get(key);
-  if (ready) return ready;
-  primeConnectorServers();
-  const cached2 = readCachedConnectors(key);
-  if (!cached2) return {};
-  const servers = connectorMcpServers({ ok: true, complete: true, connectors: cached2 });
-  if (Object.keys(servers).length === 0) return {};
-  debug(`connectors: turn-1 declarations from cache \u2014 ${Object.keys(servers).join(", ")}`);
-  return servers;
-}
-async function reportConnectorInventory(ctx2) {
-  const credentials = resolveClaudeOAuth(readCredentialFile);
-  if (!credentials) {
-    ctx2.ui.notify("Claude bridge: no Claude OAuth credentials found \u2014 cannot enumerate connectors.", "error");
-    return;
-  }
-  const inventory = await listAccountConnectors({ credentials });
-  if (!inventory.ok) {
-    ctx2.ui.notify(`Claude bridge: connector enumeration failed \u2014 ${inventory.reason}`, "error");
-    return;
-  }
-  if (inventory.connectors.length === 0) {
-    ctx2.ui.notify("Claude bridge: this account has no connectors installed.", "info");
-    return;
-  }
-  const names = inventory.connectors.map((c) => c.name).join(", ");
-  ctx2.ui.notify(`Claude bridge: ${inventory.connectors.length} connector(s) installed \u2014 ${names}`, "info");
-}
-function registerBridgeCommands(pi) {
-  const guard = pi;
-  if (guard[COMMANDS_REGISTERED_KEY]) return;
-  guard[COMMANDS_REGISTERED_KEY] = true;
-  const runExtraUsage = async (ctx2) => {
-    const cwd = commandCwd(ctx2);
-    if (extraUsageHelperInFlight) {
-      ctx2.ui.notify("Claude extra usage helper already running.", "info");
-      await extraUsageHelperInFlight.catch(() => void 0);
+      stream.push({ type: "error", reason: "aborted", error: abortCtx.turnOutput });
+      stream.end();
       return;
     }
-    try {
-      ctx2.ui.notify("Claude extra usage helper starting\u2026", "info");
-      extraUsageHelperInFlight = runExtraUsageHelper(cwd).finally(() => {
-        extraUsageHelperInFlight = null;
-      });
-      const message = await extraUsageHelperInFlight;
-      ctx2.ui.notify(`Claude extra usage helper: ${message}`, "info");
-    } catch (error51) {
-      const message = error51 instanceof Error ? error51.message : String(error51);
-      ctx2.ui.notify(`Claude extra usage helper failed: ${message}`, "error");
-    }
-  };
-  pi.registerCommand("claude-bridge", {
-    description: "Open Claude bridge settings/status",
-    handler: async (args, ctx2) => {
-      if (args.trim()) ctx2.ui.notify("Unknown /claude-bridge argument. Use /claude-bridge:extra to run Claude Code /extra-usage.", "warning");
-      if (await tryOpenExtensionManagerSettings(ctx2)) return;
-      showBridgeStatus(ctx2);
+    debug(`provider: starting account retry after ${retryFailure?.kind ?? "failure"}; excluded=${[...rotationState.excludedProfileIds].join(",")}`);
+    const retryStream = streamClaudeAgentSdk(model, context, {
+      ...options ?? {},
+      [ROTATION_STATE_KEY]: rotationState
+    });
+    for await (const event of retryStream) stream.push(event);
+    stream.end();
+  }).catch((error51) => {
+    debug("provider: account retry pipeline failed:", error51);
+    if (abortCtx.turnOutput) {
+      abortCtx.turnOutput.stopReason = "error";
+      abortCtx.turnOutput.errorMessage = error51 instanceof Error ? error51.message : String(error51);
     }
-  });
-  pi.registerCommand("claude-bridge:extra", {
-    description: "Run Claude Code /extra-usage through claude-bridge",
-    handler: async (_args, ctx2) => runExtraUsage(ctx2)
-  });
-  pi.registerCommand("claude-bridge:connectors", {
-    description: "List the Claude account's installed claude.ai connectors",
-    handler: async (_args, ctx2) => reportConnectorInventory(ctx2)
-  });
+    stream.push({ type: "error", reason: "error", error: abortCtx.turnOutput });
+    stream.end();
+  }).finally(releaseEphemeralLane);
+  return stream;
 }
 function index_default(pi) {
   setExtensionApi(pi);
   process.env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = "1";
   const config2 = loadConfig(process.cwd());
   debug("loadConfig:", JSON.stringify(config2));
+  registerExternalConfigResolver();
   registerBridgeCommands(pi);
   if (config2.enabled === false) {
     debug("provider: disabled by configuration");
     return;
   }
+  if (claimPrimaryInstance()) {
+    const host = globalThis;
+    host[CLAUDE_BRIDGE_ACCOUNT_HOST_SYMBOL] = BRIDGE_ACCOUNT_HOST;
+  }
   const clearSession = (event) => {
-    debug(`${event}: clearing session ${sharedSession?.sessionId?.slice(0, 8) ?? "none"}`);
+    const activeSession = getSharedSession();
+    debug(`${event}: clearing session ${activeSession?.sessionId?.slice(0, 8) ?? "none"}`);
     setSharedSession(null);
   };
-  pi.on("session_start", (event, ctx2) => {
+  pi.on("session_start", (event, ctx2) => runInRequestLane(ctx2.sessionManager.getSessionId(), () => {
+    recordStartedLane(ctx2.sessionManager, ctx2.sessionManager.getSessionId());
     recordProjectTrust(ctx2);
     setPiUI(ctx2.ui);
     if (event.reason === "new" || event.reason === "resume" || event.reason === "fork") {
@@ -45902,31 +47178,40 @@ function index_default(pi) {
     }
     if (event.reason === "startup" || event.reason === "resume") restoreSharedSessionFromPi(ctx2);
     applyProviderRegistration(`session_start:${event.reason}`);
+  }));
+  pi.on("session_shutdown", (_event, ctx2) => {
+    const sessionId = takeStartedLane(ctx2.sessionManager) ?? ctx2.sessionManager.getSessionId();
+    runInRequestLane(sessionId, () => {
+      cancelScheduledSessionPersistence(ctx2.sessionManager);
+      clearSession("session_shutdown");
+      releaseProviderTokens("session_shutdown");
+    });
+    deleteSharedSessionLane(sessionId);
+    deleteQueryLane(sessionId);
   });
-  pi.on("session_shutdown", () => {
-    clearSession("session_shutdown");
-    releaseProviderTokens("session_shutdown");
-  });
-  pi.on("message_end", (event, ctx2) => {
+  pi.on("message_end", (event, ctx2) => runInRequestLane(ctx2.sessionManager.getSessionId(), () => {
     const message = event.message;
     if (message?.role === "assistant" && message.provider === PROVIDER_ID) schedulePersistSharedSession(ctx2);
-  });
+  }));
   const markRebuild = (event) => {
+    const activeSession = getSharedSession();
     if (ctx().activeQuery) {
-      reportToolResultMismatch(ctx(), event, sharedSession?.cwd ?? process.cwd());
+      reportToolResultMismatch(ctx(), event, activeSession?.cwd ?? process.cwd());
     }
-    if (sharedSession) {
-      debug(`${event}: marking needsRebuild on session ${sharedSession.sessionId.slice(0, 8)}`);
-      setSharedSession({ ...sharedSession, needsRebuild: true });
+    if (activeSession) {
+      debug(`${event}: marking needsRebuild on session ${activeSession.sessionId.slice(0, 8)}`);
+      markSessionForRebuild();
     }
   };
-  pi.on("session_compact", () => markRebuild("session_compact"));
-  pi.on("session_tree", () => markRebuild("session_tree"));
+  pi.on("session_compact", (_event, ctx2) => runInRequestLane(ctx2.sessionManager.getSessionId(), () => markRebuild("session_compact")));
+  pi.on("session_tree", (_event, ctx2) => runInRequestLane(ctx2.sessionManager.getSessionId(), () => markRebuild("session_tree")));
   applyProviderRegistration("load");
 }
 export {
   ALLOWED_RATE_LIMIT_WARNING_UTILIZATION_THRESHOLD,
+  CLAUDE_ACCOUNT_ROUTER_SYMBOL,
   CLAUDE_AI_CONNECTOR_TOOL_PATTERNS,
+  CLAUDE_BRIDGE_ACCOUNT_HOST_SYMBOL,
   CLAUDE_BRIDGE_TOOL_ISOLATION,
   CONNECTOR_CALL_CUSTOM_TYPE,
   CONNECTOR_DISCOVERY_TOOLS,
@@ -45935,16 +47220,24 @@ export {
   DISALLOWED_BUILTIN_TOOLS,
   INTEGRITY_CUSTOM_TYPE,
   NATIVE_PROVIDER_UNSUPPORTED_MESSAGE,
+  RetryEventBuffer,
   STREAM_IDLE_BACKOFF_HINT_MS,
   STREAM_IDLE_TIMEOUT_ENV,
   __testGetBridgeIntegrityState,
   __testSetBridgeIntegrityState,
+  __testSetSdkQueryFactory,
+  accountSessionScope,
   appendIntegrityEntry,
   buildNativeProvider,
   buildStreamIdleTimeoutErrorMessage,
+  cancelScheduledSessionPersistence,
   cancelScheduledToolUseEnd,
   classifyClaudeExecutableBytes,
+  classifyClaudeFailure,
   claudeAuthSourceLabel,
+  claudeDirForProfile,
+  commitsVisibleOutput,
+  connectorBuiltinAllowlistHook,
   connectorCachePath,
   connectorCacheScopeKey,
   connectorDeclarationsDisabled,
@@ -45954,32 +47247,44 @@ export {
   connectorResultByteSize,
   connectorServerName,
   connectorServerNamespace,
+  connectorServersSnapshot,
   connectorWriteDenyHook,
   connectorWriteModeFor,
   connectorWriteModeFromEnv,
   connectorsEnabledFor,
   connectorsEnabledFromEnv,
   connectorsListUrl,
+  conversationFingerprint,
+  conversationFingerprintsMatch,
   createStreamIdleWatchdog,
   credentialCandidatePaths,
   index_default as default,
+  denyAllToolsHook,
   endToolUseTurn,
   finalizeToolUseTurnFromMcpInvocation,
   flushConnectorCallAudit,
   formatAllowedRateLimitWarning,
   formatResetTimestamp,
+  isAllowlistedConnectorSessionTool,
   isChildExecutedTool,
+  isChildInternalTool,
+  isConnectorTool,
   isConnectorWriteTool,
-  isExtraUsageRequiredMessage,
   isUsageLimitMessage,
   listAccountConnectors,
   mapToolName,
   normalizeRateLimitUtilization,
   noteChildExecutedToolResults,
+  planDeferredUserReplay,
+  planIncrementalPromptBatch,
   preflightClaudeExecutable,
   primeConnectorServers,
+  probeClaudeAccountProfile,
   processAssistantMessage,
   processStreamEvent,
+  rateLimitResetFromInfo,
+  rateLimitResetMs,
+  rateLimitTypeFromInfo,
   readCachedConnectors,
   reapStaleQueuedResults,
   recordConnectorCallResult,
@@ -45991,10 +47296,14 @@ export {
   resolveMcpTools,
   restoreSharedSessionFromPi,
   scheduleToolUseTurnEnd,
+  scopeKeyFor,
   setConnectorCallAuditSink,
+  settingSourcesForQuery,
   shouldRestorePersistedBridgeEntry,
   spawnClaudeCodeWithDiagnostics,
+  streamClaudeAgentSdk,
   streamIdleTimeoutMsFromEnv,
+  subscriberProfileEnv,
   supportsNativeProvider,
   toolIsolationForQuery,
   uniqueNonEmptyLines,