@sideboard-ai/core 0.1.111 → 0.1.116

package/dist/mcp/run-stdio.cjs

@@ -1507,6 +1507,7 @@ function looksLikeRetryableRunnerCrash(text4) {
 }
 function shouldRetryFailedAgentTurn(detail, opts) {
   if (looksLikeInvalidAgentSession(detail) && opts.hasSession) return true;
+  if (looksLikeV8Oom(detail) && opts.hasSession) return true;
   return looksLikeRetryableRunnerCrash(detail);
 }
 function looksLikeAgentFailureMessage(text4) {
@@ -1599,11 +1600,258 @@ var init_error_detail = __esm({
     NESTED_ELECTRON_SUMMARY = "Cursor local agent crashed at Electron startup (nested Chromium / HasCustomHostObject)";
     HOMEBREW_LIBUV_SUMMARY = "Cursor runner crashed in Node (Homebrew Node + shared libuv). Install Node 22 LTS (`brew install node@22`) and retry.";
     BUNDLED_NODE_CRASH_SUMMARY = "Cursor runner crashed in Node. Retry the turn.";
-    V8_OOM_SUMMARY = "Cursor runner ran out of memory (JavaScript heap). Retry; if it keeps happening, exclude large files from the project folder or start a new chat.";
+    V8_OOM_SUMMARY = "Agent ran out of memory (JavaScript heap). If it keeps happening, exclude large files from the project folder.";
     MINIFIED_DUMP_SUMMARY = "Cursor local agent crashed during startup (truncated crash dump)";
   }
 });
 
