@agentrific/server 0.6.0 → 0.7.1

package/claude-bridge.js

@@ -0,0 +1,2682 @@
+// ../../node_modules/pi-claude-agent-sdk/src/index.ts
+import { createAssistantMessageEventStream } from "@earendil-works/pi-ai";
+
+import { getModels } from "@earendil-works/pi-ai/compat";
+
+import { query } from "@anthropic-ai/claude-agent-sdk";
+
+import { createSession, deleteSession, openSession, repairToolPairing } from "cc-session-io";
+
+import { appendFileSync, mkdirSync as mkdirSync2, realpathSync, statSync as statSync2 } from "fs";
+
+import { dirname as dirname3, join as join4 } from "path";
+
+
+// ../../node_modules/pi-claude-agent-sdk/src/convert.ts
+import { pascalCase } from "change-case";
+
+import { createHash } from "node:crypto";
+
+
+// ../../node_modules/pi-claude-agent-sdk/src/skills.ts
+import { formatSkillsForPrompt } from "@earendil-works/pi-coding-agent";
+
+
+// ../../node_modules/pi-claude-agent-sdk/src/log-paths.ts
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+
+import { join } from "path";
+
+
+// ../../node_modules/pi-claude-agent-sdk/src/session-verify.ts
+import { statSync, readFileSync } from "fs";
+
+
+// ../../node_modules/pi-claude-agent-sdk/src/config.ts
+import { CONFIG_DIR_NAME, getAgentDir as getAgentDir2 } from "@earendil-works/pi-coding-agent";
+
+import { existsSync, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+
+import { dirname, join as join2 } from "path";
+
+
+// ../../node_modules/pi-claude-agent-sdk/src/mcp-server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+
+
+// ../../node_modules/pi-claude-agent-sdk/src/claude-executable.ts
+import { spawnSync } from "node:child_process";
+
+import { accessSync, constants, readFileSync as readFileSync3 } from "node:fs";
+
+import { createRequire } from "node:module";
+
+import { delimiter, dirname as dirname2, join as join3 } from "node:path";
+
+
+// ../../node_modules/pi-claude-agent-sdk/src/transcript.ts
+import {
+  contentText,
+  getCurrentSystemMessage,
+  getCurrentTools
+} from "@earendil-works/pi-ai";
+
+
+// ../../node_modules/pi-claude-agent-sdk/src/usage.ts
+import { calculateCost } from "@earendil-works/pi-ai";
+export function createClaudeExtension(queryImplementation) {
+const bridgeGlobals = {};
+
+var MCP_SERVER_NAME = "custom-tools";
+
+var MCP_TOOL_PREFIX = `mcp__${MCP_SERVER_NAME}__`;
+
+function renderSkillsBlock(skills, readTool) {
+  if (readTool === "none" || skills.length === 0) return void 0;
+  const block = formatSkillsForPrompt(skills).trim();
+  if (!block) return void 0;
+  return readTool === "mcp" ? rewriteSkillsBlock(block) : block;
+}
+
+function rewriteSkillsBlock(skillsBlock) {
+  return skillsBlock.replace(
+    "Use the read tool to load a skill's file",
+    `Use the read tool (mcp__${MCP_SERVER_NAME}__read) to load a skill's file`
+  );
+}
+
+
+// ../../node_modules/pi-claude-agent-sdk/src/convert.ts
+var PROVIDER_ID = "claude-bridge";
+
+var PI_TO_SDK_TOOL_NAME = {
+  read: "Read",
+  write: "Write",
+  edit: "Edit",
+  bash: "Bash"
+};
+
+var MAX_ANTHROPIC_TOOL_ID_LENGTH = 64;
+
+function sanitizeToolId(id, cache) {
+  const existing = cache.get(id);
+  if (existing) return existing;
+  const sanitized = id.replace(/[^a-zA-Z0-9_-]/g, "_") || "tool";
+  let clean = sanitized.slice(0, MAX_ANTHROPIC_TOOL_ID_LENGTH);
+  const occupied = new Set(cache.values());
+  if (occupied.has(clean)) {
+    const suffix = `_${createHash("sha256").update(id).digest("hex").slice(0, 12)}`;
+    clean = `${sanitized.slice(0, MAX_ANTHROPIC_TOOL_ID_LENGTH - suffix.length)}${suffix}`;
+    let attempt = 2;
+    while (occupied.has(clean)) {
+      const numberedSuffix = `${suffix}_${attempt++}`;
+      clean = `${sanitized.slice(0, MAX_ANTHROPIC_TOOL_ID_LENGTH - numberedSuffix.length)}${numberedSuffix}`;
+    }
+  }
+  cache.set(id, clean);
+  return clean;
+}
+
+function mapPiToolNameToSdk(name, customToolNameToSdk) {
+  if (!name) return "";
+  const normalized = name.toLowerCase();
+  if (normalized.startsWith(MCP_TOOL_PREFIX)) {
+    throw new Error(`mapPiToolNameToSdk: "${name}" is already an SDK tool name \u2014 pi history holds pi tool names`);
+  }
+  if (!customToolNameToSdk) return PI_TO_SDK_TOOL_NAME[normalized] ?? pascalCase(name);
+  return customToolNameToSdk.get(name) ?? customToolNameToSdk.get(normalized) ?? `${MCP_TOOL_PREFIX}${name}`;
+}
+
+function messageContentToText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  let hasText = false;
+  for (const block of content) {
+    if (block.type === "text" && block.text) {
+      parts.push(block.text);
+      hasText = true;
+    } else if (block.type !== "text" && block.type !== "image") {
+      parts.push(`[${block.type}]`);
+    }
+  }
+  return hasText ? parts.join("\n") : "";
+}
+
+function toolResultContent(content) {
+  if (typeof content === "string" || !Array.isArray(content)) return messageContentToText(content) || "";
+  const images = content.filter((b) => b.type === "image" && b.data && b.mimeType);
+  if (!images.length) return messageContentToText(content) || "";
+  const blocks = [];
+  for (const block of content) {
+    if (block.type === "text" && block.text) blocks.push({ type: "text", text: block.text });
+    else if (block.type === "image" && block.data && block.mimeType) {
+      blocks.push({ type: "image", source: { type: "base64", media_type: block.mimeType, data: block.data } });
+    } else if (block.type !== "text" && block.type !== "image") {
+      blocks.push({ type: "text", text: `[${block.type}]` });
+    }
+  }
+  return blocks;
+}
+
+function convertPiMessages(messages, customToolNameToSdk, dropThinking = false) {
+  const anthropicMessages = [];
+  const sanitizedIds = /* @__PURE__ */ new Map();
+  const dropped = { thinking: 0, abortedTurns: 0, providers: /* @__PURE__ */ new Set(), other: /* @__PURE__ */ new Map() };
+  let turnResults = null;
+  let turnAssistantIdx = null;
+  for (const msg of messages) {
+    if (msg.role === "user") {
+      if (typeof msg.content === "string") {
+        anthropicMessages.push({ role: "user", content: msg.content || "[empty]" });
+      } else if (Array.isArray(msg.content)) {
+        const parts = [];
+        for (const block of msg.content) {
+          if (block.type === "text" && block.text) parts.push({ type: "text", text: block.text });
+          else if (block.type === "image" && block.data && block.mimeType) {
+            parts.push({ type: "image", source: { type: "base64", media_type: block.mimeType, data: block.data } });
+          }
+        }
+        anthropicMessages.push({ role: "user", content: parts.length ? parts : "[image]" });
+      } else {
+        anthropicMessages.push({ role: "user", content: "[empty]" });
+      }
+    } else if (msg.role === "assistant") {
+      const content = Array.isArray(msg.content) ? msg.content : [];
+      const blocks = [];
+      for (const block of content) {
+        if (block.type === "text" && block.text) {
+          blocks.push({ type: "text", text: block.text });
+        } else if (block.type === "thinking") {
+          const sig = block.thinkingSignature;
+          if (!dropThinking && msg.provider === PROVIDER_ID && sig) {
+            blocks.push({ type: "thinking", thinking: block.thinking ?? "", signature: sig });
+          } else {
+            dropped.thinking++;
+            dropped.providers.add(msg.provider ?? "unknown");
+          }
+        } else if (block.type === "toolCall") {
+          const toolName = mapPiToolNameToSdk(block.name, customToolNameToSdk);
+          blocks.push({ type: "tool_use", id: sanitizeToolId(block.id, sanitizedIds), name: toolName, input: block.arguments ?? {} });
+        } else {
+          dropped.other.set(block.type, (dropped.other.get(block.type) ?? 0) + 1);
+        }
+      }
+      if (!content.length) {
+        dropped.abortedTurns++;
+        continue;
+      }
+      if (!blocks.length) blocks.push({ type: "text", text: "[incompatible content omitted]" });
+      turnResults = null;
+      turnAssistantIdx = anthropicMessages.length;
+      anthropicMessages.push({ role: "assistant", content: blocks });
+    } else if (msg.role === "toolResult") {
+      const block = { type: "tool_result", tool_use_id: sanitizeToolId(msg.toolCallId, sanitizedIds), content: toolResultContent(msg.content), is_error: msg.isError };
+      if (turnResults) {
+        turnResults.content.push(block);
+      } else {
+        turnResults = { role: "user", content: [block] };
+        anthropicMessages.splice(turnAssistantIdx === null ? anthropicMessages.length : turnAssistantIdx + 1, 0, turnResults);
+      }
+    }
+  }
+  return { anthropicMessages, sanitizedIds, dropped };
+}
+
+var DEBUG_LOG_PATH = process.env.CLAUDE_BRIDGE_DEBUG_PATH || join(getAgentDir(), "claude-bridge.log");
+
+var DIAG_LOG_PATH = join(getAgentDir(), "claude-bridge-diag.log");
+
+
+// ../../node_modules/pi-claude-agent-sdk/src/models.ts
+var TWO_HUNDRED_K_CONTEXT = 2e5;
+
+var ONE_M_CONTEXT = 1e6;
+
+function isDatedAlias(id) {
+  return /-20\d{6}$/.test(id);
+}
+
+var FAMILY_ORDER = ["fable", "opus", "sonnet", "haiku"];
+
+function versionRank(id) {
+  const [, family, major, minor] = id.split("-");
+  return { family, tuple: [Number(major) || 0, Number(minor) || 0] };
+}
+
+function buildModels(piAiModels) {
+  return piAiModels.filter((m) => typeof m.id === "string" && !isDatedAlias(m.id)).sort((a, b) => {
+    const fa = FAMILY_ORDER.indexOf(versionRank(a.id).family);
+    const fb = FAMILY_ORDER.indexOf(versionRank(b.id).family);
+    const ta = fa === -1 ? FAMILY_ORDER.length : fa;
+    const tb = fb === -1 ? FAMILY_ORDER.length : fb;
+    if (ta !== tb) return ta - tb;
+    const ra = versionRank(a.id).tuple;
+    const rb = versionRank(b.id).tuple;
+    if (ra[0] !== rb[0]) return rb[0] - ra[0];
+    if (ra[1] !== rb[1]) return rb[1] - ra[1];
+    return a.id.localeCompare(b.id);
+  }).map(({ id, name, reasoning, input, contextWindow, maxTokens, thinkingLevelMap }) => ({
+    id,
+    name,
+    reasoning,
+    input,
+    contextWindow,
+    maxTokens,
+    thinkingLevelMap,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }
+  }));
+}
+
+var MEASURED_ONE_M = /* @__PURE__ */ new Set([
+  "claude-fable-5",
+  "claude-fable-5-1",
+  "claude-opus-5-5",
+  "claude-opus-5",
+  "claude-opus-4-8",
+  "claude-opus-4-7",
+  "claude-sonnet-5",
+  "claude-sonnet-5-5"
+]);
+
+var PLAN_GATED_ONE_M = {
+  // [1m] measured 1M on Max plan / extra usage; 429 on Pro without it.
+  "claude-opus-4-6": (settings) => settings.plan === "max" || settings.longContextExtraUsage,
+  // [1m] measured 1M with extra usage only.
+  "claude-sonnet-4-6": (settings) => settings.longContextExtraUsage
+};
+
+function resolveClaudeCodeRuntimeModel(model, settings) {
+  const modelId = model.id;
+  if (settings.forceTwoHundredK?.includes(modelId)) {
+    return { cliModelId: modelId, contextWindow: TWO_HUNDRED_K_CONTEXT };
+  }
+  if (MEASURED_ONE_M.has(modelId)) {
+    return { cliModelId: `${modelId}[1m]`, contextWindow: ONE_M_CONTEXT };
+  }
+  const planGate = PLAN_GATED_ONE_M[modelId];
+  if (planGate) {
+    const useOneM = planGate(settings);
+    return {
+      cliModelId: useOneM ? `${modelId}[1m]` : modelId,
+      contextWindow: useOneM ? ONE_M_CONTEXT : TWO_HUNDRED_K_CONTEXT
+    };
+  }
+  return { cliModelId: modelId, contextWindow: TWO_HUNDRED_K_CONTEXT };
+}
+
+function claudeCodeModelId(model, settings) {
+  return resolveClaudeCodeRuntimeModel(model, settings).cliModelId;
+}
+
+function adaptiveThinkingAlwaysOn(modelId) {
+  return modelId === "claude-fable-5-1" || modelId.startsWith("claude-fable-5-1[") || modelId === "claude-fable-5" || modelId.startsWith("claude-fable-5[");
+}
+
+function thinkingBoundToPrefix(modelId) {
+  return modelId === "claude-fable-5-1" || modelId.startsWith("claude-fable-5-1[");
+}
+
+function minClaudeCodeVersionForModel(modelId) {
+  if (modelId === "claude-fable-5-1" || modelId.startsWith("claude-fable-5-1[")) return "2.1.251";
+  return void 0;
+}
+
+function applyLongContext(models, settings) {
+  return models.map((m) => {
+    const { contextWindow } = resolveClaudeCodeRuntimeModel(m, settings);
+    const name = contextWindow > TWO_HUNDRED_K_CONTEXT && !/\b1M\b/i.test(m.name) ? `${m.name} 1M` : m.name;
+    return contextWindow === m.contextWindow && name === m.name ? m : { ...m, contextWindow, name };
+  });
+}
+
+function verifyWrittenSession(jsonlPath, expectedSessionId, expectedRecordCount) {
+  const warnings = [];
+  let st;
+  try {
+    st = statSync(jsonlPath);
+  } catch (e) {
+    warnings.push(`file missing after save \u2014 path=${jsonlPath} err=${e.message}`);
+    return warnings;
+  }
+  let content;
+  try {
+    content = readFileSync(jsonlPath, "utf8");
+  } catch (e) {
+    warnings.push(`file unreadable \u2014 path=${jsonlPath} size=${st.size} err=${e.message}`);
+    return warnings;
+  }
+  const lines = content.split("\n").filter((l) => l.trim().length > 0);
+  if (lines.length !== expectedRecordCount) {
+    warnings.push(`record count mismatch \u2014 expected=${expectedRecordCount} actual=${lines.length} path=${jsonlPath} bytes=${content.length}`);
+    return warnings;
+  }
+  try {
+    const firstRec = JSON.parse(lines[0]);
+    const lastRec = JSON.parse(lines[lines.length - 1]);
+    if (firstRec.sessionId !== expectedSessionId || lastRec.sessionId !== expectedSessionId) {
+      warnings.push(`sessionId drift \u2014 expected=${expectedSessionId} first=${firstRec.sessionId} last=${lastRec.sessionId}`);
+    }
+  } catch (e) {
+    warnings.push(`malformed JSONL \u2014 path=${jsonlPath} err=${e.message}`);
+  }
+  return warnings;
+}
+
+
+// ../../node_modules/pi-claude-agent-sdk/src/extract-tool-results.ts
+function toolResultToMcpContent(content) {
+  if (typeof content === "string") return [{ type: "text", text: content || "" }];
+  if (!Array.isArray(content)) return [{ type: "text", text: "" }];
+  const blocks = [];
+  for (const block of content) {
+    if (block.type === "text" && block.text) blocks.push({ type: "text", text: block.text });
+    else if (block.type === "image" && block.data && block.mimeType) blocks.push({ type: "image", data: block.data, mimeType: block.mimeType });
+  }
+  return blocks.length ? blocks : [{ type: "text", text: "" }];
+}
+
+function extractAllToolResults(messages) {
+  const results = [];
+  let stopIdx = -1;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.role === "toolResult") {
+      results.unshift({ content: toolResultToMcpContent(msg.content), isError: msg.isError, toolCallId: msg.toolCallId });
+    } else if (msg.role === "assistant") {
+      stopIdx = i;
+      break;
+    }
+  }
+  return { results, stopIdx };
+}
+
+
+// ../../node_modules/pi-claude-agent-sdk/src/query-state.ts
+var QueryContext = class {
+  // Query-scoped (fully isolated per query)
+  activeQuery = null;
+  currentPiStream = null;
+  latestCursor = 0;
+  pendingToolCalls = /* @__PURE__ */ new Map();
+  pendingResults = /* @__PURE__ */ new Map();
+  /** tool_use ids emitted this turn. Sole purpose is routing a delivered result
+   *  to the owning query when several queries are in flight — pairing a result
+   *  to its call is done by id from Claude's tools/call _meta, not from here. */
+  turnToolCallIds = [];
+  /** Streaming-input handle for the active query — how steers reach CC mid-turn. */
+  promptStream = null;
+  /** Last rate-limit rejection seen on this query. Claude Code sends it just before the
+   *  failure it caused, which is the only thing tying the two together. */
+  rateLimitRejection = null;
+  /** Highest 5% utilization bucket we notified for, so repeat rate_limit_event spam is suppressed. */
+  lastRateLimitWarnStep = null;
+  lastRateLimitWarnThreshold;
+  /** pi session this query serves, from SimpleStreamOptions.sessionId at fresh-query
+   *  setup. A bridge process serves several pi sessions at once (subagents run their
+   *  own AgentSessions), and history rewrites must only discard the rewriting
+   *  session's parked queries — this is the match key. Null when the host did not
+   *  supply an id.
+   */
+  piSessionId = null;
+  /** pi rewrote the history this query was built from (session_compact,
+   *  session_tree in its own pi session). Set by markRebuildForSession, consumed
+   *  by the tool-result delivery that discards the query. Not session-wide state:
+   *  it dies with the context it belongs to, so it cannot leak into later turns
+   *  the way a module flag does.
+   */
+  historyStale = false;
+  /** A steer never reached CC. A first query has no session mirror yet, so
+   *  completion must carry this into the mirror it creates. */
+  missedSteer = false;
+  // Per-turn (reset together)
+  turnOutput = null;
+  turnStarted = false;
+  turnSawStreamEvent = false;
+  turnSawToolCall = false;
+  /** API message id from the last message_start, and whether its message_stop has
+   *  arrived. An `assistant` message under a different id while the stream is still
+   *  open is Claude Code's non-streaming fallback for a stalled stream. */
+  turnStreamMessageId;
+  turnStreamOpen = false;
+  /** turnBlocks length at that message_start: where an abandoned attempt's blocks begin. */
+  turnStreamBlockStart = 0;
+  get turnBlocks() {
+    if (!this.turnOutput) throw new Error("turnBlocks accessed before resetTurnState");
+    return this.turnOutput.content;
+  }
+  /** Answer every parked MCP handler with `reason` and forget the turn's queued
+   *  results. Called when the query it belongs to is going away (abort, error,
+   *  normal end). Handlers must be *resolved*, not rejected: an error reply is
+   *  still a reply, and a handler left awaiting a subprocess that is gone keeps
+   *  CC's tools/call open forever, which wedges pi's turn behind it. */
+  releasePendingToolCalls(reason) {
+    for (const pending of this.pendingToolCalls.values()) pending.resolve({ content: [{ type: "text", text: reason }] });
+    this.pendingToolCalls.clear();
+    this.pendingResults.clear();
+  }
+  resetTurnState(model) {
+    this.turnOutput = {
+      role: "assistant",
+      content: [],
+      api: model.api,
+      provider: model.provider,
+      model: model.id,
+      usage: {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: 0,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+      },
+      stopReason: "stop",
+      timestamp: Date.now()
+    };
+    this.turnStarted = false;
+    this.turnSawStreamEvent = false;
+    this.turnSawToolCall = false;
+    this.turnStreamMessageId = void 0;
+    this.turnStreamOpen = false;
+    this.turnStreamBlockStart = 0;
+  }
+};
+
+var _ctx = new QueryContext();
+
+function ctx() {
+  return _ctx;
+}
+
+
+// ../../node_modules/pi-claude-agent-sdk/src/prompt-stream.ts
+function makePromptStream() {
+  const queue = [];
+  let inflight = null;
+  let wake = null;
+  let done = false;
+  let failure = null;
+  const kick = () => {
+    wake?.();
+    wake = null;
+  };
+  async function* gen() {
+    try {
+      while (true) {
+        while (queue.length === 0 && !done && !failure) {
+          await new Promise((resolve) => {
+            wake = resolve;
+          });
+        }
+        if (failure) throw failure;
+        const item = queue.shift();
+        if (!item) return;
+        inflight = item;
+        try {
+          yield item.msg;
+          item.resolve();
+        } finally {
+          item.reject(new Error("prompt stream closed"));
+          inflight = null;
+        }
+      }
+    } finally {
+      done = true;
+    }
+  }
+  return {
+    stream: gen(),
+    push: (msg) => failure || done ? Promise.reject(failure ?? new Error("prompt stream closed")) : new Promise((resolve, reject) => {
+      queue.push({ msg, resolve, reject });
+      kick();
+    }),
+    end: () => {
+      done = true;
+      kick();
+    },
+    fail: (error) => {
+      if (failure) return;
+      failure = error;
+      queue.splice(0).forEach((item) => item.reject(error));
+      inflight?.reject(error);
+      kick();
+    }
+  };
+}
+
+function userMessage(content, priority) {
+  return {
+    type: "user",
+    message: { role: "user", content },
+    parent_tool_use_id: null,
+    ...priority ? { priority } : {}
+  };
+}
+
+function tryParseJson(path) {
+  if (!existsSync(path)) return {};
+  try {
+    return JSON.parse(readFileSync2(path, "utf-8"));
+  } catch (e) {
+    console.error(`claude-bridge: failed to parse ${path}: ${e}`);
+    return {};
+  }
+}
+
+function claudeCodeSettings(provider = {}) {
+  return { autoMemoryEnabled: provider.autoMemoryEnabled ?? false };
+}
+
+function globalConfigPath() {
+  return join2(getAgentDir2(), "claude-bridge.json");
+}
+
+function markStartupNoticeShown() {
+  const path = globalConfigPath();
+  let existing = {};
+  if (existsSync(path)) {
+    try {
+      existing = JSON.parse(readFileSync2(path, "utf-8"));
+    } catch (e) {
+      console.error(`claude-bridge: leaving ${path} alone, it does not parse: ${e}`);
+      return path;
+    }
+  }
+  const next = { ...existing, startupNoticeShown: (/* @__PURE__ */ new Date()).toLocaleDateString("en-CA") };
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(next, null, 2)}
+`);
+  return path;
+}
+
+function loadConfig(cwd) {
+  const global = tryParseJson(globalConfigPath());
+  const project = tryParseJson(join2(cwd, CONFIG_DIR_NAME, "claude-bridge.json"));
+  return {
+    startupNoticeShown: project.startupNoticeShown ?? global.startupNoticeShown,
+    provider: { ...global.provider, ...project.provider }
+  };
+}
+
+
+// ../../node_modules/pi-claude-agent-sdk/src/agents-md.ts
+function formatProjectContext(contextFiles) {
+  if (contextFiles.length === 0) return void 0;
+  let prompt = "<project_context>\n\nProject-specific instructions and guidelines:\n\n";
+  for (const { path, content } of contextFiles) {
+    prompt += `<project_instructions path="${path}">
+${content}
+</project_instructions>
+
+`;
+  }
+  return `${prompt}</project_context>`;
+}
+
+
+// ../../node_modules/pi-claude-agent-sdk/src/prompt-capture.ts
+var PromptCaptures = class {
+  /** Pi rebuilds prompts when tools change, so retain only recent lookup keys.
+   *  Inheritance edges hold direct references and survive key eviction.
+   *
+   *  Set well above any plausible working set because the costs are lopsided: a
+   *  capture is tens of KB, while evicting one that is still live fails the turn.
+   *  A parent that fans out to more distinct sub-agent prompts than this before its
+   *  own next turn would be evicted despite being in use. The bound exists only to
+   *  cap an extension that rebuilds the prompt every turn, which would otherwise
+   *  grow keys without limit. */
+  constructor(limit = 256, onDiagnose) {
+    this.limit = limit;
+    this.onDiagnose = onDiagnose ?? (() => {
+    });
+  }
+  limit;
+  captures = /* @__PURE__ */ new Map();
+  /** Invoked with everything that would otherwise be lost when resolution throws,
+   *  so the bridge can write it to its debug log. Kept off the throw path itself:
+   *  the resolver is hot and the caller may own a faster sink than string-building.
+   *
+   *  Set by the bridge on the shared instance; tests that want the diagnostic can
+   *  pass one per instance. */
+  onDiagnose;
+  record(systemPrompt, input, source) {
+    const existing = this.captures.get(systemPrompt);
+    const customChanged = existing?.custom !== input.custom;
+    const capture = existing ?? {
+      ...input,
+      assembledPrompt: systemPrompt,
+      contextFiles: [],
+      skills: [],
+      inherited: []
+    };
+    capture.custom = input.custom;
+    capture.append = input.append;
+    capture.contextFiles = input.contextFiles.map((file) => ({ ...file }));
+    capture.skills = [...input.skills];
+    capture.source = source;
+    if (!existing || customChanged) {
+      capture.inherited = this.findInheritedPrompts(systemPrompt, input.custom);
+    }
+    this.touch(systemPrompt, capture);
+  }
+  /** Exact lookup only. Callers serving a query want `resolveOrDerive`. */
+  resolve(systemPrompt) {
+    if (!systemPrompt) return void 0;
+    const capture = this.captures.get(systemPrompt);
+    if (capture) this.touch(systemPrompt, capture);
+    return capture;
+  }
+  /** Recency is by use, not just by record. A parent agent records its prompt once
+   *  and then only ever resolves it, so counting writes alone ages it out behind the
+   *  sub-agent prompts churning past it — observed in a real 135-message session,
+   *  where the parent's own prompt was evicted and its next turn resolved to
+   *  nothing. */
+  touch(systemPrompt, capture) {
+    this.captures.delete(systemPrompt);
+    this.captures.set(systemPrompt, capture);
+    for (const key of this.captures.keys()) {
+      if (this.captures.size <= this.limit) break;
+      this.captures.delete(key);
+    }
+  }
+  /**
+   * The capture to project for one provider query.
+   *
+   * An exact key is the normal case. A prompt that only *embeds* known prompts —
+   * anything that wrapped what Pi assembled after we recorded it — resolves to a
+   * transient descendant over the whole prompt, so projection swaps each embedded
+   * capture for its portable parts and carries everything around them through
+   * unchanged. That surrounding text belongs to whatever did the wrapping, and
+   * dropping it would be exactly the silent instruction loss this exists to
+   * prevent. The descendant is not retained — its key is not ours to own.
+   *
+   * Throws when a prompt can be accounted for by neither route. Returning an empty
+   * capture instead would hand Claude Code a turn with none of the user's context
+   * files, skills, custom prompt or append text, and say so only in a debug line —
+   * silently discarding policy the user wrote down. A failed turn is recoverable;
+   * a turn that quietly ignored its instructions is not.
+   */
+  resolveOrDerive(systemPrompt) {
+    if (!systemPrompt) return void 0;
+    const exact = this.captures.get(systemPrompt);
+    if (exact) {
+      this.touch(systemPrompt, exact);
+      return exact;
+    }
+    const revived = this.reachableCaptures().find((node) => node.assembledPrompt === systemPrompt);
+    if (revived) {
+      this.touch(systemPrompt, revived);
+      return revived;
+    }
+    const embedded = this.findInheritedPrompts(systemPrompt, systemPrompt);
+    if (embedded.length === 0) {
+      const matches = this.closestKnown(systemPrompt);
+      this.onDiagnose({ systemPrompt, matches });
+      const truncated = matches.find(
+        (m) => m.firstDivergent === systemPrompt.length && m.key.length > systemPrompt.length
+      );
+      if (truncated) {
+        throw new Error(
+          `prompt-capture: this ${systemPrompt.length}-char prompt is the ${truncated.key.length}-char capture recorded at ${truncated.source ?? "an unknown boundary"} with its final ${truncated.key.length - systemPrompt.length} chars missing. That shape matches pi#5581: an extension-triggered idle turn (sendMessage with triggerTurn) skips before_agent_start, so the prompt lacks that turn's extension additions. The turn fails; the next user-typed turn resolves normally. Workaround: when idle, send a user message instead of triggerTurn.`
+        );
+      }
+      throw new Error(
+        `prompt-capture: no capture for this ${systemPrompt.length}-char system prompt, and it embeds none of the ${this.captures.size} known. Closest known match diverges at offset ${matches[0]?.firstDivergent ?? "?"} (${matches.length ? matches[0].key.length : 0}-char key${matches[0]?.source ? `, last recorded at ${matches[0].source}` : ""}). Claude Code would receive none of this turn's context files, skills or custom instructions. The usual cause is an extension loaded after claude-bridge that rewrites the system prompt from before_agent_start \u2014 one that wraps it is fine, one that rebuilds or strips it leaves nothing to match. (Also possible: pi rebuilt the prompt outside before_agent_start \u2014 a late-registered tool or fresh resource discovery.)`
+      );
+    }
+    return { assembledPrompt: systemPrompt, custom: systemPrompt, contextFiles: [], skills: [], inherited: embedded };
+  }
+  get size() {
+    return this.captures.size;
+  }
+  /** Longest shared-prefix matches, best first, for the throw diagnostic. */
+  closestKnown(systemPrompt) {
+    let shared = 0;
+    const matches = [];
+    for (const [key, capture] of this.captures.entries()) {
+      const limit = Math.min(key.length, systemPrompt.length);
+      let i = 0;
+      while (i < limit && key.charCodeAt(i) === systemPrompt.charCodeAt(i)) i++;
+      if (i >= shared) {
+        if (i > shared) {
+          shared = i;
+          matches.length = 0;
+        }
+        matches.push({ key, firstDivergent: i, source: capture.source });
+      }
+    }
+    return matches;
+  }
+  findInheritedPrompts(systemPrompt, custom) {
+    if (!custom) return [];
+    const candidates = [];
+    for (const parent of this.reachableCaptures()) {
+      const key = parent.assembledPrompt;
+      if (key === systemPrompt || key.length === 0) continue;
+      for (let start = custom.indexOf(key); start !== -1; start = custom.indexOf(key, start + key.length)) {
+        candidates.push({ start, end: start + key.length, length: key.length, parent });
+      }
+    }
+    candidates.sort((a, b) => b.length - a.length || a.start - b.start);
+    const selected = [];
+    for (const candidate of candidates) {
+      if (selected.some((edge) => candidate.start < edge.end && candidate.end > edge.start)) continue;
+      selected.push({ start: candidate.start, end: candidate.end, parent: candidate.parent });
+    }
+    return selected.sort((a, b) => a.start - b.start);
+  }
+  reachableCaptures() {
+    const result = [];
+    const seen = /* @__PURE__ */ new Set();
+    const visit = (capture) => {
+      if (seen.has(capture)) return;
+      seen.add(capture);
+      result.push(capture);
+      for (const edge of capture.inherited) visit(edge.parent);
+    };
+    for (const capture of this.captures.values()) visit(capture);
+    return result;
+  }
+};
+
+var PI_PREAMBLE = "You are an expert coding assistant operating inside pi";
+
+var ANTHROPIC_THIRD_PARTY_TRIGGERS = ["docs/custom-provider.md", "docs/packages.md"];
+
+var SHARED_CAPTURES_KEY = /* @__PURE__ */ Symbol.for("claude-bridge:promptCaptures");
+
+function sharedPromptCaptures(onDiagnose) {
+  const globals = globalThis;
+  return globals[SHARED_CAPTURES_KEY] ??= new PromptCaptures(256, onDiagnose);
+}
+
+function projectPromptCapture(capture, options) {
+  return projectCapture(capture, options, /* @__PURE__ */ new Set());
+}
+
+function collectPromptSkills(capture) {
+  const result = [];
+  const seenPaths = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if (visited.has(node)) return;
+    if (visiting.has(node)) throw new Error("Cyclic prompt inheritance");
+    visiting.add(node);
+    for (const edge of node.inherited) visit(edge.parent);
+    for (const skill of node.skills) {
+      if (skill.disableModelInvocation || seenPaths.has(skill.filePath)) continue;
+      seenPaths.add(skill.filePath);
+      result.push(skill);
+    }
+    visiting.delete(node);
+    visited.add(node);
+  };
+  visit(capture);
+  return result;
+}
+
+function projectCapture(capture, options, visiting) {
+  if (visiting.has(capture)) throw new Error("Cyclic prompt inheritance");
+  visiting.add(capture);
+  try {
+    const inheritedSkillPaths = new Set(
+      capture.inherited.flatMap((edge) => collectPromptSkills(edge.parent).map((skill) => skill.filePath))
+    );
+    const ownSkillPaths = /* @__PURE__ */ new Set();
+    const ownSkills = capture.skills.filter((skill) => {
+      if (skill.disableModelInvocation || inheritedSkillPaths.has(skill.filePath) || ownSkillPaths.has(skill.filePath)) {
+        return false;
+      }
+      ownSkillPaths.add(skill.filePath);
+      return true;
+    });
+    const custom = projectCustom(capture, options, visiting);
+    const parts = [];
+    const context = formatProjectContext(capture.contextFiles);
+    if (context) parts.push({ label: "the project context block", text: context });
+    const skills = renderSkillsBlock(ownSkills, options.skillReadTool);
+    if (skills) parts.push({ label: "the skills block", text: skills });
+    if (custom) parts.push({ label: "the custom prompt", text: custom });
+    if (capture.append) parts.push({ label: "the appended instructions", text: capture.append });
+    assertSendablePrompt(parts, capture);
+    return parts.length > 0 ? parts.map((part) => part.text).join("\n\n") : void 0;
+  } finally {
+    visiting.delete(capture);
+  }
+}
+
+function assertSendablePrompt(parts, capture) {
+  const findings = [];
+  for (const { label, text } of parts) {
+    const offset = preambleAtLineStart(text);
+    if (offset !== -1) {
+      findings.push(`pi's preamble ("${PI_PREAMBLE}") in ${label}, at offset ${offset} of ${text.length} chars`);
+    }
+    if (ANTHROPIC_THIRD_PARTY_TRIGGERS.every((trigger) => text.includes(trigger))) {
+      findings.push(`${ANTHROPIC_THIRD_PARTY_TRIGGERS.join(" and ")} in ${label}`);
+    }
+  }
+  if (findings.length === 0) return;
+  throw new Error([
+    "prompt-capture: refusing to send this prompt. Claude Code's Anthropic path reads a request",
+    "  carrying pi's harness, or the phrase pair its subscription gate rejects, as a third-party",
+    "  app: it fails with 400 or is billed as extra usage.",
+    ...findings.map((finding) => `  Found: ${finding}.`),
+    `  Capture: ${capture.source ?? "unknown"}, ${capture.inherited.length} inherited capture(s) substituted.`,
+    '  If this came from an inherited pi prompt, see README "Compatibility with other extensions".',
+    "  If it is your own text, reword or remove it. CLAUDE_BRIDGE_DEBUG=1 writes the full prompt to",
+    `  ${DEBUG_LOG_PATH}.`
+  ].join("\n"));
+}
+
+function preambleAtLineStart(text) {
+  for (let offset = text.indexOf(PI_PREAMBLE); offset !== -1; offset = text.indexOf(PI_PREAMBLE, offset + PI_PREAMBLE.length)) {
+    if (offset === 0 || text[offset - 1] === "\n") return offset;
+  }
+  return -1;
+}
+
+function projectCustom(capture, options, visiting) {
+  if (!capture.custom || capture.inherited.length === 0) return capture.custom;
+  let result = "";
+  let cursor = 0;
+  for (const edge of capture.inherited) {
+    result += capture.custom.slice(cursor, edge.start);
+    result += projectCapture(edge.parent, options, visiting) ?? "";
+    cursor = edge.end;
+  }
+  return result + capture.custom.slice(cursor);
+}
+
+
+// ../../node_modules/pi-claude-agent-sdk/src/attachments.ts
+var CONTENT_BEARING = /* @__PURE__ */ new Set(["file"]);
+
+function userPromptText(record) {
+  if (record.type !== "user") return void 0;
+  const content = record.message?.content;
+  if (Array.isArray(content) && content.some((b) => b?.type === "tool_result")) return void 0;
+  const text = messageContentToText(content);
+  return text ? text : void 0;
+}
+
+function collectCarriedAttachments(records) {
+  const ordinalOf = /* @__PURE__ */ new Map();
+  const textOf = /* @__PURE__ */ new Map();
+  let ordinal = 0;
+  const carried = [];
+  for (const raw of records) {
+    const record = raw;
+    const prompt = userPromptText(record);
+    if (prompt !== void 0) {
+      ordinalOf.set(record.uuid, ordinal++);
+      textOf.set(record.uuid, prompt);
+      continue;
+    }
+    if (record.type !== "attachment") continue;
+    const parent = record.parentUuid;
+    if (parent === null || !ordinalOf.has(parent)) continue;
+    const inherited = ordinalOf.get(parent);
+    ordinalOf.set(record.uuid, inherited);
+    textOf.set(record.uuid, textOf.get(parent));
+    const attachment = record.attachment;
+    if (!attachment || !CONTENT_BEARING.has(attachment.type)) continue;
+    carried.push({ attachment, userOrdinal: inherited, parentText: textOf.get(parent) });
+  }
+  return carried;
+}
+
+function placeCarriedAttachments(carried, messages) {
+  const prompts = [];
+  messages.forEach((msg, index) => {
+    if (msg.role !== "user") return;
+    if (Array.isArray(msg.content) && msg.content.some((b) => b?.type === "tool_result")) return;
+    const text = messageContentToText(msg.content);
+    if (text) prompts.push({ index, text });
+  });
+  const attachments = [];
+  const skipped = [];
+  for (const item of carried) {
+    const name = String(item.attachment.filename ?? item.attachment.type);
+    const candidate = prompts[item.userOrdinal];
+    if (!candidate) {
+      skipped.push(`${name}: prompt #${item.userOrdinal} is no longer in history`);
+      continue;
+    }
+    if (candidate.text !== item.parentText) {
+      skipped.push(`${name}: prompt #${item.userOrdinal} changed`);
+      continue;
+    }
+    attachments.push({ afterIndex: candidate.index, attachment: item.attachment });
+  }
+  return { attachments, skipped };
+}
+
+var TOOL_USE_ID_META = "claudecode/toolUseId";
+
+function assertObjectSchema(tool) {
+  const schema = tool.inputSchema;
+  if (!schema || schema.type !== "object") {
+    throw new Error(`${tool.name}: MCP tool parameters must be an object schema, got ${JSON.stringify(schema)}`);
+  }
+}
+
+function createToolServer(name, tools) {
+  const server = new McpServer({ name, version: "1.0.0" }, { capabilities: { tools: {} } });
+  const byName = new Map(tools.map((tool) => [tool.name, tool]));
+  for (const tool of tools) assertObjectSchema(tool);
+  server.server.setRequestHandler(ListToolsRequestSchema, () => ({
+    tools: tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.inputSchema
+    }))
+  }));
+  server.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const tool = byName.get(request.params.name);
+    if (!tool) throw new Error(`Unknown tool: ${request.params.name}`);
+    const toolCallId = request.params._meta?.[TOOL_USE_ID_META];
+    if (typeof toolCallId !== "string") {
+      throw new Error(`${tool.name}: tools/call is missing _meta["${TOOL_USE_ID_META}"] \u2014 cannot pair the result with its tool call`);
+    }
+    const { content, isError } = await tool.handler(toolCallId);
+    return { content, isError };
+  });
+  return { type: "sdk", name, instance: server };
+}
+
+
+// ../../node_modules/pi-claude-agent-sdk/src/child-env.ts
+var CC_CHILD_ENV = {
+  ENABLE_CLAUDEAI_MCP_SERVERS: "0",
+  DISABLE_AUTO_COMPACT: "1"
+};
+
+function buildClaudeChildEnv(base, resolved) {
+  const env = { ...base, ...resolved?.env ?? {}, ...CC_CHILD_ENV };
+  for (const key of [
+    "ANTHROPIC_API_KEY",
+    "ANTHROPIC_AUTH_TOKEN",
+    "ANTHROPIC_OAUTH_TOKEN",
+    "ANTHROPIC_IDENTITY_TOKEN",
+    "ANTHROPIC_IDENTITY_TOKEN_FILE",
+    "ANTHROPIC_BASE_URL",
+    "ANTHROPIC_CUSTOM_HEADERS",
+    "CLAUDE_CODE_OAUTH_TOKEN",
+    "CLAUDE_CODE_CUSTOM_OAUTH_URL",
+    "CLAUDE_CODE_OAUTH_CLIENT_ID",
+    "CLAUDE_CODE_USE_BEDROCK",
+    "CLAUDE_CODE_USE_FOUNDRY",
+    "CLAUDE_CODE_USE_VERTEX"
+  ]) delete env[key];
+  const headers = Object.entries(resolved?.auth.headers ?? {}).filter((entry) => entry[1] != null);
+  const authorization = headers.find(([name]) => name.toLowerCase() === "authorization")?.[1];
+  const bearerToken = authorization?.match(/^Bearer\s+(.+)$/i)?.[1];
+  const headerApiKey = headers.find(([name]) => name.toLowerCase() === "x-api-key")?.[1];
+  const credential = resolved?.auth.apiKey ?? headerApiKey;
+  if (!credential && !bearerToken) {
+    throw new Error("No Anthropic credential is configured in Pi. Configure Anthropic authentication in Pi before using claude-bridge.");
+  }
+  if (resolved?.auth.baseUrl) env.ANTHROPIC_BASE_URL = resolved.auth.baseUrl;
+  const customHeaders = headers.filter(([name]) => !["authorization", "x-api-key"].includes(name.toLowerCase()));
+  if (customHeaders.length > 0) {
+    env.ANTHROPIC_CUSTOM_HEADERS = customHeaders.map(([name, value]) => `${name}: ${value}`).join("\n");
+  }
+  if (bearerToken) {
+    env.ANTHROPIC_AUTH_TOKEN = bearerToken;
+  } else if (resolved?.source?.toLowerCase().includes("oauth")) {
+    env.CLAUDE_CODE_OAUTH_TOKEN = credential;
+  } else {
+    env.ANTHROPIC_API_KEY = credential;
+  }
+  return env;
+}
+
+var CHILD_OAUTH_MIN_VALIDITY_MS = 2 * 60 * 60 * 1e3;
+
+var minValidityUnsatisfiable = false;
+
+async function resolveAnthropicAuth(registry) {
+  const runtime = registry.runtime;
+  if (!minValidityUnsatisfiable && typeof runtime?.getAuth === "function") {
+    try {
+      return await runtime.getAuth("anthropic", { minOAuthValidityMs: CHILD_OAUTH_MIN_VALIDITY_MS });
+    } catch (err) {
+      if (/expires too soon/i.test(err instanceof Error ? err.message : String(err))) minValidityUnsatisfiable = true;
+    }
+  }
+  return registry.getProviderAuth("anthropic");
+}
+
+async function resolveClaudeChildEnv(registry, base = process.env) {
+  return { ...base, ...CC_CHILD_ENV };
+  const resolved = registry ? await resolveAnthropicAuth(registry) : void 0;
+  return buildClaudeChildEnv(base, resolved);
+}
+
+var require2 = createRequire(import.meta.url);
+
+var versionCache = /* @__PURE__ */ new Map();
+
+function parseClaudeVersion(text) {
+  const match = text.match(/(\d+)\.(\d+)\.(\d+)/);
+  if (!match) return void 0;
+  return { major: Number(match[1]), minor: Number(match[2]), patch: Number(match[3]) };
+}
+
+function formatClaudeVersion(version) {
+  return `${version.major}.${version.minor}.${version.patch}`;
+}
+
+function compareClaudeVersion(a, b) {
+  return a.major - b.major || a.minor - b.minor || a.patch - b.patch;
+}
+
+function readBundledClaudeCodeVersion() {
+  try {
+    const pkgPath = join3(dirname2(require2.resolve("@anthropic-ai/claude-agent-sdk")), "package.json");
+    const pkg = JSON.parse(readFileSync3(pkgPath, "utf8"));
+    return parseClaudeVersion(pkg.claudeCodeVersion ?? "");
+  } catch {
+    return void 0;
+  }
+}
+
+function findExecutableOnPath(name, env = process.env) {
+  const pathEnv = env.PATH ?? env.Path;
+  if (!pathEnv) return void 0;
+  const exts = process.platform === "win32" ? (env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";").filter(Boolean) : [""];
+  const names = process.platform === "win32" && !exts.some((ext) => name.toUpperCase().endsWith(ext.toUpperCase())) ? [name, ...exts.map((ext) => name + ext)] : [name];
+  for (const dir of pathEnv.split(delimiter)) {
+    if (!dir) continue;
+    for (const candidateName of names) {
+      const candidate = join3(dir, candidateName);
+      try {
+        accessSync(candidate, constants.X_OK);
+        return candidate;
+      } catch {
+      }
+    }
+  }
+  return void 0;
+}
+
+function readClaudeCliVersion(executable) {
+  if (versionCache.has(executable)) return versionCache.get(executable);
+  try {
+    const result = spawnSync(executable, ["--version"], {
+      encoding: "utf8",
+      timeout: 8e3,
+      env: process.env,
+      windowsHide: true
+    });
+    const version = parseClaudeVersion(`${result.stdout ?? ""}
+${result.stderr ?? ""}`);
+    versionCache.set(executable, version);
+    return version;
+  } catch {
+    versionCache.set(executable, void 0);
+    return void 0;
+  }
+}
+
+function tooOldError(modelId, min, found) {
+  return `${modelId} requires Claude Code ${formatClaudeVersion(min)} or newer (${found}). Install a current claude on PATH, or set provider.pathToClaudeCodeExecutable in ~/.pi/agent/claude-bridge.json.`;
+}
+
+function resolveClaudeCodeExecutable(modelId, configured, deps = {}) {
+  const bundledVersion = deps.bundledVersion ?? readBundledClaudeCodeVersion;
+  const findOnPath = deps.findOnPath ?? (() => findExecutableOnPath("claude"));
+  const readVersion = deps.readVersion ?? readClaudeCliVersion;
+  const minText = minClaudeCodeVersionForModel(modelId);
+  const min = minText ? parseClaudeVersion(minText) : void 0;
+  if (configured) {
+    if (min) {
+      const version = readVersion(configured);
+      if (version && compareClaudeVersion(version, min) < 0) {
+        return {
+          source: "configured",
+          error: tooOldError(modelId, min, `provider.pathToClaudeCodeExecutable is ${formatClaudeVersion(version)} at ${configured}`)
+        };
+      }
+    }
+    return { path: configured, source: "configured" };
+  }
+  if (!min) return { source: "bundled" };
+  const bundled = bundledVersion();
+  if (bundled && compareClaudeVersion(bundled, min) >= 0) {
+    return { source: "bundled" };
+  }
+  const pathClaude = findOnPath();
+  if (pathClaude) {
+    const version = readVersion(pathClaude);
+    if (version && compareClaudeVersion(version, min) >= 0) {
+      return { path: pathClaude, source: "path" };
+    }
+  }
+  if (bundled) {
+    return { source: "bundled", error: tooOldError(modelId, min, `bundled CLI is ${formatClaudeVersion(bundled)}`) };
+  }
+  return { source: "bundled" };
+}
+
+var SECTION_RANK = /* @__PURE__ */ new Map([
+  ["preamble", 0],
+  ["tools", 1],
+  ["rules", 2],
+  ["docs", 3],
+  ["addendum", 4],
+  ["project_context", 5],
+  ["skills", 6],
+  ["cwd", 7]
+]);
+
+function stableRanked(sections, ranks) {
+  let predecessorRank = -1;
+  const ranked = [...sections].map(([name, value]) => {
+    const rank = ranks.get(name) ?? predecessorRank;
+    predecessorRank = rank;
+    return { name, value, rank };
+  });
+  ranked.sort((a, b) => a.rank - b.rank);
+  return new Map(ranked.map(({ name, value }) => [name, value]));
+}
+
+function canonicalSystemPrompt(message) {
+  if (!message) return void 0;
+  const sections = new Map(
+    Object.entries(message.sections ?? {}).filter((entry) => entry[1] !== null)
+  );
+  const parts = [contentText(message.content), ...stableRanked(sections, SECTION_RANK).values()].filter((part) => part.length > 0);
+  return parts.length > 0 ? parts.join("\n\n") : void 0;
+}
+
+function toBridgeContext(context) {
+  if (!context.messages.some((message) => message.role === "system")) return context;
+  const tools = getCurrentTools(context.messages);
+  return {
+    ...context,
+    systemPrompt: canonicalSystemPrompt(getCurrentSystemMessage(context.messages)),
+    tools: tools.length > 0 ? tools : void 0,
+    messages: nonSystemMessages(context.messages)
+  };
+}
+
+function nonSystemMessages(messages) {
+  return messages.filter((message) => message.role !== "system");
+}
+
+function updateUsage(output, usage, model) {
+  if (usage.input_tokens != null) output.usage.input = usage.input_tokens;
+  if (usage.output_tokens != null) output.usage.output = usage.output_tokens;
+  if (usage.cache_read_input_tokens != null) output.usage.cacheRead = usage.cache_read_input_tokens;
+  if (usage.cache_creation_input_tokens != null) output.usage.cacheWrite = usage.cache_creation_input_tokens;
+  const reasoning = usage.output_tokens_details?.thinking_tokens;
+  if (reasoning != null) output.usage.reasoning = reasoning;
+  output.usage.totalTokens = output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
+  calculateCost(model, output.usage);
+  const promptTokens = output.usage.input + output.usage.cacheRead + output.usage.cacheWrite;
+  const report = { cachePct: promptTokens > 0 ? Math.round(output.usage.cacheRead / promptTokens * 100) : 0 };
+  if (reasoning != null) report.reasoning = reasoning;
+  return report;
+}
+
+
+// ../../node_modules/pi-claude-agent-sdk/src/index.ts
+var DEBUG = process.env.CLAUDE_BRIDGE_DEBUG === "1";
+
+var RECORD_STREAM_PATH = process.env.CLAUDE_BRIDGE_RECORD_STREAM;
+
+var CLAUDE_MD_EXCLUDES = ["**/CLAUDE.md", "**/.claude/rules/**"];
+
+if (DEBUG) {
+  try {
+    mkdirSync2(dirname3(DEBUG_LOG_PATH), { recursive: true });
+  } catch {
+  }
+}
+
+var moduleInstanceId = Math.random().toString(36).slice(2, 8);
+
+function debug(...args) {
+  if (!DEBUG) return;
+  const ts = (/* @__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(" ");
+  appendFileSync(DEBUG_LOG_PATH, `[${ts}] [${moduleInstanceId}] ${msg}
+`);
+}
+
+var nextCliDebugSeq = 1;
+
+function makeCliDebugOptions(tag) {
+  if (!DEBUG) return {};
+  const seq = nextCliDebugSeq++;
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const logDir = join4(dirname3(DEBUG_LOG_PATH), "cc-cli-logs");
+  try {
+    mkdirSync2(logDir, { recursive: true });
+  } catch {
+  }
+  const debugFile = join4(logDir, `${ts}-${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) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  const entry = { ts, moduleInstanceId, label, ...data };
+  mkdirSync2(dirname3(DIAG_LOG_PATH), { recursive: true });
+  appendFileSync(DIAG_LOG_PATH, JSON.stringify(entry) + "\n");
+  debug(`DIAG: ${label} (see ${DIAG_LOG_PATH})`);
+}
+
+var ACTIVE_STREAM_SIMPLE_KEY = /* @__PURE__ */ Symbol("claude-bridge:activeStreamSimple");
+
+var MODELS = buildModels(getModels("anthropic"));
+
+var providerSettings = {};
+
+var longContextSettings = { plan: "max", longContextExtraUsage: false };
+
+function errorMessage(err) {
+  if (err instanceof Error) return err.message;
+  if (err && typeof err === "object") {
+    const obj = err;
+    if (typeof obj.message === "string") return obj.message;
+    if (typeof obj.error === "string") return obj.error;
+    try {
+      return JSON.stringify(err);
+    } catch {
+    }
+  }
+  return String(err);
+}
+
+function readCarriedAttachments(sessionId, cwd) {
+  try {
+    const previous = openSession({ sessionId, projectPath: cwd, claudeDir: process.env.CLAUDE_CONFIG_DIR });
+    return collectCarriedAttachments(previous.records);
+  } catch (error) {
+    debug(`WARNING: could not read attachments from session ${sessionId.slice(0, 8)}:`, error);
+    return [];
+  }
+}
+
+function sessionKey(piSessionId) {
+  return piSessionId ?? "(none)";
+}
+
+var sharedSessions = /* @__PURE__ */ new Map();
+
+function sessionStateFor(piSessionId) {
+  return sharedSessions.get(sessionKey(piSessionId)) ?? null;
+}
+
+function setSessionStateFor(piSessionId, state) {
+  if (state === null) sharedSessions.delete(sessionKey(piSessionId));
+  else sharedSessions.set(sessionKey(piSessionId), state);
+}
+
+var historyRewrittenBySession = /* @__PURE__ */ new Set();
+
+var MARK_REBUILD_HOOKS_KEY = /* @__PURE__ */ Symbol.for("claude-bridge:markRebuildHooks");
+
+var markRebuildHooks = globalThis[MARK_REBUILD_HOOKS_KEY] ?? /* @__PURE__ */ new Set();
+
+globalThis[MARK_REBUILD_HOOKS_KEY] = markRebuildHooks;
+
+function markRebuildForSession(piSession, event) {
+  const key = sessionKey(piSession);
+  const state = sharedSessions.get(key);
+  if (!state) {
+    debug(`${event}: history rewritten, no session to mark yet`);
+  } else {
+    sharedSessions.set(key, { ...state, needsRebuild: true });
+    debug(`${event}: marking needsRebuild on session ${state.sessionId.slice(0, 8)}`);
+  }
+  if (piSession) historyRewrittenBySession.add(piSession);
+  armStaleContexts();
+}
+
+function armStaleContexts() {
+  for (const c of activeQueryContexts) {
+    if (c.piSessionId && historyRewrittenBySession.has(c.piSessionId)) c.historyStale = true;
+  }
+}
+
+markRebuildHooks.add(markRebuildForSession);
+
+function sponsorMarkRebuildForSession(piSession, event) {
+  for (const hook of markRebuildHooks) hook(piSession, event);
+}
+
+function convertAndImportMessages(session, messages, customToolNameToSdk, carried, dropThinking = false) {
+  const { anthropicMessages, sanitizedIds, dropped } = convertPiMessages(messages, customToolNameToSdk, dropThinking);
+  debug(`convertAndImportMessages: ${messages.length} pi msgs \u2192 ${anthropicMessages.length} anthropic msgs`);
+  debug(`convertAndImportMessages: imported roles:`, anthropicMessages.map((m, i) => {
+    const c = m.content;
+    if (typeof c === "string") return `[${i}]${m.role}:text`;
+    if (Array.isArray(c)) return `[${i}]${m.role}:${c.map((b) => b.type).join("+")}`;
+    return `[${i}]${m.role}:?`;
+  }).join(" "));
+  const droppedParts = [
+    dropped.thinking ? `${dropped.thinking} thinking (${[...dropped.providers].sort().join(", ")})` : "",
+    dropped.abortedTurns ? `${dropped.abortedTurns} aborted turn(s)` : "",
+    ...[...dropped.other].map(([type, n]) => `${n} ${type}`)
+  ].filter(Boolean);
+  if (droppedParts.length > 0) {
+    debug(`convertAndImportMessages: dropped ${droppedParts.join(", ")}`);
+  }
+  if (sanitizedIds.size > 0) {
+    debug(
+      `convertAndImportMessages: sanitized ${sanitizedIds.size} tool IDs:`,
+      [...sanitizedIds.entries()].map(([orig, clean]) => orig === clean ? orig : `${orig}\u2192${clean}`).join(", ")
+    );
+  }
+  const repaired = repairToolPairing(anthropicMessages);
+  if (repaired.length !== anthropicMessages.length) {
+    debug(`convertAndImportMessages: repairToolPairing ${anthropicMessages.length} \u2192 ${repaired.length} msgs`);
+  }
+  const placed = carried?.length ? placeCarriedAttachments(carried, repaired) : void 0;
+  if (placed?.skipped.length) {
+    debug(`convertAndImportMessages: dropped ${placed.skipped.length} carried attachment(s): ${placed.skipped.join("; ")}`);
+  }
+  if (placed?.attachments.length) {
+    debug(`convertAndImportMessages: carrying ${placed.attachments.length} attachment(s) across the rebuild`);
+  }
+  if (repaired.length) {
+    session.importMessages(repaired, placed?.attachments.length ? { attachments: placed.attachments } : void 0);
+  }
+}
+
+function extractAllToolResults2(context) {
+  const { results, stopIdx } = extractAllToolResults(context.messages);
+  debug(`extractAllToolResults: ${results.length} results from ${context.messages.length} msgs, stopped at index ${stopIdx}`);
+  debug(`extractAllToolResults: all msg roles:`, context.messages.map((m, i) => `[${i}]${m.role}`).join(" "));
+  for (let r = 0; r < results.length; r++) {
+    debug(`extractAllToolResults: result[${r}] id=${results[r].toolCallId}${results[r].isError ? " ERROR" : ""} preview:`, JSON.stringify(results[r].content).slice(0, 150));
+  }
+  return results;
+}
+
+function turnStart(messages) {
+  let i = messages.length;
+  while (i > 0 && messages[i - 1].role === "user") i--;
+  return i;
+}
+
+function extractUserPrompt(messages) {
+  const turn = messages.slice(turnStart(messages));
+  if (turn.length === 0) return null;
+  return turn.map((m) => typeof m.content === "string" ? m.content : messageContentToText(m.content)).filter((text) => text).join("\n");
+}
+
+function extractUserPromptBlocks(messages) {
+  const turn = messages.slice(turnStart(messages));
+  if (turn.length === 0) return null;
+  let hasImage = false;
+  const blocks = [];
+  for (const message of turn) {
+    const content = typeof message.content === "string" ? [{ type: "text", text: message.content }] : message.content;
+    if (!Array.isArray(content)) {
+      throw new Error(
+        `extractUserPromptBlocks: user message content must be a string or block array, got ${typeof content} \u2014 likely a malformed message from another extension`
+      );
+    }
+    for (const block of content) {
+      if (block.type === "text" && block.text) {
+        blocks.push({ type: "text", text: block.text });
+      } else if (block.type === "image") {
+        if (!block.data || !block.mimeType) {
+          debug(`image block missing data or mimeType, skipping: keys=${Object.keys(block).join(",")}`);
+          continue;
+        }
+        debug(`image block: mimeType=${block.mimeType}, data length=${block.data.length}`);
+        hasImage = true;
+        blocks.push({
+          type: "image",
+          source: {
+            type: "base64",
+            media_type: block.mimeType,
+            data: block.data
+          }
+        });
+      }
+    }
+  }
+  debug(`extractUserPromptBlocks: ${turn.length} msgs in turn, ${blocks.length} blocks, types=${blocks.map((b) => b.type).join(",")}`);
+  return hasImage ? blocks : null;
+}
+
+function newAssistantOutput(model, text, stopReason, errorMessage2) {
+  return {
+    role: "assistant",
+    content: text ? [{ type: "text", text }] : [],
+    api: model.api,
+    provider: model.provider,
+    model: model.id,
+    usage: {
+      input: 0,
+      output: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+      totalTokens: 0,
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+    },
+    stopReason,
+    ...errorMessage2 ? { errorMessage: errorMessage2 } : {},
+    timestamp: Date.now()
+  };
+}
+
+function extractStandalonePrompt(context) {
+  if (context.tools?.length) {
+    throw new Error(`standalone provider requests do not support tools (got ${context.tools.length})`);
+  }
+  const messages = context.messages;
+  if (messages.length !== 1 || messages[0].role !== "user") {
+    throw new Error(
+      `standalone provider request expected exactly 1 user message, got ${messages.length} (${messages.map((m) => m.role).join(",")})`
+    );
+  }
+  const promptText = extractUserPrompt(messages);
+  if (!promptText) throw new Error("standalone provider request prompt is empty");
+  return promptText;
+}
+
+function isStandaloneRequest(context, options) {
+  return options?.cacheRetention === "none" && context.tools === void 0 && context.messages.length === 1 && context.messages[0]?.role === "user";
+}
+
+function resultErrorText(message) {
+  const result = message;
+  if (result.subtype === "success") return result.is_error ? result.result || "Claude Code reported an error" : void 0;
+  if (Array.isArray(result.errors) && result.errors.length) return result.errors.map(String).join("\n");
+  if (typeof result.error === "string") return result.error;
+  return `Claude Code failed: ${result.subtype ?? "unknown result"}`;
+}
+
+function describeRateLimitFailure(rejection, failure) {
+  const kind = rejection.rateLimitType ? ` (${rejection.rateLimitType})` : "";
+  const resets = rejection.resetsAt ? ` \u2014 resets ${new Date(rejection.resetsAt * 1e3).toLocaleTimeString()}` : "";
+  return `Claude rate limit${kind}${resets}: ${failure}`;
+}
+
+function standaloneStreamFn(model, context, options) {
+  const stream = createAssistantMessageEventStream();
+  void runStandaloneRequest(model, context, options, stream);
+  return stream;
+}
+
+async function runStandaloneRequest(model, context, options, stream) {
+  let sdkQuery;
+  let wasAborted = false;
+  const onAbort = () => {
+    wasAborted = true;
+    void sdkQuery?.interrupt().catch(() => {
+    });
+    try {
+      sdkQuery?.close();
+    } catch {
+    }
+  };
+  try {
+    const promptText = extractStandalonePrompt(context);
+    const cwd = options?.cwd ?? process.cwd();
+    const standaloneProviderSettings = loadConfig(cwd).provider;
+    const claudeExecutableResolution = resolveClaudeCodeExecutable(model.id, standaloneProviderSettings?.pathToClaudeCodeExecutable);
+    if (claudeExecutableResolution.error) throw new Error(claudeExecutableResolution.error);
+    const claudeExecutable = claudeExecutableResolution.path;
+    const cliModel = claudeCodeModelId(model, longContextSettings);
+    const mapped = options?.reasoning ? model.thinkingLevelMap?.[options.reasoning] : void 0;
+    const effort = options?.reasoning ? mapped === void 0 ? REASONING_TO_EFFORT[options.reasoning] : VALID_EFFORTS.has(mapped) ? mapped : void 0 : void 0;
+    const extraArgs = {};
+    if (effort || adaptiveThinkingAlwaysOn(model.id)) extraArgs["thinking-display"] = "summarized";
+    debug(`standalone: spawn model=${cliModel} registeredModel=${model.id} promptLen=${promptText.length} effort=${effort ?? "default"}`);
+    const childEnv = await resolveClaudeChildEnv(piModelRegistry);
+    sdkQuery = query({
+      prompt: promptText,
+      options: {
+        cwd,
+        env: childEnv,
+        settings: { autoMemoryEnabled: false },
+        tools: [],
+        strictMcpConfig: true,
+        settingSources: [],
+        skills: [],
+        persistSession: false,
+        systemPrompt: context.systemPrompt,
+        model: cliModel,
+        maxTurns: 1,
+        extraArgs,
+        ...effort ? { effort } : {},
+        ...claudeExecutable ? { pathToClaudeCodeExecutable: claudeExecutable } : {},
+        ...makeCliDebugOptions("standalone")
+      }
+    });
+    if (options?.signal) {
+      if (options.signal.aborted) onAbort();
+      else options.signal.addEventListener("abort", onAbort, { once: true });
+    }
+    let assistantText = "";
+    let finalText = "";
+    let errorText;
+    let resultUsage;
+    let firstEventLogged = false;
+    for await (const message of sdkQuery) {
+      if (!firstEventLogged) {
+        debug(`standalone: first event type=${message.type}`);
+        firstEventLogged = true;
+      }
+      if (wasAborted) break;
+      if (message.type === "assistant") {
+        for (const block of message.message?.content ?? []) {
+          if (block.type === "text" && typeof block.text === "string") assistantText += block.text;
+        }
+      } else if (message.type === "result") {
+        logServedContextWindow("standalone", message, model);
+        errorText = resultErrorText(message);
+        resultUsage = message.usage;
+        if (!errorText && message.subtype === "success") finalText = message.result || assistantText;
+      }
+    }
+    if (wasAborted) {
+      const output2 = newAssistantOutput(model, "", "aborted", "Operation aborted");
+      debug("standalone: aborted");
+      stream.push({ type: "error", reason: "aborted", error: output2 });
+      stream.end();
+      return;
+    }
+    const text = finalText || assistantText;
+    if (errorText || !text.trim()) {
+      const msg = errorText ?? "Claude Code standalone request returned empty text";
+      debug(`standalone: error ${msg}`);
+      stream.push({ type: "error", reason: "error", error: newAssistantOutput(model, "", "error", msg) });
+      stream.end();
+      return;
+    }
+    const output = newAssistantOutput(model, text, "stop");
+    if (resultUsage) recordUsage(output, resultUsage, model);
+    debug(`standalone: done textLen=${text.length}`);
+    stream.push({ type: "done", reason: "stop", message: output });
+    stream.end();
+  } catch (err) {
+    const msg = errorMessage(err);
+    debug("runStandaloneRequest threw; pushing terminal error", err);
+    stream.push({ type: "error", reason: "error", error: newAssistantOutput(model, "", "error", msg) });
+    stream.end();
+  } finally {
+    options?.signal?.removeEventListener("abort", onAbort);
+    try {
+      sdkQuery?.close();
+    } catch {
+    }
+  }
+}
+
+function verifyWrittenSession2(jsonlPath, expectedSessionId, expectedRecordCount, cwd) {
+  const warnings = verifyWrittenSession(jsonlPath, expectedSessionId, expectedRecordCount);
+  for (const msg of warnings) {
+    debug(`WARNING session verify: ${msg}`);
+    piUI?.notify(
+      `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/pi-pod/pi-claude-agent-sdk/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 });
+  }
+}
+
+function safeRealpath(p) {
+  try {
+    return realpathSync(p);
+  } catch (e) {
+    return `<failed: ${e.message}>`;
+  }
+}
+
+function debugSessionPaths(label, cwd, jsonlPath) {
+  const realCwd = safeRealpath(cwd);
+  let fileSize = null;
+  let fileExists = false;
+  try {
+    const st = statSync2(jsonlPath);
+    fileExists = true;
+    fileSize = st.size;
+  } catch {
+  }
+  debug(`${label}: cwd=${cwd}`);
+  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)"}`);
+}
+
+function syncSharedSession(messages, cwd, customToolNameToSdk, modelId, piSessionId) {
+  const sharedSession = sessionStateFor(piSessionId);
+  const history = nonSystemMessages(messages);
+  const priorMessages = history.slice(0, turnStart(history));
+  if (sharedSession && !sharedSession.needsRebuild && priorMessages.length >= sharedSession.cursor) {
+    const missed = priorMessages.slice(sharedSession.cursor);
+    const trailingAssistantOnly = missed.length === 1 && missed[0].role === "assistant";
+    if (missed.length === 0 || trailingAssistantOnly) {
+      if (trailingAssistantOnly) {
+        setSessionStateFor(piSessionId, { ...sharedSession, cursor: priorMessages.length, cwd });
+        debug(`Case 3: advanced cursor past trailing assistant, resuming session ${sharedSession.sessionId.slice(0, 8)}, cursor=${priorMessages.length}`);
+      } else {
+        debug(`Case 3: resuming session ${sharedSession.sessionId.slice(0, 8)}, cursor=${sharedSession.cursor}`);
+      }
+      debug(`syncResult: path=reuse sessionId=${sharedSession.sessionId} cursor=${sharedSession?.cursor}`);
+      return { sessionId: sharedSession.sessionId };
+    }
+  }
+  if (sharedSession && !sharedSession.needsRebuild && priorMessages.length < sharedSession.cursor) {
+    debug(`Case 1 synthetic: clean start for shorter context, preserving shared session ${sharedSession.sessionId.slice(0, 8)}, cursor=${sharedSession.cursor}`);
+    debug(`syncResult: path=clean-start preserve-shared sessionId=${sharedSession.sessionId} cursor=${sharedSession.cursor}`);
+    return { sessionId: null, preserveSharedSession: true };
+  }
+  if (priorMessages.length === 0) {
+    debug(`Case 1: clean start, ${history.length} total messages`);
+    debug(`syncResult: path=clean-start`);
+    return { sessionId: null };
+  }
+  const previousSessionId = sharedSession?.sessionId;
+  const previousCursor = sharedSession?.cursor ?? 0;
+  const preserveId = previousSessionId !== void 0 && !sharedSession?.forceRotate;
+  const carried = previousSessionId !== void 0 ? readCarriedAttachments(previousSessionId, cwd) : [];
+  if (preserveId) {
+    deleteSession(previousSessionId, cwd, process.env.CLAUDE_CONFIG_DIR);
+  }
+  const session = createSession({
+    projectPath: cwd,
+    claudeDir: process.env.CLAUDE_CONFIG_DIR,
+    ...preserveId ? { sessionId: previousSessionId } : {},
+    ...modelId ? { model: modelId } : {}
+  });
+  convertAndImportMessages(session, priorMessages, customToolNameToSdk, carried, thinkingBoundToPrefix(modelId ?? ""));
+  session.save();
+  verifyWrittenSession2(session.jsonlPath, session.sessionId, session.records.length, cwd);
+  setSessionStateFor(piSessionId, { sessionId: session.sessionId, cursor: priorMessages.length, cwd, piSessionId: piSessionId ?? void 0 });
+  if (previousSessionId === void 0) {
+    debug(`Case 2: first turn with ${priorMessages.length} prior messages \u2192 session ${session.sessionId.slice(0, 8)}, ${session.records.length} records`);
+  } 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.records.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.records.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 };
+}
+
+var queryImpl = query;
+
+var __test = {
+  setQuery(fn) {
+    queryImpl = fn ?? query;
+  },
+  resetSharedSession(piSessionId) {
+    if (piSessionId === void 0) sharedSessions.clear();
+    else setSessionStateFor(piSessionId, null);
+    historyRewrittenBySession.clear();
+  },
+  markRebuildForSession,
+  getHistoryRewritten: () => historyRewrittenBySession.size > 0,
+  historyRewrittenBySession,
+  armStaleContexts,
+  discardRewrittenQuery,
+  contextForToolResults,
+  isQueryAbandoned: (q) => abandonedQueries.has(q),
+  get activeQueryContexts() {
+    return activeQueryContexts;
+  },
+  setSharedSession(piSessionId, state) {
+    setSessionStateFor(piSessionId, state);
+  },
+  getSharedSession(piSessionId = null) {
+    return sessionStateFor(piSessionId);
+  },
+  setPiModelRegistry(registry) {
+    piModelRegistry = registry;
+  },
+  setPiUI(ui) {
+    piUI = ui;
+  },
+  toBridgeContext,
+  syncSharedSession,
+  extractUserPromptBlocks,
+  consumeQuery,
+  finalizeCurrentStream,
+  resultErrorText,
+  deliverToolResults,
+  drainForAbort,
+  CC_CHILD_ENV,
+  buildMcpServers,
+  isStandaloneRequest,
+  extractStandalonePrompt,
+  get promptCaptures() {
+    return promptCaptures;
+  }
+};
+
+function piToolNameFor(name, customToolNameToPi) {
+  return customToolNameToPi.get(name) ?? customToolNameToPi.get(name.toLowerCase());
+}
+
+var SDK_KEY_RENAMES = {
+  read: { file_path: "path" },
+  write: { file_path: "path" },
+  edit: { file_path: "path", old_string: "oldText", new_string: "newText", old_text: "oldText", new_text: "newText" }
+};
+
+function mapToolArgs(toolName, args) {
+  const input = args ?? {};
+  const renames = SDK_KEY_RENAMES[toolName.toLowerCase()];
+  const result = {};
+  for (const [key, value] of Object.entries(input)) {
+    const piKey = renames?.[key] ?? key;
+    if (!(piKey in result)) result[piKey] = value;
+  }
+  if (toolName.toLowerCase() === "bash" && result.timeout == null) {
+    result.timeout = 120;
+  }
+  return result;
+}
+
+var piUI = null;
+
+var piMode = null;
+
+var piModelRegistry = null;
+
+var activeQueryContexts = /* @__PURE__ */ new Set();
+
+var pendingNotices = [];
+
+function showStartupNoticeOnce() {
+  if (pendingNotices.length === 0 || piMode !== "tui") return;
+  const notices = pendingNotices;
+  pendingNotices = [];
+  const path = markStartupNoticeShown();
+  const title = `\x1B[33mWelcome to pi-claude-agent-sdk\x1B[39m \u2014 settings live in ${path}`;
+  const bullets = [...notices, "This message only appears once. See README.md for more."].map((n) => `\u2022 ${n}`);
+  piUI?.notify([title, ...bullets, "\u2500".repeat(64)].join("\n"), "info");
+}
+
+var promptCaptures = sharedPromptCaptures((diagnostic) => {
+  const first = diagnostic.matches[0];
+  debug(
+    `prompt-capture: no match for ${diagnostic.systemPrompt.length}-char system prompt. ` + (first ? `closest known (${first.key.length}-char) shares its first ${first.firstDivergent} chars and diverges at offset ${first.firstDivergent}: ` + JSON.stringify(diagnostic.systemPrompt.slice(first.firstDivergent - 40, first.firstDivergent + 60)) : "no known captures to compare against.") + ` known keys=${diagnostic.matches.length}`
+  );
+});
+
+function reportLeaks(label) {
+  const pendingCalls = [...activeQueryContexts].reduce((n, c) => n + c.pendingToolCalls.size, 0);
+  const liveStreams = [...activeQueryContexts].filter((c) => c.promptStream !== null).length;
+  if (activeQueryContexts.size === 0 && pendingCalls === 0 && liveStreams === 0) return;
+  debug(
+    `WARNING: ${label} left state behind \u2014 contexts=${activeQueryContexts.size} pendingToolCalls=${pendingCalls} promptStreams=${liveStreams}`
+  );
+}
+
+function contextForToolResults(results) {
+  for (const result of results) {
+    const id = result.toolCallId;
+    if (!id) continue;
+    for (const queryCtx of activeQueryContexts) {
+      if (queryCtx.pendingToolCalls.has(id) || queryCtx.pendingResults.has(id) || queryCtx.turnToolCallIds.includes(id)) {
+        return queryCtx;
+      }
+    }
+  }
+  return void 0;
+}
+
+function resolveMcpTools(context) {
+  const mcpTools = [];
+  const customToolNameToSdk = /* @__PURE__ */ new Map();
+  const customToolNameToPi = /* @__PURE__ */ new Map();
+  if (!context.tools) return { mcpTools, customToolNameToSdk, customToolNameToPi };
+  for (const tool of context.tools) {
+    const sdkName = `${MCP_TOOL_PREFIX}${tool.name}`;
+    mcpTools.push(tool);
+    customToolNameToSdk.set(tool.name, sdkName);
+    customToolNameToSdk.set(tool.name.toLowerCase(), sdkName);
+    customToolNameToPi.set(sdkName, tool.name);
+    customToolNameToPi.set(sdkName.toLowerCase(), tool.name);
+  }
+  return { mcpTools, customToolNameToSdk, customToolNameToPi };
+}
+
+function buildMcpServers(tools, queryCtx) {
+  if (!tools.length) return void 0;
+  const mcpTools = tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    inputSchema: tool.parameters,
+    handler: async (toolCallId) => {
+      if (queryCtx.pendingResults.has(toolCallId)) {
+        const result = queryCtx.pendingResults.get(toolCallId);
+        queryCtx.pendingResults.delete(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`);
+      return new Promise((resolve) => {
+        queryCtx.pendingToolCalls.set(toolCallId, { toolName: tool.name, resolve });
+      });
+    }
+  }));
+  return { [MCP_SERVER_NAME]: createToolServer(MCP_SERVER_NAME, mcpTools) };
+}
+
+function recordUsage(output, usage, model) {
+  const { cachePct, reasoning } = updateUsage(output, usage, model);
+  const reasoningText = reasoning == null ? "" : ` reasoning=${reasoning}`;
+  debug(`usage: in=${output.usage.input} out=${output.usage.output} cacheRead=${output.usage.cacheRead} cacheWrite=${output.usage.cacheWrite} total=${output.usage.totalTokens}${reasoningText} cachePct=${cachePct}% model=${model.id}`);
+}
+
+function logServedContextWindow(label, message, model) {
+  const modelUsage = message.modelUsage;
+  if (!modelUsage) return;
+  for (const [k, v] of Object.entries(modelUsage)) {
+    debug(`${label}: served contextWindow=${v.contextWindow ?? "?"} maxOutputTokens=${v.maxOutputTokens ?? "?"} servedModel=${k} registered=${model.contextWindow}`);
+  }
+}
+
+var REASONING_TO_EFFORT = {
+  minimal: "low",
+  low: "low",
+  medium: "medium",
+  high: "high",
+  xhigh: "max"
+};
+
+var VALID_EFFORTS = /* @__PURE__ */ new Set(["low", "medium", "high", "xhigh", "max"]);
+
+function mapStopReason(reason) {
+  switch (reason) {
+    case "tool_use":
+      return "toolUse";
+    case "max_tokens":
+      return "length";
+    case "end_turn":
+    default:
+      return "stop";
+  }
+}
+
+function parsePartialJson(input, fallback) {
+  if (!input) return fallback;
+  try {
+    return JSON.parse(input);
+  } catch {
+    return fallback;
+  }
+}
+
+var completedStreams = /* @__PURE__ */ new WeakSet();
+
+function markStreamComplete(stream) {
+  if (stream) completedStreams.add(stream);
+}
+
+function claimCurrentPiStream(stream, label, c) {
+  if (c.currentPiStream && !completedStreams.has(c.currentPiStream)) {
+    debug(`WARNING: currentPiStream overwritten before terminal event (${label}); activeQuery=${Boolean(c.activeQuery)} pendingHandlers=${c.pendingToolCalls.size}`);
+  }
+  c.currentPiStream = stream;
+}
+
+function ensureTurnStarted(c) {
+  if (!c.turnStarted && c.currentPiStream && c.turnOutput) {
+    c.currentPiStream.push({ type: "start", partial: c.turnOutput });
+    c.turnStarted = true;
+  }
+}
+
+function finalizeCurrentStream(c, stopReason) {
+  if (!c.currentPiStream || !c.turnOutput) return;
+  debug(`provider: finalizeCurrentStream called, stopReason=${stopReason}, turnOutput=${JSON.stringify({ stopReason: c.turnOutput.stopReason, error: c.turnOutput.errorMessage })}`);
+  if (!c.turnStarted) ensureTurnStarted(c);
+  const stream = c.currentPiStream;
+  if (c.turnOutput.stopReason === "error") {
+    stream.push({ type: "error", reason: "error", error: c.turnOutput });
+  } else {
+    const reason = stopReason === "length" ? "length" : "stop";
+    stream.push({ type: "done", reason, message: c.turnOutput });
+  }
+  markStreamComplete(stream);
+  stream.end();
+  c.currentPiStream = null;
+}
+
+function processStreamEvent(message, customToolNameToPi, model, c) {
+  if (!c.currentPiStream || !c.turnOutput) return;
+  c.turnSawStreamEvent = true;
+  const event = message.event;
+  if (event?.type === "message_start") {
+    if (c.turnStreamOpen) dropAbandonedStreamBlocks(c, `restreamed as ${event.message?.id}`);
+    c.turnToolCallIds = [];
+    c.turnStreamMessageId = event.message?.id;
+    c.turnStreamOpen = true;
+    c.turnStreamBlockStart = c.turnBlocks.length;
+    if (event.message?.usage) recordUsage(c.turnOutput, event.message.usage, model);
+    return;
+  }
+  if (event?.type === "content_block_start") {
+    ensureTurnStarted(c);
+    if (event.content_block?.type === "text") {
+      c.turnBlocks.push({ type: "text", text: "", index: event.index });
+      c.currentPiStream.push({ type: "text_start", contentIndex: c.turnBlocks.length - 1, partial: c.turnOutput });
+    } else if (event.content_block?.type === "thinking") {
+      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 piName = piToolNameFor(event.content_block.name, customToolNameToPi);
+      if (!piName) {
+        debug(`processStreamEvent: skipping tool_use for unserved tool ${event.content_block.name} [${event.content_block.id}] \u2014 CC rejects it and retries`);
+        return;
+      }
+      c.turnSawToolCall = true;
+      c.turnToolCallIds.push(event.content_block.id);
+      c.turnBlocks.push({
+        type: "toolCall",
+        id: event.content_block.id,
+        name: piName,
+        arguments: event.content_block.input ?? {},
+        partialJson: "",
+        index: event.index
+      });
+      c.currentPiStream.push({ type: "toolcall_start", contentIndex: c.turnBlocks.length - 1, partial: c.turnOutput });
+    } else {
+      debug("processStreamEvent: unhandled content_block_start type", event.content_block?.type);
+    }
+    return;
+  }
+  if (event?.type === "content_block_delta") {
+    const index = c.turnBlocks.findIndex((b) => b.index === event.index);
+    const block = c.turnBlocks[index];
+    if (!block) return;
+    if (event.delta?.type === "text_delta" && block.type === "text") {
+      block.text += event.delta.text;
+      c.currentPiStream.push({ type: "text_delta", contentIndex: index, delta: event.delta.text, partial: c.turnOutput });
+    } else if (event.delta?.type === "thinking_delta" && block.type === "thinking") {
+      block.thinking += event.delta.thinking;
+      c.currentPiStream.push({ type: "thinking_delta", contentIndex: index, delta: event.delta.thinking, partial: c.turnOutput });
+    } else if (event.delta?.type === "input_json_delta" && block.type === "toolCall") {
+      block.partialJson += event.delta.partial_json;
+      block.arguments = parsePartialJson(block.partialJson, block.arguments);
+      c.currentPiStream.push({ type: "toolcall_delta", contentIndex: index, delta: event.delta.partial_json, partial: c.turnOutput });
+    } else if (event.delta?.type === "signature_delta" && block.type === "thinking") {
+      block.thinkingSignature = (block.thinkingSignature ?? "") + event.delta.signature;
+    } else {
+      debug("processStreamEvent: unhandled content_block_delta type", event.delta?.type);
+    }
+    return;
+  }
+  if (event?.type === "content_block_stop") {
+    const index = c.turnBlocks.findIndex((b) => b.index === event.index);
+    const block = c.turnBlocks[index];
+    if (!block) return;
+    delete block.index;
+    if (block.type === "text") {
+      c.currentPiStream.push({ type: "text_end", contentIndex: index, content: block.text, partial: c.turnOutput });
+    } else if (block.type === "thinking") {
+      c.currentPiStream.push({ type: "thinking_end", contentIndex: index, content: block.thinking, partial: c.turnOutput });
+    } else if (block.type === "toolCall") {
+      c.turnSawToolCall = true;
+      block.arguments = mapToolArgs(
+        block.name,
+        parsePartialJson(block.partialJson, block.arguments)
+      );
+      delete block.partialJson;
+      c.currentPiStream.push({ type: "toolcall_end", contentIndex: index, toolCall: block, partial: c.turnOutput });
+    }
+    return;
+  }
+  if (event?.type === "message_delta") {
+    c.turnOutput.stopReason = mapStopReason(event.delta?.stop_reason);
+    if (event.usage) recordUsage(c.turnOutput, event.usage, model);
+    return;
+  }
+  if (event?.type === "message_stop") c.turnStreamOpen = false;
+  if (event?.type === "message_stop" && c.turnSawToolCall) {
+    c.turnOutput.stopReason = "toolUse";
+    const stream = c.currentPiStream;
+    stream.push({ type: "done", reason: "toolUse", message: c.turnOutput });
+    markStreamComplete(stream);
+    stream.end();
+    c.currentPiStream = null;
+    return;
+  }
+  if (event?.type !== "message_stop" && event?.type !== "ping") {
+    debug("processStreamEvent: unhandled event type", event?.type);
+  }
+}
+
+function dropAbandonedStreamBlocks(c, why) {
+  const dropped = c.turnBlocks.splice(c.turnStreamBlockStart);
+  debug(`dropAbandonedStreamBlocks: ${why}; dropped ${dropped.length} blocks from ${c.turnStreamMessageId} types=${dropped.map((b) => b.type).join(",")}`);
+  c.turnToolCallIds = [];
+  c.turnSawToolCall = c.turnBlocks.some((b) => b.type === "toolCall");
+  c.turnStreamOpen = false;
+}
+
+function processAssistantMessage(message, model, customToolNameToPi, c) {
+  const assistantMsg = message.message;
+  if (!assistantMsg?.content) return;
+  if (c.turnSawStreamEvent) {
+    const id = assistantMsg.id;
+    if (!id || !c.turnStreamMessageId || id === c.turnStreamMessageId) return;
+    if (c.turnStreamOpen) dropAbandonedStreamBlocks(c, `non-streaming fallback ${id}`);
+  }
+  c.turnToolCallIds = [];
+  debug(`processAssistantMessage fallback: ${assistantMsg.content.length} blocks, types=${assistantMsg.content.map((b) => b.type).join(",")}`);
+  for (const block of assistantMsg.content) {
+    if (block.type === "text" && block.text) {
+      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 });
+      c.currentPiStream?.push({ type: "text_delta", contentIndex: idx, delta: block.text, partial: c.turnOutput });
+      c.currentPiStream?.push({ type: "text_end", contentIndex: idx, content: block.text, partial: c.turnOutput });
+    } else if (block.type === "thinking") {
+      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 });
+      if (block.thinking) c.currentPiStream?.push({ type: "thinking_delta", contentIndex: idx, delta: block.thinking, partial: c.turnOutput });
+      c.currentPiStream?.push({ type: "thinking_end", contentIndex: idx, content: block.thinking ?? "", partial: c.turnOutput });
+    } else if (block.type === "tool_use") {
+      const piName = piToolNameFor(block.name, customToolNameToPi);
+      if (!piName) {
+        debug(`processAssistantMessage: skipping tool_use for unserved tool ${block.name} [${block.id}] \u2014 CC rejects it and retries`);
+        continue;
+      }
+      ensureTurnStarted(c);
+      c.turnSawToolCall = true;
+      c.turnToolCallIds.push(block.id);
+      c.turnBlocks.push({
+        type: "toolCall",
+        id: block.id,
+        name: piName,
+        arguments: mapToolArgs(piName, block.input)
+      });
+      const idx = c.turnBlocks.length - 1;
+      const toolBlock = c.turnBlocks[idx];
+      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 {
+      debug("processAssistantMessage: unhandled block type", block.type);
+    }
+  }
+  if (assistantMsg.usage && c.turnOutput) recordUsage(c.turnOutput, assistantMsg.usage, model);
+  if (c.turnSawToolCall && c.currentPiStream && c.turnOutput) {
+    c.turnOutput.stopReason = "toolUse";
+    const stream = c.currentPiStream;
+    stream.push({ type: "done", reason: "toolUse", message: c.turnOutput });
+    markStreamComplete(stream);
+    stream.end();
+    c.currentPiStream = null;
+  }
+}
+
+async function consumeQuery(sdkQuery, customToolNameToPi, model, wasAborted, queryCtx) {
+  let capturedSessionId;
+  for await (const message of sdkQuery) {
+    if (RECORD_STREAM_PATH) appendFileSync(RECORD_STREAM_PATH, `${JSON.stringify(message)}
+`);
+    if (wasAborted()) break;
+    let resultError;
+    if (message.type === "result") {
+      queryCtx.promptStream?.end();
+      logServedContextWindow("result", message, model);
+      resultError = resultErrorText(message);
+      if (resultError !== void 0) {
+        if (queryCtx.rateLimitRejection) {
+          resultError = describeRateLimitFailure(queryCtx.rateLimitRejection, resultError);
+          queryCtx.rateLimitRejection = null;
+        }
+        debug(`consumeQuery: error result, subtype=${message.subtype}, error=${resultError}`);
+        if (queryCtx.turnOutput) {
+          queryCtx.turnOutput.stopReason = "error";
+          queryCtx.turnOutput.errorMessage = resultError;
+        }
+      }
+    }
+    if (message.type === "rate_limit_event") {
+      const info = message.rate_limit_info;
+      debug("consumeQuery: rate_limit_event", JSON.stringify(info).slice(0, 300));
+      if (info?.status === "rejected") {
+        queryCtx.rateLimitRejection = info;
+        queryCtx.lastRateLimitWarnStep = null;
+        queryCtx.lastRateLimitWarnThreshold = void 0;
+        const resetsAt = info.resetsAt ? new Date(info.resetsAt * 1e3).toLocaleTimeString() : "unknown";
+        piUI?.notify(`Claude rate limited (${info.rateLimitType ?? "unknown"}) \u2014 resets at ${resetsAt}`, "warning");
+      } else if (info?.status === "allowed") {
+        queryCtx.lastRateLimitWarnStep = null;
+        queryCtx.lastRateLimitWarnThreshold = void 0;
+      } else if (info?.status === "allowed_warning") {
+        const percent = Math.round((info.utilization ?? 0) * 100);
+        const step = Math.floor(percent / 5);
+        const rose = queryCtx.lastRateLimitWarnStep === null || step > queryCtx.lastRateLimitWarnStep;
+        if (rose || info.surpassedThreshold !== queryCtx.lastRateLimitWarnThreshold) {
+          queryCtx.lastRateLimitWarnStep = step;
+          queryCtx.lastRateLimitWarnThreshold = info.surpassedThreshold;
+          piUI?.notify(`Claude rate limit warning: ${percent}% used (${info.rateLimitType ?? ""})`, "warning");
+        }
+      }
+      continue;
+    }
+    if (!queryCtx.currentPiStream || !queryCtx.turnOutput) continue;
+    switch (message.type) {
+      case "stream_event":
+        processStreamEvent(message, customToolNameToPi, model, queryCtx);
+        break;
+      case "assistant":
+        processAssistantMessage(message, model, customToolNameToPi, queryCtx);
+        break;
+      case "result": {
+        if (resultError === void 0 && !queryCtx.turnSawStreamEvent && message.subtype === "success") {
+          ensureTurnStarted(queryCtx);
+          const text = message.result || "";
+          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 });
+        }
+        break;
+      }
+      case "system":
+        if (message.subtype === "init" && message.session_id) {
+          capturedSessionId = message.session_id;
+        }
+        break;
+      case "user":
+        break;
+      default:
+        debug("consumeQuery: unhandled SDK message type", message.type);
+        break;
+    }
+  }
+  debug(`consumeQuery: for-await loop exited, wasAborted=${wasAborted()}, capturedSessionId=${capturedSessionId?.slice(0, 8) ?? "none"}`);
+  return { capturedSessionId };
+}
+
+function steerBlocks(messages) {
+  const blocks = extractUserPromptBlocks(messages);
+  if (blocks) return blocks;
+  const text = extractUserPrompt(messages);
+  return text ? [{ type: "text", text }] : null;
+}
+
+function steerMissedSession(c, text) {
+  c.missedSteer = true;
+  const state = sessionStateFor(c.piSessionId);
+  if (state) setSessionStateFor(c.piSessionId, { ...state, needsRebuild: true });
+  debug(`provider: steer never reached CC, marked query for rebuild: ${text.slice(0, 60)}`);
+}
+
+async function deliverToolResults(c, results, steer, contextLength) {
+  if (steer) {
+    const text = steer.map((b) => b.type === "text" ? b.text : "[image]").join("\n");
+    if (!c.promptStream) {
+      debug(`WARNING: steer with no prompt stream, dropping: ${text.slice(0, 60)}`);
+      steerMissedSession(c, text);
+    } else {
+      try {
+        await c.promptStream.push(userMessage(steer, "next"));
+        debug(`provider: steer written to CC stdin before tool result: ${text.slice(0, 60)}`);
+      } catch (error) {
+        debug(`provider: steer push rejected, delivering tool result anyway:`, error);
+        steerMissedSession(c, text);
+      }
+    }
+  }
+  debug(`provider: tool results, ${results.length} results, ${c.pendingToolCalls.size} waiting handlers, ctx.msgs=${contextLength}`);
+  for (const result of results) {
+    const id = result.toolCallId;
+    if (id && c.pendingToolCalls.has(id)) {
+      const pending = c.pendingToolCalls.get(id);
+      c.pendingToolCalls.delete(id);
+      debug(`provider: resolving ${pending.toolName} [${id}]${result.isError ? " (error)" : ""}`, JSON.stringify(result.content).slice(0, 200));
+      pending.resolve(result);
+    } else if (id) {
+      c.pendingResults.set(id, result);
+      debug(`provider: queued result [${id}] (${c.pendingResults.size} pending)`);
+    } else {
+      debug(`WARNING: tool result without toolCallId, cannot match`);
+    }
+    if (c.pendingToolCalls.size > 0 && c.pendingResults.size > 0) {
+      debug(`BUG: both maps non-empty! handlers=${c.pendingToolCalls.size} results=${c.pendingResults.size}`);
+    }
+  }
+  if (c.pendingToolCalls.size > 0) {
+    debug(`WARNING: ${c.pendingToolCalls.size} MCP handlers still waiting after delivering ${results.length} results`);
+    piUI?.notify(`pi-claude-agent-sdk: ${c.pendingToolCalls.size} tool handler(s) still waiting \u2014 provider may be stuck`, "warning");
+  }
+}
+
+function drainForAbort(c, promptStream) {
+  promptStream.fail(new Error("Operation aborted"));
+  c.releasePendingToolCalls("Operation aborted");
+}
+
+var abandonedQueries = /* @__PURE__ */ new WeakSet();
+
+var CONTINUE_AFTER_REWRITE_PROMPT = "[Your context was compacted. What precedes this is a summary plus the most recent messages, ending with the tool result you were waiting for. Continue the task from there.]";
+
+function discardRewrittenQuery(c) {
+  const discarded = c.activeQuery;
+  if (discarded) abandonedQueries.add(discarded);
+  c.activeQuery = null;
+  activeQueryContexts.delete(c);
+  c.turnToolCallIds = [];
+  c.promptStream?.fail(new Error("conversation rewritten"));
+  c.promptStream = null;
+  c.releasePendingToolCalls("Context was compacted; this query was discarded.");
+  void discarded?.interrupt?.().catch(() => {
+  });
+  try {
+    discarded?.close?.();
+  } catch {
+  }
+  const state = sessionStateFor(c.piSessionId);
+  if (state) setSessionStateFor(c.piSessionId, { ...state, needsRebuild: true, forceRotate: true });
+  if (c.piSessionId) historyRewrittenBySession.delete(c.piSessionId);
+  debug("provider: history rewritten under a parked query \u2014 discarded it, rebuilding from current history");
+}
+
+function streamClaudeAgentSdk(model, context, options) {
+  context = toBridgeContext(context);
+  if (isStandaloneRequest(context, options)) {
+    debug("provider: routing standalone cacheRetention=none request to isolated subprocess");
+    return standaloneStreamFn(model, context, options);
+  }
+  showStartupNoticeOnce();
+  const stream = createAssistantMessageEventStream();
+  const lastMsgRole = context.messages[context.messages.length - 1]?.role;
+  debug(`provider: streamClaudeAgentSdk called, activeQuery=${!!ctx().activeQuery}, lastMsgRole=${lastMsgRole}, isReentrant=${ctx().activeQuery !== null}`);
+  let activeQuery = ctx().activeQuery !== null;
+  const allResults = activeQueryContexts.size > 0 ? extractAllToolResults2(context) : [];
+  let resultCtx = allResults.length > 0 ? contextForToolResults(allResults) : void 0;
+  const rewrittenUnderQuery = Boolean(resultCtx?.historyStale);
+  if (resultCtx && rewrittenUnderQuery) {
+    discardRewrittenQuery(resultCtx);
+    resultCtx = void 0;
+    activeQuery = ctx().activeQuery !== null;
+  }
+  const isReentrantUserQuery = activeQuery && lastMsgRole === "user" && allResults.length === 0;
+  if (isReentrantUserQuery) {
+    debug(`provider: active query user-only call treated as reentrant fresh query, waitingHandlers=${ctx().pendingToolCalls.size}, ctx.msgs=${context.messages.length}`);
+  }
+  if (resultCtx) {
+    claimCurrentPiStream(stream, "tool-result", resultCtx);
+    resultCtx.resetTurnState(model);
+    if (!resultCtx.historyStale && resultCtx.piSessionId && historyRewrittenBySession.has(resultCtx.piSessionId)) {
+      resultCtx.historyStale = true;
+    }
+    const steer = lastMsgRole === "user" ? steerBlocks(context.messages) : null;
+    void deliverToolResults(resultCtx, allResults, steer, context.messages.length);
+    const state = sessionStateFor(resultCtx.piSessionId);
+    if (state) state.cursor = context.messages.length;
+    resultCtx.latestCursor = Math.max(resultCtx.latestCursor, context.messages.length);
+    return stream;
+  }
+  const lastMsg = context.messages[context.messages.length - 1];
+  if (lastMsg?.role === "toolResult" && !rewrittenUnderQuery) {
+    debug(`provider: orphaned tool result after abort, emitting end_turn`);
+    const orphanState = sessionStateFor(options?.sessionId ?? null);
+    if (orphanState && activeQueryContexts.size === 0) orphanState.cursor = context.messages.length;
+    const c = new QueryContext();
+    c.resetTurnState(model);
+    queueMicrotask(() => {
+      stream.push({ type: "done", reason: "stop", message: c.turnOutput });
+      markStreamComplete(stream);
+      stream.end();
+    });
+    return stream;
+  }
+  const isReentrant = activeQuery;
+  const queryCtx = isReentrant ? new QueryContext() : ctx();
+  debug(`provider: fresh query setup, isReentrant=${isReentrant}, activeContexts=${activeQueryContexts.size}`);
+  const claudeExecutableResolution = resolveClaudeCodeExecutable(model.id, providerSettings.pathToClaudeCodeExecutable);
+  if (claudeExecutableResolution.error) {
+    stream.push({ type: "error", reason: "error", error: newAssistantOutput(model, "", "error", claudeExecutableResolution.error) });
+    stream.end();
+    return stream;
+  }
+  const claudeExecutable = claudeExecutableResolution.path;
+  const { mcpTools, customToolNameToSdk, customToolNameToPi } = resolveMcpTools(context);
+  let promptCapture;
+  let systemPromptAppend;
+  try {
+    promptCapture = promptCaptures.resolveOrDerive(context.systemPrompt);
+    systemPromptAppend = promptCapture ? projectPromptCapture(promptCapture, {
+      skillReadTool: mcpTools.some((tool) => tool.name === "read") ? "mcp" : "none"
+    }) : void 0;
+  } catch (err) {
+    const output = newAssistantOutput(model, "", "error", errorMessage(err));
+    queueMicrotask(() => {
+      stream.push({ type: "error", reason: "error", error: output });
+      markStreamComplete(stream);
+      stream.end();
+    });
+    diagDump("prompt_capture_unresolved", {
+      promptChars: context.systemPrompt?.length ?? 0,
+      knownKeys: promptCaptures.size,
+      reentrantUserQuery: isReentrantUserQuery,
+      error: errorMessage(err)
+    });
+    return stream;
+  }
+  claimCurrentPiStream(stream, "fresh-query", queryCtx);
+  queryCtx.pendingToolCalls.clear();
+  queryCtx.pendingResults.clear();
+  queryCtx.turnToolCallIds = [];
+  queryCtx.resetTurnState(model);
+  queryCtx.latestCursor = 0;
+  queryCtx.piSessionId = options?.sessionId ?? null;
+  queryCtx.historyStale = false;
+  queryCtx.missedSteer = false;
+  const cwd = options?.cwd ?? process.cwd();
+  const cliModel = claudeCodeModelId(model, longContextSettings);
+  const piSessionId = options?.sessionId ?? null;
+  const syncResult = syncSharedSession(context.messages, cwd, customToolNameToSdk, cliModel, piSessionId);
+  if (piSessionId) historyRewrittenBySession.delete(piSessionId);
+  const { sessionId: resumeSessionId } = syncResult;
+  const promptBlocks = extractUserPromptBlocks(context.messages);
+  let promptText = extractUserPrompt(context.messages) ?? "";
+  if (rewrittenUnderQuery && !promptText && !promptBlocks) {
+    promptText = CONTINUE_AFTER_REWRITE_PROMPT;
+    debug(`provider: continuing the turn after a rewritten history, ${context.messages.length} msgs rebuilt`);
+  }
+  if (!promptText && !promptBlocks) {
+    diagDump("empty_prompt", {
+      contextLength: context.messages.length,
+      lastMsgRole: lastMsg?.role,
+      isReentrant,
+      activeQueryContexts: activeQueryContexts.size,
+      activeQueryExists: queryCtx.activeQuery !== null,
+      sharedSession: sessionStateFor(piSessionId) ? { sessionId: sessionStateFor(piSessionId).sessionId.slice(0, 8), cursor: sessionStateFor(piSessionId).cursor } : sessionStateFor(null) ? { sessionId: sessionStateFor(null).sessionId.slice(0, 8), cursor: sessionStateFor(null).cursor } : null,
+      messageRoles: context.messages.map((m, i) => `[${i}]${m.role}`).join(" ")
+    });
+    promptText = "[continue]";
+  }
+  const promptStream = makePromptStream();
+  void promptStream.push(userMessage(promptBlocks ?? [{ type: "text", text: promptText }])).catch((error) => debug(`provider: initial prompt push rejected:`, error));
+  queryCtx.promptStream = promptStream;
+  const mcpServers = buildMcpServers(mcpTools, queryCtx);
+  const strictMcpConfigEnabled = providerSettings.strictMcpConfig !== false;
+  const mapped = options?.reasoning ? model.thinkingLevelMap?.[options.reasoning] : void 0;
+  const effort = options?.reasoning ? mapped === void 0 ? REASONING_TO_EFFORT[options.reasoning] : VALID_EFFORTS.has(mapped) ? mapped : void 0 : void 0;
+  const extraArgs = { model: cliModel };
+  if (strictMcpConfigEnabled) extraArgs["strict-mcp-config"] = null;
+  if (effort || adaptiveThinkingAlwaysOn(model.id)) extraArgs["thinking-display"] = "summarized";
+  const queryOptions = {
+    cwd,
+    tools: [],
+    permissionMode: "bypassPermissions",
+    includePartialMessages: true,
+    // includeGitInstructions:false drops the gitStatus block from the preset.
+    // That block is the trailing suffix of the cached system block, and a
+    // git-state transition (new file, staging, commit) rewrites it — busting
+    // the prompt cache for the whole conversation from there on (see
+    // diag/probe-git-cache.mjs). The bridge re-invokes CC per turn, so this
+    // hit on every transition. Cost here is nil: the setting also strips
+    // CC's git-workflow guidance from its Bash tool prompt, but the provider
+    // path runs CC with `tools: []`, so those definitions never ship.
+    settings: {
+      ...claudeCodeSettings(providerSettings),
+      claudeMdExcludes: CLAUDE_MD_EXCLUDES,
+      includeGitInstructions: false
+    },
+    systemPrompt: {
+      type: "preset",
+      preset: "claude_code",
+      append: systemPromptAppend ? systemPromptAppend : void 0
+    },
+    extraArgs,
+    ...effort ? { effort } : {},
+    ...mcpServers ? { mcpServers } : {},
+    ...resumeSessionId ? { resume: resumeSessionId } : {},
+    ...claudeExecutable ? { pathToClaudeCodeExecutable: claudeExecutable } : {},
+    ...makeCliDebugOptions("provider")
+  };
+  debug(
+    "provider: fresh query",
+    `model=${cliModel} msgs=${context.messages.length} tools=${mcpTools.length}`,
+    `resume=${resumeSessionId?.slice(0, 8) ?? "none"} effort=${effort ?? "default"}`,
+    `ctxFiles=${promptCapture?.contextFiles.length ?? 0} strictMcp=${strictMcpConfigEnabled}`,
+    `prompt=${promptText.slice(0, 60)}${promptBlocks ? " [+images]" : ""}`
+  );
+  let wasAborted = false;
+  let sdkQuery = null;
+  const authPending = { kind: "claude-auth-pending" };
+  queryCtx.activeQuery = authPending;
+  const abortCtx = queryCtx;
+  const requestAbort = () => {
+    void sdkQuery?.interrupt().catch(() => {
+    });
+    try {
+      sdkQuery?.close();
+    } catch {
+    }
+  };
+  const onAbort = () => {
+    wasAborted = true;
+    drainForAbort(abortCtx, promptStream);
+    requestAbort();
+  };
+  if (options?.signal) {
+    if (options.signal.aborted) onAbort();
+    else options.signal.addEventListener("abort", onAbort, { once: true });
+  }
+  void (async () => {
+    queryOptions.env = await resolveClaudeChildEnv(piModelRegistry);
+    if (wasAborted || options?.signal?.aborted) throw new Error("Operation aborted");
+    const startedQuery = queryImpl({ prompt: promptStream.stream, options: queryOptions });
+    sdkQuery = startedQuery;
+    queryCtx.activeQuery = startedQuery;
+    activeQueryContexts.add(queryCtx);
+    if (wasAborted || options?.signal?.aborted) {
+      requestAbort();
+      throw new Error("Operation aborted");
+    }
+    const { capturedSessionId } = await consumeQuery(startedQuery, customToolNameToPi, model, () => wasAborted, queryCtx);
+    debug(`provider: consumeQuery completed, stopReason=${queryCtx.turnOutput?.stopReason}, error=${queryCtx.turnOutput?.errorMessage}, aborted=${wasAborted}`);
+    if (abandonedQueries.has(sdkQuery)) {
+      debug("provider: discarded query completed, leaving session and stream to its replacement");
+      return;
+    }
+    if (wasAborted || options?.signal?.aborted) {
+      const state = sessionStateFor(queryCtx.piSessionId);
+      if (state) setSessionStateFor(queryCtx.piSessionId, { ...state, needsRebuild: true, forceRotate: true });
+      debug(`provider: abort detected, marked sharedSession needsRebuild + forceRotate`);
+      if (queryCtx.turnOutput) {
+        queryCtx.turnOutput.stopReason = "aborted";
+        queryCtx.turnOutput.errorMessage = "Operation aborted";
+      }
+      const stream2 = queryCtx.currentPiStream;
+      stream2?.push({ type: "error", reason: "aborted", error: queryCtx.turnOutput });
+      markStreamComplete(stream2);
+      stream2?.end();
+      queryCtx.currentPiStream = null;
+      return;
+    }
+    if (syncResult.preserveSharedSession) {
+      const state = sessionStateFor(queryCtx.piSessionId);
+      if (capturedSessionId && capturedSessionId !== state?.sessionId) {
+        deleteSession(capturedSessionId, cwd, process.env.CLAUDE_CONFIG_DIR);
+        debug(`provider: query done, deleted ephemeral session ${capturedSessionId.slice(0, 8)} to preserve shared session`);
+      }
+      debug(`provider: query done, ignoring captured session ${capturedSessionId?.slice(0, 8) ?? "none"} to preserve shared session`);
+    } else {
+      const state = sessionStateFor(queryCtx.piSessionId);
+      const sessionId = capturedSessionId ?? state?.sessionId;
+      if (sessionId) {
+        const cursor = Math.max(context.messages.length, queryCtx.latestCursor, state?.cursor ?? 0);
+        debug(`provider: query done, session=${sessionId.slice(0, 8)}, cursor=${cursor}`);
+        setSessionStateFor(queryCtx.piSessionId, { ...state, sessionId, cursor, cwd, piSessionId: queryCtx.piSessionId ?? void 0, needsRebuild: queryCtx.missedSteer || state?.needsRebuild });
+      }
+    }
+    if (!isReentrant && queryCtx.activeQuery === sdkQuery) {
+      debug("provider: clearing activeQuery before final stream completion");
+      queryCtx.activeQuery = null;
+    }
+    finalizeCurrentStream(queryCtx, queryCtx.turnOutput?.stopReason);
+  })().catch((error) => {
+    debug(`provider: query error, model=${cliModel}, aborted=${Boolean(options?.signal?.aborted)}, error=`, error);
+    if (sdkQuery && abandonedQueries.has(sdkQuery)) {
+      debug("provider: discarded query ended in error, leaving session and stream to its replacement");
+      return;
+    }
+    if (wasAborted || options?.signal?.aborted) {
+      const state = sessionStateFor(queryCtx.piSessionId);
+      if (state) setSessionStateFor(queryCtx.piSessionId, { ...state, needsRebuild: true, forceRotate: true });
+    } else if (sdkQuery) {
+      setSessionStateFor(queryCtx.piSessionId, null);
+    }
+    promptStream.fail(error instanceof Error ? error : new Error(String(error)));
+    if (queryCtx.turnOutput) {
+      queryCtx.turnOutput.stopReason = options?.signal?.aborted ? "aborted" : "error";
+      queryCtx.turnOutput.errorMessage ??= error instanceof Error ? error.message : String(error);
+    }
+    if (!isReentrant && queryCtx.activeQuery === sdkQuery) {
+      queryCtx.releasePendingToolCalls("Query ended");
+      debug("provider: clearing activeQuery before error stream completion");
+      queryCtx.activeQuery = null;
+    }
+    const stream2 = queryCtx.currentPiStream;
+    stream2?.push({ type: "error", reason: queryCtx.turnOutput?.stopReason ?? "error", error: queryCtx.turnOutput });
+    markStreamComplete(stream2);
+    stream2?.end();
+    queryCtx.currentPiStream = null;
+  }).finally(() => {
+    if (options?.signal) options.signal.removeEventListener("abort", onAbort);
+    promptStream.fail(new Error("query ended"));
+    if (queryCtx.promptStream === promptStream) queryCtx.promptStream = null;
+    if (queryCtx.activeQuery === authPending || queryCtx.activeQuery === sdkQuery || queryCtx.activeQuery === null) {
+      queryCtx.releasePendingToolCalls("Query ended");
+      queryCtx.activeQuery = null;
+      activeQueryContexts.delete(queryCtx);
+    }
+    try {
+      sdkQuery?.close();
+    } catch {
+    }
+  });
+  return stream;
+}
+
+function index_default(pi) {
+  process.env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = "1";
+  const config = loadConfig(process.cwd());
+  debug("loadConfig:", JSON.stringify(config));
+  providerSettings = config.provider ?? {};
+  const forceTwoHundredK = Array.isArray(providerSettings.forceTwoHundredK) ? providerSettings.forceTwoHundredK.filter((id) => typeof id === "string") : void 0;
+  longContextSettings = {
+    plan: providerSettings.plan ?? "max",
+    longContextExtraUsage: providerSettings.longContextExtraUsage ?? false,
+    forceTwoHundredK
+  };
+  const registeredModels = applyLongContext(MODELS, longContextSettings);
+  if (registeredModels.length === 0) {
+    console.error("claude-bridge: no models available from pi-ai's anthropic catalog \u2014 update @earendil-works/pi-ai (requires >=0.86.1)");
+  }
+  if (!config.startupNoticeShown) {
+    if (config.provider?.plan === void 0) pendingNotices.push('Assuming a Max plan. On Pro, set provider.plan to "pro" so Opus 4.6 stays at 200K context.');
+  }
+  const clearSession = (event) => {
+    debug(`${event}: clearing ${sharedSessions.size} shared session${sharedSessions.size === 1 ? "" : "s"}`);
+    sharedSessions.clear();
+    historyRewrittenBySession.clear();
+    const g2 = bridgeGlobals;
+    if (g2[ACTIVE_STREAM_SIMPLE_KEY] === streamClaudeAgentSdk) {
+      debug(`${event}: clearing ACTIVE_STREAM_SIMPLE_KEY`);
+      g2[ACTIVE_STREAM_SIMPLE_KEY] = void 0;
+    }
+  };
+  pi.on("session_start", (event, ctx2) => {
+    piUI = ctx2.ui;
+    piMode = ctx2.mode;
+    piModelRegistry = ctx2.modelRegistry;
+    if (event.reason === "new" || event.reason === "resume" || event.reason === "fork") {
+      clearSession(`session_start:${event.reason}`);
+    }
+  });
+  let lastSystemPromptOptions;
+  function recordSystemPrompt(source, systemPrompt, options) {
+    if (!systemPrompt) return;
+    const hasRead = !options?.selectedTools || options.selectedTools.includes("read");
+    promptCaptures.record(systemPrompt, {
+      custom: options?.customPrompt,
+      append: options?.appendSystemPrompt,
+      contextFiles: options?.contextFiles ?? [],
+      skills: hasRead ? options?.skills ?? [] : []
+    }, source);
+  }
+  pi.on("before_agent_start", (event) => {
+    lastSystemPromptOptions = event.systemPromptOptions;
+    recordSystemPrompt("before_agent_start", event.systemPrompt, event.systemPromptOptions);
+  });
+  pi.on("agent_start", (_event, ctx2) => {
+    recordSystemPrompt("agent_start", ctx2.getSystemPrompt(), lastSystemPromptOptions);
+  });
+  pi.on("turn_start", (_event, ctx2) => {
+    recordSystemPrompt("turn_start", ctx2.getSystemPrompt(), lastSystemPromptOptions);
+  });
+  pi.on("session_shutdown", () => {
+    reportLeaks("session_shutdown");
+    clearSession("session_shutdown");
+  });
+  pi.on("session_compact", (event, ctx2) => sponsorMarkRebuildForSession(ctx2.sessionManager.getSessionId(), `session_compact:${event.reason}:willRetry=${event.willRetry}`));
+  pi.on("session_tree", (_event, ctx2) => sponsorMarkRebuildForSession(ctx2.sessionManager.getSessionId(), "session_tree"));
+  const g = bridgeGlobals;
+  const providerConfig = {
+    baseUrl: "claude-bridge",
+    apiKey: "not-used",
+    api: "claude-bridge",
+    models: registeredModels,
+    // Cast: the Provider interface passes a TranscriptContext; the bridge takes plain
+    // Context models (toBridgeContext normalizes at the stream entry points).
+    streamSimple: streamClaudeAgentSdk
+  };
+  if (!g[ACTIVE_STREAM_SIMPLE_KEY]) {
+    g[ACTIVE_STREAM_SIMPLE_KEY] = streamClaudeAgentSdk;
+    pi.registerProvider(PROVIDER_ID, providerConfig);
+  } else {
+    debug(`provider: deferring registration decision to session_start (module=${moduleInstanceId})`);
+    pi.on("session_start", (_event, ctx2) => {
+      if (ctx2.modelRegistry.getProvider(PROVIDER_ID)) {
+        debug(`provider: registry already has ${PROVIDER_ID}, skipping registration (module=${moduleInstanceId})`);
+        return;
+      }
+      debug(`provider: registry lacks ${PROVIDER_ID}, registering (module=${moduleInstanceId})`);
+      pi.registerProvider(PROVIDER_ID, providerConfig);
+    });
+  }
+}
+if (queryImplementation) __test.setQuery(queryImplementation);
+return index_default;
+}