@supanadit/morse-web 0.11.0 → 0.13.0

package/dist/server.mjs

@@ -79,7 +79,7 @@ function hasKnownType(value, allowed) {
 }
 
 // ../protocol/dist/version.js
-var PROTOCOL_VERSION = 20;
+var PROTOCOL_VERSION = 21;
 var FRONTEND_MANIFEST_FILE = "webview.manifest.json";
 var DEFAULT_WS_PATH = "/ws";
 
@@ -1710,11 +1710,11 @@ function promptDescription(raw) {
     }
     body = raw.slice(frontmatter[0].length);
   }
-  const firstLine2 = body.split("\n").find((line) => line.trim().length > 0);
-  if (firstLine2 === void 0) {
+  const firstLine = body.split("\n").find((line) => line.trim().length > 0);
+  if (firstLine === void 0) {
     return void 0;
   }
-  const trimmed = firstLine2.trim();
+  const trimmed = firstLine.trim();
   return trimmed.length > 60 ? `${trimmed.slice(0, 60)}...` : trimmed;
 }
 function unquote(value) {
@@ -2145,6 +2145,17 @@ function createPiRpcAdapter(config, logger) {
   };
 }
 
+// ../host-runtime/dist/terminal-buffer.js
+var TERMINAL_BUFFER_CHARS = 256 * 1024;
+function trimTail(text, maxChars = TERMINAL_BUFFER_CHARS) {
+  if (text.length <= maxChars) {
+    return text;
+  }
+  const tail = text.slice(-maxChars);
+  const newline = tail.indexOf("\n");
+  return newline === -1 ? tail : tail.slice(newline + 1);
+}
+
 // ../host-runtime/dist/transcript-projector.js
 var TranscriptProjector = class {
   options;
@@ -2671,8 +2682,15 @@ var HostSessionController = class {
   loadingOlderHistory = false;
   /** Discriminates history item ids across pages (see `historyItems`). */
   historyPageSeq = 0;
-  /** The shells this client has open, keyed by the terminal id it named. */
+  /** This client's live attachments to shells, keyed by the terminal id it named. */
   terminals = /* @__PURE__ */ new Map();
+  /**
+   * The ids this connection has already opened. It separates a *first* open — a
+   * page reattaching to a shell the host still runs — from a repeat open (the
+   * Restart button), which must replace the shell and clear its scrollback
+   * instead of replaying it into the emulator that already shows it.
+   */
+  openedTerminals = /* @__PURE__ */ new Set();
   /**
    * Bumped whenever a terminal id is opened or closed. A shell's late `exit`
    * (a replaced one, a killed one) compares its generation and stays silent, so
@@ -2721,11 +2739,12 @@ var HostSessionController = class {
       return;
     }
     this.disposed = true;
-    for (const process2 of this.terminals.values()) {
-      process2.kill();
+    for (const session of this.terminals.values()) {
+      session.detach();
     }
     this.terminals.clear();
     this.terminalGenerations.clear();
+    this.openedTerminals.clear();
     this.detachRegistry?.();
     this.detachRegistry = void 0;
     this.detachTranscripts?.();
@@ -2830,23 +2849,38 @@ var HostSessionController = class {
     }
   }
   /**
-   * Starts a shell for the bottom panel. The directory is the viewing session's
-   * (or the draft's), never an arbitrary path the client names — the backend
-   * still re-checks it against the host policy before spawning.
+   * Attaches this client to a shell for the bottom panel. The directory is the
+   * viewing session's (or the draft's), never an arbitrary path the client
+   * names — the backend still re-checks it against the host policy before
+   * spawning.
+   *
+   * A *first* open on this connection may land on a shell that is already running
+   * (a reloaded page reattaching); a repeat open (the Restart button) replaces
+   * it, scrollback and all, so the fresh shell does not replay the old one.
    */
   async openTerminal(payload) {
-    if (this.options.terminal === void 0) {
+    const backend = this.options.terminal;
+    if (backend === void 0) {
       this.emitTerminalExit(payload.terminalId, void 0, "This host has no terminal.");
       return;
     }
-    this.closeTerminal(payload.terminalId);
-    const generation = this.terminalGenerations.get(payload.terminalId) ?? 0;
+    const previous = this.terminals.get(payload.terminalId);
+    if (previous !== void 0) {
+      previous.detach();
+      this.terminals.delete(payload.terminalId);
+      backend.close(payload.terminalId);
+    } else if (this.openedTerminals.has(payload.terminalId)) {
+      backend.close(payload.terminalId);
+    }
+    this.openedTerminals.add(payload.terminalId);
+    const generation = (this.terminalGenerations.get(payload.terminalId) ?? 0) + 1;
+    this.terminalGenerations.set(payload.terminalId, generation);
     const cwd = payload.cwd ?? this.currentState().workspace.cwd;
     const cols = clampGeometry(payload.cols, 80);
     const rows = clampGeometry(payload.rows, 24);
-    let process2;
+    let session;
     try {
-      process2 = await this.options.terminal.open({ cwd, cols, rows }, {
+      session = await backend.attach(payload.terminalId, { cwd, cols, rows }, {
         output: (data) => {
           if (this.terminalGenerations.get(payload.terminalId) === generation) {
             this.emitTerminalOutput(payload.terminalId, data);
@@ -2866,19 +2900,25 @@ var HostSessionController = class {
       return;
     }
     if (!this.disposed && this.terminalGenerations.get(payload.terminalId) === generation) {
-      this.terminals.set(payload.terminalId, process2);
+      this.terminals.set(payload.terminalId, session);
+      if (session.replay.length > 0) {
+        this.emitTerminalOutput(payload.terminalId, session.replay);
+      }
     } else {
-      process2.kill();
+      session.detach();
     }
   }
+  /**
+   * Ends a shell for good: the reader closed the pane. Bumps the generation first,
+   * so a late `exit` for the shell being replaced is not reported as news.
+   */
   closeTerminal(terminalId) {
     this.terminalGenerations.set(terminalId, (this.terminalGenerations.get(terminalId) ?? 0) + 1);
-    const process2 = this.terminals.get(terminalId);
-    if (process2 === void 0) {
-      return;
-    }
+    const session = this.terminals.get(terminalId);
     this.terminals.delete(terminalId);
-    process2.kill();
+    this.openedTerminals.delete(terminalId);
+    session?.detach();
+    this.options.terminal?.close(terminalId);
   }
   emitTerminalOutput(terminalId, data) {
     if (data.length > 0 && !this.disposed) {
@@ -3769,7 +3809,50 @@ var ServerProjectPolicy = class {
 // ../server/src/internal/terminal/terminal.service.ts
 import { spawn as spawnPty } from "node-pty";
 import { Inject as Inject2, Injectable } from "@nestjs/common";
+
+// ../server/src/internal/terminal/terminal-log.ts
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { join as join5 } from "node:path";
+var LOG_DIR = "terminals";
+var LOG_MAX_CHARS = TERMINAL_BUFFER_CHARS * 4;
+function readTerminalLog(dataDir, terminalId) {
+  try {
+    const raw = readFileSync(logPath(dataDir, terminalId), "utf8");
+    return trimTail(raw, LOG_MAX_CHARS);
+  } catch {
+    return "";
+  }
+}
+function writeTerminalLog(dataDir, terminalId, text) {
+  const trimmed = trimTail(text, LOG_MAX_CHARS);
+  const target = logPath(dataDir, terminalId);
+  const temp = `${target}.${process.pid}.tmp`;
+  try {
+    mkdirSync(join5(dataDir, LOG_DIR), { recursive: true });
+    writeFileSync(temp, trimmed);
+    renameSync(temp, target);
+  } catch {
+    try {
+      writeFileSync(target, trimmed);
+    } catch {
+      rmSync(temp, { force: true });
+    }
+  }
+}
+function removeTerminalLog(dataDir, terminalId) {
+  rmSync(logPath(dataDir, terminalId), { force: true });
+}
+function safeTerminalName(terminalId) {
+  const safe = terminalId.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 100);
+  return safe.length > 0 ? safe : "terminal";
+}
+function logPath(dataDir, terminalId) {
+  return join5(dataDir, LOG_DIR, `${safeTerminalName(terminalId)}.log`);
+}
+
+// ../server/src/internal/terminal/terminal.service.ts
 var SIGKILL_AFTER_MS = 1500;
+var FLUSH_DEBOUNCE_MS = 2e3;
 function defaultShell() {
   const configured = process.env.SHELL?.trim();
   if (configured !== void 0 && configured.length > 0) {
@@ -3778,17 +3861,95 @@ function defaultShell() {
   return process.platform === "win32" ? "powershell.exe" : "/bin/bash";
 }
 var ServerTerminalBackend = class {
-  constructor(policy, logger) {
+  constructor(policy, logger, config) {
     this.policy = policy;
     this.logger = logger;
+    this.config = config;
+    this.entries = /* @__PURE__ */ new Map();
   }
-  open(options, sink) {
+  attach(terminalId, options, sink) {
+    const entry = this.entryFor(terminalId);
+    if (entry.pty === void 0) {
+      this.spawn(terminalId, entry, options);
+    } else {
+      this.resize(entry, options.cols, options.rows);
+    }
+    entry.sinks.add(sink);
+    this.cancelIdle(entry);
+    return {
+      replay: entry.output,
+      write: (data) => entry.pty?.write(data),
+      resize: (cols, rows) => this.resize(entry, cols, rows),
+      detach: () => this.detach(terminalId, entry, sink)
+    };
+  }
+  /** Ends a shell for good, drops its scrollback, and tells any other viewer. */
+  close(terminalId) {
+    const entry = this.entries.get(terminalId);
+    this.entries.delete(terminalId);
+    if (entry !== void 0) {
+      this.stopFlush(entry);
+      this.cancelIdle(entry);
+      entry.generation += 1;
+      const sinks = [...entry.sinks];
+      entry.sinks.clear();
+      this.killPty(entry.pty);
+      entry.pty = void 0;
+      for (const sink of sinks) {
+        sink.exit();
+      }
+    }
+    removeTerminalLog(this.config.dataDir, terminalId);
+  }
+  onModuleDestroy() {
+    for (const [terminalId, entry] of this.entries) {
+      entry.generation += 1;
+      this.persist(terminalId, entry);
+      this.killPty(entry.pty);
+      entry.pty = void 0;
+      this.stopFlush(entry);
+      this.cancelIdle(entry);
+    }
+    this.entries.clear();
+  }
+  /** SIGTERM, then SIGKILL for a shell that ignores it (a hung process group). */
+  killPty(pty) {
+    if (pty === void 0) {
+      return;
+    }
+    try {
+      pty.kill();
+    } catch {
+      return;
+    }
+    const timer = setTimeout(() => {
+      try {
+        pty.kill("SIGKILL");
+      } catch {
+      }
+    }, SIGKILL_AFTER_MS);
+    timer.unref?.();
+  }
+  entryFor(terminalId) {
+    const existing = this.entries.get(terminalId);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const entry = {
+      sinks: /* @__PURE__ */ new Set(),
+      output: readTerminalLog(this.config.dataDir, terminalId),
+      dirty: false,
+      generation: 0
+    };
+    this.entries.set(terminalId, entry);
+    return entry;
+  }
+  spawn(terminalId, entry, options) {
     if (!this.policy.canOpen(options.cwd)) {
-      throw new UnsupportedByHostError(
-        `Morse is not allowed to run a terminal in ${options.cwd}.`
-      );
+      throw new UnsupportedByHostError(`Morse is not allowed to run a terminal in ${options.cwd}.`);
     }
     const shell = defaultShell();
+    const generation = ++entry.generation;
     const pty = spawnPty(shell, [], {
       name: "xterm-256color",
       cols: options.cols,
@@ -3796,41 +3957,105 @@ var ServerTerminalBackend = class {
       cwd: options.cwd,
       env: { ...process.env, TERM: "xterm-256color", MORSE_TERMINAL: "1" }
     });
+    entry.pty = pty;
     this.logger.info(`Terminal opened in ${options.cwd} (${shell}, pid ${pty.pid})`);
-    let exited = false;
-    const data = pty.onData((chunk) => sink.output(chunk));
+    pty.onData((chunk) => {
+      if (entry.generation !== generation) {
+        return;
+      }
+      entry.output += chunk;
+      if (entry.output.length > TERMINAL_BUFFER_CHARS * 1.5) {
+        entry.output = trimTail(entry.output, TERMINAL_BUFFER_CHARS);
+      }
+      entry.dirty = true;
+      this.scheduleFlush(terminalId, entry);
+      for (const sink of entry.sinks) {
+        sink.output(chunk);
+      }
+    });
     pty.onExit(({ exitCode }) => {
-      exited = true;
-      data.dispose();
-      sink.exit(exitCode);
+      if (entry.generation !== generation) {
+        return;
+      }
+      entry.pty = void 0;
+      this.persist(terminalId, entry);
+      for (const sink of [...entry.sinks]) {
+        sink.exit(exitCode);
+      }
     });
-    return {
-      write: (input) => {
-        if (!exited) {
-          pty.write(input);
-        }
-      },
-      resize: (cols, rows) => {
-        if (!exited) {
-          pty.resize(cols, rows);
-        }
-      },
-      kill: () => {
-        if (exited) {
-          return;
-        }
-        exited = true;
-        pty.kill();
-        const timer = setTimeout(() => pty.kill("SIGKILL"), SIGKILL_AFTER_MS);
-        timer.unref?.();
+  }
+  resize(entry, cols, rows) {
+    try {
+      entry.pty?.resize(cols, rows);
+    } catch {
+    }
+  }
+  detach(terminalId, entry, sink) {
+    entry.sinks.delete(sink);
+    if (entry.sinks.size > 0) {
+      return;
+    }
+    this.persist(terminalId, entry);
+    this.scheduleIdle(terminalId, entry);
+  }
+  /**
+   * Reclaims a shell nobody has reattached to. The log stays (the output should
+   * still be there next time); only the process goes.
+   */
+  scheduleIdle(terminalId, entry) {
+    if (this.config.terminalIdleMs <= 0) {
+      return;
+    }
+    this.cancelIdle(entry);
+    entry.idleTimer = setTimeout(() => {
+      entry.idleTimer = void 0;
+      if (entry.sinks.size > 0) {
+        return;
       }
-    };
+      entry.generation += 1;
+      this.killPty(entry.pty);
+      entry.pty = void 0;
+      this.persist(terminalId, entry);
+      this.entries.delete(terminalId);
+    }, this.config.terminalIdleMs);
+    entry.idleTimer.unref?.();
+  }
+  cancelIdle(entry) {
+    if (entry.idleTimer !== void 0) {
+      clearTimeout(entry.idleTimer);
+      entry.idleTimer = void 0;
+    }
+  }
+  scheduleFlush(terminalId, entry) {
+    if (entry.flushTimer !== void 0) {
+      return;
+    }
+    entry.flushTimer = setTimeout(() => {
+      entry.flushTimer = void 0;
+      this.persist(terminalId, entry);
+    }, FLUSH_DEBOUNCE_MS);
+    entry.flushTimer.unref?.();
+  }
+  stopFlush(entry) {
+    if (entry.flushTimer !== void 0) {
+      clearTimeout(entry.flushTimer);
+      entry.flushTimer = void 0;
+    }
+  }
+  persist(terminalId, entry) {
+    this.stopFlush(entry);
+    if (!entry.dirty) {
+      return;
+    }
+    entry.dirty = false;
+    writeTerminalLog(this.config.dataDir, terminalId, entry.output);
   }
 };
 ServerTerminalBackend = __decorateClass([
   Injectable(),
   __decorateParam(0, Inject2(MORSE_PROJECT_POLICY)),
-  __decorateParam(1, Inject2(MORSE_LOGGER))
+  __decorateParam(1, Inject2(MORSE_LOGGER)),
+  __decorateParam(2, Inject2(MORSE_CONFIG))
 ], ServerTerminalBackend);
 
 // ../server/src/internal/registry.ts
@@ -3872,7 +4097,7 @@ import { Inject as Inject4, Injectable as Injectable3 } from "@nestjs/common";
 // ../server/src/internal/uploads/upload-store.ts
 import { existsSync } from "node:fs";
 import { mkdir, writeFile } from "node:fs/promises";
-import { basename as basename2, isAbsolute as isAbsolute3, join as join5, relative, sep as sep3 } from "node:path";
+import { basename as basename2, isAbsolute as isAbsolute3, join as join6, relative, sep as sep3 } from "node:path";
 var MAX_UPLOAD_BYTES = 10 * 1024 * 1024;
 var DEFAULT_UPLOAD_DIR = ".morse/uploads";
 var UploadError = class extends Error {
@@ -3892,7 +4117,7 @@ async function saveUpload(cwd, request, uploadDir = DEFAULT_UPLOAD_DIR) {
       `That file is ${formatMb(bytes.length)} MB; the limit is ${formatMb(MAX_UPLOAD_BYTES)} MB.`
     );
   }
-  const directory = isAbsolute3(uploadDir) ? uploadDir : join5(cwd, uploadDir);
+  const directory = isAbsolute3(uploadDir) ? uploadDir : join6(cwd, uploadDir);
   await mkdir(directory, { recursive: true });
   const target = uniquePath(directory, name);
   await writeFile(target, bytes);
@@ -3911,10 +4136,10 @@ function uniquePath(directory, name) {
   const dot = name.lastIndexOf(".");
   const stem = dot > 0 ? name.slice(0, dot) : name;
   const extension = dot > 0 ? name.slice(dot) : "";
-  let candidate = join5(directory, name);
+  let candidate = join6(directory, name);
   let suffix = 1;
   while (existsSync(candidate)) {
-    candidate = join5(directory, `${stem}-${suffix}${extension}`);
+    candidate = join6(directory, `${stem}-${suffix}${extension}`);
     suffix += 1;
   }
   return candidate;
@@ -3931,7 +4156,7 @@ function formatMb(bytes) {
 // ../server/src/internal/workspace/directory-browser.ts
 import { readdir as readdir3, stat as stat3 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
-import { basename as basename3, dirname, isAbsolute as isAbsolute4, join as join6, resolve as resolve4 } from "node:path";
+import { basename as basename3, dirname, isAbsolute as isAbsolute4, join as join7, resolve as resolve4 } from "node:path";
 var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set([
   "node_modules",
   "dist",
@@ -3955,7 +4180,7 @@ async function browseDirectory(path, options) {
     throw new Error(`A folder path must be absolute: ${requested}`);
   }
   const entries = await readdir3(start, { withFileTypes: true });
-  const directories = entries.filter((entry) => entry.isDirectory()).filter((entry) => !shouldSkip(entry.name)).map((entry) => ({ name: entry.name, path: join6(start, entry.name) })).sort((left, right) => left.name.localeCompare(right.name));
+  const directories = entries.filter((entry) => entry.isDirectory()).filter((entry) => !shouldSkip(entry.name)).map((entry) => ({ name: entry.name, path: join7(start, entry.name) })).sort((left, right) => left.name.localeCompare(right.name));
   const parent = dirname(start);
   return {
     path: start,
@@ -3970,7 +4195,7 @@ function shouldSkip(name) {
 }
 async function isGitRepo(path) {
   try {
-    await stat3(join6(path, ".git"));
+    await stat3(join7(path, ".git"));
     return true;
   } catch {
     return false;
@@ -4253,7 +4478,10 @@ async function commitGit(cwd, message) {
     return { ok: false, message: "This project is not a git repository." };
   }
   const result = await gitExec(["commit", "-m", text], cwd, 6e4);
-  return { ok: result.ok, message: result.ok ? void 0 : firstLine(result.output) };
+  if (result.ok) {
+    return { ok: true };
+  }
+  return { ok: false, message: describeCommitFailure(result.output) };
 }
 async function checkoutGit(cwd, branch, create) {
   const name = branch.trim();
@@ -4269,13 +4497,21 @@ async function checkoutGit(cwd, branch, create) {
     cwd,
     6e4
   );
-  return { ok: result.ok, message: result.ok ? void 0 : firstLine(result.output) };
+  return { ok: result.ok, message: result.ok ? void 0 : gitRefusal(result.output) };
 }
 function isBranchName(name) {
   return name.length > 0 && !name.startsWith("-") && !name.includes("..") && !name.includes("@{") && !name.endsWith("/") && !/\s/.test(name) && !/[~^:?*\[\\]/.test(name);
 }
-function firstLine(output) {
-  const line = output.split("\n").find((candidate) => candidate.trim().length > 0)?.trim();
+function describeCommitFailure(output) {
+  if (/nothing to commit|no changes added to commit|nothing added to commit/i.test(output)) {
+    return "Nothing is staged to commit. Stage a change first.";
+  }
+  return gitRefusal(output);
+}
+function gitRefusal(output) {
+  const line = output.split("\n").map((candidate) => candidate.trim()).find(
+    (candidate) => candidate.length > 0 && !candidate.startsWith("Command failed:") && !/^On branch /.test(candidate) && !/^Your branch /.test(candidate)
+  );
   if (line === void 0) {
     return void 0;
   }
@@ -4359,9 +4595,12 @@ function gitExec(args, cwd, timeout = 5e3) {
         }
       },
       (error, stdout, stderr) => {
-        resolve6(
-          error === null ? { ok: true, output: stdout.trim() } : { ok: false, output: (stderr || error.message || "").trim() }
-        );
+        if (error === null) {
+          resolve6({ ok: true, output: stdout.trim() });
+          return;
+        }
+        const output = [stderr.trim(), stdout.trim()].filter((part) => part.length > 0).join("\n");
+        resolve6({ ok: false, output: output.length > 0 ? output : error.message.trim() });
       }
     );
   });
@@ -4370,7 +4609,7 @@ function gitExec(args, cwd, timeout = 5e3) {
 // ../server/src/internal/workspace/workspace-index.ts
 import { execFile as execFile2 } from "node:child_process";
 import { readdir as readdir4 } from "node:fs/promises";
-import { join as join7, relative as relative4 } from "node:path";
+import { join as join8, relative as relative4 } from "node:path";
 var SKIPPED_DIRECTORIES2 = /* @__PURE__ */ new Set([
   "node_modules",
   "dist",
@@ -4481,7 +4720,7 @@ async function walk(root, directory, files) {
     if (files.length >= MAX_INDEXED_FILES) {
       return;
     }
-    const full = join7(directory, entry.name);
+    const full = join8(directory, entry.name);
     if (entry.isDirectory()) {
       if (SKIPPED_DIRECTORIES2.has(entry.name) || entry.name.startsWith(".")) {
         continue;
@@ -4498,6 +4737,81 @@ function toPosix3(path) {
   return path.split("\\").join("/");
 }
 
+// ../server/src/internal/workspace/workbench-store.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync as renameSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join9 } from "node:path";
+var LAYOUT_FILE = "workbench.json";
+var DRAFTS_FILE = "drafts.json";
+var LAYOUT_MAX_BYTES = 256 * 1024;
+var DRAFTS_MAX_BYTES = 32 * 1024 * 1024;
+function readWorkbench(dataDir) {
+  return readSlot(join9(dataDir, LAYOUT_FILE), LAYOUT_MAX_BYTES);
+}
+function saveWorkbench(dataDir, snapshot) {
+  return saveSlot(dataDir, LAYOUT_FILE, snapshot, LAYOUT_MAX_BYTES);
+}
+function readDrafts(dataDir) {
+  return readSlot(join9(dataDir, DRAFTS_FILE), DRAFTS_MAX_BYTES);
+}
+function saveDrafts(dataDir, snapshot) {
+  return saveSlot(dataDir, DRAFTS_FILE, snapshot, DRAFTS_MAX_BYTES);
+}
+function readSlot(path, maxBytes) {
+  let raw;
+  try {
+    raw = readFileSync2(path, "utf8");
+  } catch {
+    return void 0;
+  }
+  if (raw.length > maxBytes) {
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+  return asSnapshot(parsed);
+}
+function saveSlot(dataDir, file, snapshot, maxBytes) {
+  const valid = asSnapshot(snapshot);
+  if (valid === void 0) {
+    throw new UnsupportedByHostError(`Saving ${file} needs a { version, data } snapshot.`);
+  }
+  const serialized = JSON.stringify(valid);
+  if (Buffer.byteLength(serialized, "utf8") > maxBytes) {
+    throw new UnsupportedByHostError(`That ${file} snapshot is too large to save.`);
+  }
+  const target = join9(dataDir, file);
+  const temp = `${target}.${process.pid}.tmp`;
+  try {
+    mkdirSync2(dataDir, { recursive: true });
+    writeFileSync2(temp, serialized);
+    renameSync2(temp, target);
+    return true;
+  } catch {
+    try {
+      writeFileSync2(target, serialized);
+      return true;
+    } catch {
+      rmSync2(temp, { force: true });
+      return false;
+    }
+  }
+}
+function asSnapshot(value) {
+  if (typeof value !== "object" || value === null) {
+    return void 0;
+  }
+  const candidate = value;
+  const version = candidate["version"];
+  if (typeof version !== "number" || !Number.isInteger(version) || version < 1) {
+    return void 0;
+  }
+  return { version, data: candidate["data"] };
+}
+
 // ../server/src/internal/ws/session-factory.service.ts
 var MorseSessionFactory = class {
   constructor(registry, transcripts, policy, logger, config, terminal) {
@@ -4532,6 +4846,10 @@ var MorseSessionFactory = class {
       // the bottom panel's terminal is this host's. It runs in the viewing
       // session's directory and is gated by `ProjectPolicy`, like a session.
       terminal: true,
+      // The browser host restores the tabs, panel, terminals and half-written
+      // prompts the reader left open, kept under `<MORSE_HOME>`. VS Code has its
+      // own tab restoration and leaves this off.
+      workbench: true,
       // A browser cannot hand a dragged file's path to pi, so the host takes the
       // bytes and writes them next to the session; the frontend then `@mentions`
       // the path it gets back.
@@ -4595,13 +4913,25 @@ var MorseSessionFactory = class {
         });
         return { ...listing, canOpen: this.policy.canOpen(listing.path) };
       }
+      case "readWorkbench": {
+        return readWorkbench(this.config.dataDir) ?? null;
+      }
+      case "saveWorkbench": {
+        return { ok: saveWorkbench(this.config.dataDir, args) };
+      }
+      case "readDrafts": {
+        return readDrafts(this.config.dataDir) ?? null;
+      }
+      case "saveDrafts": {
+        return { ok: saveDrafts(this.config.dataDir, args) };
+      }
       case "listFiles": {
         const cwd = this.requireWritableCwd(context);
         const files = await workspaceFiles(cwd, this.logger, { fresh: args?.fresh === true });
         return { files };
       }
       case "readFile": {
-        const cwd = this.requireWritableCwd(context);
+        const cwd = this.commandCwd(context, args);
         const path = typeof args?.path === "string" ? args.path : "";
         if (path.length === 0) {
           throw new UnsupportedByHostError('readFile needs a "path" argument.');
@@ -4625,7 +4955,7 @@ var MorseSessionFactory = class {
         return readGitStatus(cwd);
       }
       case "gitDiff": {
-        const cwd = this.requireWritableCwd(context);
+        const cwd = this.commandCwd(context, args);
         const path = typeof args?.path === "string" ? args.path : "";
         if (path.length === 0) {
           throw new UnsupportedByHostError('gitDiff needs a "path" argument.');
@@ -4646,7 +4976,7 @@ var MorseSessionFactory = class {
         return readCommitFiles(cwd, hash);
       }
       case "gitCommitDiff": {
-        const cwd = this.requireWritableCwd(context);
+        const cwd = this.commandCwd(context, args);
         const hash = typeof args?.hash === "string" ? args.hash : "";
         const path = typeof args?.path === "string" ? args.path : "";
         if (path.length === 0) {
@@ -4699,6 +5029,22 @@ var MorseSessionFactory = class {
     }
     return cwd;
   }
+  /**
+   * The directory a file command works in. A restored preview tab carries the
+   * project it was read from (`args.cwd`), because the host may still be on
+   * another session when that tab is loaded; the policy checks it exactly like a
+   * terminal's directory. Without one, the viewing session's directory is used.
+   */
+  commandCwd(context, args) {
+    const requested = args?.cwd;
+    if (typeof requested === "string" && requested.length > 0) {
+      if (!this.policy.canOpen(requested)) {
+        throw new UnsupportedByHostError(`Morse is not allowed to work in ${requested}.`);
+      }
+      return requested;
+    }
+    return this.requireWritableCwd(context);
+  }
   /** The cwd of the session this connection is showing. */
   activeCwd() {
     const key = this.registry.activeKeyOf();
@@ -4771,18 +5117,19 @@ MorseGateway = __decorateClass([
 ], MorseGateway);
 
 // ../server/src/app/config.ts
-import { basename as basename4, dirname as dirname2, isAbsolute as isAbsolute6, join as join8 } from "node:path";
-import { existsSync as existsSync2, readFileSync } from "node:fs";
+import { basename as basename4, dirname as dirname2, isAbsolute as isAbsolute6, join as join10 } from "node:path";
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
 import { fileURLToPath } from "node:url";
 function loadConfig(env = process.env) {
   const workspacePath = resolveWorkspacePath(env);
   const configuredUiDir = env.MORSE_UI_DIR;
   const moduleDir = dirname2(fileURLToPath(import.meta.url));
-  const bundledUiDir = join8(moduleDir, "ui");
-  const monorepoUiDir = join8(moduleDir, "..", "..", "..", "ui-angular", "dist");
-  const defaultUiDir = existsSync2(join8(bundledUiDir, "index.html")) ? bundledUiDir : monorepoUiDir;
+  const bundledUiDir = join10(moduleDir, "ui");
+  const monorepoUiDir = join10(moduleDir, "..", "..", "..", "ui-angular", "dist");
+  const defaultUiDir = existsSync2(join10(bundledUiDir, "index.html")) ? bundledUiDir : monorepoUiDir;
   const defaultHost = "127.0.0.1";
-  const uiDir = configuredUiDir ? isAbsolute6(configuredUiDir) ? configuredUiDir : join8(process.cwd(), configuredUiDir) : defaultUiDir;
+  const uiDir = configuredUiDir ? isAbsolute6(configuredUiDir) ? configuredUiDir : join10(process.cwd(), configuredUiDir) : defaultUiDir;
   return {
     host: env.MORSE_HOST ?? defaultHost,
     port: parsePositiveInt(env.MORSE_PORT, 4399),
@@ -4797,6 +5144,8 @@ function loadConfig(env = process.env) {
     hotSessions: parsePositiveInt(env.MORSE_HOT_SESSIONS, 4),
     projects: parseList(env.MORSE_PROJECTS),
     uploadDir: env.MORSE_UPLOAD_DIR?.trim() || DEFAULT_UPLOAD_DIR,
+    dataDir: resolveDataDir(env),
+    terminalIdleMs: parsePositiveInt(env.MORSE_TERMINAL_IDLE_MS, 30 * 6e4),
     updateCheck: !isOff(env.MORSE_UPDATE_CHECK),
     instance: env.MORSE_INSTANCE?.trim() || void 0
   };
@@ -4804,12 +5153,16 @@ function loadConfig(env = process.env) {
 function readFrontendIdentity(uiDir) {
   try {
     return frontendIdentity(
-      parseFrontendManifest(readFileSync(join8(uiDir, FRONTEND_MANIFEST_FILE), "utf8"))
+      parseFrontendManifest(readFileSync3(join10(uiDir, FRONTEND_MANIFEST_FILE), "utf8"))
     );
   } catch {
     return void 0;
   }
 }
+function resolveDataDir(env) {
+  const explicit = env.MORSE_HOME?.trim();
+  return explicit && explicit.length > 0 ? explicit : join10(homedir4(), ".morse");
+}
 function parsePositiveInt(value, fallback) {
   if (!value) {
     return fallback;
@@ -4835,7 +5188,7 @@ function resolveWorkspacePath(env) {
   const start = process.cwd();
   let directory = start;
   for (; ; ) {
-    const manifest = join8(directory, "package.json");
+    const manifest = join10(directory, "package.json");
     if (existsSync2(manifest) && declaresWorkspaces(manifest)) {
       return directory;
     }
@@ -4848,7 +5201,7 @@ function resolveWorkspacePath(env) {
 }
 function declaresWorkspaces(manifestPath) {
   try {
-    const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+    const manifest = JSON.parse(readFileSync3(manifestPath, "utf8"));
     return manifest.workspaces !== void 0;
   } catch {
     return false;