@letrquan/book 0.2.0

package/dist/index.js

@@ -0,0 +1,2582 @@
+#!/usr/bin/env node
+import {
+  installFrameCapture,
+  installInkScrollRenderer
+} from "./chunk-C7D4NJ2D.js";
+import {
+  buildMcpToolDefinitions,
+  collectWithheldProjectNotices,
+  connectMcpServers,
+  disconnectMcpServers,
+  readRunStatus,
+  runHeadless
+} from "./chunk-J7MIZ5CA.js";
+import {
+  SessionStore,
+  resolveSessionBootstrap
+} from "./chunk-V4BOYR52.js";
+import {
+  aggregateToolUse,
+  createDefaultRegistry,
+  formatToolStatsReport,
+  freezeAgentConfig,
+  loadConfig,
+  pruneToolUseRecords,
+  readToolUseRecords
+} from "./chunk-XIFFTATU.js";
+import {
+  EFFORT_LEVELS,
+  applySettingWrite,
+  describeSettingShadow,
+  discoverAgents,
+  estimateUsageCost,
+  getPackageVersion,
+  isEffortLevel,
+  parseEffortLevel,
+  readScopeDocument,
+  resolvePermissionMode,
+  settingsScopeLabel,
+  withBuiltInAgents
+} from "./chunk-A7JLBK2Y.js";
+import "./chunk-KWHQ2XXL.js";
+import "./chunk-VZQXX3WW.js";
+import {
+  discoverCommands
+} from "./chunk-E75IPST5.js";
+import {
+  describeProjectCommandShell,
+  displayableCommandName,
+  partitionProjectCommands,
+  persistProjectCommandChoice,
+  projectCommandFingerprint
+} from "./chunk-5KLVH3PY.js";
+import {
+  formatMcpServerCommand,
+  isValidMcpServerName,
+  resolveMcpServerList
+} from "./chunk-3U5IBM24.js";
+import {
+  evaluateMcpServerApproval,
+  mcpServerFingerprint,
+  mcpServersToRecord,
+  partitionMcpServersByApproval,
+  persistMcpProjectServerChoice
+} from "./chunk-URLQAXTR.js";
+import "./chunk-MAQXCUR4.js";
+import {
+  canonicalToolName
+} from "./chunk-5GDZ22YP.js";
+import "./chunk-EYGD6X2T.js";
+import {
+  DEFAULT_LOCAL_DATA_RETENTION_DAYS,
+  cleanupDebugLogs,
+  createDebugLogger,
+  getDebugLogPath
+} from "./chunk-GTVB4HEM.js";
+import "./chunk-S4XL7HOM.js";
+import "./chunk-7N4J557C.js";
+import {
+  loadSettingsFile,
+  resolveSettings
+} from "./chunk-BTZZUCLI.js";
+import {
+  partitionProjectAllowRules,
+  persistProjectAllowRuleChoice
+} from "./chunk-WKBO5R4O.js";
+import {
+  collectDeclaredHooks,
+  describeDeclaredHook,
+  hookFingerprint,
+  partitionProjectHooks,
+  persistProjectHookChoice
+} from "./chunk-ANSJPYGI.js";
+import "./chunk-DGMQEI6Y.js";
+import "./chunk-5RDRAO4B.js";
+import "./chunk-CAGOB2N4.js";
+import {
+  DEFAULT_SETTINGS,
+  SettingsRepository,
+  formatSettingsDiagnostics,
+  formatSettingsKeyHelp,
+  getNestedValue,
+  parseNumericFlag,
+  redactSettingValue,
+  redactSettingsForDisplay,
+  writeFileAtomic
+} from "./chunk-574C6MQR.js";
+import {
+  resolveBookHome
+} from "./chunk-24AXE6SP.js";
+
+// src/runtime-env.ts
+if (!process.env.NODE_ENV) {
+  process.env.NODE_ENV = "production";
+}
+
+// src/index.ts
+import { InvalidArgumentError, program } from "commander";
+
+// src/cli/status-cmd.ts
+import { join } from "path";
+function isProcessAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function buildRunStatus(record) {
+  const processAlive = isProcessAlive(record.pid);
+  const liveness = record.terminal ? "completed" : record.crash ? "crashed" : processAlive ? "running" : "died";
+  return {
+    liveness,
+    pid: record.pid,
+    processAlive,
+    runId: record.runId,
+    turn: record.turn,
+    elapsedMs: record.elapsedMs,
+    updatedAt: record.updatedAt,
+    lastTool: record.lastTool,
+    currentTodo: record.currentTodo,
+    openTodos: record.openTodos,
+    costUsd: record.costUsd,
+    budgetUsd: record.budgetUsd,
+    freeDiskBytes: record.freeDiskBytes,
+    terminal: record.terminal ? { ...record.terminal } : void 0,
+    crash: record.crash ? { ...record.crash } : void 0
+  };
+}
+function firstUserTurn(transcript) {
+  for (const message of transcript) {
+    if (message.role !== "user") continue;
+    if (message.kind && message.kind !== "conversation") continue;
+    if (message.content.startsWith("[continuation]")) continue;
+    if (message.content.startsWith("[work-state]")) continue;
+    if (message.agentNotifications?.length) continue;
+    return message.content;
+  }
+  return void 0;
+}
+function buildSessionStatus(meta, loaded, runRecord) {
+  const usage = loaded.carriedUsage;
+  const models = loaded.carriedModels ?? [];
+  let costUsd = models.length > 0 && usage ? 0 : null;
+  if (usage) {
+    for (const model of models) {
+      const quote = estimateUsageCost(model, {
+        promptTokens: usage.promptTokens,
+        completionTokens: usage.completionTokens,
+        totalTokens: usage.totalTokens,
+        cacheReadInputTokens: usage.cacheReadInputTokens,
+        cacheCreationInputTokens: usage.cacheCreationInputTokens
+      });
+      if (quote.status !== "known") {
+        costUsd = null;
+        break;
+      }
+      costUsd = Math.max(costUsd ?? 0, quote.costUsd);
+    }
+  }
+  return {
+    sessionId: meta.id,
+    sessionName: meta.name,
+    workspace: meta.cwd,
+    createdAt: meta.createdAt,
+    updatedAt: meta.updatedAt,
+    objective: firstUserTurn(loaded.transcript),
+    transcriptMessages: loaded.transcript.length,
+    contextMessages: loaded.contextHistory.length,
+    compactions: loaded.compactBoundaries.length,
+    generation: loaded.compactBoundaries.at(-1)?.generation ?? 0,
+    usage: usage ? {
+      promptTokens: usage.promptTokens,
+      completionTokens: usage.completionTokens,
+      cacheReadInputTokens: usage.cacheReadInputTokens ?? 0,
+      cacheCreationInputTokens: usage.cacheCreationInputTokens ?? 0
+    } : void 0,
+    costUsd,
+    costModels: models,
+    plan: loaded.plan ? {
+      todos: (loaded.plan.todos ?? []).map((todo) => ({
+        content: todo.content,
+        status: todo.status
+      })),
+      tasks: (loaded.plan.tasks ?? []).map((task) => ({
+        id: task.id,
+        subject: task.subject,
+        status: task.status,
+        blockedBy: task.blockedBy
+      }))
+    } : void 0,
+    run: runRecord ? buildRunStatus(runRecord) : void 0
+  };
+}
+function truncate(text, max) {
+  const single = text.replace(/\s+/g, " ").trim();
+  return single.length <= max ? single : `${single.slice(0, max - 1)}\u2026`;
+}
+function since(timestamp, now) {
+  const minutes = Math.max(0, Math.round((now - timestamp) / 6e4));
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.round(minutes / 60);
+  return hours < 48 ? `${hours}h ago` : `${Math.round(hours / 24)}d ago`;
+}
+function duration(ms) {
+  const seconds = Math.max(0, Math.round(ms / 1e3));
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ${seconds % 60}s`;
+  return `${Math.floor(minutes / 60)}h ${minutes % 60}m`;
+}
+function gibibytes(bytes) {
+  return `${(bytes / 1024 ** 3).toFixed(1)} GiB`;
+}
+function renderRunStatus(run, now) {
+  const lines = [];
+  const headline = {
+    running: `running (pid ${run.pid})`,
+    completed: `finished \u2014 ${run.terminal?.status ?? "unknown"} (${run.terminal?.reason ?? "no reason recorded"})`,
+    crashed: "crashed without a terminal outcome",
+    died: `no longer running, and recorded no outcome (pid ${run.pid} is gone)`
+  };
+  lines.push(`Run: ${headline[run.liveness]}`);
+  if (run.terminal?.message) lines.push(`  ${run.terminal.message}`);
+  if (run.crash) lines.push(`  ${run.crash.message}`);
+  lines.push(`  turn ${run.turn}  \u2022  elapsed ${duration(run.elapsedMs)}`);
+  lines.push(`  last update: ${since(run.updatedAt, now)}`);
+  if (run.liveness === "running" && now - run.updatedAt > STALE_RUN_MS) {
+    lines.push(
+      `  \u26A0 the process is alive but has not written a turn boundary in ${duration(now - run.updatedAt)} \u2014 it may be wedged on a long tool call or a permission prompt.`
+    );
+  }
+  if (run.lastTool) lines.push(`  last tool: ${run.lastTool}`);
+  if (run.currentTodo) lines.push(`  in progress: ${truncate(run.currentTodo, 120)}`);
+  if (run.openTodos > 0) lines.push(`  open todos: ${run.openTodos}`);
+  if (run.costUsd !== null) {
+    lines.push(
+      `  spend: ~$${run.costUsd.toFixed(4)}` + (run.budgetUsd !== void 0 ? ` of $${run.budgetUsd.toFixed(2)} budget` : "")
+    );
+  }
+  if (run.freeDiskBytes !== void 0) lines.push(`  free disk: ${gibibytes(run.freeDiskBytes)}`);
+  return lines;
+}
+var STALE_RUN_MS = 15 * 6e4;
+function renderSessionStatus(status, now = Date.now()) {
+  const lines = [];
+  lines.push(`Session: ${status.sessionName ?? status.sessionId}`);
+  if (status.sessionName) lines.push(`  id: ${status.sessionId}`);
+  lines.push(`  workspace: ${status.workspace}`);
+  lines.push(`  last activity: ${since(status.updatedAt, now)}`);
+  lines.push("");
+  if (status.run) {
+    lines.push(...renderRunStatus(status.run, now));
+    lines.push("");
+  }
+  lines.push(
+    status.objective ? `Objective: ${truncate(status.objective, 300)}` : "Objective: (no user turn recorded)"
+  );
+  lines.push("");
+  lines.push(
+    `History: ${status.transcriptMessages} messages, ${status.contextMessages} in context` + (status.compactions > 0 ? `  \u2022  ${status.compactions} compaction${status.compactions === 1 ? "" : "s"} (generation ${status.generation})` : "  \u2022  never compacted")
+  );
+  if (status.usage) {
+    const { promptTokens, completionTokens, cacheReadInputTokens, cacheCreationInputTokens } = status.usage;
+    lines.push(
+      `Tokens: prompt ${promptTokens.toLocaleString()}  \u2022  completion ${completionTokens.toLocaleString()}  \u2022  cache read ${cacheReadInputTokens.toLocaleString()}  \u2022  cache write ${cacheCreationInputTokens.toLocaleString()}`
+    );
+    lines.push(
+      status.costUsd !== null ? `Spend: ~$${status.costUsd.toFixed(4)} (upper bound across ${status.costModels.join(", ") || "unknown model"})` : "Spend: (pricing unknown for at least one model used)"
+    );
+  } else {
+    lines.push("Tokens: (none recorded \u2014 this session predates usage records, or never ran)");
+  }
+  if (status.plan) {
+    const open = status.plan.todos.filter((todo) => todo.status !== "completed");
+    const openTasks = status.plan.tasks.filter(
+      (task) => task.status !== "completed" && task.status !== "deleted"
+    );
+    lines.push("");
+    lines.push(`Plan: ${open.length} open todo(s), ${openTasks.length} open task(s)`);
+    for (const todo of open.slice(0, 10)) lines.push(`  [${todo.status}] ${todo.content}`);
+    for (const task of openTasks.slice(0, 10)) {
+      const blockers = task.blockedBy.length ? ` (blocked by ${task.blockedBy.join(", ")})` : "";
+      lines.push(`  [${task.status}] ${task.subject}${blockers}`);
+    }
+  } else {
+    lines.push("");
+    lines.push("Plan: (none persisted)");
+  }
+  return lines.join("\n");
+}
+function runStatusCommand(options) {
+  const stdout = options.stdout ?? process.stdout;
+  const home = options.home ?? resolveBookHome();
+  const store = options.store ?? new SessionStore(join(home, "sessions"));
+  const meta = options.session ? store.findById(options.session) ?? store.findByName(options.session) : store.mostRecentInCwd(options.workspace);
+  if (!meta) {
+    stdout.write(
+      options.session ? `No session found matching "${options.session}".
+` : `No session has run in ${options.workspace} yet.
+`
+    );
+    return 1;
+  }
+  const status = buildSessionStatus(meta, store.load(meta.id), readRunStatus(meta.id, home));
+  stdout.write(
+    options.json ? `${JSON.stringify(status, null, 2)}
+` : `${renderSessionStatus(status)}
+`
+  );
+  return 0;
+}
+
+// src/cli/exit.ts
+var exitFn = (code) => {
+  process.exit(code);
+};
+var exiting = false;
+function exit(code = 0) {
+  exiting = true;
+  exitFn(code);
+}
+function isExiting() {
+  return exiting;
+}
+
+// src/cli/doctor.ts
+import { resolve } from "path";
+
+// src/agents/diagnostics.ts
+var MUTATION_TOOLS = /* @__PURE__ */ new Set([
+  "ApplyPatch",
+  "Write",
+  "Edit",
+  "MultiEdit",
+  "NotebookEdit",
+  "Bash",
+  "Check"
+]);
+function validateModel(profile, model, config) {
+  if (!model || model === "inherit") return void 0;
+  const slash = model.indexOf("/");
+  if (slash === 0 || slash === model.length - 1) {
+    return {
+      code: "invalid-model",
+      message: `${profile} uses invalid model "${model}"; expected a model or provider/model reference.`
+    };
+  }
+  if (slash > 0) {
+    const providerId = model.slice(0, slash);
+    const modelId = model.slice(slash + 1);
+    const provider = config.settings.provider[providerId];
+    if (provider && Object.keys(provider.models).length > 0 && !provider.models[modelId]) {
+      return {
+        code: "invalid-model",
+        message: `${profile} references ${model}, which is not in provider ${providerId}'s model catalog.`
+      };
+    }
+  }
+  return void 0;
+}
+function collectAgentDiagnostics(config, profiles) {
+  const diagnostics = [];
+  const counts = /* @__PURE__ */ new Map();
+  for (const profile of profiles) counts.set(profile.name, (counts.get(profile.name) ?? 0) + 1);
+  for (const [name, count] of counts) {
+    if (count > 1) {
+      diagnostics.push({
+        code: "duplicate-profile",
+        message: `${name} is defined ${count} times; keep one profile definition per name.`
+      });
+    }
+  }
+  const profileNames = new Set(profiles.map((profile) => profile.name));
+  for (const [name, override] of Object.entries(config.settings.agents.profiles)) {
+    if (!profileNames.has(name)) {
+      diagnostics.push({
+        code: "missing-profile",
+        message: `agents.profiles.${name} has settings but no matching agent definition.`
+      });
+    }
+    const modelDiagnostic = validateModel(name, override.model, config);
+    if (modelDiagnostic) diagnostics.push(modelDiagnostic);
+  }
+  for (const profile of profiles) {
+    if (profile.suppressedOverride) {
+      diagnostics.push({
+        code: "reserved-profile",
+        message: `${profile.name} is a reserved built-in agent, so the ${profile.suppressedOverride} definition of the same name is ignored. Rename it, or tune model/effort through agents.profiles.${profile.name}.`
+      });
+    }
+    for (const tool of profile.unknownTools ?? []) {
+      diagnostics.push({
+        code: "unknown-tool",
+        message: `${profile.name} declares unsupported tool ${tool}; import or edit the definition.`
+      });
+    }
+    if (profile.isolation === "workspace-readonly") {
+      const mutations = profile.allowedTools.filter(
+        (tool) => MUTATION_TOOLS.has(canonicalToolName(tool.split("(")[0].trim()))
+      );
+      if (mutations.length > 0) {
+        diagnostics.push({
+          code: "readonly-mutation",
+          message: `${profile.name} is read-only but declares mutation tools: ${mutations.join(", ")}. They will be hard-filtered.`
+        });
+      }
+    }
+    if (!config.settings.agents.profiles[profile.name]?.model) {
+      const modelDiagnostic = validateModel(profile.name, profile.model, config);
+      if (modelDiagnostic) diagnostics.push(modelDiagnostic);
+    }
+  }
+  return diagnostics;
+}
+
+// src/cli/doctor.ts
+var SHELL_SAFE_BARE = /^[A-Za-z0-9_@%+=:,./\\-]+$/;
+function shellArgument(value) {
+  if (SHELL_SAFE_BARE.test(value)) return value;
+  if (/["`$\n\r]/.test(value) || value.endsWith("\\")) return null;
+  return `"${value}"`;
+}
+function trustCommandLine(workspace, rest) {
+  if (resolve(workspace) === resolve(process.cwd())) return `book trust ${rest}`;
+  const quoted = shellArgument(workspace);
+  return quoted === null ? null : `book trust ${rest} --workspace ${quoted}`;
+}
+function approvalHint(label, workspace, rest) {
+  const command = trustCommandLine(workspace, rest);
+  return command === null ? `${label} book trust ${rest} (run it from ${workspace})` : `${label} ${command}`;
+}
+function formatRelativeTime(timestamp, now = Date.now()) {
+  const elapsedMs = Math.max(0, now - timestamp);
+  const minutes = Math.floor(elapsedMs / 6e4);
+  if (minutes < 1) return "just now";
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+function describeCredentials(config) {
+  return config.apiKey ? "API key resolved" : "not resolved - set BOOK_API_KEY or set provider.<id>.apiKey in settings";
+}
+var ABSENT_LAYER = "\0absent-settings-layer";
+async function settingsLayers(workspace) {
+  const { join: join8, resolve: resolve4 } = await import("path");
+  const root = resolve4(workspace);
+  return [
+    ["User", join8(resolveBookHome(), "settings.json")],
+    ["Project", join8(root, ".book", "settings.json")],
+    ["Local", join8(root, ".book", "settings.local.json")]
+  ];
+}
+async function attributeFailingLayer(workspace) {
+  const layers = await settingsLayers(workspace);
+  for (let included = 0; included <= layers.length; included++) {
+    const [userSettingsPath, projectSettingsPath, localSettingsPath] = layers.map(
+      ([, path], index) => index < included ? path : ABSENT_LAYER
+    );
+    try {
+      loadConfig(workspace, {
+        allowMissingApiKey: true,
+        // A probe must not write: migrations are the real load's business.
+        runMigrations: false,
+        settingsPaths: { userSettingsPath, projectSettingsPath, localSettingsPath }
+      });
+    } catch {
+      return included === 0 ? void 0 : layers[included - 1][0];
+    }
+  }
+  return void 0;
+}
+async function reportUnloadableConfig(workspace, error) {
+  const { existsSync: existsSync4 } = await import("fs");
+  const { resolve: resolve4 } = await import("path");
+  console.log("Book Doctor");
+  console.log("===========");
+  console.log();
+  console.log("Version:", getPackageVersion());
+  console.log("Node:", process.version);
+  console.log("Platform:", process.platform, process.arch);
+  console.log("Workspace:", resolve4(workspace));
+  console.log();
+  console.log("Configuration: FAILED TO LOAD");
+  console.log("  " + (error instanceof Error ? error.message : String(error)));
+  console.log();
+  console.log("  No other check can run until the configuration loads.");
+  const culprit = await attributeFailingLayer(workspace);
+  console.log("  Settings layers, in the order they are applied:");
+  for (const [label, path] of await settingsLayers(workspace)) {
+    const marker = existsSync4(path) ? "[x]" : "[ ]";
+    const blame = label === culprit ? "  <- the failure appears with this layer" : "";
+    console.log("    " + marker + " " + label + ": " + path + blame);
+  }
+  console.log();
+  if (culprit) {
+    console.log(`  The ${culprit} layer is where the configuration stops loading.`);
+  } else {
+    console.log("  No single layer accounts for it: check the environment and .bookrc.json.");
+  }
+  console.log("  Run `book doctor --no-settings` to report the rest with every layer skipped.");
+}
+async function runDoctorCommand(workspace, options = {}) {
+  let config;
+  try {
+    config = loadConfig(workspace, {
+      // --no-settings is the way past a layer doctor cannot otherwise get around;
+      // migrations would rewrite settings this run has been told to ignore.
+      noSettings: options.noSettings,
+      runMigrations: !options.noSettings,
+      allowMissingApiKey: true
+    });
+  } catch (error) {
+    await reportUnloadableConfig(workspace, error);
+    return;
+  }
+  const settings = config.settings;
+  console.log("Book Doctor");
+  console.log("===========");
+  console.log();
+  console.log("Version:", getPackageVersion());
+  console.log("Node:", process.version);
+  console.log("Platform:", process.platform, process.arch);
+  console.log("Workspace:", config.workspace);
+  console.log("Model:", config.model, "(" + config.baseUrl + ")");
+  if (config.modelProviderWarning) console.log("  \u26A0 " + config.modelProviderWarning);
+  console.log("Credentials:", describeCredentials(config));
+  const {
+    collectRemovedSettingNotices,
+    collectRemovedEnvNotices,
+    removedAuthStoreNotice,
+    readSettingsDocumentForNotices
+  } = await import("./settings-removed-JWWPT4WA.js");
+  const { settingsLayerPaths } = await import("./settings-loader-M2QP5TX2.js");
+  const { join: joinPath } = await import("path");
+  const { existsSync: fileExists } = await import("fs");
+  const removedNotices = [
+    ...settingsLayerPaths(workspace, void 0, {}).flatMap(
+      (path) => collectRemovedSettingNotices(readSettingsDocumentForNotices(path)).map(
+        (notice) => `${notice.key} in ${path}: ${notice.message}`
+      )
+    ),
+    ...collectRemovedEnvNotices(process.env).map(
+      (notice) => `${notice.key} is set: ${notice.message}`
+    )
+  ];
+  const authStorePath = joinPath(resolveBookHome(), "auth.json");
+  if (fileExists(authStorePath)) removedNotices.push(removedAuthStoreNotice(authStorePath));
+  if (removedNotices.length > 0) {
+    console.log();
+    console.log("Removed features still configured on this machine:");
+    for (const notice of removedNotices) console.log(`  [!] ${notice}`);
+  }
+  console.log();
+  console.log("Settings layers:");
+  const { existsSync: existsSync4 } = await import("fs");
+  const { join: join8 } = await import("path");
+  for (const [label, path] of await settingsLayers(config.workspace)) {
+    const marker = options.noSettings ? "[-]" : existsSync4(path) ? "[x]" : "[ ]";
+    console.log("  " + marker + " " + label + ": " + path);
+  }
+  if (options.noSettings) {
+    console.log("  (--no-settings: every layer skipped, defaults reported below)");
+  }
+  console.log();
+  const perms = settings.permissions;
+  console.log("Permissions:");
+  console.log("  Allow rules: " + perms.allow.length);
+  console.log("  Ask rules:   " + perms.ask.length);
+  console.log("  Deny rules:  " + perms.deny.length);
+  const { loadSettingsFile: loadSettingsFile2 } = await import("./settings-loader-M2QP5TX2.js");
+  const { partitionProjectAllowRules: partitionProjectAllowRules2 } = await import("./permission-approvals-76PVREFD.js");
+  const projectSettings = loadSettingsFile2(join8(config.workspace, ".book", "settings.json"));
+  const projectAllow = partitionProjectAllowRules2(
+    projectSettings?.permissions?.allow ?? [],
+    perms.projectAllowRules
+  );
+  if (projectAllow.approved.length + projectAllow.pending.length + projectAllow.rejected.length > 0) {
+    console.log("  Project-declared allow rules (require approval):");
+    for (const rule of projectAllow.approved) console.log("    [x] " + rule);
+    for (const rule of projectAllow.rejected) console.log("    [-] " + rule + " (rejected)");
+    for (const rule of projectAllow.pending) console.log("    [!] " + rule + " (not in effect)");
+    if (projectAllow.pending.length > 0) {
+      console.log(approvalHint("    Approve one:", config.workspace, "rule <rule>"));
+      console.log(
+        approvalHint("    Approve all pending:", config.workspace, "rule --all-pending") + " (add --reject to refuse)"
+      );
+    }
+  }
+  console.log();
+  const { discoverCommands: discoverCommands2 } = await import("./loader-4IDS2RIE.js");
+  const { partitionProjectCommands: partitionProjectCommands2, describeProjectCommandShell: describeProjectCommandShell2, displayableCommandName: displayableCommandName2 } = await import("./command-approvals-6Y57VCWZ.js");
+  const gatedCommands = partitionProjectCommands2(discoverCommands2(config.workspace), settings);
+  if (gatedCommands.approved.length + gatedCommands.pending.length + gatedCommands.rejected.length > 0) {
+    console.log("Project commands that run shell (require approval):");
+    for (const command of gatedCommands.approved)
+      console.log("  [x] /" + displayableCommandName2(command.name));
+    for (const command of gatedCommands.rejected)
+      console.log("  [-] /" + displayableCommandName2(command.name) + " (rejected)");
+    for (const command of gatedCommands.pending) {
+      console.log("  [!] /" + displayableCommandName2(command.name) + " (refused until approved)");
+      for (const line of describeProjectCommandShell2(command)) console.log("        " + line);
+    }
+    if (gatedCommands.pending.length > 0) {
+      console.log(approvalHint("  Approve one:", config.workspace, "command <name>"));
+      console.log(
+        approvalHint("  Approve all pending:", config.workspace, "command --all-pending") + " (add --reject to refuse)"
+      );
+    }
+    console.log();
+  }
+  const hooks = settings.hooks;
+  const hookLists = Object.entries(hooks).filter(
+    (pair) => Array.isArray(pair[1])
+  );
+  let hookTotal = 0;
+  for (const [, entries] of hookLists) hookTotal += entries.length;
+  console.log("Hooks:");
+  for (const [event, entries] of hookLists) {
+    if (entries.length > 0) console.log("  " + event + ": " + entries.length);
+  }
+  if (hookTotal === 0) console.log("  (none)");
+  const { collectDeclaredHooks: collectDeclaredHooks2, describeDeclaredHook: describeDeclaredHook2, partitionProjectHooks: partitionProjectHooks2 } = await import("./hook-approvals-CTUFKEJT.js");
+  const declaredProjectHooks = collectDeclaredHooks2(projectSettings);
+  if (declaredProjectHooks.length > 0) {
+    const hookPartition = partitionProjectHooks2(
+      declaredProjectHooks,
+      settings.hooks.projectEntries
+    );
+    console.log("  Project-declared hooks (require approval):");
+    const groups = [
+      { mark: "[x]", suffix: "", hooks: hookPartition.approved },
+      { mark: "[-]", suffix: " (rejected)", hooks: hookPartition.rejected },
+      { mark: "[!]", suffix: " (not in effect)", hooks: hookPartition.pending }
+    ];
+    for (const group of groups) {
+      for (const hook of group.hooks) {
+        const described = describeDeclaredHook2(hook);
+        console.log("    " + group.mark + " " + described.headline + group.suffix);
+        for (const detail of described.details) console.log("          " + detail);
+      }
+    }
+    if (hookPartition.pending.length > 0) {
+      console.log(approvalHint("    Approve one:", config.workspace, "hook <fingerprint>"));
+      console.log(
+        approvalHint("    Approve all pending:", config.workspace, "hook --all-pending") + " (add --reject to refuse)"
+      );
+    }
+  }
+  console.log();
+  const { formatMcpServerCommand: formatMcpServerCommand2, resolveMcpServerList: resolveMcpServerList2 } = await import("./mcp-config-YIJIES2C.js");
+  const { evaluateMcpServerApproval: evaluateMcpServerApproval2 } = await import("./mcp-approvals-WNPH65BK.js");
+  const mcpServers = resolveMcpServerList2(config.workspace);
+  console.log("MCP Servers:");
+  for (const server of mcpServers) {
+    const trust = server.source === "user" ? "user" : `project: ${evaluateMcpServerApproval2(settings, server)}`;
+    console.log("  " + server.name + ": " + formatMcpServerCommand2(server.config) + ` [${trust}]`);
+  }
+  if (mcpServers.length === 0) console.log("  (none)");
+  console.log();
+  const { createSandbox, sandboxPolicySummary } = await import("./sandbox-CNVAQDA7.js");
+  const { hasAdjudicationPolicy } = await import("./permissions-CHCKTFQQ.js");
+  const sandbox = createSandbox(settings.sandbox);
+  const policy = sandboxPolicySummary(settings.sandbox, {
+    sandboxActive: sandbox !== null,
+    adjudicationConfigured: hasAdjudicationPolicy(settings)
+  });
+  console.log("Sandbox:");
+  console.log("  Enabled: " + settings.sandbox.enabled);
+  console.log("  Available: " + (sandbox !== null));
+  if (sandbox) console.log("  Enforcing: " + sandbox.describe());
+  console.log("  Excluded commands: " + settings.sandbox.excludedCommands.length);
+  console.log("  Unsandboxed commands: " + policy.unsandboxedCommands);
+  console.log("  Auto-allow Bash: " + policy.autoAllowBash);
+  console.log();
+  const { describeShell, resolveShell } = await import("./shell-selection-V6QAYXPX.js");
+  const shell = config.shell ?? resolveShell({ requested: settings.shell });
+  console.log("Shell:");
+  console.log("  Bash tool runs: " + describeShell(shell));
+  console.log("  Selected by: " + shell.source);
+  if (shell.warning) console.log(`  [!] ${shell.warning}`);
+  console.log();
+  console.log("Managed agents:");
+  const agentDiagnostics = collectAgentDiagnostics(
+    config,
+    withBuiltInAgents(discoverAgents(config.workspace))
+  );
+  if (agentDiagnostics.length === 0) {
+    console.log("  [x] Profiles and overrides look valid");
+  } else {
+    for (const diagnostic of agentDiagnostics) {
+      console.log(`  [!] ${diagnostic.message}`);
+    }
+  }
+  for (const directory of [
+    join8(config.workspace, ".claude", "agents"),
+    join8(config.workspace, ".agents", "agents")
+  ]) {
+    if (existsSync4(directory)) {
+      console.log(
+        `  [!] Third-party definitions found at ${directory}; preview them with /agents import ${directory}.`
+      );
+    }
+  }
+  console.log();
+  const { createModelWindowStore } = await import("./model-window-store-YFVNXCIP.js");
+  const windowStore = createModelWindowStore();
+  const allLearned = windowStore.all();
+  const learnedModels = Object.keys(allLearned);
+  console.log("Learned context windows:");
+  if (learnedModels.length === 0) {
+    console.log("  (none)");
+  } else {
+    for (const modelName of learnedModels) {
+      const entry = windowStore.getEntry(modelName) ?? allLearned[modelName];
+      console.log(
+        `  ${modelName}: ${entry.contextWindow.toLocaleString()} tokens (${formatRelativeTime(entry.learnedAt)})`
+      );
+    }
+  }
+  console.log();
+  console.log("Environment:");
+  for (const key of ["BOOK_API_KEY", "BOOK_BASE_URL", "BOOK_MODEL", "BOOK_WORKSPACE"]) {
+    const val = process.env[key];
+    if (key === "BOOK_API_KEY" && val) {
+      console.log("  " + key + ": *** (set)");
+    } else {
+      console.log("  " + key + ": " + (val || "(not set)"));
+    }
+  }
+}
+
+// src/cli/tool-stats.ts
+var DAY_MS = 864e5;
+async function runToolStatsCommand(options) {
+  const settings = resolveSettings(options.workspace);
+  const retentionDays = settings.observability.toolTelemetryRetentionDays;
+  let windowDays;
+  if (options.all) {
+    windowDays = void 0;
+  } else if (options.since !== void 0) {
+    const parsed = Number(options.since);
+    windowDays = Number.isFinite(parsed) ? Math.max(0, parsed) : retentionDays;
+  } else {
+    windowDays = retentionDays;
+  }
+  const cutoffTs = windowDays === void 0 ? 0 : Date.now() - windowDays * DAY_MS;
+  if (options.prune) {
+    const result = await pruneToolUseRecords(cutoffTs);
+    console.error(
+      `Pruned ${result.dropped} record${result.dropped === 1 ? "" : "s"} older than ${windowDays ?? 0} days (${result.kept} kept).`
+    );
+  }
+  const all = await readToolUseRecords();
+  const records = all.filter((record) => (record.ts ?? 0) >= cutoffTs);
+  const aggregate = aggregateToolUse(records);
+  if (options.json) {
+    console.log(JSON.stringify(aggregate, null, 2));
+    return;
+  }
+  console.log(formatToolStatsReport(aggregate));
+  if (windowDays !== void 0 && aggregate.totalCalls > 0) {
+    console.log(
+      `
+(Window: last ${windowDays} days. Use --all for full history, --since <days> to change.)`
+    );
+  }
+}
+
+// src/cli/config-cmd.ts
+async function runConfigCommand(workspace, action, key, value, settingsOptions = {}) {
+  const resolveMergedSettings = () => settingsOptions.noSettings ? structuredClone(DEFAULT_SETTINGS) : resolveSettings(workspace, settingsOptions.settingsOverridePath);
+  const scopeRead = settingsOptions.scope ? readScopeDocument(settingsOptions.scope, workspace) : void 0;
+  if (!action || action === "list") {
+    if (scopeRead) {
+      console.log(`${settingsScopeLabel(scopeRead.scope)} settings (${scopeRead.path}):`);
+      if (scopeRead.status === "unreadable") {
+        console.error(`Could not read it: ${scopeRead.error ?? "unknown error"}`);
+        exit(1);
+      }
+      console.log(
+        scopeRead.status === "present" ? JSON.stringify(redactSettingsForDisplay(scopeRead.document), null, 2) : "No settings file at this scope yet."
+      );
+      return;
+    }
+    console.log("Resolved settings:");
+    console.log(JSON.stringify(redactSettingsForDisplay(resolveMergedSettings()), null, 2));
+    return;
+  }
+  if (action === "get") {
+    if (!key) {
+      console.error("Usage: book config get <key>");
+      exit(1);
+    }
+    if (scopeRead?.status === "unreadable") {
+      console.error(
+        `Could not read ${settingsScopeLabel(scopeRead.scope)} settings (${scopeRead.path}): ${scopeRead.error ?? "unknown error"}`
+      );
+      exit(1);
+    }
+    const source = scopeRead ? scopeRead.document : resolveMergedSettings();
+    const val = getNestedValue(source, key);
+    if (val === void 0) {
+      console.log(
+        scopeRead ? `Key ${key} is not set in ${settingsScopeLabel(scopeRead.scope)} settings (${scopeRead.path}).` : "Key " + key + " is not set (no value)."
+      );
+    } else {
+      console.log(JSON.stringify(redactSettingValue(key, val), null, 2));
+    }
+    return;
+  }
+  if (action === "set") {
+    if (!key || value === void 0) {
+      console.error("Usage: book config set <key> <value>");
+      exit(1);
+    }
+    let parsedValue;
+    try {
+      parsedValue = JSON.parse(value);
+    } catch {
+      parsedValue = value;
+    }
+    const scope = settingsOptions.scope ?? "user";
+    const result = applySettingWrite({
+      workspace,
+      key,
+      value: parsedValue,
+      scope,
+      settingsOverridePath: settingsOptions.settingsOverridePath,
+      noSettings: settingsOptions.noSettings
+    });
+    if (!result.ok) {
+      console.error(result.error);
+      exit(1);
+      return;
+    }
+    console.log(
+      "Set " + key + " = " + JSON.stringify(redactSettingValue(key, result.value)) + " in " + settingsScopeLabel(result.scope) + " settings (" + result.path + ")"
+    );
+    for (const shadow of result.shadowedBy) {
+      console.warn(`\u26A0  ${describeSettingShadow(shadow, key)}`);
+    }
+    return;
+  }
+  if (action === "unset") {
+    if (!key) {
+      console.error("Usage: book config unset <key>");
+      exit(1);
+    }
+    const scope = settingsOptions.scope ?? "user";
+    const layer = readScopeDocument(scope, workspace);
+    if (layer.status === "unreadable") {
+      console.error(
+        `Could not read ${settingsScopeLabel(scope)} settings (${layer.path}): ${layer.error ?? "unknown error"}`
+      );
+      exit(1);
+    }
+    if (layer.status === "absent" || getNestedValue(layer.document, key) === void 0) {
+      console.log(
+        `${key} is not set in ${settingsScopeLabel(scope)} settings (${layer.path}); nothing to remove.`
+      );
+      return;
+    }
+    const result = new SettingsRepository(layer.path).remove([key]);
+    if (!result.ok) {
+      console.error(formatSettingsDiagnostics(result.diagnostics));
+      exit(1);
+    }
+    console.log(`Removed ${key} from ${settingsScopeLabel(scope)} settings (${result.path})`);
+    return;
+  }
+  console.error(
+    "Unknown action: " + action + ". Use: get <key>, set <key> <value>, unset <key>, or list"
+  );
+  exit(1);
+}
+
+// src/cli/trust-cmd.ts
+import { join as join2 } from "path";
+function fail(message) {
+  console.error(message);
+  return exit(1);
+}
+async function runTrustCommand(kind, target, options) {
+  const workspace = options.workspace;
+  const choice = options.reject ? "rejected" : "approved";
+  const verb = options.reject ? "Rejected" : "Approved";
+  if (options.allPending && target !== void 0) {
+    fail(`book trust ${kind}: pass either a target or --all-pending, not both`);
+  }
+  if (!options.allPending && target === void 0) {
+    fail(
+      `book trust ${kind}: name what to trust, or pass --all-pending. Run \`book doctor\` to list what is withheld.`
+    );
+  }
+  let settings;
+  try {
+    settings = resolveSettings(workspace);
+  } catch (error) {
+    return fail(
+      `book trust ${kind}: cannot read settings for ${workspace}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const projectSettings = loadSettingsFile(join2(workspace, ".book", "settings.json"));
+  const decisions = [];
+  if (kind === "command") {
+    const partition = partitionProjectCommands(discoverCommands(workspace), settings);
+    const push = (command) => {
+      if (!options.reject) {
+        console.log(`/${displayableCommandName(command.name)} runs:`);
+        for (const line of describeProjectCommandShell(command)) console.log(`  ${line}`);
+      }
+      decisions.push({
+        key: command.name,
+        label: `/${displayableCommandName(command.name)}`,
+        fingerprint: projectCommandFingerprint(command.body)
+      });
+    };
+    if (options.allPending) {
+      if (partition.pending.length === 0) {
+        console.log(`No project commands are awaiting a decision in ${workspace}.`);
+        return;
+      }
+      for (const command of partition.pending) push(command);
+    } else {
+      const name = target.replace(/^\//, "");
+      const decidable = [...partition.pending, ...partition.approved, ...partition.rejected];
+      const command = decidable.find((candidate) => candidate.name === name);
+      if (!command) {
+        const known = partition.pending.map((pending) => `  /${displayableCommandName(pending.name)}`).join("\n");
+        return fail(
+          `book trust command: ${workspace} has no project command "${name}" that runs shell.` + (known ? `
+Awaiting a decision:
+${known}` : "\nNothing is awaiting a decision.")
+        );
+      }
+      push(command);
+    }
+  } else if (kind === "hook") {
+    const declared = collectDeclaredHooks(projectSettings);
+    const byFingerprint = new Map(
+      declared.map((hook) => [hookFingerprint(hook.event, hook.entry), hook])
+    );
+    const partition = partitionProjectHooks(declared, settings.hooks.projectEntries);
+    if (options.allPending) {
+      if (partition.pending.length === 0) {
+        console.log(`No project-declared hooks are awaiting a decision in ${workspace}.`);
+        return;
+      }
+      for (const hook of partition.pending) {
+        const fingerprint = hookFingerprint(hook.event, hook.entry);
+        decisions.push({ key: fingerprint, label: describeDeclaredHook(hook).headline });
+      }
+    } else {
+      const hook = byFingerprint.get(target);
+      if (!hook) {
+        const known = partition.pending.map(
+          (pending) => `  ${hookFingerprint(pending.event, pending.entry)}  ${describeDeclaredHook(pending).headline}`
+        ).join("\n");
+        return fail(
+          `book trust hook: no project-declared hook in ${workspace} has fingerprint "${target}".` + (known ? `
+Awaiting a decision:
+${known}` : "\nNothing is awaiting a decision.")
+        );
+      }
+      decisions.push({ key: target, label: describeDeclaredHook(hook).headline });
+    }
+  } else {
+    const declared = projectSettings?.permissions?.allow ?? [];
+    const partition = partitionProjectAllowRules(declared, settings.permissions.projectAllowRules);
+    if (options.allPending) {
+      if (partition.pending.length === 0) {
+        console.log(`No project-declared allow rules are awaiting a decision in ${workspace}.`);
+        return;
+      }
+      for (const rule of partition.pending) decisions.push({ key: rule, label: rule });
+    } else {
+      if (!declared.includes(target)) {
+        const known = partition.pending.map((rule) => `  ${rule}`).join("\n");
+        return fail(
+          `book trust rule: ${workspace} declares no project allow rule "${target}".` + (known ? `
+Awaiting a decision:
+${known}` : "\nNothing is awaiting a decision.")
+        );
+      }
+      decisions.push({ key: target, label: target });
+    }
+  }
+  const failures = [];
+  for (const decision of decisions) {
+    const result = kind === "command" ? persistProjectCommandChoice(workspace, decision.key, decision.fingerprint, choice) : kind === "hook" ? persistProjectHookChoice(workspace, decision.key, choice) : persistProjectAllowRuleChoice(workspace, decision.key, choice);
+    if (result.ok) console.log(`${verb} ${decision.label}`);
+    else failures.push(`${decision.label}: ${result.error ?? "unknown error"}`);
+  }
+  if (failures.length > 0) {
+    fail(
+      `Failed to record ${failures.length} decision(s):
+${failures.map((f) => `  ${f}`).join("\n")}`
+    );
+  }
+}
+
+// src/cli/run.ts
+import { render } from "ink";
+import { createElement } from "react";
+
+// src/mcp-host.ts
+var log = createDebugLogger("mcp");
+var MAX_EVENTS = 50;
+var McpSessionHost = class {
+  constructor(workspace, settings, options = {}) {
+    this.workspace = workspace;
+    this.settings = settings;
+    this.options = options;
+    this.persistChoice = options.persistChoice ?? persistMcpProjectServerChoice;
+  }
+  workspace;
+  settings;
+  options;
+  states = /* @__PURE__ */ new Map();
+  connections = [];
+  listeners = /* @__PURE__ */ new Set();
+  events = [];
+  abortController = new AbortController();
+  persistChoice;
+  elicitationHandler;
+  nextEventId = 1;
+  snapshot = { servers: [], pendingApprovals: [], events: [] };
+  started = false;
+  disposed = false;
+  /** Resolve declared servers and begin connecting every already-trusted one. */
+  start() {
+    if (this.started || this.disposed) return;
+    this.started = true;
+    const servers = resolveMcpServerList(this.workspace, {
+      home: this.options.home,
+      onDiagnostic: (diagnostic) => log.debug(diagnostic.message)
+    });
+    for (const server of servers) {
+      const approval = evaluateMcpServerApproval(this.settings, server);
+      const recorded = this.settings.mcp?.projectServers?.[server.name];
+      const fingerprint = mcpServerFingerprint(server.config);
+      this.states.set(server.name, {
+        server,
+        fingerprint,
+        status: approval === "approved" ? "connecting" : approval === "rejected" ? "rejected" : "pending-approval",
+        configChangedSinceApproval: approval === "unknown" && recorded !== void 0 && recorded.fingerprint !== fingerprint
+      });
+    }
+    this.rebuildSnapshot();
+    for (const state of this.states.values()) {
+      if (state.status === "connecting") void this.connect(state);
+    }
+  }
+  /** Persist approval for a pending project server and connect it. */
+  approve(name) {
+    const state = this.states.get(name);
+    if (!state || state.status !== "pending-approval") {
+      return { ok: false, error: `No pending approval for MCP server "${name}".` };
+    }
+    const persisted = this.persistChoice(this.workspace, name, state.fingerprint, "approved");
+    if (!persisted.ok) return persisted;
+    state.status = "connecting";
+    state.configChangedSinceApproval = false;
+    this.rebuildSnapshot();
+    void this.connect(state);
+    return { ok: true };
+  }
+  /** Persist rejection for a pending project server. */
+  reject(name) {
+    const state = this.states.get(name);
+    if (!state || state.status !== "pending-approval") {
+      return { ok: false, error: `No pending approval for MCP server "${name}".` };
+    }
+    const persisted = this.persistChoice(this.workspace, name, state.fingerprint, "rejected");
+    if (!persisted.ok) return persisted;
+    state.status = "rejected";
+    this.rebuildSnapshot();
+    return { ok: true };
+  }
+  /** Leave a pending server undecided for this session (re-prompts next session). */
+  defer(name) {
+    const state = this.states.get(name);
+    if (!state || state.status !== "pending-approval") return;
+    state.status = "deferred";
+    this.rebuildSnapshot();
+  }
+  /** Live tool definitions; hosts call this per send so list changes surface. */
+  getToolDefinitions() {
+    return buildMcpToolDefinitions(this.connections, this.options.requestTimeoutMs);
+  }
+  getSnapshot() {
+    return this.snapshot;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  /** Install the host prompt used to answer server elicitation requests. */
+  setElicitationHandler(handler) {
+    this.elicitationHandler = handler;
+  }
+  async dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.abortController.abort(new Error("MCP host disposed"));
+    await disconnectMcpServers(this.connections);
+    this.listeners.clear();
+  }
+  async connect(state) {
+    const { name } = state.server;
+    try {
+      const result = await (this.options.connectServers ?? connectMcpServers)(this.workspace, {
+        servers: { [name]: state.server.config },
+        home: this.options.home,
+        signal: this.abortController.signal,
+        initializationTimeoutMs: this.options.initializationTimeoutMs,
+        requestTimeoutMs: this.options.requestTimeoutMs,
+        onProcessSpawn: this.options.onProcessSpawn,
+        onDiagnostic: (diagnostic) => log.debug(diagnostic.message),
+        onToolListChanged: (serverName) => this.handleToolListChanged(serverName),
+        onConnectionClosed: (serverName) => this.handleConnectionClosed(serverName),
+        // Stable indirection: servers connect in the background before the UI
+        // can install its prompt, so the capability is declared up front and
+        // the handler is resolved per request.
+        onElicit: (request, context) => this.elicitationHandler ? this.elicitationHandler(request, context) : Promise.resolve({ action: "decline" })
+      });
+      const connection = result.connections[0];
+      if (this.disposed) {
+        if (connection) await disconnectMcpServers([connection]);
+        return;
+      }
+      if (!connection) {
+        state.status = "failed";
+        state.error = "connection failed (see debug log)";
+        this.pushEvent({ type: "failed", server: name, error: state.error });
+        return;
+      }
+      if (connection.closed) {
+        state.status = "failed";
+        state.error = "connection closed during startup";
+        this.pushEvent({ type: "failed", server: name, error: state.error });
+        return;
+      }
+      this.connections.push(connection);
+      state.status = "connected";
+      state.toolCount = connection.tools.length;
+      state.error = void 0;
+      this.pushEvent({ type: "connected", server: name, toolCount: connection.tools.length });
+    } catch (error) {
+      state.status = "failed";
+      state.error = error instanceof Error ? error.message : String(error);
+      log.debug(`MCP host connect error for "${name}": ${state.error}`);
+      this.pushEvent({ type: "failed", server: name, error: state.error });
+    }
+  }
+  handleToolListChanged(serverName) {
+    const state = this.states.get(serverName);
+    const connection = this.connections.find((conn) => conn.name === serverName);
+    if (!state || !connection) return;
+    state.toolCount = connection.tools.length;
+    this.pushEvent({ type: "tools-changed", server: serverName, toolCount: state.toolCount });
+  }
+  handleConnectionClosed(serverName) {
+    if (this.disposed) return;
+    const state = this.states.get(serverName);
+    if (!state || state.status !== "connected") return;
+    state.status = "disconnected";
+    state.error = "connection closed";
+    state.toolCount = 0;
+    this.pushEvent({ type: "disconnected", server: serverName });
+  }
+  pushEvent(event) {
+    this.events.push({ ...event, id: this.nextEventId++ });
+    if (this.events.length > MAX_EVENTS) this.events.splice(0, this.events.length - MAX_EVENTS);
+    this.rebuildSnapshot();
+  }
+  rebuildSnapshot() {
+    const servers = [...this.states.values()].map((state) => ({
+      name: state.server.name,
+      source: state.server.source,
+      path: state.server.path,
+      target: formatMcpServerCommand(state.server.config),
+      envKeys: Object.keys(state.server.config.env ?? {}).sort(),
+      headerKeys: Object.keys(state.server.config.headers ?? {}).sort(),
+      fingerprint: state.fingerprint,
+      status: state.status,
+      configChangedSinceApproval: state.configChangedSinceApproval,
+      toolCount: state.toolCount,
+      error: state.error
+    }));
+    this.snapshot = {
+      servers,
+      pendingApprovals: servers.filter((server) => server.status === "pending-approval"),
+      events: [...this.events]
+    };
+    for (const listener of this.listeners) listener();
+  }
+};
+
+// src/cli/run.ts
+import { join as join6 } from "path";
+
+// src/rewind/snapshot-store.ts
+import {
+  chmodSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  readlinkSync,
+  renameSync,
+  rmSync,
+  symlinkSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { lstat, mkdir, readFile, readdir, readlink, rename, rm, writeFile } from "fs/promises";
+import { createHash, randomUUID } from "crypto";
+import { dirname, isAbsolute, join as join3, relative, resolve as resolve2, sep } from "path";
+import ignore from "ignore";
+var REWIND_MAX_ENTRIES = 2e4;
+var REWIND_MAX_FILE_BYTES = 16 * 1024 * 1024;
+var REWIND_MAX_LOGICAL_BYTES = 256 * 1024 * 1024;
+var DEFAULT_IGNORE_PATTERNS = [
+  ".book/",
+  "node_modules/",
+  ".pnpm-store/",
+  ".npm/",
+  ".yarn/",
+  ".venv/",
+  "venv/",
+  "env/",
+  "dist/",
+  "build/",
+  "target/",
+  ".next/",
+  ".cache/",
+  ".turbo/",
+  ".parcel-cache/",
+  ".gradle/",
+  "coverage/",
+  "__pycache__/",
+  ".pytest_cache/",
+  ".mypy_cache/",
+  ".ruff_cache/",
+  ".tox/",
+  "*.pyc"
+];
+function sha256(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function pathExists(path) {
+  try {
+    lstatSync(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function normalizeWorkspace(workspace) {
+  const normalized = resolve2(workspace);
+  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function rewindWorkspaceHash(workspace) {
+  return sha256(normalizeWorkspace(workspace));
+}
+function persistentRewindRoot(workspace) {
+  return join3(resolveBookHome(), "rewind", rewindWorkspaceHash(workspace));
+}
+var UnavailableRewindSnapshotStore = class {
+  constructor(reason) {
+    this.reason = reason;
+  }
+  reason;
+  capture() {
+    return { ok: false, reason: this.reason };
+  }
+  async captureAsync() {
+    return this.capture();
+  }
+  getCurrentGitHead() {
+    return void 0;
+  }
+  getManifest() {
+    return void 0;
+  }
+  getAvailability() {
+    return { available: false, reason: this.reason };
+  }
+  restore() {
+    return { ok: false, error: this.reason };
+  }
+  rollback() {
+    return { ok: false, error: this.reason };
+  }
+  discardManifest() {
+  }
+  cleanup() {
+    return { manifests: 0, blobs: 0 };
+  }
+};
+function createUnavailableRewindSnapshotStore(reason) {
+  return new UnavailableRewindSnapshotStore(reason);
+}
+function createRewindSnapshotStore(workspace, root) {
+  try {
+    return new RewindSnapshotStore(workspace, root);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return createUnavailableRewindSnapshotStore(
+      `Code rewind unavailable: snapshot storage could not be initialized (${detail}).`
+    );
+  }
+}
+function readCustomIgnorePatterns(workspace) {
+  const path = join3(workspace, ".book", "rewindignore");
+  if (!existsSync(path)) return [];
+  return readFileSync(path, "utf-8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+}
+async function readCustomIgnorePatternsAsync(workspace) {
+  const path = join3(workspace, ".book", "rewindignore");
+  try {
+    return (await readFile(path, "utf-8")).split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+}
+function expandNegatedParents(patterns) {
+  const expanded = [];
+  for (const pattern of patterns) {
+    if (pattern.startsWith("!") && !pattern.slice(1).startsWith("*")) {
+      const parts = pattern.slice(1).split("/").filter(Boolean);
+      for (let index = 1; index < parts.length; index++) {
+        expanded.push(`!${parts.slice(0, index).join("/")}/`);
+      }
+    }
+    expanded.push(pattern);
+  }
+  return expanded;
+}
+function readOptionalText(path) {
+  try {
+    return readFileSync(path, "utf-8").trim();
+  } catch {
+    return void 0;
+  }
+}
+function resolveGitDirectory(workspace) {
+  const dotGit = join3(workspace, ".git");
+  try {
+    if (lstatSync(dotGit).isDirectory()) return dotGit;
+  } catch {
+    return void 0;
+  }
+  const match = /^gitdir:\s*(.+)$/i.exec(readOptionalText(dotGit) ?? "");
+  return match ? resolve2(dirname(dotGit), match[1]) : void 0;
+}
+function resolveCommonGitDirectory(gitDirectory) {
+  const commonDirectory = readOptionalText(join3(gitDirectory, "commondir"));
+  return commonDirectory ? resolve2(gitDirectory, commonDirectory) : gitDirectory;
+}
+function parseGitHash(value) {
+  const hash = value?.trim();
+  return hash && /^[0-9a-f]{40,64}$/i.test(hash) ? hash : void 0;
+}
+function readPackedRef(directory, ref) {
+  const packedRefs = readOptionalText(join3(directory, "packed-refs"));
+  if (!packedRefs) return void 0;
+  for (const line of packedRefs.split(/\r?\n/)) {
+    if (!line || line.startsWith("#") || line.startsWith("^")) continue;
+    const separator = line.indexOf(" ");
+    if (separator > 0 && line.slice(separator + 1) === ref) {
+      return parseGitHash(line.slice(0, separator));
+    }
+  }
+  return void 0;
+}
+function resolveGitRef(gitDirectory, commonDirectory, ref, depth = 0) {
+  if (depth > 4 || !ref.startsWith("refs/") || ref.includes("..") || ref.includes("\\") || ref.includes("\0")) {
+    return void 0;
+  }
+  for (const directory of /* @__PURE__ */ new Set([gitDirectory, commonDirectory])) {
+    const value = readOptionalText(join3(directory, ...ref.split("/")));
+    const hash = parseGitHash(value);
+    if (hash) return hash;
+    if (value?.startsWith("ref:")) {
+      const resolved = resolveGitRef(
+        gitDirectory,
+        commonDirectory,
+        value.slice("ref:".length).trim(),
+        depth + 1
+      );
+      if (resolved) return resolved;
+    }
+  }
+  return readPackedRef(gitDirectory, ref) ?? (commonDirectory === gitDirectory ? void 0 : readPackedRef(commonDirectory, ref));
+}
+function gitHead(workspace) {
+  const gitDirectory = resolveGitDirectory(workspace);
+  if (!gitDirectory) return void 0;
+  const head = readOptionalText(join3(gitDirectory, "HEAD"));
+  const directHash = parseGitHash(head);
+  if (directHash) return directHash;
+  if (!head?.startsWith("ref:")) return void 0;
+  return resolveGitRef(
+    gitDirectory,
+    resolveCommonGitDirectory(gitDirectory),
+    head.slice("ref:".length).trim()
+  );
+}
+async function gitHeadAsync(workspace) {
+  return gitHead(workspace);
+}
+function assertSafeRelativePath(path) {
+  if (!path || path.includes("\0") || isAbsolute(path) || path.includes("\\")) {
+    throw new Error(`Unsafe rewind path: ${JSON.stringify(path)}`);
+  }
+  const segments = path.split("/");
+  if (segments.some((segment) => !segment || segment === "." || segment === "..")) {
+    throw new Error(`Unsafe rewind path: ${JSON.stringify(path)}`);
+  }
+  if (segments.includes(".git")) throw new Error("Rewind snapshots may not contain .git paths.");
+}
+function resolveEntryPath(workspace, path) {
+  assertSafeRelativePath(path);
+  const target = resolve2(workspace, ...path.split("/"));
+  const rel = relative(workspace, target);
+  if (rel.startsWith(`..${sep}`) || rel === ".." || isAbsolute(rel)) {
+    throw new Error(`Rewind path escapes the workspace: ${path}`);
+  }
+  return target;
+}
+function walkIncludedEntries(workspace, patterns, maxEntries = Number.POSITIVE_INFINITY) {
+  const matcher = ignore().add(patterns);
+  const hasNegations = patterns.some((pattern) => pattern.startsWith("!"));
+  const entries = [];
+  const visit = (directory, prefix) => {
+    const children = readdirSync(directory, { withFileTypes: true }).sort(
+      (a, b) => a.name.localeCompare(b.name)
+    );
+    for (const child of children) {
+      if (child.name === ".git") continue;
+      const path = prefix ? `${prefix}/${child.name}` : child.name;
+      const absolutePath = join3(directory, child.name);
+      if (child.isDirectory()) {
+        if (!matcher.ignores(`${path}/`) || hasNegations) visit(absolutePath, path);
+        continue;
+      }
+      if (matcher.ignores(path)) continue;
+      const stat = lstatSync(absolutePath);
+      if (!stat.isFile() && !stat.isSymbolicLink()) continue;
+      entries.push({
+        path,
+        absolutePath,
+        kind: stat.isSymbolicLink() ? "symlink" : "file",
+        byteSize: stat.isSymbolicLink() ? Buffer.byteLength(readlinkSync(absolutePath)) : stat.size,
+        mode: stat.mode,
+        mtimeMs: stat.mtimeMs
+      });
+      if (entries.length > maxEntries) {
+        throw new Error(`Code rewind unavailable: checkpoint exceeds ${maxEntries} entries.`);
+      }
+    }
+  };
+  visit(workspace, "");
+  return entries;
+}
+async function walkIncludedEntriesAsync(workspace, patterns, maxEntries = Number.POSITIVE_INFINITY) {
+  const matcher = ignore().add(patterns);
+  const hasNegations = patterns.some((pattern) => pattern.startsWith("!"));
+  const entries = [];
+  const visit = async (directory, prefix) => {
+    const children = (await readdir(directory, { withFileTypes: true })).sort(
+      (a, b) => a.name.localeCompare(b.name)
+    );
+    const files = [];
+    for (const child of children) {
+      if (child.name === ".git") continue;
+      const path = prefix ? `${prefix}/${child.name}` : child.name;
+      const absolutePath = join3(directory, child.name);
+      if (child.isDirectory()) {
+        if (!matcher.ignores(`${path}/`) || hasNegations) await visit(absolutePath, path);
+        continue;
+      }
+      if (matcher.ignores(path)) continue;
+      files.push({ child, path, absolutePath });
+    }
+    const stats = await Promise.all(files.map(({ absolutePath }) => lstat(absolutePath)));
+    for (let index = 0; index < files.length; index++) {
+      const { path, absolutePath } = files[index];
+      const stat = stats[index];
+      if (!stat.isFile() && !stat.isSymbolicLink()) continue;
+      entries.push({
+        path,
+        absolutePath,
+        kind: stat.isSymbolicLink() ? "symlink" : "file",
+        byteSize: stat.isSymbolicLink() ? Buffer.byteLength(await readlink(absolutePath, { encoding: "utf-8" })) : stat.size,
+        mode: stat.mode,
+        mtimeMs: stat.mtimeMs
+      });
+      if (entries.length > maxEntries) {
+        throw new Error(`Code rewind unavailable: checkpoint exceeds ${maxEntries} entries.`);
+      }
+    }
+  };
+  await visit(workspace, "");
+  return entries;
+}
+function writeAtomic(path, contents) {
+  mkdirSync(dirname(path), { recursive: true });
+  const temporary = join3(dirname(path), `.book-rewind-${randomUUID()}.tmp`);
+  try {
+    writeFileSync(temporary, contents);
+    renameSync(temporary, path);
+  } finally {
+    if (pathExists(temporary)) unlinkSync(temporary);
+  }
+}
+async function writeAtomicAsync(path, contents) {
+  await mkdir(dirname(path), { recursive: true });
+  const temporary = join3(dirname(path), `.book-rewind-${randomUUID()}.tmp`);
+  try {
+    await writeFile(temporary, contents);
+    await rename(temporary, path);
+  } finally {
+    await rm(temporary, { force: true });
+  }
+}
+async function pathExistsAsync(path) {
+  try {
+    await lstat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var RewindSnapshotStore = class {
+  constructor(workspace, root = persistentRewindRoot(workspace), limits = {}) {
+    this.root = root;
+    this.workspace = resolve2(workspace);
+    this.limits = {
+      maxEntries: limits.maxEntries ?? REWIND_MAX_ENTRIES,
+      maxFileBytes: limits.maxFileBytes ?? REWIND_MAX_FILE_BYTES,
+      maxLogicalBytes: limits.maxLogicalBytes ?? REWIND_MAX_LOGICAL_BYTES
+    };
+    this.manifestsRoot = join3(root, "manifests");
+    this.entrySetsRoot = join3(root, "entry-sets");
+    this.blobsRoot = join3(root, "blobs");
+    mkdirSync(this.manifestsRoot, { recursive: true });
+    mkdirSync(this.entrySetsRoot, { recursive: true });
+    mkdirSync(this.blobsRoot, { recursive: true });
+  }
+  root;
+  manifestsRoot;
+  entrySetsRoot;
+  blobsRoot;
+  workspace;
+  limits;
+  fileCache = /* @__PURE__ */ new Map();
+  capture(ignorePatterns) {
+    const head = gitHead(this.workspace);
+    const patterns = ignorePatterns ?? expandNegatedParents([
+      ...DEFAULT_IGNORE_PATTERNS,
+      ...readCustomIgnorePatterns(this.workspace)
+    ]);
+    try {
+      const walked = walkIncludedEntries(this.workspace, patterns, this.limits.maxEntries);
+      let logicalBytes = 0;
+      const entries = [];
+      const nextCache = /* @__PURE__ */ new Map();
+      for (const entry of walked) {
+        if (entry.byteSize > this.limits.maxFileBytes) {
+          throw new Error(
+            `Code rewind unavailable: ${entry.path} exceeds the ${this.limits.maxFileBytes}-byte per-file limit.`
+          );
+        }
+        const cached = this.fileCache.get(entry.path);
+        if (cached && cached.kind === entry.kind && cached.byteSize === entry.byteSize && cached.mode === entry.mode && cached.mtimeMs === entry.mtimeMs) {
+          logicalBytes += cached.snapshotEntry.byteSize;
+          if (logicalBytes > this.limits.maxLogicalBytes) {
+            throw new Error(
+              `Code rewind unavailable: checkpoint exceeds ${this.limits.maxLogicalBytes} bytes of file content.`
+            );
+          }
+          entries.push(cached.snapshotEntry);
+          nextCache.set(entry.path, cached);
+          continue;
+        }
+        const contents = entry.kind === "symlink" ? Buffer.from(readlinkSync(entry.absolutePath), "utf-8") : readFileSync(entry.absolutePath);
+        if (contents.byteLength > this.limits.maxFileBytes) {
+          throw new Error(
+            `Code rewind unavailable: ${entry.path} exceeds the ${this.limits.maxFileBytes}-byte per-file limit.`
+          );
+        }
+        logicalBytes += contents.byteLength;
+        if (logicalBytes > this.limits.maxLogicalBytes) {
+          throw new Error(
+            `Code rewind unavailable: checkpoint exceeds ${this.limits.maxLogicalBytes} bytes of file content.`
+          );
+        }
+        const blobHash = sha256(contents);
+        const blobPath = join3(this.blobsRoot, blobHash);
+        if (!existsSync(blobPath)) writeAtomic(blobPath, contents);
+        const snapshotEntry = {
+          path: entry.path.replaceAll("\\", "/"),
+          kind: entry.kind,
+          blobHash,
+          byteSize: contents.byteLength,
+          mode: entry.mode
+        };
+        entries.push(snapshotEntry);
+        nextCache.set(entry.path, {
+          kind: entry.kind,
+          byteSize: entry.byteSize,
+          mode: entry.mode,
+          mtimeMs: entry.mtimeMs,
+          snapshotEntry
+        });
+      }
+      const manifest = {
+        version: 1,
+        id: randomUUID(),
+        workspace: normalizeWorkspace(this.workspace),
+        createdAt: Date.now(),
+        gitHead: head,
+        ignorePatterns: patterns,
+        entries,
+        logicalBytes
+      };
+      this.writeManifest(manifest);
+      this.fileCache = nextCache;
+      return { ok: true, manifest };
+    } catch (error) {
+      return {
+        ok: false,
+        reason: error instanceof Error ? error.message : String(error),
+        gitHead: head
+      };
+    }
+  }
+  async captureAsync(ignorePatterns) {
+    let head;
+    try {
+      const [resolvedHead, customIgnorePatterns] = await Promise.all([
+        gitHeadAsync(this.workspace),
+        ignorePatterns ? Promise.resolve([]) : readCustomIgnorePatternsAsync(this.workspace)
+      ]);
+      head = resolvedHead;
+      const patterns = ignorePatterns ?? expandNegatedParents([...DEFAULT_IGNORE_PATTERNS, ...customIgnorePatterns]);
+      const walked = await walkIncludedEntriesAsync(
+        this.workspace,
+        patterns,
+        this.limits.maxEntries
+      );
+      let logicalBytes = 0;
+      const entries = [];
+      const nextCache = /* @__PURE__ */ new Map();
+      for (const entry of walked) {
+        if (entry.byteSize > this.limits.maxFileBytes) {
+          throw new Error(
+            `Code rewind unavailable: ${entry.path} exceeds the ${this.limits.maxFileBytes}-byte per-file limit.`
+          );
+        }
+        const cached = this.fileCache.get(entry.path);
+        if (cached && cached.kind === entry.kind && cached.byteSize === entry.byteSize && cached.mode === entry.mode && cached.mtimeMs === entry.mtimeMs) {
+          logicalBytes += cached.snapshotEntry.byteSize;
+          if (logicalBytes > this.limits.maxLogicalBytes) {
+            throw new Error(
+              `Code rewind unavailable: checkpoint exceeds ${this.limits.maxLogicalBytes} bytes of file content.`
+            );
+          }
+          entries.push(cached.snapshotEntry);
+          nextCache.set(entry.path, cached);
+          continue;
+        }
+        const contents = entry.kind === "symlink" ? Buffer.from(await readlink(entry.absolutePath, { encoding: "utf-8" }), "utf-8") : await readFile(entry.absolutePath);
+        if (contents.byteLength > this.limits.maxFileBytes) {
+          throw new Error(
+            `Code rewind unavailable: ${entry.path} exceeds the ${this.limits.maxFileBytes}-byte per-file limit.`
+          );
+        }
+        logicalBytes += contents.byteLength;
+        if (logicalBytes > this.limits.maxLogicalBytes) {
+          throw new Error(
+            `Code rewind unavailable: checkpoint exceeds ${this.limits.maxLogicalBytes} bytes of file content.`
+          );
+        }
+        const blobHash = sha256(contents);
+        const blobPath = join3(this.blobsRoot, blobHash);
+        if (!await pathExistsAsync(blobPath)) await writeAtomicAsync(blobPath, contents);
+        const snapshotEntry = {
+          path: entry.path.replaceAll("\\", "/"),
+          kind: entry.kind,
+          blobHash,
+          byteSize: contents.byteLength,
+          mode: entry.mode
+        };
+        entries.push(snapshotEntry);
+        nextCache.set(entry.path, {
+          kind: entry.kind,
+          byteSize: entry.byteSize,
+          mode: entry.mode,
+          mtimeMs: entry.mtimeMs,
+          snapshotEntry
+        });
+      }
+      const manifest = {
+        version: 1,
+        id: randomUUID(),
+        workspace: normalizeWorkspace(this.workspace),
+        createdAt: Date.now(),
+        gitHead: head,
+        ignorePatterns: patterns,
+        entries,
+        logicalBytes
+      };
+      await this.writeManifestAsync(manifest);
+      this.fileCache = nextCache;
+      return { ok: true, manifest };
+    } catch (error) {
+      return {
+        ok: false,
+        reason: error instanceof Error ? error.message : String(error),
+        gitHead: head
+      };
+    }
+  }
+  getManifest(id) {
+    if (!/^[a-zA-Z0-9-]+$/.test(id)) return void 0;
+    const path = join3(this.manifestsRoot, `${id}.json`);
+    if (!existsSync(path)) return void 0;
+    try {
+      const stored = JSON.parse(readFileSync(path, "utf-8"));
+      let manifest = stored;
+      if (!Array.isArray(stored.entries) && stored.entrySetHash) {
+        if (!/^[a-f0-9]{64}$/.test(stored.entrySetHash)) return void 0;
+        const entriesPath = join3(this.entrySetsRoot, `${stored.entrySetHash}.json`);
+        if (!existsSync(entriesPath)) return void 0;
+        const serializedEntries = readFileSync(entriesPath, "utf-8");
+        if (sha256(serializedEntries) !== stored.entrySetHash) return void 0;
+        manifest = {
+          ...stored,
+          entries: JSON.parse(serializedEntries)
+        };
+      }
+      if (manifest.version !== 1 || manifest.id !== id || normalizeWorkspace(manifest.workspace) !== normalizeWorkspace(this.workspace) || !Array.isArray(manifest.entries)) {
+        return void 0;
+      }
+      return manifest;
+    } catch {
+      return void 0;
+    }
+  }
+  getCurrentGitHead() {
+    return gitHead(this.workspace);
+  }
+  getAvailability(id, expectedGitHead) {
+    if (!id) return { available: false, reason: "No filesystem checkpoint was captured." };
+    if (!this.getManifest(id)) {
+      return { available: false, reason: "The filesystem checkpoint is missing or corrupt." };
+    }
+    if (this.getCurrentGitHead() !== expectedGitHead) {
+      return {
+        available: false,
+        reason: "Git HEAD changed since this prompt; rewind never moves HEAD or the index."
+      };
+    }
+    return { available: true };
+  }
+  restore(id) {
+    const manifest = this.getManifest(id);
+    if (!manifest) return { ok: false, error: "The filesystem checkpoint is missing or corrupt." };
+    const availability = this.getAvailability(id, manifest.gitHead);
+    if (!availability.available) return { ok: false, error: availability.reason ?? "Unavailable." };
+    const safety = this.capture(manifest.ignorePatterns);
+    if (!safety.ok) {
+      return { ok: false, error: `Could not create a safety snapshot: ${safety.reason}` };
+    }
+    if (this.getCurrentGitHead() !== manifest.gitHead) {
+      this.discardManifest(safety.manifest.id);
+      return {
+        ok: false,
+        error: "Git HEAD changed while preparing rewind; no files were restored."
+      };
+    }
+    try {
+      this.applyManifest(manifest);
+      return { ok: true, safetySnapshotId: safety.manifest.id };
+    } catch (error) {
+      const rollback = this.applyManifestSafely(safety.manifest);
+      this.discardManifest(safety.manifest.id);
+      return {
+        ok: false,
+        error: error instanceof Error ? error.message : String(error),
+        ...rollback.ok ? {} : { rollbackError: rollback.error }
+      };
+    }
+  }
+  rollback(safetySnapshotId) {
+    const manifest = this.getManifest(safetySnapshotId);
+    if (!manifest) return { ok: false, error: "The safety snapshot is missing or corrupt." };
+    const result = this.applyManifestSafely(manifest);
+    if (result.ok) this.discardManifest(safetySnapshotId);
+    return result;
+  }
+  discardManifest(id) {
+    if (!/^[a-zA-Z0-9-]+$/.test(id)) return;
+    const path = join3(this.manifestsRoot, `${id}.json`);
+    if (existsSync(path)) unlinkSync(path);
+  }
+  writeManifest(manifest) {
+    const entriesHash = sha256(JSON.stringify(manifest.entries));
+    const entriesPath = join3(this.entrySetsRoot, `${entriesHash}.json`);
+    if (!existsSync(entriesPath)) writeAtomic(entriesPath, JSON.stringify(manifest.entries));
+    const metadata = { ...manifest };
+    delete metadata.entries;
+    writeAtomic(
+      join3(this.manifestsRoot, `${manifest.id}.json`),
+      JSON.stringify({ ...metadata, entrySetHash: entriesHash })
+    );
+  }
+  async writeManifestAsync(manifest) {
+    const entriesHash = sha256(JSON.stringify(manifest.entries));
+    const entriesPath = join3(this.entrySetsRoot, `${entriesHash}.json`);
+    if (!await pathExistsAsync(entriesPath)) {
+      await writeAtomicAsync(entriesPath, JSON.stringify(manifest.entries));
+    }
+    const metadata = { ...manifest };
+    delete metadata.entries;
+    await writeAtomicAsync(
+      join3(this.manifestsRoot, `${manifest.id}.json`),
+      JSON.stringify({ ...metadata, entrySetHash: entriesHash })
+    );
+  }
+  cleanup(referencedSnapshotIds, days) {
+    const cutoff = Date.now() - days * 864e5;
+    let manifests = 0;
+    let blobs = 0;
+    for (const file of readdirSync(this.manifestsRoot)) {
+      if (!file.endsWith(".json")) continue;
+      const id = file.slice(0, -5);
+      const manifest = this.getManifest(id);
+      if (referencedSnapshotIds.has(id)) continue;
+      if (!manifest || manifest.createdAt < cutoff) {
+        unlinkSync(join3(this.manifestsRoot, file));
+        manifests++;
+      }
+    }
+    const referencedBlobs = /* @__PURE__ */ new Set();
+    const referencedEntrySets = /* @__PURE__ */ new Set();
+    for (const file of readdirSync(this.manifestsRoot)) {
+      if (!file.endsWith(".json")) continue;
+      const id = file.slice(0, -5);
+      const manifest = this.getManifest(id);
+      try {
+        const stored = JSON.parse(readFileSync(join3(this.manifestsRoot, file), "utf-8"));
+        if (stored.entrySetHash) referencedEntrySets.add(stored.entrySetHash);
+      } catch {
+      }
+      for (const entry of manifest?.entries ?? []) referencedBlobs.add(entry.blobHash);
+    }
+    for (const file of readdirSync(this.entrySetsRoot)) {
+      if (!file.endsWith(".json") || referencedEntrySets.has(file.slice(0, -5))) continue;
+      rmSync(join3(this.entrySetsRoot, file), { force: true });
+    }
+    for (const file of readdirSync(this.blobsRoot)) {
+      if (referencedBlobs.has(file)) continue;
+      rmSync(join3(this.blobsRoot, file), { force: true });
+      blobs++;
+    }
+    return { manifests, blobs };
+  }
+  applyManifestSafely(manifest) {
+    try {
+      this.applyManifest(manifest);
+      return { ok: true };
+    } catch (error) {
+      return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    }
+  }
+  applyManifest(manifest) {
+    if (manifest.entries.length > this.limits.maxEntries) {
+      throw new Error(`Rewind manifest exceeds ${this.limits.maxEntries} entries.`);
+    }
+    const targetPaths = /* @__PURE__ */ new Set();
+    let logicalBytes = 0;
+    for (const entry of manifest.entries) {
+      resolveEntryPath(this.workspace, entry.path);
+      if (!["file", "symlink"].includes(entry.kind) || !Number.isInteger(entry.mode)) {
+        throw new Error(`Invalid rewind entry for ${entry.path}.`);
+      }
+      if (targetPaths.has(entry.path)) throw new Error(`Duplicate rewind path: ${entry.path}.`);
+      if (!/^[a-f0-9]{64}$/.test(entry.blobHash)) {
+        throw new Error(`Invalid blob hash for ${entry.path}.`);
+      }
+      const blobPath = join3(this.blobsRoot, entry.blobHash);
+      if (!existsSync(blobPath)) throw new Error(`Missing rewind blob for ${entry.path}.`);
+      const contents = readFileSync(blobPath);
+      if (sha256(contents) !== entry.blobHash)
+        throw new Error(`Corrupt rewind blob for ${entry.path}.`);
+      if (contents.byteLength !== entry.byteSize || contents.byteLength > this.limits.maxFileBytes) {
+        throw new Error(`Invalid rewind size for ${entry.path}.`);
+      }
+      logicalBytes += contents.byteLength;
+      if (logicalBytes > this.limits.maxLogicalBytes) {
+        throw new Error(`Rewind manifest exceeds ${this.limits.maxLogicalBytes} bytes.`);
+      }
+      targetPaths.add(entry.path);
+    }
+    const current = walkIncludedEntries(
+      this.workspace,
+      manifest.ignorePatterns,
+      this.limits.maxEntries
+    );
+    const removals = current.filter((entry) => !targetPaths.has(entry.path)).sort((a, b) => b.path.length - a.path.length);
+    for (const entry of removals) unlinkSync(entry.absolutePath);
+    for (const entry of manifest.entries) {
+      const target = resolveEntryPath(this.workspace, entry.path);
+      mkdirSync(dirname(target), { recursive: true });
+      if (pathExists(target) && lstatSync(target).isDirectory()) {
+        throw new Error(`Cannot restore ${entry.path} because a directory exists at that path.`);
+      }
+      const contents = readFileSync(join3(this.blobsRoot, entry.blobHash));
+      const temporary = join3(dirname(target), `.book-rewind-${randomUUID()}.tmp`);
+      try {
+        if (entry.kind === "symlink") {
+          symlinkSync(contents.toString("utf-8"), temporary);
+        } else {
+          writeFileSync(temporary, contents, { mode: entry.mode });
+          chmodSync(temporary, entry.mode);
+        }
+        renameSync(temporary, target);
+      } finally {
+        if (pathExists(temporary)) unlinkSync(temporary);
+      }
+    }
+  }
+};
+
+// src/rewind/environment.ts
+import { existsSync as existsSync2, mkdtempSync, rmSync as rmSync2 } from "fs";
+import { tmpdir } from "os";
+import { join as join4, resolve as resolve3, sep as sep2 } from "path";
+function createEphemeralRewindEnvironment(workspace, temporaryRoot = tmpdir()) {
+  const resolvedTemporaryRoot = resolve3(temporaryRoot);
+  const root = mkdtempSync(join4(resolvedTemporaryRoot, "book-rewind-"));
+  let disposed = false;
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    const resolvedRoot = resolve3(root);
+    if (resolvedRoot.startsWith(`${resolvedTemporaryRoot}${sep2}`) && resolvedRoot.split(sep2).at(-1)?.startsWith("book-rewind-") && existsSync2(resolvedRoot)) {
+      rmSync2(resolvedRoot, { recursive: true, force: true });
+    }
+    process.off("exit", dispose);
+  };
+  process.once("exit", dispose);
+  return {
+    root,
+    timelineStore: new SessionStore(join4(root, "sessions")),
+    snapshotStore: createRewindSnapshotStore(workspace, join4(root, "snapshots")),
+    dispose
+  };
+}
+
+// src/cli/ink-patch.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { createRequire } from "module";
+import { dirname as dirname2, join as join5 } from "path";
+var INK_PATCH_MARKER = "ansiEscapes.cursorUp(previousLines.length - 1)";
+function isInkIncrementalRendererPatched() {
+  try {
+    const require2 = createRequire(import.meta.url);
+    const logUpdatePath = join5(dirname2(require2.resolve("ink")), "log-update.js");
+    return readFileSync2(logUpdatePath, "utf8").includes(INK_PATCH_MARKER);
+  } catch {
+    return false;
+  }
+}
+
+// src/cli/tui-renderer-mode.ts
+function resolveTuiRendererMode(value = process.env.BOOK_TUI_RENDERER, context = {}) {
+  if (context.isTTY === false || context.screenReader) return "safe";
+  if (context.incrementalRendererPatched === false) return "safe";
+  if (value === "incremental") return "incremental";
+  if (value === "experimental-scroll") return "experimental-scroll";
+  if (value === void 0) return context.platform === "win32" ? "safe" : "incremental";
+  return "safe";
+}
+
+// src/cli/run.ts
+import { spawn } from "child_process";
+var SESSION_ROOT = join6(resolveBookHome(), "sessions");
+var ENTER_ALT_SCREEN = "\x1B[?1049h";
+var EXIT_ALT_SCREEN = "\x1B[?1049l";
+var DISABLE_MOUSE_REPORTING = "\x1B[?1000l\x1B[?1002l\x1B[?1003l\x1B[?1006l\x1B[?1015l";
+var ENABLE_BUTTON_EVENT_TRACKING = "\x1B[?1002h";
+var ENABLE_SGR_MOUSE = "\x1B[?1006h";
+var DISABLE_ALTERNATE_SCROLL = "\x1B[?1007l";
+var RESTORE_ALTERNATE_SCROLL = "\x1B[?1007h";
+var WSL_TERMINAL_BRIDGE_SCRIPT = `
+for process in /proc/[0-9]*; do
+  [ -r "$process/environ" ] || continue
+  /usr/bin/grep -Fzqx "WT_SESSION=$2" "$process/environ" 2>/dev/null || continue
+  target=$(/usr/bin/readlink "$process/fd/1" 2>/dev/null) || continue
+  case "$target" in
+    /dev/pts/*)
+      /usr/bin/printf '%s' "$1" > "$process/fd/1"
+      exit $?
+      ;;
+  esac
+done
+exit 1
+`.trim();
+function shouldBridgeWslTerminal(platform = process.platform, env = process.env) {
+  const sharedVariables = (env.WSLENV ?? "").split(":").map((entry) => entry.split("/")[0]);
+  return platform === "win32" && Boolean(env.WT_SESSION) && sharedVariables.includes("WT_SESSION");
+}
+function writeTerminalControl(stdout, sequence) {
+  stdout.write(sequence);
+  if (stdout !== process.stdout || !shouldBridgeWslTerminal()) return;
+  try {
+    const bridge = spawn(
+      "wsl.exe",
+      [
+        "-e",
+        "sh",
+        "-c",
+        WSL_TERMINAL_BRIDGE_SCRIPT,
+        "book-terminal-bridge",
+        sequence,
+        process.env.WT_SESSION
+      ],
+      {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true
+      }
+    );
+    bridge.on("error", () => {
+    });
+    bridge.unref();
+  } catch {
+  }
+}
+function collectSnapshotReferences(store, cwd) {
+  return store.listSnapshotReferences(cwd);
+}
+function enterInteractiveScreen(stdout = process.stdout, bridgeWslTerminal = shouldBridgeWslTerminal()) {
+  if (!stdout.isTTY && !bridgeWslTerminal) return () => {
+  };
+  let restored = false;
+  const restore = () => {
+    if (restored) return;
+    restored = true;
+    writeTerminalControl(
+      stdout,
+      DISABLE_MOUSE_REPORTING + RESTORE_ALTERNATE_SCROLL + EXIT_ALT_SCREEN
+    );
+    process.off("exit", restore);
+  };
+  writeTerminalControl(
+    stdout,
+    ENTER_ALT_SCREEN + DISABLE_MOUSE_REPORTING + DISABLE_ALTERNATE_SCROLL + ENABLE_BUTTON_EVENT_TRACKING + ENABLE_SGR_MOUSE
+  );
+  process.once("exit", restore);
+  return restore;
+}
+async function runMainAction(options) {
+  try {
+    const requestedWorkspace = options.workspace;
+    const effortOverride = options.effort ? parseEffortLevel(String(options.effort), "--effort") : void 0;
+    const config = loadConfig(requestedWorkspace, {
+      settingsOverridePath: options.settings,
+      noSettings: options.settings === false,
+      runMigrations: options.settings !== false,
+      modelOverride: options.model,
+      effortOverride,
+      allowMissingApiKey: options.print === void 0 && !options.scrollback
+    });
+    if (config.modelProviderWarning) console.warn("\u26A0  " + config.modelProviderWarning);
+    const interactiveMaxTurns = parseNumericFlag(options.maxTurns, "--max-turns", {
+      integer: true
+    });
+    if (interactiveMaxTurns !== void 0) config.maxTurns = interactiveMaxTurns;
+    if (options.agents) {
+      const agentsMode = String(options.agents);
+      if (!["adaptive", "manual", "off"].includes(agentsMode)) {
+        throw new Error("--agents must be adaptive, manual, or off");
+      }
+      config.settings.agents.mode = agentsMode;
+    }
+    if (options.provider) {
+      const VALID_PROVIDERS = /* @__PURE__ */ new Set(["anthropic", "openai", "auto"]);
+      const raw = String(options.provider).trim().toLowerCase();
+      if (VALID_PROVIDERS.has(raw)) {
+        config.provider = raw;
+      }
+    }
+    freezeAgentConfig(config);
+    cleanupDebugLogs(DEFAULT_LOCAL_DATA_RETENTION_DAYS, getDebugLogPath());
+    if (options.print !== void 0) {
+      for (const notice of collectWithheldProjectNotices({
+        workspace: config.workspace,
+        settings: config.settings,
+        settingsEnabled: options.settings !== false
+      })) {
+        console.warn(notice);
+      }
+      const declaredMcpServers = resolveMcpServerList(config.workspace);
+      const mcpPartition = partitionMcpServersByApproval(declaredMcpServers, config.settings);
+      for (const server of mcpPartition.pending) {
+        console.warn(
+          `\u26A0  Skipping MCP server "${server.name}" (${server.path}): project-declared servers require one-time approval. Approve it in an interactive session first.`
+        );
+      }
+      const mcp = await connectMcpServers(config.workspace, {
+        servers: mcpServersToRecord(mcpPartition.allowed)
+      });
+      let result;
+      try {
+        const registry = createDefaultRegistry({ agents: config.settings.agents.mode !== "off" });
+        if (mcp.tools.length > 0) {
+          registry.registerAll(mcp.tools);
+        }
+        const mode2 = resolvePermissionMode(config.settings, options.permissionMode);
+        const sessionStore2 = options.sessionPersistence ? new SessionStore(SESSION_ROOT) : void 0;
+        const bootstrap2 = resolveSessionBootstrap(sessionStore2, {
+          cwd: config.workspace,
+          resume: options.resume,
+          continue: options.continue,
+          sessionId: options.sessionId,
+          sessionName: options.name,
+          forkSession: options.forkSession
+        });
+        sessionStore2?.cleanup(DEFAULT_LOCAL_DATA_RETENTION_DAYS, /* @__PURE__ */ new Set([bootstrap2.sessionId]));
+        result = await runHeadless(config, registry, {
+          prompt: typeof options.print === "string" ? options.print : void 0,
+          inputFormat: options.inputFormat,
+          outputFormat: options.outputFormat,
+          history: bootstrap2.history,
+          transcript: bootstrap2.transcript,
+          compactBoundaries: bootstrap2.compactBoundaries,
+          plan: bootstrap2.plan,
+          carriedUsage: bootstrap2.carriedUsage,
+          carriedModels: bootstrap2.carriedModels,
+          mode: mode2,
+          signal: options.signal,
+          maxTurns: parseNumericFlag(options.maxTurns, "--max-turns", { integer: true }),
+          maxBudgetUsd: parseNumericFlag(options.maxBudgetUsd, "--max-budget-usd"),
+          verbose: options.verbose,
+          jsonSchema: options.jsonSchema ? JSON.parse(options.jsonSchema) : void 0,
+          sessionStore: sessionStore2,
+          sessionId: bootstrap2.sessionId,
+          sessionName: bootstrap2.sessionName,
+          forkSession: false,
+          sessionCreated: bootstrap2.created,
+          persistSession: options.sessionPersistence,
+          includeHookEvents: options.includeHookEvents,
+          includePartialMessages: options.includePartialMessages,
+          promptSuggestions: options.promptSuggestions
+        });
+      } finally {
+        await disconnectMcpServers(mcp.connections);
+      }
+      if (result?.outcome.status === "failed") {
+        exit(1);
+      }
+      return;
+    }
+    const mode = resolvePermissionMode(config.settings, options.permissionMode);
+    if (options.scrollback) {
+      const { runScrollbackSession } = await import("./scrollback-LUKLIBVI.js");
+      await runScrollbackSession(config, { mode });
+      return;
+    }
+    const sessionStore = options.sessionPersistence ? new SessionStore(SESSION_ROOT) : void 0;
+    const ephemeralRewind = sessionStore ? void 0 : createEphemeralRewindEnvironment(config.workspace);
+    const timelineStore = sessionStore ?? ephemeralRewind.timelineStore;
+    let snapshotStore = sessionStore ? createRewindSnapshotStore(config.workspace) : ephemeralRewind.snapshotStore;
+    if (sessionStore) {
+      try {
+        snapshotStore.cleanup(collectSnapshotReferences(sessionStore, config.workspace), 30);
+      } catch (error) {
+        snapshotStore = createUnavailableRewindSnapshotStore(
+          `Code rewind unavailable: snapshot cleanup failed (${error instanceof Error ? error.message : String(error)}).`
+        );
+      }
+    }
+    const bootstrap = resolveSessionBootstrap(sessionStore, {
+      cwd: config.workspace,
+      resume: options.resume,
+      continue: options.continue,
+      sessionId: options.sessionId,
+      sessionName: options.name,
+      forkSession: options.forkSession
+    });
+    sessionStore?.cleanup(DEFAULT_LOCAL_DATA_RETENTION_DAYS, /* @__PURE__ */ new Set([bootstrap.sessionId]));
+    if (!sessionStore) {
+      timelineStore.create({
+        id: bootstrap.sessionId,
+        cwd: config.workspace,
+        name: bootstrap.sessionName
+      });
+    }
+    const [{ App }, { loadInteractiveAssets }] = await Promise.all([
+      import("./app-MOXXWEOY.js"),
+      import("./interactive-assets-CCAAWVKH.js")
+    ]);
+    const interactiveAssets = loadInteractiveAssets(config);
+    const mcpHost = new McpSessionHost(config.workspace, config.settings);
+    mcpHost.start();
+    let app;
+    const redrawViewport = () => {
+      app?.clear();
+      process.stdout.write("\x1B[H\x1B[2J");
+    };
+    const restoreScreen = config.accessibility.screenReader ? () => {
+    } : enterInteractiveScreen(process.stdout);
+    try {
+      const rendererMode = resolveTuiRendererMode(process.env.BOOK_TUI_RENDERER, {
+        isTTY: process.stdout.isTTY === true,
+        screenReader: config.accessibility.screenReader,
+        incrementalRendererPatched: isInkIncrementalRendererPatched(),
+        platform: process.platform
+      });
+      await installInkScrollRenderer(rendererMode === "experimental-scroll");
+      await installFrameCapture();
+      app = render(
+        createElement(App, {
+          config,
+          permissionMode: mode,
+          interactiveAssets,
+          redrawViewport,
+          mcp: mcpHost,
+          session: { ...bootstrap, store: sessionStore, timelineStore, snapshotStore }
+        }),
+        {
+          exitOnCtrlC: false,
+          isScreenReaderEnabled: config.accessibility.screenReader,
+          incrementalRendering: rendererMode !== "safe",
+          maxFps: 60
+        }
+      );
+      await app.waitUntilExit();
+    } finally {
+      app?.cleanup();
+      restoreScreen();
+      await mcpHost.dispose();
+      ephemeralRewind?.dispose();
+    }
+  } catch (e) {
+    if (isExiting()) throw e;
+    console.error(e instanceof Error ? e.message : String(e));
+    exit(1);
+  }
+}
+
+// src/cli/mcp.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join7 } from "path";
+function configPath(workspace, scope, home) {
+  return scope === "project" ? join7(workspace, ".mcp.json") : home ? join7(home, ".book", "mcp.json") : join7(resolveBookHome(), "mcp.json");
+}
+function validScope(scope) {
+  const normalized = scope ?? "user";
+  if (normalized !== "user" && normalized !== "project") {
+    throw new Error('MCP scope must be "user" or "project".');
+  }
+  return normalized;
+}
+function readConfigDocument(path) {
+  if (!existsSync3(path)) return {};
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync3(path, "utf8"));
+  } catch (error) {
+    throw new Error(
+      `Cannot update ${path}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Cannot update ${path}: expected a JSON object.`);
+  }
+  const document = parsed;
+  if (document.mcpServers !== void 0 && (!document.mcpServers || typeof document.mcpServers !== "object" || Array.isArray(document.mcpServers))) {
+    throw new Error(`Cannot update ${path}: mcpServers must be an object.`);
+  }
+  return document;
+}
+function parseEntries(kind, entries = []) {
+  const parsed = {};
+  for (const entry of entries) {
+    const separator = entry.indexOf("=");
+    if (separator <= 0) throw new Error(`Invalid --${kind} value "${entry}"; expected KEY=VALUE.`);
+    const key = entry.slice(0, separator).trim();
+    if (!key) throw new Error(`Invalid --${kind} value "${entry}"; the key is empty.`);
+    parsed[key] = entry.slice(separator + 1);
+  }
+  return parsed;
+}
+function validateRemoteUrl(raw) {
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    throw new Error("Remote MCP URL must be an absolute http:// or https:// URL.");
+  }
+  if (!["http:", "https:"].includes(url.protocol)) {
+    throw new Error("Remote MCP URL must use http:// or https://.");
+  }
+  if (url.username || url.password) throw new Error("Remote MCP URL must not contain credentials.");
+  return raw;
+}
+function inferredTransport(target, requested) {
+  if (requested) {
+    if (!["stdio", "http", "sse"].includes(requested)) {
+      throw new Error('MCP transport must be "stdio", "http", or "sse".');
+    }
+    return requested;
+  }
+  return /^https?:\/\//i.test(target) ? "http" : "stdio";
+}
+function createServerConfig(target, serverArgs, options) {
+  const transport = inferredTransport(target, options.transport);
+  if (transport === "stdio") {
+    if (!target.trim()) throw new Error("Stdio MCP command must not be empty.");
+    if ((options.header?.length ?? 0) > 0) {
+      throw new Error("--header is available only for HTTP/SSE servers.");
+    }
+    return {
+      type: "stdio",
+      command: target,
+      args: serverArgs,
+      env: parseEntries("env", options.env),
+      ...options.cwd ? { cwd: options.cwd } : {}
+    };
+  }
+  if (serverArgs.length > 0)
+    throw new Error("HTTP/SSE MCP servers do not accept command arguments.");
+  if ((options.env?.length ?? 0) > 0 || options.cwd) {
+    throw new Error("--env and --cwd are available only for stdio servers.");
+  }
+  return {
+    type: transport,
+    url: validateRemoteUrl(target),
+    headers: parseEntries("header", options.header)
+  };
+}
+function writeServer(workspace, scope, name, config, force, home) {
+  const path = configPath(workspace, scope, home);
+  const document = readConfigDocument(path);
+  const servers = { ...document.mcpServers ?? {} };
+  if (Object.prototype.hasOwnProperty.call(servers, name) && !force) {
+    throw new Error(`MCP server "${name}" already exists in ${path}; pass --force to replace it.`);
+  }
+  servers[name] = config;
+  writeFileAtomic(path, JSON.stringify({ ...document, mcpServers: servers }, null, 2) + "\n");
+  return path;
+}
+function removeServer(workspace, scope, name, home) {
+  const path = configPath(workspace, scope, home);
+  const document = readConfigDocument(path);
+  const servers = { ...document.mcpServers ?? {} };
+  if (!Object.prototype.hasOwnProperty.call(servers, name)) {
+    throw new Error(`MCP server "${name}" is not declared in ${path}.`);
+  }
+  delete servers[name];
+  writeFileAtomic(path, JSON.stringify({ ...document, mcpServers: servers }, null, 2) + "\n");
+  return path;
+}
+function serverRecords(workspace, home) {
+  const settings = resolveSettings(workspace);
+  return resolveMcpServerList(workspace, { home }).map((server) => ({
+    name: server.name,
+    source: server.source,
+    path: server.path,
+    transport: server.config.type ?? (server.config.url ? "http" : "stdio"),
+    target: formatMcpServerCommand(server.config),
+    approval: server.source === "user" ? "user" : evaluateMcpServerApproval(settings, server),
+    envKeys: Object.keys(server.config.env ?? {}).sort(),
+    headerKeys: Object.keys(server.config.headers ?? {}).sort()
+  }));
+}
+function printRecords(records, json = false) {
+  if (json) {
+    console.log(JSON.stringify(records, null, 2));
+    return;
+  }
+  if (records.length === 0) {
+    console.log("No MCP servers configured.");
+    return;
+  }
+  for (const server of records) {
+    console.log(
+      `${server.name}: ${server.target} [${server.source}${server.source === "project" ? `: ${server.approval}` : ""}]`
+    );
+    if (server.envKeys.length > 0) console.log(`  env: ${server.envKeys.join(", ")}`);
+    if (server.headerKeys.length > 0) {
+      console.log(`  headers: ${server.headerKeys.join(", ")} (values hidden)`);
+    }
+    console.log(`  config: ${server.path}`);
+  }
+}
+function runMcpListCommand(options) {
+  printRecords(serverRecords(options.workspace, options.home), options.json);
+}
+function runMcpGetCommand(name, options) {
+  const server = serverRecords(options.workspace, options.home).find(
+    (candidate) => candidate.name === name
+  );
+  if (!server) throw new Error(`MCP server "${name}" is not configured.`);
+  printRecords([server], options.json);
+}
+function runMcpAddCommand(name, target, serverArgs, options) {
+  if (!isValidMcpServerName(name)) {
+    throw new Error(
+      "MCP server names may contain letters, numbers, hyphens, or underscores, but not a double underscore."
+    );
+  }
+  const scope = validScope(options.scope);
+  const config = createServerConfig(target, serverArgs, options);
+  const path = writeServer(
+    options.workspace,
+    scope,
+    name,
+    config,
+    options.force ?? false,
+    options.home
+  );
+  console.log(`Added MCP server "${name}" to ${path}.`);
+  if (scope === "project") {
+    console.log("Project servers require one-time approval in an interactive Book session.");
+  }
+}
+function runMcpRemoveCommand(name, options) {
+  const scope = options.scope ? validScope(options.scope) : serverRecords(options.workspace, options.home).find((candidate) => candidate.name === name)?.source;
+  if (!scope) throw new Error(`MCP server "${name}" is not configured.`);
+  const path = removeServer(options.workspace, scope, name, options.home);
+  console.log(`Removed MCP server "${name}" from ${path}.`);
+}
+
+// src/index.ts
+function collectOption(value, previous) {
+  return [...previous, value];
+}
+function parseEffortOption(value) {
+  const normalized = value.trim().toLowerCase();
+  if (!isEffortLevel(normalized)) {
+    throw new InvalidArgumentError(`Valid levels: ${EFFORT_LEVELS.join(", ")}.`);
+  }
+  return normalized;
+}
+function resolveWorkspace(workspace) {
+  return workspace ?? program.opts().workspace;
+}
+program.name("book").description("AI coding agent with rich TUI").enablePositionalOptions().version(getPackageVersion()).option("-w, --workspace <path>", "Workspace root directory", process.cwd()).option("-m, --model <model>", "Model to use").option(
+  "-p, --print [prompt]",
+  "Print mode (non-interactive). Reads prompt from the flag or stdin."
+).option("--output-format <format>", "text | json | stream-json (print mode)", "text").option("--input-format <format>", "text | stream-json (print mode)", "text").option("--max-turns <n>", "Max agent turns (print mode; omit for unlimited)").option("--max-budget-usd <amount>", "Max USD spend (print mode)").option(
+  "--permission-mode <mode>",
+  "default | acceptEdits | plan | auto | dontAsk | bypassPermissions (overrides settings.defaultMode)"
+).option("--verbose", "Full turn-by-turn output").option("--json-schema <schema>", "Return validated JSON matching a JSON Schema (print mode)").option("-r, --resume <id|name>", "Resume a session by id or name").option("-c, --continue", "Resume the most recent session in this directory").option("--session-id <uuid>", "Use a specific session id").option("-n, --name <name>", "Set a display name for the session").option("--no-session-persistence", "Do not save the session to disk").option("--fork-session", "On resume, create a new session id instead of reusing").option("--include-hook-events", "Emit hook lifecycle events in stream-json output").option("--include-partial-messages", "Emit partial assistant text deltas in stream-json output").option("--prompt-suggestions", "Ask model for follow-up prompt suggestions after completion").option("--agents <mode>", "Managed agents: adaptive, manual, off").option("--scrollback", "Use terminal-native scrollback instead of the full-screen TUI").option("--settings <path>", "Path to an ad-hoc settings file (overrides all scopes)").option("--no-settings", "Skip all settings.json layers (use defaults + legacy .bookrc.json)").option(
+  "--effort <level>",
+  "Thinking effort: low, medium, high, xhigh, max (default: high)",
+  parseEffortOption
+).option("--provider <type>", "Provider: anthropic, openai, auto (default: auto-detect)");
+program.command("doctor").description("Diagnose configuration and environment").option("-w, --workspace <path>", "Workspace root directory (defaults to the root -w, then cwd)").option("--no-settings", "Skip all settings.json layers (use defaults + legacy .bookrc.json)").action(async (options) => {
+  await runDoctorCommand(resolveWorkspace(options.workspace), {
+    noSettings: options.settings === false
+  });
+});
+program.command("status").description("Report what a session is working on and what it has spent (no credentials needed)").argument("[session]", "Session id or name (defaults to the most recent in this workspace)").option("-w, --workspace <path>", "Workspace root directory (defaults to the root -w, then cwd)").option("--json", "Emit the status as JSON").action((session, options) => {
+  const code = runStatusCommand({
+    session,
+    workspace: resolveWorkspace(options.workspace),
+    json: options.json
+  });
+  if (code !== 0) exit(code);
+});
+program.command("tool-stats").description(
+  "Inspect and measure tool use recorded across sessions (fail counts, rates, durations)"
+).option("-w, --workspace <path>", "Workspace root directory (defaults to the root -w, then cwd)").option("--json", "Emit the aggregate as JSON").option("--since <days>", "Only include records from the last N days").option("--all", "Include the full history, ignoring the retention window").option("--prune", "Drop records older than the window from disk before reporting").action(
+  async (options) => {
+    await runToolStatsCommand({ ...options, workspace: resolveWorkspace(options.workspace) });
+  }
+);
+var mcpCommand = program.command("mcp").description("Manage MCP server configurations");
+mcpCommand.command("list").description("List resolved MCP servers without revealing secret values").option("-w, --workspace <path>", "Workspace root directory (defaults to the root -w, then cwd)").option("--json", "Emit JSON").action(
+  (options) => runMcpListCommand({ ...options, workspace: resolveWorkspace(options.workspace) })
+);
+mcpCommand.command("get").description("Show one resolved MCP server without revealing secret values").argument("<name>", "Server name").option("-w, --workspace <path>", "Workspace root directory (defaults to the root -w, then cwd)").option("--json", "Emit JSON").action(
+  (name, options) => runMcpGetCommand(name, { ...options, workspace: resolveWorkspace(options.workspace) })
+);
+mcpCommand.command("add").description("Add an MCP server (use -- before stdio arguments that start with a dash)").argument("<name>", "Server name").argument("<command-or-url>", "Stdio executable or HTTP/SSE URL").argument("[server-args...]", "Arguments for a stdio server").option("-w, --workspace <path>", "Workspace root directory (defaults to the root -w, then cwd)").option("--scope <scope>", "user | project", "user").option("--transport <type>", "stdio | http | sse").option("-e, --env <KEY=VALUE>", "Stdio environment entry (repeatable)", collectOption, []).option("-H, --header <KEY=VALUE>", "HTTP header (repeatable)", collectOption, []).option("--cwd <path>", "Working directory for a stdio server").option("--force", "Replace an existing same-scope server").action(
+  (name, target, serverArgs, options) => runMcpAddCommand(name, target, serverArgs, {
+    ...options,
+    workspace: resolveWorkspace(options.workspace)
+  })
+);
+mcpCommand.command("remove").alias("rm").description("Remove an MCP server from its effective scope").argument("<name>", "Server name").option("-w, --workspace <path>", "Workspace root directory (defaults to the root -w, then cwd)").option("--scope <scope>", "user | project").action(
+  (name, options) => runMcpRemoveCommand(name, { ...options, workspace: resolveWorkspace(options.workspace) })
+);
+var trustCommand = program.command("trust").description("Record decisions about configuration a repository declared");
+trustCommand.command("hook").description("Approve or reject a project-declared hook (see `book doctor`)").argument("[fingerprint]", "Hook fingerprint reported by `book doctor`").option("-w, --workspace <path>", "Workspace root directory (defaults to the root -w, then cwd)").option("--all-pending", "Apply to every hook currently awaiting a decision").option("--reject", "Record a refusal instead of an approval").action(
+  async (fingerprint, options) => {
+    await runTrustCommand("hook", fingerprint, {
+      ...options,
+      workspace: resolveWorkspace(options.workspace)
+    });
+  }
+);
+trustCommand.command("command").description("Approve or reject a project command that substitutes shell into its prompt").argument("[name]", "Command name, with or without the leading slash").option("-w, --workspace <path>", "Workspace root directory (defaults to the root -w, then cwd)").option("--all-pending", "Apply to every command currently awaiting a decision").option("--reject", "Record a refusal instead of an approval").action(
+  async (name, options) => {
+    await runTrustCommand("command", name, {
+      ...options,
+      workspace: resolveWorkspace(options.workspace)
+    });
+  }
+);
+trustCommand.command("rule").description("Approve or reject a project-declared permissions.allow rule").argument("[rule]", "Rule text exactly as the project declared it").option("-w, --workspace <path>", "Workspace root directory (defaults to the root -w, then cwd)").option("--all-pending", "Apply to every rule currently awaiting a decision").option("--reject", "Record a refusal instead of an approval").action(
+  async (rule, options) => {
+    await runTrustCommand("rule", rule, {
+      ...options,
+      workspace: resolveWorkspace(options.workspace)
+    });
+  }
+);
+program.command("config").description("Read and write settings").option("-w, --workspace <path>", "Workspace root directory (defaults to the root -w, then cwd)").option("--settings <path>", "Path to an ad-hoc settings file (overrides all scopes)").option("--no-settings", "Skip all settings.json layers (use defaults + legacy .bookrc.json)").option("-g, --global", "Act on user-global settings (<BOOK_HOME>/settings.json) [default]").option("--project", "Act on checked-in project settings (.book/settings.json)").option("--local", "Act on gitignored project-local settings (.book/settings.local.json)").argument("[action]", "get <key>, set <key> <value>, unset <key>, or list").argument("[key]", "Dot-separated key path (e.g. permissions.deny)").argument("[value]", "Value to set (JSON-parsed)").addHelpText("after", `
+${formatSettingsKeyHelp()}`).action(
+  async (action, key, value, options) => {
+    const rootSettings = program.opts().settings;
+    const settings = options.settings ?? rootSettings;
+    const selected = [
+      ["user", options.global],
+      ["project", options.project],
+      ["local", options.local]
+    ].filter(([, on]) => on === true);
+    if (selected.length > 1) {
+      console.error(
+        "Pass at most one of --global, --project, --local. Writes default to --global; reads without one report the resolved merge."
+      );
+      exit(1);
+    }
+    await runConfigCommand(resolveWorkspace(options.workspace), action, key, value, {
+      settingsOverridePath: typeof settings === "string" ? settings : void 0,
+      noSettings: settings === false,
+      scope: selected[0]?.[0]
+    });
+  }
+);
+program.action(async (options) => {
+  await runMainAction(options);
+});
+program.parse();
+//# sourceMappingURL=index.js.map