@sideboard-ai/core 0.1.85 → 0.1.87

package/dist/index.cjs

@@ -78,10 +78,139 @@ var init_thinking_effort = __esm({
   }
 });
 
+// src/hook/convention-setup.ts
+function isFile(path2) {
+  try {
+    return (0, import_node_fs.statSync)(path2).isFile();
+  } catch {
+    return false;
+  }
+}
+function normPath(p) {
+  return p.replace(/\/+$/, "");
+}
+function findConventionSetup(worktreePath, repoPath) {
+  const roots = [
+    { root: worktreePath, where: "worktree" }
+  ];
+  if (repoPath && normPath(repoPath) !== normPath(worktreePath)) {
+    roots.push({ root: repoPath, where: "main repo" });
+  }
+  for (const { root, where } of roots) {
+    for (const relPath of CONVENTION_SETUP_RELPATHS) {
+      const absPath = (0, import_node_path.join)(root, relPath);
+      if (!(0, import_node_fs.existsSync)(absPath) || !isFile(absPath)) continue;
+      return {
+        relPath,
+        absPath,
+        command: `bash ${JSON.stringify(absPath)}`,
+        source: `${relPath} (${where})`
+      };
+    }
+  }
+  return null;
+}
+function hasConventionSetup(worktreePath, repoPath) {
+  return findConventionSetup(worktreePath, repoPath) !== null;
+}
+var import_node_fs, import_node_path, CONVENTION_SETUP_RELPATHS;
+var init_convention_setup = __esm({
+  "src/hook/convention-setup.ts"() {
+    "use strict";
+    import_node_fs = require("fs");
+    import_node_path = require("path");
+    CONVENTION_SETUP_RELPATHS = [
+      "script/setup",
+      "bin/setup",
+      "scripts/setup.sh",
+      "scripts/setup"
+    ];
+  }
+});
+
+// src/hook/cursor-worktrees.ts
+function loadCursorWorktreesJson(rootPath) {
+  const path2 = (0, import_node_path2.join)(rootPath, ".cursor", "worktrees.json");
+  if (!(0, import_node_fs2.existsSync)(path2)) return null;
+  try {
+    return JSON.parse((0, import_node_fs2.readFileSync)(path2, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function resolveSetupSpec(config) {
+  if (process.platform === "win32") {
+    return config["setup-worktree-windows"] ?? config["setup-worktree"] ?? null;
+  }
+  return config["setup-worktree-unix"] ?? config["setup-worktree"] ?? null;
+}
+async function runCursorWorktreeSetup(repoPath, worktreePath, onLine) {
+  const fromWorktree = loadCursorWorktreesJson(worktreePath);
+  const fromRepo = worktreePath !== repoPath ? loadCursorWorktreesJson(repoPath) : null;
+  const config = fromWorktree ?? fromRepo;
+  if (!config) return { ran: false, exitCode: null, source: null };
+  const spec = resolveSetupSpec(config);
+  if (!spec) return { ran: false, exitCode: null, source: null };
+  const sourceLabel = fromWorktree ? ".cursor/worktrees.json (worktree)" : ".cursor/worktrees.json (main repo)";
+  const env = {
+    ...process.env,
+    ROOT_WORKTREE_PATH: repoPath
+  };
+  if (process.platform === "win32") {
+    env.ROOT_WORKTREE_PATH = repoPath;
+  }
+  const commands = Array.isArray(spec) ? spec : [spec.endsWith(".sh") || spec.endsWith(".ps1") ? (0, import_node_path2.join)(
+    fromWorktree ? worktreePath : repoPath,
+    ".cursor",
+    spec
+  ) : spec];
+  let lastExit = 0;
+  for (const command of commands) {
+    const isScriptPath = typeof spec === "string" && (spec.endsWith(".sh") || spec.endsWith(".ps1"));
+    const shell = process.platform === "win32" ? "powershell" : "bash";
+    const args = process.platform === "win32" ? isScriptPath ? ["-File", command] : ["-Command", command] : isScriptPath ? [command] : ["-lc", command];
+    onLine?.(`[cursor setup] ${command}`);
+    const child = (0, import_execa.execa)(shell, args, {
+      cwd: worktreePath,
+      reject: false,
+      env
+    });
+    if (child.stdout && onLine) {
+      const rl = (0, import_node_readline.createInterface)({ input: child.stdout });
+      rl.on("line", onLine);
+    }
+    if (child.stderr && onLine) {
+      const rl = (0, import_node_readline.createInterface)({ input: child.stderr });
+      rl.on("line", onLine);
+    }
+    const result = await child;
+    lastExit = result.exitCode ?? null;
+    if (lastExit !== 0 && lastExit !== null) break;
+  }
+  return { ran: true, exitCode: lastExit, source: sourceLabel };
+}
+function hasCursorWorktreeSetup(worktreePath, repoPath) {
+  if (loadCursorWorktreesJson(worktreePath)) return true;
+  if (repoPath && repoPath !== worktreePath && loadCursorWorktreesJson(repoPath)) {
+    return true;
+  }
+  return false;
+}
+var import_node_fs2, import_node_path2, import_execa, import_node_readline;
+var init_cursor_worktrees = __esm({
+  "src/hook/cursor-worktrees.ts"() {
+    "use strict";
+    import_node_fs2 = require("fs");
+    import_node_path2 = require("path");
+    import_execa = require("execa");
+    import_node_readline = require("readline");
+  }
+});
+
 // src/hook/settings.ts
 function expandHome(path2) {
   if (path2.startsWith("~/") || path2 === "~") {
-    return (0, import_node_path.join)((0, import_node_os.homedir)(), path2.slice(2));
+    return (0, import_node_path3.join)((0, import_node_os.homedir)(), path2.slice(2));
   }
   return path2;
 }
@@ -94,8 +223,8 @@ function parseAvailableIn(raw) {
   return out.length ? out : void 0;
 }
 function parseSettingsFile(path2, source) {
-  if (!(0, import_node_fs.existsSync)(path2)) return null;
-  const raw = (0, import_node_fs.readFileSync)(path2, "utf8");
+  if (!(0, import_node_fs3.existsSync)(path2)) return null;
+  const raw = (0, import_node_fs3.readFileSync)(path2, "utf8");
   const data = (0, import_smol_toml.parse)(raw);
   const scripts = data.scripts ?? {};
   const setup = typeof scripts.setup === "string" ? scripts.setup : void 0;
@@ -198,15 +327,15 @@ function finalizeSettings(parsed) {
   };
 }
 function familyFiles(rootPath, source) {
-  const dir = (0, import_node_path.join)(rootPath, `.${source}`);
+  const dir = (0, import_node_path3.join)(rootPath, `.${source}`);
   return {
-    toml: (0, import_node_path.join)(dir, "settings.toml"),
-    local: (0, import_node_path.join)(dir, "settings.local.toml")
+    toml: (0, import_node_path3.join)(dir, "settings.toml"),
+    local: (0, import_node_path3.join)(dir, "settings.local.toml")
   };
 }
 function familyExists(rootPath, source) {
   const files = familyFiles(rootPath, source);
-  return (0, import_node_fs.existsSync)(files.toml) || (0, import_node_fs.existsSync)(files.local);
+  return (0, import_node_fs3.existsSync)(files.toml) || (0, import_node_fs3.existsSync)(files.local);
 }
 function detectFamily(rootPath) {
   if (familyExists(rootPath, "sideboard")) return "sideboard";
@@ -225,7 +354,7 @@ function loadAnyLocal(rootPath) {
     loadLocalToml(rootPath, "sideboard")
   );
 }
-function normPath(p) {
+function normPath2(p) {
   return p.replace(/\/+$/, "");
 }
 function loadRepoSettings(repoPath) {
@@ -239,11 +368,11 @@ function loadRepoSettings(repoPath) {
 }
 function loadWorkspaceSettings(worktreePath, repoPath) {
   const wtFamily = detectFamily(worktreePath);
-  const repoFamily = repoPath && normPath(repoPath) !== normPath(worktreePath) ? detectFamily(repoPath) : null;
+  const repoFamily = repoPath && normPath2(repoPath) !== normPath2(worktreePath) ? detectFamily(repoPath) : null;
   const wtToml = wtFamily ? loadCommittedToml(worktreePath, wtFamily) : null;
   const repoToml = repoPath && repoFamily ? loadCommittedToml(repoPath, repoFamily) : null;
   let merged = wtToml ?? repoToml;
-  if (repoPath && normPath(repoPath) !== normPath(worktreePath)) {
+  if (repoPath && normPath2(repoPath) !== normPath2(worktreePath)) {
     merged = mergeSettings(merged, loadAnyLocal(repoPath));
   }
   merged = mergeSettings(merged, loadAnyLocal(worktreePath));
@@ -257,7 +386,7 @@ function hasRepoHook(repoPath) {
 }
 function hasWorkspaceHook(worktreePath, repoPath) {
   if (hasRepoHook(worktreePath)) return true;
-  if (repoPath && normPath(repoPath) !== normPath(worktreePath) && hasRepoHook(repoPath)) {
+  if (repoPath && normPath2(repoPath) !== normPath2(worktreePath) && hasRepoHook(repoPath)) {
     return true;
   }
   return false;
@@ -269,16 +398,16 @@ function settingsSourceLabel(rootPath) {
   const family = detectFamily(rootPath);
   if (!family) return null;
   const files = familyFiles(rootPath, family);
-  if ((0, import_node_fs.existsSync)(files.toml) && (0, import_node_fs.existsSync)(files.local)) {
+  if ((0, import_node_fs3.existsSync)(files.toml) && (0, import_node_fs3.existsSync)(files.local)) {
     return `.${family}/settings.toml + local`;
   }
-  if ((0, import_node_fs.existsSync)(files.local)) return `.${family}/settings.local.toml`;
+  if ((0, import_node_fs3.existsSync)(files.local)) return `.${family}/settings.local.toml`;
   return `.${family}/settings.toml`;
 }
 function workspaceSettingsSourceLabel(worktreePath, repoPath) {
   const wt = settingsSourceLabel(worktreePath);
   if (wt) return `${wt} (worktree)`;
-  if (repoPath && normPath(repoPath) !== normPath(worktreePath)) {
+  if (repoPath && normPath2(repoPath) !== normPath2(worktreePath)) {
     const repo = settingsSourceLabel(repoPath);
     if (repo) return `${repo} (main repo)`;
   }
@@ -286,20 +415,32 @@ function workspaceSettingsSourceLabel(worktreePath, repoPath) {
 }
 function getRepoSetupInfo(worktreePath, repoPath) {
   const settings = loadWorkspaceSettings(worktreePath, repoPath);
+  const convention = findConventionSetup(worktreePath, repoPath);
+  const cursor = hasCursorWorktreeSetup(worktreePath, repoPath);
+  const hasSetupScript = Boolean(settings?.setup) || cursor || Boolean(convention);
+  let configLabel = workspaceSettingsSourceLabel(worktreePath, repoPath);
+  if (!settings?.setup) {
+    if (convention) configLabel = convention.source;
+    else if (cursor) {
+      configLabel = hasCursorWorktreeSetup(worktreePath) ? ".cursor/worktrees.json (worktree)" : ".cursor/worktrees.json (main repo)";
+    }
+  }
   return {
-    hasConfig: hasWorkspaceHook(worktreePath, repoPath),
-    hasSetupScript: Boolean(settings?.setup),
-    configLabel: workspaceSettingsSourceLabel(worktreePath, repoPath)
+    hasConfig: hasWorkspaceHook(worktreePath, repoPath) || cursor || Boolean(convention),
+    hasSetupScript,
+    configLabel
   };
 }
-var import_node_fs, import_node_os, import_node_path, import_smol_toml;
+var import_node_fs3, import_node_os, import_node_path3, import_smol_toml;
 var init_settings = __esm({
   "src/hook/settings.ts"() {
     "use strict";
-    import_node_fs = require("fs");
+    import_node_fs3 = require("fs");
     import_node_os = require("os");
-    import_node_path = require("path");
+    import_node_path3 = require("path");
     import_smol_toml = require("smol-toml");
+    init_convention_setup();
+    init_cursor_worktrees();
   }
 });
 
@@ -320,67 +461,67 @@ __export(paths_exports, {
 });
 function appDataDir() {
   const override = process.env.SIDEBOARD_APP_DATA?.trim();
-  const base = override ? override : process.platform === "darwin" ? (0, import_node_path3.join)((0, import_node_os2.homedir)(), "Library", "Application Support", "sideboard") : process.platform === "win32" ? (0, import_node_path3.join)(process.env.APPDATA ?? (0, import_node_path3.join)((0, import_node_os2.homedir)(), "AppData", "Roaming"), "sideboard") : (0, import_node_path3.join)((0, import_node_os2.homedir)(), ".local", "share", "sideboard");
-  (0, import_node_fs2.mkdirSync)(base, { recursive: true });
+  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 });
   return base;
 }
 function threadsDir() {
-  const dir = (0, import_node_path3.join)(appDataDir(), "threads");
-  (0, import_node_fs2.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_node_path5.join)(appDataDir(), "threads");
+  (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
   return dir;
 }
 function locksDir() {
-  const dir = (0, import_node_path3.join)(appDataDir(), "locks");
-  (0, import_node_fs2.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_node_path5.join)(appDataDir(), "locks");
+  (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
   return dir;
 }
 function sideboardHomeDir() {
-  const dir = (0, import_node_path3.join)((0, import_node_os2.homedir)(), "sideboard");
-  (0, import_node_fs2.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_node_path5.join)((0, import_node_os2.homedir)(), "sideboard");
+  (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
   return dir;
 }
 function sideboardReposDir() {
-  const dir = (0, import_node_path3.join)(sideboardHomeDir(), "repos");
-  (0, import_node_fs2.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_node_path5.join)(sideboardHomeDir(), "repos");
+  (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
   return dir;
 }
 function sideboardWorkspacesDir() {
-  const dir = (0, import_node_path3.join)(sideboardHomeDir(), "workspaces");
-  (0, import_node_fs2.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_node_path5.join)(sideboardHomeDir(), "workspaces");
+  (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
   return dir;
 }
 function repoSlug(repoPath) {
-  return (0, import_node_path2.basename)(repoPath.replace(/\/$/, "")) || "repo";
+  return (0, import_node_path4.basename)(repoPath.replace(/\/$/, "")) || "repo";
 }
 function worktreesRoot(repoPath) {
   const settings = loadRepoSettings(repoPath);
   if (settings?.worktreesRoot) {
-    (0, import_node_fs2.mkdirSync)(settings.worktreesRoot, { recursive: true });
+    (0, import_node_fs4.mkdirSync)(settings.worktreesRoot, { recursive: true });
     return settings.worktreesRoot;
   }
-  const dir = (0, import_node_path3.join)(sideboardWorkspacesDir(), repoSlug(repoPath));
-  (0, import_node_fs2.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_node_path5.join)(sideboardWorkspacesDir(), repoSlug(repoPath));
+  (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
   return dir;
 }
 function threadFilePath(id) {
-  return (0, import_node_path3.join)(threadsDir(), `${id}.json`);
+  return (0, import_node_path5.join)(threadsDir(), `${id}.json`);
 }
 function threadLockPath(id) {
-  return (0, import_node_path3.join)(locksDir(), `${id}.lock`);
+  return (0, import_node_path5.join)(locksDir(), `${id}.lock`);
 }
 function globalAgentCwd() {
-  const dir = (0, import_node_path3.join)(appDataDir(), "global");
-  (0, import_node_fs2.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_node_path5.join)(appDataDir(), "global");
+  (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
   return dir;
 }
-var import_node_path2, import_node_os2, import_node_path3, import_node_fs2;
+var import_node_path4, import_node_os2, import_node_path5, import_node_fs4;
 var init_paths = __esm({
   "src/store/paths.ts"() {
     "use strict";
-    import_node_path2 = require("path");
+    import_node_path4 = require("path");
     import_node_os2 = require("os");
-    import_node_path3 = require("path");
-    import_node_fs2 = require("fs");
+    import_node_path5 = require("path");
+    import_node_fs4 = require("fs");
     init_settings();
   }
 });
@@ -422,22 +563,22 @@ var init_nested_electron_env = __esm({
 
 // src/store/private-file.ts
 function writePrivateFile(path2, contents) {
-  (0, import_node_fs3.mkdirSync)((0, import_node_path4.dirname)(path2), { recursive: true });
-  (0, import_node_fs3.writeFileSync)(path2, contents, { encoding: "utf8", mode: PRIVATE_FILE_MODE });
+  (0, import_node_fs5.mkdirSync)((0, import_node_path6.dirname)(path2), { recursive: true });
+  (0, import_node_fs5.writeFileSync)(path2, contents, { encoding: "utf8", mode: PRIVATE_FILE_MODE });
   chmodOwnerOnly(path2);
 }
 function chmodOwnerOnly(path2) {
   try {
-    (0, import_node_fs3.chmodSync)(path2, PRIVATE_FILE_MODE);
+    (0, import_node_fs5.chmodSync)(path2, PRIVATE_FILE_MODE);
   } catch {
   }
 }
-var import_node_fs3, import_node_path4, PRIVATE_FILE_MODE;
+var import_node_fs5, import_node_path6, PRIVATE_FILE_MODE;
 var init_private_file = __esm({
   "src/store/private-file.ts"() {
     "use strict";
-    import_node_fs3 = require("fs");
-    import_node_path4 = require("path");
+    import_node_fs5 = require("fs");
+    import_node_path6 = require("path");
     PRIVATE_FILE_MODE = 384;
   }
 });
@@ -529,11 +670,11 @@ function decryptEnvelope(envelope, key) {
   return JSON.parse(plaintext.toString("utf8"));
 }
 function readSecureJson(path2) {
-  if (!(0, import_node_fs4.existsSync)(path2)) return null;
+  if (!(0, import_node_fs6.existsSync)(path2)) return null;
   chmodOwnerOnly(path2);
   let parsed;
   try {
-    parsed = JSON.parse((0, import_node_fs4.readFileSync)(path2, "utf8"));
+    parsed = JSON.parse((0, import_node_fs6.readFileSync)(path2, "utf8"));
   } catch {
     return null;
   }
@@ -553,17 +694,17 @@ function writeSecureJson(path2, value) {
 `);
 }
 function isSecureFileEncrypted(path2) {
-  if (!(0, import_node_fs4.existsSync)(path2)) return false;
+  if (!(0, import_node_fs6.existsSync)(path2)) return false;
   try {
-    return isEnvelope(JSON.parse((0, import_node_fs4.readFileSync)(path2, "utf8")));
+    return isEnvelope(JSON.parse((0, import_node_fs6.readFileSync)(path2, "utf8")));
   } catch {
     return false;
   }
 }
 function secureFileUnlocksWith(path2, key) {
-  if (!(0, import_node_fs4.existsSync)(path2) || key.length !== 32) return true;
+  if (!(0, import_node_fs6.existsSync)(path2) || key.length !== 32) return true;
   try {
-    const parsed = JSON.parse((0, import_node_fs4.readFileSync)(path2, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs6.readFileSync)(path2, "utf8"));
     if (!isEnvelope(parsed)) return true;
     decryptEnvelope(parsed, key);
     return true;
@@ -571,13 +712,13 @@ function secureFileUnlocksWith(path2, key) {
     return false;
   }
 }
-var import_node_child_process, import_node_crypto, import_node_fs4, KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT, ALG, injectedKey;
+var import_node_child_process, import_node_crypto, import_node_fs6, KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT, ALG, injectedKey;
 var init_secure_file = __esm({
   "src/store/secure-file.ts"() {
     "use strict";
     import_node_child_process = require("child_process");
     import_node_crypto = require("crypto");
-    import_node_fs4 = require("fs");
+    import_node_fs6 = require("fs");
     init_private_file();
     KEYCHAIN_SERVICE = "ai.sideboard.app";
     KEYCHAIN_ACCOUNT = "secret-vault-v1";
@@ -588,7 +729,7 @@ var init_secure_file = __esm({
 
 // src/store/secret-vault.ts
 function secretVaultPath() {
-  return (0, import_node_path5.join)(appDataDir(), "secrets.json");
+  return (0, import_node_path7.join)(appDataDir(), "secrets.json");
 }
 function loadSecretVault() {
   const parsed = readSecureJson(secretVaultPath());
@@ -632,11 +773,11 @@ function normalizeVault(raw) {
   }
   return out;
 }
-var import_node_path5;
+var import_node_path7;
 var init_secret_vault = __esm({
   "src/store/secret-vault.ts"() {
     "use strict";
-    import_node_path5 = require("path");
+    import_node_path7 = require("path");
     init_paths();
     init_secure_file();
   }
@@ -737,10 +878,10 @@ function toPublicAppSettings(settings) {
   };
 }
 function appSettingsPath() {
-  return (0, import_node_path6.join)(appDataDir(), "settings.json");
+  return (0, import_node_path8.join)(appDataDir(), "settings.json");
 }
 function claudeUserSettingsPath() {
-  return (0, import_node_path6.join)((0, import_node_os3.homedir)(), ".claude", "settings.json");
+  return (0, import_node_path8.join)((0, import_node_os3.homedir)(), ".claude", "settings.json");
 }
 function normalizeClaude(raw) {
   if (!raw || typeof raw !== "object") return {};
@@ -983,10 +1124,10 @@ function normalizeSettings(raw) {
 }
 function readSettingsFile() {
   const path2 = appSettingsPath();
-  if (!(0, import_node_fs5.existsSync)(path2)) return { ...EMPTY_SETTINGS };
+  if (!(0, import_node_fs7.existsSync)(path2)) return { ...EMPTY_SETTINGS };
   try {
     chmodOwnerOnly(path2);
-    const parsed = JSON.parse((0, import_node_fs5.readFileSync)(path2, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs7.readFileSync)(path2, "utf8"));
     return normalizeSettings(parsed);
   } catch {
     return { ...EMPTY_SETTINGS };
@@ -1546,14 +1687,14 @@ function childEnvWithAppSettings(extra) {
 function harnessEnvKey(harness) {
   return HARNESS_ENV_KEYS[harness];
 }
-var import_node_crypto2, import_node_fs5, import_node_os3, import_node_path6, HARNESS_ENV_KEYS, DEFAULT_AGENTS, GITHUB_GIT_AUTH_MODES, CLOUD_CONNECT_AGENTS, ISSUE_SOURCES, GIT_AUTH_MODES, EMPTY_SETTINGS, DEFAULT_CLI_BIN;
+var import_node_crypto2, import_node_fs7, import_node_os3, import_node_path8, HARNESS_ENV_KEYS, DEFAULT_AGENTS, GITHUB_GIT_AUTH_MODES, CLOUD_CONNECT_AGENTS, ISSUE_SOURCES, GIT_AUTH_MODES, EMPTY_SETTINGS, DEFAULT_CLI_BIN;
 var init_app_settings = __esm({
   "src/store/app-settings.ts"() {
     "use strict";
     import_node_crypto2 = require("crypto");
-    import_node_fs5 = require("fs");
+    import_node_fs7 = require("fs");
     import_node_os3 = require("os");
-    import_node_path6 = require("path");
+    import_node_path8 = require("path");
     init_thinking_effort();
     init_nested_electron_env();
     init_paths();
@@ -1615,7 +1756,7 @@ function setCaffeinateHoldHooks(next) {
   hooks = next;
 }
 function caffeinateHoldPath() {
-  return (0, import_node_path7.join)(appDataDir(), "caffeinate-hold.json");
+  return (0, import_node_path9.join)(appDataDir(), "caffeinate-hold.json");
 }
 function processAlive(pid) {
   if (hooks.processAlive) return hooks.processAlive(pid);
@@ -1649,9 +1790,9 @@ function uniqueIds(ids) {
 }
 function readHold() {
   const path2 = caffeinateHoldPath();
-  if (!(0, import_node_fs6.existsSync)(path2)) return null;
+  if (!(0, import_node_fs8.existsSync)(path2)) return null;
   try {
-    const parsed = JSON.parse((0, import_node_fs6.readFileSync)(path2, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs8.readFileSync)(path2, "utf8"));
     if (typeof parsed?.pid === "number" && parsed.pid > 0) {
       return {
         pid: parsed.pid,
@@ -1673,7 +1814,7 @@ function writeHold(pid, threadIds) {
 }
 function clearHold() {
   try {
-    (0, import_node_fs6.unlinkSync)(caffeinateHoldPath());
+    (0, import_node_fs8.unlinkSync)(caffeinateHoldPath());
   } catch {
   }
 }
@@ -1758,13 +1899,13 @@ function releaseCaffeinateHoldForThread(threadId) {
   }
   return setCaffeinateHold(false, { threadId: id });
 }
-var import_node_child_process2, import_node_fs6, import_node_path7, hooks;
+var import_node_child_process2, import_node_fs8, import_node_path9, hooks;
 var init_caffeinate_hold = __esm({
   "src/store/caffeinate-hold.ts"() {
     "use strict";
     import_node_child_process2 = require("child_process");
-    import_node_fs6 = require("fs");
-    import_node_path7 = require("path");
+    import_node_fs8 = require("fs");
+    import_node_path9 = require("path");
     init_paths();
     init_private_file();
     hooks = {};
@@ -1858,7 +1999,7 @@ function createEmptyThread(partial) {
 }
 async function withThreadLock(id, fn) {
   const lockPath = threadLockPath(id);
-  (0, import_node_fs7.writeFileSync)(lockPath, "", { flag: "a" });
+  (0, import_node_fs9.writeFileSync)(lockPath, "", { flag: "a" });
   let release;
   try {
     release = await import_proper_lockfile.default.lock(lockPath, {
@@ -1872,26 +2013,26 @@ async function withThreadLock(id, fn) {
 }
 function readThread(id) {
   const path2 = threadFilePath(id);
-  if (!(0, import_node_fs7.existsSync)(path2)) return null;
-  const raw = (0, import_node_fs7.readFileSync)(path2, "utf8");
+  if (!(0, import_node_fs9.existsSync)(path2)) return null;
+  const raw = (0, import_node_fs9.readFileSync)(path2, "utf8");
   return normalizeThread(JSON.parse(raw));
 }
 function writeThread(thread) {
   const path2 = threadFilePath(idPath(thread.id));
   const tmp = `${path2}.${process.pid}.tmp`;
   const next = { ...thread, updatedAt: nowIso() };
-  (0, import_node_fs7.writeFileSync)(tmp, JSON.stringify(next, null, 2), "utf8");
-  (0, import_node_fs7.renameSync)(tmp, path2);
+  (0, import_node_fs9.writeFileSync)(tmp, JSON.stringify(next, null, 2), "utf8");
+  (0, import_node_fs9.renameSync)(tmp, path2);
 }
 function idPath(id) {
   return id;
 }
 function listThreads(opts) {
-  const files = (0, import_node_fs7.readdirSync)(threadsDir()).filter((f) => f.endsWith(".json"));
+  const files = (0, import_node_fs9.readdirSync)(threadsDir()).filter((f) => f.endsWith(".json"));
   const threads = files.map((f) => {
     try {
       return normalizeThread(
-        JSON.parse((0, import_node_fs7.readFileSync)(threadFilePath(f.replace(/\.json$/, "")), "utf8"))
+        JSON.parse((0, import_node_fs9.readFileSync)(threadFilePath(f.replace(/\.json$/, "")), "utf8"))
       );
     } catch {
       return null;
@@ -1902,11 +2043,11 @@ function listThreads(opts) {
 }
 function deleteThreadRecord(id) {
   const path2 = threadFilePath(id);
-  if ((0, import_node_fs7.existsSync)(path2)) (0, import_node_fs7.unlinkSync)(path2);
+  if ((0, import_node_fs9.existsSync)(path2)) (0, import_node_fs9.unlinkSync)(path2);
   const lock = threadLockPath(id);
-  if ((0, import_node_fs7.existsSync)(lock)) {
+  if ((0, import_node_fs9.existsSync)(lock)) {
     try {
-      (0, import_node_fs7.unlinkSync)(lock);
+      (0, import_node_fs9.unlinkSync)(lock);
     } catch {
     }
   }
@@ -1930,12 +2071,12 @@ function findThreadByRef(ref) {
   const all = listThreads({ includeArchived: true });
   return all.find((t) => t.id === ref || t.id.startsWith(ref) || t.branchName === ref || t.title === ref) ?? null;
 }
-var import_node_crypto3, import_node_fs7, import_proper_lockfile;
+var import_node_crypto3, import_node_fs9, import_proper_lockfile;
 var init_thread_store = __esm({
   "src/store/thread-store.ts"() {
     "use strict";
     import_node_crypto3 = require("crypto");
-    import_node_fs7 = require("fs");
+    import_node_fs9 = require("fs");
     import_proper_lockfile = __toESM(require("proper-lockfile"), 1);
     init_thinking_effort();
     init_paths();
@@ -2917,17 +3058,17 @@ var init_gh_errors = __esm({
 
 // src/agents/path.ts
 function prependPathDir(env, dir) {
-  if (!dir || !(0, import_node_fs8.existsSync)(dir)) return;
+  if (!dir || !(0, import_node_fs10.existsSync)(dir)) return;
   const current = env.PATH ?? "";
-  const parts = current.split(import_node_path8.delimiter).filter(Boolean);
+  const parts = current.split(import_node_path10.delimiter).filter(Boolean);
   if (parts.includes(dir)) {
     env.PATH = current;
     return;
   }
-  env.PATH = [dir, ...parts].join(import_node_path8.delimiter);
+  env.PATH = [dir, ...parts].join(import_node_path10.delimiter);
 }
 function conductorBundledBinDir(home = process.env.HOME || process.env.USERPROFILE || (0, import_node_os4.homedir)()) {
-  return (0, import_node_path8.join)(home, "Library", "Application Support", "com.conductor.app", "bin");
+  return (0, import_node_path10.join)(home, "Library", "Application Support", "com.conductor.app", "bin");
 }
 function isConductorBundledCli(filePath) {
   const p = (filePath ?? "").replace(/\\/g, "/");
@@ -2936,21 +3077,21 @@ function isConductorBundledCli(filePath) {
 function ensureAgentPath(env = process.env) {
   const home = env.HOME || env.USERPROFILE || (0, import_node_os4.homedir)();
   const current = env.PATH ?? "";
-  const parts = current.split(import_node_path8.delimiter).filter(Boolean);
+  const parts = current.split(import_node_path10.delimiter).filter(Boolean);
   const seen = new Set(parts);
   const extras = [
-    ...EXTRA_BIN_DIRS.map((rel) => (0, import_node_path8.join)(home, rel)),
+    ...EXTRA_BIN_DIRS.map((rel) => (0, import_node_path10.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_fs8.existsSync)(dir)) continue;
+    if (!dir || seen.has(dir) || !(0, import_node_fs10.existsSync)(dir)) continue;
     parts.unshift(dir);
     seen.add(dir);
   }
-  const next = parts.join(import_node_path8.delimiter);
+  const next = parts.join(import_node_path10.delimiter);
   env.PATH = next;
   return next;
 }
@@ -2964,7 +3105,7 @@ function enrichPathWithNpmGlobalBin(env = process.env) {
       stdio: ["ignore", "pipe", "ignore"]
     }).trim().split(/\r?\n/).find(Boolean);
     if (prefix) {
-      const binDir = process.platform === "win32" ? prefix : (0, import_node_path8.join)(prefix, "bin");
+      const binDir = process.platform === "win32" ? prefix : (0, import_node_path10.join)(prefix, "bin");
       prependPathDir(env, binDir);
     }
   } catch {
@@ -2992,14 +3133,14 @@ function withExportedPath(command, pathValue) {
   if (/^(export\s+PATH=|PATH=)/.test(trimmed)) return trimmed;
   return `export PATH=${posixShellSingleQuote(pathValue)} && ${trimmed}`;
 }
-var import_node_fs8, import_node_child_process3, import_node_os4, import_node_path8, EXTRA_BIN_DIRS;
+var import_node_fs10, import_node_child_process3, import_node_os4, import_node_path10, EXTRA_BIN_DIRS;
 var init_path = __esm({
   "src/agents/path.ts"() {
     "use strict";
-    import_node_fs8 = require("fs");
+    import_node_fs10 = require("fs");
     import_node_child_process3 = require("child_process");
     import_node_os4 = require("os");
-    import_node_path8 = require("path");
+    import_node_path10 = require("path");
     EXTRA_BIN_DIRS = [
       ".local/bin",
       ".cargo/bin",
@@ -3027,7 +3168,7 @@ __export(run_exports, {
 async function run(file, args, opts) {
   ensureAgentPath();
   try {
-    const result = await (0, import_execa.execa)(file, args, {
+    const result = await (0, import_execa2.execa)(file, args, {
       cwd: opts?.cwd,
       env: { ...process.env, ...opts?.env },
       reject: opts?.reject ?? true,
@@ -3091,11 +3232,11 @@ async function resolveGhAuthToken(cwd) {
   const token = result.stdout.trim();
   return token || null;
 }
-var import_execa;
+var import_execa2;
 var init_run = __esm({
   "src/git/run.ts"() {
     "use strict";
-    import_execa = require("execa");
+    import_execa2 = require("execa");
     init_path();
   }
 });
@@ -3220,7 +3361,7 @@ function formatGitAuthModeDirective(mode) {
     default:
       return [
         "Git authentication (Account \u2192 GitHub mode: auto):",
-        "- This process rewrites GitHub SSH remotes to HTTPS and authenticates with `GH_TOKEN` from `gh` so git/ssh never prompt the macOS Keychain (required for Slack / unattended Cursor).",
+        "- This process rewrites GitHub SSH remotes to HTTPS and authenticates with `GH_TOKEN` from `gh` so git/ssh never prompt the macOS Keychain (required for unattended orchestrator turns).",
         "- Do not switch remotes to SSH. Push with `git push -u origin HEAD`.",
         "- If HTTPS auth fails, tell the user to run `gh auth login` on this Mac or set Account \u2192 GitHub to a PAT \u2014 do not wait for a Keychain dialog."
       ].join("\n");
@@ -4318,8 +4459,8 @@ function isLocalPrFetchBranch(ref) {
 }
 async function createThreadWorktree(opts) {
   let branchName = `thread/${opts.slug}`;
-  const worktreePath = (0, import_node_path9.join)(worktreesRoot(opts.repoPath), opts.slug);
-  if ((0, import_node_fs9.existsSync)(worktreePath)) {
+  const worktreePath = (0, import_node_path11.join)(worktreesRoot(opts.repoPath), opts.slug);
+  if ((0, import_node_fs11.existsSync)(worktreePath)) {
     throw new Error(`Worktree already exists at ${worktreePath}`);
   }
   await ensureGhPreferOrigin(opts.repoPath);
@@ -4388,8 +4529,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_path9.join)(worktreesRoot(opts.repoPath), opts.slug);
-  if ((0, import_node_fs9.existsSync)(worktreePath)) {
+  const worktreePath = (0, import_node_path11.join)(worktreesRoot(opts.repoPath), opts.slug);
+  if ((0, import_node_fs11.existsSync)(worktreePath)) {
     throw new Error(`Worktree already exists at ${worktreePath}`);
   }
   await ensureGhPreferOrigin(opts.repoPath);
@@ -4677,10 +4818,10 @@ function sameRepoPath(a, b) {
   return normalizeWorktreePath(a) === normalizeWorktreePath(b);
 }
 function listLocalThreadBranchSlugs(repoPath) {
-  const refsDir = (0, import_node_path9.join)(repoPath, ".git", "refs", "heads", "thread");
-  if (!(0, import_node_fs9.existsSync)(refsDir)) return [];
+  const refsDir = (0, import_node_path11.join)(repoPath, ".git", "refs", "heads", "thread");
+  if (!(0, import_node_fs11.existsSync)(refsDir)) return [];
   try {
-    return (0, import_node_fs9.readdirSync)(refsDir).filter((name) => !name.startsWith(".")).map((name) => normalizeTakenSlug(name));
+    return (0, import_node_fs11.readdirSync)(refsDir).filter((name) => !name.startsWith(".")).map((name) => normalizeTakenSlug(name));
   } catch {
     return [];
   }
@@ -4688,8 +4829,8 @@ function listLocalThreadBranchSlugs(repoPath) {
 function collectTakenTeamSlugs(repoPath) {
   const taken = /* @__PURE__ */ new Set();
   const root = worktreesRoot(repoPath);
-  if ((0, import_node_fs9.existsSync)(root)) {
-    for (const entry of (0, import_node_fs9.readdirSync)(root, { withFileTypes: true })) {
+  if ((0, import_node_fs11.existsSync)(root)) {
+    for (const entry of (0, import_node_fs11.readdirSync)(root, { withFileTypes: true })) {
       if (entry.isDirectory() && entry.name !== ".DS_Store") {
         taken.add(normalizeTakenSlug(entry.name));
       }
@@ -4710,18 +4851,18 @@ function allocateTeamSlug(repoPath) {
   const taken = collectTakenTeamSlugs(repoPath);
   for (let attempt = 0; attempt < 32; attempt++) {
     const team = allocateTeamName(taken);
-    const path2 = (0, import_node_path9.join)(worktreesRoot(repoPath), team.slug);
-    if (!(0, import_node_fs9.existsSync)(path2)) return team;
+    const path2 = (0, import_node_path11.join)(worktreesRoot(repoPath), team.slug);
+    if (!(0, import_node_fs11.existsSync)(path2)) return team;
     taken.add(team.slug);
   }
   throw new Error("No available soccer team worktree directories left");
 }
-var import_node_fs9, import_node_path9;
+var import_node_fs11, import_node_path11;
 var init_worktree = __esm({
   "src/git/worktree.ts"() {
     "use strict";
-    import_node_fs9 = require("fs");
-    import_node_path9 = require("path");
+    import_node_fs11 = require("fs");
+    import_node_path11 = require("path");
     init_paths();
     init_thread_store();
     init_teams();
@@ -4805,7 +4946,7 @@ function coordinatorTurnReminder(opts) {
 function ensureGlobalCoordinatorCwd(opts) {
   const dir = globalAgentCwd();
   try {
-    (0, import_node_fs10.mkdirSync)(dir, { recursive: true });
+    (0, import_node_fs12.mkdirSync)(dir, { recursive: true });
   } catch {
     return dir;
   }
@@ -4813,7 +4954,7 @@ function ensureGlobalCoordinatorCwd(opts) {
   let orchId = opts?.orchestratorThreadId?.trim() || "";
   if (!orchId) {
     try {
-      const existing = (0, import_node_fs10.readFileSync)((0, import_node_path10.join)(dir, "AGENTS.md"), "utf8");
+      const existing = (0, import_node_fs12.readFileSync)((0, import_node_path12.join)(dir, "AGENTS.md"), "utf8");
       const m = existing.match(
         /YOUR orchestration thread id is `([0-9a-f-]{36})`/i
       );
@@ -4855,9 +4996,9 @@ function ensureGlobalCoordinatorCwd(opts) {
     "Always ask worktree agents to commit, push, and open draft PRs (`ask_git` / `send_to_thread`). 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_fs10.writeFileSync)((0, import_node_path10.join)(dir, "CLAUDE.md"), `${body}
+    (0, import_node_fs12.writeFileSync)((0, import_node_path12.join)(dir, "CLAUDE.md"), `${body}
 `, "utf8");
-    (0, import_node_fs10.writeFileSync)((0, import_node_path10.join)(dir, "AGENTS.md"), `${body}
+    (0, import_node_fs12.writeFileSync)((0, import_node_path12.join)(dir, "AGENTS.md"), `${body}
 `, "utf8");
   } catch {
   }
@@ -4889,12 +5030,12 @@ function coordinatorSystemPrompt(opts) {
     formatWorkspaceInventory(opts.workspaces)
   ].join("\n");
 }
-var import_node_fs10, import_node_path10, COORDINATOR_TOOL_PLAYBOOK, SLACK_REPLY_FORMATTING;
+var import_node_fs12, import_node_path12, COORDINATOR_TOOL_PLAYBOOK, SLACK_REPLY_FORMATTING;
 var init_coordinator_prompt = __esm({
   "src/orchestrator/coordinator-prompt.ts"() {
     "use strict";
-    import_node_fs10 = require("fs");
-    import_node_path10 = require("path");
+    import_node_fs12 = require("fs");
+    import_node_path12 = require("path");
     init_worktree();
     init_app_settings();
     init_paths();
@@ -4915,7 +5056,7 @@ var init_coordinator_prompt = __esm({
       "Workspaces:",
       "- add_workspace / remove_workspace \u2014 register or unregister a git repo",
       "Worktree threads (chats):",
-      "- create_thread \u2014 create a worktree + chat from branch | pr | ticket; pass repoPath + parentThreadId; omit agent and model to use Sideboard Account defaults (Settings \u2192 Default agent, model & effort). If you are Codex, do not set agent=codex (nested Codex deadlocks)",
+      "- create_thread \u2014 create a worktree + chat from branch | pr | ticket; pass repoPath + parentThreadId; omit agent and model to use Sideboard Account defaults (Settings \u2192 Default agent, model & effort). If the repo has a setup script, Sideboard runs it in the background (does not block send_to_thread). If you are Codex, do not set agent=codex (nested Codex deadlocks)",
       "- fork_worktree \u2014 fork a worktree chat into a NEW git worktree + chat (transcript attached); optional agent; leave model unset (Auto) unless you have a reason. Not for orchestration chats.",
       "- fork_chat \u2014 fork a worktree chat (same worktree tab) OR a Global orchestration chat (new orchestration tab); optional agent; leave model unset (Auto) unless you have a reason. Remote coordinators: use this to continue another orchestration chat on a different agent after session limits.",
       "- send_to_thread \u2014 queue a prompt (start/continue a chat turn); pass force_stop: true to interrupt mid-turn / clear stale queued prompts before replacing with a new request",
@@ -4923,7 +5064,7 @@ var init_coordinator_prompt = __esm({
       "- stop_thread \u2014 force-stop: kill in-flight turn AND clear queued prompts (do not leave stale queue after an interrupt)",
       "- archive_thread / restore_thread \u2014 archive (tears down worktree when last tab) or restore",
       "Setup / run:",
-      "- run_setup \u2014 re-run worktree setup",
+      "- 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",
       "Inspect / review / PRs:",
       "- get_diff \u2014 compact diff summary",
@@ -5200,38 +5341,38 @@ __export(workspaces_exports, {
   syncWorkspacesFromThreads: () => syncWorkspacesFromThreads
 });
 function workspacesFile() {
-  return (0, import_node_path11.join)(appDataDir(), "workspaces.json");
+  return (0, import_node_path13.join)(appDataDir(), "workspaces.json");
 }
 function removedWorkspacesFile() {
-  return (0, import_node_path11.join)(appDataDir(), "removed-workspaces.json");
+  return (0, import_node_path13.join)(appDataDir(), "removed-workspaces.json");
 }
 function readAll() {
   const path2 = workspacesFile();
-  if (!(0, import_node_fs11.existsSync)(path2)) return [];
+  if (!(0, import_node_fs13.existsSync)(path2)) return [];
   try {
-    const raw = JSON.parse((0, import_node_fs11.readFileSync)(path2, "utf8"));
+    const raw = JSON.parse((0, import_node_fs13.readFileSync)(path2, "utf8"));
     return Array.isArray(raw) ? raw : [];
   } catch {
     return [];
   }
 }
 function writeAll(list) {
-  (0, import_node_fs11.mkdirSync)(appDataDir(), { recursive: true });
-  (0, import_node_fs11.writeFileSync)(workspacesFile(), JSON.stringify(list, null, 2), "utf8");
+  (0, import_node_fs13.mkdirSync)(appDataDir(), { recursive: true });
+  (0, import_node_fs13.writeFileSync)(workspacesFile(), JSON.stringify(list, null, 2), "utf8");
 }
 function readRemoved() {
   const path2 = removedWorkspacesFile();
-  if (!(0, import_node_fs11.existsSync)(path2)) return /* @__PURE__ */ new Set();
+  if (!(0, import_node_fs13.existsSync)(path2)) return /* @__PURE__ */ new Set();
   try {
-    const raw = JSON.parse((0, import_node_fs11.readFileSync)(path2, "utf8"));
+    const raw = JSON.parse((0, import_node_fs13.readFileSync)(path2, "utf8"));
     return new Set(Array.isArray(raw) ? raw.filter((p) => typeof p === "string") : []);
   } catch {
     return /* @__PURE__ */ new Set();
   }
 }
 function writeRemoved(paths) {
-  (0, import_node_fs11.mkdirSync)(appDataDir(), { recursive: true });
-  (0, import_node_fs11.writeFileSync)(removedWorkspacesFile(), JSON.stringify([...paths].sort(), null, 2), "utf8");
+  (0, import_node_fs13.mkdirSync)(appDataDir(), { recursive: true });
+  (0, import_node_fs13.writeFileSync)(removedWorkspacesFile(), JSON.stringify([...paths].sort(), null, 2), "utf8");
 }
 function rememberRemoved(repoPath) {
   const next = readRemoved();
@@ -5254,7 +5395,7 @@ function listWorkspaces() {
 async function addWorkspace(repoPath) {
   const root = await resolveRepoRoot(repoPath);
   if (!root || root === "/") throw new Error(`Invalid repo path: ${repoPath}`);
-  if (!(0, import_node_fs11.existsSync)(root)) throw new Error(`Repo not found: ${root}`);
+  if (!(0, import_node_fs13.existsSync)(root)) throw new Error(`Repo not found: ${root}`);
   forgetRemoved(root);
   await ensureGhPreferOrigin(root);
   const current = readAll();
@@ -5262,7 +5403,7 @@ async function addWorkspace(repoPath) {
   if (existing) return existing;
   const next = {
     path: root,
-    name: (0, import_node_path11.basename)(root),
+    name: (0, import_node_path13.basename)(root),
     addedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   writeAll([...current, next]);
@@ -5284,10 +5425,10 @@ function syncWorkspacesFromThreads(repoPaths) {
     if (!path2 || path2 === "/" || isGlobalRepoPath(path2) || byPath.has(path2) || removed.has(path2)) {
       continue;
     }
-    if (!(0, import_node_fs11.existsSync)(path2)) continue;
+    if (!(0, import_node_fs13.existsSync)(path2)) continue;
     const ws = {
       path: path2,
-      name: (0, import_node_path11.basename)(path2),
+      name: (0, import_node_path13.basename)(path2),
       addedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     byPath.set(path2, ws);
@@ -5297,12 +5438,12 @@ function syncWorkspacesFromThreads(repoPaths) {
   if (dirty) writeAll(next);
   return next.sort((a, b) => a.name.localeCompare(b.name));
 }
-var import_node_fs11, import_node_path11;
+var import_node_fs13, import_node_path13;
 var init_workspaces = __esm({
   "src/store/workspaces.ts"() {
     "use strict";
-    import_node_fs11 = require("fs");
-    import_node_path11 = require("path");
+    import_node_fs13 = require("fs");
+    import_node_path13 = require("path");
     init_paths();
     init_global_workspace();
     init_worktree();
@@ -5311,32 +5452,32 @@ var init_workspaces = __esm({
 
 // src/brightsy/config.ts
 function brightsyConfigPath() {
-  return (0, import_node_path12.join)((0, import_node_os5.homedir)(), ".brightsy", "config.json");
+  return (0, import_node_path14.join)((0, import_node_os5.homedir)(), ".brightsy", "config.json");
 }
 function loadBrightsyConfig() {
   const path2 = brightsyConfigPath();
-  if (!(0, import_node_fs12.existsSync)(path2)) {
+  if (!(0, import_node_fs14.existsSync)(path2)) {
     throw new Error("Brightsy not logged in \u2014 run `brightsy login` first");
   }
-  const raw = JSON.parse((0, import_node_fs12.readFileSync)(path2, "utf8"));
+  const raw = JSON.parse((0, import_node_fs14.readFileSync)(path2, "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_fs12.writeFileSync)(brightsyConfigPath(), `${JSON.stringify(cfg, null, 2)}
+  (0, import_node_fs14.writeFileSync)(brightsyConfigPath(), `${JSON.stringify(cfg, null, 2)}
 `, {
     mode: 384
   });
 }
-var import_node_fs12, import_node_os5, import_node_path12;
+var import_node_fs14, import_node_os5, import_node_path14;
 var init_config = __esm({
   "src/brightsy/config.ts"() {
     "use strict";
-    import_node_fs12 = require("fs");
+    import_node_fs14 = require("fs");
     import_node_os5 = require("os");
-    import_node_path12 = require("path");
+    import_node_path14 = require("path");
   }
 });
 
@@ -5439,22 +5580,22 @@ __export(connected_teams_exports, {
   listConnectedBrightsyTeams: () => listConnectedBrightsyTeams
 });
 function storePath() {
-  return (0, import_node_path13.join)(appDataDir(), "brightsy-teams.json");
+  return (0, import_node_path15.join)(appDataDir(), "brightsy-teams.json");
 }
 function readStore() {
   const path2 = storePath();
-  if (!(0, import_node_fs13.existsSync)(path2)) return [];
+  if (!(0, import_node_fs15.existsSync)(path2)) return [];
   try {
-    const parsed = JSON.parse((0, import_node_fs13.readFileSync)(path2, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs15.readFileSync)(path2, "utf8"));
     return Array.isArray(parsed.teams) ? parsed.teams : [];
   } catch {
     return [];
   }
 }
 function writeStore(teams) {
-  (0, import_node_fs13.mkdirSync)(appDataDir(), { recursive: true });
+  (0, import_node_fs15.mkdirSync)(appDataDir(), { recursive: true });
   const path2 = storePath();
-  (0, import_node_fs13.writeFileSync)(path2, `${JSON.stringify({ teams }, null, 2)}
+  (0, import_node_fs15.writeFileSync)(path2, `${JSON.stringify({ teams }, null, 2)}
 `, {
     mode: 384
   });
@@ -5616,12 +5757,12 @@ function brightsyMcpServerName(slug) {
   const cleaned = slug.replace(/[^A-Za-z0-9_-]/g, "_").replace(/^_+|_+$/g, "");
   return `brightsy_${cleaned || "team"}`;
 }
-var import_node_fs13, import_node_path13;
+var import_node_fs15, import_node_path15;
 var init_connected_teams = __esm({
   "src/brightsy/connected-teams.ts"() {
     "use strict";
-    import_node_fs13 = require("fs");
-    import_node_path13 = require("path");
+    import_node_fs15 = require("fs");
+    import_node_path15 = require("path");
     init_paths();
     init_accounts();
     init_config();
@@ -6150,11 +6291,11 @@ async function syncCliForTarget(accountId) {
   }
   applyConnectedTeamToCli(team);
 }
-var import_node_fs14, brightsyAdapter;
+var import_node_fs16, brightsyAdapter;
 var init_brightsy = __esm({
   "src/agents/brightsy.ts"() {
     "use strict";
-    import_node_fs14 = require("fs");
+    import_node_fs16 = require("fs");
     init_run();
     init_connected_teams();
     init_config();
@@ -6169,7 +6310,7 @@ var init_brightsy = __esm({
       async detect() {
         const brightsy = resolveAgentExecutable("brightsy");
         if (brightsy !== "brightsy") {
-          if (!(0, import_node_fs14.existsSync)(brightsy)) {
+          if (!(0, import_node_fs16.existsSync)(brightsy)) {
             return {
               agent: "brightsy",
               installed: false,
@@ -6426,35 +6567,35 @@ function corePackageDir() {
   try {
     const url = import_meta.url;
     if (typeof url === "string" && url.length > 0) {
-      return (0, import_node_path14.dirname)((0, import_node_url.fileURLToPath)(url));
+      return (0, import_node_path16.dirname)((0, import_node_url.fileURLToPath)(url));
     }
   } catch {
   }
   try {
-    const req = (0, import_node_module.createRequire)((0, import_node_path14.join)(process.cwd(), "package.json"));
-    return (0, import_node_path14.dirname)(req.resolve("@sideboard-ai/core"));
+    const req = (0, import_node_module.createRequire)((0, import_node_path16.join)(process.cwd(), "package.json"));
+    return (0, import_node_path16.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_fs15.existsSync)(override)) return override;
+  if (override && (0, import_node_fs17.existsSync)(override)) return override;
   let dir = corePackageDir();
   for (let i = 0; i < 10; i++) {
     const candidates = [
-      (0, import_node_path14.join)(dir, "mcp/run-stdio.js"),
-      (0, import_node_path14.join)(dir, "mcp/run-stdio.cjs"),
-      (0, import_node_path14.join)(dir, "dist/mcp/run-stdio.js"),
-      (0, import_node_path14.join)(dir, "dist/mcp/run-stdio.cjs"),
-      (0, import_node_path14.join)(dir, "packages/core/dist/mcp/run-stdio.js"),
-      (0, import_node_path14.join)(dir, "packages/cli/dist/index.js"),
-      (0, import_node_path14.join)(dir, "cli/dist/index.js")
+      (0, import_node_path16.join)(dir, "mcp/run-stdio.js"),
+      (0, import_node_path16.join)(dir, "mcp/run-stdio.cjs"),
+      (0, import_node_path16.join)(dir, "dist/mcp/run-stdio.js"),
+      (0, import_node_path16.join)(dir, "dist/mcp/run-stdio.cjs"),
+      (0, import_node_path16.join)(dir, "packages/core/dist/mcp/run-stdio.js"),
+      (0, import_node_path16.join)(dir, "packages/cli/dist/index.js"),
+      (0, import_node_path16.join)(dir, "cli/dist/index.js")
     ];
     for (const p of candidates) {
-      if ((0, import_node_fs15.existsSync)(p)) return p;
+      if ((0, import_node_fs17.existsSync)(p)) return p;
     }
-    const parent = (0, import_node_path14.dirname)(dir);
+    const parent = (0, import_node_path16.dirname)(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -6577,22 +6718,22 @@ function writeMcpServersConfig(servers) {
       ...s.env ? { env: s.env } : {}
     };
   }
-  const dir = (0, import_node_fs15.mkdtempSync)((0, import_node_path14.join)((0, import_node_os6.tmpdir)(), "sideboard-mcp-"));
-  const cfgPath = (0, import_node_path14.join)(dir, "mcp.json");
-  (0, import_node_fs15.writeFileSync)(cfgPath, JSON.stringify({ mcpServers }, null, 2));
+  const dir = (0, import_node_fs17.mkdtempSync)((0, import_node_path16.join)((0, import_node_os6.tmpdir)(), "sideboard-mcp-"));
+  const cfgPath = (0, import_node_path16.join)(dir, "mcp.json");
+  (0, import_node_fs17.writeFileSync)(cfgPath, JSON.stringify({ mcpServers }, null, 2));
   return cfgPath;
 }
 async function writeInjectedMcpConfig(opts) {
   return writeMcpServersConfig(await buildInjectedMcpServers(opts));
 }
-var import_node_fs15, import_node_module, import_node_os6, import_node_path14, import_node_url, import_meta, SIDEBOARD_MCP_ALLOWED_TOOLS, SIDEBOARD_ARTIFACT_MCP_ALLOWED_TOOLS, BRIGHTSY_MCP_ALLOWED_TOOLS, brightsyMcpCommandCache, BRIGHTSY_WORD;
+var import_node_fs17, import_node_module, import_node_os6, import_node_path16, import_node_url, import_meta, SIDEBOARD_MCP_ALLOWED_TOOLS, SIDEBOARD_ARTIFACT_MCP_ALLOWED_TOOLS, BRIGHTSY_MCP_ALLOWED_TOOLS, brightsyMcpCommandCache, BRIGHTSY_WORD;
 var init_injected_mcp = __esm({
   "src/agents/injected-mcp.ts"() {
     "use strict";
-    import_node_fs15 = require("fs");
+    import_node_fs17 = require("fs");
     import_node_module = require("module");
     import_node_os6 = require("os");
-    import_node_path14 = require("path");
+    import_node_path16 = require("path");
     import_node_url = require("url");
     init_run();
     init_config();
@@ -6784,11 +6925,11 @@ function parseIssuesJson(raw) {
   }
   return [];
 }
-var import_node_fs16, BASE_ALLOWED_TOOLS, CLAUDE_CHROME_ALLOWED_TOOLS, CLAUDE_PROMPT_ARG_MAX, claudeAdapter;
+var import_node_fs18, BASE_ALLOWED_TOOLS, CLAUDE_CHROME_ALLOWED_TOOLS, CLAUDE_PROMPT_ARG_MAX, claudeAdapter;
 var init_claude = __esm({
   "src/agents/claude.ts"() {
     "use strict";
-    import_node_fs16 = require("fs");
+    import_node_fs18 = require("fs");
     init_run();
     init_app_settings();
     init_claude_mcp();
@@ -6817,7 +6958,7 @@ var init_claude = __esm({
       async detect() {
         const claude = resolveClaudeExecutable();
         if (claude !== "claude") {
-          if (!(0, import_node_fs16.existsSync)(claude)) {
+          if (!(0, import_node_fs18.existsSync)(claude)) {
             return {
               agent: "claude",
               installed: false,
@@ -7054,7 +7195,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_fs17.existsSync)(codex)) {
+  } else if (!(0, import_node_fs19.existsSync)(codex)) {
     return FALLBACK_CODEX_MODELS;
   }
   const listed = await run(codex, ["debug", "models"], { reject: false });
@@ -7089,12 +7230,12 @@ function usageFromCodex(usage) {
 }
 function codexConfigHasNetworkAccess() {
   const candidates = [
-    (0, import_node_path15.join)((0, import_node_os7.homedir)(), ".codex", "config.toml"),
-    (0, import_node_path15.join)((0, import_node_os7.homedir)(), ".config", "codex", "config.toml")
+    (0, import_node_path17.join)((0, import_node_os7.homedir)(), ".codex", "config.toml"),
+    (0, import_node_path17.join)((0, import_node_os7.homedir)(), ".config", "codex", "config.toml")
   ];
   for (const path2 of candidates) {
-    if (!(0, import_node_fs17.existsSync)(path2)) continue;
-    const text3 = (0, import_node_fs17.readFileSync)(path2, "utf8");
+    if (!(0, import_node_fs19.existsSync)(path2)) continue;
+    const text3 = (0, import_node_fs19.readFileSync)(path2, "utf8");
     if (/network_access\s*=\s*true/.test(text3)) return true;
   }
   return false;
@@ -7126,21 +7267,21 @@ function asRecord(value) {
   return void 0;
 }
 function codexLooksAuthenticated() {
-  const authPath = (0, import_node_path15.join)((0, import_node_os7.homedir)(), ".codex", "auth.json");
-  if (!(0, import_node_fs17.existsSync)(authPath)) return false;
+  const authPath = (0, import_node_path17.join)((0, import_node_os7.homedir)(), ".codex", "auth.json");
+  if (!(0, import_node_fs19.existsSync)(authPath)) return false;
   try {
-    return (0, import_node_fs17.statSync)(authPath).size > 2;
+    return (0, import_node_fs19.statSync)(authPath).size > 2;
   } catch {
     return false;
   }
 }
-var import_node_fs17, import_node_os7, import_node_path15, CODEX_PROMPT_ARG_MAX, FALLBACK_CODEX_MODELS, cachedCodexModels, CODEX_MODEL_CACHE_MS, codexAdapter;
+var import_node_fs19, import_node_os7, import_node_path17, 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_fs17 = require("fs");
+    import_node_fs19 = require("fs");
     import_node_os7 = require("os");
-    import_node_path15 = require("path");
+    import_node_path17 = require("path");
     init_run();
     init_app_settings();
     init_global_workspace();
@@ -7165,7 +7306,7 @@ var init_codex = __esm({
       async detect() {
         const codex = resolveAgentExecutable("codex");
         if (codex !== "codex") {
-          if (!(0, import_node_fs17.existsSync)(codex)) {
+          if (!(0, import_node_fs19.existsSync)(codex)) {
             return {
               agent: "codex",
               installed: false,
@@ -7599,11 +7740,11 @@ function entryDir() {
   const cjsDir = typeof __dirname !== "undefined" ? __dirname : "";
   if (cjsDir) return cjsDir;
   try {
-    return (0, import_node_path16.dirname)((0, import_node_url2.fileURLToPath)(import_meta2.url));
+    return (0, import_node_path18.dirname)((0, import_node_url2.fileURLToPath)(import_meta2.url));
   } catch {
     try {
       const req = (0, import_node_module2.createRequire)(process.cwd() + "/");
-      return (0, import_node_path16.dirname)(req.resolve("@sideboard-ai/core"));
+      return (0, import_node_path18.dirname)(req.resolve("@sideboard-ai/core"));
     } catch {
       return process.cwd();
     }
@@ -7612,27 +7753,27 @@ function entryDir() {
 function cursorRunnerPath() {
   const root = entryDir();
   const candidates = [
-    (0, import_node_path16.join)(root, "agents", "cursor-runner.js"),
-    (0, import_node_path16.join)(root, "agents", "cursor-runner.cjs"),
+    (0, import_node_path18.join)(root, "agents", "cursor-runner.js"),
+    (0, import_node_path18.join)(root, "agents", "cursor-runner.cjs"),
     // If somehow resolved from package root instead of dist/
-    (0, import_node_path16.join)(root, "dist", "agents", "cursor-runner.js"),
-    (0, import_node_path16.join)(root, "dist", "agents", "cursor-runner.cjs"),
+    (0, import_node_path18.join)(root, "dist", "agents", "cursor-runner.js"),
+    (0, import_node_path18.join)(root, "dist", "agents", "cursor-runner.cjs"),
     // Source tree (dev): packages/core/src/agents/cursor-runner.ts
-    (0, import_node_path16.join)(root, "cursor-runner.ts"),
-    (0, import_node_path16.join)(root, "src", "agents", "cursor-runner.ts")
+    (0, import_node_path18.join)(root, "cursor-runner.ts"),
+    (0, import_node_path18.join)(root, "src", "agents", "cursor-runner.ts")
   ];
   for (const candidate of candidates) {
-    if ((0, import_node_fs18.existsSync)(candidate)) return candidate;
+    if ((0, import_node_fs20.existsSync)(candidate)) return candidate;
   }
   return candidates[0];
 }
-var import_node_fs18, import_node_module2, import_node_path16, import_node_url2, import_sdk, import_meta2, FALLBACK_CURSOR_MODELS, cachedModels, MODEL_CACHE_MS, cursorAdapter;
+var import_node_fs20, import_node_module2, import_node_path18, import_node_url2, import_sdk, import_meta2, FALLBACK_CURSOR_MODELS, cachedModels, MODEL_CACHE_MS, cursorAdapter;
 var init_cursor = __esm({
   "src/agents/cursor.ts"() {
     "use strict";
-    import_node_fs18 = require("fs");
+    import_node_fs20 = require("fs");
     import_node_module2 = require("module");
-    import_node_path16 = require("path");
+    import_node_path18 = require("path");
     import_node_url2 = require("url");
     import_sdk = require("@cursor/sdk");
     init_run();
@@ -7761,7 +7902,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_fs19.existsSync)(opencode)) {
+  } else if (!(0, import_node_fs21.existsSync)(opencode)) {
     return FALLBACK_OPENCODE_MODELS;
   }
   const listed = await run(opencode, ["models"], { reject: false });
@@ -7791,11 +7932,11 @@ function usageFromOpencode(tokens) {
     cacheWriteTokens: tokens.cache?.write ? Number(tokens.cache.write) : void 0
   };
 }
-var import_node_fs19, FALLBACK_OPENCODE_MODELS, cachedOpencodeModels, OPENCODE_MODEL_CACHE_MS, opencodeAdapter;
+var import_node_fs21, FALLBACK_OPENCODE_MODELS, cachedOpencodeModels, OPENCODE_MODEL_CACHE_MS, opencodeAdapter;
 var init_opencode = __esm({
   "src/agents/opencode.ts"() {
     "use strict";
-    import_node_fs19 = require("fs");
+    import_node_fs21 = require("fs");
     init_run();
     init_app_settings();
     init_global_workspace();
@@ -7821,7 +7962,7 @@ var init_opencode = __esm({
       async detect() {
         const opencode = resolveAgentExecutable("opencode");
         if (opencode !== "opencode") {
-          if (!(0, import_node_fs19.existsSync)(opencode)) {
+          if (!(0, import_node_fs21.existsSync)(opencode)) {
             return {
               agent: "opencode",
               installed: false,
@@ -8618,40 +8759,40 @@ __export(plan_file_exports, {
   writePlanFile: () => writePlanFile
 });
 function ensureAttachmentsGitignore2(worktreePath) {
-  const gitignoreAbs = (0, import_node_path30.join)(worktreePath, ATTACHMENTS_DIR, ".gitignore");
-  if ((0, import_node_fs34.existsSync)(gitignoreAbs)) return;
-  (0, import_node_fs34.mkdirSync)((0, import_node_path30.dirname)(gitignoreAbs), { recursive: true });
-  (0, import_node_fs34.writeFileSync)(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
+  const gitignoreAbs = (0, import_node_path31.join)(worktreePath, ATTACHMENTS_DIR, ".gitignore");
+  if ((0, import_node_fs35.existsSync)(gitignoreAbs)) return;
+  (0, import_node_fs35.mkdirSync)((0, import_node_path31.dirname)(gitignoreAbs), { recursive: true });
+  (0, import_node_fs35.writeFileSync)(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
 }
 function planFileAbs(worktreePath) {
-  return (0, import_node_path30.join)(worktreePath, PLAN_FILE_REL);
+  return (0, import_node_path31.join)(worktreePath, PLAN_FILE_REL);
 }
 function readTextIfPresent2(abs) {
-  if (!(0, import_node_fs34.existsSync)(abs)) return null;
+  if (!(0, import_node_fs35.existsSync)(abs)) return null;
   try {
-    const content = (0, import_node_fs34.readFileSync)(abs, "utf8");
+    const content = (0, import_node_fs35.readFileSync)(abs, "utf8");
     return content.trim() ? content : null;
   } catch {
     return null;
   }
 }
 function readPlanFile(worktreePath) {
-  return readTextIfPresent2(planFileAbs(worktreePath)) ?? readTextIfPresent2((0, import_node_path30.join)(worktreePath, `${LEGACY_ATTACHMENTS_DIR}/plan.md`)) ?? readTextIfPresent2((0, import_node_path30.join)(worktreePath, LEGACY_PLAN_FILE_REL));
+  return readTextIfPresent2(planFileAbs(worktreePath)) ?? readTextIfPresent2((0, import_node_path31.join)(worktreePath, `${LEGACY_ATTACHMENTS_DIR}/plan.md`)) ?? readTextIfPresent2((0, import_node_path31.join)(worktreePath, LEGACY_PLAN_FILE_REL));
 }
 function writePlanFile(worktreePath, content) {
   ensureAttachmentsGitignore2(worktreePath);
   const abs = planFileAbs(worktreePath);
-  (0, import_node_fs34.mkdirSync)((0, import_node_path30.dirname)(abs), { recursive: true });
+  (0, import_node_fs35.mkdirSync)((0, import_node_path31.dirname)(abs), { recursive: true });
   const body = content.trimEnd() + (content.endsWith("\n") ? "" : "\n");
-  (0, import_node_fs34.writeFileSync)(abs, body, "utf8");
+  (0, import_node_fs35.writeFileSync)(abs, body, "utf8");
   return PLAN_FILE_REL;
 }
-var import_node_fs34, import_node_path30;
+var import_node_fs35, import_node_path31;
 var init_plan_file = __esm({
   "src/plan/plan-file.ts"() {
     "use strict";
-    import_node_fs34 = require("fs");
-    import_node_path30 = require("path");
+    import_node_fs35 = require("fs");
+    import_node_path31 = require("path");
     init_workspace_scratch();
     init_plan_present();
     init_plan_present();
@@ -8666,10 +8807,10 @@ __export(cursor_recover_exports, {
 function recoverFinishedCursorRun(opts) {
   const agentId = opts.agentId.trim();
   if (!agentId) return null;
-  const runsPath = (0, import_node_path31.join)(appDataDir(), "cursor-sdk-store", "runs.ndjson");
-  if (!(0, import_node_fs35.existsSync)(runsPath)) return null;
+  const runsPath = (0, import_node_path32.join)(appDataDir(), "cursor-sdk-store", "runs.ndjson");
+  if (!(0, import_node_fs36.existsSync)(runsPath)) return null;
   try {
-    const lines = (0, import_node_fs35.readFileSync)(runsPath, "utf8").split("\n");
+    const lines = (0, import_node_fs36.readFileSync)(runsPath, "utf8").split("\n");
     let best = null;
     for (const line of lines) {
       const trimmed = line.trim();
@@ -8695,12 +8836,12 @@ function recoverFinishedCursorRun(opts) {
     return null;
   }
 }
-var import_node_fs35, import_node_path31;
+var import_node_fs36, import_node_path32;
 var init_cursor_recover = __esm({
   "src/agents/cursor-recover.ts"() {
     "use strict";
-    import_node_fs35 = require("fs");
-    import_node_path31 = require("path");
+    import_node_fs36 = require("fs");
+    import_node_path32 = require("path");
     init_paths();
   }
 });
@@ -8753,6 +8894,7 @@ __export(index_exports, {
   CONTEXT_KEEP_RECENT_CHARS: () => CONTEXT_KEEP_RECENT_CHARS,
   CONTEXT_KEEP_RECENT_MESSAGES: () => CONTEXT_KEEP_RECENT_MESSAGES,
   CONTEXT_MIN_MESSAGES: () => CONTEXT_MIN_MESSAGES,
+  CONVENTION_SETUP_RELPATHS: () => CONVENTION_SETUP_RELPATHS,
   COORDINATOR_TOOL_PLAYBOOK: () => COORDINATOR_TOOL_PLAYBOOK,
   FAMOUS_SOCCER_TEAMS: () => FAMOUS_SOCCER_TEAMS,
   GITHUB_GIT_AUTH_MODES: () => GITHUB_GIT_AUTH_MODES,
@@ -8914,6 +9056,7 @@ __export(index_exports, {
   extractiveSummary: () => extractiveSummary,
   fetchPrHead: () => fetchPrHead,
   finalizeParts: () => finalizeParts,
+  findConventionSetup: () => findConventionSetup,
   findInvalidCacheControlTtlOrder: () => findInvalidCacheControlTtlOrder,
   findOrphanWorktrees: () => findOrphanWorktrees,
   findThreadByRef: () => findThreadByRef,
@@ -8985,6 +9128,7 @@ __export(index_exports, {
   hasBakedLinearOAuth: () => hasBakedLinearOAuth,
   hasBakedSlackOAuth: () => hasBakedSlackOAuth,
   hasConductorHook: () => hasConductorHook,
+  hasConventionSetup: () => hasConventionSetup,
   hasCursorWorktreeSetup: () => hasCursorWorktreeSetup,
   hasRepoHook: () => hasRepoHook,
   hasWorkspaceHook: () => hasWorkspaceHook,
@@ -9160,10 +9304,12 @@ __export(index_exports, {
   run: () => run,
   runArchiveScript: () => runArchiveScript,
   runCloudConnect: () => runCloudConnect,
+  runConventionSetup: () => runConventionSetup,
   runCursorWorktreeSetup: () => runCursorWorktreeSetup,
   runSetupScript: () => runSetupScript,
   runSlackListen: () => runSlackListen,
   runSlackRelayClient: () => runSlackRelayClient,
+  runWorkspaceSetup: () => runWorkspaceSetup,
   sameWorktreePath: () => sameWorktreePath,
   sanitizeMcpServerName: () => sanitizeMcpServerName,
   saveAppSettings: () => saveAppSettings,
@@ -10009,8 +10155,8 @@ async function listIssues(repoPath) {
 init_agents();
 
 // src/agents/spawn.ts
-var import_node_readline = require("readline");
-var import_execa2 = require("execa");
+var import_node_readline2 = require("readline");
+var import_execa3 = require("execa");
 init_worktree();
 init_git_auth_mode();
 init_app_settings();
@@ -10286,7 +10432,7 @@ async function spawnAgentTurn(thread, input, onEvent) {
     const detail = err instanceof Error ? err.message : String(err);
     console.warn(`[sideboard] git auth env failed (${thread.worktreePath}): ${detail}`);
   }
-  const child = (0, import_execa2.execa)(cmd.file, cmd.args, {
+  const child = (0, import_execa3.execa)(cmd.file, cmd.args, {
     cwd: cmd.cwd,
     env,
     reject: false,
@@ -10306,7 +10452,7 @@ async function spawnAgentTurn(thread, input, onEvent) {
   let usage = null;
   const consume = (stream, kind) => {
     if (!stream) return;
-    const rl = (0, import_node_readline.createInterface)({ input: stream, crlfDelay: Infinity });
+    const rl = (0, import_node_readline2.createInterface)({ input: stream, crlfDelay: Infinity });
     rl.on("line", (line) => {
       if (kind === "stderr") {
         onEvent({ type: "stderr", data: line });
@@ -10373,11 +10519,11 @@ init_usage();
 init_claude_mcp();
 
 // src/agents/instructions.ts
-var import_node_fs20 = require("fs");
-var import_node_path17 = require("path");
+var import_node_fs22 = require("fs");
+var import_node_path19 = require("path");
 init_git_auth_mode();
 init_worktree_labels();
-function normPath2(p) {
+function normPath3(p) {
   return p.replace(/\/+$/, "");
 }
 function formatRenameBranchDirective(thread, opts) {
@@ -10398,8 +10544,8 @@ function formatRenameBranchDirective(thread, opts) {
   return lines.join("\n");
 }
 function formatWorktreeDirective(thread, opts) {
-  const worktree = normPath2(thread.worktreePath);
-  const repo = normPath2(thread.repoPath);
+  const worktree = normPath3(thread.worktreePath);
+  const repo = normPath3(thread.repoPath);
   const dir = worktreeNameFromPath(thread.worktreePath);
   const lines = [
     "Sideboard workspace (mandatory):",
@@ -10544,11 +10690,11 @@ function loadAgentInstructions(worktreePath, agent) {
   const out = [];
   for (const rel of candidates) {
     if (seenPaths.has(rel)) continue;
-    const abs = (0, import_node_path17.join)(worktreePath, rel);
-    if (!(0, import_node_fs20.existsSync)(abs)) continue;
+    const abs = (0, import_node_path19.join)(worktreePath, rel);
+    if (!(0, import_node_fs22.existsSync)(abs)) continue;
     try {
-      if (!(0, import_node_fs20.statSync)(abs).isFile()) continue;
-      let content = (0, import_node_fs20.readFileSync)(abs, "utf8");
+      if (!(0, import_node_fs22.statSync)(abs).isFile()) continue;
+      let content = (0, import_node_fs22.readFileSync)(abs, "utf8");
       if (!content.trim()) continue;
       if (content.length > MAX_CHARS_PER_FILE) {
         content = `${content.slice(0, MAX_CHARS_PER_FILE)}
@@ -10630,13 +10776,15 @@ async function requireAgent(agent, opts) {
 init_settings();
 
 // src/hook/conductor.ts
-var import_node_fs21 = require("fs");
+var import_node_fs23 = require("fs");
 var import_node_net = require("net");
-var import_node_path18 = require("path");
-var import_execa3 = require("execa");
-var import_node_readline2 = require("readline");
+var import_node_path20 = require("path");
+var import_execa4 = require("execa");
+var import_node_readline3 = require("readline");
 init_settings();
 init_nested_electron_env();
+init_convention_setup();
+init_cursor_worktrees();
 init_git_auth_mode();
 init_nested_electron_env();
 var PORT_RANGE_SIZE = 10;
@@ -10645,9 +10793,9 @@ function matchSimpleGlob(pattern, name) {
   return new RegExp(`^${escaped}$`).test(name);
 }
 function readWorktreeInclude(repoPath) {
-  const path2 = (0, import_node_path18.join)(repoPath, ".worktreeinclude");
-  if (!(0, import_node_fs21.existsSync)(path2)) return [];
-  return (0, import_node_fs21.readFileSync)(path2, "utf8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+  const path2 = (0, import_node_path20.join)(repoPath, ".worktreeinclude");
+  if (!(0, import_node_fs23.existsSync)(path2)) return [];
+  return (0, import_node_fs23.readFileSync)(path2, "utf8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
 }
 function resolveFilesToCopy(repoPath) {
   const fromInclude = readWorktreeInclude(repoPath);
@@ -10657,10 +10805,10 @@ function resolveFilesToCopy(repoPath) {
   if (settings?.fileIncludeGlobs?.length) {
     const matched = [];
     try {
-      for (const entry of (0, import_node_fs21.readdirSync)(repoPath, { withFileTypes: true })) {
+      for (const entry of (0, import_node_fs23.readdirSync)(repoPath, { withFileTypes: true })) {
         if (!entry.isFile()) continue;
         for (const glob of settings.fileIncludeGlobs) {
-          if (matchSimpleGlob(glob, entry.name) || matchSimpleGlob((0, import_node_path18.basename)(glob), entry.name)) {
+          if (matchSimpleGlob(glob, entry.name) || matchSimpleGlob((0, import_node_path20.basename)(glob), entry.name)) {
             matched.push(entry.name);
             break;
           }
@@ -10672,7 +10820,7 @@ function resolveFilesToCopy(repoPath) {
   }
   const defaults = [];
   try {
-    for (const entry of (0, import_node_fs21.readdirSync)(repoPath, { withFileTypes: true })) {
+    for (const entry of (0, import_node_fs23.readdirSync)(repoPath, { withFileTypes: true })) {
       if (entry.isFile() && entry.name.startsWith(".env")) {
         defaults.push(entry.name);
       }
@@ -10686,11 +10834,11 @@ function copyConfiguredFiles(repoPath, worktreePath) {
   const patterns = resolveFilesToCopy(repoPath);
   const copied = [];
   for (const rel of patterns) {
-    const src = (0, import_node_path18.join)(repoPath, rel);
-    if (!(0, import_node_fs21.existsSync)(src)) continue;
-    const dest = (0, import_node_path18.join)(worktreePath, rel);
-    (0, import_node_fs21.mkdirSync)((0, import_node_path18.dirname)(dest), { recursive: true });
-    (0, import_node_fs21.copyFileSync)(src, dest);
+    const src = (0, import_node_path20.join)(repoPath, rel);
+    if (!(0, import_node_fs23.existsSync)(src)) continue;
+    const dest = (0, import_node_path20.join)(worktreePath, rel);
+    (0, import_node_fs23.mkdirSync)((0, import_node_path20.dirname)(dest), { recursive: true });
+    (0, import_node_fs23.copyFileSync)(src, dest);
     copied.push(rel);
   }
   return copied;
@@ -10700,7 +10848,7 @@ async function captureLoginEnv() {
   if (cachedLoginEnv) return { ...cachedLoginEnv };
   const shell = process.env.SHELL?.trim() || (process.platform === "darwin" ? "/bin/zsh" : "/bin/bash");
   try {
-    const result = await (0, import_execa3.execa)(shell, ["-l", "-c", "env -0"], {
+    const result = await (0, import_execa4.execa)(shell, ["-l", "-c", "env -0"], {
       reject: false,
       timeout: 5e3
     });
@@ -10726,7 +10874,7 @@ function buildWorkspaceScriptEnv(opts, baseEnv) {
   const env = stripNestedElectronEnv({
     ...baseEnv ?? process.env
   });
-  const name = opts.workspaceName ?? (0, import_node_path18.basename)(opts.worktreePath);
+  const name = opts.workspaceName ?? (0, import_node_path20.basename)(opts.worktreePath);
   const ports = opts.ports ?? [];
   const primary = ports[0];
   env.SIDEBOARD_WORKSPACE_NAME = name;
@@ -10753,7 +10901,7 @@ function buildWorkspaceScriptEnv(opts, baseEnv) {
 }
 function pipeLines(stream, onLine) {
   if (!stream || !onLine) return;
-  const rl = (0, import_node_readline2.createInterface)({ input: stream });
+  const rl = (0, import_node_readline3.createInterface)({ input: stream });
   rl.on("line", onLine);
 }
 function killScriptTree(child, ports = []) {
@@ -10761,7 +10909,7 @@ function killScriptTree(child, ports = []) {
   if (pid) {
     try {
       if (process.platform === "win32") {
-        void (0, import_execa3.execa)("taskkill", ["/pid", String(pid), "/T", "/F"], { reject: false });
+        void (0, import_execa4.execa)("taskkill", ["/pid", String(pid), "/T", "/F"], { reject: false });
       } else {
         process.kill(-pid, "SIGTERM");
         setTimeout(() => {
@@ -10781,7 +10929,7 @@ function killScriptTree(child, ports = []) {
   for (const port of ports) {
     if (!Number.isFinite(port) || port <= 0) continue;
     if (process.platform === "win32") {
-      void (0, import_execa3.execa)(
+      void (0, import_execa4.execa)(
         "powershell",
         [
           "-NoProfile",
@@ -10791,7 +10939,7 @@ function killScriptTree(child, ports = []) {
         { reject: false }
       );
     } else {
-      void (0, import_execa3.execa)(
+      void (0, import_execa4.execa)(
         "zsh",
         ["-lc", `pids=$(lsof -tiTCP:${port} -sTCP:LISTEN 2>/dev/null); [ -n "$pids" ] && kill -TERM $pids 2>/dev/null; true`],
         { reject: false }
@@ -10816,7 +10964,7 @@ async function spawnWorkspaceScript(command, opts) {
   } catch {
   }
   const shell = process.platform === "darwin" ? "zsh" : "bash";
-  const child = (0, import_execa3.execa)(shell, ["-lc", command], {
+  const child = (0, import_execa4.execa)(shell, ["-lc", command], {
     cwd: opts.worktreePath,
     reject: false,
     env,
@@ -10834,6 +10982,14 @@ async function spawnWorkspaceScript(command, opts) {
     child
   };
 }
+async function attachAbort(handle, signal) {
+  if (signal) {
+    const onAbort = () => handle.kill();
+    if (signal.aborted) onAbort();
+    else signal.addEventListener("abort", onAbort, { once: true });
+  }
+  return handle.done;
+}
 async function runSetupScript(repoPath, worktreePath, onLine, opts) {
   const settings = loadWorkspaceSettings(worktreePath, repoPath);
   if (!settings?.setup) return { ran: false, exitCode: null, source: null };
@@ -10843,12 +10999,7 @@ async function runSetupScript(repoPath, worktreePath, onLine, opts) {
     defaultBranch: opts?.defaultBranch,
     onLine
   });
-  if (opts?.signal) {
-    const onAbort = () => handle.kill();
-    if (opts.signal.aborted) onAbort();
-    else opts.signal.addEventListener("abort", onAbort, { once: true });
-  }
-  const exitCode = await handle.done;
+  const exitCode = await attachAbort(handle, opts?.signal);
   return {
     ran: true,
     exitCode,
@@ -10856,6 +11007,34 @@ async function runSetupScript(repoPath, worktreePath, onLine, opts) {
     kill: handle.kill
   };
 }
+async function runConventionSetup(repoPath, worktreePath, onLine, opts) {
+  const found = findConventionSetup(worktreePath, repoPath);
+  if (!found) return { ran: false, exitCode: null, source: null };
+  onLine?.(`[setup] ${found.source}`);
+  const handle = await spawnWorkspaceScript(found.command, {
+    worktreePath,
+    repoPath,
+    defaultBranch: opts?.defaultBranch,
+    onLine
+  });
+  const exitCode = await attachAbort(handle, opts?.signal);
+  return {
+    ran: true,
+    exitCode,
+    source: found.source,
+    kill: handle.kill
+  };
+}
+async function runWorkspaceSetup(repoPath, worktreePath, onLine, opts) {
+  let setup = await runSetupScript(repoPath, worktreePath, onLine, opts);
+  if (!setup.ran) {
+    setup = await runCursorWorktreeSetup(repoPath, worktreePath, onLine);
+  }
+  if (!setup.ran) {
+    setup = await runConventionSetup(repoPath, worktreePath, onLine, opts);
+  }
+  return setup;
+}
 async function runArchiveScript(repoPath, worktreePath, onLine) {
   const settings = loadWorkspaceSettings(worktreePath, repoPath);
   if (!settings?.archive) return { ran: false, exitCode: null };
@@ -10948,86 +11127,17 @@ async function startDevServer(repoPath, worktreePath, onLine, opts) {
   };
 }
 
-// src/hook/cursor-worktrees.ts
-var import_node_fs22 = require("fs");
-var import_node_path19 = require("path");
-var import_execa4 = require("execa");
-var import_node_readline3 = require("readline");
-function loadCursorWorktreesJson(rootPath) {
-  const path2 = (0, import_node_path19.join)(rootPath, ".cursor", "worktrees.json");
-  if (!(0, import_node_fs22.existsSync)(path2)) return null;
-  try {
-    return JSON.parse((0, import_node_fs22.readFileSync)(path2, "utf8"));
-  } catch {
-    return null;
-  }
-}
-function resolveSetupSpec(config) {
-  if (process.platform === "win32") {
-    return config["setup-worktree-windows"] ?? config["setup-worktree"] ?? null;
-  }
-  return config["setup-worktree-unix"] ?? config["setup-worktree"] ?? null;
-}
-async function runCursorWorktreeSetup(repoPath, worktreePath, onLine) {
-  const fromWorktree = loadCursorWorktreesJson(worktreePath);
-  const fromRepo = worktreePath !== repoPath ? loadCursorWorktreesJson(repoPath) : null;
-  const config = fromWorktree ?? fromRepo;
-  if (!config) return { ran: false, exitCode: null, source: null };
-  const spec = resolveSetupSpec(config);
-  if (!spec) return { ran: false, exitCode: null, source: null };
-  const sourceLabel = fromWorktree ? ".cursor/worktrees.json (worktree)" : ".cursor/worktrees.json (main repo)";
-  const env = {
-    ...process.env,
-    ROOT_WORKTREE_PATH: repoPath
-  };
-  if (process.platform === "win32") {
-    env.ROOT_WORKTREE_PATH = repoPath;
-  }
-  const commands = Array.isArray(spec) ? spec : [spec.endsWith(".sh") || spec.endsWith(".ps1") ? (0, import_node_path19.join)(
-    fromWorktree ? worktreePath : repoPath,
-    ".cursor",
-    spec
-  ) : spec];
-  let lastExit = 0;
-  for (const command of commands) {
-    const isScriptPath = typeof spec === "string" && (spec.endsWith(".sh") || spec.endsWith(".ps1"));
-    const shell = process.platform === "win32" ? "powershell" : "bash";
-    const args = process.platform === "win32" ? isScriptPath ? ["-File", command] : ["-Command", command] : isScriptPath ? [command] : ["-lc", command];
-    onLine?.(`[cursor setup] ${command}`);
-    const child = (0, import_execa4.execa)(shell, args, {
-      cwd: worktreePath,
-      reject: false,
-      env
-    });
-    if (child.stdout && onLine) {
-      const rl = (0, import_node_readline3.createInterface)({ input: child.stdout });
-      rl.on("line", onLine);
-    }
-    if (child.stderr && onLine) {
-      const rl = (0, import_node_readline3.createInterface)({ input: child.stderr });
-      rl.on("line", onLine);
-    }
-    const result = await child;
-    lastExit = result.exitCode ?? null;
-    if (lastExit !== 0 && lastExit !== null) break;
-  }
-  return { ran: true, exitCode: lastExit, source: sourceLabel };
-}
-function hasCursorWorktreeSetup(worktreePath, repoPath) {
-  if (loadCursorWorktreesJson(worktreePath)) return true;
-  if (repoPath && repoPath !== worktreePath && loadCursorWorktreesJson(repoPath)) {
-    return true;
-  }
-  return false;
-}
+// src/index.ts
+init_convention_setup();
+init_cursor_worktrees();
 
 // src/diff/diff.ts
-var import_node_fs23 = require("fs");
-var import_node_path20 = require("path");
+var import_node_fs24 = require("fs");
+var import_node_path21 = require("path");
 init_run();
 init_worktree();
 async function inspectGitWorktree(worktreePath) {
-  if (!worktreePath || !(0, import_node_fs23.existsSync)(worktreePath)) return "missing_worktree";
+  if (!worktreePath || !(0, import_node_fs24.existsSync)(worktreePath)) return "missing_worktree";
   const check = await git(["rev-parse", "--is-inside-work-tree"], worktreePath, {
     reject: false
   });
@@ -11035,7 +11145,7 @@ async function inspectGitWorktree(worktreePath) {
   return "ok";
 }
 async function initializeGitRepository(worktreePath) {
-  if (!worktreePath || !(0, import_node_fs23.existsSync)(worktreePath)) {
+  if (!worktreePath || !(0, import_node_fs24.existsSync)(worktreePath)) {
     throw new Error("Worktree not found");
   }
   const status = await inspectGitWorktree(worktreePath);
@@ -11170,11 +11280,11 @@ new file mode 100644
   };
 }
 async function untrackedPatch(worktreePath, path2, maxHunk) {
-  const abs = (0, import_node_path20.join)(worktreePath, path2);
+  const abs = (0, import_node_path21.join)(worktreePath, path2);
   try {
-    const st = (0, import_node_fs23.statSync)(abs);
+    const st = (0, import_node_fs24.statSync)(abs);
     if (st.isFile() && st.size > maxHunk) {
-      const buf = (0, import_node_fs23.readFileSync)(abs).subarray(0, maxHunk);
+      const buf = (0, import_node_fs24.readFileSync)(abs).subarray(0, maxHunk);
       return syntheticAddPatch(path2, buf.toString("utf8"), maxHunk);
     }
   } catch {
@@ -11675,8 +11785,8 @@ var DEFAULT_UPLOAD_MAX_BYTES = 5e7;
 function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? DEFAULT_UPLOAD_MAX_BYTES;
-  const abs = (0, import_node_path20.join)(worktreePath, relativePath);
-  const st = (0, import_node_fs23.statSync)(abs);
+  const abs = (0, import_node_path21.join)(worktreePath, relativePath);
+  const st = (0, import_node_fs24.statSync)(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
@@ -11685,7 +11795,7 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
       `File too large to upload (${st.size} bytes; max ${maxBytes})`
     );
   }
-  const buf = (0, import_node_fs23.readFileSync)(abs);
+  const buf = (0, import_node_fs24.readFileSync)(abs);
   return {
     path: relativePath,
     contentBase64: buf.toString("base64"),
@@ -11695,12 +11805,12 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
 function readWorktreeFile(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? 2e5;
-  const abs = (0, import_node_path20.join)(worktreePath, relativePath);
-  const st = (0, import_node_fs23.statSync)(abs);
+  const abs = (0, import_node_path21.join)(worktreePath, relativePath);
+  const st = (0, import_node_fs24.statSync)(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
-  const buf = (0, import_node_fs23.readFileSync)(abs);
+  const buf = (0, import_node_fs24.readFileSync)(abs);
   if (isImageRelativePath(relativePath)) {
     const maxImageBytes = Math.max(maxBytes, 15e6);
     const truncated2 = buf.length > maxImageBytes;
@@ -11743,9 +11853,9 @@ function assertSafeRelativePath(relativePath) {
 }
 function writeWorktreeFile(worktreePath, relativePath, content) {
   assertSafeRelativePath(relativePath);
-  const abs = (0, import_node_path20.join)(worktreePath, relativePath);
-  (0, import_node_fs23.mkdirSync)((0, import_node_path20.dirname)(abs), { recursive: true });
-  (0, import_node_fs23.writeFileSync)(abs, content, "utf8");
+  const abs = (0, import_node_path21.join)(worktreePath, relativePath);
+  (0, import_node_fs24.mkdirSync)((0, import_node_path21.dirname)(abs), { recursive: true });
+  (0, import_node_fs24.writeFileSync)(abs, content, "utf8");
   return { path: relativePath };
 }
 async function getDiffSummary(worktreePath, repoPath, opts) {
@@ -11764,9 +11874,9 @@ async function getDiffSummary(worktreePath, repoPath, opts) {
 }
 
 // src/skills/discover.ts
-var import_node_fs24 = require("fs");
+var import_node_fs25 = require("fs");
 var import_node_os8 = require("os");
-var import_node_path21 = require("path");
+var import_node_path22 = require("path");
 function toCommand(name) {
   return name.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }
@@ -11798,7 +11908,7 @@ function parseFrontmatter(content) {
 }
 function readSkill(skillMd, source) {
   try {
-    const content = (0, import_node_fs24.readFileSync)(skillMd, "utf8");
+    const content = (0, import_node_fs25.readFileSync)(skillMd, "utf8");
     const { name: fmName, description } = parseFrontmatter(content);
     const dirName = skillMd.split("/").slice(-2, -1)[0] || "skill";
     const name = fmName || dirName;
@@ -11817,19 +11927,19 @@ function readSkill(skillMd, source) {
   }
 }
 function scanSkillsDir(dir, source, out) {
-  if (!(0, import_node_fs24.existsSync)(dir)) return;
+  if (!(0, import_node_fs25.existsSync)(dir)) return;
   let entries;
   try {
-    entries = (0, import_node_fs24.readdirSync)(dir);
+    entries = (0, import_node_fs25.readdirSync)(dir);
   } catch {
     return;
   }
   for (const entry of entries) {
     if (entry.startsWith(".")) continue;
-    const skillMd = (0, import_node_path21.join)(dir, entry, "SKILL.md");
-    if (!(0, import_node_fs24.existsSync)(skillMd)) continue;
+    const skillMd = (0, import_node_path22.join)(dir, entry, "SKILL.md");
+    if (!(0, import_node_fs25.existsSync)(skillMd)) continue;
     try {
-      if (!(0, import_node_fs24.statSync)(skillMd).isFile()) continue;
+      if (!(0, import_node_fs25.statSync)(skillMd).isFile()) continue;
     } catch {
       continue;
     }
@@ -11838,24 +11948,24 @@ function scanSkillsDir(dir, source, out) {
   }
 }
 function scanClaudePluginSkills(pluginsRoot, out) {
-  if (!(0, import_node_fs24.existsSync)(pluginsRoot)) return;
+  if (!(0, import_node_fs25.existsSync)(pluginsRoot)) return;
   const walk = (dir, depth, lookingForSkillsDir) => {
     if (depth > 7) return;
     let entries;
     try {
-      entries = (0, import_node_fs24.readdirSync)(dir);
+      entries = (0, import_node_fs25.readdirSync)(dir);
     } catch {
       return;
     }
     if (lookingForSkillsDir && entries.includes("SKILL.md")) {
-      const skill = readSkill((0, import_node_path21.join)(dir, "SKILL.md"), "cli");
+      const skill = readSkill((0, import_node_path22.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_path21.join)(dir, entry);
+      const full = (0, import_node_path22.join)(dir, entry);
       try {
-        if (!(0, import_node_fs24.statSync)(full).isDirectory()) continue;
+        if (!(0, import_node_fs25.statSync)(full).isDirectory()) continue;
       } catch {
         continue;
       }
@@ -11873,17 +11983,17 @@ function discoverSkills(worktreePath) {
   const home = (0, import_node_os8.homedir)();
   const collected = [];
   for (const rel of [".claude/skills", ".cursor/skills", ".sideboard/skills", ".brightsy/skills", "skills"]) {
-    scanSkillsDir((0, import_node_path21.join)(worktreePath, rel), "workspace", collected);
+    scanSkillsDir((0, import_node_path22.join)(worktreePath, rel), "workspace", collected);
   }
   for (const abs of [
-    (0, import_node_path21.join)(home, ".claude/skills"),
-    (0, import_node_path21.join)(home, ".cursor/skills"),
-    (0, import_node_path21.join)(home, ".sideboard/skills"),
-    (0, import_node_path21.join)(home, ".brightsy/skills")
+    (0, import_node_path22.join)(home, ".claude/skills"),
+    (0, import_node_path22.join)(home, ".cursor/skills"),
+    (0, import_node_path22.join)(home, ".sideboard/skills"),
+    (0, import_node_path22.join)(home, ".brightsy/skills")
   ]) {
     scanSkillsDir(abs, "user", collected);
   }
-  scanClaudePluginSkills((0, import_node_path21.join)(home, ".claude/plugins"), collected);
+  scanClaudePluginSkills((0, import_node_path22.join)(home, ".claude/plugins"), collected);
   const rank = { workspace: 0, user: 1, cli: 2 };
   const byCommand = /* @__PURE__ */ new Map();
   for (const skill of collected) {
@@ -11895,7 +12005,7 @@ function discoverSkills(worktreePath) {
   return [...byCommand.values()].sort((a, b) => a.command.localeCompare(b.command));
 }
 function readSkillBody(skillPath, maxChars = 12e3) {
-  const raw = (0, import_node_fs24.readFileSync)(skillPath, "utf8");
+  const raw = (0, import_node_fs25.readFileSync)(skillPath, "utf8");
   if (raw.startsWith("---")) {
     const end = raw.indexOf("\n---", 3);
     if (end >= 0) {
@@ -12036,8 +12146,8 @@ function buildDiffCommentAttachment(input) {
 }
 
 // src/composer/stage-files.ts
-var import_node_fs25 = require("fs");
-var import_node_path22 = require("path");
+var import_node_fs26 = require("fs");
+var import_node_path23 = require("path");
 var import_node_crypto5 = require("crypto");
 init_workspace_scratch();
 var IMAGE_EXTENSIONS2 = /* @__PURE__ */ new Set([
@@ -12063,7 +12173,7 @@ var IMAGE_MIME_BY_EXT = {
 var MAX_INLINE_BYTES = 4e5;
 var MAX_PREVIEW_BYTES = 5e6;
 function fileExtension(filePath) {
-  const base = (0, import_node_path22.basename)(filePath).toLowerCase();
+  const base = (0, import_node_path23.basename)(filePath).toLowerCase();
   return base.includes(".") ? base.split(".").pop() || "" : "";
 }
 function isImageFilePath(filePath) {
@@ -12073,22 +12183,22 @@ function imageMimeType(filePath) {
   return IMAGE_MIME_BY_EXT[fileExtension(filePath)] || "image/png";
 }
 function ensureAttachmentsDir(worktreePath) {
-  const dir = (0, import_node_path22.join)(worktreePath, ATTACHMENTS_DIR);
-  (0, import_node_fs25.mkdirSync)(dir, { recursive: true });
-  const gi = (0, import_node_path22.join)(dir, ".gitignore");
-  if (!(0, import_node_fs25.existsSync)(gi)) {
-    (0, import_node_fs25.writeFileSync)(gi, attachmentsGitignoreBody(), "utf8");
+  const dir = (0, import_node_path23.join)(worktreePath, ATTACHMENTS_DIR);
+  (0, import_node_fs26.mkdirSync)(dir, { recursive: true });
+  const gi = (0, import_node_path23.join)(dir, ".gitignore");
+  if (!(0, import_node_fs26.existsSync)(gi)) {
+    (0, import_node_fs26.writeFileSync)(gi, attachmentsGitignoreBody(), "utf8");
   }
   return dir;
 }
 function uniqueAttachmentName(dir, originalName) {
   const safe = originalName.replace(/[/\\]/g, "_") || "file";
-  if (!(0, import_node_fs25.existsSync)((0, import_node_path22.join)(dir, safe))) return safe;
-  const ext = (0, import_node_path22.extname)(safe);
+  if (!(0, import_node_fs26.existsSync)((0, import_node_path23.join)(dir, safe))) return safe;
+  const ext = (0, import_node_path23.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_fs25.existsSync)((0, import_node_path22.join)(dir, candidate))) return candidate;
+    if (!(0, import_node_fs26.existsSync)((0, import_node_path23.join)(dir, candidate))) return candidate;
   }
   return `${stem}-${(0, import_node_crypto5.randomUUID)()}${ext}`;
 }
@@ -12140,9 +12250,9 @@ function attachmentFromBuffer(name, buf, opts) {
   };
 }
 function attachmentFromAbsolutePath(absolutePath) {
-  const name = (0, import_node_path22.basename)(absolutePath);
+  const name = (0, import_node_path23.basename)(absolutePath);
   try {
-    const st = (0, import_node_fs25.statSync)(absolutePath);
+    const st = (0, import_node_fs26.statSync)(absolutePath);
     if (!st.isFile()) {
       return {
         id: (0, import_node_crypto5.randomUUID)(),
@@ -12151,7 +12261,7 @@ function attachmentFromAbsolutePath(absolutePath) {
         content: `(not a file: ${absolutePath})`
       };
     }
-    const buf = (0, import_node_fs25.readFileSync)(absolutePath);
+    const buf = (0, import_node_fs26.readFileSync)(absolutePath);
     return attachmentFromBuffer(name, buf, { sourceLabel: absolutePath });
   } catch (err) {
     return {
@@ -12167,15 +12277,15 @@ function stageAbsolutePathsAsAttachments(worktreePath, absolutePaths) {
   const dir = ensureAttachmentsDir(worktreePath);
   const out = [];
   for (const abs of absolutePaths) {
-    const originalName = (0, import_node_path22.basename)(abs);
+    const originalName = (0, import_node_path23.basename)(abs);
     try {
-      const st = (0, import_node_fs25.statSync)(abs);
+      const st = (0, import_node_fs26.statSync)(abs);
       if (!st.isFile()) continue;
       const name = uniqueAttachmentName(dir, originalName);
-      const destAbs = (0, import_node_path22.join)(dir, name);
-      (0, import_node_fs25.copyFileSync)(abs, destAbs);
+      const destAbs = (0, import_node_path23.join)(dir, name);
+      (0, import_node_fs26.copyFileSync)(abs, destAbs);
       const rel = `${ATTACHMENTS_DIR}/${name}`;
-      const buf = (0, import_node_fs25.readFileSync)(destAbs);
+      const buf = (0, import_node_fs26.readFileSync)(destAbs);
       out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
     } catch (err) {
       out.push({
@@ -12197,8 +12307,8 @@ function stageBuffersAsAttachments(worktreePath, buffers) {
     try {
       const buf = Buffer.from(item.dataBase64, "base64");
       const name = uniqueAttachmentName(dir, originalName);
-      const destAbs = (0, import_node_path22.join)(dir, name);
-      (0, import_node_fs25.writeFileSync)(destAbs, buf);
+      const destAbs = (0, import_node_path23.join)(dir, name);
+      (0, import_node_fs26.writeFileSync)(destAbs, buf);
       const rel = `${ATTACHMENTS_DIR}/${name}`;
       out.push(attachmentFromBuffer(name, buf, { path: rel }));
     } catch (err) {
@@ -12234,18 +12344,18 @@ function attachmentsFromWorktreePaths(worktreePath, relativePaths) {
     if (!rel || rel.includes("..") || rel.startsWith("/")) {
       out.push({
         id: (0, import_node_crypto5.randomUUID)(),
-        name: (0, import_node_path22.basename)(rel) || "file",
+        name: (0, import_node_path23.basename)(rel) || "file",
         kind: "file",
         content: `(invalid path: ${rel})`
       });
       continue;
     }
-    const name = (0, import_node_path22.basename)(rel);
+    const name = (0, import_node_path23.basename)(rel);
     try {
-      const abs = (0, import_node_path22.join)(worktreePath, rel);
-      const st = (0, import_node_fs25.statSync)(abs);
+      const abs = (0, import_node_path23.join)(worktreePath, rel);
+      const st = (0, import_node_fs26.statSync)(abs);
       if (!st.isFile()) continue;
-      const buf = (0, import_node_fs25.readFileSync)(abs);
+      const buf = (0, import_node_fs26.readFileSync)(abs);
       out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
     } catch (err) {
       out.push({
@@ -12733,7 +12843,7 @@ async function confirmLand(thread, opts) {
 }
 
 // src/threads/create.ts
-var import_node_fs26 = require("fs");
+var import_node_fs27 = require("fs");
 init_worktree();
 init_app_settings();
 init_thread_store();
@@ -12747,7 +12857,7 @@ async function createThread(input, _onSetupLine) {
   });
   await requireAgent(resolved.agent);
   const repoPath = await resolveRepoRoot(input.repoPath);
-  if (!(0, import_node_fs26.existsSync)(repoPath)) {
+  if (!(0, import_node_fs27.existsSync)(repoPath)) {
     throw new Error(`Repo not found: ${repoPath}`);
   }
   let sourceRef = input.sourceRef;
@@ -12974,7 +13084,7 @@ async function forkThreadWorktree(input, onSetupLine) {
 }
 
 // src/threads/stack-layers.ts
-var import_node_fs27 = require("fs");
+var import_node_fs28 = require("fs");
 init_run();
 init_stack();
 init_worktree();
@@ -13042,7 +13152,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_fs27.existsSync)(checkedOut.path)) {
+  if (checkedOut?.path && (0, import_node_fs28.existsSync)(checkedOut.path)) {
     if (input.reuseExistingWorktree !== false) {
       worktreePath = checkedOut.path;
     } else {
@@ -13184,7 +13294,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_fs27.existsSync)(repoPath)) throw new Error(`Repo not found: ${repoPath}`);
+  if (!(0, import_node_fs28.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);
@@ -13251,7 +13361,7 @@ async function createPrStack(input, onSetupLine) {
     }
   }
   const claimed = new Set(threads.map((t) => t.worktreePath));
-  if (!claimed.has(bootstrap.worktreePath) && (0, import_node_fs27.existsSync)(bootstrap.worktreePath)) {
+  if (!claimed.has(bootstrap.worktreePath) && (0, import_node_fs28.existsSync)(bootstrap.worktreePath)) {
     try {
       await removeWorktree(repoPath, bootstrap.worktreePath, {
         deleteBranch: bootstrap.branchName
@@ -13274,20 +13384,20 @@ function stackAgentDefaultsFrom(input) {
 
 // src/threads/adopt.ts
 var import_node_child_process4 = require("child_process");
-var import_node_fs28 = require("fs");
+var import_node_fs29 = require("fs");
 var import_node_os9 = require("os");
-var import_node_path23 = require("path");
+var import_node_path24 = require("path");
 var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
 init_worktree();
 init_thread_store();
-var CONDUCTOR_APP_SUPPORT = (0, import_node_path23.join)(
+var CONDUCTOR_APP_SUPPORT = (0, import_node_path24.join)(
   process.env.HOME ?? "",
   "Library",
   "Application Support",
   "com.conductor.app"
 );
-var CONDUCTOR_DB = (0, import_node_path23.join)(CONDUCTOR_APP_SUPPORT, "conductor.db");
-var CURSOR_SDK_STORE = (0, import_node_path23.join)(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
+var CONDUCTOR_DB = (0, import_node_path24.join)(CONDUCTOR_APP_SUPPORT, "conductor.db");
+var CURSOR_SDK_STORE = (0, import_node_path24.join)(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
 function mapAgentType(raw) {
   if (!raw) return null;
   const v = raw.toLowerCase();
@@ -13299,21 +13409,21 @@ function mapAgentType(raw) {
   return null;
 }
 function resolveConductorCursorAgentId(workspacePath) {
-  if (!workspacePath || !(0, import_node_fs28.existsSync)(CURSOR_SDK_STORE)) return null;
+  if (!workspacePath || !(0, import_node_fs29.existsSync)(CURSOR_SDK_STORE)) return null;
   const normalized = workspacePath.replace(/\/$/, "");
   let best = null;
   let hashes;
   try {
-    hashes = (0, import_node_fs28.readdirSync)(CURSOR_SDK_STORE);
+    hashes = (0, import_node_fs29.readdirSync)(CURSOR_SDK_STORE);
   } catch {
     return null;
   }
   for (const hash of hashes) {
-    const agentsFile = (0, import_node_path23.join)(CURSOR_SDK_STORE, hash, "agents.ndjson");
-    if (!(0, import_node_fs28.existsSync)(agentsFile)) continue;
+    const agentsFile = (0, import_node_path24.join)(CURSOR_SDK_STORE, hash, "agents.ndjson");
+    if (!(0, import_node_fs29.existsSync)(agentsFile)) continue;
     let text3;
     try {
-      text3 = (0, import_node_fs28.readFileSync)(agentsFile, "utf8");
+      text3 = (0, import_node_fs29.readFileSync)(agentsFile, "utf8");
     } catch {
       continue;
     }
@@ -13337,7 +13447,7 @@ function resolveConductorCursorAgentId(workspacePath) {
   return best?.agentId ?? null;
 }
 async function adoptThread(input) {
-  if (!(0, import_node_fs28.existsSync)(input.worktreePath)) {
+  if (!(0, import_node_fs29.existsSync)(input.worktreePath)) {
     throw new Error(`Worktree not found: ${input.worktreePath}`);
   }
   const repoPath = await resolveRepoRoot(input.worktreePath);
@@ -13364,18 +13474,18 @@ function conductorDbPath() {
   return CONDUCTOR_DB;
 }
 function listConductorWorkspaces() {
-  if (!(0, import_node_fs28.existsSync)(CONDUCTOR_DB)) {
+  if (!(0, import_node_fs29.existsSync)(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = (0, import_node_fs28.mkdtempSync)((0, import_node_path23.join)((0, import_node_os9.tmpdir)(), "sideboard-conductor-"));
-  const snapshot = (0, import_node_path23.join)(tmp, "conductor.db");
+  const tmp = (0, import_node_fs29.mkdtempSync)((0, import_node_path24.join)((0, import_node_os9.tmpdir)(), "sideboard-conductor-"));
+  const snapshot = (0, import_node_path24.join)(tmp, "conductor.db");
   try {
-    (0, import_node_fs28.copyFileSync)(CONDUCTOR_DB, snapshot);
+    (0, import_node_fs29.copyFileSync)(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if ((0, import_node_fs28.existsSync)(src)) {
+      if ((0, import_node_fs29.existsSync)(src)) {
         try {
-          (0, import_node_fs28.copyFileSync)(src, `${snapshot}${suffix}`);
+          (0, import_node_fs29.copyFileSync)(src, `${snapshot}${suffix}`);
         } catch {
         }
       }
@@ -13451,22 +13561,22 @@ function listConductorWorkspaces() {
       db.close();
     }
   } finally {
-    (0, import_node_fs28.rmSync)(tmp, { recursive: true, force: true });
+    (0, import_node_fs29.rmSync)(tmp, { recursive: true, force: true });
   }
 }
 function importConductorWorkspace(workspaceId) {
-  if (!(0, import_node_fs28.existsSync)(CONDUCTOR_DB)) {
+  if (!(0, import_node_fs29.existsSync)(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = (0, import_node_fs28.mkdtempSync)((0, import_node_path23.join)((0, import_node_os9.tmpdir)(), "sideboard-conductor-"));
-  const snapshot = (0, import_node_path23.join)(tmp, "conductor.db");
+  const tmp = (0, import_node_fs29.mkdtempSync)((0, import_node_path24.join)((0, import_node_os9.tmpdir)(), "sideboard-conductor-"));
+  const snapshot = (0, import_node_path24.join)(tmp, "conductor.db");
   try {
-    (0, import_node_fs28.copyFileSync)(CONDUCTOR_DB, snapshot);
+    (0, import_node_fs29.copyFileSync)(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if ((0, import_node_fs28.existsSync)(src)) {
+      if ((0, import_node_fs29.existsSync)(src)) {
         try {
-          (0, import_node_fs28.copyFileSync)(src, `${snapshot}${suffix}`);
+          (0, import_node_fs29.copyFileSync)(src, `${snapshot}${suffix}`);
         } catch {
         }
       }
@@ -13484,7 +13594,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_fs28.existsSync)(worktreePath)) {
+      if (!(0, import_node_fs29.existsSync)(worktreePath)) {
         throw new Error(`Conductor worktree missing on disk: ${worktreePath}`);
       }
       let sessionId = null;
@@ -13547,7 +13657,7 @@ function importConductorWorkspace(workspaceId) {
       db.close();
     }
   } finally {
-    (0, import_node_fs28.rmSync)(tmp, { recursive: true, force: true });
+    (0, import_node_fs29.rmSync)(tmp, { recursive: true, force: true });
   }
 }
 async function importConductorWorkspaceAsync(workspaceId) {
@@ -13558,8 +13668,8 @@ async function importConductorWorkspaceAsync(workspaceId) {
 var import_node_events = require("events");
 
 // src/slack/outbound-watch.ts
-var import_node_fs30 = require("fs");
-var import_node_path26 = require("path");
+var import_node_fs31 = require("fs");
+var import_node_path27 = require("path");
 init_paths();
 init_private_file();
 init_secure_file();
@@ -13605,19 +13715,19 @@ async function slackAuthTest(token) {
 }
 
 // src/slack/reply-target.ts
-var import_node_fs29 = require("fs");
-var import_node_path24 = require("path");
+var import_node_fs30 = require("fs");
+var import_node_path25 = require("path");
 init_paths();
 init_private_file();
 init_secure_file();
 function storePath2() {
-  return (0, import_node_path24.join)(appDataDir(), "slack-reply-to.json");
+  return (0, import_node_path25.join)(appDataDir(), "slack-reply-to.json");
 }
 function readStore2() {
   const path2 = storePath2();
-  if (!(0, import_node_fs29.existsSync)(path2)) return {};
+  if (!(0, import_node_fs30.existsSync)(path2)) return {};
   try {
-    const parsed = isSecureFileEncrypted(path2) ? readSecureJson(path2) : JSON.parse((0, import_node_fs29.readFileSync)(path2, "utf8"));
+    const parsed = isSecureFileEncrypted(path2) ? readSecureJson(path2) : JSON.parse((0, import_node_fs30.readFileSync)(path2, "utf8"));
     return parsed?.targets && typeof parsed.targets === "object" ? parsed.targets : {};
   } catch {
     return {};
@@ -13634,11 +13744,11 @@ function getSlackReplyTarget(threadId) {
 }
 
 // src/slack/workspaces.ts
-var import_node_path25 = require("path");
+var import_node_path26 = require("path");
 init_paths();
 init_secure_file();
 function storePath3() {
-  return (0, import_node_path25.join)(appDataDir(), "slack-workspaces.json");
+  return (0, import_node_path26.join)(appDataDir(), "slack-workspaces.json");
 }
 function readStore3() {
   try {
@@ -13754,7 +13864,7 @@ var POLL_INTERVAL_MS = 12e3;
 var lastPollMs = 0;
 var nameCache = /* @__PURE__ */ new Map();
 function storePath4() {
-  return (0, import_node_path26.join)(appDataDir(), "slack-outbound-watch.json");
+  return (0, import_node_path27.join)(appDataDir(), "slack-outbound-watch.json");
 }
 function watchId(teamId, channelId, ts) {
   return `${teamId}:${channelId}:${ts}`;
@@ -13784,9 +13894,9 @@ function tsNewer(a, b) {
 }
 function readStore4() {
   const path2 = storePath4();
-  if (!(0, import_node_fs30.existsSync)(path2)) return [];
+  if (!(0, import_node_fs31.existsSync)(path2)) return [];
   try {
-    const parsed = isSecureFileEncrypted(path2) ? readSecureJson(path2) : JSON.parse((0, import_node_fs30.readFileSync)(path2, "utf8"));
+    const parsed = isSecureFileEncrypted(path2) ? readSecureJson(path2) : JSON.parse((0, import_node_fs31.readFileSync)(path2, "utf8"));
     return Array.isArray(parsed?.watches) ? parsed.watches : [];
   } catch {
     return [];
@@ -14131,7 +14241,7 @@ async function refreshSlackReplyBadges(opts) {
 }
 
 // src/orchestrator/orchestrator.ts
-var import_node_fs36 = require("fs");
+var import_node_fs37 = require("fs");
 init_error_detail();
 init_agents();
 init_worktree();
@@ -14152,8 +14262,8 @@ function shouldAutoArchiveOnPrMerge(opts) {
 }
 
 // src/git/orphan-cleanup.ts
-var import_node_fs31 = require("fs");
-var import_node_path27 = require("path");
+var import_node_fs32 = require("fs");
+var import_node_path28 = require("path");
 init_worktree();
 init_thread_store();
 init_paths();
@@ -14168,9 +14278,9 @@ async function findOrphanWorktrees(repoPaths) {
     repoPaths?.length ? repoPaths : threads.map((t) => t.repoPath).filter(Boolean)
   );
   const homeRoot = sideboardWorkspacesDir();
-  if ((0, import_node_fs31.existsSync)(homeRoot)) {
+  if ((0, import_node_fs32.existsSync)(homeRoot)) {
     try {
-      for (const entry of (0, import_node_fs31.readdirSync)(homeRoot, { withFileTypes: true })) {
+      for (const entry of (0, import_node_fs32.readdirSync)(homeRoot, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
         void entry;
       }
@@ -14180,7 +14290,7 @@ async function findOrphanWorktrees(repoPaths) {
   const orphans = [];
   const seen = /* @__PURE__ */ new Set();
   for (const repoPath of repos) {
-    if (!repoPath || !(0, import_node_fs31.existsSync)(repoPath)) continue;
+    if (!repoPath || !(0, import_node_fs32.existsSync)(repoPath)) continue;
     try {
       const wts = await listWorktrees(repoPath);
       for (const wt of wts) {
@@ -14191,7 +14301,7 @@ async function findOrphanWorktrees(repoPaths) {
         seen.add(path2);
         let mtimeMs = 0;
         try {
-          mtimeMs = (0, import_node_fs31.statSync)(path2).mtimeMs;
+          mtimeMs = (0, import_node_fs32.statSync)(path2).mtimeMs;
         } catch {
           mtimeMs = 0;
         }
@@ -14201,16 +14311,16 @@ async function findOrphanWorktrees(repoPaths) {
     }
     try {
       const root = worktreesRoot(repoPath);
-      if ((0, import_node_fs31.existsSync)(root)) {
-        for (const entry of (0, import_node_fs31.readdirSync)(root, { withFileTypes: true })) {
+      if ((0, import_node_fs32.existsSync)(root)) {
+        for (const entry of (0, import_node_fs32.readdirSync)(root, { withFileTypes: true })) {
           if (!entry.isDirectory()) continue;
-          const path2 = (0, import_node_path27.join)(root, entry.name).replace(/\/$/, "");
+          const path2 = (0, import_node_path28.join)(root, entry.name).replace(/\/$/, "");
           if (known.has(path2) || seen.has(path2)) continue;
-          if (!(0, import_node_fs31.existsSync)((0, import_node_path27.join)(path2, ".git"))) continue;
+          if (!(0, import_node_fs32.existsSync)((0, import_node_path28.join)(path2, ".git"))) continue;
           seen.add(path2);
           let mtimeMs = 0;
           try {
-            mtimeMs = (0, import_node_fs31.statSync)(path2).mtimeMs;
+            mtimeMs = (0, import_node_fs32.statSync)(path2).mtimeMs;
           } catch {
             mtimeMs = Date.now();
           }
@@ -14356,8 +14466,8 @@ async function applyThreadIntoMain(thread, opts) {
 }
 
 // src/git/clone-repo.ts
-var import_node_fs32 = require("fs");
-var import_node_path28 = require("path");
+var import_node_fs33 = require("fs");
+var import_node_path29 = require("path");
 var import_execa6 = require("execa");
 init_paths();
 init_workspaces();
@@ -14367,12 +14477,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_path28.basename)(url.replace(/\/$/, "").replace(/\.git$/, ""));
+    const leaf = (0, import_node_path29.basename)(url.replace(/\/$/, "").replace(/\.git$/, ""));
     name = leaf || "repo";
   }
   name = name.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "repo";
-  const dest = (0, import_node_path28.join)(sideboardReposDir(), name);
-  if ((0, import_node_fs32.existsSync)(dest)) {
+  const dest = (0, import_node_path29.join)(sideboardReposDir(), name);
+  if ((0, import_node_fs33.existsSync)(dest)) {
     const repoPath2 = await resolveRepoRoot(dest);
     const workspace2 = await ensureWorkspace(repoPath2);
     return { repoPath: repoPath2, workspace: workspace2 };
@@ -14394,8 +14504,8 @@ init_orchestrator_capable();
 
 // src/review/request-review.ts
 var import_node_crypto8 = require("crypto");
-var import_node_fs33 = require("fs");
-var import_node_path29 = require("path");
+var import_node_fs34 = require("fs");
+var import_node_path30 = require("path");
 init_global_workspace();
 init_thread_store();
 
@@ -14543,22 +14653,22 @@ function shouldRefreshReviewRequestTemplate(content) {
   return LEGACY_REVIEW_TEMPLATE_MARKERS.every((m) => trimmed.includes(m));
 }
 function readTextIfPresent(abs) {
-  if (!(0, import_node_fs33.existsSync)(abs)) return null;
+  if (!(0, import_node_fs34.existsSync)(abs)) return null;
   try {
-    const content = (0, import_node_fs33.readFileSync)(abs, "utf8");
+    const content = (0, import_node_fs34.readFileSync)(abs, "utf8");
     return content.trim() ? content : null;
   } catch {
     return null;
   }
 }
 function ensureAttachmentsGitignore(worktreePath) {
-  const gitignoreAbs = (0, import_node_path29.join)(worktreePath, ATTACHMENTS_DIR, ".gitignore");
-  if ((0, import_node_fs33.existsSync)(gitignoreAbs)) return;
-  (0, import_node_fs33.mkdirSync)((0, import_node_path29.dirname)(gitignoreAbs), { recursive: true });
-  (0, import_node_fs33.writeFileSync)(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
+  const gitignoreAbs = (0, import_node_path30.join)(worktreePath, ATTACHMENTS_DIR, ".gitignore");
+  if ((0, import_node_fs34.existsSync)(gitignoreAbs)) return;
+  (0, import_node_fs34.mkdirSync)((0, import_node_path30.dirname)(gitignoreAbs), { recursive: true });
+  (0, import_node_fs34.writeFileSync)(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
 }
 function resolveReviewGuidelines(worktreePath) {
-  const repoAbs = (0, import_node_path29.join)(worktreePath, REPO_REVIEW_PATH);
+  const repoAbs = (0, import_node_path30.join)(worktreePath, REPO_REVIEW_PATH);
   const repoContent = readTextIfPresent(repoAbs);
   if (repoContent) {
     return {
@@ -14568,7 +14678,7 @@ function resolveReviewGuidelines(worktreePath) {
       source: "repo"
     };
   }
-  const localAbs = (0, import_node_path29.join)(worktreePath, REVIEW_REQUEST_PATH);
+  const localAbs = (0, import_node_path30.join)(worktreePath, REVIEW_REQUEST_PATH);
   const localContent = readTextIfPresent(localAbs);
   if (localContent && !shouldRefreshReviewRequestTemplate(localContent)) {
     return {
@@ -14578,7 +14688,7 @@ function resolveReviewGuidelines(worktreePath) {
       source: "local"
     };
   }
-  const legacyAbs = (0, import_node_path29.join)(worktreePath, LEGACY_REVIEW_REQUEST_PATH);
+  const legacyAbs = (0, import_node_path30.join)(worktreePath, LEGACY_REVIEW_REQUEST_PATH);
   const legacyContent = readTextIfPresent(legacyAbs);
   if (legacyContent && !shouldRefreshReviewRequestTemplate(legacyContent)) {
     return {
@@ -14589,8 +14699,8 @@ function resolveReviewGuidelines(worktreePath) {
     };
   }
   ensureAttachmentsGitignore(worktreePath);
-  (0, import_node_fs33.mkdirSync)((0, import_node_path29.dirname)(localAbs), { recursive: true });
-  (0, import_node_fs33.writeFileSync)(localAbs, REVIEW_REQUEST_TEMPLATE, "utf8");
+  (0, import_node_fs34.mkdirSync)((0, import_node_path30.dirname)(localAbs), { recursive: true });
+  (0, import_node_fs34.writeFileSync)(localAbs, REVIEW_REQUEST_TEMPLATE, "utf8");
   return {
     path: REVIEW_REQUEST_PATH,
     name: REVIEW_REQUEST_NAME,
@@ -14599,7 +14709,7 @@ function resolveReviewGuidelines(worktreePath) {
   };
 }
 function ensureReviewRequestFile(worktreePath) {
-  const repoAbs = (0, import_node_path29.join)(worktreePath, REPO_REVIEW_PATH);
+  const repoAbs = (0, import_node_path30.join)(worktreePath, REPO_REVIEW_PATH);
   const repoContent = readTextIfPresent(repoAbs);
   if (repoContent) {
     return {
@@ -14609,10 +14719,10 @@ function ensureReviewRequestFile(worktreePath) {
       source: "repo"
     };
   }
-  const localAbs = (0, import_node_path29.join)(worktreePath, REVIEW_REQUEST_PATH);
-  const localContent = readTextIfPresent(localAbs) ?? readTextIfPresent((0, import_node_path29.join)(worktreePath, LEGACY_REVIEW_REQUEST_PATH));
+  const localAbs = (0, import_node_path30.join)(worktreePath, REVIEW_REQUEST_PATH);
+  const localContent = readTextIfPresent(localAbs) ?? readTextIfPresent((0, import_node_path30.join)(worktreePath, LEGACY_REVIEW_REQUEST_PATH));
   if (localContent && !shouldRefreshReviewRequestTemplate(localContent)) {
-    const path2 = (0, import_node_fs33.existsSync)(localAbs) ? REVIEW_REQUEST_PATH : LEGACY_REVIEW_REQUEST_PATH;
+    const path2 = (0, import_node_fs34.existsSync)(localAbs) ? REVIEW_REQUEST_PATH : LEGACY_REVIEW_REQUEST_PATH;
     return {
       path: path2,
       name: REVIEW_REQUEST_NAME,
@@ -14620,8 +14730,8 @@ function ensureReviewRequestFile(worktreePath) {
       source: "local"
     };
   }
-  (0, import_node_fs33.mkdirSync)((0, import_node_path29.dirname)(repoAbs), { recursive: true });
-  (0, import_node_fs33.writeFileSync)(repoAbs, REVIEW_REQUEST_TEMPLATE, "utf8");
+  (0, import_node_fs34.mkdirSync)((0, import_node_path30.dirname)(repoAbs), { recursive: true });
+  (0, import_node_fs34.writeFileSync)(repoAbs, REVIEW_REQUEST_TEMPLATE, "utf8");
   return {
     path: REPO_REVIEW_PATH,
     name: REPO_REVIEW_NAME,
@@ -14641,7 +14751,7 @@ function buildReviewRequestAttachment(content, opts) {
   };
 }
 function readExistingReviewRequestFile(worktreePath) {
-  return readTextIfPresent((0, import_node_path29.join)(worktreePath, REPO_REVIEW_PATH)) ?? readTextIfPresent((0, import_node_path29.join)(worktreePath, REVIEW_REQUEST_PATH)) ?? readTextIfPresent((0, import_node_path29.join)(worktreePath, LEGACY_REVIEW_REQUEST_PATH));
+  return readTextIfPresent((0, import_node_path30.join)(worktreePath, REPO_REVIEW_PATH)) ?? readTextIfPresent((0, import_node_path30.join)(worktreePath, REVIEW_REQUEST_PATH)) ?? readTextIfPresent((0, import_node_path30.join)(worktreePath, LEGACY_REVIEW_REQUEST_PATH));
 }
 async function requestReview(threadRef, send2) {
   const from = findThreadByRef(threadRef);
@@ -14902,7 +15012,7 @@ var Orchestrator = class {
         }
         continue;
       }
-      if (!(0, import_node_fs36.existsSync)(thread.worktreePath)) {
+      if (!(0, import_node_fs37.existsSync)(thread.worktreePath)) {
         setStatus(thread.id, "broken", "Worktree missing on disk");
         this.emit({ type: "status_changed", threadId: thread.id, status: "broken" });
         continue;
@@ -15077,14 +15187,7 @@ var Orchestrator = class {
     return thread;
   }
   async finishCreateThread(threadId, prompt) {
-    await this.runSetupAfterCreate(threadId);
-    const { autoRunAfterSetupEnabled: autoRunAfterSetupEnabled2 } = await Promise.resolve().then(() => (init_app_settings(), app_settings_exports));
-    if (autoRunAfterSetupEnabled2()) {
-      try {
-        await this.startDev(threadId);
-      } catch {
-      }
-    }
+    const setup = this.runSetupAfterCreate(threadId);
     if (prompt) {
       try {
         await this.send(threadId, prompt);
@@ -15095,6 +15198,14 @@ var Orchestrator = class {
         });
       }
     }
+    await setup;
+    const { autoRunAfterSetupEnabled: autoRunAfterSetupEnabled2 } = await Promise.resolve().then(() => (init_app_settings(), app_settings_exports));
+    if (autoRunAfterSetupEnabled2()) {
+      try {
+        await this.startDev(threadId);
+      } catch {
+      }
+    }
   }
   /** Run workspace setup after a new worktree is created (no-op if none configured). */
   async runSetupAfterCreate(threadId) {
@@ -15792,7 +15903,7 @@ var Orchestrator = class {
     });
     this.emit({ type: "setup_started", threadId: thread.id });
     try {
-      let setup = await runSetupScript(
+      const setup = await runWorkspaceSetup(
         thread.repoPath,
         thread.worktreePath,
         (line) => {
@@ -15800,18 +15911,9 @@ var Orchestrator = class {
         },
         { signal: abort.signal }
       );
-      if (!setup.ran) {
-        setup = await runCursorWorktreeSetup(
-          thread.repoPath,
-          thread.worktreePath,
-          (line) => {
-            this.emit({ type: "setup_output", threadId: thread.id, line });
-          }
-        );
-      }
       if (!setup.ran) {
         throw new Error(
-          "No setup script in .sideboard/settings.toml, .conductor/settings.toml, or .cursor/worktrees.json"
+          "No setup script in .sideboard/settings.toml, .conductor/settings.toml, .cursor/worktrees.json, or script/setup (bin/setup, scripts/setup)"
         );
       }
       if (setup.exitCode !== 0 && setup.exitCode !== null) {
@@ -16119,7 +16221,7 @@ var Orchestrator = class {
       this.emit({ type: "status_changed", threadId: t.id, status: t.status });
     }
     for (const id of result.createdThreadIds) {
-      await this.runSetupAfterCreate(id);
+      void this.runSetupAfterCreate(id);
     }
     return { stack: result.stack, threads: result.threads };
   }
@@ -16136,7 +16238,7 @@ var Orchestrator = class {
       status: result.thread.status
     });
     if (result.createdWorktree) {
-      await this.runSetupAfterCreate(result.thread.id);
+      void this.runSetupAfterCreate(result.thread.id);
     }
     return { stack: result.stack, thread: result.thread };
   }
@@ -16151,7 +16253,7 @@ var Orchestrator = class {
       this.emit({ type: "status_changed", threadId: t.id, status: t.status });
     }
     for (const id of result.createdThreadIds) {
-      await this.runSetupAfterCreate(id);
+      void this.runSetupAfterCreate(id);
     }
     return { stack: result.stack, threads: result.threads };
   }
@@ -16162,7 +16264,7 @@ var Orchestrator = class {
       this.emit({ type: "status_changed", threadId: t.id, status: t.status });
     }
     for (const id of result.createdThreadIds) {
-      await this.runSetupAfterCreate(id);
+      void this.runSetupAfterCreate(id);
     }
     return { stack: result.stack, threads: result.threads };
   }
@@ -16293,7 +16395,7 @@ var Orchestrator = class {
   async forkThreadWorktree(input) {
     const thread = await forkThreadWorktree(input);
     this.emit({ type: "status_changed", threadId: thread.id, status: thread.status });
-    await this.runSetupAfterCreate(thread.id);
+    void this.runSetupAfterCreate(thread.id);
     return thread;
   }
   renameThread(threadRef, title) {
@@ -16396,7 +16498,7 @@ var Orchestrator = class {
       this.emit({ type: "status_changed", threadId: restored2.id, status: restored2.status });
       return restored2;
     }
-    if (!(0, import_node_fs36.existsSync)(thread.worktreePath)) {
+    if (!(0, import_node_fs37.existsSync)(thread.worktreePath)) {
       const { createThreadWorktree: createThreadWorktree2 } = await Promise.resolve().then(() => (init_worktree(), worktree_exports));
       const { execa: execa7 } = await import("execa");
       const slug = thread.worktreePath.split("/").pop();
@@ -16501,7 +16603,7 @@ async function startOrchestration(opts) {
     planMode: opts.planMode,
     attachments: opts.attachments
   };
-  const thread = await createThread({
+  const thread = await orch.createThread({
     sourceType: "branch",
     sourceRef: "default",
     ...createOpts
@@ -16509,7 +16611,7 @@ async function startOrchestration(opts) {
     const { resolveDefaultBranch: resolveDefaultBranch2, resolveRepoRoot: resolveRepoRoot2 } = await Promise.resolve().then(() => (init_worktree(), worktree_exports));
     const repo = await resolveRepoRoot2(repoPath);
     const def = await resolveDefaultBranch2(repo);
-    return createThread({
+    return orch.createThread({
       sourceType: "branch",
       sourceRef: def,
       ...createOpts,
@@ -16637,7 +16739,7 @@ init_coordinator_prompt();
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 var import_zod3 = require("zod");
-var import_node_path32 = require("path");
+var import_node_path33 = require("path");
 init_worktree();
 init_global_workspace();
 init_list_models();
@@ -17315,7 +17417,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_path32.basename)(t.repoPath) || t.repoPath;
+        const repo = t.repoPath === GLOBAL_WORKSPACE_ID ? "Orchestration" : (0, import_node_path33.basename)(t.repoPath) || t.repoPath;
         return `${t.id.slice(0, 8)}  ${t.status.padEnd(9)}  ${t.agent.padEnd(8)}  ${repo}  ${t.sourceType}:${t.sourceRef}  ${t.title}  sideboard://thread/${t.id}${t.devPort ? `  http://localhost:${t.devPort}` : ""}`;
       });
       return {
@@ -17526,7 +17628,7 @@ async function startMcpServer() {
     );
     server.tool(
       "create_thread",
-      `Create a new worktree thread (chat) from branch, pr, or ticket. Pass repoPath from list_workspaces. From an orchestration chat, omit parentThreadId (Sideboard binds the child to this chat) or pass the exact id from the turn reminder \u2014 never invent a uuid. Prefer omitting agent/model so Sideboard applies ${accountDefaultsHint}. Then use send_to_thread to chat.`,
+      `Create a new worktree thread (chat) from branch, pr, or ticket. Pass repoPath from list_workspaces. From an orchestration chat, omit parentThreadId (Sideboard binds the child to this chat) or pass the exact id from the turn reminder \u2014 never invent a uuid. Prefer omitting agent/model so Sideboard applies ${accountDefaultsHint}. Setup (settings.toml, .cursor/worktrees.json, or script/setup) runs in the background in parallel with the first turn. Then use send_to_thread to chat.`,
       {
         sourceType: import_zod3.z.enum(["branch", "pr", "ticket"]),
         sourceRef: import_zod3.z.string(),
@@ -18044,7 +18146,7 @@ async function startMcpServer() {
     );
     server.tool(
       "run_setup",
-      "Re-run workspace setup (Sideboard/Conductor settings or .cursor/worktrees.json)",
+      "Re-run workspace setup (Sideboard/Conductor settings, .cursor/worktrees.json, or script/setup). New worktrees already run this automatically.",
       { ref: import_zod3.z.string() },
       async ({ ref }) => {
         const result = await orch.runSetup(ref);
@@ -19929,9 +20031,9 @@ var import_node_http3 = require("http");
 var import_ws3 = require("ws");
 
 // src/slack/relay-static.ts
-var import_node_fs37 = require("fs");
+var import_node_fs38 = require("fs");
 var import_promises = require("fs/promises");
-var import_node_path33 = __toESM(require("path"), 1);
+var import_node_path34 = __toESM(require("path"), 1);
 var TYPES = {
   ".css": "text/css; charset=utf-8",
   ".html": "text/html; charset=utf-8",
@@ -19962,9 +20064,9 @@ function resolveStaticPath(root, requestUrl) {
     return null;
   }
   if (!pathname.startsWith("/") || pathname.includes("\0")) return null;
-  const rootResolved = import_node_path33.default.resolve(root);
-  const candidate = import_node_path33.default.resolve(rootResolved, `.${pathname}`);
-  if (candidate !== rootResolved && !candidate.startsWith(rootResolved + import_node_path33.default.sep)) {
+  const rootResolved = import_node_path34.default.resolve(root);
+  const candidate = import_node_path34.default.resolve(rootResolved, `.${pathname}`);
+  if (candidate !== rootResolved && !candidate.startsWith(rootResolved + import_node_path34.default.sep)) {
     return null;
   }
   return candidate;
@@ -19978,7 +20080,7 @@ async function fileSize(file) {
   }
 }
 function sendFile(req, res, file, size) {
-  const ext = import_node_path33.default.extname(file).toLowerCase();
+  const ext = import_node_path34.default.extname(file).toLowerCase();
   res.writeHead(200, {
     "Content-Type": TYPES[ext] ?? "application/octet-stream",
     "Content-Length": size,
@@ -19988,7 +20090,7 @@ function sendFile(req, res, file, size) {
     res.end();
     return true;
   }
-  (0, import_node_fs37.createReadStream)(file).pipe(res);
+  (0, import_node_fs38.createReadStream)(file).pipe(res);
   return true;
 }
 async function tryServeStatic(req, res, root) {
@@ -19997,7 +20099,7 @@ async function tryServeStatic(req, res, root) {
   if (!candidate) return false;
   const direct = await fileSize(candidate);
   if (direct != null) return sendFile(req, res, candidate, direct);
-  const asIndex = import_node_path33.default.join(candidate, "index.html");
+  const asIndex = import_node_path34.default.join(candidate, "index.html");
   const indexSize = await fileSize(asIndex);
   if (indexSize != null) return sendFile(req, res, asIndex, indexSize);
   return false;
@@ -20229,6 +20331,7 @@ async function startSlackRelayServer(opts) {
   CONTEXT_KEEP_RECENT_CHARS,
   CONTEXT_KEEP_RECENT_MESSAGES,
   CONTEXT_MIN_MESSAGES,
+  CONVENTION_SETUP_RELPATHS,
   COORDINATOR_TOOL_PLAYBOOK,
   FAMOUS_SOCCER_TEAMS,
   GITHUB_GIT_AUTH_MODES,
@@ -20390,6 +20493,7 @@ async function startSlackRelayServer(opts) {
   extractiveSummary,
   fetchPrHead,
   finalizeParts,
+  findConventionSetup,
   findInvalidCacheControlTtlOrder,
   findOrphanWorktrees,
   findThreadByRef,
@@ -20461,6 +20565,7 @@ async function startSlackRelayServer(opts) {
   hasBakedLinearOAuth,
   hasBakedSlackOAuth,
   hasConductorHook,
+  hasConventionSetup,
   hasCursorWorktreeSetup,
   hasRepoHook,
   hasWorkspaceHook,
@@ -20636,10 +20741,12 @@ async function startSlackRelayServer(opts) {
   run,
   runArchiveScript,
   runCloudConnect,
+  runConventionSetup,
   runCursorWorktreeSetup,
   runSetupScript,
   runSlackListen,
   runSlackRelayClient,
+  runWorkspaceSetup,
   sameWorktreePath,
   sanitizeMcpServerName,
   saveAppSettings,