@sideboard-ai/core 0.1.235 → 0.1.236

package/dist/mcp/run-stdio.cjs

@@ -202,10 +202,139 @@ var init_cursor_worktrees = __esm({
   }
 });
 
+// src/hook/dev-preview.ts
+function parseDevPreview(raw) {
+  return raw === "url" || raw === "window" ? raw : void 0;
+}
+function commandLooksLikeElectron(command) {
+  return ELECTRON_CMD_RE.test(command);
+}
+function pnpmFilterPackage(command) {
+  const m = command.match(PNPM_FILTER_RE);
+  return m?.[1] ?? m?.[2] ?? m?.[3] ?? null;
+}
+function readJsonObject(path) {
+  try {
+    const raw = JSON.parse((0, import_node_fs3.readFileSync)(path, "utf8"));
+    return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : null;
+  } catch {
+    return null;
+  }
+}
+function packageLooksLikeElectron(pkg) {
+  const deps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies,
+    ...pkg.optionalDependencies
+  };
+  if (deps.electron || deps["electron-vite"] || deps["electron-builder"] || deps["@electron-forge/cli"] || deps["electron-forge"]) {
+    return true;
+  }
+  const scripts = pkg.scripts;
+  if (scripts && typeof scripts === "object") {
+    for (const value of Object.values(scripts)) {
+      if (typeof value === "string" && commandLooksLikeElectron(value)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function findPackageJsonByName(root, name, budget = 80) {
+  const queue = [root];
+  let seen = 0;
+  while (queue.length && seen < budget) {
+    const dir = queue.shift();
+    const pkgPath = (0, import_node_path3.join)(dir, "package.json");
+    if ((0, import_node_fs3.existsSync)(pkgPath)) {
+      seen += 1;
+      const pkg = readJsonObject(pkgPath);
+      if (pkg?.name === name) return pkgPath;
+    }
+    let entries;
+    try {
+      entries = (0, import_node_fs3.readdirSync)(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.isSymbolicLink() || SKIP_DIR.has(entry.name) || entry.name.startsWith(".")) {
+        continue;
+      }
+      queue.push((0, import_node_path3.join)(dir, entry.name));
+    }
+  }
+  return null;
+}
+function classifyRunScriptPreview(opts) {
+  if (opts.preview === "url" || opts.preview === "window") return opts.preview;
+  if (commandLooksLikeElectron(opts.command)) return "window";
+  const root = opts.worktreePath?.trim();
+  if (!root) return "url";
+  const filter = pnpmFilterPackage(opts.command);
+  if (filter) {
+    if (filter.startsWith(".") || filter.startsWith("/")) {
+      const pkg = readJsonObject((0, import_node_path3.join)(root, filter, "package.json"));
+      if (pkg && packageLooksLikeElectron(pkg)) return "window";
+    } else {
+      const found = findPackageJsonByName(root, filter);
+      if (found) {
+        const pkg = readJsonObject(found);
+        if (pkg && packageLooksLikeElectron(pkg)) return "window";
+        return "url";
+      }
+    }
+  }
+  const rootPkg = readJsonObject((0, import_node_path3.join)(root, "package.json"));
+  if (rootPkg && packageLooksLikeElectron(rootPkg)) return "window";
+  return "url";
+}
+function runScriptPreview(script, worktreePath) {
+  if (!script) return "url";
+  return classifyRunScriptPreview({
+    command: script.command,
+    preview: script.preview,
+    worktreePath
+  });
+}
+function activeRunPreview(scriptName, scripts, worktreePath) {
+  return runScriptPreview(
+    scripts.find((s) => s.name === scriptName),
+    worktreePath
+  );
+}
+function annotateDevAccessRuns(runs, scripts, worktreePath) {
+  return runs.map((run2) => ({
+    ...run2,
+    preview: activeRunPreview(run2.scriptName, scripts, worktreePath)
+  }));
+}
+var import_node_fs3, import_node_path3, ELECTRON_CMD_RE, PNPM_FILTER_RE, SKIP_DIR;
+var init_dev_preview = __esm({
+  "src/hook/dev-preview.ts"() {
+    "use strict";
+    import_node_fs3 = require("fs");
+    import_node_path3 = require("path");
+    ELECTRON_CMD_RE = /\belectron(?:-vite|-forge|-builder|mon)?\b/i;
+    PNPM_FILTER_RE = /--filter(?:=|\s+)(?:"([^"]+)"|'([^']+)'|([^\s]+))/;
+    SKIP_DIR = /* @__PURE__ */ new Set([
+      "node_modules",
+      "dist",
+      "out",
+      "coverage",
+      ".git",
+      ".context",
+      ".next",
+      ".turbo",
+      ".output"
+    ]);
+  }
+});
+
 // src/hook/settings.ts
 function expandHome(path) {
   if (path.startsWith("~/") || path === "~") {
-    return (0, import_node_path3.join)((0, import_node_os.homedir)(), path.slice(2));
+    return (0, import_node_path4.join)((0, import_node_os.homedir)(), path.slice(2));
   }
   return path;
 }
@@ -218,8 +347,8 @@ function parseAvailableIn(raw) {
   return out.length ? out : void 0;
 }
 function parseSettingsFile(path, source) {
-  if (!(0, import_node_fs3.existsSync)(path)) return null;
-  const raw = (0, import_node_fs3.readFileSync)(path, "utf8");
+  if (!(0, import_node_fs4.existsSync)(path)) return null;
+  const raw = (0, import_node_fs4.readFileSync)(path, "utf8");
   const data = (0, import_smol_toml.parse)(raw);
   const scripts = data.scripts ?? {};
   const setup = typeof scripts.setup === "string" ? scripts.setup : void 0;
@@ -257,7 +386,8 @@ function parseSettingsFile(path, source) {
           command: value.command,
           default: Boolean(value.default),
           icon: typeof value.icon === "string" ? value.icon : void 0,
-          availableIn: parseAvailableIn(value.available_in)
+          availableIn: parseAvailableIn(value.available_in),
+          preview: parseDevPreview(value.preview)
         });
       }
     }
