@letrquan/book 0.2.0

package/dist/chunk-J7MIZ5CA.js

@@ -0,0 +1,1907 @@
+import {
+  AgentSession,
+  reviewReportJson,
+  reviewRunnerFor,
+  runHostReview,
+  toElicitationFields,
+  validateElicitationContent
+} from "./chunk-V4BOYR52.js";
+import {
+  buildAgentCompletionMessage,
+  buildPlanApprovalQuestion,
+  createAgentRunContext,
+  createSessionHistoryTools,
+  createTerminalOutcome,
+  getOrCreateAgentManager,
+  normalizePersistedTodos,
+  planApprovalFromUserQuestionResponse,
+  planStopDecision,
+  shouldCompact,
+  takeAgentCompletionBatch,
+  usagePressureTokens
+} from "./chunk-XIFFTATU.js";
+import {
+  createBuiltinCommandRegistry,
+  estimateUsageCost,
+  getPackageVersion,
+  planWasLost,
+  resolveContextLimit,
+  resolvePermissionMode
+} from "./chunk-A7JLBK2Y.js";
+import {
+  commandEnforcementContext,
+  discoverCommands,
+  parseSlashInput,
+  resolveCommandBody
+} from "./chunk-E75IPST5.js";
+import {
+  consoleMcpDiagnosticSink,
+  resolveMcpServerList
+} from "./chunk-3U5IBM24.js";
+import {
+  observationKey,
+  toolFailure,
+  toolSuccess
+} from "./chunk-5GDZ22YP.js";
+import {
+  loadSettingsFile
+} from "./chunk-BTZZUCLI.js";
+import {
+  partitionProjectAllowRules
+} from "./chunk-WKBO5R4O.js";
+import {
+  collectDeclaredHooks,
+  partitionProjectHooks
+} from "./chunk-ANSJPYGI.js";
+import {
+  resolveBookHome
+} from "./chunk-24AXE6SP.js";
+
+// src/run-status.ts
+import {
+  closeSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  statfsSync,
+  writeSync
+} from "fs";
+import { join } from "path";
+var RUN_STATUS_VERSION = 1;
+function runStatusDir(home = resolveBookHome()) {
+  return join(home, "runs");
+}
+function runStatusPath(sessionId, home = resolveBookHome()) {
+  const safe = sessionId.replace(/[^A-Za-z0-9_-]/g, "_");
+  return join(runStatusDir(home), `${safe}.json`);
+}
+function freeDiskBytes(path) {
+  try {
+    const stats = statfsSync(path);
+    const free = Number(stats.bavail) * Number(stats.bsize);
+    return Number.isFinite(free) && free >= 0 ? free : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function writeRunStatus(record, home = resolveBookHome()) {
+  const target = runStatusPath(record.sessionId, home);
+  const temp = `${target}.${process.pid}.tmp`;
+  try {
+    mkdirSync(runStatusDir(home), { recursive: true });
+    const fd = openSync(temp, "w");
+    try {
+      writeSync(fd, JSON.stringify(record, null, 2));
+    } finally {
+      closeSync(fd);
+    }
+    renameSync(temp, target);
+  } catch {
+    try {
+      rmSync(temp, { force: true });
+    } catch {
+    }
+  }
+}
+function readRunStatus(sessionId, home = resolveBookHome()) {
+  try {
+    const parsed = JSON.parse(readFileSync(runStatusPath(sessionId, home), "utf8"));
+    if (!parsed || typeof parsed !== "object") return void 0;
+    const record = parsed;
+    return record.version === RUN_STATUS_VERSION ? record : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var RunStatusWriter = class {
+  seed;
+  last;
+  crashHandlerInstalled = false;
+  constructor(seed) {
+    this.seed = seed;
+    this.last = {
+      version: RUN_STATUS_VERSION,
+      sessionId: seed.sessionId,
+      runId: seed.runId,
+      pid: process.pid,
+      startedAt: seed.startedAt,
+      updatedAt: seed.startedAt,
+      turn: 0,
+      elapsedMs: 0,
+      openTodos: 0,
+      costUsd: null,
+      budgetUsd: seed.budgetUsd,
+      freeDiskBytes: freeDiskBytes(seed.workspace)
+    };
+    writeRunStatus(this.last, seed.home);
+  }
+  update(update, now = Date.now()) {
+    this.last = {
+      ...this.last,
+      updatedAt: now,
+      elapsedMs: now - this.seed.startedAt,
+      turn: update.turn,
+      lastTool: update.lastTool ?? this.last.lastTool,
+      currentTodo: update.currentTodo,
+      openTodos: update.openTodos,
+      costUsd: update.costUsd,
+      freeDiskBytes: freeDiskBytes(this.seed.workspace),
+      terminal: update.terminal ?? this.last.terminal
+    };
+    writeRunStatus(this.last, this.seed.home);
+  }
+  /**
+   * Record that the process is dying without a terminal outcome.
+   *
+   * Synchronous by necessity: this runs from `process.on('exit')`, where the event
+   * loop is already closed and no promise will ever settle.
+   */
+  recordCrash(message, now = Date.now()) {
+    if (this.last.terminal) return;
+    if (this.last.crash) return;
+    this.last = { ...this.last, updatedAt: now, crash: { message, at: now } };
+    writeRunStatus(this.last, this.seed.home);
+  }
+  /**
+   * Install last-resort handlers so an unhandled fault leaves a record.
+   *
+   * There is no `uncaughtException` or `unhandledRejection` handler anywhere in the
+   * codebase, and `index.ts` ends in a bare `program.parse()` whose returned promise
+   * nothing awaits — so a rejection escaping the action handler becomes an unhandled
+   * rejection and the operator gets a stack trace on a stderr they may have
+   * redirected days ago. Returns a disposer.
+   */
+  installCrashHandlers() {
+    if (this.crashHandlerInstalled) return () => {
+    };
+    this.crashHandlerInstalled = true;
+    const onExit = () => {
+      this.recordCrash("The process exited before the run reached a terminal outcome.");
+    };
+    process.on("exit", onExit);
+    return () => {
+      process.off("exit", onExit);
+      this.crashHandlerInstalled = false;
+    };
+  }
+  snapshot() {
+    return this.last;
+  }
+};
+
+// src/commands/print-dispatch.ts
+var PrintEffectRegistry = class {
+  handlers = /* @__PURE__ */ new Map();
+  register(type, handler) {
+    this.handlers.set(type, handler);
+    return this;
+  }
+  has(type) {
+    return this.handlers.has(type);
+  }
+  handledTypes() {
+    return [...this.handlers.keys()];
+  }
+  handle(effect, env, command) {
+    const handler = this.handlers.get(effect.type);
+    return handler ? Promise.resolve(handler(effect, env, command)) : void 0;
+  }
+};
+var UnsupportedPrintCommandError = class extends Error {
+  command;
+  constructor(command, message) {
+    super(message);
+    this.name = "UnsupportedPrintCommandError";
+    this.command = command;
+  }
+};
+var PrintCommandUsageError = class extends Error {
+  command;
+  constructor(command, message) {
+    super(message);
+    this.name = "PrintCommandUsageError";
+    this.command = command;
+  }
+};
+var FIX_REFUSAL = [
+  "\u2715 /review --fix needs an interactive session.",
+  "",
+  "--fix spawns patcher agents that edit files and commit verified patches. A non-interactive",
+  "host cannot approve those tool calls, so the fix pass would either be denied outright or",
+  "commit unreviewed changes with no one watching.",
+  "",
+  'Run `book` interactively and use /review --fix there, or run `book -p "/review --deep"`',
+  "and apply the reported fixes yourself."
+].join("\n");
+async function performPrintReview(effect, env, command) {
+  if (effect.scope.fix) throw new UnsupportedPrintCommandError(command, FIX_REFUSAL);
+  if (!env.agents) {
+    throw new UnsupportedPrintCommandError(
+      command,
+      `\u2715 /${command} needs the managed-agent runtime, and this host did not provide one.`
+    );
+  }
+  const result = await runHostReview({
+    scope: effect.scope,
+    workspace: env.config.workspace,
+    // Every reviewer, lens and verifier agent is spawned under the host's run,
+    // so the whole pipeline is billed and budgeted as one root.
+    runner: reviewRunnerFor(env.agents.manager(), {
+      rootRunId: env.agents.runContext.rootRunId,
+      parentRunId: env.agents.runContext.runId
+    })
+  });
+  if (result.error) throw new Error(result.segments.join("\n\n"));
+  return {
+    kind: "handled",
+    command,
+    output: result.segments.join("\n\n"),
+    data: reviewReportJson(result)
+  };
+}
+function createPrintEffectRegistry() {
+  return new PrintEffectRegistry().register("send-prompt", (effect) => ({
+    kind: "prompt",
+    prompt: effect.prompt,
+    commandContext: effect.context
+  })).register("local-message", (effect, _env, command) => {
+    if (effect.isError) throw new PrintCommandUsageError(command, effect.content);
+    return { kind: "handled", command, output: effect.content };
+  }).register("review", performPrintReview);
+}
+function printBuiltinContext(env, commands) {
+  return {
+    workspace: env.config.workspace,
+    sessionId: env.sessionId,
+    model: env.config.model,
+    provider: env.config.provider,
+    currentTurn: 0,
+    messages: [],
+    lastError: null,
+    runtimeConfig: env.config,
+    mode: env.mode,
+    usage: null,
+    turnDurationMs: 0,
+    contextHistory: [],
+    compactBoundaries: [],
+    commandCount: commands.length,
+    skillCount: 0,
+    resolveAmbientContext: () => ({
+      subagentCount: 0,
+      hasMemoryIndex: false,
+      hasClaudeMdLoader: false
+    })
+  };
+}
+function supportedCommandHelp(builtins, commands) {
+  const lines = ["Commands supported in print mode:"];
+  for (const definition of builtins.getDefinitions()) {
+    if (definition.nonInteractive) lines.push(`  /${definition.name} \u2014 ${definition.description}`);
+  }
+  const custom = commands.map((command) => `/${command.name}`);
+  lines.push(
+    custom.length > 0 ? `  custom commands from .book/commands: ${custom.slice(0, 12).join(" ")}${custom.length > 12 ? " \u2026" : ""}` : "  plus any custom command in .book/commands/ or ~/.book/commands/"
+  );
+  return lines;
+}
+function unsupported(command, reason, builtins, commands) {
+  return new UnsupportedPrintCommandError(
+    command,
+    [
+      `\u2715 /${command} ${reason}`,
+      "",
+      ...supportedCommandHelp(builtins, commands),
+      "",
+      `Run book without --print (interactive mode) to use /${command}.`
+    ].join("\n")
+  );
+}
+async function resolvePrintCommand(input, env, deps = {}) {
+  const parsed = parseSlashInput(input);
+  if (!parsed || !parsed.name) return { kind: "passthrough", prompt: input };
+  const builtins = deps.builtins ?? createBuiltinCommandRegistry();
+  const effects = deps.effects ?? createPrintEffectRegistry();
+  const commands = deps.commands ?? discoverCommands(env.config.workspace);
+  const context = printBuiltinContext(env, commands);
+  const resolved = builtins.resolve(parsed.name, context);
+  if (resolved) {
+    if (!resolved.definition.nonInteractive) {
+      throw unsupported(
+        parsed.name,
+        "needs an interactive session: it changes host state instead of producing a prompt.",
+        builtins,
+        commands
+      );
+    }
+    if (!resolved.available) {
+      throw unsupported(
+        parsed.name,
+        `is unavailable: ${resolved.unavailableReason ?? "no reason given"}`,
+        builtins,
+        commands
+      );
+    }
+    const effect = resolved.definition.execute(
+      { name: resolved.invokedName, rawArguments: parsed.rawArguments },
+      context
+    );
+    const dispatch = await effects.handle(effect, env, resolved.invokedName);
+    if (!dispatch) {
+      throw unsupported(
+        parsed.name,
+        `resolved to the '${effect.type}' effect, which a non-interactive host cannot perform.`,
+        builtins,
+        commands
+      );
+    }
+    return dispatch.kind === "handled" ? { ...dispatch, command: parsed.name } : dispatch;
+  }
+  const custom = commands.find((command) => command.name === parsed.name);
+  if (!custom) return { kind: "passthrough", prompt: input };
+  const { resolved: body, shellErrors } = await resolveCommandBody(
+    custom,
+    parsed.rawArguments,
+    {
+      sessionId: env.sessionId,
+      workspace: env.config.workspace,
+      model: env.config.model,
+      projectCommands: env.config.settings.commands.projectCommands
+    },
+    env.signal
+  );
+  return {
+    kind: "prompt",
+    prompt: body,
+    commandContext: commandEnforcementContext(custom, body),
+    shellErrors
+  };
+}
+
+// src/stream-json.ts
+var EVENT_TYPES = /* @__PURE__ */ new Set([
+  "user",
+  "system",
+  "session",
+  "run_start",
+  "assistant",
+  "reasoning",
+  "tool_use",
+  "tool_result",
+  "user_question",
+  "user_question_result",
+  "agent_start",
+  "background_job_start",
+  "background_job_update",
+  "background_job_output",
+  "background_job_result",
+  "background_job_dismiss",
+  "agent_update",
+  "agent_result",
+  "agent_question",
+  "agent_status",
+  "agent_activity",
+  "agent_text_delta",
+  "agent_message",
+  "agent_completion",
+  "agent_permission",
+  "evidence_update",
+  "agent_apply",
+  "hook_event",
+  "mode_change",
+  "plan_approval",
+  "prompt_suggestions",
+  "error",
+  "result",
+  "done"
+]);
+var DEFAULT_MAX_BUFFERED_LINE_BYTES = 1024 * 1024;
+function parseStreamLineDetailed(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return {};
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch (error) {
+    return {
+      diagnostic: {
+        code: "invalid-json",
+        message: `Invalid stream-json record: ${error instanceof Error ? error.message : String(error)}`,
+        line: trimmed
+      }
+    };
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed) || !("type" in parsed) || typeof parsed.type !== "string" || !EVENT_TYPES.has(parsed.type) || parsed.type === "user" && typeof parsed.content !== "string") {
+    return {
+      diagnostic: {
+        code: "invalid-shape",
+        message: "Stream-json records must be objects with a supported type and valid fields.",
+        line: trimmed
+      }
+    };
+  }
+  return { event: parsed };
+}
+function createStreamParser(onEvent, options = {}) {
+  const maxBufferedLineBytes = options.maxBufferedLineBytes ?? DEFAULT_MAX_BUFFERED_LINE_BYTES;
+  if (!Number.isSafeInteger(maxBufferedLineBytes) || maxBufferedLineBytes < 1) {
+    throw new Error("maxBufferedLineBytes must be a positive safe integer");
+  }
+  let buffer = "";
+  let discardingOversizedLine = false;
+  const emitLine = (line) => {
+    const { event, diagnostic } = parseStreamLineDetailed(line.replace(/\r$/, ""));
+    if (event) onEvent(event);
+    if (diagnostic) options.onDiagnostic?.(diagnostic);
+  };
+  const append = (segment, terminated) => {
+    if (discardingOversizedLine) {
+      if (terminated) discardingOversizedLine = false;
+      return;
+    }
+    if (Buffer.byteLength(buffer) + Buffer.byteLength(segment) > maxBufferedLineBytes) {
+      buffer = "";
+      options.onDiagnostic?.({
+        code: "oversized-line",
+        message: `Stream-json record exceeds the ${maxBufferedLineBytes}-byte limit.`
+      });
+      discardingOversizedLine = !terminated;
+      return;
+    }
+    buffer += segment;
+    if (terminated) {
+      emitLine(buffer);
+      buffer = "";
+    }
+  };
+  return {
+    feed(chunk) {
+      const segments = chunk.toString().split("\n");
+      for (let index = 0; index < segments.length; index++) {
+        append(segments[index] ?? "", index < segments.length - 1);
+      }
+    },
+    flush() {
+      if (!discardingOversizedLine && buffer.length > 0) emitLine(buffer);
+      buffer = "";
+      discardingOversizedLine = false;
+    }
+  };
+}
+
+// src/headless.ts
+function carriedCostUsd(usage, models) {
+  let worst = null;
+  for (const model of models) {
+    const quote = estimateUsageCost(model, usage);
+    if (quote.status !== "known") return null;
+    worst = worst === null ? quote.costUsd : Math.max(worst, quote.costUsd);
+  }
+  return worst;
+}
+async function readPipedPrompt(stream) {
+  if (stream.isTTY) return void 0;
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8"));
+  }
+  const prompt = chunks.join("").trim();
+  return prompt || void 0;
+}
+async function runHeadless(config, registry, opts) {
+  const mode = resolvePermissionMode(config.settings, opts.mode);
+  const stdout = opts.stdout ?? process.stdout;
+  const emit = (obj) => {
+    if (obj && typeof obj === "object" && "type" in obj) {
+      opts.onEvent?.(obj);
+    }
+    stdout.write(JSON.stringify(obj) + "\n");
+  };
+  let disposeCrashHandlers;
+  const agentSession = new AgentSession();
+  const runtime = agentSession.getRuntime();
+  runtime.todos.push(...normalizePersistedTodos(opts.plan?.todos));
+  if (opts.plan?.tasks?.length) runtime.tasks.push(...opts.plan.tasks);
+  runtime.planUnrestored = planWasLost({
+    planRecordExisted: opts.plan !== void 0,
+    priorMessages: opts.history.length,
+    todos: runtime.todos.length,
+    tasks: runtime.tasks.length
+  });
+  try {
+    if (opts.outputFormat === "stream-json") {
+      emit({ type: "system", model: config.model, cwd: config.workspace });
+    }
+    const store = opts.persistSession === false ? void 0 : opts.sessionStore;
+    let sessionId = opts.sessionId;
+    if (store && !sessionId && opts.sessionName) {
+      sessionId = store.findByName(opts.sessionName)?.id;
+    }
+    if (store && sessionId && opts.forkSession) {
+      sessionId = void 0;
+    }
+    let sessionName = opts.sessionName;
+    let sessionCreated = opts.sessionCreated === true;
+    if (store && !sessionId) {
+      sessionId = store.create({ cwd: config.workspace, name: sessionName });
+      sessionCreated = true;
+    }
+    if (store && sessionId && !sessionName) {
+      sessionName = store.findById(sessionId)?.name;
+    }
+    if (sessionCreated && sessionId && opts.outputFormat === "stream-json") {
+      emit({ type: "session", session_id: sessionId });
+    }
+    if (store && sessionId) {
+      registry.registerAll(
+        createSessionHistoryTools({ store, sessionId: () => sessionId })
+      );
+    }
+    if (sessionId) {
+      await agentSession.startLifecycle(
+        config,
+        sessionId,
+        opts.history.length > 0 ? "resume" : "startup",
+        {
+          onHookEvent: createHookEventHandler(opts, emit)
+        }
+      );
+    }
+    const runtimeSessionId = sessionId ?? crypto.randomUUID();
+    const statusWriter = new RunStatusWriter({
+      sessionId: runtimeSessionId,
+      runId: runtimeSessionId,
+      workspace: config.workspace,
+      budgetUsd: opts.maxBudgetUsd,
+      startedAt: Date.now()
+    });
+    disposeCrashHandlers = statusWriter.installCrashHandlers();
+    const permissionRequired = async () => "deny";
+    const userQuestionStatus = opts.onUserQuestionRequired ? "pending" : "unavailable";
+    const askUser = async (request, context) => {
+      try {
+        return opts.onUserQuestionRequired ? await opts.onUserQuestionRequired(request, context) : {
+          action: "decline",
+          message: "User input is unavailable in non-interactive mode."
+        };
+      } catch (error) {
+        return {
+          action: "cancel",
+          message: `User question handler failed: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+    };
+    const decidePlanApproval = async (plan) => {
+      if (mode === "bypassPermissions") return "approve";
+      if (!opts.onUserQuestionRequired) return planStopDecision("approval_unavailable");
+      const request = buildPlanApprovalQuestion(plan, crypto.randomUUID());
+      emitAgentEvent({ type: "user_question", request, status: userQuestionStatus }, opts, emit);
+      const response = await askUser(request, { signal: opts.signal });
+      emitAgentEvent({ type: "user_question_result", requestId: request.id, response }, opts, emit);
+      return planApprovalFromUserQuestionResponse(request, response);
+    };
+    const planNotApplied = {};
+    let lastUsage = null;
+    let lastOutcome = null;
+    const runResults = [];
+    const recordRunResult = (result2) => {
+      const existing = runResults.findIndex(
+        (candidate) => candidate.context.runId === result2.context.runId
+      );
+      if (existing >= 0) runResults[existing] = result2;
+      else runResults.push(result2);
+    };
+    const recordManagedRunResult = (agent) => {
+      if (!agent.runId) return;
+      const context = createAgentRunContext({
+        sessionId: agent.parentSessionId ?? runtimeSessionId,
+        runId: agent.runId,
+        rootRunId: agent.rootRunId ?? agent.runId,
+        parentRunId: agent.parentRunId,
+        source: "internal",
+        startedAt: agent.runStartedAt ?? agent.startedAt ?? agent.createdAt
+      });
+      const outcome2 = agent.runOutcome ?? (agent.status === "completed" ? createTerminalOutcome("completed", "normal_completion", { partialOutput: false }) : createTerminalOutcome("failed", "runtime_error", {
+        partialOutput: Boolean(agent.result),
+        message: agent.error ?? `Managed agent ended with status ${agent.status}.`
+      }));
+      recordRunResult({
+        context,
+        outcome: outcome2,
+        usage: agent.runUsage ?? null,
+        accounting: runtime.runAccounting.snapshotRun(agent.runId),
+        ambient: runtime.snapshotRunAmbient(agent.runId)
+      });
+    };
+    const recordManagedCompletionResult = (notification) => {
+      if (!notification.runId || runResults.some((candidate) => candidate.context.runId === notification.runId))
+        return;
+      const completion = notification.completion;
+      const outcome2 = notification.outcome ?? (completion.status === "completed" ? createTerminalOutcome("completed", "normal_completion", { partialOutput: false }) : completion.status === "stopped" ? createTerminalOutcome("cancelled", "user_cancelled", {
+        partialOutput: Boolean(completion.summary),
+        message: completion.error
+      }) : completion.status === "interrupted" ? createTerminalOutcome("interrupted", "transport_interrupted", {
+        partialOutput: Boolean(completion.summary),
+        message: completion.error
+      }) : createTerminalOutcome("failed", "runtime_error", {
+        partialOutput: Boolean(completion.summary),
+        message: completion.error
+      }));
+      recordRunResult({
+        context: createAgentRunContext({
+          sessionId: notification.parentSessionId ?? runtimeSessionId,
+          runId: notification.runId,
+          rootRunId: notification.rootRunId ?? notification.runId,
+          parentRunId: notification.parentRunId,
+          source: "internal",
+          startedAt: completion.startedAt ?? completion.createdAt
+        }),
+        outcome: outcome2,
+        usage: completion.usage ?? null,
+        accounting: runtime.runAccounting.snapshotRun(notification.runId),
+        ambient: runtime.snapshotRunAmbient(notification.runId)
+      });
+    };
+    const rootContexts = /* @__PURE__ */ new Map();
+    let lastHostCompactAttemptKey = null;
+    const contextHistory = [...opts.history];
+    const transcript = [...opts.transcript ?? opts.history];
+    const compactBoundaries = [...opts.compactBoundaries ?? []];
+    for (const message of transcript) {
+      for (const observation of message.fileObservations ?? []) {
+        const key = observationKey(observation.workspaceId, observation.path);
+        const current = runtime.fileObservationLedger.get(key);
+        if (!current || current.timestamp <= observation.timestamp) {
+          runtime.fileObservationLedger.set(key, observation);
+        }
+      }
+    }
+    const loopConfig = {
+      ...config,
+      maxTurns: opts.maxTurns ?? config.maxTurns
+    };
+    const createRunCallbacks = (runContext, onOutcome) => ({
+      onEvent: (event) => {
+        if (event.type === "agent_result") recordManagedRunResult(event.agent);
+        if (event.type === "terminal") {
+          lastOutcome = event.outcome;
+          onOutcome(event.outcome);
+        }
+        emitAgentEvent(event, opts, emit);
+      },
+      // No header rewrite at turn boundaries: load() derives updatedAt from
+      // the last appended record, so the on-disk header is never authoritative.
+      onTurnStart: () => {
+      },
+      onDone: () => {
+      },
+      onPermissionRequired: permissionRequired,
+      onModeChange: (newMode) => {
+        if (opts.outputFormat === "stream-json") {
+          emit({ type: "mode_change", mode: newMode });
+        }
+      },
+      onPlanApprovalRequired: async (plan) => {
+        const decision = await decidePlanApproval(plan);
+        if (typeof decision === "object" && decision.decision === "stop") {
+          planNotApplied.outcome = {
+            status: "not_applied",
+            reason: decision.reason,
+            plan,
+            message: decision.message
+          };
+        }
+        if (opts.outputFormat === "stream-json") {
+          emit({ type: "plan_approval", status: planApprovalStatus(decision) });
+        }
+        return decision;
+      },
+      onUserQuestionRequired: askUser,
+      userQuestionStatus,
+      onHookEvent: createHookEventHandler(opts, emit),
+      onUsage: (nextUsage) => {
+        lastUsage = nextUsage;
+        lastHostCompactAttemptKey = null;
+      },
+      onCompact: async (history, usage, hints) => {
+        const outcome2 = await agentSession.compact({
+          config,
+          history,
+          compactBoundaries,
+          sessionId,
+          transcriptOrdinal: transcript.length,
+          runContext,
+          runtime,
+          timelineStore: store,
+          onCommitted: (_result, boundary) => compactBoundaries.push(boundary),
+          options: {
+            ...hints,
+            trigger: "auto",
+            preContextTokens: usage ? usagePressureTokens(usage) : void 0,
+            signal: opts.signal,
+            onHookEvent: createHookEventHandler(opts, emit)
+          }
+        });
+        if (outcome2.result.status === "compacted") {
+          emitCompactBoundary(opts.outputFormat, emit, outcome2.result);
+          lastUsage = null;
+        }
+        return outcome2.result;
+      },
+      onAssistantMessageComplete: (message) => {
+        if (!transcript.some((item) => item.id === message.id)) transcript.push(message);
+        if (opts.outputFormat === "stream-json" && message.content) {
+          emit({ type: "assistant", text: message.content, complete: true });
+        }
+      }
+    });
+    const runParentTurn = async (prompt, displayMessage, userMessage, runContext, commandContext) => {
+      let runOutcome;
+      lastUsage = null;
+      let updated;
+      try {
+        updated = await agentSession.run({
+          config: loopConfig,
+          registry,
+          prompt,
+          history: contextHistory,
+          compactBoundaries,
+          mode,
+          sessionId: runtimeSessionId,
+          timelineStore: store,
+          signal: opts.signal,
+          callbacks: createRunCallbacks(runContext, (outcome2) => {
+            runOutcome = outcome2;
+          }),
+          runContext,
+          maxBudgetUsd: opts.maxBudgetUsd,
+          options: {
+            displayMessage,
+            userMessageId: userMessage.id,
+            userMessageTimestamp: userMessage.timestamp,
+            userFileObservations: userMessage.fileObservations,
+            userAttachments: userMessage.attachments,
+            userMessageKind: userMessage.kind,
+            manageSessionHooks: sessionId ? false : void 0,
+            // Completion messages are host-generated notifications, not user
+            // prompts. Keep UserPromptSubmit hooks from rewriting or blocking them.
+            skipUserPromptHooks: userMessage.kind === "agent-notification",
+            parentSessionId: runtimeSessionId,
+            runContext,
+            runtime,
+            // Command frontmatter enforcement, exactly as the TUI passes it.
+            allowedTools: commandContext?.allowedTools,
+            modelOverride: commandContext?.modelOverride,
+            commands: commandContext ? [commandContext.command] : void 0,
+            statusWriter,
+            // No human can resolve a permission prompt here: `permissionRequired`
+            // answers `deny` unconditionally.
+            unattended: true
+          }
+        });
+      } catch (error) {
+        const failedOutcome = runOutcome ?? createTerminalOutcome("interrupted", "missing_terminal", { partialOutput: false });
+        recordRunResult({
+          context: runContext,
+          outcome: failedOutcome,
+          usage: runtime.runAccounting.snapshotRun(runContext.runId)?.directUsage ?? lastUsage,
+          accounting: runtime.runAccounting.snapshotRun(runContext.runId),
+          ambient: runtime.snapshotRunAmbient(runContext.runId)
+        });
+        throw error;
+      }
+      const priorIds = new Set(transcript.map((message) => message.id));
+      transcript.push(
+        ...updated.filter((message) => !priorIds.has(message.id) && message.role === "assistant")
+      );
+      contextHistory.length = 0;
+      contextHistory.push(...updated);
+      const turnOutcome = runOutcome ?? createTerminalOutcome("interrupted", "missing_terminal", {
+        partialOutput: updated.some((message) => message.role === "assistant")
+      });
+      recordRunResult({
+        context: runContext,
+        outcome: turnOutcome,
+        usage: runtime.runAccounting.snapshotRun(runContext.runId)?.directUsage ?? lastUsage,
+        accounting: runtime.runAccounting.snapshotRun(runContext.runId),
+        ambient: runtime.snapshotRunAmbient(runContext.runId)
+      });
+    };
+    const dispatchSubmittedPrompt = (submitted, runContext) => opts.expandSlashCommands === false ? Promise.resolve({ kind: "passthrough", prompt: submitted }) : resolvePrintCommand(submitted, {
+      config,
+      mode,
+      sessionId: runtimeSessionId,
+      signal: opts.signal,
+      agents: {
+        // Built only when an agent-backed command (`/review`) asks for it,
+        // and attached to this session's runtime so it is disposed with the
+        // run. Its events join the same stream-json output as the main loop,
+        // and its finished runs land in `runs` like any other execution.
+        manager: () => getOrCreateAgentManager(config, registry.getDefinitions(), {
+          runtime,
+          permissionMode: mode,
+          eventSink: (event) => {
+            if (event.type === "agent_result") recordManagedRunResult(event.agent);
+            emitAgentEvent(event, opts, emit);
+          },
+          hookEventSink: createHookEventHandler(opts, emit)
+        }),
+        runContext
+      }
+    });
+    const commandResults = [];
+    let commandUsage = null;
+    const prompts = [];
+    if (opts.inputFormat === "text") {
+      const prompt = opts.prompt ?? await readPipedPrompt(opts.stdin ?? process.stdin);
+      if (!prompt) {
+        throw new Error(
+          "print mode requires a prompt: pass one to -p, pipe one on stdin, or use --input-format stream-json"
+        );
+      }
+      prompts.push(prompt);
+    } else {
+      const stream = opts.stdin ?? process.stdin;
+      const diagnostics = [];
+      const parser = createStreamParser(
+        (event) => {
+          if (event.type === "user") prompts.push(event.content);
+        },
+        {
+          maxBufferedLineBytes: opts.maxInputLineBytes,
+          onDiagnostic: (diagnostic) => diagnostics.push(diagnostic)
+        }
+      );
+      for await (const chunk of stream) {
+        parser.feed(chunk);
+      }
+      parser.flush();
+      if (diagnostics.length > 0) throw new Error(diagnostics[0]?.message);
+      if (opts.prompt) prompts.unshift(opts.prompt);
+    }
+    let carriedSpend = opts.carriedUsage ? {
+      usage: opts.carriedUsage,
+      costUsd: carriedCostUsd(
+        opts.carriedUsage,
+        opts.carriedModels?.length ? opts.carriedModels : [config.model]
+      )
+    } : void 0;
+    for (const submitted of prompts) {
+      const runId = crypto.randomUUID();
+      const runContext = createAgentRunContext({
+        sessionId: runtimeSessionId,
+        runId,
+        source: opts.runSource ?? "headless",
+        resumedFromRunId: runResults.length === 0 ? opts.resumedFromRunId ?? (opts.history.length > 0 ? [...opts.history].reverse().find((message) => message.role === "user")?.id : void 0) : void 0
+      });
+      runtime.runAccounting.startRoot(runContext, opts.maxBudgetUsd);
+      if (carriedSpend) {
+        runtime.runAccounting.seedRoot(runContext.rootRunId, carriedSpend);
+      }
+      const dispatch = await dispatchSubmittedPrompt(submitted, runContext);
+      if (dispatch.kind === "prompt" && dispatch.shellErrors?.length) {
+        for (const shellError of dispatch.shellErrors) {
+          process.stderr.write(`warning: ${shellError}
+`);
+        }
+      }
+      if (dispatch.kind === "handled") {
+        const handled = {
+          command: dispatch.command,
+          output: dispatch.output,
+          data: dispatch.data
+        };
+        commandResults.push(handled);
+        const accounting = runtime.runAccounting.snapshotRoot(runContext.rootRunId);
+        commandUsage = accounting.inclusiveUsage ?? commandUsage;
+        recordRunResult({
+          context: runContext,
+          outcome: createTerminalOutcome("completed", "normal_completion", {
+            partialOutput: false
+          }),
+          // The host itself made no provider call; everything spent here was
+          // spent by the agents this command ran, which is the inclusive figure.
+          usage: accounting.inclusiveUsage,
+          accounting,
+          ambient: runtime.snapshotRunAmbient(runContext.runId)
+        });
+        if (opts.outputFormat === "text") {
+          if (dispatch.output) stdout.write(`${dispatch.output}
+`);
+        } else if (opts.outputFormat === "stream-json" && (dispatch.output !== void 0 || dispatch.data !== void 0)) {
+          emit({ type: "command_result", ...handled });
+        }
+        continue;
+      }
+      const prompt = dispatch.prompt;
+      const commandContext = dispatch.kind === "prompt" ? dispatch.commandContext : void 0;
+      const userMessage = {
+        id: runId,
+        role: "user",
+        content: prompt,
+        // With a command context, `prompt` is a resolved command body, not typed
+        // input -- repository-authored for a project command. Marking it keeps
+        // print and SDK runs on the same footing as the TUI.
+        derivedContent: commandContext ? true : void 0,
+        includeInContext: true,
+        kind: "conversation",
+        timestamp: Date.now()
+      };
+      const contextLimit = resolveContextLimit(config);
+      const hostCompactAttemptKey = `${usagePressureTokens(lastUsage)}:${contextHistory.length}`;
+      if (config.autoCompactEnabled !== false && contextLimit != null && shouldCompact(lastUsage, contextLimit) && lastHostCompactAttemptKey !== hostCompactAttemptKey) {
+        lastHostCompactAttemptKey = hostCompactAttemptKey;
+        try {
+          const outcome2 = await agentSession.compact({
+            config,
+            history: contextHistory,
+            compactBoundaries,
+            sessionId,
+            transcriptOrdinal: transcript.length,
+            runContext,
+            runtime,
+            timelineStore: store,
+            onCommitted: (compactResult, boundary) => {
+              contextHistory.length = 0;
+              contextHistory.push(...compactResult.replacementHistory);
+              compactBoundaries.push(boundary);
+              lastUsage = null;
+            },
+            options: {
+              trigger: "auto",
+              preContextTokens: usagePressureTokens(lastUsage),
+              signal: opts.signal,
+              upcomingUserIntent: prompt,
+              onHookEvent: createHookEventHandler(opts, emit)
+            }
+          });
+          if (outcome2.result.status === "compacted") {
+            emitCompactBoundary(opts.outputFormat, emit, outcome2.result);
+          }
+        } catch {
+        }
+      }
+      const recorded = await agentSession.recordUserMessage({
+        config,
+        sessionId: runtimeSessionId,
+        displayMessage: prompt,
+        userMessage,
+        sessionName,
+        timelineStore: store && sessionId ? store : void 0,
+        expandShellInput: false,
+        runtime,
+        signal: opts.signal
+      });
+      sessionName = recorded.sessionName;
+      const contextMessage = recorded.contextMessage;
+      transcript.push(userMessage);
+      rootContexts.set(runContext.rootRunId, runContext);
+      await runParentTurn(contextMessage, prompt, userMessage, runContext, commandContext);
+      const spentSoFar = runtime.runAccounting.snapshotRoot(runContext.rootRunId);
+      carriedSpend = {
+        usage: spentSoFar.inclusiveUsage,
+        costUsd: spentSoFar.inclusiveCostUsd
+      };
+      if (planNotApplied.outcome) break;
+    }
+    const managedAgentManager = planNotApplied.outcome ? void 0 : runtime.agentManager;
+    if (managedAgentManager) {
+      const deliveredCompletionIds = new Set(
+        transcript.flatMap(
+          (message) => (message.agentNotifications ?? []).map((notification) => notification.deliveryId).filter((id) => Boolean(id))
+        )
+      );
+      while (true) {
+        await managedAgentManager.waitForIdle();
+        const pending = (await managedAgentManager.listPendingCompletions()).filter(
+          (notification) => notification.parentSessionId === runtimeSessionId
+        );
+        if (pending.length === 0) break;
+        const alreadyDelivered = pending.filter(
+          (notification) => deliveredCompletionIds.has(notification.deliveryId)
+        );
+        for (const notification of alreadyDelivered) {
+          await managedAgentManager.acknowledgeCompletion(notification.deliveryId);
+        }
+        const fresh = pending.filter(
+          (notification) => !deliveredCompletionIds.has(notification.deliveryId)
+        );
+        if (fresh.length === 0) continue;
+        const firstRootRunId = fresh[0]?.rootRunId;
+        const sameRoot = firstRootRunId ? fresh.filter((notification) => notification.rootRunId === firstRootRunId) : fresh;
+        const batch = takeAgentCompletionBatch(sameRoot);
+        for (const notification of batch) recordManagedCompletionResult(notification);
+        const built = batch.map(
+          (notification) => buildAgentCompletionMessage(notification)
+        );
+        const displayMessage = built.map((item) => item.displayMessage).join("\n");
+        const userMessage = {
+          id: crypto.randomUUID(),
+          role: "user",
+          content: displayMessage,
+          contextContent: built.map((item) => item.contextMessage).join("\n"),
+          includeInContext: true,
+          kind: "agent-notification",
+          agentNotifications: built.map((item) => item.display),
+          timestamp: Date.now()
+        };
+        const recorded = await agentSession.recordUserMessage({
+          config,
+          sessionId: runtimeSessionId,
+          displayMessage,
+          contextMessage: userMessage.contextContent,
+          userMessage,
+          timelineStore: store && sessionId ? store : void 0,
+          expandShellInput: false,
+          runtime,
+          signal: opts.signal
+        });
+        transcript.push(userMessage);
+        const parentContext = batch[0]?.rootRunId ? rootContexts.get(batch[0].rootRunId) : void 0;
+        const runContext = createAgentRunContext({
+          sessionId: runtimeSessionId,
+          source: opts.runSource ?? "headless",
+          rootRunId: parentContext?.rootRunId ?? batch[0]?.rootRunId,
+          parentRunId: batch[0]?.runId ?? parentContext?.runId
+        });
+        if (parentContext) rootContexts.set(runContext.rootRunId, parentContext);
+        else rootContexts.set(runContext.rootRunId, runContext);
+        await runParentTurn(recorded.contextMessage, displayMessage, userMessage, runContext);
+        for (const notification of batch) {
+          deliveredCompletionIds.add(notification.deliveryId);
+          await managedAgentManager.acknowledgeCompletion(notification.deliveryId);
+        }
+      }
+    }
+    const outcome = lastOutcome ?? (commandResults.length > 0 ? createTerminalOutcome("completed", "normal_completion", { partialOutput: false }) : createTerminalOutcome("interrupted", "missing_terminal", {
+      partialOutput: transcript.some((message) => message.role === "assistant")
+    }));
+    runResults.sort((left, right) => left.context.startedAt - right.context.startedAt);
+    const reportedUsage = lastUsage ?? commandUsage;
+    const result = {
+      messages: contextHistory,
+      transcript,
+      compactBoundaries,
+      usage: reportedUsage,
+      accounting: runtime.runAccounting.snapshotAll(),
+      outcome,
+      runs: runResults,
+      sessionId,
+      plan: planNotApplied.outcome,
+      commandResults
+    };
+    if (opts.jsonSchema) {
+      const text = lastAssistantText(contextHistory);
+      try {
+        result.structured = JSON.parse(text);
+      } catch {
+        result.structuredError = "Failed to parse JSON from assistant output";
+      }
+    }
+    if (opts.promptSuggestions && opts.outputFormat === "stream-json") {
+      try {
+        const suggestions = await generatePromptSuggestions(
+          config,
+          registry,
+          contextHistory,
+          opts.signal,
+          store?.readImageAttachment ? (attachment) => store.readImageAttachment(runtimeSessionId, attachment) : void 0
+        );
+        if (suggestions.length > 0) {
+          emit({ type: "prompt_suggestions", suggestions });
+        }
+      } catch {
+      }
+    }
+    if (opts.outputFormat === "text") {
+      const stopped = planNotApplied.outcome;
+      if (stopped) {
+        stdout.write(`${stopped.plan}
+
+${stopped.message}
+`);
+      } else {
+        const last = lastAssistantText(contextHistory);
+        if (last) stdout.write(last + "\n");
+      }
+    } else if (opts.outputFormat === "json") {
+      emit({
+        result: {
+          messages: contextHistory,
+          usage: reportedUsage,
+          accounting: result.accounting,
+          outcome,
+          stopReason: outcome.reason,
+          runs: runResults,
+          structured: result.structured,
+          structuredError: result.structuredError,
+          plan: result.plan,
+          commandResults
+        }
+      });
+    } else if (opts.outputFormat === "stream-json") {
+      emit({
+        type: "result",
+        stopReason: outcome.reason,
+        result: {
+          messages: contextHistory,
+          usage: reportedUsage,
+          accounting: result.accounting,
+          outcome,
+          stopReason: outcome.reason,
+          runs: runResults,
+          structured: result.structured,
+          structuredError: result.structuredError,
+          plan: result.plan,
+          commandResults
+        }
+      });
+    }
+    if (sessionId) {
+      await agentSession.endLifecycle(config, sessionId, "completion", {
+        onHookEvent: createHookEventHandler(opts, emit)
+      });
+    }
+    return result;
+  } finally {
+    disposeCrashHandlers?.();
+    agentSession.dispose("headless_complete");
+  }
+}
+function lastAssistantText(history) {
+  for (let i = history.length - 1; i >= 0; i--) {
+    const m = history[i];
+    if (m.role === "assistant" && m.content) return m.content;
+  }
+  return "";
+}
+function planApprovalStatus(decision) {
+  return typeof decision === "string" ? decision : decision.decision;
+}
+function createHookEventHandler(opts, emit) {
+  if (!opts.includeHookEvents || opts.outputFormat !== "stream-json") return void 0;
+  return (event, payload) => emit({ type: "hook_event", event, ...payload });
+}
+function emitAgentEvent(event, opts, emit) {
+  if (event.type === "terminal") return;
+  if (event.type === "agent_text_delta" && opts.forwardSubagentText !== true) return;
+  opts.onAgentEvent?.(event);
+  if (event.type === "error") {
+    if (opts.outputFormat === "stream-json") emit({ type: "error", error: event.error });
+    else process.stderr.write(`error: ${event.error}
+`);
+    return;
+  }
+  if (opts.outputFormat !== "stream-json") return;
+  switch (event.type) {
+    case "run_started":
+      emit({ type: "run_start", run: event.context, ambient: event.ambient });
+      break;
+    case "text":
+      if (opts.includePartialMessages === true)
+        emit({ type: "assistant", text: event.content, complete: false });
+      break;
+    case "reasoning":
+      if (opts.includePartialMessages === true) emit({ type: "reasoning", text: event.content });
+      break;
+    case "tool_use":
+      emit({ type: "tool_use", tool_call: event.toolCall });
+      break;
+    case "tool_result":
+      emit({ type: "tool_result", tool_result: event.toolResult });
+      break;
+    case "user_question":
+      emit({ type: "user_question", request: event.request, status: event.status });
+      break;
+    case "user_question_result":
+      emit({
+        type: "user_question_result",
+        request_id: event.requestId,
+        response: event.response
+      });
+      break;
+    case "agent_start":
+    case "background_job_start":
+    case "background_job_update":
+    case "background_job_output":
+    case "background_job_result":
+    case "background_job_dismiss":
+    case "agent_update":
+    case "agent_result":
+    case "agent_question":
+    case "agent_status":
+    case "agent_activity":
+    case "agent_text_delta":
+    case "agent_message":
+    case "agent_completion":
+    case "agent_permission":
+    case "agent_apply":
+    case "evidence_update":
+    case "skill_lifecycle":
+    case "attempt_discarded":
+      emit(event);
+      break;
+    case "system":
+    case "session":
+    case "result":
+    case "done":
+      break;
+  }
+}
+function emitCompactBoundary(outputFormat, emit, result) {
+  if (outputFormat !== "stream-json") return;
+  emit({
+    type: "system",
+    subtype: "compact_boundary",
+    trigger: result.trigger,
+    pre_tokens: result.preContextTokens,
+    compact_id: result.compactId,
+    generation: result.generation,
+    pre_messages: result.preMessageCount,
+    post_messages: result.replacementHistory.length,
+    post_tokens: result.postContextTokens,
+    checkpoint_version: 2,
+    strategy: result.strategy,
+    model_calls: result.modelCalls,
+    degraded: result.degraded,
+    coverage_status: result.checkpoint.coverage?.status ?? "complete",
+    // This generation's status above; the conversation's accumulated one here.
+    coverage_lifetime_status: result.checkpoint.coverage?.lifetime?.status ?? "complete",
+    coverage: result.checkpoint.coverage,
+    warning: result.warning
+  });
+}
+async function generatePromptSuggestions(config, _registry, history, signal, resolveAttachment) {
+  const { chatCompletionStream } = await import("./openai-compatible-RHZUBHV6.js");
+  const { buildMessages } = await import("./context-ZC5IFEAX.js");
+  const suggestionMessages = await buildMessages(
+    config,
+    [
+      ...history,
+      {
+        id: crypto.randomUUID(),
+        role: "user",
+        content: "Based on the conversation above, suggest 1-3 follow-up prompts the user might want to ask next. Keep each suggestion under 80 characters. Return ONLY a JSON array of strings, no other text.",
+        includeInContext: true,
+        timestamp: Date.now()
+      }
+    ],
+    void 0,
+    void 0,
+    signal,
+    void 0,
+    void 0,
+    resolveAttachment
+  );
+  const stream = chatCompletionStream(config, suggestionMessages, [], { signal });
+  let content = "";
+  for await (const event of stream) {
+    if (event.type === "text" && event.content) {
+      content += event.content;
+    }
+  }
+  try {
+    const jsonMatch = content.match(/\[[\s\S]*?\]/);
+    if (jsonMatch) {
+      const parsed = JSON.parse(jsonMatch[0]);
+      if (Array.isArray(parsed)) {
+        return parsed.filter((s) => typeof s === "string" && s.length > 0).slice(0, 3);
+      }
+    }
+  } catch {
+    const quoted = content.match(/"([^"]+)"/g);
+    if (quoted) {
+      return quoted.map((s) => s.replace(/^"|"$/g, "")).slice(0, 3);
+    }
+  }
+  return [];
+}
+
+// src/mcp.ts
+import spawn from "cross-spawn";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { ReadBuffer, serializeMessage } from "@modelcontextprotocol/sdk/shared/stdio.js";
+import {
+  ElicitRequestSchema,
+  ErrorCode,
+  McpError,
+  ToolListChangedNotificationSchema
+} from "@modelcontextprotocol/sdk/types.js";
+var DEFAULT_INITIALIZATION_TIMEOUT_MS = 1e4;
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_STDERR_BYTES = 8192;
+function waitForProcessExit(child, timeoutMs) {
+  if (child.exitCode !== null || child.signalCode !== null) return Promise.resolve(true);
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (exited) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      child.removeListener("exit", onExit);
+      resolve(exited);
+    };
+    const onExit = () => finish(true);
+    const timer = setTimeout(() => finish(false), timeoutMs);
+    timer.unref();
+    child.once("exit", onExit);
+  });
+}
+async function terminateProcess(child) {
+  child.stdin?.end();
+  if (child.exitCode === null && child.signalCode === null) child.kill();
+  if (!await waitForProcessExit(child, 250)) {
+    child.kill("SIGKILL");
+    await waitForProcessExit(child, 750);
+  }
+  child.stdin?.destroy();
+  child.stdout?.destroy();
+  child.stderr?.destroy();
+  child.unref();
+}
+var StdioProcessTransport = class {
+  constructor(name, config, options) {
+    this.name = name;
+    this.config = config;
+    this.options = options;
+  }
+  name;
+  config;
+  options;
+  onclose;
+  onerror;
+  onmessage;
+  child;
+  readBuffer = new ReadBuffer();
+  stderrTail = "";
+  closed = false;
+  cleanupListeners = () => {
+  };
+  protocolVersion;
+  get process() {
+    return this.child;
+  }
+  get stderr() {
+    return this.stderrTail;
+  }
+  setProtocolVersion(version) {
+    this.protocolVersion = version;
+  }
+  start() {
+    if (this.child) {
+      return Promise.reject(new Error(`MCP server ${this.name} transport already started`));
+    }
+    if (!this.config.command) {
+      return Promise.reject(new Error(`MCP server ${this.name} is not a stdio server`));
+    }
+    const child = spawn(this.config.command, this.config.args ?? [], {
+      env: { ...process.env, ...this.config.env },
+      cwd: this.config.cwd,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.child = child;
+    this.options.onSpawn?.(child);
+    const onStdoutData = (data) => {
+      this.readBuffer.append(data);
+      while (true) {
+        let message;
+        try {
+          message = this.readBuffer.readMessage();
+        } catch (error) {
+          this.onerror?.(error instanceof Error ? error : new Error(String(error)));
+          continue;
+        }
+        if (!message) break;
+        this.onmessage?.(message);
+      }
+    };
+    const onStderrData = (data) => {
+      this.stderrTail = (this.stderrTail + data.toString()).slice(-this.options.maxStderrBytes);
+    };
+    const onChildError = (error) => {
+      this.onerror?.(error);
+      this.teardown();
+    };
+    const onStdinError = () => {
+    };
+    const onExit = () => this.teardown();
+    const onClose = () => this.teardown();
+    this.cleanupListeners = () => {
+      child.stdout?.removeListener("data", onStdoutData);
+      child.stderr?.removeListener("data", onStderrData);
+      child.removeListener("error", onChildError);
+      child.stdin?.removeListener("error", onStdinError);
+      child.removeListener("exit", onExit);
+      child.removeListener("close", onClose);
+      this.cleanupListeners = () => {
+      };
+    };
+    child.stdout?.on("data", onStdoutData);
+    child.stderr?.on("data", onStderrData);
+    child.once("error", onChildError);
+    child.stdin?.on("error", onStdinError);
+    child.once("exit", onExit);
+    child.once("close", onClose);
+    return Promise.resolve();
+  }
+  send(message) {
+    return new Promise((resolve, reject) => {
+      const stdin = this.child?.stdin;
+      if (this.closed || !stdin || stdin.destroyed) {
+        reject(new Error(`MCP server ${this.name} stdin is closed`));
+        return;
+      }
+      try {
+        stdin.write(serializeMessage(message), (error) => {
+          if (error) reject(error);
+          else resolve();
+        });
+      } catch (error) {
+        reject(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+  }
+  /** Child died or streams closed underneath us: settle pending work, then reap. */
+  teardown() {
+    if (this.closed) return;
+    this.closed = true;
+    this.cleanupListeners();
+    this.onclose?.();
+    if (this.child) void terminateProcess(this.child).catch(() => {
+    });
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.cleanupListeners();
+    this.onclose?.();
+    if (this.child) await terminateProcess(this.child).catch(() => {
+    });
+  }
+};
+function isMcpErrorWithCode(error, code) {
+  return error instanceof McpError && error.code === code;
+}
+function withStderrContext(message, transport) {
+  const tail = transport.stderr.trim();
+  return tail ? `${message} (stderr: ${tail})` : message;
+}
+function createSecretRedactor(config) {
+  let queryValues = [];
+  try {
+    queryValues = config.url ? [...new URL(config.url).searchParams.values()] : [];
+  } catch {
+  }
+  const secrets = [
+    ...Object.values(config.env ?? {}),
+    ...Object.values(config.headers ?? {}),
+    ...queryValues
+  ].filter((value) => value.length > 0).sort((left, right) => right.length - left.length);
+  return (message) => {
+    let redacted = message;
+    for (const secret of secrets) redacted = redacted.replaceAll(secret, "<redacted>");
+    return redacted;
+  };
+}
+function renderMcpContent(result) {
+  const blocks = Array.isArray(result.content) ? result.content : [];
+  const parts = [];
+  for (const block of blocks) {
+    if (!block || typeof block !== "object") continue;
+    switch (block.type) {
+      case "text":
+        if (typeof block.text === "string") parts.push(block.text);
+        break;
+      case "image":
+      case "audio":
+        parts.push(`[${block.type}${block.mimeType ? `: ${block.mimeType}` : ""}]`);
+        break;
+      case "resource_link":
+        parts.push(`[resource_link: ${block.uri ?? "unknown"}]`);
+        break;
+      case "resource": {
+        const resource = block.resource;
+        if (resource && typeof resource.text === "string") parts.push(resource.text);
+        else if (resource?.uri) {
+          parts.push(
+            `[resource: ${resource.uri}${resource.mimeType ? ` (${resource.mimeType})` : ""}]`
+          );
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  if (parts.length === 0 && result.structuredContent !== void 0) {
+    parts.push(JSON.stringify(result.structuredContent, null, 2));
+  }
+  return { text: parts.join("\n"), isError: result.isError === true };
+}
+async function listAllTools(client, requestTimeoutMs, signal) {
+  const tools = [];
+  let cursor;
+  do {
+    const page = await client.listTools(cursor ? { cursor } : void 0, {
+      timeout: requestTimeoutMs,
+      signal
+    });
+    for (const tool of page.tools) {
+      tools.push({
+        name: tool.name,
+        description: tool.description ?? "",
+        inputSchema: tool.inputSchema ?? { type: "object", properties: {} }
+      });
+    }
+    cursor = page.nextCursor;
+  } while (cursor);
+  return tools;
+}
+function isRemoteConfig(config) {
+  return config.type === "http" || config.type === "sse" || Boolean(config.url && !config.command);
+}
+function createTransport(name, cfg, options) {
+  if (isRemoteConfig(cfg)) {
+    if (!cfg.url) throw new Error(`MCP server ${name} has no URL`);
+    const url = new URL(cfg.url);
+    const headers = { ...cfg.headers ?? {} };
+    if (cfg.type === "sse") {
+      let protocolVersion;
+      const transport3 = new SSEClientTransport(url, {
+        // The SDK derives the SSE GET headers from requestInit too. Supplying
+        // them here therefore covers both the initial stream and later POSTs.
+        requestInit: { headers }
+      });
+      const sdkSetProtocolVersion = transport3.setProtocolVersion.bind(transport3);
+      transport3.setProtocolVersion = (version) => {
+        protocolVersion = version;
+        sdkSetProtocolVersion(version);
+      };
+      return {
+        transport: transport3,
+        getStderr: () => "",
+        getProtocolVersion: () => protocolVersion
+      };
+    }
+    const transport2 = new StreamableHTTPClientTransport(url, {
+      requestInit: { headers }
+    });
+    return {
+      transport: transport2,
+      getStderr: () => "",
+      getProtocolVersion: () => transport2.protocolVersion
+    };
+  }
+  const transport = new StdioProcessTransport(name, cfg, {
+    maxStderrBytes: options.maxStderrBytes ?? DEFAULT_MAX_STDERR_BYTES,
+    onSpawn: (child) => options.onProcessSpawn?.(name, child)
+  });
+  return {
+    transport,
+    getStderr: () => transport.stderr,
+    getProtocolVersion: () => transport.protocolVersion
+  };
+}
+function registerElicitationHandler(client, name, options) {
+  const onElicit = options.onElicit;
+  if (!onElicit) return;
+  let counter = 0;
+  client.setRequestHandler(
+    ElicitRequestSchema,
+    async (request, extra) => {
+      const params = request.params;
+      if (params.mode === "url") {
+        options.onDiagnostic({
+          level: "warn",
+          message: `MCP server "${name}" requested URL elicitation, which Book does not support`,
+          server: name
+        });
+        return { action: "decline" };
+      }
+      const converted = toElicitationFields(params.requestedSchema);
+      if ("error" in converted) {
+        options.onDiagnostic({
+          level: "warn",
+          message: `Declined an elicitation from MCP server "${name}": ${converted.error}`,
+          server: name
+        });
+        return { action: "decline" };
+      }
+      const response = await onElicit(
+        {
+          id: `${name}:${++counter}`,
+          server: name,
+          message: params.message,
+          fields: converted.fields
+        },
+        { signal: extra?.signal }
+      );
+      if (response.action !== "accept") return { action: response.action };
+      const validated = validateElicitationContent(converted.fields, response.content);
+      if ("error" in validated) {
+        options.onDiagnostic({
+          level: "warn",
+          message: `Discarded an elicitation answer for MCP server "${name}": ${validated.error}`,
+          server: name
+        });
+        return { action: "cancel" };
+      }
+      return { action: "accept", content: validated.content };
+    }
+  );
+}
+async function connectMcpServer(name, cfg, options) {
+  let handle;
+  let liveConnection;
+  let transportClosed = false;
+  const redact = createSecretRedactor(cfg);
+  try {
+    handle = createTransport(name, cfg, options);
+    const { transport, getStderr, getProtocolVersion } = handle;
+    transport.onclose = () => {
+      transportClosed = true;
+      if (!liveConnection || liveConnection.closed) return;
+      liveConnection.closed = true;
+      options.onConnectionClosed?.(name);
+    };
+    transport.onerror = (error) => {
+      options.onDiagnostic({
+        level: "warn",
+        message: redact(`MCP server "${name}" transport error: ${error.message}`),
+        server: name
+      });
+    };
+    const client = new Client(
+      { name: "book", version: getPackageVersion() },
+      { capabilities: options.onElicit ? { elicitation: { form: {} } } : {} }
+    );
+    registerElicitationHandler(client, name, options);
+    await client.connect(transport, {
+      timeout: options.initializationTimeoutMs,
+      signal: options.signal
+    });
+    const supportsTools = client.getServerCapabilities()?.tools !== void 0;
+    const tools = supportsTools ? await listAllTools(client, options.requestTimeoutMs, options.signal) : [];
+    if (transportClosed) throw new Error("connection closed during initialization");
+    const conn = {
+      name,
+      client,
+      process: transport.process,
+      tools,
+      pending: /* @__PURE__ */ new Map(),
+      closed: false,
+      requestCounter: 0,
+      redact,
+      get stderr() {
+        return redact(getStderr());
+      },
+      protocolVersion: getProtocolVersion(),
+      serverInfo: client.getServerVersion(),
+      capabilities: client.getServerCapabilities(),
+      async close() {
+        try {
+          await transport.terminateSession?.();
+        } catch (error) {
+          options.onDiagnostic({
+            level: "warn",
+            message: redact(
+              `Failed to terminate MCP server "${name}" session: ${error instanceof Error ? error.message : String(error)}`
+            ),
+            server: name
+          });
+        } finally {
+          await client.close();
+        }
+      }
+    };
+    liveConnection = conn;
+    if (supportsTools) {
+      let refreshing = false;
+      client.setNotificationHandler(ToolListChangedNotificationSchema, async () => {
+        if (refreshing || conn.closed) return;
+        refreshing = true;
+        try {
+          conn.tools = await listAllTools(client, options.requestTimeoutMs);
+          options.onToolListChanged?.(name);
+        } catch (error) {
+          options.onDiagnostic({
+            level: "warn",
+            message: redact(
+              `Failed to refresh tools for MCP server "${name}": ${error instanceof Error ? error.message : String(error)}`
+            ),
+            server: name
+          });
+        } finally {
+          refreshing = false;
+        }
+      });
+    }
+    return conn;
+  } catch (error) {
+    const message = redact(error instanceof Error ? error.message : String(error));
+    options.onDiagnostic({
+      level: "warn",
+      message: withStderrContext(`Failed to connect to MCP server "${name}": ${message}`, {
+        stderr: redact(handle?.getStderr() ?? "")
+      }),
+      server: name
+    });
+    if (handle?.transport.terminateSession) {
+      await handle.transport.terminateSession().catch(() => {
+      });
+    }
+    await handle?.transport.close().catch(() => {
+    });
+    return null;
+  }
+}
+function buildToolDefinition(conn, tool, requestTimeoutMs) {
+  const prefixedName = `mcp__${conn.name}__${tool.name}`;
+  const live = conn;
+  return {
+    name: prefixedName,
+    description: `[MCP:${conn.name}] ${tool.description || tool.name}`,
+    parameters: tool.inputSchema || { type: "object", properties: {} },
+    execute: async (args, ctx) => {
+      const requestId = ++live.requestCounter;
+      conn.pending.set(requestId, { method: tool.name });
+      try {
+        const result = await conn.client.callTool({ name: tool.name, arguments: args }, void 0, {
+          timeout: requestTimeoutMs,
+          resetTimeoutOnProgress: true,
+          signal: ctx.signal
+        });
+        const rendered = renderMcpContent(result);
+        if (rendered.isError) {
+          return toolFailure(
+            `MCP tool ${prefixedName} failed: ${rendered.text || "the server reported an error"}`,
+            { code: "mcp_tool_error", content: rendered.text }
+          );
+        }
+        return toolSuccess(rendered.text, { data: result });
+      } catch (error) {
+        let message;
+        if (ctx.signal?.aborted) {
+          message = `MCP request aborted: ${tool.name}`;
+        } else if (conn.closed && isMcpErrorWithCode(error, ErrorCode.ConnectionClosed)) {
+          message = `MCP server ${conn.name} disconnected`;
+        } else {
+          message = live.redact(error instanceof Error ? error.message : String(error));
+        }
+        const tail = conn.stderr.trim();
+        return toolFailure(
+          `MCP tool ${prefixedName} failed: ${message}${tail ? ` (stderr: ${tail})` : ""}`,
+          { code: "mcp_tool_failed" }
+        );
+      } finally {
+        conn.pending.delete(requestId);
+      }
+    }
+  };
+}
+function buildMcpToolDefinitions(connections, requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+  const tools = [];
+  for (const conn of connections) {
+    if (conn.closed) continue;
+    for (const tool of conn.tools) tools.push(buildToolDefinition(conn, tool, requestTimeoutMs));
+  }
+  return tools;
+}
+async function connectMcpServers(workspace, options = {}) {
+  const resolved = {
+    ...options,
+    initializationTimeoutMs: options.initializationTimeoutMs ?? DEFAULT_INITIALIZATION_TIMEOUT_MS,
+    requestTimeoutMs: options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS,
+    onDiagnostic: options.onDiagnostic ?? consoleMcpDiagnosticSink
+  };
+  let servers;
+  if (options.servers) {
+    servers = Object.entries(options.servers).map(([name, config]) => ({ name, config }));
+  } else {
+    const declared = resolveMcpServerList(workspace, {
+      home: options.home,
+      onDiagnostic: resolved.onDiagnostic
+    });
+    for (const server of declared) {
+      if (server.source === "user") continue;
+      resolved.onDiagnostic({
+        level: "warn",
+        message: `Skipping project-declared MCP server "${server.name}" (${server.path}): it requires approval, and this caller supplied no approved server list.`,
+        server: server.name
+      });
+    }
+    servers = declared.filter((server) => server.source === "user");
+  }
+  const results = await Promise.allSettled(
+    servers.map(({ name, config }) => connectMcpServer(name, config, resolved))
+  );
+  const connections = [];
+  for (const [index, result] of results.entries()) {
+    if (result.status === "rejected") {
+      const server = servers[index];
+      resolved.onDiagnostic({
+        level: "warn",
+        message: `Failed to connect to MCP server "${server.name}": ${result.reason instanceof Error ? result.reason.message : String(result.reason)}`,
+        server: server.name
+      });
+      continue;
+    }
+    if (!result.value) continue;
+    connections.push(result.value);
+  }
+  return { connections, tools: buildMcpToolDefinitions(connections, resolved.requestTimeoutMs) };
+}
+async function disconnectMcpServers(connections) {
+  const closing = connections.map(async (conn) => {
+    if (conn.closed) return;
+    conn.closed = true;
+    await conn.close().catch(() => {
+    });
+  });
+  await Promise.all(closing);
+}
+
+// src/project-approval-notices.ts
+import { join as join2 } from "path";
+function collectWithheldProjectNotices(input) {
+  if (!input.settingsEnabled) return [];
+  const projectSettings = loadSettingsFile(join2(input.workspace, ".book", "settings.json"));
+  const notices = [];
+  const allow = partitionProjectAllowRules(
+    projectSettings?.permissions?.allow ?? [],
+    input.settings.permissions.projectAllowRules
+  );
+  for (const rule of allow.pending) {
+    notices.push(
+      `\u26A0  Ignoring project-declared permission rule "${rule}": it requires approval. Run \`book doctor\` to see how to grant it.`
+    );
+  }
+  const hooks = partitionProjectHooks(
+    collectDeclaredHooks(projectSettings),
+    input.settings.hooks.projectEntries
+  );
+  if (hooks.pending.length > 0) {
+    const byEvent = /* @__PURE__ */ new Map();
+    for (const hook of hooks.pending) {
+      byEvent.set(hook.event, (byEvent.get(hook.event) ?? 0) + 1);
+    }
+    const summary = [...byEvent].map(([event, count]) => `${event} x${count}`).join(", ");
+    notices.push(
+      `\u26A0  Ignoring ${hooks.pending.length} project-declared hook(s) (${summary}): hooks require approval. Run \`book doctor\` to approve them.`
+    );
+  }
+  return notices;
+}
+
+export {
+  readRunStatus,
+  runHeadless,
+  buildMcpToolDefinitions,
+  connectMcpServers,
+  disconnectMcpServers,
+  collectWithheldProjectNotices
+};
+//# sourceMappingURL=chunk-J7MIZ5CA.js.map