@sideboard-ai/core 0.1.67 → 0.1.71

package/dist/mcp/run-stdio.cjs

@@ -92,13 +92,13 @@ function summarizeTurnStderr(tail, maxChars = 500) {
   if (joined.length <= maxChars) return joined;
   return joined.slice(joined.length - maxChars);
 }
-function looksLikeInvalidAgentSession(text) {
-  const lower = text.trim().toLowerCase();
+function looksLikeInvalidAgentSession(text2) {
+  const lower = text2.trim().toLowerCase();
   if (!lower) return false;
   return /session not found/.test(lower) || /no conversation found/.test(lower) || /conversation .+ not found/.test(lower) || /thread .+ not found/.test(lower) || /unknown session/.test(lower) || /invalid session/.test(lower) || /session .+ (missing|expired|deleted|gone)/.test(lower) || /cannot resume/.test(lower) || /failed to (load|resume|open) session/.test(lower);
 }
-function looksLikeAgentFailureMessage(text) {
-  const lower = text.trim().toLowerCase();
+function looksLikeAgentFailureMessage(text2) {
+  const lower = text2.trim().toLowerCase();
   if (!lower) return false;
   return /you've hit your|hit your (session|weekly|opus) limit|usage limit/.test(lower) || /credit balance is too low|out of credits|insufficient.?quota|quota.?exceeded/.test(lower) || /invalid user api key|invalid api key|not logged in|not authenticated|unauthorized/.test(
     lower
@@ -1451,8 +1451,8 @@ var init_worktree_labels = __esm({
 });
 
 // src/git/gh-errors.ts
-function isGhRateLimitError(text) {
-  return /API rate limit (already )?exceeded/i.test(text) || /rate limit exceeded/i.test(text);
+function isGhRateLimitError(text2) {
+  return /API rate limit (already )?exceeded/i.test(text2) || /rate limit exceeded/i.test(text2);
 }
 function formatRateLimitResetHint(resetEpochSec, nowMs = Date.now()) {
   const ms = resetEpochSec * 1e3 - nowMs;
@@ -1464,8 +1464,8 @@ function formatRateLimitResetHint(resetEpochSec, nowMs = Date.now()) {
   const hours = Math.ceil(mins / 60);
   return `in about ${hours} hour${hours === 1 ? "" : "s"}`;
 }
-function extractGhErrorDetail(text) {
-  const trimmed = text.trim();
+function extractGhErrorDetail(text2) {
+  const trimmed = text2.trim();
   if (!trimmed) return "";
   const graphql = trimmed.match(/\bGraphQL:\s*(.+)$/im);
   if (graphql?.[1]) return `GraphQL: ${graphql[1].trim()}`;
@@ -1649,7 +1649,7 @@ async function git(args, cwd, opts) {
       prefix.push("-c", `${key}=${value}`);
     }
   }
-  return run("git", [...prefix, ...args], {
+  return run("git", ["--no-pager", ...prefix, ...args], {
     cwd,
     reject: opts?.reject,
     timeoutMs: opts?.timeoutMs,
@@ -1685,6 +1685,10 @@ var init_run = __esm({
 });
 
 // src/git/pr-gates.ts
+function prIsInMergeQueue(gate) {
+  if (gate.isInMergeQueue) return true;
+  return (gate.mergeStateStatus ?? "").toUpperCase() === "QUEUED";
+}
 function buildMergeGateChecks(gate, opts = {}) {
   const rows = [];
   const base = gate.baseRefName?.trim() || "the base branch";
@@ -1694,7 +1698,8 @@ function buildMergeGateChecks(gate, opts = {}) {
   const review = (gate.reviewDecision ?? "").toUpperCase();
   const suppressBlocked = opts.suppressGenericBlocked !== false;
   const conflicting = mergeable === "CONFLICTING" || mergeState === "DIRTY";
-  if (conflicting) {
+  const inQueue = prIsInMergeQueue(gate);
+  if (conflicting && !inQueue) {
     rows.push({
       name: "Merge conflicts",
       state: mergeable === "CONFLICTING" ? "CONFLICTING" : mergeState || "DIRTY",
@@ -1706,6 +1711,18 @@ function buildMergeGateChecks(gate, opts = {}) {
       workflow: "mergeability",
       kind: "mergeability"
     });
+  } else if (inQueue) {
+    rows.push({
+      name: "Merge queue",
+      state: "QUEUED",
+      bucket: "pending",
+      startedAt: null,
+      completedAt: null,
+      link,
+      description: `This pull request is in the GitHub merge queue for ${base}.`,
+      workflow: "mergeability",
+      kind: "mergeability"
+    });
   } else if (mergeState === "BEHIND") {
     rows.push({
       name: "Branch behind",
@@ -2124,7 +2141,7 @@ async function originGhRepoEnv(cwd) {
   const slug = await resolveGithubRepoSlug(cwd);
   return slug ? { GH_REPO: slug } : {};
 }
-async function resolveDefaultBranch(repoPath) {
+async function resolveDefaultBranch(repoPath, opts) {
   const viaOrigin = await git(
     ["symbolic-ref", "refs/remotes/origin/HEAD"],
     repoPath,
@@ -2133,22 +2150,24 @@ async function resolveDefaultBranch(repoPath) {
   if (viaOrigin.exitCode === 0 && viaOrigin.stdout.trim()) {
     return viaOrigin.stdout.trim().replace(/^refs\/remotes\/origin\//, "");
   }
-  const slug = await resolveGithubRepoSlug(repoPath);
-  const viaGh = await gh(
-    [
-      "repo",
-      "view",
-      ...slug ? ["--repo", slug] : [],
-      "--json",
-      "defaultBranchRef",
-      "--jq",
-      ".defaultBranchRef.name"
-    ],
-    repoPath,
-    { reject: false }
-  );
-  if (viaGh.exitCode === 0 && viaGh.stdout.trim()) {
-    return viaGh.stdout.trim();
+  if (opts?.network !== false) {
+    const slug = await resolveGithubRepoSlug(repoPath);
+    const viaGh = await gh(
+      [
+        "repo",
+        "view",
+        ...slug ? ["--repo", slug] : [],
+        "--json",
+        "defaultBranchRef",
+        "--jq",
+        ".defaultBranchRef.name"
+      ],
+      repoPath,
+      { reject: false, timeoutMs: 8e3 }
+    );
+    if (viaGh.exitCode === 0 && viaGh.stdout.trim()) {
+      return viaGh.stdout.trim();
+    }
   }
   for (const candidate of ["main", "master"]) {
     const check = await git(
@@ -2289,10 +2308,21 @@ async function fetchPrMergeGate(cwd, selector, slug) {
     "view",
     selector,
     "--json",
-    "mergeable,mergeStateStatus,reviewDecision,baseRefName,url"
+    "mergeable,mergeStateStatus,reviewDecision,baseRefName,url,isInMergeQueue"
   ];
   if (slug) args.push("--repo", slug);
-  const { stdout, exitCode, stderr } = await gh(args, cwd, { reject: false });
+  let { stdout, exitCode, stderr } = await gh(args, cwd, { reject: false });
+  if (exitCode !== 0 && isUnknownJsonField(stderr, "isInMergeQueue")) {
+    const retry = [
+      "pr",
+      "view",
+      selector,
+      "--json",
+      "mergeable,mergeStateStatus,reviewDecision,baseRefName,url"
+    ];
+    if (slug) retry.push("--repo", slug);
+    ({ stdout, exitCode, stderr } = await gh(retry, cwd, { reject: false }));
+  }
   if (exitCode !== 0 || !stdout.trim()) {
     if (/no pull requests found/i.test(stderr)) return null;
     return null;
@@ -2304,12 +2334,22 @@ async function fetchPrMergeGate(cwd, selector, slug) {
       mergeStateStatus: typeof view.mergeStateStatus === "string" && view.mergeStateStatus ? view.mergeStateStatus : null,
       reviewDecision: typeof view.reviewDecision === "string" && view.reviewDecision ? view.reviewDecision : null,
       baseRefName: typeof view.baseRefName === "string" && view.baseRefName ? view.baseRefName : null,
-      url: typeof view.url === "string" && view.url ? view.url : null
+      url: typeof view.url === "string" && view.url ? view.url : null,
+      isInMergeQueue: parseInMergeQueue(view)
     };
   } catch {
     return null;
   }
 }
+function isUnknownJsonField(stderr, field) {
+  return new RegExp(`unknown json field[^\\n]*${field}`, "i").test(stderr);
+}
+function parseInMergeQueue(view) {
+  return prIsInMergeQueue({
+    isInMergeQueue: view.isInMergeQueue === true,
+    mergeStateStatus: typeof view.mergeStateStatus === "string" ? view.mergeStateStatus : null
+  });
+}
 async function detectLocalMergeConflicts(cwd, baseRefName) {
   const baseName = (baseRefName?.trim() || await resolveDefaultBranch(cwd)).replace(
     /^origin\//,
@@ -2370,7 +2410,8 @@ async function getPrChecks(cwd, selector) {
   const mergeable = (gate?.mergeable ?? "").toUpperCase();
   const mergeState = (gate?.mergeStateStatus ?? "").toUpperCase();
   const alreadyConflicting = mergeable === "CONFLICTING" || mergeState === "DIRTY";
-  const needsLocalProbe = !alreadyConflicting;
+  const inQueue = gate ? prIsInMergeQueue(gate) : false;
+  const needsLocalProbe = !alreadyConflicting && !inQueue;
   if (needsLocalProbe) {
     try {
       const local = await detectLocalMergeConflicts(cwd, gate?.baseRefName ?? null);
@@ -2381,7 +2422,8 @@ async function getPrChecks(cwd, selector) {
           mergeStateStatus: "DIRTY",
           reviewDecision: gate?.reviewDecision ?? null,
           baseRefName: local.base,
-          url: gate?.url ?? null
+          url: gate?.url ?? null,
+          isInMergeQueue: false
         };
         const ciFailed2 = ciChecks.some((c) => c.bucket === "fail");
         const review2 = (gate.reviewDecision ?? "").toUpperCase();
@@ -2425,10 +2467,21 @@ async function getPrMeta(cwd, selector) {
     "view",
     selector,
     "--json",
-    "number,title,url,state,isDraft,reviewDecision,baseRefName,headRefName"
+    "number,title,url,state,isDraft,reviewDecision,baseRefName,headRefName,isInMergeQueue,mergeStateStatus"
   ];
   if (slug) viewArgs.push("--repo", slug);
-  const { stdout, exitCode, stderr } = await gh(viewArgs, cwd, { reject: false });
+  let { stdout, exitCode, stderr } = await gh(viewArgs, cwd, { reject: false });
+  if (exitCode !== 0 && isUnknownJsonField(stderr, "isInMergeQueue")) {
+    const retry = [
+      "pr",
+      "view",
+      selector,
+      "--json",
+      "number,title,url,state,isDraft,reviewDecision,baseRefName,headRefName,mergeStateStatus"
+    ];
+    if (slug) retry.push("--repo", slug);
+    ({ stdout, exitCode, stderr } = await gh(retry, cwd, { reject: false }));
+  }
   if (exitCode !== 0 || !stdout.trim()) {
     if (/no pull requests found/i.test(stderr)) return null;
     return null;
@@ -2443,7 +2496,8 @@ async function getPrMeta(cwd, selector) {
       isDraft: Boolean(view.isDraft),
       reviewDecision: typeof view.reviewDecision === "string" && view.reviewDecision ? view.reviewDecision : null,
       baseRefName: String(view.baseRefName ?? ""),
-      headRefName: String(view.headRefName ?? "")
+      headRefName: String(view.headRefName ?? ""),
+      isInMergeQueue: parseInMergeQueue(view)
     };
   } catch {
     return null;
@@ -2800,11 +2854,11 @@ async function listWorktrees(repoPath) {
   return entries;
 }
 async function isDirty(worktreePath) {
-  const { stdout } = await git(["status", "--porcelain", "-uall"], worktreePath);
+  const { stdout } = await git(["status", "--porcelain"], worktreePath);
   for (const line of stdout.split("\n")) {
     if (!line.trim()) continue;
     const rel = porcelainStatusPath(line);
-    if (!rel || isSideboardScratchPath(rel)) continue;
+    if (!rel || isSideboardScratchPath(rel) || rel === ".sideboard") continue;
     return true;
   }
   return false;
@@ -3048,6 +3102,208 @@ var init_worktree = __esm({
   }
 });
 
+// src/store/private-file.ts
+function writePrivateFile(path, contents) {
+  (0, import_node_fs6.mkdirSync)((0, import_node_path6.dirname)(path), { recursive: true });
+  (0, import_node_fs6.writeFileSync)(path, contents, { encoding: "utf8", mode: PRIVATE_FILE_MODE });
+  chmodOwnerOnly(path);
+}
+function chmodOwnerOnly(path) {
+  try {
+    (0, import_node_fs6.chmodSync)(path, PRIVATE_FILE_MODE);
+  } catch {
+  }
+}
+var import_node_fs6, import_node_path6, PRIVATE_FILE_MODE;
+var init_private_file = __esm({
+  "src/store/private-file.ts"() {
+    "use strict";
+    import_node_fs6 = require("fs");
+    import_node_path6 = require("path");
+    PRIVATE_FILE_MODE = 384;
+  }
+});
+
+// src/store/secure-file.ts
+function persistVaultKeyInKeychain(key) {
+  if (process.platform !== "darwin" || key.length !== 32) return;
+  try {
+    (0, import_node_child_process2.execFileSync)(
+      "security",
+      [
+        "add-generic-password",
+        "-s",
+        KEYCHAIN_SERVICE,
+        "-a",
+        KEYCHAIN_ACCOUNT,
+        "-w",
+        key.toString("hex"),
+        "-U"
+      ],
+      { encoding: "utf8", timeout: 8e3, stdio: ["ignore", "pipe", "pipe"] }
+    );
+  } catch {
+  }
+}
+function hexKey(value) {
+  const trimmed = value?.trim() ?? "";
+  if (!/^[0-9a-f]{64}$/i.test(trimmed)) return null;
+  return Buffer.from(trimmed, "hex");
+}
+function keychainKey(create) {
+  if (process.platform !== "darwin") return null;
+  try {
+    const out = (0, import_node_child_process2.execFileSync)(
+      "security",
+      ["find-generic-password", "-s", KEYCHAIN_SERVICE, "-a", KEYCHAIN_ACCOUNT, "-w"],
+      { encoding: "utf8", timeout: 5e3, stdio: ["ignore", "pipe", "pipe"] }
+    ).trim();
+    const key2 = hexKey(out);
+    if (key2) return key2;
+  } catch {
+  }
+  if (!create) return null;
+  const key = (0, import_node_crypto2.randomBytes)(32);
+  persistVaultKeyInKeychain(key);
+  return key;
+}
+function resolveVaultKey() {
+  if (process.env.SIDEBOARD_SECRET_VAULT === "plain") return null;
+  if (injectedKey) return injectedKey;
+  const fromEnv = hexKey(process.env.SIDEBOARD_VAULT_KEY);
+  if (fromEnv) return fromEnv;
+  if (process.env.VITEST) return null;
+  return keychainKey(true);
+}
+function isEnvelope(value) {
+  if (!value || typeof value !== "object") return false;
+  const o = value;
+  return o.v === 1 && o.alg === ALG && typeof o.iv === "string" && typeof o.tag === "string" && typeof o.data === "string";
+}
+function encryptJson(value, key) {
+  const iv = (0, import_node_crypto2.randomBytes)(12);
+  const cipher = (0, import_node_crypto2.createCipheriv)(ALG, key, iv);
+  const plaintext = Buffer.from(`${JSON.stringify(value)}
+`, "utf8");
+  const data = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return {
+    v: 1,
+    alg: ALG,
+    iv: iv.toString("base64"),
+    tag: tag.toString("base64"),
+    data: data.toString("base64")
+  };
+}
+function decryptEnvelope(envelope, key) {
+  const decipher = (0, import_node_crypto2.createDecipheriv)(ALG, key, Buffer.from(envelope.iv, "base64"));
+  decipher.setAuthTag(Buffer.from(envelope.tag, "base64"));
+  const plaintext = Buffer.concat([
+    decipher.update(Buffer.from(envelope.data, "base64")),
+    decipher.final()
+  ]);
+  return JSON.parse(plaintext.toString("utf8"));
+}
+function readSecureJson(path) {
+  if (!(0, import_node_fs7.existsSync)(path)) return null;
+  chmodOwnerOnly(path);
+  let parsed;
+  try {
+    parsed = JSON.parse((0, import_node_fs7.readFileSync)(path, "utf8"));
+  } catch {
+    return null;
+  }
+  if (!isEnvelope(parsed)) return parsed;
+  const key = resolveVaultKey();
+  if (!key) {
+    throw new Error(
+      "Encrypted Sideboard secrets need a vault key (desktop Keychain / safeStorage, or SIDEBOARD_VAULT_KEY)."
+    );
+  }
+  return decryptEnvelope(parsed, key);
+}
+function writeSecureJson(path, value) {
+  const key = resolveVaultKey();
+  const body = key ? encryptJson(value, key) : value;
+  writePrivateFile(path, `${JSON.stringify(body, null, 2)}
+`);
+}
+function isSecureFileEncrypted(path) {
+  if (!(0, import_node_fs7.existsSync)(path)) return false;
+  try {
+    return isEnvelope(JSON.parse((0, import_node_fs7.readFileSync)(path, "utf8")));
+  } catch {
+    return false;
+  }
+}
+var import_node_child_process2, import_node_crypto2, import_node_fs7, KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT, ALG, injectedKey;
+var init_secure_file = __esm({
+  "src/store/secure-file.ts"() {
+    "use strict";
+    import_node_child_process2 = require("child_process");
+    import_node_crypto2 = require("crypto");
+    import_node_fs7 = require("fs");
+    init_private_file();
+    KEYCHAIN_SERVICE = "ai.sideboard.app";
+    KEYCHAIN_ACCOUNT = "secret-vault-v1";
+    ALG = "aes-256-gcm";
+    injectedKey = null;
+  }
+});
+
+// src/store/secret-vault.ts
+function secretVaultPath() {
+  return (0, import_node_path7.join)(appDataDir(), "secrets.json");
+}
+function loadSecretVault() {
+  const parsed = readSecureJson(secretVaultPath());
+  if (!parsed || typeof parsed !== "object") return {};
+  return normalizeVault(parsed);
+}
+function saveSecretVault(vault) {
+  writeSecureJson(secretVaultPath(), normalizeVault(vault));
+}
+function normalizeVault(raw) {
+  const out = {};
+  if (typeof raw.linearApiKey === "string" && raw.linearApiKey.trim()) {
+    out.linearApiKey = raw.linearApiKey.trim();
+  }
+  if (typeof raw.linearAccessToken === "string" && raw.linearAccessToken.trim()) {
+    out.linearAccessToken = raw.linearAccessToken.trim();
+  }
+  if (typeof raw.linearRefreshToken === "string" && raw.linearRefreshToken.trim()) {
+    out.linearRefreshToken = raw.linearRefreshToken.trim();
+  }
+  if (typeof raw.linearClientSecret === "string" && raw.linearClientSecret.trim()) {
+    out.linearClientSecret = raw.linearClientSecret.trim();
+  }
+  if (typeof raw.slackClientSecret === "string" && raw.slackClientSecret.trim()) {
+    out.slackClientSecret = raw.slackClientSecret.trim();
+  }
+  if (typeof raw.slackAppToken === "string" && raw.slackAppToken.trim()) {
+    out.slackAppToken = raw.slackAppToken.trim();
+  }
+  if (raw.environment && typeof raw.environment === "object") {
+    const environment = {};
+    for (const [key, value] of Object.entries(raw.environment)) {
+      const k = key.trim();
+      const v = typeof value === "string" ? value.trim() : "";
+      if (k && v) environment[k] = v;
+    }
+    if (Object.keys(environment).length > 0) out.environment = environment;
+  }
+  return out;
+}
+var import_node_path7;
+var init_secret_vault = __esm({
+  "src/store/secret-vault.ts"() {
+    "use strict";
+    import_node_path7 = require("path");
+    init_paths();
+    init_secure_file();
+  }
+});
+
 // src/store/app-settings.ts
 var app_settings_exports = {};
 __export(app_settings_exports, {
@@ -3063,10 +3319,13 @@ __export(app_settings_exports, {
   brightsyInjectWorktreeMcpEnabled: () => brightsyInjectWorktreeMcpEnabled,
   caffeinateWhileCloudConnectEnabled: () => caffeinateWhileCloudConnectEnabled,
   caffeinateWhileRunningEnabled: () => caffeinateWhileRunningEnabled,
+  caffeinateWhileSlackListenEnabled: () => caffeinateWhileSlackListenEnabled,
   childEnvWithAppSettings: () => childEnvWithAppSettings,
   claudeChromeEnabled: () => claudeChromeEnabled,
   claudeUserSettingsPath: () => claudeUserSettingsPath,
   deleteBranchOnPurgeEnabled: () => deleteBranchOnPurgeEnabled,
+  disconnectLinearConnection: () => disconnectLinearConnection,
+  ensureSlackDeviceIdentity: () => ensureSlackDeviceIdentity,
   getDefaultAgent: () => getDefaultAgent,
   getDefaultEffort: () => getDefaultEffort,
   getDefaultFast: () => getDefaultFast,
@@ -3085,6 +3344,10 @@ __export(app_settings_exports, {
   resolveNewThreadOptions: () => resolveNewThreadOptions,
   resolveThreadDefaults: () => resolveThreadDefaults,
   saveAppSettings: () => saveAppSettings,
+  saveLinearOAuth: () => saveLinearOAuth,
+  slackAppLevelToken: () => slackAppLevelToken,
+  slackListenEnabled: () => slackListenEnabled,
+  toPublicAppSettings: () => toPublicAppSettings,
   updateAdvancedSettings: () => updateAdvancedSettings,
   updateAgentExecutable: () => updateAgentExecutable,
   updateAppEnvironment: () => updateAppEnvironment,
@@ -3095,11 +3358,45 @@ __export(app_settings_exports, {
   updateIntegrationsSettings: () => updateIntegrationsSettings,
   updateOpencodeSettings: () => updateOpencodeSettings
 });
+function hasLinearOAuth(integrations) {
+  return Boolean(
+    integrations.linearAccessToken?.trim() || integrations.linearRefreshToken?.trim()
+  );
+}
+function hasLinearCredentials(integrations) {
+  return Boolean(integrations.linearApiKey?.trim()) || hasLinearOAuth(integrations);
+}
+function toPublicAppSettings(settings) {
+  const environment = {};
+  for (const key of Object.keys(settings.environment)) {
+    if (key.trim()) environment[key] = "";
+  }
+  const integrations = { ...settings.integrations };
+  const slackClientSecret = integrations.slackClientSecret;
+  const slackAppToken = integrations.slackAppToken;
+  delete integrations.linearApiKey;
+  delete integrations.linearAccessToken;
+  delete integrations.linearRefreshToken;
+  delete integrations.linearClientSecret;
+  delete integrations.slackClientSecret;
+  delete integrations.slackAppToken;
+  return {
+    ...settings,
+    environment,
+    integrations: {
+      ...integrations,
+      hasLinearApiKey: hasLinearCredentials(settings.integrations),
+      hasLinearOAuth: hasLinearOAuth(settings.integrations),
+      hasSlackClientSecret: Boolean(slackClientSecret?.trim()),
+      hasSlackAppToken: Boolean(slackAppToken?.trim())
+    }
+  };
+}
 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_os4.homedir)(), ".claude", "settings.json");
+  return (0, import_node_path8.join)((0, import_node_os4.homedir)(), ".claude", "settings.json");
 }
 function normalizeClaude(raw) {
   if (!raw || typeof raw !== "object") return {};
@@ -3151,9 +3448,62 @@ function normalizeIntegrations(raw) {
     const key = source.linearApiKey.trim();
     if (key) out.linearApiKey = key;
   }
+  if (typeof source.linearAccessToken === "string") {
+    const token = source.linearAccessToken.trim();
+    if (token) out.linearAccessToken = token;
+  }
+  if (typeof source.linearRefreshToken === "string") {
+    const token = source.linearRefreshToken.trim();
+    if (token) out.linearRefreshToken = token;
+  }
+  if (typeof source.linearTokenExpiresAt === "number" && Number.isFinite(source.linearTokenExpiresAt)) {
+    out.linearTokenExpiresAt = source.linearTokenExpiresAt;
+  } else if (typeof source.linearTokenExpiresAt === "string") {
+    const n = Number(source.linearTokenExpiresAt);
+    if (Number.isFinite(n)) out.linearTokenExpiresAt = n;
+  }
+  if (typeof source.linearClientId === "string") {
+    const id = source.linearClientId.trim();
+    if (id) out.linearClientId = id;
+  }
+  if (typeof source.linearClientSecret === "string") {
+    const secret = source.linearClientSecret.trim();
+    if (secret) out.linearClientSecret = secret;
+  }
+  if (typeof source.linearViewerName === "string") {
+    const name = source.linearViewerName.trim().slice(0, 120);
+    if (name) out.linearViewerName = name;
+  }
+  if (typeof source.linearOrganizationName === "string") {
+    const name = source.linearOrganizationName.trim().slice(0, 120);
+    if (name) out.linearOrganizationName = name;
+  }
   if (typeof source.issueSource === "string" && ISSUE_SOURCES.has(source.issueSource)) {
     out.issueSource = source.issueSource;
   }
+  if (typeof source.slackClientId === "string") {
+    const id = source.slackClientId.trim();
+    if (id) out.slackClientId = id;
+  }
+  if (typeof source.slackClientSecret === "string") {
+    const secret = source.slackClientSecret.trim();
+    if (secret) out.slackClientSecret = secret;
+  }
+  if (typeof source.slackAppToken === "string") {
+    const token = source.slackAppToken.trim();
+    if (token) out.slackAppToken = token;
+  }
+  if (typeof source.slackListenEnabled === "boolean") {
+    out.slackListenEnabled = source.slackListenEnabled;
+  }
+  if (typeof source.slackDeviceId === "string") {
+    const id = source.slackDeviceId.trim();
+    if (id) out.slackDeviceId = id;
+  }
+  if (typeof source.slackDeviceLabel === "string") {
+    const label = source.slackDeviceLabel.trim().slice(0, 64);
+    if (label) out.slackDeviceLabel = label;
+  }
   return out;
 }
 function normalizeDefaults(raw) {
@@ -3188,8 +3538,10 @@ function normalizeAdvanced(raw) {
   if (typeof source.caffeinateWhileRunning === "boolean") {
     out.caffeinateWhileRunning = source.caffeinateWhileRunning;
   }
-  if (typeof source.caffeinateWhileCloudConnect === "boolean") {
-    out.caffeinateWhileCloudConnect = source.caffeinateWhileCloudConnect;
+  if (typeof source.caffeinateWhileSlackListen === "boolean") {
+    out.caffeinateWhileSlackListen = source.caffeinateWhileSlackListen;
+  } else if (typeof source.caffeinateWhileCloudConnect === "boolean") {
+    out.caffeinateWhileSlackListen = source.caffeinateWhileCloudConnect;
   }
   if (typeof source.deleteBranchOnPurge === "boolean") {
     out.deleteBranchOnPurge = source.deleteBranchOnPurge;
@@ -3278,23 +3630,84 @@ function normalizeSettings(raw) {
     advanced
   };
 }
-function loadAppSettings() {
+function readSettingsFile() {
   const path = appSettingsPath();
-  if (!(0, import_node_fs6.existsSync)(path)) {
-    return { ...EMPTY_SETTINGS };
-  }
+  if (!(0, import_node_fs8.existsSync)(path)) return { ...EMPTY_SETTINGS };
   try {
-    const parsed = JSON.parse((0, import_node_fs6.readFileSync)(path, "utf8"));
+    chmodOwnerOnly(path);
+    const parsed = JSON.parse((0, import_node_fs8.readFileSync)(path, "utf8"));
     return normalizeSettings(parsed);
   } catch {
     return { ...EMPTY_SETTINGS };
   }
 }
+function diskHoldsSecrets(disk) {
+  return Boolean(
+    disk.integrations.linearApiKey || disk.integrations.linearAccessToken || disk.integrations.linearRefreshToken || disk.integrations.linearClientSecret || disk.integrations.slackClientSecret || disk.integrations.slackAppToken || Object.keys(disk.environment).length > 0
+  );
+}
+function mergeVault(disk) {
+  const vault = loadSecretVault();
+  const environment = { ...vault.environment ?? {}, ...disk.environment };
+  const integrations = { ...disk.integrations };
+  if (vault.linearApiKey && !integrations.linearApiKey) {
+    integrations.linearApiKey = vault.linearApiKey;
+  }
+  if (vault.linearAccessToken && !integrations.linearAccessToken) {
+    integrations.linearAccessToken = vault.linearAccessToken;
+  }
+  if (vault.linearRefreshToken && !integrations.linearRefreshToken) {
+    integrations.linearRefreshToken = vault.linearRefreshToken;
+  }
+  if (vault.linearClientSecret && !integrations.linearClientSecret) {
+    integrations.linearClientSecret = vault.linearClientSecret;
+  }
+  if (vault.slackClientSecret && !integrations.slackClientSecret) {
+    integrations.slackClientSecret = vault.slackClientSecret;
+  }
+  if (vault.slackAppToken && !integrations.slackAppToken) {
+    integrations.slackAppToken = vault.slackAppToken;
+  }
+  return { ...disk, environment, integrations };
+}
+function persistSplit(settings) {
+  const integrations = { ...settings.integrations };
+  const linearApiKey = integrations.linearApiKey;
+  const linearAccessToken = integrations.linearAccessToken;
+  const linearRefreshToken = integrations.linearRefreshToken;
+  const linearClientSecret = integrations.linearClientSecret;
+  const slackClientSecret = integrations.slackClientSecret;
+  const slackAppToken = integrations.slackAppToken;
+  delete integrations.linearApiKey;
+  delete integrations.linearAccessToken;
+  delete integrations.linearRefreshToken;
+  delete integrations.linearClientSecret;
+  delete integrations.slackClientSecret;
+  delete integrations.slackAppToken;
+  writePrivateFile(
+    appSettingsPath(),
+    `${JSON.stringify({ ...settings, environment: {}, integrations }, null, 2)}
+`
+  );
+  saveSecretVault({
+    linearApiKey,
+    linearAccessToken,
+    linearRefreshToken,
+    linearClientSecret,
+    slackClientSecret,
+    slackAppToken,
+    environment: settings.environment
+  });
+}
+function loadAppSettings() {
+  const disk = readSettingsFile();
+  const merged = mergeVault(disk);
+  if (diskHoldsSecrets(disk)) persistSplit(merged);
+  return merged;
+}
 function saveAppSettings(settings) {
   const normalized = normalizeSettings(settings);
-  (0, import_node_fs6.mkdirSync)(appDataDir(), { recursive: true });
-  (0, import_node_fs6.writeFileSync)(appSettingsPath(), `${JSON.stringify(normalized, null, 2)}
-`, "utf8");
+  persistSplit(normalized);
   return normalized;
 }
 function updateAppEnvironment(patch) {
@@ -3385,6 +3798,20 @@ function updateIntegrationsSettings(patch) {
       integrations.linearApiKey = patch.linearApiKey.trim();
     }
   }
+  if ("linearClientId" in patch) {
+    if (patch.linearClientId == null || patch.linearClientId.trim() === "") {
+      delete integrations.linearClientId;
+    } else {
+      integrations.linearClientId = patch.linearClientId.trim();
+    }
+  }
+  if ("linearClientSecret" in patch) {
+    if (patch.linearClientSecret == null || patch.linearClientSecret.trim() === "") {
+      delete integrations.linearClientSecret;
+    } else {
+      integrations.linearClientSecret = patch.linearClientSecret.trim();
+    }
+  }
   if ("issueSource" in patch) {
     if (patch.issueSource == null) {
       delete integrations.issueSource;
@@ -3392,6 +3819,48 @@ function updateIntegrationsSettings(patch) {
       integrations.issueSource = patch.issueSource;
     }
   }
+  if ("slackClientId" in patch) {
+    if (patch.slackClientId == null || patch.slackClientId.trim() === "") {
+      delete integrations.slackClientId;
+    } else {
+      integrations.slackClientId = patch.slackClientId.trim();
+    }
+  }
+  if ("slackClientSecret" in patch) {
+    if (patch.slackClientSecret == null || patch.slackClientSecret.trim() === "") {
+      delete integrations.slackClientSecret;
+    } else {
+      integrations.slackClientSecret = patch.slackClientSecret.trim();
+    }
+  }
+  if ("slackAppToken" in patch) {
+    if (patch.slackAppToken == null || patch.slackAppToken.trim() === "") {
+      delete integrations.slackAppToken;
+    } else {
+      integrations.slackAppToken = patch.slackAppToken.trim();
+    }
+  }
+  if ("slackListenEnabled" in patch) {
+    if (patch.slackListenEnabled == null) {
+      delete integrations.slackListenEnabled;
+    } else {
+      integrations.slackListenEnabled = Boolean(patch.slackListenEnabled);
+    }
+  }
+  if ("slackDeviceId" in patch) {
+    if (patch.slackDeviceId == null || patch.slackDeviceId.trim() === "") {
+      delete integrations.slackDeviceId;
+    } else {
+      integrations.slackDeviceId = patch.slackDeviceId.trim();
+    }
+  }
+  if ("slackDeviceLabel" in patch) {
+    if (patch.slackDeviceLabel == null || patch.slackDeviceLabel.trim() === "") {
+      delete integrations.slackDeviceLabel;
+    } else {
+      integrations.slackDeviceLabel = patch.slackDeviceLabel.trim().slice(0, 64);
+    }
+  }
   return saveAppSettings({ ...current, integrations });
 }
 function updateDefaultsSettings(patch) {
@@ -3465,7 +3934,36 @@ function resolveNewThreadOptions(overrides = {}, settings = loadAppSettings()) {
   };
 }
 function isLinearConnected(settings = loadAppSettings()) {
-  return Boolean(settings.integrations.linearApiKey?.trim());
+  return hasLinearCredentials(settings.integrations);
+}
+function saveLinearOAuth(input) {
+  const current = loadAppSettings();
+  const integrations = { ...current.integrations };
+  integrations.linearAccessToken = input.accessToken.trim();
+  if (input.refreshToken?.trim()) {
+    integrations.linearRefreshToken = input.refreshToken.trim();
+  }
+  if (typeof input.expiresIn === "number" && Number.isFinite(input.expiresIn)) {
+    integrations.linearTokenExpiresAt = Date.now() + Math.max(0, input.expiresIn) * 1e3;
+  }
+  if (input.viewerName?.trim()) {
+    integrations.linearViewerName = input.viewerName.trim().slice(0, 120);
+  }
+  if (input.organizationName?.trim()) {
+    integrations.linearOrganizationName = input.organizationName.trim().slice(0, 120);
+  }
+  return saveAppSettings({ ...current, integrations });
+}
+function disconnectLinearConnection() {
+  const current = loadAppSettings();
+  const integrations = { ...current.integrations };
+  delete integrations.linearApiKey;
+  delete integrations.linearAccessToken;
+  delete integrations.linearRefreshToken;
+  delete integrations.linearTokenExpiresAt;
+  delete integrations.linearViewerName;
+  delete integrations.linearOrganizationName;
+  return saveAppSettings({ ...current, integrations });
 }
 function getIssueSource(settings = loadAppSettings()) {
   return settings.integrations.issueSource ?? "github";
@@ -3482,6 +3980,33 @@ function getLinearApiKey(settings = loadAppSettings()) {
 function brightsyCloudConnectEnabled(settings = loadAppSettings()) {
   return Boolean(settings.brightsy.cloudConnectEnabled);
 }
+function slackListenEnabled(settings = loadAppSettings()) {
+  return settings.integrations.slackListenEnabled === true;
+}
+function ensureSlackDeviceIdentity(settings = loadAppSettings()) {
+  let deviceId = settings.integrations.slackDeviceId?.trim() ?? "";
+  let deviceLabel = settings.integrations.slackDeviceLabel?.trim() ?? "";
+  const patch = {};
+  if (!deviceId) {
+    deviceId = (0, import_node_crypto3.randomUUID)();
+    patch.slackDeviceId = deviceId;
+  }
+  if (!deviceLabel) {
+    try {
+      deviceLabel = (0, import_node_os4.hostname)().split(".")[0]?.trim() || "This Mac";
+    } catch {
+      deviceLabel = "This Mac";
+    }
+    patch.slackDeviceLabel = deviceLabel;
+  }
+  if (Object.keys(patch).length > 0) {
+    updateIntegrationsSettings(patch);
+  }
+  return { deviceId, deviceLabel };
+}
+function slackAppLevelToken(settings = loadAppSettings()) {
+  return process.env.SIDEBOARD_SLACK_APP_TOKEN?.trim() || settings.integrations.slackAppToken?.trim() || "";
+}
 function brightsyInjectWorktreeMcpEnabled(settings = loadAppSettings()) {
   return Boolean(settings.brightsy.injectWorktreeMcp);
 }
@@ -3505,8 +4030,12 @@ function updateAdvancedSettings(patch) {
   if (typeof patch.caffeinateWhileRunning === "boolean") {
     advanced.caffeinateWhileRunning = patch.caffeinateWhileRunning;
   }
-  if (typeof patch.caffeinateWhileCloudConnect === "boolean") {
-    advanced.caffeinateWhileCloudConnect = patch.caffeinateWhileCloudConnect;
+  if (typeof patch.caffeinateWhileSlackListen === "boolean") {
+    advanced.caffeinateWhileSlackListen = patch.caffeinateWhileSlackListen;
+    delete advanced.caffeinateWhileCloudConnect;
+  } else if (typeof patch.caffeinateWhileCloudConnect === "boolean") {
+    advanced.caffeinateWhileSlackListen = patch.caffeinateWhileCloudConnect;
+    delete advanced.caffeinateWhileCloudConnect;
   }
   if (typeof patch.deleteBranchOnPurge === "boolean") {
     advanced.deleteBranchOnPurge = patch.deleteBranchOnPurge;
@@ -3549,8 +4078,11 @@ function autoRunAfterSetupEnabled(settings = loadAppSettings()) {
 function caffeinateWhileRunningEnabled(settings = loadAppSettings()) {
   return Boolean(settings.advanced.caffeinateWhileRunning);
 }
+function caffeinateWhileSlackListenEnabled(settings = loadAppSettings()) {
+  return Boolean(settings.advanced.caffeinateWhileSlackListen);
+}
 function caffeinateWhileCloudConnectEnabled(settings = loadAppSettings()) {
-  return Boolean(settings.advanced.caffeinateWhileCloudConnect);
+  return caffeinateWhileSlackListenEnabled(settings);
 }
 function deleteBranchOnPurgeEnabled(settings = loadAppSettings()) {
   return Boolean(settings.advanced.deleteBranchOnPurge);
@@ -3636,15 +4168,18 @@ function childEnvWithAppSettings(extra) {
 function harnessEnvKey(harness) {
   return HARNESS_ENV_KEYS[harness];
 }
-var import_node_fs6, import_node_os4, import_node_path6, HARNESS_ENV_KEYS, DEFAULT_AGENTS, CLOUD_CONNECT_AGENTS, ISSUE_SOURCES, EMPTY_SETTINGS, DEFAULT_CLI_BIN;
+var import_node_crypto3, import_node_fs8, import_node_os4, import_node_path8, HARNESS_ENV_KEYS, DEFAULT_AGENTS, CLOUD_CONNECT_AGENTS, ISSUE_SOURCES, EMPTY_SETTINGS, DEFAULT_CLI_BIN;
 var init_app_settings = __esm({
   "src/store/app-settings.ts"() {
     "use strict";
-    import_node_fs6 = require("fs");
+    import_node_crypto3 = require("crypto");
+    import_node_fs8 = require("fs");
     import_node_os4 = require("os");
-    import_node_path6 = require("path");
+    import_node_path8 = require("path");
     init_thinking_effort();
     init_paths();
+    init_private_file();
+    init_secret_vault();
     HARNESS_ENV_KEYS = {
       claude: "ANTHROPIC_API_KEY",
       codex: "CODEX_API_KEY",
@@ -3747,6 +4282,7 @@ var init_orchestrator_capable = __esm({
 var coordinator_prompt_exports = {};
 __export(coordinator_prompt_exports, {
   COORDINATOR_TOOL_PLAYBOOK: () => COORDINATOR_TOOL_PLAYBOOK,
+  SLACK_REPLY_FORMATTING: () => SLACK_REPLY_FORMATTING,
   coordinatorGreenfieldPlaybook: () => coordinatorGreenfieldPlaybook,
   coordinatorSystemPrompt: () => coordinatorSystemPrompt,
   coordinatorTurnReminder: () => coordinatorTurnReminder,
@@ -3801,13 +4337,14 @@ function coordinatorTurnReminder(opts) {
     `- For "what's going on": call list_threads (and list_workspaces if needed). Summarize fleet status \u2014 do not ls/git-status this synthetic home.`,
     "- Existing repo: create_thread on a repoPath \u2192 send_to_thread \u2192 wait_for_turn.",
     "- New repo: Bash (clone or gh repo create under ~/sideboard/repos/<name>) \u2192 add_workspace \u2192 create_thread \u2192 send_to_thread \u2192 wait_for_turn \u2192 draft PR.",
-    "- When naming threads for the user, link them as `[Title](sideboard://thread/<id>)`."
+    "- When naming threads for the user, link them as `[Title](sideboard://thread/<id>)`.",
+    "- If they will wait on Slack or leave the Mac, call set_caffeinate enabled=true. When they say they are done / wrapping up / going to sleep, call set_caffeinate enabled=false."
   ].filter(Boolean).join("\n");
 }
 function ensureGlobalCoordinatorCwd(opts) {
   const dir = globalAgentCwd();
   try {
-    (0, import_node_fs7.mkdirSync)(dir, { recursive: true });
+    (0, import_node_fs9.mkdirSync)(dir, { recursive: true });
   } catch {
     return dir;
   }
@@ -3815,7 +4352,7 @@ function ensureGlobalCoordinatorCwd(opts) {
   let orchId = opts?.orchestratorThreadId?.trim() || "";
   if (!orchId) {
     try {
-      const existing = (0, import_node_fs7.readFileSync)((0, import_node_path7.join)(dir, "AGENTS.md"), "utf8");
+      const existing = (0, import_node_fs9.readFileSync)((0, import_node_path9.join)(dir, "AGENTS.md"), "utf8");
       const m = existing.match(
         /YOUR orchestration thread id is `([0-9a-f-]{36})`/i
       );
@@ -3857,9 +4394,9 @@ function ensureGlobalCoordinatorCwd(opts) {
     "Always ask worktree agents to open draft PRs (`send_to_thread` + `gh pr create --draft -R <origin>`); never open PRs from the orchestrator."
   ].join("\n");
   try {
-    (0, import_node_fs7.writeFileSync)((0, import_node_path7.join)(dir, "CLAUDE.md"), `${body}
+    (0, import_node_fs9.writeFileSync)((0, import_node_path9.join)(dir, "CLAUDE.md"), `${body}
 `, "utf8");
-    (0, import_node_fs7.writeFileSync)((0, import_node_path7.join)(dir, "AGENTS.md"), `${body}
+    (0, import_node_fs9.writeFileSync)((0, import_node_path9.join)(dir, "AGENTS.md"), `${body}
 `, "utf8");
   } catch {
   }
@@ -3869,8 +4406,14 @@ function coordinatorSystemPrompt(opts) {
   const audience = opts.audience ?? "cloud";
   const reposDir = sideboardReposDir();
   const intro = audience === "cloud" ? [
-    "You are a Sideboard coordinator responding to a request from a Brightsy cloud agent (Slack, Discord, Teams, or other chat).",
+    "You are a Sideboard coordinator responding to a request from a Brightsy cloud agent (Discord, Teams, or other chat).",
     "Your reply will be sent back to that cloud agent \u2014 be concise and actionable."
+  ] : audience === "slack" ? [
+    "You are a Sideboard coordinator responding to a Slack DM or @mention via the Sideboard Slack app.",
+    "Your reply will be posted back in Slack \u2014 be concise and actionable.",
+    "Sideboard signs the Slack reply with this Mac's destination name (Personal / Work). Do not prefix that name yourself.",
+    "Call set_caffeinate enabled=true when they start a stretch of remote work so the Mac stays awake. Call set_caffeinate enabled=false when they say they are done, wrapping up, or going to sleep.",
+    SLACK_REPLY_FORMATTING
   ] : [
     "You are a Sideboard orchestration agent: you oversee worktree agents across registered workspaces in the Sideboard app.",
     "Stay concise and actionable; prefer Sideboard MCP for fleet status; use Bash for greenfield repo setup and inspecting target worktree paths."
@@ -3892,12 +4435,12 @@ function coordinatorSystemPrompt(opts) {
     formatWorkspaceInventory(opts.workspaces)
   ].join("\n");
 }
-var import_node_fs7, import_node_path7, COORDINATOR_TOOL_PLAYBOOK;
+var import_node_fs9, import_node_path9, COORDINATOR_TOOL_PLAYBOOK, SLACK_REPLY_FORMATTING;
 var init_coordinator_prompt = __esm({
   "src/orchestrator/coordinator-prompt.ts"() {
     "use strict";
-    import_node_fs7 = require("fs");
-    import_node_path7 = require("path");
+    import_node_fs9 = require("fs");
+    import_node_path9 = require("path");
     init_worktree();
     init_app_settings();
     init_paths();
@@ -3907,9 +4450,12 @@ var init_coordinator_prompt = __esm({
       "Discover:",
       "- list_workspaces \u2014 registered repos (path + github slug when known)",
       "- list_branches / list_prs / list_issues \u2014 pass repoPath from list_workspaces (issues: Linear API or GitHub Issues)",
+      "- list_teams / slack_list_channels / slack_list_users / slack_search / slack_read / slack_post \u2014 Slack workspaces from Account settings; pass team_id from list_teams",
+      "- Slack notify (only when the user asks): list_teams \u2192 slack_list_users or slack_list_channels \u2192 slack_post with to=@user or #channel and optional github_url (PR, blob permalink, or review/issue comment). Do not notify proactively.",
       "- get_pr_stack / open_pr_stack_layers / add_stack_layer / create_pr_stack \u2014 GitHub stacked PRs (`gh stack`); one worktree per layer",
       "- list_models \u2014 only when you need a specific model (rare); otherwise omit model so Account defaults apply",
       "- list_threads / get_thread \u2014 fleet status (what is going on)",
+      "- set_caffeinate \u2014 keep this Mac awake across turns (macOS caffeinate). Turn on for Slack / away-from-keyboard work. Turn OFF when the user says they are done, wrapping up, going to sleep, or no longer need the machine awake.",
       "Workspaces:",
       "- add_workspace / remove_workspace \u2014 register or unregister a git repo",
       "Worktree threads (chats):",
@@ -3931,6 +4477,13 @@ var init_coordinator_prompt = __esm({
       "Thread links in replies: when mentioning a chat/thread for the user, include a markdown link `[Title](sideboard://thread/<id>)` using the full id (or the link field from create_thread / list_threads). Sideboard renders these as clickable opens.",
       "Bash / Read / etc: allowed for (1) inspecting target worktrees / registered repo paths from MCP, and (2) greenfield setup under ~/sideboard/repos (git clone, gh repo create, git init+remote). Never git init/clone *inside* this synthetic home cwd \u2014 emptiness here is expected, not a bug."
     ].join("\n");
+    SLACK_REPLY_FORMATTING = [
+      "Slack formatting (mandatory \u2014 your reply is posted verbatim to Slack):",
+      "- Use Slack mrkdwn, NOT GitHub/CommonMark markdown. Slack does not render `**bold**`, `# headings`, or `[label](url)`.",
+      "- Bold: *text* (single asterisks). Italic: _text_. Strikethrough: ~text~. Inline code: `code`.",
+      "- Links: <https://example.com|label> or bare URLs. Thread ids: plain `sideboard://thread/<id>` (no markdown link syntax).",
+      "- Prefer short paragraphs and *bold* section labels over markdown headings or bullet trees with `**`."
+    ].join("\n");
   }
 });
 
@@ -3940,15 +4493,18 @@ __export(global_workspace_exports, {
   GLOBAL_WORKSPACE_ID: () => GLOBAL_WORKSPACE_ID,
   createGlobalChat: () => createGlobalChat,
   ensureCloudCoordinator: () => ensureCloudCoordinator,
+  ensureSlackCoordinator: () => ensureSlackCoordinator,
   globalAgentCwd: () => globalAgentCwd,
   healOrchestrationSoccerTitles: () => healOrchestrationSoccerTitles,
   isCloudCoordinatorThread: () => isCloudCoordinatorThread,
   isGlobalRepoPath: () => isGlobalRepoPath,
   isGlobalThread: () => isGlobalThread,
   isOrchestratorThread: () => isOrchestratorThread,
+  isSlackCoordinatorThread: () => isSlackCoordinatorThread,
   listGlobalThreads: () => listGlobalThreads,
   orchestrationTitleNeedsSoccerNickname: () => orchestrationTitleNeedsSoccerNickname,
   orchestratorSessionPoisonedByBuiltins: () => orchestratorSessionPoisonedByBuiltins,
+  slackCoordinatorSourceRef: () => slackCoordinatorSourceRef,
   takenTeamSlugsForOrchestration: () => takenTeamSlugsForOrchestration
 });
 function isGlobalThread(thread) {
@@ -4065,6 +4621,62 @@ function findCloudCoordinator() {
     (t) => t.status !== "archived" && isCloudCoordinatorThread(t)
   );
 }
+function slackCoordinatorSourceRef(teamId, userId) {
+  const team = teamId.trim();
+  const user = userId.trim();
+  if (!team || !user) {
+    throw new Error("Slack coordinator needs teamId and userId");
+  }
+  return `slack:${team}:${user}`;
+}
+function isSlackCoordinatorThread(thread) {
+  const ref = thread.sourceRef?.trim() ?? "";
+  if (!ref.startsWith("slack:")) return false;
+  return isGlobalThread(thread) || thread.sourceType === "orchestration";
+}
+function findSlackCoordinator(teamId, userId) {
+  const ref = slackCoordinatorSourceRef(teamId, userId);
+  return listThreads({ includeArchived: true }).find(
+    (t) => t.status !== "archived" && t.sourceRef === ref && isSlackCoordinatorThread(t)
+  );
+}
+function ensureSlackCoordinator(teamId, userId, agent) {
+  const defaults = resolveThreadDefaults();
+  const desired = assertOrchestratorCapableAgent(agent);
+  const ref = slackCoordinatorSourceRef(teamId, userId);
+  const existing = findSlackCoordinator(teamId, userId);
+  if (existing) {
+    const patch = {};
+    if (existing.repoPath !== GLOBAL_WORKSPACE_ID) {
+      patch.repoPath = GLOBAL_WORKSPACE_ID;
+      patch.worktreePath = globalAgentCwd();
+      patch.branchName = "global";
+    }
+    const hasAgentTurns = existing.messages.some((m) => m.role === "agent");
+    const canRetarget = !existing.sessionId && !hasAgentTurns && existing.status !== "running" && existing.status !== "queued";
+    if (canRetarget) {
+      if (existing.agent !== desired) patch.agent = desired;
+      if (existing.model !== defaults.model) patch.model = defaults.model;
+      if (existing.effort !== defaults.effort) patch.effort = defaults.effort;
+      if (existing.fast !== defaults.fast) patch.fast = defaults.fast;
+    }
+    if (Object.keys(patch).length > 0) {
+      return updateThread(existing.id, patch);
+    }
+    return existing;
+  }
+  const created = createGlobalChat({
+    sourceRef: ref,
+    agent: desired,
+    model: defaults.model,
+    effort: defaults.effort,
+    fast: defaults.fast
+  });
+  const all = listThreads({ includeArchived: true }).filter(
+    (t) => t.status !== "archived" && t.sourceRef === ref && isSlackCoordinatorThread(t)
+  ).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  return all[0] ?? created;
+}
 function ensureCloudCoordinator(agent) {
   const defaults = resolveThreadDefaults();
   const desired = assertOrchestratorCapableAgent(agent);
@@ -4118,32 +4730,32 @@ var init_global_workspace = __esm({
 
 // src/brightsy/config.ts
 function brightsyConfigPath() {
-  return (0, import_node_path8.join)((0, import_node_os5.homedir)(), ".brightsy", "config.json");
+  return (0, import_node_path10.join)((0, import_node_os5.homedir)(), ".brightsy", "config.json");
 }
 function loadBrightsyConfig() {
   const path = brightsyConfigPath();
-  if (!(0, import_node_fs8.existsSync)(path)) {
+  if (!(0, import_node_fs10.existsSync)(path)) {
     throw new Error("Brightsy not logged in \u2014 run `brightsy login` first");
   }
-  const raw = JSON.parse((0, import_node_fs8.readFileSync)(path, "utf8"));
+  const raw = JSON.parse((0, import_node_fs10.readFileSync)(path, "utf8"));
   if (!raw.access_token || !raw.account_id) {
     throw new Error("Brightsy config incomplete \u2014 run `brightsy login`");
   }
   return raw;
 }
 function saveBrightsyConfig(cfg) {
-  (0, import_node_fs8.writeFileSync)(brightsyConfigPath(), `${JSON.stringify(cfg, null, 2)}
+  (0, import_node_fs10.writeFileSync)(brightsyConfigPath(), `${JSON.stringify(cfg, null, 2)}
 `, {
     mode: 384
   });
 }
-var import_node_fs8, import_node_os5, import_node_path8;
+var import_node_fs10, import_node_os5, import_node_path10;
 var init_config = __esm({
   "src/brightsy/config.ts"() {
     "use strict";
-    import_node_fs8 = require("fs");
+    import_node_fs10 = require("fs");
     import_node_os5 = require("os");
-    import_node_path8 = require("path");
+    import_node_path10 = require("path");
   }
 });
 
@@ -4158,22 +4770,22 @@ var init_accounts = __esm({
 
 // src/brightsy/connected-teams.ts
 function storePath() {
-  return (0, import_node_path9.join)(appDataDir(), "brightsy-teams.json");
+  return (0, import_node_path11.join)(appDataDir(), "brightsy-teams.json");
 }
 function readStore() {
   const path = storePath();
-  if (!(0, import_node_fs9.existsSync)(path)) return [];
+  if (!(0, import_node_fs11.existsSync)(path)) return [];
   try {
-    const parsed = JSON.parse((0, import_node_fs9.readFileSync)(path, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs11.readFileSync)(path, "utf8"));
     return Array.isArray(parsed.teams) ? parsed.teams : [];
   } catch {
     return [];
   }
 }
 function writeStore(teams) {
-  (0, import_node_fs9.mkdirSync)(appDataDir(), { recursive: true });
+  (0, import_node_fs11.mkdirSync)(appDataDir(), { recursive: true });
   const path = storePath();
-  (0, import_node_fs9.writeFileSync)(path, `${JSON.stringify({ teams }, null, 2)}
+  (0, import_node_fs11.writeFileSync)(path, `${JSON.stringify({ teams }, null, 2)}
 `, {
     mode: 384
   });
@@ -4285,12 +4897,12 @@ function brightsyMcpServerName(slug) {
   const cleaned = slug.replace(/[^A-Za-z0-9_-]/g, "_").replace(/^_+|_+$/g, "");
   return `brightsy_${cleaned || "team"}`;
 }
-var import_node_fs9, import_node_path9;
+var import_node_fs11, import_node_path11;
 var init_connected_teams = __esm({
   "src/brightsy/connected-teams.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_accounts();
     init_config();
@@ -4576,11 +5188,11 @@ async function syncCliForTarget(accountId) {
   }
   applyConnectedTeamToCli(team);
 }
-var import_node_fs10, brightsyAdapter;
+var import_node_fs12, brightsyAdapter;
 var init_brightsy = __esm({
   "src/agents/brightsy.ts"() {
     "use strict";
-    import_node_fs10 = require("fs");
+    import_node_fs12 = require("fs");
     init_run();
     init_connected_teams();
     init_config();
@@ -4594,7 +5206,7 @@ var init_brightsy = __esm({
       async detect() {
         const brightsy = resolveAgentExecutable("brightsy");
         if (brightsy !== "brightsy") {
-          if (!(0, import_node_fs10.existsSync)(brightsy)) {
+          if (!(0, import_node_fs12.existsSync)(brightsy)) {
             return {
               agent: "brightsy",
               installed: false,
@@ -4670,10 +5282,10 @@ var init_brightsy = __esm({
 });
 
 // src/agents/claude-mcp.ts
-function parseMcpList(text) {
+function parseMcpList(text2) {
   const servers = [];
   const seen = /* @__PURE__ */ new Set();
-  for (const raw of text.split("\n")) {
+  for (const raw of text2.split("\n")) {
     const line = raw.trim();
     if (!line || /^Checking MCP/i.test(line)) continue;
     const m = line.match(/^(.+?):\s+\S+/);
@@ -4767,8 +5379,8 @@ function isBrightsyConnected() {
     return false;
   }
 }
-function promptMentionsBrightsy(text) {
-  return BRIGHTSY_WORD.test(text ?? "");
+function promptMentionsBrightsy(text2) {
+  return BRIGHTSY_WORD.test(text2 ?? "");
 }
 function isBrightsyMcpToolName(name) {
   const n = name.toLowerCase();
@@ -4831,35 +5443,35 @@ function corePackageDir() {
   try {
     const url = import_meta.url;
     if (typeof url === "string" && url.length > 0) {
-      return (0, import_node_path10.dirname)((0, import_node_url.fileURLToPath)(url));
+      return (0, import_node_path12.dirname)((0, import_node_url.fileURLToPath)(url));
     }
   } catch {
   }
   try {
-    const req = (0, import_node_module.createRequire)((0, import_node_path10.join)(process.cwd(), "package.json"));
-    return (0, import_node_path10.dirname)(req.resolve("@sideboard-ai/core"));
+    const req = (0, import_node_module.createRequire)((0, import_node_path12.join)(process.cwd(), "package.json"));
+    return (0, import_node_path12.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_fs11.existsSync)(override)) return override;
+  if (override && (0, import_node_fs13.existsSync)(override)) return override;
   let dir = corePackageDir();
   for (let i = 0; i < 10; i++) {
     const candidates = [
-      (0, import_node_path10.join)(dir, "mcp/run-stdio.js"),
-      (0, import_node_path10.join)(dir, "mcp/run-stdio.cjs"),
-      (0, import_node_path10.join)(dir, "dist/mcp/run-stdio.js"),
-      (0, import_node_path10.join)(dir, "dist/mcp/run-stdio.cjs"),
-      (0, import_node_path10.join)(dir, "packages/core/dist/mcp/run-stdio.js"),
-      (0, import_node_path10.join)(dir, "packages/cli/dist/index.js"),
-      (0, import_node_path10.join)(dir, "cli/dist/index.js")
+      (0, import_node_path12.join)(dir, "mcp/run-stdio.js"),
+      (0, import_node_path12.join)(dir, "mcp/run-stdio.cjs"),
+      (0, import_node_path12.join)(dir, "dist/mcp/run-stdio.js"),
+      (0, import_node_path12.join)(dir, "dist/mcp/run-stdio.cjs"),
+      (0, import_node_path12.join)(dir, "packages/core/dist/mcp/run-stdio.js"),
+      (0, import_node_path12.join)(dir, "packages/cli/dist/index.js"),
+      (0, import_node_path12.join)(dir, "cli/dist/index.js")
     ];
     for (const p of candidates) {
-      if ((0, import_node_fs11.existsSync)(p)) return p;
+      if ((0, import_node_fs13.existsSync)(p)) return p;
     }
-    const parent = (0, import_node_path10.dirname)(dir);
+    const parent = (0, import_node_path12.dirname)(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -4969,19 +5581,19 @@ function writeMcpServersConfig(servers) {
       ...s.env ? { env: s.env } : {}
     };
   }
-  const dir = (0, import_node_fs11.mkdtempSync)((0, import_node_path10.join)((0, import_node_os6.tmpdir)(), "sideboard-mcp-"));
-  const cfgPath = (0, import_node_path10.join)(dir, "mcp.json");
-  (0, import_node_fs11.writeFileSync)(cfgPath, JSON.stringify({ mcpServers }, null, 2));
+  const dir = (0, import_node_fs13.mkdtempSync)((0, import_node_path12.join)((0, import_node_os6.tmpdir)(), "sideboard-mcp-"));
+  const cfgPath = (0, import_node_path12.join)(dir, "mcp.json");
+  (0, import_node_fs13.writeFileSync)(cfgPath, JSON.stringify({ mcpServers }, null, 2));
   return cfgPath;
 }
-var import_node_fs11, import_node_module, import_node_os6, import_node_path10, import_node_url, import_meta, SIDEBOARD_MCP_ALLOWED_TOOLS, SIDEBOARD_ARTIFACT_MCP_ALLOWED_TOOLS, brightsyMcpCommandCache, BRIGHTSY_WORD;
+var import_node_fs13, import_node_module, import_node_os6, import_node_path12, import_node_url, import_meta, SIDEBOARD_MCP_ALLOWED_TOOLS, SIDEBOARD_ARTIFACT_MCP_ALLOWED_TOOLS, brightsyMcpCommandCache, BRIGHTSY_WORD;
 var init_injected_mcp = __esm({
   "src/agents/injected-mcp.ts"() {
     "use strict";
-    import_node_fs11 = require("fs");
+    import_node_fs13 = require("fs");
     import_node_module = require("module");
     import_node_os6 = require("os");
-    import_node_path10 = require("path");
+    import_node_path12 = require("path");
     import_node_url = require("url");
     init_run();
     init_config();
@@ -5000,7 +5612,13 @@ var init_injected_mcp = __esm({
       "mcp__sideboard__present_schema",
       "mcp__sideboard__present_files",
       "mcp__sideboard__ask_user",
-      "mcp__sideboard__present_plan"
+      "mcp__sideboard__present_plan",
+      "mcp__sideboard__list_teams",
+      "mcp__sideboard__slack_list_channels",
+      "mcp__sideboard__slack_list_users",
+      "mcp__sideboard__slack_search",
+      "mcp__sideboard__slack_read",
+      "mcp__sideboard__slack_post"
     ];
     brightsyMcpCommandCache = null;
     BRIGHTSY_WORD = /(?<![a-z0-9_-])brightsy(?![a-z0-9_-])/i;
@@ -5134,9 +5752,9 @@ function eventsFromContentBlocks(blocks) {
   return out;
 }
 function parseIssuesJson(raw) {
-  const text = raw.trim();
-  const candidates = [text];
-  const match = text.match(/\[[\s\S]*\]/);
+  const text2 = raw.trim();
+  const candidates = [text2];
+  const match = text2.match(/\[[\s\S]*\]/);
   if (match) candidates.push(match[0]);
   for (const c of candidates) {
     try {
@@ -5158,11 +5776,11 @@ function parseIssuesJson(raw) {
   }
   return [];
 }
-var import_node_fs12, BASE_ALLOWED_TOOLS, CLAUDE_CHROME_ALLOWED_TOOLS, CLAUDE_PROMPT_ARG_MAX, claudeAdapter;
+var import_node_fs14, BASE_ALLOWED_TOOLS, CLAUDE_CHROME_ALLOWED_TOOLS, CLAUDE_PROMPT_ARG_MAX, claudeAdapter;
 var init_claude = __esm({
   "src/agents/claude.ts"() {
     "use strict";
-    import_node_fs12 = require("fs");
+    import_node_fs14 = require("fs");
     init_run();
     init_app_settings();
     init_claude_mcp();
@@ -5191,7 +5809,7 @@ var init_claude = __esm({
       async detect() {
         const claude = resolveClaudeExecutable();
         if (claude !== "claude") {
-          if (!(0, import_node_fs12.existsSync)(claude)) {
+          if (!(0, import_node_fs14.existsSync)(claude)) {
             return {
               agent: "claude",
               installed: false,
@@ -5365,8 +5983,8 @@ var init_claude = __esm({
             if (errorDetail) {
               events.push({ type: "stderr", data: errorDetail });
             } else {
-              const text = obj.result;
-              if (typeof text === "string" && text) events.push({ type: "stdout", data: text });
+              const text2 = obj.result;
+              if (typeof text2 === "string" && text2) events.push({ type: "stdout", data: text2 });
             }
             const usage = usageFromClaude(obj.usage);
             if (usage) events.push({ type: "usage", data: usage });
@@ -5424,7 +6042,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_fs13.existsSync)(codex)) {
+  } else if (!(0, import_node_fs15.existsSync)(codex)) {
     return FALLBACK_CODEX_MODELS;
   }
   const listed = await run(codex, ["debug", "models"], { reject: false });
@@ -5462,13 +6080,13 @@ function usageFromCodex(usage) {
 }
 function codexConfigHasNetworkAccess() {
   const candidates = [
-    (0, import_node_path11.join)((0, import_node_os7.homedir)(), ".codex", "config.toml"),
-    (0, import_node_path11.join)((0, import_node_os7.homedir)(), ".config", "codex", "config.toml")
+    (0, import_node_path13.join)((0, import_node_os7.homedir)(), ".codex", "config.toml"),
+    (0, import_node_path13.join)((0, import_node_os7.homedir)(), ".config", "codex", "config.toml")
   ];
   for (const path of candidates) {
-    if (!(0, import_node_fs13.existsSync)(path)) continue;
-    const text = (0, import_node_fs13.readFileSync)(path, "utf8");
-    if (/network_access\s*=\s*true/.test(text)) return true;
+    if (!(0, import_node_fs15.existsSync)(path)) continue;
+    const text2 = (0, import_node_fs15.readFileSync)(path, "utf8");
+    if (/network_access\s*=\s*true/.test(text2)) return true;
   }
   return false;
 }
@@ -5481,8 +6099,8 @@ function unwrapCodexMcpResult(result) {
     const texts = [];
     for (const item of rec.content) {
       if (!item || typeof item !== "object") continue;
-      const text = item.text;
-      if (typeof text === "string") texts.push(text);
+      const text2 = item.text;
+      if (typeof text2 === "string") texts.push(text2);
     }
     if (texts.length) return texts.join("\n");
   }
@@ -5499,21 +6117,21 @@ function asRecord(value) {
   return void 0;
 }
 function codexLooksAuthenticated() {
-  const authPath = (0, import_node_path11.join)((0, import_node_os7.homedir)(), ".codex", "auth.json");
-  if (!(0, import_node_fs13.existsSync)(authPath)) return false;
+  const authPath = (0, import_node_path13.join)((0, import_node_os7.homedir)(), ".codex", "auth.json");
+  if (!(0, import_node_fs15.existsSync)(authPath)) return false;
   try {
-    return (0, import_node_fs13.statSync)(authPath).size > 2;
+    return (0, import_node_fs15.statSync)(authPath).size > 2;
   } catch {
     return false;
   }
 }
-var import_node_fs13, import_node_os7, import_node_path11, CODEX_PROMPT_ARG_MAX, FALLBACK_CODEX_MODELS, cachedCodexModels, CODEX_MODEL_CACHE_MS, codexAdapter;
+var import_node_fs15, import_node_os7, import_node_path13, 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_fs13 = require("fs");
+    import_node_fs15 = require("fs");
     import_node_os7 = require("os");
-    import_node_path11 = require("path");
+    import_node_path13 = require("path");
     init_run();
     init_app_settings();
     init_global_workspace();
@@ -5536,7 +6154,7 @@ var init_codex = __esm({
       async detect() {
         const codex = resolveAgentExecutable("codex");
         if (codex !== "codex") {
-          if (!(0, import_node_fs13.existsSync)(codex)) {
+          if (!(0, import_node_fs15.existsSync)(codex)) {
             return {
               agent: "codex",
               installed: false,
@@ -5968,11 +6586,11 @@ function entryDir() {
   const cjsDir = typeof __dirname !== "undefined" ? __dirname : "";
   if (cjsDir) return cjsDir;
   try {
-    return (0, import_node_path12.dirname)((0, import_node_url2.fileURLToPath)(import_meta2.url));
+    return (0, import_node_path14.dirname)((0, import_node_url2.fileURLToPath)(import_meta2.url));
   } catch {
     try {
       const req = (0, import_node_module2.createRequire)(process.cwd() + "/");
-      return (0, import_node_path12.dirname)(req.resolve("@sideboard-ai/core"));
+      return (0, import_node_path14.dirname)(req.resolve("@sideboard-ai/core"));
     } catch {
       return process.cwd();
     }
@@ -5981,27 +6599,27 @@ function entryDir() {
 function cursorRunnerPath() {
   const root = entryDir();
   const candidates = [
-    (0, import_node_path12.join)(root, "agents", "cursor-runner.js"),
-    (0, import_node_path12.join)(root, "agents", "cursor-runner.cjs"),
+    (0, import_node_path14.join)(root, "agents", "cursor-runner.js"),
+    (0, import_node_path14.join)(root, "agents", "cursor-runner.cjs"),
     // If somehow resolved from package root instead of dist/
-    (0, import_node_path12.join)(root, "dist", "agents", "cursor-runner.js"),
-    (0, import_node_path12.join)(root, "dist", "agents", "cursor-runner.cjs"),
+    (0, import_node_path14.join)(root, "dist", "agents", "cursor-runner.js"),
+    (0, import_node_path14.join)(root, "dist", "agents", "cursor-runner.cjs"),
     // Source tree (dev): packages/core/src/agents/cursor-runner.ts
-    (0, import_node_path12.join)(root, "cursor-runner.ts"),
-    (0, import_node_path12.join)(root, "src", "agents", "cursor-runner.ts")
+    (0, import_node_path14.join)(root, "cursor-runner.ts"),
+    (0, import_node_path14.join)(root, "src", "agents", "cursor-runner.ts")
   ];
   for (const candidate of candidates) {
-    if ((0, import_node_fs14.existsSync)(candidate)) return candidate;
+    if ((0, import_node_fs16.existsSync)(candidate)) return candidate;
   }
   return candidates[0];
 }
-var import_node_fs14, import_node_module2, import_node_path12, import_node_url2, import_sdk, import_meta2, FALLBACK_CURSOR_MODELS, cachedModels, MODEL_CACHE_MS, cursorAdapter;
+var import_node_fs16, import_node_module2, import_node_path14, 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_fs14 = require("fs");
+    import_node_fs16 = require("fs");
     import_node_module2 = require("module");
-    import_node_path12 = require("path");
+    import_node_path14 = require("path");
     import_node_url2 = require("url");
     import_sdk = require("@cursor/sdk");
     init_run();
@@ -6127,7 +6745,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_fs15.existsSync)(opencode)) {
+  } else if (!(0, import_node_fs17.existsSync)(opencode)) {
     return FALLBACK_OPENCODE_MODELS;
   }
   const listed = await run(opencode, ["models"], { reject: false });
@@ -6157,11 +6775,11 @@ function usageFromOpencode(tokens) {
     cacheWriteTokens: tokens.cache?.write ? Number(tokens.cache.write) : void 0
   };
 }
-var import_node_fs15, FALLBACK_OPENCODE_MODELS, cachedOpencodeModels, OPENCODE_MODEL_CACHE_MS, opencodeAdapter;
+var import_node_fs17, FALLBACK_OPENCODE_MODELS, cachedOpencodeModels, OPENCODE_MODEL_CACHE_MS, opencodeAdapter;
 var init_opencode = __esm({
   "src/agents/opencode.ts"() {
     "use strict";
-    import_node_fs15 = require("fs");
+    import_node_fs17 = require("fs");
     init_run();
     init_app_settings();
     init_global_workspace();
@@ -6187,7 +6805,7 @@ var init_opencode = __esm({
       async detect() {
         const opencode = resolveAgentExecutable("opencode");
         if (opencode !== "opencode") {
-          if (!(0, import_node_fs15.existsSync)(opencode)) {
+          if (!(0, import_node_fs17.existsSync)(opencode)) {
             return {
               agent: "opencode",
               installed: false,
@@ -6277,8 +6895,8 @@ var init_opencode = __esm({
             return { type: "session_id", data: sid };
           }
           if (obj.type === "text") {
-            const text = obj.part?.text ?? obj.text;
-            if (text) return { type: "stdout", data: text };
+            const text2 = obj.part?.text ?? obj.text;
+            if (text2) return { type: "stdout", data: text2 };
           }
           if (obj.type === "tool_use") {
             const part = obj.part;
@@ -6491,8 +7109,8 @@ var init_list_models = __esm({
 });
 
 // src/agents/session-quota.ts
-function isSessionQuotaLimit(text) {
-  const lower = text.trim().toLowerCase();
+function isSessionQuotaLimit(text2) {
+  const lower = text2.trim().toLowerCase();
   if (!lower) return false;
   if (/credit balance is too low|out of credits|insufficient.?quota|billing/.test(lower)) {
     return false;
@@ -6500,10 +7118,10 @@ function isSessionQuotaLimit(text) {
   if (/prompt is too long|context.*(too long|exceed)|conversation too long/.test(lower)) {
     return false;
   }
-  return /you've hit your/.test(lower) || /hit your (session|weekly|opus) limit/.test(lower) || /usage limit/.test(lower) || /rate.?limit|too many requests|\b429\b/.test(lower) && /reset/i.test(text);
+  return /you've hit your/.test(lower) || /hit your (session|weekly|opus) limit/.test(lower) || /usage limit/.test(lower) || /rate.?limit|too many requests|\b429\b/.test(lower) && /reset/i.test(text2);
 }
-function parseSessionQuotaResetAt(text, now = /* @__PURE__ */ new Date()) {
-  const absolute = text.match(
+function parseSessionQuotaResetAt(text2, now = /* @__PURE__ */ new Date()) {
+  const absolute = text2.match(
     /resets\s+(?:at\s+)?(\d{1,2}):(\d{2})\s*(am|pm)(?:\s*\(([^)]+)\))?/i
   );
   if (absolute) {
@@ -6521,7 +7139,7 @@ function parseSessionQuotaResetAt(text, now = /* @__PURE__ */ new Date()) {
     }
     return at;
   }
-  const relative = text.match(
+  const relative = text2.match(
     /resets\s+in\s+(\d+)\s*(minutes?|hours?|days?)/i
   );
   if (relative) {
@@ -6924,38 +7542,38 @@ __export(workspaces_exports, {
   syncWorkspacesFromThreads: () => syncWorkspacesFromThreads
 });
 function workspacesFile() {
-  return (0, import_node_path16.join)(appDataDir(), "workspaces.json");
+  return (0, import_node_path18.join)(appDataDir(), "workspaces.json");
 }
 function removedWorkspacesFile() {
-  return (0, import_node_path16.join)(appDataDir(), "removed-workspaces.json");
+  return (0, import_node_path18.join)(appDataDir(), "removed-workspaces.json");
 }
 function readAll() {
   const path = workspacesFile();
-  if (!(0, import_node_fs19.existsSync)(path)) return [];
+  if (!(0, import_node_fs21.existsSync)(path)) return [];
   try {
-    const raw = JSON.parse((0, import_node_fs19.readFileSync)(path, "utf8"));
+    const raw = JSON.parse((0, import_node_fs21.readFileSync)(path, "utf8"));
     return Array.isArray(raw) ? raw : [];
   } catch {
     return [];
   }
 }
 function writeAll(list) {
-  (0, import_node_fs19.mkdirSync)(appDataDir(), { recursive: true });
-  (0, import_node_fs19.writeFileSync)(workspacesFile(), JSON.stringify(list, null, 2), "utf8");
+  (0, import_node_fs21.mkdirSync)(appDataDir(), { recursive: true });
+  (0, import_node_fs21.writeFileSync)(workspacesFile(), JSON.stringify(list, null, 2), "utf8");
 }
 function readRemoved() {
   const path = removedWorkspacesFile();
-  if (!(0, import_node_fs19.existsSync)(path)) return /* @__PURE__ */ new Set();
+  if (!(0, import_node_fs21.existsSync)(path)) return /* @__PURE__ */ new Set();
   try {
-    const raw = JSON.parse((0, import_node_fs19.readFileSync)(path, "utf8"));
+    const raw = JSON.parse((0, import_node_fs21.readFileSync)(path, "utf8"));
     return new Set(Array.isArray(raw) ? raw.filter((p) => typeof p === "string") : []);
   } catch {
     return /* @__PURE__ */ new Set();
   }
 }
 function writeRemoved(paths) {
-  (0, import_node_fs19.mkdirSync)(appDataDir(), { recursive: true });
-  (0, import_node_fs19.writeFileSync)(removedWorkspacesFile(), JSON.stringify([...paths].sort(), null, 2), "utf8");
+  (0, import_node_fs21.mkdirSync)(appDataDir(), { recursive: true });
+  (0, import_node_fs21.writeFileSync)(removedWorkspacesFile(), JSON.stringify([...paths].sort(), null, 2), "utf8");
 }
 function rememberRemoved(repoPath) {
   const next = readRemoved();
@@ -6978,7 +7596,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_fs19.existsSync)(root)) throw new Error(`Repo not found: ${root}`);
+  if (!(0, import_node_fs21.existsSync)(root)) throw new Error(`Repo not found: ${root}`);
   forgetRemoved(root);
   await ensureGhPreferOrigin(root);
   const current = readAll();
@@ -6986,7 +7604,7 @@ async function addWorkspace(repoPath) {
   if (existing) return existing;
   const next = {
     path: root,
-    name: (0, import_node_path16.basename)(root),
+    name: (0, import_node_path18.basename)(root),
     addedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   writeAll([...current, next]);
@@ -7008,10 +7626,10 @@ function syncWorkspacesFromThreads(repoPaths) {
     if (!path || path === "/" || isGlobalRepoPath(path) || byPath.has(path) || removed.has(path)) {
       continue;
     }
-    if (!(0, import_node_fs19.existsSync)(path)) continue;
+    if (!(0, import_node_fs21.existsSync)(path)) continue;
     const ws = {
       path,
-      name: (0, import_node_path16.basename)(path),
+      name: (0, import_node_path18.basename)(path),
       addedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     byPath.set(path, ws);
@@ -7021,12 +7639,12 @@ function syncWorkspacesFromThreads(repoPaths) {
   if (dirty) writeAll(next);
   return next.sort((a, b) => a.name.localeCompare(b.name));
 }
-var import_node_fs19, import_node_path16;
+var import_node_fs21, import_node_path18;
 var init_workspaces = __esm({
   "src/store/workspaces.ts"() {
     "use strict";
-    import_node_fs19 = require("fs");
-    import_node_path16 = require("path");
+    import_node_fs21 = require("fs");
+    import_node_path18 = require("path");
     init_paths();
     init_global_workspace();
     init_worktree();
@@ -7067,11 +7685,11 @@ function resolvePlanMarkdown(opts) {
       source: "exit_plan"
     };
   }
-  const text = opts.text?.trim();
-  if (text && text.length >= 80) {
+  const text2 = opts.text?.trim();
+  if (text2 && text2.length >= 80) {
     return {
       title: "Plan",
-      content: text,
+      content: text2,
       path: PLAN_FILE_REL,
       source: "text"
     };
@@ -7103,40 +7721,40 @@ __export(plan_file_exports, {
   writePlanFile: () => writePlanFile
 });
 function ensureAttachmentsGitignore2(worktreePath) {
-  const gitignoreAbs = (0, import_node_path24.join)(worktreePath, ATTACHMENTS_DIR, ".gitignore");
-  if ((0, import_node_fs29.existsSync)(gitignoreAbs)) return;
-  (0, import_node_fs29.mkdirSync)((0, import_node_path24.dirname)(gitignoreAbs), { recursive: true });
-  (0, import_node_fs29.writeFileSync)(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
+  const gitignoreAbs = (0, import_node_path26.join)(worktreePath, ATTACHMENTS_DIR, ".gitignore");
+  if ((0, import_node_fs31.existsSync)(gitignoreAbs)) return;
+  (0, import_node_fs31.mkdirSync)((0, import_node_path26.dirname)(gitignoreAbs), { recursive: true });
+  (0, import_node_fs31.writeFileSync)(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
 }
 function planFileAbs(worktreePath) {
-  return (0, import_node_path24.join)(worktreePath, PLAN_FILE_REL);
+  return (0, import_node_path26.join)(worktreePath, PLAN_FILE_REL);
 }
 function readTextIfPresent2(abs) {
-  if (!(0, import_node_fs29.existsSync)(abs)) return null;
+  if (!(0, import_node_fs31.existsSync)(abs)) return null;
   try {
-    const content = (0, import_node_fs29.readFileSync)(abs, "utf8");
+    const content = (0, import_node_fs31.readFileSync)(abs, "utf8");
     return content.trim() ? content : null;
   } catch {
     return null;
   }
 }
 function readPlanFile(worktreePath) {
-  return readTextIfPresent2(planFileAbs(worktreePath)) ?? readTextIfPresent2((0, import_node_path24.join)(worktreePath, `${LEGACY_ATTACHMENTS_DIR}/plan.md`)) ?? readTextIfPresent2((0, import_node_path24.join)(worktreePath, LEGACY_PLAN_FILE_REL));
+  return readTextIfPresent2(planFileAbs(worktreePath)) ?? readTextIfPresent2((0, import_node_path26.join)(worktreePath, `${LEGACY_ATTACHMENTS_DIR}/plan.md`)) ?? readTextIfPresent2((0, import_node_path26.join)(worktreePath, LEGACY_PLAN_FILE_REL));
 }
 function writePlanFile(worktreePath, content) {
   ensureAttachmentsGitignore2(worktreePath);
   const abs = planFileAbs(worktreePath);
-  (0, import_node_fs29.mkdirSync)((0, import_node_path24.dirname)(abs), { recursive: true });
+  (0, import_node_fs31.mkdirSync)((0, import_node_path26.dirname)(abs), { recursive: true });
   const body = content.trimEnd() + (content.endsWith("\n") ? "" : "\n");
-  (0, import_node_fs29.writeFileSync)(abs, body, "utf8");
+  (0, import_node_fs31.writeFileSync)(abs, body, "utf8");
   return PLAN_FILE_REL;
 }
-var import_node_fs29, import_node_path24;
+var import_node_fs31, import_node_path26;
 var init_plan_file = __esm({
   "src/plan/plan-file.ts"() {
     "use strict";
-    import_node_fs29 = require("fs");
-    import_node_path24 = require("path");
+    import_node_fs31 = require("fs");
+    import_node_path26 = require("path");
     init_workspace_scratch();
     init_plan_present();
     init_plan_present();
@@ -7151,10 +7769,10 @@ __export(cursor_recover_exports, {
 function recoverFinishedCursorRun(opts) {
   const agentId = opts.agentId.trim();
   if (!agentId) return null;
-  const runsPath = (0, import_node_path25.join)(appDataDir(), "cursor-sdk-store", "runs.ndjson");
-  if (!(0, import_node_fs30.existsSync)(runsPath)) return null;
+  const runsPath = (0, import_node_path27.join)(appDataDir(), "cursor-sdk-store", "runs.ndjson");
+  if (!(0, import_node_fs32.existsSync)(runsPath)) return null;
   try {
-    const lines = (0, import_node_fs30.readFileSync)(runsPath, "utf8").split("\n");
+    const lines = (0, import_node_fs32.readFileSync)(runsPath, "utf8").split("\n");
     let best = null;
     for (const line of lines) {
       const trimmed = line.trim();
@@ -7180,25 +7798,133 @@ function recoverFinishedCursorRun(opts) {
     return null;
   }
 }
-var import_node_fs30, import_node_path25;
+var import_node_fs32, import_node_path27;
 var init_cursor_recover = __esm({
   "src/agents/cursor-recover.ts"() {
     "use strict";
-    import_node_fs30 = require("fs");
-    import_node_path25 = require("path");
+    import_node_fs32 = require("fs");
+    import_node_path27 = require("path");
     init_paths();
   }
 });
 
+// src/store/caffeinate-hold.ts
+var caffeinate_hold_exports = {};
+__export(caffeinate_hold_exports, {
+  caffeinateHoldPath: () => caffeinateHoldPath,
+  getCaffeinateHold: () => getCaffeinateHold,
+  setCaffeinateHold: () => setCaffeinateHold,
+  setCaffeinateHoldHooks: () => setCaffeinateHoldHooks
+});
+function setCaffeinateHoldHooks(next) {
+  hooks = next;
+}
+function caffeinateHoldPath() {
+  return (0, import_node_path30.join)(appDataDir(), "caffeinate-hold.json");
+}
+function processAlive(pid) {
+  if (hooks.processAlive) return hooks.processAlive(pid);
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function killPid(pid) {
+  if (hooks.kill) {
+    hooks.kill(pid);
+    return;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+  }
+}
+function readHold() {
+  const path = caffeinateHoldPath();
+  if (!(0, import_node_fs35.existsSync)(path)) return null;
+  try {
+    const parsed = JSON.parse((0, import_node_fs35.readFileSync)(path, "utf8"));
+    if (typeof parsed?.pid === "number" && parsed.pid > 0) return parsed;
+  } catch {
+  }
+  return null;
+}
+function writeHold(pid) {
+  writePrivateFile(caffeinateHoldPath(), `${JSON.stringify({ pid })}
+`);
+}
+function clearHold() {
+  try {
+    (0, import_node_fs35.unlinkSync)(caffeinateHoldPath());
+  } catch {
+  }
+}
+function getCaffeinateHold() {
+  const platform = hooks.platform ?? process.platform;
+  const hold = readHold();
+  if (!hold) {
+    return { held: false, pid: null, running: false, platform };
+  }
+  const running = processAlive(hold.pid);
+  if (!running) {
+    clearHold();
+    return { held: false, pid: null, running: false, platform };
+  }
+  return { held: true, pid: hold.pid, running: true, platform };
+}
+function setCaffeinateHold(enabled) {
+  const platform = hooks.platform ?? process.platform;
+  const current = getCaffeinateHold();
+  if (!enabled) {
+    if (current.pid) killPid(current.pid);
+    clearHold();
+    return { held: false, pid: null, running: false, platform };
+  }
+  if (current.running && current.pid) return current;
+  if (platform !== "darwin") {
+    return { held: false, pid: null, running: false, platform };
+  }
+  const spawnImpl = hooks.spawn ?? import_node_child_process4.spawn;
+  const child = spawnImpl("caffeinate", ["-dimsu"], {
+    detached: true,
+    stdio: "ignore"
+  });
+  const pid = child.pid;
+  if (!pid) {
+    try {
+      child.kill();
+    } catch {
+    }
+    return { held: false, pid: null, running: false, platform };
+  }
+  child.unref();
+  writeHold(pid);
+  return { held: true, pid, running: true, platform };
+}
+var import_node_child_process4, import_node_fs35, import_node_path30, hooks;
+var init_caffeinate_hold = __esm({
+  "src/store/caffeinate-hold.ts"() {
+    "use strict";
+    import_node_child_process4 = require("child_process");
+    import_node_fs35 = require("fs");
+    import_node_path30 = require("path");
+    init_paths();
+    init_private_file();
+    hooks = {};
+  }
+});
+
 // src/mcp/server.ts
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
-var import_zod = require("zod");
-var import_node_path26 = require("path");
+var import_zod2 = require("zod");
+var import_node_path31 = require("path");
 
 // src/orchestrator/orchestrator.ts
 var import_node_events = require("events");
-var import_node_fs31 = require("fs");
+var import_node_fs33 = require("fs");
 init_error_detail();
 
 // src/agents/spawn.ts
@@ -7285,9 +8011,9 @@ function toolFilePath(input) {
   if (!input) return void 0;
   return str2(input.file_path) ?? str2(input.path) ?? str2(input.filePath) ?? str2(input.filename);
 }
-function countLines(text) {
-  if (!text) return 0;
-  return text.split("\n").length;
+function countLines(text2) {
+  if (!text2) return 0;
+  return text2.split("\n").length;
 }
 function diffFromInput(input) {
   if (!input) return {};
@@ -7414,9 +8140,9 @@ function applyAgentEvent(parts, event) {
 function partsToAssistantText(parts) {
   return parts.filter((p) => p.type === "text").map((p) => p.text).join("").trim();
 }
-function stripBrightsyNdjsonNoise(text) {
-  if (!text || !text.includes('"type"')) return text;
-  let out = text;
+function stripBrightsyNdjsonNoise(text2) {
+  if (!text2 || !text2.includes('"type"')) return text2;
+  let out = text2;
   out = out.replace(
     /\{"type":"(?:tool_use|tool_result|tool|thinking|usage|done|error)"[\s\S]*?\}\s*(?=\{"type":"|$|(?=[A-Za-z*#]))/g,
     ""
@@ -7553,8 +8279,8 @@ async function spawnAgentTurn(thread, input, onEvent) {
     onEvent({ type: "exit", data: exitCode });
     const finalized = finalizeParts(parts);
     const rawText = assistantText.trim() || partsToAssistantText(finalized);
-    const text = thread.agent === "brightsy" ? stripBrightsyNdjsonNoise(rawText) : rawText;
-    return { exitCode, sessionId, assistantText: text, parts: finalized, usage };
+    const text2 = thread.agent === "brightsy" ? stripBrightsyNdjsonNoise(rawText) : rawText;
+    return { exitCode, sessionId, assistantText: text2, parts: finalized, usage };
   });
   return {
     pid: child.pid,
@@ -7588,9 +8314,9 @@ function shouldAutoArchiveOnPrMerge(opts) {
 }
 
 // src/hook/conductor.ts
-var import_node_fs16 = require("fs");
+var import_node_fs18 = require("fs");
 var import_node_net = require("net");
-var import_node_path13 = require("path");
+var import_node_path15 = require("path");
 var import_execa3 = require("execa");
 var import_node_readline2 = require("readline");
 init_settings();
@@ -7600,9 +8326,9 @@ function matchSimpleGlob(pattern, name) {
   return new RegExp(`^${escaped}$`).test(name);
 }
 function readWorktreeInclude(repoPath) {
-  const path = (0, import_node_path13.join)(repoPath, ".worktreeinclude");
-  if (!(0, import_node_fs16.existsSync)(path)) return [];
-  return (0, import_node_fs16.readFileSync)(path, "utf8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+  const path = (0, import_node_path15.join)(repoPath, ".worktreeinclude");
+  if (!(0, import_node_fs18.existsSync)(path)) return [];
+  return (0, import_node_fs18.readFileSync)(path, "utf8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
 }
 function resolveFilesToCopy(repoPath) {
   const fromInclude = readWorktreeInclude(repoPath);
@@ -7612,10 +8338,10 @@ function resolveFilesToCopy(repoPath) {
   if (settings?.fileIncludeGlobs?.length) {
     const matched = [];
     try {
-      for (const entry of (0, import_node_fs16.readdirSync)(repoPath, { withFileTypes: true })) {
+      for (const entry of (0, import_node_fs18.readdirSync)(repoPath, { withFileTypes: true })) {
         if (!entry.isFile()) continue;
         for (const glob of settings.fileIncludeGlobs) {
-          if (matchSimpleGlob(glob, entry.name) || matchSimpleGlob((0, import_node_path13.basename)(glob), entry.name)) {
+          if (matchSimpleGlob(glob, entry.name) || matchSimpleGlob((0, import_node_path15.basename)(glob), entry.name)) {
             matched.push(entry.name);
             break;
           }
@@ -7627,7 +8353,7 @@ function resolveFilesToCopy(repoPath) {
   }
   const defaults = [];
   try {
-    for (const entry of (0, import_node_fs16.readdirSync)(repoPath, { withFileTypes: true })) {
+    for (const entry of (0, import_node_fs18.readdirSync)(repoPath, { withFileTypes: true })) {
       if (entry.isFile() && entry.name.startsWith(".env")) {
         defaults.push(entry.name);
       }
@@ -7641,11 +8367,11 @@ function copyConfiguredFiles(repoPath, worktreePath) {
   const patterns = resolveFilesToCopy(repoPath);
   const copied = [];
   for (const rel of patterns) {
-    const src = (0, import_node_path13.join)(repoPath, rel);
-    if (!(0, import_node_fs16.existsSync)(src)) continue;
-    const dest = (0, import_node_path13.join)(worktreePath, rel);
-    (0, import_node_fs16.mkdirSync)((0, import_node_path13.dirname)(dest), { recursive: true });
-    (0, import_node_fs16.copyFileSync)(src, dest);
+    const src = (0, import_node_path15.join)(repoPath, rel);
+    if (!(0, import_node_fs18.existsSync)(src)) continue;
+    const dest = (0, import_node_path15.join)(worktreePath, rel);
+    (0, import_node_fs18.mkdirSync)((0, import_node_path15.dirname)(dest), { recursive: true });
+    (0, import_node_fs18.copyFileSync)(src, dest);
     copied.push(rel);
   }
   return copied;
@@ -7679,7 +8405,7 @@ async function captureLoginEnv() {
 }
 function buildWorkspaceScriptEnv(opts, baseEnv) {
   const env = { ...baseEnv ?? process.env };
-  const name = opts.workspaceName ?? (0, import_node_path13.basename)(opts.worktreePath);
+  const name = opts.workspaceName ?? (0, import_node_path15.basename)(opts.worktreePath);
   const ports = opts.ports ?? [];
   const primary = ports[0];
   env.SIDEBOARD_WORKSPACE_NAME = name;
@@ -7898,15 +8624,15 @@ async function startDevServer(repoPath, worktreePath, onLine, opts) {
 }
 
 // src/hook/cursor-worktrees.ts
-var import_node_fs17 = require("fs");
-var import_node_path14 = require("path");
+var import_node_fs19 = require("fs");
+var import_node_path16 = require("path");
 var import_execa4 = require("execa");
 var import_node_readline3 = require("readline");
 function loadCursorWorktreesJson(rootPath) {
-  const path = (0, import_node_path14.join)(rootPath, ".cursor", "worktrees.json");
-  if (!(0, import_node_fs17.existsSync)(path)) return null;
+  const path = (0, import_node_path16.join)(rootPath, ".cursor", "worktrees.json");
+  if (!(0, import_node_fs19.existsSync)(path)) return null;
   try {
-    return JSON.parse((0, import_node_fs17.readFileSync)(path, "utf8"));
+    return JSON.parse((0, import_node_fs19.readFileSync)(path, "utf8"));
   } catch {
     return null;
   }
@@ -7932,7 +8658,7 @@ async function runCursorWorktreeSetup(repoPath, worktreePath, onLine) {
   if (process.platform === "win32") {
     env.ROOT_WORKTREE_PATH = repoPath;
   }
-  const commands = Array.isArray(spec) ? spec : [spec.endsWith(".sh") || spec.endsWith(".ps1") ? (0, import_node_path14.join)(
+  const commands = Array.isArray(spec) ? spec : [spec.endsWith(".sh") || spec.endsWith(".ps1") ? (0, import_node_path16.join)(
     fromWorktree ? worktreePath : repoPath,
     ".cursor",
     spec
@@ -7964,8 +8690,8 @@ async function runCursorWorktreeSetup(repoPath, worktreePath, onLine) {
 }
 
 // src/git/orphan-cleanup.ts
-var import_node_fs18 = require("fs");
-var import_node_path15 = require("path");
+var import_node_fs20 = require("fs");
+var import_node_path17 = require("path");
 init_worktree();
 init_thread_store();
 init_paths();
@@ -7980,9 +8706,9 @@ async function findOrphanWorktrees(repoPaths) {
     repoPaths?.length ? repoPaths : threads.map((t) => t.repoPath).filter(Boolean)
   );
   const homeRoot = sideboardWorkspacesDir();
-  if ((0, import_node_fs18.existsSync)(homeRoot)) {
+  if ((0, import_node_fs20.existsSync)(homeRoot)) {
     try {
-      for (const entry of (0, import_node_fs18.readdirSync)(homeRoot, { withFileTypes: true })) {
+      for (const entry of (0, import_node_fs20.readdirSync)(homeRoot, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
         void entry;
       }
@@ -7992,7 +8718,7 @@ async function findOrphanWorktrees(repoPaths) {
   const orphans = [];
   const seen = /* @__PURE__ */ new Set();
   for (const repoPath of repos) {
-    if (!repoPath || !(0, import_node_fs18.existsSync)(repoPath)) continue;
+    if (!repoPath || !(0, import_node_fs20.existsSync)(repoPath)) continue;
     try {
       const wts = await listWorktrees(repoPath);
       for (const wt of wts) {
@@ -8003,7 +8729,7 @@ async function findOrphanWorktrees(repoPaths) {
         seen.add(path);
         let mtimeMs = 0;
         try {
-          mtimeMs = (0, import_node_fs18.statSync)(path).mtimeMs;
+          mtimeMs = (0, import_node_fs20.statSync)(path).mtimeMs;
         } catch {
           mtimeMs = 0;
         }
@@ -8013,16 +8739,16 @@ async function findOrphanWorktrees(repoPaths) {
     }
     try {
       const root = worktreesRoot(repoPath);
-      if ((0, import_node_fs18.existsSync)(root)) {
-        for (const entry of (0, import_node_fs18.readdirSync)(root, { withFileTypes: true })) {
+      if ((0, import_node_fs20.existsSync)(root)) {
+        for (const entry of (0, import_node_fs20.readdirSync)(root, { withFileTypes: true })) {
           if (!entry.isDirectory()) continue;
-          const path = (0, import_node_path15.join)(root, entry.name).replace(/\/$/, "");
+          const path = (0, import_node_path17.join)(root, entry.name).replace(/\/$/, "");
           if (known.has(path) || seen.has(path)) continue;
-          if (!(0, import_node_fs18.existsSync)((0, import_node_path15.join)(path, ".git"))) continue;
+          if (!(0, import_node_fs20.existsSync)((0, import_node_path17.join)(path, ".git"))) continue;
           seen.add(path);
           let mtimeMs = 0;
           try {
-            mtimeMs = (0, import_node_fs18.statSync)(path).mtimeMs;
+            mtimeMs = (0, import_node_fs20.statSync)(path).mtimeMs;
           } catch {
             mtimeMs = Date.now();
           }
@@ -8159,8 +8885,8 @@ async function applyThreadIntoMain(thread, opts) {
 }
 
 // src/git/clone-repo.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");
 var import_execa6 = require("execa");
 init_paths();
 init_workspaces();
@@ -8170,12 +8896,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_path17.basename)(url.replace(/\/$/, "").replace(/\.git$/, ""));
+    const leaf = (0, import_node_path19.basename)(url.replace(/\/$/, "").replace(/\.git$/, ""));
     name = leaf || "repo";
   }
   name = name.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "repo";
-  const dest = (0, import_node_path17.join)(sideboardReposDir(), name);
-  if ((0, import_node_fs20.existsSync)(dest)) {
+  const dest = (0, import_node_path19.join)(sideboardReposDir(), name);
+  if ((0, import_node_fs22.existsSync)(dest)) {
     const repoPath2 = await resolveRepoRoot(dest);
     const workspace2 = await ensureWorkspace(repoPath2);
     return { repoPath: repoPath2, workspace: workspace2 };
@@ -8195,7 +8921,7 @@ async function cloneRepoIntoSideboard(opts) {
 init_thread_store();
 
 // src/threads/create.ts
-var import_node_fs21 = require("fs");
+var import_node_fs23 = require("fs");
 
 // src/detect/detect.ts
 init_agents();
@@ -8240,7 +8966,7 @@ async function createThread(input, _onSetupLine) {
   });
   await requireAgent(resolved.agent);
   const repoPath = await resolveRepoRoot(input.repoPath);
-  if (!(0, import_node_fs21.existsSync)(repoPath)) {
+  if (!(0, import_node_fs23.existsSync)(repoPath)) {
     throw new Error(`Repo not found: ${repoPath}`);
   }
   let sourceRef = input.sourceRef;
@@ -8311,7 +9037,7 @@ async function listLinearIssues(agent, repoPath) {
 init_orchestrator_capable();
 
 // src/threads/chat-tabs.ts
-var import_node_crypto2 = require("crypto");
+var import_node_crypto4 = require("crypto");
 
 // src/composer/summarize.ts
 init_run();
@@ -8359,9 +9085,9 @@ async function tryClaudeSummary(transcript, opts) {
       { cwd: opts?.cwd, reject: false }
     );
     if (exitCode !== 0) return null;
-    const text = stdout.trim();
-    if (text.length < 40) return null;
-    return text;
+    const text2 = stdout.trim();
+    if (text2.length < 40) return null;
+    return text2;
   } catch {
     return null;
   }
@@ -8410,9 +9136,9 @@ function extractiveSummary(transcript) {
   );
   return parts.join("\n");
 }
-function clipSummary(text) {
-  if (text.length <= MAX_SUMMARY_CHARS) return text;
-  return `${text.slice(0, MAX_SUMMARY_CHARS)}
+function clipSummary(text2) {
+  if (text2.length <= MAX_SUMMARY_CHARS) return text2;
+  return `${text2.slice(0, MAX_SUMMARY_CHARS)}
 
 [\u2026summary truncated\u2026]`;
 }
@@ -8648,7 +9374,7 @@ function forkMessageSlice(from, throughIndex) {
 function buildForkTranscriptAttachment(baseTitle, messages) {
   const title = baseTitle || "Chat";
   return {
-    id: (0, import_node_crypto2.randomUUID)(),
+    id: (0, import_node_crypto4.randomUUID)(),
     name: `Transcript of ${title}.md`,
     kind: "transcript",
     content: formatTranscriptMarkdown(title, messages)
@@ -8702,9 +9428,9 @@ function forkChatTab(input) {
 }
 
 // src/review/request-review.ts
-var import_node_crypto3 = require("crypto");
-var import_node_fs22 = require("fs");
-var import_node_path18 = require("path");
+var import_node_crypto5 = require("crypto");
+var import_node_fs24 = require("fs");
+var import_node_path20 = require("path");
 init_global_workspace();
 init_thread_store();
 
@@ -8848,22 +9574,22 @@ function shouldRefreshReviewRequestTemplate(content) {
   return LEGACY_REVIEW_TEMPLATE_MARKERS.every((m) => trimmed.includes(m));
 }
 function readTextIfPresent(abs) {
-  if (!(0, import_node_fs22.existsSync)(abs)) return null;
+  if (!(0, import_node_fs24.existsSync)(abs)) return null;
   try {
-    const content = (0, import_node_fs22.readFileSync)(abs, "utf8");
+    const content = (0, import_node_fs24.readFileSync)(abs, "utf8");
     return content.trim() ? content : null;
   } catch {
     return null;
   }
 }
 function ensureAttachmentsGitignore(worktreePath) {
-  const gitignoreAbs = (0, import_node_path18.join)(worktreePath, ATTACHMENTS_DIR, ".gitignore");
-  if ((0, import_node_fs22.existsSync)(gitignoreAbs)) return;
-  (0, import_node_fs22.mkdirSync)((0, import_node_path18.dirname)(gitignoreAbs), { recursive: true });
-  (0, import_node_fs22.writeFileSync)(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
+  const gitignoreAbs = (0, import_node_path20.join)(worktreePath, ATTACHMENTS_DIR, ".gitignore");
+  if ((0, import_node_fs24.existsSync)(gitignoreAbs)) return;
+  (0, import_node_fs24.mkdirSync)((0, import_node_path20.dirname)(gitignoreAbs), { recursive: true });
+  (0, import_node_fs24.writeFileSync)(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
 }
 function resolveReviewGuidelines(worktreePath) {
-  const repoAbs = (0, import_node_path18.join)(worktreePath, REPO_REVIEW_PATH);
+  const repoAbs = (0, import_node_path20.join)(worktreePath, REPO_REVIEW_PATH);
   const repoContent = readTextIfPresent(repoAbs);
   if (repoContent) {
     return {
@@ -8873,7 +9599,7 @@ function resolveReviewGuidelines(worktreePath) {
       source: "repo"
     };
   }
-  const localAbs = (0, import_node_path18.join)(worktreePath, REVIEW_REQUEST_PATH);
+  const localAbs = (0, import_node_path20.join)(worktreePath, REVIEW_REQUEST_PATH);
   const localContent = readTextIfPresent(localAbs);
   if (localContent && !shouldRefreshReviewRequestTemplate(localContent)) {
     return {
@@ -8883,7 +9609,7 @@ function resolveReviewGuidelines(worktreePath) {
       source: "local"
     };
   }
-  const legacyAbs = (0, import_node_path18.join)(worktreePath, LEGACY_REVIEW_REQUEST_PATH);
+  const legacyAbs = (0, import_node_path20.join)(worktreePath, LEGACY_REVIEW_REQUEST_PATH);
   const legacyContent = readTextIfPresent(legacyAbs);
   if (legacyContent && !shouldRefreshReviewRequestTemplate(legacyContent)) {
     return {
@@ -8894,8 +9620,8 @@ function resolveReviewGuidelines(worktreePath) {
     };
   }
   ensureAttachmentsGitignore(worktreePath);
-  (0, import_node_fs22.mkdirSync)((0, import_node_path18.dirname)(localAbs), { recursive: true });
-  (0, import_node_fs22.writeFileSync)(localAbs, REVIEW_REQUEST_TEMPLATE, "utf8");
+  (0, import_node_fs24.mkdirSync)((0, import_node_path20.dirname)(localAbs), { recursive: true });
+  (0, import_node_fs24.writeFileSync)(localAbs, REVIEW_REQUEST_TEMPLATE, "utf8");
   return {
     path: REVIEW_REQUEST_PATH,
     name: REVIEW_REQUEST_NAME,
@@ -8907,7 +9633,7 @@ function buildReviewRequestAttachment(content, opts) {
   const path = opts?.path ?? REVIEW_REQUEST_PATH;
   const name = opts?.name ?? (path === REPO_REVIEW_PATH ? REPO_REVIEW_NAME : REVIEW_REQUEST_NAME);
   return {
-    id: (0, import_node_crypto3.randomUUID)(),
+    id: (0, import_node_crypto5.randomUUID)(),
     name,
     kind: "file",
     path,
@@ -8985,7 +9711,7 @@ async function forkThreadWorktree(input, onSetupLine) {
 }
 
 // src/orchestrator/quota-failover.ts
-var import_node_crypto4 = require("crypto");
+var import_node_crypto6 = require("crypto");
 init_session_quota();
 init_app_settings();
 init_global_workspace();
@@ -9040,8 +9766,8 @@ function buildQuotaHandoffAttachment(from, limitText, fallbackAgent) {
   );
   const recent = from.messages.slice(-8).map((m) => {
     const role = m.role === "user" ? "User" : m.role === "agent" ? "Agent" : "Summary";
-    const text = m.text.trim().replace(/\s+/g, " ").slice(0, 280);
-    return text ? `- ${role}: ${text}` : null;
+    const text2 = m.text.trim().replace(/\s+/g, " ").slice(0, 280);
+    return text2 ? `- ${role}: ${text2}` : null;
   }).filter(Boolean);
   const body = [
     `# Orchestration handoff`,
@@ -9066,7 +9792,7 @@ function buildQuotaHandoffAttachment(from, limitText, fallbackAgent) {
     `- Do not wait on the limited ${from.agent} account; keep going on ${fallbackAgent}.`
   ].join("\n");
   return {
-    id: (0, import_node_crypto4.randomUUID)(),
+    id: (0, import_node_crypto6.randomUUID)(),
     name: "Orchestration quota handoff.md",
     kind: "transcript",
     content: body
@@ -9094,21 +9820,21 @@ function createQuotaFailoverChat(from, fallbackAgent, limitText) {
 }
 
 // src/threads/adopt.ts
-var import_node_child_process2 = require("child_process");
-var import_node_fs23 = require("fs");
+var import_node_child_process3 = require("child_process");
+var import_node_fs25 = require("fs");
 var import_node_os8 = require("os");
-var import_node_path19 = require("path");
+var import_node_path21 = require("path");
 var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
 init_worktree();
 init_thread_store();
-var CONDUCTOR_APP_SUPPORT = (0, import_node_path19.join)(
+var CONDUCTOR_APP_SUPPORT = (0, import_node_path21.join)(
   process.env.HOME ?? "",
   "Library",
   "Application Support",
   "com.conductor.app"
 );
-var CONDUCTOR_DB = (0, import_node_path19.join)(CONDUCTOR_APP_SUPPORT, "conductor.db");
-var CURSOR_SDK_STORE = (0, import_node_path19.join)(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
+var CONDUCTOR_DB = (0, import_node_path21.join)(CONDUCTOR_APP_SUPPORT, "conductor.db");
+var CURSOR_SDK_STORE = (0, import_node_path21.join)(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
 function mapAgentType(raw) {
   if (!raw) return null;
   const v = raw.toLowerCase();
@@ -9120,25 +9846,25 @@ function mapAgentType(raw) {
   return null;
 }
 function resolveConductorCursorAgentId(workspacePath) {
-  if (!workspacePath || !(0, import_node_fs23.existsSync)(CURSOR_SDK_STORE)) return null;
+  if (!workspacePath || !(0, import_node_fs25.existsSync)(CURSOR_SDK_STORE)) return null;
   const normalized = workspacePath.replace(/\/$/, "");
   let best = null;
   let hashes;
   try {
-    hashes = (0, import_node_fs23.readdirSync)(CURSOR_SDK_STORE);
+    hashes = (0, import_node_fs25.readdirSync)(CURSOR_SDK_STORE);
   } catch {
     return null;
   }
   for (const hash of hashes) {
-    const agentsFile = (0, import_node_path19.join)(CURSOR_SDK_STORE, hash, "agents.ndjson");
-    if (!(0, import_node_fs23.existsSync)(agentsFile)) continue;
-    let text;
+    const agentsFile = (0, import_node_path21.join)(CURSOR_SDK_STORE, hash, "agents.ndjson");
+    if (!(0, import_node_fs25.existsSync)(agentsFile)) continue;
+    let text2;
     try {
-      text = (0, import_node_fs23.readFileSync)(agentsFile, "utf8");
+      text2 = (0, import_node_fs25.readFileSync)(agentsFile, "utf8");
     } catch {
       continue;
     }
-    for (const line of text.split("\n")) {
+    for (const line of text2.split("\n")) {
       const trimmed = line.trim();
       if (!trimmed) continue;
       try {
@@ -9158,7 +9884,7 @@ function resolveConductorCursorAgentId(workspacePath) {
   return best?.agentId ?? null;
 }
 async function adoptThread(input) {
-  if (!(0, import_node_fs23.existsSync)(input.worktreePath)) {
+  if (!(0, import_node_fs25.existsSync)(input.worktreePath)) {
     throw new Error(`Worktree not found: ${input.worktreePath}`);
   }
   const repoPath = await resolveRepoRoot(input.worktreePath);
@@ -9182,18 +9908,18 @@ async function adoptThread(input) {
   return thread;
 }
 function listConductorWorkspaces() {
-  if (!(0, import_node_fs23.existsSync)(CONDUCTOR_DB)) {
+  if (!(0, import_node_fs25.existsSync)(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = (0, import_node_fs23.mkdtempSync)((0, import_node_path19.join)((0, import_node_os8.tmpdir)(), "sideboard-conductor-"));
-  const snapshot = (0, import_node_path19.join)(tmp, "conductor.db");
+  const tmp = (0, import_node_fs25.mkdtempSync)((0, import_node_path21.join)((0, import_node_os8.tmpdir)(), "sideboard-conductor-"));
+  const snapshot = (0, import_node_path21.join)(tmp, "conductor.db");
   try {
-    (0, import_node_fs23.copyFileSync)(CONDUCTOR_DB, snapshot);
+    (0, import_node_fs25.copyFileSync)(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if ((0, import_node_fs23.existsSync)(src)) {
+      if ((0, import_node_fs25.existsSync)(src)) {
         try {
-          (0, import_node_fs23.copyFileSync)(src, `${snapshot}${suffix}`);
+          (0, import_node_fs25.copyFileSync)(src, `${snapshot}${suffix}`);
         } catch {
         }
       }
@@ -9269,22 +9995,22 @@ function listConductorWorkspaces() {
       db.close();
     }
   } finally {
-    (0, import_node_fs23.rmSync)(tmp, { recursive: true, force: true });
+    (0, import_node_fs25.rmSync)(tmp, { recursive: true, force: true });
   }
 }
 function importConductorWorkspace(workspaceId) {
-  if (!(0, import_node_fs23.existsSync)(CONDUCTOR_DB)) {
+  if (!(0, import_node_fs25.existsSync)(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = (0, import_node_fs23.mkdtempSync)((0, import_node_path19.join)((0, import_node_os8.tmpdir)(), "sideboard-conductor-"));
-  const snapshot = (0, import_node_path19.join)(tmp, "conductor.db");
+  const tmp = (0, import_node_fs25.mkdtempSync)((0, import_node_path21.join)((0, import_node_os8.tmpdir)(), "sideboard-conductor-"));
+  const snapshot = (0, import_node_path21.join)(tmp, "conductor.db");
   try {
-    (0, import_node_fs23.copyFileSync)(CONDUCTOR_DB, snapshot);
+    (0, import_node_fs25.copyFileSync)(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if ((0, import_node_fs23.existsSync)(src)) {
+      if ((0, import_node_fs25.existsSync)(src)) {
         try {
-          (0, import_node_fs23.copyFileSync)(src, `${snapshot}${suffix}`);
+          (0, import_node_fs25.copyFileSync)(src, `${snapshot}${suffix}`);
         } catch {
         }
       }
@@ -9302,7 +10028,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_fs23.existsSync)(worktreePath)) {
+      if (!(0, import_node_fs25.existsSync)(worktreePath)) {
         throw new Error(`Conductor worktree missing on disk: ${worktreePath}`);
       }
       let sessionId = null;
@@ -9342,7 +10068,7 @@ function importConductorWorkspace(workspaceId) {
       }
       let repoPath = worktreePath;
       try {
-        repoPath = (0, import_node_child_process2.execFileSync)("git", ["rev-parse", "--show-toplevel"], {
+        repoPath = (0, import_node_child_process3.execFileSync)("git", ["rev-parse", "--show-toplevel"], {
           cwd: worktreePath,
           encoding: "utf8"
         }).trim();
@@ -9365,7 +10091,7 @@ function importConductorWorkspace(workspaceId) {
       db.close();
     }
   } finally {
-    (0, import_node_fs23.rmSync)(tmp, { recursive: true, force: true });
+    (0, import_node_fs25.rmSync)(tmp, { recursive: true, force: true });
   }
 }
 async function importConductorWorkspaceAsync(workspaceId) {
@@ -9373,7 +10099,7 @@ async function importConductorWorkspaceAsync(workspaceId) {
 }
 
 // src/threads/stack-layers.ts
-var import_node_fs24 = require("fs");
+var import_node_fs26 = require("fs");
 init_run();
 init_stack();
 init_worktree();
@@ -9441,7 +10167,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_fs24.existsSync)(checkedOut.path)) {
+  if (checkedOut?.path && (0, import_node_fs26.existsSync)(checkedOut.path)) {
     if (input.reuseExistingWorktree !== false) {
       worktreePath = checkedOut.path;
     } else {
@@ -9583,7 +10309,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_fs24.existsSync)(repoPath)) throw new Error(`Repo not found: ${repoPath}`);
+  if (!(0, import_node_fs26.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);
@@ -9650,7 +10376,7 @@ async function createPrStack(input, onSetupLine) {
     }
   }
   const claimed = new Set(threads.map((t) => t.worktreePath));
-  if (!claimed.has(bootstrap.worktreePath) && (0, import_node_fs24.existsSync)(bootstrap.worktreePath)) {
+  if (!claimed.has(bootstrap.worktreePath) && (0, import_node_fs26.existsSync)(bootstrap.worktreePath)) {
     try {
       await removeWorktree(repoPath, bootstrap.worktreePath, {
         deleteBranch: bootstrap.branchName
@@ -9665,12 +10391,12 @@ async function createPrStack(input, onSetupLine) {
 init_worktree();
 
 // src/diff/diff.ts
-var import_node_fs25 = require("fs");
-var import_node_path20 = require("path");
+var import_node_fs27 = require("fs");
+var import_node_path22 = require("path");
 init_run();
 init_worktree();
 async function inspectGitWorktree(worktreePath) {
-  if (!worktreePath || !(0, import_node_fs25.existsSync)(worktreePath)) return "missing_worktree";
+  if (!worktreePath || !(0, import_node_fs27.existsSync)(worktreePath)) return "missing_worktree";
   const check = await git(["rev-parse", "--is-inside-work-tree"], worktreePath, {
     reject: false
   });
@@ -9678,7 +10404,7 @@ async function inspectGitWorktree(worktreePath) {
   return "ok";
 }
 async function initializeGitRepository(worktreePath) {
-  if (!worktreePath || !(0, import_node_fs25.existsSync)(worktreePath)) {
+  if (!worktreePath || !(0, import_node_fs27.existsSync)(worktreePath)) {
     throw new Error("Worktree not found");
   }
   const status = await inspectGitWorktree(worktreePath);
@@ -9744,24 +10470,25 @@ function capPatch(patch, maxHunk) {
 
 \u2026 truncated (${patch.length - maxHunk} more chars)`;
 }
+var mergeBaseCache = /* @__PURE__ */ new Map();
+var MERGE_BASE_TTL_MS = 45e3;
 async function resolveMergeBase(worktreePath, base, repoPath) {
   const baseRef = await resolveDiffBaseRef(worktreePath, base, repoPath);
+  const cacheKey = `${worktreePath}\0${baseRef}`;
+  const hit = mergeBaseCache.get(cacheKey);
+  if (hit && Date.now() - hit.at < MERGE_BASE_TTL_MS) return hit.value;
   const { stdout } = await git(["merge-base", baseRef, "HEAD"], worktreePath, {
     reject: false
   });
-  const mb = stdout.trim();
-  return mb || baseRef;
+  const mb = stdout.trim() || baseRef;
+  mergeBaseCache.set(cacheKey, { at: Date.now(), value: mb });
+  return mb;
 }
 async function countUnpushedCommits(worktreePath) {
   const head = await git(["rev-parse", "--abbrev-ref", "HEAD"], worktreePath, {
     reject: false
   });
   const branch = head.stdout.trim();
-  if (branch && branch !== "HEAD") {
-    await git(["fetch", "origin", branch, "--quiet"], worktreePath, {
-      reject: false
-    });
-  }
   const upstream = await git(
     ["rev-list", "--count", "@{upstream}..HEAD"],
     worktreePath,
@@ -9794,11 +10521,37 @@ function splitCombinedDiff(stdout) {
   }
   return map;
 }
+function syntheticAddPatch(path, content, maxHunk) {
+  const lines = content.split("\n");
+  const body = lines.map((l) => `+${l}`).join("\n");
+  const header = `diff --git a/${path} b/${path}
+new file mode 100644
+--- /dev/null
++++ b/${path}
+@@ -0,0 +1,${lines.length} @@
+`;
+  return {
+    path,
+    status: "A",
+    patch: capPatch(`${header}${body}`, maxHunk),
+    additions: lines.length,
+    deletions: 0
+  };
+}
 async function untrackedPatch(worktreePath, path, maxHunk) {
+  const abs = (0, import_node_path22.join)(worktreePath, path);
+  try {
+    const st = (0, import_node_fs27.statSync)(abs);
+    if (st.isFile() && st.size > maxHunk) {
+      const buf = (0, import_node_fs27.readFileSync)(abs).subarray(0, maxHunk);
+      return syntheticAddPatch(path, buf.toString("utf8"), maxHunk);
+    }
+  } catch {
+  }
   const { stdout: patch } = await git(
-    ["diff", "--no-index", "--", "/dev/null", path],
+    ["diff", "--no-ext-diff", "--no-color", "--no-index", "--", "/dev/null", path],
     worktreePath,
-    { reject: false }
+    { reject: false, timeoutMs: 4e3 }
   );
   const normalized = patch.replace(/^diff --git a\/.+? b\/.+?$/m, `diff --git a/${path} b/${path}`).replace(/^--- .*$/m, "--- /dev/null").replace(/^\+\+\+ .*$/m, `+++ b/${path}`);
   const addLines = normalized.split("\n").filter((l) => l.startsWith("+") && !l.startsWith("+++")).length;
@@ -9810,22 +10563,97 @@ async function untrackedPatch(worktreePath, path, maxHunk) {
     deletions: 0
   };
 }
-async function listUntrackedPaths(worktreePath) {
-  const { stdout } = await git(
-    ["ls-files", "-z", "--others", "--exclude-standard"],
-    worktreePath,
-    { reject: false }
-  );
+async function listUntrackedPaths(worktreePath, path) {
+  const args = ["ls-files", "-z", "--others", "--exclude-standard"];
+  if (path) args.push("--", path);
+  const { stdout } = await git(args, worktreePath, { reject: false });
   return stdout.split("\0").filter(Boolean).filter((p) => !isSideboardScratchPath(p));
 }
-async function listUntrackedFiles(worktreePath, maxHunk) {
-  const paths = await listUntrackedPaths(worktreePath);
-  if (paths.length === 0) return [];
-  return Promise.all(paths.map((path) => untrackedPatch(worktreePath, path, maxHunk)));
+async function listUntrackedFiles(worktreePath, maxHunk, paths) {
+  const list = paths ?? await listUntrackedPaths(worktreePath);
+  if (list.length === 0) return [];
+  return Promise.all(list.map((path) => untrackedPatch(worktreePath, path, maxHunk)));
+}
+function untrackedStubs(paths) {
+  return paths.map((path) => ({
+    path,
+    status: "A",
+    patch: "",
+    additions: 0,
+    deletions: 0
+  }));
+}
+function pathspec(path) {
+  return path ? ["--", path] : [];
+}
+function gitDiff(args, cwd, opts) {
+  return git(["diff", "--no-ext-diff", "--no-color", ...args], cwd, {
+    reject: false,
+    timeoutMs: opts?.timeoutMs
+  });
+}
+function fileFromPatch(path, patch, maxHunk) {
+  let status = "M";
+  if (/^new file mode /m.test(patch) || /^--- \/dev\/null/m.test(patch)) {
+    status = "A";
+  } else if (/^deleted file mode /m.test(patch) || /^\+\+\+ \/dev\/null/m.test(patch)) {
+    status = "D";
+  } else if (/^rename from /m.test(patch)) {
+    status = "R";
+  }
+  const additions = patch.split("\n").filter((l) => l.startsWith("+") && !l.startsWith("+++")).length;
+  const deletions = patch.split("\n").filter((l) => l.startsWith("-") && !l.startsWith("---")).length;
+  return {
+    path,
+    status,
+    patch: capPatch(patch, maxHunk),
+    additions,
+    deletions
+  };
+}
+async function gitDiffParts(worktreePath, diffArgs, includePatches, path) {
+  const extra = pathspec(path);
+  if (includePatches) {
+    const diff = await gitDiff([...diffArgs, ...extra], worktreePath, {
+      timeoutMs: 4e3
+    });
+    return { nameStatus: "", numstat: "", combinedDiff: diff.stdout };
+  }
+  const [ns, num2] = await Promise.all([
+    gitDiff(["--name-status", ...diffArgs, ...extra], worktreePath),
+    gitDiff(["--numstat", ...diffArgs, ...extra], worktreePath)
+  ]);
+  return {
+    nameStatus: ns.stdout,
+    numstat: num2.stdout,
+    combinedDiff: ""
+  };
+}
+function formatStat(files) {
+  if (files.length === 0) return "(no changes)";
+  const additions = files.reduce((n2, f) => n2 + (f.additions ?? 0), 0);
+  const deletions = files.reduce((n2, f) => n2 + (f.deletions ?? 0), 0);
+  const n = files.length;
+  return `${n} file${n === 1 ? "" : "s"} changed, ${additions} insertions(+), ${deletions} deletions(-)`;
+}
+function emptyScopeStats() {
+  const z3 = emptyStat();
+  return {
+    commits: z3,
+    uncommitted: z3,
+    staged: z3,
+    unstaged: z3,
+    last_turn: z3
+  };
 }
 function filesFromDiff(nameStatus, numstat, combinedDiff, maxHunk) {
-  const counts = parseNumstat(numstat);
   const patches = splitCombinedDiff(combinedDiff);
+  if (!nameStatus.trim() && patches.size > 0) {
+    return [...patches.entries()].map(
+      ([path, patch]) => fileFromPatch(path, patch, maxHunk)
+    );
+  }
+  const counts = parseNumstat(numstat);
   const files = [];
   for (const { status, path } of parseNameStatus(nameStatus)) {
     const n = counts.get(path);
@@ -9847,11 +10675,11 @@ async function computeScopeStats(worktreePath, mergeBase, lastTurnBase, untracke
     { stdout: unstagedNum },
     lastTurnNum
   ] = await Promise.all([
-    mergeBase ? git(["diff", "--numstat", mergeBase], worktreePath, { reject: false }) : Promise.resolve({ stdout: "" }),
-    git(["diff", "--numstat", "HEAD"], worktreePath, { reject: false }),
-    git(["diff", "--numstat", "--cached"], worktreePath, { reject: false }),
-    git(["diff", "--numstat"], worktreePath, { reject: false }),
-    lastTurnBase ? git(["diff", "--numstat", lastTurnBase], worktreePath, { reject: false }) : Promise.resolve({ stdout: "" })
+    mergeBase ? gitDiff(["--numstat", mergeBase], worktreePath) : Promise.resolve({ stdout: "" }),
+    gitDiff(["--numstat", "HEAD"], worktreePath),
+    gitDiff(["--numstat", "--cached"], worktreePath),
+    gitDiff(["--numstat"], worktreePath),
+    lastTurnBase ? gitDiff(["--numstat", lastTurnBase], worktreePath) : Promise.resolve({ stdout: "" })
   ]);
   return {
     commits: mergeBase ? statFromNumstat(commitsNum, untrackedCount) : emptyStat(),
@@ -9870,7 +10698,7 @@ async function listBranchCommits(worktreePath, repoPath, opts) {
   if (head.exitCode !== 0) return [];
   let base = opts?.base;
   try {
-    base = base ?? await resolveDefaultBranch(repoPath);
+    base = base ?? await resolveDefaultBranch(repoPath, { network: false });
   } catch {
     base = "HEAD";
   }
@@ -9900,7 +10728,121 @@ async function listBranchCommits(worktreePath, repoPath, opts) {
   }
   return commits;
 }
+var SHA_RE = /^[0-9a-f]{7,40}$/i;
+function emptyPathDiff(scope, base, hasLastTurnBase, commitSha = null) {
+  return {
+    scope,
+    commitSha: scope === "commits" ? commitSha : null,
+    base,
+    files: [],
+    stat: formatStat([]),
+    dirty: false,
+    unpushed: 0,
+    hasLastTurnBase,
+    commits: [],
+    scopeStats: emptyScopeStats()
+  };
+}
+async function getPathDiff(worktreePath, repoPath, opts) {
+  const { path, scope, commitSha, lastTurnBase, hasLastTurnBase, includePatches, maxHunk } = opts;
+  if (scope === "last_turn" && !lastTurnBase) {
+    return emptyPathDiff(scope, "last turn", false);
+  }
+  let diffArgs;
+  let labelBase;
+  if (scope === "staged") {
+    diffArgs = ["--cached"];
+    labelBase = "staged";
+  } else if (scope === "unstaged") {
+    diffArgs = [];
+    labelBase = "unstaged";
+  } else if (scope === "uncommitted") {
+    diffArgs = ["HEAD"];
+    labelBase = "HEAD";
+  } else if (scope === "last_turn") {
+    diffArgs = [lastTurnBase];
+    labelBase = "last turn";
+  } else if (scope === "commits" && commitSha) {
+    diffArgs = [`${commitSha}^!`];
+    labelBase = commitSha.slice(0, 7);
+  } else if (scope === "commits" && opts.base && SHA_RE.test(opts.base)) {
+    diffArgs = [opts.base];
+    labelBase = opts.base.slice(0, 7);
+  } else if (scope === "commits") {
+    let base = opts.base;
+    try {
+      base = base ?? await resolveDefaultBranch(repoPath, { network: false });
+    } catch {
+      base = "HEAD";
+    }
+    const mergeBase = await resolveMergeBase(worktreePath, base, repoPath);
+    diffArgs = [mergeBase];
+    labelBase = mergeBase;
+  } else {
+    diffArgs = ["HEAD"];
+    labelBase = "HEAD";
+  }
+  const diff = await gitDiff(
+    includePatches ? [...diffArgs, "--", path] : ["--name-status", ...diffArgs, "--", path],
+    worktreePath,
+    { timeoutMs: 4e3 }
+  );
+  const filesMap = /* @__PURE__ */ new Map();
+  if (includePatches) {
+    const parsed = filesFromDiff("", "", diff.stdout, maxHunk);
+    for (const file of parsed) filesMap.set(file.path, file);
+    if (diff.stdout.trim() && !filesMap.has(path)) {
+      filesMap.set(path, fileFromPatch(path, diff.stdout, maxHunk));
+    }
+  } else {
+    for (const file of filesFromDiff(diff.stdout, "", "", maxHunk)) {
+      filesMap.set(file.path, file);
+    }
+  }
+  if (filesMap.size === 0) {
+    const maybe = await listUntrackedPaths(worktreePath, path);
+    if (maybe.length > 0) {
+      const extra = includePatches ? await listUntrackedFiles(worktreePath, maxHunk, maybe) : untrackedStubs(maybe);
+      for (const file of extra) filesMap.set(file.path, file);
+    }
+  }
+  const files = [...filesMap.values()].sort((a, b) => a.path.localeCompare(b.path));
+  return {
+    scope,
+    commitSha: scope === "commits" ? commitSha : null,
+    base: labelBase,
+    files,
+    stat: formatStat(files),
+    dirty: files.length > 0,
+    unpushed: 0,
+    hasLastTurnBase,
+    commits: [],
+    scopeStats: emptyScopeStats(),
+    mergeBase: SHA_RE.test(diffArgs[0] ?? "") ? diffArgs[0] : null
+  };
+}
 async function getDiff(worktreePath, repoPath, opts) {
+  const maxHunk = opts?.maxHunkChars ?? 8e3;
+  const scope = opts?.scope ?? "commits";
+  const lastTurnBase = opts?.lastTurnBase?.trim() || null;
+  const hasLastTurnBase = Boolean(lastTurnBase);
+  const commitSha = opts?.commitSha?.trim() || null;
+  const includePatches = opts?.includePatches ?? true;
+  const pathFilter = opts?.path?.trim() || null;
+  const fileOnly = Boolean(pathFilter);
+  const includeMeta = (opts?.includeMeta ?? true) && !fileOnly;
+  if (fileOnly && pathFilter && !includeMeta) {
+    return getPathDiff(worktreePath, repoPath, {
+      path: pathFilter,
+      scope,
+      commitSha,
+      lastTurnBase,
+      hasLastTurnBase,
+      base: opts?.base,
+      includePatches,
+      maxHunk
+    });
+  }
   const status = await inspectGitWorktree(worktreePath);
   if (status === "missing_worktree") {
     throw new Error("Worktree not found");
@@ -9908,18 +10850,19 @@ async function getDiff(worktreePath, repoPath, opts) {
   if (status === "not_git") {
     throw new Error("Not a Git repository");
   }
-  const maxHunk = opts?.maxHunkChars ?? 8e3;
-  const scope = opts?.scope ?? "commits";
-  const lastTurnBase = opts?.lastTurnBase?.trim() || null;
-  const hasLastTurnBase = Boolean(lastTurnBase);
-  const commitSha = opts?.commitSha?.trim() || null;
-  const head = await git(["rev-parse", "--verify", "HEAD"], worktreePath, {
+  const wantUntracked = opts?.includeUntracked !== void 0 ? opts.includeUntracked : !fileOnly && (scope === "commits" && !commitSha || scope === "uncommitted" || scope === "unstaged" || scope === "last_turn");
+  const needsMergeBase = scope === "commits" && !commitSha || includeMeta;
+  const headP = git(["rev-parse", "--verify", "HEAD"], worktreePath, {
     reject: false
   });
+  const untrackedP = wantUntracked ? listUntrackedPaths(worktreePath, pathFilter) : Promise.resolve([]);
+  const head = await headP;
   const hasHead = head.exitCode === 0;
-  const untrackedPaths = await listUntrackedPaths(worktreePath);
   if (!hasHead) {
-    const files2 = scope === "staged" ? [] : (await listUntrackedFiles(worktreePath, maxHunk)).sort(
+    const untrackedPaths2 = await untrackedP;
+    const files2 = scope === "staged" ? [] : includePatches ? (await listUntrackedFiles(worktreePath, maxHunk, untrackedPaths2)).sort(
+      (a, b) => a.path.localeCompare(b.path)
+    ) : untrackedStubs(untrackedPaths2).sort(
       (a, b) => a.path.localeCompare(b.path)
     );
     const untrackedStat = {
@@ -9933,7 +10876,7 @@ async function getDiff(worktreePath, repoPath, opts) {
       commitSha: null,
       base: "(no commits)",
       files: files2,
-      stat: files2.length ? files2.map((f) => ` ${f.path} | untracked`).join("\n") : "(no changes)",
+      stat: formatStat(files2),
       dirty: files2.length > 0,
       unpushed: 0,
       hasLastTurnBase,
@@ -9947,137 +10890,122 @@ async function getDiff(worktreePath, repoPath, opts) {
       }
     };
   }
-  let base = opts?.base;
-  try {
-    base = base ?? await resolveDefaultBranch(repoPath);
-  } catch {
-    base = "HEAD";
+  let mergeBase = "HEAD";
+  let baseLabel = "HEAD";
+  if (needsMergeBase) {
+    let base = opts?.base;
+    try {
+      base = base ?? await resolveDefaultBranch(repoPath, { network: false });
+    } catch {
+      base = "HEAD";
+    }
+    mergeBase = await resolveMergeBase(worktreePath, base, repoPath);
+    baseLabel = await resolveDiffBaseRef(worktreePath, base, repoPath);
   }
-  base = await resolveDiffBaseRef(worktreePath, base, repoPath);
-  if (base.startsWith("origin/")) {
-    const short = base.slice("origin/".length);
-    await git(["fetch", "origin", short, "--quiet"], worktreePath, {
-      reject: false
-    });
-    base = await resolveDiffBaseRef(worktreePath, short, repoPath);
+  const includeUntracked = wantUntracked;
+  const metaPromise = includeMeta ? Promise.all([
+    computeScopeStats(
+      worktreePath,
+      mergeBase,
+      lastTurnBase,
+      // Cheap: don't wait on the untracked walk just to pad the badge.
+      0
+    ),
+    listBranchCommits(worktreePath, repoPath, { base: baseLabel }),
+    isDirty(worktreePath),
+    countUnpushedCommits(worktreePath)
+  ]).then(([scopeStats, commits, dirty, unpushed]) => ({
+    scopeStats,
+    commits,
+    dirty,
+    unpushed
+  })) : Promise.resolve({
+    scopeStats: emptyScopeStats(),
+    commits: [],
+    dirty: false,
+    unpushed: 0
+  });
+  if (scope === "last_turn" && !lastTurnBase) {
+    const meta2 = await metaPromise;
+    return {
+      scope,
+      commitSha: null,
+      base: "last turn",
+      files: [],
+      stat: "(no last agent turn)",
+      dirty: meta2.dirty,
+      unpushed: meta2.unpushed,
+      hasLastTurnBase: false,
+      commits: meta2.commits,
+      scopeStats: meta2.scopeStats
+    };
   }
-  const mergeBase = await resolveMergeBase(worktreePath, base, repoPath);
-  const scopeStats = await computeScopeStats(
-    worktreePath,
-    mergeBase,
-    lastTurnBase,
-    untrackedPaths.length
-  );
-  const includeUntracked = scope === "commits" && !commitSha || scope === "uncommitted" || scope === "unstaged" || scope === "last_turn";
-  let nameStatus = "";
-  let numstat = "";
-  let combinedDiff = "";
-  let labelBase = base;
+  let diffArgs;
+  let labelBase = baseLabel;
   if (scope === "staged") {
-    const [ns, num2, diff] = await Promise.all([
-      git(["diff", "--name-status", "--cached"], worktreePath, { reject: false }),
-      git(["diff", "--numstat", "--cached"], worktreePath, { reject: false }),
-      git(["diff", "--cached"], worktreePath, { reject: false })
-    ]);
-    nameStatus = ns.stdout;
-    numstat = num2.stdout;
-    combinedDiff = diff.stdout;
+    diffArgs = ["--cached"];
     labelBase = "staged";
   } else if (scope === "unstaged") {
-    const [ns, num2, diff] = await Promise.all([
-      git(["diff", "--name-status"], worktreePath, { reject: false }),
-      git(["diff", "--numstat"], worktreePath, { reject: false }),
-      git(["diff"], worktreePath, { reject: false })
-    ]);
-    nameStatus = ns.stdout;
-    numstat = num2.stdout;
-    combinedDiff = diff.stdout;
+    diffArgs = [];
     labelBase = "unstaged";
   } else if (scope === "uncommitted") {
-    const [ns, num2, diff] = await Promise.all([
-      git(["diff", "--name-status", "HEAD"], worktreePath, { reject: false }),
-      git(["diff", "--numstat", "HEAD"], worktreePath, { reject: false }),
-      git(["diff", "HEAD"], worktreePath, { reject: false })
-    ]);
-    nameStatus = ns.stdout;
-    numstat = num2.stdout;
-    combinedDiff = diff.stdout;
+    diffArgs = ["HEAD"];
     labelBase = "HEAD";
   } else if (scope === "last_turn") {
-    if (!lastTurnBase) {
-      const commits2 = await listBranchCommits(worktreePath, repoPath, { base });
-      return {
-        scope,
-        commitSha: null,
-        base: "last turn",
-        files: [],
-        stat: "(no last agent turn)",
-        dirty: await isDirty(worktreePath),
-        unpushed: await countUnpushedCommits(worktreePath),
-        hasLastTurnBase: false,
-        commits: commits2,
-        scopeStats
-      };
-    }
-    const [ns, num2, diff] = await Promise.all([
-      git(["diff", "--name-status", lastTurnBase], worktreePath, { reject: false }),
-      git(["diff", "--numstat", lastTurnBase], worktreePath, { reject: false }),
-      git(["diff", lastTurnBase], worktreePath, { reject: false })
-    ]);
-    nameStatus = ns.stdout;
-    numstat = num2.stdout;
-    combinedDiff = diff.stdout;
+    diffArgs = [lastTurnBase];
     labelBase = "last turn";
   } else if (scope === "commits" && commitSha) {
-    const range = `${commitSha}^!`;
-    const [ns, num2, diff] = await Promise.all([
-      git(["diff", "--name-status", range], worktreePath, { reject: false }),
-      git(["diff", "--numstat", range], worktreePath, { reject: false }),
-      git(["diff", range], worktreePath, { reject: false })
-    ]);
-    nameStatus = ns.stdout;
-    numstat = num2.stdout;
-    combinedDiff = diff.stdout;
+    diffArgs = [`${commitSha}^!`];
     labelBase = commitSha.slice(0, 7);
   } else {
-    const [ns, num2, diff] = await Promise.all([
-      git(["diff", "--name-status", mergeBase], worktreePath, { reject: false }),
-      git(["diff", "--numstat", mergeBase], worktreePath, { reject: false }),
-      git(["diff", mergeBase], worktreePath, { reject: false })
-    ]);
-    nameStatus = ns.stdout;
-    numstat = num2.stdout;
-    combinedDiff = diff.stdout;
-    labelBase = base;
+    diffArgs = [mergeBase];
+    labelBase = baseLabel;
   }
-  const commits = await listBranchCommits(worktreePath, repoPath, { base });
+  const partsPromise = gitDiffParts(
+    worktreePath,
+    diffArgs,
+    includePatches,
+    pathFilter
+  );
+  const [parts, meta, untrackedPaths] = await Promise.all([
+    partsPromise,
+    metaPromise,
+    untrackedP
+  ]);
   const filesMap = /* @__PURE__ */ new Map();
-  for (const file of filesFromDiff(nameStatus, numstat, combinedDiff, maxHunk)) {
+  for (const file of filesFromDiff(
+    parts.nameStatus,
+    parts.numstat,
+    parts.combinedDiff,
+    maxHunk
+  )) {
     filesMap.set(file.path, file);
   }
   if (includeUntracked) {
-    const untrackedFiles = await listUntrackedFiles(worktreePath, maxHunk);
-    for (const file of untrackedFiles) {
+    const extra = includePatches ? await listUntrackedFiles(worktreePath, maxHunk, untrackedPaths) : untrackedStubs(untrackedPaths);
+    for (const file of extra) {
       if (!filesMap.has(file.path)) filesMap.set(file.path, file);
     }
+  } else if (fileOnly && pathFilter && !filesMap.has(pathFilter)) {
+    const maybe = await listUntrackedPaths(worktreePath, pathFilter);
+    if (maybe.length > 0) {
+      const extra = includePatches ? await listUntrackedFiles(worktreePath, maxHunk, maybe) : untrackedStubs(maybe);
+      for (const file of extra) filesMap.set(file.path, file);
+    }
   }
   const files = [...filesMap.values()].sort((a, b) => a.path.localeCompare(b.path));
-  const { stdout: statOut } = await git(
-    scope === "staged" ? ["diff", "--stat", "--cached"] : scope === "unstaged" ? ["diff", "--stat"] : scope === "uncommitted" ? ["diff", "--stat", "HEAD"] : scope === "last_turn" && lastTurnBase ? ["diff", "--stat", lastTurnBase] : scope === "commits" && commitSha ? ["diff", "--stat", `${commitSha}^!`] : ["diff", "--stat", mergeBase],
-    worktreePath,
-    { reject: false }
-  );
   return {
     scope,
     commitSha: scope === "commits" ? commitSha : null,
     base: labelBase,
     files,
-    stat: statOut.trim() || (files.length ? `${files.length} file(s)` : "(no changes)"),
-    dirty: await isDirty(worktreePath),
-    unpushed: await countUnpushedCommits(worktreePath),
+    stat: formatStat(files),
+    dirty: fileOnly || !includeMeta ? files.length > 0 : meta.dirty,
+    unpushed: meta.unpushed,
     hasLastTurnBase,
-    commits,
-    scopeStats
+    commits: meta.commits,
+    scopeStats: meta.scopeStats,
+    mergeBase: needsMergeBase ? mergeBase : null
   };
 }
 async function listWorktreeFiles(worktreePath, opts) {
@@ -10115,8 +11043,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_fs25.statSync)(abs);
+  const abs = (0, import_node_path22.join)(worktreePath, relativePath);
+  const st = (0, import_node_fs27.statSync)(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
@@ -10125,7 +11053,7 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
       `File too large to upload (${st.size} bytes; max ${maxBytes})`
     );
   }
-  const buf = (0, import_node_fs25.readFileSync)(abs);
+  const buf = (0, import_node_fs27.readFileSync)(abs);
   return {
     path: relativePath,
     contentBase64: buf.toString("base64"),
@@ -10135,12 +11063,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_fs25.statSync)(abs);
+  const abs = (0, import_node_path22.join)(worktreePath, relativePath);
+  const st = (0, import_node_fs27.statSync)(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
-  const buf = (0, import_node_fs25.readFileSync)(abs);
+  const buf = (0, import_node_fs27.readFileSync)(abs);
   if (isImageRelativePath(relativePath)) {
     const maxImageBytes = Math.max(maxBytes, 15e6);
     const truncated2 = buf.length > maxImageBytes;
@@ -10183,9 +11111,9 @@ function assertSafeRelativePath(relativePath) {
 }
 function writeWorktreeFile(worktreePath, relativePath, content) {
   assertSafeRelativePath(relativePath);
-  const abs = (0, import_node_path20.join)(worktreePath, relativePath);
-  (0, import_node_fs25.mkdirSync)((0, import_node_path20.dirname)(abs), { recursive: true });
-  (0, import_node_fs25.writeFileSync)(abs, content, "utf8");
+  const abs = (0, import_node_path22.join)(worktreePath, relativePath);
+  (0, import_node_fs27.mkdirSync)((0, import_node_path22.dirname)(abs), { recursive: true });
+  (0, import_node_fs27.writeFileSync)(abs, content, "utf8");
   return { path: relativePath };
 }
 async function getDiffSummary(worktreePath, repoPath, opts) {
@@ -10364,9 +11292,9 @@ async function confirmLand(thread, opts) {
 }
 
 // src/skills/discover.ts
-var import_node_fs26 = require("fs");
+var import_node_fs28 = require("fs");
 var import_node_os9 = require("os");
-var import_node_path21 = require("path");
+var import_node_path23 = require("path");
 function toCommand(name) {
   return name.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }
@@ -10398,7 +11326,7 @@ function parseFrontmatter(content) {
 }
 function readSkill(skillMd, source) {
   try {
-    const content = (0, import_node_fs26.readFileSync)(skillMd, "utf8");
+    const content = (0, import_node_fs28.readFileSync)(skillMd, "utf8");
     const { name: fmName, description } = parseFrontmatter(content);
     const dirName = skillMd.split("/").slice(-2, -1)[0] || "skill";
     const name = fmName || dirName;
@@ -10417,19 +11345,19 @@ function readSkill(skillMd, source) {
   }
 }
 function scanSkillsDir(dir, source, out) {
-  if (!(0, import_node_fs26.existsSync)(dir)) return;
+  if (!(0, import_node_fs28.existsSync)(dir)) return;
   let entries;
   try {
-    entries = (0, import_node_fs26.readdirSync)(dir);
+    entries = (0, import_node_fs28.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_fs26.existsSync)(skillMd)) continue;
+    const skillMd = (0, import_node_path23.join)(dir, entry, "SKILL.md");
+    if (!(0, import_node_fs28.existsSync)(skillMd)) continue;
     try {
-      if (!(0, import_node_fs26.statSync)(skillMd).isFile()) continue;
+      if (!(0, import_node_fs28.statSync)(skillMd).isFile()) continue;
     } catch {
       continue;
     }
@@ -10438,24 +11366,24 @@ function scanSkillsDir(dir, source, out) {
   }
 }
 function scanClaudePluginSkills(pluginsRoot, out) {
-  if (!(0, import_node_fs26.existsSync)(pluginsRoot)) return;
+  if (!(0, import_node_fs28.existsSync)(pluginsRoot)) return;
   const walk = (dir, depth, lookingForSkillsDir) => {
     if (depth > 7) return;
     let entries;
     try {
-      entries = (0, import_node_fs26.readdirSync)(dir);
+      entries = (0, import_node_fs28.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_path23.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_path23.join)(dir, entry);
       try {
-        if (!(0, import_node_fs26.statSync)(full).isDirectory()) continue;
+        if (!(0, import_node_fs28.statSync)(full).isDirectory()) continue;
       } catch {
         continue;
       }
@@ -10473,17 +11401,17 @@ function discoverSkills(worktreePath) {
   const home = (0, import_node_os9.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_path23.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_path23.join)(home, ".claude/skills"),
+    (0, import_node_path23.join)(home, ".cursor/skills"),
+    (0, import_node_path23.join)(home, ".sideboard/skills"),
+    (0, import_node_path23.join)(home, ".brightsy/skills")
   ]) {
     scanSkillsDir(abs, "user", collected);
   }
-  scanClaudePluginSkills((0, import_node_path21.join)(home, ".claude/plugins"), collected);
+  scanClaudePluginSkills((0, import_node_path23.join)(home, ".claude/plugins"), collected);
   const rank = { workspace: 0, user: 1, cli: 2 };
   const byCommand = /* @__PURE__ */ new Map();
   for (const skill of collected) {
@@ -10495,7 +11423,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_fs26.readFileSync)(skillPath, "utf8");
+  const raw = (0, import_node_fs28.readFileSync)(skillPath, "utf8");
   if (raw.startsWith("---")) {
     const end = raw.indexOf("\n---", 3);
     if (end >= 0) {
@@ -10588,9 +11516,9 @@ function expandComposerPrompt(worktreePath, prompt, opts) {
 }
 
 // src/composer/stage-files.ts
-var import_node_fs27 = require("fs");
-var import_node_path22 = require("path");
-var import_node_crypto5 = require("crypto");
+var import_node_fs29 = require("fs");
+var import_node_path24 = require("path");
+var import_node_crypto7 = require("crypto");
 init_workspace_scratch();
 var IMAGE_EXTENSIONS2 = /* @__PURE__ */ new Set([
   "png",
@@ -10615,7 +11543,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_path24.basename)(filePath).toLowerCase();
   return base.includes(".") ? base.split(".").pop() || "" : "";
 }
 function isImageFilePath(filePath) {
@@ -10625,24 +11553,24 @@ 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_fs27.mkdirSync)(dir, { recursive: true });
-  const gi = (0, import_node_path22.join)(dir, ".gitignore");
-  if (!(0, import_node_fs27.existsSync)(gi)) {
-    (0, import_node_fs27.writeFileSync)(gi, attachmentsGitignoreBody(), "utf8");
+  const dir = (0, import_node_path24.join)(worktreePath, ATTACHMENTS_DIR);
+  (0, import_node_fs29.mkdirSync)(dir, { recursive: true });
+  const gi = (0, import_node_path24.join)(dir, ".gitignore");
+  if (!(0, import_node_fs29.existsSync)(gi)) {
+    (0, import_node_fs29.writeFileSync)(gi, attachmentsGitignoreBody(), "utf8");
   }
   return dir;
 }
 function uniqueAttachmentName(dir, originalName) {
   const safe = originalName.replace(/[/\\]/g, "_") || "file";
-  if (!(0, import_node_fs27.existsSync)((0, import_node_path22.join)(dir, safe))) return safe;
-  const ext = (0, import_node_path22.extname)(safe);
+  if (!(0, import_node_fs29.existsSync)((0, import_node_path24.join)(dir, safe))) return safe;
+  const ext = (0, import_node_path24.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_fs27.existsSync)((0, import_node_path22.join)(dir, candidate))) return candidate;
+    if (!(0, import_node_fs29.existsSync)((0, import_node_path24.join)(dir, candidate))) return candidate;
   }
-  return `${stem}-${(0, import_node_crypto5.randomUUID)()}${ext}`;
+  return `${stem}-${(0, import_node_crypto7.randomUUID)()}${ext}`;
 }
 function previewDataUrlFromBuf(filePath, buf) {
   if (!isImageFilePath(filePath)) return void 0;
@@ -10654,7 +11582,7 @@ function attachmentFromBuffer(name, buf, opts) {
   if (isImageFilePath(name)) {
     const pathHint = opts.path ? `\`${opts.path}\`` : opts.sourceLabel || name;
     return {
-      id: (0, import_node_crypto5.randomUUID)(),
+      id: (0, import_node_crypto7.randomUUID)(),
       name,
       kind: "file",
       path: opts.path,
@@ -10667,7 +11595,7 @@ function attachmentFromBuffer(name, buf, opts) {
   }
   if (buf.length > MAX_INLINE_BYTES) {
     return {
-      id: (0, import_node_crypto5.randomUUID)(),
+      id: (0, import_node_crypto7.randomUUID)(),
       name,
       kind: "file",
       path: opts.path,
@@ -10676,7 +11604,7 @@ function attachmentFromBuffer(name, buf, opts) {
   }
   if (buf.includes(0)) {
     return {
-      id: (0, import_node_crypto5.randomUUID)(),
+      id: (0, import_node_crypto7.randomUUID)(),
       name,
       kind: "file",
       path: opts.path,
@@ -10684,7 +11612,7 @@ function attachmentFromBuffer(name, buf, opts) {
     };
   }
   return {
-    id: (0, import_node_crypto5.randomUUID)(),
+    id: (0, import_node_crypto7.randomUUID)(),
     name,
     kind: "file",
     path: opts.path,
@@ -10696,19 +11624,19 @@ 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_path24.basename)(abs);
     try {
-      const st = (0, import_node_fs27.statSync)(abs);
+      const st = (0, import_node_fs29.statSync)(abs);
       if (!st.isFile()) continue;
       const name = uniqueAttachmentName(dir, originalName);
-      const destAbs = (0, import_node_path22.join)(dir, name);
-      (0, import_node_fs27.copyFileSync)(abs, destAbs);
+      const destAbs = (0, import_node_path24.join)(dir, name);
+      (0, import_node_fs29.copyFileSync)(abs, destAbs);
       const rel = `${ATTACHMENTS_DIR}/${name}`;
-      const buf = (0, import_node_fs27.readFileSync)(destAbs);
+      const buf = (0, import_node_fs29.readFileSync)(destAbs);
       out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
     } catch (err) {
       out.push({
-        id: (0, import_node_crypto5.randomUUID)(),
+        id: (0, import_node_crypto7.randomUUID)(),
         name: originalName,
         kind: "file",
         content: `(could not attach ${abs}: ${err instanceof Error ? err.message : String(err)})`
@@ -10726,13 +11654,13 @@ 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_fs27.writeFileSync)(destAbs, buf);
+      const destAbs = (0, import_node_path24.join)(dir, name);
+      (0, import_node_fs29.writeFileSync)(destAbs, buf);
       const rel = `${ATTACHMENTS_DIR}/${name}`;
       out.push(attachmentFromBuffer(name, buf, { path: rel }));
     } catch (err) {
       out.push({
-        id: (0, import_node_crypto5.randomUUID)(),
+        id: (0, import_node_crypto7.randomUUID)(),
         name: originalName,
         kind: "file",
         content: `(could not attach ${originalName}: ${err instanceof Error ? err.message : String(err)})`
@@ -10746,23 +11674,23 @@ function attachmentsFromWorktreePaths(worktreePath, relativePaths) {
   for (const rel of relativePaths) {
     if (!rel || rel.includes("..") || rel.startsWith("/")) {
       out.push({
-        id: (0, import_node_crypto5.randomUUID)(),
-        name: (0, import_node_path22.basename)(rel) || "file",
+        id: (0, import_node_crypto7.randomUUID)(),
+        name: (0, import_node_path24.basename)(rel) || "file",
         kind: "file",
         content: `(invalid path: ${rel})`
       });
       continue;
     }
-    const name = (0, import_node_path22.basename)(rel);
+    const name = (0, import_node_path24.basename)(rel);
     try {
-      const abs = (0, import_node_path22.join)(worktreePath, rel);
-      const st = (0, import_node_fs27.statSync)(abs);
+      const abs = (0, import_node_path24.join)(worktreePath, rel);
+      const st = (0, import_node_fs29.statSync)(abs);
       if (!st.isFile()) continue;
-      const buf = (0, import_node_fs27.readFileSync)(abs);
+      const buf = (0, import_node_fs29.readFileSync)(abs);
       out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
     } catch (err) {
       out.push({
-        id: (0, import_node_crypto5.randomUUID)(),
+        id: (0, import_node_crypto7.randomUUID)(),
         name,
         kind: "file",
         content: `(could not read ${rel}: ${err instanceof Error ? err.message : String(err)})`
@@ -10773,8 +11701,8 @@ function attachmentsFromWorktreePaths(worktreePath, relativePaths) {
 }
 
 // src/agents/instructions.ts
-var import_node_fs28 = require("fs");
-var import_node_path23 = require("path");
+var import_node_fs30 = require("fs");
+var import_node_path25 = require("path");
 init_worktree_labels();
 function normPath2(p) {
   return p.replace(/\/+$/, "");
@@ -11020,7 +11948,7 @@ var Orchestrator = class {
         }
         continue;
       }
-      if (!(0, import_node_fs31.existsSync)(thread.worktreePath)) {
+      if (!(0, import_node_fs33.existsSync)(thread.worktreePath)) {
         setStatus(thread.id, "broken", "Worktree missing on disk");
         this.emit({ type: "status_changed", threadId: thread.id, status: "broken" });
         continue;
@@ -11276,11 +12204,11 @@ var Orchestrator = class {
     return results;
   }
   /** Edit the text of a not-yet-started queued message. */
-  async editQueuedMessage(threadRef, index, text) {
+  async editQueuedMessage(threadRef, index, text2) {
     const thread = this.requireThread(threadRef);
     return withThreadLock(thread.id, async () => {
       const current = this.requireThread(thread.id);
-      const trimmed = text.trim();
+      const trimmed = text2.trim();
       if (!trimmed || index < 0 || index >= current.queue.length) {
         return current;
       }
@@ -11425,10 +12353,19 @@ var Orchestrator = class {
         attachments: sentAttachments ?? thread.attachments
       }
     );
-    const orchestrationReminder = isOrchestratorThread(thread) ? coordinatorTurnReminder({
-      parentId: threadId,
-      goal: thread.sourceRef || thread.title
-    }) : null;
+    const slackInbound = /^(Slack DM|Slack @mention)(?:\n|$)/.test(
+      expandedPrompt.trim()
+    );
+    const orchestrationReminder = isOrchestratorThread(thread) ? [
+      coordinatorTurnReminder({
+        parentId: threadId,
+        goal: thread.sourceRef || thread.title
+      }),
+      slackInbound ? [
+        "This turn is a Slack DM or @mention. Your reply is posted back in Slack \u2014 keep it concise. Sideboard signs it with this Mac's destination name; do not prefix the name yourself.",
+        SLACK_REPLY_FORMATTING
+      ].join("\n") : null
+    ].filter(Boolean).join("\n") : null;
     const artifactReminder = thread.agent !== "brightsy" ? [
       "Sideboard side column (important):",
       "There is no claude.ai Artifact tool here \u2014 that is normal.",
@@ -11488,7 +12425,9 @@ var Orchestrator = class {
           goal: fresh.sourceRef || fresh.title || "Orchestration",
           parentId: fresh.id,
           workspaces: inventory,
-          audience: "desktop"
+          audience: /^(Slack DM|Slack @mention)(?:\n|$)/.test(
+            expandedPrompt.trim()
+          ) ? "slack" : "desktop"
         });
       }
     }
@@ -12031,6 +12970,11 @@ var Orchestrator = class {
     return getDiff(thread.worktreePath, thread.repoPath, {
       scope: opts?.scope,
       commitSha: opts?.commitSha,
+      base: opts?.base,
+      includePatches: opts?.includePatches,
+      includeMeta: opts?.includeMeta,
+      includeUntracked: opts?.includeUntracked,
+      path: opts?.path,
       lastTurnBase: this.turnBaselines.get(thread.id) ?? null
     });
   }
@@ -12108,7 +13052,8 @@ var Orchestrator = class {
       isDraft: false,
       reviewDecision: null,
       baseRefName: "",
-      headRefName: ""
+      headRefName: "",
+      isInMergeQueue: false
     };
     await this.persistPrMetaAndMaybeArchive(thread, metaLike);
     return { url: metaLike.url, state };
@@ -12423,7 +13368,7 @@ var Orchestrator = class {
       this.emit({ type: "status_changed", threadId: restored2.id, status: restored2.status });
       return restored2;
     }
-    if (!(0, import_node_fs31.existsSync)(thread.worktreePath)) {
+    if (!(0, import_node_fs33.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();
@@ -12504,8 +13449,105 @@ init_worktree();
 init_run();
 init_app_settings();
 
-// src/integrations/linear.ts
+// src/integrations/linear-oauth.ts
+var import_node_crypto8 = require("crypto");
+var import_node_http = require("http");
 init_app_settings();
+
+// src/integrations/linear-app.ts
+var BAKED_LINEAR_CLIENT_ID = "39a15abc7ea5bea17c47f47f85ff5fd0";
+var BAKED_LINEAR_CLIENT_SECRET = "";
+
+// src/integrations/linear-oauth.ts
+var LINEAR_OAUTH_PORT = 19848;
+var LINEAR_OAUTH_REDIRECT = `http://127.0.0.1:${LINEAR_OAUTH_PORT}/callback`;
+var LINEAR_TOKEN = "https://api.linear.app/oauth/token";
+var REFRESH_SKEW_MS = 5 * 6e4;
+function linearOAuthCredentials() {
+  const settings = loadAppSettings();
+  const clientId = process.env.SIDEBOARD_LINEAR_CLIENT_ID?.trim() || settings.integrations.linearClientId?.trim() || BAKED_LINEAR_CLIENT_ID.trim();
+  const clientSecret = process.env.SIDEBOARD_LINEAR_CLIENT_SECRET?.trim() || settings.integrations.linearClientSecret?.trim() || BAKED_LINEAR_CLIENT_SECRET.trim();
+  if (!clientId) {
+    throw new Error(
+      `Linear browser sign-in needs a Linear OAuth app Client ID. Create one at linear.app/settings/api/applications/new with callback ${LINEAR_OAUTH_REDIRECT}, then set SIDEBOARD_LINEAR_CLIENT_ID (PKCE does not require a secret). You can still paste a personal API key.`
+    );
+  }
+  return { clientId, clientSecret };
+}
+function linearAuthorizationHeader(token) {
+  const t = token.trim();
+  if (!t) return t;
+  if (/^bearer\s+/i.test(t)) return t;
+  if (t.startsWith("lin_api_")) return t;
+  return `Bearer ${t}`;
+}
+async function exchangeLinearToken(body) {
+  const res = await fetch(LINEAR_TOKEN, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok || data.error || !data.access_token?.trim()) {
+    const detail = data.error_description || data.error || `HTTP ${res.status}`;
+    throw new Error(`Linear OAuth token exchange failed: ${detail}`);
+  }
+  return data;
+}
+async function persistLinearTokens(data, viewer) {
+  return saveLinearOAuth({
+    accessToken: data.access_token.trim(),
+    refreshToken: data.refresh_token?.trim(),
+    expiresIn: data.expires_in,
+    viewerName: viewer?.name,
+    organizationName: viewer?.organizationName
+  });
+}
+var refreshInFlight = null;
+async function refreshLinearAccessToken(refreshToken) {
+  const { clientId, clientSecret } = linearOAuthCredentials();
+  const body = new URLSearchParams({
+    grant_type: "refresh_token",
+    refresh_token: refreshToken,
+    client_id: clientId
+  });
+  if (clientSecret) body.set("client_secret", clientSecret);
+  try {
+    const data = await exchangeLinearToken(body);
+    await persistLinearTokens(data);
+    return data.access_token.trim();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (/invalid_grant|invalid_token|unauthorized/i.test(message)) {
+      disconnectLinearConnection();
+      throw new Error("Linear sign-in expired \u2014 connect again in Account settings");
+    }
+    throw err;
+  }
+}
+async function getLinearAuthToken(settings = loadAppSettings()) {
+  const access = settings.integrations.linearAccessToken?.trim() || "";
+  const refresh = settings.integrations.linearRefreshToken?.trim() || "";
+  const expiresAt = settings.integrations.linearTokenExpiresAt ?? 0;
+  const apiKey = settings.integrations.linearApiKey?.trim() || "";
+  if (access && (!refresh || Date.now() < expiresAt - REFRESH_SKEW_MS)) {
+    return access;
+  }
+  if (refresh) {
+    if (!refreshInFlight) {
+      refreshInFlight = refreshLinearAccessToken(refresh).finally(() => {
+        refreshInFlight = null;
+      });
+    }
+    return refreshInFlight.catch((err) => {
+      if (apiKey) return apiKey;
+      throw err;
+    });
+  }
+  return apiKey || null;
+}
+
+// src/integrations/linear.ts
 var LINEAR_GRAPHQL = "https://api.linear.app/graphql";
 var ASSIGNED_ISSUES_QUERY = `
 query SideboardAssignedIssues($first: Int!) {
@@ -12527,16 +13569,16 @@ query SideboardAssignedIssues($first: Int!) {
 }
 `;
 async function listLinearIssuesDirect(opts) {
-  const apiKey = (opts?.apiKey ?? getLinearApiKey())?.trim();
+  const apiKey = (opts?.apiKey ?? await getLinearAuthToken())?.trim();
   if (!apiKey) {
-    throw new Error("Linear is not connected \u2014 add an API key in Account settings");
+    throw new Error("Linear is not connected \u2014 sign in from Account settings");
   }
   const first = Math.max(1, Math.min(100, opts?.limit ?? 50));
   const res = await fetch(LINEAR_GRAPHQL, {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
-      Authorization: apiKey
+      Authorization: linearAuthorizationHeader(apiKey)
     },
     body: JSON.stringify({
       query: ASSIGNED_ISSUES_QUERY,
@@ -12633,6 +13675,647 @@ function mcpArchiveBlockedReason(thread) {
 
 // src/mcp/server.ts
 init_profile();
+
+// src/mcp/slack-tools.ts
+var import_zod = require("zod");
+
+// src/slack/api.ts
+var SLACK_API = "https://slack.com/api";
+var SlackApiError = class extends Error {
+  constructor(method, slackError) {
+    super(`Slack ${method}: ${slackError}`);
+    this.method = method;
+    this.slackError = slackError;
+    this.name = "SlackApiError";
+  }
+  method;
+  slackError;
+};
+async function slackApi(token, method, params, fetchImpl) {
+  const doFetch = fetchImpl ?? fetch;
+  const body = new URLSearchParams();
+  if (params) {
+    for (const [key, value] of Object.entries(params)) {
+      if (value === void 0) continue;
+      body.set(key, String(value));
+    }
+  }
+  const res = await doFetch(`${SLACK_API}/${method}`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body
+  });
+  const json = await res.json();
+  if (!json.ok) {
+    throw new SlackApiError(method, json.error || `HTTP ${res.status}`);
+  }
+  return json;
+}
+
+// src/slack/destination.ts
+function isChannelId(raw) {
+  return /^[CGD][A-Z0-9]+$/i.test(raw);
+}
+function isUserId(raw) {
+  return /^U[A-Z0-9]+$/i.test(raw);
+}
+function isEmail(raw) {
+  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(raw);
+}
+function normalizeSlackHandle(raw) {
+  let s = raw.trim();
+  const mention = s.match(/^<@([UW][A-Z0-9]+)(?:\|[^>]+)?>$/i);
+  if (mention?.[1]) return mention[1];
+  const channelMention = s.match(/^<#([CGD][A-Z0-9]+)(?:\|[^>]+)?>$/i);
+  if (channelMention?.[1]) return channelMention[1];
+  if (s.startsWith("#") || s.startsWith("@")) s = s.slice(1);
+  return s.trim();
+}
+async function listSlackUsers(token, opts) {
+  const query = opts?.query?.trim().toLowerCase() ?? "";
+  const limit = Math.min(200, Math.max(1, opts?.limit ?? 50));
+  const members = [];
+  let cursor;
+  do {
+    const data = await slackApi(
+      token,
+      "users.list",
+      {
+        limit: 200,
+        cursor: cursor || void 0
+      },
+      opts?.fetchImpl
+    );
+    for (const m of data.members ?? []) {
+      if (!m.id || m.deleted || m.is_bot) continue;
+      members.push(m);
+    }
+    cursor = data.response_metadata?.next_cursor?.trim() || void 0;
+  } while (cursor && members.length < 2e3);
+  const mapped = members.map((m) => ({
+    id: m.id,
+    name: m.name ?? m.id,
+    real_name: m.profile?.real_name,
+    display_name: m.profile?.display_name,
+    email: m.profile?.email
+  }));
+  const filtered = query ? mapped.filter((u) => {
+    const hay = [u.name, u.real_name, u.display_name, u.email, u.id].filter(Boolean).join(" ").toLowerCase();
+    return hay.includes(query);
+  }) : mapped;
+  return filtered.slice(0, limit);
+}
+async function findUserId(token, handle, fetchImpl) {
+  if (isUserId(handle)) {
+    return { id: handle, name: handle };
+  }
+  if (isEmail(handle)) {
+    try {
+      const data = await slackApi(
+        token,
+        "users.lookupByEmail",
+        { email: handle },
+        fetchImpl
+      );
+      if (data.user?.id) {
+        return {
+          id: data.user.id,
+          name: data.user.name ?? data.user.id,
+          real_name: data.user.profile?.real_name,
+          display_name: data.user.profile?.display_name,
+          email: data.user.profile?.email
+        };
+      }
+    } catch {
+    }
+  }
+  const users = await listSlackUsers(token, { query: handle, limit: 20, fetchImpl });
+  const exact = users.find(
+    (u) => u.name.toLowerCase() === handle.toLowerCase() || u.display_name?.toLowerCase() === handle.toLowerCase() || u.real_name?.toLowerCase() === handle.toLowerCase() || u.email?.toLowerCase() === handle.toLowerCase()
+  );
+  if (exact) return exact;
+  if (users.length === 1) return users[0];
+  if (users.length === 0) {
+    throw new Error(`No Slack user matching "${handle}"`);
+  }
+  throw new Error(
+    `Ambiguous Slack user "${handle}". Matches: ${users.slice(0, 5).map((u) => `${u.name} (${u.id})`).join(", ")}. Pass a user id (U\u2026) or use slack_list_users.`
+  );
+}
+async function openDmChannel(token, userId, fetchImpl) {
+  const data = await slackApi(
+    token,
+    "conversations.open",
+    { users: userId },
+    fetchImpl
+  );
+  const id = data.channel?.id?.trim();
+  if (!id) throw new Error(`Could not open Slack DM with user ${userId}`);
+  return id;
+}
+async function resolveChannelByName(token, name, fetchImpl) {
+  const data = await slackApi(
+    token,
+    "conversations.list",
+    {
+      types: "public_channel,private_channel",
+      exclude_archived: true,
+      limit: 200
+    },
+    fetchImpl
+  );
+  const match = (data.channels ?? []).find((c) => c.name?.toLowerCase() === name.toLowerCase());
+  if (!match?.id) throw new Error(`No Slack channel named #${name}`);
+  return match.id;
+}
+async function resolveSlackDestination(token, destination, opts) {
+  const raw = destination.trim();
+  if (!raw) throw new Error("destination is required");
+  const hadAt = raw.startsWith("@") || /^<@/i.test(raw);
+  const hadHash = raw.startsWith("#") || /^<#/i.test(raw);
+  const handle = normalizeSlackHandle(raw);
+  if (isChannelId(handle)) {
+    return {
+      channelId: handle,
+      kind: handle.toUpperCase().startsWith("D") ? "dm" : "channel",
+      label: handle
+    };
+  }
+  if (isUserId(handle) || hadAt || isEmail(handle)) {
+    const user = await findUserId(token, handle, opts?.fetchImpl);
+    if (opts?.forRead) {
+      const channelId2 = await openDmChannel(token, user.id, opts?.fetchImpl);
+      return {
+        channelId: channelId2,
+        kind: "user",
+        userId: user.id,
+        label: user.display_name || user.real_name || user.name
+      };
+    }
+    const channelId = await openDmChannel(token, user.id, opts?.fetchImpl);
+    return {
+      channelId,
+      kind: "user",
+      userId: user.id,
+      label: user.display_name || user.real_name || user.name
+    };
+  }
+  if (hadHash) {
+    const channelId = await resolveChannelByName(token, handle, opts?.fetchImpl);
+    return { channelId, kind: "channel", label: `#${handle}` };
+  }
+  try {
+    const channelId = await resolveChannelByName(token, handle, opts?.fetchImpl);
+    return { channelId, kind: "channel", label: `#${handle}` };
+  } catch (channelErr) {
+    try {
+      const user = await findUserId(token, handle, opts?.fetchImpl);
+      const channelId = await openDmChannel(token, user.id, opts?.fetchImpl);
+      return {
+        channelId,
+        kind: "user",
+        userId: user.id,
+        label: user.display_name || user.real_name || user.name
+      };
+    } catch {
+      throw channelErr;
+    }
+  }
+}
+
+// src/slack/github-link.ts
+function labelGithubUrl(url) {
+  const raw = url.trim();
+  if (!raw) return null;
+  let parsed;
+  try {
+    parsed = new URL(raw);
+  } catch {
+    return null;
+  }
+  if (!/(^|\.)github\.com$/i.test(parsed.hostname)) return null;
+  const path = parsed.pathname;
+  const hash = parsed.hash || "";
+  const pr = path.match(/\/([^/]+)\/([^/]+)\/pull\/(\d+)/i);
+  if (pr) {
+    const n = pr[3];
+    if (/#discussion_r\d+/i.test(hash) || /#pullrequestreview-\d+/i.test(hash)) {
+      return { kind: "comment", label: `PR #${n} comment`, url: raw };
+    }
+    if (/#issuecomment-\d+/i.test(hash)) {
+      return { kind: "comment", label: `PR #${n} comment`, url: raw };
+    }
+    return { kind: "pr", label: `PR #${n}`, url: raw };
+  }
+  const issueComment = path.match(/\/([^/]+)\/([^/]+)\/issues\/(\d+)/i);
+  if (issueComment && /#issuecomment-\d+/i.test(hash)) {
+    return { kind: "comment", label: `Issue #${issueComment[3]} comment`, url: raw };
+  }
+  const blob = path.match(/\/([^/]+)\/([^/]+)\/blob\/[^/]+\/(.+)$/i);
+  if (blob) {
+    const filePath = decodeURIComponent(blob[3]);
+    const fileName = filePath.split("/").pop() || filePath;
+    const line = hash.match(/^#L(\d+)(?:-L(\d+))?$/i);
+    if (line) {
+      const start = line[1];
+      const end = line[2];
+      const loc = end && end !== start ? `${start}-${end}` : start;
+      return { kind: "code", label: `${fileName}:${loc}`, url: raw };
+    }
+    return { kind: "code", label: fileName, url: raw };
+  }
+  return { kind: "other", label: "GitHub", url: raw };
+}
+function appendGithubLink(text2, githubUrl) {
+  const body = text2.trimEnd();
+  if (!githubUrl?.trim()) return body;
+  const labeled = labelGithubUrl(githubUrl);
+  if (!labeled) {
+    return body ? `${body}
+${githubUrl.trim()}` : githubUrl.trim();
+  }
+  const link = `<${labeled.url}|${labeled.label}>`;
+  return body ? `${body}
+${link}` : link;
+}
+
+// src/slack/outbound-watch.ts
+var import_node_fs34 = require("fs");
+var import_node_path29 = require("path");
+init_paths();
+init_private_file();
+init_secure_file();
+
+// src/slack/workspaces.ts
+var import_node_path28 = require("path");
+init_paths();
+init_secure_file();
+function storePath2() {
+  return (0, import_node_path28.join)(appDataDir(), "slack-workspaces.json");
+}
+function readStore2() {
+  try {
+    const path = storePath2();
+    const wasEncrypted = isSecureFileEncrypted(path);
+    const parsed = readSecureJson(path);
+    const workspaces = Array.isArray(parsed?.workspaces) ? parsed.workspaces : [];
+    if (workspaces.length > 0 && !wasEncrypted && resolveVaultKey()) {
+      writeSecureJson(path, { workspaces });
+    }
+    return workspaces;
+  } catch {
+    return [];
+  }
+}
+function toInfo(ws) {
+  return {
+    team_id: ws.team_id,
+    team_name: ws.team_name,
+    user_id: ws.user_id,
+    has_bot_token: Boolean(ws.bot_token),
+    has_user_token: Boolean(ws.user_token),
+    connected_at: ws.connected_at
+  };
+}
+function listSlackWorkspaces() {
+  return readStore2().map(toInfo).sort((a, b) => a.team_name.localeCompare(b.team_name));
+}
+function getSlackWorkspace(teamId) {
+  const id = teamId.trim();
+  if (!id) return null;
+  return readStore2().find(
+    (ws) => ws.team_id === id || ws.team_name.toLowerCase() === id.toLowerCase()
+  ) ?? null;
+}
+function slackTokenFor(ws, kind = "read") {
+  if (kind === "search") {
+    const token2 = ws.user_token?.trim();
+    if (!token2) {
+      throw new Error(
+        `Slack search needs a user token for ${ws.team_name}. Reconnect via Account \u2192 Slack (browser) or paste an xoxp- token.`
+      );
+    }
+    return token2;
+  }
+  const token = (kind === "write" ? ws.bot_token || ws.user_token : ws.user_token || ws.bot_token)?.trim();
+  if (!token) {
+    throw new Error(`Slack workspace ${ws.team_name} has no token`);
+  }
+  return token;
+}
+function requireSlackWorkspace(teamId) {
+  const ws = getSlackWorkspace(teamId);
+  if (!ws) {
+    const connected = listSlackWorkspaces();
+    const hint = connected.length === 0 ? "Connect a workspace in Account \u2192 Slack workspaces." : `Connected: ${connected.map((t) => `${t.team_name} (${t.team_id})`).join(", ")}`;
+    throw new Error(`Unknown Slack team_id "${teamId}". ${hint}`);
+  }
+  return ws;
+}
+
+// src/slack/outbound-watch.ts
+var MAX_WATCHES = 40;
+var WATCH_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+function storePath3() {
+  return (0, import_node_path29.join)(appDataDir(), "slack-outbound-watch.json");
+}
+function watchId(teamId, channelId, ts) {
+  return `${teamId}:${channelId}:${ts}`;
+}
+function slackArchiveUrl(channelId, ts) {
+  return `https://slack.com/archives/${channelId}/p${ts.replace(".", "")}`;
+}
+function readStore3() {
+  const path = storePath3();
+  if (!(0, import_node_fs34.existsSync)(path)) return [];
+  try {
+    const parsed = isSecureFileEncrypted(path) ? readSecureJson(path) : JSON.parse((0, import_node_fs34.readFileSync)(path, "utf8"));
+    return Array.isArray(parsed?.watches) ? parsed.watches : [];
+  } catch {
+    return [];
+  }
+}
+function writeStore2(watches) {
+  writePrivateFile(storePath3(), `${JSON.stringify({ watches }, null, 2)}
+`);
+  return watches;
+}
+function pruneWatches(watches, nowMs = Date.now()) {
+  const cutoff = nowMs - WATCH_TTL_MS;
+  const kept = watches.filter((w) => {
+    const posted = Date.parse(w.postedAt);
+    return Number.isFinite(posted) ? posted >= cutoff : true;
+  });
+  if (kept.length <= MAX_WATCHES) return kept;
+  return kept.slice().sort((a, b) => b.postedAt.localeCompare(a.postedAt)).slice(0, MAX_WATCHES);
+}
+function recordSlackOutboundWatch(input) {
+  const ts = input.ts.trim();
+  const channelId = input.channelId.trim();
+  const teamId = input.teamId.trim();
+  if (!ts || !channelId || !teamId) return null;
+  const owner = input.ownerUserId?.trim();
+  const toUser = input.toUserId?.trim();
+  if (toUser && owner && toUser === owner) return null;
+  const id = watchId(teamId, channelId, ts);
+  const next = {
+    id,
+    teamId,
+    channelId,
+    ts,
+    threadTs: input.threadTs?.trim() || ts,
+    kind: input.kind === "dm" ? "dm" : "channel",
+    toUserId: toUser,
+    toLabel: input.toLabel.trim() || toUser || channelId,
+    ownerUserId: owner,
+    postedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastSeenTs: ts,
+    unread: false,
+    permalink: slackArchiveUrl(channelId, ts)
+  };
+  const watches = pruneWatches(readStore3().filter((w) => w.id !== id));
+  watches.unshift(next);
+  writeStore2(pruneWatches(watches));
+  return next;
+}
+
+// src/mcp/slack-tools.ts
+function text(payload, isError = false) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
+    ...isError ? { isError: true } : {}
+  };
+}
+function fail(err) {
+  return text(
+    { error: err instanceof Error ? err.message : String(err) },
+    true
+  );
+}
+function registerSlackTools(server) {
+  server.tool(
+    "list_teams",
+    "List Slack workspaces connected in Sideboard Account settings. Each row is team_id + name. Pass team_id to slack_list_channels, slack_list_users, slack_search, slack_read, and slack_post.",
+    {},
+    async () => {
+      const teams = listSlackWorkspaces();
+      if (teams.length === 0) {
+        return text({
+          teams: [],
+          hint: "No Slack workspaces connected. Add one in Account \u2192 Slack workspaces (paste xoxb-/xoxp- or browser sign-in)."
+        });
+      }
+      return text({
+        teams: teams.map((t) => ({
+          team_id: t.team_id,
+          name: t.team_name,
+          search: t.has_user_token
+        }))
+      });
+    }
+  );
+  server.tool(
+    "slack_list_channels",
+    "List channels in a connected Slack workspace. Pass team_id from list_teams.",
+    {
+      team_id: import_zod.z.string(),
+      limit: import_zod.z.number().optional()
+    },
+    async ({ team_id, limit }) => {
+      try {
+        const ws = requireSlackWorkspace(team_id);
+        const token = slackTokenFor(ws, "read");
+        const data = await slackApi(token, "conversations.list", {
+          types: "public_channel,private_channel",
+          exclude_archived: true,
+          limit: Math.min(200, Math.max(1, limit ?? 100))
+        });
+        return text({
+          team_id: ws.team_id,
+          team_name: ws.team_name,
+          channels: (data.channels ?? []).map((c) => ({
+            id: c.id,
+            name: c.name,
+            private: Boolean(c.is_private),
+            member: Boolean(c.is_member)
+          }))
+        });
+      } catch (err) {
+        return fail(err);
+      }
+    }
+  );
+  server.tool(
+    "slack_list_users",
+    "List or search people in a connected Slack workspace (for DMs / @mentions). Pass team_id from list_teams. Optional query matches name, display name, real name, or email.",
+    {
+      team_id: import_zod.z.string(),
+      query: import_zod.z.string().optional(),
+      limit: import_zod.z.number().optional()
+    },
+    async ({ team_id, query, limit }) => {
+      try {
+        const ws = requireSlackWorkspace(team_id);
+        const token = slackTokenFor(ws, "read");
+        const users = await listSlackUsers(token, { query, limit });
+        return text({
+          team_id: ws.team_id,
+          team_name: ws.team_name,
+          query: query?.trim() || void 0,
+          users
+        });
+      } catch (err) {
+        return fail(err);
+      }
+    }
+  );
+  server.tool(
+    "slack_search",
+    "Search messages in a connected Slack workspace (needs a user token). Pass team_id from list_teams.",
+    {
+      team_id: import_zod.z.string(),
+      query: import_zod.z.string(),
+      count: import_zod.z.number().optional()
+    },
+    async ({ team_id, query, count }) => {
+      try {
+        const ws = requireSlackWorkspace(team_id);
+        const token = slackTokenFor(ws, "search");
+        const data = await slackApi(token, "search.messages", {
+          query,
+          count: Math.min(50, Math.max(1, count ?? 10)),
+          sort: "timestamp"
+        });
+        return text({
+          team_id: ws.team_id,
+          team_name: ws.team_name,
+          query,
+          matches: (data.messages?.matches ?? []).map((m) => ({
+            channel: m.channel?.name || m.channel?.id,
+            user: m.username || m.user,
+            ts: m.ts,
+            text: m.text,
+            permalink: m.permalink
+          }))
+        });
+      } catch (err) {
+        return fail(err);
+      }
+    }
+  );
+  server.tool(
+    "slack_read",
+    "Read recent messages in a Slack channel or DM, or a thread when ts is set. Pass team_id from list_teams and #channel, @user, or a C\u2026/D\u2026/U\u2026 id.",
+    {
+      team_id: import_zod.z.string(),
+      channel: import_zod.z.string(),
+      ts: import_zod.z.string().optional(),
+      limit: import_zod.z.number().optional()
+    },
+    async ({ team_id, channel, ts, limit }) => {
+      try {
+        const ws = requireSlackWorkspace(team_id);
+        const token = slackTokenFor(ws, "read");
+        const dest = await resolveSlackDestination(token, channel, { forRead: true });
+        const n = Math.min(100, Math.max(1, limit ?? 20));
+        if (ts?.trim()) {
+          const data2 = await slackApi(token, "conversations.replies", {
+            channel: dest.channelId,
+            ts: ts.trim(),
+            limit: n
+          });
+          return text({
+            team_id: ws.team_id,
+            channel: dest.channelId,
+            label: dest.label,
+            thread_ts: ts.trim(),
+            messages: data2.messages ?? []
+          });
+        }
+        const data = await slackApi(token, "conversations.history", {
+          channel: dest.channelId,
+          limit: n
+        });
+        return text({
+          team_id: ws.team_id,
+          channel: dest.channelId,
+          label: dest.label,
+          messages: data.messages ?? []
+        });
+      } catch (err) {
+        return fail(err);
+      }
+    }
+  );
+  server.tool(
+    "slack_post",
+    "Post a message to a Slack channel or DM (as the Sideboard bot). Pass team_id from list_teams. Use to or channel for #name, @user, or C\u2026/D\u2026/U\u2026 ids. Optional github_url appends a PR / code / comment link. Only notify when the user asks. Thread with thread_ts when set.",
+    {
+      team_id: import_zod.z.string(),
+      channel: import_zod.z.string().optional(),
+      to: import_zod.z.string().optional(),
+      text: import_zod.z.string(),
+      github_url: import_zod.z.string().optional(),
+      thread_ts: import_zod.z.string().optional()
+    },
+    async ({ team_id, channel, to, text: message, github_url, thread_ts }) => {
+      try {
+        const destRaw = (to ?? channel)?.trim();
+        if (!destRaw) {
+          return fail(new Error("slack_post needs `to` or `channel` (#name, @user, or Slack id)"));
+        }
+        const ws = requireSlackWorkspace(team_id);
+        const token = slackTokenFor(ws, "write");
+        const dest = await resolveSlackDestination(token, destRaw);
+        const body = appendGithubLink(message, github_url);
+        const data = await slackApi(
+          token,
+          "chat.postMessage",
+          {
+            channel: dest.channelId,
+            text: body,
+            thread_ts: thread_ts?.trim() || void 0,
+            unfurl_links: true,
+            unfurl_media: true
+          }
+        );
+        const postedTs = data.ts?.trim();
+        const postedChannel = (data.channel || dest.channelId).trim();
+        if (postedTs && postedChannel) {
+          try {
+            recordSlackOutboundWatch({
+              teamId: ws.team_id,
+              channelId: postedChannel,
+              ts: postedTs,
+              threadTs: thread_ts?.trim() || postedTs,
+              kind: dest.kind === "channel" ? "channel" : "dm",
+              toUserId: dest.userId,
+              toLabel: dest.label,
+              ownerUserId: ws.user_id
+            });
+          } catch {
+          }
+        }
+        return text({
+          ok: true,
+          team_id: ws.team_id,
+          channel: postedChannel,
+          label: dest.label,
+          kind: dest.kind,
+          user_id: dest.userId,
+          ts: postedTs
+        });
+      } catch (err) {
+        return fail(err);
+      }
+    }
+  );
+}
+
+// src/mcp/server.ts
 var MAX_ORCH_THREADS = 5;
 var CREATE_THREAD_TIMEOUT_MS = 9e4;
 function withTimeout(promise, ms, label) {
@@ -12697,7 +14380,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_path26.basename)(t.repoPath) || t.repoPath;
+        const repo = t.repoPath === GLOBAL_WORKSPACE_ID ? "Orchestration" : (0, import_node_path31.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 {
@@ -12708,7 +14391,7 @@ async function startMcpServer() {
   server.tool(
     "get_thread",
     "Get a compact thread summary by id/ref",
-    { ref: import_zod.z.string() },
+    { ref: import_zod2.z.string() },
     async ({ ref }) => {
       const t = orch.getThread(ref);
       if (!t) {
@@ -12737,14 +14420,14 @@ async function startMcpServer() {
     "present_artifact",
     "Show an HTML, SVG, markdown, or React document in Sideboard\u2019s Claude-style side column (desktop). Use instead of claude.ai\u2019s artifact tool \u2014 pass the full document content. Prefer type=html for interactive pages. For type=react, pass a single component module that `export default`s a component (JSX/TSX ok) \u2014 Sideboard bootstraps React/ReactDOM/Babel and renders it; only `react`/`react-dom` imports are available, no other npm packages.",
     {
-      title: import_zod.z.string().describe("Short title shown in the artifact pane header"),
-      type: import_zod.z.enum(["html", "svg", "markdown", "react"]).describe(
+      title: import_zod2.z.string().describe("Short title shown in the artifact pane header"),
+      type: import_zod2.z.enum(["html", "svg", "markdown", "react"]).describe(
         "Artifact kind \u2014 html opens an iframe preview; react transpiles and renders a default-exported component in a sandboxed iframe"
       ),
-      content: import_zod.z.string().describe(
+      content: import_zod2.z.string().describe(
         "Full document body (complete HTML page, SVG markup, markdown, or a React component module with a default export)"
       ),
-      artifact_id: import_zod.z.string().optional().describe("Stable id when updating the same artifact across turns")
+      artifact_id: import_zod2.z.string().optional().describe("Stable id when updating the same artifact across turns")
     },
     async ({ title, type, artifact_id }) => {
       const id = artifact_id?.trim() || `artifact_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
@@ -12762,15 +14445,15 @@ async function startMcpServer() {
     "ask_user",
     "Ask the user clarifying multiple-choice questions in Sideboard\u2019s composer (plan mode). Before calling, write a short chat message explaining the decision and what each option means. Include a description on every option. Use for approach forks and requirements \u2014 not for \u201Cis the plan ready?\u201D. After calling, stop and wait for their next message with answers.",
     {
-      questions: import_zod.z.array(
-        import_zod.z.object({
-          question: import_zod.z.string().describe("Full question text ending with ?"),
-          header: import_zod.z.string().max(24).optional().describe("Short label shown above the question"),
-          multiSelect: import_zod.z.boolean().optional().describe("Allow selecting multiple options"),
-          options: import_zod.z.array(
-            import_zod.z.object({
-              label: import_zod.z.string(),
-              description: import_zod.z.string().optional().describe("What this option means / when to choose it (strongly preferred)")
+      questions: import_zod2.z.array(
+        import_zod2.z.object({
+          question: import_zod2.z.string().describe("Full question text ending with ?"),
+          header: import_zod2.z.string().max(24).optional().describe("Short label shown above the question"),
+          multiSelect: import_zod2.z.boolean().optional().describe("Allow selecting multiple options"),
+          options: import_zod2.z.array(
+            import_zod2.z.object({
+              label: import_zod2.z.string(),
+              description: import_zod2.z.string().optional().describe("What this option means / when to choose it (strongly preferred)")
             })
           ).min(2).max(6).describe("2\u20136 choices (Sideboard also offers Other)")
         })
@@ -12789,9 +14472,9 @@ async function startMcpServer() {
     "present_plan",
     "Save the implementation plan as markdown to .context/attachments/plan.md and show it in Sideboard chat for user approval (Copy / Hand off / Approve). Call this when the plan is ready \u2014 required in plan mode. Pass the full plan body in content. Then Claude should call ExitPlanMode.",
     {
-      title: import_zod.z.string().optional().describe("Short plan title (defaults to Plan)"),
-      content: import_zod.z.string().min(1).describe("Full plan markdown (headings, steps, risks, open questions)"),
-      thread_id: import_zod.z.string().optional().describe("Sideboard thread id when cwd is not the worktree")
+      title: import_zod2.z.string().optional().describe("Short plan title (defaults to Plan)"),
+      content: import_zod2.z.string().min(1).describe("Full plan markdown (headings, steps, risks, open questions)"),
+      thread_id: import_zod2.z.string().optional().describe("Sideboard thread id when cwd is not the worktree")
     },
     async ({ title, content, thread_id }) => {
       const { writePlanFile: writePlanFile2 } = await Promise.resolve().then(() => (init_plan_file(), plan_file_exports));
@@ -12812,17 +14495,17 @@ async function startMcpServer() {
   );
   server.tool(
     "present_schema",
-    "Open Sideboard\u2019s schema-driven CMS side column (filterable table and/or form). Pass JSON Schema + schemaUi (Brightsy extensions supported). Use datasource=brightsy with resource_id (record type UUID) when logged into Brightsy; use datasource=inline with embedded resource/records for any other source.",
+    "Open Sideboard\u2019s schema-driven side column (filterable table and/or form). Pass JSON Schema + optional schemaUi. Prefer datasource=inline with embedded resource/records. Use datasource=brightsy with resource_id only when the user is logged into Brightsy.",
     {
-      title: import_zod.z.string().describe("Pane title"),
-      mode: import_zod.z.enum(["table", "form"]).optional().describe("table = list/filter records; form = edit one record"),
-      datasource: import_zod.z.enum(["brightsy", "inline"]).optional().describe("brightsy resolves via login; inline uses embedded resource/records"),
-      resource_id: import_zod.z.string().optional().describe("Brightsy record type UUID (or generic resource id)"),
-      record_id: import_zod.z.string().optional().describe("Record id when opening form mode"),
-      resource: import_zod.z.record(import_zod.z.unknown()).optional().describe("Inline { id, title, schema, schemaUi?, slug? }"),
-      record: import_zod.z.record(import_zod.z.unknown()).optional().describe("Inline record { id, data, published_at? }"),
-      records: import_zod.z.array(import_zod.z.record(import_zod.z.unknown())).optional().describe("Inline records for table mode"),
-      pane_id: import_zod.z.string().optional().describe("Stable pane id across updates")
+      title: import_zod2.z.string().describe("Pane title"),
+      mode: import_zod2.z.enum(["table", "form"]).optional().describe("table = list/filter records; form = edit one record"),
+      datasource: import_zod2.z.enum(["brightsy", "inline"]).optional().describe("brightsy resolves via login; inline uses embedded resource/records"),
+      resource_id: import_zod2.z.string().optional().describe("Brightsy record type UUID (or generic resource id)"),
+      record_id: import_zod2.z.string().optional().describe("Record id when opening form mode"),
+      resource: import_zod2.z.record(import_zod2.z.unknown()).optional().describe("Inline { id, title, schema, schemaUi?, slug? }"),
+      record: import_zod2.z.record(import_zod2.z.unknown()).optional().describe("Inline record { id, data, published_at? }"),
+      records: import_zod2.z.array(import_zod2.z.record(import_zod2.z.unknown())).optional().describe("Inline records for table mode"),
+      pane_id: import_zod2.z.string().optional().describe("Stable pane id across updates")
     },
     async (args) => {
       const id = args.pane_id?.trim() || `schema_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
@@ -12843,10 +14526,10 @@ async function startMcpServer() {
     "present_files",
     "Open Sideboard\u2019s Files column (CMS-style file manager: browse, upload, pick). Use datasource=brightsy when the user is logged into Brightsy account storage; datasource=memory for a session-local demo store. Prefer this over claiming a file manager UI is unavailable. Pair with present_schema when editing records that need media.",
     {
-      title: import_zod.z.string().optional().describe("Pane title (default: Files)"),
-      datasource: import_zod.z.enum(["brightsy", "memory"]).optional().describe("brightsy = account storage via login; memory = session demo store"),
-      path: import_zod.z.string().optional().describe("Initial folder path (e.g. public)"),
-      pane_id: import_zod.z.string().optional().describe("Stable pane id across updates")
+      title: import_zod2.z.string().optional().describe("Pane title (default: Files)"),
+      datasource: import_zod2.z.enum(["brightsy", "memory"]).optional().describe("brightsy = account storage via login; memory = session demo store"),
+      path: import_zod2.z.string().optional().describe("Initial folder path (e.g. public)"),
+      pane_id: import_zod2.z.string().optional().describe("Stable pane id across updates")
     },
     async (args) => {
       const id = args.pane_id?.trim() || `files_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
@@ -12861,23 +14544,62 @@ async function startMcpServer() {
       return { content: [{ type: "text", text: JSON.stringify(payload) }] };
     }
   );
+  registerSlackTools(server);
   if (sideboardMcpProfile() !== "worktree") {
+    const { getCaffeinateHold: getCaffeinateHold2, setCaffeinateHold: setCaffeinateHold2 } = await Promise.resolve().then(() => (init_caffeinate_hold(), caffeinate_hold_exports));
     const { resolveNewThreadOptions: resolveNewThreadOptions2, resolveThreadDefaults: resolveThreadDefaults2 } = await Promise.resolve().then(() => (init_app_settings(), app_settings_exports));
     const accountDefaults = resolveThreadDefaults2();
     const accountDefaultsHint = `Account defaults: agent=${accountDefaults.agent}, model=${accountDefaults.model?.trim() || "Auto"}, effort=${accountDefaults.effort}`;
+    server.tool(
+      "set_caffeinate",
+      "Keep this Mac awake with caffeinate (like Claude Code) across turns \u2014 independent of Settings toggles. Turn ON when the user will be away from the keyboard, is driving work from Slack, or asks you to keep the machine awake. Turn OFF when they say they are done, wrapping up, going to sleep, or no longer need the Mac awake. macOS only.",
+      {
+        enabled: import_zod2.z.boolean().describe("true = hold caffeinate on; false = release and let the Mac sleep")
+      },
+      async ({ enabled }) => {
+        const state = setCaffeinateHold2(enabled);
+        if (enabled && !state.held) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  ...state,
+                  ok: false,
+                  message: state.platform === "darwin" ? "Could not start caffeinate." : "Caffeinate is macOS only."
+                })
+              }
+            ],
+            isError: true
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                ...getCaffeinateHold2(),
+                ok: true,
+                message: state.held ? "Mac will stay awake until you call set_caffeinate with enabled=false (or the user says they are done)." : "Caffeinate hold released. The Mac can sleep (unless Settings caffeinate toggles are on)."
+              })
+            }
+          ]
+        };
+      }
+    );
     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.`,
       {
-        sourceType: import_zod.z.enum(["branch", "pr", "ticket"]),
-        sourceRef: import_zod.z.string(),
-        agent: import_zod.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"]).optional().describe(`Omit to use Account default agent (${accountDefaults.agent})`),
-        model: import_zod.z.string().nullable().optional().describe(
+        sourceType: import_zod2.z.enum(["branch", "pr", "ticket"]),
+        sourceRef: import_zod2.z.string(),
+        agent: import_zod2.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"]).optional().describe(`Omit to use Account default agent (${accountDefaults.agent})`),
+        model: import_zod2.z.string().nullable().optional().describe(
           `Usually omit to use Account default model (${accountDefaults.model?.trim() || "Auto"}). Pass null only to force Auto / agent-default.`
         ),
-        repoPath: import_zod.z.string(),
-        title: import_zod.z.string().optional(),
-        parentThreadId: import_zod.z.string().optional().describe(
+        repoPath: import_zod2.z.string(),
+        title: import_zod2.z.string().optional(),
+        parentThreadId: import_zod2.z.string().optional().describe(
           "Orchestration: omit (preferred) or pass YOUR chat id from the turn reminder / AGENTS.md. Do not invent uuids."
         )
       },
@@ -12984,9 +14706,9 @@ async function startMcpServer() {
       "send_to_thread",
       "Queue a prompt on a worktree thread chat (runs under concurrency cap). Use after create_thread to start or continue a conversation. Set force_stop=true to interrupt an in-flight/queued turn (kill + clear queue) before queueing this prompt \u2014 use when the thread is mid-turn or has stale queued prompts you need to replace.",
       {
-        ref: import_zod.z.string(),
-        prompt: import_zod.z.string(),
-        force_stop: import_zod.z.boolean().optional()
+        ref: import_zod2.z.string(),
+        prompt: import_zod2.z.string(),
+        force_stop: import_zod2.z.boolean().optional()
       },
       async ({ ref, prompt, force_stop }) => {
         if (force_stop) {
@@ -13015,8 +14737,8 @@ async function startMcpServer() {
       "wait_for_turn",
       "Block until the thread finishes its current/queued turn (avoids polling). Use after send_to_thread to read the agent reply.",
       {
-        ref: import_zod.z.string(),
-        timeoutMs: import_zod.z.number().optional()
+        ref: import_zod2.z.string(),
+        timeoutMs: import_zod2.z.number().optional()
       },
       async ({ ref, timeoutMs }) => {
         const thread = await orch.waitForTurn(ref, timeoutMs ?? 6e5);
@@ -13038,7 +14760,7 @@ async function startMcpServer() {
     server.tool(
       "get_turn_result",
       "Final assistant message only (not full transcript)",
-      { ref: import_zod.z.string() },
+      { ref: import_zod2.z.string() },
       async ({ ref }) => {
         const result = orch.getTurnResult(ref);
         return { content: [{ type: "text", text: JSON.stringify(result) }] };
@@ -13048,8 +14770,8 @@ async function startMcpServer() {
       "stop_thread",
       "Force-stop a thread: kill any in-flight agent turn AND clear queued prompts so drainQueue cannot continue. Does not archive the worktree. Optional force defaults to true.",
       {
-        ref: import_zod.z.string(),
-        force: import_zod.z.boolean().optional()
+        ref: import_zod2.z.string(),
+        force: import_zod2.z.boolean().optional()
       },
       async ({ ref, force }) => {
         const t = orch.getThread(ref);
@@ -13078,8 +14800,8 @@ async function startMcpServer() {
     );
     server.tool(
       "archive_thread",
-      "Archive a thread (stops agent/dev, runs archive script, removes worktree when last chat tab). Cannot archive the cloud coordinator \u2014 use the Sideboard UI for that.",
-      { ref: import_zod.z.string() },
+      "Archive a thread (stops agent/dev, runs archive script, removes worktree when last chat tab). Coordinators open PRs only by asking the worktree agent.",
+      { ref: import_zod2.z.string() },
       async ({ ref }) => {
         const t = orch.getThread(ref);
         if (!t) {
@@ -13112,7 +14834,7 @@ async function startMcpServer() {
     server.tool(
       "restore_thread",
       "Restore an archived thread (recreates worktree from branch when needed)",
-      { ref: import_zod.z.string() },
+      { ref: import_zod2.z.string() },
       async ({ ref }) => {
         try {
           const restored = await orch.restore(ref);
@@ -13138,8 +14860,8 @@ async function startMcpServer() {
       "get_diff",
       "Compact diff summary (capped hunks, paginated)",
       {
-        ref: import_zod.z.string(),
-        maxFiles: import_zod.z.number().optional()
+        ref: import_zod2.z.string(),
+        maxFiles: import_zod2.z.number().optional()
       },
       async ({ ref, maxFiles }) => {
         const summary = await orch.diffSummary(ref);
@@ -13159,7 +14881,7 @@ async function startMcpServer() {
     server.tool(
       "request_review",
       'Start a merge-readiness Review on a worktree agent thread (same as the desktop Review button). Opens a new Review chat tab, attaches .sideboard/review.md when present (else local Review request.md / stock template), and sends "Review changes in this workspace." Expect Approve / Approve with nits / Request changes / Needs more information. Pass a worktree thread ref \u2014 not the orchestrator. Then wait_for_turn / get_turn_result on the returned review tab id.',
-      { ref: import_zod.z.string().describe("Worktree thread id/ref to review") },
+      { ref: import_zod2.z.string().describe("Worktree thread id/ref to review") },
       async ({ ref }) => {
         try {
           const tab = await orch.requestReview(ref);
@@ -13184,7 +14906,7 @@ async function startMcpServer() {
         }
       }
     );
-    const agentEnum = import_zod.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"]);
+    const agentEnum = import_zod2.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"]);
     server.tool(
       "list_models",
       "List models for an agent. Prefer Auto: do not call this unless you have a reason to pin a specific model (user request, cost/latency, capability). Omit agent to list all.",
@@ -13207,11 +14929,11 @@ async function startMcpServer() {
       "fork_worktree",
       "Fork a worktree agent chat into a NEW git worktree + chat (desktop \u201CFork to new workspace\u201D). Seeds a transcript (through through_index, default all). Optional agent override. Leave model unset for Auto (default) \u2014 only pass model when you have a reason. Not for the orchestrator. Then send_to_thread / wait_for_turn on the returned id.",
       {
-        ref: import_zod.z.string().describe("Worktree thread id/ref to fork"),
-        through_index: import_zod.z.number().optional().describe("Inclusive message index to include in the transcript (default: all)"),
+        ref: import_zod2.z.string().describe("Worktree thread id/ref to fork"),
+        through_index: import_zod2.z.number().optional().describe("Inclusive message index to include in the transcript (default: all)"),
         agent: agentEnum.optional().describe("Agent for the forked chat (default: same as source)"),
-        model: import_zod.z.string().nullable().optional().describe("Usually omit (Auto). Only set from list_models when you need a specific model"),
-        title: import_zod.z.string().optional()
+        model: import_zod2.z.string().nullable().optional().describe("Usually omit (Auto). Only set from list_models when you need a specific model"),
+        title: import_zod2.z.string().optional()
       },
       async ({ ref, through_index, agent, model, title }) => {
         try {
@@ -13250,13 +14972,13 @@ async function startMcpServer() {
     );
     server.tool(
       "fork_chat",
-      "Fork a chat into a NEW tab on the SAME workspace: worktree agent \u2192 same worktree tab; Global orchestration chat \u2192 new orchestration chat (same synthetic home). Seeds a transcript; optional agent override. Leave model unset for Auto unless you have a reason. Orchestration forks require an MCP-capable agent (claude, cursor, codex, opencode \u2014 not brightsy). Remote coordinators use this to continue an orchestration chat on another agent after session limits. Then send_to_thread / wait_for_turn on the returned id. Use fork_worktree only for worktree agents that need a new git worktree.",
+      "Fork a chat into a NEW tab on the SAME workspace: worktree agent \u2192 same worktree tab; Global orchestration chat \u2192 new orchestration chat (same synthetic home). Seeds a transcript; optional agent override. Leave model unset for Auto unless you have a reason. Orchestration forks require an MCP-capable agent (claude, cursor, codex, opencode \u2014 not brightsy). Slack / Global orchestrators use this to continue an orchestration chat on another agent after session limits. Then send_to_thread / wait_for_turn on the returned id. Use fork_worktree only for worktree agents that need a new git worktree.",
       {
-        ref: import_zod.z.string().describe("Thread id/ref to fork (worktree agent or orchestration chat)"),
-        through_index: import_zod.z.number().optional().describe("Inclusive message index to include in the transcript (default: all)"),
+        ref: import_zod2.z.string().describe("Thread id/ref to fork (worktree agent or orchestration chat)"),
+        through_index: import_zod2.z.number().optional().describe("Inclusive message index to include in the transcript (default: all)"),
         agent: agentEnum.optional().describe("Agent for the forked chat (default: same as source)"),
-        model: import_zod.z.string().nullable().optional().describe("Usually omit (Auto). Only set from list_models when you need a specific model"),
-        title: import_zod.z.string().optional()
+        model: import_zod2.z.string().nullable().optional().describe("Usually omit (Auto). Only set from list_models when you need a specific model"),
+        title: import_zod2.z.string().optional()
       },
       async ({ ref, through_index, agent, model, title }) => {
         try {
@@ -13302,8 +15024,8 @@ async function startMcpServer() {
       "run_dev_script",
       "Start a .sideboard/.conductor run script for a thread (default script if name omitted); returns port",
       {
-        ref: import_zod.z.string(),
-        name: import_zod.z.string().optional()
+        ref: import_zod2.z.string(),
+        name: import_zod2.z.string().optional()
       },
       async ({ ref, name }) => {
         const result = await orch.startDev(ref, name);
@@ -13325,7 +15047,7 @@ async function startMcpServer() {
     server.tool(
       "list_run_scripts",
       "List named run scripts available for a thread",
-      { ref: import_zod.z.string() },
+      { ref: import_zod2.z.string() },
       async ({ ref }) => {
         const scripts = orch.listThreadRunScripts(ref);
         const active = orch.getActiveRuns(ref);
@@ -13343,8 +15065,8 @@ async function startMcpServer() {
       "stop_dev_script",
       "Stop a running script for a thread (all scripts if name omitted)",
       {
-        ref: import_zod.z.string(),
-        name: import_zod.z.string().optional()
+        ref: import_zod2.z.string(),
+        name: import_zod2.z.string().optional()
       },
       async ({ ref, name }) => {
         orch.stopDev(ref, name);
@@ -13354,7 +15076,7 @@ async function startMcpServer() {
     server.tool(
       "run_setup",
       "Re-run workspace setup (Sideboard/Conductor settings or .cursor/worktrees.json)",
-      { ref: import_zod.z.string() },
+      { ref: import_zod2.z.string() },
       async ({ ref }) => {
         const result = await orch.runSetup(ref);
         return {
@@ -13365,7 +15087,7 @@ async function startMcpServer() {
     server.tool(
       "add_workspace",
       "Register a git repo as a Sideboard workspace",
-      { repoPath: import_zod.z.string() },
+      { repoPath: import_zod2.z.string() },
       async ({ repoPath }) => {
         const ws = await orch.addWorkspace(repoPath);
         return { content: [{ type: "text", text: JSON.stringify(ws) }] };
@@ -13374,7 +15096,7 @@ async function startMcpServer() {
     server.tool(
       "remove_workspace",
       "Unregister a Sideboard workspace (does not archive threads)",
-      { repoPath: import_zod.z.string() },
+      { repoPath: import_zod2.z.string() },
       async ({ repoPath }) => {
         orch.removeWorkspace(repoPath);
         return { content: [{ type: "text", text: "ok" }] };
@@ -13384,12 +15106,12 @@ async function startMcpServer() {
       "fanout",
       "Best-of-n: create one thread per agent with the same prompt (parallel attempts)",
       {
-        prompt: import_zod.z.string(),
-        agents: import_zod.z.array(import_zod.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"])),
-        repoPath: import_zod.z.string(),
-        sourceType: import_zod.z.enum(["branch", "pr", "ticket"]).optional(),
-        sourceRef: import_zod.z.string().optional(),
-        title: import_zod.z.string().optional()
+        prompt: import_zod2.z.string(),
+        agents: import_zod2.z.array(import_zod2.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"])),
+        repoPath: import_zod2.z.string(),
+        sourceType: import_zod2.z.enum(["branch", "pr", "ticket"]).optional(),
+        sourceRef: import_zod2.z.string().optional(),
+        title: import_zod2.z.string().optional()
       },
       async (args) => {
         const threads = await orch.bestOfN(args);
@@ -13416,8 +15138,8 @@ async function startMcpServer() {
       "list_branches",
       "List git branches in a registered workspace. Pass repoPath from list_workspaces (unmerged into the default branch by default \u2014 for create_thread sourceType=branch).",
       {
-        repoPath: import_zod.z.string(),
-        unmergedOnly: import_zod.z.boolean().optional()
+        repoPath: import_zod2.z.string(),
+        unmergedOnly: import_zod2.z.boolean().optional()
       },
       async ({ repoPath, unmergedOnly }) => {
         const root = await resolveRepoRoot(repoPath);
@@ -13437,7 +15159,7 @@ async function startMcpServer() {
     server.tool(
       "list_prs",
       "List open GitHub PRs for a registered workspace. Pass repoPath from list_workspaces (uses gh against that repo remote). Then create_thread with sourceType=pr.",
-      { repoPath: import_zod.z.string() },
+      { repoPath: import_zod2.z.string() },
       async ({ repoPath }) => {
         const root = await resolveRepoRoot(repoPath);
         const prs = await listPrs(root);
@@ -13456,7 +15178,7 @@ async function startMcpServer() {
     server.tool(
       "get_pr_stack",
       "Load the GitHub PR stack for a thread worktree (`gh stack view --json`). Returns null JSON when the branch is not stacked. Prefer this before mergePr on stacked PRs.",
-      { ref: import_zod.z.string() },
+      { ref: import_zod2.z.string() },
       async ({ ref }) => {
         const stack = await orch.getPrStack(ref);
         return {
@@ -13468,8 +15190,8 @@ async function startMcpServer() {
       "open_pr_stack_layers",
       "Materialize one worktree+thread per stack layer (or a single 1-based layer). Pass a thread ref already on the stack.",
       {
-        ref: import_zod.z.string(),
-        layer: import_zod.z.number().int().positive().optional()
+        ref: import_zod2.z.string(),
+        layer: import_zod2.z.number().int().positive().optional()
       },
       async ({ ref, layer }) => {
         const result = await orch.openPrStackLayers(ref, { layer });
@@ -13503,9 +15225,9 @@ async function startMcpServer() {
       "add_stack_layer",
       "Add a branch on top of the current stack (`gh stack add`) and open a worktree+thread for it.",
       {
-        ref: import_zod.z.string(),
-        branchName: import_zod.z.string(),
-        title: import_zod.z.string().optional()
+        ref: import_zod2.z.string(),
+        branchName: import_zod2.z.string(),
+        title: import_zod2.z.string().optional()
       },
       async ({ ref, branchName, title }) => {
         const result = await orch.addStackLayer(ref, branchName, { title });
@@ -13534,11 +15256,11 @@ async function startMcpServer() {
       "create_pr_stack",
       "Create a new GitHub PR stack with one Sideboard worktree per layer (bottom\u2192top branch names). Requires `gh extension install github/gh-stack`.",
       {
-        repoPath: import_zod.z.string(),
-        branches: import_zod.z.array(import_zod.z.string()).min(1),
-        agent: import_zod.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"]),
-        base: import_zod.z.string().optional(),
-        title: import_zod.z.string().optional()
+        repoPath: import_zod2.z.string(),
+        branches: import_zod2.z.array(import_zod2.z.string()).min(1),
+        agent: import_zod2.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"]),
+        base: import_zod2.z.string().optional(),
+        title: import_zod2.z.string().optional()
       },
       async (args) => {
         const result = await orch.createPrStack({
@@ -13576,7 +15298,7 @@ async function startMcpServer() {
     server.tool(
       "list_issues",
       "List issues from Sideboard Account connections (Linear API or GitHub Issues; Linear\u2192GitHub fallback when Linear is not connected). Pass repoPath from list_workspaces \u2014 GitHub Issues are scoped to that repo. Then create_thread with sourceType=ticket.",
-      { repoPath: import_zod.z.string() },
+      { repoPath: import_zod2.z.string() },
       async ({ repoPath }) => {
         const root = await resolveRepoRoot(repoPath);
         const result = await listIssues(root);
@@ -13587,8 +15309,8 @@ async function startMcpServer() {
       "list_linear_issues",
       "Deprecated: prefer list_issues. Lists assigned Linear issues via the chosen agent MCP connector",
       {
-        agent: import_zod.z.enum(["claude", "codex", "opencode"]),
-        repoPath: import_zod.z.string()
+        agent: import_zod2.z.enum(["claude", "codex", "opencode"]),
+        repoPath: import_zod2.z.string()
       },
       async ({ agent, repoPath }) => {
         const issues = await listLinearIssues(agent, repoPath);