@sideboard-ai/core 0.1.135 → 0.1.136

package/dist/index.cjs

@@ -2648,6 +2648,300 @@ var init_cloud_connect_constants = __esm({
   }
 });
 
+// src/paths/workspace-scratch.ts
+function attachmentsGitignoreBody() {
+  return ATTACHMENTS_GITIGNORE;
+}
+function isWorkspaceScratchPath(relativePath) {
+  const p = relativePath.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/$/, "");
+  return p === ATTACHMENTS_DIR || p.startsWith(`${ATTACHMENTS_DIR}/`) || p === LEGACY_ATTACHMENTS_DIR || p.startsWith(`${LEGACY_ATTACHMENTS_DIR}/`) || p === ".context" || p.startsWith(".context/");
+}
+var ATTACHMENTS_DIR, LEGACY_ATTACHMENTS_DIR, ATTACHMENTS_GITIGNORE;
+var init_workspace_scratch = __esm({
+  "src/paths/workspace-scratch.ts"() {
+    "use strict";
+    ATTACHMENTS_DIR = ".context/attachments";
+    LEGACY_ATTACHMENTS_DIR = ".sideboard/attachments";
+    ATTACHMENTS_GITIGNORE = `# Sideboard / workspace attachments (local only)
+*
+!.gitignore
+`;
+  }
+});
+
+// src/composer/stage-files.ts
+function fileExtension(filePath) {
+  const base = (0, import_node_path13.basename)(filePath).toLowerCase();
+  return base.includes(".") ? base.split(".").pop() || "" : "";
+}
+function isImageFilePath(filePath) {
+  return IMAGE_EXTENSIONS.has(fileExtension(filePath));
+}
+function imageMimeType(filePath) {
+  return IMAGE_MIME_BY_EXT[fileExtension(filePath)] || "image/png";
+}
+function ensureAttachmentsDir(worktreePath) {
+  const dir = (0, import_node_path13.join)(worktreePath, ATTACHMENTS_DIR);
+  (0, import_node_fs12.mkdirSync)(dir, { recursive: true });
+  const gi = (0, import_node_path13.join)(dir, ".gitignore");
+  if (!(0, import_node_fs12.existsSync)(gi)) {
+    (0, import_node_fs12.writeFileSync)(gi, attachmentsGitignoreBody(), "utf8");
+  }
+  return dir;
+}
+function uniqueAttachmentName(dir, originalName) {
+  const safe = originalName.replace(/[/\\]/g, "_") || "file";
+  if (!(0, import_node_fs12.existsSync)((0, import_node_path13.join)(dir, safe))) return safe;
+  const ext = (0, import_node_path13.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_fs12.existsSync)((0, import_node_path13.join)(dir, candidate))) return candidate;
+  }
+  return `${stem}-${(0, import_node_crypto5.randomUUID)()}${ext}`;
+}
+function previewDataUrlFromBuf(filePath, buf) {
+  if (!isImageFilePath(filePath)) return void 0;
+  if (buf.length > MAX_PREVIEW_BYTES) return void 0;
+  return `data:${imageMimeType(filePath)};base64,${buf.toString("base64")}`;
+}
+function attachmentFromBuffer(name, buf, opts) {
+  const previewDataUrl = previewDataUrlFromBuf(name, buf);
+  if (isImageFilePath(name)) {
+    const pathHint = opts.path ? `\`${opts.path}\`` : opts.sourceLabel || name;
+    return {
+      id: (0, import_node_crypto5.randomUUID)(),
+      name,
+      kind: "file",
+      path: opts.path,
+      previewDataUrl,
+      content: [
+        `Image attached: ${pathHint}`,
+        opts.path ? `Use the Read tool on \`${opts.path}\` to view this image.` : "The image is shown in the composer; copy it into the worktree if you need to inspect pixels."
+      ].join("\n")
+    };
+  }
+  if (buf.length > MAX_INLINE_BYTES) {
+    return {
+      id: (0, import_node_crypto5.randomUUID)(),
+      name,
+      kind: "file",
+      path: opts.path,
+      content: opts.path ? `(file too large to attach inline: \`${opts.path}\`, ${buf.length} bytes \u2014 use the Read tool)` : `(file too large to attach inline: ${opts.sourceLabel || name}, ${buf.length} bytes)`
+    };
+  }
+  if (buf.includes(0)) {
+    return {
+      id: (0, import_node_crypto5.randomUUID)(),
+      name,
+      kind: "file",
+      path: opts.path,
+      content: opts.path ? `(binary file at \`${opts.path}\` \u2014 use tools to inspect)` : `(binary file attached by path only: ${opts.sourceLabel || name})`
+    };
+  }
+  return {
+    id: (0, import_node_crypto5.randomUUID)(),
+    name,
+    kind: "file",
+    path: opts.path,
+    content: buf.toString("utf8")
+  };
+}
+function attachmentFromAbsolutePath(absolutePath) {
+  const name = (0, import_node_path13.basename)(absolutePath);
+  try {
+    const st = (0, import_node_fs12.statSync)(absolutePath);
+    if (!st.isFile()) {
+      return {
+        id: (0, import_node_crypto5.randomUUID)(),
+        name,
+        kind: "file",
+        content: `(not a file: ${absolutePath})`
+      };
+    }
+    const buf = (0, import_node_fs12.readFileSync)(absolutePath);
+    return attachmentFromBuffer(name, buf, { sourceLabel: absolutePath });
+  } catch (err) {
+    return {
+      id: (0, import_node_crypto5.randomUUID)(),
+      name,
+      kind: "file",
+      content: `(could not read ${absolutePath}: ${err instanceof Error ? err.message : String(err)})`
+    };
+  }
+}
+function stageAbsolutePathsAsAttachments(worktreePath, absolutePaths) {
+  if (absolutePaths.length === 0) return [];
+  const dir = ensureAttachmentsDir(worktreePath);
+  const out = [];
+  for (const abs of absolutePaths) {
+    const originalName = (0, import_node_path13.basename)(abs);
+    try {
+      const st = (0, import_node_fs12.statSync)(abs);
+      if (!st.isFile()) continue;
+      const name = uniqueAttachmentName(dir, originalName);
+      const destAbs = (0, import_node_path13.join)(dir, name);
+      (0, import_node_fs12.copyFileSync)(abs, destAbs);
+      const rel = `${ATTACHMENTS_DIR}/${name}`;
+      const buf = (0, import_node_fs12.readFileSync)(destAbs);
+      out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
+    } catch (err) {
+      out.push({
+        id: (0, import_node_crypto5.randomUUID)(),
+        name: originalName,
+        kind: "file",
+        content: `(could not attach ${abs}: ${err instanceof Error ? err.message : String(err)})`
+      });
+    }
+  }
+  return out;
+}
+function stageBuffersAsAttachments(worktreePath, buffers2) {
+  if (buffers2.length === 0) return [];
+  const dir = ensureAttachmentsDir(worktreePath);
+  const out = [];
+  for (const item of buffers2) {
+    const originalName = (item.name || "file").replace(/[/\\]/g, "_") || "file";
+    try {
+      const buf = Buffer.from(item.dataBase64, "base64");
+      const name = uniqueAttachmentName(dir, originalName);
+      const destAbs = (0, import_node_path13.join)(dir, name);
+      (0, import_node_fs12.writeFileSync)(destAbs, buf);
+      const rel = `${ATTACHMENTS_DIR}/${name}`;
+      out.push(attachmentFromBuffer(name, buf, { path: rel }));
+    } catch (err) {
+      out.push({
+        id: (0, import_node_crypto5.randomUUID)(),
+        name: originalName,
+        kind: "file",
+        content: `(could not attach ${originalName}: ${err instanceof Error ? err.message : String(err)})`
+      });
+    }
+  }
+  return out;
+}
+function attachmentsFromBuffers(buffers2) {
+  return buffers2.map((item) => {
+    const name = (item.name || "file").replace(/[/\\]/g, "_") || "file";
+    try {
+      const buf = Buffer.from(item.dataBase64, "base64");
+      return attachmentFromBuffer(name, buf, { sourceLabel: name });
+    } catch (err) {
+      return {
+        id: (0, import_node_crypto5.randomUUID)(),
+        name,
+        kind: "file",
+        content: `(could not attach ${name}: ${err instanceof Error ? err.message : String(err)})`
+      };
+    }
+  });
+}
+function isWorktreeRelativePath(p) {
+  if (!p || p.includes("..")) return false;
+  if (p.startsWith("/")) return false;
+  if (/^[A-Za-z]:[\\/]/.test(p)) return false;
+  return true;
+}
+function dataUrlToBase64(url) {
+  if (!url) return null;
+  const m = /^data:[^;]+;base64,(.+)$/s.exec(url);
+  return m?.[1] ?? null;
+}
+function persistPendingFileAttachments(worktreePath, attachments) {
+  if (attachments.length === 0) return attachments;
+  const keep = [];
+  const buffers2 = [];
+  for (const att of attachments) {
+    if (att.kind !== "file") {
+      keep.push(att);
+      continue;
+    }
+    if (att.path && isWorktreeRelativePath(att.path)) {
+      keep.push(att);
+      continue;
+    }
+    const fromPreview = dataUrlToBase64(att.previewDataUrl);
+    if (fromPreview) {
+      buffers2.push({ name: att.name, dataBase64: fromPreview });
+      continue;
+    }
+    if (att.content && !IMAGE_HINT_RE.test(att.content) && !PLACEHOLDER_CONTENT_RE.test(att.content)) {
+      buffers2.push({
+        name: att.name,
+        dataBase64: Buffer.from(att.content, "utf8").toString("base64")
+      });
+      continue;
+    }
+    keep.push(att);
+  }
+  if (buffers2.length === 0) return attachments;
+  return [...keep, ...stageBuffersAsAttachments(worktreePath, buffers2)];
+}
+function attachmentsFromWorktreePaths(worktreePath, relativePaths) {
+  const out = [];
+  for (const rel of relativePaths) {
+    if (!rel || rel.includes("..") || rel.startsWith("/")) {
+      out.push({
+        id: (0, import_node_crypto5.randomUUID)(),
+        name: (0, import_node_path13.basename)(rel) || "file",
+        kind: "file",
+        content: `(invalid path: ${rel})`
+      });
+      continue;
+    }
+    const name = (0, import_node_path13.basename)(rel);
+    try {
+      const abs = (0, import_node_path13.join)(worktreePath, rel);
+      const st = (0, import_node_fs12.statSync)(abs);
+      if (!st.isFile()) continue;
+      const buf = (0, import_node_fs12.readFileSync)(abs);
+      out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
+    } catch (err) {
+      out.push({
+        id: (0, import_node_crypto5.randomUUID)(),
+        name,
+        kind: "file",
+        content: `(could not read ${rel}: ${err instanceof Error ? err.message : String(err)})`
+      });
+    }
+  }
+  return out;
+}
+var import_node_fs12, import_node_path13, import_node_crypto5, IMAGE_EXTENSIONS, IMAGE_MIME_BY_EXT, MAX_INLINE_BYTES, MAX_PREVIEW_BYTES, IMAGE_HINT_RE, PLACEHOLDER_CONTENT_RE;
+var init_stage_files = __esm({
+  "src/composer/stage-files.ts"() {
+    "use strict";
+    import_node_fs12 = require("fs");
+    import_node_path13 = require("path");
+    import_node_crypto5 = require("crypto");
+    init_workspace_scratch();
+    IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
+      "png",
+      "jpg",
+      "jpeg",
+      "gif",
+      "webp",
+      "svg",
+      "bmp",
+      "ico"
+    ]);
+    IMAGE_MIME_BY_EXT = {
+      png: "image/png",
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      gif: "image/gif",
+      webp: "image/webp",
+      svg: "image/svg+xml",
+      bmp: "image/bmp",
+      ico: "image/x-icon"
+    };
+    MAX_INLINE_BYTES = 4e5;
+    MAX_PREVIEW_BYTES = 5e6;
+    IMAGE_HINT_RE = /^Image attached:/;
+    PLACEHOLDER_CONTENT_RE = /^\((could not |file too large|binary file|not a file|invalid path)/;
+  }
+});
+
 // src/git/team-meta.ts
 var SOCCER_TEAM_META;
 var init_team_meta = __esm({
@@ -3559,23 +3853,23 @@ var init_gh_errors = __esm({
 function githubAgentAuthDir() {
   const override = process.env.SIDEBOARD_GIT_AUTH_DIR?.trim();
   if (override) return override;
-  return (0, import_node_path13.join)((0, import_node_os4.homedir)(), ".sideboard-git-auth");
+  return (0, import_node_path14.join)((0, import_node_os4.homedir)(), ".sideboard-git-auth");
 }
 function githubCredentialStorePath() {
-  return (0, import_node_path13.join)(githubAgentAuthDir(), "git-credentials");
+  return (0, import_node_path14.join)(githubAgentAuthDir(), "git-credentials");
 }
 function githubGhConfigDir() {
-  return (0, import_node_path13.join)(githubAgentAuthDir(), "gh");
+  return (0, import_node_path14.join)(githubAgentAuthDir(), "gh");
 }
 function writePrivateFile2(file, body) {
-  (0, import_node_fs12.mkdirSync)((0, import_node_path13.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_fs12.chmodSync)((0, import_node_path13.dirname)(file), 448);
+    (0, import_node_fs13.chmodSync)((0, import_node_path14.dirname)(file), 448);
   } catch {
   }
-  (0, import_node_fs12.writeFileSync)(file, body, { encoding: "utf8", mode: 384 });
+  (0, import_node_fs13.writeFileSync)(file, body, { encoding: "utf8", mode: 384 });
   try {
-    (0, import_node_fs12.chmodSync)(file, 384);
+    (0, import_node_fs13.chmodSync)(file, 384);
   } catch {
   }
 }
@@ -3600,19 +3894,19 @@ function materializeGithubAgentAuth(token, user) {
   const trimmed = token.trim();
   if (!trimmed) return;
   const root = githubAgentAuthDir();
-  (0, import_node_fs12.mkdirSync)(root, { recursive: true, mode: 448 });
+  (0, import_node_fs13.mkdirSync)(root, { recursive: true, mode: 448 });
   try {
-    (0, import_node_fs12.chmodSync)(root, 448);
+    (0, import_node_fs13.chmodSync)(root, 448);
   } catch {
   }
   writePrivateFile2(githubCredentialStorePath(), gitCredentialStoreContents(trimmed));
   const ghDir = githubGhConfigDir();
-  (0, import_node_fs12.mkdirSync)(ghDir, { recursive: true, mode: 448 });
-  writePrivateFile2((0, import_node_path13.join)(ghDir, "hosts.yml"), ghHostsYml(trimmed, user));
-  writePrivateFile2((0, import_node_path13.join)(ghDir, "config.yml"), "git_protocol: https\nprompt: disabled\n");
+  (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");
 }
 function githubAgentAuthReady() {
-  return (0, import_node_fs12.existsSync)(githubCredentialStorePath()) && (0, import_node_fs12.existsSync)((0, import_node_path13.join)(githubGhConfigDir(), "hosts.yml"));
+  return (0, import_node_fs13.existsSync)(githubCredentialStorePath()) && (0, import_node_fs13.existsSync)((0, import_node_path14.join)(githubGhConfigDir(), "hosts.yml"));
 }
 function githubCredentialHelperGitConfig() {
   const file = githubCredentialStorePath();
@@ -3627,29 +3921,29 @@ function githubGhConfigEnv() {
     GH_PROMPT_DISABLED: "1"
   };
 }
-var import_node_fs12, import_node_os4, import_node_path13;
+var import_node_fs13, import_node_os4, import_node_path14;
 var init_github_agent_auth = __esm({
   "src/git/github-agent-auth.ts"() {
     "use strict";
-    import_node_fs12 = require("fs");
+    import_node_fs13 = require("fs");
     import_node_os4 = require("os");
-    import_node_path13 = require("path");
+    import_node_path14 = require("path");
   }
 });
 
 // src/agents/path.ts
 function prependPathDir(env, dir) {
-  if (!dir || !(0, import_node_fs13.existsSync)(dir)) return;
+  if (!dir || !(0, import_node_fs14.existsSync)(dir)) return;
   const current = env.PATH ?? "";
-  const parts = current.split(import_node_path14.delimiter).filter(Boolean);
+  const parts = current.split(import_node_path15.delimiter).filter(Boolean);
   if (parts.includes(dir)) {
     env.PATH = current;
     return;
   }
-  env.PATH = [dir, ...parts].join(import_node_path14.delimiter);
+  env.PATH = [dir, ...parts].join(import_node_path15.delimiter);
 }
 function conductorBundledBinDir(home = process.env.HOME || process.env.USERPROFILE || (0, import_node_os5.homedir)()) {
-  return (0, import_node_path14.join)(home, "Library", "Application Support", "com.conductor.app", "bin");
+  return (0, import_node_path15.join)(home, "Library", "Application Support", "com.conductor.app", "bin");
 }
 function isConductorBundledCli(filePath) {
   const p = (filePath ?? "").replace(/\\/g, "/");
@@ -3658,21 +3952,21 @@ function isConductorBundledCli(filePath) {
 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_path14.delimiter).filter(Boolean);
+  const parts = current.split(import_node_path15.delimiter).filter(Boolean);
   const seen = new Set(parts);
   const extras = [
-    ...EXTRA_BIN_DIRS.map((rel) => (0, import_node_path14.join)(home, rel)),
+    ...EXTRA_BIN_DIRS.map((rel) => (0, import_node_path15.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_fs13.existsSync)(dir)) continue;
+    if (!dir || seen.has(dir) || !(0, import_node_fs14.existsSync)(dir)) continue;
     parts.unshift(dir);
     seen.add(dir);
   }
-  const next = parts.join(import_node_path14.delimiter);
+  const next = parts.join(import_node_path15.delimiter);
   env.PATH = next;
   return next;
 }
@@ -3686,7 +3980,7 @@ function enrichPathWithNpmGlobalBin(env = process.env) {
       stdio: ["ignore", "pipe", "ignore"]
     }).trim().split(/\r?\n/).find(Boolean);
     if (prefix) {
-      const binDir = process.platform === "win32" ? prefix : (0, import_node_path14.join)(prefix, "bin");
+      const binDir = process.platform === "win32" ? prefix : (0, import_node_path15.join)(prefix, "bin");
       prependPathDir(env, binDir);
     }
   } catch {
@@ -3714,14 +4008,14 @@ function withExportedPath(command, pathValue) {
   if (/^(export\s+PATH=|PATH=)/.test(trimmed)) return trimmed;
   return `export PATH=${posixShellSingleQuote(pathValue)} && ${trimmed}`;
 }
-var import_node_fs13, import_node_child_process3, import_node_os5, import_node_path14, EXTRA_BIN_DIRS;
+var import_node_fs14, import_node_child_process3, import_node_os5, import_node_path15, EXTRA_BIN_DIRS;
 var init_path = __esm({
   "src/agents/path.ts"() {
     "use strict";
-    import_node_fs13 = require("fs");
+    import_node_fs14 = require("fs");
     import_node_child_process3 = require("child_process");
     import_node_os5 = require("os");
-    import_node_path14 = require("path");
+    import_node_path15 = require("path");
     EXTRA_BIN_DIRS = [
       ".local/bin",
       ".cargo/bin",
@@ -3743,11 +4037,11 @@ function isIndexLockError(text5) {
   return /Unable to create ['"][^'"]*index\.lock['"]: File exists/i.test(text5);
 }
 function clearStaleIndexLock(gitDir, maxAgeMs = STALE_INDEX_LOCK_MS, now = Date.now()) {
-  const lockPath = (0, import_node_path15.join)(gitDir, "index.lock");
+  const lockPath = (0, import_node_path16.join)(gitDir, "index.lock");
   try {
-    if (!(0, import_node_fs14.existsSync)(lockPath)) return null;
-    if (now - (0, import_node_fs14.statSync)(lockPath).mtimeMs < maxAgeMs) return null;
-    (0, import_node_fs14.unlinkSync)(lockPath);
+    if (!(0, import_node_fs15.existsSync)(lockPath)) return null;
+    if (now - (0, import_node_fs15.statSync)(lockPath).mtimeMs < maxAgeMs) return null;
+    (0, import_node_fs15.unlinkSync)(lockPath);
     return lockPath;
   } catch {
     return null;
@@ -3762,12 +4056,12 @@ function clearStaleIndexLocks(gitDirs, maxAgeMs = STALE_INDEX_LOCK_MS) {
   }
   return removed;
 }
-var import_node_fs14, import_node_path15, STALE_INDEX_LOCK_MS;
+var import_node_fs15, import_node_path16, STALE_INDEX_LOCK_MS;
 var init_stale_lock = __esm({
   "src/git/stale-lock.ts"() {
     "use strict";
-    import_node_fs14 = require("fs");
-    import_node_path15 = require("path");
+    import_node_fs15 = require("fs");
+    import_node_path16 = require("path");
     STALE_INDEX_LOCK_MS = 2e4;
   }
 });
@@ -3975,7 +4269,7 @@ async function warmGithubAgentAuth(opts) {
 }
 function normalizeWritableRoot(raw) {
   const trimmed = raw.trim().replace(/\/+$/, "");
-  return trimmed && (0, import_node_path16.isAbsolute)(trimmed) ? trimmed : null;
+  return trimmed && (0, import_node_path17.isAbsolute)(trimmed) ? trimmed : null;
 }
 async function resolveCodexGitWritableRoots(cwd) {
   const roots = /* @__PURE__ */ new Set();
@@ -4052,11 +4346,11 @@ function formatGitAuthModeDirective(mode) {
       ].join("\n");
   }
 }
-var import_node_path16, HTTPS_REWRITE, TOKEN_TTL_MS, tokenMemo, GITHUB_CHILD_TOKEN_KEYS;
+var import_node_path17, 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_path16 = require("path");
+    import_node_path17 = require("path");
     init_app_settings();
     init_github_agent_auth();
     init_run();
@@ -4426,27 +4720,6 @@ var init_stack = __esm({
   }
 });
 
-// src/paths/workspace-scratch.ts
-function attachmentsGitignoreBody() {
-  return ATTACHMENTS_GITIGNORE;
-}
-function isWorkspaceScratchPath(relativePath) {
-  const p = relativePath.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/$/, "");
-  return p === ATTACHMENTS_DIR || p.startsWith(`${ATTACHMENTS_DIR}/`) || p === LEGACY_ATTACHMENTS_DIR || p.startsWith(`${LEGACY_ATTACHMENTS_DIR}/`) || p === ".context" || p.startsWith(".context/");
-}
-var ATTACHMENTS_DIR, LEGACY_ATTACHMENTS_DIR, ATTACHMENTS_GITIGNORE;
-var init_workspace_scratch = __esm({
-  "src/paths/workspace-scratch.ts"() {
-    "use strict";
-    ATTACHMENTS_DIR = ".context/attachments";
-    LEGACY_ATTACHMENTS_DIR = ".sideboard/attachments";
-    ATTACHMENTS_GITIGNORE = `# Sideboard / workspace attachments (local only)
-*
-!.gitignore
-`;
-  }
-});
-
 // src/git/worktree.ts
 var worktree_exports = {};
 __export(worktree_exports, {
@@ -4534,7 +4807,7 @@ async function resolveRepoRoot(cwd) {
 }
 function canonicalizeRepoPath(path2) {
   try {
-    return (0, import_node_fs15.realpathSync)(path2);
+    return (0, import_node_fs16.realpathSync)(path2);
   } catch {
     return path2.replace(/\/+$/, "");
   }
@@ -5262,8 +5535,8 @@ function isLocalPrFetchBranch(ref) {
 }
 async function createThreadWorktree(opts) {
   let branchName = `thread/${opts.slug}`;
-  const worktreePath = (0, import_node_path17.join)(worktreesRoot(opts.repoPath), opts.slug);
-  if ((0, import_node_fs15.existsSync)(worktreePath)) {
+  const worktreePath = (0, import_node_path18.join)(worktreesRoot(opts.repoPath), opts.slug);
+  if ((0, import_node_fs16.existsSync)(worktreePath)) {
     throw new Error(`Worktree already exists at ${worktreePath}`);
   }
   await ensureGhPreferOrigin(opts.repoPath);
@@ -5330,8 +5603,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_path17.join)(worktreesRoot(opts.repoPath), opts.slug);
-  if ((0, import_node_fs15.existsSync)(worktreePath)) {
+  const worktreePath = (0, import_node_path18.join)(worktreesRoot(opts.repoPath), opts.slug);
+  if ((0, import_node_fs16.existsSync)(worktreePath)) {
     throw new Error(`Worktree already exists at ${worktreePath}`);
   }
   await ensureGhPreferOrigin(opts.repoPath);
@@ -5622,10 +5895,10 @@ function sameRepoPath(a, b) {
   return normalizeWorktreePath(a) === normalizeWorktreePath(b);
 }
 function listLocalThreadBranchSlugs(repoPath) {
-  const refsDir = (0, import_node_path17.join)(repoPath, ".git", "refs", "heads", "thread");
-  if (!(0, import_node_fs15.existsSync)(refsDir)) return [];
+  const refsDir = (0, import_node_path18.join)(repoPath, ".git", "refs", "heads", "thread");
+  if (!(0, import_node_fs16.existsSync)(refsDir)) return [];
   try {
-    return (0, import_node_fs15.readdirSync)(refsDir).filter((name) => !name.startsWith(".")).map((name) => normalizeTakenSlug(name));
+    return (0, import_node_fs16.readdirSync)(refsDir).filter((name) => !name.startsWith(".")).map((name) => normalizeTakenSlug(name));
   } catch {
     return [];
   }
@@ -5633,8 +5906,8 @@ function listLocalThreadBranchSlugs(repoPath) {
 function collectTakenTeamSlugs(repoPath) {
   const taken = /* @__PURE__ */ new Set();
   const root = worktreesRoot(repoPath);
-  if ((0, import_node_fs15.existsSync)(root)) {
-    for (const entry of (0, import_node_fs15.readdirSync)(root, { withFileTypes: true })) {
+  if ((0, import_node_fs16.existsSync)(root)) {
+    for (const entry of (0, import_node_fs16.readdirSync)(root, { withFileTypes: true })) {
       if (entry.isDirectory() && entry.name !== ".DS_Store") {
         taken.add(normalizeTakenSlug(entry.name));
       }
@@ -5655,18 +5928,18 @@ function allocateTeamSlug(repoPath) {
   const taken = collectTakenTeamSlugs(repoPath);
   for (let attempt = 0; attempt < 32; attempt++) {
     const team = allocateTeamName(taken);
-    const path2 = (0, import_node_path17.join)(worktreesRoot(repoPath), team.slug);
-    if (!(0, import_node_fs15.existsSync)(path2)) return team;
+    const path2 = (0, import_node_path18.join)(worktreesRoot(repoPath), team.slug);
+    if (!(0, import_node_fs16.existsSync)(path2)) return team;
     taken.add(team.slug);
   }
   throw new Error("No available soccer team worktree directories left");
 }
-var import_node_fs15, import_node_path17;
+var import_node_fs16, import_node_path18;
 var init_worktree = __esm({
   "src/git/worktree.ts"() {
     "use strict";
-    import_node_fs15 = require("fs");
-    import_node_path17 = require("path");
+    import_node_fs16 = require("fs");
+    import_node_path18 = require("path");
     init_paths();
     init_thread_store();
     init_teams();
@@ -5737,13 +6010,13 @@ function coordinatorTurnReminder(opts) {
     `- YOUR orchestration thread id is ${opts.parentId} \u2014 pass parentThreadId="${opts.parentId}" on create_thread, or omit it.`,
     goal ? `- Goal / title: ${goal}` : null,
     accountDefaultsPlaybookLine(),
-    "- Status: list_board (worktree Kanban: New \u2192 Draft \u2192 Review \u2192 Merged) or list_threads. Link chats as `[Title](sideboard://thread/<id>)`. Merge only if the user asked."
+    "- Status: list_board (worktree Kanban: New \u2192 Draft \u2192 Review \u2192 Merged) or list_threads. Link chats as `[Title](sideboard://thread/<id>)`. Merge only if the user asked. If a child is stopped/error/broken, it did not finish \u2014 resume or tell the user."
   ].filter(Boolean).join("\n");
 }
 function ensureGlobalCoordinatorCwd(opts) {
   const dir = globalAgentCwd();
   try {
-    (0, import_node_fs16.mkdirSync)(dir, { recursive: true });
+    (0, import_node_fs17.mkdirSync)(dir, { recursive: true });
   } catch {
     return dir;
   }
@@ -5751,7 +6024,7 @@ function ensureGlobalCoordinatorCwd(opts) {
   let orchId = opts?.orchestratorThreadId?.trim() || "";
   if (!orchId) {
     try {
-      const existing = (0, import_node_fs16.readFileSync)((0, import_node_path18.join)(dir, "AGENTS.md"), "utf8");
+      const existing = (0, import_node_fs17.readFileSync)((0, import_node_path19.join)(dir, "AGENTS.md"), "utf8");
       const m = existing.match(
         /YOUR orchestration thread id is `([0-9a-f-]{36})`/i
       );
@@ -5794,9 +6067,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_fs16.writeFileSync)((0, import_node_path18.join)(dir, "CLAUDE.md"), `${body}
+    (0, import_node_fs17.writeFileSync)((0, import_node_path19.join)(dir, "CLAUDE.md"), `${body}
 `, "utf8");
-    (0, import_node_fs16.writeFileSync)((0, import_node_path18.join)(dir, "AGENTS.md"), `${body}
+    (0, import_node_fs17.writeFileSync)((0, import_node_path19.join)(dir, "AGENTS.md"), `${body}
 `, "utf8");
   } catch {
   }
@@ -5828,12 +6101,12 @@ function coordinatorSystemPrompt(opts) {
     formatWorkspaceInventory(opts.workspaces)
   ].join("\n");
 }
-var import_node_fs16, import_node_path18, COORDINATOR_TOOL_PLAYBOOK, SLACK_REPLY_FORMATTING;
+var import_node_fs17, import_node_path19, COORDINATOR_TOOL_PLAYBOOK, SLACK_REPLY_FORMATTING;
 var init_coordinator_prompt = __esm({
   "src/orchestrator/coordinator-prompt.ts"() {
     "use strict";
-    import_node_fs16 = require("fs");
-    import_node_path18 = require("path");
+    import_node_fs17 = require("fs");
+    import_node_path19 = require("path");
     init_worktree();
     init_app_settings();
     init_paths();
@@ -5862,7 +6135,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 (includes last-turn usage / costUsd when the child agent reported it). 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.",
+      "- wait_for_turn / get_turn_result \u2014 wait for and read the agent reply (includes last-turn usage / costUsd when the child agent reported it). 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. On status stopped or broken (or incomplete=true), the child was interrupted or died \u2014 resume with send_to_thread or tell the user; never treat stopped as a finished turn. Sideboard also injects a notice into this chat when a child stops unexpectedly.",
       "- 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:",
@@ -5982,6 +6255,7 @@ function createGlobalChat(opts) {
     fast: opts.fast
   });
   const agent = assertOrchestratorCapableAgent(resolved.agent);
+  const worktreePath = globalAgentCwd();
   const thread = createEmptyThread({
     title,
     // Stick nicknames the same way chat tabs do (avoid later sync overwrites).
@@ -5989,7 +6263,7 @@ function createGlobalChat(opts) {
     sourceType: "orchestration",
     sourceRef,
     branchName: "global",
-    worktreePath: globalAgentCwd(),
+    worktreePath,
     repoPath: GLOBAL_WORKSPACE_ID,
     agent,
     autonomy: opts.autonomy ?? "default",
@@ -5997,7 +6271,10 @@ function createGlobalChat(opts) {
     effort: resolved.effort,
     fast: resolved.fast,
     planMode: Boolean(opts.planMode),
-    attachments: opts.attachments ?? [],
+    attachments: persistPendingFileAttachments(
+      worktreePath,
+      opts.attachments ?? []
+    ),
     parentThreadId: opts.parentThreadId ?? null,
     status: "idle"
   });
@@ -6122,6 +6399,7 @@ var init_global_workspace = __esm({
   "src/store/global-workspace.ts"() {
     "use strict";
     init_cloud_connect_constants();
+    init_stage_files();
     init_orchestrator_capable();
     init_teams();
     init_coordinator_prompt();
@@ -6179,13 +6457,13 @@ var init_api = __esm({
 
 // src/slack/reply-target.ts
 function storePath() {
-  return (0, import_node_path19.join)(appDataDir(), "slack-reply-to.json");
+  return (0, import_node_path20.join)(appDataDir(), "slack-reply-to.json");
 }
 function readStore() {
   const path2 = storePath();
-  if (!(0, import_node_fs17.existsSync)(path2)) return {};
+  if (!(0, import_node_fs18.existsSync)(path2)) return {};
   try {
-    const parsed = isSecureFileEncrypted(path2) ? readSecureJson(path2) : JSON.parse((0, import_node_fs17.readFileSync)(path2, "utf8"));
+    const parsed = isSecureFileEncrypted(path2) ? readSecureJson(path2) : JSON.parse((0, import_node_fs18.readFileSync)(path2, "utf8"));
     return parsed?.targets && typeof parsed.targets === "object" ? parsed.targets : {};
   } catch {
     return {};
@@ -6200,12 +6478,12 @@ function setSlackReplyTarget(target) {
 function getSlackReplyTarget(threadId) {
   return readStore()[threadId] ?? null;
 }
-var import_node_fs17, import_node_path19;
+var import_node_fs18, import_node_path20;
 var init_reply_target = __esm({
   "src/slack/reply-target.ts"() {
     "use strict";
-    import_node_fs17 = require("fs");
-    import_node_path19 = require("path");
+    import_node_fs18 = require("fs");
+    import_node_path20 = require("path");
     init_paths();
     init_private_file();
     init_secure_file();
@@ -6214,7 +6492,7 @@ var init_reply_target = __esm({
 
 // src/slack/workspaces.ts
 function storePath2() {
-  return (0, import_node_path20.join)(appDataDir(), "slack-workspaces.json");
+  return (0, import_node_path21.join)(appDataDir(), "slack-workspaces.json");
 }
 function readStore2() {
   try {
@@ -6321,11 +6599,11 @@ function requireSlackWorkspace(teamId) {
   }
   return ws;
 }
-var import_node_path20;
+var import_node_path21;
 var init_workspaces = __esm({
   "src/slack/workspaces.ts"() {
     "use strict";
-    import_node_path20 = require("path");
+    import_node_path21 = require("path");
     init_paths();
     init_secure_file();
     init_api();
@@ -6334,7 +6612,7 @@ var init_workspaces = __esm({
 
 // src/slack/outbound-watch.ts
 function storePath3() {
-  return (0, import_node_path21.join)(appDataDir(), "slack-outbound-watch.json");
+  return (0, import_node_path22.join)(appDataDir(), "slack-outbound-watch.json");
 }
 function watchId(teamId, channelId, ts) {
   return `${teamId}:${channelId}:${ts}`;
@@ -6347,9 +6625,9 @@ function tsNewer(a, b) {
 }
 function readStore3() {
   const path2 = storePath3();
-  if (!(0, import_node_fs18.existsSync)(path2)) return [];
+  if (!(0, import_node_fs19.existsSync)(path2)) return [];
   try {
-    const parsed = isSecureFileEncrypted(path2) ? readSecureJson(path2) : JSON.parse((0, import_node_fs18.readFileSync)(path2, "utf8"));
+    const parsed = isSecureFileEncrypted(path2) ? readSecureJson(path2) : JSON.parse((0, import_node_fs19.readFileSync)(path2, "utf8"));
     return Array.isArray(parsed?.watches) ? parsed.watches : [];
   } catch {
     return [];
@@ -6671,12 +6949,12 @@ async function pollSlackOutboundWatches(opts) {
   }
   if (changed) writeStore2(watches);
 }
-var import_node_fs18, import_node_path21, MAX_WATCHES, MAX_REPLIES_PER_WATCH, WATCH_TTL_MS, POLL_INTERVAL_MS, lastPollMs, nameCache, continueOnReply;
+var import_node_fs19, import_node_path22, MAX_WATCHES, MAX_REPLIES_PER_WATCH, WATCH_TTL_MS, POLL_INTERVAL_MS, lastPollMs, nameCache, continueOnReply;
 var init_outbound_watch = __esm({
   "src/slack/outbound-watch.ts"() {
     "use strict";
-    import_node_fs18 = require("fs");
-    import_node_path21 = require("path");
+    import_node_fs19 = require("fs");
+    import_node_path22 = require("path");
     init_paths();
     init_private_file();
     init_secure_file();
@@ -6957,32 +7235,32 @@ var init_error_detail = __esm({
 function brightsyConfigPath() {
   const override = process.env.BRIGHTSY_CONFIG?.trim();
   if (override) return override;
-  return (0, import_node_path22.join)((0, import_node_os6.homedir)(), ".brightsy", "config.json");
+  return (0, import_node_path23.join)((0, import_node_os6.homedir)(), ".brightsy", "config.json");
 }
 function loadBrightsyConfig() {
   const path2 = brightsyConfigPath();
-  if (!(0, import_node_fs19.existsSync)(path2)) {
+  if (!(0, import_node_fs20.existsSync)(path2)) {
     throw new Error("Brightsy not logged in \u2014 run `brightsy login` first");
   }
-  const raw = JSON.parse((0, import_node_fs19.readFileSync)(path2, "utf8"));
+  const raw = JSON.parse((0, import_node_fs20.readFileSync)(path2, "utf8"));
   if (!raw.access_token || !raw.account_id) {
     throw new Error("Brightsy config incomplete \u2014 run `brightsy login`");
   }
   return raw;
 }
 function saveBrightsyConfig(cfg) {
-  (0, import_node_fs19.writeFileSync)(brightsyConfigPath(), `${JSON.stringify(cfg, null, 2)}
+  (0, import_node_fs20.writeFileSync)(brightsyConfigPath(), `${JSON.stringify(cfg, null, 2)}
 `, {
     mode: 384
   });
 }
-var import_node_fs19, import_node_os6, import_node_path22;
+var import_node_fs20, import_node_os6, import_node_path23;
 var init_config = __esm({
   "src/brightsy/config.ts"() {
     "use strict";
-    import_node_fs19 = require("fs");
+    import_node_fs20 = require("fs");
     import_node_os6 = require("os");
-    import_node_path22 = require("path");
+    import_node_path23 = require("path");
   }
 });
 
@@ -7200,22 +7478,22 @@ __export(connected_teams_exports, {
   listConnectedBrightsyTeams: () => listConnectedBrightsyTeams
 });
 function storePath4() {
-  return (0, import_node_path23.join)(appDataDir(), "brightsy-teams.json");
+  return (0, import_node_path24.join)(appDataDir(), "brightsy-teams.json");
 }
 function readStore4() {
   const path2 = storePath4();
-  if (!(0, import_node_fs20.existsSync)(path2)) return [];
+  if (!(0, import_node_fs21.existsSync)(path2)) return [];
   try {
-    const parsed = JSON.parse((0, import_node_fs20.readFileSync)(path2, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs21.readFileSync)(path2, "utf8"));
     return Array.isArray(parsed.teams) ? parsed.teams : [];
   } catch {
     return [];
   }
 }
 function writeStore3(teams) {
-  (0, import_node_fs20.mkdirSync)(appDataDir(), { recursive: true });
+  (0, import_node_fs21.mkdirSync)(appDataDir(), { recursive: true });
   const path2 = storePath4();
-  (0, import_node_fs20.writeFileSync)(path2, `${JSON.stringify({ teams }, null, 2)}
+  (0, import_node_fs21.writeFileSync)(path2, `${JSON.stringify({ teams }, null, 2)}
 `, {
     mode: 384
   });
@@ -7371,12 +7649,12 @@ function brightsyMcpServerName(slug) {
   const cleaned = slug.replace(/[^A-Za-z0-9_-]/g, "_").replace(/^_+|_+$/g, "");
   return `brightsy_${cleaned || "team"}`;
 }
-var import_node_fs20, import_node_path23;
+var import_node_fs21, import_node_path24;
 var init_connected_teams = __esm({
   "src/brightsy/connected-teams.ts"() {
     "use strict";
-    import_node_fs20 = require("fs");
-    import_node_path23 = require("path");
+    import_node_fs21 = require("fs");
+    import_node_path24 = require("path");
     init_paths();
     init_accounts();
     init_config();
@@ -7795,11 +8073,11 @@ async function syncCliForTarget(accountId) {
   }
   applyConnectedTeamToCli(team);
 }
-var import_node_fs21, brightsyAdapter;
+var import_node_fs22, brightsyAdapter;
 var init_brightsy = __esm({
   "src/agents/brightsy.ts"() {
     "use strict";
-    import_node_fs21 = require("fs");
+    import_node_fs22 = require("fs");
     init_run();
     init_connected_teams();
     init_config();
@@ -7814,7 +8092,7 @@ var init_brightsy = __esm({
       async detect() {
         const brightsy = resolveAgentExecutable("brightsy");
         if (brightsy !== "brightsy") {
-          if (!(0, import_node_fs21.existsSync)(brightsy)) {
+          if (!(0, import_node_fs22.existsSync)(brightsy)) {
             return {
               agent: "brightsy",
               installed: false,
@@ -7945,14 +8223,47 @@ function asRecord(input) {
 function str2(v) {
   return typeof v === "string" && v.trim() ? v : void 0;
 }
+function looksLikeFilePath(value) {
+  if (value.startsWith("/") || value.startsWith("~/")) return true;
+  if (/^[A-Za-z]:[\\/]/.test(value)) return true;
+  return value.includes("/") || value.includes("\\");
+}
+function stripWorktreePrefix(path2, worktreePath) {
+  if (!worktreePath) return path2;
+  const prefix = worktreePath.replace(/[/\\]+$/, "");
+  if (path2 === prefix || path2 === `${prefix}/`) return "";
+  if (path2.startsWith(`${prefix}/`)) return path2.slice(prefix.length + 1);
+  return path2;
+}
+function visibleToolRowDetail(detail, description, worktreePath) {
+  if (!detail?.trim()) return void 0;
+  const raw = detail.trim();
+  const desc = (description ?? "").trim();
+  if (!looksLikeFilePath(raw)) {
+    if (desc === raw) return void 0;
+    return raw;
+  }
+  const rel = stripWorktreePrefix(raw, worktreePath);
+  if (!rel) return void 0;
+  const base = fileBasename(rel);
+  if (desc && (desc === base || desc.endsWith(` ${base}`))) return void 0;
+  if (rel.length <= 42) return rel;
+  const parts = rel.split(/[/\\]/).filter(Boolean);
+  if (parts.length >= 2) return `\u2026/${parts.slice(-2).join("/")}`;
+  return base;
+}
 function toolDetail(name, input) {
   if (!input) return void 0;
   const command = str2(input.command) ?? str2(input.cmd);
   if (command) return command;
+  const pattern = str2(input.pattern) ?? str2(input.glob) ?? str2(input.glob_pattern);
+  const isSearch = /grep|glob|search|ripgrep|findfiles|semsearch/i.test(name);
+  if (isSearch && pattern) {
+    return pattern.length > 80 ? `${pattern.slice(0, 77)}\u2026` : pattern;
+  }
   const path2 = str2(input.file_path) ?? str2(input.path) ?? str2(input.filePath) ?? str2(input.filename);
   if (path2) return path2;
-  const pattern = str2(input.pattern) ?? str2(input.glob) ?? str2(input.glob_pattern);
-  if (pattern) return pattern;
+  if (pattern) return pattern.length > 80 ? `${pattern.slice(0, 77)}\u2026` : pattern;
   const query = str2(input.query) ?? str2(input.prompt);
   if (query) return query.length > 80 ? `${query.slice(0, 77)}\u2026` : query;
   try {
@@ -8471,43 +8782,43 @@ function electronResourcesPath() {
 function packagedCursorRuntimeDir() {
   const resources = electronResourcesPath();
   if (!resources) return null;
-  const dir = (0, import_node_path24.join)(resources, "cursor-runtime");
-  if (!(0, import_node_fs22.existsSync)((0, import_node_path24.join)(dir, "core-dist", "agents", "cursor-runner.js"))) return null;
+  const dir = (0, import_node_path25.join)(resources, "cursor-runtime");
+  if (!(0, import_node_fs23.existsSync)((0, import_node_path25.join)(dir, "core-dist", "agents", "cursor-runner.js"))) return null;
   return dir;
 }
 function packagedCursorRunnerPath() {
   const dir = packagedCursorRuntimeDir();
-  return dir ? (0, import_node_path24.join)(dir, "core-dist", "agents", "cursor-runner.js") : null;
+  return dir ? (0, import_node_path25.join)(dir, "core-dist", "agents", "cursor-runner.js") : null;
 }
 function packagedMcpDir() {
   const resources = electronResourcesPath();
   if (!resources) return null;
-  const dir = (0, import_node_path24.join)(resources, "sideboard-mcp");
-  if (!(0, import_node_fs22.existsSync)((0, import_node_path24.join)(dir, "core-dist", "mcp", "run-stdio.js"))) return null;
+  const dir = (0, import_node_path25.join)(resources, "sideboard-mcp");
+  if (!(0, import_node_fs23.existsSync)((0, import_node_path25.join)(dir, "core-dist", "mcp", "run-stdio.js"))) return null;
   return dir;
 }
 function packagedMcpStdioPath() {
   const dir = packagedMcpDir();
-  return dir ? (0, import_node_path24.join)(dir, "core-dist", "mcp", "run-stdio.js") : null;
+  return dir ? (0, import_node_path25.join)(dir, "core-dist", "mcp", "run-stdio.js") : null;
 }
 function packagedBundledNodePath() {
   const resources = electronResourcesPath();
   if (!resources) return null;
-  const bin = (0, import_node_path24.join)(resources, "node", "bin", "node");
-  if (!(0, import_node_fs22.existsSync)(bin)) return null;
+  const bin = (0, import_node_path25.join)(resources, "node", "bin", "node");
+  if (!(0, import_node_fs23.existsSync)(bin)) return null;
   return bin;
 }
 function packagedCursorRipgrepCandidate(platformPkg, binName) {
   const dir = packagedCursorRuntimeDir();
   if (!dir) return null;
-  return (0, import_node_path24.join)(dir, "node_modules", platformPkg, "bin", binName);
+  return (0, import_node_path25.join)(dir, "node_modules", platformPkg, "bin", binName);
 }
-var import_node_fs22, import_node_path24;
+var import_node_fs23, import_node_path25;
 var init_packaged_runtime = __esm({
   "src/agents/packaged-runtime.ts"() {
     "use strict";
-    import_node_fs22 = require("fs");
-    import_node_path24 = require("path");
+    import_node_fs23 = require("fs");
+    import_node_path25 = require("path");
   }
 });
 
@@ -8541,7 +8852,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_fs23.existsSync)(unpacked) ? unpacked : null;
+  return (0, import_node_fs24.existsSync)(unpacked) ? unpacked : null;
 }
 function nodeReadableScriptPath(scriptPath) {
   return unpackedAsarPath(scriptPath) ?? scriptPath;
@@ -8581,37 +8892,37 @@ function pickPreferredNode(candidates) {
   return best;
 }
 function versionDirNodeBins(root, toBin) {
-  if (!(0, import_node_fs23.existsSync)(root)) return [];
+  if (!(0, import_node_fs24.existsSync)(root)) return [];
   try {
-    return (0, import_node_fs23.readdirSync)(root).map(toBin);
+    return (0, import_node_fs24.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_path25.join)(prefix, "opt", `node@${major}`, "bin", "node"))
+    (prefix) => PREFERRED_LTS_MAJORS.map((major) => (0, import_node_path26.join)(prefix, "opt", `node@${major}`, "bin", "node"))
   );
   return [
     ...kegs,
     "/opt/homebrew/bin/node",
     "/usr/local/bin/node",
-    (0, import_node_path25.join)(home, ".local/share/fnm/aliases/default/bin/node"),
-    (0, import_node_path25.join)(home, ".nvm/current/bin/node"),
-    (0, import_node_path25.join)(home, ".volta/bin/node"),
-    (0, import_node_path25.join)(home, ".asdf/shims/node"),
-    (0, import_node_path25.join)(home, ".local/share/mise/shims/node"),
+    (0, import_node_path26.join)(home, ".local/share/fnm/aliases/default/bin/node"),
+    (0, import_node_path26.join)(home, ".nvm/current/bin/node"),
+    (0, import_node_path26.join)(home, ".volta/bin/node"),
+    (0, import_node_path26.join)(home, ".asdf/shims/node"),
+    (0, import_node_path26.join)(home, ".local/share/mise/shims/node"),
     ...versionDirNodeBins(
-      (0, import_node_path25.join)(home, ".nvm", "versions", "node"),
-      (name) => (0, import_node_path25.join)(home, ".nvm", "versions", "node", name, "bin", "node")
+      (0, import_node_path26.join)(home, ".nvm", "versions", "node"),
+      (name) => (0, import_node_path26.join)(home, ".nvm", "versions", "node", name, "bin", "node")
     ),
     ...versionDirNodeBins(
-      (0, import_node_path25.join)(home, ".local/share/fnm", "node-versions"),
-      (name) => (0, import_node_path25.join)(home, ".local/share/fnm", "node-versions", name, "installation", "bin", "node")
+      (0, import_node_path26.join)(home, ".local/share/fnm", "node-versions"),
+      (name) => (0, import_node_path26.join)(home, ".local/share/fnm", "node-versions", name, "installation", "bin", "node")
     ),
     ...versionDirNodeBins(
-      (0, import_node_path25.join)(home, ".volta", "tools", "image", "node"),
-      (name) => (0, import_node_path25.join)(home, ".volta", "tools", "image", "node", name, "bin", "node")
+      (0, import_node_path26.join)(home, ".volta", "tools", "image", "node"),
+      (name) => (0, import_node_path26.join)(home, ".volta", "tools", "image", "node", name, "bin", "node")
     )
   ];
 }
@@ -8620,10 +8931,10 @@ function uniqueExistingNodeBins(paths) {
   const out = [];
   for (const raw of paths) {
     const p = raw.trim();
-    if (!p || !(0, import_node_fs23.existsSync)(p) || isElectronLikeCommand(p)) continue;
+    if (!p || !(0, import_node_fs24.existsSync)(p) || isElectronLikeCommand(p)) continue;
     let key = p;
     try {
-      key = (0, import_node_fs23.realpathSync)(p);
+      key = (0, import_node_fs24.realpathSync)(p);
     } catch {
       continue;
     }
@@ -8703,13 +9014,13 @@ async function resolveNodeLaunch(scriptPath) {
     env: { ELECTRON_RUN_AS_NODE: "1" }
   };
 }
-var import_node_fs23, import_node_os7, import_node_path25, AGENT_RUNNER_MAX_OLD_SPACE_MB, MAX_OLD_SPACE_FLAG, PREFERRED_LTS_MAJORS;
+var import_node_fs24, import_node_os7, import_node_path26, 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_fs23 = require("fs");
+    import_node_fs24 = require("fs");
     import_node_os7 = require("os");
-    import_node_path25 = require("path");
+    import_node_path26 = require("path");
     init_nested_electron_env();
     init_run();
     init_packaged_runtime();
@@ -8803,37 +9114,37 @@ function corePackageDir() {
   try {
     const url = import_meta.url;
     if (typeof url === "string" && url.length > 0) {
-      return (0, import_node_path26.dirname)((0, import_node_url.fileURLToPath)(url));
+      return (0, import_node_path27.dirname)((0, import_node_url.fileURLToPath)(url));
     }
   } catch {
   }
   try {
-    const req = (0, import_node_module.createRequire)((0, import_node_path26.join)(process.cwd(), "package.json"));
-    return (0, import_node_path26.dirname)(req.resolve("@sideboard-ai/core"));
+    const req = (0, import_node_module.createRequire)((0, import_node_path27.join)(process.cwd(), "package.json"));
+    return (0, import_node_path27.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_fs24.existsSync)(override)) return override;
+  if (override && (0, import_node_fs25.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_path26.join)(dir, "mcp/run-stdio.js"),
-      (0, import_node_path26.join)(dir, "mcp/run-stdio.cjs"),
-      (0, import_node_path26.join)(dir, "dist/mcp/run-stdio.js"),
-      (0, import_node_path26.join)(dir, "dist/mcp/run-stdio.cjs"),
-      (0, import_node_path26.join)(dir, "packages/core/dist/mcp/run-stdio.js"),
-      (0, import_node_path26.join)(dir, "packages/cli/dist/index.js"),
-      (0, import_node_path26.join)(dir, "cli/dist/index.js")
+      (0, import_node_path27.join)(dir, "mcp/run-stdio.js"),
+      (0, import_node_path27.join)(dir, "mcp/run-stdio.cjs"),
+      (0, import_node_path27.join)(dir, "dist/mcp/run-stdio.js"),
+      (0, import_node_path27.join)(dir, "dist/mcp/run-stdio.cjs"),
+      (0, import_node_path27.join)(dir, "packages/core/dist/mcp/run-stdio.js"),
+      (0, import_node_path27.join)(dir, "packages/cli/dist/index.js"),
+      (0, import_node_path27.join)(dir, "cli/dist/index.js")
     ];
     for (const p of candidates) {
-      if ((0, import_node_fs24.existsSync)(p) && !isAsarPath(p)) return p;
+      if ((0, import_node_fs25.existsSync)(p) && !isAsarPath(p)) return p;
     }
-    const parent = (0, import_node_path26.dirname)(dir);
+    const parent = (0, import_node_path27.dirname)(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -8975,22 +9286,22 @@ function writeMcpServersConfig(servers) {
       ...env ? { env } : {}
     };
   }
-  const dir = (0, import_node_fs24.mkdtempSync)((0, import_node_path26.join)((0, import_node_os8.tmpdir)(), "sideboard-mcp-"));
-  const cfgPath = (0, import_node_path26.join)(dir, "mcp.json");
-  (0, import_node_fs24.writeFileSync)(cfgPath, JSON.stringify({ mcpServers }, null, 2));
+  const dir = (0, import_node_fs25.mkdtempSync)((0, import_node_path27.join)((0, import_node_os8.tmpdir)(), "sideboard-mcp-"));
+  const cfgPath = (0, import_node_path27.join)(dir, "mcp.json");
+  (0, import_node_fs25.writeFileSync)(cfgPath, JSON.stringify({ mcpServers }, null, 2));
   return cfgPath;
 }
 async function writeInjectedMcpConfig(opts) {
   return writeMcpServersConfig(await buildInjectedMcpServers(opts));
 }
-var import_node_fs24, import_node_module, import_node_os8, import_node_path26, import_node_url, import_meta, SIDEBOARD_MCP_ALLOWED_TOOLS, SIDEBOARD_ARTIFACT_MCP_ALLOWED_TOOLS, BRIGHTSY_MCP_ALLOWED_TOOLS, brightsyMcpCommandCache, BRIGHTSY_WORD;
+var import_node_fs25, import_node_module, import_node_os8, import_node_path27, import_node_url, import_meta, SIDEBOARD_MCP_ALLOWED_TOOLS, SIDEBOARD_ARTIFACT_MCP_ALLOWED_TOOLS, BRIGHTSY_MCP_ALLOWED_TOOLS, brightsyMcpCommandCache, BRIGHTSY_WORD;
 var init_injected_mcp = __esm({
   "src/agents/injected-mcp.ts"() {
     "use strict";
-    import_node_fs24 = require("fs");
+    import_node_fs25 = require("fs");
     import_node_module = require("module");
     import_node_os8 = require("os");
-    import_node_path26 = require("path");
+    import_node_path27 = require("path");
     import_node_url = require("url");
     init_run();
     init_config();
@@ -9294,11 +9605,11 @@ function parseIssuesJson(raw) {
   }
   return [];
 }
-var import_node_fs25, BASE_ALLOWED_TOOLS, CLAUDE_PRINT_BG_WAIT_CEILING_MS, CLAUDE_CHROME_ALLOWED_TOOLS, CLAUDE_PROMPT_ARG_MAX, mcpListCache, claudeAdapter;
+var import_node_fs26, BASE_ALLOWED_TOOLS, CLAUDE_PRINT_BG_WAIT_CEILING_MS, CLAUDE_CHROME_ALLOWED_TOOLS, CLAUDE_PROMPT_ARG_MAX, mcpListCache, claudeAdapter;
 var init_claude = __esm({
   "src/agents/claude.ts"() {
     "use strict";
-    import_node_fs25 = require("fs");
+    import_node_fs26 = require("fs");
     init_run();
     init_app_settings();
     init_claude_mcp();
@@ -9338,7 +9649,7 @@ var init_claude = __esm({
       async detect() {
         const claude = resolveClaudeExecutable();
         if (claude !== "claude") {
-          if (!(0, import_node_fs25.existsSync)(claude)) {
+          if (!(0, import_node_fs26.existsSync)(claude)) {
             return {
               agent: "claude",
               installed: false,
@@ -9593,7 +9904,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_fs26.existsSync)(codex)) {
+  } else if (!(0, import_node_fs27.existsSync)(codex)) {
     return FALLBACK_CODEX_MODELS;
   }
   const listed = await run(codex, ["debug", "models"], { reject: false });
@@ -9628,12 +9939,12 @@ function usageFromCodex(usage) {
 }
 function codexConfigHasNetworkAccess() {
   const candidates = [
-    (0, import_node_path27.join)((0, import_node_os9.homedir)(), ".codex", "config.toml"),
-    (0, import_node_path27.join)((0, import_node_os9.homedir)(), ".config", "codex", "config.toml")
+    (0, import_node_path28.join)((0, import_node_os9.homedir)(), ".codex", "config.toml"),
+    (0, import_node_path28.join)((0, import_node_os9.homedir)(), ".config", "codex", "config.toml")
   ];
   for (const path2 of candidates) {
-    if (!(0, import_node_fs26.existsSync)(path2)) continue;
-    const text5 = (0, import_node_fs26.readFileSync)(path2, "utf8");
+    if (!(0, import_node_fs27.existsSync)(path2)) continue;
+    const text5 = (0, import_node_fs27.readFileSync)(path2, "utf8");
     if (/network_access\s*=\s*true/.test(text5)) return true;
   }
   return false;
@@ -9665,21 +9976,21 @@ function asRecord2(value) {
   return void 0;
 }
 function codexLooksAuthenticated() {
-  const authPath = (0, import_node_path27.join)((0, import_node_os9.homedir)(), ".codex", "auth.json");
-  if (!(0, import_node_fs26.existsSync)(authPath)) return false;
+  const authPath = (0, import_node_path28.join)((0, import_node_os9.homedir)(), ".codex", "auth.json");
+  if (!(0, import_node_fs27.existsSync)(authPath)) return false;
   try {
-    return (0, import_node_fs26.statSync)(authPath).size > 2;
+    return (0, import_node_fs27.statSync)(authPath).size > 2;
   } catch {
     return false;
   }
 }
-var import_node_fs26, import_node_os9, import_node_path27, CODEX_PROMPT_ARG_MAX, FALLBACK_CODEX_MODELS, cachedCodexModels, CODEX_MODEL_CACHE_MS, codexAdapter;
+var import_node_fs27, import_node_os9, import_node_path28, 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_fs26 = require("fs");
+    import_node_fs27 = require("fs");
     import_node_os9 = require("os");
-    import_node_path27 = require("path");
+    import_node_path28 = require("path");
     init_run();
     init_app_settings();
     init_global_workspace();
@@ -9704,7 +10015,7 @@ var init_codex = __esm({
       async detect() {
         const codex = resolveAgentExecutable("codex");
         if (codex !== "codex") {
-          if (!(0, import_node_fs26.existsSync)(codex)) {
+          if (!(0, import_node_fs27.existsSync)(codex)) {
             return {
               agent: "codex",
               installed: false,
@@ -10191,21 +10502,21 @@ function platformRipgrepPackage() {
 }
 function usableRipgrepPath(candidate) {
   const raw = candidate?.trim();
-  if (!raw || !(0, import_node_path28.isAbsolute)(raw)) return null;
+  if (!raw || !(0, import_node_path29.isAbsolute)(raw)) return null;
   const readable = nodeReadableScriptPath(raw);
-  if (!(0, import_node_fs27.existsSync)(readable) || isAsarPath(readable)) return null;
+  if (!(0, import_node_fs28.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_path28.dirname)((0, import_node_path28.resolve)(startFile));
-  const root = (0, import_node_path28.parse)(dir).root;
+  let dir = (0, import_node_path29.dirname)((0, import_node_path29.resolve)(startFile));
+  const root = (0, import_node_path29.parse)(dir).root;
   while (dir !== root) {
-    const hit = usableRipgrepPath((0, import_node_path28.join)(dir, "node_modules", pkg, "bin", name));
+    const hit = usableRipgrepPath((0, import_node_path29.join)(dir, "node_modules", pkg, "bin", name));
     if (hit) return hit;
-    const next = (0, import_node_path28.dirname)(dir);
+    const next = (0, import_node_path29.dirname)(dir);
     if (next === dir) break;
     dir = next;
   }
@@ -10215,7 +10526,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_path28.join)((0, import_node_path28.dirname)(pkgJson), "bin", rgBinaryName()));
+    return usableRipgrepPath((0, import_node_path29.join)((0, import_node_path29.dirname)(pkgJson), "bin", rgBinaryName()));
   } catch {
     return null;
   }
@@ -10237,13 +10548,13 @@ function cursorRipgrepEnv(opts) {
   const path2 = resolveCursorRipgrepPath(opts);
   return path2 ? { [RIPGREP_ENV]: path2 } : {};
 }
-var import_node_fs27, import_node_module2, import_node_path28, RIPGREP_ENV;
+var import_node_fs28, import_node_module2, import_node_path29, RIPGREP_ENV;
 var init_cursor_ripgrep = __esm({
   "src/agents/cursor-ripgrep.ts"() {
     "use strict";
-    import_node_fs27 = require("fs");
+    import_node_fs28 = require("fs");
     import_node_module2 = require("module");
-    import_node_path28 = require("path");
+    import_node_path29 = require("path");
     init_node_launch();
     init_packaged_runtime();
     RIPGREP_ENV = "CURSOR_RIPGREP_PATH";
@@ -10289,11 +10600,11 @@ function entryDir() {
   const cjsDir = typeof __dirname !== "undefined" ? __dirname : "";
   if (cjsDir) return cjsDir;
   try {
-    return (0, import_node_path29.dirname)((0, import_node_url2.fileURLToPath)(import_meta2.url));
+    return (0, import_node_path30.dirname)((0, import_node_url2.fileURLToPath)(import_meta2.url));
   } catch {
     try {
       const req = (0, import_node_module3.createRequire)(process.cwd() + "/");
-      return (0, import_node_path29.dirname)(req.resolve("@sideboard-ai/core"));
+      return (0, import_node_path30.dirname)(req.resolve("@sideboard-ai/core"));
     } catch {
       return process.cwd();
     }
@@ -10304,27 +10615,27 @@ function cursorRunnerPath() {
   if (packaged) return packaged;
   const root = entryDir();
   const candidates = [
-    (0, import_node_path29.join)(root, "agents", "cursor-runner.js"),
-    (0, import_node_path29.join)(root, "agents", "cursor-runner.cjs"),
+    (0, import_node_path30.join)(root, "agents", "cursor-runner.js"),
+    (0, import_node_path30.join)(root, "agents", "cursor-runner.cjs"),
     // If somehow resolved from package root instead of dist/
-    (0, import_node_path29.join)(root, "dist", "agents", "cursor-runner.js"),
-    (0, import_node_path29.join)(root, "dist", "agents", "cursor-runner.cjs"),
+    (0, import_node_path30.join)(root, "dist", "agents", "cursor-runner.js"),
+    (0, import_node_path30.join)(root, "dist", "agents", "cursor-runner.cjs"),
     // Source tree (dev): packages/core/src/agents/cursor-runner.ts
-    (0, import_node_path29.join)(root, "cursor-runner.ts"),
-    (0, import_node_path29.join)(root, "src", "agents", "cursor-runner.ts")
+    (0, import_node_path30.join)(root, "cursor-runner.ts"),
+    (0, import_node_path30.join)(root, "src", "agents", "cursor-runner.ts")
   ];
   for (const candidate of candidates) {
-    if ((0, import_node_fs28.existsSync)(candidate)) return candidate;
+    if ((0, import_node_fs29.existsSync)(candidate)) return candidate;
   }
   return candidates[0];
 }
-var import_node_fs28, import_node_module3, import_node_path29, import_node_url2, import_sdk, import_meta2, FALLBACK_CURSOR_MODELS, cachedModels, MODEL_CACHE_MS, cursorAdapter;
+var import_node_fs29, import_node_module3, import_node_path30, 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_fs28 = require("fs");
+    import_node_fs29 = require("fs");
     import_node_module3 = require("module");
-    import_node_path29 = require("path");
+    import_node_path30 = require("path");
     import_node_url2 = require("url");
     import_sdk = require("@cursor/sdk");
     init_run();
@@ -10475,7 +10786,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_fs29.existsSync)(opencode)) {
+  } else if (!(0, import_node_fs30.existsSync)(opencode)) {
     return FALLBACK_OPENCODE_MODELS;
   }
   const listed = await run(opencode, ["models"], { reject: false });
@@ -10505,11 +10816,11 @@ function usageFromOpencode(tokens) {
     cacheWriteTokens: tokens.cache?.write ? Number(tokens.cache.write) : void 0
   };
 }
-var import_node_fs29, FALLBACK_OPENCODE_MODELS, cachedOpencodeModels, OPENCODE_MODEL_CACHE_MS, opencodeAdapter;
+var import_node_fs30, FALLBACK_OPENCODE_MODELS, cachedOpencodeModels, OPENCODE_MODEL_CACHE_MS, opencodeAdapter;
 var init_opencode = __esm({
   "src/agents/opencode.ts"() {
     "use strict";
-    import_node_fs29 = require("fs");
+    import_node_fs30 = require("fs");
     init_run();
     init_app_settings();
     init_global_workspace();
@@ -10536,7 +10847,7 @@ var init_opencode = __esm({
       async detect() {
         const opencode = resolveAgentExecutable("opencode");
         if (opencode !== "opencode") {
-          if (!(0, import_node_fs29.existsSync)(opencode)) {
+          if (!(0, import_node_fs30.existsSync)(opencode)) {
             return {
               agent: "opencode",
               installed: false,
@@ -12039,7 +12350,7 @@ function forkMessageSlice(from, throughIndex) {
 function buildForkTranscriptAttachment(baseTitle, messages) {
   const title = baseTitle || "Chat";
   return {
-    id: (0, import_node_crypto5.randomUUID)(),
+    id: (0, import_node_crypto6.randomUUID)(),
     name: `Transcript of ${title}.md`,
     kind: "transcript",
     content: formatTranscriptMarkdown(title, messages)
@@ -12096,11 +12407,11 @@ function forkChatTab(input) {
   }
   return tab;
 }
-var import_node_crypto5;
+var import_node_crypto6;
 var init_chat_tabs = __esm({
   "src/threads/chat-tabs.ts"() {
     "use strict";
-    import_node_crypto5 = require("crypto");
+    import_node_crypto6 = require("crypto");
     init_context_compact();
     init_teams();
     init_worktree_labels();
@@ -12270,21 +12581,21 @@ function shouldRefreshReviewRequestTemplate(content) {
   return LEGACY_REVIEW_TEMPLATE_MARKERS.every((m) => trimmed.includes(m));
 }
 function readTextIfPresent(abs) {
-  if (!(0, import_node_fs30.existsSync)(abs)) return null;
+  if (!(0, import_node_fs31.existsSync)(abs)) return null;
   try {
-    const content = (0, import_node_fs30.readFileSync)(abs, "utf8");
+    const content = (0, import_node_fs31.readFileSync)(abs, "utf8");
     return content.trim() ? content : null;
   } catch {
     return null;
   }
 }
 function readLocalGuidelines(worktreePath) {
-  const localAbs = (0, import_node_path30.join)(worktreePath, REVIEW_REQUEST_PATH);
+  const localAbs = (0, import_node_path31.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_path30.join)(worktreePath, LEGACY_REVIEW_REQUEST_PATH);
+  const legacyAbs = (0, import_node_path31.join)(worktreePath, LEGACY_REVIEW_REQUEST_PATH);
   const legacyContent = readTextIfPresent(legacyAbs);
   if (legacyContent && !shouldRefreshReviewRequestTemplate(legacyContent)) {
     return { path: LEGACY_REVIEW_REQUEST_PATH, content: legacyContent };
@@ -12300,20 +12611,20 @@ function skillGuidelines(content, source) {
   };
 }
 function ensureReviewSkillFile(worktreePath) {
-  const abs = (0, import_node_path30.join)(worktreePath, REVIEW_SKILL_PATH);
+  const abs = (0, import_node_path31.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_path30.join)(worktreePath, REPO_REVIEW_PATH));
+  const fromRepo = readTextIfPresent((0, import_node_path31.join)(worktreePath, REPO_REVIEW_PATH));
   const fromLocal = readLocalGuidelines(worktreePath)?.content ?? null;
   const content = wrapReviewSkillMarkdown(fromRepo ?? fromLocal ?? REVIEW_REQUEST_TEMPLATE);
-  (0, import_node_fs30.mkdirSync)((0, import_node_path30.dirname)(abs), { recursive: true });
-  (0, import_node_fs30.writeFileSync)(abs, content, "utf8");
+  (0, import_node_fs31.mkdirSync)((0, import_node_path31.dirname)(abs), { recursive: true });
+  (0, import_node_fs31.writeFileSync)(abs, content, "utf8");
   return { path: REVIEW_SKILL_PATH, content, wrote: true };
 }
 function resolveReviewGuidelines(worktreePath) {
-  const skillContent = readTextIfPresent((0, import_node_path30.join)(worktreePath, REVIEW_SKILL_PATH));
+  const skillContent = readTextIfPresent((0, import_node_path31.join)(worktreePath, REVIEW_SKILL_PATH));
   if (skillContent) return skillGuidelines(skillContent, "skill");
   const local = readLocalGuidelines(worktreePath);
   if (local) {
@@ -12335,7 +12646,7 @@ function buildReviewRequestAttachment(content, opts) {
   const path2 = opts?.path ?? REVIEW_SKILL_PATH;
   const name = opts?.name ?? (path2 === REVIEW_SKILL_PATH ? REVIEW_SKILL_NAME : path2 === REPO_REVIEW_PATH ? REPO_REVIEW_NAME : REVIEW_REQUEST_NAME);
   return {
-    id: (0, import_node_crypto6.randomUUID)(),
+    id: (0, import_node_crypto7.randomUUID)(),
     name,
     kind: "file",
     path: path2,
@@ -12343,7 +12654,7 @@ function buildReviewRequestAttachment(content, opts) {
   };
 }
 function readExistingReviewRequestFile(worktreePath) {
-  return readTextIfPresent((0, import_node_path30.join)(worktreePath, REVIEW_SKILL_PATH)) ?? readTextIfPresent((0, import_node_path30.join)(worktreePath, REPO_REVIEW_PATH)) ?? readTextIfPresent((0, import_node_path30.join)(worktreePath, REVIEW_REQUEST_PATH)) ?? readTextIfPresent((0, import_node_path30.join)(worktreePath, LEGACY_REVIEW_REQUEST_PATH));
+  return readTextIfPresent((0, import_node_path31.join)(worktreePath, REVIEW_SKILL_PATH)) ?? readTextIfPresent((0, import_node_path31.join)(worktreePath, REPO_REVIEW_PATH)) ?? readTextIfPresent((0, import_node_path31.join)(worktreePath, REVIEW_REQUEST_PATH)) ?? readTextIfPresent((0, import_node_path31.join)(worktreePath, LEGACY_REVIEW_REQUEST_PATH));
 }
 async function requestReview(threadRef, send2) {
   const from = findThreadByRef(threadRef);
@@ -12370,13 +12681,13 @@ async function requestReview(threadRef, send2) {
   const started = await send2(tab.id, REVIEW_REQUEST_PREFILL);
   return { tab: started, from };
 }
-var import_node_crypto6, import_node_fs30, import_node_path30, 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_crypto7, import_node_fs31, import_node_path31, 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_crypto6 = require("crypto");
-    import_node_fs30 = require("fs");
-    import_node_path30 = require("path");
+    import_node_crypto7 = require("crypto");
+    import_node_fs31 = require("fs");
+    import_node_path31 = require("path");
     init_global_workspace();
     init_chat_tabs();
     init_thread_store();
@@ -12401,9 +12712,9 @@ function matchSimpleGlob(pattern, name) {
   return new RegExp(`^${escaped}$`).test(name);
 }
 function readWorktreeInclude(repoPath) {
-  const path2 = (0, import_node_path31.join)(repoPath, ".worktreeinclude");
-  if (!(0, import_node_fs31.existsSync)(path2)) return [];
-  return (0, import_node_fs31.readFileSync)(path2, "utf8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+  const path2 = (0, import_node_path32.join)(repoPath, ".worktreeinclude");
+  if (!(0, import_node_fs32.existsSync)(path2)) return [];
+  return (0, import_node_fs32.readFileSync)(path2, "utf8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
 }
 function resolveFilesToCopy(repoPath) {
   const fromInclude = readWorktreeInclude(repoPath);
@@ -12413,10 +12724,10 @@ function resolveFilesToCopy(repoPath) {
   if (settings?.fileIncludeGlobs?.length) {
     const matched = [];
     try {
-      for (const entry of (0, import_node_fs31.readdirSync)(repoPath, { withFileTypes: true })) {
+      for (const entry of (0, import_node_fs32.readdirSync)(repoPath, { withFileTypes: true })) {
         if (!entry.isFile()) continue;
         for (const glob of settings.fileIncludeGlobs) {
-          if (matchSimpleGlob(glob, entry.name) || matchSimpleGlob((0, import_node_path31.basename)(glob), entry.name)) {
+          if (matchSimpleGlob(glob, entry.name) || matchSimpleGlob((0, import_node_path32.basename)(glob), entry.name)) {
             matched.push(entry.name);
             break;
           }
@@ -12428,7 +12739,7 @@ function resolveFilesToCopy(repoPath) {
   }
   const defaults = [];
   try {
-    for (const entry of (0, import_node_fs31.readdirSync)(repoPath, { withFileTypes: true })) {
+    for (const entry of (0, import_node_fs32.readdirSync)(repoPath, { withFileTypes: true })) {
       if (entry.isFile() && entry.name.startsWith(".env")) {
         defaults.push(entry.name);
       }
@@ -12442,11 +12753,11 @@ function copyConfiguredFiles(repoPath, worktreePath) {
   const patterns = resolveFilesToCopy(repoPath);
   const copied = [];
   for (const rel of patterns) {
-    const src = (0, import_node_path31.join)(repoPath, rel);
-    if (!(0, import_node_fs31.existsSync)(src)) continue;
-    const dest = (0, import_node_path31.join)(worktreePath, rel);
-    (0, import_node_fs31.mkdirSync)((0, import_node_path31.dirname)(dest), { recursive: true });
-    (0, import_node_fs31.copyFileSync)(src, dest);
+    const src = (0, import_node_path32.join)(repoPath, rel);
+    if (!(0, import_node_fs32.existsSync)(src)) continue;
+    const dest = (0, import_node_path32.join)(worktreePath, rel);
+    (0, import_node_fs32.mkdirSync)((0, import_node_path32.dirname)(dest), { recursive: true });
+    (0, import_node_fs32.copyFileSync)(src, dest);
     copied.push(rel);
   }
   return copied;
@@ -12481,7 +12792,7 @@ function buildWorkspaceScriptEnv(opts, baseEnv) {
   const env = stripNestedElectronEnv({
     ...baseEnv ?? process.env
   });
-  const name = opts.workspaceName ?? (0, import_node_path31.basename)(opts.worktreePath);
+  const name = opts.workspaceName ?? (0, import_node_path32.basename)(opts.worktreePath);
   const ports = opts.ports ?? [];
   const primary = ports[0];
   env.SIDEBOARD_WORKSPACE_NAME = name;
@@ -12742,13 +13053,13 @@ async function startDevServer(repoPath, worktreePath, onLine, opts) {
     done: handle.done
   };
 }
-var import_node_fs31, import_node_net, import_node_path31, import_execa4, import_node_readline3, PORT_RANGE_SIZE, cachedLoginEnv;
+var import_node_fs32, import_node_net, import_node_path32, import_execa4, import_node_readline3, PORT_RANGE_SIZE, cachedLoginEnv;
 var init_conductor = __esm({
   "src/hook/conductor.ts"() {
     "use strict";
-    import_node_fs31 = require("fs");
+    import_node_fs32 = require("fs");
     import_node_net = require("net");
-    import_node_path31 = require("path");
+    import_node_path32 = require("path");
     import_execa4 = require("execa");
     import_node_readline3 = require("readline");
     init_settings();
@@ -12774,9 +13085,9 @@ async function findOrphanWorktrees(repoPaths) {
     repoPaths?.length ? repoPaths : threads.map((t) => t.repoPath).filter(Boolean)
   );
   const homeRoot = sideboardWorkspacesDir();
-  if ((0, import_node_fs32.existsSync)(homeRoot)) {
+  if ((0, import_node_fs33.existsSync)(homeRoot)) {
     try {
-      for (const entry of (0, import_node_fs32.readdirSync)(homeRoot, { withFileTypes: true })) {
+      for (const entry of (0, import_node_fs33.readdirSync)(homeRoot, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
         void entry;
       }
@@ -12786,7 +13097,7 @@ async function findOrphanWorktrees(repoPaths) {
   const orphans = [];
   const seen = /* @__PURE__ */ new Set();
   for (const repoPath of repos) {
-    if (!repoPath || !(0, import_node_fs32.existsSync)(repoPath)) continue;
+    if (!repoPath || !(0, import_node_fs33.existsSync)(repoPath)) continue;
     try {
       const wts = await listWorktrees(repoPath);
       for (const wt of wts) {
@@ -12797,7 +13108,7 @@ async function findOrphanWorktrees(repoPaths) {
         seen.add(path2);
         let mtimeMs = 0;
         try {
-          mtimeMs = (0, import_node_fs32.statSync)(path2).mtimeMs;
+          mtimeMs = (0, import_node_fs33.statSync)(path2).mtimeMs;
         } catch {
           mtimeMs = 0;
         }
@@ -12807,16 +13118,16 @@ async function findOrphanWorktrees(repoPaths) {
     }
     try {
       const root = worktreesRoot(repoPath);
-      if ((0, import_node_fs32.existsSync)(root)) {
-        for (const entry of (0, import_node_fs32.readdirSync)(root, { withFileTypes: true })) {
+      if ((0, import_node_fs33.existsSync)(root)) {
+        for (const entry of (0, import_node_fs33.readdirSync)(root, { withFileTypes: true })) {
           if (!entry.isDirectory()) continue;
-          const path2 = (0, import_node_path32.join)(root, entry.name).replace(/\/$/, "");
+          const path2 = (0, import_node_path33.join)(root, entry.name).replace(/\/$/, "");
           if (known.has(path2) || seen.has(path2)) continue;
-          if (!(0, import_node_fs32.existsSync)((0, import_node_path32.join)(path2, ".git"))) continue;
+          if (!(0, import_node_fs33.existsSync)((0, import_node_path33.join)(path2, ".git"))) continue;
           seen.add(path2);
           let mtimeMs = 0;
           try {
-            mtimeMs = (0, import_node_fs32.statSync)(path2).mtimeMs;
+            mtimeMs = (0, import_node_fs33.statSync)(path2).mtimeMs;
           } catch {
             mtimeMs = Date.now();
           }
@@ -12877,12 +13188,12 @@ function worktreeCleanupSettings() {
     autoCleanupOrphans: a.autoCleanupOrphans
   };
 }
-var import_node_fs32, import_node_path32;
+var import_node_fs33, import_node_path33;
 var init_orphan_cleanup = __esm({
   "src/git/orphan-cleanup.ts"() {
     "use strict";
-    import_node_fs32 = require("fs");
-    import_node_path32 = require("path");
+    import_node_fs33 = require("fs");
+    import_node_path33 = require("path");
     init_worktree();
     init_thread_store();
     init_paths();
@@ -12989,38 +13300,38 @@ __export(workspaces_exports, {
   syncWorkspacesFromThreads: () => syncWorkspacesFromThreads
 });
 function workspacesFile() {
-  return (0, import_node_path33.join)(appDataDir(), "workspaces.json");
+  return (0, import_node_path34.join)(appDataDir(), "workspaces.json");
 }
 function removedWorkspacesFile() {
-  return (0, import_node_path33.join)(appDataDir(), "removed-workspaces.json");
+  return (0, import_node_path34.join)(appDataDir(), "removed-workspaces.json");
 }
 function readAll2() {
   const path2 = workspacesFile();
-  if (!(0, import_node_fs33.existsSync)(path2)) return [];
+  if (!(0, import_node_fs34.existsSync)(path2)) return [];
   try {
-    const raw = JSON.parse((0, import_node_fs33.readFileSync)(path2, "utf8"));
+    const raw = JSON.parse((0, import_node_fs34.readFileSync)(path2, "utf8"));
     return Array.isArray(raw) ? raw : [];
   } catch {
     return [];
   }
 }
 function writeAll2(list) {
-  (0, import_node_fs33.mkdirSync)(appDataDir(), { recursive: true });
-  (0, import_node_fs33.writeFileSync)(workspacesFile(), JSON.stringify(list, null, 2), "utf8");
+  (0, import_node_fs34.mkdirSync)(appDataDir(), { recursive: true });
+  (0, import_node_fs34.writeFileSync)(workspacesFile(), JSON.stringify(list, null, 2), "utf8");
 }
 function readRemoved() {
   const path2 = removedWorkspacesFile();
-  if (!(0, import_node_fs33.existsSync)(path2)) return /* @__PURE__ */ new Set();
+  if (!(0, import_node_fs34.existsSync)(path2)) return /* @__PURE__ */ new Set();
   try {
-    const raw = JSON.parse((0, import_node_fs33.readFileSync)(path2, "utf8"));
+    const raw = JSON.parse((0, import_node_fs34.readFileSync)(path2, "utf8"));
     return new Set(Array.isArray(raw) ? raw.filter((p) => typeof p === "string") : []);
   } catch {
     return /* @__PURE__ */ new Set();
   }
 }
 function writeRemoved(paths) {
-  (0, import_node_fs33.mkdirSync)(appDataDir(), { recursive: true });
-  (0, import_node_fs33.writeFileSync)(removedWorkspacesFile(), JSON.stringify([...paths].sort(), null, 2), "utf8");
+  (0, import_node_fs34.mkdirSync)(appDataDir(), { recursive: true });
+  (0, import_node_fs34.writeFileSync)(removedWorkspacesFile(), JSON.stringify([...paths].sort(), null, 2), "utf8");
 }
 function rememberRemoved(repoPath) {
   const next = readRemoved();
@@ -13043,7 +13354,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_fs33.existsSync)(root)) throw new Error(`Repo not found: ${root}`);
+  if (!(0, import_node_fs34.existsSync)(root)) throw new Error(`Repo not found: ${root}`);
   forgetRemoved(root);
   await ensureGhPreferOrigin(root);
   const current = readAll2();
@@ -13051,7 +13362,7 @@ async function addWorkspace(repoPath) {
   if (existing) return existing;
   const next = {
     path: root,
-    name: (0, import_node_path33.basename)(root),
+    name: (0, import_node_path34.basename)(root),
     addedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   writeAll2([...current, next]);
@@ -13073,10 +13384,10 @@ function syncWorkspacesFromThreads(repoPaths) {
     if (!path2 || path2 === "/" || isGlobalRepoPath(path2) || byPath.has(path2) || removed.has(path2)) {
       continue;
     }
-    if (!(0, import_node_fs33.existsSync)(path2)) continue;
+    if (!(0, import_node_fs34.existsSync)(path2)) continue;
     const ws = {
       path: path2,
-      name: (0, import_node_path33.basename)(path2),
+      name: (0, import_node_path34.basename)(path2),
       addedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     byPath.set(path2, ws);
@@ -13086,12 +13397,12 @@ function syncWorkspacesFromThreads(repoPaths) {
   if (dirty) writeAll2(next);
   return next.sort((a, b) => a.name.localeCompare(b.name));
 }
-var import_node_fs33, import_node_path33;
+var import_node_fs34, import_node_path34;
 var init_workspaces2 = __esm({
   "src/store/workspaces.ts"() {
     "use strict";
-    import_node_fs33 = require("fs");
-    import_node_path33 = require("path");
+    import_node_fs34 = require("fs");
+    import_node_path34 = require("path");
     init_paths();
     init_global_workspace();
     init_worktree();
@@ -13104,12 +13415,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_path34.basename)(url.replace(/\/$/, "").replace(/\.git$/, ""));
+    const leaf = (0, import_node_path35.basename)(url.replace(/\/$/, "").replace(/\.git$/, ""));
     name = leaf || "repo";
   }
   name = name.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "repo";
-  const dest = (0, import_node_path34.join)(sideboardReposDir(), name);
-  if ((0, import_node_fs34.existsSync)(dest)) {
+  const dest = (0, import_node_path35.join)(sideboardReposDir(), name);
+  if ((0, import_node_fs35.existsSync)(dest)) {
     const repoPath2 = await resolveRepoRoot(dest);
     const workspace2 = await ensureWorkspace(repoPath2);
     return { repoPath: repoPath2, workspace: workspace2 };
@@ -13124,16 +13435,63 @@ async function cloneRepoIntoSideboard(opts) {
   const workspace = await ensureWorkspace(repoPath);
   return { repoPath, workspace };
 }
-var import_node_fs34, import_node_path34, import_execa6;
+var import_node_fs35, import_node_path35, import_execa6;
 var init_clone_repo = __esm({
   "src/git/clone-repo.ts"() {
     "use strict";
-    import_node_fs34 = require("fs");
-    import_node_path34 = require("path");
-    import_execa6 = require("execa");
-    init_paths();
-    init_workspaces2();
-    init_worktree();
+    import_node_fs35 = require("fs");
+    import_node_path35 = require("path");
+    import_execa6 = require("execa");
+    init_paths();
+    init_workspaces2();
+    init_worktree();
+  }
+});
+
+// src/orchestrator/child-halt.ts
+function isIncompleteChildStatus(status) {
+  return HALT_STATUSES.has(status);
+}
+function childHaltNotice(child, status) {
+  const title = child.title?.trim() || "Untitled";
+  const link = `[${title}](sideboard://thread/${child.id})`;
+  const why = child.lastError?.trim();
+  const extra = why ? ` lastError: ${why}` : "";
+  return [
+    `Sideboard: child worktree ${link} ${status} before finishing (status=${status}).${extra}`,
+    "This is information \u2014 not a user command. Resume with send_to_thread or tell the user. Do not treat this as a successful turn."
+  ].join("\n");
+}
+function shouldNotifyParentOfChildHalt(opts) {
+  if (!isIncompleteChildStatus(opts.status)) return false;
+  if (!opts.child.parentThreadId) return false;
+  if (!opts.parent || opts.parent.status === "archived") return false;
+  if (opts.parent.id === opts.child.id) return false;
+  return isOrchestratorThread(opts.parent);
+}
+function noticeKey(childId, status) {
+  return `${childId}:${status}`;
+}
+function notifyParentOfChildHalt(child, status, send2) {
+  const parent = child.parentThreadId ? readThread(child.parentThreadId) : null;
+  if (!shouldNotifyParentOfChildHalt({ child, parent, status })) return false;
+  const key = noticeKey(child.id, status);
+  if (notified.has(key)) return false;
+  notified.add(key);
+  const parentId = parent.id;
+  void send2(parentId, childHaltNotice(child, status)).catch(() => {
+    notified.delete(key);
+  });
+  return true;
+}
+var HALT_STATUSES, notified;
+var init_child_halt = __esm({
+  "src/orchestrator/child-halt.ts"() {
+    "use strict";
+    init_global_workspace();
+    init_thread_store();
+    HALT_STATUSES = /* @__PURE__ */ new Set(["stopped", "error", "broken"]);
+    notified = /* @__PURE__ */ new Set();
   }
 });
 
@@ -14094,9 +14452,12 @@ var init_abletime = __esm({
 });
 
 // src/threads/create.ts
+function persistCreateAttachments(worktreePath, attachments) {
+  return persistPendingFileAttachments(worktreePath, attachments ?? []);
+}
 async function createThread(input, _onSetupLine) {
   const repoPath = await resolveRepoRoot(input.repoPath);
-  if (!(0, import_node_fs35.existsSync)(repoPath)) {
+  if (!(0, import_node_fs36.existsSync)(repoPath)) {
     throw new Error(`Repo not found: ${repoPath}`);
   }
   if (input.reuseExisting !== false) {
@@ -14113,7 +14474,16 @@ async function createThread(input, _onSetupLine) {
         repoPath: canonicalizeRepoPath(t.repoPath)
       }))
     );
-    if (existing) return readThread(existing.id) ?? existing;
+    if (existing) {
+      const thread2 = readThread(existing.id) ?? existing;
+      if (!input.attachments?.length) return thread2;
+      return updateThread(thread2.id, {
+        attachments: persistCreateAttachments(thread2.worktreePath, [
+          ...thread2.attachments,
+          ...input.attachments
+        ])
+      });
+    }
   }
   const resolved = resolveNewThreadOptions({
     agent: input.agent,
@@ -14161,7 +14531,7 @@ async function createThread(input, _onSetupLine) {
       effort: resolved.effort,
       fast: resolved.fast,
       planMode: Boolean(input.planMode),
-      attachments: input.attachments ?? [],
+      attachments: persistCreateAttachments(repoPath, input.attachments),
       sourceIsFork: false,
       parentThreadId: input.parentThreadId ?? null,
       status: "idle",
@@ -14240,7 +14610,7 @@ async function createThread(input, _onSetupLine) {
     effort: resolved.effort,
     fast: resolved.fast,
     planMode: Boolean(input.planMode),
-    attachments,
+    attachments: persistCreateAttachments(worktreePath, attachments),
     sourceIsFork,
     parentThreadId: input.parentThreadId ?? null,
     status: "idle",
@@ -14260,16 +14630,17 @@ async function listLinearIssues(agent, repoPath) {
   }
   return adapter.listLinearIssues(repoPath);
 }
-var import_node_fs35;
+var import_node_fs36;
 var init_create = __esm({
   "src/threads/create.ts"() {
     "use strict";
-    import_node_fs35 = require("fs");
+    import_node_fs36 = require("fs");
     init_detect();
     init_worktree();
     init_home_board();
     init_conductor();
     init_app_settings();
+    init_stage_files();
     init_thread_store();
     init_workspaces2();
   }
@@ -14366,20 +14737,20 @@ function writeTurnLive(threadId, progress) {
   const path2 = threadLivePath(threadId);
   const tmp = `${path2}.${process.pid}.tmp`;
   try {
-    (0, import_node_fs36.writeFileSync)(tmp, JSON.stringify(progress), "utf8");
-    (0, import_node_fs36.renameSync)(tmp, path2);
+    (0, import_node_fs37.writeFileSync)(tmp, JSON.stringify(progress), "utf8");
+    (0, import_node_fs37.renameSync)(tmp, path2);
   } catch {
     try {
-      (0, import_node_fs36.unlinkSync)(tmp);
+      (0, import_node_fs37.unlinkSync)(tmp);
     } catch {
     }
   }
 }
 function readTurnLive(threadId) {
   const path2 = threadLivePath(threadId);
-  if (!(0, import_node_fs36.existsSync)(path2)) return null;
+  if (!(0, import_node_fs37.existsSync)(path2)) return null;
   try {
-    const raw = JSON.parse((0, import_node_fs36.readFileSync)(path2, "utf8"));
+    const raw = JSON.parse((0, import_node_fs37.readFileSync)(path2, "utf8"));
     if (!raw || typeof raw.summary !== "string") return null;
     return raw;
   } catch {
@@ -14391,17 +14762,17 @@ function clearTurnLive(threadId) {
   if (buf?.timer) clearTimeout(buf.timer);
   buffers.delete(threadId);
   const path2 = threadLivePath(threadId);
-  if (!(0, import_node_fs36.existsSync)(path2)) return;
+  if (!(0, import_node_fs37.existsSync)(path2)) return;
   try {
-    (0, import_node_fs36.unlinkSync)(path2);
+    (0, import_node_fs37.unlinkSync)(path2);
   } catch {
   }
 }
-var import_node_fs36, buffers, FLUSH_MS, MAX_PARTS;
+var import_node_fs37, buffers, FLUSH_MS, MAX_PARTS;
 var init_turn_live = __esm({
   "src/store/turn-live.ts"() {
     "use strict";
-    import_node_fs36 = require("fs");
+    import_node_fs37 = require("fs");
     init_message_parts();
     init_paths();
     buffers = /* @__PURE__ */ new Map();
@@ -14560,7 +14931,7 @@ function buildQuotaHandoffAttachment(from, limitText, fallbackAgent) {
     `- Do not wait on the limited ${from.agent} account; keep going on ${fallbackAgent}.`
   ].join("\n");
   return {
-    id: (0, import_node_crypto7.randomUUID)(),
+    id: (0, import_node_crypto8.randomUUID)(),
     name: "Orchestration quota handoff.md",
     kind: "transcript",
     content: body
@@ -14581,11 +14952,11 @@ function createQuotaFailoverChat(from, fallbackAgent, limitText) {
     sourceType: "orchestration"
   });
 }
-var import_node_crypto7, QUOTA_CONTINUE_PROMPT, QUOTA_RESUME_PROMPT;
+var import_node_crypto8, QUOTA_CONTINUE_PROMPT, QUOTA_RESUME_PROMPT;
 var init_quota_failover = __esm({
   "src/orchestrator/quota-failover.ts"() {
     "use strict";
-    import_node_crypto7 = require("crypto");
+    import_node_crypto8 = require("crypto");
     init_session_quota();
     init_app_settings();
     init_global_workspace();
@@ -14602,7 +14973,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_path35.join)(process.cwd(), "package.json");
+  return cjsFile || process.argv[1] || (0, import_node_path36.join)(process.cwd(), "package.json");
 }
 function openReadonlySqlite(file) {
   const req = (0, import_node_module4.createRequire)(thisModuleFile());
@@ -14620,21 +14991,21 @@ function mapAgentType(raw) {
   return null;
 }
 function resolveConductorCursorAgentId(workspacePath) {
-  if (!workspacePath || !(0, import_node_fs37.existsSync)(CURSOR_SDK_STORE)) return null;
+  if (!workspacePath || !(0, import_node_fs38.existsSync)(CURSOR_SDK_STORE)) return null;
   const normalized = workspacePath.replace(/\/$/, "");
   let best = null;
   let hashes;
   try {
-    hashes = (0, import_node_fs37.readdirSync)(CURSOR_SDK_STORE);
+    hashes = (0, import_node_fs38.readdirSync)(CURSOR_SDK_STORE);
   } catch {
     return null;
   }
   for (const hash of hashes) {
-    const agentsFile = (0, import_node_path35.join)(CURSOR_SDK_STORE, hash, "agents.ndjson");
-    if (!(0, import_node_fs37.existsSync)(agentsFile)) continue;
+    const agentsFile = (0, import_node_path36.join)(CURSOR_SDK_STORE, hash, "agents.ndjson");
+    if (!(0, import_node_fs38.existsSync)(agentsFile)) continue;
     let text5;
     try {
-      text5 = (0, import_node_fs37.readFileSync)(agentsFile, "utf8");
+      text5 = (0, import_node_fs38.readFileSync)(agentsFile, "utf8");
     } catch {
       continue;
     }
@@ -14658,7 +15029,7 @@ function resolveConductorCursorAgentId(workspacePath) {
   return best?.agentId ?? null;
 }
 async function adoptThread(input) {
-  if (!(0, import_node_fs37.existsSync)(input.worktreePath)) {
+  if (!(0, import_node_fs38.existsSync)(input.worktreePath)) {
     throw new Error(`Worktree not found: ${input.worktreePath}`);
   }
   const repoPath = await resolveRepoRoot(input.worktreePath);
@@ -14685,18 +15056,18 @@ function conductorDbPath() {
   return CONDUCTOR_DB;
 }
 function listConductorWorkspaces() {
-  if (!(0, import_node_fs37.existsSync)(CONDUCTOR_DB)) {
+  if (!(0, import_node_fs38.existsSync)(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = (0, import_node_fs37.mkdtempSync)((0, import_node_path35.join)((0, import_node_os10.tmpdir)(), "sideboard-conductor-"));
-  const snapshot = (0, import_node_path35.join)(tmp, "conductor.db");
+  const tmp = (0, import_node_fs38.mkdtempSync)((0, import_node_path36.join)((0, import_node_os10.tmpdir)(), "sideboard-conductor-"));
+  const snapshot = (0, import_node_path36.join)(tmp, "conductor.db");
   try {
-    (0, import_node_fs37.copyFileSync)(CONDUCTOR_DB, snapshot);
+    (0, import_node_fs38.copyFileSync)(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if ((0, import_node_fs37.existsSync)(src)) {
+      if ((0, import_node_fs38.existsSync)(src)) {
         try {
-          (0, import_node_fs37.copyFileSync)(src, `${snapshot}${suffix}`);
+          (0, import_node_fs38.copyFileSync)(src, `${snapshot}${suffix}`);
         } catch {
         }
       }
@@ -14772,22 +15143,22 @@ function listConductorWorkspaces() {
       db.close();
     }
   } finally {
-    (0, import_node_fs37.rmSync)(tmp, { recursive: true, force: true });
+    (0, import_node_fs38.rmSync)(tmp, { recursive: true, force: true });
   }
 }
 function importConductorWorkspace(workspaceId) {
-  if (!(0, import_node_fs37.existsSync)(CONDUCTOR_DB)) {
+  if (!(0, import_node_fs38.existsSync)(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = (0, import_node_fs37.mkdtempSync)((0, import_node_path35.join)((0, import_node_os10.tmpdir)(), "sideboard-conductor-"));
-  const snapshot = (0, import_node_path35.join)(tmp, "conductor.db");
+  const tmp = (0, import_node_fs38.mkdtempSync)((0, import_node_path36.join)((0, import_node_os10.tmpdir)(), "sideboard-conductor-"));
+  const snapshot = (0, import_node_path36.join)(tmp, "conductor.db");
   try {
-    (0, import_node_fs37.copyFileSync)(CONDUCTOR_DB, snapshot);
+    (0, import_node_fs38.copyFileSync)(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if ((0, import_node_fs37.existsSync)(src)) {
+      if ((0, import_node_fs38.existsSync)(src)) {
         try {
-          (0, import_node_fs37.copyFileSync)(src, `${snapshot}${suffix}`);
+          (0, import_node_fs38.copyFileSync)(src, `${snapshot}${suffix}`);
         } catch {
         }
       }
@@ -14805,7 +15176,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_fs37.existsSync)(worktreePath)) {
+      if (!(0, import_node_fs38.existsSync)(worktreePath)) {
         throw new Error(`Conductor worktree missing on disk: ${worktreePath}`);
       }
       let sessionId = null;
@@ -14868,31 +15239,31 @@ function importConductorWorkspace(workspaceId) {
       db.close();
     }
   } finally {
-    (0, import_node_fs37.rmSync)(tmp, { recursive: true, force: true });
+    (0, import_node_fs38.rmSync)(tmp, { recursive: true, force: true });
   }
 }
 async function importConductorWorkspaceAsync(workspaceId) {
   return importConductorWorkspace(workspaceId);
 }
-var import_node_child_process4, import_node_fs37, import_node_os10, import_node_path35, import_node_module4, CONDUCTOR_APP_SUPPORT, CONDUCTOR_DB, CURSOR_SDK_STORE;
+var import_node_child_process4, import_node_fs38, import_node_os10, import_node_path36, import_node_module4, CONDUCTOR_APP_SUPPORT, CONDUCTOR_DB, CURSOR_SDK_STORE;
 var init_adopt = __esm({
   "src/threads/adopt.ts"() {
     "use strict";
     import_node_child_process4 = require("child_process");
-    import_node_fs37 = require("fs");
+    import_node_fs38 = require("fs");
     import_node_os10 = require("os");
-    import_node_path35 = require("path");
+    import_node_path36 = require("path");
     import_node_module4 = require("module");
     init_worktree();
     init_thread_store();
-    CONDUCTOR_APP_SUPPORT = (0, import_node_path35.join)(
+    CONDUCTOR_APP_SUPPORT = (0, import_node_path36.join)(
       process.env.HOME ?? "",
       "Library",
       "Application Support",
       "com.conductor.app"
     );
-    CONDUCTOR_DB = (0, import_node_path35.join)(CONDUCTOR_APP_SUPPORT, "conductor.db");
-    CURSOR_SDK_STORE = (0, import_node_path35.join)(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
+    CONDUCTOR_DB = (0, import_node_path36.join)(CONDUCTOR_APP_SUPPORT, "conductor.db");
+    CURSOR_SDK_STORE = (0, import_node_path36.join)(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
   }
 });
 
@@ -14959,7 +15330,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_fs38.existsSync)(checkedOut.path)) {
+  if (checkedOut?.path && (0, import_node_fs39.existsSync)(checkedOut.path)) {
     if (input.reuseExistingWorktree !== false) {
       worktreePath = checkedOut.path;
     } else {
@@ -15101,7 +15472,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_fs38.existsSync)(repoPath)) throw new Error(`Repo not found: ${repoPath}`);
+  if (!(0, import_node_fs39.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);
@@ -15168,7 +15539,7 @@ async function createPrStack(input, onSetupLine) {
     }
   }
   const claimed = new Set(threads.map((t) => t.worktreePath));
-  if (!claimed.has(bootstrap.worktreePath) && (0, import_node_fs38.existsSync)(bootstrap.worktreePath)) {
+  if (!claimed.has(bootstrap.worktreePath) && (0, import_node_fs39.existsSync)(bootstrap.worktreePath)) {
     try {
       await removeWorktree(repoPath, bootstrap.worktreePath, {
         deleteBranch: bootstrap.branchName
@@ -15188,11 +15559,11 @@ function stackAgentDefaultsFrom(input) {
     planMode: input.planMode
   };
 }
-var import_node_fs38;
+var import_node_fs39;
 var init_stack_layers = __esm({
   "src/threads/stack-layers.ts"() {
     "use strict";
-    import_node_fs38 = require("fs");
+    import_node_fs39 = require("fs");
     init_detect();
     init_run();
     init_stack();
@@ -15205,7 +15576,7 @@ var init_stack_layers = __esm({
 
 // src/diff/diff.ts
 async function inspectGitWorktree(worktreePath) {
-  if (!worktreePath || !(0, import_node_fs39.existsSync)(worktreePath)) return "missing_worktree";
+  if (!worktreePath || !(0, import_node_fs40.existsSync)(worktreePath)) return "missing_worktree";
   const check = await git(["rev-parse", "--is-inside-work-tree"], worktreePath, {
     reject: false
   });
@@ -15213,7 +15584,7 @@ async function inspectGitWorktree(worktreePath) {
   return "ok";
 }
 async function initializeGitRepository(worktreePath) {
-  if (!worktreePath || !(0, import_node_fs39.existsSync)(worktreePath)) {
+  if (!worktreePath || !(0, import_node_fs40.existsSync)(worktreePath)) {
     throw new Error("Worktree not found");
   }
   const status = await inspectGitWorktree(worktreePath);
@@ -15347,11 +15718,11 @@ new file mode 100644
   };
 }
 async function untrackedPatch(worktreePath, path2, maxHunk) {
-  const abs = (0, import_node_path36.join)(worktreePath, path2);
+  const abs = (0, import_node_path37.join)(worktreePath, path2);
   try {
-    const st = (0, import_node_fs39.statSync)(abs);
+    const st = (0, import_node_fs40.statSync)(abs);
     if (st.isFile() && st.size > maxHunk) {
-      const buf = (0, import_node_fs39.readFileSync)(abs).subarray(0, maxHunk);
+      const buf = (0, import_node_fs40.readFileSync)(abs).subarray(0, maxHunk);
       return syntheticAddPatch(path2, buf.toString("utf8"), maxHunk);
     }
   } catch {
@@ -15835,13 +16206,13 @@ async function listWorktreeFiles(worktreePath, opts) {
 function isImageRelativePath(relativePath) {
   const base = relativePath.split("/").pop()?.toLowerCase() || "";
   const ext = base.includes(".") ? base.split(".").pop() || "" : "";
-  return IMAGE_EXTENSIONS.has(ext);
+  return IMAGE_EXTENSIONS2.has(ext);
 }
 function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? DEFAULT_UPLOAD_MAX_BYTES;
-  const abs = (0, import_node_path36.join)(worktreePath, relativePath);
-  const st = (0, import_node_fs39.statSync)(abs);
+  const abs = (0, import_node_path37.join)(worktreePath, relativePath);
+  const st = (0, import_node_fs40.statSync)(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
@@ -15850,7 +16221,7 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
       `File too large to upload (${st.size} bytes; max ${maxBytes})`
     );
   }
-  const buf = (0, import_node_fs39.readFileSync)(abs);
+  const buf = (0, import_node_fs40.readFileSync)(abs);
   return {
     path: relativePath,
     contentBase64: buf.toString("base64"),
@@ -15860,12 +16231,12 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
 function readWorktreeFile(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? 2e5;
-  const abs = (0, import_node_path36.join)(worktreePath, relativePath);
-  const st = (0, import_node_fs39.statSync)(abs);
+  const abs = (0, import_node_path37.join)(worktreePath, relativePath);
+  const st = (0, import_node_fs40.statSync)(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
-  const buf = (0, import_node_fs39.readFileSync)(abs);
+  const buf = (0, import_node_fs40.readFileSync)(abs);
   if (isImageRelativePath(relativePath)) {
     const maxImageBytes = Math.max(maxBytes, 15e6);
     const truncated2 = buf.length > maxImageBytes;
@@ -15908,9 +16279,9 @@ function assertSafeRelativePath(relativePath) {
 }
 function writeWorktreeFile(worktreePath, relativePath, content) {
   assertSafeRelativePath(relativePath);
-  const abs = (0, import_node_path36.join)(worktreePath, relativePath);
-  (0, import_node_fs39.mkdirSync)((0, import_node_path36.dirname)(abs), { recursive: true });
-  (0, import_node_fs39.writeFileSync)(abs, content, "utf8");
+  const abs = (0, import_node_path37.join)(worktreePath, relativePath);
+  (0, import_node_fs40.mkdirSync)((0, import_node_path37.dirname)(abs), { recursive: true });
+  (0, import_node_fs40.writeFileSync)(abs, content, "utf8");
   return { path: relativePath };
 }
 async function getDiffSummary(worktreePath, repoPath, opts) {
@@ -15927,18 +16298,18 @@ async function getDiffSummary(worktreePath, repoPath, opts) {
     truncated: full.files.length > maxFiles
   };
 }
-var import_node_fs39, import_node_path36, mergeBaseCache, MERGE_BASE_TTL_MS, SHA_RE, IMAGE_EXTENSIONS, DEFAULT_UPLOAD_MAX_BYTES;
+var import_node_fs40, import_node_path37, mergeBaseCache, MERGE_BASE_TTL_MS, SHA_RE, IMAGE_EXTENSIONS2, DEFAULT_UPLOAD_MAX_BYTES;
 var init_diff = __esm({
   "src/diff/diff.ts"() {
     "use strict";
-    import_node_fs39 = require("fs");
-    import_node_path36 = require("path");
+    import_node_fs40 = require("fs");
+    import_node_path37 = require("path");
     init_run();
     init_worktree();
     mergeBaseCache = /* @__PURE__ */ new Map();
     MERGE_BASE_TTL_MS = 45e3;
     SHA_RE = /^[0-9a-f]{7,40}$/i;
-    IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
+    IMAGE_EXTENSIONS2 = /* @__PURE__ */ new Set([
       "png",
       "jpg",
       "jpeg",
@@ -16100,7 +16471,7 @@ function parseFrontmatter(content) {
 }
 function readSkill(skillMd, source) {
   try {
-    const content = (0, import_node_fs40.readFileSync)(skillMd, "utf8");
+    const content = (0, import_node_fs41.readFileSync)(skillMd, "utf8");
     const { name: fmName, description } = parseFrontmatter(content);
     const dirName = skillMd.split("/").slice(-2, -1)[0] || "skill";
     const name = fmName || dirName;
@@ -16119,19 +16490,19 @@ function readSkill(skillMd, source) {
   }
 }
 function scanSkillsDir(dir, source, out) {
-  if (!(0, import_node_fs40.existsSync)(dir)) return;
+  if (!(0, import_node_fs41.existsSync)(dir)) return;
   let entries;
   try {
-    entries = (0, import_node_fs40.readdirSync)(dir);
+    entries = (0, import_node_fs41.readdirSync)(dir);
   } catch {
     return;
   }
   for (const entry of entries) {
     if (entry.startsWith(".")) continue;
-    const skillMd = (0, import_node_path37.join)(dir, entry, "SKILL.md");
-    if (!(0, import_node_fs40.existsSync)(skillMd)) continue;
+    const skillMd = (0, import_node_path38.join)(dir, entry, "SKILL.md");
+    if (!(0, import_node_fs41.existsSync)(skillMd)) continue;
     try {
-      if (!(0, import_node_fs40.statSync)(skillMd).isFile()) continue;
+      if (!(0, import_node_fs41.statSync)(skillMd).isFile()) continue;
     } catch {
       continue;
     }
@@ -16140,24 +16511,24 @@ function scanSkillsDir(dir, source, out) {
   }
 }
 function scanClaudePluginSkills(pluginsRoot, out) {
-  if (!(0, import_node_fs40.existsSync)(pluginsRoot)) return;
+  if (!(0, import_node_fs41.existsSync)(pluginsRoot)) return;
   const walk = (dir, depth, lookingForSkillsDir) => {
     if (depth > 7) return;
     let entries;
     try {
-      entries = (0, import_node_fs40.readdirSync)(dir);
+      entries = (0, import_node_fs41.readdirSync)(dir);
     } catch {
       return;
     }
     if (lookingForSkillsDir && entries.includes("SKILL.md")) {
-      const skill = readSkill((0, import_node_path37.join)(dir, "SKILL.md"), "cli");
+      const skill = readSkill((0, import_node_path38.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_path37.join)(dir, entry);
+      const full = (0, import_node_path38.join)(dir, entry);
       try {
-        if (!(0, import_node_fs40.statSync)(full).isDirectory()) continue;
+        if (!(0, import_node_fs41.statSync)(full).isDirectory()) continue;
       } catch {
         continue;
       }
@@ -16175,17 +16546,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_path37.join)(worktreePath, rel), "workspace", collected);
+    scanSkillsDir((0, import_node_path38.join)(worktreePath, rel), "workspace", collected);
   }
   for (const abs of [
-    (0, import_node_path37.join)(home, ".claude/skills"),
-    (0, import_node_path37.join)(home, ".cursor/skills"),
-    (0, import_node_path37.join)(home, ".sideboard/skills"),
-    (0, import_node_path37.join)(home, ".brightsy/skills")
+    (0, import_node_path38.join)(home, ".claude/skills"),
+    (0, import_node_path38.join)(home, ".cursor/skills"),
+    (0, import_node_path38.join)(home, ".sideboard/skills"),
+    (0, import_node_path38.join)(home, ".brightsy/skills")
   ]) {
     scanSkillsDir(abs, "user", collected);
   }
-  scanClaudePluginSkills((0, import_node_path37.join)(home, ".claude/plugins"), collected);
+  scanClaudePluginSkills((0, import_node_path38.join)(home, ".claude/plugins"), collected);
   const rank = { workspace: 0, user: 1, cli: 2 };
   const byCommand = /* @__PURE__ */ new Map();
   for (const skill of collected) {
@@ -16197,7 +16568,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_fs40.readFileSync)(skillPath, "utf8");
+  const raw = (0, import_node_fs41.readFileSync)(skillPath, "utf8");
   if (raw.startsWith("---")) {
     const end = raw.indexOf("\n---", 3);
     if (end >= 0) {
@@ -16211,13 +16582,13 @@ function readSkillBody(skillPath, maxChars = 12e3) {
 
 \u2026(truncated)` : raw;
 }
-var import_node_fs40, import_node_os11, import_node_path37;
+var import_node_fs41, import_node_os11, import_node_path38;
 var init_discover = __esm({
   "src/skills/discover.ts"() {
     "use strict";
-    import_node_fs40 = require("fs");
+    import_node_fs41 = require("fs");
     import_node_os11 = require("os");
-    import_node_path37 = require("path");
+    import_node_path38 = require("path");
   }
 });
 
@@ -16306,236 +16677,6 @@ var init_expand = __esm({
   }
 });
 
-// src/composer/stage-files.ts
-function fileExtension(filePath) {
-  const base = (0, import_node_path38.basename)(filePath).toLowerCase();
-  return base.includes(".") ? base.split(".").pop() || "" : "";
-}
-function isImageFilePath(filePath) {
-  return IMAGE_EXTENSIONS2.has(fileExtension(filePath));
-}
-function imageMimeType(filePath) {
-  return IMAGE_MIME_BY_EXT[fileExtension(filePath)] || "image/png";
-}
-function ensureAttachmentsDir(worktreePath) {
-  const dir = (0, import_node_path38.join)(worktreePath, ATTACHMENTS_DIR);
-  (0, import_node_fs41.mkdirSync)(dir, { recursive: true });
-  const gi = (0, import_node_path38.join)(dir, ".gitignore");
-  if (!(0, import_node_fs41.existsSync)(gi)) {
-    (0, import_node_fs41.writeFileSync)(gi, attachmentsGitignoreBody(), "utf8");
-  }
-  return dir;
-}
-function uniqueAttachmentName(dir, originalName) {
-  const safe = originalName.replace(/[/\\]/g, "_") || "file";
-  if (!(0, import_node_fs41.existsSync)((0, import_node_path38.join)(dir, safe))) return safe;
-  const ext = (0, import_node_path38.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_fs41.existsSync)((0, import_node_path38.join)(dir, candidate))) return candidate;
-  }
-  return `${stem}-${(0, import_node_crypto8.randomUUID)()}${ext}`;
-}
-function previewDataUrlFromBuf(filePath, buf) {
-  if (!isImageFilePath(filePath)) return void 0;
-  if (buf.length > MAX_PREVIEW_BYTES) return void 0;
-  return `data:${imageMimeType(filePath)};base64,${buf.toString("base64")}`;
-}
-function attachmentFromBuffer(name, buf, opts) {
-  const previewDataUrl = previewDataUrlFromBuf(name, buf);
-  if (isImageFilePath(name)) {
-    const pathHint = opts.path ? `\`${opts.path}\`` : opts.sourceLabel || name;
-    return {
-      id: (0, import_node_crypto8.randomUUID)(),
-      name,
-      kind: "file",
-      path: opts.path,
-      previewDataUrl,
-      content: [
-        `Image attached: ${pathHint}`,
-        opts.path ? `Use the Read tool on \`${opts.path}\` to view this image.` : "The image is shown in the composer; copy it into the worktree if you need to inspect pixels."
-      ].join("\n")
-    };
-  }
-  if (buf.length > MAX_INLINE_BYTES) {
-    return {
-      id: (0, import_node_crypto8.randomUUID)(),
-      name,
-      kind: "file",
-      path: opts.path,
-      content: opts.path ? `(file too large to attach inline: \`${opts.path}\`, ${buf.length} bytes \u2014 use the Read tool)` : `(file too large to attach inline: ${opts.sourceLabel || name}, ${buf.length} bytes)`
-    };
-  }
-  if (buf.includes(0)) {
-    return {
-      id: (0, import_node_crypto8.randomUUID)(),
-      name,
-      kind: "file",
-      path: opts.path,
-      content: opts.path ? `(binary file at \`${opts.path}\` \u2014 use tools to inspect)` : `(binary file attached by path only: ${opts.sourceLabel || name})`
-    };
-  }
-  return {
-    id: (0, import_node_crypto8.randomUUID)(),
-    name,
-    kind: "file",
-    path: opts.path,
-    content: buf.toString("utf8")
-  };
-}
-function attachmentFromAbsolutePath(absolutePath) {
-  const name = (0, import_node_path38.basename)(absolutePath);
-  try {
-    const st = (0, import_node_fs41.statSync)(absolutePath);
-    if (!st.isFile()) {
-      return {
-        id: (0, import_node_crypto8.randomUUID)(),
-        name,
-        kind: "file",
-        content: `(not a file: ${absolutePath})`
-      };
-    }
-    const buf = (0, import_node_fs41.readFileSync)(absolutePath);
-    return attachmentFromBuffer(name, buf, { sourceLabel: absolutePath });
-  } catch (err) {
-    return {
-      id: (0, import_node_crypto8.randomUUID)(),
-      name,
-      kind: "file",
-      content: `(could not read ${absolutePath}: ${err instanceof Error ? err.message : String(err)})`
-    };
-  }
-}
-function stageAbsolutePathsAsAttachments(worktreePath, absolutePaths) {
-  if (absolutePaths.length === 0) return [];
-  const dir = ensureAttachmentsDir(worktreePath);
-  const out = [];
-  for (const abs of absolutePaths) {
-    const originalName = (0, import_node_path38.basename)(abs);
-    try {
-      const st = (0, import_node_fs41.statSync)(abs);
-      if (!st.isFile()) continue;
-      const name = uniqueAttachmentName(dir, originalName);
-      const destAbs = (0, import_node_path38.join)(dir, name);
-      (0, import_node_fs41.copyFileSync)(abs, destAbs);
-      const rel = `${ATTACHMENTS_DIR}/${name}`;
-      const buf = (0, import_node_fs41.readFileSync)(destAbs);
-      out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
-    } catch (err) {
-      out.push({
-        id: (0, import_node_crypto8.randomUUID)(),
-        name: originalName,
-        kind: "file",
-        content: `(could not attach ${abs}: ${err instanceof Error ? err.message : String(err)})`
-      });
-    }
-  }
-  return out;
-}
-function stageBuffersAsAttachments(worktreePath, buffers2) {
-  if (buffers2.length === 0) return [];
-  const dir = ensureAttachmentsDir(worktreePath);
-  const out = [];
-  for (const item of buffers2) {
-    const originalName = (item.name || "file").replace(/[/\\]/g, "_") || "file";
-    try {
-      const buf = Buffer.from(item.dataBase64, "base64");
-      const name = uniqueAttachmentName(dir, originalName);
-      const destAbs = (0, import_node_path38.join)(dir, name);
-      (0, import_node_fs41.writeFileSync)(destAbs, buf);
-      const rel = `${ATTACHMENTS_DIR}/${name}`;
-      out.push(attachmentFromBuffer(name, buf, { path: rel }));
-    } catch (err) {
-      out.push({
-        id: (0, import_node_crypto8.randomUUID)(),
-        name: originalName,
-        kind: "file",
-        content: `(could not attach ${originalName}: ${err instanceof Error ? err.message : String(err)})`
-      });
-    }
-  }
-  return out;
-}
-function attachmentsFromBuffers(buffers2) {
-  return buffers2.map((item) => {
-    const name = (item.name || "file").replace(/[/\\]/g, "_") || "file";
-    try {
-      const buf = Buffer.from(item.dataBase64, "base64");
-      return attachmentFromBuffer(name, buf, { sourceLabel: name });
-    } catch (err) {
-      return {
-        id: (0, import_node_crypto8.randomUUID)(),
-        name,
-        kind: "file",
-        content: `(could not attach ${name}: ${err instanceof Error ? err.message : String(err)})`
-      };
-    }
-  });
-}
-function attachmentsFromWorktreePaths(worktreePath, relativePaths) {
-  const out = [];
-  for (const rel of relativePaths) {
-    if (!rel || rel.includes("..") || rel.startsWith("/")) {
-      out.push({
-        id: (0, import_node_crypto8.randomUUID)(),
-        name: (0, import_node_path38.basename)(rel) || "file",
-        kind: "file",
-        content: `(invalid path: ${rel})`
-      });
-      continue;
-    }
-    const name = (0, import_node_path38.basename)(rel);
-    try {
-      const abs = (0, import_node_path38.join)(worktreePath, rel);
-      const st = (0, import_node_fs41.statSync)(abs);
-      if (!st.isFile()) continue;
-      const buf = (0, import_node_fs41.readFileSync)(abs);
-      out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
-    } catch (err) {
-      out.push({
-        id: (0, import_node_crypto8.randomUUID)(),
-        name,
-        kind: "file",
-        content: `(could not read ${rel}: ${err instanceof Error ? err.message : String(err)})`
-      });
-    }
-  }
-  return out;
-}
-var import_node_fs41, import_node_path38, import_node_crypto8, 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_fs41 = require("fs");
-    import_node_path38 = require("path");
-    import_node_crypto8 = require("crypto");
-    init_workspace_scratch();
-    IMAGE_EXTENSIONS2 = /* @__PURE__ */ new Set([
-      "png",
-      "jpg",
-      "jpeg",
-      "gif",
-      "webp",
-      "svg",
-      "bmp",
-      "ico"
-    ]);
-    IMAGE_MIME_BY_EXT = {
-      png: "image/png",
-      jpg: "image/jpeg",
-      jpeg: "image/jpeg",
-      gif: "image/gif",
-      webp: "image/webp",
-      svg: "image/svg+xml",
-      bmp: "image/bmp",
-      ico: "image/x-icon"
-    };
-    MAX_INLINE_BYTES = 4e5;
-    MAX_PREVIEW_BYTES = 5e6;
-  }
-});
-
 // src/agents/instructions.ts
 function normPath3(p) {
   return p.replace(/\/+$/, "");
@@ -17138,6 +17279,7 @@ var init_orchestrator = __esm({
     init_usage();
     init_thread_store();
     init_desktop_host();
+    init_child_halt();
     init_create();
     init_cowboy();
     init_orchestrator_capable();
@@ -17285,6 +17427,9 @@ var init_orchestrator = __esm({
        * MCP-created review threads don't stay `queued` after the MCP child exits.
        */
       adoptPersistedQueues() {
+        if (thisProcessShouldDrainAgentQueues()) {
+          this.healStaleRunningTurns();
+        }
         for (const thread of listThreads()) {
           if (thread.status === "stopped" || thread.status === "archived") continue;
           const pid = thread.agentPid;
@@ -17305,6 +17450,32 @@ var init_orchestrator = __esm({
           }
         }
       }
+      /**
+       * Mid-session: a worktree can sit at `running` after the agent process dies
+       * (Cursor/CLI crash, OOM) while wait_for_turn still reports stillRunning.
+       * Reclaim those and wake the parent orchestration chat.
+       */
+      healStaleRunningTurns() {
+        for (const thread of listThreads()) {
+          if (thread.status === "archived") continue;
+          const handle = this.activeTurns.get(thread.id);
+          if (handle) {
+            const pid = thread.agentPid;
+            if (typeof pid === "number" && pid > 0 && !isPidAlive(pid)) {
+              handle.kill();
+            }
+            continue;
+          }
+          if (!this.shouldReclaimRunningThread(thread)) continue;
+          setStatus(thread.id, "stopped", "Process died (agent exited)");
+          this.emit({ type: "status_changed", threadId: thread.id, status: "stopped" });
+          this.emit({ type: "turn_finished", threadId: thread.id, exitCode: 1 });
+          const latest = readThread(thread.id);
+          if (latest) {
+            notifyParentOfChildHalt(latest, "stopped", (id, prompt) => this.send(id, prompt));
+          }
+        }
+      }
       clearQuotaResumeTimer(threadId) {
         const timer = this.quotaResumeTimers.get(threadId);
         if (timer) clearTimeout(timer);
@@ -18022,6 +18193,12 @@ var init_orchestrator = __esm({
                 assistantText: chatText,
                 partsCount: parts.length
               });
+              if (!this.crashContinued.has(threadId)) {
+                const failed = readThread(threadId);
+                if (failed) {
+                  notifyParentOfChildHalt(failed, "error", (id, prompt2) => this.send(id, prompt2));
+                }
+              }
             }
           }
         } catch (err) {
@@ -18046,6 +18223,12 @@ var init_orchestrator = __esm({
               assistantText: "",
               partsCount: 0
             });
+            if (!this.crashContinued.has(threadId)) {
+              const failed = readThread(threadId);
+              if (failed) {
+                notifyParentOfChildHalt(failed, "error", (id, prompt2) => this.send(id, prompt2));
+              }
+            }
           }
         } finally {
           this.startingTurns.delete(threadId);
@@ -18101,6 +18284,9 @@ var init_orchestrator = __esm({
         const stopped = writeLiveStatus(thread.id, "stopped") ?? readThread(thread.id) ?? thread;
         if (stopped.status === "stopped") {
           this.emit({ type: "status_changed", threadId: thread.id, status: "stopped" });
+          if (opts?.notifyParent !== false) {
+            notifyParentOfChildHalt(stopped, "stopped", (id, prompt) => this.send(id, prompt));
+          }
         }
         return stopped;
       }
@@ -18345,21 +18531,25 @@ var init_orchestrator = __esm({
             fn();
           };
           const off = this.on((event) => {
-            if (event.type === "turn_finished" && event.threadId === thread.id) {
+            if (!("threadId" in event) || event.threadId !== thread.id) return;
+            if (event.type === "turn_finished" || event.type === "error") {
               const latest = readThread(thread.id);
               if (!latest) {
                 finish(() => reject(new Error(`Thread not found: ${thread.id}`)));
                 return;
               }
               finish(() => resolve(latest));
+              return;
             }
-            if (event.type === "error" && event.threadId === thread.id) {
+            if (event.type === "status_changed") {
               const latest = readThread(thread.id);
               if (!latest) {
                 finish(() => reject(new Error(`Thread not found: ${thread.id}`)));
                 return;
               }
-              finish(() => resolve(latest));
+              if (!["running", "queued"].includes(latest.status)) {
+                finish(() => resolve(latest));
+              }
             }
           });
           timer = setInterval(() => {
@@ -18394,7 +18584,7 @@ var init_orchestrator = __esm({
         const thread = this.requireThread(threadRef);
         const lastAgent = [...thread.messages].reverse().find((m) => m.role === "agent");
         const lastError = thread.lastError ?? null;
-        const text5 = (lastAgent?.text ?? "").trim() || (thread.status === "error" ? lastError ?? "" : "");
+        const text5 = (lastAgent?.text ?? "").trim() || (thread.status === "error" || thread.status === "stopped" || thread.status === "broken" ? 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;
@@ -19172,6 +19362,7 @@ __export(index_exports, {
   PLAN_FILE_NAME: () => PLAN_FILE_NAME,
   PLAN_FILE_REL: () => PLAN_FILE_REL,
   PLAN_MODE_INSTRUCTION: () => PLAN_MODE_INSTRUCTION,
+  PLAN_QUESTION_ANSWERS_PREFIX: () => PLAN_QUESTION_ANSWERS_PREFIX,
   REPO_REVIEW_NAME: () => REPO_REVIEW_NAME,
   REPO_REVIEW_PATH: () => REPO_REVIEW_PATH,
   REVIEW_REQUEST_NAME: () => REVIEW_REQUEST_NAME,
@@ -19471,6 +19662,7 @@ __export(index_exports, {
   isOrchestratorThread: () => isOrchestratorThread,
   isPidAlive: () => isPidAlive,
   isPlaceholderBranch: () => isPlaceholderBranch,
+  isPlanQuestionAnswersMessage: () => isPlanQuestionAnswersMessage,
   isPollWrapperToolName: () => isPollWrapperToolName,
   isPrNotMergeableError: () => isPrNotMergeableError,
   isPresentPlanToolName: () => isPresentPlanToolName,
@@ -19581,6 +19773,7 @@ __export(index_exports, {
   pastedTextStats: () => pastedTextStats,
   pendingSlackExternalReplies: () => pendingSlackExternalReplies,
   permissionMode: () => permissionMode,
+  persistPendingFileAttachments: () => persistPendingFileAttachments,
   persistVaultKeyInKeychain: () => persistVaultKeyInKeychain,
   planFileAbs: () => planFileAbs,
   planQuestionsSignature: () => planQuestionsSignature,
@@ -19750,6 +19943,7 @@ __export(index_exports, {
   userCursorMcpConfigPath: () => userCursorMcpConfigPath,
   validateLinearApiKey: () => validateLinearApiKey,
   verifyAbleTimeConnection: () => verifyAbleTimeConnection,
+  visibleToolRowDetail: () => visibleToolRowDetail,
   waitForPidExit: () => waitForPidExit,
   warmGithubAgentAuth: () => warmGithubAgentAuth,
   withAgentInstructions: () => withAgentInstructions,
@@ -20775,8 +20969,12 @@ function latestPendingPlanQuestions(input) {
   if (last?.role === "agent") return extractPendingPlanQuestions(last.parts);
   return null;
 }
+var PLAN_QUESTION_ANSWERS_PREFIX = "Answers to your questions:";
+function isPlanQuestionAnswersMessage(text5) {
+  return text5.startsWith(PLAN_QUESTION_ANSWERS_PREFIX);
+}
 function formatPlanQuestionAnswers(questions, answers) {
-  const lines = ["Answers to your questions:"];
+  const lines = [PLAN_QUESTION_ANSWERS_PREFIX, ""];
   for (let i = 0; i < questions.length; i++) {
     const q = questions[i];
     const a = answers.find((x) => x.questionIndex === i);
@@ -20785,7 +20983,7 @@ function formatPlanQuestionAnswers(questions, answers) {
     if (a?.selected.length) parts.push(a.selected.join(", "));
     if (a?.other?.trim()) parts.push(a.other.trim());
     const body = parts.length ? parts.join(" \xB7 ") : "(no answer)";
-    lines.push(`${i + 1}. ${header}${q.question}`);
+    lines.push(`${i + 1}. ${header}${q.question}  `);
     lines.push(`   \u2192 ${body}`);
   }
   return lines.join("\n");
@@ -20853,6 +21051,15 @@ var MCP_WAIT_QUEUED_HINT = "Child is queued waiting for a concurrency slot \u201
 function mcpWaitStillRunningHint(status) {
   return status === "queued" ? MCP_WAIT_QUEUED_HINT : MCP_WAIT_STILL_RUNNING_HINT;
 }
+var MCP_WAIT_STOPPED_HINT = "Child was stopped before the turn finished. Do not treat this as success. send_to_thread to resume, or tell the user.";
+var MCP_WAIT_BROKEN_HINT = "Child worktree is broken (missing on disk). Tell the user \u2014 do not treat this as success.";
+var MCP_WAIT_ERROR_HINT = "Child turn failed. lastError/text is the failure \u2014 switch agent, tell the user, or retry. Do not treat empty text as success.";
+function mcpWaitFinishedHint(status) {
+  if (status === "stopped") return MCP_WAIT_STOPPED_HINT;
+  if (status === "broken") return MCP_WAIT_BROKEN_HINT;
+  if (status === "error") return MCP_WAIT_ERROR_HINT;
+  return void 0;
+}
 
 // src/mcp/server.ts
 init_turn_live();
@@ -22631,7 +22838,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 (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. When finished, usage is the last agent turn\u2019s tokens + costUsd (when the provider reported cost).",
+      "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. On status stopped or broken, the child did not finish \u2014 resume with send_to_thread or tell the user; do not treat that as success. When finished, usage is the last agent turn\u2019s tokens + costUsd (when the provider reported cost).",
       {
         ref: import_zod5.z.string(),
         timeoutMs: import_zod5.z.number().optional()
@@ -22653,7 +22860,8 @@ async function startMcpServer() {
                 stillRunning: result.stillRunning,
                 progress: result.progress,
                 lastActivityAt: result.lastActivityAt,
-                hint: result.stillRunning ? mcpWaitStillRunningHint(result.status) : void 0
+                hint: result.stillRunning ? mcpWaitStillRunningHint(result.status) : mcpWaitFinishedHint(result.status),
+                incomplete: !result.stillRunning && Boolean(mcpWaitFinishedHint(result.status))
               })
             }
           ]
@@ -22672,7 +22880,8 @@ async function startMcpServer() {
               type: "text",
               text: JSON.stringify({
                 ...result,
-                hint: result.stillRunning ? mcpWaitStillRunningHint(result.status) : void 0
+                hint: result.stillRunning ? mcpWaitStillRunningHint(result.status) : mcpWaitFinishedHint(result.status),
+                incomplete: !result.stillRunning && Boolean(mcpWaitFinishedHint(result.status))
               })
             }
           ]
@@ -22696,7 +22905,7 @@ async function startMcpServer() {
         }
         const clearQueue = force !== false;
         const hadQueued = t.queue.length > 0;
-        const stopped = orch.stop(ref, { clearQueue });
+        const stopped = orch.stop(ref, { clearQueue, notifyParent: false });
         return {
           content: [
             {
@@ -25631,6 +25840,7 @@ init_outbound_watch();
   PLAN_FILE_NAME,
   PLAN_FILE_REL,
   PLAN_MODE_INSTRUCTION,
+  PLAN_QUESTION_ANSWERS_PREFIX,
   REPO_REVIEW_NAME,
   REPO_REVIEW_PATH,
   REVIEW_REQUEST_NAME,
@@ -25930,6 +26140,7 @@ init_outbound_watch();
   isOrchestratorThread,
   isPidAlive,
   isPlaceholderBranch,
+  isPlanQuestionAnswersMessage,
   isPollWrapperToolName,
   isPrNotMergeableError,
   isPresentPlanToolName,
@@ -26040,6 +26251,7 @@ init_outbound_watch();
   pastedTextStats,
   pendingSlackExternalReplies,
   permissionMode,
+  persistPendingFileAttachments,
   persistVaultKeyInKeychain,
   planFileAbs,
   planQuestionsSignature,
@@ -26209,6 +26421,7 @@ init_outbound_watch();
   userCursorMcpConfigPath,
   validateLinearApiKey,
   verifyAbleTimeConnection,
+  visibleToolRowDetail,
   waitForPidExit,
   warmGithubAgentAuth,
   withAgentInstructions,