@sideboard-ai/core 0.1.238 → 0.1.239

package/dist/{chunk-E6UJGLPM.js → chunk-CDG4CLWQ.js}

@@ -792,13 +792,14 @@ function shouldAutoArchiveOnPrMerge(opts) {
 import {
   copyFileSync,
   existsSync as existsSync3,
-  mkdirSync as mkdirSync3,
+  mkdirSync as mkdirSync4,
   readdirSync,
-  readFileSync as readFileSync2
+  readFileSync as readFileSync3,
+  realpathSync
 } from "fs";
 import { execFileSync } from "child_process";
 import { createServer } from "net";
-import { basename, dirname as dirname2, join as join4 } from "path";
+import { basename, dirname as dirname3, join as join5, resolve, sep } from "path";
 import { execa as execa2 } from "execa";
 import { createInterface as createInterface2 } from "readline";
 
@@ -1658,16 +1659,73 @@ async function requestReview(threadRef, send) {
   return { tab: started, from };
 }
 
+// src/hook/worktree-run-ports.ts
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2, join as join4 } from "path";
+var RUN_PORTS_REL = ".context/.sideboard/run-ports.json";
+function worktreeRunPortsPath(worktreePath) {
+  return join4(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 = readFileSync2(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(readFileSync2(path, "utf8"));
+  } catch {
+    current = {};
+  }
+  const scripts = { ...current.scripts ?? {} };
+  scripts[scriptName] = cleaned;
+  mkdirSync3(dirname2(path), { recursive: true });
+  writeFileSync2(path, `${JSON.stringify({ scripts }, null, 2)}
+`, "utf8");
+}
+
 // src/hook/conductor.ts
 var PORT_RANGE_SIZE = 10;
+var RECLAIM_RETRY_DELAY_MS = 40;
+var RECLAIM_TRIES = 8;
 function matchSimpleGlob(pattern, name) {
   const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
   return new RegExp(`^${escaped}$`).test(name);
 }
 function readWorktreeInclude(repoPath) {
-  const path = join4(repoPath, ".worktreeinclude");
+  const path = join5(repoPath, ".worktreeinclude");
   if (!existsSync3(path)) return [];
-  return readFileSync2(path, "utf8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+  return readFileSync3(path, "utf8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
 }
 function resolveFilesToCopy(repoPath) {
   const fromInclude = readWorktreeInclude(repoPath);
@@ -1706,10 +1764,10 @@ function copyConfiguredFiles(repoPath, worktreePath) {
   const patterns = resolveFilesToCopy(repoPath);
   const copied = [];
   for (const rel of patterns) {
-    const src = join4(repoPath, rel);
+    const src = join5(repoPath, rel);
     if (!existsSync3(src)) continue;
-    const dest = join4(worktreePath, rel);
-    mkdirSync3(dirname2(dest), { recursive: true });
+    const dest = join5(worktreePath, rel);
+    mkdirSync4(dirname3(dest), { recursive: true });
     copyFileSync(src, dest);
     copied.push(rel);
   }
@@ -1786,6 +1844,57 @@ function killableListenerPids(raw, selfPid = process.pid) {
   }
   return pids;
 }
+function listUnixListenerPids(port, selfPid) {
+  try {
+    const raw = 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 = 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 realpathSync(path);
+  } catch {
+    return resolve(path);
+  }
+}
+function isOtherWorktreeListenerCwd(cwd, worktreePath) {
+  const wt = realpathOrResolve(worktreePath);
+  const c = realpathOrResolve(cwd);
+  if (c === wt || c.startsWith(wt + sep)) return false;
+  const parent = dirname3(wt);
+  const thisName = basename(wt);
+  if (!thisName || c === parent) return false;
+  if (!c.startsWith(parent + sep)) return false;
+  const first = c.slice(parent.length + 1).split(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) {
@@ -1803,26 +1912,32 @@ function killListenersOnPorts(ports) {
         );
         continue;
       }
-      let raw = "";
-      try {
-        raw = 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) {
@@ -1984,7 +2099,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 = createServer();
     let released = false;
     const release = () => new Promise((res) => {
@@ -2001,13 +2116,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 = createServer();
     let released = false;
     const release = () => new Promise((res) => {
@@ -2018,24 +2134,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) {
@@ -2043,11 +2189,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,
@@ -2073,8 +2251,8 @@ async function startDevServer(repoPath, worktreePath, onLine, opts) {
 
 // src/store/setup-log.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { join as join6 } from "path";
 var EMPTY = {
   output: "",
   running: false,
@@ -2116,7 +2294,7 @@ function materialize(mem) {
   };
 }
 function setupLogPath(threadId) {
-  return join5(threadsDir(), `${threadId}.setup.log.json`);
+  return join6(threadsDir(), `${threadId}.setup.log.json`);
 }
 function setupLogKeyForWorktree(worktreePath) {
   const norm = normalizeWorktreePath(worktreePath);
@@ -2135,7 +2313,7 @@ function persistNow(threadId) {
   const mem = memory.get(threadId);
   if (!mem) return;
   try {
-    writeFileSync2(
+    writeFileSync3(
       setupLogPath(threadId),
       `${JSON.stringify(materialize(mem))}
 `,
@@ -2158,7 +2336,7 @@ function loadFromDisk(threadId) {
   const path = setupLogPath(threadId);
   if (!existsSync4(path)) return null;
   try {
-    const raw = JSON.parse(readFileSync3(path, "utf8"));
+    const raw = JSON.parse(readFileSync4(path, "utf8"));
     return {
       output: typeof raw.output === "string" ? raw.output : "",
       running: Boolean(raw.running),
@@ -2217,8 +2395,8 @@ function finishSetupLog(threadId, exitCode, source) {
 
 // src/store/run-log.ts
 import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { join as join7 } from "path";
 var EMPTY2 = {
   output: "",
   running: false,
@@ -2257,7 +2435,7 @@ function safeScriptToken(scriptName) {
   return token || "dev";
 }
 function runLogPath(key) {
-  return join6(threadsDir(), `${key}.run.log.json`);
+  return join7(threadsDir(), `${key}.run.log.json`);
 }
 function runLogKeyForWorktree(worktreePath, scriptName) {
   const norm = normalizeWorktreePath(worktreePath);
@@ -2286,7 +2464,7 @@ function persistNow2(key) {
   const mem = memory2.get(key);
   if (!mem) return;
   try {
-    writeFileSync3(runLogPath(key), `${JSON.stringify(materialize2(mem))}
+    writeFileSync4(runLogPath(key), `${JSON.stringify(materialize2(mem))}
 `, "utf8");
   } catch {
   }
@@ -2305,7 +2483,7 @@ function loadFromDisk2(key) {
   const path = runLogPath(key);
   if (!existsSync5(path)) return null;
   try {
-    const raw = JSON.parse(readFileSync4(path, "utf8"));
+    const raw = JSON.parse(readFileSync5(path, "utf8"));
     return {
       output: typeof raw.output === "string" ? raw.output : "",
       running: Boolean(raw.running),
@@ -2366,7 +2544,7 @@ function flushRunLog(key) {
 
 // src/git/orphan-cleanup.ts
 import { existsSync as existsSync6, readdirSync as readdirSync2, statSync } from "fs";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 function isSideboardWorktreePath(path) {
   return path.includes("/.sideboard/worktrees/") || path.includes("/sideboard/workspaces/");
 }
@@ -2413,9 +2591,9 @@ async function findOrphanWorktrees(repoPaths) {
       if (existsSync6(root)) {
         for (const entry of readdirSync2(root, { withFileTypes: true })) {
           if (!entry.isDirectory()) continue;
-          const path = join7(root, entry.name).replace(/\/$/, "");
+          const path = join8(root, entry.name).replace(/\/$/, "");
           if (known.has(path) || seen.has(path)) continue;
-          if (!existsSync6(join7(path, ".git"))) continue;
+          if (!existsSync6(join8(path, ".git"))) continue;
           seen.add(path);
           let mtimeMs = 0;
           try {
@@ -2620,7 +2798,7 @@ async function applyThreadIntoMain(thread, opts) {
 
 // src/git/clone-repo.ts
 import { existsSync as existsSync7 } from "fs";
-import { basename as basename2, join as join8 } from "path";
+import { basename as basename2, join as join9 } from "path";
 import { execa as execa4 } from "execa";
 async function cloneRepoIntoSideboard(opts) {
   const url = opts.url.trim();
@@ -2631,7 +2809,7 @@ async function cloneRepoIntoSideboard(opts) {
     name = leaf || "repo";
   }
   name = name.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "repo";
-  const dest = join8(sideboardReposDir(), name);
+  const dest = join9(sideboardReposDir(), name);
   if (existsSync7(dest)) {
     const repoPath2 = await resolveRepoRoot(dest);
     const workspace2 = await ensureWorkspace(repoPath2);
@@ -2654,14 +2832,14 @@ function isAdoptableRunScriptRequest(req) {
 }
 
 // src/store/desktop-host.ts
-import { readFileSync as readFileSync5, unlinkSync, writeFileSync as writeFileSync4 } from "fs";
-import { join as join9 } from "path";
+import { readFileSync as readFileSync6, unlinkSync, writeFileSync as writeFileSync5 } from "fs";
+import { join as join10 } from "path";
 function desktopHostPidPath() {
-  return join9(appDataDir(), "desktop-host.pid");
+  return join10(appDataDir(), "desktop-host.pid");
 }
 function readDesktopHostPid() {
   try {
-    const pid = Number.parseInt(readFileSync5(desktopHostPidPath(), "utf8").trim(), 10);
+    const pid = Number.parseInt(readFileSync6(desktopHostPidPath(), "utf8").trim(), 10);
     if (!Number.isFinite(pid) || pid <= 0) return null;
     return pid;
   } catch {
@@ -2734,12 +2912,12 @@ function notifyParentOfChildHalt(child, status, send) {
 import {
   appendFileSync as appendFileSync2,
   existsSync as existsSync8,
-  mkdirSync as mkdirSync4,
+  mkdirSync as mkdirSync5,
   readdirSync as readdirSync3,
-  readFileSync as readFileSync6,
-  writeFileSync as writeFileSync5
+  readFileSync as readFileSync7,
+  writeFileSync as writeFileSync6
 } from "fs";
-import { dirname as dirname3, join as join10 } from "path";
+import { dirname as dirname4, join as join11 } from "path";
 
 // src/mcp/wait-for-turn.ts
 var MCP_WAIT_FOR_TURN_MAX_MS = 45e3;
@@ -2815,11 +2993,11 @@ function jobTreeAlive(pid) {
 }
 function readIntFile(file) {
   if (!existsSync8(file)) return null;
-  const n = Number.parseInt(readFileSync6(file, "utf8").trim(), 10);
+  const n = Number.parseInt(readFileSync7(file, "utf8").trim(), 10);
   return Number.isInteger(n) ? n : null;
 }
 function jobDir(root, id, legacy = false) {
-  return join10(root, legacy ? LEGACY_DETACHED_JOBS_DIR : DETACHED_JOBS_DIR, id);
+  return join11(root, legacy ? LEGACY_DETACHED_JOBS_DIR : DETACHED_JOBS_DIR, id);
 }
 function resolveJobDir(root, id) {
   const modern = jobDir(root, id, false);
@@ -2829,7 +3007,7 @@ function resolveJobDir(root, id) {
   return modern;
 }
 function listJobIdsIn(root, rel) {
-  const dir = join10(root, rel);
+  const dir = join11(root, rel);
   if (!existsSync8(dir)) return [];
   return readdirSync3(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && JOB_ID_RE.test(e.name)).map((e) => e.name);
 }
@@ -2843,7 +3021,7 @@ function listRunningDetachedJobs(worktreePath) {
   const running = [];
   for (const id of ids) {
     const dir = resolveJobDir(root, id);
-    const pid = readIntFile(join10(dir, "pid"));
+    const pid = readIntFile(join11(dir, "pid"));
     if (jobTreeAlive(pid)) running.push(id);
   }
   return running.sort();
@@ -2927,7 +3105,7 @@ function planJobContinue(opts) {
 }
 function tailProgress(logFile, maxLines = 12) {
   if (!existsSync8(logFile)) return "(no log yet)";
-  const lines = readFileSync6(logFile, "utf8").split("\n");
+  const lines = readFileSync7(logFile, "utf8").split("\n");
   return lines.slice(-maxLines).join("\n");
 }
 function lastProgressLine(progress) {
@@ -2936,7 +3114,7 @@ function lastProgressLine(progress) {
 }
 function readLogLines(file) {
   if (!existsSync8(file)) return [];
-  const lines = readFileSync6(file, "utf8").split("\n");
+  const lines = readFileSync7(file, "utf8").split("\n");
   if (lines.length && lines[lines.length - 1] === "") lines.pop();
   return lines;
 }
@@ -2947,15 +3125,15 @@ function takeDelta(logFile, cursorFile) {
   return { delta: capJobLogDelta(lines.slice(start).join("\n")), nextCursor: lines.length };
 }
 function snapshotJob(dir) {
-  const pid = readIntFile(join10(dir, "pid"));
+  const pid = readIntFile(join11(dir, "pid"));
   const running = jobTreeAlive(pid);
   return {
     pid,
     running,
-    exitCode: readIntFile(join10(dir, "exit")),
-    log: join10(dir, "log"),
-    cursor: join10(dir, "present.cursor"),
-    progress: tailProgress(join10(dir, "log"))
+    exitCode: readIntFile(join11(dir, "exit")),
+    log: join11(dir, "log"),
+    cursor: join11(dir, "present.cursor"),
+    progress: tailProgress(join11(dir, "log"))
   };
 }
 function toResult(id, snap, extra) {
@@ -2964,8 +3142,8 @@ function toResult(id, snap, extra) {
   const stillRunning = snap.running && !ok;
   const { delta, nextCursor } = takeDelta(snap.log, snap.cursor);
   try {
-    mkdirSync4(dirname3(snap.cursor), { recursive: true });
-    writeFileSync5(snap.cursor, `${nextCursor}
+    mkdirSync5(dirname4(snap.cursor), { recursive: true });
+    writeFileSync6(snap.cursor, `${nextCursor}
 `);
   } catch {
   }
@@ -2986,7 +3164,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);
@@ -3040,7 +3218,7 @@ function killProcessTree(pid, signal) {
 }
 function appendJobLog(logFile, line) {
   try {
-    mkdirSync4(dirname3(logFile), { recursive: true });
+    mkdirSync5(dirname4(logFile), { recursive: true });
     const body = line.endsWith("\n") ? line : `${line}
 `;
     appendFileSync2(logFile, body);
@@ -3089,10 +3267,10 @@ async function stopDetachedJob(cwd, id, opts) {
     killProcessTree(targetPid, "SIGKILL");
     await sleep(100);
   }
-  const exitFile = join10(dir, "exit");
+  const exitFile = join11(dir, "exit");
   if (!existsSync8(exitFile)) {
     try {
-      writeFileSync5(exitFile, "1\n");
+      writeFileSync6(exitFile, "1\n");
     } catch {
     }
   }
@@ -3899,8 +4077,8 @@ import {
   existsSync as existsSync10,
   renameSync,
   unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync6,
-  readFileSync as readFileSync7
+  writeFileSync as writeFileSync7,
+  readFileSync as readFileSync8
 } from "fs";
 var buffers = /* @__PURE__ */ new Map();
 var FLUSH_MS = 800;
@@ -3977,7 +4155,7 @@ function writeTurnLive(threadId, progress) {
   const path = threadLivePath(threadId);
   const tmp = `${path}.${process.pid}.tmp`;
   try {
-    writeFileSync6(tmp, JSON.stringify(progress), "utf8");
+    writeFileSync7(tmp, JSON.stringify(progress), "utf8");
     renameSync(tmp, path);
   } catch {
     try {
@@ -3990,7 +4168,7 @@ function readTurnLive(threadId) {
   const path = threadLivePath(threadId);
   if (!existsSync10(path)) return null;
   try {
-    const raw = JSON.parse(readFileSync7(path, "utf8"));
+    const raw = JSON.parse(readFileSync8(path, "utf8"));
     if (!raw || typeof raw.summary !== "string") return null;
     return raw;
   } catch {
@@ -4214,23 +4392,23 @@ import {
   existsSync as existsSync11,
   mkdtempSync,
   readdirSync as readdirSync4,
-  readFileSync as readFileSync8,
+  readFileSync as readFileSync9,
   rmSync
 } from "fs";
 import { tmpdir } from "os";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 import { createRequire } from "module";
-var CONDUCTOR_APP_SUPPORT = join11(
+var CONDUCTOR_APP_SUPPORT = join12(
   process.env.HOME ?? "",
   "Library",
   "Application Support",
   "com.conductor.app"
 );
-var CONDUCTOR_DB = join11(CONDUCTOR_APP_SUPPORT, "conductor.db");
-var CURSOR_SDK_STORE = join11(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
+var CONDUCTOR_DB = join12(CONDUCTOR_APP_SUPPORT, "conductor.db");
+var CURSOR_SDK_STORE = join12(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
 function thisModuleFile() {
   const cjsFile = typeof __filename !== "undefined" ? __filename : "";
-  return cjsFile || process.argv[1] || join11(process.cwd(), "package.json");
+  return cjsFile || process.argv[1] || join12(process.cwd(), "package.json");
 }
 function openReadonlySqlite(file) {
   const req = createRequire(thisModuleFile());
@@ -4258,11 +4436,11 @@ function resolveConductorCursorAgentId(workspacePath) {
     return null;
   }
   for (const hash of hashes) {
-    const agentsFile = join11(CURSOR_SDK_STORE, hash, "agents.ndjson");
+    const agentsFile = join12(CURSOR_SDK_STORE, hash, "agents.ndjson");
     if (!existsSync11(agentsFile)) continue;
     let text;
     try {
-      text = readFileSync8(agentsFile, "utf8");
+      text = readFileSync9(agentsFile, "utf8");
     } catch {
       continue;
     }
@@ -4315,8 +4493,8 @@ function listConductorWorkspaces() {
   if (!existsSync11(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = mkdtempSync(join11(tmpdir(), "sideboard-conductor-"));
-  const snapshot = join11(tmp, "conductor.db");
+  const tmp = mkdtempSync(join12(tmpdir(), "sideboard-conductor-"));
+  const snapshot = join12(tmp, "conductor.db");
   try {
     copyFileSync2(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
@@ -4406,8 +4584,8 @@ function importConductorWorkspace(workspaceId) {
   if (!existsSync11(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = mkdtempSync(join11(tmpdir(), "sideboard-conductor-"));
-  const snapshot = join11(tmp, "conductor.db");
+  const tmp = mkdtempSync(join12(tmpdir(), "sideboard-conductor-"));
+  const snapshot = join12(tmp, "conductor.db");
   try {
     copyFileSync2(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
@@ -4787,8 +4965,8 @@ async function createPrStack(input, onSetupLine) {
 }
 
 // src/diff/diff.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync5, readFileSync as readFileSync9, statSync as statSync2, writeFileSync as writeFileSync7 } from "fs";
-import { dirname as dirname4, join as join12 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync10, statSync as statSync2, writeFileSync as writeFileSync8 } from "fs";
+import { dirname as dirname5, join as join13 } from "path";
 async function inspectGitWorktree(worktreePath) {
   if (!worktreePath || !existsSync13(worktreePath)) return "missing_worktree";
   const check = await git(["rev-parse", "--is-inside-work-tree"], worktreePath, {
@@ -4934,11 +5112,11 @@ new file mode 100644
   };
 }
 async function untrackedPatch(worktreePath, path, maxHunk) {
-  const abs = join12(worktreePath, path);
+  const abs = join13(worktreePath, path);
   try {
     const st = statSync2(abs);
     if (st.isFile() && st.size > maxHunk) {
-      const buf = readFileSync9(abs).subarray(0, maxHunk);
+      const buf = readFileSync10(abs).subarray(0, maxHunk);
       return syntheticAddPatch(path, buf.toString("utf8"), maxHunk);
     }
   } catch {
@@ -5406,7 +5584,7 @@ async function getDiff(worktreePath, repoPath, opts) {
 }
 function statWorktreePath(worktreePath, relativePath) {
   assertSafeRelativePath(relativePath);
-  const abs = join12(worktreePath, relativePath);
+  const abs = join13(worktreePath, relativePath);
   if (!existsSync13(abs)) return "missing";
   const st = statSync2(abs);
   if (st.isDirectory()) return "dir";
@@ -5448,7 +5626,7 @@ var DEFAULT_UPLOAD_MAX_BYTES = 5e7;
 function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? DEFAULT_UPLOAD_MAX_BYTES;
-  const abs = join12(worktreePath, relativePath);
+  const abs = join13(worktreePath, relativePath);
   const st = statSync2(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
@@ -5458,7 +5636,7 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
       `File too large to upload (${st.size} bytes; max ${maxBytes})`
     );
   }
-  const buf = readFileSync9(abs);
+  const buf = readFileSync10(abs);
   return {
     path: relativePath,
     contentBase64: buf.toString("base64"),
@@ -5468,12 +5646,12 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
 function readWorktreeFile(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? 2e5;
-  const abs = join12(worktreePath, relativePath);
+  const abs = join13(worktreePath, relativePath);
   const st = statSync2(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
-  const buf = readFileSync9(abs);
+  const buf = readFileSync10(abs);
   if (isImageRelativePath(relativePath)) {
     const maxImageBytes = Math.max(maxBytes, 15e6);
     const truncated2 = buf.length > maxImageBytes;
@@ -5516,9 +5694,9 @@ function assertSafeRelativePath(relativePath) {
 }
 function writeWorktreeFile(worktreePath, relativePath, content) {
   assertSafeRelativePath(relativePath);
-  const abs = join12(worktreePath, relativePath);
-  mkdirSync5(dirname4(abs), { recursive: true });
-  writeFileSync7(abs, content, "utf8");
+  const abs = join13(worktreePath, relativePath);
+  mkdirSync6(dirname5(abs), { recursive: true });
+  writeFileSync8(abs, content, "utf8");
   return { path: relativePath };
 }
 async function getWorktreeDirtyStat(worktreePath) {
@@ -5740,9 +5918,9 @@ async function confirmLand(thread, opts) {
 }
 
 // src/skills/discover.ts
-import { existsSync as existsSync14, readdirSync as readdirSync5, readFileSync as readFileSync10, statSync as statSync3 } from "fs";
+import { existsSync as existsSync14, readdirSync as readdirSync5, readFileSync as readFileSync11, statSync as statSync3 } from "fs";
 import { homedir } from "os";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 
 // src/skills/bundled/long-running.ts
 var LONG_RUNNING_SKILL_COMMAND = "long-running";
@@ -5879,7 +6057,7 @@ function parseFrontmatter(content) {
 }
 function readSkill(skillMd, source) {
   try {
-    const content = readFileSync10(skillMd, "utf8");
+    const content = readFileSync11(skillMd, "utf8");
     const { name: fmName, description } = parseFrontmatter(content);
     const dirName = skillMd.split("/").slice(-2, -1)[0] || "skill";
     const name = fmName || dirName;
@@ -5907,7 +6085,7 @@ function scanSkillsDir(dir, source, out) {
   }
   for (const entry of entries) {
     if (entry.startsWith(".")) continue;
-    const skillMd = join13(dir, entry, "SKILL.md");
+    const skillMd = join14(dir, entry, "SKILL.md");
     if (!existsSync14(skillMd)) continue;
     try {
       if (!statSync3(skillMd).isFile()) continue;
@@ -5929,12 +6107,12 @@ function scanClaudePluginSkills(pluginsRoot, out) {
       return;
     }
     if (lookingForSkillsDir && entries.includes("SKILL.md")) {
-      const skill = readSkill(join13(dir, "SKILL.md"), "cli");
+      const skill = readSkill(join14(dir, "SKILL.md"), "cli");
       if (skill) out.push(skill);
     }
     for (const entry of entries) {
       if (entry === "node_modules" || entry === ".git") continue;
-      const full = join13(dir, entry);
+      const full = join14(dir, entry);
       try {
         if (!statSync3(full).isDirectory()) continue;
       } catch {
@@ -5954,17 +6132,17 @@ function discoverSkills(worktreePath) {
   const home = homedir();
   const collected = [];
   for (const rel of [".claude/skills", ".cursor/skills", ".sideboard/skills", ".brightsy/skills", "skills"]) {
-    scanSkillsDir(join13(worktreePath, rel), "workspace", collected);
+    scanSkillsDir(join14(worktreePath, rel), "workspace", collected);
   }
   for (const abs of [
-    join13(home, ".claude/skills"),
-    join13(home, ".cursor/skills"),
-    join13(home, ".sideboard/skills"),
-    join13(home, ".brightsy/skills")
+    join14(home, ".claude/skills"),
+    join14(home, ".cursor/skills"),
+    join14(home, ".sideboard/skills"),
+    join14(home, ".brightsy/skills")
   ]) {
     scanSkillsDir(abs, "user", collected);
   }
-  scanClaudePluginSkills(join13(home, ".claude/plugins"), collected);
+  scanClaudePluginSkills(join14(home, ".claude/plugins"), collected);
   collected.push(...bundledSkills());
   const rank = {
     workspace: 0,
@@ -5990,7 +6168,7 @@ function readSkillBody(skillPath, maxChars = 12e3) {
 \u2026(truncated)` : body;
     }
   }
-  const raw = readFileSync10(skillPath, "utf8");
+  const raw = readFileSync11(skillPath, "utf8");
   if (raw.startsWith("---")) {
     const end = raw.indexOf("\n---", 3);
     if (end >= 0) {
@@ -6136,11 +6314,11 @@ function shiftQueuedItem(queue, queueAttachments) {
 
 // src/agents/instructions.ts
 import { existsSync as existsSync16 } from "fs";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 
 // src/skills/detached-job-path.ts
 import { existsSync as existsSync15 } from "fs";
-import { dirname as dirname5, join as join14 } from "path";
+import { dirname as dirname6, join as join15 } from "path";
 import { fileURLToPath } from "url";
 var DETACHED_JOB_FILENAMES = ["detached-job.cjs", "detached-job.js"];
 function compiledModuleDir() {
@@ -6149,7 +6327,7 @@ function compiledModuleDir() {
   try {
     const url = import.meta.url;
     if (typeof url === "string" && url.length > 0) {
-      return dirname5(fileURLToPath(url));
+      return dirname6(fileURLToPath(url));
     }
   } catch {
   }
@@ -6157,7 +6335,7 @@ function compiledModuleDir() {
 }
 function detachedJobScriptIn(dir) {
   for (const name of DETACHED_JOB_FILENAMES) {
-    const script = join14(dir, "scripts", name);
+    const script = join15(dir, "scripts", name);
     if (existsSync15(script)) return script;
   }
   return null;
@@ -6175,7 +6353,7 @@ function resolveDetachedJobScript() {
   for (let i = 0; i < 8; i++) {
     const candidate = detachedJobScriptIn(dir);
     if (candidate) return candidate;
-    const parent = dirname5(dir);
+    const parent = dirname6(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -6280,9 +6458,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(
@@ -6372,9 +6550,9 @@ function formatPrGateDirective() {
 }
 function formatProcessGuideDirective(opts) {
   const worktree = opts?.worktreePath?.trim();
-  const hasGraphSkill = !!worktree && existsSync16(join15(worktree, ".claude/skills/graph-engineering/SKILL.md"));
-  const hasReviewSkill = !!worktree && existsSync16(join15(worktree, ".claude/skills/review/SKILL.md"));
-  const hasInstallSkill = !!worktree && existsSync16(join15(worktree, ".claude/skills/worktree-install/SKILL.md"));
+  const hasGraphSkill = !!worktree && existsSync16(join16(worktree, ".claude/skills/graph-engineering/SKILL.md"));
+  const hasReviewSkill = !!worktree && existsSync16(join16(worktree, ".claude/skills/review/SKILL.md"));
+  const hasInstallSkill = !!worktree && existsSync16(join16(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,
@@ -6575,8 +6753,8 @@ async function syncThreadBranchFromGit(threadId) {
 
 // src/store/schedules.ts
 import { randomUUID as randomUUID4 } from "crypto";
-import { existsSync as existsSync17, readFileSync as readFileSync11 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync12 } from "fs";
+import { join as join17 } from "path";
 import { Cron } from "croner";
 var DURATION_RE = /^(\d+)(s|m|h|d)$/i;
 var UNIT_MS = {
@@ -6586,7 +6764,7 @@ var UNIT_MS = {
   d: 864e5
 };
 function schedulesPath() {
-  return join16(appDataDir(), "schedules.json");
+  return join17(appDataDir(), "schedules.json");
 }
 function parseDurationMs(every) {
   const m = every.trim().match(DURATION_RE);
@@ -6688,7 +6866,7 @@ function readAll() {
   const path = schedulesPath();
   if (!existsSync17(path)) return [];
   try {
-    const parsed = JSON.parse(readFileSync11(path, "utf8"));
+    const parsed = JSON.parse(readFileSync12(path, "utf8"));
     if (!Array.isArray(parsed)) return [];
     return parsed.map((row) => {
       try {
@@ -6811,7 +6989,7 @@ function formatScheduledPrompt(name, prompt) {
 ${prompt}`;
 }
 async function defaultDeps() {
-  const { getOrchestrator: getOrchestrator2, startOrchestration: startOrchestration2 } = await import("./orchestrator-AAYKR4AI.js");
+  const { getOrchestrator: getOrchestrator2, startOrchestration: startOrchestration2 } = await import("./orchestrator-3ZP4WTQ4.js");
   const orch = getOrchestrator2();
   return {
     findThread: (id) => findThreadByRef(id),
@@ -6876,14 +7054,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);
@@ -7267,8 +7445,8 @@ var Orchestrator = class {
   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);
@@ -8323,6 +8501,7 @@ var Orchestrator = class {
         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(
@@ -8361,7 +8540,7 @@ var Orchestrator = class {
         thread.repoPath,
         thread.worktreePath,
         runOutput.push,
-        { scriptName: resolvedName }
+        { scriptName: resolvedName, preferredPorts }
       );
     } catch (err) {
       runOutput.flush();
@@ -8810,7 +8989,7 @@ var Orchestrator = class {
       return thread;
     }
     const start = Date.now();
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       let settled = false;
       let timer;
       const finish = (fn) => {
@@ -8828,7 +9007,7 @@ var Orchestrator = class {
             finish(() => reject(new Error(`Thread not found: ${thread.id}`)));
             return;
           }
-          finish(() => resolve(latest));
+          finish(() => resolve2(latest));
           return;
         }
         if (event.type === "status_changed") {
@@ -8838,7 +9017,7 @@ var Orchestrator = class {
             return;
           }
           if (!["running", "queued"].includes(latest.status)) {
-            finish(() => resolve(latest));
+            finish(() => resolve2(latest));
           }
         }
       });
@@ -8850,12 +9029,12 @@ var Orchestrator = class {
         }
         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")));
           }