@letrquan/book 0.2.0 → 0.4.0-beta.0

package/dist/index.js

@@ -1,98 +1,159 @@
 #!/usr/bin/env node
 import {
+  checkProviderKey,
+  hasInkTrailingNewlineFix,
+  inkBuildDir,
   installFrameCapture,
-  installInkScrollRenderer
-} from "./chunk-C7D4NJ2D.js";
+  installInkFrameClip,
+  installInkOutputCache,
+  installInkRenderCull,
+  installInkScrollRenderer,
+  isCiEnvironment,
+  loadInkFlushSync,
+  providerKeyTarget,
+  resolveInkMaxFps,
+  resolveTuiRendererMode,
+  validateApiKey,
+  writeProviderKey
+} from "./chunk-ECLC4CIJ.js";
 import {
   buildMcpToolDefinitions,
+  cleanupRunStatus,
+  collectSkippedProjectFileNotices,
   collectWithheldProjectNotices,
+  collectWithheldProviderNotices,
   connectMcpServers,
   disconnectMcpServers,
+  isReaderGoneError,
   readRunStatus,
-  runHeadless
-} from "./chunk-J7MIZ5CA.js";
+  runHeadless,
+  runStatusPath
+} from "./chunk-E5WLQSKA.js";
+import {
+  evaluateMcpServerApproval,
+  mcpServerFingerprint,
+  mcpServersToRecord,
+  partitionMcpServersByApproval,
+  persistMcpProjectServerChoice
+} from "./chunk-PTDC7ZUP.js";
 import {
   SessionStore,
-  resolveSessionBootstrap
-} from "./chunk-V4BOYR52.js";
+  discardUntouchedSessions,
+  parseSessionDriver,
+  resolveSessionBootstrap,
+  resolveSessionDriver
+} from "./chunk-ENLB7NYV.js";
 import {
   aggregateToolUse,
   createDefaultRegistry,
   formatToolStatsReport,
-  freezeAgentConfig,
-  loadConfig,
+  pathExists,
   pruneToolUseRecords,
   readToolUseRecords
-} from "./chunk-XIFFTATU.js";
+} from "./chunk-KDNWMKXV.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";
+} from "./chunk-FPR7SKIE.js";
+import {
+  EFFORT_LEVELS,
+  freezeAgentConfig,
+  isEffortLevel,
+  loadConfig,
+  parseEffortLevel,
+  readLegacyBaseUrl
+} from "./chunk-N2G4Q7ME.js";
+import "./chunk-XJRJVXJR.js";
+import "./chunk-AHC7OU75.js";
+import "./chunk-DNFQTSMJ.js";
+import {
+  applySettingsEnvOverrides,
+  isUserSettingsFile,
+  loadSettingsFile,
+  resolveSettings,
+  resolveSettingsWithProviderGate,
+  startupAnimationEnvNote
+} from "./chunk-UCFJ43OS.js";
+import "./chunk-HOZXKOE3.js";
+import "./chunk-EFXVSQ5J.js";
+import "./chunk-62EEAUID.js";
 import {
   discoverCommands
-} from "./chunk-E75IPST5.js";
+} from "./chunk-AJZWLKLQ.js";
+import "./chunk-KXAYUIKP.js";
 import {
   describeProjectCommandShell,
   displayableCommandName,
   partitionProjectCommands,
   persistProjectCommandChoice,
   projectCommandFingerprint
-} from "./chunk-5KLVH3PY.js";
+} from "./chunk-SWPDKLNM.js";
+import "./chunk-2AAOF5B5.js";
 import {
   formatMcpServerCommand,
   isValidMcpServerName,
   resolveMcpServerList
-} from "./chunk-3U5IBM24.js";
+} from "./chunk-MEOB2DZA.js";
+import "./chunk-W7SLYS3M.js";
+import "./chunk-JGF5HLSI.js";
+import "./chunk-32WBCUAN.js";
+import "./chunk-RT5SATF7.js";
 import {
-  evaluateMcpServerApproval,
-  mcpServerFingerprint,
-  mcpServersToRecord,
-  partitionMcpServersByApproval,
-  persistMcpProjectServerChoice
-} from "./chunk-URLQAXTR.js";
-import "./chunk-MAQXCUR4.js";
+  buildChildEnv
+} from "./chunk-XHAO3K7I.js";
+import "./chunk-SBTU5BEC.js";
 import {
-  canonicalToolName
-} from "./chunk-5GDZ22YP.js";
-import "./chunk-EYGD6X2T.js";
+  collectDeclaredDirectories,
+  partitionProjectDirectories,
+  persistProjectDirectoryChoice,
+  realPathOfDirectory
+} from "./chunk-4DKHLZRI.js";
 import {
   DEFAULT_LOCAL_DATA_RETENTION_DAYS,
   cleanupDebugLogs,
   createDebugLogger,
   getDebugLogPath
-} from "./chunk-GTVB4HEM.js";
-import "./chunk-S4XL7HOM.js";
-import "./chunk-7N4J557C.js";
+} from "./chunk-OJBMDM5H.js";
 import {
-  loadSettingsFile,
-  resolveSettings
-} from "./chunk-BTZZUCLI.js";
+  canonicalToolName
+} from "./chunk-YIL6HTJX.js";
+import {
+  createUncGuard,
+  reachesUncPath
+} from "./chunk-EEX6QNXV.js";
 import {
   partitionProjectAllowRules,
   persistProjectAllowRuleChoice
-} from "./chunk-WKBO5R4O.js";
+} from "./chunk-MV5PQNIA.js";
+import {
+  LEGACY_BASE_URL_ID,
+  describeLegacyBaseUrl,
+  describeReservedProvider,
+  describeWorkspaceProvider,
+  environmentModelSelections,
+  evaluateLegacyBaseUrl,
+  legacyBaseUrlFingerprint,
+  persistWorkspaceProviderChoice,
+  providerTrustCommand,
+  trustCommandText,
+  withEnvironmentSelections
+} from "./chunk-B5FC3MYZ.js";
 import {
   collectDeclaredHooks,
   describeDeclaredHook,
   hookFingerprint,
   partitionProjectHooks,
-  persistProjectHookChoice
-} from "./chunk-ANSJPYGI.js";
-import "./chunk-DGMQEI6Y.js";
-import "./chunk-5RDRAO4B.js";
-import "./chunk-CAGOB2N4.js";
+  persistProjectHookChoice,
+  renderUntrustedText
+} from "./chunk-WV3O5PGX.js";
+import "./chunk-HFB74CLM.js";
 import {
   DEFAULT_SETTINGS,
   SettingsRepository,
@@ -102,21 +163,27 @@ import {
   parseNumericFlag,
   redactSettingValue,
   redactSettingsForDisplay,
+  resolvePrintPrompt,
   writeFileAtomic
-} from "./chunk-574C6MQR.js";
+} from "./chunk-REASC2QG.js";
+import {
+  projectFileWriteRefusal
+} from "./chunk-IDYWN37T.js";
 import {
   resolveBookHome
-} from "./chunk-24AXE6SP.js";
+} from "./chunk-ZPSZZUWF.js";
 
 // src/runtime-env.ts
 if (!process.env.NODE_ENV) {
   process.env.NODE_ENV = "production";
+  process.env.BOOK_DEFAULTED_NODE_ENV = "1";
 }
 
 // src/index.ts
 import { InvalidArgumentError, program } from "commander";
 
 // src/cli/status-cmd.ts
+import { existsSync } from "fs";
 import { join } from "path";
 function isProcessAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return false;