+// src/agents/path.ts
+function prependPathDir(env, dir) {
+  if (!dir || !(0, import_node_fs10.existsSync)(dir)) return;
+  const current = env.PATH ?? "";
+  const parts = current.split(import_node_path10.delimiter).filter(Boolean);
+  if (parts.includes(dir)) {
+    env.PATH = current;
+    return;
+  }
+  env.PATH = [dir, ...parts].join(import_node_path10.delimiter);
+}
+function conductorBundledBinDir(home = process.env.HOME || process.env.USERPROFILE || (0, import_node_os3.homedir)()) {
+  return (0, import_node_path10.join)(home, "Library", "Application Support", "com.conductor.app", "bin");
+}
+function isConductorBundledCli(filePath) {
+  const p = (filePath ?? "").replace(/\\/g, "/");
+  return p.includes("/com.conductor.app/bin/") || p.endsWith("/com.conductor.app/bin");
+}
+function ensureAgentPath(env = process.env) {
+  const home = env.HOME || env.USERPROFILE || (0, import_node_os3.homedir)();
+  const current = env.PATH ?? "";
+  const parts = current.split(import_node_path10.delimiter).filter(Boolean);
+  const seen = new Set(parts);
+  const extras = [
+    ...EXTRA_BIN_DIRS.map((rel) => (0, import_node_path10.join)(home, rel)),
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+    // Keep after Homebrew/npm so a user-installed CLI still wins.
+    conductorBundledBinDir(home)
+  ];
+  for (const dir of extras.reverse()) {
+    if (!dir || seen.has(dir) || !(0, import_node_fs10.existsSync)(dir)) continue;
+    parts.unshift(dir);
+    seen.add(dir);
+  }
+  const next = parts.join(import_node_path10.delimiter);
+  env.PATH = next;
+  return next;
+}
+function enrichPathWithNpmGlobalBin(env = process.env) {
+  ensureAgentPath(env);
+  try {
+    const prefix = (0, import_node_child_process2.execFileSync)("npm", ["prefix", "-g"], {
+      encoding: "utf8",
+      env: { ...process.env, ...env },
+      timeout: 8e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim().split(/\r?\n/).find(Boolean);
+    if (prefix) {
+      const binDir = process.platform === "win32" ? prefix : (0, import_node_path10.join)(prefix, "bin");
+      prependPathDir(env, binDir);
+    }
+  } catch {
+  }
+  return env.PATH ?? "";
+}
+function posixShellSingleQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function resolveCommandBinarySync(command, whichPath) {
+  const trimmed = command.trim();
+  if (!trimmed) return trimmed;
+  const match = /^(\S+)(\s[\s\S]*)?$/.exec(trimmed);
+  if (!match) return trimmed;
+  const bin = match[1];
+  const rest = match[2] ?? "";
+  if (bin.includes("/") || bin.includes("\\")) return trimmed;
+  const abs = whichPath?.trim().split(/\r?\n/).find(Boolean);
+  if (!abs) return trimmed;
+  return `${abs}${rest}`;
+}
+function withExportedPath(command, pathValue) {
+  const trimmed = command.trim();
+  if (!trimmed) return trimmed;
+  if (/^(export\s+PATH=|PATH=)/.test(trimmed)) return trimmed;
+  return `export PATH=${posixShellSingleQuote(pathValue)} && ${trimmed}`;
+}
+var import_node_fs10, import_node_child_process2, import_node_os3, import_node_path10, EXTRA_BIN_DIRS;
+var init_path = __esm({
+  "src/agents/path.ts"() {
+    "use strict";
+    import_node_fs10 = require("fs");
+    import_node_child_process2 = require("child_process");
+    import_node_os3 = require("os");
+    import_node_path10 = require("path");
+    EXTRA_BIN_DIRS = [
+      ".local/bin",
+      ".cargo/bin",
+      ".nvm/current/bin",
+      ".asdf/shims",
+      ".volta/bin",
+      ".npm-global/bin",
+      // fnm default alias (common when shell init is skipped)
+      ".local/share/fnm/aliases/default/bin",
+      // pnpm / npm global bins (where `@brightsy/cli` typically lands)
+      "Library/pnpm",
+      ".pnpm"
+    ];
+  }
+});
+
+// src/git/stale-lock.ts
+function isIndexLockError(text4) {
+  return /Unable to create ['"][^'"]*index\.lock['"]: File exists/i.test(text4);
+}
+function clearStaleIndexLock(gitDir, maxAgeMs = STALE_INDEX_LOCK_MS, now = Date.now()) {
+  const lockPath = (0, import_node_path11.join)(gitDir, "index.lock");
+  try {
+    if (!(0, import_node_fs11.existsSync)(lockPath)) return null;
+    if (now - (0, import_node_fs11.statSync)(lockPath).mtimeMs < maxAgeMs) return null;
+    (0, import_node_fs11.unlinkSync)(lockPath);
+    return lockPath;
+  } catch {
+    return null;
+  }
+}
+function clearStaleIndexLocks(gitDirs, maxAgeMs = STALE_INDEX_LOCK_MS) {
+  const now = Date.now();
+  const removed = [];
+  for (const dir of new Set(gitDirs)) {
+    const cleared = clearStaleIndexLock(dir, maxAgeMs, now);
+    if (cleared) removed.push(cleared);
+  }
+  return removed;
+}
+var import_node_fs11, import_node_path11, STALE_INDEX_LOCK_MS;
+var init_stale_lock = __esm({
+  "src/git/stale-lock.ts"() {
+    "use strict";
+    import_node_fs11 = require("fs");
+    import_node_path11 = require("path");
+    STALE_INDEX_LOCK_MS = 2e4;
+  }
+});
+
+// src/git/run.ts
+var run_exports = {};
+__export(run_exports, {
+  gh: () => gh,
+  git: () => git,
+  resolveGhAuthToken: () => resolveGhAuthToken,
+  resolveGitDirsForLockRecovery: () => resolveGitDirsForLockRecovery,
+  run: () => run
+});
+async function run(file, args, opts) {
+  ensureAgentPath();
+  try {
+    const result = await (0, import_execa2.execa)(file, args, {
+      cwd: opts?.cwd,
+      env: { ...process.env, ...opts?.env },
+      reject: opts?.reject ?? true,
+      ...opts?.timeoutMs != null ? { timeout: opts.timeoutMs } : {}
+    });
+    return {
+      stdout: result.stdout ?? "",
+      stderr: result.stderr ?? "",
+      exitCode: result.exitCode ?? 0
+    };
+  } catch (err) {
+    const e = err;
+    if (opts?.reject === false) {
+      return {
+        stdout: String(e.stdout ?? ""),
+        stderr: String(e.stderr ?? ""),
+        exitCode: e.exitCode ?? 1
+      };
+    }
+    throw err;
+  }
+}
+async function resolveGitDirsForLockRecovery(cwd, env = {}) {
+  const dirs = /* @__PURE__ */ new Set();
+  const [gitDir, commonDir] = await Promise.all([
+    run("git", ["rev-parse", "--absolute-git-dir"], { cwd, reject: false, env, timeoutMs: 5e3 }),
+    run("git", ["rev-parse", "--path-format=absolute", "--git-common-dir"], {
+      cwd,
+      reject: false,
+      env,
+      timeoutMs: 5e3
+    })
+  ]);
+  if (gitDir.exitCode === 0 && gitDir.stdout.trim()) dirs.add(gitDir.stdout.trim());
+  if (commonDir.exitCode === 0 && commonDir.stdout.trim()) dirs.add(commonDir.stdout.trim());
+  return [...dirs];
+}
+async function git(args, cwd, opts) {
+  const prefix = [];
+  if (opts?.config) {
+    for (const [key, value] of Object.entries(opts.config)) {
+      if (!key) continue;
+      prefix.push("-c", `${key}=${value}`);
+    }
+  }
+  const gitArgs = ["--no-pager", ...prefix, ...args];
+  const env = {
+    // Never block forever on a credential/SSH prompt inside MCP / Electron.
+    GIT_TERMINAL_PROMPT: "0",
+    GIT_ASKPASS: process.env.GIT_ASKPASS || "echo",
+    SSH_ASKPASS: process.env.SSH_ASKPASS || "echo",
+    GIT_SSH_COMMAND: process.env.GIT_SSH_COMMAND || "ssh -o BatchMode=yes -o ConnectTimeout=15",
+    GCM_INTERACTIVE: "never",
+    GH_PROMPT_DISABLED: "1",
+    ...opts?.env
+  };
+  let result = await run("git", gitArgs, { cwd, reject: false, timeoutMs: opts?.timeoutMs, env });
+  if (result.exitCode !== 0 && isIndexLockError(result.stderr)) {
+    const gitDirs = await resolveGitDirsForLockRecovery(cwd, env);
+    const cleared = clearStaleIndexLocks(gitDirs);
+    if (cleared.length > 0) {
+      result = await run("git", gitArgs, { cwd, reject: false, timeoutMs: opts?.timeoutMs, env });
+    }
+  }
+  if ((opts?.reject ?? true) && result.exitCode !== 0) {
+    throw new Error(
+      `Command failed with exit code ${result.exitCode}: git ${gitArgs.join(" ")}
+${result.stderr}`
+    );
+  }
+  return result;
+}
+async function gh(args, cwd, opts) {
+  return run("gh", args, {
+    cwd,
+    reject: opts?.reject,
+    timeoutMs: opts?.timeoutMs,
+    env: {
+      GH_PROMPT_DISABLED: "1",
+      GIT_TERMINAL_PROMPT: "0"
+    }
+  });
+}
+async function resolveGhAuthToken(cwd) {
+  const result = await gh(["auth", "token"], cwd, { reject: false, timeoutMs: 8e3 });
+  if (result.exitCode !== 0) return null;
+  const token = result.stdout.trim();
+  return token || null;
+}
+var import_execa2;
+var init_run = __esm({
+  "src/git/run.ts"() {
+    "use strict";
+    import_execa2 = require("execa");
+    init_path();
+    init_stale_lock();
+  }
+});
+
 // src/git/team-meta.ts
 var SOCCER_TEAM_META;
 var init_team_meta = __esm({
@@ -2505,7 +2753,7 @@ var init_gh_errors = __esm({
 
 // src/store/secret-vault.ts
 function secretVaultPath() {
-  return (0, import_node_path10.join)(appDataDir(), "secrets.json");
+  return (0, import_node_path12.join)(appDataDir(), "secrets.json");
 }
 function loadSecretVault() {
   const parsed = readSecureJson(secretVaultPath());
@@ -2549,11 +2797,11 @@ function normalizeVault(raw) {
   }
   return out;
 }
-var import_node_path10;
+var import_node_path12;
 var init_secret_vault = __esm({
   "src/store/secret-vault.ts"() {
     "use strict";
-    import_node_path10 = require("path");
+    import_node_path12 = require("path");
     init_paths();
     init_secure_file();
   }
@@ -2656,10 +2904,10 @@ function toPublicAppSettings(settings) {
   };
 }
 function appSettingsPath() {
-  return (0, import_node_path11.join)(appDataDir(), "settings.json");
+  return (0, import_node_path13.join)(appDataDir(), "settings.json");
 }
 function claudeUserSettingsPath() {
-  return (0, import_node_path11.join)((0, import_node_os3.homedir)(), ".claude", "settings.json");
+  return (0, import_node_path13.join)((0, import_node_os4.homedir)(), ".claude", "settings.json");
 }
 function normalizeClaude(raw) {
   if (!raw || typeof raw !== "object") return {};
@@ -2908,10 +3156,10 @@ function normalizeSettings(raw) {
 }
 function readSettingsFile() {
   const path = appSettingsPath();
-  if (!(0, import_node_fs10.existsSync)(path)) return { ...EMPTY_SETTINGS };
+  if (!(0, import_node_fs12.existsSync)(path)) return { ...EMPTY_SETTINGS };
   try {
     chmodOwnerOnly(path);
-    const parsed = JSON.parse((0, import_node_fs10.readFileSync)(path, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs12.readFileSync)(path, "utf8"));
     return normalizeSettings(parsed);
   } catch {
     return { ...EMPTY_SETTINGS };
@@ -3296,7 +3544,7 @@ function ensureSlackDeviceIdentity(settings = loadAppSettings()) {
   }
   if (!deviceLabel) {
     try {
-      deviceLabel = (0, import_node_os3.hostname)().split(".")[0]?.trim() || "This Mac";
+      deviceLabel = (0, import_node_os4.hostname)().split(".")[0]?.trim() || "This Mac";
     } catch {
       deviceLabel = "This Mac";
     }
@@ -3483,14 +3731,14 @@ function childEnvWithAppSettings(extra) {
 function harnessEnvKey(harness) {
   return HARNESS_ENV_KEYS[harness];
 }
-var import_node_crypto3, import_node_fs10, import_node_os3, import_node_path11, HARNESS_ENV_KEYS, DEFAULT_AGENTS, GITHUB_GIT_AUTH_MODES, CLOUD_CONNECT_AGENTS, ISSUE_SOURCES, GIT_AUTH_MODES, EMPTY_SETTINGS, DEFAULT_CLI_BIN;
+var import_node_crypto3, import_node_fs12, import_node_os4, import_node_path13, HARNESS_ENV_KEYS, DEFAULT_AGENTS, GITHUB_GIT_AUTH_MODES, CLOUD_CONNECT_AGENTS, ISSUE_SOURCES, GIT_AUTH_MODES, EMPTY_SETTINGS, DEFAULT_CLI_BIN;
 var init_app_settings = __esm({
   "src/store/app-settings.ts"() {
     "use strict";
     import_node_crypto3 = require("crypto");
-    import_node_fs10 = require("fs");
-    import_node_os3 = require("os");
-    import_node_path11 = require("path");
+    import_node_fs12 = require("fs");
+    import_node_os4 = require("os");
+    import_node_path13 = require("path");
     init_thinking_effort();
     init_nested_electron_env();
     init_paths();
@@ -3542,23 +3790,23 @@ var init_app_settings = __esm({
 function githubAgentAuthDir() {
   const override = process.env.SIDEBOARD_GIT_AUTH_DIR?.trim();
   if (override) return override;
-  return (0, import_node_path12.join)((0, import_node_os4.homedir)(), ".sideboard-git-auth");
+  return (0, import_node_path14.join)((0, import_node_os5.homedir)(), ".sideboard-git-auth");
 }
 function githubCredentialStorePath() {
-  return (0, import_node_path12.join)(githubAgentAuthDir(), "git-credentials");
+  return (0, import_node_path14.join)(githubAgentAuthDir(), "git-credentials");
 }
 function githubGhConfigDir() {
-  return (0, import_node_path12.join)(githubAgentAuthDir(), "gh");
+  return (0, import_node_path14.join)(githubAgentAuthDir(), "gh");
 }
 function writePrivateFile2(file, body) {
-  (0, import_node_fs11.mkdirSync)((0, import_node_path12.dirname)(file), { recursive: true, mode: 448 });
+  (0, import_node_fs13.mkdirSync)((0, import_node_path14.dirname)(file), { recursive: true, mode: 448 });
   try {
-    (0, import_node_fs11.chmodSync)((0, import_node_path12.dirname)(file), 448);
+    (0, import_node_fs13.chmodSync)((0, import_node_path14.dirname)(file), 448);
   } catch {
   }
-  (0, import_node_fs11.writeFileSync)(file, body, { encoding: "utf8", mode: 384 });
+  (0, import_node_fs13.writeFileSync)(file, body, { encoding: "utf8", mode: 384 });
   try {
-    (0, import_node_fs11.chmodSync)(file, 384);
+    (0, import_node_fs13.chmodSync)(file, 384);
   } catch {
   }
 }
@@ -3583,225 +3831,40 @@ function materializeGithubAgentAuth(token, user) {
   const trimmed = token.trim();
   if (!trimmed) return;
   const root = githubAgentAuthDir();
-  (0, import_node_fs11.mkdirSync)(root, { recursive: true, mode: 448 });
+  (0, import_node_fs13.mkdirSync)(root, { recursive: true, mode: 448 });
   try {
-    (0, import_node_fs11.chmodSync)(root, 448);
+    (0, import_node_fs13.chmodSync)(root, 448);
   } catch {
   }
   writePrivateFile2(githubCredentialStorePath(), gitCredentialStoreContents(trimmed));
-  const ghDir = githubGhConfigDir();
-  (0, import_node_fs11.mkdirSync)(ghDir, { recursive: true, mode: 448 });
-  writePrivateFile2((0, import_node_path12.join)(ghDir, "hosts.yml"), ghHostsYml(trimmed, user));
-  writePrivateFile2((0, import_node_path12.join)(ghDir, "config.yml"), "git_protocol: https\nprompt: disabled\n");
-}
-function githubAgentAuthReady() {
-  return (0, import_node_fs11.existsSync)(githubCredentialStorePath()) && (0, import_node_fs11.existsSync)((0, import_node_path12.join)(githubGhConfigDir(), "hosts.yml"));
-}
-function githubCredentialHelperGitConfig() {
-  const file = githubCredentialStorePath();
-  return [
-    { key: "credential.helper", value: "" },
-    { key: "credential.helper", value: `store --file=${file}` }
-  ];
-}
-function githubGhConfigEnv() {
-  return {
-    GH_CONFIG_DIR: githubGhConfigDir(),
-    GH_PROMPT_DISABLED: "1"
-  };
-}
-var import_node_fs11, import_node_os4, import_node_path12;
-var init_github_agent_auth = __esm({
-  "src/git/github-agent-auth.ts"() {
-    "use strict";
-    import_node_fs11 = require("fs");
-    import_node_os4 = require("os");
-    import_node_path12 = require("path");
-  }
-});
-
-// src/agents/path.ts
-function prependPathDir(env, dir) {
-  if (!dir || !(0, import_node_fs12.existsSync)(dir)) return;
-  const current = env.PATH ?? "";
-  const parts = current.split(import_node_path13.delimiter).filter(Boolean);
-  if (parts.includes(dir)) {
-    env.PATH = current;
-    return;
-  }
-  env.PATH = [dir, ...parts].join(import_node_path13.delimiter);
-}
-function conductorBundledBinDir(home = process.env.HOME || process.env.USERPROFILE || (0, import_node_os5.homedir)()) {
-  return (0, import_node_path13.join)(home, "Library", "Application Support", "com.conductor.app", "bin");
-}
-function isConductorBundledCli(filePath) {
-  const p = (filePath ?? "").replace(/\\/g, "/");
-  return p.includes("/com.conductor.app/bin/") || p.endsWith("/com.conductor.app/bin");
-}
-function ensureAgentPath(env = process.env) {
-  const home = env.HOME || env.USERPROFILE || (0, import_node_os5.homedir)();
-  const current = env.PATH ?? "";
-  const parts = current.split(import_node_path13.delimiter).filter(Boolean);
-  const seen = new Set(parts);
-  const extras = [
-    ...EXTRA_BIN_DIRS.map((rel) => (0, import_node_path13.join)(home, rel)),
-    "/opt/homebrew/bin",
-    "/usr/local/bin",
-    // Keep after Homebrew/npm so a user-installed CLI still wins.
-    conductorBundledBinDir(home)
-  ];
-  for (const dir of extras.reverse()) {
-    if (!dir || seen.has(dir) || !(0, import_node_fs12.existsSync)(dir)) continue;
-    parts.unshift(dir);
-    seen.add(dir);
-  }
-  const next = parts.join(import_node_path13.delimiter);
-  env.PATH = next;
-  return next;
-}
-function enrichPathWithNpmGlobalBin(env = process.env) {
-  ensureAgentPath(env);
-  try {
-    const prefix = (0, import_node_child_process2.execFileSync)("npm", ["prefix", "-g"], {
-      encoding: "utf8",
-      env: { ...process.env, ...env },
-      timeout: 8e3,
-      stdio: ["ignore", "pipe", "ignore"]
-    }).trim().split(/\r?\n/).find(Boolean);
-    if (prefix) {
-      const binDir = process.platform === "win32" ? prefix : (0, import_node_path13.join)(prefix, "bin");
-      prependPathDir(env, binDir);
-    }
-  } catch {
-  }
-  return env.PATH ?? "";
-}
-function posixShellSingleQuote(value) {
-  return `'${value.replace(/'/g, `'\\''`)}'`;
-}
-function resolveCommandBinarySync(command, whichPath) {
-  const trimmed = command.trim();
-  if (!trimmed) return trimmed;
-  const match = /^(\S+)(\s[\s\S]*)?$/.exec(trimmed);
-  if (!match) return trimmed;
-  const bin = match[1];
-  const rest = match[2] ?? "";
-  if (bin.includes("/") || bin.includes("\\")) return trimmed;
-  const abs = whichPath?.trim().split(/\r?\n/).find(Boolean);
-  if (!abs) return trimmed;
-  return `${abs}${rest}`;
-}
-function withExportedPath(command, pathValue) {
-  const trimmed = command.trim();
-  if (!trimmed) return trimmed;
-  if (/^(export\s+PATH=|PATH=)/.test(trimmed)) return trimmed;
-  return `export PATH=${posixShellSingleQuote(pathValue)} && ${trimmed}`;
-}
-var import_node_fs12, import_node_child_process2, import_node_os5, import_node_path13, EXTRA_BIN_DIRS;
-var init_path = __esm({
-  "src/agents/path.ts"() {
-    "use strict";
-    import_node_fs12 = require("fs");
-    import_node_child_process2 = require("child_process");
-    import_node_os5 = require("os");
-    import_node_path13 = require("path");
-    EXTRA_BIN_DIRS = [
-      ".local/bin",
-      ".cargo/bin",
-      ".nvm/current/bin",
-      ".asdf/shims",
-      ".volta/bin",
-      ".npm-global/bin",
-      // fnm default alias (common when shell init is skipped)
-      ".local/share/fnm/aliases/default/bin",
-      // pnpm / npm global bins (where `@brightsy/cli` typically lands)
-      "Library/pnpm",
-      ".pnpm"
-    ];
-  }
-});
-
-// src/git/run.ts
-var run_exports = {};
-__export(run_exports, {
-  gh: () => gh,
-  git: () => git,
-  resolveGhAuthToken: () => resolveGhAuthToken,
-  run: () => run
-});
-async function run(file, args, opts) {
-  ensureAgentPath();
-  try {
-    const result = await (0, import_execa2.execa)(file, args, {
-      cwd: opts?.cwd,
-      env: { ...process.env, ...opts?.env },
-      reject: opts?.reject ?? true,
-      ...opts?.timeoutMs != null ? { timeout: opts.timeoutMs } : {}
-    });
-    return {
-      stdout: result.stdout ?? "",
-      stderr: result.stderr ?? "",
-      exitCode: result.exitCode ?? 0
-    };
-  } catch (err) {
-    const e = err;
-    if (opts?.reject === false) {
-      return {
-        stdout: String(e.stdout ?? ""),
-        stderr: String(e.stderr ?? ""),
-        exitCode: e.exitCode ?? 1
-      };
-    }
-    throw err;
-  }
-}
-async function git(args, cwd, opts) {
-  const prefix = [];
-  if (opts?.config) {
-    for (const [key, value] of Object.entries(opts.config)) {
-      if (!key) continue;
-      prefix.push("-c", `${key}=${value}`);
-    }
-  }
-  return run("git", ["--no-pager", ...prefix, ...args], {
-    cwd,
-    reject: opts?.reject,
-    timeoutMs: opts?.timeoutMs,
-    // Never block forever on a credential/SSH prompt inside MCP / Electron.
-    env: {
-      GIT_TERMINAL_PROMPT: "0",
-      GIT_ASKPASS: process.env.GIT_ASKPASS || "echo",
-      SSH_ASKPASS: process.env.SSH_ASKPASS || "echo",
-      GIT_SSH_COMMAND: process.env.GIT_SSH_COMMAND || "ssh -o BatchMode=yes -o ConnectTimeout=15",
-      GCM_INTERACTIVE: "never",
-      GH_PROMPT_DISABLED: "1",
-      ...opts?.env
-    }
-  });
+  const ghDir = githubGhConfigDir();
+  (0, import_node_fs13.mkdirSync)(ghDir, { recursive: true, mode: 448 });
+  writePrivateFile2((0, import_node_path14.join)(ghDir, "hosts.yml"), ghHostsYml(trimmed, user));
+  writePrivateFile2((0, import_node_path14.join)(ghDir, "config.yml"), "git_protocol: https\nprompt: disabled\n");
 }
-async function gh(args, cwd, opts) {
-  return run("gh", args, {
-    cwd,
-    reject: opts?.reject,
-    timeoutMs: opts?.timeoutMs,
-    env: {
-      GH_PROMPT_DISABLED: "1",
-      GIT_TERMINAL_PROMPT: "0"
-    }
-  });
+function githubAgentAuthReady() {
+  return (0, import_node_fs13.existsSync)(githubCredentialStorePath()) && (0, import_node_fs13.existsSync)((0, import_node_path14.join)(githubGhConfigDir(), "hosts.yml"));
 }
-async function resolveGhAuthToken(cwd) {
-  const result = await gh(["auth", "token"], cwd, { reject: false, timeoutMs: 8e3 });
-  if (result.exitCode !== 0) return null;
-  const token = result.stdout.trim();
-  return token || null;
+function githubCredentialHelperGitConfig() {
+  const file = githubCredentialStorePath();
+  return [
+    { key: "credential.helper", value: "" },
+    { key: "credential.helper", value: `store --file=${file}` }
+  ];
 }
-var import_execa2;
-var init_run = __esm({
-  "src/git/run.ts"() {
+function githubGhConfigEnv() {
+  return {
+    GH_CONFIG_DIR: githubGhConfigDir(),
+    GH_PROMPT_DISABLED: "1"
+  };
+}
+var import_node_fs13, import_node_os5, import_node_path14;
+var init_github_agent_auth = __esm({
+  "src/git/github-agent-auth.ts"() {
     "use strict";
-    import_execa2 = require("execa");
-    init_path();
+    import_node_fs13 = require("fs");
+    import_node_os5 = require("os");
+    import_node_path14 = require("path");
   }
 });
 
@@ -3893,7 +3956,7 @@ async function warmGithubAgentAuth(opts) {
 }
 function normalizeWritableRoot(raw) {
   const trimmed = raw.trim().replace(/\/+$/, "");
-  return trimmed && (0, import_node_path14.isAbsolute)(trimmed) ? trimmed : null;
+  return trimmed && (0, import_node_path15.isAbsolute)(trimmed) ? trimmed : null;
 }
 async function resolveCodexGitWritableRoots(cwd) {
   const roots = /* @__PURE__ */ new Set();
@@ -3970,11 +4033,11 @@ function formatGitAuthModeDirective(mode) {
       ].join("\n");
   }
 }
-var import_node_path14, HTTPS_REWRITE, TOKEN_TTL_MS, tokenMemo, GITHUB_CHILD_TOKEN_KEYS;
+var import_node_path15, HTTPS_REWRITE, TOKEN_TTL_MS, tokenMemo, GITHUB_CHILD_TOKEN_KEYS;
 var init_git_auth_mode = __esm({
   "src/git/git-auth-mode.ts"() {
     "use strict";
-    import_node_path14 = require("path");
+    import_node_path15 = require("path");
     init_app_settings();
     init_github_agent_auth();
     init_run();
@@ -5144,8 +5207,8 @@ function isLocalPrFetchBranch(ref) {
 }
 async function createThreadWorktree(opts) {
   let branchName = `thread/${opts.slug}`;
-  const worktreePath = (0, import_node_path15.join)(worktreesRoot(opts.repoPath), opts.slug);
-  if ((0, import_node_fs13.existsSync)(worktreePath)) {
+  const worktreePath = (0, import_node_path16.join)(worktreesRoot(opts.repoPath), opts.slug);
+  if ((0, import_node_fs14.existsSync)(worktreePath)) {
     throw new Error(`Worktree already exists at ${worktreePath}`);
   }
   await ensureGhPreferOrigin(opts.repoPath);
@@ -5212,8 +5275,8 @@ ${add.stdout}`;
 async function createExistingBranchWorktree(opts) {
   const branchName = opts.branchName.trim();
   if (!branchName) throw new Error("branch name required");
-  const worktreePath = (0, import_node_path15.join)(worktreesRoot(opts.repoPath), opts.slug);
-  if ((0, import_node_fs13.existsSync)(worktreePath)) {
+  const worktreePath = (0, import_node_path16.join)(worktreesRoot(opts.repoPath), opts.slug);
+  if ((0, import_node_fs14.existsSync)(worktreePath)) {
     throw new Error(`Worktree already exists at ${worktreePath}`);
   }
   await ensureGhPreferOrigin(opts.repoPath);
@@ -5504,10 +5567,10 @@ function sameRepoPath(a, b) {
   return normalizeWorktreePath(a) === normalizeWorktreePath(b);
 }
 function listLocalThreadBranchSlugs(repoPath) {
-  const refsDir = (0, import_node_path15.join)(repoPath, ".git", "refs", "heads", "thread");
-  if (!(0, import_node_fs13.existsSync)(refsDir)) return [];
+  const refsDir = (0, import_node_path16.join)(repoPath, ".git", "refs", "heads", "thread");
+  if (!(0, import_node_fs14.existsSync)(refsDir)) return [];
   try {
-    return (0, import_node_fs13.readdirSync)(refsDir).filter((name) => !name.startsWith(".")).map((name) => normalizeTakenSlug(name));
+    return (0, import_node_fs14.readdirSync)(refsDir).filter((name) => !name.startsWith(".")).map((name) => normalizeTakenSlug(name));
   } catch {
     return [];
   }
@@ -5515,8 +5578,8 @@ function listLocalThreadBranchSlugs(repoPath) {
 function collectTakenTeamSlugs(repoPath) {
   const taken = /* @__PURE__ */ new Set();
   const root = worktreesRoot(repoPath);
-  if ((0, import_node_fs13.existsSync)(root)) {
-    for (const entry of (0, import_node_fs13.readdirSync)(root, { withFileTypes: true })) {
+  if ((0, import_node_fs14.existsSync)(root)) {
+    for (const entry of (0, import_node_fs14.readdirSync)(root, { withFileTypes: true })) {
       if (entry.isDirectory() && entry.name !== ".DS_Store") {
         taken.add(normalizeTakenSlug(entry.name));
       }
@@ -5537,18 +5600,18 @@ function allocateTeamSlug(repoPath) {
   const taken = collectTakenTeamSlugs(repoPath);
   for (let attempt = 0; attempt < 32; attempt++) {
     const team = allocateTeamName(taken);
-    const path = (0, import_node_path15.join)(worktreesRoot(repoPath), team.slug);
-    if (!(0, import_node_fs13.existsSync)(path)) return team;
+    const path = (0, import_node_path16.join)(worktreesRoot(repoPath), team.slug);
+    if (!(0, import_node_fs14.existsSync)(path)) return team;
     taken.add(team.slug);
   }
   throw new Error("No available soccer team worktree directories left");
 }
-var import_node_fs13, import_node_path15;
+var import_node_fs14, import_node_path16;
 var init_worktree = __esm({
   "src/git/worktree.ts"() {
     "use strict";
-    import_node_fs13 = require("fs");
-    import_node_path15 = require("path");
+    import_node_fs14 = require("fs");
+    import_node_path16 = require("path");
     init_paths();
     init_thread_store();
     init_teams();
@@ -5683,7 +5746,7 @@ function coordinatorTurnReminder(opts) {
 function ensureGlobalCoordinatorCwd(opts) {
   const dir = globalAgentCwd();
   try {
-    (0, import_node_fs14.mkdirSync)(dir, { recursive: true });
+    (0, import_node_fs15.mkdirSync)(dir, { recursive: true });
   } catch {
     return dir;
   }
@@ -5691,7 +5754,7 @@ function ensureGlobalCoordinatorCwd(opts) {
   let orchId = opts?.orchestratorThreadId?.trim() || "";
   if (!orchId) {
     try {
-      const existing = (0, import_node_fs14.readFileSync)((0, import_node_path16.join)(dir, "AGENTS.md"), "utf8");
+      const existing = (0, import_node_fs15.readFileSync)((0, import_node_path17.join)(dir, "AGENTS.md"), "utf8");
       const m = existing.match(
         /YOUR orchestration thread id is `([0-9a-f-]{36})`/i
       );
@@ -5733,9 +5796,9 @@ function ensureGlobalCoordinatorCwd(opts) {
     "Always ask worktree agents to commit, push, and open draft PRs (`ask_git` / `send_to_thread`). Tell them to merge only when the user explicitly asked. The worktree agent runs git/gh; never merge from this orchestration cwd."
   ].join("\n");
   try {
-    (0, import_node_fs14.writeFileSync)((0, import_node_path16.join)(dir, "CLAUDE.md"), `${body}
+    (0, import_node_fs15.writeFileSync)((0, import_node_path17.join)(dir, "CLAUDE.md"), `${body}
 `, "utf8");
-    (0, import_node_fs14.writeFileSync)((0, import_node_path16.join)(dir, "AGENTS.md"), `${body}
+    (0, import_node_fs15.writeFileSync)((0, import_node_path17.join)(dir, "AGENTS.md"), `${body}
 `, "utf8");
   } catch {
   }
@@ -5767,12 +5830,12 @@ function coordinatorSystemPrompt(opts) {
     formatWorkspaceInventory(opts.workspaces)
   ].join("\n");
 }
-var import_node_fs14, import_node_path16, COORDINATOR_TOOL_PLAYBOOK, SLACK_REPLY_FORMATTING;
+var import_node_fs15, import_node_path17, COORDINATOR_TOOL_PLAYBOOK, SLACK_REPLY_FORMATTING;
 var init_coordinator_prompt = __esm({
   "src/orchestrator/coordinator-prompt.ts"() {
     "use strict";
-    import_node_fs14 = require("fs");
-    import_node_path16 = require("path");
+    import_node_fs15 = require("fs");
+    import_node_path17 = require("path");
     init_worktree();
     init_app_settings();
     init_paths();
@@ -5798,7 +5861,7 @@ var init_coordinator_prompt = __esm({
       "- fork_worktree \u2014 fork a worktree chat into a NEW git worktree + chat (transcript attached); optional agent; leave model unset (Auto) unless you have a reason. Not for orchestration chats.",
       "- fork_chat \u2014 fork a worktree chat (same worktree tab) OR a Global orchestration chat (new orchestration tab); optional agent; leave model unset (Auto) unless you have a reason. Remote coordinators: use this to continue another orchestration chat on a different agent after session limits.",
       "- send_to_thread \u2014 queue a prompt (start/continue a chat turn); pass force_stop: true to interrupt mid-turn / clear stale queued prompts before replacing with a new request",
-      "- wait_for_turn / get_turn_result \u2014 wait for and read the agent reply. wait_for_turn returns within ~45s even if the child is still working (MCP clients kill longer tool calls). If stillRunning is true, progress is a live snapshot of tools/thinking \u2014 call wait_for_turn again. Do not send \u201Care you stuck?\u201D or assume a hang while lastActivityAt is recent. On status error, lastError (and text) is the failure \u2014 switch agent, tell the user, or retry; do not treat empty text as success.",
+      "- wait_for_turn / get_turn_result \u2014 wait for and read the agent reply. wait_for_turn returns within ~45s even if the child is still working (MCP clients kill longer tool calls). If stillRunning is true, progress is a live snapshot of tools/thinking \u2014 call wait_for_turn again. status=queued with no lastActivityAt means the child has not started yet (concurrency cap) \u2014 keep waiting; do not force_stop or send a check-in. Do not send \u201Care you stuck?\u201D or assume a hang while lastActivityAt is recent. On status error, lastError (and text) is the failure \u2014 switch agent, tell the user, or retry; do not treat empty text as success.",
       "- stop_thread \u2014 force-stop: kill in-flight turn AND clear queued prompts (do not leave stale queue after an interrupt)",
       "- archive_thread / restore_thread \u2014 archive (tears down worktree when last tab) or restore",
       "Setup / run:",
@@ -6070,32 +6133,32 @@ var init_global_workspace = __esm({
 
 // src/brightsy/config.ts
 function brightsyConfigPath() {
-  return (0, import_node_path17.join)((0, import_node_os6.homedir)(), ".brightsy", "config.json");
+  return (0, import_node_path18.join)((0, import_node_os6.homedir)(), ".brightsy", "config.json");
 }
 function loadBrightsyConfig() {
   const path = brightsyConfigPath();
-  if (!(0, import_node_fs15.existsSync)(path)) {
+  if (!(0, import_node_fs16.existsSync)(path)) {
     throw new Error("Brightsy not logged in \u2014 run `brightsy login` first");
   }
-  const raw = JSON.parse((0, import_node_fs15.readFileSync)(path, "utf8"));
+  const raw = JSON.parse((0, import_node_fs16.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_fs15.writeFileSync)(brightsyConfigPath(), `${JSON.stringify(cfg, null, 2)}
+  (0, import_node_fs16.writeFileSync)(brightsyConfigPath(), `${JSON.stringify(cfg, null, 2)}
 `, {
     mode: 384
   });
 }
-var import_node_fs15, import_node_os6, import_node_path17;
+var import_node_fs16, import_node_os6, import_node_path18;
 var init_config = __esm({
   "src/brightsy/config.ts"() {
     "use strict";
-    import_node_fs15 = require("fs");
+    import_node_fs16 = require("fs");
     import_node_os6 = require("os");
-    import_node_path17 = require("path");
+    import_node_path18 = require("path");
   }
 });
 
@@ -6110,22 +6173,22 @@ var init_accounts = __esm({
 
 // src/brightsy/connected-teams.ts
 function storePath4() {
-  return (0, import_node_path18.join)(appDataDir(), "brightsy-teams.json");
+  return (0, import_node_path19.join)(appDataDir(), "brightsy-teams.json");
 }
 function readStore4() {
   const path = storePath4();
-  if (!(0, import_node_fs16.existsSync)(path)) return [];
+  if (!(0, import_node_fs17.existsSync)(path)) return [];
   try {
-    const parsed = JSON.parse((0, import_node_fs16.readFileSync)(path, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs17.readFileSync)(path, "utf8"));
     return Array.isArray(parsed.teams) ? parsed.teams : [];
   } catch {
     return [];
   }
 }
 function writeStore2(teams) {
-  (0, import_node_fs16.mkdirSync)(appDataDir(), { recursive: true });
+  (0, import_node_fs17.mkdirSync)(appDataDir(), { recursive: true });
   const path = storePath4();
-  (0, import_node_fs16.writeFileSync)(path, `${JSON.stringify({ teams }, null, 2)}
+  (0, import_node_fs17.writeFileSync)(path, `${JSON.stringify({ teams }, null, 2)}
 `, {
     mode: 384
   });
@@ -6237,12 +6300,12 @@ function brightsyMcpServerName(slug) {
   const cleaned = slug.replace(/[^A-Za-z0-9_-]/g, "_").replace(/^_+|_+$/g, "");
   return `brightsy_${cleaned || "team"}`;
 }
-var import_node_fs16, import_node_path18;
+var import_node_fs17, import_node_path19;
 var init_connected_teams = __esm({
   "src/brightsy/connected-teams.ts"() {
     "use strict";
-    import_node_fs16 = require("fs");
-    import_node_path18 = require("path");
+    import_node_fs17 = require("fs");
+    import_node_path19 = require("path");
     init_paths();
     init_accounts();
     init_config();
@@ -6573,11 +6636,11 @@ async function syncCliForTarget(accountId) {
   }
   applyConnectedTeamToCli(team);
 }
-var import_node_fs17, brightsyAdapter;
+var import_node_fs18, brightsyAdapter;
 var init_brightsy = __esm({
   "src/agents/brightsy.ts"() {
     "use strict";
-    import_node_fs17 = require("fs");
+    import_node_fs18 = require("fs");
     init_run();
     init_connected_teams();
     init_config();
@@ -6592,7 +6655,7 @@ var init_brightsy = __esm({
       async detect() {
         const brightsy = resolveAgentExecutable("brightsy");
         if (brightsy !== "brightsy") {
-          if (!(0, import_node_fs17.existsSync)(brightsy)) {
+          if (!(0, import_node_fs18.existsSync)(brightsy)) {
             return {
               agent: "brightsy",
               installed: false,
@@ -6761,9 +6824,9 @@ function toolDescription(name, input) {
     if (/connectedAgentRequest/i.test(name)) {
       return str2(input?.agent_id) ? `Ask connected agent` : "Ask connected agent";
     }
-    if (desc && kind) return `${kind}: ${desc}`;
-    if (desc) return desc;
-    return "Subagent";
+    if (desc && kind) return `${kind}: ${desc}${subagentLiveSuffix(input)}`;
+    if (desc) return `${desc}${subagentLiveSuffix(input)}`;
+    return `Subagent${subagentLiveSuffix(input)}`;
   }
   if (/^(create|update)_artifact$/i.test(name.replace(/^mcp__[^_]+__/, ""))) {
     return str2(input?.title) ? `Artifact ${str2(input?.title)}` : "Artifact";
@@ -6788,13 +6851,83 @@ function toolDescription(name, input) {
   }
   if (/grep/i.test(name)) return "Search files";
   if (/glob/i.test(name)) return "Find files";
+  const compact = n.replace(/[_-]/g, "");
+  if (/^taskoutput$/i.test(compact)) {
+    return str2(input.task_id) ? `Wait for ${str2(input.task_id)}` : "Wait for background task";
+  }
+  if (/^taskstop$/i.test(compact)) {
+    return str2(input.task_id) ? `Stop ${str2(input.task_id)}` : "Stop background task";
+  }
+  if (/^monitor$/i.test(compact)) {
+    const command = str2(input.command);
+    return command ? `Watch ${command.length > 48 ? `${command.slice(0, 45)}\u2026` : command}` : "Watch command";
+  }
   return n;
 }
+function subagentLiveSuffix(input) {
+  if (!input) return "";
+  const bits = [];
+  const status = str2(input.live_status);
+  if (status && !/^runn(ing)?$|^working$/i.test(status)) bits.push(status);
+  if (typeof input.live_tool_uses === "number") bits.push(`${input.live_tool_uses} tools`);
+  if (typeof input.live_duration_ms === "number") {
+    bits.push(`${Math.max(0, Math.round(Number(input.live_duration_ms) / 1e3))}s`);
+  }
+  const last = str2(input.live_last_tool);
+  if (last) bits.push(last);
+  return bits.length ? ` \xB7 ${bits.join(" \xB7 ")}` : "";
+}
 function isSubagentToolName(name) {
   const n = (name ?? "").trim();
   if (/^(task|agent|spawn_agent)$/i.test(n)) return true;
   return /connectedAgentRequest/i.test(n);
 }
+function isPollWrapperToolName(name) {
+  const n = (name ?? "").replace(/[_-]/g, "");
+  return /^(taskoutput|taskstop|sleep)$/i.test(n);
+}
+function lastTextPart(parts, type) {
+  for (let i = parts.length - 1; i >= 0; i--) {
+    const p = parts[i];
+    if (p.type === type && p.text.trim()) return p.text.trim();
+  }
+  return "";
+}
+function toolLabel(tool) {
+  return tool.description || toolDescription(tool.name, tool.input) || tool.name;
+}
+function liveActivitySummary(parts, opts) {
+  if (opts?.queued && parts.length === 0) {
+    return "Queued \u2014 waiting for a slot";
+  }
+  const tools = parts.filter((p) => p.type === "tool");
+  const runningSubs = tools.filter(
+    (t) => t.status === "running" && !t.parentId && isSubagentToolName(t.name)
+  );
+  const runningNested = [...tools].reverse().find((t) => t.status === "running" && t.parentId && !isPollWrapperToolName(t.name));
+  const runningTop = [...tools].reverse().find(
+    (t) => t.status === "running" && !t.parentId && !isPollWrapperToolName(t.name) && !isSubagentToolName(t.name)
+  );
+  const runningPoll = [...tools].reverse().find((t) => t.status === "running" && isPollWrapperToolName(t.name));
+  const thinking = lastTextPart(parts, "thinking");
+  const text4 = lastTextPart(parts, "text");
+  if (runningSubs.length > 0) {
+    const heads = runningSubs.map(toolLabel);
+    const head = runningSubs.length === 1 ? heads[0] : `${runningSubs.length} subagents \xB7 ${heads.slice(0, 2).join(" \xB7 ")}`;
+    if (runningNested) return `${head} \xB7 ${toolLabel(runningNested)}`;
+    return head;
+  }
+  if (runningTop) return toolLabel(runningTop);
+  if (runningPoll) return toolLabel(runningPoll);
+  if (thinking) return thinking.length > 96 ? `\u2026${thinking.slice(-96)}` : thinking;
+  if (text4) return "Writing reply\u2026";
+  const last = [...tools].reverse().find((t) => !isPollWrapperToolName(t.name)) ?? tools.at(-1);
+  if (last) {
+    const label = toolLabel(last);
+    return last.status === "running" ? label : `Finished ${label}`;
+  }
+  return "Working\u2026";
+}
 function messagePartParentId(part) {
   if ("parentId" in part && typeof part.parentId === "string" && part.parentId.trim()) {
     return part.parentId;
@@ -6876,6 +7009,25 @@ function applyAgentEvent(parts, event) {
     const data = event.data;
     if (!data) return parts;
     const next = [...parts];
+    if (event.replace) {
+      for (let i = next.length - 1; i >= 0; i--) {
+        const prev = next[i];
+        if (prev?.type === "thinking" && sameParentId(prev.parentId, event.parentId)) {
+          next[i] = {
+            type: "thinking",
+            text: data,
+            ...event.parentId ? { parentId: event.parentId } : {}
+          };
+          return next;
+        }
+      }
+      next.push({
+        type: "thinking",
+        text: data,
+        ...event.parentId ? { parentId: event.parentId } : {}
+      });
+      return next;
+    }
     const last = next[next.length - 1];
     if (last?.type === "thinking" && sameParentId(last.parentId, event.parentId)) {
       next[next.length - 1] = {
@@ -6899,14 +7051,18 @@ function applyAgentEvent(parts, event) {
     if (existing >= 0) {
       const prev = parts[existing];
       const next = [...parts];
-      const mergedInput = input && Object.keys(input).length > 0 ? input : prev.input ?? input;
+      const mergedInput = {
+        ...prev.input ?? {},
+        ...input ?? {}
+      };
+      const mergedRecord = Object.keys(mergedInput).length > 0 ? mergedInput : void 0;
       next[existing] = {
         ...prev,
         name: event.name || prev.name,
-        input: mergedInput,
-        description: toolDescription(event.name || prev.name, mergedInput),
-        detail: toolDetail(event.name || prev.name, mergedInput) ?? prev.detail,
-        filePath: toolFilePath(mergedInput) ?? prev.filePath,
+        input: mergedRecord,
+        description: toolDescription(event.name || prev.name, mergedRecord),
+        detail: toolDetail(event.name || prev.name, mergedRecord) ?? prev.detail,
+        filePath: toolFilePath(mergedRecord) ?? prev.filePath,
         additions: diff.additions ?? prev.additions,
         deletions: diff.deletions ?? prev.deletions,
         parentId: event.parentId ?? prev.parentId
@@ -6932,6 +7088,30 @@ function applyAgentEvent(parts, event) {
   if (event.type === "tool_result") {
     const existing = parts.findIndex((p) => p.type === "tool" && p.id === event.id);
     const fromResult = parseDiffStat(event.content);
+    if (event.partial) {
+      if (existing < 0) {
+        return [
+          ...parts,
+          {
+            type: "tool",
+            id: event.id,
+            name: "tool",
+            description: "tool",
+            status: event.isError ? "error" : "running",
+            result: event.content,
+            ...event.parentId ? { parentId: event.parentId } : {}
+          }
+        ];
+      }
+      return parts.map((p, i) => {
+        if (i !== existing || p.type !== "tool") return p;
+        if (p.status === "done" || p.status === "error") return p;
+        return {
+          ...p,
+          result: event.content ?? p.result
+        };
+      });
+    }
     if (existing < 0) {
       return [
         ...parts,
@@ -7017,47 +7197,68 @@ function electronResourcesPath() {
 function packagedCursorRuntimeDir() {
   const resources = electronResourcesPath();
   if (!resources) return null;
-  const dir = (0, import_node_path19.join)(resources, "cursor-runtime");
-  if (!(0, import_node_fs18.existsSync)((0, import_node_path19.join)(dir, "core-dist", "agents", "cursor-runner.js"))) return null;
+  const dir = (0, import_node_path20.join)(resources, "cursor-runtime");
+  if (!(0, import_node_fs19.existsSync)((0, import_node_path20.join)(dir, "core-dist", "agents", "cursor-runner.js"))) return null;
   return dir;
 }
 function packagedCursorRunnerPath() {
   const dir = packagedCursorRuntimeDir();
-  return dir ? (0, import_node_path19.join)(dir, "core-dist", "agents", "cursor-runner.js") : null;
+  return dir ? (0, import_node_path20.join)(dir, "core-dist", "agents", "cursor-runner.js") : null;
 }
 function packagedMcpDir() {
   const resources = electronResourcesPath();
   if (!resources) return null;
-  const dir = (0, import_node_path19.join)(resources, "sideboard-mcp");
-  if (!(0, import_node_fs18.existsSync)((0, import_node_path19.join)(dir, "core-dist", "mcp", "run-stdio.js"))) return null;
+  const dir = (0, import_node_path20.join)(resources, "sideboard-mcp");
+  if (!(0, import_node_fs19.existsSync)((0, import_node_path20.join)(dir, "core-dist", "mcp", "run-stdio.js"))) return null;
   return dir;
 }
 function packagedMcpStdioPath() {
   const dir = packagedMcpDir();
-  return dir ? (0, import_node_path19.join)(dir, "core-dist", "mcp", "run-stdio.js") : null;
+  return dir ? (0, import_node_path20.join)(dir, "core-dist", "mcp", "run-stdio.js") : null;
 }
 function packagedBundledNodePath() {
   const resources = electronResourcesPath();
   if (!resources) return null;
-  const bin = (0, import_node_path19.join)(resources, "node", "bin", "node");
-  if (!(0, import_node_fs18.existsSync)(bin)) return null;
+  const bin = (0, import_node_path20.join)(resources, "node", "bin", "node");
+  if (!(0, import_node_fs19.existsSync)(bin)) return null;
   return bin;
 }
 function packagedCursorRipgrepCandidate(platformPkg, binName) {
   const dir = packagedCursorRuntimeDir();
   if (!dir) return null;
-  return (0, import_node_path19.join)(dir, "node_modules", platformPkg, "bin", binName);
+  return (0, import_node_path20.join)(dir, "node_modules", platformPkg, "bin", binName);
 }
-var import_node_fs18, import_node_path19;
+var import_node_fs19, import_node_path20;
 var init_packaged_runtime = __esm({
   "src/agents/packaged-runtime.ts"() {
     "use strict";
-    import_node_fs18 = require("fs");
-    import_node_path19 = require("path");
+    import_node_fs19 = require("fs");
+    import_node_path20 = require("path");
   }
 });
 
 // src/agents/node-launch.ts
+function withMaxOldSpaceSize(nodeOptions, heapMb) {
+  const existing = (nodeOptions ?? "").trim();
+  const match = MAX_OLD_SPACE_FLAG.exec(existing);
+  if (match) {
+    const current = match[2] ? Number(match[2]) : 0;
+    if (Number.isFinite(current) && current >= heapMb) return existing;
+    return existing.replace(MAX_OLD_SPACE_FLAG, ` --max-old-space-size=${heapMb}`).trim();
+  }
+  return existing ? `${existing} --max-old-space-size=${heapMb}` : `--max-old-space-size=${heapMb}`;
+}
+function applyAgentRunnerHeapEnv(env) {
+  env.NODE_OPTIONS = withMaxOldSpaceSize(
+    env.NODE_OPTIONS,
+    AGENT_RUNNER_MAX_OLD_SPACE_MB
+  );
+}
+function envWithAgentHeap(env) {
+  const next = { ...env };
+  applyAgentRunnerHeapEnv(next);
+  return next;
+}
 function isAsarPath(filePath) {
   if (/\.asar\.unpacked([/\\]|$)/.test(filePath)) return false;
   return /\.asar([/\\]|$)/.test(filePath);
@@ -7066,7 +7267,7 @@ function unpackedAsarPath(filePath) {
   if (!isAsarPath(filePath)) return null;
   const unpacked = filePath.replace(/\.asar(?=[/\\])/, ".asar.unpacked");
   if (unpacked === filePath) return null;
-  return (0, import_node_fs19.existsSync)(unpacked) ? unpacked : null;
+  return (0, import_node_fs20.existsSync)(unpacked) ? unpacked : null;
 }
 function nodeReadableScriptPath(scriptPath) {
   return unpackedAsarPath(scriptPath) ?? scriptPath;
@@ -7106,37 +7307,37 @@ function pickPreferredNode(candidates) {
   return best;
 }
 function versionDirNodeBins(root, toBin) {
-  if (!(0, import_node_fs19.existsSync)(root)) return [];
+  if (!(0, import_node_fs20.existsSync)(root)) return [];
   try {
-    return (0, import_node_fs19.readdirSync)(root).map(toBin);
+    return (0, import_node_fs20.readdirSync)(root).map(toBin);
   } catch {
     return [];
   }
 }
 function defaultNodeBinCandidates(home = (0, import_node_os7.homedir)()) {
   const kegs = ["/opt/homebrew", "/usr/local"].flatMap(
-    (prefix) => PREFERRED_LTS_MAJORS.map((major) => (0, import_node_path20.join)(prefix, "opt", `node@${major}`, "bin", "node"))
+    (prefix) => PREFERRED_LTS_MAJORS.map((major) => (0, import_node_path21.join)(prefix, "opt", `node@${major}`, "bin", "node"))
   );
   return [
     ...kegs,
     "/opt/homebrew/bin/node",
     "/usr/local/bin/node",
-    (0, import_node_path20.join)(home, ".local/share/fnm/aliases/default/bin/node"),
-    (0, import_node_path20.join)(home, ".nvm/current/bin/node"),
-    (0, import_node_path20.join)(home, ".volta/bin/node"),
-    (0, import_node_path20.join)(home, ".asdf/shims/node"),
-    (0, import_node_path20.join)(home, ".local/share/mise/shims/node"),
+    (0, import_node_path21.join)(home, ".local/share/fnm/aliases/default/bin/node"),
+    (0, import_node_path21.join)(home, ".nvm/current/bin/node"),
+    (0, import_node_path21.join)(home, ".volta/bin/node"),
+    (0, import_node_path21.join)(home, ".asdf/shims/node"),
+    (0, import_node_path21.join)(home, ".local/share/mise/shims/node"),
     ...versionDirNodeBins(
-      (0, import_node_path20.join)(home, ".nvm", "versions", "node"),
-      (name) => (0, import_node_path20.join)(home, ".nvm", "versions", "node", name, "bin", "node")
+      (0, import_node_path21.join)(home, ".nvm", "versions", "node"),
+      (name) => (0, import_node_path21.join)(home, ".nvm", "versions", "node", name, "bin", "node")
     ),
     ...versionDirNodeBins(
-      (0, import_node_path20.join)(home, ".local/share/fnm", "node-versions"),
-      (name) => (0, import_node_path20.join)(home, ".local/share/fnm", "node-versions", name, "installation", "bin", "node")
+      (0, import_node_path21.join)(home, ".local/share/fnm", "node-versions"),
+      (name) => (0, import_node_path21.join)(home, ".local/share/fnm", "node-versions", name, "installation", "bin", "node")
     ),
     ...versionDirNodeBins(
-      (0, import_node_path20.join)(home, ".volta", "tools", "image", "node"),
-      (name) => (0, import_node_path20.join)(home, ".volta", "tools", "image", "node", name, "bin", "node")
+      (0, import_node_path21.join)(home, ".volta", "tools", "image", "node"),
+      (name) => (0, import_node_path21.join)(home, ".volta", "tools", "image", "node", name, "bin", "node")
     )
   ];
 }
@@ -7145,10 +7346,10 @@ function uniqueExistingNodeBins(paths) {
   const out = [];
   for (const raw of paths) {
     const p = raw.trim();
-    if (!p || !(0, import_node_fs19.existsSync)(p) || isElectronLikeCommand(p)) continue;
+    if (!p || !(0, import_node_fs20.existsSync)(p) || isElectronLikeCommand(p)) continue;
     let key = p;
     try {
-      key = (0, import_node_fs19.realpathSync)(p);
+      key = (0, import_node_fs20.realpathSync)(p);
     } catch {
       continue;
     }
@@ -7193,13 +7394,21 @@ async function findSystemNode() {
 function applyNodeLaunch(launch, args) {
   const readableArgs = args.map(nodeReadableScriptPath);
   if (!launch.env.ELECTRON_RUN_AS_NODE) {
-    return { file: launch.file, args: readableArgs, env: launch.env };
+    return {
+      file: launch.file,
+      args: readableArgs,
+      env: envWithAgentHeap(launch.env)
+    };
   }
   const wrapped = wrapElectronAsNodeLaunch(launch.file, readableArgs);
   if (process.platform === "win32") {
-    return { file: wrapped.file, args: wrapped.args, env: launch.env };
+    return {
+      file: wrapped.file,
+      args: wrapped.args,
+      env: envWithAgentHeap(launch.env)
+    };
   }
-  const env = { ...launch.env };
+  const env = envWithAgentHeap(launch.env);
   delete env.ELECTRON_RUN_AS_NODE;
   return { file: wrapped.file, args: wrapped.args, env };
 }
@@ -7220,16 +7429,18 @@ async function resolveNodeLaunch(scriptPath) {
     env: { ELECTRON_RUN_AS_NODE: "1" }
   };
 }
-var import_node_fs19, import_node_os7, import_node_path20, PREFERRED_LTS_MAJORS;
+var import_node_fs20, import_node_os7, import_node_path21, AGENT_RUNNER_MAX_OLD_SPACE_MB, MAX_OLD_SPACE_FLAG, PREFERRED_LTS_MAJORS;
 var init_node_launch = __esm({
   "src/agents/node-launch.ts"() {
     "use strict";
-    import_node_fs19 = require("fs");
+    import_node_fs20 = require("fs");
     import_node_os7 = require("os");
-    import_node_path20 = require("path");
+    import_node_path21 = require("path");
     init_nested_electron_env();
     init_run();
     init_packaged_runtime();
+    AGENT_RUNNER_MAX_OLD_SPACE_MB = 8192;
+    MAX_OLD_SPACE_FLAG = /(?:^|\s)(--max[-_]old[-_]space[-_]size)(?:[= ](\d+))?(?=\s|$)/;
     PREFERRED_LTS_MAJORS = [24, 22, 20];
   }
 });
@@ -7317,37 +7528,37 @@ function corePackageDir() {
   try {
     const url = import_meta.url;
     if (typeof url === "string" && url.length > 0) {
-      return (0, import_node_path21.dirname)((0, import_node_url.fileURLToPath)(url));
+      return (0, import_node_path22.dirname)((0, import_node_url.fileURLToPath)(url));
     }
   } catch {
   }
   try {
-    const req = (0, import_node_module.createRequire)((0, import_node_path21.join)(process.cwd(), "package.json"));
-    return (0, import_node_path21.dirname)(req.resolve("@sideboard-ai/core"));
+    const req = (0, import_node_module.createRequire)((0, import_node_path22.join)(process.cwd(), "package.json"));
+    return (0, import_node_path22.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_fs20.existsSync)(override)) return override;
+  if (override && (0, import_node_fs21.existsSync)(override)) return override;
   const packaged = packagedMcpStdioPath();
   if (packaged) return packaged;
   let dir = corePackageDir();
   for (let i = 0; i < 10; i++) {
     const candidates = [
-      (0, import_node_path21.join)(dir, "mcp/run-stdio.js"),
-      (0, import_node_path21.join)(dir, "mcp/run-stdio.cjs"),
-      (0, import_node_path21.join)(dir, "dist/mcp/run-stdio.js"),
-      (0, import_node_path21.join)(dir, "dist/mcp/run-stdio.cjs"),
-      (0, import_node_path21.join)(dir, "packages/core/dist/mcp/run-stdio.js"),
-      (0, import_node_path21.join)(dir, "packages/cli/dist/index.js"),
-      (0, import_node_path21.join)(dir, "cli/dist/index.js")
+      (0, import_node_path22.join)(dir, "mcp/run-stdio.js"),
+      (0, import_node_path22.join)(dir, "mcp/run-stdio.cjs"),
+      (0, import_node_path22.join)(dir, "dist/mcp/run-stdio.js"),
+      (0, import_node_path22.join)(dir, "dist/mcp/run-stdio.cjs"),
+      (0, import_node_path22.join)(dir, "packages/core/dist/mcp/run-stdio.js"),
+      (0, import_node_path22.join)(dir, "packages/cli/dist/index.js"),
+      (0, import_node_path22.join)(dir, "cli/dist/index.js")
     ];
     for (const p of candidates) {
-      if ((0, import_node_fs20.existsSync)(p) && !isAsarPath(p)) return p;
+      if ((0, import_node_fs21.existsSync)(p) && !isAsarPath(p)) return p;
     }
-    const parent = (0, import_node_path21.dirname)(dir);
+    const parent = (0, import_node_path22.dirname)(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -7395,6 +7606,7 @@ async function buildInjectedMcpServers(opts) {
       );
     } catch {
     }
+    applyAgentRunnerHeapEnv(sideboard.env);
     servers.push(sideboard);
   }
   if (opts.includeBrightsy && isBrightsyConnected()) {
@@ -7488,19 +7700,19 @@ function writeMcpServersConfig(servers) {
       ...env ? { env } : {}
     };
   }
-  const dir = (0, import_node_fs20.mkdtempSync)((0, import_node_path21.join)((0, import_node_os8.tmpdir)(), "sideboard-mcp-"));
-  const cfgPath = (0, import_node_path21.join)(dir, "mcp.json");
-  (0, import_node_fs20.writeFileSync)(cfgPath, JSON.stringify({ mcpServers }, null, 2));
+  const dir = (0, import_node_fs21.mkdtempSync)((0, import_node_path22.join)((0, import_node_os8.tmpdir)(), "sideboard-mcp-"));
+  const cfgPath = (0, import_node_path22.join)(dir, "mcp.json");
+  (0, import_node_fs21.writeFileSync)(cfgPath, JSON.stringify({ mcpServers }, null, 2));
   return cfgPath;
 }
-var import_node_fs20, import_node_module, import_node_os8, import_node_path21, import_node_url, import_meta, SIDEBOARD_MCP_ALLOWED_TOOLS, SIDEBOARD_ARTIFACT_MCP_ALLOWED_TOOLS, brightsyMcpCommandCache, BRIGHTSY_WORD;
+var import_node_fs21, import_node_module, import_node_os8, import_node_path22, 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_fs20 = require("fs");
+    import_node_fs21 = require("fs");
     import_node_module = require("module");
     import_node_os8 = require("os");
-    import_node_path21 = require("path");
+    import_node_path22 = require("path");
     import_node_url = require("url");
     init_run();
     init_config();
@@ -7674,6 +7886,80 @@ function claudeParentToolUseId(obj) {
   }
   return void 0;
 }
+function claudeString(obj, key) {
+  const v = obj[key];
+  return typeof v === "string" && v.trim() ? v.trim() : void 0;
+}
+function eventsFromClaudeSystem(obj) {
+  const subtype = claudeString(obj, "subtype") ?? "";
+  const parentId = claudeParentToolUseId(obj);
+  if (subtype === "init") {
+    if (parentId) return null;
+    const sid = claudeString(obj, "session_id");
+    return sid ? { type: "session_id", data: sid } : null;
+  }
+  if (subtype === "task_started") {
+    const id = claudeString(obj, "tool_use_id") ?? claudeString(obj, "task_id");
+    if (!id) return null;
+    const description = claudeString(obj, "description");
+    const taskType = claudeString(obj, "task_type");
+    const prompt = claudeString(obj, "prompt");
+    return withEventParentId(
+      {
+        type: "tool_use",
+        id,
+        name: taskType || "Agent",
+        input: {
+          ...description ? { description } : {},
+          ...prompt ? { prompt } : {},
+          ...claudeString(obj, "task_id") ? { task_id: claudeString(obj, "task_id") } : {}
+        }
+      },
+      parentId
+    );
+  }
+  if (subtype === "task_notification") {
+    const id = claudeString(obj, "tool_use_id") ?? claudeString(obj, "task_id") ?? parentId;
+    if (!id) return null;
+    const status = claudeString(obj, "status") ?? "working";
+    const tools = typeof obj.tool_uses === "number" ? obj.tool_uses : void 0;
+    const durationMs = typeof obj.duration_ms === "number" ? obj.duration_ms : void 0;
+    const lastTool = claudeString(obj, "last_tool") ?? claudeString(obj, "current_tool") ?? claudeString(obj, "tool");
+    const snapshot = [
+      status,
+      tools != null ? `${tools} tools` : null,
+      durationMs != null ? `${Math.round(durationMs / 1e3)}s` : null,
+      lastTool
+    ].filter((bit) => Boolean(bit)).join(" \xB7 ");
+    return [
+      {
+        type: "tool_use",
+        id,
+        name: claudeString(obj, "task_type") || "Agent",
+        input: {
+          live_status: status,
+          ...tools != null ? { live_tool_uses: tools } : {},
+          ...durationMs != null ? { live_duration_ms: durationMs } : {},
+          ...lastTool ? { live_last_tool: lastTool } : {}
+        }
+      },
+      withEventParentId(
+        { type: "thinking", data: snapshot, replace: true },
+        id
+      )
+    ];
+  }
+  if (subtype === "api_retry") {
+    const attempt = obj.attempt;
+    const max = obj.max_retries;
+    const delay = obj.retry_delay_ms;
+    return {
+      type: "thinking",
+      data: `API retry ${attempt ?? "?"}/${max ?? "?"}${typeof delay === "number" ? ` (wait ${delay}ms)` : ""}`
+    };
+  }
+  return null;
+}
 function parseIssuesJson(raw) {
   const text4 = raw.trim();
   const candidates = [text4];
@@ -7699,11 +7985,11 @@ function parseIssuesJson(raw) {
   }
   return [];
 }
-var import_node_fs21, BASE_ALLOWED_TOOLS, CLAUDE_CHROME_ALLOWED_TOOLS, CLAUDE_PROMPT_ARG_MAX, claudeAdapter;
+var import_node_fs22, BASE_ALLOWED_TOOLS, CLAUDE_PRINT_BG_WAIT_CEILING_MS, CLAUDE_CHROME_ALLOWED_TOOLS, CLAUDE_PROMPT_ARG_MAX, claudeAdapter;
 var init_claude = __esm({
   "src/agents/claude.ts"() {
     "use strict";
-    import_node_fs21 = require("fs");
+    import_node_fs22 = require("fs");
     init_run();
     init_app_settings();
     init_claude_mcp();
@@ -7723,8 +8009,14 @@ var init_claude = __esm({
       "WebSearch",
       // Subagents (Claude Code v2.1.63 renamed Task → Agent; allow both).
       "Task",
-      "Agent"
+      "Agent",
+      "TaskOutput",
+      "TaskStop",
+      "EnterWorktree",
+      "ExitWorktree",
+      "Skill"
     ];
+    CLAUDE_PRINT_BG_WAIT_CEILING_MS = 72e5;
     CLAUDE_CHROME_ALLOWED_TOOLS = [
       "mcp__claude-in-chrome",
       "mcp__claude-in-chrome__*",
@@ -7736,7 +8028,7 @@ var init_claude = __esm({
       async detect() {
         const claude = resolveClaudeExecutable();
         if (claude !== "claude") {
-          if (!(0, import_node_fs21.existsSync)(claude)) {
+          if (!(0, import_node_fs22.existsSync)(claude)) {
             return {
               agent: "claude",
               installed: false,
@@ -7853,7 +8145,12 @@ var init_claude = __esm({
           stdin: useStdin ? `${promptText}
 ` : void 0,
           // Nested Task/Agent thinking+text in stream-json (Claude Code 2.1.211+).
-          env: { CLAUDE_CODE_FORWARD_SUBAGENT_TEXT: "1" }
+          // Raise the -p background-agent wait so long TaskOutput polls are not
+          // abandoned at Claude Code’s 10-minute default.
+          env: {
+            CLAUDE_CODE_FORWARD_SUBAGENT_TEXT: "1",
+            CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS: process.env.CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS ?? String(CLAUDE_PRINT_BG_WAIT_CEILING_MS)
+          }
         };
       },
       parseEvent(line) {
@@ -7861,13 +8158,8 @@ var init_claude = __esm({
         if (!trimmed) return null;
         try {
           const obj = JSON.parse(trimmed);
-          if (obj.type === "system" && obj.subtype === "init") {
-            const sid = obj.session_id;
-            if (typeof sid === "string") return { type: "session_id", data: sid };
-            return null;
-          }
-          if (obj.type === "system" && typeof obj.session_id === "string") {
-            return { type: "session_id", data: obj.session_id };
+          if (obj.type === "system") {
+            return eventsFromClaudeSystem(obj);
           }
           if (obj.type === "assistant" || obj.type === "user") {
             const parentId = claudeParentToolUseId(obj);
@@ -7987,7 +8279,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_fs22.existsSync)(codex)) {
+  } else if (!(0, import_node_fs23.existsSync)(codex)) {
     return FALLBACK_CODEX_MODELS;
   }
   const listed = await run(codex, ["debug", "models"], { reject: false });
@@ -8022,12 +8314,12 @@ function usageFromCodex(usage) {
 }
 function codexConfigHasNetworkAccess() {
   const candidates = [
-    (0, import_node_path22.join)((0, import_node_os9.homedir)(), ".codex", "config.toml"),
-    (0, import_node_path22.join)((0, import_node_os9.homedir)(), ".config", "codex", "config.toml")
+    (0, import_node_path23.join)((0, import_node_os9.homedir)(), ".codex", "config.toml"),
+    (0, import_node_path23.join)((0, import_node_os9.homedir)(), ".config", "codex", "config.toml")
   ];
   for (const path of candidates) {
-    if (!(0, import_node_fs22.existsSync)(path)) continue;
-    const text4 = (0, import_node_fs22.readFileSync)(path, "utf8");
+    if (!(0, import_node_fs23.existsSync)(path)) continue;
+    const text4 = (0, import_node_fs23.readFileSync)(path, "utf8");
     if (/network_access\s*=\s*true/.test(text4)) return true;
   }
   return false;
@@ -8059,21 +8351,21 @@ function asRecord2(value) {
   return void 0;
 }
 function codexLooksAuthenticated() {
-  const authPath = (0, import_node_path22.join)((0, import_node_os9.homedir)(), ".codex", "auth.json");
-  if (!(0, import_node_fs22.existsSync)(authPath)) return false;
+  const authPath = (0, import_node_path23.join)((0, import_node_os9.homedir)(), ".codex", "auth.json");
+  if (!(0, import_node_fs23.existsSync)(authPath)) return false;
   try {
-    return (0, import_node_fs22.statSync)(authPath).size > 2;
+    return (0, import_node_fs23.statSync)(authPath).size > 2;
   } catch {
     return false;
   }
 }
-var import_node_fs22, import_node_os9, import_node_path22, CODEX_PROMPT_ARG_MAX, FALLBACK_CODEX_MODELS, cachedCodexModels, CODEX_MODEL_CACHE_MS, codexAdapter;
+var import_node_fs23, import_node_os9, import_node_path23, 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_fs22 = require("fs");
+    import_node_fs23 = require("fs");
     import_node_os9 = require("os");
-    import_node_path22 = require("path");
+    import_node_path23 = require("path");
     init_run();
     init_app_settings();
     init_global_workspace();
@@ -8098,7 +8390,7 @@ var init_codex = __esm({
       async detect() {
         const codex = resolveAgentExecutable("codex");
         if (codex !== "codex") {
-          if (!(0, import_node_fs22.existsSync)(codex)) {
+          if (!(0, import_node_fs23.existsSync)(codex)) {
             return {
               agent: "codex",
               installed: false,
@@ -8238,13 +8530,22 @@ var init_codex = __esm({
               const events = [
                 { type: "tool_use", id: item.id, name: "Bash", input }
               ];
-              if (type === "item.completed" || item.status === "completed" || item.status === "failed") {
+              const finished = type === "item.completed" || item.status === "completed" || item.status === "failed";
+              const output = typeof item.aggregated_output === "string" && item.aggregated_output ? item.aggregated_output : void 0;
+              if (finished) {
                 events.push({
                   type: "tool_result",
                   id: item.id,
-                  content: item.aggregated_output,
+                  content: output,
                   isError: item.status === "failed"
                 });
+              } else if (output) {
+                events.push({
+                  type: "tool_result",
+                  id: item.id,
+                  content: output,
+                  partial: true
+                });
               }
               return events.length === 1 ? events[0] : events;
             }
@@ -8287,9 +8588,6 @@ var init_codex = __esm({
           if (sid && (type === "thread.started" || type === "session" || !type)) {
             return { type: "session_id", data: sid };
           }
-          if (sid && type.endsWith(".started")) {
-            return { type: "session_id", data: sid };
-          }
           if (type === "turn.completed" || type === "turn_completed") {
             const usage = usageFromCodex(obj.usage);
             return usage ? { type: "usage", data: usage, scope: "turn" } : null;
@@ -8463,7 +8761,7 @@ function cursorSdkMessageToEvents(msg) {
   if (msg.type === "tool_call" && msg.call_id && msg.name) {
     const normalized = normalizeCursorToolCall(msg.name, msg.args);
     if (msg.status === "running") {
-      return [
+      const events = [
         {
           type: "tool_use",
           id: msg.call_id,
@@ -8471,6 +8769,16 @@ function cursorSdkMessageToEvents(msg) {
           input: normalized.input
         }
       ];
+      const live = unwrapCursorToolResult(msg.result);
+      if (live) {
+        events.push({
+          type: "tool_result",
+          id: msg.call_id,
+          content: live,
+          partial: true
+        });
+      }
+      return events;
     }
     if (msg.status === "completed" || msg.status === "error") {
       return [
@@ -8537,21 +8845,21 @@ function platformRipgrepPackage() {
 }
 function usableRipgrepPath(candidate) {
   const raw = candidate?.trim();
-  if (!raw || !(0, import_node_path23.isAbsolute)(raw)) return null;
+  if (!raw || !(0, import_node_path24.isAbsolute)(raw)) return null;
   const readable = nodeReadableScriptPath(raw);
-  if (!(0, import_node_fs23.existsSync)(readable) || isAsarPath(readable)) return null;
+  if (!(0, import_node_fs24.existsSync)(readable) || isAsarPath(readable)) return null;
   return readable;
 }
 function walkForBundledRipgrep(startFile) {
   if (!startFile) return null;
   const pkg = platformRipgrepPackage();
   const name = rgBinaryName();
-  let dir = (0, import_node_path23.dirname)((0, import_node_path23.resolve)(startFile));
-  const root = (0, import_node_path23.parse)(dir).root;
+  let dir = (0, import_node_path24.dirname)((0, import_node_path24.resolve)(startFile));
+  const root = (0, import_node_path24.parse)(dir).root;
   while (dir !== root) {
-    const hit = usableRipgrepPath((0, import_node_path23.join)(dir, "node_modules", pkg, "bin", name));
+    const hit = usableRipgrepPath((0, import_node_path24.join)(dir, "node_modules", pkg, "bin", name));
     if (hit) return hit;
-    const next = (0, import_node_path23.dirname)(dir);
+    const next = (0, import_node_path24.dirname)(dir);
     if (next === dir) break;
     dir = next;
   }
@@ -8561,7 +8869,7 @@ function requireResolveBundledRipgrep(fromFile) {
   try {
     const req = (0, import_node_module2.createRequire)(fromFile);
     const pkgJson = req.resolve(`${platformRipgrepPackage()}/package.json`);
-    return usableRipgrepPath((0, import_node_path23.join)((0, import_node_path23.dirname)(pkgJson), "bin", rgBinaryName()));
+    return usableRipgrepPath((0, import_node_path24.join)((0, import_node_path24.dirname)(pkgJson), "bin", rgBinaryName()));
   } catch {
     return null;
   }
@@ -8583,13 +8891,13 @@ function cursorRipgrepEnv(opts) {
   const path = resolveCursorRipgrepPath(opts);
   return path ? { [RIPGREP_ENV]: path } : {};
 }
-var import_node_fs23, import_node_module2, import_node_path23, RIPGREP_ENV;
+var import_node_fs24, import_node_module2, import_node_path24, RIPGREP_ENV;
 var init_cursor_ripgrep = __esm({
   "src/agents/cursor-ripgrep.ts"() {
     "use strict";
-    import_node_fs23 = require("fs");
+    import_node_fs24 = require("fs");
     import_node_module2 = require("module");
-    import_node_path23 = require("path");
+    import_node_path24 = require("path");
     init_node_launch();
     init_packaged_runtime();
     RIPGREP_ENV = "CURSOR_RIPGREP_PATH";
@@ -8635,11 +8943,11 @@ function entryDir() {
   const cjsDir = typeof __dirname !== "undefined" ? __dirname : "";
   if (cjsDir) return cjsDir;
   try {
-    return (0, import_node_path24.dirname)((0, import_node_url2.fileURLToPath)(import_meta2.url));
+    return (0, import_node_path25.dirname)((0, import_node_url2.fileURLToPath)(import_meta2.url));
   } catch {
     try {
       const req = (0, import_node_module3.createRequire)(process.cwd() + "/");
-      return (0, import_node_path24.dirname)(req.resolve("@sideboard-ai/core"));
+      return (0, import_node_path25.dirname)(req.resolve("@sideboard-ai/core"));
     } catch {
       return process.cwd();
     }
@@ -8650,27 +8958,27 @@ function cursorRunnerPath() {
   if (packaged) return packaged;
   const root = entryDir();
   const candidates = [
-    (0, import_node_path24.join)(root, "agents", "cursor-runner.js"),
-    (0, import_node_path24.join)(root, "agents", "cursor-runner.cjs"),
+    (0, import_node_path25.join)(root, "agents", "cursor-runner.js"),
+    (0, import_node_path25.join)(root, "agents", "cursor-runner.cjs"),
     // If somehow resolved from package root instead of dist/
-    (0, import_node_path24.join)(root, "dist", "agents", "cursor-runner.js"),
-    (0, import_node_path24.join)(root, "dist", "agents", "cursor-runner.cjs"),
+    (0, import_node_path25.join)(root, "dist", "agents", "cursor-runner.js"),
+    (0, import_node_path25.join)(root, "dist", "agents", "cursor-runner.cjs"),
     // Source tree (dev): packages/core/src/agents/cursor-runner.ts
-    (0, import_node_path24.join)(root, "cursor-runner.ts"),
-    (0, import_node_path24.join)(root, "src", "agents", "cursor-runner.ts")
+    (0, import_node_path25.join)(root, "cursor-runner.ts"),
+    (0, import_node_path25.join)(root, "src", "agents", "cursor-runner.ts")
   ];
   for (const candidate of candidates) {
-    if ((0, import_node_fs24.existsSync)(candidate)) return candidate;
+    if ((0, import_node_fs25.existsSync)(candidate)) return candidate;
   }
   return candidates[0];
 }
-var import_node_fs24, import_node_module3, import_node_path24, import_node_url2, import_sdk, import_meta2, FALLBACK_CURSOR_MODELS, cachedModels, MODEL_CACHE_MS, cursorAdapter;
+var import_node_fs25, import_node_module3, import_node_path25, 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_fs24 = require("fs");
+    import_node_fs25 = require("fs");
     import_node_module3 = require("module");
-    import_node_path24 = require("path");
+    import_node_path25 = require("path");
     import_node_url2 = require("url");
     import_sdk = require("@cursor/sdk");
     init_run();
@@ -8820,7 +9128,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_fs25.existsSync)(opencode)) {
+  } else if (!(0, import_node_fs26.existsSync)(opencode)) {
     return FALLBACK_OPENCODE_MODELS;
   }
   const listed = await run(opencode, ["models"], { reject: false });
@@ -8850,11 +9158,11 @@ function usageFromOpencode(tokens) {
     cacheWriteTokens: tokens.cache?.write ? Number(tokens.cache.write) : void 0
   };
 }
-var import_node_fs25, FALLBACK_OPENCODE_MODELS, cachedOpencodeModels, OPENCODE_MODEL_CACHE_MS, opencodeAdapter;
+var import_node_fs26, FALLBACK_OPENCODE_MODELS, cachedOpencodeModels, OPENCODE_MODEL_CACHE_MS, opencodeAdapter;
 var init_opencode = __esm({
   "src/agents/opencode.ts"() {
     "use strict";
-    import_node_fs25 = require("fs");
+    import_node_fs26 = require("fs");
     init_run();
     init_app_settings();
     init_global_workspace();
@@ -8881,7 +9189,7 @@ var init_opencode = __esm({
       async detect() {
         const opencode = resolveAgentExecutable("opencode");
         if (opencode !== "opencode") {
-          if (!(0, import_node_fs25.existsSync)(opencode)) {
+          if (!(0, import_node_fs26.existsSync)(opencode)) {
             return {
               agent: "opencode",
               installed: false,
@@ -8967,7 +9275,8 @@ var init_opencode = __esm({
             return { type: "stderr", data: detail };
           }
           const sid = typeof obj.sessionID === "string" && obj.sessionID || typeof obj.sessionId === "string" && obj.sessionId || typeof obj.session_id === "string" && obj.session_id;
-          if (sid && (!obj.type || obj.type === "step_start" || obj.type === "session")) {
+          const childSid = str3(obj.childSessionID) ?? str3(obj.childSessionId) ?? str3(obj.parentID) ?? str3(obj.parentId);
+          if (sid && !childSid && (!obj.type || obj.type === "step_start" || obj.type === "session")) {
             return { type: "session_id", data: sid };
           }
           if (obj.type === "text") {
@@ -8987,13 +9296,16 @@ var init_opencode = __esm({
             );
             const events = [{ type: "tool_use", id, name, input }];
             const output = state?.output;
-            if (output != null || state?.status === "completed" || state?.status === "error") {
+            const finished = state?.status === "completed" || state?.status === "error" || state?.status === "failed";
+            const running = state?.status === "running" || state?.status === "in_progress" || state?.status === "pending";
+            if (output != null || finished) {
               const content = typeof output === "string" ? output : output != null ? JSON.stringify(output) : formatUnknownDetail(state?.error) || void 0;
               events.push({
                 type: "tool_result",
                 id,
                 content,
-                isError: state?.status === "error" || state?.status === "failed"
+                isError: state?.status === "error" || state?.status === "failed",
+                ...running && !finished ? { partial: true } : {}
               });
             }
             return events.length === 1 ? events[0] : events;
@@ -9028,14 +9340,17 @@ var init_opencode = __esm({
                 withEventParentId({ type: "tool_use", id, name, input }, parentId)
               ];
               const output = state?.output ?? part.output;
-              if (output != null || state?.status === "completed" || state?.status === "error") {
+              const finished = state?.status === "completed" || state?.status === "error" || state?.status === "failed";
+              const running = state?.status === "running" || state?.status === "in_progress" || state?.status === "pending";
+              if (output != null || finished) {
                 nested.push(
                   withEventParentId(
                     {
                       type: "tool_result",
                       id,
                       content: typeof output === "string" ? output : output != null ? JSON.stringify(output) : void 0,
-                      isError: state?.status === "error" || state?.status === "failed"
+                      isError: state?.status === "error" || state?.status === "failed",
+                      ...running && !finished ? { partial: true } : {}
                     },
                     parentId
                   )
@@ -9698,6 +10013,11 @@ function createAgentStreamCoalescer(emit, opts) {
         return;
       }
       if (!event.data) return;
+      if (event.type === "thinking" && event.replace) {
+        flush2();
+        emit(event);
+        return;
+      }
       if (pending && pending.type === event.type && parentKey(pending) === parentKey(event)) {
         pending.data += event.data;
       } else {
@@ -9754,6 +10074,7 @@ async function spawnAgentTurn(thread, input, onEvent) {
   }
   const env = childEnvWithAppSettings(cmd.env);
   applyPromptCacheTtlEnv(thread.agent, env);
+  applyAgentRunnerHeapEnv(env);
   try {
     if (isOrchestratorThread(thread)) {
       mergeAgentGitAuthEnv(env, await resolveAgentGitAuthEnv(env));
@@ -9861,9 +10182,11 @@ var init_spawn = __esm({
     init_agents();
     init_orchestrator_capable();
     init_message_parts();
+    init_node_launch();
     init_path();
     init_usage();
     init_cursor_stream_coalesce();
+    init_node_launch();
   }
 });
 
@@ -10589,21 +10912,21 @@ function shouldRefreshReviewRequestTemplate(content) {
   return LEGACY_REVIEW_TEMPLATE_MARKERS.every((m) => trimmed.includes(m));
 }
 function readTextIfPresent(abs) {
-  if (!(0, import_node_fs26.existsSync)(abs)) return null;
+  if (!(0, import_node_fs27.existsSync)(abs)) return null;
   try {
-    const content = (0, import_node_fs26.readFileSync)(abs, "utf8");
+    const content = (0, import_node_fs27.readFileSync)(abs, "utf8");
     return content.trim() ? content : null;
   } catch {
     return null;
   }
 }
 function readLocalGuidelines(worktreePath) {
-  const localAbs = (0, import_node_path25.join)(worktreePath, REVIEW_REQUEST_PATH);
+  const localAbs = (0, import_node_path26.join)(worktreePath, REVIEW_REQUEST_PATH);
   const localContent = readTextIfPresent(localAbs);
   if (localContent && !shouldRefreshReviewRequestTemplate(localContent)) {
     return { path: REVIEW_REQUEST_PATH, content: localContent };
   }
-  const legacyAbs = (0, import_node_path25.join)(worktreePath, LEGACY_REVIEW_REQUEST_PATH);
+  const legacyAbs = (0, import_node_path26.join)(worktreePath, LEGACY_REVIEW_REQUEST_PATH);
   const legacyContent = readTextIfPresent(legacyAbs);
   if (legacyContent && !shouldRefreshReviewRequestTemplate(legacyContent)) {
     return { path: LEGACY_REVIEW_REQUEST_PATH, content: legacyContent };
@@ -10619,20 +10942,20 @@ function skillGuidelines(content, source) {
   };
 }
 function ensureReviewSkillFile(worktreePath) {
-  const abs = (0, import_node_path25.join)(worktreePath, REVIEW_SKILL_PATH);
+  const abs = (0, import_node_path26.join)(worktreePath, REVIEW_SKILL_PATH);
   const existing = readTextIfPresent(abs);
   if (existing) {
     return { path: REVIEW_SKILL_PATH, content: existing, wrote: false };
   }
-  const fromRepo = readTextIfPresent((0, import_node_path25.join)(worktreePath, REPO_REVIEW_PATH));
+  const fromRepo = readTextIfPresent((0, import_node_path26.join)(worktreePath, REPO_REVIEW_PATH));
   const fromLocal = readLocalGuidelines(worktreePath)?.content ?? null;
   const content = wrapReviewSkillMarkdown(fromRepo ?? fromLocal ?? REVIEW_REQUEST_TEMPLATE);
-  (0, import_node_fs26.mkdirSync)((0, import_node_path25.dirname)(abs), { recursive: true });
-  (0, import_node_fs26.writeFileSync)(abs, content, "utf8");
+  (0, import_node_fs27.mkdirSync)((0, import_node_path26.dirname)(abs), { recursive: true });
+  (0, import_node_fs27.writeFileSync)(abs, content, "utf8");
   return { path: REVIEW_SKILL_PATH, content, wrote: true };
 }
 function resolveReviewGuidelines(worktreePath) {
-  const skillContent = readTextIfPresent((0, import_node_path25.join)(worktreePath, REVIEW_SKILL_PATH));
+  const skillContent = readTextIfPresent((0, import_node_path26.join)(worktreePath, REVIEW_SKILL_PATH));
   if (skillContent) return skillGuidelines(skillContent, "skill");
   const local = readLocalGuidelines(worktreePath);
   if (local) {
@@ -10682,13 +11005,13 @@ async function requestReview(threadRef, send) {
   const started = await send(tab.id, REVIEW_REQUEST_PREFILL);
   return { tab: started, from };
 }
-var import_node_crypto5, import_node_fs26, import_node_path25, REPO_REVIEW_PATH, REPO_REVIEW_NAME, REVIEW_REQUEST_PATH, LEGACY_REVIEW_REQUEST_PATH, REVIEW_REQUEST_NAME, REVIEW_REQUEST_PREFILL, LEGACY_REVIEW_TEMPLATE_MARKERS;
+var import_node_crypto5, import_node_fs27, import_node_path26, REPO_REVIEW_PATH, REPO_REVIEW_NAME, REVIEW_REQUEST_PATH, LEGACY_REVIEW_REQUEST_PATH, REVIEW_REQUEST_NAME, REVIEW_REQUEST_PREFILL, LEGACY_REVIEW_TEMPLATE_MARKERS;
 var init_request_review = __esm({
   "src/review/request-review.ts"() {
     "use strict";
     import_node_crypto5 = require("crypto");
-    import_node_fs26 = require("fs");
-    import_node_path25 = require("path");
+    import_node_fs27 = require("fs");
+    import_node_path26 = require("path");
     init_global_workspace();
     init_chat_tabs();
     init_thread_store();
@@ -10713,9 +11036,9 @@ function matchSimpleGlob(pattern, name) {
   return new RegExp(`^${escaped}$`).test(name);
 }
 function readWorktreeInclude(repoPath) {
-  const path = (0, import_node_path26.join)(repoPath, ".worktreeinclude");
-  if (!(0, import_node_fs27.existsSync)(path)) return [];
-  return (0, import_node_fs27.readFileSync)(path, "utf8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+  const path = (0, import_node_path27.join)(repoPath, ".worktreeinclude");
+  if (!(0, import_node_fs28.existsSync)(path)) return [];
+  return (0, import_node_fs28.readFileSync)(path, "utf8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
 }
 function resolveFilesToCopy(repoPath) {
   const fromInclude = readWorktreeInclude(repoPath);
@@ -10725,10 +11048,10 @@ function resolveFilesToCopy(repoPath) {
   if (settings?.fileIncludeGlobs?.length) {
     const matched = [];
     try {
-      for (const entry of (0, import_node_fs27.readdirSync)(repoPath, { withFileTypes: true })) {
+      for (const entry of (0, import_node_fs28.readdirSync)(repoPath, { withFileTypes: true })) {
         if (!entry.isFile()) continue;
         for (const glob of settings.fileIncludeGlobs) {
-          if (matchSimpleGlob(glob, entry.name) || matchSimpleGlob((0, import_node_path26.basename)(glob), entry.name)) {
+          if (matchSimpleGlob(glob, entry.name) || matchSimpleGlob((0, import_node_path27.basename)(glob), entry.name)) {
             matched.push(entry.name);
             break;
           }
@@ -10740,7 +11063,7 @@ function resolveFilesToCopy(repoPath) {
   }
   const defaults = [];
   try {
-    for (const entry of (0, import_node_fs27.readdirSync)(repoPath, { withFileTypes: true })) {
+    for (const entry of (0, import_node_fs28.readdirSync)(repoPath, { withFileTypes: true })) {
       if (entry.isFile() && entry.name.startsWith(".env")) {
         defaults.push(entry.name);
       }
@@ -10754,11 +11077,11 @@ function copyConfiguredFiles(repoPath, worktreePath) {
   const patterns = resolveFilesToCopy(repoPath);
   const copied = [];
   for (const rel of patterns) {
-    const src = (0, import_node_path26.join)(repoPath, rel);
-    if (!(0, import_node_fs27.existsSync)(src)) continue;
-    const dest = (0, import_node_path26.join)(worktreePath, rel);
-    (0, import_node_fs27.mkdirSync)((0, import_node_path26.dirname)(dest), { recursive: true });
-    (0, import_node_fs27.copyFileSync)(src, dest);
+    const src = (0, import_node_path27.join)(repoPath, rel);
+    if (!(0, import_node_fs28.existsSync)(src)) continue;
+    const dest = (0, import_node_path27.join)(worktreePath, rel);
+    (0, import_node_fs28.mkdirSync)((0, import_node_path27.dirname)(dest), { recursive: true });
+    (0, import_node_fs28.copyFileSync)(src, dest);
     copied.push(rel);
   }
   return copied;
@@ -10793,7 +11116,7 @@ function buildWorkspaceScriptEnv(opts, baseEnv) {
   const env = stripNestedElectronEnv({
     ...baseEnv ?? process.env
   });
-  const name = opts.workspaceName ?? (0, import_node_path26.basename)(opts.worktreePath);
+  const name = opts.workspaceName ?? (0, import_node_path27.basename)(opts.worktreePath);
   const ports = opts.ports ?? [];
   const primary = ports[0];
   env.SIDEBOARD_WORKSPACE_NAME = name;
@@ -11054,13 +11377,13 @@ async function startDevServer(repoPath, worktreePath, onLine, opts) {
     done: handle.done
   };
 }
-var import_node_fs27, import_node_net, import_node_path26, import_execa4, import_node_readline3, PORT_RANGE_SIZE, cachedLoginEnv;
+var import_node_fs28, import_node_net, import_node_path27, import_execa4, import_node_readline3, PORT_RANGE_SIZE, cachedLoginEnv;
 var init_conductor = __esm({
   "src/hook/conductor.ts"() {
     "use strict";
-    import_node_fs27 = require("fs");
+    import_node_fs28 = require("fs");
     import_node_net = require("net");
-    import_node_path26 = require("path");
+    import_node_path27 = require("path");
     import_execa4 = require("execa");
     import_node_readline3 = require("readline");
     init_settings();
@@ -11086,9 +11409,9 @@ async function findOrphanWorktrees(repoPaths) {
     repoPaths?.length ? repoPaths : threads.map((t) => t.repoPath).filter(Boolean)
   );
   const homeRoot = sideboardWorkspacesDir();
-  if ((0, import_node_fs28.existsSync)(homeRoot)) {
+  if ((0, import_node_fs29.existsSync)(homeRoot)) {
     try {
-      for (const entry of (0, import_node_fs28.readdirSync)(homeRoot, { withFileTypes: true })) {
+      for (const entry of (0, import_node_fs29.readdirSync)(homeRoot, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
         void entry;
       }
@@ -11098,7 +11421,7 @@ async function findOrphanWorktrees(repoPaths) {
   const orphans = [];
   const seen = /* @__PURE__ */ new Set();
   for (const repoPath of repos) {
-    if (!repoPath || !(0, import_node_fs28.existsSync)(repoPath)) continue;
+    if (!repoPath || !(0, import_node_fs29.existsSync)(repoPath)) continue;
     try {
       const wts = await listWorktrees(repoPath);
       for (const wt of wts) {
@@ -11109,7 +11432,7 @@ async function findOrphanWorktrees(repoPaths) {
         seen.add(path);
         let mtimeMs = 0;
         try {
-          mtimeMs = (0, import_node_fs28.statSync)(path).mtimeMs;
+          mtimeMs = (0, import_node_fs29.statSync)(path).mtimeMs;
         } catch {
           mtimeMs = 0;
         }
@@ -11119,16 +11442,16 @@ async function findOrphanWorktrees(repoPaths) {
     }
     try {
       const root = worktreesRoot(repoPath);
-      if ((0, import_node_fs28.existsSync)(root)) {
-        for (const entry of (0, import_node_fs28.readdirSync)(root, { withFileTypes: true })) {
+      if ((0, import_node_fs29.existsSync)(root)) {
+        for (const entry of (0, import_node_fs29.readdirSync)(root, { withFileTypes: true })) {
           if (!entry.isDirectory()) continue;
-          const path = (0, import_node_path27.join)(root, entry.name).replace(/\/$/, "");
+          const path = (0, import_node_path28.join)(root, entry.name).replace(/\/$/, "");
           if (known.has(path) || seen.has(path)) continue;
-          if (!(0, import_node_fs28.existsSync)((0, import_node_path27.join)(path, ".git"))) continue;
+          if (!(0, import_node_fs29.existsSync)((0, import_node_path28.join)(path, ".git"))) continue;
           seen.add(path);
           let mtimeMs = 0;
           try {
-            mtimeMs = (0, import_node_fs28.statSync)(path).mtimeMs;
+            mtimeMs = (0, import_node_fs29.statSync)(path).mtimeMs;
           } catch {
             mtimeMs = Date.now();
           }
@@ -11180,12 +11503,12 @@ function shouldRunWorktreeCleanup(settings = loadAppSettings()) {
   const elapsed = Date.now() - Date.parse(last);
   return elapsed >= intervalHours * 36e5;
 }
-var import_node_fs28, import_node_path27;
+var import_node_fs29, import_node_path28;
 var init_orphan_cleanup = __esm({
   "src/git/orphan-cleanup.ts"() {
     "use strict";
-    import_node_fs28 = require("fs");
-    import_node_path27 = require("path");
+    import_node_fs29 = require("fs");
+    import_node_path28 = require("path");
     init_worktree();
     init_thread_store();
     init_paths();
@@ -11292,38 +11615,38 @@ __export(workspaces_exports, {
   syncWorkspacesFromThreads: () => syncWorkspacesFromThreads
 });
 function workspacesFile() {
-  return (0, import_node_path28.join)(appDataDir(), "workspaces.json");
+  return (0, import_node_path29.join)(appDataDir(), "workspaces.json");
 }
 function removedWorkspacesFile() {
-  return (0, import_node_path28.join)(appDataDir(), "removed-workspaces.json");
+  return (0, import_node_path29.join)(appDataDir(), "removed-workspaces.json");
 }
 function readAll() {
   const path = workspacesFile();
-  if (!(0, import_node_fs29.existsSync)(path)) return [];
+  if (!(0, import_node_fs30.existsSync)(path)) return [];
   try {
-    const raw = JSON.parse((0, import_node_fs29.readFileSync)(path, "utf8"));
+    const raw = JSON.parse((0, import_node_fs30.readFileSync)(path, "utf8"));
     return Array.isArray(raw) ? raw : [];
   } catch {
     return [];
   }
 }
 function writeAll(list) {
-  (0, import_node_fs29.mkdirSync)(appDataDir(), { recursive: true });
-  (0, import_node_fs29.writeFileSync)(workspacesFile(), JSON.stringify(list, null, 2), "utf8");
+  (0, import_node_fs30.mkdirSync)(appDataDir(), { recursive: true });
+  (0, import_node_fs30.writeFileSync)(workspacesFile(), JSON.stringify(list, null, 2), "utf8");
 }
 function readRemoved() {
   const path = removedWorkspacesFile();
-  if (!(0, import_node_fs29.existsSync)(path)) return /* @__PURE__ */ new Set();
+  if (!(0, import_node_fs30.existsSync)(path)) return /* @__PURE__ */ new Set();
   try {
-    const raw = JSON.parse((0, import_node_fs29.readFileSync)(path, "utf8"));
+    const raw = JSON.parse((0, import_node_fs30.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_fs29.mkdirSync)(appDataDir(), { recursive: true });
-  (0, import_node_fs29.writeFileSync)(removedWorkspacesFile(), JSON.stringify([...paths].sort(), null, 2), "utf8");
+  (0, import_node_fs30.mkdirSync)(appDataDir(), { recursive: true });
+  (0, import_node_fs30.writeFileSync)(removedWorkspacesFile(), JSON.stringify([...paths].sort(), null, 2), "utf8");
 }
 function rememberRemoved(repoPath) {
   const next = readRemoved();
@@ -11346,7 +11669,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_fs29.existsSync)(root)) throw new Error(`Repo not found: ${root}`);
+  if (!(0, import_node_fs30.existsSync)(root)) throw new Error(`Repo not found: ${root}`);
   forgetRemoved(root);
   await ensureGhPreferOrigin(root);
   const current = readAll();
@@ -11354,7 +11677,7 @@ async function addWorkspace(repoPath) {
   if (existing) return existing;
   const next = {
     path: root,
-    name: (0, import_node_path28.basename)(root),
+    name: (0, import_node_path29.basename)(root),
     addedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   writeAll([...current, next]);
@@ -11376,10 +11699,10 @@ function syncWorkspacesFromThreads(repoPaths) {
     if (!path || path === "/" || isGlobalRepoPath(path) || byPath.has(path) || removed.has(path)) {
       continue;
     }
-    if (!(0, import_node_fs29.existsSync)(path)) continue;
+    if (!(0, import_node_fs30.existsSync)(path)) continue;
     const ws = {
       path,
-      name: (0, import_node_path28.basename)(path),
+      name: (0, import_node_path29.basename)(path),
       addedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     byPath.set(path, ws);
@@ -11389,12 +11712,12 @@ function syncWorkspacesFromThreads(repoPaths) {
   if (dirty) writeAll(next);
   return next.sort((a, b) => a.name.localeCompare(b.name));
 }
-var import_node_fs29, import_node_path28;
+var import_node_fs30, import_node_path29;
 var init_workspaces2 = __esm({
   "src/store/workspaces.ts"() {
     "use strict";
-    import_node_fs29 = require("fs");
-    import_node_path28 = require("path");
+    import_node_fs30 = require("fs");
+    import_node_path29 = require("path");
     init_paths();
     init_global_workspace();
     init_worktree();
@@ -11407,12 +11730,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_path29.basename)(url.replace(/\/$/, "").replace(/\.git$/, ""));
+    const leaf = (0, import_node_path30.basename)(url.replace(/\/$/, "").replace(/\.git$/, ""));
     name = leaf || "repo";
   }
   name = name.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "repo";
-  const dest = (0, import_node_path29.join)(sideboardReposDir(), name);
-  if ((0, import_node_fs30.existsSync)(dest)) {
+  const dest = (0, import_node_path30.join)(sideboardReposDir(), name);
+  if ((0, import_node_fs31.existsSync)(dest)) {
     const repoPath2 = await resolveRepoRoot(dest);
     const workspace2 = await ensureWorkspace(repoPath2);
     return { repoPath: repoPath2, workspace: workspace2 };
@@ -11427,12 +11750,12 @@ async function cloneRepoIntoSideboard(opts) {
   const workspace = await ensureWorkspace(repoPath);
   return { repoPath, workspace };
 }
-var import_node_fs30, import_node_path29, import_execa6;
+var import_node_fs31, import_node_path30, import_execa6;
 var init_clone_repo = __esm({
   "src/git/clone-repo.ts"() {
     "use strict";
-    import_node_fs30 = require("fs");
-    import_node_path29 = require("path");
+    import_node_fs31 = require("fs");
+    import_node_path30 = require("path");
     import_execa6 = require("execa");
     init_paths();
     init_workspaces2();
@@ -11442,11 +11765,11 @@ var init_clone_repo = __esm({
 
 // src/store/desktop-host.ts
 function desktopHostPidPath() {
-  return (0, import_node_path30.join)(appDataDir(), "desktop-host.pid");
+  return (0, import_node_path31.join)(appDataDir(), "desktop-host.pid");
 }
 function readDesktopHostPid() {
   try {
-    const pid = Number.parseInt((0, import_node_fs31.readFileSync)(desktopHostPidPath(), "utf8").trim(), 10);
+    const pid = Number.parseInt((0, import_node_fs32.readFileSync)(desktopHostPidPath(), "utf8").trim(), 10);
     if (!Number.isFinite(pid) || pid <= 0) return null;
     return pid;
   } catch {
@@ -11472,12 +11795,12 @@ function thisProcessShouldDrainAgentQueues() {
   if (isThisProcessDesktopHost()) return true;
   return !isDesktopHostAlive();
 }
-var import_node_fs31, import_node_path30;
+var import_node_fs32, import_node_path31;
 var init_desktop_host = __esm({
   "src/store/desktop-host.ts"() {
     "use strict";
-    import_node_fs31 = require("fs");
-    import_node_path30 = require("path");
+    import_node_fs32 = require("fs");
+    import_node_path31 = require("path");
     init_paths();
   }
 });
@@ -11527,7 +11850,7 @@ async function createThread(input, _onSetupLine) {
   });
   await requireAgent(resolved.agent);
   const repoPath = await resolveRepoRoot(input.repoPath);
-  if (!(0, import_node_fs32.existsSync)(repoPath)) {
+  if (!(0, import_node_fs33.existsSync)(repoPath)) {
     throw new Error(`Repo not found: ${repoPath}`);
   }
   if (input.cowboy) {
@@ -11650,11 +11973,11 @@ async function listLinearIssues(agent, repoPath) {
   }
   return adapter.listLinearIssues(repoPath);
 }
-var import_node_fs32;
+var import_node_fs33;
 var init_create = __esm({
   "src/threads/create.ts"() {
     "use strict";
-    import_node_fs32 = require("fs");
+    import_node_fs33 = require("fs");
     init_detect();
     init_worktree();
     init_conductor();
@@ -11699,21 +12022,13 @@ function summarizeTurnLive(parts) {
     (p) => p.type === "tool"
   );
   const lastTool = tools[tools.length - 1];
-  const lastToolLabel = lastTool ? lastTool.description || toolDescription(lastTool.name, lastTool.input) || lastTool.name : void 0;
-  const running = lastTool?.status === "running";
+  const interesting = [...tools].reverse().find((t) => !isPollWrapperToolName(t.name)) ?? lastTool;
+  const lastToolLabel = interesting ? interesting.description || toolDescription(interesting.name, interesting.input) || interesting.name : void 0;
   const thinking = lastText(parts, "thinking");
   const text4 = lastText(parts, "text");
   const excerptRaw = thinking || text4;
   const excerpt = excerptRaw.length > 280 ? `${excerptRaw.slice(-280)}` : excerptRaw || void 0;
-  let summary = "Working\u2026";
-  if (lastToolLabel) {
-    const verb = running ? lastToolLabel : `Finished ${lastToolLabel}`;
-    summary = tools.length > 1 ? `${verb} (${tools.length} tools)` : verb;
-  } else if (thinking) {
-    summary = "Thinking\u2026";
-  } else if (text4) {
-    summary = "Writing reply\u2026";
-  }
+  const summary = liveActivitySummary(parts);
   return {
     updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     summary,
@@ -11763,20 +12078,20 @@ function writeTurnLive(threadId, progress) {
   const path = threadLivePath(threadId);
   const tmp = `${path}.${process.pid}.tmp`;
   try {
-    (0, import_node_fs33.writeFileSync)(tmp, JSON.stringify(progress), "utf8");
-    (0, import_node_fs33.renameSync)(tmp, path);
+    (0, import_node_fs34.writeFileSync)(tmp, JSON.stringify(progress), "utf8");
+    (0, import_node_fs34.renameSync)(tmp, path);
   } catch {
     try {
-      (0, import_node_fs33.unlinkSync)(tmp);
+      (0, import_node_fs34.unlinkSync)(tmp);
     } catch {
     }
   }
 }
 function readTurnLive(threadId) {
   const path = threadLivePath(threadId);
-  if (!(0, import_node_fs33.existsSync)(path)) return null;
+  if (!(0, import_node_fs34.existsSync)(path)) return null;
   try {
-    const raw = JSON.parse((0, import_node_fs33.readFileSync)(path, "utf8"));
+    const raw = JSON.parse((0, import_node_fs34.readFileSync)(path, "utf8"));
     if (!raw || typeof raw.summary !== "string") return null;
     return raw;
   } catch {
@@ -11788,17 +12103,17 @@ function clearTurnLive(threadId) {
   if (buf?.timer) clearTimeout(buf.timer);
   buffers.delete(threadId);
   const path = threadLivePath(threadId);
-  if (!(0, import_node_fs33.existsSync)(path)) return;
+  if (!(0, import_node_fs34.existsSync)(path)) return;
   try {
-    (0, import_node_fs33.unlinkSync)(path);
+    (0, import_node_fs34.unlinkSync)(path);
   } catch {
   }
 }
-var import_node_fs33, buffers, FLUSH_MS, MAX_PARTS;
+var import_node_fs34, buffers, FLUSH_MS, MAX_PARTS;
 var init_turn_live = __esm({
   "src/store/turn-live.ts"() {
     "use strict";
-    import_node_fs33 = require("fs");
+    import_node_fs34 = require("fs");
     init_message_parts();
     init_paths();
     buffers = /* @__PURE__ */ new Map();
@@ -11977,7 +12292,7 @@ var init_quota_failover = __esm({
 // src/threads/adopt.ts
 function thisModuleFile() {
   const cjsFile = typeof __filename !== "undefined" ? __filename : "";
-  return cjsFile || process.argv[1] || (0, import_node_path31.join)(process.cwd(), "package.json");
+  return cjsFile || process.argv[1] || (0, import_node_path32.join)(process.cwd(), "package.json");
 }
 function openReadonlySqlite(file) {
   const req = (0, import_node_module4.createRequire)(thisModuleFile());
@@ -11995,21 +12310,21 @@ function mapAgentType(raw) {
   return null;
 }
 function resolveConductorCursorAgentId(workspacePath) {
-  if (!workspacePath || !(0, import_node_fs34.existsSync)(CURSOR_SDK_STORE)) return null;
+  if (!workspacePath || !(0, import_node_fs35.existsSync)(CURSOR_SDK_STORE)) return null;
   const normalized = workspacePath.replace(/\/$/, "");
   let best = null;
   let hashes;
   try {
-    hashes = (0, import_node_fs34.readdirSync)(CURSOR_SDK_STORE);
+    hashes = (0, import_node_fs35.readdirSync)(CURSOR_SDK_STORE);
   } catch {
     return null;
   }
   for (const hash of hashes) {
-    const agentsFile = (0, import_node_path31.join)(CURSOR_SDK_STORE, hash, "agents.ndjson");
-    if (!(0, import_node_fs34.existsSync)(agentsFile)) continue;
+    const agentsFile = (0, import_node_path32.join)(CURSOR_SDK_STORE, hash, "agents.ndjson");
+    if (!(0, import_node_fs35.existsSync)(agentsFile)) continue;
     let text4;
     try {
-      text4 = (0, import_node_fs34.readFileSync)(agentsFile, "utf8");
+      text4 = (0, import_node_fs35.readFileSync)(agentsFile, "utf8");
     } catch {
       continue;
     }
@@ -12033,7 +12348,7 @@ function resolveConductorCursorAgentId(workspacePath) {
   return best?.agentId ?? null;
 }
 async function adoptThread(input) {
-  if (!(0, import_node_fs34.existsSync)(input.worktreePath)) {
+  if (!(0, import_node_fs35.existsSync)(input.worktreePath)) {
     throw new Error(`Worktree not found: ${input.worktreePath}`);
   }
   const repoPath = await resolveRepoRoot(input.worktreePath);
@@ -12057,18 +12372,18 @@ async function adoptThread(input) {
   return thread;
 }
 function listConductorWorkspaces() {
-  if (!(0, import_node_fs34.existsSync)(CONDUCTOR_DB)) {
+  if (!(0, import_node_fs35.existsSync)(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = (0, import_node_fs34.mkdtempSync)((0, import_node_path31.join)((0, import_node_os10.tmpdir)(), "sideboard-conductor-"));
-  const snapshot = (0, import_node_path31.join)(tmp, "conductor.db");
+  const tmp = (0, import_node_fs35.mkdtempSync)((0, import_node_path32.join)((0, import_node_os10.tmpdir)(), "sideboard-conductor-"));
+  const snapshot = (0, import_node_path32.join)(tmp, "conductor.db");
   try {
-    (0, import_node_fs34.copyFileSync)(CONDUCTOR_DB, snapshot);
+    (0, import_node_fs35.copyFileSync)(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if ((0, import_node_fs34.existsSync)(src)) {
+      if ((0, import_node_fs35.existsSync)(src)) {
         try {
-          (0, import_node_fs34.copyFileSync)(src, `${snapshot}${suffix}`);
+          (0, import_node_fs35.copyFileSync)(src, `${snapshot}${suffix}`);
         } catch {
         }
       }
@@ -12144,22 +12459,22 @@ function listConductorWorkspaces() {
       db.close();
     }
   } finally {
-    (0, import_node_fs34.rmSync)(tmp, { recursive: true, force: true });
+    (0, import_node_fs35.rmSync)(tmp, { recursive: true, force: true });
   }
 }
 function importConductorWorkspace(workspaceId) {
-  if (!(0, import_node_fs34.existsSync)(CONDUCTOR_DB)) {
+  if (!(0, import_node_fs35.existsSync)(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = (0, import_node_fs34.mkdtempSync)((0, import_node_path31.join)((0, import_node_os10.tmpdir)(), "sideboard-conductor-"));
-  const snapshot = (0, import_node_path31.join)(tmp, "conductor.db");
+  const tmp = (0, import_node_fs35.mkdtempSync)((0, import_node_path32.join)((0, import_node_os10.tmpdir)(), "sideboard-conductor-"));
+  const snapshot = (0, import_node_path32.join)(tmp, "conductor.db");
   try {
-    (0, import_node_fs34.copyFileSync)(CONDUCTOR_DB, snapshot);
+    (0, import_node_fs35.copyFileSync)(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if ((0, import_node_fs34.existsSync)(src)) {
+      if ((0, import_node_fs35.existsSync)(src)) {
         try {
-          (0, import_node_fs34.copyFileSync)(src, `${snapshot}${suffix}`);
+          (0, import_node_fs35.copyFileSync)(src, `${snapshot}${suffix}`);
         } catch {
         }
       }
@@ -12177,7 +12492,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_fs34.existsSync)(worktreePath)) {
+      if (!(0, import_node_fs35.existsSync)(worktreePath)) {
         throw new Error(`Conductor worktree missing on disk: ${worktreePath}`);
       }
       let sessionId = null;
@@ -12240,31 +12555,31 @@ function importConductorWorkspace(workspaceId) {
       db.close();
     }
   } finally {
-    (0, import_node_fs34.rmSync)(tmp, { recursive: true, force: true });
+    (0, import_node_fs35.rmSync)(tmp, { recursive: true, force: true });
   }
 }
 async function importConductorWorkspaceAsync(workspaceId) {
   return importConductorWorkspace(workspaceId);
 }
-var import_node_child_process3, import_node_fs34, import_node_os10, import_node_path31, import_node_module4, CONDUCTOR_APP_SUPPORT, CONDUCTOR_DB, CURSOR_SDK_STORE;
+var import_node_child_process3, import_node_fs35, import_node_os10, import_node_path32, import_node_module4, CONDUCTOR_APP_SUPPORT, CONDUCTOR_DB, CURSOR_SDK_STORE;
 var init_adopt = __esm({
   "src/threads/adopt.ts"() {
     "use strict";
     import_node_child_process3 = require("child_process");
-    import_node_fs34 = require("fs");
+    import_node_fs35 = require("fs");
     import_node_os10 = require("os");
-    import_node_path31 = require("path");
+    import_node_path32 = require("path");
     import_node_module4 = require("module");
     init_worktree();
     init_thread_store();
-    CONDUCTOR_APP_SUPPORT = (0, import_node_path31.join)(
+    CONDUCTOR_APP_SUPPORT = (0, import_node_path32.join)(
       process.env.HOME ?? "",
       "Library",
       "Application Support",
       "com.conductor.app"
     );
-    CONDUCTOR_DB = (0, import_node_path31.join)(CONDUCTOR_APP_SUPPORT, "conductor.db");
-    CURSOR_SDK_STORE = (0, import_node_path31.join)(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
+    CONDUCTOR_DB = (0, import_node_path32.join)(CONDUCTOR_APP_SUPPORT, "conductor.db");
+    CURSOR_SDK_STORE = (0, import_node_path32.join)(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
   }
 });
 
@@ -12331,7 +12646,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_fs35.existsSync)(checkedOut.path)) {
+  if (checkedOut?.path && (0, import_node_fs36.existsSync)(checkedOut.path)) {
     if (input.reuseExistingWorktree !== false) {
       worktreePath = checkedOut.path;
     } else {
@@ -12473,7 +12788,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_fs35.existsSync)(repoPath)) throw new Error(`Repo not found: ${repoPath}`);
+  if (!(0, import_node_fs36.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);
@@ -12540,7 +12855,7 @@ async function createPrStack(input, onSetupLine) {
     }
   }
   const claimed = new Set(threads.map((t) => t.worktreePath));
-  if (!claimed.has(bootstrap.worktreePath) && (0, import_node_fs35.existsSync)(bootstrap.worktreePath)) {
+  if (!claimed.has(bootstrap.worktreePath) && (0, import_node_fs36.existsSync)(bootstrap.worktreePath)) {
     try {
       await removeWorktree(repoPath, bootstrap.worktreePath, {
         deleteBranch: bootstrap.branchName
@@ -12550,11 +12865,11 @@ async function createPrStack(input, onSetupLine) {
   }
   return { stack, threads, createdThreadIds };
 }
-var import_node_fs35;
+var import_node_fs36;
 var init_stack_layers = __esm({
   "src/threads/stack-layers.ts"() {
     "use strict";
-    import_node_fs35 = require("fs");
+    import_node_fs36 = require("fs");
     init_detect();
     init_run();
     init_stack();
@@ -12567,7 +12882,7 @@ var init_stack_layers = __esm({
 
 // src/diff/diff.ts
 async function inspectGitWorktree(worktreePath) {
-  if (!worktreePath || !(0, import_node_fs36.existsSync)(worktreePath)) return "missing_worktree";
+  if (!worktreePath || !(0, import_node_fs37.existsSync)(worktreePath)) return "missing_worktree";
   const check = await git(["rev-parse", "--is-inside-work-tree"], worktreePath, {
     reject: false
   });
@@ -12575,7 +12890,7 @@ async function inspectGitWorktree(worktreePath) {
   return "ok";
 }
 async function initializeGitRepository(worktreePath) {
-  if (!worktreePath || !(0, import_node_fs36.existsSync)(worktreePath)) {
+  if (!worktreePath || !(0, import_node_fs37.existsSync)(worktreePath)) {
     throw new Error("Worktree not found");
   }
   const status = await inspectGitWorktree(worktreePath);
@@ -12709,11 +13024,11 @@ new file mode 100644
   };
 }
 async function untrackedPatch(worktreePath, path, maxHunk) {
-  const abs = (0, import_node_path32.join)(worktreePath, path);
+  const abs = (0, import_node_path33.join)(worktreePath, path);
   try {
-    const st = (0, import_node_fs36.statSync)(abs);
+    const st = (0, import_node_fs37.statSync)(abs);
     if (st.isFile() && st.size > maxHunk) {
-      const buf = (0, import_node_fs36.readFileSync)(abs).subarray(0, maxHunk);
+      const buf = (0, import_node_fs37.readFileSync)(abs).subarray(0, maxHunk);
       return syntheticAddPatch(path, buf.toString("utf8"), maxHunk);
     }
   } catch {
@@ -13202,8 +13517,8 @@ function isImageRelativePath(relativePath) {
 function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? DEFAULT_UPLOAD_MAX_BYTES;
-  const abs = (0, import_node_path32.join)(worktreePath, relativePath);
-  const st = (0, import_node_fs36.statSync)(abs);
+  const abs = (0, import_node_path33.join)(worktreePath, relativePath);
+  const st = (0, import_node_fs37.statSync)(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
@@ -13212,7 +13527,7 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
       `File too large to upload (${st.size} bytes; max ${maxBytes})`
     );
   }
-  const buf = (0, import_node_fs36.readFileSync)(abs);
+  const buf = (0, import_node_fs37.readFileSync)(abs);
   return {
     path: relativePath,
     contentBase64: buf.toString("base64"),
@@ -13222,12 +13537,12 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
 function readWorktreeFile(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? 2e5;
-  const abs = (0, import_node_path32.join)(worktreePath, relativePath);
-  const st = (0, import_node_fs36.statSync)(abs);
+  const abs = (0, import_node_path33.join)(worktreePath, relativePath);
+  const st = (0, import_node_fs37.statSync)(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
-  const buf = (0, import_node_fs36.readFileSync)(abs);
+  const buf = (0, import_node_fs37.readFileSync)(abs);
   if (isImageRelativePath(relativePath)) {
     const maxImageBytes = Math.max(maxBytes, 15e6);
     const truncated2 = buf.length > maxImageBytes;
@@ -13270,9 +13585,9 @@ function assertSafeRelativePath(relativePath) {
 }
 function writeWorktreeFile(worktreePath, relativePath, content) {
   assertSafeRelativePath(relativePath);
-  const abs = (0, import_node_path32.join)(worktreePath, relativePath);
-  (0, import_node_fs36.mkdirSync)((0, import_node_path32.dirname)(abs), { recursive: true });
-  (0, import_node_fs36.writeFileSync)(abs, content, "utf8");
+  const abs = (0, import_node_path33.join)(worktreePath, relativePath);
+  (0, import_node_fs37.mkdirSync)((0, import_node_path33.dirname)(abs), { recursive: true });
+  (0, import_node_fs37.writeFileSync)(abs, content, "utf8");
   return { path: relativePath };
 }
 async function getDiffSummary(worktreePath, repoPath, opts) {
@@ -13289,12 +13604,12 @@ async function getDiffSummary(worktreePath, repoPath, opts) {
     truncated: full.files.length > maxFiles
   };
 }
-var import_node_fs36, import_node_path32, mergeBaseCache, MERGE_BASE_TTL_MS, SHA_RE, IMAGE_EXTENSIONS, DEFAULT_UPLOAD_MAX_BYTES;
+var import_node_fs37, import_node_path33, mergeBaseCache, MERGE_BASE_TTL_MS, SHA_RE, IMAGE_EXTENSIONS, DEFAULT_UPLOAD_MAX_BYTES;
 var init_diff = __esm({
   "src/diff/diff.ts"() {
     "use strict";
-    import_node_fs36 = require("fs");
-    import_node_path32 = require("path");
+    import_node_fs37 = require("fs");
+    import_node_path33 = require("path");
     init_run();
     init_worktree();
     mergeBaseCache = /* @__PURE__ */ new Map();
@@ -13462,7 +13777,7 @@ function parseFrontmatter(content) {
 }
 function readSkill(skillMd, source) {
   try {
-    const content = (0, import_node_fs37.readFileSync)(skillMd, "utf8");
+    const content = (0, import_node_fs38.readFileSync)(skillMd, "utf8");
     const { name: fmName, description } = parseFrontmatter(content);
     const dirName = skillMd.split("/").slice(-2, -1)[0] || "skill";
     const name = fmName || dirName;
@@ -13481,19 +13796,19 @@ function readSkill(skillMd, source) {
   }
 }
 function scanSkillsDir(dir, source, out) {
-  if (!(0, import_node_fs37.existsSync)(dir)) return;
+  if (!(0, import_node_fs38.existsSync)(dir)) return;
   let entries;
   try {
-    entries = (0, import_node_fs37.readdirSync)(dir);
+    entries = (0, import_node_fs38.readdirSync)(dir);
   } catch {
     return;
   }
   for (const entry of entries) {
     if (entry.startsWith(".")) continue;
-    const skillMd = (0, import_node_path33.join)(dir, entry, "SKILL.md");
-    if (!(0, import_node_fs37.existsSync)(skillMd)) continue;
+    const skillMd = (0, import_node_path34.join)(dir, entry, "SKILL.md");
+    if (!(0, import_node_fs38.existsSync)(skillMd)) continue;
     try {
-      if (!(0, import_node_fs37.statSync)(skillMd).isFile()) continue;
+      if (!(0, import_node_fs38.statSync)(skillMd).isFile()) continue;
     } catch {
       continue;
     }
@@ -13502,24 +13817,24 @@ function scanSkillsDir(dir, source, out) {
   }
 }
 function scanClaudePluginSkills(pluginsRoot, out) {
-  if (!(0, import_node_fs37.existsSync)(pluginsRoot)) return;
+  if (!(0, import_node_fs38.existsSync)(pluginsRoot)) return;
   const walk = (dir, depth, lookingForSkillsDir) => {
     if (depth > 7) return;
     let entries;
     try {
-      entries = (0, import_node_fs37.readdirSync)(dir);
+      entries = (0, import_node_fs38.readdirSync)(dir);
     } catch {
       return;
     }
     if (lookingForSkillsDir && entries.includes("SKILL.md")) {
-      const skill = readSkill((0, import_node_path33.join)(dir, "SKILL.md"), "cli");
+      const skill = readSkill((0, import_node_path34.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_path33.join)(dir, entry);
+      const full = (0, import_node_path34.join)(dir, entry);
       try {
-        if (!(0, import_node_fs37.statSync)(full).isDirectory()) continue;
+        if (!(0, import_node_fs38.statSync)(full).isDirectory()) continue;
       } catch {
         continue;
       }
@@ -13537,17 +13852,17 @@ function discoverSkills(worktreePath) {
   const home = (0, import_node_os11.homedir)();
   const collected = [];
   for (const rel of [".claude/skills", ".cursor/skills", ".sideboard/skills", ".brightsy/skills", "skills"]) {
-    scanSkillsDir((0, import_node_path33.join)(worktreePath, rel), "workspace", collected);
+    scanSkillsDir((0, import_node_path34.join)(worktreePath, rel), "workspace", collected);
   }
   for (const abs of [
-    (0, import_node_path33.join)(home, ".claude/skills"),
-    (0, import_node_path33.join)(home, ".cursor/skills"),
-    (0, import_node_path33.join)(home, ".sideboard/skills"),
-    (0, import_node_path33.join)(home, ".brightsy/skills")
+    (0, import_node_path34.join)(home, ".claude/skills"),
+    (0, import_node_path34.join)(home, ".cursor/skills"),
+    (0, import_node_path34.join)(home, ".sideboard/skills"),
+    (0, import_node_path34.join)(home, ".brightsy/skills")
   ]) {
     scanSkillsDir(abs, "user", collected);
   }
-  scanClaudePluginSkills((0, import_node_path33.join)(home, ".claude/plugins"), collected);
+  scanClaudePluginSkills((0, import_node_path34.join)(home, ".claude/plugins"), collected);
   const rank = { workspace: 0, user: 1, cli: 2 };
   const byCommand = /* @__PURE__ */ new Map();
   for (const skill of collected) {
@@ -13559,7 +13874,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_fs37.readFileSync)(skillPath, "utf8");
+  const raw = (0, import_node_fs38.readFileSync)(skillPath, "utf8");
   if (raw.startsWith("---")) {
     const end = raw.indexOf("\n---", 3);
     if (end >= 0) {
@@ -13573,13 +13888,13 @@ function readSkillBody(skillPath, maxChars = 12e3) {
 
 \u2026(truncated)` : raw;
 }
-var import_node_fs37, import_node_os11, import_node_path33;
+var import_node_fs38, import_node_os11, import_node_path34;
 var init_discover = __esm({
   "src/skills/discover.ts"() {
     "use strict";
-    import_node_fs37 = require("fs");
+    import_node_fs38 = require("fs");
     import_node_os11 = require("os");
-    import_node_path33 = require("path");
+    import_node_path34 = require("path");
   }
 });
 
@@ -13670,7 +13985,7 @@ var init_expand = __esm({
 
 // src/composer/stage-files.ts
 function fileExtension(filePath) {
-  const base = (0, import_node_path34.basename)(filePath).toLowerCase();
+  const base = (0, import_node_path35.basename)(filePath).toLowerCase();
   return base.includes(".") ? base.split(".").pop() || "" : "";
 }
 function isImageFilePath(filePath) {
@@ -13680,22 +13995,22 @@ function imageMimeType(filePath) {
   return IMAGE_MIME_BY_EXT[fileExtension(filePath)] || "image/png";
 }
 function ensureAttachmentsDir(worktreePath) {
-  const dir = (0, import_node_path34.join)(worktreePath, ATTACHMENTS_DIR);
-  (0, import_node_fs38.mkdirSync)(dir, { recursive: true });
-  const gi = (0, import_node_path34.join)(dir, ".gitignore");
-  if (!(0, import_node_fs38.existsSync)(gi)) {
-    (0, import_node_fs38.writeFileSync)(gi, attachmentsGitignoreBody(), "utf8");
+  const dir = (0, import_node_path35.join)(worktreePath, ATTACHMENTS_DIR);
+  (0, import_node_fs39.mkdirSync)(dir, { recursive: true });
+  const gi = (0, import_node_path35.join)(dir, ".gitignore");
+  if (!(0, import_node_fs39.existsSync)(gi)) {
+    (0, import_node_fs39.writeFileSync)(gi, attachmentsGitignoreBody(), "utf8");
   }
   return dir;
 }
 function uniqueAttachmentName(dir, originalName) {
   const safe = originalName.replace(/[/\\]/g, "_") || "file";
-  if (!(0, import_node_fs38.existsSync)((0, import_node_path34.join)(dir, safe))) return safe;
-  const ext = (0, import_node_path34.extname)(safe);
+  if (!(0, import_node_fs39.existsSync)((0, import_node_path35.join)(dir, safe))) return safe;
+  const ext = (0, import_node_path35.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_fs38.existsSync)((0, import_node_path34.join)(dir, candidate))) return candidate;
+    if (!(0, import_node_fs39.existsSync)((0, import_node_path35.join)(dir, candidate))) return candidate;
   }
   return `${stem}-${(0, import_node_crypto7.randomUUID)()}${ext}`;
 }
@@ -13751,15 +14066,15 @@ function stageAbsolutePathsAsAttachments(worktreePath, absolutePaths) {
   const dir = ensureAttachmentsDir(worktreePath);
   const out = [];
   for (const abs of absolutePaths) {
-    const originalName = (0, import_node_path34.basename)(abs);
+    const originalName = (0, import_node_path35.basename)(abs);
     try {
-      const st = (0, import_node_fs38.statSync)(abs);
+      const st = (0, import_node_fs39.statSync)(abs);
       if (!st.isFile()) continue;
       const name = uniqueAttachmentName(dir, originalName);
-      const destAbs = (0, import_node_path34.join)(dir, name);
-      (0, import_node_fs38.copyFileSync)(abs, destAbs);
+      const destAbs = (0, import_node_path35.join)(dir, name);
+      (0, import_node_fs39.copyFileSync)(abs, destAbs);
       const rel = `${ATTACHMENTS_DIR}/${name}`;
-      const buf = (0, import_node_fs38.readFileSync)(destAbs);
+      const buf = (0, import_node_fs39.readFileSync)(destAbs);
       out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
     } catch (err) {
       out.push({
@@ -13781,8 +14096,8 @@ function stageBuffersAsAttachments(worktreePath, buffers2) {
     try {
       const buf = Buffer.from(item.dataBase64, "base64");
       const name = uniqueAttachmentName(dir, originalName);
-      const destAbs = (0, import_node_path34.join)(dir, name);
-      (0, import_node_fs38.writeFileSync)(destAbs, buf);
+      const destAbs = (0, import_node_path35.join)(dir, name);
+      (0, import_node_fs39.writeFileSync)(destAbs, buf);
       const rel = `${ATTACHMENTS_DIR}/${name}`;
       out.push(attachmentFromBuffer(name, buf, { path: rel }));
     } catch (err) {
@@ -13802,18 +14117,18 @@ function attachmentsFromWorktreePaths(worktreePath, relativePaths) {
     if (!rel || rel.includes("..") || rel.startsWith("/")) {
       out.push({
         id: (0, import_node_crypto7.randomUUID)(),
-        name: (0, import_node_path34.basename)(rel) || "file",
+        name: (0, import_node_path35.basename)(rel) || "file",
         kind: "file",
         content: `(invalid path: ${rel})`
       });
       continue;
     }
-    const name = (0, import_node_path34.basename)(rel);
+    const name = (0, import_node_path35.basename)(rel);
     try {
-      const abs = (0, import_node_path34.join)(worktreePath, rel);
-      const st = (0, import_node_fs38.statSync)(abs);
+      const abs = (0, import_node_path35.join)(worktreePath, rel);
+      const st = (0, import_node_fs39.statSync)(abs);
       if (!st.isFile()) continue;
-      const buf = (0, import_node_fs38.readFileSync)(abs);
+      const buf = (0, import_node_fs39.readFileSync)(abs);
       out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
     } catch (err) {
       out.push({
@@ -13826,12 +14141,12 @@ function attachmentsFromWorktreePaths(worktreePath, relativePaths) {
   }
   return out;
 }
-var import_node_fs38, import_node_path34, import_node_crypto7, IMAGE_EXTENSIONS2, IMAGE_MIME_BY_EXT, MAX_INLINE_BYTES, MAX_PREVIEW_BYTES;
+var import_node_fs39, import_node_path35, import_node_crypto7, IMAGE_EXTENSIONS2, IMAGE_MIME_BY_EXT, MAX_INLINE_BYTES, MAX_PREVIEW_BYTES;
 var init_stage_files = __esm({
   "src/composer/stage-files.ts"() {
     "use strict";
-    import_node_fs38 = require("fs");
-    import_node_path34 = require("path");
+    import_node_fs39 = require("fs");
+    import_node_path35 = require("path");
     import_node_crypto7 = require("crypto");
     init_workspace_scratch();
     IMAGE_EXTENSIONS2 = /* @__PURE__ */ new Set([
@@ -13978,14 +14293,15 @@ function formatArtifactDirective() {
   return [
     "Sideboard side column (desktop UI):",
     "claude.ai\u2019s \u201CArtifact\u201D tool does NOT exist in Claude Code. That is expected.",
+    "Do not unprompted-duplicate a payload. Chat markdown (including tables) already renders in the transcript \u2014 do not also call present_schema with those same rows just to display them. If the user asks for an editable / interactive table, call present_schema even if markdown already showed the data. Do not also call present_artifact for a document you already fenced in chat.",
     "Documents (HTML/SVG/markdown):",
     "1) Emit a fenced code block tagged `html` (preferred), `svg`, or `markdown` with the FULL document \u2014 Sideboard opens a side column. Example:",
     "```html",
     "<!DOCTYPE html><html><head><title>Demo</title></head><body><h1>Hi</h1></body></html>",
     "```",
-    "2) Or call Sideboard MCP `present_artifact` with title, type (html|svg|markdown), and content.",
+    "2) Or call Sideboard MCP `present_artifact` with title, type (html|svg|markdown), and content \u2014 not both a fence and this tool for the same body.",
     "CMS / JSON Schema forms & tables (Brightsy or any schema+schemaUi source):",
-    "3) Call Sideboard MCP `present_schema` with title, mode (table|form), and either:",
+    "3) Call Sideboard MCP `present_schema` when the user needs to filter, edit, publish, or persist rows \u2014 including after you already showed a markdown table, if they then ask for an editable table. If they only need to read the data, a markdown table is enough. When you do call it, pass title, mode (table|form), and either:",
     "   - datasource=brightsy + resource_id (record type UUID) after fetching types via Brightsy MCP, or",
     "   - datasource=inline + resource: { id, title, schema, schemaUi } and optional records/record.",
     "Files / media browser (CMS file manager column):",
@@ -13994,18 +14310,18 @@ function formatArtifactDirective() {
     "Multiple-choice questions:",
     "5) Call Sideboard MCP `ask_user` only when work is blocked on choosing among a few concrete options (approach forks, which API, auth vs cookies). First write a short chat message that explains the decision and what each option means (tradeoffs, when to pick it). Include a description on every option. After calling, stop and wait for their next message with answers. If you are asking a real multiple-choice, use ask_user rather than chat bullets so Sideboard shows the composer picker.",
     "Do not call ask_user for greetings, check-ins, \u201Chello\u201D, open-ended how-can-I-help, or to invent a menu of possible next tasks \u2014 reply in chat. If one option is the obvious default, proceed without asking.",
-    "Never say artifacts, CMS UI, or the Files column are unavailable. Prefer present_schema for list/edit/publish; present_files for storage UI; html fences for standalone pages; ask_user only for those blocked predefined-option questions."
+    "Never say artifacts, CMS UI, or the Files column are unavailable. present_schema is for interactive list/edit/publish (use it when they ask to edit, even if chat already had a markdown table); present_files for storage UI; html fences for standalone pages; ask_user only for those blocked predefined-option questions."
   ].join("\n");
 }
 function formatUiReminder() {
-  return "Sideboard UI: html fence or present_artifact / present_schema / present_files; ask_user only for a real multiple-choice (not hellos or \u201Cwhat next?\u201D) \u2014 reply in chat. Do not say artifacts/CMS UI are unavailable.";
+  return "Sideboard UI: markdown table is enough to read data; present_schema if they ask to edit/filter (even after markdown); present_files for the file manager. html fence or present_artifact, not both for the same document. ask_user only for a real multiple-choice (not hellos or \u201Cwhat next?\u201D) \u2014 reply in chat. Do not say artifacts/CMS UI are unavailable.";
 }
-var import_node_fs39, import_node_path35;
+var import_node_fs40, import_node_path36;
 var init_instructions = __esm({
   "src/agents/instructions.ts"() {
     "use strict";
-    import_node_fs39 = require("fs");
-    import_node_path35 = require("path");
+    import_node_fs40 = require("fs");
+    import_node_path36 = require("path");
     init_git_auth_mode();
     init_worktree_labels();
   }
@@ -14081,40 +14397,40 @@ __export(plan_file_exports, {
   writePlanFile: () => writePlanFile
 });
 function ensureAttachmentsGitignore(worktreePath) {
-  const gitignoreAbs = (0, import_node_path36.join)(worktreePath, ATTACHMENTS_DIR, ".gitignore");
-  if ((0, import_node_fs40.existsSync)(gitignoreAbs)) return;
-  (0, import_node_fs40.mkdirSync)((0, import_node_path36.dirname)(gitignoreAbs), { recursive: true });
-  (0, import_node_fs40.writeFileSync)(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
+  const gitignoreAbs = (0, import_node_path37.join)(worktreePath, ATTACHMENTS_DIR, ".gitignore");
+  if ((0, import_node_fs41.existsSync)(gitignoreAbs)) return;
+  (0, import_node_fs41.mkdirSync)((0, import_node_path37.dirname)(gitignoreAbs), { recursive: true });
+  (0, import_node_fs41.writeFileSync)(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
 }
 function planFileAbs(worktreePath) {
-  return (0, import_node_path36.join)(worktreePath, PLAN_FILE_REL);
+  return (0, import_node_path37.join)(worktreePath, PLAN_FILE_REL);
 }
 function readTextIfPresent2(abs) {
-  if (!(0, import_node_fs40.existsSync)(abs)) return null;
+  if (!(0, import_node_fs41.existsSync)(abs)) return null;
   try {
-    const content = (0, import_node_fs40.readFileSync)(abs, "utf8");
+    const content = (0, import_node_fs41.readFileSync)(abs, "utf8");
     return content.trim() ? content : null;
   } catch {
     return null;
   }
 }
 function readPlanFile(worktreePath) {
-  return readTextIfPresent2(planFileAbs(worktreePath)) ?? readTextIfPresent2((0, import_node_path36.join)(worktreePath, `${LEGACY_ATTACHMENTS_DIR}/plan.md`)) ?? readTextIfPresent2((0, import_node_path36.join)(worktreePath, LEGACY_PLAN_FILE_REL));
+  return readTextIfPresent2(planFileAbs(worktreePath)) ?? readTextIfPresent2((0, import_node_path37.join)(worktreePath, `${LEGACY_ATTACHMENTS_DIR}/plan.md`)) ?? readTextIfPresent2((0, import_node_path37.join)(worktreePath, LEGACY_PLAN_FILE_REL));
 }
 function writePlanFile(worktreePath, content) {
   ensureAttachmentsGitignore(worktreePath);
   const abs = planFileAbs(worktreePath);
-  (0, import_node_fs40.mkdirSync)((0, import_node_path36.dirname)(abs), { recursive: true });
+  (0, import_node_fs41.mkdirSync)((0, import_node_path37.dirname)(abs), { recursive: true });
   const body = content.trimEnd() + (content.endsWith("\n") ? "" : "\n");
-  (0, import_node_fs40.writeFileSync)(abs, body, "utf8");
+  (0, import_node_fs41.writeFileSync)(abs, body, "utf8");
   return PLAN_FILE_REL;
 }
-var import_node_fs40, import_node_path36;
+var import_node_fs41, import_node_path37;
 var init_plan_file = __esm({
   "src/plan/plan-file.ts"() {
     "use strict";
-    import_node_fs40 = require("fs");
-    import_node_path36 = require("path");
+    import_node_fs41 = require("fs");
+    import_node_path37 = require("path");
     init_workspace_scratch();
     init_plan_present();
     init_plan_present();
@@ -14174,7 +14490,7 @@ function setCaffeinateHoldHooks(next) {
   hooks = next;
 }
 function caffeinateHoldPath() {
-  return (0, import_node_path37.join)(appDataDir(), "caffeinate-hold.json");
+  return (0, import_node_path38.join)(appDataDir(), "caffeinate-hold.json");
 }
 function processAlive(pid) {
   if (hooks.processAlive) return hooks.processAlive(pid);
@@ -14208,9 +14524,9 @@ function uniqueIds(ids) {
 }
 function readHold() {
   const path = caffeinateHoldPath();
-  if (!(0, import_node_fs41.existsSync)(path)) return null;
+  if (!(0, import_node_fs42.existsSync)(path)) return null;
   try {
-    const parsed = JSON.parse((0, import_node_fs41.readFileSync)(path, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs42.readFileSync)(path, "utf8"));
     if (typeof parsed?.pid === "number" && parsed.pid > 0) {
       return {
         pid: parsed.pid,
@@ -14232,7 +14548,7 @@ function writeHold(pid, threadIds) {
 }
 function clearHold() {
   try {
-    (0, import_node_fs41.unlinkSync)(caffeinateHoldPath());
+    (0, import_node_fs42.unlinkSync)(caffeinateHoldPath());
   } catch {
   }
 }
@@ -14317,13 +14633,13 @@ function releaseCaffeinateHoldForThread(threadId) {
   }
   return setCaffeinateHold(false, { threadId: id });
 }
-var import_node_child_process4, import_node_fs41, import_node_path37, hooks;
+var import_node_child_process4, import_node_fs42, import_node_path38, hooks;
 var init_caffeinate_hold = __esm({
   "src/store/caffeinate-hold.ts"() {
     "use strict";
     import_node_child_process4 = require("child_process");
-    import_node_fs41 = require("fs");
-    import_node_path37 = require("path");
+    import_node_fs42 = require("fs");
+    import_node_path38 = require("path");
     init_paths();
     init_private_file();
     hooks = {};
@@ -14332,7 +14648,7 @@ var init_caffeinate_hold = __esm({
 
 // src/store/schedules.ts
 function schedulesPath() {
-  return (0, import_node_path38.join)(appDataDir(), "schedules.json");
+  return (0, import_node_path39.join)(appDataDir(), "schedules.json");
 }
 function parseDurationMs(every) {
   const m = every.trim().match(DURATION_RE);
@@ -14432,9 +14748,9 @@ function normalizeTask(raw) {
 }
 function readAll2() {
   const path = schedulesPath();
-  if (!(0, import_node_fs42.existsSync)(path)) return [];
+  if (!(0, import_node_fs43.existsSync)(path)) return [];
   try {
-    const parsed = JSON.parse((0, import_node_fs42.readFileSync)(path, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs43.readFileSync)(path, "utf8"));
     if (!Array.isArray(parsed)) return [];
     return parsed.map((row) => {
       try {
@@ -14546,13 +14862,13 @@ function recordScheduleRun(id, result) {
   writeAll2(rows);
   return next;
 }
-var import_node_crypto8, import_node_fs42, import_node_path38, import_croner, DURATION_RE, UNIT_MS;
+var import_node_crypto8, import_node_fs43, import_node_path39, import_croner, DURATION_RE, UNIT_MS;
 var init_schedules = __esm({
   "src/store/schedules.ts"() {
     "use strict";
     import_node_crypto8 = require("crypto");
-    import_node_fs42 = require("fs");
-    import_node_path38 = require("path");
+    import_node_fs43 = require("fs");
+    import_node_path39 = require("path");
     import_croner = require("croner");
     init_orchestrator_capable();
     init_paths();
@@ -14700,10 +15016,10 @@ __export(cursor_recover_exports, {
 function recoverFinishedCursorRun(opts) {
   const agentId = opts.agentId.trim();
   if (!agentId) return null;
-  const runsPath = (0, import_node_path39.join)(appDataDir(), "cursor-sdk-store", "runs.ndjson");
-  if (!(0, import_node_fs43.existsSync)(runsPath)) return null;
+  const runsPath = (0, import_node_path40.join)(appDataDir(), "cursor-sdk-store", "runs.ndjson");
+  if (!(0, import_node_fs44.existsSync)(runsPath)) return null;
   try {
-    const lines = (0, import_node_fs43.readFileSync)(runsPath, "utf8").split("\n");
+    const lines = (0, import_node_fs44.readFileSync)(runsPath, "utf8").split("\n");
     let best = null;
     for (const line of lines) {
       const trimmed = line.trim();
@@ -14729,12 +15045,12 @@ function recoverFinishedCursorRun(opts) {
     return null;
   }
 }
-var import_node_fs43, import_node_path39;
+var import_node_fs44, import_node_path40;
 var init_cursor_recover = __esm({
   "src/agents/cursor-recover.ts"() {
     "use strict";
-    import_node_fs43 = require("fs");
-    import_node_path39 = require("path");
+    import_node_fs44 = require("fs");
+    import_node_path40 = require("path");
     init_paths();
   }
 });
@@ -14865,14 +15181,16 @@ async function startOrchestration(opts) {
   }
   return updated;
 }
-var import_node_events, import_node_fs44, STALE_AGENT_PID_WAIT_MS, Orchestrator, singleton;
+var import_node_events, import_node_fs45, STALE_AGENT_PID_WAIT_MS, Orchestrator, singleton;
 var init_orchestrator = __esm({
   "src/orchestrator/orchestrator.ts"() {
     "use strict";
     import_node_events = require("events");
     init_outbound_watch();
-    import_node_fs44 = require("fs");
+    import_node_fs45 = require("fs");
     init_error_detail();
+    init_run();
+    init_stale_lock();
     init_spawn();
     init_agents();
     init_worktree();
@@ -14988,7 +15306,7 @@ var init_orchestrator = __esm({
             }
             continue;
           }
-          if (!(0, import_node_fs44.existsSync)(thread.worktreePath)) {
+          if (!(0, import_node_fs45.existsSync)(thread.worktreePath)) {
             setStatus(thread.id, "broken", "Worktree missing on disk");
             this.emit({ type: "status_changed", threadId: thread.id, status: "broken" });
             continue;
@@ -15581,7 +15899,15 @@ var init_orchestrator = __esm({
             hasSession: Boolean(this.requireThread(threadId).sessionId)
           })) {
             updateThread(threadId, { sessionId: null });
-            const retryNote = looksLikeInvalidAgentSession(detail) ? "Agent session missing \u2014 starting a fresh session" : "Agent runner crashed \u2014 restarting Node once";
+            try {
+              const gitDirs = await resolveGitDirsForLockRecovery(thread.worktreePath);
+              const clearedLocks = clearStaleIndexLocks(gitDirs, 2e3);
+              if (clearedLocks.length > 0) {
+                pushTurnStderr(stderrTail, "Cleared a stale git lock left by the crashed agent process");
+              }
+            } catch {
+            }
+            const retryNote = looksLikeInvalidAgentSession(detail) ? "Agent session missing \u2014 starting a fresh session" : looksLikeV8Oom(detail) ? "Agent ran out of memory \u2014 starting a fresh session" : "Agent runner crashed \u2014 restarting Node once";
             pushTurnStderr(stderrTail, retryNote);
             this.emit({
               type: "turn_output",
@@ -16053,13 +16379,14 @@ var init_orchestrator = __esm({
         const text4 = (lastAgent?.text ?? "").trim() || (thread.status === "error" ? lastError ?? "" : "");
         const stillRunning = thread.status === "running" || thread.status === "queued";
         const live = stillRunning ? readTurnLive(thread.id) : null;
+        const queuedHint = thread.status === "queued" && !live?.summary ? "Queued \u2014 waiting for a concurrency slot" : null;
         return {
           text: text4,
           status: thread.status,
           sessionId: thread.sessionId,
           lastError,
           stillRunning,
-          progress: live?.summary ?? null,
+          progress: live?.summary ?? queuedHint,
           lastActivityAt: live?.updatedAt ?? null
         };
       }
@@ -16576,7 +16903,7 @@ var init_orchestrator = __esm({
           this.emit({ type: "status_changed", threadId: restored2.id, status: restored2.status });
           return restored2;
         }
-        if (!(0, import_node_fs44.existsSync)(thread.worktreePath)) {
+        if (!(0, import_node_fs45.existsSync)(thread.worktreePath)) {
           if (isCowboyThread(thread) || isPrimaryCheckoutThread(thread)) {
             throw new Error(
               `Cowboy checkout missing: ${thread.worktreePath}. Re-add the project folder, then restore.`
@@ -16656,7 +16983,7 @@ init_nested_electron_env();
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 var import_zod4 = require("zod");
-var import_node_path40 = require("path");
+var import_node_path41 = require("path");
 init_orchestrator();
 init_worktree();
 
@@ -17163,6 +17490,10 @@ function mcpWaitForTurnTimeoutMs(requested) {
   return Math.min(Math.max(1e3, Math.floor(n)), MCP_WAIT_FOR_TURN_MAX_MS);
 }
 var MCP_WAIT_STILL_RUNNING_HINT = "Child is still working. Call wait_for_turn again. Do not send a check-in prompt or assume a hang while progress is updating.";
+var MCP_WAIT_QUEUED_HINT = "Child is queued waiting for a concurrency slot \u2014 it has not started yet. Call wait_for_turn again. Do not send a check-in prompt, force_stop, or assume it failed to start.";
+function mcpWaitStillRunningHint(status) {
+  return status === "queued" ? MCP_WAIT_QUEUED_HINT : MCP_WAIT_STILL_RUNNING_HINT;
+}
 
 // src/mcp/server.ts
 init_turn_live();
@@ -18009,7 +18340,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_path40.basename)(t.repoPath) || t.repoPath;
+          const repo = t.repoPath === GLOBAL_WORKSPACE_ID ? "Orchestration" : (0, import_node_path41.basename)(t.repoPath) || t.repoPath;
           const live = t.status === "running" || t.status === "queued" ? readTurnLive(t.id) : null;
           const progress = live?.summary ? `  ${live.summary}` : "";
           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}` : ""}${progress}`;
@@ -18045,7 +18376,7 @@ async function startMcpServer() {
           prUrl: t.prUrl,
           lastError: t.lastError ?? null,
           stillRunning: t.status === "running" || t.status === "queued",
-          progress: live?.summary ?? null,
+          progress: live?.summary ?? (t.status === "queued" ? "Queued \u2014 waiting for a concurrency slot" : null),
           lastActivityAt: live?.updatedAt ?? null
         };
         return { content: [{ type: "text", text: JSON.stringify(summary, null, 2) }] };
@@ -18054,7 +18385,7 @@ async function startMcpServer() {
   }
   server.tool(
     "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.",
+    "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. Do not also emit the same document as a chat html/markdown fence. 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_zod4.z.string().describe("Short title shown in the artifact pane header"),
       type: import_zod4.z.enum(["html", "svg", "markdown", "react"]).describe(
@@ -18131,7 +18462,7 @@ async function startMcpServer() {
   );
   server.tool(
     "present_schema",
-    "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.",
+    "Open Sideboard\u2019s schema-driven side column (filterable table and/or form) when the user needs to filter, edit, publish, or persist records. Do not call this just to re-display rows you already wrote as a markdown table. If the user asks for an editable / interactive table, call this even if chat already showed those rows. 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_zod4.z.string().describe("Pane title"),
       mode: import_zod4.z.enum(["table", "form"]).optional().describe("table = list/filter records; form = edit one record"),
@@ -18379,7 +18710,7 @@ async function startMcpServer() {
     );
     server.tool(
       "wait_for_turn",
-      "Wait until the thread finishes its current/queued turn, or return early with a live progress snapshot. MCP clients often kill tools around 60s, so this returns within 45s even while the child is still working. If stillRunning is true, progress is tools/thinking \u2014 call wait_for_turn again. Do not send a check-in prompt or assume a hang. On status error, lastError/text is the failure.",
+      "Wait until the thread finishes its current/queued turn, or return early with a live progress snapshot. MCP clients often kill tools around 60s, so this returns within 45s even while the child is still working. If stillRunning is true, progress is tools/thinking (or \u201Cqueued, waiting for a concurrency slot\u201D if it has not started). Call wait_for_turn again. Do not send a check-in prompt, force_stop, or assume a hang. On status error, lastError/text is the failure.",
       {
         ref: import_zod4.z.string(),
         timeoutMs: import_zod4.z.number().optional()
@@ -18401,7 +18732,7 @@ async function startMcpServer() {
                 stillRunning: result.stillRunning,
                 progress: result.progress,
                 lastActivityAt: result.lastActivityAt,
-                hint: result.stillRunning ? MCP_WAIT_STILL_RUNNING_HINT : void 0
+                hint: result.stillRunning ? mcpWaitStillRunningHint(result.status) : void 0
               })
             }
           ]
@@ -18420,7 +18751,7 @@ async function startMcpServer() {
               type: "text",
               text: JSON.stringify({
                 ...result,
-                hint: result.stillRunning ? MCP_WAIT_STILL_RUNNING_HINT : void 0
+                hint: result.stillRunning ? mcpWaitStillRunningHint(result.status) : void 0
               })
             }
           ]