@factiii/runner 0.9.0 → 0.9.2

package/dist/cli.js

@@ -961,7 +961,7 @@ var require_suggestSimilar = __commonJS({
 // node_modules/commander/lib/command.js
 var require_command = __commonJS({
   "node_modules/commander/lib/command.js"(exports2) {
-    var EventEmitter = require("node:events").EventEmitter;
+    var EventEmitter2 = require("node:events").EventEmitter;
     var childProcess = require("node:child_process");
     var path15 = require("node:path");
     var fs13 = require("node:fs");
@@ -971,7 +971,7 @@ var require_command = __commonJS({
     var { Help: Help2 } = require_help();
     var { Option: Option2, DualOptions } = require_option();
     var { suggestSimilar } = require_suggestSimilar();
-    var Command2 = class _Command extends EventEmitter {
+    var Command2 = class _Command extends EventEmitter2 {
       /**
        * Initialize a new `Command`.
        *
@@ -6503,13 +6503,13 @@ var require_extension = __commonJS({
 var require_websocket = __commonJS({
   "../../node_modules/ws/lib/websocket.js"(exports2, module2) {
     "use strict";
-    var EventEmitter = require("events");
+    var EventEmitter2 = require("events");
     var https = require("https");
     var http = require("http");
     var net2 = require("net");
     var tls = require("tls");
     var { randomBytes, createHash: createHash2 } = require("crypto");
-    var { Duplex, Readable } = require("stream");
+    var { Duplex, Readable: Readable2 } = require("stream");
     var { URL: URL2 } = require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
     var Receiver2 = require_receiver();
@@ -6535,7 +6535,7 @@ var require_websocket = __commonJS({
     var protocolVersions = [8, 13];
     var readyStates = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
     var subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
-    var WebSocket2 = class _WebSocket extends EventEmitter {
+    var WebSocket2 = class _WebSocket extends EventEmitter2 {
       /**
        * Create a new `WebSocket`.
        *
@@ -7457,7 +7457,7 @@ var require_stream = __commonJS({
       };
       duplex._final = function(callback) {
         if (ws.readyState === ws.CONNECTING) {
-          ws.once("open", function open() {
+          ws.once("open", function open2() {
             duplex._final(callback);
           });
           return;
@@ -7478,7 +7478,7 @@ var require_stream = __commonJS({
       };
       duplex._write = function(chunk, encoding, callback) {
         if (ws.readyState === ws.CONNECTING) {
-          ws.once("open", function open() {
+          ws.once("open", function open2() {
             duplex._write(chunk, encoding, callback);
           });
           return;
@@ -7542,7 +7542,7 @@ var require_subprotocol = __commonJS({
 var require_websocket_server = __commonJS({
   "../../node_modules/ws/lib/websocket-server.js"(exports2, module2) {
     "use strict";
-    var EventEmitter = require("events");
+    var EventEmitter2 = require("events");
     var http = require("http");
     var { Duplex } = require("stream");
     var { createHash: createHash2 } = require("crypto");
@@ -7555,7 +7555,7 @@ var require_websocket_server = __commonJS({
     var RUNNING = 0;
     var CLOSING = 1;
     var CLOSED = 2;
-    var WebSocketServer2 = class extends EventEmitter {
+    var WebSocketServer2 = class extends EventEmitter2 {
       /**
        * Create a `WebSocketServer` instance.
        *
@@ -7967,10 +7967,10 @@ function prompt(msg) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve2) => {
+  return new Promise((resolve4) => {
     rl.question(msg, (answer) => {
       rl.close();
-      resolve2(answer.trim());
+      resolve4(answer.trim());
     });
   });
 }
@@ -8779,11 +8779,11 @@ function promptPassword(label) {
   rl._writeToOutput = (text) => {
     if (!muted) write(text);
   };
-  return new Promise((resolve2) => {
+  return new Promise((resolve4) => {
     rl.question(label, (answer) => {
       rl.close();
       process.stdout.write("\n");
-      resolve2(answer);
+      resolve4(answer);
     });
     muted = true;
   });
@@ -13603,7 +13603,7 @@ async function markOnboardingComplete(target) {
   await target.sh(`node -e "${script}"`);
 }
 function runAgentProc(proc, prompt2, stream, label, errorPrefix) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve4, reject) => {
     let errorOutput = "";
     proc.stderr?.on("data", (chunk) => {
       errorOutput += chunk.toString();
@@ -13618,7 +13618,7 @@ function runAgentProc(proc, prompt2, stream, label, errorPrefix) {
       } else if (code !== 0 && !text) {
         reject(new Error(errorOutput || `${label} exited with code ${code}`));
       } else {
-        resolve2({ text, sessionId });
+        resolve4({ text, sessionId });
       }
     });
     proc.on("error", (err) => {
@@ -13767,8 +13767,14 @@ function hostSpacePaths(spaceDir) {
     bin: import_path6.default.join(spaceDir, "bin")
   };
 }
-function worktreeFor(paths, taskId) {
-  return `${paths.worktrees}/${taskId.replace(/[^a-zA-Z0-9._-]/g, "_")}`;
+function worktreeFor(paths, workName) {
+  return `${paths.worktrees}/${workName.replace(/[^a-zA-Z0-9._-]/g, "_")}`;
+}
+
+// ../../shared/all/helpers/board-agent-core/workName.ts
+var WORK_NAME_MAX = 48;
+function slugifyWorkName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, WORK_NAME_MAX).replace(/^-+|-+$/g, "");
 }
 
 // ../../shared/all/helpers/board-agent-core/git.ts
@@ -13784,8 +13790,37 @@ function buildCloneUrl(repoUrl, githubToken) {
 async function gitInDir(target, workdir, ...args) {
   return target.run(["git", "-C", workdir, ...args]);
 }
-function cardWorkBranch(taskId) {
-  return `factiii/card-${taskId.replace(/[^a-zA-Z0-9._-]/g, "-")}`;
+var WORK_BRANCH_PREFIX = "factiii/card-";
+function cardWorkBranch(workName) {
+  return `${WORK_BRANCH_PREFIX}${workName.replace(/[^a-zA-Z0-9._-]/g, "-")}`;
+}
+async function listWorkNames(target) {
+  const dirs = await target.sh(`ls -1 ${target.paths.worktrees} 2>/dev/null || true`).catch(() => "");
+  const branches = await gitInDir(
+    target,
+    target.paths.repo,
+    "for-each-ref",
+    "--format=%(refname:short)",
+    "refs/heads/"
+  ).catch(() => "");
+  const names = new Set(dirs.split("\n").map((line) => line.trim()));
+  for (const line of branches.split("\n")) {
+    const name = line.trim();
+    if (name.startsWith(WORK_BRANCH_PREFIX)) {
+      names.add(name.slice(WORK_BRANCH_PREFIX.length));
+    }
+  }
+  names.delete("");
+  return [...names];
+}
+async function claimWorkName(target, desired, extraTaken = []) {
+  const name = slugifyWorkName(desired);
+  if (!name) throw new Error("Name this terminal before starting it.");
+  const taken = /* @__PURE__ */ new Set([...await listWorkNames(target), ...extraTaken]);
+  if (taken.has(name)) {
+    throw new Error(`"${name}" is already in use. Pick another name.`);
+  }
+  return name;
 }
 async function ensurePrimaryClone(target, cloneUrl, branch) {
   const repo = target.paths.repo;
@@ -13807,9 +13842,9 @@ async function ensurePrimaryClone(target, cloneUrl, branch) {
   });
   await target.sh(`mkdir -p ${target.paths.worktrees}`);
 }
-async function addWorktree(target, taskId, baseBranch) {
-  const path15 = worktreeFor(target.paths, taskId);
-  const branch = cardWorkBranch(taskId);
+async function addWorktree(target, workName, baseBranch) {
+  const path15 = worktreeFor(target.paths, workName);
+  const branch = cardWorkBranch(workName);
   await removeWorktree(target, path15).catch(() => {
   });
   await gitInDir(
@@ -14066,14 +14101,14 @@ function killTree(proc, signal = "SIGKILL") {
 function execLogin(command, opts) {
   const [bin, args] = isWindows ? ["bash", ["-c", command]] : [process.env.SHELL || "/bin/bash", ["-lc", command]];
   const cap = opts.maxBuffer ?? 4 * 1024 * 1024;
-  return new Promise((resolve2) => {
+  return new Promise((resolve4) => {
     let output = "";
     let settled = false;
     const done = (code, extra = "") => {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      resolve2({ code, output: (output + extra).slice(-cap) });
+      resolve4({ code, output: (output + extra).slice(-cap) });
     };
     let proc;
     try {
@@ -14143,7 +14178,7 @@ async function allocateSpacePorts(spaceDir) {
   const ports = [];
   const seen = /* @__PURE__ */ new Set();
   while (ports.length < NUM_PORTS) {
-    const port = await new Promise((resolve2, reject) => {
+    const port = await new Promise((resolve4, reject) => {
       const srv = import_net.default.createServer();
       srv.unref();
       srv.on("error", reject);
@@ -14151,7 +14186,7 @@ async function allocateSpacePorts(spaceDir) {
         const addr = srv.address();
         if (typeof addr === "object" && addr) {
           const p = addr.port;
-          srv.close(() => resolve2(p));
+          srv.close(() => resolve4(p));
         } else {
           srv.close(() => reject(new Error("Failed to get a free port")));
         }
@@ -14221,7 +14256,7 @@ function hostTarget(spaceDir, extraEnv) {
     async runWithStdin(argv, input, label) {
       const [bin, ...rest] = argv;
       const env = await spawnEnv();
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve4, reject) => {
         const proc = (0, import_child_process4.spawn)(bin, rest, { cwd: usableCwd(paths.root), env });
         let stderr = "";
         proc.stderr?.on("data", (d) => {
@@ -14229,7 +14264,7 @@ function hostTarget(spaceDir, extraEnv) {
         });
         proc.on("error", reject);
         proc.on("close", (code) => {
-          if (code === 0) resolve2();
+          if (code === 0) resolve4();
           else reject(new Error(`${label}: ${stderr.trim()}`));
         });
         proc.stdin?.on("error", () => {
@@ -14398,6 +14433,9 @@ function createEventSink(send, spaceSlug, notify) {
     },
     emitDeployEnv(payload) {
       send(channel("deploy-env"), payload);
+    },
+    emitBareFsChange(postId, change) {
+      send(channel(`bare-fs:${postId}`), change);
     }
   };
 }
@@ -14779,8 +14817,8 @@ var ClaudeModeEngine = class _ClaudeModeEngine {
       "system",
       "The agent has a question - waiting for your input."
     );
-    const answer = await new Promise((resolve2) => {
-      session.answerResolver = resolve2;
+    const answer = await new Promise((resolve4) => {
+      session.answerResolver = resolve4;
     });
     if (this.stopped(session)) return;
     session.phase = "research";
@@ -15239,6 +15277,18 @@ ${buildPrompt(prompts_default.implement)}`;
   }
 };
 
+// ../../shared/all/helpers/terminal-ai/terminal-mode.ts
+var import_crypto4 = require("crypto");
+
+// ../../shared/all/helpers/board-agent-core/boardTerminal.ts
+function boardTerminalKey(spaceSlug) {
+  return `board-${spaceSlug}`;
+}
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isCardPostId(id) {
+  return UUID_RE.test(id);
+}
+
 // ../../shared/all/helpers/board-agent-core/tmux.ts
 var TMUX_CONF = [
   // Wheel scrolls, drag selects in copy mode.
@@ -15328,6 +15378,1865 @@ async function startTmuxSession(opts) {
   };
 }
 
+// ../../node_modules/chokidar/esm/index.js
+var import_fs8 = require("fs");
+var import_promises5 = require("fs/promises");
+var import_events = require("events");
+var sysPath2 = __toESM(require("path"), 1);
+
+// ../../node_modules/readdirp/esm/index.js
+var import_promises3 = require("node:fs/promises");
+var import_node_stream = require("node:stream");
+var import_node_path = require("node:path");
+var EntryTypes = {
+  FILE_TYPE: "files",
+  DIR_TYPE: "directories",
+  FILE_DIR_TYPE: "files_directories",
+  EVERYTHING_TYPE: "all"
+};
+var defaultOptions = {
+  root: ".",
+  fileFilter: (_entryInfo) => true,
+  directoryFilter: (_entryInfo) => true,
+  type: EntryTypes.FILE_TYPE,
+  lstat: false,
+  depth: 2147483648,
+  alwaysStat: false,
+  highWaterMark: 4096
+};
+Object.freeze(defaultOptions);
+var RECURSIVE_ERROR_CODE = "READDIRP_RECURSIVE_ERROR";
+var NORMAL_FLOW_ERRORS = /* @__PURE__ */ new Set(["ENOENT", "EPERM", "EACCES", "ELOOP", RECURSIVE_ERROR_CODE]);
+var ALL_TYPES = [
+  EntryTypes.DIR_TYPE,
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE,
+  EntryTypes.FILE_TYPE
+];
+var DIR_TYPES = /* @__PURE__ */ new Set([
+  EntryTypes.DIR_TYPE,
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE
+]);
+var FILE_TYPES = /* @__PURE__ */ new Set([
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE,
+  EntryTypes.FILE_TYPE
+]);
+var isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);
+var wantBigintFsStats = process.platform === "win32";
+var emptyFn = (_entryInfo) => true;
+var normalizeFilter = (filter) => {
+  if (filter === void 0)
+    return emptyFn;
+  if (typeof filter === "function")
+    return filter;
+  if (typeof filter === "string") {
+    const fl = filter.trim();
+    return (entry) => entry.basename === fl;
+  }
+  if (Array.isArray(filter)) {
+    const trItems = filter.map((item) => item.trim());
+    return (entry) => trItems.some((f) => entry.basename === f);
+  }
+  return emptyFn;
+};
+var ReaddirpStream = class extends import_node_stream.Readable {
+  constructor(options = {}) {
+    super({
+      objectMode: true,
+      autoDestroy: true,
+      highWaterMark: options.highWaterMark
+    });
+    const opts = { ...defaultOptions, ...options };
+    const { root, type } = opts;
+    this._fileFilter = normalizeFilter(opts.fileFilter);
+    this._directoryFilter = normalizeFilter(opts.directoryFilter);
+    const statMethod = opts.lstat ? import_promises3.lstat : import_promises3.stat;
+    if (wantBigintFsStats) {
+      this._stat = (path15) => statMethod(path15, { bigint: true });
+    } else {
+      this._stat = statMethod;
+    }
+    this._maxDepth = opts.depth ?? defaultOptions.depth;
+    this._wantsDir = type ? DIR_TYPES.has(type) : false;
+    this._wantsFile = type ? FILE_TYPES.has(type) : false;
+    this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
+    this._root = (0, import_node_path.resolve)(root);
+    this._isDirent = !opts.alwaysStat;
+    this._statsProp = this._isDirent ? "dirent" : "stats";
+    this._rdOptions = { encoding: "utf8", withFileTypes: this._isDirent };
+    this.parents = [this._exploreDir(root, 1)];
+    this.reading = false;
+    this.parent = void 0;
+  }
+  async _read(batch) {
+    if (this.reading)
+      return;
+    this.reading = true;
+    try {
+      while (!this.destroyed && batch > 0) {
+        const par = this.parent;
+        const fil = par && par.files;
+        if (fil && fil.length > 0) {
+          const { path: path15, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path15));
+          const awaited = await Promise.all(slice);
+          for (const entry of awaited) {
+            if (!entry)
+              continue;
+            if (this.destroyed)
+              return;
+            const entryType = await this._getEntryType(entry);
+            if (entryType === "directory" && this._directoryFilter(entry)) {
+              if (depth <= this._maxDepth) {
+                this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+              }
+              if (this._wantsDir) {
+                this.push(entry);
+                batch--;
+              }
+            } else if ((entryType === "file" || this._includeAsFile(entry)) && this._fileFilter(entry)) {
+              if (this._wantsFile) {
+                this.push(entry);
+                batch--;
+              }
+            }
+          }
+        } else {
+          const parent = this.parents.pop();
+          if (!parent) {
+            this.push(null);
+            break;
+          }
+          this.parent = await parent;
+          if (this.destroyed)
+            return;
+        }
+      }
+    } catch (error) {
+      this.destroy(error);
+    } finally {
+      this.reading = false;
+    }
+  }
+  async _exploreDir(path15, depth) {
+    let files;
+    try {
+      files = await (0, import_promises3.readdir)(path15, this._rdOptions);
+    } catch (error) {
+      this._onError(error);
+    }
+    return { files, depth, path: path15 };
+  }
+  async _formatEntry(dirent, path15) {
+    let entry;
+    const basename3 = this._isDirent ? dirent.name : dirent;
+    try {
+      const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path15, basename3));
+      entry = { path: (0, import_node_path.relative)(this._root, fullPath), fullPath, basename: basename3 };
+      entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+    } catch (err) {
+      this._onError(err);
+      return;
+    }
+    return entry;
+  }
+  _onError(err) {
+    if (isNormalFlowError(err) && !this.destroyed) {
+      this.emit("warn", err);
+    } else {
+      this.destroy(err);
+    }
+  }
+  async _getEntryType(entry) {
+    if (!entry && this._statsProp in entry) {
+      return "";
+    }
+    const stats = entry[this._statsProp];
+    if (stats.isFile())
+      return "file";
+    if (stats.isDirectory())
+      return "directory";
+    if (stats && stats.isSymbolicLink()) {
+      const full = entry.fullPath;
+      try {
+        const entryRealPath = await (0, import_promises3.realpath)(full);
+        const entryRealPathStats = await (0, import_promises3.lstat)(entryRealPath);
+        if (entryRealPathStats.isFile()) {
+          return "file";
+        }
+        if (entryRealPathStats.isDirectory()) {
+          const len = entryRealPath.length;
+          if (full.startsWith(entryRealPath) && full.substr(len, 1) === import_node_path.sep) {
+            const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
+            recursiveError.code = RECURSIVE_ERROR_CODE;
+            return this._onError(recursiveError);
+          }
+          return "directory";
+        }
+      } catch (error) {
+        this._onError(error);
+        return "";
+      }
+    }
+  }
+  _includeAsFile(entry) {
+    const stats = entry && entry[this._statsProp];
+    return stats && this._wantsEverything && !stats.isDirectory();
+  }
+};
+function readdirp(root, options = {}) {
+  let type = options.entryType || options.type;
+  if (type === "both")
+    type = EntryTypes.FILE_DIR_TYPE;
+  if (type)
+    options.type = type;
+  if (!root) {
+    throw new Error("readdirp: root argument is required. Usage: readdirp(root, options)");
+  } else if (typeof root !== "string") {
+    throw new TypeError("readdirp: root argument must be a string. Usage: readdirp(root, options)");
+  } else if (type && !ALL_TYPES.includes(type)) {
+    throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(", ")}`);
+  }
+  options.root = root;
+  return new ReaddirpStream(options);
+}
+
+// ../../node_modules/chokidar/esm/handler.js
+var import_fs7 = require("fs");
+var import_promises4 = require("fs/promises");
+var sysPath = __toESM(require("path"), 1);
+var import_os4 = require("os");
+var STR_DATA = "data";
+var STR_END = "end";
+var STR_CLOSE = "close";
+var EMPTY_FN = () => {
+};
+var pl = process.platform;
+var isWindows2 = pl === "win32";
+var isMacos = pl === "darwin";
+var isLinux = pl === "linux";
+var isFreeBSD = pl === "freebsd";
+var isIBMi = (0, import_os4.type)() === "OS400";
+var EVENTS = {
+  ALL: "all",
+  READY: "ready",
+  ADD: "add",
+  CHANGE: "change",
+  ADD_DIR: "addDir",
+  UNLINK: "unlink",
+  UNLINK_DIR: "unlinkDir",
+  RAW: "raw",
+  ERROR: "error"
+};
+var EV = EVENTS;
+var THROTTLE_MODE_WATCH = "watch";
+var statMethods = { lstat: import_promises4.lstat, stat: import_promises4.stat };
+var KEY_LISTENERS = "listeners";
+var KEY_ERR = "errHandlers";
+var KEY_RAW = "rawEmitters";
+var HANDLER_KEYS = [KEY_LISTENERS, KEY_ERR, KEY_RAW];
+var binaryExtensions = /* @__PURE__ */ new Set([
+  "3dm",
+  "3ds",
+  "3g2",
+  "3gp",
+  "7z",
+  "a",
+  "aac",
+  "adp",
+  "afdesign",
+  "afphoto",
+  "afpub",
+  "ai",
+  "aif",
+  "aiff",
+  "alz",
+  "ape",
+  "apk",
+  "appimage",
+  "ar",
+  "arj",
+  "asf",
+  "au",
+  "avi",
+  "bak",
+  "baml",
+  "bh",
+  "bin",
+  "bk",
+  "bmp",
+  "btif",
+  "bz2",
+  "bzip2",
+  "cab",
+  "caf",
+  "cgm",
+  "class",
+  "cmx",
+  "cpio",
+  "cr2",
+  "cur",
+  "dat",
+  "dcm",
+  "deb",
+  "dex",
+  "djvu",
+  "dll",
+  "dmg",
+  "dng",
+  "doc",
+  "docm",
+  "docx",
+  "dot",
+  "dotm",
+  "dra",
+  "DS_Store",
+  "dsk",
+  "dts",
+  "dtshd",
+  "dvb",
+  "dwg",
+  "dxf",
+  "ecelp4800",
+  "ecelp7470",
+  "ecelp9600",
+  "egg",
+  "eol",
+  "eot",
+  "epub",
+  "exe",
+  "f4v",
+  "fbs",
+  "fh",
+  "fla",
+  "flac",
+  "flatpak",
+  "fli",
+  "flv",
+  "fpx",
+  "fst",
+  "fvt",
+  "g3",
+  "gh",
+  "gif",
+  "graffle",
+  "gz",
+  "gzip",
+  "h261",
+  "h263",
+  "h264",
+  "icns",
+  "ico",
+  "ief",
+  "img",
+  "ipa",
+  "iso",
+  "jar",
+  "jpeg",
+  "jpg",
+  "jpgv",
+  "jpm",
+  "jxr",
+  "key",
+  "ktx",
+  "lha",
+  "lib",
+  "lvp",
+  "lz",
+  "lzh",
+  "lzma",
+  "lzo",
+  "m3u",
+  "m4a",
+  "m4v",
+  "mar",
+  "mdi",
+  "mht",
+  "mid",
+  "midi",
+  "mj2",
+  "mka",
+  "mkv",
+  "mmr",
+  "mng",
+  "mobi",
+  "mov",
+  "movie",
+  "mp3",
+  "mp4",
+  "mp4a",
+  "mpeg",
+  "mpg",
+  "mpga",
+  "mxu",
+  "nef",
+  "npx",
+  "numbers",
+  "nupkg",
+  "o",
+  "odp",
+  "ods",
+  "odt",
+  "oga",
+  "ogg",
+  "ogv",
+  "otf",
+  "ott",
+  "pages",
+  "pbm",
+  "pcx",
+  "pdb",
+  "pdf",
+  "pea",
+  "pgm",
+  "pic",
+  "png",
+  "pnm",
+  "pot",
+  "potm",
+  "potx",
+  "ppa",
+  "ppam",
+  "ppm",
+  "pps",
+  "ppsm",
+  "ppsx",
+  "ppt",
+  "pptm",
+  "pptx",
+  "psd",
+  "pya",
+  "pyc",
+  "pyo",
+  "pyv",
+  "qt",
+  "rar",
+  "ras",
+  "raw",
+  "resources",
+  "rgb",
+  "rip",
+  "rlc",
+  "rmf",
+  "rmvb",
+  "rpm",
+  "rtf",
+  "rz",
+  "s3m",
+  "s7z",
+  "scpt",
+  "sgi",
+  "shar",
+  "snap",
+  "sil",
+  "sketch",
+  "slk",
+  "smv",
+  "snk",
+  "so",
+  "stl",
+  "suo",
+  "sub",
+  "swf",
+  "tar",
+  "tbz",
+  "tbz2",
+  "tga",
+  "tgz",
+  "thmx",
+  "tif",
+  "tiff",
+  "tlz",
+  "ttc",
+  "ttf",
+  "txz",
+  "udf",
+  "uvh",
+  "uvi",
+  "uvm",
+  "uvp",
+  "uvs",
+  "uvu",
+  "viv",
+  "vob",
+  "war",
+  "wav",
+  "wax",
+  "wbmp",
+  "wdp",
+  "weba",
+  "webm",
+  "webp",
+  "whl",
+  "wim",
+  "wm",
+  "wma",
+  "wmv",
+  "wmx",
+  "woff",
+  "woff2",
+  "wrm",
+  "wvx",
+  "xbm",
+  "xif",
+  "xla",
+  "xlam",
+  "xls",
+  "xlsb",
+  "xlsm",
+  "xlsx",
+  "xlt",
+  "xltm",
+  "xltx",
+  "xm",
+  "xmind",
+  "xpi",
+  "xpm",
+  "xwd",
+  "xz",
+  "z",
+  "zip",
+  "zipx"
+]);
+var isBinaryPath = (filePath) => binaryExtensions.has(sysPath.extname(filePath).slice(1).toLowerCase());
+var foreach = (val, fn) => {
+  if (val instanceof Set) {
+    val.forEach(fn);
+  } else {
+    fn(val);
+  }
+};
+var addAndConvert = (main, prop, item) => {
+  let container = main[prop];
+  if (!(container instanceof Set)) {
+    main[prop] = container = /* @__PURE__ */ new Set([container]);
+  }
+  container.add(item);
+};
+var clearItem = (cont) => (key) => {
+  const set = cont[key];
+  if (set instanceof Set) {
+    set.clear();
+  } else {
+    delete cont[key];
+  }
+};
+var delFromSet = (main, prop, item) => {
+  const container = main[prop];
+  if (container instanceof Set) {
+    container.delete(item);
+  } else if (container === item) {
+    delete main[prop];
+  }
+};
+var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
+var FsWatchInstances = /* @__PURE__ */ new Map();
+function createFsWatchInstance(path15, options, listener, errHandler, emitRaw) {
+  const handleEvent = (rawEvent, evPath) => {
+    listener(path15);
+    emitRaw(rawEvent, evPath, { watchedPath: path15 });
+    if (evPath && path15 !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path15, evPath), KEY_LISTENERS, sysPath.join(path15, evPath));
+    }
+  };
+  try {
+    return (0, import_fs7.watch)(path15, {
+      persistent: options.persistent
+    }, handleEvent);
+  } catch (error) {
+    errHandler(error);
+    return void 0;
+  }
+}
+var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
+  const cont = FsWatchInstances.get(fullPath);
+  if (!cont)
+    return;
+  foreach(cont[listenerType], (listener) => {
+    listener(val1, val2, val3);
+  });
+};
+var setFsWatchListener = (path15, fullPath, options, handlers) => {
+  const { listener, errHandler, rawEmitter } = handlers;
+  let cont = FsWatchInstances.get(fullPath);
+  let watcher;
+  if (!options.persistent) {
+    watcher = createFsWatchInstance(path15, options, listener, errHandler, rawEmitter);
+    if (!watcher)
+      return;
+    return watcher.close.bind(watcher);
+  }
+  if (cont) {
+    addAndConvert(cont, KEY_LISTENERS, listener);
+    addAndConvert(cont, KEY_ERR, errHandler);
+    addAndConvert(cont, KEY_RAW, rawEmitter);
+  } else {
+    watcher = createFsWatchInstance(
+      path15,
+      options,
+      fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
+      errHandler,
+      // no need to use broadcast here
+      fsWatchBroadcast.bind(null, fullPath, KEY_RAW)
+    );
+    if (!watcher)
+      return;
+    watcher.on(EV.ERROR, async (error) => {
+      const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
+      if (cont)
+        cont.watcherUnusable = true;
+      if (isWindows2 && error.code === "EPERM") {
+        try {
+          const fd = await (0, import_promises4.open)(path15, "r");
+          await fd.close();
+          broadcastErr(error);
+        } catch (err) {
+        }
+      } else {
+        broadcastErr(error);
+      }
+    });
+    cont = {
+      listeners: listener,
+      errHandlers: errHandler,
+      rawEmitters: rawEmitter,
+      watcher
+    };
+    FsWatchInstances.set(fullPath, cont);
+  }
+  return () => {
+    delFromSet(cont, KEY_LISTENERS, listener);
+    delFromSet(cont, KEY_ERR, errHandler);
+    delFromSet(cont, KEY_RAW, rawEmitter);
+    if (isEmptySet(cont.listeners)) {
+      cont.watcher.close();
+      FsWatchInstances.delete(fullPath);
+      HANDLER_KEYS.forEach(clearItem(cont));
+      cont.watcher = void 0;
+      Object.freeze(cont);
+    }
+  };
+};
+var FsWatchFileInstances = /* @__PURE__ */ new Map();
+var setFsWatchFileListener = (path15, fullPath, options, handlers) => {
+  const { listener, rawEmitter } = handlers;
+  let cont = FsWatchFileInstances.get(fullPath);
+  const copts = cont && cont.options;
+  if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
+    (0, import_fs7.unwatchFile)(fullPath);
+    cont = void 0;
+  }
+  if (cont) {
+    addAndConvert(cont, KEY_LISTENERS, listener);
+    addAndConvert(cont, KEY_RAW, rawEmitter);
+  } else {
+    cont = {
+      listeners: listener,
+      rawEmitters: rawEmitter,
+      options,
+      watcher: (0, import_fs7.watchFile)(fullPath, options, (curr, prev) => {
+        foreach(cont.rawEmitters, (rawEmitter2) => {
+          rawEmitter2(EV.CHANGE, fullPath, { curr, prev });
+        });
+        const currmtime = curr.mtimeMs;
+        if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
+          foreach(cont.listeners, (listener2) => listener2(path15, curr));
+        }
+      })
+    };
+    FsWatchFileInstances.set(fullPath, cont);
+  }
+  return () => {
+    delFromSet(cont, KEY_LISTENERS, listener);
+    delFromSet(cont, KEY_RAW, rawEmitter);
+    if (isEmptySet(cont.listeners)) {
+      FsWatchFileInstances.delete(fullPath);
+      (0, import_fs7.unwatchFile)(fullPath);
+      cont.options = cont.watcher = void 0;
+      Object.freeze(cont);
+    }
+  };
+};
+var NodeFsHandler = class {
+  constructor(fsW) {
+    this.fsw = fsW;
+    this._boundHandleError = (error) => fsW._handleError(error);
+  }
+  /**
+   * Watch file for changes with fs_watchFile or fs_watch.
+   * @param path to file or dir
+   * @param listener on fs change
+   * @returns closer for the watcher instance
+   */
+  _watchWithNodeFs(path15, listener) {
+    const opts = this.fsw.options;
+    const directory = sysPath.dirname(path15);
+    const basename3 = sysPath.basename(path15);
+    const parent = this.fsw._getWatchedDir(directory);
+    parent.add(basename3);
+    const absolutePath = sysPath.resolve(path15);
+    const options = {
+      persistent: opts.persistent
+    };
+    if (!listener)
+      listener = EMPTY_FN;
+    let closer;
+    if (opts.usePolling) {
+      const enableBin = opts.interval !== opts.binaryInterval;
+      options.interval = enableBin && isBinaryPath(basename3) ? opts.binaryInterval : opts.interval;
+      closer = setFsWatchFileListener(path15, absolutePath, options, {
+        listener,
+        rawEmitter: this.fsw._emitRaw
+      });
+    } else {
+      closer = setFsWatchListener(path15, absolutePath, options, {
+        listener,
+        errHandler: this._boundHandleError,
+        rawEmitter: this.fsw._emitRaw
+      });
+    }
+    return closer;
+  }
+  /**
+   * Watch a file and emit add event if warranted.
+   * @returns closer for the watcher instance
+   */
+  _handleFile(file, stats, initialAdd) {
+    if (this.fsw.closed) {
+      return;
+    }
+    const dirname4 = sysPath.dirname(file);
+    const basename3 = sysPath.basename(file);
+    const parent = this.fsw._getWatchedDir(dirname4);
+    let prevStats = stats;
+    if (parent.has(basename3))
+      return;
+    const listener = async (path15, newStats) => {
+      if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
+        return;
+      if (!newStats || newStats.mtimeMs === 0) {
+        try {
+          const newStats2 = await (0, import_promises4.stat)(file);
+          if (this.fsw.closed)
+            return;
+          const at = newStats2.atimeMs;
+          const mt = newStats2.mtimeMs;
+          if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+            this.fsw._emit(EV.CHANGE, file, newStats2);
+          }
+          if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
+            this.fsw._closeFile(path15);
+            prevStats = newStats2;
+            const closer2 = this._watchWithNodeFs(file, listener);
+            if (closer2)
+              this.fsw._addPathCloser(path15, closer2);
+          } else {
+            prevStats = newStats2;
+          }
+        } catch (error) {
+          this.fsw._remove(dirname4, basename3);
+        }
+      } else if (parent.has(basename3)) {
+        const at = newStats.atimeMs;
+        const mt = newStats.mtimeMs;
+        if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+          this.fsw._emit(EV.CHANGE, file, newStats);
+        }
+        prevStats = newStats;
+      }
+    };
+    const closer = this._watchWithNodeFs(file, listener);
+    if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
+      if (!this.fsw._throttle(EV.ADD, file, 0))
+        return;
+      this.fsw._emit(EV.ADD, file, stats);
+    }
+    return closer;
+  }
+  /**
+   * Handle symlinks encountered while reading a dir.
+   * @param entry returned by readdirp
+   * @param directory path of dir being read
+   * @param path of this item
+   * @param item basename of this item
+   * @returns true if no more processing is needed for this entry.
+   */
+  async _handleSymlink(entry, directory, path15, item) {
+    if (this.fsw.closed) {
+      return;
+    }
+    const full = entry.fullPath;
+    const dir = this.fsw._getWatchedDir(directory);
+    if (!this.fsw.options.followSymlinks) {
+      this.fsw._incrReadyCount();
+      let linkPath;
+      try {
+        linkPath = await (0, import_promises4.realpath)(path15);
+      } catch (e) {
+        this.fsw._emitReady();
+        return true;
+      }
+      if (this.fsw.closed)
+        return;
+      if (dir.has(item)) {
+        if (this.fsw._symlinkPaths.get(full) !== linkPath) {
+          this.fsw._symlinkPaths.set(full, linkPath);
+          this.fsw._emit(EV.CHANGE, path15, entry.stats);
+        }
+      } else {
+        dir.add(item);
+        this.fsw._symlinkPaths.set(full, linkPath);
+        this.fsw._emit(EV.ADD, path15, entry.stats);
+      }
+      this.fsw._emitReady();
+      return true;
+    }
+    if (this.fsw._symlinkPaths.has(full)) {
+      return true;
+    }
+    this.fsw._symlinkPaths.set(full, true);
+  }
+  _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
+    directory = sysPath.join(directory, "");
+    throttler = this.fsw._throttle("readdir", directory, 1e3);
+    if (!throttler)
+      return;
+    const previous = this.fsw._getWatchedDir(wh.path);
+    const current = /* @__PURE__ */ new Set();
+    let stream = this.fsw._readdirp(directory, {
+      fileFilter: (entry) => wh.filterPath(entry),
+      directoryFilter: (entry) => wh.filterDir(entry)
+    });
+    if (!stream)
+      return;
+    stream.on(STR_DATA, async (entry) => {
+      if (this.fsw.closed) {
+        stream = void 0;
+        return;
+      }
+      const item = entry.path;
+      let path15 = sysPath.join(directory, item);
+      current.add(item);
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path15, item)) {
+        return;
+      }
+      if (this.fsw.closed) {
+        stream = void 0;
+        return;
+      }
+      if (item === target || !target && !previous.has(item)) {
+        this.fsw._incrReadyCount();
+        path15 = sysPath.join(dir, sysPath.relative(dir, path15));
+        this._addToNodeFs(path15, initialAdd, wh, depth + 1);
+      }
+    }).on(EV.ERROR, this._boundHandleError);
+    return new Promise((resolve4, reject) => {
+      if (!stream)
+        return reject();
+      stream.once(STR_END, () => {
+        if (this.fsw.closed) {
+          stream = void 0;
+          return;
+        }
+        const wasThrottled = throttler ? throttler.clear() : false;
+        resolve4(void 0);
+        previous.getChildren().filter((item) => {
+          return item !== directory && !current.has(item);
+        }).forEach((item) => {
+          this.fsw._remove(directory, item);
+        });
+        stream = void 0;
+        if (wasThrottled)
+          this._handleRead(directory, false, wh, target, dir, depth, throttler);
+      });
+    });
+  }
+  /**
+   * Read directory to add / remove files from `@watched` list and re-read it on change.
+   * @param dir fs path
+   * @param stats
+   * @param initialAdd
+   * @param depth relative to user-supplied path
+   * @param target child path targeted for watch
+   * @param wh Common watch helpers for this path
+   * @param realpath
+   * @returns closer for the watcher instance.
+   */
+  async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath2) {
+    const parentDir = this.fsw._getWatchedDir(sysPath.dirname(dir));
+    const tracked = parentDir.has(sysPath.basename(dir));
+    if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
+      this.fsw._emit(EV.ADD_DIR, dir, stats);
+    }
+    parentDir.add(sysPath.basename(dir));
+    this.fsw._getWatchedDir(dir);
+    let throttler;
+    let closer;
+    const oDepth = this.fsw.options.depth;
+    if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath2)) {
+      if (!target) {
+        await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
+        if (this.fsw.closed)
+          return;
+      }
+      closer = this._watchWithNodeFs(dir, (dirPath, stats2) => {
+        if (stats2 && stats2.mtimeMs === 0)
+          return;
+        this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
+      });
+    }
+    return closer;
+  }
+  /**
+   * Handle added file, directory, or glob pattern.
+   * Delegates call to _handleFile / _handleDir after checks.
+   * @param path to file or ir
+   * @param initialAdd was the file added at watch instantiation?
+   * @param priorWh depth relative to user-supplied path
+   * @param depth Child path actually targeted for watch
+   * @param target Child path actually targeted for watch
+   */
+  async _addToNodeFs(path15, initialAdd, priorWh, depth, target) {
+    const ready = this.fsw._emitReady;
+    if (this.fsw._isIgnored(path15) || this.fsw.closed) {
+      ready();
+      return false;
+    }
+    const wh = this.fsw._getWatchHelpers(path15);
+    if (priorWh) {
+      wh.filterPath = (entry) => priorWh.filterPath(entry);
+      wh.filterDir = (entry) => priorWh.filterDir(entry);
+    }
+    try {
+      const stats = await statMethods[wh.statMethod](wh.watchPath);
+      if (this.fsw.closed)
+        return;
+      if (this.fsw._isIgnored(wh.watchPath, stats)) {
+        ready();
+        return false;
+      }
+      const follow = this.fsw.options.followSymlinks;
+      let closer;
+      if (stats.isDirectory()) {
+        const absPath = sysPath.resolve(path15);
+        const targetPath = follow ? await (0, import_promises4.realpath)(path15) : path15;
+        if (this.fsw.closed)
+          return;
+        closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
+        if (this.fsw.closed)
+          return;
+        if (absPath !== targetPath && targetPath !== void 0) {
+          this.fsw._symlinkPaths.set(absPath, targetPath);
+        }
+      } else if (stats.isSymbolicLink()) {
+        const targetPath = follow ? await (0, import_promises4.realpath)(path15) : path15;
+        if (this.fsw.closed)
+          return;
+        const parent = sysPath.dirname(wh.watchPath);
+        this.fsw._getWatchedDir(parent).add(wh.watchPath);
+        this.fsw._emit(EV.ADD, wh.watchPath, stats);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path15, wh, targetPath);
+        if (this.fsw.closed)
+          return;
+        if (targetPath !== void 0) {
+          this.fsw._symlinkPaths.set(sysPath.resolve(path15), targetPath);
+        }
+      } else {
+        closer = this._handleFile(wh.watchPath, stats, initialAdd);
+      }
+      ready();
+      if (closer)
+        this.fsw._addPathCloser(path15, closer);
+      return false;
+    } catch (error) {
+      if (this.fsw._handleError(error)) {
+        ready();
+        return path15;
+      }
+    }
+  }
+};
+
+// ../../node_modules/chokidar/esm/index.js
+var SLASH = "/";
+var SLASH_SLASH = "//";
+var ONE_DOT = ".";
+var TWO_DOTS = "..";
+var STRING_TYPE = "string";
+var BACK_SLASH_RE = /\\/g;
+var DOUBLE_SLASH_RE = /\/\//;
+var DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
+var REPLACER_RE = /^\.[/\\]/;
+function arrify(item) {
+  return Array.isArray(item) ? item : [item];
+}
+var isMatcherObject = (matcher) => typeof matcher === "object" && matcher !== null && !(matcher instanceof RegExp);
+function createPattern(matcher) {
+  if (typeof matcher === "function")
+    return matcher;
+  if (typeof matcher === "string")
+    return (string) => matcher === string;
+  if (matcher instanceof RegExp)
+    return (string) => matcher.test(string);
+  if (typeof matcher === "object" && matcher !== null) {
+    return (string) => {
+      if (matcher.path === string)
+        return true;
+      if (matcher.recursive) {
+        const relative3 = sysPath2.relative(matcher.path, string);
+        if (!relative3) {
+          return false;
+        }
+        return !relative3.startsWith("..") && !sysPath2.isAbsolute(relative3);
+      }
+      return false;
+    };
+  }
+  return () => false;
+}
+function normalizePath(path15) {
+  if (typeof path15 !== "string")
+    throw new Error("string expected");
+  path15 = sysPath2.normalize(path15);
+  path15 = path15.replace(/\\/g, "/");
+  let prepend = false;
+  if (path15.startsWith("//"))
+    prepend = true;
+  const DOUBLE_SLASH_RE2 = /\/\//;
+  while (path15.match(DOUBLE_SLASH_RE2))
+    path15 = path15.replace(DOUBLE_SLASH_RE2, "/");
+  if (prepend)
+    path15 = "/" + path15;
+  return path15;
+}
+function matchPatterns(patterns, testString, stats) {
+  const path15 = normalizePath(testString);
+  for (let index = 0; index < patterns.length; index++) {
+    const pattern = patterns[index];
+    if (pattern(path15, stats)) {
+      return true;
+    }
+  }
+  return false;
+}
+function anymatch(matchers, testString) {
+  if (matchers == null) {
+    throw new TypeError("anymatch: specify first argument");
+  }
+  const matchersArray = arrify(matchers);
+  const patterns = matchersArray.map((matcher) => createPattern(matcher));
+  if (testString == null) {
+    return (testString2, stats) => {
+      return matchPatterns(patterns, testString2, stats);
+    };
+  }
+  return matchPatterns(patterns, testString);
+}
+var unifyPaths = (paths_) => {
+  const paths = arrify(paths_).flat();
+  if (!paths.every((p) => typeof p === STRING_TYPE)) {
+    throw new TypeError(`Non-string provided as watch path: ${paths}`);
+  }
+  return paths.map(normalizePathToUnix);
+};
+var toUnix = (string) => {
+  let str = string.replace(BACK_SLASH_RE, SLASH);
+  let prepend = false;
+  if (str.startsWith(SLASH_SLASH)) {
+    prepend = true;
+  }
+  while (str.match(DOUBLE_SLASH_RE)) {
+    str = str.replace(DOUBLE_SLASH_RE, SLASH);
+  }
+  if (prepend) {
+    str = SLASH + str;
+  }
+  return str;
+};
+var normalizePathToUnix = (path15) => toUnix(sysPath2.normalize(toUnix(path15)));
+var normalizeIgnored = (cwd = "") => (path15) => {
+  if (typeof path15 === "string") {
+    return normalizePathToUnix(sysPath2.isAbsolute(path15) ? path15 : sysPath2.join(cwd, path15));
+  } else {
+    return path15;
+  }
+};
+var getAbsolutePath = (path15, cwd) => {
+  if (sysPath2.isAbsolute(path15)) {
+    return path15;
+  }
+  return sysPath2.join(cwd, path15);
+};
+var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
+var DirEntry = class {
+  constructor(dir, removeWatcher) {
+    this.path = dir;
+    this._removeWatcher = removeWatcher;
+    this.items = /* @__PURE__ */ new Set();
+  }
+  add(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    if (item !== ONE_DOT && item !== TWO_DOTS)
+      items.add(item);
+  }
+  async remove(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    items.delete(item);
+    if (items.size > 0)
+      return;
+    const dir = this.path;
+    try {
+      await (0, import_promises5.readdir)(dir);
+    } catch (err) {
+      if (this._removeWatcher) {
+        this._removeWatcher(sysPath2.dirname(dir), sysPath2.basename(dir));
+      }
+    }
+  }
+  has(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    return items.has(item);
+  }
+  getChildren() {
+    const { items } = this;
+    if (!items)
+      return [];
+    return [...items.values()];
+  }
+  dispose() {
+    this.items.clear();
+    this.path = "";
+    this._removeWatcher = EMPTY_FN;
+    this.items = EMPTY_SET;
+    Object.freeze(this);
+  }
+};
+var STAT_METHOD_F = "stat";
+var STAT_METHOD_L = "lstat";
+var WatchHelper = class {
+  constructor(path15, follow, fsw) {
+    this.fsw = fsw;
+    const watchPath = path15;
+    this.path = path15 = path15.replace(REPLACER_RE, "");
+    this.watchPath = watchPath;
+    this.fullWatchPath = sysPath2.resolve(watchPath);
+    this.dirParts = [];
+    this.dirParts.forEach((parts2) => {
+      if (parts2.length > 1)
+        parts2.pop();
+    });
+    this.followSymlinks = follow;
+    this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
+  }
+  entryPath(entry) {
+    return sysPath2.join(this.watchPath, sysPath2.relative(this.watchPath, entry.fullPath));
+  }
+  filterPath(entry) {
+    const { stats } = entry;
+    if (stats && stats.isSymbolicLink())
+      return this.filterDir(entry);
+    const resolvedPath = this.entryPath(entry);
+    return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);
+  }
+  filterDir(entry) {
+    return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
+  }
+};
+var FSWatcher = class extends import_events.EventEmitter {
+  // Not indenting methods for history sake; for now.
+  constructor(_opts = {}) {
+    super();
+    this.closed = false;
+    this._closers = /* @__PURE__ */ new Map();
+    this._ignoredPaths = /* @__PURE__ */ new Set();
+    this._throttled = /* @__PURE__ */ new Map();
+    this._streams = /* @__PURE__ */ new Set();
+    this._symlinkPaths = /* @__PURE__ */ new Map();
+    this._watched = /* @__PURE__ */ new Map();
+    this._pendingWrites = /* @__PURE__ */ new Map();
+    this._pendingUnlinks = /* @__PURE__ */ new Map();
+    this._readyCount = 0;
+    this._readyEmitted = false;
+    const awf = _opts.awaitWriteFinish;
+    const DEF_AWF = { stabilityThreshold: 2e3, pollInterval: 100 };
+    const opts = {
+      // Defaults
+      persistent: true,
+      ignoreInitial: false,
+      ignorePermissionErrors: false,
+      interval: 100,
+      binaryInterval: 300,
+      followSymlinks: true,
+      usePolling: false,
+      // useAsync: false,
+      atomic: true,
+      // NOTE: overwritten later (depends on usePolling)
+      ..._opts,
+      // Change format
+      ignored: _opts.ignored ? arrify(_opts.ignored) : arrify([]),
+      awaitWriteFinish: awf === true ? DEF_AWF : typeof awf === "object" ? { ...DEF_AWF, ...awf } : false
+    };
+    if (isIBMi)
+      opts.usePolling = true;
+    if (opts.atomic === void 0)
+      opts.atomic = !opts.usePolling;
+    const envPoll = process.env.CHOKIDAR_USEPOLLING;
+    if (envPoll !== void 0) {
+      const envLower = envPoll.toLowerCase();
+      if (envLower === "false" || envLower === "0")
+        opts.usePolling = false;
+      else if (envLower === "true" || envLower === "1")
+        opts.usePolling = true;
+      else
+        opts.usePolling = !!envLower;
+    }
+    const envInterval = process.env.CHOKIDAR_INTERVAL;
+    if (envInterval)
+      opts.interval = Number.parseInt(envInterval, 10);
+    let readyCalls = 0;
+    this._emitReady = () => {
+      readyCalls++;
+      if (readyCalls >= this._readyCount) {
+        this._emitReady = EMPTY_FN;
+        this._readyEmitted = true;
+        process.nextTick(() => this.emit(EVENTS.READY));
+      }
+    };
+    this._emitRaw = (...args) => this.emit(EVENTS.RAW, ...args);
+    this._boundRemove = this._remove.bind(this);
+    this.options = opts;
+    this._nodeFsHandler = new NodeFsHandler(this);
+    Object.freeze(opts);
+  }
+  _addIgnoredPath(matcher) {
+    if (isMatcherObject(matcher)) {
+      for (const ignored of this._ignoredPaths) {
+        if (isMatcherObject(ignored) && ignored.path === matcher.path && ignored.recursive === matcher.recursive) {
+          return;
+        }
+      }
+    }
+    this._ignoredPaths.add(matcher);
+  }
+  _removeIgnoredPath(matcher) {
+    this._ignoredPaths.delete(matcher);
+    if (typeof matcher === "string") {
+      for (const ignored of this._ignoredPaths) {
+        if (isMatcherObject(ignored) && ignored.path === matcher) {
+          this._ignoredPaths.delete(ignored);
+        }
+      }
+    }
+  }
+  // Public methods
+  /**
+   * Adds paths to be watched on an existing FSWatcher instance.
+   * @param paths_ file or file list. Other arguments are unused
+   */
+  add(paths_, _origAdd, _internal) {
+    const { cwd } = this.options;
+    this.closed = false;
+    this._closePromise = void 0;
+    let paths = unifyPaths(paths_);
+    if (cwd) {
+      paths = paths.map((path15) => {
+        const absPath = getAbsolutePath(path15, cwd);
+        return absPath;
+      });
+    }
+    paths.forEach((path15) => {
+      this._removeIgnoredPath(path15);
+    });
+    this._userIgnored = void 0;
+    if (!this._readyCount)
+      this._readyCount = 0;
+    this._readyCount += paths.length;
+    Promise.all(paths.map(async (path15) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path15, !_internal, void 0, 0, _origAdd);
+      if (res)
+        this._emitReady();
+      return res;
+    })).then((results) => {
+      if (this.closed)
+        return;
+      results.forEach((item) => {
+        if (item)
+          this.add(sysPath2.dirname(item), sysPath2.basename(_origAdd || item));
+      });
+    });
+    return this;
+  }
+  /**
+   * Close watchers or start ignoring events from specified paths.
+   */
+  unwatch(paths_) {
+    if (this.closed)
+      return this;
+    const paths = unifyPaths(paths_);
+    const { cwd } = this.options;
+    paths.forEach((path15) => {
+      if (!sysPath2.isAbsolute(path15) && !this._closers.has(path15)) {
+        if (cwd)
+          path15 = sysPath2.join(cwd, path15);
+        path15 = sysPath2.resolve(path15);
+      }
+      this._closePath(path15);
+      this._addIgnoredPath(path15);
+      if (this._watched.has(path15)) {
+        this._addIgnoredPath({
+          path: path15,
+          recursive: true
+        });
+      }
+      this._userIgnored = void 0;
+    });
+    return this;
+  }
+  /**
+   * Close watchers and remove all listeners from watched paths.
+   */
+  close() {
+    if (this._closePromise) {
+      return this._closePromise;
+    }
+    this.closed = true;
+    this.removeAllListeners();
+    const closers = [];
+    this._closers.forEach((closerList) => closerList.forEach((closer) => {
+      const promise = closer();
+      if (promise instanceof Promise)
+        closers.push(promise);
+    }));
+    this._streams.forEach((stream) => stream.destroy());
+    this._userIgnored = void 0;
+    this._readyCount = 0;
+    this._readyEmitted = false;
+    this._watched.forEach((dirent) => dirent.dispose());
+    this._closers.clear();
+    this._watched.clear();
+    this._streams.clear();
+    this._symlinkPaths.clear();
+    this._throttled.clear();
+    this._closePromise = closers.length ? Promise.all(closers).then(() => void 0) : Promise.resolve();
+    return this._closePromise;
+  }
+  /**
+   * Expose list of watched paths
+   * @returns for chaining
+   */
+  getWatched() {
+    const watchList = {};
+    this._watched.forEach((entry, dir) => {
+      const key = this.options.cwd ? sysPath2.relative(this.options.cwd, dir) : dir;
+      const index = key || ONE_DOT;
+      watchList[index] = entry.getChildren().sort();
+    });
+    return watchList;
+  }
+  emitWithAll(event, args) {
+    this.emit(event, ...args);
+    if (event !== EVENTS.ERROR)
+      this.emit(EVENTS.ALL, event, ...args);
+  }
+  // Common helpers
+  // --------------
+  /**
+   * Normalize and emit events.
+   * Calling _emit DOES NOT MEAN emit() would be called!
+   * @param event Type of event
+   * @param path File or directory path
+   * @param stats arguments to be passed with event
+   * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+   */
+  async _emit(event, path15, stats) {
+    if (this.closed)
+      return;
+    const opts = this.options;
+    if (isWindows2)
+      path15 = sysPath2.normalize(path15);
+    if (opts.cwd)
+      path15 = sysPath2.relative(opts.cwd, path15);
+    const args = [path15];
+    if (stats != null)
+      args.push(stats);
+    const awf = opts.awaitWriteFinish;
+    let pw;
+    if (awf && (pw = this._pendingWrites.get(path15))) {
+      pw.lastChange = /* @__PURE__ */ new Date();
+      return this;
+    }
+    if (opts.atomic) {
+      if (event === EVENTS.UNLINK) {
+        this._pendingUnlinks.set(path15, [event, ...args]);
+        setTimeout(() => {
+          this._pendingUnlinks.forEach((entry, path16) => {
+            this.emit(...entry);
+            this.emit(EVENTS.ALL, ...entry);
+            this._pendingUnlinks.delete(path16);
+          });
+        }, typeof opts.atomic === "number" ? opts.atomic : 100);
+        return this;
+      }
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path15)) {
+        event = EVENTS.CHANGE;
+        this._pendingUnlinks.delete(path15);
+      }
+    }
+    if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
+      const awfEmit = (err, stats2) => {
+        if (err) {
+          event = EVENTS.ERROR;
+          args[0] = err;
+          this.emitWithAll(event, args);
+        } else if (stats2) {
+          if (args.length > 1) {
+            args[1] = stats2;
+          } else {
+            args.push(stats2);
+          }
+          this.emitWithAll(event, args);
+        }
+      };
+      this._awaitWriteFinish(path15, awf.stabilityThreshold, event, awfEmit);
+      return this;
+    }
+    if (event === EVENTS.CHANGE) {
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path15, 50);
+      if (isThrottled)
+        return this;
+    }
+    if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
+      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path15) : path15;
+      let stats2;
+      try {
+        stats2 = await (0, import_promises5.stat)(fullPath);
+      } catch (err) {
+      }
+      if (!stats2 || this.closed)
+        return;
+      args.push(stats2);
+    }
+    this.emitWithAll(event, args);
+    return this;
+  }
+  /**
+   * Common handler for errors
+   * @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+   */
+  _handleError(error) {
+    const code = error && error.code;
+    if (error && code !== "ENOENT" && code !== "ENOTDIR" && (!this.options.ignorePermissionErrors || code !== "EPERM" && code !== "EACCES")) {
+      this.emit(EVENTS.ERROR, error);
+    }
+    return error || this.closed;
+  }
+  /**
+   * Helper utility for throttling
+   * @param actionType type being throttled
+   * @param path being acted upon
+   * @param timeout duration of time to suppress duplicate actions
+   * @returns tracking object or false if action should be suppressed
+   */
+  _throttle(actionType, path15, timeout) {
+    if (!this._throttled.has(actionType)) {
+      this._throttled.set(actionType, /* @__PURE__ */ new Map());
+    }
+    const action = this._throttled.get(actionType);
+    if (!action)
+      throw new Error("invalid throttle");
+    const actionPath = action.get(path15);
+    if (actionPath) {
+      actionPath.count++;
+      return false;
+    }
+    let timeoutObject;
+    const clear = () => {
+      const item = action.get(path15);
+      const count = item ? item.count : 0;
+      action.delete(path15);
+      clearTimeout(timeoutObject);
+      if (item)
+        clearTimeout(item.timeoutObject);
+      return count;
+    };
+    timeoutObject = setTimeout(clear, timeout);
+    const thr = { timeoutObject, clear, count: 0 };
+    action.set(path15, thr);
+    return thr;
+  }
+  _incrReadyCount() {
+    return this._readyCount++;
+  }
+  /**
+   * Awaits write operation to finish.
+   * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
+   * @param path being acted upon
+   * @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
+   * @param event
+   * @param awfEmit Callback to be called when ready for event to be emitted.
+   */
+  _awaitWriteFinish(path15, threshold, event, awfEmit) {
+    const awf = this.options.awaitWriteFinish;
+    if (typeof awf !== "object")
+      return;
+    const pollInterval = awf.pollInterval;
+    let timeoutHandler;
+    let fullPath = path15;
+    if (this.options.cwd && !sysPath2.isAbsolute(path15)) {
+      fullPath = sysPath2.join(this.options.cwd, path15);
+    }
+    const now = /* @__PURE__ */ new Date();
+    const writes = this._pendingWrites;
+    function awaitWriteFinishFn(prevStat) {
+      (0, import_fs8.stat)(fullPath, (err, curStat) => {
+        if (err || !writes.has(path15)) {
+          if (err && err.code !== "ENOENT")
+            awfEmit(err);
+          return;
+        }
+        const now2 = Number(/* @__PURE__ */ new Date());
+        if (prevStat && curStat.size !== prevStat.size) {
+          writes.get(path15).lastChange = now2;
+        }
+        const pw = writes.get(path15);
+        const df = now2 - pw.lastChange;
+        if (df >= threshold) {
+          writes.delete(path15);
+          awfEmit(void 0, curStat);
+        } else {
+          timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
+        }
+      });
+    }
+    if (!writes.has(path15)) {
+      writes.set(path15, {
+        lastChange: now,
+        cancelWait: () => {
+          writes.delete(path15);
+          clearTimeout(timeoutHandler);
+          return event;
+        }
+      });
+      timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
+    }
+  }
+  /**
+   * Determines whether user has asked to ignore this path.
+   */
+  _isIgnored(path15, stats) {
+    if (this.options.atomic && DOT_RE.test(path15))
+      return true;
+    if (!this._userIgnored) {
+      const { cwd } = this.options;
+      const ign = this.options.ignored;
+      const ignored = (ign || []).map(normalizeIgnored(cwd));
+      const ignoredPaths = [...this._ignoredPaths];
+      const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
+      this._userIgnored = anymatch(list, void 0);
+    }
+    return this._userIgnored(path15, stats);
+  }
+  _isntIgnored(path15, stat4) {
+    return !this._isIgnored(path15, stat4);
+  }
+  /**
+   * Provides a set of common helpers and properties relating to symlink handling.
+   * @param path file or directory pattern being watched
+   */
+  _getWatchHelpers(path15) {
+    return new WatchHelper(path15, this.options.followSymlinks, this);
+  }
+  // Directory helpers
+  // -----------------
+  /**
+   * Provides directory tracking objects
+   * @param directory path of the directory
+   */
+  _getWatchedDir(directory) {
+    const dir = sysPath2.resolve(directory);
+    if (!this._watched.has(dir))
+      this._watched.set(dir, new DirEntry(dir, this._boundRemove));
+    return this._watched.get(dir);
+  }
+  // File helpers
+  // ------------
+  /**
+   * Check for read permissions: https://stackoverflow.com/a/11781404/1358405
+   */
+  _hasReadPermissions(stats) {
+    if (this.options.ignorePermissionErrors)
+      return true;
+    return Boolean(Number(stats.mode) & 256);
+  }
+  /**
+   * Handles emitting unlink events for
+   * files and directories, and via recursion, for
+   * files and directories within directories that are unlinked
+   * @param directory within which the following item is located
+   * @param item      base path of item/directory
+   */
+  _remove(directory, item, isDirectory) {
+    const path15 = sysPath2.join(directory, item);
+    const fullPath = sysPath2.resolve(path15);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path15) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path15, 100))
+      return;
+    if (!isDirectory && this._watched.size === 1) {
+      this.add(directory, item, true);
+    }
+    const wp = this._getWatchedDir(path15);
+    const nestedDirectoryChildren = wp.getChildren();
+    nestedDirectoryChildren.forEach((nested) => this._remove(path15, nested));
+    const parent = this._getWatchedDir(directory);
+    const wasTracked = parent.has(item);
+    parent.remove(item);
+    if (this._symlinkPaths.has(fullPath)) {
+      this._symlinkPaths.delete(fullPath);
+    }
+    let relPath = path15;
+    if (this.options.cwd)
+      relPath = sysPath2.relative(this.options.cwd, path15);
+    if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
+      const event = this._pendingWrites.get(relPath).cancelWait();
+      if (event === EVENTS.ADD)
+        return;
+    }
+    this._watched.delete(path15);
+    this._watched.delete(fullPath);
+    const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
+    if (wasTracked && !this._isIgnored(path15))
+      this._emit(eventName, path15);
+    this._closePath(path15);
+  }
+  /**
+   * Closes all watchers for a path
+   */
+  _closePath(path15) {
+    this._closeFile(path15);
+    const dir = sysPath2.dirname(path15);
+    this._getWatchedDir(dir).remove(sysPath2.basename(path15));
+  }
+  /**
+   * Closes only file-specific watchers
+   */
+  _closeFile(path15) {
+    const closers = this._closers.get(path15);
+    if (!closers)
+      return;
+    closers.forEach((closer) => closer());
+    this._closers.delete(path15);
+  }
+  _addPathCloser(path15, closer) {
+    if (!closer)
+      return;
+    let list = this._closers.get(path15);
+    if (!list) {
+      list = [];
+      this._closers.set(path15, list);
+    }
+    list.push(closer);
+  }
+  _readdirp(root, opts) {
+    if (this.closed)
+      return;
+    const options = { type: EVENTS.ALL, alwaysStat: true, lstat: true, ...opts, depth: 0 };
+    let stream = readdirp(root, options);
+    this._streams.add(stream);
+    stream.once(STR_CLOSE, () => {
+      stream = void 0;
+    });
+    stream.once(STR_END, () => {
+      if (stream) {
+        this._streams.delete(stream);
+        stream = void 0;
+      }
+    });
+    return stream;
+  }
+};
+function watch(paths, options = {}) {
+  const watcher = new FSWatcher(options);
+  watcher.add(paths);
+  return watcher;
+}
+
+// ../../shared/all/helpers/terminal-ai/watcher.ts
+var PRUNED_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  "node_modules",
+  ".next",
+  ".turbo",
+  ".expo",
+  "dist",
+  "build",
+  "out",
+  "coverage",
+  ".cache",
+  ".venv",
+  "venv",
+  "__pycache__",
+  ".gradle",
+  "Pods",
+  "DerivedData"
+]);
+function isNoiseFile(name) {
+  return name === ".DS_Store" || name === "4913" || name.startsWith(".#") || name.startsWith("#") && name.endsWith("#");
+}
+var MAX_BATCH = 200;
+var FLUSH_MS = 120;
+var SELF_WRITE_MS = 2e3;
+var emptyPending = () => ({
+  added: /* @__PURE__ */ new Set(),
+  changed: /* @__PURE__ */ new Set(),
+  removed: /* @__PURE__ */ new Set(),
+  resync: false
+});
+var WorkspaceWatcher = class {
+  /**
+   * @param root     Absolute path of the working tree. Every emitted path is
+   *                 repo-relative and `/`-prefixed, matching `bareFsList`.
+   * @param emit     Called with a coalesced batch, never with an empty one.
+   * @param exclude  Absolute subtrees to skip on top of the name-based pruning.
+   *                 A no-git card's root is the space dir itself, which also
+   *                 holds the runner's own bookkeeping.
+   */
+  constructor(root, emit, exclude = []) {
+    this.root = root;
+    this.emit = emit;
+    this.exclude = exclude;
+    this.watcher = null;
+    this.pending = emptyPending();
+    this.flushTimer = null;
+    /** path -> expiry. Events for these paths are ours (the editor just saved)
+     *  and must not come back as "changed on disk". */
+    this.selfWrites = /* @__PURE__ */ new Map();
+    this.closed = false;
+  }
+  start() {
+    if (this.watcher || this.closed) return;
+    const watcher = watch(this.root, {
+      // `ignored` prunes: returning true for a directory stops the walk there,
+      // so a pruned tree is never even enumerated.
+      ignored: (absPath) => this.shouldIgnore(absPath),
+      ignoreInitial: true,
+      // A symlink to $HOME (or a sibling checkout) would pull the whole machine
+      // into the watch set.
+      followSymlinks: false,
+      // Report a write only once it stops growing - otherwise a large file
+      // fires while it's still half on disk and the editor reads a torn read.
+      awaitWriteFinish: { stabilityThreshold: 100, pollInterval: 30 },
+      // Recognise the unlink+rename that editors use to save atomically as a
+      // single change rather than a delete followed by a create.
+      atomic: true,
+      ignorePermissionErrors: true,
+      cwd: this.root
+    });
+    this.watcher = watcher;
+    watcher.on("add", (p) => this.record("added", p));
+    watcher.on("addDir", (p) => this.record("added", p));
+    watcher.on("change", (p) => this.record("changed", p));
+    watcher.on("unlink", (p) => this.record("removed", p));
+    watcher.on("unlinkDir", (p) => this.record("removed", p));
+    watcher.on("error", () => {
+      if (this.closed) return;
+      void this.close();
+      this.emit({
+        added: [],
+        changed: [],
+        removed: [],
+        resync: false,
+        stopped: true
+      });
+    });
+  }
+  /**
+   * Mark a path as about to be written by us. The event the write produces is
+   * dropped, so the editor doesn't get told its own save was an outside edit.
+   */
+  expectWrite(repoPath) {
+    this.selfWrites.set(repoPath, Date.now() + SELF_WRITE_MS);
+  }
+  async close() {
+    this.closed = true;
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    this.pending = emptyPending();
+    this.selfWrites.clear();
+    const watcher = this.watcher;
+    this.watcher = null;
+    if (watcher) await watcher.close().catch(() => void 0);
+  }
+  /** chokidar tests absolute paths, always under the watch root. Matching is
+   *  done on the part BELOW the root, so a runner whose space dir happens to
+   *  sit under a `build/` or `dist/` of its own doesn't prune everything. */
+  shouldIgnore(absPath) {
+    if (absPath === this.root) return false;
+    for (const excluded of this.exclude) {
+      if (absPath === excluded || absPath.startsWith(excluded + "/")) {
+        return true;
+      }
+    }
+    const segments = absPath.slice(this.root.length + 1).split("/");
+    for (const segment of segments) {
+      if (PRUNED_DIRS.has(segment)) return true;
+    }
+    return isNoiseFile(segments[segments.length - 1] ?? "");
+  }
+  record(kind, relPath) {
+    if (this.closed || !relPath) return;
+    const path15 = "/" + relPath;
+    const expiry = this.selfWrites.get(path15);
+    if (expiry !== void 0) {
+      if (expiry > Date.now()) return;
+      this.selfWrites.delete(path15);
+    }
+    const { added, changed, removed } = this.pending;
+    added.delete(path15);
+    changed.delete(path15);
+    removed.delete(path15);
+    if (kind === "added") added.add(path15);
+    else if (kind === "changed") changed.add(path15);
+    else removed.add(path15);
+    if (added.size + changed.size + removed.size > MAX_BATCH) {
+      this.pending = { ...emptyPending(), resync: true };
+    }
+    this.scheduleFlush();
+  }
+  scheduleFlush() {
+    if (this.flushTimer) return;
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = null;
+      this.flush();
+    }, FLUSH_MS);
+  }
+  flush() {
+    if (this.closed) return;
+    const { added, changed, removed, resync } = this.pending;
+    this.pending = emptyPending();
+    if (!resync && !added.size && !changed.size && !removed.size) return;
+    const now = Date.now();
+    for (const [path15, expiry] of this.selfWrites) {
+      if (expiry <= now) this.selfWrites.delete(path15);
+    }
+    this.emit({
+      added: resync ? [] : [...added],
+      changed: resync ? [] : [...changed],
+      removed: resync ? [] : [...removed],
+      resync
+    });
+  }
+};
+
 // ../../shared/all/helpers/terminal-ai/terminal-mode.ts
 function posixNormalize(p) {
   const parts2 = p.split("/").filter(Boolean);
@@ -15355,6 +17264,54 @@ var TerminalModeEngine = class {
     this.core = core;
     this.emitter = emitter;
     this.sessions = /* @__PURE__ */ new Map();
+    /** One working-tree watcher per live bare session, keyed by postId. */
+    this.watchers = /* @__PURE__ */ new Map();
+    /** Worktree name each session claimed, keyed by postId. Covers the window
+     *  `claimWorkName`'s disk scan cannot: a name taken but not yet created. */
+    this.reservedNames = /* @__PURE__ */ new Map();
+  }
+  // ── working-tree watching ──
+  /** Start watching a session's tree. Idempotent: re-entering a session (the
+   *  modal reopening, a hydrate after restart) must not stack watchers. */
+  startWatching(session) {
+    const postId = session.postId;
+    if (this.watchers.has(postId)) return;
+    const paths = this.core.target().paths;
+    const root = session.workspacePath || paths.root;
+    if (!root) return;
+    const exclude = session.workspacePath ? [] : [
+      paths.state,
+      paths.backups,
+      paths.builds,
+      paths.bin,
+      paths.worktrees,
+      paths.repo,
+      `${paths.root}/drops`
+    ];
+    const watcher = new WorkspaceWatcher(
+      root,
+      (change) => {
+        this.emitter.emitBareFsChange(postId, change);
+      },
+      exclude
+    );
+    this.watchers.set(postId, watcher);
+    watcher.start();
+  }
+  /** Silent by design: a session that ends also emits session-update, and a
+   *  re-point stops then starts. The one `stopped` the client cares about is
+   *  the watcher failing under a live session, which the watcher emits itself. */
+  stopWatching(postId) {
+    const watcher = this.watchers.get(postId);
+    if (!watcher) return;
+    this.watchers.delete(postId);
+    void watcher.close();
+  }
+  /** Suppress the change event our own write is about to produce, so a save
+   *  never comes back to the editor as an outside edit. Normalized to the form
+   *  the watcher emits, since callers spell the path either way. */
+  expectWrite(postId, path15) {
+    this.watchers.get(postId)?.expectWrite(posixNormalize(path15));
   }
   // ── Lifecycle / ModeEngine ──
   start(base, args) {
@@ -15398,6 +17355,8 @@ var TerminalModeEngine = class {
     return !!s && (s.phase === "starting" || s.phase === "bare-active");
   }
   remove(postId) {
+    this.stopWatching(postId);
+    this.reservedNames.delete(postId);
     this.sessions.delete(postId);
   }
   async kill(postId) {
@@ -15411,12 +17370,17 @@ var TerminalModeEngine = class {
       }
     }
     if (!session) return;
+    this.stopWatching(session.postId);
     await this.teardown(session);
     const removedPostId = session.postId;
+    this.reservedNames.delete(removedPostId);
     this.sessions.delete(removedPostId);
     this.emitter.emitSessionRemoved(removedPostId);
   }
   destroy() {
+    for (const watcher of this.watchers.values()) void watcher.close();
+    this.watchers.clear();
+    this.reservedNames.clear();
     this.sessions.clear();
   }
   teardown(session) {
@@ -15461,6 +17425,7 @@ var TerminalModeEngine = class {
         exposed: []
       };
       this.sessions.set(r.postId, session);
+      this.startWatching(session);
       this.emitter.emitSessionUpdate(session);
     }
   }