@@ -165,13 +232,17 @@ function buildSessionStatus(meta, loaded, runRecord) {
   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
-      });
+      const quote = estimateUsageCost(
+        model,
+        {
+          promptTokens: usage.promptTokens,
+          completionTokens: usage.completionTokens,
+          totalTokens: usage.totalTokens,
+          cacheReadInputTokens: usage.cacheReadInputTokens,
+          cacheCreationInputTokens: usage.cacheCreationInputTokens
+        },
+        "pool"
+      );
       if (quote.status !== "known") {
         costUsd = null;
         break;
@@ -314,7 +385,13 @@ 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);
+  const meta = options.session ? store.findById(options.session) ?? store.findByName(options.session) : (
+    // A print run of host-performed commands records no message, only a run record (#428).
+    store.mostRecentInCwd(
+      options.workspace,
+      (candidate) => candidate.messageCount > 0 || existsSync(runStatusPath(candidate.id, home))
+    )
+  );
   if (!meta) {
     stdout.write(
       options.session ? `No session found matching "${options.session}".
@@ -344,9 +421,12 @@ function exit(code = 0) {
 function isExiting() {
   return exiting;
 }
-
-// src/cli/doctor.ts
-import { resolve } from "path";
+var exitCodeFn = (code) => {
+  process.exitCode = code;
+};
+function setExitCode(code) {
+  exitCodeFn(code);
+}
 
 // src/agents/diagnostics.ts
 var MUTATION_TOOLS = /* @__PURE__ */ new Set([
@@ -436,20 +516,14 @@ function collectAgentDiagnostics(config, profiles) {
 }
 
 // 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}`;
-}
+var WORKSPACE_LAYER_TRUST = {
+  User: "trusted",
+  Project: "repository",
+  Local: "local"
+};
 function approvalHint(label, workspace, rest) {
-  const command = trustCommandLine(workspace, rest);
-  return command === null ? `${label} book trust ${rest} (run it from ${workspace})` : `${label} ${command}`;
+  const { command, note } = trustCommandText(workspace, rest);
+  return `${label} ${command}${note}`;
 }
 function formatRelativeTime(timestamp, now = Date.now()) {
   const elapsedMs = Math.max(0, now - timestamp);
@@ -466,8 +540,8 @@ function describeCredentials(config) {
 }
 var ABSENT_LAYER = "\0absent-settings-layer";
 async function settingsLayers(workspace) {
-  const { join: join8, resolve: resolve4 } = await import("path");
-  const root = resolve4(workspace);
+  const { join: join8, resolve: resolve3 } = await import("path");
+  const root = resolve3(workspace);
   return [
     ["User", join8(resolveBookHome(), "settings.json")],
     ["Project", join8(root, ".book", "settings.json")],
@@ -494,15 +568,15 @@ async function attributeFailingLayer(workspace) {
   return void 0;
 }
 async function reportUnloadableConfig(workspace, error) {
-  const { existsSync: existsSync4 } = await import("fs");
-  const { resolve: resolve4 } = await import("path");
+  const { existsSync: existsSync5 } = await import("fs");
+  const { resolve: resolve3 } = 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("Workspace:", resolve3(workspace));
   console.log();
   console.log("Configuration: FAILED TO LOAD");
   console.log("  " + (error instanceof Error ? error.message : String(error)));
@@ -511,7 +585,7 @@ async function reportUnloadableConfig(workspace, error) {
   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 marker = existsSync5(path) ? "[x]" : "[ ]";
     const blame = label === culprit ? "  <- the failure appears with this layer" : "";
     console.log("    " + marker + " " + label + ": " + path + blame);
   }
@@ -553,8 +627,8 @@ async function runDoctorCommand(workspace, options = {}) {
     collectRemovedEnvNotices,
     removedAuthStoreNotice,
     readSettingsDocumentForNotices
-  } = await import("./settings-removed-JWWPT4WA.js");
-  const { settingsLayerPaths } = await import("./settings-loader-M2QP5TX2.js");
+  } = await import("./settings-removed-3ATWJEF3.js");
+  const { settingsLayerPaths } = await import("./settings-loader-KDBH45AQ.js");
   const { join: joinPath } = await import("path");
   const { existsSync: fileExists } = await import("fs");
   const removedNotices = [
@@ -576,11 +650,13 @@ async function runDoctorCommand(workspace, options = {}) {
   }
   console.log();
   console.log("Settings layers:");
-  const { existsSync: existsSync4 } = await import("fs");
+  const { existsSync: existsSync5 } = await import("fs");
   const { join: join8 } = await import("path");
+  const { isUserSettingsFile: isUserSettingsFile2 } = await import("./settings-loader-KDBH45AQ.js");
   for (const [label, path] of await settingsLayers(config.workspace)) {
-    const marker = options.noSettings ? "[-]" : existsSync4(path) ? "[x]" : "[ ]";
-    console.log("  " + marker + " " + label + ": " + path);
+    const marker = options.noSettings ? "[-]" : existsSync5(path) ? "[x]" : "[ ]";
+    const note = label === "Project" && isUserSettingsFile2(path) ? " (the User file; read once, as User)" : "";
+    console.log("  " + marker + " " + label + ": " + path + note);
   }
   if (options.noSettings) {
     console.log("  (--no-settings: every layer skipped, defaults reported below)");
@@ -591,9 +667,10 @@ async function runDoctorCommand(workspace, options = {}) {
   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 { loadSettingsFile: loadSettingsFile2 } = await import("./settings-loader-KDBH45AQ.js");
+  const { partitionProjectAllowRules: partitionProjectAllowRules2 } = await import("./permission-approvals-Q5IMFEZI.js");
+  const projectPath = join8(config.workspace, ".book", "settings.json");
+  const projectSettings = isUserSettingsFile2(projectPath) ? null : loadSettingsFile2(projectPath);
   const projectAllow = partitionProjectAllowRules2(
     projectSettings?.permissions?.allow ?? [],
     perms.projectAllowRules
@@ -610,9 +687,33 @@ async function runDoctorCommand(workspace, options = {}) {
       );
     }
   }
+  const { collectDeclaredDirectories: collectDeclaredDirectories2, partitionProjectDirectories: partitionProjectDirectories2, resolveAdditionalRoots } = await import("./additional-roots-VAWRQ625.js");
+  const projectDirectories = partitionProjectDirectories2(
+    collectDeclaredDirectories2(config.workspace, projectSettings?.additionalDirectories ?? []),
+    settings.projectDirectories
+  );
+  const honoredAdditionalRoots = resolveAdditionalRoots(
+    config.workspace,
+    settings.additionalDirectories
+  );
+  if (honoredAdditionalRoots.length > 0 || projectDirectories.pending.length > 0) {
+    console.log("Additional directories (Read, Glob and Grep may reach these):");
+    for (const root of honoredAdditionalRoots) console.log("    [x] " + root);
+    for (const directory of projectDirectories.pending) {
+      console.log(
+        "    [!] " + directory.realPath + " (not in effect; declared as " + directory.declared + ")"
+      );
+    }
+    if (projectDirectories.pending.length > 0) {
+      console.log(approvalHint("    Approve one:", config.workspace, "dir <path>"));
+      console.log(
+        approvalHint("    Approve all pending:", config.workspace, "dir --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 { discoverCommands: discoverCommands2 } = await import("./loader-DQNPDKOX.js");
+  const { partitionProjectCommands: partitionProjectCommands2, describeProjectCommandShell: describeProjectCommandShell2, displayableCommandName: displayableCommandName2 } = await import("./command-approvals-ZRY66LCW.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):");
@@ -632,6 +733,90 @@ async function runDoctorCommand(workspace, options = {}) {
     }
     console.log();
   }
+  const providerGate = config.workspaceProviderGate;
+  if (providerGate) {
+    const {
+      describeDroppedOverride,
+      describeLegacyBaseUrl: describeLegacyBaseUrl2,
+      describeReservedProvider: describeReservedProvider2,
+      describeUnaffectedSelection,
+      describeWithheldSelection,
+      describeWorkspaceProvider: describeWorkspaceProvider2
+    } = await import("./provider-approvals-5AGH3RVT.js");
+    const STATE_MARKS = {
+      approved: { mark: "[x]", suffix: "" },
+      rejected: { mark: "[-]", suffix: " (rejected)" },
+      pending: { mark: "[!]", suffix: " (not in effect)" }
+    };
+    const providerGroups = ["approved", "rejected", "pending"].map((state) => ({
+      ...STATE_MARKS[state],
+      state,
+      entries: providerGate.partition[state]
+    }));
+    const legacy = providerGate.legacyBaseUrl;
+    const anyPending = providerGate.partition.pending.length > 0 || legacy?.state === "pending";
+    if (providerGate.declared.length > 0 || legacy) {
+      console.log("Workspace-declared providers (require approval):");
+      for (const group of providerGroups) {
+        for (const entry of group.entries) {
+          const routed = group.state === "pending" ? providerGate.unaffectedSelections.filter((s) => s.providerId === entry.id) : [];
+          const [first, ...rest] = describeWorkspaceProvider2(entry, config.workspace, routed);
+          console.log(`  ${group.mark} ${first}${group.suffix}`);
+          for (const line of rest) console.log(`        ${line}`);
+          console.log(`        declared in: ${entry.layers.join(", ")}`);
+        }
+      }
+      for (const entry of providerGate.partition.reserved) {
+        console.log(`  [!] ${describeReservedProvider2(entry)}`);
+      }
+      if (legacy) {
+        const { mark, suffix } = STATE_MARKS[legacy.state];
+        const [first, ...rest] = describeLegacyBaseUrl2(legacy.baseUrl, {
+          providers: settings.provider,
+          workspace: config.workspace
+        });
+        console.log(`  ${mark} ${first}${suffix}`);
+        for (const line of rest) console.log(`      ${line}`);
+      }
+      for (const entry of providerGate.partition.pending) {
+        const { command, note } = providerTrustCommand(config.workspace, entry.id);
+        console.log(`  Approve ${renderUntrustedText(entry.id, 64)}:`);
+        console.log(`    ${command}${note}`);
+      }
+      if (legacy?.state === "pending") {
+        console.log(
+          approvalHint("  Approve the legacy baseUrl:", config.workspace, "provider .bookrc.json")
+        );
+      }
+      if (anyPending) {
+        console.log(
+          approvalHint("  Approve all pending:", config.workspace, "provider --all-pending") + " (add --reject to refuse)"
+        );
+      }
+      console.log();
+    }
+    if (providerGate.droppedOverrides.length > 0) {
+      console.log("Workspace overrides of your providers (dropped):");
+      for (const dropped of providerGate.droppedOverrides) {
+        console.log(`  [!] ${describeDroppedOverride(dropped)}`);
+      }
+      console.log();
+    }
+    if (providerGate.withheldSelections.length > 0) {
+      console.log("Withheld model selections:");
+      for (const selection of providerGate.withheldSelections) {
+        console.log(`  [!] ${describeWithheldSelection(selection)}`);
+      }
+      console.log();
+    }
+    if (providerGate.unaffectedSelections.length > 0) {
+      console.log("Your model selections that share a prefix with a withheld provider:");
+      for (const selection of providerGate.unaffectedSelections) {
+        console.log(`  [x] ${describeUnaffectedSelection(selection)}`);
+      }
+      console.log();
+    }
+  }
   const hooks = settings.hooks;
   const hookLists = Object.entries(hooks).filter(
     (pair) => Array.isArray(pair[1])
@@ -643,7 +828,7 @@ async function runDoctorCommand(workspace, options = {}) {
     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 { collectDeclaredHooks: collectDeclaredHooks2, describeDeclaredHook: describeDeclaredHook2, partitionProjectHooks: partitionProjectHooks2 } = await import("./hook-approvals-DPQD5H65.js");
   const declaredProjectHooks = collectDeclaredHooks2(projectSettings);
   if (declaredProjectHooks.length > 0) {
     const hookPartition = partitionProjectHooks2(
@@ -671,8 +856,8 @@ async function runDoctorCommand(workspace, options = {}) {
     }
   }
   console.log();
-  const { formatMcpServerCommand: formatMcpServerCommand2, resolveMcpServerList: resolveMcpServerList2 } = await import("./mcp-config-YIJIES2C.js");
-  const { evaluateMcpServerApproval: evaluateMcpServerApproval2 } = await import("./mcp-approvals-WNPH65BK.js");
+  const { formatMcpServerCommand: formatMcpServerCommand2, resolveMcpServerList: resolveMcpServerList2 } = await import("./mcp-config-GXSODNCM.js");
+  const { evaluateMcpServerApproval: evaluateMcpServerApproval2 } = await import("./mcp-approvals-27LJYADQ.js");
   const mcpServers = resolveMcpServerList2(config.workspace);
   console.log("MCP Servers:");
   for (const server of mcpServers) {
@@ -681,8 +866,8 @@ async function runDoctorCommand(workspace, options = {}) {
   }
   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 { createSandbox, sandboxPolicySummary } = await import("./sandbox-N2RY72GN.js");
+  const { hasAdjudicationPolicy } = await import("./permissions-7Y35X6HZ.js");
   const sandbox = createSandbox(settings.sandbox);
   const policy = sandboxPolicySummary(settings.sandbox, {
     sandboxActive: sandbox !== null,
@@ -695,12 +880,49 @@ async function runDoctorCommand(workspace, options = {}) {
   console.log("  Excluded commands: " + settings.sandbox.excludedCommands.length);
   console.log("  Unsandboxed commands: " + policy.unsandboxedCommands);
   console.log("  Auto-allow Bash: " + policy.autoAllowBash);
+  console.log("  Git directories: " + policy.gitDirectories);
+  if (!options.noSettings) {
+    const {
+      formatIgnoredWorkspaceSandboxKey,
+      ignoredWorkspaceSandboxKeys,
+      loadSettingsFile: loadSettingsFile3,
+      workspaceLayerThatEnabledSandbox
+    } = await import("./settings-loader-KDBH45AQ.js");
+    const layers = (await settingsLayers(config.workspace)).map(([label, path]) => ({
+      label,
+      path,
+      document: label === "Project" && isUserSettingsFile2(path) ? null : loadSettingsFile3(path)
+    }));
+    const activation = workspaceLayerThatEnabledSandbox(
+      layers.map((layer) => ({
+        path: layer.path,
+        trust: WORKSPACE_LAYER_TRUST[layer.label] ?? "local",
+        document: layer.document
+      }))
+    );
+    for (const { label, path, document } of layers) {
+      if (label === "User") continue;
+      for (const entry of ignoredWorkspaceSandboxKeys(document ?? {})) {
+        console.log(
+          `  Ignored from ${path}: ${formatIgnoredWorkspaceSandboxKey(entry)} \u2014 workspace settings may only tighten the sandbox; set it in ~/.book/settings.json or pass --settings`
+        );
+      }
+      if (path === activation) {
+        console.log(
+          `  From ${path}: sandbox.enabled=true \u2014 a workspace file turned the sandbox on, so sandbox.autoAllowBashIfSandboxed=false with it; set autoAllowBashIfSandboxed in ~/.book/settings.json to have it back.`
+        );
+      }
+    }
+  }
   console.log();
-  const { describeShell, resolveShell } = await import("./shell-selection-V6QAYXPX.js");
+  const { describeShell, resolveShell } = await import("./shell-selection-Z5WORZU4.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 (process.platform === "win32" && (shell.kind === "bash" || shell.kind === "sh")) {
+    console.log("  msys: " + (shell.msys ? "yes" : "no"));
+  }
   if (shell.warning) console.log(`  [!] ${shell.warning}`);
   console.log();
   console.log("Managed agents:");
@@ -719,14 +941,14 @@ async function runDoctorCommand(workspace, options = {}) {
     join8(config.workspace, ".claude", "agents"),
     join8(config.workspace, ".agents", "agents")
   ]) {
-    if (existsSync4(directory)) {
+    if (existsSync5(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 { createModelWindowStore } = await import("./model-window-store-6VKXXTPJ.js");
   const windowStore = createModelWindowStore();
   const allLearned = windowStore.all();
   const learnedModels = Object.keys(allLearned);
@@ -742,6 +964,41 @@ async function runDoctorCommand(workspace, options = {}) {
     }
   }
   console.log();
+  const {
+    DEFAULT_MAX_INDEX_LINES,
+    MAX_INDEX_BYTES,
+    findLegacyMemoryBackup,
+    getMemoryHealth,
+    legacyBackupNotice,
+    loadMemoryContext
+  } = await import("./memory-store-I6Z54VUN.js");
+  const memoryContext = loadMemoryContext(config.workspace);
+  const memoryHealth = getMemoryHealth(memoryContext);
+  const memoryBackup = findLegacyMemoryBackup(memoryContext.dir);
+  const lastWrite = memoryHealth.lastWrite ? memoryHealth.lastWrite.toISOString() : "never";
+  console.log("Memory:");
+  console.log("  Memories:          " + memoryHealth.fileCount);
+  if (memoryHealth.legacySupersededCount > 0) {
+    console.log(
+      `  Legacy superseded: ${memoryHealth.legacySupersededCount} (retired by the old save tool; they load like any other)`
+    );
+  }
+  console.log(`  Index lines:       ${memoryHealth.indexLineCount} / ${DEFAULT_MAX_INDEX_LINES}`);
+  console.log(
+    `  Index bytes:       ${memoryHealth.indexByteCount.toLocaleString("en-US")} / ${MAX_INDEX_BYTES.toLocaleString("en-US")}`
+  );
+  if (memoryHealth.wasLineTruncated || memoryHealth.wasByteTruncated) {
+    const limits = [
+      memoryHealth.wasLineTruncated ? `${DEFAULT_MAX_INDEX_LINES} lines` : "",
+      memoryHealth.wasByteTruncated ? `${MAX_INDEX_BYTES.toLocaleString("en-US")} bytes` : ""
+    ].filter(Boolean);
+    console.log(
+      `  Index cut:         MEMORY.md is over the ${limits.join(" and ")} limit; a session loads only part of it. Consolidate it.`
+    );
+  }
+  console.log("  Last write:        " + lastWrite);
+  if (memoryBackup) console.log("  " + legacyBackupNotice(memoryBackup));
+  console.log();
   console.log("Environment:");
   for (const key of ["BOOK_API_KEY", "BOOK_BASE_URL", "BOOK_MODEL", "BOOK_WORKSPACE"]) {
     const val = process.env[key];
@@ -790,9 +1047,190 @@ async function runToolStatsCommand(options) {
   }
 }
 
+// src/cli/provider-key-cmd.ts
+import { createInterface } from "readline";
+import { Writable } from "stream";
+var USAGE = "Usage: book config provider-key <provider-id>  (the key is read from stdin)";
+var MAX_PIPED_BYTES = 64 * 1024;
+async function readPiped(input) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of input) {
+    const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+    size += buffer.length;
+    if (size > MAX_PIPED_BYTES) return void 0;
+    chunks.push(buffer);
+  }
+  return Buffer.concat(chunks).toString("utf-8").replace(/\r?\n$/, "");
+}
+async function readTerminalLine(input, stderr, prompt, hidden) {
+  stderr.write(prompt);
+  const output = hidden ? new Writable({
+    write(_chunk, _encoding, done) {
+      done();
+    }
+  }) : stderr;
+  const rl = createInterface({ input, output, terminal: true });
+  try {
+    return await new Promise((resolve3) => {
+      rl.once("line", resolve3);
+      rl.once("SIGINT", () => resolve3(void 0));
+      rl.once("close", () => resolve3(void 0));
+    });
+  } finally {
+    rl.close();
+    if (hidden) stderr.write("\n");
+  }
+}
+async function askAfterFailure(input, stderr) {
+  const answer = await readTerminalLine(
+    input,
+    stderr,
+    "[s] save anyway  [r] retry  [e] enter a different key  [c] cancel: ",
+    false
+  );
+  switch (answer?.trim().toLowerCase()) {
+    case "s":
+      return "save";
+    case "r":
+      return "retry";
+    case "e":
+      return "edit";
+    default:
+      return "cancel";
+  }
+}
+async function runProviderKeyCommand(workspace, providerId, extra, options = {}) {
+  const stdin = options.stdin ?? process.stdin;
+  const stderr = options.stderr ?? process.stderr;
+  if (extra !== void 0) {
+    console.error(
+      "provider-key reads the key from stdin, never from an argument; nothing was saved. A key typed on the command line is in your shell history: consider rotating it."
+    );
+    console.error(USAGE);
+    return exit(1);
+  }
+  if (!providerId) {
+    console.error(USAGE);
+    return exit(1);
+  }
+  if (options.ignoresSettingsFlags) {
+    console.error(
+      "provider-key edits your user settings (<BOOK_HOME>/settings.json) whatever the settings layers in use; --settings and --no-settings do not apply to it."
+    );
+    return exit(1);
+  }
+  if (options.scope && options.scope !== "user") {
+    console.error(
+      `provider-key changes providers in your user settings only, not ${settingsScopeLabel(options.scope)} settings.`
+    );
+    return exit(1);
+  }
+  const target = providerKeyTarget(workspace, providerId);
+  if (target.kind === "unreadable") {
+    console.error(`Could not read user settings (${target.path}): ${target.error}`);
+    return exit(1);
+  }
+  if (target.kind === "workspace-only") {
+    console.error(
+      `Provider "${providerId}" is declared by this repository (${target.declaredIn}), not your user settings (${target.path}). provider-key changes only providers you configured.`
+    );
+    return exit(1);
+  }
+  if (target.kind === "unknown") {
+    console.error(
+      // The id is not repeated: one that names no provider is as likely to be a key typed in
+      // its place, and the command promises never to echo a key.
+      `No provider with that id in user settings (${target.path}). ` + (target.configured.length > 0 ? `Configured: ${target.configured.join(", ")}.` : "No providers are configured there yet; add one with /providers in the TUI.")
+    );
+    return exit(1);
+  }
+  const interactive = stdin.isTTY === true;
+  const readKey = async () => {
+    const raw = interactive ? await readTerminalLine(stdin, stderr, `API key for ${providerId}: `, true) : await readPiped(stdin);
+    if (raw === void 0) {
+      console.error(
+        interactive ? "Cancelled; nothing was saved." : `The input is longer than ${MAX_PIPED_BYTES} bytes, which no API key is; nothing was saved.`
+      );
+      return exit(1);
+    }
+    try {
+      return validateApiKey(raw);
+    } catch (caught) {
+      console.error(caught instanceof Error ? caught.message : "Invalid API key.");
+      return exit(1);
+    }
+  };
+  let apiKey = await readKey();
+  let tested = false;
+  while (options.check !== false) {
+    const result = await checkProviderKey({
+      provider: target.provider,
+      apiKey,
+      workspace,
+      retry: DEFAULT_SETTINGS.retry,
+      discover: options.discover
+    });
+    if (result.ok) {
+      tested = true;
+      break;
+    }
+    console.error(`The key check failed: ${result.error}`);
+    if (options.force) {
+      console.warn("Saving anyway (--force).");
+      break;
+    }
+    if (!interactive) {
+      console.error(
+        "Nothing was saved. Pass --force to save anyway, or --no-check to skip the check."
+      );
+      return exit(1);
+    }
+    const choice = await askAfterFailure(stdin, stderr);
+    if (choice === "save") break;
+    if (choice === "cancel") {
+      console.error("Cancelled; nothing was saved.");
+      return exit(1);
+    }
+    if (choice === "edit") apiKey = await readKey();
+  }
+  const written = writeProviderKey(workspace, providerId, apiKey);
+  if (!written.ok) {
+    console.error(written.error);
+    return exit(1);
+  }
+  console.log(
+    `Updated the API key of provider "${providerId}" in user settings (${written.path})` + (tested ? "; the endpoint accepted it." : ".")
+  );
+  if (written.localCleared) {
+    console.log(
+      `Removed the connection keys of the same-named entry in ${written.localCleared}, which would otherwise look like they override it.`
+    );
+  }
+  if (written.localError) {
+    console.warn(`\u26A0  Could not clean up the local entry: ${written.localError}`);
+  }
+}
+
 // 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 resolveMergedSettings = () => applySettingsEnvOverrides(
+    settingsOptions.noSettings ? structuredClone(DEFAULT_SETTINGS) : resolveSettings(workspace, settingsOptions.settingsOverridePath)
+  );
+  if (action === "provider-key") {
+    await runProviderKeyCommand(workspace, key, value, {
+      ...settingsOptions.providerKey,
+      scope: settingsOptions.scope,
+      ignoresSettingsFlags: Boolean(
+        settingsOptions.settingsOverridePath || settingsOptions.noSettings
+      )
+    });
+    return;
+  }
+  if (settingsOptions.providerKey?.force || settingsOptions.providerKey?.check === false) {
+    console.error("--force and --no-check apply to provider-key only.");
+    exit(1);
+  }
   const scopeRead = settingsOptions.scope ? readScopeDocument(settingsOptions.scope, workspace) : void 0;
   if (!action || action === "list") {
     if (scopeRead) {
@@ -808,6 +1246,8 @@ async function runConfigCommand(workspace, action, key, value, settingsOptions =
     }
     console.log("Resolved settings:");
     console.log(JSON.stringify(redactSettingsForDisplay(resolveMergedSettings()), null, 2));
+    const listNote = startupAnimationEnvNote();
+    if (listNote) console.log(`\u26A0  ${listNote}`);
     return;
   }
   if (action === "get") {
@@ -829,6 +1269,10 @@ async function runConfigCommand(workspace, action, key, value, settingsOptions =
       );
     } else {
       console.log(JSON.stringify(redactSettingValue(key, val), null, 2));
+      if (!scopeRead && key === "ui.startupAnimation") {
+        const note = startupAnimationEnvNote();
+        if (note) console.log(`\u26A0  ${note}`);
+      }
     }
     return;
   }
@@ -871,7 +1315,7 @@ async function runConfigCommand(workspace, action, key, value, settingsOptions =
       exit(1);
     }
     const scope = settingsOptions.scope ?? "user";
-    const layer = readScopeDocument(scope, workspace);
+    const layer = readScopeDocument(scope, workspace, { forWrite: true });
     if (layer.status === "unreadable") {
       console.error(
         `Could not read ${settingsScopeLabel(scope)} settings (${layer.path}): ${layer.error ?? "unknown error"}`
@@ -893,7 +1337,7 @@ async function runConfigCommand(workspace, action, key, value, settingsOptions =
     return;
   }
   console.error(
-    "Unknown action: " + action + ". Use: get <key>, set <key> <value>, unset <key>, or list"
+    "Unknown action: " + action + ". Use: get <key>, set <key> <value>, unset <key>, list, or provider-key <id>"
   );
   exit(1);
 }
@@ -911,21 +1355,25 @@ async function runTrustCommand(kind, target, options) {
   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) {
+  const listsProviders = kind === "provider" && !options.allPending && target === void 0;
+  if (!options.allPending && target === void 0 && !listsProviders) {
     fail(
       `book trust ${kind}: name what to trust, or pass --all-pending. Run \`book doctor\` to list what is withheld.`
     );
   }
   let settings;
+  let providerGate;
   try {
-    settings = resolveSettings(workspace);
+    ({ settings, providerGate } = resolveSettingsWithProviderGate(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 projectPath = join2(workspace, ".book", "settings.json");
+  const projectSettings = isUserSettingsFile(projectPath) ? null : loadSettingsFile(projectPath);
   const decisions = [];
+  const directoryDecisions = [];
   if (kind === "command") {
     const partition = partitionProjectCommands(discoverCommands(workspace), settings);
     const push = (command) => {
@@ -988,6 +1436,120 @@ ${known}` : "\nNothing is awaiting a decision.")
       }
       decisions.push({ key: target, label: describeDeclaredHook(hook).headline });
     }
+  } else if (kind === "dir") {
+    const declared = collectDeclaredDirectories(
+      workspace,
+      projectSettings?.additionalDirectories ?? []
+    );
+    const partition = partitionProjectDirectories(declared, settings.projectDirectories);
+    const targetRealPath = realPathOfDirectory(workspace, target ?? "");
+    const entry = declared.find(
+      (candidate) => candidate.realPath === targetRealPath || candidate.declared === target
+    );
+    if (options.allPending) {
+      if (partition.pending.length === 0) {
+        console.log(`No project-declared directories are awaiting a decision in ${workspace}.`);
+        return;
+      }
+      for (const pending of partition.pending) {
+        console.log(`${pending.declared} is really:`);
+        console.log(`  ${pending.realPath}`);
+        directoryDecisions.push(pending);
+      }
+    } else if (!entry) {
+      const known = partition.pending.map((pending) => `  ${pending.realPath}`).join("\n");
+      return fail(
+        `book trust dir: ${workspace} declares no project additionalDirectories entry at "${target}".` + (known ? `
+Awaiting a decision:
+${known}` : "\nNothing is awaiting a decision.")
+      );
+    } else {
+      if (!options.reject) {
+        console.log(`${entry.declared} is really:`);
+        console.log(`  ${entry.realPath}`);
+      }
+      directoryDecisions.push(entry);
+    }
+  } else if (kind === "provider") {
+    const unaffected = withEnvironmentSelections(
+      providerGate.unaffectedSelections,
+      environmentModelSelections(void 0),
+      new Set(providerGate.withheld)
+    );
+    const candidates = ["approved", "pending", "rejected"].flatMap(
+      (state) => providerGate.partition[state].map((entry) => ({
+        id: entry.id,
+        fingerprint: entry.fingerprint,
+        state,
+        lines: describeWorkspaceProvider(
+          entry,
+          workspace,
+          unaffected.filter((selection) => selection.providerId === entry.id)
+        )
+      }))
+    );
+    const legacyBaseUrl = readLegacyBaseUrl(workspace);
+    if (legacyBaseUrl !== void 0) {
+      candidates.push({
+        id: LEGACY_BASE_URL_ID,
+        fingerprint: legacyBaseUrlFingerprint(legacyBaseUrl),
+        state: evaluateLegacyBaseUrl(settings.workspaceProviders, legacyBaseUrl),
+        lines: describeLegacyBaseUrl(legacyBaseUrl, { providers: settings.provider, workspace })
+      });
+    }
+    const pending = candidates.filter((candidate) => candidate.state === "pending");
+    const printCandidate = (candidate, prefix) => {
+      const [first, ...rest] = candidate.lines;
+      console.log(`${prefix}${first}`);
+      for (const line of rest) console.log(`      ${line}`);
+    };
+    const push = (candidate) => {
+      if (!options.reject) printCandidate(candidate, "  ");
+      decisions.push({
+        key: candidate.id,
+        label: candidate.id,
+        fingerprint: candidate.fingerprint
+      });
+    };
+    const reserved = providerGate.partition.reserved.map(
+      (entry) => `  [!] ${describeReservedProvider(entry)}`
+    );
+    if (listsProviders) {
+      for (const line of reserved) console.log(line);
+      if (pending.length === 0) {
+        console.log(`No workspace-declared providers are awaiting a decision in ${workspace}.`);
+        return;
+      }
+      console.log(`Workspace-declared providers awaiting a decision in ${workspace}:`);
+      for (const candidate of pending) printCandidate(candidate, "  [!] ");
+      for (const candidate of pending) {
+        const { command, note } = providerTrustCommand(workspace, candidate.id);
+        console.log(`Approve ${renderUntrustedText(candidate.id, 64)}:`);
+        console.log(`  ${command}${note}`);
+      }
+      const all = trustCommandText(workspace, "provider --all-pending");
+      console.log(`Approve all: ${all.command}${all.note}   (add --reject to refuse)`);
+      return;
+    }
+    if (options.allPending) {
+      if (pending.length === 0) {
+        console.log(`No workspace-declared providers are awaiting a decision in ${workspace}.`);
+        return;
+      }
+      for (const candidate of pending) push(candidate);
+    } else {
+      const candidate = candidates.find((known) => known.id === target);
+      if (!candidate) {
+        const known = candidates.map((entry) => `  ${renderUntrustedText(entry.id, 64)}  (${entry.state})`).join("\n");
+        return fail(
+          `book trust provider: ${workspace} declares no provider "${target}" that can be decided.` + (known ? `
+Declared by the workspace:
+${known}` : "\nNothing is declared.") + (reserved.length > 0 ? `
+${reserved.join("\n")}` : "")
+        );
+      }
+      push(candidate);
+    }
   } else {
     const declared = projectSettings?.permissions?.allow ?? [];
     const partition = partitionProjectAllowRules(declared, settings.permissions.projectAllowRules);
@@ -1010,8 +1572,13 @@ ${known}` : "\nNothing is awaiting a decision.")
     }
   }
   const failures = [];
+  for (const directory of directoryDecisions) {
+    const result = persistProjectDirectoryChoice(workspace, directory.realPath, choice);
+    if (result.ok) console.log(`${verb} ${directory.realPath}`);
+    else failures.push(`${directory.realPath}: ${result.error ?? "unknown error"}`);
+  }
   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);
+    const result = kind === "command" ? persistProjectCommandChoice(workspace, decision.key, decision.fingerprint, choice) : kind === "provider" ? persistWorkspaceProviderChoice(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"}`);
   }
@@ -1023,10 +1590,6 @@ ${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;
@@ -1221,13 +1784,49 @@ var McpSessionHost = class {
   }
 };
 
+// src/cli/print-interrupt.ts
+function installPrintInterrupt(options = {}) {
+  const controller = new AbortController();
+  let interrupted;
+  const onSignal = (signal) => {
+    if (interrupted) {
+      (options.onSecondSignal ?? ((second) => exit(second === "SIGINT" ? 130 : 143)))(signal);
+      return;
+    }
+    interrupted = signal;
+    (options.stderr ?? process.stderr).write(
+      "\nCancelling: running SessionEnd hooks. Press Ctrl+C again to exit now.\n"
+    );
+    controller.abort(
+      Object.assign(new Error(`Cancelled by ${signal}`), { bookTerminalReason: "user_cancelled" })
+    );
+  };
+  const onSigint = () => onSignal("SIGINT");
+  const onSigterm = () => onSignal("SIGTERM");
+  process.on("SIGINT", onSigint);
+  process.on("SIGTERM", onSigterm);
+  return {
+    signal: controller.signal,
+    interruptedBy: () => interrupted,
+    dispose: () => {
+      process.off("SIGINT", onSigint);
+      process.off("SIGTERM", onSigterm);
+    }
+  };
+}
+function printExitCode(run) {
+  if (run.interruptedBy) return run.interruptedBy === "SIGINT" ? 130 : 143;
+  if (run.outcome) return run.outcome.status === "failed" ? 1 : 0;
+  return run.aborted ? 0 : 1;
+}
+
 // src/cli/run.ts
 import { join as join6 } from "path";
 
 // src/rewind/snapshot-store.ts
 import {
   chmodSync,
-  existsSync,
+  existsSync as existsSync2,
   lstatSync,
   mkdirSync,
   readFileSync,
@@ -1241,7 +1840,7 @@ import {
 } 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 { dirname, isAbsolute, join as join3, relative, resolve, sep } from "path";
 import ignore from "ignore";
 var REWIND_MAX_ENTRIES = 2e4;
 var REWIND_MAX_FILE_BYTES = 16 * 1024 * 1024;
@@ -1274,7 +1873,7 @@ var DEFAULT_IGNORE_PATTERNS = [
 function sha256(value) {
   return createHash("sha256").update(value).digest("hex");
 }
-function pathExists(path) {
+function pathExists2(path) {
   try {
     lstatSync(path);
     return true;
@@ -1283,7 +1882,7 @@ function pathExists(path) {
   }
 }
 function normalizeWorkspace(workspace) {
-  const normalized = resolve2(workspace);
+  const normalized = resolve(workspace);
   return process.platform === "win32" ? normalized.toLowerCase() : normalized;
 }
 function rewindWorkspaceHash(workspace) {
@@ -1339,11 +1938,12 @@ function createRewindSnapshotStore(workspace, root) {
 }
 function readCustomIgnorePatterns(workspace) {
   const path = join3(workspace, ".book", "rewindignore");
-  if (!existsSync(path)) return [];
+  if (reachesUncPath(path) || !existsSync2(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");
+  if (reachesUncPath(path)) return [];
   try {
     return (await readFile(path, "utf-8")).split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
   } catch (error) {
@@ -1364,33 +1964,39 @@ function expandNegatedParents(patterns) {
   }
   return expanded;
 }
-function readOptionalText(path) {
+function readOptionalText(path, reachesUnc) {
+  if (reachesUnc(path)) return void 0;
   try {
     return readFileSync(path, "utf-8").trim();
   } catch {
     return void 0;
   }
 }
-function resolveGitDirectory(workspace) {
+function resolveGitDirectory(workspace, reachesUnc) {
   const dotGit = join3(workspace, ".git");
+  if (reachesUnc(dotGit)) return void 0;
   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;
+  const match = /^gitdir:\s*(.+)$/i.exec(readOptionalText(dotGit, reachesUnc) ?? "");
+  if (!match) return void 0;
+  const gitDirectory = resolve(dirname(dotGit), match[1]);
+  return reachesUnc(gitDirectory) ? void 0 : gitDirectory;
 }
-function resolveCommonGitDirectory(gitDirectory) {
-  const commonDirectory = readOptionalText(join3(gitDirectory, "commondir"));
-  return commonDirectory ? resolve2(gitDirectory, commonDirectory) : gitDirectory;
+function resolveCommonGitDirectory(gitDirectory, reachesUnc) {
+  const commonDirectory = readOptionalText(join3(gitDirectory, "commondir"), reachesUnc);
+  if (!commonDirectory) return gitDirectory;
+  const common = resolve(gitDirectory, commonDirectory);
+  return reachesUnc(common) ? gitDirectory : common;
 }
 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"));
+function readPackedRef(directory, ref, reachesUnc) {
+  const packedRefs = readOptionalText(join3(directory, "packed-refs"), reachesUnc);
   if (!packedRefs) return void 0;
   for (const line of packedRefs.split(/\r?\n/)) {
     if (!line || line.startsWith("#") || line.startsWith("^")) continue;
@@ -1401,12 +2007,12 @@ function readPackedRef(directory, ref) {
   }
   return void 0;
 }
-function resolveGitRef(gitDirectory, commonDirectory, ref, depth = 0) {
+function resolveGitRef(gitDirectory, commonDirectory, ref, reachesUnc, 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 value = readOptionalText(join3(directory, ...ref.split("/")), reachesUnc);
     const hash = parseGitHash(value);
     if (hash) return hash;
     if (value?.startsWith("ref:")) {
@@ -1414,24 +2020,27 @@ function resolveGitRef(gitDirectory, commonDirectory, ref, depth = 0) {
         gitDirectory,
         commonDirectory,
         value.slice("ref:".length).trim(),
+        reachesUnc,
         depth + 1
       );
       if (resolved) return resolved;
     }
   }
-  return readPackedRef(gitDirectory, ref) ?? (commonDirectory === gitDirectory ? void 0 : readPackedRef(commonDirectory, ref));
+  return readPackedRef(gitDirectory, ref, reachesUnc) ?? (commonDirectory === gitDirectory ? void 0 : readPackedRef(commonDirectory, ref, reachesUnc));
 }
 function gitHead(workspace) {
-  const gitDirectory = resolveGitDirectory(workspace);
+  const reachesUnc = createUncGuard();
+  const gitDirectory = resolveGitDirectory(workspace, reachesUnc);
   if (!gitDirectory) return void 0;
-  const head = readOptionalText(join3(gitDirectory, "HEAD"));
+  const head = readOptionalText(join3(gitDirectory, "HEAD"), reachesUnc);
   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()
+    resolveCommonGitDirectory(gitDirectory, reachesUnc),
+    head.slice("ref:".length).trim(),
+    reachesUnc
   );
 }
 async function gitHeadAsync(workspace) {
@@ -1449,7 +2058,7 @@ function assertSafeRelativePath(path) {
 }
 function resolveEntryPath(workspace, path) {
   assertSafeRelativePath(path);
-  const target = resolve2(workspace, ...path.split("/"));
+  const target = resolve(workspace, ...path.split("/"));
   const rel = relative(workspace, target);
   if (rel.startsWith(`..${sep}`) || rel === ".." || isAbsolute(rel)) {
     throw new Error(`Rewind path escapes the workspace: ${path}`);
@@ -1539,7 +2148,7 @@ function writeAtomic(path, contents) {
     writeFileSync(temporary, contents);
     renameSync(temporary, path);
   } finally {
-    if (pathExists(temporary)) unlinkSync(temporary);
+    if (pathExists2(temporary)) unlinkSync(temporary);
   }
 }
 async function writeAtomicAsync(path, contents) {
@@ -1552,18 +2161,10 @@ async function writeAtomicAsync(path, contents) {
     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.workspace = resolve(workspace);
     this.limits = {
       maxEntries: limits.maxEntries ?? REWIND_MAX_ENTRIES,
       maxFileBytes: limits.maxFileBytes ?? REWIND_MAX_FILE_BYTES,
@@ -1626,7 +2227,7 @@ var RewindSnapshotStore = class {
         }
         const blobHash = sha256(contents);
         const blobPath = join3(this.blobsRoot, blobHash);
-        if (!existsSync(blobPath)) writeAtomic(blobPath, contents);
+        if (!existsSync2(blobPath)) writeAtomic(blobPath, contents);
         const snapshotEntry = {
           path: entry.path.replaceAll("\\", "/"),
           kind: entry.kind,
@@ -1713,7 +2314,7 @@ var RewindSnapshotStore = class {
         }
         const blobHash = sha256(contents);
         const blobPath = join3(this.blobsRoot, blobHash);
-        if (!await pathExistsAsync(blobPath)) await writeAtomicAsync(blobPath, contents);
+        if (!await pathExists(blobPath)) await writeAtomicAsync(blobPath, contents);
         const snapshotEntry = {
           path: entry.path.replaceAll("\\", "/"),
           kind: entry.kind,
@@ -1754,14 +2355,14 @@ var RewindSnapshotStore = class {
   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;
+    if (!existsSync2(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;
+        if (!existsSync2(entriesPath)) return void 0;
         const serializedEntries = readFileSync(entriesPath, "utf-8");
         if (sha256(serializedEntries) !== stored.entrySetHash) return void 0;
         manifest = {
@@ -1832,12 +2433,12 @@ var RewindSnapshotStore = class {
   discardManifest(id) {
     if (!/^[a-zA-Z0-9-]+$/.test(id)) return;
     const path = join3(this.manifestsRoot, `${id}.json`);
-    if (existsSync(path)) unlinkSync(path);
+    if (existsSync2(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));
+    if (!existsSync2(entriesPath)) writeAtomic(entriesPath, JSON.stringify(manifest.entries));
     const metadata = { ...manifest };
     delete metadata.entries;
     writeAtomic(
@@ -1848,7 +2449,7 @@ var RewindSnapshotStore = class {
   async writeManifestAsync(manifest) {
     const entriesHash = sha256(JSON.stringify(manifest.entries));
     const entriesPath = join3(this.entrySetsRoot, `${entriesHash}.json`);
-    if (!await pathExistsAsync(entriesPath)) {
+    if (!await pathExists(entriesPath)) {
       await writeAtomicAsync(entriesPath, JSON.stringify(manifest.entries));
     }
     const metadata = { ...manifest };
@@ -1920,7 +2521,7 @@ var RewindSnapshotStore = class {
         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}.`);
+      if (!existsSync2(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}.`);
@@ -1943,7 +2544,7 @@ var RewindSnapshotStore = class {
     for (const entry of manifest.entries) {
       const target = resolveEntryPath(this.workspace, entry.path);
       mkdirSync(dirname(target), { recursive: true });
-      if (pathExists(target) && lstatSync(target).isDirectory()) {
+      if (pathExists2(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));
@@ -1957,25 +2558,25 @@ var RewindSnapshotStore = class {
         }
         renameSync(temporary, target);
       } finally {
-        if (pathExists(temporary)) unlinkSync(temporary);
+        if (pathExists2(temporary)) unlinkSync(temporary);
       }
     }
   }
 };
 
 // src/rewind/environment.ts
-import { existsSync as existsSync2, mkdtempSync, rmSync as rmSync2 } from "fs";
+import { existsSync as existsSync3, mkdtempSync, rmSync as rmSync2 } from "fs";
 import { tmpdir } from "os";
-import { join as join4, resolve as resolve3, sep as sep2 } from "path";
+import { join as join4, resolve as resolve2, sep as sep2 } from "path";
 function createEphemeralRewindEnvironment(workspace, temporaryRoot = tmpdir()) {
-  const resolvedTemporaryRoot = resolve3(temporaryRoot);
+  const resolvedTemporaryRoot = resolve2(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)) {
+    const resolvedRoot = resolve2(root);
+    if (resolvedRoot.startsWith(`${resolvedTemporaryRoot}${sep2}`) && resolvedRoot.split(sep2).at(-1)?.startsWith("book-rewind-") && existsSync3(resolvedRoot)) {
       rmSync2(resolvedRoot, { recursive: true, force: true });
     }
     process.off("exit", dispose);
@@ -1989,34 +2590,63 @@ function createEphemeralRewindEnvironment(workspace, temporaryRoot = tmpdir()) {
   };
 }
 
-// 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() {
+// src/cli/ink-frame-throttle.ts
+import { join as join5 } from "path";
+import { pathToFileURL } from "url";
+function createFrameThrottle(draw, intervalMs, now = () => performance.now()) {
+  let lastDrawAt = Number.NEGATIVE_INFINITY;
+  let timer = null;
+  const fire = () => {
+    timer = null;
+    lastDrawAt = now();
+    draw();
+  };
+  const throttled = (() => {
+    if (timer !== null) return;
+    const wait = lastDrawAt + intervalMs - now();
+    if (wait <= 0) fire();
+    else timer = setTimeout(fire, wait);
+  });
+  throttled.flush = () => {
+    if (timer === null) return;
+    clearTimeout(timer);
+    fire();
+  };
+  throttled.cancel = () => {
+    if (timer === null) return;
+    clearTimeout(timer);
+    timer = null;
+  };
+  return throttled;
+}
+function isThrottledInk(ink) {
+  if (typeof ink !== "object" || ink === null) return false;
+  const candidate = ink;
+  return typeof candidate.onRender === "function" && typeof candidate.renderThrottleMs === "number" && candidate.renderThrottleMs > 0 && typeof candidate.throttledOnRender?.flush === "function" && typeof candidate.throttledOnRender.cancel === "function" && typeof candidate.rootNode?.onRender === "function";
+}
+async function installInkFrameThrottle(stdout) {
   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);
+    const module = await import(pathToFileURL(join5(inkBuildDir(), "instances.js")).href);
+    const ink = module.default.get(stdout);
+    if (!isThrottledInk(ink)) return false;
+    ink.throttledOnRender.flush();
+    const throttle = createFrameThrottle(() => ink.onRender(), ink.renderThrottleMs);
+    ink.throttledOnRender = throttle;
+    ink.rootNode.onRender = () => {
+      ink.hasPendingThrottledRender = true;
+      throttle();
+    };
+    return true;
   } 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");
+function sessionRoot() {
+  return 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";
@@ -2060,7 +2690,8 @@ function writeTerminalControl(stdout, sequence) {
       {
         detached: true,
         stdio: "ignore",
-        windowsHide: true
+        windowsHide: true,
+        env: buildChildEnv()
       }
     );
     bridge.on("error", () => {
@@ -2072,6 +2703,12 @@ function writeTerminalControl(stdout, sequence) {
 function collectSnapshotReferences(store, cwd) {
   return store.listSnapshotReferences(cwd);
 }
+function printPipeErrorHandler(stream, printFormat, readerGone) {
+  return (error) => {
+    if (!isReaderGoneError(error)) throw error;
+    if (stream === "stdout" && printFormat === "stream-json") readerGone.abort();
+  };
+}
 function enterInteractiveScreen(stdout = process.stdout, bridgeWslTerminal = shouldBridgeWslTerminal()) {
   if (!stdout.isTTY && !bridgeWslTerminal) return () => {
   };
@@ -2093,9 +2730,17 @@ function enterInteractiveScreen(stdout = process.stdout, bridgeWslTerminal = sho
   return restore;
 }
 async function runMainAction(options) {
+  let printInterrupt;
+  let printSignal;
+  let launched;
+  const createdSessions = /* @__PURE__ */ new Set();
   try {
     const requestedWorkspace = options.workspace;
     const effortOverride = options.effort ? parseEffortLevel(String(options.effort), "--effort") : void 0;
+    const explicitDriver = options.sessionDriver === void 0 ? void 0 : parseSessionDriver(String(options.sessionDriver));
+    if (options.sessionDriver !== void 0 && !explicitDriver) {
+      throw new Error("--session-driver must be human or agent");
+    }
     const config = loadConfig(requestedWorkspace, {
       settingsOverridePath: options.settings,
       noSettings: options.settings === false,
@@ -2105,6 +2750,11 @@ async function runMainAction(options) {
       allowMissingApiKey: options.print === void 0 && !options.scrollback
     });
     if (config.modelProviderWarning) console.warn("\u26A0  " + config.modelProviderWarning);
+    const providerNotices = options.print === void 0 && config.workspaceProviderGate ? collectWithheldProviderNotices(config.workspaceProviderGate, config.workspace) : [];
+    const instructionNotices = collectSkippedProjectFileNotices(config.workspace);
+    if (options.scrollback) {
+      for (const notice of [...providerNotices, ...instructionNotices]) console.warn(notice);
+    }
     const interactiveMaxTurns = parseNumericFlag(options.maxTurns, "--max-turns", {
       integer: true
     });
@@ -2123,14 +2773,22 @@ async function runMainAction(options) {
         config.provider = raw;
       }
     }
+    const sessionDriver = resolveSessionDriver({ explicit: explicitDriver, env: process.env });
+    config.sessionDriver = sessionDriver.driver;
+    createDebugLogger("memory").info("session driver", { ...sessionDriver });
     freezeAgentConfig(config);
     cleanupDebugLogs(DEFAULT_LOCAL_DATA_RETENTION_DAYS, getDebugLogPath());
+    cleanupRunStatus(DEFAULT_LOCAL_DATA_RETENTION_DAYS);
     if (options.print !== void 0) {
-      for (const notice of collectWithheldProjectNotices({
-        workspace: config.workspace,
-        settings: config.settings,
-        settingsEnabled: options.settings !== false
-      })) {
+      for (const notice of [
+        ...collectWithheldProjectNotices({
+          workspace: config.workspace,
+          settings: config.settings,
+          settingsEnabled: options.settings !== false,
+          providerGate: config.workspaceProviderGate
+        }),
+        ...instructionNotices
+      ]) {
         console.warn(notice);
       }
       const declaredMcpServers = resolveMcpServerList(config.workspace);
@@ -2150,16 +2808,29 @@ async function runMainAction(options) {
           registry.registerAll(mcp.tools);
         }
         const mode2 = resolvePermissionMode(config.settings, options.permissionMode);
-        const sessionStore2 = options.sessionPersistence ? new SessionStore(SESSION_ROOT) : void 0;
+        const sessionStore2 = options.sessionPersistence ? new SessionStore(sessionRoot()) : void 0;
         const bootstrap2 = resolveSessionBootstrap(sessionStore2, {
           cwd: config.workspace,
           resume: options.resume,
           continue: options.continue,
           sessionId: options.sessionId,
           sessionName: options.name,
-          forkSession: options.forkSession
+          forkSession: options.forkSession,
+          driver: config.sessionDriver
         });
+        launched = { store: sessionStore2, bootstrap: bootstrap2 };
         sessionStore2?.cleanup(DEFAULT_LOCAL_DATA_RETENTION_DAYS, /* @__PURE__ */ new Set([bootstrap2.sessionId]));
+        const printFormat = options.outputFormat;
+        const readerGone = new AbortController();
+        printInterrupt = installPrintInterrupt();
+        const callerSignal = options.signal;
+        printSignal = AbortSignal.any(
+          [callerSignal, readerGone.signal, printInterrupt.signal].filter(
+            (signal) => signal !== void 0
+          )
+        );
+        process.stderr.on("error", printPipeErrorHandler("stderr", printFormat, readerGone));
+        process.stdout.on("error", printPipeErrorHandler("stdout", printFormat, readerGone));
         result = await runHeadless(config, registry, {
           prompt: typeof options.print === "string" ? options.print : void 0,
           inputFormat: options.inputFormat,
@@ -2168,13 +2839,15 @@ async function runMainAction(options) {
           transcript: bootstrap2.transcript,
           compactBoundaries: bootstrap2.compactBoundaries,
           plan: bootstrap2.plan,
+          goal: bootstrap2.goal,
           carriedUsage: bootstrap2.carriedUsage,
           carriedModels: bootstrap2.carriedModels,
           mode: mode2,
-          signal: options.signal,
+          signal: printSignal,
           maxTurns: parseNumericFlag(options.maxTurns, "--max-turns", { integer: true }),
           maxBudgetUsd: parseNumericFlag(options.maxBudgetUsd, "--max-budget-usd"),
           verbose: options.verbose,
+          quiet: options.quiet,
           jsonSchema: options.jsonSchema ? JSON.parse(options.jsonSchema) : void 0,
           sessionStore: sessionStore2,
           sessionId: bootstrap2.sessionId,
@@ -2184,23 +2857,28 @@ async function runMainAction(options) {
           persistSession: options.sessionPersistence,
           includeHookEvents: options.includeHookEvents,
           includePartialMessages: options.includePartialMessages,
+          includeResultMessages: options.includeResultMessages,
           promptSuggestions: options.promptSuggestions
         });
       } finally {
+        printInterrupt?.dispose();
         await disconnectMcpServers(mcp.connections);
       }
-      if (result?.outcome.status === "failed") {
-        exit(1);
-      }
+      const code = printExitCode({
+        outcome: result?.outcome,
+        aborted: printSignal?.aborted === true,
+        interruptedBy: printInterrupt?.interruptedBy()
+      });
+      if (code !== 0) setExitCode(code);
       return;
     }
     const mode = resolvePermissionMode(config.settings, options.permissionMode);
     if (options.scrollback) {
-      const { runScrollbackSession } = await import("./scrollback-LUKLIBVI.js");
+      const { runScrollbackSession } = await import("./scrollback-GD76GNM4.js");
       await runScrollbackSession(config, { mode });
       return;
     }
-    const sessionStore = options.sessionPersistence ? new SessionStore(SESSION_ROOT) : void 0;
+    const sessionStore = options.sessionPersistence ? new SessionStore(sessionRoot()) : void 0;
     const ephemeralRewind = sessionStore ? void 0 : createEphemeralRewindEnvironment(config.workspace);
     const timelineStore = sessionStore ?? ephemeralRewind.timelineStore;
     let snapshotStore = sessionStore ? createRewindSnapshotStore(config.workspace) : ephemeralRewind.snapshotStore;
@@ -2219,26 +2897,30 @@ async function runMainAction(options) {
       continue: options.continue,
       sessionId: options.sessionId,
       sessionName: options.name,
-      forkSession: options.forkSession
+      forkSession: options.forkSession,
+      driver: config.sessionDriver
     });
+    launched = { store: sessionStore, bootstrap };
     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
+        name: bootstrap.sessionName,
+        driver: config.sessionDriver
       });
     }
-    const [{ App }, { loadInteractiveAssets }] = await Promise.all([
-      import("./app-MOXXWEOY.js"),
-      import("./interactive-assets-CCAAWVKH.js")
+    const [{ App }, { loadInteractiveAssets }, { render }, { createElement }] = await Promise.all([
+      import("./app-J7BVPSUH.js"),
+      import("./interactive-assets-73AQO5WP.js"),
+      import("ink"),
+      import("react")
     ]);
     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 ? () => {
@@ -2247,27 +2929,42 @@ async function runMainAction(options) {
       const rendererMode = resolveTuiRendererMode(process.env.BOOK_TUI_RENDERER, {
         isTTY: process.stdout.isTTY === true,
         screenReader: config.accessibility.screenReader,
-        incrementalRendererPatched: isInkIncrementalRendererPatched(),
+        incrementalRendererFixed: hasInkTrailingNewlineFix(),
         platform: process.platform
       });
       await installInkScrollRenderer(rendererMode === "experimental-scroll");
       await installFrameCapture();
+      await installInkOutputCache();
+      await installInkRenderCull();
+      await installInkFrameClip();
+      const flushSync = await loadInkFlushSync();
       app = render(
         createElement(App, {
           config,
           permissionMode: mode,
           interactiveAssets,
           redrawViewport,
+          flushSync,
           mcp: mcpHost,
-          session: { ...bootstrap, store: sessionStore, timelineStore, snapshotStore }
+          session: {
+            ...bootstrap,
+            store: sessionStore,
+            timelineStore,
+            snapshotStore,
+            createdSessions
+          },
+          startupNotices: [...providerNotices, ...instructionNotices]
         }),
         {
           exitOnCtrlC: false,
           isScreenReaderEnabled: config.accessibility.screenReader,
           incrementalRendering: rendererMode !== "safe",
-          maxFps: 60
+          maxFps: resolveInkMaxFps(process.platform),
+          // Ink 7 also turns live frames off for a non-TTY stdout, which the WSL bridge uses.
+          interactive: !isCiEnvironment()
         }
       );
+      await installInkFrameThrottle(process.stdout);
       await app.waitUntilExit();
     } finally {
       app?.cleanup();
@@ -2278,12 +2975,23 @@ async function runMainAction(options) {
   } catch (e) {
     if (isExiting()) throw e;
     console.error(e instanceof Error ? e.message : String(e));
-    exit(1);
+    if (options.print !== void 0) {
+      printInterrupt?.dispose();
+      const code = printExitCode({
+        aborted: printSignal?.aborted === true,
+        interruptedBy: printInterrupt?.interruptedBy()
+      });
+      if (code !== 0) setExitCode(code);
+      return;
+    }
+    setExitCode(1);
+  } finally {
+    if (launched) discardUntouchedSessions(launched.store, launched.bootstrap, createdSessions);
   }
 }
 
 // src/cli/mcp.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync2 } 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");
@@ -2296,10 +3004,12 @@ function validScope(scope) {
   return normalized;
 }
 function readConfigDocument(path) {
-  if (!existsSync3(path)) return {};
+  const refusal = projectFileWriteRefusal(path);
+  if (refusal) throw new Error(`Cannot update ${path}: ${refusal}.`);
+  if (!existsSync4(path)) return {};
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync3(path, "utf8"));
+    parsed = JSON.parse(readFileSync2(path, "utf8"));
   } catch (error) {
     throw new Error(
       `Cannot update ${path}: ${error instanceof Error ? error.message : String(error)}`
@@ -2480,13 +3190,19 @@ function parseEffortOption(value) {
 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(
+program.name("book").description("AI coding agent with rich TUI").enablePositionalOptions().version(getPackageVersion()).argument("[prompt]", "Prompt for print mode; the same as the -p value, in either position").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."
+  "Print mode (non-interactive). Reads the prompt from the flag, the [prompt] argument, 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(
+).option("--verbose", "Print mode: add each tool result to the progress lines on stderr").option("-q, --quiet", "Print mode: no progress lines on stderr").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 that has a message").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(
+  "--session-driver <driver>",
+  "human or agent (default: agent under another agent harness); an agent-driven session saves only what it learned, never its instructions"
+).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(
+  "--include-result-messages",
+  "Include the full message history in the stream-json result event"
+).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
@@ -2496,7 +3212,10 @@ program.command("doctor").description("Diagnose configuration and environment").
     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) => {
+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 session in this workspace with a message or a run record)"
+).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),
@@ -2552,7 +3271,29 @@ trustCommand.command("rule").description("Approve or reject a project-declared p
     });
   }
 );
-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", `
+trustCommand.command("dir").description("Approve or reject a project-declared additionalDirectories entry").argument("[path]", "The declared entry, or the real path `book doctor` reported for it").option("-w, --workspace <path>", "Workspace root directory (defaults to the root -w, then cwd)").option("--all-pending", "Apply to every directory currently awaiting a decision").option("--reject", "Record a refusal instead of an approval").action(
+  async (path, options) => {
+    await runTrustCommand("dir", path, {
+      ...options,
+      workspace: resolveWorkspace(options.workspace)
+    });
+  }
+);
+trustCommand.command("provider").description("Approve or reject a provider (origin and key) a repository declared").argument(
+  "[id]",
+  "Provider id, or .bookrc.json for a legacy baseUrl; omit to list what is pending"
+).option("-w, --workspace <path>", "Workspace root directory (defaults to the root -w, then cwd)").option("--all-pending", "Apply to every provider currently awaiting a decision").option("--reject", "Record a refusal instead of an approval").action(
+  async (id, options) => {
+    await runTrustCommand("provider", id, {
+      ...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)").option("--no-check", "provider-key: save without testing the key against the endpoint").option("--force", "provider-key: save even when the endpoint rejects the key").argument(
+  "[action]",
+  "get <key>, set <key> <value>, unset <key>, list, or provider-key <id> (key read from stdin)"
+).argument("[key]", "Dot-separated key path (e.g. permissions.deny), or the provider id").argument("[value]", "Value to set (JSON-parsed)").addHelpText("after", `
 ${formatSettingsKeyHelp()}`).action(
   async (action, key, value, options) => {
     const rootSettings = program.opts().settings;
@@ -2571,12 +3312,15 @@ ${formatSettingsKeyHelp()}`).action(
     await runConfigCommand(resolveWorkspace(options.workspace), action, key, value, {
       settingsOverridePath: typeof settings === "string" ? settings : void 0,
       noSettings: settings === false,
-      scope: selected[0]?.[0]
+      scope: selected[0]?.[0],
+      providerKey: { check: options.check, force: options.force }
     });
   }
 );
-program.action(async (options) => {
-  await runMainAction(options);
+program.action(async (prompt, options) => {
+  const resolved = resolvePrintPrompt(options.print, prompt);
+  if ("error" in resolved) program.error(`error: ${resolved.error}`);
+  await runMainAction({ ...options, print: resolved.print });
 });
 program.parse();
 //# sourceMappingURL=index.js.map