@@ -328,15 +458,15 @@ function finalizeSettings(parsed) {
   };
 }
 function familyFiles(rootPath, source) {
-  const dir = (0, import_node_path3.join)(rootPath, `.${source}`);
+  const dir = (0, import_node_path4.join)(rootPath, `.${source}`);
   return {
-    toml: (0, import_node_path3.join)(dir, "settings.toml"),
-    local: (0, import_node_path3.join)(dir, "settings.local.toml")
+    toml: (0, import_node_path4.join)(dir, "settings.toml"),
+    local: (0, import_node_path4.join)(dir, "settings.local.toml")
   };
 }
 function familyExists(rootPath, source) {
   const files = familyFiles(rootPath, source);
-  return (0, import_node_fs3.existsSync)(files.toml) || (0, import_node_fs3.existsSync)(files.local);
+  return (0, import_node_fs4.existsSync)(files.toml) || (0, import_node_fs4.existsSync)(files.local);
 }
 function detectFamily(rootPath) {
   if (familyExists(rootPath, "sideboard")) return "sideboard";
@@ -383,10 +513,10 @@ function settingsSourceLabel(rootPath) {
   const family = detectFamily(rootPath);
   if (!family) return null;
   const files = familyFiles(rootPath, family);
-  if ((0, import_node_fs3.existsSync)(files.toml) && (0, import_node_fs3.existsSync)(files.local)) {
+  if ((0, import_node_fs4.existsSync)(files.toml) && (0, import_node_fs4.existsSync)(files.local)) {
     return `.${family}/settings.toml + local`;
   }
-  if ((0, import_node_fs3.existsSync)(files.local)) return `.${family}/settings.local.toml`;
+  if ((0, import_node_fs4.existsSync)(files.local)) return `.${family}/settings.local.toml`;
   return `.${family}/settings.toml`;
 }
 function workspaceSettingsSourceLabel(worktreePath, repoPath) {
@@ -398,16 +528,17 @@ function workspaceSettingsSourceLabel(worktreePath, repoPath) {
   }
   return null;
 }
-var import_node_fs3, import_node_os, import_node_path3, import_smol_toml;
+var import_node_fs4, import_node_os, import_node_path4, import_smol_toml;
 var init_settings = __esm({
   "src/hook/settings.ts"() {
     "use strict";
-    import_node_fs3 = require("fs");
+    import_node_fs4 = require("fs");
     import_node_os = require("os");
-    import_node_path3 = require("path");
+    import_node_path4 = require("path");
     import_smol_toml = require("smol-toml");
     init_convention_setup();
     init_cursor_worktrees();
+    init_dev_preview();
   }
 });
 
@@ -429,70 +560,70 @@ __export(paths_exports, {
 });
 function appDataDir() {
   const override = process.env.SIDEBOARD_APP_DATA?.trim();
-  const base = override ? override : process.platform === "darwin" ? (0, import_node_path5.join)((0, import_node_os2.homedir)(), "Library", "Application Support", "sideboard") : process.platform === "win32" ? (0, import_node_path5.join)(process.env.APPDATA ?? (0, import_node_path5.join)((0, import_node_os2.homedir)(), "AppData", "Roaming"), "sideboard") : (0, import_node_path5.join)((0, import_node_os2.homedir)(), ".local", "share", "sideboard");
-  (0, import_node_fs4.mkdirSync)(base, { recursive: true });
+  const base = override ? override : process.platform === "darwin" ? (0, import_node_path6.join)((0, import_node_os2.homedir)(), "Library", "Application Support", "sideboard") : process.platform === "win32" ? (0, import_node_path6.join)(process.env.APPDATA ?? (0, import_node_path6.join)((0, import_node_os2.homedir)(), "AppData", "Roaming"), "sideboard") : (0, import_node_path6.join)((0, import_node_os2.homedir)(), ".local", "share", "sideboard");
+  (0, import_node_fs5.mkdirSync)(base, { recursive: true });
   return base;
 }
 function threadsDir() {
-  const dir = (0, import_node_path5.join)(appDataDir(), "threads");
-  (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_node_path6.join)(appDataDir(), "threads");
+  (0, import_node_fs5.mkdirSync)(dir, { recursive: true });
   return dir;
 }
 function locksDir() {
-  const dir = (0, import_node_path5.join)(appDataDir(), "locks");
-  (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_node_path6.join)(appDataDir(), "locks");
+  (0, import_node_fs5.mkdirSync)(dir, { recursive: true });
   return dir;
 }
 function sideboardHomeDir() {
-  const dir = (0, import_node_path5.join)((0, import_node_os2.homedir)(), "sideboard");
-  (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_node_path6.join)((0, import_node_os2.homedir)(), "sideboard");
+  (0, import_node_fs5.mkdirSync)(dir, { recursive: true });
   return dir;
 }
 function sideboardReposDir() {
-  const dir = (0, import_node_path5.join)(sideboardHomeDir(), "repos");
-  (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_node_path6.join)(sideboardHomeDir(), "repos");
+  (0, import_node_fs5.mkdirSync)(dir, { recursive: true });
   return dir;
 }
 function sideboardWorkspacesDir() {
-  const dir = (0, import_node_path5.join)(sideboardHomeDir(), "workspaces");
-  (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_node_path6.join)(sideboardHomeDir(), "workspaces");
+  (0, import_node_fs5.mkdirSync)(dir, { recursive: true });
   return dir;
 }
 function repoSlug(repoPath) {
-  return (0, import_node_path4.basename)(repoPath.replace(/\/$/, "")) || "repo";
+  return (0, import_node_path5.basename)(repoPath.replace(/\/$/, "")) || "repo";
 }
 function worktreesRoot(repoPath) {
   const settings = loadRepoSettings(repoPath);
   if (settings?.worktreesRoot) {
-    (0, import_node_fs4.mkdirSync)(settings.worktreesRoot, { recursive: true });
+    (0, import_node_fs5.mkdirSync)(settings.worktreesRoot, { recursive: true });
     return settings.worktreesRoot;
   }
-  const dir = (0, import_node_path5.join)(sideboardWorkspacesDir(), repoSlug(repoPath));
-  (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_node_path6.join)(sideboardWorkspacesDir(), repoSlug(repoPath));
+  (0, import_node_fs5.mkdirSync)(dir, { recursive: true });
   return dir;
 }
 function threadFilePath(id) {
-  return (0, import_node_path5.join)(threadsDir(), `${id}.json`);
+  return (0, import_node_path6.join)(threadsDir(), `${id}.json`);
 }
 function threadLivePath(id) {
-  return (0, import_node_path5.join)(threadsDir(), `${id}.live.json`);
+  return (0, import_node_path6.join)(threadsDir(), `${id}.live.json`);
 }
 function threadLockPath(id) {
-  return (0, import_node_path5.join)(locksDir(), `${id}.lock`);
+  return (0, import_node_path6.join)(locksDir(), `${id}.lock`);
 }
 function globalAgentCwd() {
-  const dir = (0, import_node_path5.join)(appDataDir(), "global");
-  (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_node_path6.join)(appDataDir(), "global");
+  (0, import_node_fs5.mkdirSync)(dir, { recursive: true });
   return dir;
 }
-var import_node_path4, import_node_os2, import_node_path5, import_node_fs4;
+var import_node_path5, import_node_os2, import_node_path6, import_node_fs5;
 var init_paths = __esm({
   "src/store/paths.ts"() {
     "use strict";
-    import_node_path4 = require("path");
-    import_node_os2 = require("os");
     import_node_path5 = require("path");
-    import_node_fs4 = require("fs");
+    import_node_os2 = require("os");
+    import_node_path6 = require("path");
+    import_node_fs5 = require("fs");
     init_settings();
   }
 });
@@ -503,7 +634,7 @@ function splitPemCertificates(pem) {
 }
 function readExistingFile(path) {
   try {
-    return (0, import_node_fs5.existsSync)(path) ? (0, import_node_fs5.readFileSync)(path, "utf8") : "";
+    return (0, import_node_fs6.existsSync)(path) ? (0, import_node_fs6.readFileSync)(path, "utf8") : "";
   } catch {
     return "";
   }
@@ -535,13 +666,13 @@ function collectSystemCaPem(io = {}) {
   return "";
 }
 function systemCaBundlePath(io = {}) {
-  return (0, import_node_path6.join)((io.appData ?? appDataDir)(), BUNDLE_NAME);
+  return (0, import_node_path7.join)((io.appData ?? appDataDir)(), BUNDLE_NAME);
 }
 function bundleIsFresh(path, now) {
   try {
-    if (!(0, import_node_fs5.existsSync)(path)) return false;
-    if (splitPemCertificates((0, import_node_fs5.readFileSync)(path, "utf8")).length === 0) return false;
-    return now - (0, import_node_fs5.statSync)(path).mtimeMs < BUNDLE_MAX_AGE_MS;
+    if (!(0, import_node_fs6.existsSync)(path)) return false;
+    if (splitPemCertificates((0, import_node_fs6.readFileSync)(path, "utf8")).length === 0) return false;
+    return now - (0, import_node_fs6.statSync)(path).mtimeMs < BUNDLE_MAX_AGE_MS;
   } catch {
     return false;
   }
@@ -562,11 +693,11 @@ function materializeSystemCaBundle(io = {}) {
   if (bundleIsFresh(dest, now)) return dest;
   const pem = collectSystemCaPem(io);
   if (splitPemCertificates(pem).length === 0) {
-    return (0, import_node_fs5.existsSync)(dest) && splitPemCertificates(readExistingFile(dest)).length > 0 ? dest : void 0;
+    return (0, import_node_fs6.existsSync)(dest) && splitPemCertificates(readExistingFile(dest)).length > 0 ? dest : void 0;
   }
   try {
-    (0, import_node_fs5.mkdirSync)((0, import_node_path6.dirname)(dest), { recursive: true });
-    (0, import_node_fs5.writeFileSync)(dest, pem.endsWith("\n") ? pem : `${pem}
+    (0, import_node_fs6.mkdirSync)((0, import_node_path7.dirname)(dest), { recursive: true });
+    (0, import_node_fs6.writeFileSync)(dest, pem.endsWith("\n") ? pem : `${pem}
 `, { mode: 384 });
     return dest;
   } catch {
@@ -606,13 +737,13 @@ function trustSystemCertificates(io = {}) {
     return false;
   }
 }
-var import_node_child_process, import_node_fs5, import_node_path6, import_node_tls, NODE_USE_SYSTEM_CA, NODE_EXTRA_CA_CERTS, BUNDLE_NAME, BUNDLE_MAX_AGE_MS, LINUX_CA_FILES, PEM_CERT_RE;
+var import_node_child_process, import_node_fs6, import_node_path7, import_node_tls, NODE_USE_SYSTEM_CA, NODE_EXTRA_CA_CERTS, BUNDLE_NAME, BUNDLE_MAX_AGE_MS, LINUX_CA_FILES, PEM_CERT_RE;
 var init_system_ca = __esm({
   "src/http/system-ca.ts"() {
     "use strict";
     import_node_child_process = require("child_process");
-    import_node_fs5 = require("fs");
-    import_node_path6 = require("path");
+    import_node_fs6 = require("fs");
+    import_node_path7 = require("path");
     import_node_tls = __toESM(require("tls"), 1);
     init_paths();
     NODE_USE_SYSTEM_CA = "NODE_USE_SYSTEM_CA";
@@ -631,22 +762,22 @@ var init_system_ca = __esm({
 
 // src/store/private-file.ts
 function writePrivateFile(path, contents) {
-  (0, import_node_fs6.mkdirSync)((0, import_node_path7.dirname)(path), { recursive: true });
-  (0, import_node_fs6.writeFileSync)(path, contents, { encoding: "utf8", mode: PRIVATE_FILE_MODE });
+  (0, import_node_fs7.mkdirSync)((0, import_node_path8.dirname)(path), { recursive: true });
+  (0, import_node_fs7.writeFileSync)(path, contents, { encoding: "utf8", mode: PRIVATE_FILE_MODE });
   chmodOwnerOnly(path);
 }
 function chmodOwnerOnly(path) {
   try {
-    (0, import_node_fs6.chmodSync)(path, PRIVATE_FILE_MODE);
+    (0, import_node_fs7.chmodSync)(path, PRIVATE_FILE_MODE);
   } catch {
   }
 }
-var import_node_fs6, import_node_path7, PRIVATE_FILE_MODE;
+var import_node_fs7, import_node_path8, PRIVATE_FILE_MODE;
 var init_private_file = __esm({
   "src/store/private-file.ts"() {
     "use strict";
-    import_node_fs6 = require("fs");
-    import_node_path7 = require("path");
+    import_node_fs7 = require("fs");
+    import_node_path8 = require("path");
     PRIVATE_FILE_MODE = 384;
   }
 });
@@ -732,11 +863,11 @@ function decryptEnvelope(envelope, key) {
   return JSON.parse(plaintext.toString("utf8"));
 }
 function readSecureJson(path) {
-  if (!(0, import_node_fs7.existsSync)(path)) return null;
+  if (!(0, import_node_fs8.existsSync)(path)) return null;
   chmodOwnerOnly(path);
   let parsed;
   try {
-    parsed = JSON.parse((0, import_node_fs7.readFileSync)(path, "utf8"));
+    parsed = JSON.parse((0, import_node_fs8.readFileSync)(path, "utf8"));
   } catch {
     return null;
   }
@@ -756,20 +887,20 @@ function writeSecureJson(path, value) {
 `);
 }
 function isSecureFileEncrypted(path) {
-  if (!(0, import_node_fs7.existsSync)(path)) return false;
+  if (!(0, import_node_fs8.existsSync)(path)) return false;
   try {
-    return isEnvelope(JSON.parse((0, import_node_fs7.readFileSync)(path, "utf8")));
+    return isEnvelope(JSON.parse((0, import_node_fs8.readFileSync)(path, "utf8")));
   } catch {
     return false;
   }
 }
-var import_node_child_process2, import_node_crypto, import_node_fs7, KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT, ALG, injectedKey;
+var import_node_child_process2, import_node_crypto, import_node_fs8, KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT, ALG, injectedKey;
 var init_secure_file = __esm({
   "src/store/secure-file.ts"() {
     "use strict";
     import_node_child_process2 = require("child_process");
     import_node_crypto = require("crypto");
-    import_node_fs7 = require("fs");
+    import_node_fs8 = require("fs");
     init_private_file();
     KEYCHAIN_SERVICE = "ai.sideboard.app";
     KEYCHAIN_ACCOUNT = "secret-vault-v1";
@@ -803,13 +934,13 @@ var init_thinking_effort = __esm({
 
 // src/agents/cursor-store.ts
 function cursorSdkStoreDir(threadId) {
-  const root = (0, import_node_path8.join)(appDataDir(), CURSOR_SDK_STORE_DIR);
+  const root = (0, import_node_path9.join)(appDataDir(), CURSOR_SDK_STORE_DIR);
   const id = sanitizeCursorStoreSegment(threadId);
   if (!id) return root;
-  return (0, import_node_path8.join)(root, "threads", id);
+  return (0, import_node_path9.join)(root, "threads", id);
 }
 function cursorSdkRunsNdjsonPath(threadId) {
-  return (0, import_node_path8.join)(cursorSdkStoreDir(threadId), "runs.ndjson");
+  return (0, import_node_path9.join)(cursorSdkStoreDir(threadId), "runs.ndjson");
 }
 function cursorSdkRunsNdjsonSearchPaths(threadId) {
   const scoped = cursorSdkRunsNdjsonPath(threadId);
@@ -822,11 +953,11 @@ function cursorSdkRunsNdjsonSearchPaths(threadId) {
 function sanitizeCursorStoreSegment(threadId) {
   return (threadId ?? "").trim().replace(/[^a-zA-Z0-9._-]/g, "_");
 }
-var import_node_path8, CURSOR_SDK_STORE_DIR;
+var import_node_path9, CURSOR_SDK_STORE_DIR;
 var init_cursor_store = __esm({
   "src/agents/cursor-store.ts"() {
     "use strict";
-    import_node_path8 = require("path");
+    import_node_path9 = require("path");
     init_paths();
     CURSOR_SDK_STORE_DIR = "cursor-sdk-store";
   }
@@ -953,7 +1084,7 @@ function createEmptyThread(partial) {
 }
 async function withThreadLock(id, fn) {
   const lockPath = threadLockPath(id);
-  (0, import_node_fs8.writeFileSync)(lockPath, "", { flag: "a" });
+  (0, import_node_fs9.writeFileSync)(lockPath, "", { flag: "a" });
   let release;
   try {
     release = await import_proper_lockfile.default.lock(lockPath, {
@@ -974,7 +1105,7 @@ function cacheForDir() {
 }
 function fileMtimeMs(path) {
   try {
-    return (0, import_node_fs8.statSync)(path).mtimeMs;
+    return (0, import_node_fs9.statSync)(path).mtimeMs;
   } catch {
     return null;
   }
@@ -1007,7 +1138,7 @@ function readThread(id) {
   const cache = cacheForDir();
   const cached = cache.byId.get(id);
   if (cached && cache.mtimeMs.get(id) === mtimeMs) return cached;
-  const raw = (0, import_node_fs8.readFileSync)(path, "utf8");
+  const raw = (0, import_node_fs9.readFileSync)(path, "utf8");
   const thread = normalizeThread(JSON.parse(raw));
   rememberThread(thread, mtimeMs);
   return thread;
@@ -1016,8 +1147,8 @@ function writeThread(thread, opts) {
   const path = threadFilePath(idPath(thread.id));
   const tmp = `${path}.${process.pid}.tmp`;
   const next = opts?.touch === false ? { ...thread } : { ...thread, updatedAt: nowIso() };
-  (0, import_node_fs8.writeFileSync)(tmp, JSON.stringify(next, null, 2), "utf8");
-  (0, import_node_fs8.renameSync)(tmp, path);
+  (0, import_node_fs9.writeFileSync)(tmp, JSON.stringify(next, null, 2), "utf8");
+  (0, import_node_fs9.renameSync)(tmp, path);
   const mtimeMs = fileMtimeMs(path) ?? Date.now();
   rememberThread(next, mtimeMs);
   selfWriteMtimes.set(thread.id, mtimeMs);
@@ -1031,12 +1162,12 @@ function idPath(id) {
   return id;
 }
 function isThreadRecordFile(nameOrPath) {
-  const name = (0, import_node_path9.basename)(nameOrPath);
+  const name = (0, import_node_path10.basename)(nameOrPath);
   return name.endsWith(".json") && !name.endsWith(".live.json") && !name.endsWith(".setup.log.json");
 }
 function listThreads(opts) {
   const cache = cacheForDir();
-  const files = (0, import_node_fs8.readdirSync)(threadsDir()).filter(isThreadRecordFile);
+  const files = (0, import_node_fs9.readdirSync)(threadsDir()).filter(isThreadRecordFile);
   const seen = /* @__PURE__ */ new Set();
   for (const f of files) {
     const id = f.replace(/\.json$/, "");
@@ -1059,16 +1190,16 @@ function listThreads(opts) {
 function deleteThreadRecord(id) {
   forgetThread(id);
   const path = threadFilePath(id);
-  if ((0, import_node_fs8.existsSync)(path)) (0, import_node_fs8.unlinkSync)(path);
+  if ((0, import_node_fs9.existsSync)(path)) (0, import_node_fs9.unlinkSync)(path);
   const lock = threadLockPath(id);
-  if ((0, import_node_fs8.existsSync)(lock)) {
+  if ((0, import_node_fs9.existsSync)(lock)) {
     try {
-      (0, import_node_fs8.unlinkSync)(lock);
+      (0, import_node_fs9.unlinkSync)(lock);
     } catch {
     }
   }
   try {
-    (0, import_node_fs8.rmSync)(cursorSdkStoreDir(id), { recursive: true, force: true });
+    (0, import_node_fs9.rmSync)(cursorSdkStoreDir(id), { recursive: true, force: true });
   } catch {
   }
 }
@@ -1098,13 +1229,13 @@ function findThreadByRef(ref) {
     (t) => t.id === ref || t.id.startsWith(ref) || t.branchName === ref || t.title === ref
   ) ?? null;
 }
-var import_node_crypto2, import_node_fs8, import_node_path9, import_proper_lockfile, listCache, selfWriteMtimes;
+var import_node_crypto2, import_node_fs9, import_node_path10, import_proper_lockfile, listCache, selfWriteMtimes;
 var init_thread_store = __esm({
   "src/store/thread-store.ts"() {
     "use strict";
     import_node_crypto2 = require("crypto");
-    import_node_fs8 = require("fs");
-    import_node_path9 = require("path");
+    import_node_fs9 = require("fs");
+    import_node_path10 = require("path");
     import_proper_lockfile = __toESM(require("proper-lockfile"), 1);
     init_thinking_effort();
     init_cursor_store();
@@ -1158,13 +1289,13 @@ var init_api = __esm({
 
 // src/slack/reply-target.ts
 function storePath() {
-  return (0, import_node_path10.join)(appDataDir(), "slack-reply-to.json");
+  return (0, import_node_path11.join)(appDataDir(), "slack-reply-to.json");
 }
 function readStore() {
   const path = storePath();
-  if (!(0, import_node_fs9.existsSync)(path)) return {};
+  if (!(0, import_node_fs10.existsSync)(path)) return {};
   try {
-    const parsed = isSecureFileEncrypted(path) ? readSecureJson(path) : JSON.parse((0, import_node_fs9.readFileSync)(path, "utf8"));
+    const parsed = isSecureFileEncrypted(path) ? readSecureJson(path) : JSON.parse((0, import_node_fs10.readFileSync)(path, "utf8"));
     return parsed?.targets && typeof parsed.targets === "object" ? parsed.targets : {};
   } catch {
     return {};
@@ -1173,12 +1304,12 @@ function readStore() {
 function getSlackReplyTarget(threadId) {
   return readStore()[threadId] ?? null;
 }
-var import_node_fs9, import_node_path10;
+var import_node_fs10, import_node_path11;
 var init_reply_target = __esm({
   "src/slack/reply-target.ts"() {
     "use strict";
-    import_node_fs9 = require("fs");
-    import_node_path10 = require("path");
+    import_node_fs10 = require("fs");
+    import_node_path11 = require("path");
     init_paths();
     init_private_file();
     init_secure_file();
@@ -1187,7 +1318,7 @@ var init_reply_target = __esm({
 
 // src/slack/workspaces.ts
 function storePath2() {
-  return (0, import_node_path11.join)(appDataDir(), "slack-workspaces.json");
+  return (0, import_node_path12.join)(appDataDir(), "slack-workspaces.json");
 }
 function readStore2() {
   try {
@@ -1248,11 +1379,11 @@ function requireSlackWorkspace(teamId) {
   }
   return ws;
 }
-var import_node_path11;
+var import_node_path12;
 var init_workspaces = __esm({
   "src/slack/workspaces.ts"() {
     "use strict";
-    import_node_path11 = require("path");
+    import_node_path12 = require("path");
     init_paths();
     init_secure_file();
     init_api();
@@ -1261,7 +1392,7 @@ var init_workspaces = __esm({
 
 // src/slack/outbound-watch.ts
 function storePath3() {
-  return (0, import_node_path12.join)(appDataDir(), "slack-outbound-watch.json");
+  return (0, import_node_path13.join)(appDataDir(), "slack-outbound-watch.json");
 }
 function watchId(teamId, channelId, ts) {
   return `${teamId}:${channelId}:${ts}`;
@@ -1274,9 +1405,9 @@ function tsNewer(a, b) {
 }
 function readStore3() {
   const path = storePath3();
-  if (!(0, import_node_fs10.existsSync)(path)) return [];
+  if (!(0, import_node_fs11.existsSync)(path)) return [];
   try {
-    const parsed = isSecureFileEncrypted(path) ? readSecureJson(path) : JSON.parse((0, import_node_fs10.readFileSync)(path, "utf8"));
+    const parsed = isSecureFileEncrypted(path) ? readSecureJson(path) : JSON.parse((0, import_node_fs11.readFileSync)(path, "utf8"));
     return Array.isArray(parsed?.watches) ? parsed.watches : [];
   } catch {
     return [];
@@ -1598,12 +1729,12 @@ async function pollSlackOutboundWatches(opts) {
   }
   if (changed) writeStore(watches);
 }
-var import_node_fs10, import_node_path12, MAX_WATCHES, MAX_REPLIES_PER_WATCH, WATCH_TTL_MS, POLL_INTERVAL_MS, lastPollMs, nameCache, continueOnReply;
+var import_node_fs11, import_node_path13, MAX_WATCHES, MAX_REPLIES_PER_WATCH, WATCH_TTL_MS, POLL_INTERVAL_MS, lastPollMs, nameCache, continueOnReply;
 var init_outbound_watch = __esm({
   "src/slack/outbound-watch.ts"() {
     "use strict";
-    import_node_fs10 = require("fs");
-    import_node_path12 = require("path");
+    import_node_fs11 = require("fs");
+    import_node_path13 = require("path");
     init_paths();
     init_private_file();
     init_secure_file();
@@ -1999,36 +2130,36 @@ var init_error_detail = __esm({
 
 // src/agents/path.ts
 function prependPathDir(env, dir) {
-  if (!dir || !(0, import_node_fs11.existsSync)(dir)) return;
+  if (!dir || !(0, import_node_fs12.existsSync)(dir)) return;
   const current = env.PATH ?? "";
-  const parts = current.split(import_node_path13.delimiter).filter(Boolean);
+  const parts = current.split(import_node_path14.delimiter).filter(Boolean);
   if (parts.includes(dir)) {
     env.PATH = current;
     return;
   }
-  env.PATH = [dir, ...parts].join(import_node_path13.delimiter);
+  env.PATH = [dir, ...parts].join(import_node_path14.delimiter);
 }
 function conductorBundledBinDir(home = process.env.HOME || process.env.USERPROFILE || (0, import_node_os3.homedir)()) {
-  return (0, import_node_path13.join)(home, "Library", "Application Support", "com.conductor.app", "bin");
+  return (0, import_node_path14.join)(home, "Library", "Application Support", "com.conductor.app", "bin");
 }
 function ensureAgentPath(env = process.env) {
   const home = env.HOME || env.USERPROFILE || (0, import_node_os3.homedir)();
   const current = env.PATH ?? "";
-  const parts = current.split(import_node_path13.delimiter).filter(Boolean);
+  const parts = current.split(import_node_path14.delimiter).filter(Boolean);
   const seen = new Set(parts);
   const extras = [
-    ...EXTRA_BIN_DIRS.map((rel) => (0, import_node_path13.join)(home, rel)),
+    ...EXTRA_BIN_DIRS.map((rel) => (0, import_node_path14.join)(home, rel)),
     "/opt/homebrew/bin",
     "/usr/local/bin",
     // Keep after Homebrew/npm so a user-installed CLI still wins.
     conductorBundledBinDir(home)
   ];
   for (const dir of extras.reverse()) {
-    if (!dir || seen.has(dir) || !(0, import_node_fs11.existsSync)(dir)) continue;
+    if (!dir || seen.has(dir) || !(0, import_node_fs12.existsSync)(dir)) continue;
     parts.unshift(dir);
     seen.add(dir);
   }
-  const next = parts.join(import_node_path13.delimiter);
+  const next = parts.join(import_node_path14.delimiter);
   env.PATH = next;
   return next;
 }
@@ -2036,7 +2167,7 @@ function enrichPathWithNpmGlobalBin(env = process.env) {
   ensureAgentPath(env);
   const prefix = npmGlobalPrefix(env);
   if (prefix) {
-    const binDir = process.platform === "win32" ? prefix : (0, import_node_path13.join)(prefix, "bin");
+    const binDir = process.platform === "win32" ? prefix : (0, import_node_path14.join)(prefix, "bin");
     prependPathDir(env, binDir);
   }
   return env.PATH ?? "";
@@ -2057,17 +2188,17 @@ function npmGlobalPrefix(env = process.env) {
 function npmGlobalNodeModules(env = process.env) {
   const prefix = npmGlobalPrefix(env);
   if (!prefix) return null;
-  const dir = process.platform === "win32" ? (0, import_node_path13.join)(prefix, "node_modules") : (0, import_node_path13.join)(prefix, "lib", "node_modules");
-  return (0, import_node_fs11.existsSync)(dir) ? dir : null;
+  const dir = process.platform === "win32" ? (0, import_node_path14.join)(prefix, "node_modules") : (0, import_node_path14.join)(prefix, "lib", "node_modules");
+  return (0, import_node_fs12.existsSync)(dir) ? dir : null;
 }
-var import_node_fs11, import_node_child_process3, import_node_os3, import_node_path13, EXTRA_BIN_DIRS;
+var import_node_fs12, import_node_child_process3, import_node_os3, import_node_path14, EXTRA_BIN_DIRS;
 var init_path = __esm({
   "src/agents/path.ts"() {
     "use strict";
-    import_node_fs11 = require("fs");
+    import_node_fs12 = require("fs");
     import_node_child_process3 = require("child_process");
     import_node_os3 = require("os");
-    import_node_path13 = require("path");
+    import_node_path14 = require("path");
     EXTRA_BIN_DIRS = [
       ".local/bin",
       ".cargo/bin",
@@ -2088,23 +2219,23 @@ var init_path = __esm({
 function githubAgentAuthDir() {
   const override = process.env.SIDEBOARD_GIT_AUTH_DIR?.trim();
   if (override) return override;
-  return (0, import_node_path14.join)((0, import_node_os4.homedir)(), ".sideboard-git-auth");
+  return (0, import_node_path15.join)((0, import_node_os4.homedir)(), ".sideboard-git-auth");
 }
 function githubCredentialStorePath() {
-  return (0, import_node_path14.join)(githubAgentAuthDir(), "git-credentials");
+  return (0, import_node_path15.join)(githubAgentAuthDir(), "git-credentials");
 }
 function githubGhConfigDir() {
-  return (0, import_node_path14.join)(githubAgentAuthDir(), "gh");
+  return (0, import_node_path15.join)(githubAgentAuthDir(), "gh");
 }
 function writePrivateFile2(file, body) {
-  (0, import_node_fs12.mkdirSync)((0, import_node_path14.dirname)(file), { recursive: true, mode: 448 });
+  (0, import_node_fs13.mkdirSync)((0, import_node_path15.dirname)(file), { recursive: true, mode: 448 });
   try {
-    (0, import_node_fs12.chmodSync)((0, import_node_path14.dirname)(file), 448);
+    (0, import_node_fs13.chmodSync)((0, import_node_path15.dirname)(file), 448);
   } catch {
   }
-  (0, import_node_fs12.writeFileSync)(file, body, { encoding: "utf8", mode: 384 });
+  (0, import_node_fs13.writeFileSync)(file, body, { encoding: "utf8", mode: 384 });
   try {
-    (0, import_node_fs12.chmodSync)(file, 384);
+    (0, import_node_fs13.chmodSync)(file, 384);
   } catch {
   }
 }
@@ -2129,19 +2260,19 @@ function materializeGithubAgentAuth(token, user) {
   const trimmed = token.trim();
   if (!trimmed) return;
   const root = githubAgentAuthDir();
-  (0, import_node_fs12.mkdirSync)(root, { recursive: true, mode: 448 });
+  (0, import_node_fs13.mkdirSync)(root, { recursive: true, mode: 448 });
   try {
-    (0, import_node_fs12.chmodSync)(root, 448);
+    (0, import_node_fs13.chmodSync)(root, 448);
   } catch {
   }
   writePrivateFile2(githubCredentialStorePath(), gitCredentialStoreContents(trimmed));
   const ghDir = githubGhConfigDir();
-  (0, import_node_fs12.mkdirSync)(ghDir, { recursive: true, mode: 448 });
-  writePrivateFile2((0, import_node_path14.join)(ghDir, "hosts.yml"), ghHostsYml(trimmed, user));
-  writePrivateFile2((0, import_node_path14.join)(ghDir, "config.yml"), "git_protocol: https\nprompt: disabled\n");
+  (0, import_node_fs13.mkdirSync)(ghDir, { recursive: true, mode: 448 });
+  writePrivateFile2((0, import_node_path15.join)(ghDir, "hosts.yml"), ghHostsYml(trimmed, user));
+  writePrivateFile2((0, import_node_path15.join)(ghDir, "config.yml"), "git_protocol: https\nprompt: disabled\n");
 }
 function githubAgentAuthReady() {
-  return (0, import_node_fs12.existsSync)(githubCredentialStorePath()) && (0, import_node_fs12.existsSync)((0, import_node_path14.join)(githubGhConfigDir(), "hosts.yml"));
+  return (0, import_node_fs13.existsSync)(githubCredentialStorePath()) && (0, import_node_fs13.existsSync)((0, import_node_path15.join)(githubGhConfigDir(), "hosts.yml"));
 }
 function githubCredentialHelperGitConfig() {
   const file = githubCredentialStorePath();
@@ -2156,13 +2287,13 @@ function githubGhConfigEnv() {
     GH_PROMPT_DISABLED: "1"
   };
 }
-var import_node_fs12, import_node_os4, import_node_path14;
+var import_node_fs13, import_node_os4, import_node_path15;
 var init_github_agent_auth = __esm({
   "src/git/github-agent-auth.ts"() {
     "use strict";
-    import_node_fs12 = require("fs");
+    import_node_fs13 = require("fs");
     import_node_os4 = require("os");
-    import_node_path14 = require("path");
+    import_node_path15 = require("path");
   }
 });
 
@@ -2171,11 +2302,11 @@ function isIndexLockError(text7) {
   return /Unable to create ['"][^'"]*index\.lock['"]: File exists/i.test(text7);
 }
 function clearStaleIndexLock(gitDir, maxAgeMs = STALE_INDEX_LOCK_MS, now = Date.now()) {
-  const lockPath = (0, import_node_path15.join)(gitDir, "index.lock");
+  const lockPath = (0, import_node_path16.join)(gitDir, "index.lock");
   try {
-    if (!(0, import_node_fs13.existsSync)(lockPath)) return null;
-    if (now - (0, import_node_fs13.statSync)(lockPath).mtimeMs < maxAgeMs) return null;
-    (0, import_node_fs13.unlinkSync)(lockPath);
+    if (!(0, import_node_fs14.existsSync)(lockPath)) return null;
+    if (now - (0, import_node_fs14.statSync)(lockPath).mtimeMs < maxAgeMs) return null;
+    (0, import_node_fs14.unlinkSync)(lockPath);
     return lockPath;
   } catch {
     return null;
@@ -2190,12 +2321,12 @@ function clearStaleIndexLocks(gitDirs, maxAgeMs = STALE_INDEX_LOCK_MS) {
   }
   return removed;
 }
-var import_node_fs13, import_node_path15, STALE_INDEX_LOCK_MS;
+var import_node_fs14, import_node_path16, STALE_INDEX_LOCK_MS;
 var init_stale_lock = __esm({
   "src/git/stale-lock.ts"() {
     "use strict";
-    import_node_fs13 = require("fs");
-    import_node_path15 = require("path");
+    import_node_fs14 = require("fs");
+    import_node_path16 = require("path");
     STALE_INDEX_LOCK_MS = 2e4;
   }
 });
@@ -3306,11 +3437,11 @@ async function ensureWorktreeSideboardIgnored(worktreePath) {
   if (gitDir.exitCode !== 0) return;
   const dir = gitDir.stdout.trim();
   if (!dir) return;
-  const excludePath = (0, import_node_path16.join)(dir, "info", "exclude");
-  (0, import_node_fs14.mkdirSync)((0, import_node_path16.dirname)(excludePath), { recursive: true });
+  const excludePath = (0, import_node_path17.join)(dir, "info", "exclude");
+  (0, import_node_fs15.mkdirSync)((0, import_node_path17.dirname)(excludePath), { recursive: true });
   let body = "";
   try {
-    body = (0, import_node_fs14.readFileSync)(excludePath, "utf8");
+    body = (0, import_node_fs15.readFileSync)(excludePath, "utf8");
   } catch {
     body = "";
   }
@@ -3326,7 +3457,7 @@ async function ensureWorktreeSideboardIgnored(worktreePath) {
 ` : body;
     const header = body.includes(EXCLUDE_COMMENT) ? "" : `${EXCLUDE_COMMENT}
 `;
-    (0, import_node_fs14.writeFileSync)(excludePath, `${prefix}${header}${missing.join("\n")}
+    (0, import_node_fs15.writeFileSync)(excludePath, `${prefix}${header}${missing.join("\n")}
 `, "utf8");
   }
   const listed = await git(["ls-files", "-z", "--", ".sideboard"], worktreePath, {
@@ -3341,12 +3472,12 @@ async function ensureWorktreeSideboardIgnored(worktreePath) {
     timeoutMs: 8e3
   });
 }
-var import_node_fs14, import_node_path16, WORKTREE_SIDEBOARD_EXCLUDE, WORKTREE_CONTEXT_EXCLUDE, EXCLUDE_COMMENT;
+var import_node_fs15, import_node_path17, WORKTREE_SIDEBOARD_EXCLUDE, WORKTREE_CONTEXT_EXCLUDE, EXCLUDE_COMMENT;
 var init_worktree_exclude = __esm({
   "src/git/worktree-exclude.ts"() {
     "use strict";
-    import_node_fs14 = require("fs");
-    import_node_path16 = require("path");
+    import_node_fs15 = require("fs");
+    import_node_path17 = require("path");
     init_run();
     WORKTREE_SIDEBOARD_EXCLUDE = ".sideboard/";
     WORKTREE_CONTEXT_EXCLUDE = ".context/";
@@ -3497,7 +3628,7 @@ var init_account_profile = __esm({
 
 // src/store/secret-vault.ts
 function secretVaultPath() {
-  return (0, import_node_path17.join)(appDataDir(), "secrets.json");
+  return (0, import_node_path18.join)(appDataDir(), "secrets.json");
 }
 function loadSecretVault() {
   const parsed = readSecureJson(secretVaultPath());
@@ -3559,11 +3690,11 @@ function normalizeVault(raw) {
   }
   return out;
 }
-var import_node_path17;
+var import_node_path18;
 var init_secret_vault = __esm({
   "src/store/secret-vault.ts"() {
     "use strict";
-    import_node_path17 = require("path");
+    import_node_path18 = require("path");
     init_paths();
     init_secure_file();
   }
@@ -3986,10 +4117,10 @@ function toPublicAppSettings(settings) {
   };
 }
 function appSettingsPath() {
-  return (0, import_node_path18.join)(appDataDir(), "settings.json");
+  return (0, import_node_path19.join)(appDataDir(), "settings.json");
 }
 function claudeUserSettingsPath() {
-  return (0, import_node_path18.join)((0, import_node_os5.homedir)(), ".claude", "settings.json");
+  return (0, import_node_path19.join)((0, import_node_os5.homedir)(), ".claude", "settings.json");
 }
 function normalizeClaude(raw) {
   if (!raw || typeof raw !== "object") return {};
@@ -3997,7 +4128,7 @@ function normalizeClaude(raw) {
   const out = {};
   if (typeof source.executablePath === "string") {
     const path = source.executablePath.trim();
-    if (path && (0, import_node_path18.isAbsolute)(path)) out.executablePath = path;
+    if (path && (0, import_node_path19.isAbsolute)(path)) out.executablePath = path;
   }
   if (typeof source.chromeEnabled === "boolean") {
     out.chromeEnabled = source.chromeEnabled;
@@ -4010,13 +4141,13 @@ function normalizeCliExecutable(raw) {
   const out = {};
   if (typeof source.executablePath === "string") {
     const path = source.executablePath.trim();
-    if (path && (0, import_node_path18.isAbsolute)(path)) out.executablePath = path;
+    if (path && (0, import_node_path19.isAbsolute)(path)) out.executablePath = path;
   }
   return out;
 }
 function absoluteExecutablePath(value) {
   const path = value.trim();
-  if (!(0, import_node_path18.isAbsolute)(path)) {
+  if (!(0, import_node_path19.isAbsolute)(path)) {
     throw new Error("Executable path must be absolute. Leave it empty to use the system CLI.");
   }
   return path;
@@ -4027,7 +4158,7 @@ function normalizeBrightsy(raw) {
   const out = {};
   if (typeof source.executablePath === "string") {
     const path = source.executablePath.trim();
-    if (path && (0, import_node_path18.isAbsolute)(path)) out.executablePath = path;
+    if (path && (0, import_node_path19.isAbsolute)(path)) out.executablePath = path;
   }
   if (typeof source.cloudConnectEnabled === "boolean") {
     out.cloudConnectEnabled = source.cloudConnectEnabled;
@@ -4416,10 +4547,10 @@ function normalizeSettings(raw) {
 }
 function readSettingsFile() {
   const path = appSettingsPath();
-  if (!(0, import_node_fs15.existsSync)(path)) return { ...EMPTY_SETTINGS };
+  if (!(0, import_node_fs16.existsSync)(path)) return { ...EMPTY_SETTINGS };
   try {
     chmodOwnerOnly(path);
-    const parsed = JSON.parse((0, import_node_fs15.readFileSync)(path, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs16.readFileSync)(path, "utf8"));
     return normalizeSettings(parsed);
   } catch {
     return { ...EMPTY_SETTINGS };
@@ -5429,14 +5560,14 @@ function childEnvWithAppSettings(extra) {
 function harnessEnvKey(harness) {
   return HARNESS_ENV_KEYS[harness];
 }
-var import_node_crypto3, import_node_fs15, import_node_os5, import_node_path18, HARNESS_ENV_KEYS, DEFAULT_AGENTS, GITHUB_GIT_AUTH_MODES, FOLLOW_UP_BEHAVIORS, AGENT_DONE_SOUNDS, CLOUD_CONNECT_AGENTS, ISSUE_SOURCES, GIT_AUTH_MODES, EMPTY_SETTINGS, CONFIRM_ACCOUNT, CONFIRM_PROJECT, DEFAULT_CLI_BIN;
+var import_node_crypto3, import_node_fs16, import_node_os5, import_node_path19, HARNESS_ENV_KEYS, DEFAULT_AGENTS, GITHUB_GIT_AUTH_MODES, FOLLOW_UP_BEHAVIORS, AGENT_DONE_SOUNDS, CLOUD_CONNECT_AGENTS, ISSUE_SOURCES, GIT_AUTH_MODES, EMPTY_SETTINGS, CONFIRM_ACCOUNT, CONFIRM_PROJECT, DEFAULT_CLI_BIN;
 var init_app_settings = __esm({
   "src/store/app-settings.ts"() {
     "use strict";
     import_node_crypto3 = require("crypto");
-    import_node_fs15 = require("fs");
+    import_node_fs16 = require("fs");
     import_node_os5 = require("os");
-    import_node_path18 = require("path");
+    import_node_path19 = require("path");
     init_orchestrator_capable();
     init_thinking_effort();
     init_nested_electron_env();
@@ -5618,7 +5749,7 @@ async function warmGithubAgentAuth(opts) {
 }
 function normalizeWritableRoot(raw) {
   const trimmed = raw.trim().replace(/\/+$/, "");
-  return trimmed && (0, import_node_path19.isAbsolute)(trimmed) ? trimmed : null;
+  return trimmed && (0, import_node_path20.isAbsolute)(trimmed) ? trimmed : null;
 }
 async function resolveCodexGitWritableRoots(cwd) {
   const roots = /* @__PURE__ */ new Set();
@@ -5696,11 +5827,11 @@ function formatGitAuthModeDirective(mode) {
       ].join("\n");
   }
 }
-var import_node_path19, HTTPS_REWRITE, TOKEN_TTL_MS, tokenMemo, GITHUB_CHILD_TOKEN_KEYS;
+var import_node_path20, HTTPS_REWRITE, TOKEN_TTL_MS, tokenMemo, GITHUB_CHILD_TOKEN_KEYS;
 var init_git_auth_mode = __esm({
   "src/git/git-auth-mode.ts"() {
     "use strict";
-    import_node_path19 = require("path");
+    import_node_path20 = require("path");
     init_app_settings();
     init_github_agent_auth();
     init_run();
@@ -6532,7 +6663,7 @@ async function resolveRepoRoot(cwd) {
 }
 function canonicalizeRepoPath(path) {
   try {
-    return (0, import_node_fs16.realpathSync)(path);
+    return (0, import_node_fs17.realpathSync)(path);
   } catch {
     return path.replace(/\/+$/, "");
   }
@@ -7393,8 +7524,8 @@ async function refreshOriginAndMaybeFastForwardMain(repoPath, sourceRef) {
 }
 async function createThreadWorktree(opts) {
   let branchName = `thread/${opts.slug}`;
-  const worktreePath = (0, import_node_path20.join)(worktreesRoot(opts.repoPath), opts.slug);
-  if ((0, import_node_fs16.existsSync)(worktreePath)) {
+  const worktreePath = (0, import_node_path21.join)(worktreesRoot(opts.repoPath), opts.slug);
+  if ((0, import_node_fs17.existsSync)(worktreePath)) {
     throw new Error(`Worktree already exists at ${worktreePath}`);
   }
   await ensureGhPreferOrigin(opts.repoPath);
@@ -7435,8 +7566,8 @@ ${add.stdout}`;
 async function createExistingBranchWorktree(opts) {
   const branchName = opts.branchName.trim();
   if (!branchName) throw new Error("branch name required");
-  const worktreePath = (0, import_node_path20.join)(worktreesRoot(opts.repoPath), opts.slug);
-  if ((0, import_node_fs16.existsSync)(worktreePath)) {
+  const worktreePath = (0, import_node_path21.join)(worktreesRoot(opts.repoPath), opts.slug);
+  if ((0, import_node_fs17.existsSync)(worktreePath)) {
     throw new Error(`Worktree already exists at ${worktreePath}`);
   }
   await ensureGhPreferOrigin(opts.repoPath);
@@ -7717,11 +7848,11 @@ async function createOrUpdatePr(worktreePath, opts) {
   const headRef = ghHeadRef(slug, opts.head);
   const branchOnly = opts.head.trim().replace(/^refs\/heads\//, "");
   const bodyText = clampGithubPrBody(opts.body ?? opts.title);
-  const bodyFile = (0, import_node_path20.join)(
+  const bodyFile = (0, import_node_path21.join)(
     (0, import_node_os6.tmpdir)(),
     `sideboard-pr-body-${process.pid}-${(0, import_node_crypto4.randomBytes)(6).toString("hex")}.md`
   );
-  (0, import_node_fs16.writeFileSync)(bodyFile, bodyText.endsWith("\n") ? bodyText : `${bodyText}
+  (0, import_node_fs17.writeFileSync)(bodyFile, bodyText.endsWith("\n") ? bodyText : `${bodyText}
 `, "utf8");
   const bodyArgs = ["--body-file", bodyFile];
   try {
@@ -7735,7 +7866,7 @@ async function createOrUpdatePr(worktreePath, opts) {
     });
   } finally {
     try {
-      (0, import_node_fs16.unlinkSync)(bodyFile);
+      (0, import_node_fs17.unlinkSync)(bodyFile);
     } catch {
     }
   }
@@ -7817,10 +7948,10 @@ function sameRepoPath(a, b) {
   return normalizeWorktreePath(a) === normalizeWorktreePath(b);
 }
 function listLocalThreadBranchSlugs(repoPath) {
-  const refsDir = (0, import_node_path20.join)(repoPath, ".git", "refs", "heads", "thread");
-  if (!(0, import_node_fs16.existsSync)(refsDir)) return [];
+  const refsDir = (0, import_node_path21.join)(repoPath, ".git", "refs", "heads", "thread");
+  if (!(0, import_node_fs17.existsSync)(refsDir)) return [];
   try {
-    return (0, import_node_fs16.readdirSync)(refsDir).filter((name) => !name.startsWith(".")).map((name) => normalizeTakenSlug(name));
+    return (0, import_node_fs17.readdirSync)(refsDir).filter((name) => !name.startsWith(".")).map((name) => normalizeTakenSlug(name));
   } catch {
     return [];
   }
@@ -7828,8 +7959,8 @@ function listLocalThreadBranchSlugs(repoPath) {
 function collectTakenTeamSlugs(repoPath) {
   const taken = /* @__PURE__ */ new Set();
   const root = worktreesRoot(repoPath);
-  if ((0, import_node_fs16.existsSync)(root)) {
-    for (const entry of (0, import_node_fs16.readdirSync)(root, { withFileTypes: true })) {
+  if ((0, import_node_fs17.existsSync)(root)) {
+    for (const entry of (0, import_node_fs17.readdirSync)(root, { withFileTypes: true })) {
       if (entry.isDirectory() && entry.name !== ".DS_Store") {
         for (const slug of takenSlugsFromThread({ worktreePath: entry.name })) {
           taken.add(slug);
@@ -7854,20 +7985,20 @@ function allocateTeamSlug(repoPath) {
   const taken = collectTakenTeamSlugs(repoPath);
   for (let attempt = 0; attempt < 32; attempt++) {
     const team = allocateTeamName(taken);
-    const path = (0, import_node_path20.join)(worktreesRoot(repoPath), team.slug);
-    if (!(0, import_node_fs16.existsSync)(path)) return team;
+    const path = (0, import_node_path21.join)(worktreesRoot(repoPath), team.slug);
+    if (!(0, import_node_fs17.existsSync)(path)) return team;
     taken.add(team.slug);
   }
   throw new Error("No available soccer team worktree directories left");
 }
-var import_node_crypto4, import_node_fs16, import_node_os6, import_node_path20, PR_DETAILS_JSON_FIELDS;
+var import_node_crypto4, import_node_fs17, import_node_os6, import_node_path21, PR_DETAILS_JSON_FIELDS;
 var init_worktree = __esm({
   "src/git/worktree.ts"() {
     "use strict";
     import_node_crypto4 = require("crypto");
-    import_node_fs16 = require("fs");
+    import_node_fs17 = require("fs");
     import_node_os6 = require("os");
-    import_node_path20 = require("path");
+    import_node_path21 = require("path");
     init_paths();
     init_thread_store();
     init_teams();
@@ -7939,7 +8070,7 @@ var init_cloud_connect_constants = __esm({
 
 // src/composer/stage-files.ts
 function fileExtension(filePath) {
-  const base = (0, import_node_path21.basename)(filePath).toLowerCase();
+  const base = (0, import_node_path22.basename)(filePath).toLowerCase();
   return base.includes(".") ? base.split(".").pop() || "" : "";
 }
 function isImageFilePath(filePath) {
@@ -7949,22 +8080,22 @@ function imageMimeType(filePath) {
   return IMAGE_MIME_BY_EXT[fileExtension(filePath)] || "image/png";
 }
 function ensureAttachmentsDir(worktreePath) {
-  const dir = (0, import_node_path21.join)(worktreePath, ATTACHMENTS_DIR);
-  (0, import_node_fs17.mkdirSync)(dir, { recursive: true });
-  const gi = (0, import_node_path21.join)(dir, ".gitignore");
-  if (!(0, import_node_fs17.existsSync)(gi)) {
-    (0, import_node_fs17.writeFileSync)(gi, attachmentsGitignoreBody(), "utf8");
+  const dir = (0, import_node_path22.join)(worktreePath, ATTACHMENTS_DIR);
+  (0, import_node_fs18.mkdirSync)(dir, { recursive: true });
+  const gi = (0, import_node_path22.join)(dir, ".gitignore");
+  if (!(0, import_node_fs18.existsSync)(gi)) {
+    (0, import_node_fs18.writeFileSync)(gi, attachmentsGitignoreBody(), "utf8");
   }
   return dir;
 }
 function uniqueAttachmentName(dir, originalName) {
   const safe = originalName.replace(/[/\\]/g, "_") || "file";
-  if (!(0, import_node_fs17.existsSync)((0, import_node_path21.join)(dir, safe))) return safe;
-  const ext = (0, import_node_path21.extname)(safe);
+  if (!(0, import_node_fs18.existsSync)((0, import_node_path22.join)(dir, safe))) return safe;
+  const ext = (0, import_node_path22.extname)(safe);
   const stem = ext ? safe.slice(0, -ext.length) : safe;
   for (let i = 1; i < 1e4; i++) {
     const candidate = `${stem}-${i}${ext}`;
-    if (!(0, import_node_fs17.existsSync)((0, import_node_path21.join)(dir, candidate))) return candidate;
+    if (!(0, import_node_fs18.existsSync)((0, import_node_path22.join)(dir, candidate))) return candidate;
   }
   return `${stem}-${(0, import_node_crypto5.randomUUID)()}${ext}`;
 }
@@ -8020,15 +8151,15 @@ function stageAbsolutePathsAsAttachments(worktreePath, absolutePaths) {
   const dir = ensureAttachmentsDir(worktreePath);
   const out = [];
   for (const abs of absolutePaths) {
-    const originalName = (0, import_node_path21.basename)(abs);
+    const originalName = (0, import_node_path22.basename)(abs);
     try {
-      const st = (0, import_node_fs17.statSync)(abs);
+      const st = (0, import_node_fs18.statSync)(abs);
       if (!st.isFile()) continue;
       const name = uniqueAttachmentName(dir, originalName);
-      const destAbs = (0, import_node_path21.join)(dir, name);
-      (0, import_node_fs17.copyFileSync)(abs, destAbs);
+      const destAbs = (0, import_node_path22.join)(dir, name);
+      (0, import_node_fs18.copyFileSync)(abs, destAbs);
       const rel = `${ATTACHMENTS_DIR}/${name}`;
-      const buf = (0, import_node_fs17.readFileSync)(destAbs);
+      const buf = (0, import_node_fs18.readFileSync)(destAbs);
       out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
     } catch (err) {
       out.push({
@@ -8050,8 +8181,8 @@ function stageBuffersAsAttachments(worktreePath, buffers2) {
     try {
       const buf = Buffer.from(item.dataBase64, "base64");
       const name = uniqueAttachmentName(dir, originalName);
-      const destAbs = (0, import_node_path21.join)(dir, name);
-      (0, import_node_fs17.writeFileSync)(destAbs, buf);
+      const destAbs = (0, import_node_path22.join)(dir, name);
+      (0, import_node_fs18.writeFileSync)(destAbs, buf);
       const rel = `${ATTACHMENTS_DIR}/${name}`;
       out.push(attachmentFromBuffer(name, buf, { path: rel }));
     } catch (err) {
@@ -8112,18 +8243,18 @@ function attachmentsFromWorktreePaths(worktreePath, relativePaths) {
     if (!rel || rel.includes("..") || rel.startsWith("/")) {
       out.push({
         id: (0, import_node_crypto5.randomUUID)(),
-        name: (0, import_node_path21.basename)(rel) || "file",
+        name: (0, import_node_path22.basename)(rel) || "file",
         kind: "file",
         content: `(invalid path: ${rel})`
       });
       continue;
     }
-    const name = (0, import_node_path21.basename)(rel);
+    const name = (0, import_node_path22.basename)(rel);
     try {
-      const abs = (0, import_node_path21.join)(worktreePath, rel);
-      const st = (0, import_node_fs17.statSync)(abs);
+      const abs = (0, import_node_path22.join)(worktreePath, rel);
+      const st = (0, import_node_fs18.statSync)(abs);
       if (!st.isFile()) continue;
-      const buf = (0, import_node_fs17.readFileSync)(abs);
+      const buf = (0, import_node_fs18.readFileSync)(abs);
       out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
     } catch (err) {
       out.push({
@@ -8136,12 +8267,12 @@ function attachmentsFromWorktreePaths(worktreePath, relativePaths) {
   }
   return out;
 }
-var import_node_fs17, import_node_path21, import_node_crypto5, IMAGE_EXTENSIONS, IMAGE_MIME_BY_EXT, MAX_INLINE_BYTES, MAX_PREVIEW_BYTES, IMAGE_HINT_RE, PLACEHOLDER_CONTENT_RE;
+var import_node_fs18, import_node_path22, import_node_crypto5, IMAGE_EXTENSIONS, IMAGE_MIME_BY_EXT, MAX_INLINE_BYTES, MAX_PREVIEW_BYTES, IMAGE_HINT_RE, PLACEHOLDER_CONTENT_RE;
 var init_stage_files = __esm({
   "src/composer/stage-files.ts"() {
     "use strict";
-    import_node_fs17 = require("fs");
-    import_node_path21 = require("path");
+    import_node_fs18 = require("fs");
+    import_node_path22 = require("path");
     import_node_crypto5 = require("crypto");
     init_workspace_scratch();
     IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
@@ -8182,38 +8313,38 @@ __export(workspaces_exports, {
   syncWorkspacesFromThreads: () => syncWorkspacesFromThreads
 });
 function workspacesFile() {
-  return (0, import_node_path22.join)(appDataDir(), "workspaces.json");
+  return (0, import_node_path23.join)(appDataDir(), "workspaces.json");
 }
 function removedWorkspacesFile() {
-  return (0, import_node_path22.join)(appDataDir(), "removed-workspaces.json");
+  return (0, import_node_path23.join)(appDataDir(), "removed-workspaces.json");
 }
 function readAll() {
   const path = workspacesFile();
-  if (!(0, import_node_fs18.existsSync)(path)) return [];
+  if (!(0, import_node_fs19.existsSync)(path)) return [];
   try {
-    const raw = JSON.parse((0, import_node_fs18.readFileSync)(path, "utf8"));
+    const raw = JSON.parse((0, import_node_fs19.readFileSync)(path, "utf8"));
     return Array.isArray(raw) ? raw : [];
   } catch {
     return [];
   }
 }
 function writeAll(list) {
-  (0, import_node_fs18.mkdirSync)(appDataDir(), { recursive: true });
-  (0, import_node_fs18.writeFileSync)(workspacesFile(), JSON.stringify(list, null, 2), "utf8");
+  (0, import_node_fs19.mkdirSync)(appDataDir(), { recursive: true });
+  (0, import_node_fs19.writeFileSync)(workspacesFile(), JSON.stringify(list, null, 2), "utf8");
 }
 function readRemoved() {
   const path = removedWorkspacesFile();
-  if (!(0, import_node_fs18.existsSync)(path)) return /* @__PURE__ */ new Set();
+  if (!(0, import_node_fs19.existsSync)(path)) return /* @__PURE__ */ new Set();
   try {
-    const raw = JSON.parse((0, import_node_fs18.readFileSync)(path, "utf8"));
+    const raw = JSON.parse((0, import_node_fs19.readFileSync)(path, "utf8"));
     return new Set(Array.isArray(raw) ? raw.filter((p) => typeof p === "string") : []);
   } catch {
     return /* @__PURE__ */ new Set();
   }
 }
 function writeRemoved(paths) {
-  (0, import_node_fs18.mkdirSync)(appDataDir(), { recursive: true });
-  (0, import_node_fs18.writeFileSync)(removedWorkspacesFile(), JSON.stringify([...paths].sort(), null, 2), "utf8");
+  (0, import_node_fs19.mkdirSync)(appDataDir(), { recursive: true });
+  (0, import_node_fs19.writeFileSync)(removedWorkspacesFile(), JSON.stringify([...paths].sort(), null, 2), "utf8");
 }
 function rememberRemoved(repoPath) {
   const next = readRemoved();
@@ -8235,10 +8366,10 @@ function listWorkspaces() {
 }
 function isLinkedWorktreeOf(path, mainRepo) {
   if (!path || path === mainRepo) return false;
-  const git2 = (0, import_node_path22.join)(path, ".git");
+  const git2 = (0, import_node_path23.join)(path, ".git");
   try {
-    if (!(0, import_node_fs18.existsSync)(git2) || (0, import_node_fs18.statSync)(git2).isDirectory()) return false;
-    const text7 = (0, import_node_fs18.readFileSync)(git2, "utf8");
+    if (!(0, import_node_fs19.existsSync)(git2) || (0, import_node_fs19.statSync)(git2).isDirectory()) return false;
+    const text7 = (0, import_node_fs19.readFileSync)(git2, "utf8");
     const needle = `${mainRepo.replace(/\/+$/, "")}/.git`;
     return text7.includes(needle);
   } catch {
@@ -8247,10 +8378,10 @@ function isLinkedWorktreeOf(path, mainRepo) {
 }
 function primaryCheckoutFromLinkedWorktree(path) {
   if (!path) return null;
-  const git2 = (0, import_node_path22.join)(path, ".git");
+  const git2 = (0, import_node_path23.join)(path, ".git");
   try {
-    if (!(0, import_node_fs18.existsSync)(git2) || (0, import_node_fs18.statSync)(git2).isDirectory()) return null;
-    const text7 = (0, import_node_fs18.readFileSync)(git2, "utf8");
+    if (!(0, import_node_fs19.existsSync)(git2) || (0, import_node_fs19.statSync)(git2).isDirectory()) return null;
+    const text7 = (0, import_node_fs19.readFileSync)(git2, "utf8");
     const match = /^\s*gitdir:\s*(.+)$/m.exec(text7);
     if (!match) return null;
     const gitdir = match[1].trim().replace(/\/+$/, "");
@@ -8271,7 +8402,7 @@ function resolveSyncWorkspacePath(path) {
 async function addWorkspace(repoPath) {
   const root = await resolveRepoRoot(repoPath);
   if (!root || root === "/") throw new Error(`Invalid repo path: ${repoPath}`);
-  if (!(0, import_node_fs18.existsSync)(root)) throw new Error(`Repo not found: ${root}`);
+  if (!(0, import_node_fs19.existsSync)(root)) throw new Error(`Repo not found: ${root}`);
   forgetRemoved(root);
   await ensureGhPreferOrigin(root);
   const current = readAll();
@@ -8280,7 +8411,7 @@ async function addWorkspace(repoPath) {
   if (existing && withoutLinked.length === current.length) return existing;
   const next = existing ?? {
     path: root,
-    name: (0, import_node_path22.basename)(root),
+    name: (0, import_node_path23.basename)(root),
     addedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   writeAll(existing ? withoutLinked : [...withoutLinked, next]);
@@ -8308,7 +8439,7 @@ function syncWorkspacesFromThreads(repoPaths) {
     if (!byPath.has(resolved)) {
       byPath.set(
         resolved,
-        resolved === w.path ? w : { ...w, path: resolved, name: (0, import_node_path22.basename)(resolved) }
+        resolved === w.path ? w : { ...w, path: resolved, name: (0, import_node_path23.basename)(resolved) }
       );
     }
   }
@@ -8317,10 +8448,10 @@ function syncWorkspacesFromThreads(repoPaths) {
     if (!path || path === "/" || isGlobalRepoPath(path) || byPath.has(path) || removed.has(path)) {
       continue;
     }
-    if (!(0, import_node_fs18.existsSync)(path)) continue;
+    if (!(0, import_node_fs19.existsSync)(path)) continue;
     const ws = {
       path,
-      name: (0, import_node_path22.basename)(path),
+      name: (0, import_node_path23.basename)(path),
       addedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     byPath.set(path, ws);
@@ -8337,12 +8468,12 @@ function syncWorkspacesFromThreads(repoPaths) {
   if (dirty) writeAll(next);
   return next.sort((a, b) => a.name.localeCompare(b.name));
 }
-var import_node_fs18, import_node_path22;
+var import_node_fs19, import_node_path23;
 var init_workspaces2 = __esm({
   "src/store/workspaces.ts"() {
     "use strict";
-    import_node_fs18 = require("fs");
-    import_node_path22 = require("path");
+    import_node_fs19 = require("fs");
+    import_node_path23 = require("path");
     init_paths();
     init_global_workspace();
     init_worktree();
@@ -8453,7 +8584,7 @@ function coordinatorTurnReminder(opts) {
 function ensureGlobalCoordinatorCwd(opts) {
   const dir = globalAgentCwd();
   try {
-    (0, import_node_fs19.mkdirSync)(dir, { recursive: true });
+    (0, import_node_fs20.mkdirSync)(dir, { recursive: true });
   } catch {
     return dir;
   }
@@ -8461,7 +8592,7 @@ function ensureGlobalCoordinatorCwd(opts) {
   let orchId = opts?.orchestratorThreadId?.trim() || "";
   if (!orchId) {
     try {
-      const existing = (0, import_node_fs19.readFileSync)((0, import_node_path23.join)(dir, "AGENTS.md"), "utf8");
+      const existing = (0, import_node_fs20.readFileSync)((0, import_node_path24.join)(dir, "AGENTS.md"), "utf8");
       const m = existing.match(
         /YOUR orchestration thread id is `([0-9a-f-]{36})`/i
       );
@@ -8506,9 +8637,9 @@ function ensureGlobalCoordinatorCwd(opts) {
     "Always ask worktree agents to commit, push, and open draft PRs (`ask_git` / `send_to_thread`). If the user gave a goal (Greptile 5/5, CI green), pass that goal through so they watch-fix-push until it lands \u2014 do not start that loop on a plain push, and do not tell the human to poll. Tell them to merge only when the user explicitly asked. The worktree agent runs git/gh; never merge from this orchestration cwd."
   ].join("\n");
   try {
-    (0, import_node_fs19.writeFileSync)((0, import_node_path23.join)(dir, "CLAUDE.md"), `${body}
+    (0, import_node_fs20.writeFileSync)((0, import_node_path24.join)(dir, "CLAUDE.md"), `${body}
 `, "utf8");
-    (0, import_node_fs19.writeFileSync)((0, import_node_path23.join)(dir, "AGENTS.md"), `${body}
+    (0, import_node_fs20.writeFileSync)((0, import_node_path24.join)(dir, "AGENTS.md"), `${body}
 `, "utf8");
   } catch {
   }
@@ -8540,12 +8671,12 @@ function coordinatorSystemPrompt(opts) {
     formatWorkspaceInventory(opts.workspaces)
   ].join("\n");
 }
-var import_node_fs19, import_node_path23, COORDINATOR_TOOL_PLAYBOOK, SLACK_REPLY_FORMATTING;
+var import_node_fs20, import_node_path24, COORDINATOR_TOOL_PLAYBOOK, SLACK_REPLY_FORMATTING;
 var init_coordinator_prompt = __esm({
   "src/orchestrator/coordinator-prompt.ts"() {
     "use strict";
-    import_node_fs19 = require("fs");
-    import_node_path23 = require("path");
+    import_node_fs20 = require("fs");
+    import_node_path24 = require("path");
     init_worktree();
     init_app_settings();
     init_paths();
@@ -8585,7 +8716,7 @@ var init_coordinator_prompt = __esm({
       "- archive_thread / restore_thread \u2014 archive (tears down worktree when last tab) or restore",
       "Setup / run:",
       "- run_setup \u2014 re-run worktree setup (already runs automatically on create when a script exists)",
-      "- list_run_scripts / run_dev_script / stop_dev_script \u2014 start/stop named run scripts",
+      "- list_run_scripts / run_dev_script / stop_dev_script \u2014 start/stop named run scripts. run_dev_script returns {url, port, preview} (SIDEBOARD_PORT). preview=url \u2192 tell the worktree agent to open that URL; preview=window \u2192 Electron: the native window is the app (url is renderer/HMR only). Never localhost:3000. list_run_scripts active[].url if already running.",
       "Inspect / review / PRs:",
       "- get_diff \u2014 compact diff summary",
       "- get_pr_checks \u2014 snapshot of a worktree thread's PR checks (null = no PR). Use this to inspect status. If the user gave a goal, the worktree agent watches with `gh pr checks --watch` \u2014 do not poll for the human.",
@@ -8862,7 +8993,7 @@ function traceTurn(phase, extra) {
   try {
     const line = `${JSON.stringify({ t: (/* @__PURE__ */ new Date()).toISOString(), phase, ...extra })}
 `;
-    (0, import_node_fs20.appendFileSync)((0, import_node_path24.join)(appDataDir(), "turn-spawn.log"), line);
+    (0, import_node_fs21.appendFileSync)((0, import_node_path25.join)(appDataDir(), "turn-spawn.log"), line);
   } catch {
   }
 }
@@ -8882,12 +9013,12 @@ async function withTimeout(promise, ms, label) {
     if (timer) clearTimeout(timer);
   }
 }
-var import_node_fs20, import_node_path24;
+var import_node_fs21, import_node_path25;
 var init_turn_trace = __esm({
   "src/agents/turn-trace.ts"() {
     "use strict";
-    import_node_fs20 = require("fs");
-    import_node_path24 = require("path");
+    import_node_fs21 = require("fs");
+    import_node_path25 = require("path");
     init_paths();
   }
 });
@@ -8896,32 +9027,32 @@ var init_turn_trace = __esm({
 function brightsyConfigPath() {
   const override = process.env.BRIGHTSY_CONFIG?.trim();
   if (override) return override;
-  return (0, import_node_path25.join)((0, import_node_os7.homedir)(), ".brightsy", "config.json");
+  return (0, import_node_path26.join)((0, import_node_os7.homedir)(), ".brightsy", "config.json");
 }
 function loadBrightsyConfig() {
   const path = brightsyConfigPath();
-  if (!(0, import_node_fs21.existsSync)(path)) {
+  if (!(0, import_node_fs22.existsSync)(path)) {
     throw new Error("Brightsy not logged in \u2014 run `brightsy login` first");
   }
-  const raw = JSON.parse((0, import_node_fs21.readFileSync)(path, "utf8"));
+  const raw = JSON.parse((0, import_node_fs22.readFileSync)(path, "utf8"));
   if (!raw.access_token || !raw.account_id) {
     throw new Error("Brightsy config incomplete \u2014 run `brightsy login`");
   }
   return raw;
 }
 function saveBrightsyConfig(cfg) {
-  (0, import_node_fs21.writeFileSync)(brightsyConfigPath(), `${JSON.stringify(cfg, null, 2)}
+  (0, import_node_fs22.writeFileSync)(brightsyConfigPath(), `${JSON.stringify(cfg, null, 2)}
 `, {
     mode: 384
   });
 }
-var import_node_fs21, import_node_os7, import_node_path25;
+var import_node_fs22, import_node_os7, import_node_path26;
 var init_config = __esm({
   "src/brightsy/config.ts"() {
     "use strict";
-    import_node_fs21 = require("fs");
+    import_node_fs22 = require("fs");
     import_node_os7 = require("os");
-    import_node_path25 = require("path");
+    import_node_path26 = require("path");
   }
 });
 
@@ -9117,22 +9248,22 @@ var init_oauth = __esm({
 
 // src/brightsy/connected-teams.ts
 function storePath4() {
-  return (0, import_node_path26.join)(appDataDir(), "brightsy-teams.json");
+  return (0, import_node_path27.join)(appDataDir(), "brightsy-teams.json");
 }
 function readStore4() {
   const path = storePath4();
-  if (!(0, import_node_fs22.existsSync)(path)) return [];
+  if (!(0, import_node_fs23.existsSync)(path)) return [];
   try {
-    const parsed = JSON.parse((0, import_node_fs22.readFileSync)(path, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs23.readFileSync)(path, "utf8"));
     return Array.isArray(parsed.teams) ? parsed.teams : [];
   } catch {
     return [];
   }
 }
 function writeStore2(teams) {
-  (0, import_node_fs22.mkdirSync)(appDataDir(), { recursive: true });
+  (0, import_node_fs23.mkdirSync)(appDataDir(), { recursive: true });
   const path = storePath4();
-  (0, import_node_fs22.writeFileSync)(path, `${JSON.stringify({ teams }, null, 2)}
+  (0, import_node_fs23.writeFileSync)(path, `${JSON.stringify({ teams }, null, 2)}
 `, {
     mode: 384
   });
@@ -9269,12 +9400,12 @@ function brightsyMcpServerName(slug) {
   const cleaned = slug.replace(/[^A-Za-z0-9_-]/g, "_").replace(/^_+|_+$/g, "");
   return `brightsy_${cleaned || "team"}`;
 }
-var import_node_fs22, import_node_path26;
+var import_node_fs23, import_node_path27;
 var init_connected_teams = __esm({
   "src/brightsy/connected-teams.ts"() {
     "use strict";
-    import_node_fs22 = require("fs");
-    import_node_path26 = require("path");
+    import_node_fs23 = require("fs");
+    import_node_path27 = require("path");
     init_paths();
     init_accounts();
     init_config();
@@ -9595,11 +9726,11 @@ async function syncCliForTarget(accountId) {
   }
   applyConnectedTeamToCli(team);
 }
-var import_node_fs23, brightsyAdapter;
+var import_node_fs24, brightsyAdapter;
 var init_brightsy = __esm({
   "src/agents/brightsy.ts"() {
     "use strict";
-    import_node_fs23 = require("fs");
+    import_node_fs24 = require("fs");
     init_run();
     init_connected_teams();
     init_config();
@@ -9614,7 +9745,7 @@ var init_brightsy = __esm({
       async detect() {
         const brightsy = resolveAgentExecutable("brightsy");
         if (brightsy !== "brightsy") {
-          if (!(0, import_node_fs23.existsSync)(brightsy)) {
+          if (!(0, import_node_fs24.existsSync)(brightsy)) {
             return {
               agent: "brightsy",
               installed: false,
@@ -9736,43 +9867,43 @@ function electronResourcesPath() {
 function packagedCursorRuntimeDir() {
   const resources = electronResourcesPath();
   if (!resources) return null;
-  const dir = (0, import_node_path27.join)(resources, "cursor-runtime");
-  if (!(0, import_node_fs24.existsSync)((0, import_node_path27.join)(dir, "core-dist", "agents", "cursor-runner.js"))) return null;
+  const dir = (0, import_node_path28.join)(resources, "cursor-runtime");
+  if (!(0, import_node_fs25.existsSync)((0, import_node_path28.join)(dir, "core-dist", "agents", "cursor-runner.js"))) return null;
   return dir;
 }
 function packagedCursorRunnerPath() {
   const dir = packagedCursorRuntimeDir();
-  return dir ? (0, import_node_path27.join)(dir, "core-dist", "agents", "cursor-runner.js") : null;
+  return dir ? (0, import_node_path28.join)(dir, "core-dist", "agents", "cursor-runner.js") : null;
 }
 function packagedMcpDir() {
   const resources = electronResourcesPath();
   if (!resources) return null;
-  const dir = (0, import_node_path27.join)(resources, "sideboard-mcp");
-  if (!(0, import_node_fs24.existsSync)((0, import_node_path27.join)(dir, "core-dist", "mcp", "run-stdio.js"))) return null;
+  const dir = (0, import_node_path28.join)(resources, "sideboard-mcp");
+  if (!(0, import_node_fs25.existsSync)((0, import_node_path28.join)(dir, "core-dist", "mcp", "run-stdio.js"))) return null;
   return dir;
 }
 function packagedMcpStdioPath() {
   const dir = packagedMcpDir();
-  return dir ? (0, import_node_path27.join)(dir, "core-dist", "mcp", "run-stdio.js") : null;
+  return dir ? (0, import_node_path28.join)(dir, "core-dist", "mcp", "run-stdio.js") : null;
 }
 function packagedBundledNodePath() {
   const resources = electronResourcesPath();
   if (!resources) return null;
-  const bin = (0, import_node_path27.join)(resources, "node", "bin", "node");
-  if (!(0, import_node_fs24.existsSync)(bin)) return null;
+  const bin = (0, import_node_path28.join)(resources, "node", "bin", "node");
+  if (!(0, import_node_fs25.existsSync)(bin)) return null;
   return bin;
 }
 function packagedCursorRipgrepCandidate(platformPkg, binName) {
   const dir = packagedCursorRuntimeDir();
   if (!dir) return null;
-  return (0, import_node_path27.join)(dir, "node_modules", platformPkg, "bin", binName);
+  return (0, import_node_path28.join)(dir, "node_modules", platformPkg, "bin", binName);
 }
-var import_node_fs24, import_node_path27;
+var import_node_fs25, import_node_path28;
 var init_packaged_runtime = __esm({
   "src/agents/packaged-runtime.ts"() {
     "use strict";
-    import_node_fs24 = require("fs");
-    import_node_path27 = require("path");
+    import_node_fs25 = require("fs");
+    import_node_path28 = require("path");
   }
 });
 
@@ -9807,7 +9938,7 @@ function unpackedAsarPath(filePath) {
   if (!isAsarPath(filePath)) return null;
   const unpacked = filePath.replace(/\.asar(?=[/\\])/, ".asar.unpacked");
   if (unpacked === filePath) return null;
-  return (0, import_node_fs25.existsSync)(unpacked) ? unpacked : null;
+  return (0, import_node_fs26.existsSync)(unpacked) ? unpacked : null;
 }
 function nodeReadableScriptPath(scriptPath) {
   return unpackedAsarPath(scriptPath) ?? scriptPath;
@@ -9847,37 +9978,37 @@ function pickPreferredNode(candidates) {
   return best;
 }
 function versionDirNodeBins(root, toBin) {
-  if (!(0, import_node_fs25.existsSync)(root)) return [];
+  if (!(0, import_node_fs26.existsSync)(root)) return [];
   try {
-    return (0, import_node_fs25.readdirSync)(root).map(toBin);
+    return (0, import_node_fs26.readdirSync)(root).map(toBin);
   } catch {
     return [];
   }
 }
 function defaultNodeBinCandidates(home = (0, import_node_os8.homedir)()) {
   const kegs = ["/opt/homebrew", "/usr/local"].flatMap(
-    (prefix) => PREFERRED_LTS_MAJORS.map((major) => (0, import_node_path28.join)(prefix, "opt", `node@${major}`, "bin", "node"))
+    (prefix) => PREFERRED_LTS_MAJORS.map((major) => (0, import_node_path29.join)(prefix, "opt", `node@${major}`, "bin", "node"))
   );
   return [
     ...kegs,
     "/opt/homebrew/bin/node",
     "/usr/local/bin/node",
-    (0, import_node_path28.join)(home, ".local/share/fnm/aliases/default/bin/node"),
-    (0, import_node_path28.join)(home, ".nvm/current/bin/node"),
-    (0, import_node_path28.join)(home, ".volta/bin/node"),
-    (0, import_node_path28.join)(home, ".asdf/shims/node"),
-    (0, import_node_path28.join)(home, ".local/share/mise/shims/node"),
+    (0, import_node_path29.join)(home, ".local/share/fnm/aliases/default/bin/node"),
+    (0, import_node_path29.join)(home, ".nvm/current/bin/node"),
+    (0, import_node_path29.join)(home, ".volta/bin/node"),
+    (0, import_node_path29.join)(home, ".asdf/shims/node"),
+    (0, import_node_path29.join)(home, ".local/share/mise/shims/node"),
     ...versionDirNodeBins(
-      (0, import_node_path28.join)(home, ".nvm", "versions", "node"),
-      (name) => (0, import_node_path28.join)(home, ".nvm", "versions", "node", name, "bin", "node")
+      (0, import_node_path29.join)(home, ".nvm", "versions", "node"),
+      (name) => (0, import_node_path29.join)(home, ".nvm", "versions", "node", name, "bin", "node")
     ),
     ...versionDirNodeBins(
-      (0, import_node_path28.join)(home, ".local/share/fnm", "node-versions"),
-      (name) => (0, import_node_path28.join)(home, ".local/share/fnm", "node-versions", name, "installation", "bin", "node")
+      (0, import_node_path29.join)(home, ".local/share/fnm", "node-versions"),
+      (name) => (0, import_node_path29.join)(home, ".local/share/fnm", "node-versions", name, "installation", "bin", "node")
     ),
     ...versionDirNodeBins(
-      (0, import_node_path28.join)(home, ".volta", "tools", "image", "node"),
-      (name) => (0, import_node_path28.join)(home, ".volta", "tools", "image", "node", name, "bin", "node")
+      (0, import_node_path29.join)(home, ".volta", "tools", "image", "node"),
+      (name) => (0, import_node_path29.join)(home, ".volta", "tools", "image", "node", name, "bin", "node")
     )
   ];
 }
@@ -9886,10 +10017,10 @@ function uniqueExistingNodeBins(paths) {
   const out = [];
   for (const raw of paths) {
     const p = raw.trim();
-    if (!p || !(0, import_node_fs25.existsSync)(p) || isElectronLikeCommand(p)) continue;
+    if (!p || !(0, import_node_fs26.existsSync)(p) || isElectronLikeCommand(p)) continue;
     let key = p;
     try {
-      key = (0, import_node_fs25.realpathSync)(p);
+      key = (0, import_node_fs26.realpathSync)(p);
     } catch {
       continue;
     }
@@ -9969,13 +10100,13 @@ async function resolveNodeLaunch(scriptPath) {
     env: { ELECTRON_RUN_AS_NODE: "1" }
   };
 }
-var import_node_fs25, import_node_os8, import_node_path28, AGENT_RUNNER_MAX_OLD_SPACE_MB, MAX_OLD_SPACE_FLAG, PREFERRED_LTS_MAJORS;
+var import_node_fs26, import_node_os8, import_node_path29, AGENT_RUNNER_MAX_OLD_SPACE_MB, MAX_OLD_SPACE_FLAG, PREFERRED_LTS_MAJORS;
 var init_node_launch = __esm({
   "src/agents/node-launch.ts"() {
     "use strict";
-    import_node_fs25 = require("fs");
+    import_node_fs26 = require("fs");
     import_node_os8 = require("os");
-    import_node_path28 = require("path");
+    import_node_path29 = require("path");
     init_nested_electron_env();
     init_system_ca();
     init_run();
@@ -10078,37 +10209,37 @@ function corePackageDir() {
   try {
     const url = import_meta.url;
     if (typeof url === "string" && url.length > 0) {
-      return (0, import_node_path29.dirname)((0, import_node_url.fileURLToPath)(url));
+      return (0, import_node_path30.dirname)((0, import_node_url.fileURLToPath)(url));
     }
   } catch {
   }
   try {
-    const req = (0, import_node_module.createRequire)((0, import_node_path29.join)(process.cwd(), "package.json"));
-    return (0, import_node_path29.dirname)(req.resolve("@sideboard-ai/core"));
+    const req = (0, import_node_module.createRequire)((0, import_node_path30.join)(process.cwd(), "package.json"));
+    return (0, import_node_path30.dirname)(req.resolve("@sideboard-ai/core"));
   } catch {
     return process.cwd();
   }
 }
 function findSideboardMcpJsEntry() {
   const override = process.env.SIDEBOARD_MCP_ENTRY?.trim() || process.env.SIDEBOARD_CLI?.trim();
-  if (override && (0, import_node_fs26.existsSync)(override)) return override;
+  if (override && (0, import_node_fs27.existsSync)(override)) return override;
   const packaged = packagedMcpStdioPath();
   if (packaged) return packaged;
   let dir = corePackageDir();
   for (let i = 0; i < 10; i++) {
     const candidates = [
-      (0, import_node_path29.join)(dir, "mcp/run-stdio.js"),
-      (0, import_node_path29.join)(dir, "mcp/run-stdio.cjs"),
-      (0, import_node_path29.join)(dir, "dist/mcp/run-stdio.js"),
-      (0, import_node_path29.join)(dir, "dist/mcp/run-stdio.cjs"),
-      (0, import_node_path29.join)(dir, "packages/core/dist/mcp/run-stdio.js"),
-      (0, import_node_path29.join)(dir, "packages/cli/dist/index.js"),
-      (0, import_node_path29.join)(dir, "cli/dist/index.js")
+      (0, import_node_path30.join)(dir, "mcp/run-stdio.js"),
+      (0, import_node_path30.join)(dir, "mcp/run-stdio.cjs"),
+      (0, import_node_path30.join)(dir, "dist/mcp/run-stdio.js"),
+      (0, import_node_path30.join)(dir, "dist/mcp/run-stdio.cjs"),
+      (0, import_node_path30.join)(dir, "packages/core/dist/mcp/run-stdio.js"),
+      (0, import_node_path30.join)(dir, "packages/cli/dist/index.js"),
+      (0, import_node_path30.join)(dir, "cli/dist/index.js")
     ];
     for (const p of candidates) {
-      if ((0, import_node_fs26.existsSync)(p) && !isAsarPath(p)) return p;
+      if ((0, import_node_fs27.existsSync)(p) && !isAsarPath(p)) return p;
     }
-    const parent = (0, import_node_path29.dirname)(dir);
+    const parent = (0, import_node_path30.dirname)(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -10271,19 +10402,19 @@ function writeMcpServersConfig(servers, extraServers) {
     }
   }
   if (Object.keys(mcpServers).length === 0) return null;
-  const dir = (0, import_node_fs26.mkdtempSync)((0, import_node_path29.join)((0, import_node_os9.tmpdir)(), "sideboard-mcp-"));
-  const cfgPath = (0, import_node_path29.join)(dir, "mcp.json");
-  (0, import_node_fs26.writeFileSync)(cfgPath, JSON.stringify({ mcpServers }, null, 2));
+  const dir = (0, import_node_fs27.mkdtempSync)((0, import_node_path30.join)((0, import_node_os9.tmpdir)(), "sideboard-mcp-"));
+  const cfgPath = (0, import_node_path30.join)(dir, "mcp.json");
+  (0, import_node_fs27.writeFileSync)(cfgPath, JSON.stringify({ mcpServers }, null, 2));
   return cfgPath;
 }
-var import_node_fs26, import_node_module, import_node_os9, import_node_path29, import_node_url, import_meta, SIDEBOARD_MCP_ALLOWED_TOOLS, SIDEBOARD_ARTIFACT_MCP_ALLOWED_TOOLS, SIDEBOARD_GITHUB_MCP_ALLOWED_TOOLS, SIDEBOARD_LINEAR_MCP_ALLOWED_TOOLS, SIDEBOARD_ABLETIME_MCP_ALLOWED_TOOLS, brightsyMcpCommandCache, BRIGHTSY_WORD;
+var import_node_fs27, import_node_module, import_node_os9, import_node_path30, import_node_url, import_meta, SIDEBOARD_MCP_ALLOWED_TOOLS, SIDEBOARD_ARTIFACT_MCP_ALLOWED_TOOLS, SIDEBOARD_GITHUB_MCP_ALLOWED_TOOLS, SIDEBOARD_LINEAR_MCP_ALLOWED_TOOLS, SIDEBOARD_ABLETIME_MCP_ALLOWED_TOOLS, brightsyMcpCommandCache, BRIGHTSY_WORD;
 var init_injected_mcp = __esm({
   "src/agents/injected-mcp.ts"() {
     "use strict";
-    import_node_fs26 = require("fs");
+    import_node_fs27 = require("fs");
     import_node_module = require("module");
     import_node_os9 = require("os");
-    import_node_path29 = require("path");
+    import_node_path30 = require("path");
     import_node_url = require("url");
     init_run();
     init_config();
@@ -10324,15 +10455,15 @@ var init_injected_mcp = __esm({
 
 // src/agents/user-mcp-config.ts
 function userClaudeMcpConfigPath() {
-  return (0, import_node_path30.join)((0, import_node_os10.homedir)(), ".claude.json");
+  return (0, import_node_path31.join)((0, import_node_os10.homedir)(), ".claude.json");
 }
-var import_node_fs27, import_node_os10, import_node_path30;
+var import_node_fs28, import_node_os10, import_node_path31;
 var init_user_mcp_config = __esm({
   "src/agents/user-mcp-config.ts"() {
     "use strict";
-    import_node_fs27 = require("fs");
+    import_node_fs28 = require("fs");
     import_node_os10 = require("os");
-    import_node_path30 = require("path");
+    import_node_path31 = require("path");
     init_paths();
     init_injected_mcp();
   }
@@ -10358,27 +10489,27 @@ function listMcpNamesFromCodexToml(text7) {
     return [];
   }
 }
-function readJsonObject(path) {
+function readJsonObject2(path) {
   try {
-    return JSON.parse((0, import_node_fs28.readFileSync)(path, "utf8"));
+    return JSON.parse((0, import_node_fs29.readFileSync)(path, "utf8"));
   } catch {
     return {};
   }
 }
 function readText(path) {
   try {
-    return (0, import_node_fs28.readFileSync)(path, "utf8");
+    return (0, import_node_fs29.readFileSync)(path, "utf8");
   } catch {
     return "";
   }
 }
 function userCodexConfigPaths(home = (0, import_node_os11.homedir)()) {
-  return [(0, import_node_path31.join)(home, ".codex", "config.toml"), (0, import_node_path31.join)(home, ".config", "codex", "config.toml")];
+  return [(0, import_node_path32.join)(home, ".codex", "config.toml"), (0, import_node_path32.join)(home, ".config", "codex", "config.toml")];
 }
 function userOpencodeConfigPaths(home = (0, import_node_os11.homedir)()) {
   return [
-    (0, import_node_path31.join)(home, ".config", "opencode", "opencode.json"),
-    (0, import_node_path31.join)(home, ".config", "opencode", "opencode.jsonc")
+    (0, import_node_path32.join)(home, ".config", "opencode", "opencode.json"),
+    (0, import_node_path32.join)(home, ".config", "opencode", "opencode.jsonc")
   ];
 }
 function userMcpNamesToDisable(opts) {
@@ -10400,7 +10531,7 @@ function userMcpNamesToDisable(opts) {
 function listUserCodexMcpNames(home = (0, import_node_os11.homedir)()) {
   const names = [];
   for (const path of userCodexConfigPaths(home)) {
-    if (!(0, import_node_fs28.existsSync)(path)) continue;
+    if (!(0, import_node_fs29.existsSync)(path)) continue;
     names.push(...listMcpNamesFromCodexToml(readText(path)));
   }
   return names;
@@ -10408,15 +10539,15 @@ function listUserCodexMcpNames(home = (0, import_node_os11.homedir)()) {
 function listUserOpencodeMcpNames(home = (0, import_node_os11.homedir)()) {
   const names = [];
   for (const path of userOpencodeConfigPaths(home)) {
-    if (!(0, import_node_fs28.existsSync)(path)) continue;
-    names.push(...listMcpNamesFromJsonMap(readJsonObject(path), "mcp"));
+    if (!(0, import_node_fs29.existsSync)(path)) continue;
+    names.push(...listMcpNamesFromJsonMap(readJsonObject2(path), "mcp"));
   }
   return names;
 }
 function userClaudeMcpConfigObject(home = (0, import_node_os11.homedir)()) {
-  const claudePath = home === (0, import_node_os11.homedir)() ? userClaudeMcpConfigPath() : (0, import_node_path31.join)(home, ".claude.json");
-  if (!(0, import_node_fs28.existsSync)(claudePath)) return {};
-  return asObject(asObject(readJsonObject(claudePath)).mcpServers);
+  const claudePath = home === (0, import_node_os11.homedir)() ? userClaudeMcpConfigPath() : (0, import_node_path32.join)(home, ".claude.json");
+  if (!(0, import_node_fs29.existsSync)(claudePath)) return {};
+  return asObject(asObject(readJsonObject2(claudePath)).mcpServers);
 }
 function listUserClaudeMcpServerEntries(home = (0, import_node_os11.homedir)()) {
   const out = {};
@@ -10448,13 +10579,13 @@ function toCodexUnattendedAppsArgs() {
     "features.plugins=false"
   ];
 }
-var import_node_fs28, import_node_os11, import_node_path31, import_smol_toml2;
+var import_node_fs29, import_node_os11, import_node_path32, import_smol_toml2;
 var init_orch_mcp_isolation = __esm({
   "src/agents/orch-mcp-isolation.ts"() {
     "use strict";
-    import_node_fs28 = require("fs");
+    import_node_fs29 = require("fs");
     import_node_os11 = require("os");
-    import_node_path31 = require("path");
+    import_node_path32 = require("path");
     import_smol_toml2 = require("smol-toml");
     init_user_mcp_config();
   }
@@ -10475,7 +10606,76 @@ function clipChatLine(value, max = CHAT_DETAIL_MAX) {
   if (line.length <= max) return line;
   return `${line.slice(0, Math.max(1, max - 1))}\u2026`;
 }
+function isSkillToolName(name) {
+  const n = (name ?? "").trim();
+  if (/^(Skill|SlashCommand)$/i.test(n)) return true;
+  return /(?:^|__)Skill$/i.test(n);
+}
+function skillCommandFromInput(input) {
+  const raw = str2(input?.skill) ?? str2(input?.command) ?? str2(input?.name) ?? str2(input?.skill_name) ?? str2(input?.skillName);
+  if (raw) return raw.replace(/^\//, "").trim() || void 0;
+  const path = str2(input?.file_path) ?? str2(input?.path);
+  if (path && /SKILL\.md$/i.test(path)) {
+    const parts = path.replace(/\\/g, "/").split("/");
+    const dir = parts[parts.length - 2];
+    if (dir && dir !== "skills") return dir;
+  }
+  return void 0;
+}
+function looksLikeSkillBody(text7) {
+  const t = text7.trim();
+  if (!t) return false;
+  if (/^## Skill: \//m.test(t) && /Follow this skill for the request above:/i.test(t)) {
+    return true;
+  }
+  return skillNameFromFrontmatter(t) != null;
+}
+function skillNameFromFrontmatter(text7) {
+  const t = text7.trim();
+  if (!t.startsWith("---")) return void 0;
+  const close = t.indexOf("\n---", 3);
+  if (close < 0) return void 0;
+  const fm = t.slice(3, close);
+  const m = fm.match(/^\s*name\s*:\s*['"]?([A-Za-z0-9][A-Za-z0-9._-]*)['"]?\s*$/m);
+  return m?.[1];
+}
+function skillCommandFromBody(text7) {
+  return skillNameFromFrontmatter(text7) ?? text7.match(/^## Skill: \/([A-Za-z0-9][A-Za-z0-9._-]*)/m)?.[1];
+}
+function isCompactToolName(name) {
+  const short = (name ?? "").replace(/^mcp__[^_]+__/, "").trim();
+  return /^(Compact|ConversationCompact|summarize_context|SummarizeContext|SummarizeConversation)$/i.test(
+    short
+  );
+}
+function isContextCompactInProgress(text7) {
+  return /^Compressing context/i.test(text7.trim());
+}
+function isContextCompactDone(text7) {
+  return /^Context compressed\b/i.test(text7.trim());
+}
+function looksLikeConversationSummary(text7) {
+  const t = text7.trim();
+  if (t.length < 80) return false;
+  if (/<summarized_conversation\b/i.test(t) || /<conversation_summary\b/i.test(t)) {
+    return true;
+  }
+  if (/this session is being continued from a previous conversation/i.test(t)) {
+    return true;
+  }
+  if (/conversation compacted|replaced with a summary/i.test(t)) return true;
+  if (/^## Prior summary\b/m.test(t)) return true;
+  if (/_Automatic extractive summary/i.test(t)) return true;
+  if (/"context_summary"\s*:/.test(t)) return true;
+  if (/^(?:#+\s*)?(?:conversation summary|summary of (?:the )?conversation|compacted (?:conversation|context))\b/im.test(
+    t
+  )) {
+    return true;
+  }
+  return false;
+}
 function toolDetail(name, input) {
+  if (isSkillToolName(name) || isCompactToolName(name)) return void 0;
   if (!input) return void 0;
   const command = str2(input.command) ?? str2(input.cmd);
   if (command) return clipChatLine(command);
@@ -10527,6 +10727,17 @@ function toolDescription(name, input) {
   if (/stop_dev_script$/i.test(name)) {
     return str2(input?.name) ? `Stop ${str2(input?.name)}` : "Stop Dev script";
   }
+  if (isSkillToolName(name)) {
+    const cmd = skillCommandFromInput(input);
+    return cmd ? `Using /${cmd}` : "Using skill";
+  }
+  if (isCompactToolName(name)) {
+    const trigger = str2(input?.trigger);
+    if (trigger && !/^auto$/i.test(trigger) && trigger !== "injected") {
+      return `Summarized conversation (${trigger})`;
+    }
+    return "Summarized conversation";
+  }
   if (isSubagentToolName(name)) {
     const desc = str2(input?.description);
     const sub = asRecord(input?.subagentType);
@@ -10739,10 +10950,107 @@ function withPartTimes(next, prev) {
   const startedAt = prev && typeof prev.startedAt === "number" ? prev.startedAt : now;
   return { ...next, startedAt, updatedAt: now };
 }
+function skillToolFromTextPart(part, id) {
+  const command = skillCommandFromBody(part.text);
+  const input = command ? { skill: command } : void 0;
+  return {
+    type: "tool",
+    id,
+    name: "Skill",
+    input,
+    description: toolDescription("Skill", input),
+    status: "done",
+    result: clipToolResultForStore(part.text),
+    ...part.parentId ? { parentId: part.parentId } : {},
+    startedAt: part.startedAt,
+    updatedAt: Date.now()
+  };
+}
+function compactToolPart(text7, id, opts) {
+  const input = { trigger: opts?.trigger ?? "auto" };
+  return withPartTimes(
+    {
+      type: "tool",
+      id,
+      name: "Compact",
+      input,
+      description: toolDescription("Compact", input),
+      status: opts?.status ?? "done",
+      result: clipToolResultForStore(text7) ?? "",
+      ...opts?.parentId ? { parentId: opts.parentId } : {}
+    },
+    opts?.prev
+  );
+}
+function contextCompactInProgress(parts, parentId) {
+  let compressing = false;
+  for (const p of parts) {
+    if (!sameParentId(p.parentId, parentId)) continue;
+    if (p.type === "thinking" && isContextCompactInProgress(p.text)) compressing = true;
+    if (p.type === "thinking" && isContextCompactDone(p.text)) compressing = false;
+  }
+  return compressing;
+}
+function lastRunningCompactIndex(parts, parentId) {
+  for (let i = parts.length - 1; i >= 0; i--) {
+    const p = parts[i];
+    if (p.type === "tool" && isCompactToolName(p.name) && p.status === "running" && sameParentId(p.parentId, parentId)) {
+      return i;
+    }
+  }
+  return -1;
+}
+function markRunningCompactDone(parts, parentId) {
+  return parts.map((p) => {
+    if (p.type === "tool" && isCompactToolName(p.name) && p.status === "running" && sameParentId(p.parentId, parentId)) {
+      return withPartTimes({ ...p, status: "done" }, p);
+    }
+    return p;
+  });
+}
+function ensureCompactTool(parts, parentId) {
+  const hasCompact = parts.some(
+    (p) => p.type === "tool" && isCompactToolName(p.name) && sameParentId(p.parentId, parentId)
+  );
+  if (hasCompact) return parts;
+  return [
+    ...parts,
+    compactToolPart("Context compressed", `compact-${parts.length}`, {
+      parentId,
+      status: "done"
+    })
+  ];
+}
+function withCompactFinish(parts, thinking, parentId) {
+  if (!isContextCompactDone(thinking)) return parts;
+  return ensureCompactTool(markRunningCompactDone(parts, parentId), parentId);
+}
 function applyAgentEvent(parts, event) {
   if (event.type === "stdout") {
     const data = event.data;
     if (!data) return parts;
+    const runningIdx = lastRunningCompactIndex(parts, event.parentId);
+    if (runningIdx >= 0) {
+      const prev = parts[runningIdx];
+      const next2 = [...parts];
+      next2[runningIdx] = withPartTimes(
+        {
+          ...prev,
+          result: clipToolResultForStore(`${prev.result ?? ""}${data}`)
+        },
+        prev
+      );
+      return next2;
+    }
+    if (contextCompactInProgress(parts, event.parentId)) {
+      return [
+        ...parts,
+        compactToolPart(data, `compact-${parts.length}`, {
+          parentId: event.parentId,
+          status: "running"
+        })
+      ];
+    }
     const next = [...parts];
     const last = next[next.length - 1];
     if (last?.type === "text" && sameParentId(last.parentId, event.parentId)) {
@@ -10763,6 +11071,16 @@ function applyAgentEvent(parts, event) {
         })
       );
     }
+    const acc = next[next.length - 1];
+    if (acc?.type === "text" && looksLikeSkillBody(acc.text)) {
+      next[next.length - 1] = skillToolFromTextPart(acc, `skill-${next.length}`);
+    } else if (acc?.type === "text" && looksLikeConversationSummary(acc.text)) {
+      next[next.length - 1] = compactToolPart(acc.text, `compact-${next.length}`, {
+        parentId: acc.parentId,
+        status: "done",
+        prev: acc
+      });
+    }
     return next;
   }
   if (event.type === "thinking") {
@@ -10781,7 +11099,7 @@ function applyAgentEvent(parts, event) {
             },
             prev
           );
-          return next;
+          return withCompactFinish(next, data, event.parentId);
         }
       }
       next.push(
@@ -10791,7 +11109,7 @@ function applyAgentEvent(parts, event) {
           ...event.parentId ? { parentId: event.parentId } : {}
         })
       );
-      return next;
+      return withCompactFinish(next, data, event.parentId);
     }
     const last = next[next.length - 1];
     if (last?.type === "thinking" && sameParentId(last.parentId, event.parentId)) {
@@ -10812,7 +11130,7 @@ function applyAgentEvent(parts, event) {
         })
       );
     }
-    return next;
+    return withCompactFinish(next, data, event.parentId);
   }
   if (event.type === "tool_use") {
     const input = asRecord(event.input);
@@ -11072,6 +11390,87 @@ function claudeResultErrorDetail(obj) {
   }
   return "Claude turn failed";
 }
+function toolResultContent(block) {
+  if (typeof block.content === "string") return block.content;
+  if (Array.isArray(block.content)) {
+    return block.content.map(
+      (c) => typeof c === "string" ? c : c && typeof c === "object" && "text" in c ? String(c.text ?? "") : ""
+    ).join("");
+  }
+  if (block.content != null) return JSON.stringify(block.content);
+  return void 0;
+}
+function skillToolEventsFromBody(text7, parentId) {
+  const command = skillCommandFromBody(text7) ?? "skill";
+  const id = `skill-${command}`;
+  return [
+    withEventParentId(
+      { type: "tool_use", id, name: "Skill", input: { skill: command } },
+      parentId
+    ),
+    withEventParentId({ type: "tool_result", id, content: text7 }, parentId)
+  ];
+}
+function compactToolEventsFromBody(text7, parentId) {
+  const id = "compact-summary";
+  return [
+    withEventParentId(
+      { type: "tool_use", id, name: "Compact", input: { trigger: "injected" } },
+      parentId
+    ),
+    withEventParentId({ type: "tool_result", id, content: text7 }, parentId)
+  ];
+}
+function eventsFromInjectedUserText(text7, parentId) {
+  if (looksLikeSkillBody(text7)) return skillToolEventsFromBody(text7, parentId);
+  if (looksLikeConversationSummary(text7)) return compactToolEventsFromBody(text7, parentId);
+  return [];
+}
+function eventsFromUserContent(content, parentId) {
+  if (typeof content === "string" && content.trim()) {
+    return eventsFromInjectedUserText(content, parentId);
+  }
+  if (!Array.isArray(content) || content.length === 0) return [];
+  const out = [];
+  const textBlocks = [];
+  for (const block of content) {
+    if (!block?.type) continue;
+    if (block.type === "tool_use" && block.id && block.name) {
+      out.push(
+        withEventParentId(
+          {
+            type: "tool_use",
+            id: block.id,
+            name: block.name,
+            input: block.input
+          },
+          parentId
+        )
+      );
+      continue;
+    }
+    if (block.type === "tool_result" && block.tool_use_id) {
+      out.push(
+        withEventParentId(
+          {
+            type: "tool_result",
+            id: block.tool_use_id,
+            content: toolResultContent(block),
+            isError: Boolean(block.is_error)
+          },
+          parentId
+        )
+      );
+      continue;
+    }
+    if (block.type === "text" && block.text) textBlocks.push(block.text);
+  }
+  if (out.length > 0) return out;
+  for (const text7 of textBlocks) {
+    out.push(...eventsFromInjectedUserText(text7, parentId));
+  }
+  return out;
+}
 function eventsFromContentBlocks(blocks, parentId) {
   if (!blocks?.length) return [];
   const out = [];
@@ -11100,15 +11499,12 @@ function eventsFromContentBlocks(blocks, parentId) {
       continue;
     }
     if (block.type === "tool_result" && block.tool_use_id) {
-      const content = typeof block.content === "string" ? block.content : Array.isArray(block.content) ? block.content.map(
-        (c) => typeof c === "string" ? c : c && typeof c === "object" && "text" in c ? String(c.text ?? "") : ""
-      ).join("") : block.content != null ? JSON.stringify(block.content) : void 0;
       out.push(
         withEventParentId(
           {
             type: "tool_result",
             id: block.tool_use_id,
-            content,
+            content: toolResultContent(block),
             isError: Boolean(block.is_error)
           },
           parentId
@@ -11318,11 +11714,11 @@ function parseIssuesJson(raw) {
   }
   return [];
 }
-var import_node_fs29, BASE_ALLOWED_TOOLS, CLAUDE_PRINT_BG_WAIT_CEILING_MS, CLAUDE_CHROME_ALLOWED_TOOLS, CLAUDE_PROMPT_ARG_MAX, claudeAdapter;
+var import_node_fs30, BASE_ALLOWED_TOOLS, CLAUDE_PRINT_BG_WAIT_CEILING_MS, CLAUDE_CHROME_ALLOWED_TOOLS, CLAUDE_PROMPT_ARG_MAX, claudeAdapter;
 var init_claude = __esm({
   "src/agents/claude.ts"() {
     "use strict";
-    import_node_fs29 = require("fs");
+    import_node_fs30 = require("fs");
     init_run();
     init_app_settings();
     init_claude_mcp();
@@ -11362,7 +11758,7 @@ var init_claude = __esm({
       async detect() {
         const claude = resolveClaudeExecutable();
         if (claude !== "claude") {
-          if (!(0, import_node_fs29.existsSync)(claude)) {
+          if (!(0, import_node_fs30.existsSync)(claude)) {
             return {
               agent: "claude",
               installed: false,
@@ -11511,7 +11907,10 @@ var init_claude = __esm({
           if (obj.type === "assistant" || obj.type === "user") {
             const parentId = claudeParentToolUseId(obj);
             const message = obj.message;
-            const events = eventsFromContentBlocks(message?.content, parentId);
+            const events = obj.type === "user" ? eventsFromUserContent(message?.content, parentId) : eventsFromContentBlocks(
+              Array.isArray(message?.content) ? message.content : void 0,
+              parentId
+            );
             if (obj.type === "assistant") {
               const usage = usageFromClaude(message?.usage);
               if (usage) events.push({ type: "usage", data: usage, scope: "request" });
@@ -11630,7 +12029,7 @@ async function listCodexModels() {
   if (codex === "codex") {
     const which = await run("which", ["codex"], { reject: false });
     if (which.exitCode !== 0) return FALLBACK_CODEX_MODELS;
-  } else if (!(0, import_node_fs30.existsSync)(codex)) {
+  } else if (!(0, import_node_fs31.existsSync)(codex)) {
     return FALLBACK_CODEX_MODELS;
   }
   const listed = await run(codex, ["debug", "models"], { reject: false });
@@ -11665,12 +12064,12 @@ function usageFromCodex(usage) {
 }
 function codexConfigHasNetworkAccess() {
   const candidates = [
-    (0, import_node_path32.join)((0, import_node_os12.homedir)(), ".codex", "config.toml"),
-    (0, import_node_path32.join)((0, import_node_os12.homedir)(), ".config", "codex", "config.toml")
+    (0, import_node_path33.join)((0, import_node_os12.homedir)(), ".codex", "config.toml"),
+    (0, import_node_path33.join)((0, import_node_os12.homedir)(), ".config", "codex", "config.toml")
   ];
   for (const path of candidates) {
-    if (!(0, import_node_fs30.existsSync)(path)) continue;
-    const text7 = (0, import_node_fs30.readFileSync)(path, "utf8");
+    if (!(0, import_node_fs31.existsSync)(path)) continue;
+    const text7 = (0, import_node_fs31.readFileSync)(path, "utf8");
     if (/network_access\s*=\s*true/.test(text7)) return true;
   }
   return false;
@@ -11702,21 +12101,21 @@ function asRecord2(value) {
   return void 0;
 }
 function codexLooksAuthenticated() {
-  const authPath = (0, import_node_path32.join)((0, import_node_os12.homedir)(), ".codex", "auth.json");
-  if (!(0, import_node_fs30.existsSync)(authPath)) return false;
+  const authPath = (0, import_node_path33.join)((0, import_node_os12.homedir)(), ".codex", "auth.json");
+  if (!(0, import_node_fs31.existsSync)(authPath)) return false;
   try {
-    return (0, import_node_fs30.statSync)(authPath).size > 2;
+    return (0, import_node_fs31.statSync)(authPath).size > 2;
   } catch {
     return false;
   }
 }
-var import_node_fs30, import_node_os12, import_node_path32, CODEX_PROMPT_ARG_MAX, FALLBACK_CODEX_MODELS, cachedCodexModels, CODEX_MODEL_CACHE_MS, codexAdapter;
+var import_node_fs31, import_node_os12, import_node_path33, CODEX_PROMPT_ARG_MAX, FALLBACK_CODEX_MODELS, cachedCodexModels, CODEX_MODEL_CACHE_MS, codexAdapter;
 var init_codex = __esm({
   "src/agents/codex.ts"() {
     "use strict";
-    import_node_fs30 = require("fs");
+    import_node_fs31 = require("fs");
     import_node_os12 = require("os");
-    import_node_path32 = require("path");
+    import_node_path33 = require("path");
     init_run();
     init_app_settings();
     init_global_workspace();
@@ -11742,7 +12141,7 @@ var init_codex = __esm({
       async detect() {
         const codex = resolveAgentExecutable("codex");
         if (codex !== "codex") {
-          if (!(0, import_node_fs30.existsSync)(codex)) {
+          if (!(0, import_node_fs31.existsSync)(codex)) {
             return {
               agent: "codex",
               installed: false,
@@ -12019,18 +12418,18 @@ var init_codex = __esm({
 // src/agents/cursor-sdk-resolve.ts
 function thisModuleFile() {
   const cjsDir = typeof __dirname !== "undefined" ? __dirname : "";
-  if (cjsDir) return (0, import_node_path33.join)(cjsDir, "cursor-sdk-resolve.js");
+  if (cjsDir) return (0, import_node_path34.join)(cjsDir, "cursor-sdk-resolve.js");
   try {
     return (0, import_node_url2.fileURLToPath)(import_meta2.url);
   } catch {
-    return (0, import_node_path33.join)(process.cwd(), "package.json");
+    return (0, import_node_path34.join)(process.cwd(), "package.json");
   }
 }
 function packageRootLooksLikeSdk(dir) {
   try {
-    const raw = (0, import_node_fs31.readFileSync)((0, import_node_path33.join)(dir, "package.json"), "utf8");
+    const raw = (0, import_node_fs32.readFileSync)((0, import_node_path34.join)(dir, "package.json"), "utf8");
     const pkg = JSON.parse(raw);
-    return pkg.name === "@cursor/sdk" && (0, import_node_fs31.existsSync)(dir);
+    return pkg.name === "@cursor/sdk" && (0, import_node_fs32.existsSync)(dir);
   } catch {
     return false;
   }
@@ -12039,7 +12438,7 @@ function resolvedPackageRoot(fromFile) {
   try {
     const req = (0, import_node_module2.createRequire)(fromFile);
     const pkgJson = req.resolve("@cursor/sdk/package.json");
-    const root = (0, import_node_path33.dirname)(pkgJson);
+    const root = (0, import_node_path34.dirname)(pkgJson);
     return packageRootLooksLikeSdk(root) ? root : null;
   } catch {
     return null;
@@ -12053,10 +12452,10 @@ function resolveCursorSdkRoot(opts) {
   }
   const globalNm = npmGlobalNodeModules(env);
   if (globalNm) {
-    const globalRoot = (0, import_node_path33.join)(globalNm, "@cursor/sdk");
+    const globalRoot = (0, import_node_path34.join)(globalNm, "@cursor/sdk");
     if (packageRootLooksLikeSdk(globalRoot)) return globalRoot;
   }
-  const cwdPkg = (0, import_node_path33.join)(process.cwd(), "package.json");
+  const cwdPkg = (0, import_node_path34.join)(process.cwd(), "package.json");
   return resolvedPackageRoot(thisModuleFile()) ?? resolvedPackageRoot(cwdPkg);
 }
 function isCursorSdkInstalled(opts) {
@@ -12072,13 +12471,13 @@ function exportTarget(value) {
 }
 function cursorSdkEsmEntry(root) {
   try {
-    const pkg = JSON.parse((0, import_node_fs31.readFileSync)((0, import_node_path33.join)(root, "package.json"), "utf8"));
+    const pkg = JSON.parse((0, import_node_fs32.readFileSync)((0, import_node_path34.join)(root, "package.json"), "utf8"));
     const exp = pkg.exports;
     const dot = exp && typeof exp === "object" && !Array.isArray(exp) && "." in exp ? exp["."] : exp;
     const rel = exportTarget(dot) ?? (typeof pkg.module === "string" ? pkg.module : null);
     if (!rel) return null;
-    const entry = (0, import_node_path33.join)(root, rel);
-    return (0, import_node_fs31.existsSync)(entry) ? entry : null;
+    const entry = (0, import_node_path34.join)(root, rel);
+    return (0, import_node_fs32.existsSync)(entry) ? entry : null;
   } catch {
     return null;
   }
@@ -12094,7 +12493,7 @@ async function importCursorSdk(opts) {
   try {
     let entry = cursorSdkEsmEntry(root);
     if (!entry) {
-      const req = (0, import_node_module2.createRequire)((0, import_node_path33.join)(root, "package.json"));
+      const req = (0, import_node_module2.createRequire)((0, import_node_path34.join)(root, "package.json"));
       entry = req.resolve("@cursor/sdk");
     }
     return unwrapCursorSdkModule(await import((0, import_node_url2.pathToFileURL)(entry).href));
@@ -12106,8 +12505,8 @@ function cursorSdkPlatformRipgrepPackage() {
   return `@cursor/sdk-${process.platform}-${process.arch}`;
 }
 function nodeModulesDirForPackageRoot(packageRoot) {
-  const parent = (0, import_node_path33.dirname)(packageRoot);
-  return (0, import_node_path33.basename)(parent).startsWith("@") ? (0, import_node_path33.dirname)(parent) : parent;
+  const parent = (0, import_node_path34.dirname)(packageRoot);
+  return (0, import_node_path34.basename)(parent).startsWith("@") ? (0, import_node_path34.dirname)(parent) : parent;
 }
 function cursorSdkRipgrepCandidate(opts) {
   const root = resolveCursorSdkRoot(opts);
@@ -12115,18 +12514,18 @@ function cursorSdkRipgrepCandidate(opts) {
   const nm = nodeModulesDirForPackageRoot(root);
   const pkg = cursorSdkPlatformRipgrepPackage();
   const bin = process.platform === "win32" ? "rg.exe" : "rg";
-  const sibling = (0, import_node_path33.join)(nm, pkg, "bin", bin);
-  if ((0, import_node_fs31.existsSync)(sibling)) return sibling;
-  const nested = (0, import_node_path33.join)(root, "node_modules", pkg, "bin", bin);
-  return (0, import_node_fs31.existsSync)(nested) ? nested : null;
+  const sibling = (0, import_node_path34.join)(nm, pkg, "bin", bin);
+  if ((0, import_node_fs32.existsSync)(sibling)) return sibling;
+  const nested = (0, import_node_path34.join)(root, "node_modules", pkg, "bin", bin);
+  return (0, import_node_fs32.existsSync)(nested) ? nested : null;
 }
-var import_node_fs31, import_node_module2, import_node_path33, import_node_url2, import_meta2, CURSOR_SDK_INSTALL_HINT;
+var import_node_fs32, import_node_module2, import_node_path34, import_node_url2, import_meta2, CURSOR_SDK_INSTALL_HINT;
 var init_cursor_sdk_resolve = __esm({
   "src/agents/cursor-sdk-resolve.ts"() {
     "use strict";
-    import_node_fs31 = require("fs");
+    import_node_fs32 = require("fs");
     import_node_module2 = require("module");
-    import_node_path33 = require("path");
+    import_node_path34 = require("path");
     import_node_url2 = require("url");
     init_path();
     import_meta2 = {};
@@ -12168,21 +12567,21 @@ function platformRipgrepPackage() {
 }
 function usableRipgrepPath(candidate) {
   const raw = candidate?.trim();
-  if (!raw || !(0, import_node_path34.isAbsolute)(raw)) return null;
+  if (!raw || !(0, import_node_path35.isAbsolute)(raw)) return null;
   const readable = nodeReadableScriptPath(raw);
-  if (!(0, import_node_fs32.existsSync)(readable) || isAsarPath(readable)) return null;
+  if (!(0, import_node_fs33.existsSync)(readable) || isAsarPath(readable)) return null;
   return readable;
 }
 function walkForBundledRipgrep(startFile) {
   if (!startFile) return null;
   const pkg = platformRipgrepPackage();
   const name = rgBinaryName();
-  let dir = (0, import_node_path34.dirname)((0, import_node_path34.resolve)(startFile));
-  const root = (0, import_node_path34.parse)(dir).root;
+  let dir = (0, import_node_path35.dirname)((0, import_node_path35.resolve)(startFile));
+  const root = (0, import_node_path35.parse)(dir).root;
   while (dir !== root) {
-    const hit = usableRipgrepPath((0, import_node_path34.join)(dir, "node_modules", pkg, "bin", name));
+    const hit = usableRipgrepPath((0, import_node_path35.join)(dir, "node_modules", pkg, "bin", name));
     if (hit) return hit;
-    const next = (0, import_node_path34.dirname)(dir);
+    const next = (0, import_node_path35.dirname)(dir);
     if (next === dir) break;
     dir = next;
   }
@@ -12192,7 +12591,7 @@ function requireResolveBundledRipgrep(fromFile) {
   try {
     const req = (0, import_node_module3.createRequire)(fromFile);
     const pkgJson = req.resolve(`${platformRipgrepPackage()}/package.json`);
-    return usableRipgrepPath((0, import_node_path34.join)((0, import_node_path34.dirname)(pkgJson), "bin", rgBinaryName()));
+    return usableRipgrepPath((0, import_node_path35.join)((0, import_node_path35.dirname)(pkgJson), "bin", rgBinaryName()));
   } catch {
     return null;
   }
@@ -12214,13 +12613,13 @@ function cursorRipgrepEnv(opts) {
   const path = resolveCursorRipgrepPath(opts);
   return path ? { [RIPGREP_ENV]: path } : {};
 }
-var import_node_fs32, import_node_module3, import_node_path34, RIPGREP_ENV;
+var import_node_fs33, import_node_module3, import_node_path35, RIPGREP_ENV;
 var init_cursor_ripgrep = __esm({
   "src/agents/cursor-ripgrep.ts"() {
     "use strict";
-    import_node_fs32 = require("fs");
+    import_node_fs33 = require("fs");
     import_node_module3 = require("module");
-    import_node_path34 = require("path");
+    import_node_path35 = require("path");
     init_cursor_sdk_resolve();
     init_node_launch();
     init_packaged_runtime();
@@ -12264,11 +12663,11 @@ function entryDir() {
   const cjsDir = typeof __dirname !== "undefined" ? __dirname : "";
   if (cjsDir) return cjsDir;
   try {
-    return (0, import_node_path35.dirname)((0, import_node_url3.fileURLToPath)(import_meta3.url));
+    return (0, import_node_path36.dirname)((0, import_node_url3.fileURLToPath)(import_meta3.url));
   } catch {
     try {
       const req = (0, import_node_module4.createRequire)(process.cwd() + "/");
-      return (0, import_node_path35.dirname)(req.resolve("@sideboard-ai/core"));
+      return (0, import_node_path36.dirname)(req.resolve("@sideboard-ai/core"));
     } catch {
       return process.cwd();
     }
@@ -12279,27 +12678,27 @@ function cursorRunnerPath() {
   if (packaged) return packaged;
   const root = entryDir();
   const candidates = [
-    (0, import_node_path35.join)(root, "agents", "cursor-runner.js"),
-    (0, import_node_path35.join)(root, "agents", "cursor-runner.cjs"),
+    (0, import_node_path36.join)(root, "agents", "cursor-runner.js"),
+    (0, import_node_path36.join)(root, "agents", "cursor-runner.cjs"),
     // If somehow resolved from package root instead of dist/
-    (0, import_node_path35.join)(root, "dist", "agents", "cursor-runner.js"),
-    (0, import_node_path35.join)(root, "dist", "agents", "cursor-runner.cjs"),
+    (0, import_node_path36.join)(root, "dist", "agents", "cursor-runner.js"),
+    (0, import_node_path36.join)(root, "dist", "agents", "cursor-runner.cjs"),
     // Source tree (dev): packages/core/src/agents/cursor-runner.ts
-    (0, import_node_path35.join)(root, "cursor-runner.ts"),
-    (0, import_node_path35.join)(root, "src", "agents", "cursor-runner.ts")
+    (0, import_node_path36.join)(root, "cursor-runner.ts"),
+    (0, import_node_path36.join)(root, "src", "agents", "cursor-runner.ts")
   ];
   for (const candidate of candidates) {
-    if ((0, import_node_fs33.existsSync)(candidate)) return candidate;
+    if ((0, import_node_fs34.existsSync)(candidate)) return candidate;
   }
   return candidates[0];
 }
-var import_node_fs33, import_node_module4, import_node_path35, import_node_url3, import_meta3, FALLBACK_CURSOR_MODELS, cachedModels, MODEL_CACHE_MS, cursorAdapter;
+var import_node_fs34, import_node_module4, import_node_path36, import_node_url3, import_meta3, FALLBACK_CURSOR_MODELS, cachedModels, MODEL_CACHE_MS, cursorAdapter;
 var init_cursor = __esm({
   "src/agents/cursor.ts"() {
     "use strict";
-    import_node_fs33 = require("fs");
+    import_node_fs34 = require("fs");
     import_node_module4 = require("module");
-    import_node_path35 = require("path");
+    import_node_path36 = require("path");
     import_node_url3 = require("url");
     init_run();
     init_app_settings();
@@ -12461,7 +12860,7 @@ async function listOpencodeModels() {
   if (opencode === "opencode") {
     const which = await run("which", ["opencode"], { reject: false });
     if (which.exitCode !== 0) return FALLBACK_OPENCODE_MODELS;
-  } else if (!(0, import_node_fs34.existsSync)(opencode)) {
+  } else if (!(0, import_node_fs35.existsSync)(opencode)) {
     return FALLBACK_OPENCODE_MODELS;
   }
   const listed = await run(opencode, ["models"], { reject: false });
@@ -12491,11 +12890,11 @@ function usageFromOpencode(tokens) {
     cacheWriteTokens: tokens.cache?.write ? Number(tokens.cache.write) : void 0
   };
 }
-var import_node_fs34, FALLBACK_OPENCODE_MODELS, cachedOpencodeModels, OPENCODE_MODEL_CACHE_MS, opencodeAdapter;
+var import_node_fs35, FALLBACK_OPENCODE_MODELS, cachedOpencodeModels, OPENCODE_MODEL_CACHE_MS, opencodeAdapter;
 var init_opencode = __esm({
   "src/agents/opencode.ts"() {
     "use strict";
-    import_node_fs34 = require("fs");
+    import_node_fs35 = require("fs");
     init_run();
     init_app_settings();
     init_global_workspace();
@@ -12523,7 +12922,7 @@ var init_opencode = __esm({
       async detect() {
         const opencode = resolveAgentExecutable("opencode");
         if (opencode !== "opencode") {
-          if (!(0, import_node_fs34.existsSync)(opencode)) {
+          if (!(0, import_node_fs35.existsSync)(opencode)) {
             return {
               agent: "opencode",
               installed: false,
@@ -13010,13 +13409,13 @@ var init_claude_usage = __esm({
 });
 
 // src/agents/claude-usage-client.ts
-var import_node_fs35, import_node_os13, import_node_path36, CLAUDE_USAGE_ERROR_TTL_MS, CLAUDE_USAGE_STALE_OK_MS;
+var import_node_fs36, import_node_os13, import_node_path37, CLAUDE_USAGE_ERROR_TTL_MS, CLAUDE_USAGE_STALE_OK_MS;
 var init_claude_usage_client = __esm({
   "src/agents/claude-usage-client.ts"() {
     "use strict";
-    import_node_fs35 = require("fs");
+    import_node_fs36 = require("fs");
     import_node_os13 = require("os");
-    import_node_path36 = require("path");
+    import_node_path37 = require("path");
     init_run();
     init_fetch();
     init_app_settings();
@@ -13027,11 +13426,11 @@ var init_claude_usage_client = __esm({
 });
 
 // src/agents/install.ts
-var import_node_fs36;
+var import_node_fs37;
 var init_install = __esm({
   "src/agents/install.ts"() {
     "use strict";
-    import_node_fs36 = require("fs");
+    import_node_fs37 = require("fs");
     init_run();
     init_app_settings();
     init_path();
@@ -13085,7 +13484,7 @@ function isAgentHostEnvKey(key) {
 }
 function stripHostToolingPath(pathValue) {
   if (!pathValue?.trim()) return "";
-  return pathValue.split(import_node_path37.delimiter).filter((part) => part && !HOST_PATH_NOISE.test(part.replace(/\\/g, "/"))).join(import_node_path37.delimiter);
+  return pathValue.split(import_node_path38.delimiter).filter((part) => part && !HOST_PATH_NOISE.test(part.replace(/\\/g, "/"))).join(import_node_path38.delimiter);
 }
 function sanitizeAgentHostEnv(env, cwd) {
   for (const key of Object.keys(env)) {
@@ -13099,11 +13498,11 @@ function sanitizeAgentHostEnv(env, cwd) {
   }
   return env;
 }
-var import_node_path37, DROP_EXACT, DROP_PREFIXES, HOST_PATH_NOISE;
+var import_node_path38, DROP_EXACT, DROP_PREFIXES, HOST_PATH_NOISE;
 var init_agent_host_env = __esm({
   "src/hook/agent-host-env.ts"() {
     "use strict";
-    import_node_path37 = require("path");
+    import_node_path38 = require("path");
     DROP_EXACT = /* @__PURE__ */ new Set([
       "NODE_PATH",
       "NODE_ENV_ELECTRON_VITE",
@@ -13142,15 +13541,15 @@ var init_agent_host_env = __esm({
 
 // src/hook/worktree-pkg-cache.ts
 function worktreePkgCacheRoot(worktreePath) {
-  return (0, import_node_path38.join)(worktreePath, WORKTREE_PKG_CACHE_REL);
+  return (0, import_node_path39.join)(worktreePath, WORKTREE_PKG_CACHE_REL);
 }
 function worktreePkgCacheEnv(worktreePath) {
   const root = worktreePkgCacheRoot(worktreePath);
-  const store = (0, import_node_path38.join)(root, "pnpm-store");
-  const pnpmCache = (0, import_node_path38.join)(root, "pnpm");
-  const npmCache = (0, import_node_path38.join)(root, "npm");
-  const nodeGyp = (0, import_node_path38.join)(root, "node-gyp");
-  const electron = (0, import_node_path38.join)(root, "electron");
+  const store = (0, import_node_path39.join)(root, "pnpm-store");
+  const pnpmCache = (0, import_node_path39.join)(root, "pnpm");
+  const npmCache = (0, import_node_path39.join)(root, "npm");
+  const nodeGyp = (0, import_node_path39.join)(root, "node-gyp");
+  const electron = (0, import_node_path39.join)(root, "electron");
   return {
     npm_config_store_dir: store,
     PNPM_STORE_DIR: store,
@@ -13172,8 +13571,8 @@ function fillGroup(env, keys, values) {
   }
 }
 function ensureWorktreePkgCacheDirs(worktreePath) {
-  if (!(0, import_node_fs37.existsSync)(worktreePath)) return;
-  (0, import_node_fs37.mkdirSync)(worktreePkgCacheRoot(worktreePath), { recursive: true });
+  if (!(0, import_node_fs38.existsSync)(worktreePath)) return;
+  (0, import_node_fs38.mkdirSync)(worktreePkgCacheRoot(worktreePath), { recursive: true });
 }
 function applyWorktreePkgCacheEnv(env, worktreePath) {
   const cwd = worktreePath.trim();
@@ -13186,12 +13585,12 @@ function applyWorktreePkgCacheEnv(env, worktreePath) {
   fillGroup(env, ["electron_config_cache"], next);
   ensureWorktreePkgCacheDirs(cwd);
 }
-var import_node_fs37, import_node_path38, WORKTREE_PKG_CACHE_REL;
+var import_node_fs38, import_node_path39, WORKTREE_PKG_CACHE_REL;
 var init_worktree_pkg_cache = __esm({
   "src/hook/worktree-pkg-cache.ts"() {
     "use strict";
-    import_node_fs37 = require("fs");
-    import_node_path38 = require("path");
+    import_node_fs38 = require("fs");
+    import_node_path39 = require("path");
     WORKTREE_PKG_CACHE_REL = ".context/.sideboard/pkg-cache";
   }
 });
@@ -14389,21 +14788,21 @@ function shouldRefreshReviewRequestTemplate(content) {
   return LEGACY_REVIEW_TEMPLATE_MARKERS.every((m) => trimmed.includes(m));
 }
 function readTextIfPresent(abs) {
-  if (!(0, import_node_fs38.existsSync)(abs)) return null;
+  if (!(0, import_node_fs39.existsSync)(abs)) return null;
   try {
-    const content = (0, import_node_fs38.readFileSync)(abs, "utf8");
+    const content = (0, import_node_fs39.readFileSync)(abs, "utf8");
     return content.trim() ? content : null;
   } catch {
     return null;
   }
 }
 function readLocalGuidelines(worktreePath) {
-  const localAbs = (0, import_node_path39.join)(worktreePath, REVIEW_REQUEST_PATH);
+  const localAbs = (0, import_node_path40.join)(worktreePath, REVIEW_REQUEST_PATH);
   const localContent = readTextIfPresent(localAbs);
   if (localContent && !shouldRefreshReviewRequestTemplate(localContent)) {
     return { path: REVIEW_REQUEST_PATH, content: localContent };
   }
-  const legacyAbs = (0, import_node_path39.join)(worktreePath, LEGACY_REVIEW_REQUEST_PATH);
+  const legacyAbs = (0, import_node_path40.join)(worktreePath, LEGACY_REVIEW_REQUEST_PATH);
   const legacyContent = readTextIfPresent(legacyAbs);
   if (legacyContent && !shouldRefreshReviewRequestTemplate(legacyContent)) {
     return { path: LEGACY_REVIEW_REQUEST_PATH, content: legacyContent };
@@ -14427,27 +14826,27 @@ function contextGuidelines(content, source) {
   };
 }
 function writeContextGuidelines(worktreePath, content) {
-  const abs = (0, import_node_path39.join)(worktreePath, CONTEXT_REVIEW_PATH);
-  (0, import_node_fs38.mkdirSync)((0, import_node_path39.dirname)(abs), { recursive: true });
+  const abs = (0, import_node_path40.join)(worktreePath, CONTEXT_REVIEW_PATH);
+  (0, import_node_fs39.mkdirSync)((0, import_node_path40.dirname)(abs), { recursive: true });
   const body = content.endsWith("\n") ? content : `${content}
 `;
-  (0, import_node_fs38.writeFileSync)(abs, body, "utf8");
+  (0, import_node_fs39.writeFileSync)(abs, body, "utf8");
   return body;
 }
 function readSideboardReview(worktreePath, repoPath) {
-  const fromWorktree = readTextIfPresent((0, import_node_path39.join)(worktreePath, REPO_REVIEW_PATH));
+  const fromWorktree = readTextIfPresent((0, import_node_path40.join)(worktreePath, REPO_REVIEW_PATH));
   if (fromWorktree) return fromWorktree;
   const repo = repoPath?.replace(/\/+$/, "");
   const wt = worktreePath.replace(/\/+$/, "");
   if (!repo || repo === wt) return null;
-  return readTextIfPresent((0, import_node_path39.join)(repo, REPO_REVIEW_PATH));
+  return readTextIfPresent((0, import_node_path40.join)(repo, REPO_REVIEW_PATH));
 }
 function ensureReviewGuidelinesFile(worktreePath, repoPath) {
-  const skillContent = readTextIfPresent((0, import_node_path39.join)(worktreePath, REVIEW_SKILL_PATH));
+  const skillContent = readTextIfPresent((0, import_node_path40.join)(worktreePath, REVIEW_SKILL_PATH));
   if (skillContent) {
     return { ...skillGuidelines(skillContent, "skill"), wrote: false };
   }
-  const contextContent = readTextIfPresent((0, import_node_path39.join)(worktreePath, CONTEXT_REVIEW_PATH));
+  const contextContent = readTextIfPresent((0, import_node_path40.join)(worktreePath, CONTEXT_REVIEW_PATH));
   if (contextContent && !shouldRefreshReviewRequestTemplate(contextContent)) {
     return { ...contextGuidelines(contextContent, "local"), wrote: false };
   }
@@ -14502,13 +14901,13 @@ async function requestReview(threadRef, send) {
   const started = await send(tab.id, REVIEW_REQUEST_PREFILL);
   return { tab: started, from };
 }
-var import_node_crypto7, import_node_fs38, import_node_path39, REPO_REVIEW_PATH, REPO_REVIEW_NAME, CONTEXT_REVIEW_PATH, REVIEW_REQUEST_PATH, LEGACY_REVIEW_REQUEST_PATH, REVIEW_REQUEST_NAME, REVIEW_REQUEST_PREFILL, LEGACY_REVIEW_TEMPLATE_MARKERS;
+var import_node_crypto7, import_node_fs39, import_node_path40, REPO_REVIEW_PATH, REPO_REVIEW_NAME, CONTEXT_REVIEW_PATH, REVIEW_REQUEST_PATH, LEGACY_REVIEW_REQUEST_PATH, REVIEW_REQUEST_NAME, REVIEW_REQUEST_PREFILL, LEGACY_REVIEW_TEMPLATE_MARKERS;
 var init_request_review = __esm({
   "src/review/request-review.ts"() {
     "use strict";
     import_node_crypto7 = require("crypto");
-    import_node_fs38 = require("fs");
-    import_node_path39 = require("path");
+    import_node_fs39 = require("fs");
+    import_node_path40 = require("path");
     init_global_workspace();
     init_chat_tabs();
     init_thread_store();
@@ -14534,9 +14933,9 @@ function matchSimpleGlob(pattern, name) {
   return new RegExp(`^${escaped}$`).test(name);
 }
 function readWorktreeInclude(repoPath) {
-  const path = (0, import_node_path40.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("#"));
+  const path = (0, import_node_path41.join)(repoPath, ".worktreeinclude");
+  if (!(0, import_node_fs40.existsSync)(path)) return [];
+  return (0, import_node_fs40.readFileSync)(path, "utf8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
 }
 function resolveFilesToCopy(repoPath) {
   const fromInclude = readWorktreeInclude(repoPath);
@@ -14546,10 +14945,10 @@ function resolveFilesToCopy(repoPath) {
   if (settings?.fileIncludeGlobs?.length) {
     const matched = [];
     try {
-      for (const entry of (0, import_node_fs39.readdirSync)(repoPath, { withFileTypes: true })) {
+      for (const entry of (0, import_node_fs40.readdirSync)(repoPath, { withFileTypes: true })) {
         if (!entry.isFile()) continue;
         for (const glob of settings.fileIncludeGlobs) {
-          if (matchSimpleGlob(glob, entry.name) || matchSimpleGlob((0, import_node_path40.basename)(glob), entry.name)) {
+          if (matchSimpleGlob(glob, entry.name) || matchSimpleGlob((0, import_node_path41.basename)(glob), entry.name)) {
             matched.push(entry.name);
             break;
           }
@@ -14561,7 +14960,7 @@ function resolveFilesToCopy(repoPath) {
   }
   const defaults = [];
   try {
-    for (const entry of (0, import_node_fs39.readdirSync)(repoPath, { withFileTypes: true })) {
+    for (const entry of (0, import_node_fs40.readdirSync)(repoPath, { withFileTypes: true })) {
       if (entry.isFile() && entry.name.startsWith(".env")) {
         defaults.push(entry.name);
       }
@@ -14575,11 +14974,11 @@ function copyConfiguredFiles(repoPath, worktreePath) {
   const patterns = resolveFilesToCopy(repoPath);
   const copied = [];
   for (const rel of patterns) {
-    const src = (0, import_node_path40.join)(repoPath, rel);
-    if (!(0, import_node_fs39.existsSync)(src)) continue;
-    const dest = (0, import_node_path40.join)(worktreePath, rel);
-    (0, import_node_fs39.mkdirSync)((0, import_node_path40.dirname)(dest), { recursive: true });
-    (0, import_node_fs39.copyFileSync)(src, dest);
+    const src = (0, import_node_path41.join)(repoPath, rel);
+    if (!(0, import_node_fs40.existsSync)(src)) continue;
+    const dest = (0, import_node_path41.join)(worktreePath, rel);
+    (0, import_node_fs40.mkdirSync)((0, import_node_path41.dirname)(dest), { recursive: true });
+    (0, import_node_fs40.copyFileSync)(src, dest);
     copied.push(rel);
   }
   return copied;
@@ -14614,7 +15013,7 @@ function buildWorkspaceScriptEnv(opts, baseEnv) {
   const env = stripNestedElectronEnv({
     ...baseEnv ?? process.env
   });
-  const name = opts.workspaceName ?? (0, import_node_path40.basename)(opts.worktreePath);
+  const name = opts.workspaceName ?? (0, import_node_path41.basename)(opts.worktreePath);
   const ports = opts.ports ?? [];
   const primary = ports[0];
   env.SIDEBOARD_WORKSPACE_NAME = name;
@@ -14938,14 +15337,14 @@ async function startDevServer(repoPath, worktreePath, onLine, opts) {
     throw err;
   }
 }
-var import_node_fs39, import_node_child_process4, import_node_net, import_node_path40, import_execa4, import_node_readline3, PORT_RANGE_SIZE, cachedLoginEnv;
+var import_node_fs40, import_node_child_process4, import_node_net, import_node_path41, import_execa4, import_node_readline3, PORT_RANGE_SIZE, cachedLoginEnv;
 var init_conductor = __esm({
   "src/hook/conductor.ts"() {
     "use strict";
-    import_node_fs39 = require("fs");
+    import_node_fs40 = require("fs");
     import_node_child_process4 = require("child_process");
     import_node_net = require("net");
-    import_node_path40 = require("path");
+    import_node_path41 = require("path");
     import_execa4 = require("execa");
     import_node_readline3 = require("readline");
     init_settings();
@@ -14995,7 +15394,7 @@ function materialize(mem) {
   };
 }
 function setupLogPath(threadId) {
-  return (0, import_node_path41.join)(threadsDir(), `${threadId}.setup.log.json`);
+  return (0, import_node_path42.join)(threadsDir(), `${threadId}.setup.log.json`);
 }
 function setupLogKeyForWorktree(worktreePath) {
   const norm = normalizeWorktreePath(worktreePath);
@@ -15013,7 +15412,7 @@ function persistNow(threadId) {
   const mem = memory.get(threadId);
   if (!mem) return;
   try {
-    (0, import_node_fs40.writeFileSync)(
+    (0, import_node_fs41.writeFileSync)(
       setupLogPath(threadId),
       `${JSON.stringify(materialize(mem))}
 `,
@@ -15034,9 +15433,9 @@ function schedulePersist(threadId) {
 }
 function loadFromDisk(threadId) {
   const path = setupLogPath(threadId);
-  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),
@@ -15092,13 +15491,13 @@ function finishSetupLog(threadId, exitCode, source) {
   persistNow(threadId);
   return materialize(mem);
 }
-var import_node_crypto8, import_node_fs40, import_node_path41, EMPTY, MAX_SETUP_LOG_CHARS, memory, persistTimers, PERSIST_DEBOUNCE_MS;
+var import_node_crypto8, import_node_fs41, import_node_path42, 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_fs40 = require("fs");
-    import_node_path41 = require("path");
+    import_node_fs41 = require("fs");
+    import_node_path42 = require("path");
     init_worktree_labels();
     init_paths();
     EMPTY = {
@@ -15125,9 +15524,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;
       }
@@ -15137,7 +15536,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) {
@@ -15148,7 +15547,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;
         }
@@ -15158,16 +15557,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_path42.join)(root, entry.name).replace(/\/$/, "");
+          const path = (0, import_node_path43.join)(root, entry.name).replace(/\/$/, "");
           if (known.has(path) || seen.has(path)) continue;
-          if (!(0, import_node_fs41.existsSync)((0, import_node_path42.join)(path, ".git"))) continue;
+          if (!(0, import_node_fs42.existsSync)((0, import_node_path43.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();
           }
@@ -15219,12 +15618,12 @@ function shouldRunWorktreeCleanup(settings = loadAppSettings()) {
   const elapsed = Date.now() - Date.parse(last);
   return elapsed >= intervalHours * 36e5;
 }
-var import_node_fs41, import_node_path42;
+var import_node_fs42, import_node_path43;
 var init_orphan_cleanup = __esm({
   "src/git/orphan-cleanup.ts"() {
     "use strict";
-    import_node_fs41 = require("fs");
-    import_node_path42 = require("path");
+    import_node_fs42 = require("fs");
+    import_node_path43 = require("path");
     init_worktree();
     init_thread_store();
     init_paths();
@@ -15399,12 +15798,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_path43.basename)(url.replace(/\/$/, "").replace(/\.git$/, ""));
+    const leaf = (0, import_node_path44.basename)(url.replace(/\/$/, "").replace(/\.git$/, ""));
     name = leaf || "repo";
   }
   name = name.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "repo";
-  const dest = (0, import_node_path43.join)(sideboardReposDir(), name);
-  if ((0, import_node_fs42.existsSync)(dest)) {
+  const dest = (0, import_node_path44.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 };
@@ -15419,12 +15818,12 @@ async function cloneRepoIntoSideboard(opts) {
   const workspace = await ensureWorkspace(repoPath);
   return { repoPath, workspace };
 }
-var import_node_fs42, import_node_path43, import_execa6;
+var import_node_fs43, import_node_path44, import_execa6;
 var init_clone_repo = __esm({
   "src/git/clone-repo.ts"() {
     "use strict";
-    import_node_fs42 = require("fs");
-    import_node_path43 = require("path");
+    import_node_fs43 = require("fs");
+    import_node_path44 = require("path");
     import_execa6 = require("execa");
     init_paths();
     init_workspaces2();
@@ -15444,11 +15843,11 @@ var init_thread = __esm({
 
 // src/store/desktop-host.ts
 function desktopHostPidPath() {
-  return (0, import_node_path44.join)(appDataDir(), "desktop-host.pid");
+  return (0, import_node_path45.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 {
@@ -15474,12 +15873,12 @@ function thisProcessShouldDrainAgentQueues() {
   if (isThisProcessDesktopHost()) return true;
   return !isDesktopHostAlive();
 }
-var import_node_fs43, import_node_path44;
+var import_node_fs44, import_node_path45;
 var init_desktop_host = __esm({
   "src/store/desktop-host.ts"() {
     "use strict";
-    import_node_fs43 = require("fs");
-    import_node_path44 = require("path");
+    import_node_fs44 = require("fs");
+    import_node_path45 = require("path");
     init_paths();
   }
 });
@@ -15597,24 +15996,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_path45.join)(root, legacy ? LEGACY_DETACHED_JOBS_DIR : DETACHED_JOBS_DIR, id);
+  return (0, import_node_path46.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_path45.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_path46.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();
@@ -15626,7 +16025,7 @@ function listRunningDetachedJobs(worktreePath) {
   const running = [];
   for (const id of ids) {
     const dir = resolveJobDir(root, id);
-    const pid = readIntFile((0, import_node_path45.join)(dir, "pid"));
+    const pid = readIntFile((0, import_node_path46.join)(dir, "pid"));
     if (jobTreeAlive(pid)) running.push(id);
   }
   return running.sort();
@@ -15709,8 +16108,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) {
@@ -15718,8 +16117,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;
 }
@@ -15730,15 +16129,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_path45.join)(dir, "pid"));
+  const pid = readIntFile((0, import_node_path46.join)(dir, "pid"));
   const running = jobTreeAlive(pid);
   return {
     pid,
     running,
-    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"))
+    exitCode: readIntFile((0, import_node_path46.join)(dir, "exit")),
+    log: (0, import_node_path46.join)(dir, "log"),
+    cursor: (0, import_node_path46.join)(dir, "present.cursor"),
+    progress: tailProgress((0, import_node_path46.join)(dir, "log"))
   };
 }
 function toResult(id, snap, extra) {
@@ -15747,8 +16146,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_path45.dirname)(snap.cursor), { recursive: true });
-    (0, import_node_fs44.writeFileSync)(snap.cursor, `${nextCursor}
+    (0, import_node_fs45.mkdirSync)((0, import_node_path46.dirname)(snap.cursor), { recursive: true });
+    (0, import_node_fs45.writeFileSync)(snap.cursor, `${nextCursor}
 `);
   } catch {
   }
@@ -15777,7 +16176,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,
@@ -15823,10 +16222,10 @@ function killProcessTree(pid, signal) {
 }
 function appendJobLog(logFile, line) {
   try {
-    (0, import_node_fs44.mkdirSync)((0, import_node_path45.dirname)(logFile), { recursive: true });
+    (0, import_node_fs45.mkdirSync)((0, import_node_path46.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 {
   }
 }
@@ -15836,7 +16235,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,
@@ -15872,10 +16271,10 @@ async function stopDetachedJob(cwd, id, opts) {
     killProcessTree(targetPid, "SIGKILL");
     await sleep(100);
   }
-  const exitFile = (0, import_node_path45.join)(dir, "exit");
-  if (!(0, import_node_fs44.existsSync)(exitFile)) {
+  const exitFile = (0, import_node_path46.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 {
     }
   }
@@ -15895,12 +16294,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_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 import_node_fs45, import_node_path46, 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_path45 = require("path");
+    import_node_fs45 = require("fs");
+    import_node_path46 = require("path");
     init_workspace_scratch();
     init_wait_for_turn();
     MAX_JOB_CONTINUES = 8;
@@ -17935,7 +18334,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, {
@@ -18111,11 +18510,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();
@@ -18267,20 +18666,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 {
@@ -18292,17 +18691,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();
@@ -18543,7 +18942,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_path46.join)(process.cwd(), "package.json");
+  return cjsFile || process.argv[1] || (0, import_node_path47.join)(process.cwd(), "package.json");
 }
 function openReadonlySqlite(file) {
   const req = (0, import_node_module5.createRequire)(thisModuleFile2());
@@ -18561,21 +18960,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_path46.join)(CURSOR_SDK_STORE, hash, "agents.ndjson");
-    if (!(0, import_node_fs47.existsSync)(agentsFile)) continue;
+    const agentsFile = (0, import_node_path47.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;
     }
@@ -18599,7 +18998,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);
@@ -18625,18 +19024,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_path46.join)((0, import_node_os14.tmpdir)(), "sideboard-conductor-"));
-  const snapshot = (0, import_node_path46.join)(tmp, "conductor.db");
+  const tmp = (0, import_node_fs48.mkdtempSync)((0, import_node_path47.join)((0, import_node_os14.tmpdir)(), "sideboard-conductor-"));
+  const snapshot = (0, import_node_path47.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 {
         }
       }
@@ -18712,22 +19111,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_path46.join)((0, import_node_os14.tmpdir)(), "sideboard-conductor-"));
-  const snapshot = (0, import_node_path46.join)(tmp, "conductor.db");
+  const tmp = (0, import_node_fs48.mkdtempSync)((0, import_node_path47.join)((0, import_node_os14.tmpdir)(), "sideboard-conductor-"));
+  const snapshot = (0, import_node_path47.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 {
         }
       }
@@ -18745,7 +19144,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;
@@ -18808,31 +19207,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_path46, import_node_module5, CONDUCTOR_APP_SUPPORT, CONDUCTOR_DB, CURSOR_SDK_STORE;
+var import_node_child_process5, import_node_fs48, import_node_os14, import_node_path47, 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_path46 = require("path");
+    import_node_path47 = require("path");
     import_node_module5 = require("module");
     init_worktree();
     init_thread_store();
-    CONDUCTOR_APP_SUPPORT = (0, import_node_path46.join)(
+    CONDUCTOR_APP_SUPPORT = (0, import_node_path47.join)(
       process.env.HOME ?? "",
       "Library",
       "Application Support",
       "com.conductor.app"
     );
-    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");
+    CONDUCTOR_DB = (0, import_node_path47.join)(CONDUCTOR_APP_SUPPORT, "conductor.db");
+    CURSOR_SDK_STORE = (0, import_node_path47.join)(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
   }
 });
 
@@ -18899,7 +19298,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 {
@@ -19041,7 +19440,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);
@@ -19108,7 +19507,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
@@ -19118,11 +19517,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();
@@ -19135,7 +19534,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
   });
@@ -19143,7 +19542,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);
@@ -19277,11 +19676,11 @@ new file mode 100644
   };
 }
 async function untrackedPatch(worktreePath, path, maxHunk) {
-  const abs = (0, import_node_path47.join)(worktreePath, path);
+  const abs = (0, import_node_path48.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 {
@@ -19748,9 +20147,9 @@ async function getDiff(worktreePath, repoPath, opts) {
 }
 function statWorktreePath(worktreePath, relativePath) {
   assertSafeRelativePath(relativePath);
-  const abs = (0, import_node_path47.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_path48.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";
@@ -19779,8 +20178,8 @@ function isImageRelativePath(relativePath) {
 function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? DEFAULT_UPLOAD_MAX_BYTES;
-  const abs = (0, import_node_path47.join)(worktreePath, relativePath);
-  const st = (0, import_node_fs49.statSync)(abs);
+  const abs = (0, import_node_path48.join)(worktreePath, relativePath);
+  const st = (0, import_node_fs50.statSync)(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
@@ -19789,7 +20188,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"),
@@ -19799,12 +20198,12 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
 function readWorktreeFile(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? 2e5;
-  const abs = (0, import_node_path47.join)(worktreePath, relativePath);
-  const st = (0, import_node_fs49.statSync)(abs);
+  const abs = (0, import_node_path48.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;
@@ -19847,9 +20246,9 @@ function assertSafeRelativePath(relativePath) {
 }
 function writeWorktreeFile(worktreePath, relativePath, content) {
   assertSafeRelativePath(relativePath);
-  const abs = (0, import_node_path47.join)(worktreePath, relativePath);
-  (0, import_node_fs49.mkdirSync)((0, import_node_path47.dirname)(abs), { recursive: true });
-  (0, import_node_fs49.writeFileSync)(abs, content, "utf8");
+  const abs = (0, import_node_path48.join)(worktreePath, relativePath);
+  (0, import_node_fs50.mkdirSync)((0, import_node_path48.dirname)(abs), { recursive: true });
+  (0, import_node_fs50.writeFileSync)(abs, content, "utf8");
   return { path: relativePath };
 }
 async function getWorktreeDirtyStat(worktreePath) {
@@ -19889,12 +20288,12 @@ async function getDiffSummary(worktreePath, repoPath, opts) {
     truncated: full.files.length > maxFiles
   };
 }
-var import_node_fs49, import_node_path47, mergeBaseCache, MERGE_BASE_TTL_MS, SHA_RE, IMAGE_EXTENSIONS2, DEFAULT_UPLOAD_MAX_BYTES;
+var import_node_fs50, import_node_path48, 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_path47 = require("path");
+    import_node_fs50 = require("fs");
+    import_node_path48 = require("path");
     init_run();
     init_worktree();
     mergeBaseCache = /* @__PURE__ */ new Map();
@@ -20251,7 +20650,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;
@@ -20270,19 +20669,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_path48.join)(dir, entry, "SKILL.md");
-    if (!(0, import_node_fs50.existsSync)(skillMd)) continue;
+    const skillMd = (0, import_node_path49.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;
     }
@@ -20291,24 +20690,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_path48.join)(dir, "SKILL.md"), "cli");
+      const skill = readSkill((0, import_node_path49.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_path48.join)(dir, entry);
+      const full = (0, import_node_path49.join)(dir, entry);
       try {
-        if (!(0, import_node_fs50.statSync)(full).isDirectory()) continue;
+        if (!(0, import_node_fs51.statSync)(full).isDirectory()) continue;
       } catch {
         continue;
       }
@@ -20326,17 +20725,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_path48.join)(worktreePath, rel), "workspace", collected);
+    scanSkillsDir((0, import_node_path49.join)(worktreePath, rel), "workspace", collected);
   }
   for (const abs of [
-    (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")
+    (0, import_node_path49.join)(home, ".claude/skills"),
+    (0, import_node_path49.join)(home, ".cursor/skills"),
+    (0, import_node_path49.join)(home, ".sideboard/skills"),
+    (0, import_node_path49.join)(home, ".brightsy/skills")
   ]) {
     scanSkillsDir(abs, "user", collected);
   }
-  scanClaudePluginSkills((0, import_node_path48.join)(home, ".claude/plugins"), collected);
+  scanClaudePluginSkills((0, import_node_path49.join)(home, ".claude/plugins"), collected);
   collected.push(...bundledSkills());
   const rank = {
     workspace: 0,
@@ -20362,7 +20761,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) {
@@ -20376,13 +20775,13 @@ function readSkillBody(skillPath, maxChars = 12e3) {
 
 \u2026(truncated)` : raw;
 }
-var import_node_fs50, import_node_os15, import_node_path48, BUNDLED_SKILL_PREFIX;
+var import_node_fs51, import_node_os15, import_node_path49, 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_path48 = require("path");
+    import_node_path49 = require("path");
     init_long_running();
     BUNDLED_SKILL_PREFIX = "bundled:";
   }
@@ -20537,7 +20936,7 @@ function compiledModuleDir() {
   try {
     const url = import_meta4.url;
     if (typeof url === "string" && url.length > 0) {
-      return (0, import_node_path49.dirname)((0, import_node_url4.fileURLToPath)(url));
+      return (0, import_node_path50.dirname)((0, import_node_url4.fileURLToPath)(url));
     }
   } catch {
   }
@@ -20545,8 +20944,8 @@ function compiledModuleDir() {
 }
 function detachedJobScriptIn(dir) {
   for (const name of DETACHED_JOB_FILENAMES) {
-    const script = (0, import_node_path49.join)(dir, "scripts", name);
-    if ((0, import_node_fs51.existsSync)(script)) return script;
+    const script = (0, import_node_path50.join)(dir, "scripts", name);
+    if ((0, import_node_fs52.existsSync)(script)) return script;
   }
   return null;
 }
@@ -20563,7 +20962,7 @@ function resolveDetachedJobScript() {
   for (let i = 0; i < 8; i++) {
     const candidate = detachedJobScriptIn(dir);
     if (candidate) return candidate;
-    const parent = (0, import_node_path49.dirname)(dir);
+    const parent = (0, import_node_path50.dirname)(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -20574,12 +20973,12 @@ function formatDetachedJobInvoke(scriptPath) {
   if (resolved) return `node ${JSON.stringify(resolved)}`;
   return "node scripts/detached-job.cjs";
 }
-var import_node_fs51, import_node_path49, import_node_url4, import_meta4, DETACHED_JOB_FILENAMES;
+var import_node_fs52, import_node_path50, 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_path49 = require("path");
+    import_node_fs52 = require("fs");
+    import_node_path50 = require("path");
     import_node_url4 = require("url");
     init_packaged_runtime();
     import_meta4 = {};
@@ -20614,6 +21013,34 @@ function formatRenameBranchDirective(thread, opts) {
   }
   return lines.join("\n");
 }
+function localhostPreviewUrl(port) {
+  return `http://localhost:${port}`;
+}
+function describeLiveDevRun(run2) {
+  const url = localhostPreviewUrl(run2.port);
+  if (run2.preview === "window") {
+    return `${run2.scriptName} Electron window (renderer ${url})`;
+  }
+  return `${run2.scriptName} ${url}`;
+}
+function formatDevAccessHint(runs) {
+  const live = (runs ?? []).filter(
+    (r) => Number.isFinite(r.port) && r.port > 0
+  );
+  if (live.length === 1) {
+    const r = live[0];
+    const url = localhostPreviewUrl(r.port);
+    if (r.preview === "window") {
+      return `This worktree's Dev app is the Electron window (${r.scriptName}). Renderer origin ${url} \u2014 curl to confirm Vite; do not open it in a browser (no preload/IPC). Do not guess :3000.`;
+    }
+    return `This worktree's Dev app is ${url} (${r.scriptName}). Open that URL (browser, curl, Playwright) \u2014 do not guess :3000.`;
+  }
+  if (live.length > 1) {
+    const bits = live.map(describeLiveDevRun).join("; ");
+    return `This worktree's Dev apps: ${bits}. preview=url \u2192 open the URL; preview=window \u2192 Electron window is the app. Do not guess :3000.`;
+  }
+  return "To open the project Dev app: MCP `run_dev_script` (same as the desktop Dev button) returns `{url, port, preview}` (`SIDEBOARD_PORT`, not 3000). preview=url \u2192 open that URL (browser, curl, Playwright). preview=window \u2192 Electron: the native window is the app; url is renderer/HMR only (no preload/IPC in a browser). If already running, `list_run_scripts` `active[].url`. `stop_dev_script` to stop.";
+}
 function formatWorktreeDirective(thread, opts) {
   const worktree = normPath3(thread.worktreePath);
   const repo = normPath3(thread.repoPath);
@@ -20661,6 +21088,8 @@ function formatWorktreeDirective(thread, opts) {
     '- Sideboard git buttons send short phrases ("Commit and push.", "Ready for review.", "Merge PR.", \u2026) with their meaning attached \u2014 act on them without asking for clarification. If the user gives a goal (Greptile 5/5, CI green, until checks pass), you get the watch-fix-push playbook with that request.'
   );
   lines.push("");
+  lines.push(formatDevAccessHint(opts?.activeRuns));
+  lines.push("");
   lines.push(formatProcessGuideDirective({ worktreePath: thread.worktreePath }));
   return lines.join("\n");
 }
@@ -20739,9 +21168,9 @@ function formatPrGateDirective() {
 }
 function formatProcessGuideDirective(opts) {
   const worktree = opts?.worktreePath?.trim();
-  const hasGraphSkill = !!worktree && (0, import_node_fs52.existsSync)((0, import_node_path50.join)(worktree, ".claude/skills/graph-engineering/SKILL.md"));
-  const hasReviewSkill = !!worktree && (0, import_node_fs52.existsSync)((0, import_node_path50.join)(worktree, ".claude/skills/review/SKILL.md"));
-  const hasInstallSkill = !!worktree && (0, import_node_fs52.existsSync)((0, import_node_path50.join)(worktree, ".claude/skills/worktree-install/SKILL.md"));
+  const hasGraphSkill = !!worktree && (0, import_node_fs53.existsSync)((0, import_node_path51.join)(worktree, ".claude/skills/graph-engineering/SKILL.md"));
+  const hasReviewSkill = !!worktree && (0, import_node_fs53.existsSync)((0, import_node_path51.join)(worktree, ".claude/skills/review/SKILL.md"));
+  const hasInstallSkill = !!worktree && (0, import_node_fs53.existsSync)((0, import_node_path51.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,
@@ -20761,12 +21190,12 @@ function formatLongRunningDirective(opts) {
     "- Hanging, no useful output, or the wrong thing \u2192 `stop_job` (or the helper with `stop <id>`). Do not stop a pack/test/deploy that is clearly making progress.",
     "- Stay in the loop until stillRunning is false (or you stopped it). ok \u2192 finish the task. failed / stopped \u2192 read the log, fix or narrow the command, start once.",
     "State: `.context/.sideboard/detached-jobs/<id>/` (local scratch). Full guide: `/long-running` (always available).",
-    "Project Dev / run scripts (`.sideboard` `[scripts.run.*]`, same as the desktop Dev button): use MCP `list_run_scripts` / `run_dev_script` / `stop_dev_script` \u2014 logs and Stop live in the thread UI. Do not detached-job or shell-spawn that same command."
+    "Project Dev / run scripts (`.sideboard` `[scripts.run.*]`, same as the desktop Dev button): use MCP `list_run_scripts` / `run_dev_script` / `stop_dev_script` \u2014 logs and Stop live in the thread UI. Do not detached-job or shell-spawn that same command. `run_dev_script` returns `{url, port, preview}` (`SIDEBOARD_PORT`). preview=url \u2192 open that URL; preview=window \u2192 Electron window is the app (url is renderer/HMR only). Never guess :3000."
   ].join("\n");
 }
 function formatLongRunningReminder(opts) {
   const invoke = formatDetachedJobInvoke(opts?.scriptPath);
-  return `Long jobs: \`${invoke} start <id> -- <cmd>\`, loop wait_for_job (or detached-job wait). The log pane updates from wait JSON; present_artifact type=log is optional. stop_job if hanging or wrong. Do not say you will let the user know later \u2014 stay in the turn. Project Dev button: list_run_scripts / run_dev_script / stop_dev_script (UI-connected \u2014 not detached-job).`;
+  return `Long jobs: \`${invoke} start <id> -- <cmd>\`, loop wait_for_job (or detached-job wait). The log pane updates from wait JSON; present_artifact type=log is optional. stop_job if hanging or wrong. Do not say you will let the user know later \u2014 stay in the turn. Project Dev button: list_run_scripts / run_dev_script / stop_dev_script (UI-connected \u2014 not detached-job). ${formatDevAccessHint(opts?.activeRuns)}`;
 }
 function formatArtifactDirective() {
   return [
@@ -20778,14 +21207,14 @@ function formatArtifactDirective() {
   ].join("\n");
 }
 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. Do not say artifacts/CMS UI are unavailable. Dev / preview: run_dev_script (same as the Dev button); stop_dev_script to stop.";
+  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. 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; stop_dev_script to stop.";
 }
-var import_node_fs52, import_node_path50, PR_GOAL_RE, GITHUB_TICKET_REF, KEYED_TICKET_REF;
+var import_node_fs53, import_node_path51, 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_path50 = require("path");
+    import_node_fs53 = require("fs");
+    import_node_path51 = require("path");
     init_git_auth_mode();
     init_branch_prefix();
     init_worktree_labels();
@@ -21009,40 +21438,40 @@ __export(plan_file_exports, {
   writePlanFile: () => writePlanFile
 });
 function ensureAttachmentsGitignore(worktreePath) {
-  const gitignoreAbs = (0, import_node_path51.join)(worktreePath, ATTACHMENTS_DIR, ".gitignore");
-  if ((0, import_node_fs53.existsSync)(gitignoreAbs)) return;
-  (0, import_node_fs53.mkdirSync)((0, import_node_path51.dirname)(gitignoreAbs), { recursive: true });
-  (0, import_node_fs53.writeFileSync)(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
+  const gitignoreAbs = (0, import_node_path52.join)(worktreePath, ATTACHMENTS_DIR, ".gitignore");
+  if ((0, import_node_fs54.existsSync)(gitignoreAbs)) return;
+  (0, import_node_fs54.mkdirSync)((0, import_node_path52.dirname)(gitignoreAbs), { recursive: true });
+  (0, import_node_fs54.writeFileSync)(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
 }
 function planFileAbs(worktreePath) {
-  return (0, import_node_path51.join)(worktreePath, PLAN_FILE_REL);
+  return (0, import_node_path52.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_path51.join)(worktreePath, `${LEGACY_ATTACHMENTS_DIR}/plan.md`)) ?? readTextIfPresent2((0, import_node_path51.join)(worktreePath, LEGACY_PLAN_FILE_REL));
+  return readTextIfPresent2(planFileAbs(worktreePath)) ?? readTextIfPresent2((0, import_node_path52.join)(worktreePath, `${LEGACY_ATTACHMENTS_DIR}/plan.md`)) ?? readTextIfPresent2((0, import_node_path52.join)(worktreePath, LEGACY_PLAN_FILE_REL));
 }
 function writePlanFile(worktreePath, content) {
   ensureAttachmentsGitignore(worktreePath);
   const abs = planFileAbs(worktreePath);
-  (0, import_node_fs53.mkdirSync)((0, import_node_path51.dirname)(abs), { recursive: true });
+  (0, import_node_fs54.mkdirSync)((0, import_node_path52.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_path51;
+var import_node_fs54, import_node_path52;
 var init_plan_file = __esm({
   "src/plan/plan-file.ts"() {
     "use strict";
-    import_node_fs53 = require("fs");
-    import_node_path51 = require("path");
+    import_node_fs54 = require("fs");
+    import_node_path52 = require("path");
     init_workspace_scratch();
     init_plan_present();
     init_plan_present();
@@ -21102,7 +21531,7 @@ function setCaffeinateHoldHooks(next) {
   hooks = next;
 }
 function caffeinateHoldPath() {
-  return (0, import_node_path52.join)(appDataDir(), "caffeinate-hold.json");
+  return (0, import_node_path53.join)(appDataDir(), "caffeinate-hold.json");
 }
 function processAlive(pid) {
   if (hooks.processAlive) return hooks.processAlive(pid);
@@ -21136,9 +21565,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,
@@ -21160,7 +21589,7 @@ function writeHold(pid, threadIds) {
 }
 function clearHold() {
   try {
-    (0, import_node_fs54.unlinkSync)(caffeinateHoldPath());
+    (0, import_node_fs55.unlinkSync)(caffeinateHoldPath());
   } catch {
   }
 }
@@ -21245,13 +21674,13 @@ function releaseCaffeinateHoldForThread(threadId) {
   }
   return setCaffeinateHold(false, { threadId: id });
 }
-var import_node_child_process6, import_node_fs54, import_node_path52, hooks;
+var import_node_child_process6, import_node_fs55, import_node_path53, 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_path52 = require("path");
+    import_node_fs55 = require("fs");
+    import_node_path53 = require("path");
     init_paths();
     init_private_file();
     hooks = {};
@@ -21260,7 +21689,7 @@ var init_caffeinate_hold = __esm({
 
 // src/store/schedules.ts
 function schedulesPath() {
-  return (0, import_node_path53.join)(appDataDir(), "schedules.json");
+  return (0, import_node_path54.join)(appDataDir(), "schedules.json");
 }
 function parseDurationMs(every) {
   const m = every.trim().match(DURATION_RE);
@@ -21360,9 +21789,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 {
@@ -21474,13 +21903,13 @@ function recordScheduleRun(id, result) {
   writeAll2(rows);
   return next;
 }
-var import_node_crypto11, import_node_fs55, import_node_path53, import_croner, DURATION_RE, UNIT_MS;
+var import_node_crypto11, import_node_fs56, import_node_path54, import_croner, DURATION_RE, UNIT_MS;
 var init_schedules = __esm({
   "src/store/schedules.ts"() {
     "use strict";
     import_node_crypto11 = require("crypto");
-    import_node_fs55 = require("fs");
-    import_node_path53 = require("path");
+    import_node_fs56 = require("fs");
+    import_node_path54 = require("path");
     import_croner = require("croner");
     init_orchestrator_capable();
     init_paths();
@@ -21636,9 +22065,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();
@@ -21664,11 +22093,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();
   }
 });
@@ -21822,14 +22251,14 @@ async function startOrchestration(opts) {
   }
   return updated;
 }
-var import_node_events, import_node_crypto12, 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_crypto12, 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";
     import_node_events = require("events");
     init_outbound_watch();
     import_node_crypto12 = require("crypto");
-    import_node_fs57 = require("fs");
+    import_node_fs58 = require("fs");
     init_error_detail();
     init_run();
     init_stale_lock();
@@ -21841,6 +22270,7 @@ var init_orchestrator = __esm({
     init_agent_git_actions();
     init_pr_merge_archive();
     init_conductor();
+    init_dev_preview();
     init_setup_log();
     init_orphan_cleanup();
     init_history_cleanup();
@@ -22006,7 +22436,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" });
             }
@@ -22035,7 +22465,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;
@@ -22722,8 +23152,13 @@ var init_orchestrator = __esm({
               SLACK_REPLY_FORMATTING
             ].join("\n") : null
           ].filter(Boolean).join("\n") : null;
+          const worktreeActiveRuns = thread.agent !== "brightsy" && !isOrchestratorThread(thread) && thread.worktreePath ? annotateDevAccessRuns(
+            mergeWorktreeActiveRuns(threadsSharingWorktree(thread.worktreePath)).activeRuns,
+            listRunScripts(thread.worktreePath, thread.repoPath),
+            thread.worktreePath
+          ) : [];
           const artifactReminder = thread.agent !== "brightsy" ? formatUiReminder() : null;
-          const longRunningReminder = thread.agent !== "brightsy" && !isOrchestratorThread(thread) ? formatLongRunningReminder() : null;
+          const longRunningReminder = thread.agent !== "brightsy" && !isOrchestratorThread(thread) ? formatLongRunningReminder({ activeRuns: worktreeActiveRuns }) : null;
           const worktreeReminder = thread.agent !== "brightsy" && !isOrchestratorThread(thread) ? formatWorktreeReminder() : null;
           const optionalServicesReminder = thread.agent !== "brightsy" && !isOrchestratorThread(thread) ? formatOptionalServicesReminder(loadAppSettings().integrations) : null;
           const issueTicket = issueTicketFromThread(thread, resolveEffectiveIssueSource());
@@ -22783,7 +23218,14 @@ var init_orchestrator = __esm({
               8e3,
               "resolveGithubRepoSlug"
             ).catch(() => null),
-            gitAuthMode
+            gitAuthMode,
+            activeRuns: annotateDevAccessRuns(
+              mergeWorktreeActiveRuns(
+                threadsSharingWorktree(fresh.worktreePath)
+              ).activeRuns,
+              listRunScripts(fresh.worktreePath, fresh.repoPath),
+              fresh.worktreePath
+            )
           });
           const artifactDirective = isBrightsy ? null : formatArtifactDirective();
           const longRunningDirective = isBrightsy || isOrchestration ? null : formatLongRunningDirective();
@@ -24336,7 +24778,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.`
@@ -24420,7 +24862,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_crypto15 = require("crypto");
-var import_node_path56 = require("path");
+var import_node_path57 = require("path");
 init_orchestrator();
 init_worktree();
 
@@ -26137,6 +26579,8 @@ function resolveRunScriptThreadRef(ref) {
 }
 
 // src/mcp/server.ts
+init_dev_preview();
+init_instructions();
 init_wait_for_turn();
 init_wait_for_job();
 init_message_parts();
@@ -27840,27 +28284,27 @@ init_gh_errors();
 init_git_auth_mode();
 
 // src/board/load-home-board.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_worktree();
 init_paths();
 
 // src/board/board-pins.ts
 var import_node_crypto14 = require("crypto");
-var import_node_fs58 = require("fs");
-var import_node_path54 = require("path");
+var import_node_fs59 = require("fs");
+var import_node_path55 = require("path");
 init_paths();
 init_home_board();
 var FILE = "home-board-pins.json";
 var VERSION = 1;
 function pinsFile() {
-  return (0, import_node_path54.join)(appDataDir(), FILE);
+  return (0, import_node_path55.join)(appDataDir(), FILE);
 }
 function readDisk() {
   const path = pinsFile();
-  if (!(0, import_node_fs58.existsSync)(path)) return [];
+  if (!(0, import_node_fs59.existsSync)(path)) return [];
   try {
-    const raw = JSON.parse((0, import_node_fs58.readFileSync)(path, "utf8"));
+    const raw = JSON.parse((0, import_node_fs59.readFileSync)(path, "utf8"));
     if (raw?.version !== VERSION || !Array.isArray(raw.items)) return [];
     return raw.items.filter((item) => item?.id && item.kind && item.ref);
   } catch {
@@ -27868,8 +28312,8 @@ function readDisk() {
   }
 }
 function writeDisk(items) {
-  (0, import_node_fs58.mkdirSync)(appDataDir(), { recursive: true });
-  (0, import_node_fs58.writeFileSync)(pinsFile(), JSON.stringify({ version: VERSION, items }, null, 2), "utf8");
+  (0, import_node_fs59.mkdirSync)(appDataDir(), { recursive: true });
+  (0, import_node_fs59.writeFileSync)(pinsFile(), JSON.stringify({ version: VERSION, items }, null, 2), "utf8");
 }
 function listBoardPins() {
   return readDisk();
@@ -27890,7 +28334,7 @@ function homeBoardWorkspaceKey(workspaces) {
   return workspaces.map((w) => w.path).filter(Boolean).sort().join("\n");
 }
 function cacheFile() {
-  return (0, import_node_path55.join)(appDataDir(), "home-board-cache.json");
+  return (0, import_node_path56.join)(appDataDir(), "home-board-cache.json");
 }
 function emptyInputs() {
   return {
@@ -27916,9 +28360,9 @@ function shouldCacheHomeBoardInputs(inputs) {
 }
 function readDiskCache() {
   const path = cacheFile();
-  if (!(0, import_node_fs59.existsSync)(path)) return null;
+  if (!(0, import_node_fs60.existsSync)(path)) return null;
   try {
-    const raw = JSON.parse((0, import_node_fs59.readFileSync)(path, "utf8"));
+    const raw = JSON.parse((0, import_node_fs60.readFileSync)(path, "utf8"));
     if (raw?.version !== CACHE_VERSION || typeof raw.fetchedAt !== "number") {
       return null;
     }
@@ -27932,8 +28376,8 @@ function readDiskCache() {
 }
 function writeDiskCache(entry) {
   try {
-    (0, import_node_fs59.mkdirSync)(appDataDir(), { recursive: true });
-    (0, import_node_fs59.writeFileSync)(cacheFile(), JSON.stringify(entry), "utf8");
+    (0, import_node_fs60.mkdirSync)(appDataDir(), { recursive: true });
+    (0, import_node_fs60.writeFileSync)(cacheFile(), JSON.stringify(entry), "utf8");
   } catch {
   }
 }
@@ -28254,6 +28698,9 @@ async function createOrchChildThread(orch, args, resolveNewThreadOptions2) {
     return { ok: false, text: `create_thread failed: ${message}` };
   }
 }
+function previewHint(preview) {
+  return preview === "window" ? "Electron: the native window is the app. url is the renderer/HMR origin only \u2014 do not open it in a browser (no preload/IPC)." : "Open url in a browser, curl, or Playwright to use the app.";
+}
 async function startMcpServer() {
   const orch = getOrchestrator();
   try {
@@ -28320,7 +28767,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_path56.basename)(t.repoPath) || t.repoPath;
+          const repo = t.repoPath === GLOBAL_WORKSPACE_ID ? "Orchestration" : (0, import_node_path57.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);
@@ -28577,15 +29024,27 @@ async function startMcpServer() {
   );
   server.tool(
     "list_run_scripts",
-    "List .sideboard/.conductor run scripts for this thread (same menu as the desktop Dev button) and which are active. Worktree turns may omit ref (uses cwd).",
+    "List .sideboard/.conductor run scripts for this thread (same menu as the desktop Dev button) and which are active. Each script and active run includes preview: url (open http://localhost:<SIDEBOARD_PORT>) or window (Electron: native window is the app; url is renderer/HMR only). Never guess :3000. Worktree turns may omit ref (uses cwd).",
     {
       ref: import_zod9.z.string().optional().describe("Thread id. Omit on a worktree turn (uses cwd).")
     },
     async ({ ref }) => {
       try {
         const threadRef = resolveRunScriptThreadRef(ref);
-        const scripts = orch.listThreadRunScripts(threadRef);
-        const active = orch.getActiveRuns(threadRef);
+        const worktreePath = orch.getThread(threadRef)?.worktreePath ?? "";
+        const scripts = orch.listThreadRunScripts(threadRef).map((script) => ({
+          ...script,
+          preview: runScriptPreview(script, worktreePath)
+        }));
+        const active = orch.getActiveRuns(threadRef).map((run2) => {
+          const preview = activeRunPreview(run2.scriptName, scripts, worktreePath);
+          return {
+            ...run2,
+            url: localhostPreviewUrl(run2.port),
+            preview,
+            hint: previewHint(preview)
+          };
+        });
         return mcpJson({ scripts, active, ref: threadRef });
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
@@ -28595,7 +29054,7 @@ async function startMcpServer() {
   );
   server.tool(
     "run_dev_script",
-    "Start a .sideboard/.conductor run script (same as the desktop Dev / play button). Logs and Stop appear in the thread UI \u2014 do not detached-job or shell-spawn the same command. Returns the allocated port. Worktree turns may omit ref (uses cwd). Omit name for the default script.",
+    "Start a .sideboard/.conductor run script (same as the desktop Dev / play button). Logs and Stop appear in the thread UI \u2014 do not detached-job or shell-spawn the same command. Returns {port, ports, url, preview}. preview=url \u2192 open url (browser, curl, Playwright). preview=window \u2192 Electron: the native window is the app; url is renderer/HMR only (no preload/IPC in a browser). The port is allocated SIDEBOARD_PORT, not 3000. Worktree turns may omit ref (uses cwd). Omit name for the default script.",
     {
       ref: import_zod9.z.string().optional().describe("Thread id. Omit on a worktree turn (uses cwd)."),
       name: import_zod9.z.string().optional().describe("Script name from list_run_scripts (default script if omitted).")
@@ -28604,11 +29063,16 @@ async function startMcpServer() {
       try {
         const threadRef = resolveRunScriptThreadRef(ref);
         const result = await orch.startDev(threadRef, name);
+        const worktreePath = orch.getThread(threadRef)?.worktreePath ?? "";
+        const scripts = orch.listThreadRunScripts(threadRef);
+        const preview = activeRunPreview(result.scriptName, scripts, worktreePath);
         return mcpJson({
           port: result.port,
           scriptName: result.scriptName,
           ports: result.ports,
-          url: `http://localhost:${result.port}`,
+          url: localhostPreviewUrl(result.port),
+          preview,
+          hint: previewHint(preview),
           ref: threadRef
         });
       } catch (err) {