@band-app/server 0.32.0 → 0.33.0

package/dist/terminal-daemon.mjs

@@ -1283,7 +1283,7 @@ var require_sonic_boom = __commonJS({
       if (!(this instanceof SonicBoom)) {
         return new SonicBoom(opts);
       }
-      let { fd, dest, minLength, maxLength, maxWrite, periodicFlush, sync, append = true, mkdir, retryEAGAIN, fsync, contentMode, mode } = opts || {};
+      let { fd, dest, minLength, maxLength, maxWrite, periodicFlush, sync, append = true, mkdir: mkdir2, retryEAGAIN, fsync, contentMode, mode } = opts || {};
       fd = fd || dest;
       this._len = 0;
       this.fd = -1;
@@ -1308,7 +1308,7 @@ var require_sonic_boom = __commonJS({
       this.append = append || false;
       this.mode = mode;
       this.retryEAGAIN = retryEAGAIN || (() => true);
-      this.mkdir = mkdir || false;
+      this.mkdir = mkdir2 || false;
       let fsWriteSync;
       let fsWrite;
       if (contentMode === kContentModeBuffer) {
@@ -2024,7 +2024,7 @@ var require_thread_stream = __commonJS({
     var { version } = require_package();
     var { EventEmitter } = __require("events");
     var { Worker } = __require("worker_threads");
-    var { join: join4 } = __require("path");
+    var { join: join7 } = __require("path");
     var { pathToFileURL } = __require("url");
     var { wait } = require_wait();
     var {
@@ -2060,7 +2060,7 @@ var require_thread_stream = __commonJS({
     function createWorker(stream, opts) {
       const { filename, workerData } = opts;
       const bundlerOverrides = "__bundlerPathsOverrides" in globalThis ? globalThis.__bundlerPathsOverrides : {};
-      const toExecute = bundlerOverrides["thread-stream-worker"] || join4(__dirname, "lib", "worker.js");
+      const toExecute = bundlerOverrides["thread-stream-worker"] || join7(__dirname, "lib", "worker.js");
       const worker = new Worker(toExecute, {
         ...opts.workerOpts,
         trackUnmanagedFds: false,
@@ -2446,7 +2446,7 @@ var require_transport = __commonJS({
     "use strict";
     var { createRequire } = __require("module");
     var getCallers = require_caller();
-    var { join: join4, isAbsolute, sep: sep2 } = __require("node:path");
+    var { join: join7, isAbsolute, sep: sep2 } = __require("node:path");
     var sleep = require_atomic_sleep();
     var onExit = require_on_exit_leak_free();
     var ThreadStream = require_thread_stream();
@@ -2509,7 +2509,7 @@ var require_transport = __commonJS({
         throw new Error("only one of target or targets can be specified");
       }
       if (targets) {
-        target = bundlerOverrides["pino-worker"] || join4(__dirname, "worker.js");
+        target = bundlerOverrides["pino-worker"] || join7(__dirname, "worker.js");
         options.targets = targets.filter((dest) => dest.target).map((dest) => {
           return {
             ...dest,
@@ -2527,7 +2527,7 @@ var require_transport = __commonJS({
           });
         });
       } else if (pipeline) {
-        target = bundlerOverrides["pino-worker"] || join4(__dirname, "worker.js");
+        target = bundlerOverrides["pino-worker"] || join7(__dirname, "worker.js");
         options.pipelines = [pipeline.map((dest) => {
           return {
             ...dest,
@@ -2549,7 +2549,7 @@ var require_transport = __commonJS({
           return origin;
         }
         if (origin === "pino/file") {
-          return join4(__dirname, "..", "file.js");
+          return join7(__dirname, "..", "file.js");
         }
         let fixTarget2;
         for (const filePath of callers) {
@@ -2877,11 +2877,11 @@ var require_tools = __commonJS({
         }
       }
     }
-    function buildFormatters(level, bindings, log4) {
+    function buildFormatters(level, bindings, log5) {
       return {
         level,
         bindings,
-        log: log4
+        log: log5
       };
     }
     function normalizeDestFileDescriptor(destination) {
@@ -3264,11 +3264,11 @@ var require_proto = __commonJS({
         }
       } else instance[serializersSym] = serializers;
       if (options.hasOwnProperty("formatters")) {
-        const { level, bindings: chindings, log: log4 } = options.formatters;
+        const { level, bindings: chindings, log: log5 } = options.formatters;
         instance[formattersSym] = buildFormatters(
           level || formatters.level,
           chindings || resetChildingsFormatter,
-          log4 || formatters.log
+          log5 || formatters.log
         );
       } else {
         instance[formattersSym] = buildFormatters(
@@ -3538,7 +3538,7 @@ var require_safe_stable_stringify = __commonJS({
               return circularValue;
             }
             let res = "";
-            let join4 = ",";
+            let join7 = ",";
             const originalIndentation = indentation;
             if (Array.isArray(value)) {
               if (value.length === 0) {
@@ -3552,7 +3552,7 @@ var require_safe_stable_stringify = __commonJS({
                 indentation += spacer;
                 res += `
 ${indentation}`;
-                join4 = `,
+                join7 = `,
 ${indentation}`;
               }
               const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
@@ -3560,13 +3560,13 @@ ${indentation}`;
               for (; i < maximumValuesToStringify - 1; i++) {
                 const tmp2 = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
                 res += tmp2 !== void 0 ? tmp2 : "null";
-                res += join4;
+                res += join7;
               }
               const tmp = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
               res += tmp !== void 0 ? tmp : "null";
               if (value.length - 1 > maximumBreadth) {
                 const removedKeys = value.length - maximumBreadth - 1;
-                res += `${join4}"... ${getItemCount(removedKeys)} not stringified"`;
+                res += `${join7}"... ${getItemCount(removedKeys)} not stringified"`;
               }
               if (spacer !== "") {
                 res += `
@@ -3587,7 +3587,7 @@ ${originalIndentation}`;
             let separator = "";
             if (spacer !== "") {
               indentation += spacer;
-              join4 = `,
+              join7 = `,
 ${indentation}`;
               whitespace = " ";
             }
@@ -3601,13 +3601,13 @@ ${indentation}`;
               const tmp = stringifyFnReplacer(key2, value, stack, replacer, spacer, indentation);
               if (tmp !== void 0) {
                 res += `${separator}${strEscape(key2)}:${whitespace}${tmp}`;
-                separator = join4;
+                separator = join7;
               }
             }
             if (keyLength > maximumBreadth) {
               const removedKeys = keyLength - maximumBreadth;
               res += `${separator}"...":${whitespace}"${getItemCount(removedKeys)} not stringified"`;
-              separator = join4;
+              separator = join7;
             }
             if (spacer !== "" && separator.length > 1) {
               res = `
@@ -3648,7 +3648,7 @@ ${originalIndentation}`;
             }
             const originalIndentation = indentation;
             let res = "";
-            let join4 = ",";
+            let join7 = ",";
             if (Array.isArray(value)) {
               if (value.length === 0) {
                 return "[]";
@@ -3661,7 +3661,7 @@ ${originalIndentation}`;
                 indentation += spacer;
                 res += `
 ${indentation}`;
-                join4 = `,
+                join7 = `,
 ${indentation}`;
               }
               const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
@@ -3669,13 +3669,13 @@ ${indentation}`;
               for (; i < maximumValuesToStringify - 1; i++) {
                 const tmp2 = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
                 res += tmp2 !== void 0 ? tmp2 : "null";
-                res += join4;
+                res += join7;
               }
               const tmp = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
               res += tmp !== void 0 ? tmp : "null";
               if (value.length - 1 > maximumBreadth) {
                 const removedKeys = value.length - maximumBreadth - 1;
-                res += `${join4}"... ${getItemCount(removedKeys)} not stringified"`;
+                res += `${join7}"... ${getItemCount(removedKeys)} not stringified"`;
               }
               if (spacer !== "") {
                 res += `
@@ -3688,7 +3688,7 @@ ${originalIndentation}`;
             let whitespace = "";
             if (spacer !== "") {
               indentation += spacer;
-              join4 = `,
+              join7 = `,
 ${indentation}`;
               whitespace = " ";
             }
@@ -3697,7 +3697,7 @@ ${indentation}`;
               const tmp = stringifyArrayReplacer(key2, value[key2], stack, replacer, spacer, indentation);
               if (tmp !== void 0) {
                 res += `${separator}${strEscape(key2)}:${whitespace}${tmp}`;
-                separator = join4;
+                separator = join7;
               }
             }
             if (spacer !== "" && separator.length > 1) {
@@ -3755,20 +3755,20 @@ ${originalIndentation}`;
               indentation += spacer;
               let res2 = `
 ${indentation}`;
-              const join5 = `,
+              const join8 = `,
 ${indentation}`;
               const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
               let i = 0;
               for (; i < maximumValuesToStringify - 1; i++) {
                 const tmp2 = stringifyIndent(String(i), value[i], stack, spacer, indentation);
                 res2 += tmp2 !== void 0 ? tmp2 : "null";
-                res2 += join5;
+                res2 += join8;
               }
               const tmp = stringifyIndent(String(i), value[i], stack, spacer, indentation);
               res2 += tmp !== void 0 ? tmp : "null";
               if (value.length - 1 > maximumBreadth) {
                 const removedKeys = value.length - maximumBreadth - 1;
-                res2 += `${join5}"... ${getItemCount(removedKeys)} not stringified"`;
+                res2 += `${join8}"... ${getItemCount(removedKeys)} not stringified"`;
               }
               res2 += `
 ${originalIndentation}`;
@@ -3784,16 +3784,16 @@ ${originalIndentation}`;
               return '"[Object]"';
             }
             indentation += spacer;
-            const join4 = `,
+            const join7 = `,
 ${indentation}`;
             let res = "";
             let separator = "";
             let maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
             if (isTypedArrayWithEntries(value)) {
-              res += stringifyTypedArray(value, join4, maximumBreadth);
+              res += stringifyTypedArray(value, join7, maximumBreadth);
               keys = keys.slice(value.length);
               maximumPropertiesToStringify -= value.length;
-              separator = join4;
+              separator = join7;
             }
             if (deterministic) {
               keys = sort(keys, comparator);
@@ -3804,13 +3804,13 @@ ${indentation}`;
               const tmp = stringifyIndent(key2, value[key2], stack, spacer, indentation);
               if (tmp !== void 0) {
                 res += `${separator}${strEscape(key2)}: ${tmp}`;
-                separator = join4;
+                separator = join7;
               }
             }
             if (keyLength > maximumBreadth) {
               const removedKeys = keyLength - maximumBreadth;
               res += `${separator}"...": "${getItemCount(removedKeys)} not stringified"`;
-              separator = join4;
+              separator = join7;
             }
             if (separator !== "") {
               res = `
@@ -8855,15 +8855,22 @@ function createLogger(name) {
 
 // src/server/infra/terminals/daemon/daemon-server.ts
 import { randomBytes as randomBytes2, timingSafeEqual } from "node:crypto";
-import { chmodSync as chmodSync2, lstatSync as lstatSync2, readFileSync, renameSync as renameSync2, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { chmodSync as chmodSync2, lstatSync as lstatSync2, readFileSync as readFileSync2, renameSync as renameSync2, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2 } from "node:fs";
 import { createServer } from "node:net";
-import { dirname as dirname3 } from "node:path";
+import { dirname as dirname3, join as join6 } from "node:path";
+
+// src/server/infra/terminals/node-pty-loader.ts
+var cachedImport;
+function preloadNodePty() {
+  cachedImport ??= import("node-pty");
+  return cachedImport;
+}
 
 // src/server/infra/terminals/terminal-pool.ts
 import { randomUUID } from "node:crypto";
 import { existsSync as existsSync2, unlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join, sep } from "node:path";
+import { join as join3, sep } from "node:path";
 
 // src/server/infra/process/path.ts
 import { execFile } from "node:child_process";
@@ -8925,12 +8932,163 @@ async function shellPath() {
   return fallback;
 }
 
+// src/server/infra/terminals/claude-resume.ts
+import { readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var CLAUDE_COMMAND_PATTERN = /^claude(\s|$)/;
+var CLAUDE_RESUME_FLAG_PATTERN = /(^|\s)(--resume|-r)(\s|$)/;
+var SESSION_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isResumableClaudeCommand(command) {
+  if (!command) return false;
+  const trimmed = command.trim();
+  return CLAUDE_COMMAND_PATTERN.test(trimmed) && !CLAUDE_RESUME_FLAG_PATTERN.test(trimmed);
+}
+function claudeProjectDir(cwd) {
+  return join(homedir(), ".claude", "projects", cwd.replaceAll("/", "-"));
+}
+function findLatestClaudeSessionId(cwd) {
+  const dir = claudeProjectDir(cwd);
+  let names;
+  try {
+    names = readdirSync(dir).filter((name) => name.endsWith(".jsonl"));
+  } catch {
+    return null;
+  }
+  let newest = null;
+  for (const name of names) {
+    let mtimeMs;
+    try {
+      mtimeMs = statSync(join(dir, name)).mtimeMs;
+    } catch {
+      continue;
+    }
+    if (!newest || mtimeMs > newest.mtimeMs) {
+      newest = { id: name.slice(0, -".jsonl".length), mtimeMs };
+    }
+  }
+  if (!newest || !SESSION_ID_PATTERN.test(newest.id)) return null;
+  return newest.id;
+}
+function buildClaudeResumeCommand(originalCommand, sessionId) {
+  return `${originalCommand.trim()} --resume ${sessionId}`;
+}
+
+// src/server/infra/terminals/pty-error-hints.ts
+var MODULE_LOAD_PATTERN = /Cannot find module|MODULE_NOT_FOUND|pty\.node/i;
+var RESOURCE_EXHAUSTION_PATTERN = /\b(EMFILE|ENFILE|ENOMEM|EAGAIN)\b/;
+function hintForPtySpawnError(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  if (MODULE_LOAD_PATTERN.test(message)) {
+    return "The terminal service could not load its native module. Restart the terminal service from Settings.";
+  }
+  if (RESOURCE_EXHAUSTION_PATTERN.test(message)) {
+    return "Your system cannot start another terminal process. Close unused terminals and try again.";
+  }
+  return "Failed to start the terminal shell.";
+}
+
+// src/server/infra/terminals/terminal-history.ts
+import { readdirSync as readdirSync2, readFileSync, rmSync } from "node:fs";
+import { mkdir, rename, writeFile } from "node:fs/promises";
+import { join as join2 } from "node:path";
+var log = createLogger("terminal-history");
+var CHECKPOINT_MAX_BYTES = 5 * 1024 * 1024;
+var TerminalHistoryManager = class {
+  constructor(historyDir) {
+    this.historyDir = historyDir;
+  }
+  sessionDir(terminalId) {
+    return join2(this.historyDir, encodeURIComponent(terminalId));
+  }
+  readMeta(terminalId) {
+    return readJson(join2(this.sessionDir(terminalId), "meta.json"));
+  }
+  readCheckpoint(terminalId) {
+    return readJson(
+      join2(this.sessionDir(terminalId), "checkpoint.json")
+    );
+  }
+  /**
+   * Async: called from the PTY output hot path (`TerminalPool.onData`), so
+   * this must never block the daemon's single event loop the way the
+   * synchronous `fs` calls it replaced (`writeFileSync`/`renameSync`) would —
+   * a slow or networked filesystem could otherwise delay every other
+   * terminal's output delivery, the exact regression issue #676 fixed for a
+   * different code path.
+   */
+  async writeMeta(terminalId, meta) {
+    await writeJson(this.sessionDir(terminalId), "meta.json", meta);
+  }
+  async writeCheckpoint(terminalId, checkpoint) {
+    const serialized = JSON.stringify(checkpoint);
+    const bytes = Buffer.byteLength(serialized);
+    if (bytes > CHECKPOINT_MAX_BYTES) {
+      log.warn({ terminalId, bytes }, "terminal history checkpoint too large; skipping this write");
+      return;
+    }
+    await writeJson(this.sessionDir(terminalId), "checkpoint.json", checkpoint, serialized);
+  }
+  /** Drop a terminal's saved history: its tab or workspace was actually closed or deleted. */
+  removeSession(terminalId) {
+    try {
+      rmSync(this.sessionDir(terminalId), { recursive: true, force: true });
+    } catch (err) {
+      log.warn({ err, terminalId }, "failed to remove terminal history directory");
+    }
+  }
+  /**
+   * Drop every saved session whose last known `workspaceId` is `workspaceId`
+   * — used when a workspace is deleted. Scans the whole history directory
+   * rather than the pool's live reverse index, which by then may already be
+   * missing terminals that exited (and were never explicitly killed) before
+   * the workspace was removed.
+   */
+  removeSessionsForWorkspace(workspaceId) {
+    let names;
+    try {
+      names = readdirSync2(this.historyDir);
+    } catch {
+      return;
+    }
+    for (const name of names) {
+      const dir = join2(this.historyDir, name);
+      const meta = readJson(join2(dir, "meta.json"));
+      if (meta?.workspaceId !== workspaceId) continue;
+      try {
+        rmSync(dir, { recursive: true, force: true });
+      } catch (err) {
+        log.warn({ err, dir }, "failed to remove terminal history directory");
+      }
+    }
+  }
+};
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function writeJson(dir, name, value, serialized) {
+  try {
+    await mkdir(dir, { recursive: true, mode: 448 });
+    const path = join2(dir, name);
+    const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
+    await writeFile(tmp, serialized ?? JSON.stringify(value), { mode: 384 });
+    await rename(tmp, path);
+  } catch (err) {
+    log.warn({ err, dir, name }, "failed to write terminal history file");
+  }
+}
+
 // src/server/infra/terminals/terminal-pool.ts
-var log = createLogger("terminal-pool");
+var log2 = createLogger("terminal-pool");
 var MAX_SCROLLBACK_SIZE = 1e5;
 var HEADLESS_SCROLLBACK_LINES = 1e4;
 var MAX_COLS = 1e3;
 var MAX_ROWS = 1e3;
+var HISTORY_CHECKPOINT_INTERVAL_MS = 1e4;
 var OutputTail = class {
   constructor(max) {
     this.max = max;
@@ -8964,6 +9122,22 @@ var OutputTail = class {
   }
 };
 var TerminalPool = class {
+  historyStore;
+  /**
+   * terminalIds whose next `onExit` should prune (not checkpoint) their
+   * history: set by an explicit `kill` / `killWorkspace`, i.e. the tab or
+   * workspace is actually being closed or deleted. `killAll` (daemon
+   * shutdown/restart) deliberately never adds to this set, so those sessions
+   * stay cold-restorable.
+   */
+  pruneHistoryOnExit = /* @__PURE__ */ new Set();
+  /**
+   * In-flight history checkpoint writes (see {@link checkpointHistoryNow}).
+   * `hasPendingHistoryWrites` lets the daemon's shutdown wait for these
+   * before exiting, since they are async and no longer complete before
+   * `onExit` returns.
+   */
+  pendingHistoryWrites = /* @__PURE__ */ new Set();
   /** terminalId -> session */
   terminals = /* @__PURE__ */ new Map();
   /** workspaceId -> Set<terminalId> (reverse index for workspace-level cleanup) */
@@ -8988,6 +9162,9 @@ var TerminalPool = class {
   /** terminalIds with a shrink-and-restore nudge in flight (see
    *  {@link nudgeResize} for why concurrent nudges must not compound). */
   nudging = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.historyStore = options?.historyDir ? new TerminalHistoryManager(options.historyDir) : null;
+  }
   /**
    * Spawn (or return the already-spawning/spawned) PTY for a terminalId.
    *
@@ -9014,6 +9191,8 @@ var TerminalPool = class {
   async spawnNew(workspaceId, terminalId, workspaceRoot, options, extras) {
     const shell = defaultShell();
     const resolvedPath = await shellPath();
+    const historyMeta = this.historyStore?.readMeta(terminalId) ?? null;
+    const checkpoint = historyMeta?.workspaceId === workspaceId ? this.historyStore?.readCheckpoint(terminalId) ?? null : null;
     const env = {};
     for (const [key, value] of Object.entries(extras?.baseEnv ?? process.env)) {
       if (value != null) {
@@ -9034,18 +9213,14 @@ var TerminalPool = class {
     env.BAND_DISPATCH = "terminal";
     let cwd = workspaceRoot;
     if (options?.cwd) {
-      const resolved = join(workspaceRoot, options.cwd);
-      if (resolved !== workspaceRoot && !resolved.startsWith(workspaceRoot + sep)) {
-        log.warn(
-          "Ignoring cwd %s \u2014 resolves outside workspace root %s",
-          options.cwd,
-          workspaceRoot
-        );
-      } else if (existsSync2(resolved)) {
-        cwd = resolved;
-      } else {
-        log.warn("Ignoring cwd %s \u2014 directory does not exist", options.cwd);
-      }
+      cwd = resolveSafeCwd(join3(workspaceRoot, options.cwd), workspaceRoot, "cwd", options.cwd) ?? cwd;
+    } else if (checkpoint?.cwd) {
+      cwd = resolveSafeCwd(
+        checkpoint.cwd,
+        workspaceRoot,
+        "saved terminal history cwd",
+        checkpoint.cwd
+      ) ?? cwd;
     }
     if (!existsSync2(cwd)) {
       throw new Error(`Workspace directory does not exist: ${cwd}`);
@@ -9053,16 +9228,16 @@ var TerminalPool = class {
     if (!existsSync2(shell)) {
       throw new Error(`Shell not found: ${shell}`);
     }
-    log.debug(
+    log2.debug(
       "Spawning shell %s in %s for terminal %s (PATH=%s)",
       shell,
       cwd,
       terminalId,
       resolvedPath.slice(0, 200)
     );
-    const nodePty = await import("node-pty");
     let ptyProcess;
     try {
+      const nodePty = await preloadNodePty();
       ptyProcess = nodePty.spawn(shell, [], {
         name: "xterm-256color",
         cols: 80,
@@ -9072,8 +9247,8 @@ var TerminalPool = class {
       });
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      log.error("pty.spawn failed: %s (shell=%s, cwd=%s)", msg, shell, cwd);
-      throw err;
+      log2.error("pty.spawn failed: %s (shell=%s, cwd=%s)", msg, shell, cwd);
+      throw new Error(hintForPtySpawnError(err));
     }
     let headless;
     let serializeAddon;
@@ -9099,7 +9274,7 @@ var TerminalPool = class {
     } catch (err) {
       ptyProcess.kill();
       const msg = err instanceof Error ? err.message : String(err);
-      log.error("headless mirror setup failed for terminal %s: %s", terminalId, msg);
+      log2.error("headless mirror setup failed for terminal %s: %s", terminalId, msg);
       throw err;
     }
     const session = {
@@ -9110,11 +9285,25 @@ var TerminalPool = class {
       workspaceId,
       seq: 0,
       holds: 0,
-      cleanupOnExit: extras?.cleanupOnExit ?? false
+      cleanupOnExit: extras?.cleanupOnExit ?? false,
+      history: this.historyStore ? {
+        cwd,
+        startedAt: historyMeta?.startedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+        sessionCommand: options?.command ?? historyMeta?.sessionCommand,
+        lastCheckpointAt: 0
+      } : void 0
     };
     this.terminals.set(terminalId, session);
-    if (options?.command) {
-      this.autoRunCommand(session, options.command);
+    if (checkpoint) {
+      const restored = `${checkpoint.scrollback}\r
+\x1B[90m--- session restored ---\x1B[0m\r
+`;
+      session.scrollback.append(restored);
+      session.headless.write(restored);
+    }
+    const commandToRun = options?.command ?? this.claudeResumeCommand(checkpoint, historyMeta, cwd);
+    if (commandToRun) {
+      this.autoRunCommand(session, commandToRun);
     }
     let ids = this.workspaceTerminals.get(workspaceId);
     if (!ids) {
@@ -9136,9 +9325,10 @@ var TerminalPool = class {
           }
         }
       }
+      this.maybeCheckpointHistory(terminalId, session);
     });
     ptyProcess.onExit(({ exitCode: exitCode2 }) => {
-      log.debug("Terminal exited: %s (workspace %s)", terminalId, workspaceId);
+      log2.debug("Terminal exited: %s (workspace %s)", terminalId, workspaceId);
       const explicitlyKilled = !this.terminals.has(terminalId);
       this.terminals.delete(terminalId);
       this.outputListeners.delete(terminalId);
@@ -9155,6 +9345,13 @@ var TerminalPool = class {
         } catch {
         }
       }
+      if (this.historyStore) {
+        if (this.pruneHistoryOnExit.delete(terminalId)) {
+          this.historyStore.removeSession(terminalId);
+        } else if (session.history) {
+          this.checkpointHistoryNow(terminalId, session);
+        }
+      }
       session.headless.dispose();
       const event = {
         terminalId,
@@ -9167,12 +9364,86 @@ var TerminalPool = class {
         try {
           listener(event);
         } catch (err) {
-          log.warn("exit listener threw for terminal %s: %s", terminalId, err);
+          log2.warn("exit listener threw for terminal %s: %s", terminalId, err);
         }
       }
     });
     return session;
   }
+  /**
+   * A resumable Claude Code command for a cold-restored terminal, or
+   * `undefined` if this isn't one: the checkpoint's saved command must look
+   * like a plain `claude` invocation (see `claude-resume.ts`) and there must
+   * be a Claude Code session transcript for `cwd`. Scoped to Claude Code
+   * only — its on-disk session layout is documented and stable; other
+   * agents' formats weren't verified for this feature.
+   *
+   * Takes the already boundary-checked `cwd` the new shell is actually
+   * spawning in, not the checkpoint's raw saved cwd: if that saved cwd fell
+   * outside the workspace root and `cwd` fell back to `workspaceRoot`, the
+   * resume lookup must follow, not probe a directory the spawn itself
+   * decided not to trust.
+   */
+  claudeResumeCommand(checkpoint, meta, cwd) {
+    const command = meta?.sessionCommand;
+    if (!checkpoint || !command || !isResumableClaudeCommand(command)) return void 0;
+    const sessionId = findLatestClaudeSessionId(cwd);
+    return sessionId ? buildClaudeResumeCommand(command, sessionId) : void 0;
+  }
+  /**
+   * Checkpoint at most every `HISTORY_CHECKPOINT_INTERVAL_MS`, driven by
+   * output arriving. Deferred off the PTY-output hot path via `setImmediate`:
+   * `serialize()` is synchronous CPU work proportional to the scrollback
+   * size, and running it inline in `onData` would delay delivering this (and
+   * every other terminal's already-pending) output on the daemon's single
+   * event loop — the class of regression issue #676 fixed for a different
+   * code path.
+   */
+  maybeCheckpointHistory(terminalId, session) {
+    if (!this.historyStore || !session.history) return;
+    const now = Date.now();
+    if (now - session.history.lastCheckpointAt < HISTORY_CHECKPOINT_INTERVAL_MS) return;
+    session.history.lastCheckpointAt = now;
+    setImmediate(() => {
+      if (this.terminals.get(terminalId) === session) {
+        this.checkpointHistoryNow(terminalId, session);
+      }
+    });
+  }
+  /**
+   * Serializes the current screen synchronously — the only part of a
+   * checkpoint that must be, since it must run before `headless.dispose()` on
+   * exit — then hands the actual write off to `TerminalHistoryManager`'s async,
+   * non-blocking I/O. The write is tracked in {@link pendingHistoryWrites} so
+   * a daemon shutdown can wait for it rather than exiting mid-write and
+   * losing a session's last checkpoint; `TerminalHistoryManager` logs its own
+   * failures and never rejects, so there is nothing for this method's caller
+   * to await or catch.
+   */
+  checkpointHistoryNow(terminalId, session) {
+    if (!this.historyStore || !session.history) return;
+    const { cols, rows } = session.headless;
+    const { cwd, startedAt, sessionCommand } = session.history;
+    const pending = Promise.all([
+      this.historyStore.writeCheckpoint(terminalId, {
+        scrollback: session.serializeAddon.serialize(),
+        cwd,
+        cols,
+        rows
+      }),
+      this.historyStore.writeMeta(terminalId, {
+        workspaceId: session.workspaceId,
+        cwd,
+        cols,
+        rows,
+        startedAt,
+        checkpointedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        sessionCommand
+      })
+    ]);
+    this.pendingHistoryWrites.add(pending);
+    void pending.finally(() => this.pendingHistoryWrites.delete(pending));
+  }
   /**
    * Auto-run the workspace's initial command inside a freshly spawned PTY,
    * robustly.
@@ -9204,12 +9475,12 @@ var TerminalPool = class {
     const pty = session.pty;
     let cmdFile;
     try {
-      cmdFile = join(tmpdir(), `band-autorun-${randomUUID()}.sh`);
+      cmdFile = join3(tmpdir(), `band-autorun-${randomUUID()}.sh`);
       writeFileSync(cmdFile, `${command}
 `, { encoding: "utf-8", mode: 384, flag: "wx" });
       session.autoRunFile = cmdFile;
     } catch (err) {
-      log.warn(
+      log2.warn(
         "autoRunCommand: temp-file staging failed (%s); writing command directly",
         err instanceof Error ? err.message : String(err)
       );
@@ -9227,7 +9498,7 @@ var TerminalPool = class {
       try {
         pty.write(sourceLine);
       } catch (err) {
-        log.warn("autoRunCommand: failed to inject command line (%s)", err);
+        log2.warn("autoRunCommand: failed to inject command line (%s)", err);
       }
     };
     let dataDisposed = false;
@@ -9480,7 +9751,7 @@ var TerminalPool = class {
     try {
       snapshot = await this.serialize(terminalId);
     } catch (err) {
-      log.error("Failed to serialize terminal %s for replay: %s", terminalId, err);
+      log2.error("Failed to serialize terminal %s for replay: %s", terminalId, err);
       snapshot = { data: "", seq: 0 };
     }
     if (!snapshot) {
@@ -9523,6 +9794,7 @@ var TerminalPool = class {
   kill(terminalId) {
     const session = this.terminals.get(terminalId);
     if (session) {
+      this.pruneHistoryOnExit.add(terminalId);
       session.pty.kill();
       this.terminals.delete(terminalId);
       const set = this.workspaceTerminals.get(session.workspaceId);
@@ -9532,6 +9804,8 @@ var TerminalPool = class {
           this.workspaceTerminals.delete(session.workspaceId);
         }
       }
+    } else {
+      this.historyStore?.removeSession(terminalId);
     }
   }
   /**
@@ -9539,15 +9813,18 @@ var TerminalPool = class {
    */
   killWorkspace(workspaceId) {
     const ids = this.workspaceTerminals.get(workspaceId);
-    if (!ids) return;
-    for (const terminalId of ids) {
-      const session = this.terminals.get(terminalId);
-      if (session) {
-        session.pty.kill();
-        this.terminals.delete(terminalId);
+    if (ids) {
+      for (const terminalId of ids) {
+        const session = this.terminals.get(terminalId);
+        if (session) {
+          this.pruneHistoryOnExit.add(terminalId);
+          session.pty.kill();
+          this.terminals.delete(terminalId);
+        }
       }
+      this.workspaceTerminals.delete(workspaceId);
     }
-    this.workspaceTerminals.delete(workspaceId);
+    this.historyStore?.removeSessionsForWorkspace(workspaceId);
   }
   /**
    * Kill every tracked PTY (server shutdown path).
@@ -9560,7 +9837,27 @@ var TerminalPool = class {
     this.workspaceTerminals.clear();
     this.outputListeners.clear();
   }
+  /**
+   * True while a history checkpoint write is still in flight. The daemon's
+   * shutdown polls this alongside its shells' liveness so it never exits
+   * mid-write and loses the last checkpoint a dying session's `onExit`
+   * kicked off (see {@link checkpointHistoryNow}).
+   */
+  hasPendingHistoryWrites() {
+    return this.pendingHistoryWrites.size > 0;
+  }
 };
+function resolveSafeCwd(candidate, workspaceRoot, label, original) {
+  if (candidate !== workspaceRoot && !candidate.startsWith(workspaceRoot + sep)) {
+    log2.warn("Ignoring %s %s \u2014 resolves outside workspace root %s", label, original, workspaceRoot);
+    return null;
+  }
+  if (!existsSync2(candidate)) {
+    log2.warn("Ignoring %s %s \u2014 directory does not exist", label, original);
+    return null;
+  }
+  return candidate;
+}
 
 // src/server/infra/terminals/daemon/endpoint.ts
 import { randomBytes } from "node:crypto";
@@ -9570,11 +9867,11 @@ import {
   lstatSync,
   mkdirSync,
   renameSync,
-  statSync,
+  statSync as statSync2,
   unlinkSync as unlinkSync2
 } from "node:fs";
 import { connect } from "node:net";
-import { dirname, join as join2 } from "node:path";
+import { dirname, join as join4 } from "node:path";
 var PROBE_TIMEOUT_MS = 500;
 var PUBLISH_ATTEMPTS = 3;
 function isProvenDead(outcome) {
@@ -9609,10 +9906,10 @@ function probeEndpoint(socketPath) {
   });
 }
 function privateBindPath(socketPath) {
-  return join2(dirname(socketPath), `.p${randomBytes(5).toString("hex")}`);
+  return join4(dirname(socketPath), `.p${randomBytes(5).toString("hex")}`);
 }
 async function publishEndpoint(boundPath, canonicalPath, supersede2) {
-  const identity = entryIdentity(boundPath, statSync);
+  const identity = entryIdentity(boundPath, statSync2);
   if (!identity) throw new Error(`Cannot stat the bound daemon socket at ${boundPath}`);
   for (let attempt = 0; attempt < PUBLISH_ATTEMPTS; attempt++) {
     try {
@@ -9669,7 +9966,7 @@ function sameEntry(a, b) {
 function confirmPublished(canonicalPath, identity, superseded) {
   let published;
   try {
-    const stats = statSync(canonicalPath, { bigint: true });
+    const stats = statSync2(canonicalPath, { bigint: true });
     published = { dev: stats.dev, ino: stats.ino };
   } catch (err) {
     return errorCode(err) === "ENOENT" ? { status: "lost" } : { status: "inconclusive" };
@@ -9678,7 +9975,7 @@ function confirmPublished(canonicalPath, identity, superseded) {
 }
 function endpointOwnership(canonicalPath, owned) {
   try {
-    const stats = statSync(canonicalPath, { bigint: true });
+    const stats = statSync2(canonicalPath, { bigint: true });
     return stats.dev === owned.dev && stats.ino === owned.ino ? "owned" : "lost";
   } catch (err) {
     return errorCode(err) === "ENOENT" ? "lost" : "indeterminate";
@@ -9706,36 +10003,37 @@ function errorCode(err) {
 
 // src/server/infra/terminals/daemon/protocol.ts
 import { createHash } from "node:crypto";
-import { basename, dirname as dirname2, join as join3 } from "node:path";
+import { basename, dirname as dirname2, join as join5 } from "node:path";
 var PROTOCOL_VERSION = 1;
 var EXIT_ENDPOINT_OCCUPIED = 20;
 var EXIT_ENDPOINT_UNAVAILABLE = 21;
+var EXIT_NODE_PTY_UNAVAILABLE = 22;
 var ENDPOINT_LOST_ERROR = "Terminal daemon no longer owns its endpoint";
 var MAX_SOCKET_PATH_BYTES = 103;
 function daemonPaths(runDir2, version = PROTOCOL_VERSION) {
-  const inRunDir = join3(runDir2, `terminal-daemon-v${version}.sock`);
-  const socket = Buffer.byteLength(inRunDir) <= MAX_SOCKET_PATH_BYTES ? inRunDir : join3(
+  const inRunDir = join5(runDir2, `terminal-daemon-v${version}.sock`);
+  const socket = Buffer.byteLength(inRunDir) <= MAX_SOCKET_PATH_BYTES ? inRunDir : join5(
     shortSocketDir(),
     `td-${createHash("sha256").update(runDir2).digest("hex").slice(0, 16)}-v${version}.sock`
   );
   return {
     runDir: runDir2,
     socket,
-    token: join3(runDir2, `terminal-daemon-v${version}.token`),
-    pid: join3(runDir2, `terminal-daemon-v${version}.pid`),
-    log: join3(runDir2, "terminal-daemon.log")
+    token: join5(runDir2, `terminal-daemon-v${version}.token`),
+    pid: join5(runDir2, `terminal-daemon-v${version}.pid`),
+    log: join5(runDir2, "terminal-daemon.log")
   };
 }
 function retiredDaemonPaths(paths, tag) {
   return {
     ...paths,
-    socket: join3(dirname2(paths.socket), `.r${tag}`),
+    socket: join5(dirname2(paths.socket), `.r${tag}`),
     token: paths.token.replace(/\.token$/, `.retired-${tag}.token`),
     pid: paths.pid.replace(/\.pid$/, `.retired-${tag}.pid`)
   };
 }
 function shortSocketDir() {
-  return join3("/tmp", `band-${process.getuid?.() ?? "user"}`);
+  return join5("/tmp", `band-${process.getuid?.() ?? "user"}`);
 }
 function writeFrame(socket, message) {
   socket.write(`${JSON.stringify(message)}
@@ -9782,7 +10080,7 @@ function readFrames(socket, onFrame, maxLineBytes = 64 * 1024 * 1024) {
 }
 
 // src/server/infra/terminals/daemon/daemon-server.ts
-var log2 = createLogger("terminal-daemon");
+var log3 = createLogger("terminal-daemon");
 var HELLO_TIMEOUT_MS = 5e3;
 var WATCHDOG_INTERVAL_MS = 2e3;
 var SHUTDOWN_GRACE_MS = 2e3;
@@ -9792,10 +10090,16 @@ var STREAM_HOLD_BYTES = 128 * 1024;
 var SMALL_SESSION_CHARS = 4 * 1024;
 async function runDaemon(options) {
   const { paths, buildId, supersede: supersede2 } = options;
+  try {
+    await preloadNodePty();
+  } catch (err) {
+    log3.error({ err }, "terminal daemon could not load its native module (node-pty); exiting");
+    return EXIT_NODE_PTY_UNAVAILABLE;
+  }
   ensurePrivateDir(paths.runDir);
   ensurePrivateDir(dirname3(paths.socket));
   const token = randomBytes2(32).toString("hex");
-  const pool = new TerminalPool();
+  const pool = new TerminalPool({ historyDir: join6(dirname3(paths.runDir), "terminal-history") });
   const clients = /* @__PURE__ */ new Map();
   let shuttingDown = false;
   let openConnections = 0;
@@ -9827,13 +10131,13 @@ async function runDaemon(options) {
     retired = null;
   }
   if (outcome.status !== "published") {
-    log2.warn({ outcome: outcome.status }, "terminal daemon could not publish its endpoint");
+    log3.warn({ outcome: outcome.status }, "terminal daemon could not publish its endpoint");
     await closeServer(server);
     return outcome.status === "occupied" ? EXIT_ENDPOINT_OCCUPIED : EXIT_ENDPOINT_UNAVAILABLE;
   }
   const identity = outcome.identity;
   if (retired) {
-    log2.info({ retired: retired.socket }, "terminal daemon superseded a daemon of another build");
+    log3.info({ retired: retired.socket }, "terminal daemon superseded a daemon of another build");
   }
   let probingRetired = false;
   writePrivateFile(paths.token, token);
@@ -9846,7 +10150,7 @@ async function runDaemon(options) {
     entry: options.entry
   };
   writePrivateFile(paths.pid, JSON.stringify(pidRecord));
-  log2.info({ pid: process.pid, socket: paths.socket, buildId }, "terminal daemon ready");
+  log3.info({ pid: process.pid, socket: paths.socket, buildId }, "terminal daemon ready");
   pool.onExit((event) => {
     for (const client of clients.values()) {
       client.attached.delete(event.terminalId);
@@ -9862,7 +10166,7 @@ async function runDaemon(options) {
     }
     if (!endpointLost && endpointOwnership(paths.socket, identity) === "lost") {
       endpointLost = true;
-      log2.warn({ sessions: pool.size }, "terminal daemon lost its endpoint; draining");
+      log3.warn({ sessions: pool.size }, "terminal daemon lost its endpoint; draining");
       reevaluateIdle();
     }
     if (retired && !probingRetired) {
@@ -9873,7 +10177,7 @@ async function runDaemon(options) {
         if (!isProvenDead(probe) || retired !== target) return;
         removeRetiredFiles(target);
         retired = null;
-        log2.info({ retired: target.socket }, "superseded terminal daemon exited");
+        log3.info({ retired: target.socket }, "superseded terminal daemon exited");
         reevaluateIdle();
       });
     }
@@ -9906,9 +10210,9 @@ async function runDaemon(options) {
     if (shuttingDown) return;
     shuttingDown = true;
     if (retired) {
-      log2.warn({ retired: retired.socket }, "exiting while a superseded daemon is still running");
+      log3.warn({ retired: retired.socket }, "exiting while a superseded daemon is still running");
     }
-    log2.info({ reason, sessions: pool.size }, "terminal daemon shutting down");
+    log3.info({ reason, sessions: pool.size }, "terminal daemon shutting down");
     clearInterval(watchdog);
     if (adoptionTimer) clearTimeout(adoptionTimer);
     const shells = pool.listAll().map((entry) => entry.pid);
@@ -9919,7 +10223,7 @@ async function runDaemon(options) {
     }
     const deadline = Date.now() + SHUTDOWN_GRACE_MS;
     const waitForShells = setInterval(() => {
-      if (Date.now() < deadline && shells.some(isAlive)) return;
+      if (Date.now() < deadline && (shells.some(isAlive) || pool.hasPendingHistoryWrites())) return;
       clearInterval(waitForShells);
       process.exit(0);
     }, 50);
@@ -9957,7 +10261,7 @@ async function runDaemon(options) {
           return;
         }
         if (hello.buildId !== buildId) {
-          log2.info({ daemon: buildId, server: hello.buildId }, "server build differs from daemon");
+          log3.info({ daemon: buildId, server: hello.buildId }, "server build differs from daemon");
         }
         role = hello.role;
         client = registerClient(hello.clientId, role, socket);
@@ -10017,7 +10321,7 @@ async function runDaemon(options) {
     const socket = client[role];
     if (!socket || socket.destroyed) return;
     if (socket.writableLength > MAX_STREAM_BACKLOG_BYTES) {
-      log2.warn({ clientId: client.id }, "server stopped reading; dropping its connection");
+      log3.warn({ clientId: client.id }, "server stopped reading; dropping its connection");
       dropClient(client);
       return;
     }
@@ -10185,7 +10489,7 @@ function writePrivateFile(path, content) {
 function copyPrivateFile(from, to) {
   let content;
   try {
-    content = readFileSync(from, "utf8");
+    content = readFileSync2(from, "utf8");
   } catch {
     return;
   }
@@ -10220,12 +10524,12 @@ function closeServer(server) {
 }
 
 // terminal-daemon.ts
-var log3 = createLogger("terminal-daemon");
+var log4 = createLogger("terminal-daemon");
 process.on("uncaughtException", (err) => {
-  log3.error({ err }, "uncaught exception in terminal daemon");
+  log4.error({ err }, "uncaught exception in terminal daemon");
 });
 process.on("unhandledRejection", (err) => {
-  log3.error({ err }, "unhandled rejection in terminal daemon");
+  log4.error({ err }, "unhandled rejection in terminal daemon");
 });
 var { values } = parseArgs({
   options: {
@@ -10236,12 +10540,12 @@ var { values } = parseArgs({
 });
 var runDir = values["run-dir"];
 if (!runDir) {
-  log3.error("terminal daemon needs --run-dir");
+  log4.error("terminal daemon needs --run-dir");
   process.exit(2);
 }
 var supersede = values.supersede?.match(/^(\d+):(\d+)$/);
 if (values.supersede !== void 0 && !supersede) {
-  log3.error({ supersede: values.supersede }, "terminal daemon got a malformed --supersede");
+  log4.error({ supersede: values.supersede }, "terminal daemon got a malformed --supersede");
   process.exit(2);
 }
 var exitCode = await runDaemon({