@band-app/server 0.31.1 → 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 = `
@@ -8596,6 +8596,250 @@ var require_addon_serialize = __commonJS({
   }
 });
 
+// ../../node_modules/.pnpm/@xterm+addon-unicode11@0.10.0-beta.291_@xterm+xterm@6.1.0-beta.291/node_modules/@xterm/addon-unicode11/lib/addon-unicode11.js
+var require_addon_unicode11 = __commonJS({
+  "../../node_modules/.pnpm/@xterm+addon-unicode11@0.10.0-beta.291_@xterm+xterm@6.1.0-beta.291/node_modules/@xterm/addon-unicode11/lib/addon-unicode11.js"(exports, module) {
+    !(function(e, s) {
+      "object" == typeof exports && "object" == typeof module ? module.exports = s() : "function" == typeof define && define.amd ? define([], s) : "object" == typeof exports ? exports.Unicode11Addon = s() : e.Unicode11Addon = s();
+    })(globalThis, () => (() => {
+      "use strict";
+      var e = { 414(e2, s2, t2) {
+        Object.defineProperty(s2, "__esModule", { value: true }), s2.EventUtils = s2.Emitter = void 0;
+        const i2 = t2(426);
+        var r;
+        s2.Emitter = class {
+          constructor() {
+            this._listeners = [], this._disposed = false;
+          }
+          get event() {
+            return this._event || (this._event = (e3, s3, t3) => {
+              if (this._disposed) return (0, i2.toDisposable)(() => {
+              });
+              const r2 = { fn: e3, thisArgs: s3 };
+              this._listeners.push(r2);
+              const o = (0, i2.toDisposable)(() => {
+                const e4 = this._listeners.indexOf(r2);
+                -1 !== e4 && this._listeners.splice(e4, 1);
+              });
+              return t3 && (Array.isArray(t3) ? t3.push(o) : t3.add(o)), o;
+            }), this._event;
+          }
+          fire(e3) {
+            if (!this._disposed) switch (this._listeners.length) {
+              case 0:
+                return;
+              case 1: {
+                const { fn: s3, thisArgs: t3 } = this._listeners[0];
+                return void s3.call(t3, e3);
+              }
+              default: {
+                const s3 = this._listeners.slice();
+                for (const { fn: t3, thisArgs: i3 } of s3) t3.call(i3, e3);
+              }
+            }
+          }
+          dispose() {
+            this._disposed || (this._disposed = true, this._listeners.length = 0);
+          }
+        }, (function(e3) {
+          e3.forward = function(e4, s3) {
+            return e4((e5) => s3.fire(e5));
+          }, e3.map = function(e4, s3) {
+            return (t3, i3, r2) => e4((e5) => t3.call(i3, s3(e5)), void 0, r2);
+          }, e3.any = function(...e4) {
+            return (s3, t3, r2) => {
+              const o = new i2.DisposableStore();
+              for (const i3 of e4) o.add(i3((e5) => s3.call(t3, e5)));
+              return r2 && (Array.isArray(r2) ? r2.push(o) : r2.add(o)), o;
+            };
+          }, e3.runAndSubscribe = function(e4, s3, t3) {
+            return s3(t3), e4((e5) => s3(e5));
+          };
+        })(r || (s2.EventUtils = r = {}));
+      }, 426(e2, s2) {
+        function t2(e3) {
+          return { dispose: e3 };
+        }
+        function i2(e3) {
+          if (!e3) return e3;
+          if (Array.isArray(e3)) {
+            for (const s3 of e3) s3.dispose();
+            return [];
+          }
+          return e3.dispose(), e3;
+        }
+        Object.defineProperty(s2, "__esModule", { value: true }), s2.MutableDisposable = s2.Disposable = s2.DisposableStore = void 0, s2.toDisposable = t2, s2.dispose = i2, s2.combinedDisposable = function(...e3) {
+          return t2(() => i2(e3));
+        };
+        class r {
+          constructor() {
+            this._disposables = /* @__PURE__ */ new Set(), this._isDisposed = false;
+          }
+          get isDisposed() {
+            return this._isDisposed;
+          }
+          add(e3) {
+            return this._isDisposed ? e3.dispose() : this._disposables.add(e3), e3;
+          }
+          dispose() {
+            if (!this._isDisposed) {
+              this._isDisposed = true;
+              for (const e3 of this._disposables) e3.dispose();
+              this._disposables.clear();
+            }
+          }
+          clear() {
+            for (const e3 of this._disposables) e3.dispose();
+            this._disposables.clear();
+          }
+        }
+        s2.DisposableStore = r;
+        class o {
+          constructor() {
+            this._store = new r();
+          }
+          dispose() {
+            this._store.dispose();
+          }
+          _register(e3) {
+            return this._store.add(e3);
+          }
+        }
+        s2.Disposable = o, o.None = Object.freeze({ dispose() {
+        } }), s2.MutableDisposable = class {
+          constructor() {
+            this._isDisposed = false;
+          }
+          get value() {
+            return this._isDisposed ? void 0 : this._value;
+          }
+          set value(e3) {
+            this._isDisposed || e3 === this._value || (this._value?.dispose(), this._value = e3);
+          }
+          clear() {
+            this.value = void 0;
+          }
+          dispose() {
+            this._isDisposed = true, this._value?.dispose(), this._value = void 0;
+          }
+        };
+      }, 765(e2, s2, t2) {
+        Object.defineProperty(s2, "__esModule", { value: true }), s2.UnicodeService = void 0;
+        const i2 = t2(414);
+        class r {
+          constructor() {
+            this._providers = /* @__PURE__ */ Object.create(null), this._active = "", this._onChange = new i2.Emitter(), this.onChange = this._onChange.event;
+          }
+          static extractShouldJoin(e3) {
+            return !!(1 & e3);
+          }
+          static extractWidth(e3) {
+            return e3 >> 1 & 3;
+          }
+          static extractCharKind(e3) {
+            return e3 >> 3;
+          }
+          static createPropertyValue(e3, s3, t3 = false) {
+            return (16777215 & e3) << 3 | (3 & s3) << 1 | (t3 ? 1 : 0);
+          }
+          dispose() {
+            this._onChange.dispose();
+          }
+          get versions() {
+            return Object.keys(this._providers);
+          }
+          get activeVersion() {
+            return this._active;
+          }
+          set activeVersion(e3) {
+            if (!this._providers[e3]) throw new Error(`unknown Unicode version "${e3}"`);
+            this._active = e3, this._activeProvider = this._providers[e3], this._onChange.fire(e3);
+          }
+          register(e3) {
+            this._providers[e3.version] = e3, this._active || (this.activeVersion = e3.version);
+          }
+          wcwidth(e3) {
+            return this._activeProvider.wcwidth(e3);
+          }
+          getStringCellWidth(e3) {
+            let s3 = 0, t3 = 0;
+            const i3 = e3.length;
+            for (let o = 0; o < i3; ++o) {
+              let n = e3.charCodeAt(o);
+              if (55296 <= n && n <= 56319) {
+                if (++o >= i3) return s3 + this.wcwidth(n);
+                const t4 = e3.charCodeAt(o);
+                56320 <= t4 && t4 <= 57343 ? n = 1024 * (n - 55296) + t4 - 56320 + 65536 : s3 += this.wcwidth(t4);
+              }
+              const d = this.charProperties(n, t3);
+              let c = r.extractWidth(d);
+              r.extractShouldJoin(d) && (c -= r.extractWidth(t3)), s3 += c, t3 = d;
+            }
+            return s3;
+          }
+          charProperties(e3, s3) {
+            return this._activeProvider.charProperties(e3, s3);
+          }
+        }
+        s2.UnicodeService = r;
+      }, 384(e2, s2, t2) {
+        Object.defineProperty(s2, "__esModule", { value: true }), s2.UnicodeV11 = void 0;
+        const i2 = t2(765), r = [[768, 879], [1155, 1161], [1425, 1469], [1471, 1471], [1473, 1474], [1476, 1477], [1479, 1479], [1536, 1541], [1552, 1562], [1564, 1564], [1611, 1631], [1648, 1648], [1750, 1757], [1759, 1764], [1767, 1768], [1770, 1773], [1807, 1807], [1809, 1809], [1840, 1866], [1958, 1968], [2027, 2035], [2045, 2045], [2070, 2073], [2075, 2083], [2085, 2087], [2089, 2093], [2137, 2139], [2259, 2306], [2362, 2362], [2364, 2364], [2369, 2376], [2381, 2381], [2385, 2391], [2402, 2403], [2433, 2433], [2492, 2492], [2497, 2500], [2509, 2509], [2530, 2531], [2558, 2558], [2561, 2562], [2620, 2620], [2625, 2626], [2631, 2632], [2635, 2637], [2641, 2641], [2672, 2673], [2677, 2677], [2689, 2690], [2748, 2748], [2753, 2757], [2759, 2760], [2765, 2765], [2786, 2787], [2810, 2815], [2817, 2817], [2876, 2876], [2879, 2879], [2881, 2884], [2893, 2893], [2902, 2902], [2914, 2915], [2946, 2946], [3008, 3008], [3021, 3021], [3072, 3072], [3076, 3076], [3134, 3136], [3142, 3144], [3146, 3149], [3157, 3158], [3170, 3171], [3201, 3201], [3260, 3260], [3263, 3263], [3270, 3270], [3276, 3277], [3298, 3299], [3328, 3329], [3387, 3388], [3393, 3396], [3405, 3405], [3426, 3427], [3530, 3530], [3538, 3540], [3542, 3542], [3633, 3633], [3636, 3642], [3655, 3662], [3761, 3761], [3764, 3772], [3784, 3789], [3864, 3865], [3893, 3893], [3895, 3895], [3897, 3897], [3953, 3966], [3968, 3972], [3974, 3975], [3981, 3991], [3993, 4028], [4038, 4038], [4141, 4144], [4146, 4151], [4153, 4154], [4157, 4158], [4184, 4185], [4190, 4192], [4209, 4212], [4226, 4226], [4229, 4230], [4237, 4237], [4253, 4253], [4448, 4607], [4957, 4959], [5906, 5908], [5938, 5940], [5970, 5971], [6002, 6003], [6068, 6069], [6071, 6077], [6086, 6086], [6089, 6099], [6109, 6109], [6155, 6158], [6277, 6278], [6313, 6313], [6432, 6434], [6439, 6440], [6450, 6450], [6457, 6459], [6679, 6680], [6683, 6683], [6742, 6742], [6744, 6750], [6752, 6752], [6754, 6754], [6757, 6764], [6771, 6780], [6783, 6783], [6832, 6846], [6912, 6915], [6964, 6964], [6966, 6970], [6972, 6972], [6978, 6978], [7019, 7027], [7040, 7041], [7074, 7077], [7080, 7081], [7083, 7085], [7142, 7142], [7144, 7145], [7149, 7149], [7151, 7153], [7212, 7219], [7222, 7223], [7376, 7378], [7380, 7392], [7394, 7400], [7405, 7405], [7412, 7412], [7416, 7417], [7616, 7673], [7675, 7679], [8203, 8207], [8234, 8238], [8288, 8292], [8294, 8303], [8400, 8432], [11503, 11505], [11647, 11647], [11744, 11775], [12330, 12333], [12441, 12442], [42607, 42610], [42612, 42621], [42654, 42655], [42736, 42737], [43010, 43010], [43014, 43014], [43019, 43019], [43045, 43046], [43204, 43205], [43232, 43249], [43263, 43263], [43302, 43309], [43335, 43345], [43392, 43394], [43443, 43443], [43446, 43449], [43452, 43453], [43493, 43493], [43561, 43566], [43569, 43570], [43573, 43574], [43587, 43587], [43596, 43596], [43644, 43644], [43696, 43696], [43698, 43700], [43703, 43704], [43710, 43711], [43713, 43713], [43756, 43757], [43766, 43766], [44005, 44005], [44008, 44008], [44013, 44013], [64286, 64286], [65024, 65039], [65056, 65071], [65279, 65279], [65529, 65531]], o = [[66045, 66045], [66272, 66272], [66422, 66426], [68097, 68099], [68101, 68102], [68108, 68111], [68152, 68154], [68159, 68159], [68325, 68326], [68900, 68903], [69446, 69456], [69633, 69633], [69688, 69702], [69759, 69761], [69811, 69814], [69817, 69818], [69821, 69821], [69837, 69837], [69888, 69890], [69927, 69931], [69933, 69940], [70003, 70003], [70016, 70017], [70070, 70078], [70089, 70092], [70191, 70193], [70196, 70196], [70198, 70199], [70206, 70206], [70367, 70367], [70371, 70378], [70400, 70401], [70459, 70460], [70464, 70464], [70502, 70508], [70512, 70516], [70712, 70719], [70722, 70724], [70726, 70726], [70750, 70750], [70835, 70840], [70842, 70842], [70847, 70848], [70850, 70851], [71090, 71093], [71100, 71101], [71103, 71104], [71132, 71133], [71219, 71226], [71229, 71229], [71231, 71232], [71339, 71339], [71341, 71341], [71344, 71349], [71351, 71351], [71453, 71455], [71458, 71461], [71463, 71467], [71727, 71735], [71737, 71738], [72148, 72151], [72154, 72155], [72160, 72160], [72193, 72202], [72243, 72248], [72251, 72254], [72263, 72263], [72273, 72278], [72281, 72283], [72330, 72342], [72344, 72345], [72752, 72758], [72760, 72765], [72767, 72767], [72850, 72871], [72874, 72880], [72882, 72883], [72885, 72886], [73009, 73014], [73018, 73018], [73020, 73021], [73023, 73029], [73031, 73031], [73104, 73105], [73109, 73109], [73111, 73111], [73459, 73460], [78896, 78904], [92912, 92916], [92976, 92982], [94031, 94031], [94095, 94098], [113821, 113822], [113824, 113827], [119143, 119145], [119155, 119170], [119173, 119179], [119210, 119213], [119362, 119364], [121344, 121398], [121403, 121452], [121461, 121461], [121476, 121476], [121499, 121503], [121505, 121519], [122880, 122886], [122888, 122904], [122907, 122913], [122915, 122916], [122918, 122922], [123184, 123190], [123628, 123631], [125136, 125142], [125252, 125258], [917505, 917505], [917536, 917631], [917760, 917999]], n = [[4352, 4447], [8986, 8987], [9001, 9002], [9193, 9196], [9200, 9200], [9203, 9203], [9725, 9726], [9748, 9749], [9800, 9811], [9855, 9855], [9875, 9875], [9889, 9889], [9898, 9899], [9917, 9918], [9924, 9925], [9934, 9934], [9940, 9940], [9962, 9962], [9970, 9971], [9973, 9973], [9978, 9978], [9981, 9981], [9989, 9989], [9994, 9995], [10024, 10024], [10060, 10060], [10062, 10062], [10067, 10069], [10071, 10071], [10133, 10135], [10160, 10160], [10175, 10175], [11035, 11036], [11088, 11088], [11093, 11093], [11904, 11929], [11931, 12019], [12032, 12245], [12272, 12283], [12288, 12329], [12334, 12350], [12353, 12438], [12443, 12543], [12549, 12591], [12593, 12686], [12688, 12730], [12736, 12771], [12784, 12830], [12832, 12871], [12880, 19903], [19968, 42124], [42128, 42182], [43360, 43388], [44032, 55203], [63744, 64255], [65040, 65049], [65072, 65106], [65108, 65126], [65128, 65131], [65281, 65376], [65504, 65510]], d = [[94176, 94179], [94208, 100343], [100352, 101106], [110592, 110878], [110928, 110930], [110948, 110951], [110960, 111355], [126980, 126980], [127183, 127183], [127374, 127374], [127377, 127386], [127488, 127490], [127504, 127547], [127552, 127560], [127568, 127569], [127584, 127589], [127744, 127776], [127789, 127797], [127799, 127868], [127870, 127891], [127904, 127946], [127951, 127955], [127968, 127984], [127988, 127988], [127992, 128062], [128064, 128064], [128066, 128252], [128255, 128317], [128331, 128334], [128336, 128359], [128378, 128378], [128405, 128406], [128420, 128420], [128507, 128591], [128640, 128709], [128716, 128716], [128720, 128722], [128725, 128725], [128747, 128748], [128756, 128762], [128992, 129003], [129293, 129393], [129395, 129398], [129402, 129442], [129445, 129450], [129454, 129482], [129485, 129535], [129648, 129651], [129656, 129658], [129664, 129666], [129680, 129685], [131072, 196605], [196608, 262141]];
+        let c;
+        function a(e3, s3) {
+          let t3, i3 = 0, r2 = s3.length - 1;
+          if (e3 < s3[0][0] || e3 > s3[r2][1]) return false;
+          for (; r2 >= i3; ) if (t3 = i3 + r2 >> 1, e3 > s3[t3][1]) i3 = t3 + 1;
+          else {
+            if (!(e3 < s3[t3][0])) return true;
+            r2 = t3 - 1;
+          }
+          return false;
+        }
+        s2.UnicodeV11 = class {
+          constructor() {
+            if (this.version = "11", !c) {
+              c = new Uint8Array(65536), c.fill(1), c[0] = 0, c.fill(0, 1, 32), c.fill(0, 127, 160);
+              for (let e3 = 0; e3 < r.length; ++e3) c.fill(0, r[e3][0], r[e3][1] + 1);
+              for (let e3 = 0; e3 < n.length; ++e3) c.fill(2, n[e3][0], n[e3][1] + 1);
+            }
+          }
+          wcwidth(e3) {
+            return e3 < 32 ? 0 : e3 < 127 ? 1 : e3 < 65536 ? c[e3] : a(e3, o) ? 0 : a(e3, d) ? 2 : 1;
+          }
+          charProperties(e3, s3) {
+            let t3 = this.wcwidth(e3), r2 = 0 === t3 && 0 !== s3;
+            if (r2) {
+              const e4 = i2.UnicodeService.extractWidth(s3);
+              0 === e4 ? r2 = false : e4 > t3 && (t3 = e4);
+            }
+            return i2.UnicodeService.createPropertyValue(0, t3, r2);
+          }
+        };
+      } }, s = {};
+      function t(i2) {
+        var r = s[i2];
+        if (void 0 !== r) return r.exports;
+        var o = s[i2] = { exports: {} };
+        return e[i2](o, o.exports, t), o.exports;
+      }
+      var i = {};
+      return (() => {
+        var e2 = i;
+        Object.defineProperty(e2, "__esModule", { value: true }), e2.Unicode11Addon = void 0;
+        const s2 = t(384);
+        e2.Unicode11Addon = class {
+          activate(e3) {
+            e3.unicode.register(new s2.UnicodeV11());
+          }
+          dispose() {
+          }
+        };
+      })(), i;
+    })());
+  }
+});
+
 // terminal-daemon.ts
 import { fileURLToPath } from "node:url";
 import { parseArgs } from "node:util";
@@ -8611,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";
@@ -8681,13 +8932,212 @@ 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;
+  }
+  chunks = [];
+  /** Index of the oldest chunk still held; earlier slots are dropped. */
+  head = 0;
+  /** Total characters in `chunks[head..]`. */
+  size = 0;
+  get length() {
+    return Math.min(this.size, this.max);
+  }
+  append(data) {
+    if (data.length === 0) return;
+    this.chunks.push(data);
+    this.size += data.length;
+    while (this.size - this.chunks[this.head].length >= this.max) {
+      this.size -= this.chunks[this.head].length;
+      this.head += 1;
+    }
+    if (this.head > 64 && this.head * 2 > this.chunks.length) {
+      this.chunks = this.chunks.slice(this.head);
+      this.head = 0;
+    }
+  }
+  toString() {
+    const joined = this.chunks.slice(this.head).join("");
+    this.chunks = [joined];
+    this.head = 0;
+    return joined.length > this.max ? joined.slice(-this.max) : joined;
+  }
+};
 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) */
@@ -8712,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.
    *
@@ -8738,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) {
@@ -8758,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}`);
@@ -8777,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,
@@ -8796,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;
@@ -8806,6 +9257,8 @@ var TerminalPool = class {
       const { Terminal } = "Terminal" in headlessNs ? headlessNs : headlessNs.default;
       const serializeNs = await Promise.resolve().then(() => __toESM(require_addon_serialize(), 1));
       const { SerializeAddon } = "SerializeAddon" in serializeNs ? serializeNs : serializeNs.default;
+      const unicode11Ns = await Promise.resolve().then(() => __toESM(require_addon_unicode11(), 1));
+      const { Unicode11Addon } = "Unicode11Addon" in unicode11Ns ? unicode11Ns : unicode11Ns.default;
       headless = new Terminal({
         cols: 80,
         rows: 24,
@@ -8814,24 +9267,43 @@ var TerminalPool = class {
       });
       serializeAddon = new SerializeAddon();
       headless.loadAddon(serializeAddon);
+      headless.loadAddon(
+        new Unicode11Addon()
+      );
+      headless.unicode.activeVersion = "11";
     } 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 = {
       pty: ptyProcess,
-      scrollback: "",
+      scrollback: new OutputTail(MAX_SCROLLBACK_SIZE),
       headless,
       serializeAddon,
       workspaceId,
       seq: 0,
-      cleanupOnExit: extras?.cleanupOnExit ?? false
+      holds: 0,
+      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) {
@@ -8840,10 +9312,7 @@ var TerminalPool = class {
     }
     ids.add(terminalId);
     ptyProcess.onData((data) => {
-      session.scrollback += data;
-      if (session.scrollback.length > MAX_SCROLLBACK_SIZE) {
-        session.scrollback = session.scrollback.slice(-MAX_SCROLLBACK_SIZE);
-      }
+      session.scrollback.append(data);
       session.headless.write(data);
       session.seq += 1;
       const seq = session.seq;
@@ -8856,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);
@@ -8875,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,
@@ -8887,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.
@@ -8924,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)
       );
@@ -8947,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;
@@ -9085,8 +9636,9 @@ var TerminalPool = class {
   getScrollback(terminalId, lines) {
     const session = this.terminals.get(terminalId);
     if (!session) return null;
-    if (lines == null) return session.scrollback;
-    const allLines = session.scrollback.split("\n");
+    const scrollback = session.scrollback.toString();
+    if (lines == null) return scrollback;
+    const allLines = scrollback.split("\n");
     return allLines.slice(-lines).join("\n");
   }
   /**
@@ -9129,7 +9681,7 @@ var TerminalPool = class {
     const session = this.terminals.get(terminalId);
     if (!session) return null;
     if (session.scrollback.length === 0) return { data: "", seq: session.seq };
-    session.pty.pause();
+    this.holdOutput(terminalId);
     let deathWatch;
     let drainCap;
     try {
@@ -9147,9 +9699,27 @@ var TerminalPool = class {
     } finally {
       if (deathWatch) clearInterval(deathWatch);
       if (drainCap) clearTimeout(drainCap);
-      if (this.terminals.get(terminalId) === session) session.pty.resume();
+      if (this.terminals.get(terminalId) === session) this.releaseOutput(terminalId);
     }
   }
+  /**
+   * Stop reading the terminal's PTY until a matching {@link releaseOutput}.
+   * The shell blocks once the kernel's PTY buffer fills, so a flood stops at
+   * its source instead of piling up in memory. Holds nest.
+   */
+  holdOutput(terminalId) {
+    const session = this.terminals.get(terminalId);
+    if (!session) return;
+    session.holds += 1;
+    if (session.holds === 1) session.pty.pause();
+  }
+  /** Undo one {@link holdOutput}; the PTY resumes when the last is released. */
+  releaseOutput(terminalId) {
+    const session = this.terminals.get(terminalId);
+    if (!session || session.holds === 0) return;
+    session.holds -= 1;
+    if (session.holds === 0) session.pty.resume();
+  }
   /**
    * Writes data to a terminal's PTY stdin.
    * Returns false if the terminal is not found.
@@ -9181,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) {
@@ -9224,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);
@@ -9233,6 +9804,8 @@ var TerminalPool = class {
           this.workspaceTerminals.delete(session.workspaceId);
         }
       }
+    } else {
+      this.historyStore?.removeSession(terminalId);
     }
   }
   /**
@@ -9240,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).
@@ -9261,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";
@@ -9271,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) {
@@ -9310,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 {
@@ -9370,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" };
@@ -9379,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";
@@ -9407,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)}
@@ -9483,18 +10080,26 @@ 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;
 var INITIAL_ADOPTION_MS = 2 * 6e4;
 var MAX_STREAM_BACKLOG_BYTES = 64 * 1024 * 1024;
+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;
@@ -9526,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);
@@ -9545,10 +10150,11 @@ 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);
+      client.held.delete(event.terminalId);
       send(client, "stream", { t: "exit", ...event });
     }
     reevaluateIdle();
@@ -9560,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) {
@@ -9571,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();
       });
     }
@@ -9604,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);
@@ -9617,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);
@@ -9655,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);
@@ -9681,7 +10287,14 @@ async function runDaemon(options) {
   function registerClient(clientId, role, socket) {
     let client = clients.get(clientId);
     if (!client) {
-      client = { id: clientId, control: null, stream: null, attached: /* @__PURE__ */ new Map() };
+      client = {
+        id: clientId,
+        control: null,
+        stream: null,
+        attached: /* @__PURE__ */ new Map(),
+        held: /* @__PURE__ */ new Set(),
+        sentSinceEmpty: /* @__PURE__ */ new Map()
+      };
       clients.set(clientId, client);
     }
     if (client[role]) return null;