@@ -15503,6 +17468,8 @@ var TerminalModeEngine = class {
       exposed: []
     };
     this.sessions.set(args.postId, session);
+    this.stopWatching(args.postId);
+    this.startWatching(session);
     this.emitter.emitSessionUpdate(session);
   }
   // ── workspace + Claude CLI, user drives ──
@@ -15512,11 +17479,13 @@ var TerminalModeEngine = class {
     await this.core.ensureSpaceWorkspace();
     if (config.repoUrl && config.githubToken) {
       const branch = baseBranch || config.mainBranch || "main";
-      const { path: path15 } = await addWorktree(
+      const workName = isCardPostId(session.postId) ? session.taskId : await claimWorkName(
         this.core.target(),
-        session.taskId,
-        branch
+        session.taskTitle,
+        this.reservedNames.values()
       );
+      this.reservedNames.set(session.postId, workName);
+      const { path: path15 } = await addWorktree(this.core.target(), workName, branch);
       session.workspacePath = path15;
       await setGitIdentity(
         this.core.target(),
@@ -15546,6 +17515,7 @@ var TerminalModeEngine = class {
       }
     }
     session.phase = "bare-active";
+    this.startWatching(session);
     this.emitter.emitSessionUpdate(session);
     this.emitter.addLog(
       session,
@@ -15653,12 +17623,41 @@ var TerminalModeEngine = class {
     if (!/^[A-Za-z0-9+/=\n\r]*$/.test(b64)) {
       throw new Error("Invalid base64 payload.");
     }
+    this.expectWrite(String(postId), path15);
     await target.sh(
       `mkdir -p ${shEscape(posixDirname(abs))} && printf %s ${shEscape(b64)} | base64 -d > ${shEscape(abs)}`
     );
     const session = this.sessions.get(String(postId));
     if (session) delete session.buffers[path15];
   }
+  /** Write a dropped image to the per-space drops dir (`paths.root`, OUTSIDE the
+   *  card worktree so it never touches the repo) and return its absolute path. */
+  async terminalDropImage({
+    postId,
+    content,
+    ext
+  }) {
+    const target = this.getBareTarget(postId);
+    if (!/^[A-Za-z0-9+/=\n\r]*$/.test(content)) {
+      throw new Error("Invalid base64 payload.");
+    }
+    if (content.length > 14e6) {
+      throw new Error("Image too large (max ~10MB).");
+    }
+    const safeExt = (ext || "png").toLowerCase().replace(/[^a-z0-9]/g, "") || "png";
+    const dropsDir = `${target.paths.root}/drops`;
+    const abs = `${dropsDir}/${(0, import_crypto4.randomUUID)()}.${safeExt}`;
+    await target.sh(
+      `mkdir -p ${shEscape(dropsDir)} && printf %s ${shEscape(content)} | base64 -d > ${shEscape(abs)}`
+    );
+    try {
+      await target.sh(
+        `find ${shEscape(dropsDir)} -type f -mtime +1 -delete 2>/dev/null || true`
+      );
+    } catch {
+    }
+    return abs;
+  }
   bareEditorState({
     postId: rawPostId
   }) {
@@ -15876,11 +17875,6 @@ var TerminalModeEngine = class {
   }
 };
 
-// ../../shared/all/helpers/board-agent-core/boardTerminal.ts
-function boardTerminalKey(spaceSlug) {
-  return `board-${spaceSlug}`;
-}
-
 // ../../shared/all/helpers/board-agent-core/ansi.ts
 var CSI = String.raw`\x1b\[[0-?]*[ -/]*[@-~]`;
 var OSC = String.raw`\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)`;
@@ -15957,8 +17951,8 @@ var ClaudeLoginFlow = class {
     if (this.active) throw new Error("A Claude sign-in is already running.");
     this.reset();
     this.inFlight = true;
-    const urlPromise = new Promise((resolve2, reject) => {
-      this.urlResolver = resolve2;
+    const urlPromise = new Promise((resolve4, reject) => {
+      this.urlResolver = resolve4;
       this.urlRejecter = reject;
     });
     urlPromise.catch(() => {
@@ -16019,10 +18013,10 @@ var ClaudeLoginFlow = class {
         /https:\/\/[^\s\x00-\x1f]*oauth[^\s\x00-\x1f]*/
       )?.[0];
       if (url2) {
-        const resolve2 = this.urlResolver;
+        const resolve4 = this.urlResolver;
         this.urlResolver = null;
         this.urlRejecter = null;
-        resolve2(url2.replace(/[.,;)\]]+$/, ""));
+        resolve4(url2.replace(/[.,;)\]]+$/, ""));
       }
     }
     if (this.submitMark < 0 || this.settled) return;
@@ -16118,8 +18112,8 @@ var CodexLoginFlow = class {
     this.reset();
     this.inFlight = true;
     const startPromise = new Promise(
-      (resolve2, reject) => {
-        this.startResolver = resolve2;
+      (resolve4, reject) => {
+        this.startResolver = resolve4;
         this.startRejecter = reject;
       }
     );
@@ -16165,10 +18159,10 @@ var CodexLoginFlow = class {
       const url2 = this.output.match(/https:\/\/[^\s\x00-\x1f]+/)?.[0];
       const code = this.output.match(CODE_LINE_RE)?.[1] ?? this.output.match(CODE_TOKEN_RE)?.[1];
       if (url2 && code) {
-        const resolve2 = this.startResolver;
+        const resolve4 = this.startResolver;
         this.startResolver = null;
         this.startRejecter = null;
-        resolve2({ url: url2.replace(/[.,;)\]]+$/, ""), code });
+        resolve4({ url: url2.replace(/[.,;)\]]+$/, ""), code });
       }
       return;
     }
@@ -16347,7 +18341,7 @@ async function listGithubBranches(token, fullName) {
 
 // ../../shared/all/helpers/board-agent-core/host-deploy.ts
 var import_child_process5 = require("child_process");
-var import_promises3 = __toESM(require("fs/promises"));
+var import_promises6 = __toESM(require("fs/promises"));
 var import_path9 = __toESM(require("path"));
 var import_util5 = require("util");
 var execFileAsync2 = (0, import_util5.promisify)(import_child_process5.execFile);
@@ -16360,12 +18354,12 @@ var CLAUDE_LINK = `${CLAUDE_SKILLS_DIR}/deploy`;
 async function ensureClaudeSkillLink(workspace) {
   const linkPath = import_path9.default.join(workspace, CLAUDE_LINK);
   try {
-    await import_promises3.default.lstat(linkPath);
+    await import_promises6.default.lstat(linkPath);
     return;
   } catch {
   }
-  await import_promises3.default.mkdir(import_path9.default.join(workspace, CLAUDE_SKILLS_DIR), { recursive: true });
-  await import_promises3.default.symlink("../../.agents/skills/deploy", linkPath, "dir");
+  await import_promises6.default.mkdir(import_path9.default.join(workspace, CLAUDE_SKILLS_DIR), { recursive: true });
+  await import_promises6.default.symlink("../../.agents/skills/deploy", linkPath, "dir");
 }
 var GIT_NO_HELPER = ["-c", "credential.helper="];
 var GIT_ENV = { ...process.env, GIT_TERMINAL_PROMPT: "0" };
@@ -16474,15 +18468,15 @@ function spaceEnv(spaceDir) {
   };
 }
 async function readContract(workspace) {
-  const skill = await import_promises3.default.readFile(import_path9.default.join(workspace, SKILL_PATH), "utf-8").catch(() => {
+  const skill = await import_promises6.default.readFile(import_path9.default.join(workspace, SKILL_PATH), "utf-8").catch(() => {
     throw new Error("The creator wrote no SKILL.md.");
   });
-  const checker = await import_promises3.default.readFile(import_path9.default.join(workspace, CHECKER_PATH), "utf-8").catch(() => {
+  const checker = await import_promises6.default.readFile(import_path9.default.join(workspace, CHECKER_PATH), "utf-8").catch(() => {
     throw new Error("The creator wrote no check-environment.sh.");
   });
   try {
     const raw = JSON.parse(
-      await import_promises3.default.readFile(import_path9.default.join(workspace, VARIABLES_PATH), "utf-8")
+      await import_promises6.default.readFile(import_path9.default.join(workspace, VARIABLES_PATH), "utf-8")
     );
     return {
       skill,
@@ -16635,7 +18629,7 @@ async function runEnvironmentCheck(opts) {
     `origin/${status.branch}:${CHECKER_PATH}`
   );
   const tmp = import_path9.default.join(opts.spaceDir, `.env-check.${process.pid}.sh`);
-  await import_promises3.default.writeFile(tmp, script, { mode: 448 });
+  await import_promises6.default.writeFile(tmp, script, { mode: 448 });
   let ok = true;
   let output = "";
   try {
@@ -16648,7 +18642,7 @@ async function runEnvironmentCheck(opts) {
     output = res.output;
     if (res.code !== 0) ok = false;
   } finally {
-    await import_promises3.default.rm(tmp, { force: true });
+    await import_promises6.default.rm(tmp, { force: true });
   }
   const checks = [];
   for (const line of output.split("\n")) {
@@ -16717,8 +18711,8 @@ var import_path11 = __toESM(require("path"));
 
 // ../../shared/all/helpers/board-agent-core/host-secrets.ts
 var import_child_process6 = require("child_process");
-var import_crypto4 = __toESM(require("crypto"));
-var import_promises4 = __toESM(require("fs/promises"));
+var import_crypto5 = __toESM(require("crypto"));
+var import_promises7 = __toESM(require("fs/promises"));
 var import_path10 = __toESM(require("path"));
 var import_util6 = require("util");
 var execFileAsync3 = (0, import_util6.promisify)(import_child_process6.execFile);
@@ -16745,14 +18739,14 @@ async function assertBinaries() {
   }
 }
 function deriveKey(password, salt) {
-  return import_crypto4.default.scryptSync(password, salt, 32, {
+  return import_crypto5.default.scryptSync(password, salt, 32, {
     N: SCRYPT_N2,
     maxmem: 64 * 1024 * 1024
   });
 }
 async function secretsInitialized(configDir) {
   try {
-    await import_promises4.default.access(import_path10.default.join(configDir, IDENTITY_FILE));
+    await import_promises7.default.access(import_path10.default.join(configDir, IDENTITY_FILE));
     return true;
   } catch {
     return false;
@@ -16774,9 +18768,9 @@ async function initSecrets(configDir, password) {
   if (!identity || !recipient) {
     throw new Error("age-keygen returned no usable keypair.");
   }
-  const salt = import_crypto4.default.randomBytes(16);
-  const iv = import_crypto4.default.randomBytes(12);
-  const cipher = import_crypto4.default.createCipheriv(
+  const salt = import_crypto5.default.randomBytes(16);
+  const iv = import_crypto5.default.randomBytes(12);
+  const cipher = import_crypto5.default.createCipheriv(
     "aes-256-gcm",
     deriveKey(password, salt),
     iv
@@ -16791,17 +18785,17 @@ async function initSecrets(configDir, password) {
     tag: cipher.getAuthTag().toString("base64"),
     data: data.toString("base64")
   };
-  await import_promises4.default.writeFile(import_path10.default.join(configDir, IDENTITY_FILE), JSON.stringify(box), {
+  await import_promises7.default.writeFile(import_path10.default.join(configDir, IDENTITY_FILE), JSON.stringify(box), {
     mode: 384
   });
-  await import_promises4.default.writeFile(import_path10.default.join(configDir, RECIPIENT_FILE), `${recipient}
+  await import_promises7.default.writeFile(import_path10.default.join(configDir, RECIPIENT_FILE), `${recipient}
 `, {
     mode: 384
   });
   return { success: true };
 }
 function decryptIdentity(box, password) {
-  const decipher = import_crypto4.default.createDecipheriv(
+  const decipher = import_crypto5.default.createDecipheriv(
     "aes-256-gcm",
     deriveKey(password, Buffer.from(box.salt, "base64")),
     Buffer.from(box.iv, "base64")
@@ -16821,13 +18815,13 @@ function envPath(spaceDir) {
 }
 async function identityFor(configDir, password) {
   const box = JSON.parse(
-    await import_promises4.default.readFile(import_path10.default.join(configDir, IDENTITY_FILE), "utf-8")
+    await import_promises7.default.readFile(import_path10.default.join(configDir, IDENTITY_FILE), "utf-8")
   );
   return decryptIdentity(box, password);
 }
 async function readEnv(spaceDir, identity) {
   try {
-    await import_promises4.default.access(envPath(spaceDir));
+    await import_promises7.default.access(envPath(spaceDir));
   } catch {
     return {};
   }
@@ -16856,14 +18850,14 @@ async function readEnv(spaceDir, identity) {
   return values;
 }
 async function writeEnv(configDir, spaceDir, identity, values) {
-  const recipient = (await import_promises4.default.readFile(import_path10.default.join(configDir, RECIPIENT_FILE), "utf-8")).trim();
+  const recipient = (await import_promises7.default.readFile(import_path10.default.join(configDir, RECIPIENT_FILE), "utf-8")).trim();
   const plain = `${Object.entries(values).map(([k, v]) => `${k}=${v}`).join("\n")}
 `;
   const tmp = envPath(spaceDir).replace(
     /\.enc\.env$/,
     `.${process.pid}.tmp.env`
   );
-  await import_promises4.default.writeFile(tmp, plain, { mode: 384 });
+  await import_promises7.default.writeFile(tmp, plain, { mode: 384 });
   try {
     const { stdout } = await execFileAsync3(
       "sops",
@@ -16882,9 +18876,9 @@ async function writeEnv(configDir, spaceDir, identity, values) {
         maxBuffer: 4 * 1024 * 1024
       }
     );
-    await import_promises4.default.writeFile(envPath(spaceDir), stdout, { mode: 384 });
+    await import_promises7.default.writeFile(envPath(spaceDir), stdout, { mode: 384 });
   } finally {
-    await import_promises4.default.rm(tmp, { force: true });
+    await import_promises7.default.rm(tmp, { force: true });
   }
 }
 async function listSecretKeys(configDir, spaceDir, password) {
@@ -17619,6 +19613,12 @@ var SpaceCore = class {
     await this.ensureSpaceWorkspace();
     return { ready: true };
   }
+  async bareWorkNames() {
+    const config = this.configProvider.readConfig(this.spaceSlug);
+    if (!config.githubToken || !config.repoUrl) return [];
+    await this.ensureSpaceWorkspace();
+    return listWorkNames(this.target());
+  }
   async cardRemoteBranches() {
     const config = this.configProvider.readConfig(this.spaceSlug);
     if (!config.githubToken || !config.repoUrl) return [];
@@ -17737,6 +19737,9 @@ var BoardAgentEngine = class _BoardAgentEngine {
   cardRemoteBranches() {
     return this.core.cardRemoteBranches();
   }
+  bareWorkNames() {
+    return this.core.bareWorkNames();
+  }
   // Deploy button entry: is the repo's deploy contract (SKILL.md +
   // required-variables.json) on the default branch? See .specs/deploy.md.
   async deployStatus() {
@@ -17806,18 +19809,18 @@ var BoardAgentEngine = class _BoardAgentEngine {
    *  setup-status channel. A second request cancels the pending one. */
   askSudo(reason) {
     this.sudoResolver?.(null);
-    return new Promise((resolve2) => {
-      this.sudoResolver = resolve2;
+    return new Promise((resolve4) => {
+      this.sudoResolver = resolve4;
       this.emitter.emitSetupStatus(`${SETUP_AUTH_PREFIX}${reason}`);
     });
   }
   /** Answer a pending sudo request. An empty password denies it, so setup
    *  fails with a message rather than hanging. */
   setupAuthorize(p) {
-    const resolve2 = this.sudoResolver;
-    if (!resolve2) return { success: false };
+    const resolve4 = this.sudoResolver;
+    if (!resolve4) return { success: false };
     this.sudoResolver = null;
-    resolve2(p.password || null);
+    resolve4(p.password || null);
     return { success: true };
   }
   deployRunState() {
@@ -17871,12 +19874,12 @@ var BoardAgentEngine = class _BoardAgentEngine {
       hooks: {
         sendLog: bufferLog,
         onTodos: (todos) => this.setRun({ todos }),
-        requestHuman: (question) => new Promise((resolve2) => {
-          this.runResolvers.human = resolve2;
+        requestHuman: (question) => new Promise((resolve4) => {
+          this.runResolvers.human = resolve4;
           this.setRun({ phase: "awaiting-input", question });
         }),
-        requestAuth: (command, errorNote) => new Promise((resolve2) => {
-          this.runResolvers.auth = resolve2;
+        requestAuth: (command, errorNote) => new Promise((resolve4) => {
+          this.runResolvers.auth = resolve4;
           this.setRun({
             phase: "awaiting-auth",
             pendingCommand: command,
@@ -17909,35 +19912,35 @@ var BoardAgentEngine = class _BoardAgentEngine {
     return { started: true };
   }
   deployRunAnswer(payload) {
-    const resolve2 = this.runResolvers.human;
-    if (!resolve2 || this.runState.phase !== "awaiting-input") {
+    const resolve4 = this.runResolvers.human;
+    if (!resolve4 || this.runState.phase !== "awaiting-input") {
       throw new Error("No step is awaiting input.");
     }
     this.runResolvers.human = void 0;
     this.setRun({ phase: "running", question: "", error: "" });
-    resolve2(payload.answer);
+    resolve4(payload.answer);
     return { success: true };
   }
   // The password arrives RUNNER-DIRECT here and only feeds decryption; it
   // never enters the agent session (see .specs/deploy.md).
   deployRunAuthorize(payload) {
-    const resolve2 = this.runResolvers.auth;
-    if (!resolve2 || this.runState.phase !== "awaiting-auth") {
+    const resolve4 = this.runResolvers.auth;
+    if (!resolve4 || this.runState.phase !== "awaiting-auth") {
       throw new Error("No command is awaiting authorization.");
     }
     this.runResolvers.auth = void 0;
     this.setRun({ phase: "running", pendingCommand: "", error: "" });
-    resolve2({ password: payload.password });
+    resolve4({ password: payload.password });
     return { success: true };
   }
   deployRunDeny() {
-    const resolve2 = this.runResolvers.auth;
-    if (!resolve2 || this.runState.phase !== "awaiting-auth") {
+    const resolve4 = this.runResolvers.auth;
+    if (!resolve4 || this.runState.phase !== "awaiting-auth") {
       throw new Error("No command is awaiting authorization.");
     }
     this.runResolvers.auth = void 0;
     this.setRun({ phase: "running", pendingCommand: "" });
-    resolve2({ denied: true });
+    resolve4({ denied: true });
     return { success: true };
   }
   deployRunCancel() {
@@ -18392,6 +20395,9 @@ var BoardAgentEngine = class _BoardAgentEngine {
   bareFsWrite(p) {
     return this.terminal.bareFsWrite(p);
   }
+  terminalDropImage(p) {
+    return this.terminal.terminalDropImage(p);
+  }
   bareFsDelete(p) {
     return this.terminal.bareFsDelete(p);
   }
@@ -18822,6 +20828,8 @@ ${c.content.trim() || "(no description)"}`
         return await this.ensureSetup();
       case "cardRemoteBranches":
         return await this.cardRemoteBranches();
+      case "bareWorkNames":
+        return await this.bareWorkNames();
       case "deployStatus":
         return await this.deployStatus();
       case "deployCreateSkill":
@@ -18965,6 +20973,10 @@ ${c.content.trim() || "(no description)"}`
           payload
         );
         return void 0;
+      case "terminalDropImage":
+        return await this.terminalDropImage(
+          payload
+        );
       case "bareFsDelete":
         await this.bareFsDelete(
           payload
@@ -19029,9 +21041,9 @@ ${c.content.trim() || "(no description)"}`
 
 // ../../shared/all/helpers/board-agent-core/index-service.ts
 var import_child_process7 = require("child_process");
-var import_crypto5 = require("crypto");
-var import_fs7 = require("fs");
-var import_promises5 = __toESM(require("fs/promises"));
+var import_crypto6 = require("crypto");
+var import_fs9 = require("fs");
+var import_promises8 = __toESM(require("fs/promises"));
 var import_net2 = require("net");
 var import_path13 = require("path");
 var import_util7 = require("util");
@@ -19047,7 +21059,7 @@ var IndexService = class {
   /** Per-space bearer for MCP + file, derived from the control token (the
    *  service computes the same). */
   bearerToken(spaceSlug) {
-    return (0, import_crypto5.createHmac)("sha256", this.opts.controlToken).update(`mcp:${spaceSlug}`).digest("hex");
+    return (0, import_crypto6.createHmac)("sha256", this.opts.controlToken).update(`mcp:${spaceSlug}`).digest("hex");
   }
   /** MCP bridge for a space. Null until the service is up (which it kicks
    *  off), so a bad :0 URL is never baked in; provisionMcpLane re-runs. */
@@ -19120,8 +21132,8 @@ var IndexService = class {
    *  opened (a missing log must never stop the service from starting). */
   async openLog() {
     try {
-      await import_promises5.default.mkdir(this.opts.dataDir, { recursive: true });
-      return (0, import_fs7.openSync)((0, import_path13.join)(this.opts.dataDir, "index.log"), "a");
+      await import_promises8.default.mkdir(this.opts.dataDir, { recursive: true });
+      return (0, import_fs9.openSync)((0, import_path13.join)(this.opts.dataDir, "index.log"), "a");
     } catch {
       return null;
     }
@@ -19130,8 +21142,8 @@ var IndexService = class {
    *  platform needing node-gyp fails here rather than at query time. */
   async installDeps() {
     const dir = this.opts.indexDir;
-    if ((0, import_fs7.existsSync)((0, import_path13.join)(dir, "node_modules"))) return;
-    await import_promises5.default.copyFile(
+    if ((0, import_fs9.existsSync)((0, import_path13.join)(dir, "node_modules"))) return;
+    await import_promises8.default.copyFile(
       (0, import_path13.join)(dir, "image-package.json"),
       (0, import_path13.join)(dir, "package.json")
     );
@@ -19146,14 +21158,14 @@ var IndexService = class {
    *  registration pointing at a dead one. */
   async stablePort() {
     const file = (0, import_path13.join)(this.opts.dataDir, ".port");
-    const saved = Number(await import_promises5.default.readFile(file, "utf-8").catch(() => ""));
+    const saved = Number(await import_promises8.default.readFile(file, "utf-8").catch(() => ""));
     if (Number.isInteger(saved) && saved > 0 && await isFree(saved)) {
       return saved;
     }
     const port = await freePort();
-    await import_promises5.default.mkdir(this.opts.dataDir, { recursive: true }).catch(() => {
+    await import_promises8.default.mkdir(this.opts.dataDir, { recursive: true }).catch(() => {
     });
-    await import_promises5.default.writeFile(file, String(port), "utf-8").catch(() => {
+    await import_promises8.default.writeFile(file, String(port), "utf-8").catch(() => {
     });
     return port;
   }
@@ -19246,20 +21258,20 @@ var IndexService = class {
   }
 };
 function isFree(port) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve4) => {
     const srv = (0, import_net2.createServer)();
-    srv.once("error", () => resolve2(false));
-    srv.listen(port, "127.0.0.1", () => srv.close(() => resolve2(true)));
+    srv.once("error", () => resolve4(false));
+    srv.listen(port, "127.0.0.1", () => srv.close(() => resolve4(true)));
   });
 }
 function freePort() {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve4, reject) => {
     const srv = (0, import_net2.createServer)();
     srv.on("error", reject);
     srv.listen(0, "127.0.0.1", () => {
       const addr = srv.address();
       const port = typeof addr === "object" && addr ? addr.port : 0;
-      srv.close(() => resolve2(port));
+      srv.close(() => resolve4(port));
     });
   });
 }
@@ -19310,7 +21322,7 @@ async function setup(serverUrl) {
 // src/selfUpdate.ts
 var import_node_child_process = require("node:child_process");
 var import_node_fs = __toESM(require("node:fs"));
-var import_node_path = __toESM(require("node:path"));
+var import_node_path2 = __toESM(require("node:path"));
 var PACKAGE_NAME = "@factiii/runner";
 var RESTART_FOR_UPDATE = 75;
 var WORKER_ENV = "FACTIII_RUNNER_WORKER";
@@ -19323,7 +21335,7 @@ function isWorker() {
 function currentVersion() {
   try {
     const pkg = JSON.parse(
-      import_node_fs.default.readFileSync(import_node_path.default.join(__dirname, "..", "package.json"), "utf-8")
+      import_node_fs.default.readFileSync(import_node_path2.default.join(__dirname, "..", "package.json"), "utf-8")
     );
     return pkg.version ?? "0.0.0";
   } catch {
@@ -19398,8 +21410,8 @@ function makeChunkReassembler() {
 }
 
 // src/daemon.ts
-var import_crypto6 = require("crypto");
-var import_fs9 = __toESM(require("fs"));
+var import_crypto7 = require("crypto");
+var import_fs11 = __toESM(require("fs"));
 var import_node_datachannel = require("node-datachannel");
 var import_path15 = __toESM(require("path"));
 
@@ -21898,9 +23910,9 @@ var Socket2 = class extends import_component_emitter5.Emitter {
    * @return a Promise that will be fulfilled when the server acknowledges the event
    */
   emitWithAck(ev, ...args) {
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve4, reject) => {
       const fn = (arg1, arg2) => {
-        return arg1 ? reject(arg1) : resolve2(arg2);
+        return arg1 ? reject(arg1) : resolve4(arg2);
       };
       fn.withError = true;
       args.push(fn);
@@ -23081,7 +25093,7 @@ var TerminalManager = class {
 };
 
 // src/agent-adapter.ts
-var import_fs8 = __toESM(require("fs"));
+var import_fs10 = __toESM(require("fs"));
 var import_path14 = __toESM(require("path"));
 var RUNNER_CONFIG_PATH = import_path14.default.join(CONFIG_DIR, "runner-config.json");
 function connectionPath(spaceSlug) {
@@ -23112,7 +25124,7 @@ function migrateLegacyConfigs() {
   const file = { boards: {} };
   let legacy = [];
   try {
-    legacy = import_fs8.default.readdirSync(CONFIG_DIR).filter((f) => f.startsWith("space-") && f.endsWith(".json")).filter((f) => !f.endsWith(".onedrive.json"));
+    legacy = import_fs10.default.readdirSync(CONFIG_DIR).filter((f) => f.startsWith("space-") && f.endsWith(".json")).filter((f) => !f.endsWith(".onedrive.json"));
   } catch {
     return file;
   }
@@ -23139,14 +25151,14 @@ function encryptStrayPlaintextConfigs() {
   const OURS = /^(config|runner-config|space-.*)\.json(\.bak-\d+)?$/;
   let names = [];
   try {
-    names = import_fs8.default.readdirSync(CONFIG_DIR).filter((f) => OURS.test(f));
+    names = import_fs10.default.readdirSync(CONFIG_DIR).filter((f) => OURS.test(f));
   } catch {
     return;
   }
   for (const name of names) {
     const filePath = import_path14.default.join(CONFIG_DIR, name);
     try {
-      const raw = import_fs8.default.readFileSync(filePath, "utf-8");
+      const raw = import_fs10.default.readFileSync(filePath, "utf-8");
       if (!raw.startsWith("{")) continue;
       writeSecureJson(filePath, JSON.parse(raw));
     } catch {
@@ -23177,7 +25189,7 @@ async function getConfiguredConnections() {
   }
   if (await isSignedIn(hostTarget(CONFIG_DIR), "claude")) kinds.add("claude");
   try {
-    const hasOneDrive = import_fs8.default.readdirSync(CONFIG_DIR).some((f) => f.endsWith(".onedrive.json"));
+    const hasOneDrive = import_fs10.default.readdirSync(CONFIG_DIR).some((f) => f.endsWith(".onedrive.json"));
     if (hasOneDrive) kinds.add("onedrive");
   } catch {
   }
@@ -23248,7 +25260,7 @@ var localConfigProvider = {
   writeOneDriveConnection(spaceSlug, connection) {
     const filePath = connectionPath(spaceSlug);
     if (!connection) {
-      import_fs8.default.rmSync(filePath, { force: true });
+      import_fs10.default.rmSync(filePath, { force: true });
       return;
     }
     writeJson(filePath, connection);
@@ -23273,7 +25285,7 @@ var localConfigProvider = {
       "claude",
       "codex"
     ]) {
-      import_fs8.default.mkdirSync(import_path14.default.join(dir, sub), { recursive: true });
+      import_fs10.default.mkdirSync(import_path14.default.join(dir, sub), { recursive: true });
     }
     return dir;
   }
@@ -23397,17 +25409,17 @@ async function startDaemon(config) {
     }
   };
   const mintWebhook = (spaceSlug) => new Promise(
-    (resolve2) => {
+    (resolve4) => {
       if (!socket.connected) {
-        resolve2(null);
+        resolve4(null);
         return;
       }
       socket.timeout(8e3).emit("onedriveWebhookRegister", { spaceSlug }, (err, res) => {
         if (err || !res || "error" in res) {
-          resolve2(null);
+          resolve4(null);
           return;
         }
-        resolve2({
+        resolve4({
           notificationUrl: `${config.serverUrl.replace(/\/$/, "")}/onedrive/webhook`,
           clientState: res.clientState
         });
@@ -23418,9 +25430,9 @@ async function startDaemon(config) {
     import_path15.default.join(__dirname, "..", "index"),
     import_path15.default.join(__dirname, "..", "..", "index", "image")
   ];
-  const indexDir = indexCandidates.find((p) => import_fs9.default.existsSync(p)) ?? indexCandidates[0];
+  const indexDir = indexCandidates.find((p) => import_fs11.default.existsSync(p)) ?? indexCandidates[0];
   const odIndex = new IndexService({
-    controlToken: (0, import_crypto6.createHash)("sha256").update(config.authToken).digest("hex"),
+    controlToken: (0, import_crypto7.createHash)("sha256").update(config.authToken).digest("hex"),
     embedUrl: () => config.serverUrl,
     indexDir,
     dataDir: import_path15.default.join(CONFIG_DIR, "index-data")
@@ -24073,5 +26085,8 @@ xmlhttprequest-ssl/lib/XMLHttpRequest.js:
    * @contributor David Ellis <d.f.ellis@ieee.org>
    * @license MIT
    *)
+
+chokidar/esm/index.js:
+  (*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) *)
 */
 //# sourceMappingURL=cli.js.map