@sideboard-ai/core 0.1.238 → 0.1.239

package/dist/index.cjs

@@ -13264,10 +13264,10 @@ function eventsFromClaudeSystem(obj) {
   if (subtype === "api_retry") {
     const attempt = obj.attempt;
     const max = obj.max_retries;
-    const delay = obj.retry_delay_ms;
+    const delay2 = obj.retry_delay_ms;
     return {
       type: "thinking",
-      data: `API retry ${attempt ?? "?"}/${max ?? "?"}${typeof delay === "number" ? ` (wait ${delay}ms)` : ""}`
+      data: `API retry ${attempt ?? "?"}/${max ?? "?"}${typeof delay2 === "number" ? ` (wait ${delay2}ms)` : ""}`
     };
   }
   if (subtype === "status") {
@@ -17481,15 +17481,76 @@ var init_request_review = __esm({
   }
 });
 
+// src/hook/worktree-run-ports.ts
+function worktreeRunPortsPath(worktreePath) {
+  return (0, import_node_path44.join)(worktreePath, RUN_PORTS_REL);
+}
+function isPort(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 && value <= 65535;
+}
+function parseFile(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return {};
+    const scripts = parsed.scripts;
+    if (!scripts || typeof scripts !== "object") return {};
+    const next = {};
+    for (const [name, ports] of Object.entries(scripts)) {
+      if (!name || !Array.isArray(ports)) continue;
+      const cleaned = ports.filter(isPort);
+      if (cleaned.length) next[name] = cleaned;
+    }
+    return { scripts: next };
+  } catch {
+    return {};
+  }
+}
+function loadWorktreeRunPorts(worktreePath, scriptName) {
+  if (!worktreePath.trim() || !scriptName.trim()) return null;
+  try {
+    const raw = (0, import_node_fs44.readFileSync)(worktreeRunPortsPath(worktreePath), "utf8");
+    const ports = parseFile(raw).scripts?.[scriptName];
+    return ports?.length ? ports : null;
+  } catch {
+    return null;
+  }
+}
+function saveWorktreeRunPorts(worktreePath, scriptName, ports) {
+  if (!worktreePath.trim() || !scriptName.trim()) return;
+  const cleaned = ports.filter(isPort);
+  if (!cleaned.length) return;
+  const path2 = worktreeRunPortsPath(worktreePath);
+  let current = {};
+  try {
+    current = parseFile((0, import_node_fs44.readFileSync)(path2, "utf8"));
+  } catch {
+    current = {};
+  }
+  const scripts = { ...current.scripts ?? {} };
+  scripts[scriptName] = cleaned;
+  (0, import_node_fs44.mkdirSync)((0, import_node_path44.dirname)(path2), { recursive: true });
+  (0, import_node_fs44.writeFileSync)(path2, `${JSON.stringify({ scripts }, null, 2)}
+`, "utf8");
+}
+var import_node_fs44, import_node_path44, RUN_PORTS_REL;
+var init_worktree_run_ports = __esm({
+  "src/hook/worktree-run-ports.ts"() {
+    "use strict";
+    import_node_fs44 = require("fs");
+    import_node_path44 = require("path");
+    RUN_PORTS_REL = ".context/.sideboard/run-ports.json";
+  }
+});
+
 // src/hook/conductor.ts
 function matchSimpleGlob(pattern, name) {
   const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
   return new RegExp(`^${escaped}$`).test(name);
 }
 function readWorktreeInclude(repoPath) {
-  const path2 = (0, import_node_path44.join)(repoPath, ".worktreeinclude");
-  if (!(0, import_node_fs44.existsSync)(path2)) return [];
-  return (0, import_node_fs44.readFileSync)(path2, "utf8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+  const path2 = (0, import_node_path45.join)(repoPath, ".worktreeinclude");
+  if (!(0, import_node_fs45.existsSync)(path2)) return [];
+  return (0, import_node_fs45.readFileSync)(path2, "utf8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
 }
 function resolveFilesToCopy(repoPath) {
   const fromInclude = readWorktreeInclude(repoPath);
@@ -17499,10 +17560,10 @@ function resolveFilesToCopy(repoPath) {
   if (settings?.fileIncludeGlobs?.length) {
     const matched = [];
     try {
-      for (const entry of (0, import_node_fs44.readdirSync)(repoPath, { withFileTypes: true })) {
+      for (const entry of (0, import_node_fs45.readdirSync)(repoPath, { withFileTypes: true })) {
         if (!entry.isFile()) continue;
         for (const glob of settings.fileIncludeGlobs) {
-          if (matchSimpleGlob(glob, entry.name) || matchSimpleGlob((0, import_node_path44.basename)(glob), entry.name)) {
+          if (matchSimpleGlob(glob, entry.name) || matchSimpleGlob((0, import_node_path45.basename)(glob), entry.name)) {
             matched.push(entry.name);
             break;
           }
@@ -17514,7 +17575,7 @@ function resolveFilesToCopy(repoPath) {
   }
   const defaults = [];
   try {
-    for (const entry of (0, import_node_fs44.readdirSync)(repoPath, { withFileTypes: true })) {
+    for (const entry of (0, import_node_fs45.readdirSync)(repoPath, { withFileTypes: true })) {
       if (entry.isFile() && entry.name.startsWith(".env")) {
         defaults.push(entry.name);
       }
@@ -17528,11 +17589,11 @@ function copyConfiguredFiles(repoPath, worktreePath) {
   const patterns = resolveFilesToCopy(repoPath);
   const copied = [];
   for (const rel of patterns) {
-    const src = (0, import_node_path44.join)(repoPath, rel);
-    if (!(0, import_node_fs44.existsSync)(src)) continue;
-    const dest = (0, import_node_path44.join)(worktreePath, rel);
-    (0, import_node_fs44.mkdirSync)((0, import_node_path44.dirname)(dest), { recursive: true });
-    (0, import_node_fs44.copyFileSync)(src, dest);
+    const src = (0, import_node_path45.join)(repoPath, rel);
+    if (!(0, import_node_fs45.existsSync)(src)) continue;
+    const dest = (0, import_node_path45.join)(worktreePath, rel);
+    (0, import_node_fs45.mkdirSync)((0, import_node_path45.dirname)(dest), { recursive: true });
+    (0, import_node_fs45.copyFileSync)(src, dest);
     copied.push(rel);
   }
   return copied;
@@ -17567,7 +17628,7 @@ function buildWorkspaceScriptEnv(opts, baseEnv) {
   const env = stripNestedElectronEnv({
     ...baseEnv ?? process.env
   });
-  const name = opts.workspaceName ?? (0, import_node_path44.basename)(opts.worktreePath);
+  const name = opts.workspaceName ?? (0, import_node_path45.basename)(opts.worktreePath);
   const ports = opts.ports ?? [];
   const primary = ports[0];
   env.SIDEBOARD_WORKSPACE_NAME = name;
@@ -17607,6 +17668,57 @@ function killableListenerPids(raw, selfPid = process.pid) {
   }
   return pids;
 }
+function listUnixListenerPids(port, selfPid) {
+  try {
+    const raw = (0, import_node_child_process5.execFileSync)("lsof", [`-tiTCP:${port}`, "-sTCP:LISTEN"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 2e3
+    });
+    return killableListenerPids(raw, selfPid);
+  } catch {
+    return [];
+  }
+}
+function listenerCwd(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) return null;
+  try {
+    const raw = (0, import_node_child_process5.execFileSync)("lsof", ["-a", "-p", String(pid), "-d", "cwd", "-Fn"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 2e3
+    });
+    for (const line of raw.split("\n")) {
+      if (line.startsWith("n") && line.length > 1) return line.slice(1);
+    }
+  } catch {
+  }
+  return null;
+}
+function realpathOrResolve(path2) {
+  try {
+    return (0, import_node_fs45.realpathSync)(path2);
+  } catch {
+    return (0, import_node_path45.resolve)(path2);
+  }
+}
+function isOtherWorktreeListenerCwd(cwd, worktreePath) {
+  const wt = realpathOrResolve(worktreePath);
+  const c = realpathOrResolve(cwd);
+  if (c === wt || c.startsWith(wt + import_node_path45.sep)) return false;
+  const parent = (0, import_node_path45.dirname)(wt);
+  const thisName = (0, import_node_path45.basename)(wt);
+  if (!thisName || c === parent) return false;
+  if (!c.startsWith(parent + import_node_path45.sep)) return false;
+  const first = c.slice(parent.length + 1).split(import_node_path45.sep)[0];
+  return Boolean(first) && first !== thisName;
+}
+function signalPid(pid, signal) {
+  try {
+    process.kill(pid, signal);
+  } catch {
+  }
+}
 function killListenersOnPorts(ports) {
   const selfPid = process.pid;
   for (const port of ports) {
@@ -17624,26 +17736,32 @@ function killListenersOnPorts(ports) {
         );
         continue;
       }
-      let raw = "";
-      try {
-        raw = (0, import_node_child_process5.execFileSync)("lsof", [`-tiTCP:${port}`, "-sTCP:LISTEN"], {
-          encoding: "utf8",
-          stdio: ["ignore", "pipe", "ignore"],
-          timeout: 2e3
-        });
-      } catch {
-        continue;
-      }
-      for (const pid of killableListenerPids(raw, selfPid)) {
-        try {
-          process.kill(pid, "SIGTERM");
-        } catch {
-        }
+      for (const pid of listUnixListenerPids(port, selfPid)) {
+        signalPid(pid, "SIGTERM");
       }
     } catch {
     }
   }
 }
+function killStaleWorktreeListeners(ports, worktreePath, signal = "SIGTERM") {
+  if (!worktreePath.trim()) {
+    killListenersOnPorts(ports);
+    return;
+  }
+  if (process.platform === "win32") {
+    killListenersOnPorts(ports);
+    return;
+  }
+  const selfPid = process.pid;
+  for (const port of ports) {
+    if (!Number.isFinite(port) || port <= 0) continue;
+    for (const pid of listUnixListenerPids(port, selfPid)) {
+      const cwd = listenerCwd(pid);
+      if (cwd && isOtherWorktreeListenerCwd(cwd, worktreePath)) continue;
+      signalPid(pid, signal);
+    }
+  }
+}
 function killScriptTree(child, ports = []) {
   const pid = child.pid;
   if (pid) {
@@ -17805,7 +17923,7 @@ function getRunMode(worktreePath, repoPath) {
   return loadWorkspaceSettings(worktreePath, repoPath)?.runMode ?? "concurrent";
 }
 async function reservePort() {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const server = (0, import_node_net.createServer)();
     let released = false;
     const release = () => new Promise((res) => {
@@ -17822,7 +17940,7 @@ async function reservePort() {
         void release().then(() => reject(new Error("Failed to allocate port")));
         return;
       }
-      resolve({ port: addr.port, release });
+      resolve2({ port: addr.port, release });
     });
     server.on("error", reject);
   });
@@ -17833,7 +17951,8 @@ async function allocatePort() {
   return held.port;
 }
 async function tryReservePort(port) {
-  return new Promise((resolve) => {
+  if (!Number.isInteger(port) || port <= 0 || port > 65535) return null;
+  return new Promise((resolve2) => {
     const server = (0, import_node_net.createServer)();
     let released = false;
     const release = () => new Promise((res) => {
@@ -17844,24 +17963,54 @@ async function tryReservePort(port) {
       released = true;
       server.close(() => res());
     });
-    server.once("error", () => resolve(null));
+    server.once("error", () => {
+      try {
+        server.close();
+      } catch {
+      }
+      resolve2(null);
+    });
     server.listen(port, "127.0.0.1", () => {
-      resolve({ port, release });
+      resolve2({ port, release });
     });
   });
 }
-async function reservePortRange(size = PORT_RANGE_SIZE) {
-  const held = [await reservePort()];
-  const base = held[0].port;
+async function tryReservePorts(ports) {
+  const held = [];
+  for (const port of ports) {
+    const next = await tryReservePort(port);
+    if (!next) {
+      await Promise.all(held.map((h) => h.release()));
+      return null;
+    }
+    held.push(next);
+  }
+  return held;
+}
+function normalizePreferredPorts(ports, size) {
+  if (!ports?.length) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const p of ports) {
+    if (!Number.isInteger(p) || p <= 0 || p > 65535 || seen.has(p)) continue;
+    seen.add(p);
+    out.push(p);
+    if (out.length >= size) break;
+  }
+  return out;
+}
+function delay(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function fillPortRange(held, size) {
+  if (held.length >= size) return held;
+  const base = held[0]?.port;
   try {
-    for (let i = 1; i < size; i++) {
-      const candidate = base + i;
-      const next = await tryReservePort(candidate);
-      if (next) {
-        held.push(next);
-      } else {
-        held.push(await reservePort());
-      }
+    for (let i = held.length; i < size; i++) {
+      const candidate = base != null ? base + i : null;
+      const next = candidate != null ? await tryReservePort(candidate) : null;
+      if (next) held.push(next);
+      else held.push(await reservePort());
     }
     return held;
   } catch (err) {
@@ -17869,6 +18018,33 @@ async function reservePortRange(size = PORT_RANGE_SIZE) {
     throw err;
   }
 }
+async function reclaimPreferredPorts(ports, worktreePath) {
+  let held = await tryReservePorts(ports);
+  if (held) return held;
+  if (worktreePath) {
+    killStaleWorktreeListeners(ports, worktreePath, "SIGTERM");
+  } else {
+    killListenersOnPorts(ports);
+  }
+  for (let i = 0; i < RECLAIM_TRIES; i++) {
+    await delay(RECLAIM_RETRY_DELAY_MS);
+    held = await tryReservePorts(ports);
+    if (held) return held;
+    if (i === 2 && worktreePath) {
+      killStaleWorktreeListeners(ports, worktreePath, "SIGKILL");
+    }
+  }
+  return null;
+}
+async function reservePortRange(size = PORT_RANGE_SIZE, opts) {
+  const preferred = normalizePreferredPorts(opts?.preferred, size);
+  if (preferred.length) {
+    const reused = await reclaimPreferredPorts(preferred, opts?.worktreePath);
+    if (reused) return fillPortRange(reused, size);
+  }
+  const held = [await reservePort()];
+  return fillPortRange(held, size);
+}
 async function allocatePortRange(size = PORT_RANGE_SIZE) {
   const held = await reservePortRange(size);
   const ports = held.map((h) => h.port);
@@ -17878,8 +18054,13 @@ async function allocatePortRange(size = PORT_RANGE_SIZE) {
 async function startDevServer(repoPath, worktreePath, onLine, opts) {
   const script = getRunScript(worktreePath, repoPath, opts?.scriptName);
   if (!script) return null;
-  const held = await reservePortRange(PORT_RANGE_SIZE);
+  const preferred = loadWorktreeRunPorts(worktreePath, script.name) ?? opts?.preferredPorts;
+  const held = await reservePortRange(PORT_RANGE_SIZE, {
+    preferred: preferred ?? void 0,
+    worktreePath
+  });
   const ports = held.map((h) => h.port);
+  saveWorktreeRunPorts(worktreePath, script.name, ports);
   try {
     const handle = await spawnWorkspaceScript(script.command, {
       worktreePath,
@@ -17902,14 +18083,14 @@ async function startDevServer(repoPath, worktreePath, onLine, opts) {
     throw err;
   }
 }
-var import_node_fs44, import_node_child_process5, import_node_net, import_node_path44, import_execa4, import_node_readline3, PORT_RANGE_SIZE, cachedLoginEnv;
+var import_node_fs45, import_node_child_process5, import_node_net, import_node_path45, import_execa4, import_node_readline3, PORT_RANGE_SIZE, RECLAIM_RETRY_DELAY_MS, RECLAIM_TRIES, cachedLoginEnv;
 var init_conductor = __esm({
   "src/hook/conductor.ts"() {
     "use strict";
-    import_node_fs44 = require("fs");
+    import_node_fs45 = require("fs");
     import_node_child_process5 = require("child_process");
     import_node_net = require("net");
-    import_node_path44 = require("path");
+    import_node_path45 = require("path");
     import_execa4 = require("execa");
     import_node_readline3 = require("readline");
     init_settings();
@@ -17920,8 +18101,12 @@ var init_conductor = __esm({
     init_git_auth_mode();
     init_request_review();
     init_worktree_exclude();
+    init_worktree_run_ports();
+    init_worktree_run_ports();
     init_nested_electron_env();
     PORT_RANGE_SIZE = 10;
+    RECLAIM_RETRY_DELAY_MS = 40;
+    RECLAIM_TRIES = 8;
     cachedLoginEnv = null;
   }
 });
@@ -17937,9 +18122,9 @@ async function findOrphanWorktrees(repoPaths) {
     repoPaths?.length ? repoPaths : threads.map((t) => t.repoPath).filter(Boolean)
   );
   const homeRoot = sideboardWorkspacesDir();
-  if ((0, import_node_fs45.existsSync)(homeRoot)) {
+  if ((0, import_node_fs46.existsSync)(homeRoot)) {
     try {
-      for (const entry of (0, import_node_fs45.readdirSync)(homeRoot, { withFileTypes: true })) {
+      for (const entry of (0, import_node_fs46.readdirSync)(homeRoot, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
         void entry;
       }
@@ -17949,7 +18134,7 @@ async function findOrphanWorktrees(repoPaths) {
   const orphans = [];
   const seen = /* @__PURE__ */ new Set();
   for (const repoPath of repos) {
-    if (!repoPath || !(0, import_node_fs45.existsSync)(repoPath)) continue;
+    if (!repoPath || !(0, import_node_fs46.existsSync)(repoPath)) continue;
     try {
       const wts = await listWorktrees(repoPath);
       for (const wt of wts) {
@@ -17960,7 +18145,7 @@ async function findOrphanWorktrees(repoPaths) {
         seen.add(path2);
         let mtimeMs = 0;
         try {
-          mtimeMs = (0, import_node_fs45.statSync)(path2).mtimeMs;
+          mtimeMs = (0, import_node_fs46.statSync)(path2).mtimeMs;
         } catch {
           mtimeMs = 0;
         }
@@ -17970,16 +18155,16 @@ async function findOrphanWorktrees(repoPaths) {
     }
     try {
       const root = worktreesRoot(repoPath);
-      if ((0, import_node_fs45.existsSync)(root)) {
-        for (const entry of (0, import_node_fs45.readdirSync)(root, { withFileTypes: true })) {
+      if ((0, import_node_fs46.existsSync)(root)) {
+        for (const entry of (0, import_node_fs46.readdirSync)(root, { withFileTypes: true })) {
           if (!entry.isDirectory()) continue;
-          const path2 = (0, import_node_path45.join)(root, entry.name).replace(/\/$/, "");
+          const path2 = (0, import_node_path46.join)(root, entry.name).replace(/\/$/, "");
           if (known.has(path2) || seen.has(path2)) continue;
-          if (!(0, import_node_fs45.existsSync)((0, import_node_path45.join)(path2, ".git"))) continue;
+          if (!(0, import_node_fs46.existsSync)((0, import_node_path46.join)(path2, ".git"))) continue;
           seen.add(path2);
           let mtimeMs = 0;
           try {
-            mtimeMs = (0, import_node_fs45.statSync)(path2).mtimeMs;
+            mtimeMs = (0, import_node_fs46.statSync)(path2).mtimeMs;
           } catch {
             mtimeMs = Date.now();
           }
@@ -18040,12 +18225,12 @@ function worktreeCleanupSettings() {
     autoCleanupOrphans: a.autoCleanupOrphans
   };
 }
-var import_node_fs45, import_node_path45;
+var import_node_fs46, import_node_path46;
 var init_orphan_cleanup = __esm({
   "src/git/orphan-cleanup.ts"() {
     "use strict";
-    import_node_fs45 = require("fs");
-    import_node_path45 = require("path");
+    import_node_fs46 = require("fs");
+    import_node_path46 = require("path");
     init_worktree();
     init_thread_store();
     init_paths();
@@ -18220,12 +18405,12 @@ async function cloneRepoIntoSideboard(opts) {
   if (!url) throw new Error("Clone URL is required");
   let name = opts.name?.trim();
   if (!name) {
-    const leaf = (0, import_node_path46.basename)(url.replace(/\/$/, "").replace(/\.git$/, ""));
+    const leaf = (0, import_node_path47.basename)(url.replace(/\/$/, "").replace(/\.git$/, ""));
     name = leaf || "repo";
   }
   name = name.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "repo";
-  const dest = (0, import_node_path46.join)(sideboardReposDir(), name);
-  if ((0, import_node_fs46.existsSync)(dest)) {
+  const dest = (0, import_node_path47.join)(sideboardReposDir(), name);
+  if ((0, import_node_fs47.existsSync)(dest)) {
     const repoPath2 = await resolveRepoRoot(dest);
     const workspace2 = await ensureWorkspace(repoPath2);
     return { repoPath: repoPath2, workspace: workspace2 };
@@ -18240,12 +18425,12 @@ async function cloneRepoIntoSideboard(opts) {
   const workspace = await ensureWorkspace(repoPath);
   return { repoPath, workspace };
 }
-var import_node_fs46, import_node_path46, import_execa6;
+var import_node_fs47, import_node_path47, import_execa6;
 var init_clone_repo = __esm({
   "src/git/clone-repo.ts"() {
     "use strict";
-    import_node_fs46 = require("fs");
-    import_node_path46 = require("path");
+    import_node_fs47 = require("fs");
+    import_node_path47 = require("path");
     import_execa6 = require("execa");
     init_paths();
     init_workspaces();
@@ -18374,24 +18559,24 @@ function jobTreeAlive(pid) {
   return jobAlive(pid) || processGroupAlive(pid);
 }
 function readIntFile(file) {
-  if (!(0, import_node_fs47.existsSync)(file)) return null;
-  const n = Number.parseInt((0, import_node_fs47.readFileSync)(file, "utf8").trim(), 10);
+  if (!(0, import_node_fs48.existsSync)(file)) return null;
+  const n = Number.parseInt((0, import_node_fs48.readFileSync)(file, "utf8").trim(), 10);
   return Number.isInteger(n) ? n : null;
 }
 function jobDir(root, id, legacy = false) {
-  return (0, import_node_path47.join)(root, legacy ? LEGACY_DETACHED_JOBS_DIR : DETACHED_JOBS_DIR, id);
+  return (0, import_node_path48.join)(root, legacy ? LEGACY_DETACHED_JOBS_DIR : DETACHED_JOBS_DIR, id);
 }
 function resolveJobDir(root, id) {
   const modern = jobDir(root, id, false);
-  if ((0, import_node_fs47.existsSync)(modern)) return modern;
+  if ((0, import_node_fs48.existsSync)(modern)) return modern;
   const legacy = jobDir(root, id, true);
-  if ((0, import_node_fs47.existsSync)(legacy)) return legacy;
+  if ((0, import_node_fs48.existsSync)(legacy)) return legacy;
   return modern;
 }
 function listJobIdsIn(root, rel) {
-  const dir = (0, import_node_path47.join)(root, rel);
-  if (!(0, import_node_fs47.existsSync)(dir)) return [];
-  return (0, import_node_fs47.readdirSync)(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && JOB_ID_RE.test(e.name)).map((e) => e.name);
+  const dir = (0, import_node_path48.join)(root, rel);
+  if (!(0, import_node_fs48.existsSync)(dir)) return [];
+  return (0, import_node_fs48.readdirSync)(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && JOB_ID_RE.test(e.name)).map((e) => e.name);
 }
 function listRunningDetachedJobs(worktreePath) {
   const root = worktreePath.trim();
@@ -18403,7 +18588,7 @@ function listRunningDetachedJobs(worktreePath) {
   const running = [];
   for (const id of ids) {
     const dir = resolveJobDir(root, id);
-    const pid = readIntFile((0, import_node_path47.join)(dir, "pid"));
+    const pid = readIntFile((0, import_node_path48.join)(dir, "pid"));
     if (jobTreeAlive(pid)) running.push(id);
   }
   return running.sort();
@@ -18486,8 +18671,8 @@ function planJobContinue(opts) {
   return { action: "none" };
 }
 function tailProgress(logFile, maxLines = 12) {
-  if (!(0, import_node_fs47.existsSync)(logFile)) return "(no log yet)";
-  const lines = (0, import_node_fs47.readFileSync)(logFile, "utf8").split("\n");
+  if (!(0, import_node_fs48.existsSync)(logFile)) return "(no log yet)";
+  const lines = (0, import_node_fs48.readFileSync)(logFile, "utf8").split("\n");
   return lines.slice(-maxLines).join("\n");
 }
 function lastProgressLine(progress) {
@@ -18495,8 +18680,8 @@ function lastProgressLine(progress) {
   return last ? last.slice(0, 72) : void 0;
 }
 function readLogLines(file) {
-  if (!(0, import_node_fs47.existsSync)(file)) return [];
-  const lines = (0, import_node_fs47.readFileSync)(file, "utf8").split("\n");
+  if (!(0, import_node_fs48.existsSync)(file)) return [];
+  const lines = (0, import_node_fs48.readFileSync)(file, "utf8").split("\n");
   if (lines.length && lines[lines.length - 1] === "") lines.pop();
   return lines;
 }
@@ -18507,15 +18692,15 @@ function takeDelta(logFile, cursorFile) {
   return { delta: capJobLogDelta(lines.slice(start).join("\n")), nextCursor: lines.length };
 }
 function snapshotJob(dir) {
-  const pid = readIntFile((0, import_node_path47.join)(dir, "pid"));
+  const pid = readIntFile((0, import_node_path48.join)(dir, "pid"));
   const running = jobTreeAlive(pid);
   return {
     pid,
     running,
-    exitCode: readIntFile((0, import_node_path47.join)(dir, "exit")),
-    log: (0, import_node_path47.join)(dir, "log"),
-    cursor: (0, import_node_path47.join)(dir, "present.cursor"),
-    progress: tailProgress((0, import_node_path47.join)(dir, "log"))
+    exitCode: readIntFile((0, import_node_path48.join)(dir, "exit")),
+    log: (0, import_node_path48.join)(dir, "log"),
+    cursor: (0, import_node_path48.join)(dir, "present.cursor"),
+    progress: tailProgress((0, import_node_path48.join)(dir, "log"))
   };
 }
 function toResult(id, snap, extra) {
@@ -18524,8 +18709,8 @@ function toResult(id, snap, extra) {
   const stillRunning = snap.running && !ok;
   const { delta, nextCursor } = takeDelta(snap.log, snap.cursor);
   try {
-    (0, import_node_fs47.mkdirSync)((0, import_node_path47.dirname)(snap.cursor), { recursive: true });
-    (0, import_node_fs47.writeFileSync)(snap.cursor, `${nextCursor}
+    (0, import_node_fs48.mkdirSync)((0, import_node_path48.dirname)(snap.cursor), { recursive: true });
+    (0, import_node_fs48.writeFileSync)(snap.cursor, `${nextCursor}
 `);
   } catch {
   }
@@ -18546,7 +18731,7 @@ function toResult(id, snap, extra) {
   };
 }
 async function sleepMs(ms) {
-  await new Promise((resolve) => setTimeout(resolve, ms));
+  await new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 async function waitForDetachedJob(cwd, id, opts) {
   const jobId = sanitizeDetachedJobId(id);
@@ -18554,7 +18739,7 @@ async function waitForDetachedJob(cwd, id, opts) {
   const dir = resolveJobDir(root, jobId);
   const timeoutMs = mcpWaitForJobTimeoutMs(opts?.timeoutMs);
   const sleep2 = opts?.sleep ?? sleepMs;
-  if (!(0, import_node_fs47.existsSync)(dir)) {
+  if (!(0, import_node_fs48.existsSync)(dir)) {
     return {
       stillRunning: false,
       ok: false,
@@ -18600,10 +18785,10 @@ function killProcessTree(pid, signal) {
 }
 function appendJobLog(logFile, line) {
   try {
-    (0, import_node_fs47.mkdirSync)((0, import_node_path47.dirname)(logFile), { recursive: true });
+    (0, import_node_fs48.mkdirSync)((0, import_node_path48.dirname)(logFile), { recursive: true });
     const body = line.endsWith("\n") ? line : `${line}
 `;
-    (0, import_node_fs47.appendFileSync)(logFile, body);
+    (0, import_node_fs48.appendFileSync)(logFile, body);
   } catch {
   }
 }
@@ -18613,7 +18798,7 @@ async function stopDetachedJob(cwd, id, opts) {
   const dir = resolveJobDir(root, jobId);
   const sleep2 = opts?.sleep ?? sleepMs;
   const why = opts?.reason?.trim() ?? "";
-  if (!(0, import_node_fs47.existsSync)(dir)) {
+  if (!(0, import_node_fs48.existsSync)(dir)) {
     return {
       stillRunning: false,
       ok: false,
@@ -18649,10 +18834,10 @@ async function stopDetachedJob(cwd, id, opts) {
     killProcessTree(targetPid, "SIGKILL");
     await sleep2(100);
   }
-  const exitFile = (0, import_node_path47.join)(dir, "exit");
-  if (!(0, import_node_fs47.existsSync)(exitFile)) {
+  const exitFile = (0, import_node_path48.join)(dir, "exit");
+  if (!(0, import_node_fs48.existsSync)(exitFile)) {
     try {
-      (0, import_node_fs47.writeFileSync)(exitFile, "1\n");
+      (0, import_node_fs48.writeFileSync)(exitFile, "1\n");
     } catch {
     }
   }
@@ -18672,12 +18857,12 @@ async function stopDetachedJob(cwd, id, opts) {
     hint: stopped ? MCP_STOP_JOB_HINT : MCP_WAIT_JOB_STILL_RUNNING_HINT
   };
 }
-var import_node_fs47, import_node_path47, MAX_JOB_CONTINUES, MAX_JOB_DELTA_LINES, MAX_JOB_DELTA_CHARS, DEFERRED_DONE_MAX_CHARS, GH_WATCH_REFRESH, MCP_WAIT_JOB_STILL_RUNNING_HINT, MCP_STOP_JOB_HINT, JOB_ID_RE;
+var import_node_fs48, import_node_path48, MAX_JOB_CONTINUES, MAX_JOB_DELTA_LINES, MAX_JOB_DELTA_CHARS, DEFERRED_DONE_MAX_CHARS, GH_WATCH_REFRESH, MCP_WAIT_JOB_STILL_RUNNING_HINT, MCP_STOP_JOB_HINT, JOB_ID_RE;
 var init_wait_for_job = __esm({
   "src/mcp/wait-for-job.ts"() {
     "use strict";
-    import_node_fs47 = require("fs");
-    import_node_path47 = require("path");
+    import_node_fs48 = require("fs");
+    import_node_path48 = require("path");
     init_workspace_scratch();
     init_wait_for_turn();
     MAX_JOB_CONTINUES = 8;
@@ -18922,14 +19107,14 @@ async function startAbleTimeOAuth(opts) {
   const pkce = createAbleTimePkce();
   const authorizeUrl = ableTimeOAuthAuthorizeUrl(clientId, state, pkce.challenge, host);
   const timeoutMs = opts?.timeoutMs ?? 5 * 6e4;
-  const code = await new Promise((resolve, reject) => {
+  const code = await new Promise((resolve2, reject) => {
     let settled = false;
     const finish = (err, value) => {
       if (settled) return;
       settled = true;
       cleanup();
       if (err) reject(err);
-      else resolve(value);
+      else resolve2(value);
     };
     const server = (0, import_node_http.createServer)((req, res) => {
       try {
@@ -20222,7 +20407,7 @@ function reuseLiveThread(input, repoPath, match) {
 }
 async function createThread(input, _onSetupLine) {
   const repoPath = await resolveRepoRoot(input.repoPath);
-  if (!(0, import_node_fs48.existsSync)(repoPath)) {
+  if (!(0, import_node_fs49.existsSync)(repoPath)) {
     throw new Error(`Repo not found: ${repoPath}`);
   }
   const reused = reuseLiveThread(input, repoPath, {
@@ -20407,11 +20592,11 @@ async function listLinearIssues(agent, repoPath) {
   }
   return adapter.listLinearIssues(repoPath);
 }
-var import_node_fs48;
+var import_node_fs49;
 var init_create = __esm({
   "src/threads/create.ts"() {
     "use strict";
-    import_node_fs48 = require("fs");
+    import_node_fs49 = require("fs");
     init_detect();
     init_worktree();
     init_home_board();
@@ -20563,20 +20748,20 @@ function writeTurnLive(threadId, progress) {
   const path2 = threadLivePath(threadId);
   const tmp = `${path2}.${process.pid}.tmp`;
   try {
-    (0, import_node_fs49.writeFileSync)(tmp, JSON.stringify(progress), "utf8");
-    (0, import_node_fs49.renameSync)(tmp, path2);
+    (0, import_node_fs50.writeFileSync)(tmp, JSON.stringify(progress), "utf8");
+    (0, import_node_fs50.renameSync)(tmp, path2);
   } catch {
     try {
-      (0, import_node_fs49.unlinkSync)(tmp);
+      (0, import_node_fs50.unlinkSync)(tmp);
     } catch {
     }
   }
 }
 function readTurnLive(threadId) {
   const path2 = threadLivePath(threadId);
-  if (!(0, import_node_fs49.existsSync)(path2)) return null;
+  if (!(0, import_node_fs50.existsSync)(path2)) return null;
   try {
-    const raw = JSON.parse((0, import_node_fs49.readFileSync)(path2, "utf8"));
+    const raw = JSON.parse((0, import_node_fs50.readFileSync)(path2, "utf8"));
     if (!raw || typeof raw.summary !== "string") return null;
     return raw;
   } catch {
@@ -20588,17 +20773,17 @@ function clearTurnLive(threadId) {
   if (buf?.timer) clearTimeout(buf.timer);
   buffers.delete(threadId);
   const path2 = threadLivePath(threadId);
-  if (!(0, import_node_fs49.existsSync)(path2)) return;
+  if (!(0, import_node_fs50.existsSync)(path2)) return;
   try {
-    (0, import_node_fs49.unlinkSync)(path2);
+    (0, import_node_fs50.unlinkSync)(path2);
   } catch {
   }
 }
-var import_node_fs49, buffers, FLUSH_MS, MAX_PARTS;
+var import_node_fs50, buffers, FLUSH_MS, MAX_PARTS;
 var init_turn_live = __esm({
   "src/store/turn-live.ts"() {
     "use strict";
-    import_node_fs49 = require("fs");
+    import_node_fs50 = require("fs");
     init_message_parts();
     init_paths();
     buffers = /* @__PURE__ */ new Map();
@@ -20842,7 +21027,7 @@ var init_quota_failover = __esm({
 // src/threads/adopt.ts
 function thisModuleFile2() {
   const cjsFile = typeof __filename !== "undefined" ? __filename : "";
-  return cjsFile || process.argv[1] || (0, import_node_path48.join)(process.cwd(), "package.json");
+  return cjsFile || process.argv[1] || (0, import_node_path49.join)(process.cwd(), "package.json");
 }
 function openReadonlySqlite(file) {
   const req = (0, import_node_module5.createRequire)(thisModuleFile2());
@@ -20860,21 +21045,21 @@ function mapAgentType(raw) {
   return null;
 }
 function resolveConductorCursorAgentId(workspacePath) {
-  if (!workspacePath || !(0, import_node_fs50.existsSync)(CURSOR_SDK_STORE)) return null;
+  if (!workspacePath || !(0, import_node_fs51.existsSync)(CURSOR_SDK_STORE)) return null;
   const normalized = workspacePath.replace(/\/$/, "");
   let best = null;
   let hashes;
   try {
-    hashes = (0, import_node_fs50.readdirSync)(CURSOR_SDK_STORE);
+    hashes = (0, import_node_fs51.readdirSync)(CURSOR_SDK_STORE);
   } catch {
     return null;
   }
   for (const hash of hashes) {
-    const agentsFile = (0, import_node_path48.join)(CURSOR_SDK_STORE, hash, "agents.ndjson");
-    if (!(0, import_node_fs50.existsSync)(agentsFile)) continue;
+    const agentsFile = (0, import_node_path49.join)(CURSOR_SDK_STORE, hash, "agents.ndjson");
+    if (!(0, import_node_fs51.existsSync)(agentsFile)) continue;
     let text7;
     try {
-      text7 = (0, import_node_fs50.readFileSync)(agentsFile, "utf8");
+      text7 = (0, import_node_fs51.readFileSync)(agentsFile, "utf8");
     } catch {
       continue;
     }
@@ -20898,7 +21083,7 @@ function resolveConductorCursorAgentId(workspacePath) {
   return best?.agentId ?? null;
 }
 async function adoptThread(input) {
-  if (!(0, import_node_fs50.existsSync)(input.worktreePath)) {
+  if (!(0, import_node_fs51.existsSync)(input.worktreePath)) {
     throw new Error(`Worktree not found: ${input.worktreePath}`);
   }
   const repoPath = await resolveRepoRoot(input.worktreePath);
@@ -20927,18 +21112,18 @@ function conductorDbPath() {
   return CONDUCTOR_DB;
 }
 function listConductorWorkspaces() {
-  if (!(0, import_node_fs50.existsSync)(CONDUCTOR_DB)) {
+  if (!(0, import_node_fs51.existsSync)(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = (0, import_node_fs50.mkdtempSync)((0, import_node_path48.join)((0, import_node_os14.tmpdir)(), "sideboard-conductor-"));
-  const snapshot = (0, import_node_path48.join)(tmp, "conductor.db");
+  const tmp = (0, import_node_fs51.mkdtempSync)((0, import_node_path49.join)((0, import_node_os14.tmpdir)(), "sideboard-conductor-"));
+  const snapshot = (0, import_node_path49.join)(tmp, "conductor.db");
   try {
-    (0, import_node_fs50.copyFileSync)(CONDUCTOR_DB, snapshot);
+    (0, import_node_fs51.copyFileSync)(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if ((0, import_node_fs50.existsSync)(src)) {
+      if ((0, import_node_fs51.existsSync)(src)) {
         try {
-          (0, import_node_fs50.copyFileSync)(src, `${snapshot}${suffix}`);
+          (0, import_node_fs51.copyFileSync)(src, `${snapshot}${suffix}`);
         } catch {
         }
       }
@@ -21014,22 +21199,22 @@ function listConductorWorkspaces() {
       db.close();
     }
   } finally {
-    (0, import_node_fs50.rmSync)(tmp, { recursive: true, force: true });
+    (0, import_node_fs51.rmSync)(tmp, { recursive: true, force: true });
   }
 }
 function importConductorWorkspace(workspaceId) {
-  if (!(0, import_node_fs50.existsSync)(CONDUCTOR_DB)) {
+  if (!(0, import_node_fs51.existsSync)(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = (0, import_node_fs50.mkdtempSync)((0, import_node_path48.join)((0, import_node_os14.tmpdir)(), "sideboard-conductor-"));
-  const snapshot = (0, import_node_path48.join)(tmp, "conductor.db");
+  const tmp = (0, import_node_fs51.mkdtempSync)((0, import_node_path49.join)((0, import_node_os14.tmpdir)(), "sideboard-conductor-"));
+  const snapshot = (0, import_node_path49.join)(tmp, "conductor.db");
   try {
-    (0, import_node_fs50.copyFileSync)(CONDUCTOR_DB, snapshot);
+    (0, import_node_fs51.copyFileSync)(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if ((0, import_node_fs50.existsSync)(src)) {
+      if ((0, import_node_fs51.existsSync)(src)) {
         try {
-          (0, import_node_fs50.copyFileSync)(src, `${snapshot}${suffix}`);
+          (0, import_node_fs51.copyFileSync)(src, `${snapshot}${suffix}`);
         } catch {
         }
       }
@@ -21047,7 +21232,7 @@ function importConductorWorkspace(workspaceId) {
       ).get(workspaceId);
       if (!row) throw new Error(`Conductor workspace not found: ${workspaceId}`);
       const worktreePath = String(row.workspacePath);
-      if (!(0, import_node_fs50.existsSync)(worktreePath)) {
+      if (!(0, import_node_fs51.existsSync)(worktreePath)) {
         throw new Error(`Conductor worktree missing on disk: ${worktreePath}`);
       }
       let sessionId = null;
@@ -21110,31 +21295,31 @@ function importConductorWorkspace(workspaceId) {
       db.close();
     }
   } finally {
-    (0, import_node_fs50.rmSync)(tmp, { recursive: true, force: true });
+    (0, import_node_fs51.rmSync)(tmp, { recursive: true, force: true });
   }
 }
 async function importConductorWorkspaceAsync(workspaceId) {
   return importConductorWorkspace(workspaceId);
 }
-var import_node_child_process6, import_node_fs50, import_node_os14, import_node_path48, import_node_module5, CONDUCTOR_APP_SUPPORT, CONDUCTOR_DB, CURSOR_SDK_STORE;
+var import_node_child_process6, import_node_fs51, import_node_os14, import_node_path49, import_node_module5, CONDUCTOR_APP_SUPPORT, CONDUCTOR_DB, CURSOR_SDK_STORE;
 var init_adopt = __esm({
   "src/threads/adopt.ts"() {
     "use strict";
     import_node_child_process6 = require("child_process");
-    import_node_fs50 = require("fs");
+    import_node_fs51 = require("fs");
     import_node_os14 = require("os");
-    import_node_path48 = require("path");
+    import_node_path49 = require("path");
     import_node_module5 = require("module");
     init_worktree();
     init_thread_store();
-    CONDUCTOR_APP_SUPPORT = (0, import_node_path48.join)(
+    CONDUCTOR_APP_SUPPORT = (0, import_node_path49.join)(
       process.env.HOME ?? "",
       "Library",
       "Application Support",
       "com.conductor.app"
     );
-    CONDUCTOR_DB = (0, import_node_path48.join)(CONDUCTOR_APP_SUPPORT, "conductor.db");
-    CURSOR_SDK_STORE = (0, import_node_path48.join)(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
+    CONDUCTOR_DB = (0, import_node_path49.join)(CONDUCTOR_APP_SUPPORT, "conductor.db");
+    CURSOR_SDK_STORE = (0, import_node_path49.join)(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
   }
 });
 
@@ -21201,7 +21386,7 @@ async function openStackLayer(input, _onSetupLine) {
   let createdWorktree = false;
   const trees = await listWorktrees(repoPath);
   const checkedOut = trees.find((w) => w.branch === branchName);
-  if (checkedOut?.path && (0, import_node_fs51.existsSync)(checkedOut.path)) {
+  if (checkedOut?.path && (0, import_node_fs52.existsSync)(checkedOut.path)) {
     if (input.reuseExistingWorktree !== false) {
       worktreePath = checkedOut.path;
     } else {
@@ -21343,7 +21528,7 @@ async function initStackFromThread(input, onSetupLine) {
 async function createPrStack(input, onSetupLine) {
   await requireAgent(input.agent);
   const repoPath = await resolveRepoRoot(input.repoPath);
-  if (!(0, import_node_fs51.existsSync)(repoPath)) throw new Error(`Repo not found: ${repoPath}`);
+  if (!(0, import_node_fs52.existsSync)(repoPath)) throw new Error(`Repo not found: ${repoPath}`);
   if (!input.branches.length) throw new Error("At least one branch name required");
   const status = await detectGhStack(repoPath);
   if (!status.available) throw new Error(status.reason);
@@ -21410,7 +21595,7 @@ async function createPrStack(input, onSetupLine) {
     }
   }
   const claimed = new Set(threads.map((t) => t.worktreePath));
-  if (!claimed.has(bootstrap.worktreePath) && (0, import_node_fs51.existsSync)(bootstrap.worktreePath)) {
+  if (!claimed.has(bootstrap.worktreePath) && (0, import_node_fs52.existsSync)(bootstrap.worktreePath)) {
     try {
       await removeWorktree(repoPath, bootstrap.worktreePath, {
         deleteBranch: bootstrap.branchName
@@ -21430,11 +21615,11 @@ function stackAgentDefaultsFrom(input) {
     planMode: input.planMode
   };
 }
-var import_node_fs51;
+var import_node_fs52;
 var init_stack_layers = __esm({
   "src/threads/stack-layers.ts"() {
     "use strict";
-    import_node_fs51 = require("fs");
+    import_node_fs52 = require("fs");
     init_detect();
     init_run();
     init_stack();
@@ -21447,7 +21632,7 @@ var init_stack_layers = __esm({
 
 // src/diff/diff.ts
 async function inspectGitWorktree(worktreePath) {
-  if (!worktreePath || !(0, import_node_fs52.existsSync)(worktreePath)) return "missing_worktree";
+  if (!worktreePath || !(0, import_node_fs53.existsSync)(worktreePath)) return "missing_worktree";
   const check = await git(["rev-parse", "--is-inside-work-tree"], worktreePath, {
     reject: false
   });
@@ -21455,7 +21640,7 @@ async function inspectGitWorktree(worktreePath) {
   return "ok";
 }
 async function initializeGitRepository(worktreePath) {
-  if (!worktreePath || !(0, import_node_fs52.existsSync)(worktreePath)) {
+  if (!worktreePath || !(0, import_node_fs53.existsSync)(worktreePath)) {
     throw new Error("Worktree not found");
   }
   const status = await inspectGitWorktree(worktreePath);
@@ -21589,11 +21774,11 @@ new file mode 100644
   };
 }
 async function untrackedPatch(worktreePath, path2, maxHunk) {
-  const abs = (0, import_node_path49.join)(worktreePath, path2);
+  const abs = (0, import_node_path50.join)(worktreePath, path2);
   try {
-    const st = (0, import_node_fs52.statSync)(abs);
+    const st = (0, import_node_fs53.statSync)(abs);
     if (st.isFile() && st.size > maxHunk) {
-      const buf = (0, import_node_fs52.readFileSync)(abs).subarray(0, maxHunk);
+      const buf = (0, import_node_fs53.readFileSync)(abs).subarray(0, maxHunk);
       return syntheticAddPatch(path2, buf.toString("utf8"), maxHunk);
     }
   } catch {
@@ -22060,9 +22245,9 @@ async function getDiff(worktreePath, repoPath, opts) {
 }
 function statWorktreePath(worktreePath, relativePath) {
   assertSafeRelativePath(relativePath);
-  const abs = (0, import_node_path49.join)(worktreePath, relativePath);
-  if (!(0, import_node_fs52.existsSync)(abs)) return "missing";
-  const st = (0, import_node_fs52.statSync)(abs);
+  const abs = (0, import_node_path50.join)(worktreePath, relativePath);
+  if (!(0, import_node_fs53.existsSync)(abs)) return "missing";
+  const st = (0, import_node_fs53.statSync)(abs);
   if (st.isDirectory()) return "dir";
   if (st.isFile()) return "file";
   return "missing";
@@ -22091,8 +22276,8 @@ function isImageRelativePath(relativePath) {
 function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? DEFAULT_UPLOAD_MAX_BYTES;
-  const abs = (0, import_node_path49.join)(worktreePath, relativePath);
-  const st = (0, import_node_fs52.statSync)(abs);
+  const abs = (0, import_node_path50.join)(worktreePath, relativePath);
+  const st = (0, import_node_fs53.statSync)(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
@@ -22101,7 +22286,7 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
       `File too large to upload (${st.size} bytes; max ${maxBytes})`
     );
   }
-  const buf = (0, import_node_fs52.readFileSync)(abs);
+  const buf = (0, import_node_fs53.readFileSync)(abs);
   return {
     path: relativePath,
     contentBase64: buf.toString("base64"),
@@ -22111,12 +22296,12 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
 function readWorktreeFile(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? 2e5;
-  const abs = (0, import_node_path49.join)(worktreePath, relativePath);
-  const st = (0, import_node_fs52.statSync)(abs);
+  const abs = (0, import_node_path50.join)(worktreePath, relativePath);
+  const st = (0, import_node_fs53.statSync)(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
-  const buf = (0, import_node_fs52.readFileSync)(abs);
+  const buf = (0, import_node_fs53.readFileSync)(abs);
   if (isImageRelativePath(relativePath)) {
     const maxImageBytes = Math.max(maxBytes, 15e6);
     const truncated2 = buf.length > maxImageBytes;
@@ -22159,9 +22344,9 @@ function assertSafeRelativePath(relativePath) {
 }
 function writeWorktreeFile(worktreePath, relativePath, content) {
   assertSafeRelativePath(relativePath);
-  const abs = (0, import_node_path49.join)(worktreePath, relativePath);
-  (0, import_node_fs52.mkdirSync)((0, import_node_path49.dirname)(abs), { recursive: true });
-  (0, import_node_fs52.writeFileSync)(abs, content, "utf8");
+  const abs = (0, import_node_path50.join)(worktreePath, relativePath);
+  (0, import_node_fs53.mkdirSync)((0, import_node_path50.dirname)(abs), { recursive: true });
+  (0, import_node_fs53.writeFileSync)(abs, content, "utf8");
   return { path: relativePath };
 }
 async function getWorktreeDirtyStat(worktreePath) {
@@ -22201,12 +22386,12 @@ async function getDiffSummary(worktreePath, repoPath, opts) {
     truncated: full.files.length > maxFiles
   };
 }
-var import_node_fs52, import_node_path49, mergeBaseCache, MERGE_BASE_TTL_MS, SHA_RE, IMAGE_EXTENSIONS2, DEFAULT_UPLOAD_MAX_BYTES;
+var import_node_fs53, import_node_path50, mergeBaseCache, MERGE_BASE_TTL_MS, SHA_RE, IMAGE_EXTENSIONS2, DEFAULT_UPLOAD_MAX_BYTES;
 var init_diff = __esm({
   "src/diff/diff.ts"() {
     "use strict";
-    import_node_fs52 = require("fs");
-    import_node_path49 = require("path");
+    import_node_fs53 = require("fs");
+    import_node_path50 = require("path");
     init_run();
     init_worktree();
     mergeBaseCache = /* @__PURE__ */ new Map();
@@ -22563,7 +22748,7 @@ function parseFrontmatter(content) {
 }
 function readSkill(skillMd, source) {
   try {
-    const content = (0, import_node_fs53.readFileSync)(skillMd, "utf8");
+    const content = (0, import_node_fs54.readFileSync)(skillMd, "utf8");
     const { name: fmName, description } = parseFrontmatter(content);
     const dirName = skillMd.split("/").slice(-2, -1)[0] || "skill";
     const name = fmName || dirName;
@@ -22582,19 +22767,19 @@ function readSkill(skillMd, source) {
   }
 }
 function scanSkillsDir(dir, source, out) {
-  if (!(0, import_node_fs53.existsSync)(dir)) return;
+  if (!(0, import_node_fs54.existsSync)(dir)) return;
   let entries;
   try {
-    entries = (0, import_node_fs53.readdirSync)(dir);
+    entries = (0, import_node_fs54.readdirSync)(dir);
   } catch {
     return;
   }
   for (const entry of entries) {
     if (entry.startsWith(".")) continue;
-    const skillMd = (0, import_node_path50.join)(dir, entry, "SKILL.md");
-    if (!(0, import_node_fs53.existsSync)(skillMd)) continue;
+    const skillMd = (0, import_node_path51.join)(dir, entry, "SKILL.md");
+    if (!(0, import_node_fs54.existsSync)(skillMd)) continue;
     try {
-      if (!(0, import_node_fs53.statSync)(skillMd).isFile()) continue;
+      if (!(0, import_node_fs54.statSync)(skillMd).isFile()) continue;
     } catch {
       continue;
     }
@@ -22603,24 +22788,24 @@ function scanSkillsDir(dir, source, out) {
   }
 }
 function scanClaudePluginSkills(pluginsRoot, out) {
-  if (!(0, import_node_fs53.existsSync)(pluginsRoot)) return;
+  if (!(0, import_node_fs54.existsSync)(pluginsRoot)) return;
   const walk = (dir, depth, lookingForSkillsDir) => {
     if (depth > 7) return;
     let entries;
     try {
-      entries = (0, import_node_fs53.readdirSync)(dir);
+      entries = (0, import_node_fs54.readdirSync)(dir);
     } catch {
       return;
     }
     if (lookingForSkillsDir && entries.includes("SKILL.md")) {
-      const skill = readSkill((0, import_node_path50.join)(dir, "SKILL.md"), "cli");
+      const skill = readSkill((0, import_node_path51.join)(dir, "SKILL.md"), "cli");
       if (skill) out.push(skill);
     }
     for (const entry of entries) {
       if (entry === "node_modules" || entry === ".git") continue;
-      const full = (0, import_node_path50.join)(dir, entry);
+      const full = (0, import_node_path51.join)(dir, entry);
       try {
-        if (!(0, import_node_fs53.statSync)(full).isDirectory()) continue;
+        if (!(0, import_node_fs54.statSync)(full).isDirectory()) continue;
       } catch {
         continue;
       }
@@ -22638,17 +22823,17 @@ function discoverSkills(worktreePath) {
   const home = (0, import_node_os15.homedir)();
   const collected = [];
   for (const rel of [".claude/skills", ".cursor/skills", ".sideboard/skills", ".brightsy/skills", "skills"]) {
-    scanSkillsDir((0, import_node_path50.join)(worktreePath, rel), "workspace", collected);
+    scanSkillsDir((0, import_node_path51.join)(worktreePath, rel), "workspace", collected);
   }
   for (const abs of [
-    (0, import_node_path50.join)(home, ".claude/skills"),
-    (0, import_node_path50.join)(home, ".cursor/skills"),
-    (0, import_node_path50.join)(home, ".sideboard/skills"),
-    (0, import_node_path50.join)(home, ".brightsy/skills")
+    (0, import_node_path51.join)(home, ".claude/skills"),
+    (0, import_node_path51.join)(home, ".cursor/skills"),
+    (0, import_node_path51.join)(home, ".sideboard/skills"),
+    (0, import_node_path51.join)(home, ".brightsy/skills")
   ]) {
     scanSkillsDir(abs, "user", collected);
   }
-  scanClaudePluginSkills((0, import_node_path50.join)(home, ".claude/plugins"), collected);
+  scanClaudePluginSkills((0, import_node_path51.join)(home, ".claude/plugins"), collected);
   collected.push(...bundledSkills());
   const rank = {
     workspace: 0,
@@ -22674,7 +22859,7 @@ function readSkillBody(skillPath, maxChars = 12e3) {
 \u2026(truncated)` : body;
     }
   }
-  const raw = (0, import_node_fs53.readFileSync)(skillPath, "utf8");
+  const raw = (0, import_node_fs54.readFileSync)(skillPath, "utf8");
   if (raw.startsWith("---")) {
     const end = raw.indexOf("\n---", 3);
     if (end >= 0) {
@@ -22688,13 +22873,13 @@ function readSkillBody(skillPath, maxChars = 12e3) {
 
 \u2026(truncated)` : raw;
 }
-var import_node_fs53, import_node_os15, import_node_path50, BUNDLED_SKILL_PREFIX;
+var import_node_fs54, import_node_os15, import_node_path51, BUNDLED_SKILL_PREFIX;
 var init_discover = __esm({
   "src/skills/discover.ts"() {
     "use strict";
-    import_node_fs53 = require("fs");
+    import_node_fs54 = require("fs");
     import_node_os15 = require("os");
-    import_node_path50 = require("path");
+    import_node_path51 = require("path");
     init_long_running();
     BUNDLED_SKILL_PREFIX = "bundled:";
   }
@@ -22849,7 +23034,7 @@ function compiledModuleDir() {
   try {
     const url = import_meta4.url;
     if (typeof url === "string" && url.length > 0) {
-      return (0, import_node_path51.dirname)((0, import_node_url4.fileURLToPath)(url));
+      return (0, import_node_path52.dirname)((0, import_node_url4.fileURLToPath)(url));
     }
   } catch {
   }
@@ -22857,8 +23042,8 @@ function compiledModuleDir() {
 }
 function detachedJobScriptIn(dir) {
   for (const name of DETACHED_JOB_FILENAMES) {
-    const script = (0, import_node_path51.join)(dir, "scripts", name);
-    if ((0, import_node_fs54.existsSync)(script)) return script;
+    const script = (0, import_node_path52.join)(dir, "scripts", name);
+    if ((0, import_node_fs55.existsSync)(script)) return script;
   }
   return null;
 }
@@ -22875,7 +23060,7 @@ function resolveDetachedJobScript() {
   for (let i = 0; i < 8; i++) {
     const candidate = detachedJobScriptIn(dir);
     if (candidate) return candidate;
-    const parent = (0, import_node_path51.dirname)(dir);
+    const parent = (0, import_node_path52.dirname)(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -22886,12 +23071,12 @@ function formatDetachedJobInvoke(scriptPath) {
   if (resolved) return `node ${JSON.stringify(resolved)}`;
   return "node scripts/detached-job.cjs";
 }
-var import_node_fs54, import_node_path51, import_node_url4, import_meta4, DETACHED_JOB_FILENAMES;
+var import_node_fs55, import_node_path52, import_node_url4, import_meta4, DETACHED_JOB_FILENAMES;
 var init_detached_job_path = __esm({
   "src/skills/detached-job-path.ts"() {
     "use strict";
-    import_node_fs54 = require("fs");
-    import_node_path51 = require("path");
+    import_node_fs55 = require("fs");
+    import_node_path52 = require("path");
     import_node_url4 = require("url");
     init_packaged_runtime();
     import_meta4 = {};
@@ -22992,9 +23177,9 @@ function formatWorktreeDirective(thread, opts) {
     );
   } else {
     const slug = opts?.githubSlug ?? "<origin-owner/name>";
-    const resolve = opts?.githubSlug ? "" : " Resolve `<origin-owner/name>` with `git remote get-url origin` in this worktree.";
+    const resolve2 = opts?.githubSlug ? "" : " Resolve `<origin-owner/name>` with `git remote get-url origin` in this worktree.";
     lines.push(
-      `- Prefer a draft PR first: \`gh pr create --draft -R ${slug}\` (update via \`gh pr edit -R ${slug}\`). Always pass \`-R\` \u2014 bare \`gh pr create\` may target upstream on dual-remote checkouts.${resolve} Mark ready for review only when asked. If GitHub rejects the body as too long, retry with a short \`--body-file\` \u2014 do not paste a changelog or diff into \`--body\`.`
+      `- Prefer a draft PR first: \`gh pr create --draft -R ${slug}\` (update via \`gh pr edit -R ${slug}\`). Always pass \`-R\` \u2014 bare \`gh pr create\` may target upstream on dual-remote checkouts.${resolve2} Mark ready for review only when asked. If GitHub rejects the body as too long, retry with a short \`--body-file\` \u2014 do not paste a changelog or diff into \`--body\`.`
     );
   }
   lines.push(
@@ -23103,9 +23288,9 @@ function formatPrGateDirective() {
 }
 function formatProcessGuideDirective(opts) {
   const worktree = opts?.worktreePath?.trim();
-  const hasGraphSkill = !!worktree && (0, import_node_fs55.existsSync)((0, import_node_path52.join)(worktree, ".claude/skills/graph-engineering/SKILL.md"));
-  const hasReviewSkill = !!worktree && (0, import_node_fs55.existsSync)((0, import_node_path52.join)(worktree, ".claude/skills/review/SKILL.md"));
-  const hasInstallSkill = !!worktree && (0, import_node_fs55.existsSync)((0, import_node_path52.join)(worktree, ".claude/skills/worktree-install/SKILL.md"));
+  const hasGraphSkill = !!worktree && (0, import_node_fs56.existsSync)((0, import_node_path53.join)(worktree, ".claude/skills/graph-engineering/SKILL.md"));
+  const hasReviewSkill = !!worktree && (0, import_node_fs56.existsSync)((0, import_node_path53.join)(worktree, ".claude/skills/review/SKILL.md"));
+  const hasInstallSkill = !!worktree && (0, import_node_fs56.existsSync)((0, import_node_path53.join)(worktree, ".claude/skills/worktree-install/SKILL.md"));
   return [
     "Process guides (recurring work only):",
     hasGraphSkill ? "- Migrations, ports, batch fixes, and other fan-out: follow `.claude/skills/graph-engineering/SKILL.md` (`/graph-engineering`). Judge first; state on disk; grow the rulebook; do not patch around it." : null,
@@ -23144,12 +23329,12 @@ function formatArtifactDirective() {
 function formatUiReminder() {
   return "Sideboard UI: markdown table is enough to read data; present_schema if they ask to edit/filter (even after markdown); present_files for the file manager. html fence or present_artifact, not both for the same document. type=log appends (same artifact_id, new lines only). ask_user only for a real multiple-choice (not hellos, \u201Cwhat next?\u201D, or after a review) \u2014 reply in chat. ask_user wakes the parent orchestrator; notify_orchestrator if blocked without a picker. Do not say artifacts/CMS UI are unavailable. Dev / preview: run_dev_script (same as the Dev button) returns {url, port, preview} (SIDEBOARD_PORT \u2014 never guess :3000). preview=url \u2192 open url; preview=window \u2192 Electron window is the app, url is renderer/HMR only. list_run_scripts active[].url if already running; get_run_log for the Run-tab terminal; stop_dev_script to stop.";
 }
-var import_node_fs55, import_node_path52, PR_GOAL_RE, GITHUB_TICKET_REF, KEYED_TICKET_REF;
+var import_node_fs56, import_node_path53, PR_GOAL_RE, GITHUB_TICKET_REF, KEYED_TICKET_REF;
 var init_instructions = __esm({
   "src/agents/instructions.ts"() {
     "use strict";
-    import_node_fs55 = require("fs");
-    import_node_path52 = require("path");
+    import_node_fs56 = require("fs");
+    import_node_path53 = require("path");
     init_git_auth_mode();
     init_branch_prefix();
     init_worktree_labels();
@@ -23535,40 +23720,40 @@ __export(plan_file_exports, {
   writePlanFile: () => writePlanFile
 });
 function ensureAttachmentsGitignore(worktreePath) {
-  const gitignoreAbs = (0, import_node_path53.join)(worktreePath, ATTACHMENTS_DIR, ".gitignore");
-  if ((0, import_node_fs56.existsSync)(gitignoreAbs)) return;
-  (0, import_node_fs56.mkdirSync)((0, import_node_path53.dirname)(gitignoreAbs), { recursive: true });
-  (0, import_node_fs56.writeFileSync)(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
+  const gitignoreAbs = (0, import_node_path54.join)(worktreePath, ATTACHMENTS_DIR, ".gitignore");
+  if ((0, import_node_fs57.existsSync)(gitignoreAbs)) return;
+  (0, import_node_fs57.mkdirSync)((0, import_node_path54.dirname)(gitignoreAbs), { recursive: true });
+  (0, import_node_fs57.writeFileSync)(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
 }
 function planFileAbs(worktreePath) {
-  return (0, import_node_path53.join)(worktreePath, PLAN_FILE_REL);
+  return (0, import_node_path54.join)(worktreePath, PLAN_FILE_REL);
 }
 function readTextIfPresent2(abs) {
-  if (!(0, import_node_fs56.existsSync)(abs)) return null;
+  if (!(0, import_node_fs57.existsSync)(abs)) return null;
   try {
-    const content = (0, import_node_fs56.readFileSync)(abs, "utf8");
+    const content = (0, import_node_fs57.readFileSync)(abs, "utf8");
     return content.trim() ? content : null;
   } catch {
     return null;
   }
 }
 function readPlanFile(worktreePath) {
-  return readTextIfPresent2(planFileAbs(worktreePath)) ?? readTextIfPresent2((0, import_node_path53.join)(worktreePath, `${LEGACY_ATTACHMENTS_DIR}/plan.md`)) ?? readTextIfPresent2((0, import_node_path53.join)(worktreePath, LEGACY_PLAN_FILE_REL));
+  return readTextIfPresent2(planFileAbs(worktreePath)) ?? readTextIfPresent2((0, import_node_path54.join)(worktreePath, `${LEGACY_ATTACHMENTS_DIR}/plan.md`)) ?? readTextIfPresent2((0, import_node_path54.join)(worktreePath, LEGACY_PLAN_FILE_REL));
 }
 function writePlanFile(worktreePath, content) {
   ensureAttachmentsGitignore(worktreePath);
   const abs = planFileAbs(worktreePath);
-  (0, import_node_fs56.mkdirSync)((0, import_node_path53.dirname)(abs), { recursive: true });
+  (0, import_node_fs57.mkdirSync)((0, import_node_path54.dirname)(abs), { recursive: true });
   const body = content.trimEnd() + (content.endsWith("\n") ? "" : "\n");
-  (0, import_node_fs56.writeFileSync)(abs, body, "utf8");
+  (0, import_node_fs57.writeFileSync)(abs, body, "utf8");
   return PLAN_FILE_REL;
 }
-var import_node_fs56, import_node_path53;
+var import_node_fs57, import_node_path54;
 var init_plan_file = __esm({
   "src/plan/plan-file.ts"() {
     "use strict";
-    import_node_fs56 = require("fs");
-    import_node_path53 = require("path");
+    import_node_fs57 = require("fs");
+    import_node_path54 = require("path");
     init_workspace_scratch();
     init_plan_present();
     init_plan_present();
@@ -23630,9 +23815,9 @@ function recoverFinishedCursorRun(opts) {
   return best;
 }
 function scanFinishedCursorRuns(runsPath, agentId, startedAfterMs) {
-  if (!(0, import_node_fs57.existsSync)(runsPath)) return null;
+  if (!(0, import_node_fs58.existsSync)(runsPath)) return null;
   try {
-    const lines = (0, import_node_fs57.readFileSync)(runsPath, "utf8").split("\n");
+    const lines = (0, import_node_fs58.readFileSync)(runsPath, "utf8").split("\n");
     let best = null;
     for (const line of lines) {
       const trimmed = line.trim();
@@ -23658,11 +23843,11 @@ function scanFinishedCursorRuns(runsPath, agentId, startedAfterMs) {
     return null;
   }
 }
-var import_node_fs57;
+var import_node_fs58;
 var init_cursor_recover = __esm({
   "src/agents/cursor-recover.ts"() {
     "use strict";
-    import_node_fs57 = require("fs");
+    import_node_fs58 = require("fs");
     init_cursor_store();
   }
 });
@@ -23816,7 +24001,7 @@ async function startOrchestration(opts) {
   }
   return updated;
 }
-var import_node_events, import_node_crypto13, import_node_fs58, LIVE_TURN_SPAWN_GRACE_MS, RUN_SCRIPT_DESKTOP_ADOPT_MS, STALE_AGENT_PID_WAIT_MS, LIGHT_RECONCILE_THROTTLE_MS, Orchestrator, singleton;
+var import_node_events, import_node_crypto13, import_node_fs59, LIVE_TURN_SPAWN_GRACE_MS, RUN_SCRIPT_DESKTOP_ADOPT_MS, STALE_AGENT_PID_WAIT_MS, LIGHT_RECONCILE_THROTTLE_MS, Orchestrator, singleton;
 var init_orchestrator = __esm({
   "src/orchestrator/orchestrator.ts"() {
     "use strict";
@@ -23824,7 +24009,7 @@ var init_orchestrator = __esm({
     init_injected_notices();
     init_task_state();
     import_node_crypto13 = require("crypto");
-    import_node_fs58 = require("fs");
+    import_node_fs59 = require("fs");
     init_error_detail();
     init_run();
     init_stale_lock();
@@ -24003,7 +24188,7 @@ var init_orchestrator = __esm({
           this.lightReconcileAt.set(repoPath, Date.now());
           for (const thread of listThreads()) {
             if (isGlobalThread(thread) || thread.repoPath !== repoPath) continue;
-            if (!(0, import_node_fs58.existsSync)(thread.worktreePath)) {
+            if (!(0, import_node_fs59.existsSync)(thread.worktreePath)) {
               setStatus(thread.id, "broken", "Worktree missing on disk");
               this.emit({ type: "status_changed", threadId: thread.id, status: "broken" });
             }
@@ -24032,7 +24217,7 @@ var init_orchestrator = __esm({
             }
             continue;
           }
-          if (!(0, import_node_fs58.existsSync)(thread.worktreePath)) {
+          if (!(0, import_node_fs59.existsSync)(thread.worktreePath)) {
             setStatus(thread.id, "broken", "Worktree missing on disk");
             this.emit({ type: "status_changed", threadId: thread.id, status: "broken" });
             continue;
@@ -24200,8 +24385,8 @@ var init_orchestrator = __esm({
       scheduleQuotaResume(threadId, resumeAt) {
         this.clearQuotaResumeTimer(threadId);
         updateThread(threadId, { quotaResumeAt: resumeAt.toISOString() });
-        const delay = Math.max(5e3, resumeAt.getTime() - Date.now());
-        const capped = Math.min(delay, 2147483647);
+        const delay2 = Math.max(5e3, resumeAt.getTime() - Date.now());
+        const capped = Math.min(delay2, 2147483647);
         const timer = setTimeout(() => {
           this.quotaResumeTimers.delete(threadId);
           void this.resumeAfterQuotaWait(threadId);
@@ -25256,6 +25441,7 @@ var init_orchestrator = __esm({
             return { port: shared.devPort, scriptName: resolvedName, ports: [shared.devPort] };
           }
         }
+        const preferredPorts = active?.ports?.length ? active.ports : active?.port != null ? [active.port] : void 0;
         if (active && !existing) {
           killListenersOnPorts(collectActiveRunPorts([active]));
           this.syncWorktreeRuns(
@@ -25294,7 +25480,7 @@ var init_orchestrator = __esm({
             thread.repoPath,
             thread.worktreePath,
             runOutput.push,
-            { scriptName: resolvedName }
+            { scriptName: resolvedName, preferredPorts }
           );
         } catch (err) {
           runOutput.flush();
@@ -25743,7 +25929,7 @@ var init_orchestrator = __esm({
           return thread;
         }
         const start = Date.now();
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           let settled = false;
           let timer;
           const finish = (fn) => {
@@ -25761,7 +25947,7 @@ var init_orchestrator = __esm({
                 finish(() => reject(new Error(`Thread not found: ${thread.id}`)));
                 return;
               }
-              finish(() => resolve(latest));
+              finish(() => resolve2(latest));
               return;
             }
             if (event.type === "status_changed") {
@@ -25771,7 +25957,7 @@ var init_orchestrator = __esm({
                 return;
               }
               if (!["running", "queued"].includes(latest.status)) {
-                finish(() => resolve(latest));
+                finish(() => resolve2(latest));
               }
             }
           });
@@ -25783,12 +25969,12 @@ var init_orchestrator = __esm({
             }
             const current = this.healStaleReportedActivity(raw);
             if (!this.threadLooksLive(current)) {
-              finish(() => resolve(current));
+              finish(() => resolve2(current));
               return;
             }
             if (Date.now() - start > timeoutMs) {
               if (opts?.resolveIfStillRunning) {
-                finish(() => resolve(current));
+                finish(() => resolve2(current));
               } else {
                 finish(() => reject(new Error("wait_for_turn timed out")));
               }
@@ -26380,7 +26566,7 @@ var init_orchestrator = __esm({
           this.emit({ type: "status_changed", threadId: restored2.id, status: restored2.status });
           return restored2;
         }
-        if (!(0, import_node_fs58.existsSync)(thread.worktreePath)) {
+        if (!(0, import_node_fs59.existsSync)(thread.worktreePath)) {
           if (isCowboyThread(thread) || isPrimaryCheckoutThread(thread)) {
             throw new Error(
               `Cowboy checkout missing: ${thread.worktreePath}. Re-add the project folder, then restore.`
@@ -26526,14 +26712,14 @@ function armOne(schedule) {
   if (!schedule.enabled) return;
   const at = new Date(schedule.nextRunAt);
   if (Number.isNaN(at.getTime())) return;
-  const delay = Math.max(0, at.getTime() - Date.now());
-  if (delay <= 250) {
+  const delay2 = Math.max(0, at.getTime() - Date.now());
+  if (delay2 <= 250) {
     void fireSchedule(schedule.id).then(() => {
       if (isThisProcessDesktopHost()) armSchedules();
     });
     return;
   }
-  const capped = Math.min(delay, SET_TIMEOUT_MAX);
+  const capped = Math.min(delay2, SET_TIMEOUT_MAX);
   const timer = setTimeout(() => {
     timers.delete(schedule.id);
     const live = getSchedule(schedule.id);
@@ -26671,6 +26857,7 @@ __export(index_exports, {
   PLAN_FILE_REL: () => PLAN_FILE_REL,
   PLAN_MODE_INSTRUCTION: () => PLAN_MODE_INSTRUCTION,
   PLAN_QUESTION_ANSWERS_PREFIX: () => PLAN_QUESTION_ANSWERS_PREFIX,
+  PORT_RANGE_SIZE: () => PORT_RANGE_SIZE,
   PROFILE_NOTES_MAX: () => PROFILE_NOTES_MAX,
   PR_DETAILS_JSON_FIELDS: () => PR_DETAILS_JSON_FIELDS,
   REPO_REVIEW_NAME: () => REPO_REVIEW_NAME,
@@ -26681,6 +26868,7 @@ __export(index_exports, {
   REVIEW_REQUEST_TEMPLATE: () => REVIEW_REQUEST_TEMPLATE,
   REVIEW_SKILL_NAME: () => REVIEW_SKILL_NAME,
   REVIEW_SKILL_PATH: () => REVIEW_SKILL_PATH,
+  RUN_PORTS_REL: () => RUN_PORTS_REL,
   RUN_SCRIPT_DESKTOP_ADOPT_MS: () => RUN_SCRIPT_DESKTOP_ADOPT_MS,
   SEED_FULL_TOOL_MESSAGES: () => SEED_FULL_TOOL_MESSAGES,
   SEED_MAX_CHARS: () => SEED_MAX_CHARS,
@@ -27111,6 +27299,7 @@ __export(index_exports, {
   isOptionalServiceId: () => isOptionalServiceId,
   isOrchestratorCapableAgent: () => isOrchestratorCapableAgent,
   isOrchestratorThread: () => isOrchestratorThread,
+  isOtherWorktreeListenerCwd: () => isOtherWorktreeListenerCwd,
   isPidAlive: () => isPidAlive,
   isPlaceholderBranch: () => isPlaceholderBranch,
   isPlanQuestionAnswersMessage: () => isPlanQuestionAnswersMessage,
@@ -27142,6 +27331,7 @@ __export(index_exports, {
   issueSourceLabel: () => issueSourceLabel,
   issueTicketFromThread: () => issueTicketFromThread,
   killListenersOnPorts: () => killListenersOnPorts,
+  killStaleWorktreeListeners: () => killStaleWorktreeListeners,
   killableListenerPids: () => killableListenerPids,
   lastAgentReply: () => lastAgentReply,
   lastAssistantMessageText: () => lastAssistantMessageText,
@@ -27189,6 +27379,7 @@ __export(index_exports, {
   listWorkspaces: () => listWorkspaces,
   listWorktreeFiles: () => listWorktreeFiles,
   listWorktrees: () => listWorktrees,
+  listenerCwd: () => listenerCwd,
   liveActivitySummary: () => liveActivitySummary,
   loadAppSettings: () => loadAppSettings,
   loadBrightsyConfig: () => loadBrightsyConfig,
@@ -27196,6 +27387,7 @@ __export(index_exports, {
   loadHomeBoardInputs: () => loadHomeBoardInputs,
   loadRepoSettings: () => loadRepoSettings,
   loadWorkspaceSettings: () => loadWorkspaceSettings,
+  loadWorktreeRunPorts: () => loadWorktreeRunPorts,
   localhostPreviewUrl: () => localhostPreviewUrl,
   locksDir: () => locksDir,
   loginAgent: () => loginAgent,
@@ -27389,6 +27581,7 @@ __export(index_exports, {
   saveAbleTimeConnection: () => saveAbleTimeConnection,
   saveAppSettings: () => saveAppSettings,
   saveLinearOAuth: () => saveLinearOAuth,
+  saveWorktreeRunPorts: () => saveWorktreeRunPorts,
   schedulesPath: () => schedulesPath,
   scrubGithubTokensFromChildEnv: () => scrubGithubTokensFromChildEnv,
   searchAbleTimeTasks: () => searchAbleTimeTasks,
@@ -27478,6 +27671,8 @@ __export(index_exports, {
   toolFilePath: () => toolFilePath,
   totalTokens: () => totalTokens,
   trustSystemCertificates: () => trustSystemCertificates,
+  tryReservePort: () => tryReservePort,
+  tryReservePorts: () => tryReservePorts,
   turnCostUsdFromCursorUsage: () => turnCostUsdFromCursorUsage,
   updateAbleTimeTask: () => updateAbleTimeTask,
   updateAdvancedSettings: () => updateAdvancedSettings,
@@ -27516,6 +27711,7 @@ __export(index_exports, {
   worktreeDisplayLabel: () => worktreeDisplayLabel,
   worktreeDisplayLabelForGroup: () => worktreeDisplayLabelForGroup,
   worktreeNameFromPath: () => worktreeNameFromPath,
+  worktreeRunPortsPath: () => worktreeRunPortsPath,
   worktreeSlugForTicket: () => worktreeSlugForTicket,
   worktreesRoot: () => worktreesRoot,
   wrapReviewSkillMarkdown: () => wrapReviewSkillMarkdown,
@@ -28002,14 +28198,14 @@ async function startLinearOAuth(opts) {
   const pkce = createLinearPkce();
   const authorizeUrl = linearOAuthAuthorizeUrl(clientId, state, pkce.challenge);
   const timeoutMs = opts?.timeoutMs ?? 5 * 6e4;
-  const code = await new Promise((resolve, reject) => {
+  const code = await new Promise((resolve2, reject) => {
     let settled = false;
     const finish = (err, value) => {
       if (settled) return;
       settled = true;
       cleanup();
       if (err) reject(err);
-      else resolve(value);
+      else resolve2(value);
     };
     const server = (0, import_node_http2.createServer)((req, res) => {
       try {
@@ -30171,7 +30367,7 @@ var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 var import_zod9 = require("zod");
 var import_node_crypto17 = require("crypto");
-var import_node_path59 = require("path");
+var import_node_path60 = require("path");
 init_orchestrator();
 init_task_state();
 init_worktree();
@@ -30507,8 +30703,8 @@ ${link}` : link;
 }
 
 // src/slack/outbound-watch.ts
-var import_node_fs60 = require("fs");
-var import_node_path56 = require("path");
+var import_node_fs61 = require("fs");
+var import_node_path57 = require("path");
 init_paths();
 init_private_file();
 init_secure_file();
@@ -30516,19 +30712,19 @@ init_thread_store();
 init_injected_notices();
 
 // src/slack/reply-target.ts
-var import_node_fs59 = require("fs");
-var import_node_path54 = require("path");
+var import_node_fs60 = require("fs");
+var import_node_path55 = require("path");
 init_paths();
 init_private_file();
 init_secure_file();
 function storePath2() {
-  return (0, import_node_path54.join)(appDataDir(), "slack-reply-to.json");
+  return (0, import_node_path55.join)(appDataDir(), "slack-reply-to.json");
 }
 function readStore2() {
   const path2 = storePath2();
-  if (!(0, import_node_fs59.existsSync)(path2)) return {};
+  if (!(0, import_node_fs60.existsSync)(path2)) return {};
   try {
-    const parsed = isSecureFileEncrypted(path2) ? readSecureJson(path2) : JSON.parse((0, import_node_fs59.readFileSync)(path2, "utf8"));
+    const parsed = isSecureFileEncrypted(path2) ? readSecureJson(path2) : JSON.parse((0, import_node_fs60.readFileSync)(path2, "utf8"));
     return parsed?.targets && typeof parsed.targets === "object" ? parsed.targets : {};
   } catch {
     return {};
@@ -30545,11 +30741,11 @@ function getSlackReplyTarget(threadId) {
 }
 
 // src/slack/workspaces.ts
-var import_node_path55 = require("path");
+var import_node_path56 = require("path");
 init_paths();
 init_secure_file();
 function storePath3() {
-  return (0, import_node_path55.join)(appDataDir(), "slack-workspaces.json");
+  return (0, import_node_path56.join)(appDataDir(), "slack-workspaces.json");
 }
 function readStore3() {
   try {
@@ -30665,7 +30861,7 @@ var POLL_INTERVAL_MS = 12e3;
 var lastPollMs = 0;
 var nameCache = /* @__PURE__ */ new Map();
 function storePath4() {
-  return (0, import_node_path56.join)(appDataDir(), "slack-outbound-watch.json");
+  return (0, import_node_path57.join)(appDataDir(), "slack-outbound-watch.json");
 }
 function watchId(teamId, channelId, ts) {
   return `${teamId}:${channelId}:${ts}`;
@@ -30678,9 +30874,9 @@ function tsNewer(a, b) {
 }
 function readStore4() {
   const path2 = storePath4();
-  if (!(0, import_node_fs60.existsSync)(path2)) return [];
+  if (!(0, import_node_fs61.existsSync)(path2)) return [];
   try {
-    const parsed = isSecureFileEncrypted(path2) ? readSecureJson(path2) : JSON.parse((0, import_node_fs60.readFileSync)(path2, "utf8"));
+    const parsed = isSecureFileEncrypted(path2) ? readSecureJson(path2) : JSON.parse((0, import_node_fs61.readFileSync)(path2, "utf8"));
     return Array.isArray(parsed?.watches) ? parsed.watches : [];
   } catch {
     return [];
@@ -32431,27 +32627,27 @@ init_gh_errors();
 init_git_auth_mode();
 
 // src/board/load-home-board.ts
-var import_node_fs62 = require("fs");
-var import_node_path58 = require("path");
+var import_node_fs63 = require("fs");
+var import_node_path59 = require("path");
 init_worktree();
 init_paths();
 
 // src/board/board-pins.ts
 var import_node_crypto16 = require("crypto");
-var import_node_fs61 = require("fs");
-var import_node_path57 = require("path");
+var import_node_fs62 = require("fs");
+var import_node_path58 = require("path");
 init_paths();
 init_home_board();
 var FILE = "home-board-pins.json";
 var VERSION = 1;
 function pinsFile() {
-  return (0, import_node_path57.join)(appDataDir(), FILE);
+  return (0, import_node_path58.join)(appDataDir(), FILE);
 }
 function readDisk() {
   const path2 = pinsFile();
-  if (!(0, import_node_fs61.existsSync)(path2)) return [];
+  if (!(0, import_node_fs62.existsSync)(path2)) return [];
   try {
-    const raw = JSON.parse((0, import_node_fs61.readFileSync)(path2, "utf8"));
+    const raw = JSON.parse((0, import_node_fs62.readFileSync)(path2, "utf8"));
     if (raw?.version !== VERSION || !Array.isArray(raw.items)) return [];
     return raw.items.filter((item) => item?.id && item.kind && item.ref);
   } catch {
@@ -32459,8 +32655,8 @@ function readDisk() {
   }
 }
 function writeDisk(items) {
-  (0, import_node_fs61.mkdirSync)(appDataDir(), { recursive: true });
-  (0, import_node_fs61.writeFileSync)(pinsFile(), JSON.stringify({ version: VERSION, items }, null, 2), "utf8");
+  (0, import_node_fs62.mkdirSync)(appDataDir(), { recursive: true });
+  (0, import_node_fs62.writeFileSync)(pinsFile(), JSON.stringify({ version: VERSION, items }, null, 2), "utf8");
 }
 function listBoardPins() {
   return readDisk();
@@ -32512,7 +32708,7 @@ function replaceBoardPins(items) {
 }
 function clearBoardPins() {
   try {
-    (0, import_node_fs61.unlinkSync)(pinsFile());
+    (0, import_node_fs62.unlinkSync)(pinsFile());
   } catch {
   }
 }
@@ -32529,7 +32725,7 @@ function homeBoardWorkspaceKey(workspaces) {
   return workspaces.map((w) => w.path).filter(Boolean).sort().join("\n");
 }
 function cacheFile() {
-  return (0, import_node_path58.join)(appDataDir(), "home-board-cache.json");
+  return (0, import_node_path59.join)(appDataDir(), "home-board-cache.json");
 }
 function emptyInputs() {
   return {
@@ -32555,9 +32751,9 @@ function shouldCacheHomeBoardInputs(inputs) {
 }
 function readDiskCache() {
   const path2 = cacheFile();
-  if (!(0, import_node_fs62.existsSync)(path2)) return null;
+  if (!(0, import_node_fs63.existsSync)(path2)) return null;
   try {
-    const raw = JSON.parse((0, import_node_fs62.readFileSync)(path2, "utf8"));
+    const raw = JSON.parse((0, import_node_fs63.readFileSync)(path2, "utf8"));
     if (raw?.version !== CACHE_VERSION || typeof raw.fetchedAt !== "number") {
       return null;
     }
@@ -32571,14 +32767,14 @@ function readDiskCache() {
 }
 function writeDiskCache(entry) {
   try {
-    (0, import_node_fs62.mkdirSync)(appDataDir(), { recursive: true });
-    (0, import_node_fs62.writeFileSync)(cacheFile(), JSON.stringify(entry), "utf8");
+    (0, import_node_fs63.mkdirSync)(appDataDir(), { recursive: true });
+    (0, import_node_fs63.writeFileSync)(cacheFile(), JSON.stringify(entry), "utf8");
   } catch {
   }
 }
 function deleteDiskCache() {
   try {
-    (0, import_node_fs62.unlinkSync)(cacheFile());
+    (0, import_node_fs63.unlinkSync)(cacheFile());
   } catch {
   }
 }
@@ -32765,14 +32961,14 @@ function orchCreateThreadAgentNote(input) {
 var MAX_ORCH_THREADS = 5;
 var CREATE_THREAD_TIMEOUT_MS = 9e4;
 function withTimeout2(promise, ms, label) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const timer = setTimeout(() => {
       reject(new Error(`${label} timed out after ${Math.round(ms / 1e3)}s`));
     }, ms);
     promise.then(
       (value) => {
         clearTimeout(timer);
-        resolve(value);
+        resolve2(value);
       },
       (err) => {
         clearTimeout(timer);
@@ -32944,7 +33140,7 @@ async function startMcpServer() {
       async () => {
         const threads = orch.getThreads(true);
         const lines = threads.map((t) => {
-          const repo = t.repoPath === GLOBAL_WORKSPACE_ID2 ? "Orchestration" : (0, import_node_path59.basename)(t.repoPath) || t.repoPath;
+          const repo = t.repoPath === GLOBAL_WORKSPACE_ID2 ? "Orchestration" : (0, import_node_path60.basename)(t.repoPath) || t.repoPath;
           const live = orch.threadLooksLive(t) ? readTurnLive(t.id) : null;
           const parent = t.parentThreadId ? `  parent:${t.parentThreadId.slice(0, 8)}` : "";
           const preview = lastMessagePreview(t.messages, 80);
@@ -34398,13 +34594,13 @@ async function runCloudConnect(opts) {
         log(`poll error: ${msg}`);
       }
     }
-    await new Promise((resolve) => {
-      const t = setTimeout(resolve, pollMs);
+    await new Promise((resolve2) => {
+      const t = setTimeout(resolve2, pollMs);
       opts.signal?.addEventListener(
         "abort",
         () => {
           clearTimeout(t);
-          resolve();
+          resolve2();
         },
         { once: true }
       );
@@ -34612,14 +34808,14 @@ function slackOAuthAuthorizeUrl(clientId, state) {
   return `https://slack.com/oauth/v2/authorize?${params.toString()}`;
 }
 function sleep(ms, signal) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     if (signal?.aborted) {
       reject(new SlackOAuthCancelledError());
       return;
     }
     const timer = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve();
+      resolve2();
     }, ms);
     const onAbort = () => {
       clearTimeout(timer);
@@ -34811,12 +35007,12 @@ function resolveWebSocket(ctor) {
   return nodeWebSocketCtor();
 }
 function wait(ms, signal) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     if (signal?.aborted) {
       reject(new Error("aborted"));
       return;
     }
-    const t = setTimeout(resolve, ms);
+    const t = setTimeout(resolve2, ms);
     signal?.addEventListener(
       "abort",
       () => {
@@ -34861,14 +35057,14 @@ async function runSlackSocketMode(opts) {
   }
 }
 function connectSession(ws, opts, log) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     let settled = false;
     const finish = (err) => {
       if (settled) return;
       settled = true;
       opts.signal?.removeEventListener("abort", onAbort);
       if (err) reject(err);
-      else resolve();
+      else resolve2();
     };
     const onAbort = () => {
       try {
@@ -35039,12 +35235,12 @@ var CLAIM_FALLBACK_MS = 400;
 var BACKOFF_START_MS2 = 1e3;
 var BACKOFF_MAX_MS2 = 3e4;
 function wait2(ms, signal) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     if (signal?.aborted) {
       reject(new Error("aborted"));
       return;
     }
-    const t = setTimeout(resolve, ms);
+    const t = setTimeout(resolve2, ms);
     signal?.addEventListener(
       "abort",
       () => {
@@ -35103,7 +35299,7 @@ async function runSlackRelayClient(opts) {
   }
 }
 function connectSession2(ws, opts, log) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     let settled = false;
     const pending = /* @__PURE__ */ new Map();
     let relayAnswersClaims = false;
@@ -35137,7 +35333,7 @@ function connectSession2(ws, opts, log) {
       stopKeepalive();
       opts.signal?.removeEventListener("abort", onAbort);
       if (err) reject(err);
-      else resolve();
+      else resolve2();
     };
     const onAbort = () => {
       try {
@@ -36063,9 +36259,9 @@ var import_node_http4 = require("http");
 var import_ws3 = require("ws");
 
 // src/slack/relay-static.ts
-var import_node_fs63 = require("fs");
+var import_node_fs64 = require("fs");
 var import_promises = require("fs/promises");
-var import_node_path60 = __toESM(require("path"), 1);
+var import_node_path61 = __toESM(require("path"), 1);
 var TYPES = {
   ".css": "text/css; charset=utf-8",
   ".html": "text/html; charset=utf-8",
@@ -36096,9 +36292,9 @@ function resolveStaticPath(root, requestUrl) {
     return null;
   }
   if (!pathname.startsWith("/") || pathname.includes("\0")) return null;
-  const rootResolved = import_node_path60.default.resolve(root);
-  const candidate = import_node_path60.default.resolve(rootResolved, `.${pathname}`);
-  if (candidate !== rootResolved && !candidate.startsWith(rootResolved + import_node_path60.default.sep)) {
+  const rootResolved = import_node_path61.default.resolve(root);
+  const candidate = import_node_path61.default.resolve(rootResolved, `.${pathname}`);
+  if (candidate !== rootResolved && !candidate.startsWith(rootResolved + import_node_path61.default.sep)) {
     return null;
   }
   return candidate;
@@ -36112,7 +36308,7 @@ async function fileSize(file) {
   }
 }
 function sendFile(req, res, file, size) {
-  const ext = import_node_path60.default.extname(file).toLowerCase();
+  const ext = import_node_path61.default.extname(file).toLowerCase();
   res.writeHead(200, {
     "Content-Type": TYPES[ext] ?? "application/octet-stream",
     "Content-Length": size,
@@ -36122,7 +36318,7 @@ function sendFile(req, res, file, size) {
     res.end();
     return true;
   }
-  (0, import_node_fs63.createReadStream)(file).pipe(res);
+  (0, import_node_fs64.createReadStream)(file).pipe(res);
   return true;
 }
 async function tryServeStatic(req, res, root) {
@@ -36131,7 +36327,7 @@ async function tryServeStatic(req, res, root) {
   if (!candidate) return false;
   const direct = await fileSize(candidate);
   if (direct != null) return sendFile(req, res, candidate, direct);
-  const asIndex = import_node_path60.default.join(candidate, "index.html");
+  const asIndex = import_node_path61.default.join(candidate, "index.html");
   const indexSize = await fileSize(asIndex);
   if (indexSize != null) return sendFile(req, res, asIndex, indexSize);
   return false;
@@ -36331,9 +36527,9 @@ async function startSlackRelayServer(opts) {
   });
   const port = opts.port ?? 0;
   const host = opts.host ?? "0.0.0.0";
-  await new Promise((resolve, reject) => {
+  await new Promise((resolve2, reject) => {
     httpServer.once("error", reject);
-    httpServer.listen(port, host, () => resolve());
+    httpServer.listen(port, host, () => resolve2());
   });
   const address = httpServer.address();
   const boundPort = typeof address === "object" && address ? address.port : typeof port === "number" ? port : 0;
@@ -36362,11 +36558,11 @@ async function startSlackRelayServer(opts) {
     close: async () => {
       opts.signal?.removeEventListener("abort", onAbort);
       ac.abort();
-      await new Promise((resolve) => {
-        wss.close(() => resolve());
+      await new Promise((resolve2) => {
+        wss.close(() => resolve2());
       });
-      await new Promise((resolve, reject) => {
-        httpServer.close((err) => err ? reject(err) : resolve());
+      await new Promise((resolve2, reject) => {
+        httpServer.close((err) => err ? reject(err) : resolve2());
       });
       await socketModeDone.catch(() => void 0);
     }
@@ -36462,6 +36658,7 @@ async function startSlackRelayServer(opts) {
   PLAN_FILE_REL,
   PLAN_MODE_INSTRUCTION,
   PLAN_QUESTION_ANSWERS_PREFIX,
+  PORT_RANGE_SIZE,
   PROFILE_NOTES_MAX,
   PR_DETAILS_JSON_FIELDS,
   REPO_REVIEW_NAME,
@@ -36472,6 +36669,7 @@ async function startSlackRelayServer(opts) {
   REVIEW_REQUEST_TEMPLATE,
   REVIEW_SKILL_NAME,
   REVIEW_SKILL_PATH,
+  RUN_PORTS_REL,
   RUN_SCRIPT_DESKTOP_ADOPT_MS,
   SEED_FULL_TOOL_MESSAGES,
   SEED_MAX_CHARS,
@@ -36902,6 +37100,7 @@ async function startSlackRelayServer(opts) {
   isOptionalServiceId,
   isOrchestratorCapableAgent,
   isOrchestratorThread,
+  isOtherWorktreeListenerCwd,
   isPidAlive,
   isPlaceholderBranch,
   isPlanQuestionAnswersMessage,
@@ -36933,6 +37132,7 @@ async function startSlackRelayServer(opts) {
   issueSourceLabel,
   issueTicketFromThread,
   killListenersOnPorts,
+  killStaleWorktreeListeners,
   killableListenerPids,
   lastAgentReply,
   lastAssistantMessageText,
@@ -36980,6 +37180,7 @@ async function startSlackRelayServer(opts) {
   listWorkspaces,
   listWorktreeFiles,
   listWorktrees,
+  listenerCwd,
   liveActivitySummary,
   loadAppSettings,
   loadBrightsyConfig,
@@ -36987,6 +37188,7 @@ async function startSlackRelayServer(opts) {
   loadHomeBoardInputs,
   loadRepoSettings,
   loadWorkspaceSettings,
+  loadWorktreeRunPorts,
   localhostPreviewUrl,
   locksDir,
   loginAgent,
@@ -37180,6 +37382,7 @@ async function startSlackRelayServer(opts) {
   saveAbleTimeConnection,
   saveAppSettings,
   saveLinearOAuth,
+  saveWorktreeRunPorts,
   schedulesPath,
   scrubGithubTokensFromChildEnv,
   searchAbleTimeTasks,
@@ -37269,6 +37472,8 @@ async function startSlackRelayServer(opts) {
   toolFilePath,
   totalTokens,
   trustSystemCertificates,
+  tryReservePort,
+  tryReservePorts,
   turnCostUsdFromCursorUsage,
   updateAbleTimeTask,
   updateAdvancedSettings,
@@ -37307,6 +37512,7 @@ async function startSlackRelayServer(opts) {
   worktreeDisplayLabel,
   worktreeDisplayLabelForGroup,
   worktreeNameFromPath,
+  worktreeRunPortsPath,
   worktreeSlugForTicket,
   worktreesRoot,
   wrapReviewSkillMarkdown,