@@ -9698,6 +10311,7 @@ async function runDaemon(options) {
     clients.delete(client.id);
     for (const unsubscribe of client.attached.values()) unsubscribe();
     client.attached.clear();
+    releaseHolds(client);
     client.control?.destroy();
     client.stream?.destroy();
     if (clients.size === 0) retirementRequested = true;
@@ -9707,12 +10321,31 @@ 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;
     }
     writeFrame(socket, message);
   }
+  function sendOutput(client, terminalId, seq, d) {
+    const socket = client.stream;
+    if (socket && socket.writableLength === 0) client.sentSinceEmpty.clear();
+    send(client, "stream", { t: "data", id: terminalId, seq, d });
+    if (!socket || socket.destroyed || clients.get(client.id) !== client) return;
+    const sent = (client.sentSinceEmpty.get(terminalId) ?? 0) + d.length;
+    client.sentSinceEmpty.set(terminalId, sent);
+    if (socket.writableLength < STREAM_HOLD_BYTES || sent <= SMALL_SESSION_CHARS || client.held.has(terminalId)) {
+      return;
+    }
+    client.held.add(terminalId);
+    pool.holdOutput(terminalId);
+    if (client.held.size === 1) socket.once("drain", () => releaseHolds(client));
+  }
+  function releaseHolds(client) {
+    for (const terminalId of client.held) pool.releaseOutput(terminalId);
+    client.held.clear();
+    client.sentSinceEmpty.clear();
+  }
   function handleControl(client, frame) {
     const message = frame;
     if (!hasValidIds(frame)) {
@@ -9750,6 +10383,7 @@ async function runDaemon(options) {
         const unsubscribe = client.attached.get(message.terminalId);
         client.attached.delete(message.terminalId);
         unsubscribe?.();
+        if (client.held.delete(message.terminalId)) pool.releaseOutput(message.terminalId);
         return;
       }
       case "shutdown":
@@ -9807,7 +10441,7 @@ async function runDaemon(options) {
     const attached = await pool.attach(
       terminalId,
       dims,
-      (d, seq) => send(client, "stream", { t: "data", id: terminalId, seq, d })
+      (d, seq) => sendOutput(client, terminalId, seq, d)
     );
     if (!attached) return null;
     if (client.attached.has(terminalId) || clients.get(client.id) !== client) {
@@ -9855,7 +10489,7 @@ function writePrivateFile(path, content) {
 function copyPrivateFile(from, to) {
   let content;
   try {
-    content = readFileSync(from, "utf8");
+    content = readFileSync2(from, "utf8");
   } catch {
     return;
   }
@@ -9890,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: {
@@ -9906,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({