npm - @sideboard-ai/core - Versions diffs - 0.1.238 → 0.1.239 - Mend

@sideboard-ai/core 0.1.238 → 0.1.239

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/dist/{chunk-E6UJGLPM.js → chunk-CDG4CLWQ.js} +326 -147
package/dist/{chunk-32DG3DA2.js → chunk-D5SDZSEA.js} +337 -148
package/dist/index.cjs +501 -295
package/dist/index.d.cts +33 -2
package/dist/index.d.ts +33 -2
package/dist/index.js +22 -2
package/dist/mcp/run-stdio.cjs +482 -296
package/dist/mcp/run-stdio.js +2 -2
package/dist/{orchestrator-AAYKR4AI.js → orchestrator-3ZP4WTQ4.js} +1 -1
package/dist/{orchestrator-HPMDB2SG.js → orchestrator-R75VDUR2.js} +1 -1
package/package.json +1 -1

package/dist/mcp/run-stdio.cjs CHANGED Viewed

@@ -11236,10 +11236,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") {
@@ -14525,15 +14525,76 @@ var init_request_review = __esm({
   }
 });
+// src/hook/worktree-run-ports.ts
+function worktreeRunPortsPath(worktreePath) {
+  return (0, import_node_path38.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_fs38.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 path = worktreeRunPortsPath(worktreePath);
+  let current = {};
+  try {
+    current = parseFile((0, import_node_fs38.readFileSync)(path, "utf8"));
+  } catch {
+    current = {};
+  }
+  const scripts = { ...current.scripts ?? {} };
+  scripts[scriptName] = cleaned;
+  (0, import_node_fs38.mkdirSync)((0, import_node_path38.dirname)(path), { recursive: true });
+  (0, import_node_fs38.writeFileSync)(path, `${JSON.stringify({ scripts }, null, 2)}
+`, "utf8");
+}
+var import_node_fs38, import_node_path38, RUN_PORTS_REL;
+var init_worktree_run_ports = __esm({
+  "src/hook/worktree-run-ports.ts"() {
+    "use strict";
+    import_node_fs38 = require("fs");
+    import_node_path38 = 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 path = (0, import_node_path38.join)(repoPath, ".worktreeinclude");
-  if (!(0, import_node_fs38.existsSync)(path)) return [];
-  return (0, import_node_fs38.readFileSync)(path, "utf8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+  const path = (0, import_node_path39.join)(repoPath, ".worktreeinclude");
+  if (!(0, import_node_fs39.existsSync)(path)) return [];
+  return (0, import_node_fs39.readFileSync)(path, "utf8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
 }
 function resolveFilesToCopy(repoPath) {
   const fromInclude = readWorktreeInclude(repoPath);
@@ -14543,10 +14604,10 @@ function resolveFilesToCopy(repoPath) {
   if (settings?.fileIncludeGlobs?.length) {
     const matched = [];
     try {
-      for (const entry of (0, import_node_fs38.readdirSync)(repoPath, { withFileTypes: true })) {
+      for (const entry of (0, import_node_fs39.readdirSync)(repoPath, { withFileTypes: true })) {
         if (!entry.isFile()) continue;
         for (const glob of settings.fileIncludeGlobs) {
-          if (matchSimpleGlob(glob, entry.name) || matchSimpleGlob((0, import_node_path38.basename)(glob), entry.name)) {
+          if (matchSimpleGlob(glob, entry.name) || matchSimpleGlob((0, import_node_path39.basename)(glob), entry.name)) {
             matched.push(entry.name);
             break;
           }
@@ -14558,7 +14619,7 @@ function resolveFilesToCopy(repoPath) {
   }
   const defaults = [];
   try {
-    for (const entry of (0, import_node_fs38.readdirSync)(repoPath, { withFileTypes: true })) {
+    for (const entry of (0, import_node_fs39.readdirSync)(repoPath, { withFileTypes: true })) {
       if (entry.isFile() && entry.name.startsWith(".env")) {
         defaults.push(entry.name);
       }
@@ -14572,11 +14633,11 @@ function copyConfiguredFiles(repoPath, worktreePath) {
   const patterns = resolveFilesToCopy(repoPath);
   const copied = [];
   for (const rel of patterns) {
-    const src = (0, import_node_path38.join)(repoPath, rel);
-    if (!(0, import_node_fs38.existsSync)(src)) continue;
-    const dest = (0, import_node_path38.join)(worktreePath, rel);
-    (0, import_node_fs38.mkdirSync)((0, import_node_path38.dirname)(dest), { recursive: true });
-    (0, import_node_fs38.copyFileSync)(src, dest);
+    const src = (0, import_node_path39.join)(repoPath, rel);
+    if (!(0, import_node_fs39.existsSync)(src)) continue;
+    const dest = (0, import_node_path39.join)(worktreePath, rel);
+    (0, import_node_fs39.mkdirSync)((0, import_node_path39.dirname)(dest), { recursive: true });
+    (0, import_node_fs39.copyFileSync)(src, dest);
     copied.push(rel);
   }
   return copied;
@@ -14611,7 +14672,7 @@ function buildWorkspaceScriptEnv(opts, baseEnv) {
   const env = stripNestedElectronEnv({
     ...baseEnv ?? process.env
   });
-  const name = opts.workspaceName ?? (0, import_node_path38.basename)(opts.worktreePath);
+  const name = opts.workspaceName ?? (0, import_node_path39.basename)(opts.worktreePath);
   const ports = opts.ports ?? [];
   const primary = ports[0];
   env.SIDEBOARD_WORKSPACE_NAME = name;
@@ -14651,6 +14712,57 @@ function killableListenerPids(raw, selfPid = process.pid) {
   }
   return pids;
 }
+function listUnixListenerPids(port, selfPid) {
+  try {
+    const raw = (0, import_node_child_process4.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_process4.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(path) {
+  try {
+    return (0, import_node_fs39.realpathSync)(path);
+  } catch {
+    return (0, import_node_path39.resolve)(path);
+  }
+}
+function isOtherWorktreeListenerCwd(cwd, worktreePath) {
+  const wt = realpathOrResolve(worktreePath);
+  const c = realpathOrResolve(cwd);
+  if (c === wt || c.startsWith(wt + import_node_path39.sep)) return false;
+  const parent = (0, import_node_path39.dirname)(wt);
+  const thisName = (0, import_node_path39.basename)(wt);
+  if (!thisName || c === parent) return false;
+  if (!c.startsWith(parent + import_node_path39.sep)) return false;
+  const first = c.slice(parent.length + 1).split(import_node_path39.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) {
@@ -14668,26 +14780,32 @@ function killListenersOnPorts(ports) {
         );
         continue;
       }
-      let raw = "";
-      try {
-        raw = (0, import_node_child_process4.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) {
@@ -14849,7 +14967,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) => {
@@ -14866,13 +14984,14 @@ 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);
   });
 }
 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) => {
@@ -14883,24 +15002,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) {
@@ -14908,11 +15057,43 @@ 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 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,
@@ -14935,14 +15116,14 @@ async function startDevServer(repoPath, worktreePath, onLine, opts) {
     throw err;
   }
 }
-var import_node_fs38, import_node_child_process4, import_node_net, import_node_path38, import_execa4, import_node_readline3, PORT_RANGE_SIZE, cachedLoginEnv;
+var import_node_fs39, import_node_child_process4, import_node_net, import_node_path39, 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_fs38 = require("fs");
+    import_node_fs39 = require("fs");
     import_node_child_process4 = require("child_process");
     import_node_net = require("net");
-    import_node_path38 = require("path");
+    import_node_path39 = require("path");
     import_execa4 = require("execa");
     import_node_readline3 = require("readline");
     init_settings();
@@ -14953,8 +15134,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;
   }
 });
@@ -14992,7 +15177,7 @@ function materialize(mem) {
   };
 }
 function setupLogPath(threadId) {
-  return (0, import_node_path39.join)(threadsDir(), `${threadId}.setup.log.json`);
+  return (0, import_node_path40.join)(threadsDir(), `${threadId}.setup.log.json`);
 }
 function setupLogKeyForWorktree(worktreePath) {
   const norm = normalizeWorktreePath(worktreePath);
@@ -15010,7 +15195,7 @@ function persistNow(threadId) {
   const mem = memory.get(threadId);
   if (!mem) return;
   try {
-    (0, import_node_fs39.writeFileSync)(
+    (0, import_node_fs40.writeFileSync)(
       setupLogPath(threadId),
       `${JSON.stringify(materialize(mem))}
 `,
@@ -15031,9 +15216,9 @@ function schedulePersist(threadId) {
 }
 function loadFromDisk(threadId) {
   const path = setupLogPath(threadId);
-  if (!(0, import_node_fs39.existsSync)(path)) return null;
+  if (!(0, import_node_fs40.existsSync)(path)) return null;
   try {
-    const raw = JSON.parse((0, import_node_fs39.readFileSync)(path, "utf8"));
+    const raw = JSON.parse((0, import_node_fs40.readFileSync)(path, "utf8"));
     return {
       output: typeof raw.output === "string" ? raw.output : "",
       running: Boolean(raw.running),
@@ -15089,13 +15274,13 @@ function finishSetupLog(threadId, exitCode, source) {
   persistNow(threadId);
   return materialize(mem);
 }
-var import_node_crypto8, import_node_fs39, import_node_path39, EMPTY, MAX_SETUP_LOG_CHARS, memory, persistTimers, PERSIST_DEBOUNCE_MS;
+var import_node_crypto8, import_node_fs40, import_node_path40, EMPTY, MAX_SETUP_LOG_CHARS, memory, persistTimers, PERSIST_DEBOUNCE_MS;
 var init_setup_log = __esm({
   "src/store/setup-log.ts"() {
     "use strict";
     import_node_crypto8 = require("crypto");
-    import_node_fs39 = require("fs");
-    import_node_path39 = require("path");
+    import_node_fs40 = require("fs");
+    import_node_path40 = require("path");
     init_worktree_labels();
     init_paths();
     EMPTY = {
@@ -15140,7 +15325,7 @@ function safeScriptToken(scriptName) {
   return token || "dev";
 }
 function runLogPath(key) {
-  return (0, import_node_path40.join)(threadsDir(), `${key}.run.log.json`);
+  return (0, import_node_path41.join)(threadsDir(), `${key}.run.log.json`);
 }
 function runLogKeyForWorktree(worktreePath, scriptName) {
   const norm = normalizeWorktreePath(worktreePath);
@@ -15168,7 +15353,7 @@ function persistNow2(key) {
   const mem = memory2.get(key);
   if (!mem) return;
   try {
-    (0, import_node_fs40.writeFileSync)(runLogPath(key), `${JSON.stringify(materialize2(mem))}
+    (0, import_node_fs41.writeFileSync)(runLogPath(key), `${JSON.stringify(materialize2(mem))}
 `, "utf8");
   } catch {
   }
@@ -15185,9 +15370,9 @@ function schedulePersist2(key) {
 }
 function loadFromDisk2(key) {
   const path = runLogPath(key);
-  if (!(0, import_node_fs40.existsSync)(path)) return null;
+  if (!(0, import_node_fs41.existsSync)(path)) return null;
   try {
-    const raw = JSON.parse((0, import_node_fs40.readFileSync)(path, "utf8"));
+    const raw = JSON.parse((0, import_node_fs41.readFileSync)(path, "utf8"));
     return {
       output: typeof raw.output === "string" ? raw.output : "",
       running: Boolean(raw.running),
@@ -15245,13 +15430,13 @@ function finishRunLog(key, exitCode) {
 function flushRunLog(key) {
   persistNow2(key);
 }
-var import_node_crypto9, import_node_fs40, import_node_path40, EMPTY2, MAX_RUN_LOG_CHARS, DEFAULT_RUN_LOG_TAIL_CHARS, memory2, persistTimers2, PERSIST_DEBOUNCE_MS2;
+var import_node_crypto9, import_node_fs41, import_node_path41, EMPTY2, MAX_RUN_LOG_CHARS, DEFAULT_RUN_LOG_TAIL_CHARS, memory2, persistTimers2, PERSIST_DEBOUNCE_MS2;
 var init_run_log = __esm({
   "src/store/run-log.ts"() {
     "use strict";
     import_node_crypto9 = require("crypto");
-    import_node_fs40 = require("fs");
-    import_node_path40 = require("path");
+    import_node_fs41 = require("fs");
+    import_node_path41 = require("path");
     init_worktree_labels();
     init_setup_log();
     init_paths();
@@ -15280,9 +15465,9 @@ async function findOrphanWorktrees(repoPaths) {
     repoPaths?.length ? repoPaths : threads.map((t) => t.repoPath).filter(Boolean)
   );
   const homeRoot = sideboardWorkspacesDir();
-  if ((0, import_node_fs41.existsSync)(homeRoot)) {
+  if ((0, import_node_fs42.existsSync)(homeRoot)) {
     try {
-      for (const entry of (0, import_node_fs41.readdirSync)(homeRoot, { withFileTypes: true })) {
+      for (const entry of (0, import_node_fs42.readdirSync)(homeRoot, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
         void entry;
       }
@@ -15292,7 +15477,7 @@ async function findOrphanWorktrees(repoPaths) {
   const orphans = [];
   const seen = /* @__PURE__ */ new Set();
   for (const repoPath of repos) {
-    if (!repoPath || !(0, import_node_fs41.existsSync)(repoPath)) continue;
+    if (!repoPath || !(0, import_node_fs42.existsSync)(repoPath)) continue;
     try {
       const wts = await listWorktrees(repoPath);
       for (const wt of wts) {
@@ -15303,7 +15488,7 @@ async function findOrphanWorktrees(repoPaths) {
         seen.add(path);
         let mtimeMs = 0;
         try {
-          mtimeMs = (0, import_node_fs41.statSync)(path).mtimeMs;
+          mtimeMs = (0, import_node_fs42.statSync)(path).mtimeMs;
         } catch {
           mtimeMs = 0;
         }
@@ -15313,16 +15498,16 @@ async function findOrphanWorktrees(repoPaths) {
     }
     try {
       const root = worktreesRoot(repoPath);
-      if ((0, import_node_fs41.existsSync)(root)) {
-        for (const entry of (0, import_node_fs41.readdirSync)(root, { withFileTypes: true })) {
+      if ((0, import_node_fs42.existsSync)(root)) {
+        for (const entry of (0, import_node_fs42.readdirSync)(root, { withFileTypes: true })) {
           if (!entry.isDirectory()) continue;
-          const path = (0, import_node_path41.join)(root, entry.name).replace(/\/$/, "");
+          const path = (0, import_node_path42.join)(root, entry.name).replace(/\/$/, "");
           if (known.has(path) || seen.has(path)) continue;
-          if (!(0, import_node_fs41.existsSync)((0, import_node_path41.join)(path, ".git"))) continue;
+          if (!(0, import_node_fs42.existsSync)((0, import_node_path42.join)(path, ".git"))) continue;
           seen.add(path);
           let mtimeMs = 0;
           try {
-            mtimeMs = (0, import_node_fs41.statSync)(path).mtimeMs;
+            mtimeMs = (0, import_node_fs42.statSync)(path).mtimeMs;
           } catch {
             mtimeMs = Date.now();
           }
@@ -15374,12 +15559,12 @@ function shouldRunWorktreeCleanup(settings = loadAppSettings()) {
   const elapsed = Date.now() - Date.parse(last);
   return elapsed >= intervalHours * 36e5;
 }
-var import_node_fs41, import_node_path41;
+var import_node_fs42, import_node_path42;
 var init_orphan_cleanup = __esm({
   "src/git/orphan-cleanup.ts"() {
     "use strict";
-    import_node_fs41 = require("fs");
-    import_node_path41 = require("path");
+    import_node_fs42 = require("fs");
+    import_node_path42 = require("path");
     init_worktree();
     init_thread_store();
     init_paths();
@@ -15554,12 +15739,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_path42.basename)(url.replace(/\/$/, "").replace(/\.git$/, ""));
+    const leaf = (0, import_node_path43.basename)(url.replace(/\/$/, "").replace(/\.git$/, ""));
     name = leaf || "repo";
   }
   name = name.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "repo";
-  const dest = (0, import_node_path42.join)(sideboardReposDir(), name);
-  if ((0, import_node_fs42.existsSync)(dest)) {
+  const dest = (0, import_node_path43.join)(sideboardReposDir(), name);
+  if ((0, import_node_fs43.existsSync)(dest)) {
     const repoPath2 = await resolveRepoRoot(dest);
     const workspace2 = await ensureWorkspace(repoPath2);
     return { repoPath: repoPath2, workspace: workspace2 };
@@ -15574,12 +15759,12 @@ async function cloneRepoIntoSideboard(opts) {
   const workspace = await ensureWorkspace(repoPath);
   return { repoPath, workspace };
 }
-var import_node_fs42, import_node_path42, import_execa6;
+var import_node_fs43, import_node_path43, import_execa6;
 var init_clone_repo = __esm({
   "src/git/clone-repo.ts"() {
     "use strict";
-    import_node_fs42 = require("fs");
-    import_node_path42 = require("path");
+    import_node_fs43 = require("fs");
+    import_node_path43 = require("path");
     import_execa6 = require("execa");
     init_paths();
     init_workspaces();
@@ -15599,11 +15784,11 @@ var init_thread = __esm({
 // src/store/desktop-host.ts
 function desktopHostPidPath() {
-  return (0, import_node_path43.join)(appDataDir(), "desktop-host.pid");
+  return (0, import_node_path44.join)(appDataDir(), "desktop-host.pid");
 }
 function readDesktopHostPid() {
   try {
-    const pid = Number.parseInt((0, import_node_fs43.readFileSync)(desktopHostPidPath(), "utf8").trim(), 10);
+    const pid = Number.parseInt((0, import_node_fs44.readFileSync)(desktopHostPidPath(), "utf8").trim(), 10);
     if (!Number.isFinite(pid) || pid <= 0) return null;
     return pid;
   } catch {
@@ -15629,12 +15814,12 @@ function thisProcessShouldDrainAgentQueues() {
   if (isThisProcessDesktopHost()) return true;
   return !isDesktopHostAlive();
 }
-var import_node_fs43, import_node_path43;
+var import_node_fs44, import_node_path44;
 var init_desktop_host = __esm({
   "src/store/desktop-host.ts"() {
     "use strict";
-    import_node_fs43 = require("fs");
-    import_node_path43 = require("path");
+    import_node_fs44 = require("fs");
+    import_node_path44 = require("path");
     init_paths();
   }
 });
@@ -15760,24 +15945,24 @@ function jobTreeAlive(pid) {
   return jobAlive(pid) || processGroupAlive(pid);
 }
 function readIntFile(file) {
-  if (!(0, import_node_fs44.existsSync)(file)) return null;
-  const n = Number.parseInt((0, import_node_fs44.readFileSync)(file, "utf8").trim(), 10);
+  if (!(0, import_node_fs45.existsSync)(file)) return null;
+  const n = Number.parseInt((0, import_node_fs45.readFileSync)(file, "utf8").trim(), 10);
   return Number.isInteger(n) ? n : null;
 }
 function jobDir(root, id, legacy = false) {
-  return (0, import_node_path44.join)(root, legacy ? LEGACY_DETACHED_JOBS_DIR : DETACHED_JOBS_DIR, id);
+  return (0, import_node_path45.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_fs44.existsSync)(modern)) return modern;
+  if ((0, import_node_fs45.existsSync)(modern)) return modern;
   const legacy = jobDir(root, id, true);
-  if ((0, import_node_fs44.existsSync)(legacy)) return legacy;
+  if ((0, import_node_fs45.existsSync)(legacy)) return legacy;
   return modern;
 }
 function listJobIdsIn(root, rel) {
-  const dir = (0, import_node_path44.join)(root, rel);
-  if (!(0, import_node_fs44.existsSync)(dir)) return [];
-  return (0, import_node_fs44.readdirSync)(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && JOB_ID_RE.test(e.name)).map((e) => e.name);
+  const dir = (0, import_node_path45.join)(root, rel);
+  if (!(0, import_node_fs45.existsSync)(dir)) return [];
+  return (0, import_node_fs45.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();
@@ -15789,7 +15974,7 @@ function listRunningDetachedJobs(worktreePath) {
   const running = [];
   for (const id of ids) {
     const dir = resolveJobDir(root, id);
-    const pid = readIntFile((0, import_node_path44.join)(dir, "pid"));
+    const pid = readIntFile((0, import_node_path45.join)(dir, "pid"));
     if (jobTreeAlive(pid)) running.push(id);
   }
   return running.sort();
@@ -15872,8 +16057,8 @@ function planJobContinue(opts) {
   return { action: "none" };
 }
 function tailProgress(logFile, maxLines = 12) {
-  if (!(0, import_node_fs44.existsSync)(logFile)) return "(no log yet)";
-  const lines = (0, import_node_fs44.readFileSync)(logFile, "utf8").split("\n");
+  if (!(0, import_node_fs45.existsSync)(logFile)) return "(no log yet)";
+  const lines = (0, import_node_fs45.readFileSync)(logFile, "utf8").split("\n");
   return lines.slice(-maxLines).join("\n");
 }
 function lastProgressLine(progress) {
@@ -15881,8 +16066,8 @@ function lastProgressLine(progress) {
   return last ? last.slice(0, 72) : void 0;
 }
 function readLogLines(file) {
-  if (!(0, import_node_fs44.existsSync)(file)) return [];
-  const lines = (0, import_node_fs44.readFileSync)(file, "utf8").split("\n");
+  if (!(0, import_node_fs45.existsSync)(file)) return [];
+  const lines = (0, import_node_fs45.readFileSync)(file, "utf8").split("\n");
   if (lines.length && lines[lines.length - 1] === "") lines.pop();
   return lines;
 }
@@ -15893,15 +16078,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_path44.join)(dir, "pid"));
+  const pid = readIntFile((0, import_node_path45.join)(dir, "pid"));
   const running = jobTreeAlive(pid);
   return {
     pid,
     running,
-    exitCode: readIntFile((0, import_node_path44.join)(dir, "exit")),
-    log: (0, import_node_path44.join)(dir, "log"),
-    cursor: (0, import_node_path44.join)(dir, "present.cursor"),
-    progress: tailProgress((0, import_node_path44.join)(dir, "log"))
+    exitCode: readIntFile((0, import_node_path45.join)(dir, "exit")),
+    log: (0, import_node_path45.join)(dir, "log"),
+    cursor: (0, import_node_path45.join)(dir, "present.cursor"),
+    progress: tailProgress((0, import_node_path45.join)(dir, "log"))
   };
 }
 function toResult(id, snap, extra) {
@@ -15910,8 +16095,8 @@ function toResult(id, snap, extra) {
   const stillRunning = snap.running && !ok;
   const { delta, nextCursor } = takeDelta(snap.log, snap.cursor);
   try {
-    (0, import_node_fs44.mkdirSync)((0, import_node_path44.dirname)(snap.cursor), { recursive: true });
-    (0, import_node_fs44.writeFileSync)(snap.cursor, `${nextCursor}
+    (0, import_node_fs45.mkdirSync)((0, import_node_path45.dirname)(snap.cursor), { recursive: true });
+    (0, import_node_fs45.writeFileSync)(snap.cursor, `${nextCursor}
 `);
   } catch {
   }
@@ -15932,7 +16117,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);
@@ -15940,7 +16125,7 @@ async function waitForDetachedJob(cwd, id, opts) {
   const dir = resolveJobDir(root, jobId);
   const timeoutMs = mcpWaitForJobTimeoutMs(opts?.timeoutMs);
   const sleep = opts?.sleep ?? sleepMs;
-  if (!(0, import_node_fs44.existsSync)(dir)) {
+  if (!(0, import_node_fs45.existsSync)(dir)) {
     return {
       stillRunning: false,
       ok: false,
@@ -15986,10 +16171,10 @@ function killProcessTree(pid, signal) {
 }
 function appendJobLog(logFile, line) {
   try {
-    (0, import_node_fs44.mkdirSync)((0, import_node_path44.dirname)(logFile), { recursive: true });
+    (0, import_node_fs45.mkdirSync)((0, import_node_path45.dirname)(logFile), { recursive: true });
     const body = line.endsWith("\n") ? line : `${line}
 `;
-    (0, import_node_fs44.appendFileSync)(logFile, body);
+    (0, import_node_fs45.appendFileSync)(logFile, body);
   } catch {
   }
 }
@@ -15999,7 +16184,7 @@ async function stopDetachedJob(cwd, id, opts) {
   const dir = resolveJobDir(root, jobId);
   const sleep = opts?.sleep ?? sleepMs;
   const why = opts?.reason?.trim() ?? "";
-  if (!(0, import_node_fs44.existsSync)(dir)) {
+  if (!(0, import_node_fs45.existsSync)(dir)) {
     return {
       stillRunning: false,
       ok: false,
@@ -16035,10 +16220,10 @@ async function stopDetachedJob(cwd, id, opts) {
     killProcessTree(targetPid, "SIGKILL");
     await sleep(100);
   }
-  const exitFile = (0, import_node_path44.join)(dir, "exit");
-  if (!(0, import_node_fs44.existsSync)(exitFile)) {
+  const exitFile = (0, import_node_path45.join)(dir, "exit");
+  if (!(0, import_node_fs45.existsSync)(exitFile)) {
     try {
-      (0, import_node_fs44.writeFileSync)(exitFile, "1\n");
+      (0, import_node_fs45.writeFileSync)(exitFile, "1\n");
     } catch {
     }
   }
@@ -16058,12 +16243,12 @@ async function stopDetachedJob(cwd, id, opts) {
     hint: stopped ? MCP_STOP_JOB_HINT : MCP_WAIT_JOB_STILL_RUNNING_HINT
   };
 }
-var import_node_fs44, import_node_path44, 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_fs45, import_node_path45, 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_fs44 = require("fs");
-    import_node_path44 = require("path");
+    import_node_fs45 = require("fs");
+    import_node_path45 = require("path");
     init_workspace_scratch();
     init_wait_for_turn();
     MAX_JOB_CONTINUES = 8;
@@ -16798,14 +16983,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 {
@@ -18098,7 +18283,7 @@ function reuseLiveThread(input, repoPath, match) {
 }
 async function createThread(input, _onSetupLine) {
   const repoPath = await resolveRepoRoot(input.repoPath);
-  if (!(0, import_node_fs45.existsSync)(repoPath)) {
+  if (!(0, import_node_fs46.existsSync)(repoPath)) {
     throw new Error(`Repo not found: ${repoPath}`);
   }
   const reused = reuseLiveThread(input, repoPath, {
@@ -18274,11 +18459,11 @@ async function createThread(input, _onSetupLine) {
   await ensureWorkspace(repoPath);
   return readThread(thread.id) ?? thread;
 }
-var import_node_fs45;
+var import_node_fs46;
 var init_create = __esm({
   "src/threads/create.ts"() {
     "use strict";
-    import_node_fs45 = require("fs");
+    import_node_fs46 = require("fs");
     init_detect();
     init_worktree();
     init_home_board();
@@ -18430,20 +18615,20 @@ function writeTurnLive(threadId, progress) {
   const path = threadLivePath(threadId);
   const tmp = `${path}.${process.pid}.tmp`;
   try {
-    (0, import_node_fs46.writeFileSync)(tmp, JSON.stringify(progress), "utf8");
-    (0, import_node_fs46.renameSync)(tmp, path);
+    (0, import_node_fs47.writeFileSync)(tmp, JSON.stringify(progress), "utf8");
+    (0, import_node_fs47.renameSync)(tmp, path);
   } catch {
     try {
-      (0, import_node_fs46.unlinkSync)(tmp);
+      (0, import_node_fs47.unlinkSync)(tmp);
     } catch {
     }
   }
 }
 function readTurnLive(threadId) {
   const path = threadLivePath(threadId);
-  if (!(0, import_node_fs46.existsSync)(path)) return null;
+  if (!(0, import_node_fs47.existsSync)(path)) return null;
   try {
-    const raw = JSON.parse((0, import_node_fs46.readFileSync)(path, "utf8"));
+    const raw = JSON.parse((0, import_node_fs47.readFileSync)(path, "utf8"));
     if (!raw || typeof raw.summary !== "string") return null;
     return raw;
   } catch {
@@ -18455,17 +18640,17 @@ function clearTurnLive(threadId) {
   if (buf?.timer) clearTimeout(buf.timer);
   buffers.delete(threadId);
   const path = threadLivePath(threadId);
-  if (!(0, import_node_fs46.existsSync)(path)) return;
+  if (!(0, import_node_fs47.existsSync)(path)) return;
   try {
-    (0, import_node_fs46.unlinkSync)(path);
+    (0, import_node_fs47.unlinkSync)(path);
   } catch {
   }
 }
-var import_node_fs46, buffers, FLUSH_MS, MAX_PARTS;
+var import_node_fs47, buffers, FLUSH_MS, MAX_PARTS;
 var init_turn_live = __esm({
   "src/store/turn-live.ts"() {
     "use strict";
-    import_node_fs46 = require("fs");
+    import_node_fs47 = require("fs");
     init_message_parts();
     init_paths();
     buffers = /* @__PURE__ */ new Map();
@@ -18706,7 +18891,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_path45.join)(process.cwd(), "package.json");
+  return cjsFile || process.argv[1] || (0, import_node_path46.join)(process.cwd(), "package.json");
 }
 function openReadonlySqlite(file) {
   const req = (0, import_node_module5.createRequire)(thisModuleFile2());
@@ -18724,21 +18909,21 @@ function mapAgentType(raw) {
   return null;
 }
 function resolveConductorCursorAgentId(workspacePath) {
-  if (!workspacePath || !(0, import_node_fs47.existsSync)(CURSOR_SDK_STORE)) return null;
+  if (!workspacePath || !(0, import_node_fs48.existsSync)(CURSOR_SDK_STORE)) return null;
   const normalized = workspacePath.replace(/\/$/, "");
   let best = null;
   let hashes;
   try {
-    hashes = (0, import_node_fs47.readdirSync)(CURSOR_SDK_STORE);
+    hashes = (0, import_node_fs48.readdirSync)(CURSOR_SDK_STORE);
   } catch {
     return null;
   }
   for (const hash of hashes) {
-    const agentsFile = (0, import_node_path45.join)(CURSOR_SDK_STORE, hash, "agents.ndjson");
-    if (!(0, import_node_fs47.existsSync)(agentsFile)) continue;
+    const agentsFile = (0, import_node_path46.join)(CURSOR_SDK_STORE, hash, "agents.ndjson");
+    if (!(0, import_node_fs48.existsSync)(agentsFile)) continue;
     let text7;
     try {
-      text7 = (0, import_node_fs47.readFileSync)(agentsFile, "utf8");
+      text7 = (0, import_node_fs48.readFileSync)(agentsFile, "utf8");
     } catch {
       continue;
     }
@@ -18762,7 +18947,7 @@ function resolveConductorCursorAgentId(workspacePath) {
   return best?.agentId ?? null;
 }
 async function adoptThread(input) {
-  if (!(0, import_node_fs47.existsSync)(input.worktreePath)) {
+  if (!(0, import_node_fs48.existsSync)(input.worktreePath)) {
     throw new Error(`Worktree not found: ${input.worktreePath}`);
   }
   const repoPath = await resolveRepoRoot(input.worktreePath);
@@ -18788,18 +18973,18 @@ async function adoptThread(input) {
   return thread;
 }
 function listConductorWorkspaces() {
-  if (!(0, import_node_fs47.existsSync)(CONDUCTOR_DB)) {
+  if (!(0, import_node_fs48.existsSync)(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = (0, import_node_fs47.mkdtempSync)((0, import_node_path45.join)((0, import_node_os14.tmpdir)(), "sideboard-conductor-"));
-  const snapshot = (0, import_node_path45.join)(tmp, "conductor.db");
+  const tmp = (0, import_node_fs48.mkdtempSync)((0, import_node_path46.join)((0, import_node_os14.tmpdir)(), "sideboard-conductor-"));
+  const snapshot = (0, import_node_path46.join)(tmp, "conductor.db");
   try {
-    (0, import_node_fs47.copyFileSync)(CONDUCTOR_DB, snapshot);
+    (0, import_node_fs48.copyFileSync)(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if ((0, import_node_fs47.existsSync)(src)) {
+      if ((0, import_node_fs48.existsSync)(src)) {
         try {
-          (0, import_node_fs47.copyFileSync)(src, `${snapshot}${suffix}`);
+          (0, import_node_fs48.copyFileSync)(src, `${snapshot}${suffix}`);
         } catch {
         }
       }
@@ -18875,22 +19060,22 @@ function listConductorWorkspaces() {
       db.close();
     }
   } finally {
-    (0, import_node_fs47.rmSync)(tmp, { recursive: true, force: true });
+    (0, import_node_fs48.rmSync)(tmp, { recursive: true, force: true });
   }
 }
 function importConductorWorkspace(workspaceId) {
-  if (!(0, import_node_fs47.existsSync)(CONDUCTOR_DB)) {
+  if (!(0, import_node_fs48.existsSync)(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = (0, import_node_fs47.mkdtempSync)((0, import_node_path45.join)((0, import_node_os14.tmpdir)(), "sideboard-conductor-"));
-  const snapshot = (0, import_node_path45.join)(tmp, "conductor.db");
+  const tmp = (0, import_node_fs48.mkdtempSync)((0, import_node_path46.join)((0, import_node_os14.tmpdir)(), "sideboard-conductor-"));
+  const snapshot = (0, import_node_path46.join)(tmp, "conductor.db");
   try {
-    (0, import_node_fs47.copyFileSync)(CONDUCTOR_DB, snapshot);
+    (0, import_node_fs48.copyFileSync)(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if ((0, import_node_fs47.existsSync)(src)) {
+      if ((0, import_node_fs48.existsSync)(src)) {
         try {
-          (0, import_node_fs47.copyFileSync)(src, `${snapshot}${suffix}`);
+          (0, import_node_fs48.copyFileSync)(src, `${snapshot}${suffix}`);
         } catch {
         }
       }
@@ -18908,7 +19093,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_fs47.existsSync)(worktreePath)) {
+      if (!(0, import_node_fs48.existsSync)(worktreePath)) {
         throw new Error(`Conductor worktree missing on disk: ${worktreePath}`);
       }
       let sessionId = null;
@@ -18971,31 +19156,31 @@ function importConductorWorkspace(workspaceId) {
       db.close();
     }
   } finally {
-    (0, import_node_fs47.rmSync)(tmp, { recursive: true, force: true });
+    (0, import_node_fs48.rmSync)(tmp, { recursive: true, force: true });
   }
 }
 async function importConductorWorkspaceAsync(workspaceId) {
   return importConductorWorkspace(workspaceId);
 }
-var import_node_child_process5, import_node_fs47, import_node_os14, import_node_path45, import_node_module5, CONDUCTOR_APP_SUPPORT, CONDUCTOR_DB, CURSOR_SDK_STORE;
+var import_node_child_process5, import_node_fs48, import_node_os14, import_node_path46, import_node_module5, CONDUCTOR_APP_SUPPORT, CONDUCTOR_DB, CURSOR_SDK_STORE;
 var init_adopt = __esm({
   "src/threads/adopt.ts"() {
     "use strict";
     import_node_child_process5 = require("child_process");
-    import_node_fs47 = require("fs");
+    import_node_fs48 = require("fs");
     import_node_os14 = require("os");
-    import_node_path45 = require("path");
+    import_node_path46 = require("path");
     import_node_module5 = require("module");
     init_worktree();
     init_thread_store();
-    CONDUCTOR_APP_SUPPORT = (0, import_node_path45.join)(
+    CONDUCTOR_APP_SUPPORT = (0, import_node_path46.join)(
       process.env.HOME ?? "",
       "Library",
       "Application Support",
       "com.conductor.app"
     );
-    CONDUCTOR_DB = (0, import_node_path45.join)(CONDUCTOR_APP_SUPPORT, "conductor.db");
-    CURSOR_SDK_STORE = (0, import_node_path45.join)(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
+    CONDUCTOR_DB = (0, import_node_path46.join)(CONDUCTOR_APP_SUPPORT, "conductor.db");
+    CURSOR_SDK_STORE = (0, import_node_path46.join)(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
   }
 });
@@ -19062,7 +19247,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_fs48.existsSync)(checkedOut.path)) {
+  if (checkedOut?.path && (0, import_node_fs49.existsSync)(checkedOut.path)) {
     if (input.reuseExistingWorktree !== false) {
       worktreePath = checkedOut.path;
     } else {
@@ -19204,7 +19389,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_fs48.existsSync)(repoPath)) throw new Error(`Repo not found: ${repoPath}`);
+  if (!(0, import_node_fs49.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);
@@ -19271,7 +19456,7 @@ async function createPrStack(input, onSetupLine) {
     }
   }
   const claimed = new Set(threads.map((t) => t.worktreePath));
-  if (!claimed.has(bootstrap.worktreePath) && (0, import_node_fs48.existsSync)(bootstrap.worktreePath)) {
+  if (!claimed.has(bootstrap.worktreePath) && (0, import_node_fs49.existsSync)(bootstrap.worktreePath)) {
     try {
       await removeWorktree(repoPath, bootstrap.worktreePath, {
         deleteBranch: bootstrap.branchName
@@ -19281,11 +19466,11 @@ async function createPrStack(input, onSetupLine) {
   }
   return { stack, threads, createdThreadIds };
 }
-var import_node_fs48;
+var import_node_fs49;
 var init_stack_layers = __esm({
   "src/threads/stack-layers.ts"() {
     "use strict";
-    import_node_fs48 = require("fs");
+    import_node_fs49 = require("fs");
     init_detect();
     init_run();
     init_stack();
@@ -19298,7 +19483,7 @@ var init_stack_layers = __esm({
 // src/diff/diff.ts
 async function inspectGitWorktree(worktreePath) {
-  if (!worktreePath || !(0, import_node_fs49.existsSync)(worktreePath)) return "missing_worktree";
+  if (!worktreePath || !(0, import_node_fs50.existsSync)(worktreePath)) return "missing_worktree";
   const check = await git(["rev-parse", "--is-inside-work-tree"], worktreePath, {
     reject: false
   });
@@ -19306,7 +19491,7 @@ async function inspectGitWorktree(worktreePath) {
   return "ok";
 }
 async function initializeGitRepository(worktreePath) {
-  if (!worktreePath || !(0, import_node_fs49.existsSync)(worktreePath)) {
+  if (!worktreePath || !(0, import_node_fs50.existsSync)(worktreePath)) {
     throw new Error("Worktree not found");
   }
   const status = await inspectGitWorktree(worktreePath);
@@ -19440,11 +19625,11 @@ new file mode 100644
   };
 }
 async function untrackedPatch(worktreePath, path, maxHunk) {
-  const abs = (0, import_node_path46.join)(worktreePath, path);
+  const abs = (0, import_node_path47.join)(worktreePath, path);
   try {
-    const st = (0, import_node_fs49.statSync)(abs);
+    const st = (0, import_node_fs50.statSync)(abs);
     if (st.isFile() && st.size > maxHunk) {
-      const buf = (0, import_node_fs49.readFileSync)(abs).subarray(0, maxHunk);
+      const buf = (0, import_node_fs50.readFileSync)(abs).subarray(0, maxHunk);
       return syntheticAddPatch(path, buf.toString("utf8"), maxHunk);
     }
   } catch {
@@ -19911,9 +20096,9 @@ async function getDiff(worktreePath, repoPath, opts) {
 }
 function statWorktreePath(worktreePath, relativePath) {
   assertSafeRelativePath(relativePath);
-  const abs = (0, import_node_path46.join)(worktreePath, relativePath);
-  if (!(0, import_node_fs49.existsSync)(abs)) return "missing";
-  const st = (0, import_node_fs49.statSync)(abs);
+  const abs = (0, import_node_path47.join)(worktreePath, relativePath);
+  if (!(0, import_node_fs50.existsSync)(abs)) return "missing";
+  const st = (0, import_node_fs50.statSync)(abs);
   if (st.isDirectory()) return "dir";
   if (st.isFile()) return "file";
   return "missing";
@@ -19942,8 +20127,8 @@ function isImageRelativePath(relativePath) {
 function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? DEFAULT_UPLOAD_MAX_BYTES;
-  const abs = (0, import_node_path46.join)(worktreePath, relativePath);
-  const st = (0, import_node_fs49.statSync)(abs);
+  const abs = (0, import_node_path47.join)(worktreePath, relativePath);
+  const st = (0, import_node_fs50.statSync)(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
@@ -19952,7 +20137,7 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
       `File too large to upload (${st.size} bytes; max ${maxBytes})`
     );
   }
-  const buf = (0, import_node_fs49.readFileSync)(abs);
+  const buf = (0, import_node_fs50.readFileSync)(abs);
   return {
     path: relativePath,
     contentBase64: buf.toString("base64"),
@@ -19962,12 +20147,12 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
 function readWorktreeFile(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? 2e5;
-  const abs = (0, import_node_path46.join)(worktreePath, relativePath);
-  const st = (0, import_node_fs49.statSync)(abs);
+  const abs = (0, import_node_path47.join)(worktreePath, relativePath);
+  const st = (0, import_node_fs50.statSync)(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
-  const buf = (0, import_node_fs49.readFileSync)(abs);
+  const buf = (0, import_node_fs50.readFileSync)(abs);
   if (isImageRelativePath(relativePath)) {
     const maxImageBytes = Math.max(maxBytes, 15e6);
     const truncated2 = buf.length > maxImageBytes;
@@ -20010,9 +20195,9 @@ function assertSafeRelativePath(relativePath) {
 }
 function writeWorktreeFile(worktreePath, relativePath, content) {
   assertSafeRelativePath(relativePath);
-  const abs = (0, import_node_path46.join)(worktreePath, relativePath);
-  (0, import_node_fs49.mkdirSync)((0, import_node_path46.dirname)(abs), { recursive: true });
-  (0, import_node_fs49.writeFileSync)(abs, content, "utf8");
+  const abs = (0, import_node_path47.join)(worktreePath, relativePath);
+  (0, import_node_fs50.mkdirSync)((0, import_node_path47.dirname)(abs), { recursive: true });
+  (0, import_node_fs50.writeFileSync)(abs, content, "utf8");
   return { path: relativePath };
 }
 async function getWorktreeDirtyStat(worktreePath) {
@@ -20052,12 +20237,12 @@ async function getDiffSummary(worktreePath, repoPath, opts) {
     truncated: full.files.length > maxFiles
   };
 }
-var import_node_fs49, import_node_path46, mergeBaseCache, MERGE_BASE_TTL_MS, SHA_RE, IMAGE_EXTENSIONS2, DEFAULT_UPLOAD_MAX_BYTES;
+var import_node_fs50, import_node_path47, 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_fs49 = require("fs");
-    import_node_path46 = require("path");
+    import_node_fs50 = require("fs");
+    import_node_path47 = require("path");
     init_run();
     init_worktree();
     mergeBaseCache = /* @__PURE__ */ new Map();
@@ -20414,7 +20599,7 @@ function parseFrontmatter(content) {
 }
 function readSkill(skillMd, source) {
   try {
-    const content = (0, import_node_fs50.readFileSync)(skillMd, "utf8");
+    const content = (0, import_node_fs51.readFileSync)(skillMd, "utf8");
     const { name: fmName, description } = parseFrontmatter(content);
     const dirName = skillMd.split("/").slice(-2, -1)[0] || "skill";
     const name = fmName || dirName;
@@ -20433,19 +20618,19 @@ function readSkill(skillMd, source) {
   }
 }
 function scanSkillsDir(dir, source, out) {
-  if (!(0, import_node_fs50.existsSync)(dir)) return;
+  if (!(0, import_node_fs51.existsSync)(dir)) return;
   let entries;
   try {
-    entries = (0, import_node_fs50.readdirSync)(dir);
+    entries = (0, import_node_fs51.readdirSync)(dir);
   } catch {
     return;
   }
   for (const entry of entries) {
     if (entry.startsWith(".")) continue;
-    const skillMd = (0, import_node_path47.join)(dir, entry, "SKILL.md");
-    if (!(0, import_node_fs50.existsSync)(skillMd)) continue;
+    const skillMd = (0, import_node_path48.join)(dir, entry, "SKILL.md");
+    if (!(0, import_node_fs51.existsSync)(skillMd)) continue;
     try {
-      if (!(0, import_node_fs50.statSync)(skillMd).isFile()) continue;
+      if (!(0, import_node_fs51.statSync)(skillMd).isFile()) continue;
     } catch {
       continue;
     }
@@ -20454,24 +20639,24 @@ function scanSkillsDir(dir, source, out) {
   }
 }
 function scanClaudePluginSkills(pluginsRoot, out) {
-  if (!(0, import_node_fs50.existsSync)(pluginsRoot)) return;
+  if (!(0, import_node_fs51.existsSync)(pluginsRoot)) return;
   const walk = (dir, depth, lookingForSkillsDir) => {
     if (depth > 7) return;
     let entries;
     try {
-      entries = (0, import_node_fs50.readdirSync)(dir);
+      entries = (0, import_node_fs51.readdirSync)(dir);
     } catch {
       return;
     }
     if (lookingForSkillsDir && entries.includes("SKILL.md")) {
-      const skill = readSkill((0, import_node_path47.join)(dir, "SKILL.md"), "cli");
+      const skill = readSkill((0, import_node_path48.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_path47.join)(dir, entry);
+      const full = (0, import_node_path48.join)(dir, entry);
       try {
-        if (!(0, import_node_fs50.statSync)(full).isDirectory()) continue;
+        if (!(0, import_node_fs51.statSync)(full).isDirectory()) continue;
       } catch {
         continue;
       }
@@ -20489,17 +20674,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_path47.join)(worktreePath, rel), "workspace", collected);
+    scanSkillsDir((0, import_node_path48.join)(worktreePath, rel), "workspace", collected);
   }
   for (const abs of [
-    (0, import_node_path47.join)(home, ".claude/skills"),
-    (0, import_node_path47.join)(home, ".cursor/skills"),
-    (0, import_node_path47.join)(home, ".sideboard/skills"),
-    (0, import_node_path47.join)(home, ".brightsy/skills")
+    (0, import_node_path48.join)(home, ".claude/skills"),
+    (0, import_node_path48.join)(home, ".cursor/skills"),
+    (0, import_node_path48.join)(home, ".sideboard/skills"),
+    (0, import_node_path48.join)(home, ".brightsy/skills")
   ]) {
     scanSkillsDir(abs, "user", collected);
   }
-  scanClaudePluginSkills((0, import_node_path47.join)(home, ".claude/plugins"), collected);
+  scanClaudePluginSkills((0, import_node_path48.join)(home, ".claude/plugins"), collected);
   collected.push(...bundledSkills());
   const rank = {
     workspace: 0,
@@ -20525,7 +20710,7 @@ function readSkillBody(skillPath, maxChars = 12e3) {
 \u2026(truncated)` : body;
     }
   }
-  const raw = (0, import_node_fs50.readFileSync)(skillPath, "utf8");
+  const raw = (0, import_node_fs51.readFileSync)(skillPath, "utf8");
   if (raw.startsWith("---")) {
     const end = raw.indexOf("\n---", 3);
     if (end >= 0) {
@@ -20539,13 +20724,13 @@ function readSkillBody(skillPath, maxChars = 12e3) {
 \u2026(truncated)` : raw;
 }
-var import_node_fs50, import_node_os15, import_node_path47, BUNDLED_SKILL_PREFIX;
+var import_node_fs51, import_node_os15, import_node_path48, BUNDLED_SKILL_PREFIX;
 var init_discover = __esm({
   "src/skills/discover.ts"() {
     "use strict";
-    import_node_fs50 = require("fs");
+    import_node_fs51 = require("fs");
     import_node_os15 = require("os");
-    import_node_path47 = require("path");
+    import_node_path48 = require("path");
     init_long_running();
     BUNDLED_SKILL_PREFIX = "bundled:";
   }
@@ -20700,7 +20885,7 @@ function compiledModuleDir() {
   try {
     const url = import_meta4.url;
     if (typeof url === "string" && url.length > 0) {
-      return (0, import_node_path48.dirname)((0, import_node_url4.fileURLToPath)(url));
+      return (0, import_node_path49.dirname)((0, import_node_url4.fileURLToPath)(url));
     }
   } catch {
   }
@@ -20708,8 +20893,8 @@ function compiledModuleDir() {
 }
 function detachedJobScriptIn(dir) {
   for (const name of DETACHED_JOB_FILENAMES) {
-    const script = (0, import_node_path48.join)(dir, "scripts", name);
-    if ((0, import_node_fs51.existsSync)(script)) return script;
+    const script = (0, import_node_path49.join)(dir, "scripts", name);
+    if ((0, import_node_fs52.existsSync)(script)) return script;
   }
   return null;
 }
@@ -20726,7 +20911,7 @@ function resolveDetachedJobScript() {
   for (let i = 0; i < 8; i++) {
     const candidate = detachedJobScriptIn(dir);
     if (candidate) return candidate;
-    const parent = (0, import_node_path48.dirname)(dir);
+    const parent = (0, import_node_path49.dirname)(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -20737,12 +20922,12 @@ function formatDetachedJobInvoke(scriptPath) {
   if (resolved) return `node ${JSON.stringify(resolved)}`;
   return "node scripts/detached-job.cjs";
 }
-var import_node_fs51, import_node_path48, import_node_url4, import_meta4, DETACHED_JOB_FILENAMES;
+var import_node_fs52, import_node_path49, import_node_url4, import_meta4, DETACHED_JOB_FILENAMES;
 var init_detached_job_path = __esm({
   "src/skills/detached-job-path.ts"() {
     "use strict";
-    import_node_fs51 = require("fs");
-    import_node_path48 = require("path");
+    import_node_fs52 = require("fs");
+    import_node_path49 = require("path");
     import_node_url4 = require("url");
     init_packaged_runtime();
     import_meta4 = {};
@@ -20843,9 +21028,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(
@@ -20932,9 +21117,9 @@ function formatPrGateDirective() {
 }
 function formatProcessGuideDirective(opts) {
   const worktree = opts?.worktreePath?.trim();
-  const hasGraphSkill = !!worktree && (0, import_node_fs52.existsSync)((0, import_node_path49.join)(worktree, ".claude/skills/graph-engineering/SKILL.md"));
-  const hasReviewSkill = !!worktree && (0, import_node_fs52.existsSync)((0, import_node_path49.join)(worktree, ".claude/skills/review/SKILL.md"));
-  const hasInstallSkill = !!worktree && (0, import_node_fs52.existsSync)((0, import_node_path49.join)(worktree, ".claude/skills/worktree-install/SKILL.md"));
+  const hasGraphSkill = !!worktree && (0, import_node_fs53.existsSync)((0, import_node_path50.join)(worktree, ".claude/skills/graph-engineering/SKILL.md"));
+  const hasReviewSkill = !!worktree && (0, import_node_fs53.existsSync)((0, import_node_path50.join)(worktree, ".claude/skills/review/SKILL.md"));
+  const hasInstallSkill = !!worktree && (0, import_node_fs53.existsSync)((0, import_node_path50.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,
@@ -20973,12 +21158,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_fs52, import_node_path49, PR_GOAL_RE, GITHUB_TICKET_REF, KEYED_TICKET_REF;
+var import_node_fs53, import_node_path50, PR_GOAL_RE, GITHUB_TICKET_REF, KEYED_TICKET_REF;
 var init_instructions = __esm({
   "src/agents/instructions.ts"() {
     "use strict";
-    import_node_fs52 = require("fs");
-    import_node_path49 = require("path");
+    import_node_fs53 = require("fs");
+    import_node_path50 = require("path");
     init_git_auth_mode();
     init_branch_prefix();
     init_worktree_labels();
@@ -21202,40 +21387,40 @@ __export(plan_file_exports, {
   writePlanFile: () => writePlanFile
 });
 function ensureAttachmentsGitignore(worktreePath) {
-  const gitignoreAbs = (0, import_node_path50.join)(worktreePath, ATTACHMENTS_DIR, ".gitignore");
-  if ((0, import_node_fs53.existsSync)(gitignoreAbs)) return;
-  (0, import_node_fs53.mkdirSync)((0, import_node_path50.dirname)(gitignoreAbs), { recursive: true });
-  (0, import_node_fs53.writeFileSync)(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
+  const gitignoreAbs = (0, import_node_path51.join)(worktreePath, ATTACHMENTS_DIR, ".gitignore");
+  if ((0, import_node_fs54.existsSync)(gitignoreAbs)) return;
+  (0, import_node_fs54.mkdirSync)((0, import_node_path51.dirname)(gitignoreAbs), { recursive: true });
+  (0, import_node_fs54.writeFileSync)(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
 }
 function planFileAbs(worktreePath) {
-  return (0, import_node_path50.join)(worktreePath, PLAN_FILE_REL);
+  return (0, import_node_path51.join)(worktreePath, PLAN_FILE_REL);
 }
 function readTextIfPresent2(abs) {
-  if (!(0, import_node_fs53.existsSync)(abs)) return null;
+  if (!(0, import_node_fs54.existsSync)(abs)) return null;
   try {
-    const content = (0, import_node_fs53.readFileSync)(abs, "utf8");
+    const content = (0, import_node_fs54.readFileSync)(abs, "utf8");
     return content.trim() ? content : null;
   } catch {
     return null;
   }
 }
 function readPlanFile(worktreePath) {
-  return readTextIfPresent2(planFileAbs(worktreePath)) ?? readTextIfPresent2((0, import_node_path50.join)(worktreePath, `${LEGACY_ATTACHMENTS_DIR}/plan.md`)) ?? readTextIfPresent2((0, import_node_path50.join)(worktreePath, LEGACY_PLAN_FILE_REL));
+  return readTextIfPresent2(planFileAbs(worktreePath)) ?? readTextIfPresent2((0, import_node_path51.join)(worktreePath, `${LEGACY_ATTACHMENTS_DIR}/plan.md`)) ?? readTextIfPresent2((0, import_node_path51.join)(worktreePath, LEGACY_PLAN_FILE_REL));
 }
 function writePlanFile(worktreePath, content) {
   ensureAttachmentsGitignore(worktreePath);
   const abs = planFileAbs(worktreePath);
-  (0, import_node_fs53.mkdirSync)((0, import_node_path50.dirname)(abs), { recursive: true });
+  (0, import_node_fs54.mkdirSync)((0, import_node_path51.dirname)(abs), { recursive: true });
   const body = content.trimEnd() + (content.endsWith("\n") ? "" : "\n");
-  (0, import_node_fs53.writeFileSync)(abs, body, "utf8");
+  (0, import_node_fs54.writeFileSync)(abs, body, "utf8");
   return PLAN_FILE_REL;
 }
-var import_node_fs53, import_node_path50;
+var import_node_fs54, import_node_path51;
 var init_plan_file = __esm({
   "src/plan/plan-file.ts"() {
     "use strict";
-    import_node_fs53 = require("fs");
-    import_node_path50 = require("path");
+    import_node_fs54 = require("fs");
+    import_node_path51 = require("path");
     init_workspace_scratch();
     init_plan_present();
     init_plan_present();
@@ -21295,7 +21480,7 @@ function setCaffeinateHoldHooks(next) {
   hooks = next;
 }
 function caffeinateHoldPath() {
-  return (0, import_node_path51.join)(appDataDir(), "caffeinate-hold.json");
+  return (0, import_node_path52.join)(appDataDir(), "caffeinate-hold.json");
 }
 function processAlive(pid) {
   if (hooks.processAlive) return hooks.processAlive(pid);
@@ -21329,9 +21514,9 @@ function uniqueIds(ids) {
 }
 function readHold() {
   const path = caffeinateHoldPath();
-  if (!(0, import_node_fs54.existsSync)(path)) return null;
+  if (!(0, import_node_fs55.existsSync)(path)) return null;
   try {
-    const parsed = JSON.parse((0, import_node_fs54.readFileSync)(path, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs55.readFileSync)(path, "utf8"));
     if (typeof parsed?.pid === "number" && parsed.pid > 0) {
       return {
         pid: parsed.pid,
@@ -21353,7 +21538,7 @@ function writeHold(pid, threadIds) {
 }
 function clearHold() {
   try {
-    (0, import_node_fs54.unlinkSync)(caffeinateHoldPath());
+    (0, import_node_fs55.unlinkSync)(caffeinateHoldPath());
   } catch {
   }
 }
@@ -21438,13 +21623,13 @@ function releaseCaffeinateHoldForThread(threadId) {
   }
   return setCaffeinateHold(false, { threadId: id });
 }
-var import_node_child_process6, import_node_fs54, import_node_path51, hooks;
+var import_node_child_process6, import_node_fs55, import_node_path52, hooks;
 var init_caffeinate_hold = __esm({
   "src/store/caffeinate-hold.ts"() {
     "use strict";
     import_node_child_process6 = require("child_process");
-    import_node_fs54 = require("fs");
-    import_node_path51 = require("path");
+    import_node_fs55 = require("fs");
+    import_node_path52 = require("path");
     init_paths();
     init_private_file();
     hooks = {};
@@ -21453,7 +21638,7 @@ var init_caffeinate_hold = __esm({
 // src/store/schedules.ts
 function schedulesPath() {
-  return (0, import_node_path52.join)(appDataDir(), "schedules.json");
+  return (0, import_node_path53.join)(appDataDir(), "schedules.json");
 }
 function parseDurationMs(every) {
   const m = every.trim().match(DURATION_RE);
@@ -21553,9 +21738,9 @@ function normalizeTask(raw) {
 }
 function readAll2() {
   const path = schedulesPath();
-  if (!(0, import_node_fs55.existsSync)(path)) return [];
+  if (!(0, import_node_fs56.existsSync)(path)) return [];
   try {
-    const parsed = JSON.parse((0, import_node_fs55.readFileSync)(path, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs56.readFileSync)(path, "utf8"));
     if (!Array.isArray(parsed)) return [];
     return parsed.map((row) => {
       try {
@@ -21667,13 +21852,13 @@ function recordScheduleRun(id, result) {
   writeAll2(rows);
   return next;
 }
-var import_node_crypto12, import_node_fs55, import_node_path52, import_croner, DURATION_RE, UNIT_MS;
+var import_node_crypto12, import_node_fs56, import_node_path53, import_croner, DURATION_RE, UNIT_MS;
 var init_schedules = __esm({
   "src/store/schedules.ts"() {
     "use strict";
     import_node_crypto12 = require("crypto");
-    import_node_fs55 = require("fs");
-    import_node_path52 = require("path");
+    import_node_fs56 = require("fs");
+    import_node_path53 = require("path");
     import_croner = require("croner");
     init_orchestrator_capable();
     init_paths();
@@ -21759,14 +21944,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);
@@ -21829,9 +22014,9 @@ function recoverFinishedCursorRun(opts) {
   return best;
 }
 function scanFinishedCursorRuns(runsPath, agentId, startedAfterMs) {
-  if (!(0, import_node_fs56.existsSync)(runsPath)) return null;
+  if (!(0, import_node_fs57.existsSync)(runsPath)) return null;
   try {
-    const lines = (0, import_node_fs56.readFileSync)(runsPath, "utf8").split("\n");
+    const lines = (0, import_node_fs57.readFileSync)(runsPath, "utf8").split("\n");
     let best = null;
     for (const line of lines) {
       const trimmed = line.trim();
@@ -21857,11 +22042,11 @@ function scanFinishedCursorRuns(runsPath, agentId, startedAfterMs) {
     return null;
   }
 }
-var import_node_fs56;
+var import_node_fs57;
 var init_cursor_recover = __esm({
   "src/agents/cursor-recover.ts"() {
     "use strict";
-    import_node_fs56 = require("fs");
+    import_node_fs57 = require("fs");
     init_cursor_store();
   }
 });
@@ -22015,7 +22200,7 @@ async function startOrchestration(opts) {
   }
   return updated;
 }
-var import_node_events, import_node_crypto13, import_node_fs57, 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_fs58, 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";
@@ -22023,7 +22208,7 @@ var init_orchestrator = __esm({
     init_injected_notices();
     init_task_state();
     import_node_crypto13 = require("crypto");
-    import_node_fs57 = require("fs");
+    import_node_fs58 = require("fs");
     init_error_detail();
     init_run();
     init_stale_lock();
@@ -22202,7 +22387,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_fs57.existsSync)(thread.worktreePath)) {
+            if (!(0, import_node_fs58.existsSync)(thread.worktreePath)) {
               setStatus(thread.id, "broken", "Worktree missing on disk");
               this.emit({ type: "status_changed", threadId: thread.id, status: "broken" });
             }
@@ -22231,7 +22416,7 @@ var init_orchestrator = __esm({
             }
             continue;
           }
-          if (!(0, import_node_fs57.existsSync)(thread.worktreePath)) {
+          if (!(0, import_node_fs58.existsSync)(thread.worktreePath)) {
             setStatus(thread.id, "broken", "Worktree missing on disk");
             this.emit({ type: "status_changed", threadId: thread.id, status: "broken" });
             continue;
@@ -22399,8 +22584,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);
@@ -23455,6 +23640,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(
@@ -23493,7 +23679,7 @@ var init_orchestrator = __esm({
             thread.repoPath,
             thread.worktreePath,
             runOutput.push,
-            { scriptName: resolvedName }
+            { scriptName: resolvedName, preferredPorts }
           );
         } catch (err) {
           runOutput.flush();
@@ -23942,7 +24128,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) => {
@@ -23960,7 +24146,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") {
@@ -23970,7 +24156,7 @@ var init_orchestrator = __esm({
                 return;
               }
               if (!["running", "queued"].includes(latest.status)) {
-                finish(() => resolve(latest));
+                finish(() => resolve2(latest));
               }
             }
           });
@@ -23982,12 +24168,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")));
               }
@@ -24579,7 +24765,7 @@ var init_orchestrator = __esm({
           this.emit({ type: "status_changed", threadId: restored2.id, status: restored2.status });
           return restored2;
         }
-        if (!(0, import_node_fs57.existsSync)(thread.worktreePath)) {
+        if (!(0, import_node_fs58.existsSync)(thread.worktreePath)) {
           if (isCowboyThread(thread) || isPrimaryCheckoutThread(thread)) {
             throw new Error(
               `Cowboy checkout missing: ${thread.worktreePath}. Re-add the project folder, then restore.`
@@ -24663,7 +24849,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_crypto16 = require("crypto");
-var import_node_path58 = require("path");
+var import_node_path59 = require("path");
 init_orchestrator();
 init_task_state();
 init_worktree();
@@ -26778,8 +26964,8 @@ ${link}` : link;
 }
 // src/slack/outbound-watch.ts
-var import_node_fs59 = require("fs");
-var import_node_path55 = require("path");
+var import_node_fs60 = require("fs");
+var import_node_path56 = require("path");
 init_paths();
 init_private_file();
 init_secure_file();
@@ -26787,19 +26973,19 @@ init_thread_store();
 init_injected_notices();
 // src/slack/reply-target.ts
-var import_node_fs58 = require("fs");
-var import_node_path53 = require("path");
+var import_node_fs59 = require("fs");
+var import_node_path54 = require("path");
 init_paths();
 init_private_file();
 init_secure_file();
 function storePath2() {
-  return (0, import_node_path53.join)(appDataDir(), "slack-reply-to.json");
+  return (0, import_node_path54.join)(appDataDir(), "slack-reply-to.json");
 }
 function readStore2() {
   const path = storePath2();
-  if (!(0, import_node_fs58.existsSync)(path)) return {};
+  if (!(0, import_node_fs59.existsSync)(path)) return {};
   try {
-    const parsed = isSecureFileEncrypted(path) ? readSecureJson(path) : JSON.parse((0, import_node_fs58.readFileSync)(path, "utf8"));
+    const parsed = isSecureFileEncrypted(path) ? readSecureJson(path) : JSON.parse((0, import_node_fs59.readFileSync)(path, "utf8"));
     return parsed?.targets && typeof parsed.targets === "object" ? parsed.targets : {};
   } catch {
     return {};
@@ -26810,11 +26996,11 @@ function getSlackReplyTarget(threadId) {
 }
 // src/slack/workspaces.ts
-var import_node_path54 = require("path");
+var import_node_path55 = require("path");
 init_paths();
 init_secure_file();
 function storePath3() {
-  return (0, import_node_path54.join)(appDataDir(), "slack-workspaces.json");
+  return (0, import_node_path55.join)(appDataDir(), "slack-workspaces.json");
 }
 function readStore3() {
   try {
@@ -26884,7 +27070,7 @@ var POLL_INTERVAL_MS = 12e3;
 var lastPollMs = 0;
 var nameCache = /* @__PURE__ */ new Map();
 function storePath4() {
-  return (0, import_node_path55.join)(appDataDir(), "slack-outbound-watch.json");
+  return (0, import_node_path56.join)(appDataDir(), "slack-outbound-watch.json");
 }
 function watchId(teamId, channelId, ts) {
   return `${teamId}:${channelId}:${ts}`;
@@ -26897,9 +27083,9 @@ function tsNewer(a, b) {
 }
 function readStore4() {
   const path = storePath4();
-  if (!(0, import_node_fs59.existsSync)(path)) return [];
+  if (!(0, import_node_fs60.existsSync)(path)) return [];
   try {
-    const parsed = isSecureFileEncrypted(path) ? readSecureJson(path) : JSON.parse((0, import_node_fs59.readFileSync)(path, "utf8"));
+    const parsed = isSecureFileEncrypted(path) ? readSecureJson(path) : JSON.parse((0, import_node_fs60.readFileSync)(path, "utf8"));
     return Array.isArray(parsed?.watches) ? parsed.watches : [];
   } catch {
     return [];
@@ -28641,27 +28827,27 @@ init_gh_errors();
 init_git_auth_mode();
 // src/board/load-home-board.ts
-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_worktree();
 init_paths();
 // src/board/board-pins.ts
 var import_node_crypto15 = require("crypto");
-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_home_board();
 var FILE = "home-board-pins.json";
 var VERSION = 1;
 function pinsFile() {
-  return (0, import_node_path56.join)(appDataDir(), FILE);
+  return (0, import_node_path57.join)(appDataDir(), FILE);
 }
 function readDisk() {
   const path = pinsFile();
-  if (!(0, import_node_fs60.existsSync)(path)) return [];
+  if (!(0, import_node_fs61.existsSync)(path)) return [];
   try {
-    const raw = JSON.parse((0, import_node_fs60.readFileSync)(path, "utf8"));
+    const raw = JSON.parse((0, import_node_fs61.readFileSync)(path, "utf8"));
     if (raw?.version !== VERSION || !Array.isArray(raw.items)) return [];
     return raw.items.filter((item) => item?.id && item.kind && item.ref);
   } catch {
@@ -28669,8 +28855,8 @@ function readDisk() {
   }
 }
 function writeDisk(items) {
-  (0, import_node_fs60.mkdirSync)(appDataDir(), { recursive: true });
-  (0, import_node_fs60.writeFileSync)(pinsFile(), JSON.stringify({ version: VERSION, items }, null, 2), "utf8");
+  (0, import_node_fs61.mkdirSync)(appDataDir(), { recursive: true });
+  (0, import_node_fs61.writeFileSync)(pinsFile(), JSON.stringify({ version: VERSION, items }, null, 2), "utf8");
 }
 function listBoardPins() {
   return readDisk();
@@ -28691,7 +28877,7 @@ function homeBoardWorkspaceKey(workspaces) {
   return workspaces.map((w) => w.path).filter(Boolean).sort().join("\n");
 }
 function cacheFile() {
-  return (0, import_node_path57.join)(appDataDir(), "home-board-cache.json");
+  return (0, import_node_path58.join)(appDataDir(), "home-board-cache.json");
 }
 function emptyInputs() {
   return {
@@ -28717,9 +28903,9 @@ function shouldCacheHomeBoardInputs(inputs) {
 }
 function readDiskCache() {
   const path = cacheFile();
-  if (!(0, import_node_fs61.existsSync)(path)) return null;
+  if (!(0, import_node_fs62.existsSync)(path)) return null;
   try {
-    const raw = JSON.parse((0, import_node_fs61.readFileSync)(path, "utf8"));
+    const raw = JSON.parse((0, import_node_fs62.readFileSync)(path, "utf8"));
     if (raw?.version !== CACHE_VERSION || typeof raw.fetchedAt !== "number") {
       return null;
     }
@@ -28733,8 +28919,8 @@ function readDiskCache() {
 }
 function writeDiskCache(entry) {
   try {
-    (0, import_node_fs61.mkdirSync)(appDataDir(), { recursive: true });
-    (0, import_node_fs61.writeFileSync)(cacheFile(), JSON.stringify(entry), "utf8");
+    (0, import_node_fs62.mkdirSync)(appDataDir(), { recursive: true });
+    (0, import_node_fs62.writeFileSync)(cacheFile(), JSON.stringify(entry), "utf8");
   } catch {
   }
 }
@@ -28958,14 +29144,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);
@@ -29137,7 +29323,7 @@ async function startMcpServer() {
       async () => {
         const threads = orch.getThreads(true);
         const lines = threads.map((t) => {
-          const repo = t.repoPath === GLOBAL_WORKSPACE_ID ? "Orchestration" : (0, import_node_path58.basename)(t.repoPath) || t.repoPath;
+          const repo = t.repoPath === GLOBAL_WORKSPACE_ID ? "Orchestration" : (0, import_node_path59.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);