@sideboard-ai/core 0.1.23 → 0.1.30

package/dist/index.cjs

@@ -5241,6 +5241,9 @@ __export(index_exports, {
   applyAppEnvironment: () => applyAppEnvironment,
   applyCompaction: () => applyCompaction,
   applyThreadIntoMain: () => applyThreadIntoMain,
+  attachmentFromAbsolutePath: () => attachmentFromAbsolutePath,
+  attachmentsFromBuffers: () => attachmentsFromBuffers,
+  attachmentsFromWorktreePaths: () => attachmentsFromWorktreePaths,
   autoCleanupOrphansEnabled: () => autoCleanupOrphansEnabled,
   autoRenameBranchEnabled: () => autoRenameBranchEnabled,
   autoRunAfterSetupEnabled: () => autoRunAfterSetupEnabled,
@@ -5363,6 +5366,7 @@ __export(index_exports, {
   isGhRateLimitError: () => isGhRateLimitError,
   isGlobalRepoPath: () => isGlobalRepoPath,
   isGlobalThread: () => isGlobalThread,
+  isImageFilePath: () => isImageFilePath,
   isLinearConnected: () => isLinearConnected,
   isOrchestratorThread: () => isOrchestratorThread,
   isPlaceholderBranch: () => isPlaceholderBranch,
@@ -5451,6 +5455,8 @@ __export(index_exports, {
   slugify: () => slugify,
   spawnAgentTurn: () => spawnAgentTurn,
   splitForCompaction: () => splitForCompaction,
+  stageAbsolutePathsAsAttachments: () => stageAbsolutePathsAsAttachments,
+  stageBuffersAsAttachments: () => stageBuffersAsAttachments,
   startDevServer: () => startDevServer,
   startMcpServer: () => startMcpServer,
   startOrchestration: () => startOrchestration,
@@ -7257,6 +7263,9 @@ function expandComposerPrompt(worktreePath, prompt, opts) {
     parts.push("");
     parts.push(`## Attachment: ${att.name}`);
     parts.push(`Kind: ${att.kind}`);
+    if (att.path) {
+      parts.push(`Path in worktree: \`${att.path}\``);
+    }
     parts.push("");
     parts.push(att.content);
   }
@@ -7342,10 +7351,239 @@ function buildDiffCommentAttachment(input) {
     id: input.id ?? `diff-comment-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
     name,
     kind: "diff-comment",
+    path: input.path.trim(),
     content
   };
 }
 
+// src/composer/stage-files.ts
+var import_node_fs19 = require("fs");
+var import_node_path19 = require("path");
+var import_node_crypto2 = require("crypto");
+var IMAGE_EXTENSIONS2 = /* @__PURE__ */ new Set([
+  "png",
+  "jpg",
+  "jpeg",
+  "gif",
+  "webp",
+  "svg",
+  "bmp",
+  "ico"
+]);
+var 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"
+};
+var ATTACHMENTS_DIR = ".sideboard/attachments";
+var ATTACHMENTS_GITIGNORE = `# Sideboard review / composer attachments (local only)
+*
+!.gitignore
+`;
+var MAX_INLINE_BYTES = 4e5;
+var MAX_PREVIEW_BYTES = 5e6;
+function fileExtension(filePath) {
+  const base = (0, import_node_path19.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_path19.join)(worktreePath, ATTACHMENTS_DIR);
+  (0, import_node_fs19.mkdirSync)(dir, { recursive: true });
+  const gi = (0, import_node_path19.join)(dir, ".gitignore");
+  if (!(0, import_node_fs19.existsSync)(gi)) {
+    (0, import_node_fs19.writeFileSync)(gi, ATTACHMENTS_GITIGNORE, "utf8");
+  }
+  return dir;
+}
+function uniqueAttachmentName(dir, originalName) {
+  const safe = originalName.replace(/[/\\]/g, "_") || "file";
+  if (!(0, import_node_fs19.existsSync)((0, import_node_path19.join)(dir, safe))) return safe;
+  const ext = (0, import_node_path19.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_fs19.existsSync)((0, import_node_path19.join)(dir, candidate))) return candidate;
+  }
+  return `${stem}-${(0, import_node_crypto2.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_crypto2.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_crypto2.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_crypto2.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_crypto2.randomUUID)(),
+    name,
+    kind: "file",
+    path: opts.path,
+    content: buf.toString("utf8")
+  };
+}
+function attachmentFromAbsolutePath(absolutePath) {
+  const name = (0, import_node_path19.basename)(absolutePath);
+  try {
+    const st = (0, import_node_fs19.statSync)(absolutePath);
+    if (!st.isFile()) {
+      return {
+        id: (0, import_node_crypto2.randomUUID)(),
+        name,
+        kind: "file",
+        content: `(not a file: ${absolutePath})`
+      };
+    }
+    const buf = (0, import_node_fs19.readFileSync)(absolutePath);
+    return attachmentFromBuffer(name, buf, { sourceLabel: absolutePath });
+  } catch (err) {
+    return {
+      id: (0, import_node_crypto2.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_path19.basename)(abs);
+    try {
+      const st = (0, import_node_fs19.statSync)(abs);
+      if (!st.isFile()) continue;
+      const name = uniqueAttachmentName(dir, originalName);
+      const destAbs = (0, import_node_path19.join)(dir, name);
+      (0, import_node_fs19.copyFileSync)(abs, destAbs);
+      const rel = `${ATTACHMENTS_DIR}/${name}`;
+      const buf = (0, import_node_fs19.readFileSync)(destAbs);
+      out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
+    } catch (err) {
+      out.push({
+        id: (0, import_node_crypto2.randomUUID)(),
+        name: originalName,
+        kind: "file",
+        content: `(could not attach ${abs}: ${err instanceof Error ? err.message : String(err)})`
+      });
+    }
+  }
+  return out;
+}
+function stageBuffersAsAttachments(worktreePath, buffers) {
+  if (buffers.length === 0) return [];
+  const dir = ensureAttachmentsDir(worktreePath);
+  const out = [];
+  for (const item of buffers) {
+    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_path19.join)(dir, name);
+      (0, import_node_fs19.writeFileSync)(destAbs, buf);
+      const rel = `${ATTACHMENTS_DIR}/${name}`;
+      out.push(attachmentFromBuffer(name, buf, { path: rel }));
+    } catch (err) {
+      out.push({
+        id: (0, import_node_crypto2.randomUUID)(),
+        name: originalName,
+        kind: "file",
+        content: `(could not attach ${originalName}: ${err instanceof Error ? err.message : String(err)})`
+      });
+    }
+  }
+  return out;
+}
+function attachmentsFromBuffers(buffers) {
+  return buffers.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_crypto2.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_crypto2.randomUUID)(),
+        name: (0, import_node_path19.basename)(rel) || "file",
+        kind: "file",
+        content: `(invalid path: ${rel})`
+      });
+      continue;
+    }
+    const name = (0, import_node_path19.basename)(rel);
+    try {
+      const abs = (0, import_node_path19.join)(worktreePath, rel);
+      const st = (0, import_node_fs19.statSync)(abs);
+      if (!st.isFile()) continue;
+      const buf = (0, import_node_fs19.readFileSync)(abs);
+      out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
+    } catch (err) {
+      out.push({
+        id: (0, import_node_crypto2.randomUUID)(),
+        name,
+        kind: "file",
+        content: `(could not read ${rel}: ${err instanceof Error ? err.message : String(err)})`
+      });
+    }
+  }
+  return out;
+}
+
 // src/composer/summarize.ts
 init_run();
 init_path();
@@ -7784,14 +8022,14 @@ async function confirmLand(thread, opts) {
 }
 
 // src/threads/create.ts
-var import_node_fs19 = require("fs");
+var import_node_fs20 = require("fs");
 init_worktree();
 init_thread_store();
 init_workspaces();
 async function createThread(input, onSetupLine) {
   await requireAgent(input.agent);
   const repoPath = await resolveRepoRoot(input.repoPath);
-  if (!(0, import_node_fs19.existsSync)(repoPath)) {
+  if (!(0, import_node_fs20.existsSync)(repoPath)) {
     throw new Error(`Repo not found: ${repoPath}`);
   }
   let sourceRef = input.sourceRef;
@@ -7874,7 +8112,7 @@ async function listLinearIssues(agent, repoPath) {
 }
 
 // src/threads/chat-tabs.ts
-var import_node_crypto2 = require("crypto");
+var import_node_crypto3 = require("crypto");
 init_teams();
 init_worktree_labels();
 init_global_workspace();
@@ -7930,7 +8168,7 @@ function forkMessageSlice(from, throughIndex) {
 function buildForkTranscriptAttachment(baseTitle, messages) {
   const title = baseTitle || "Chat";
   return {
-    id: (0, import_node_crypto2.randomUUID)(),
+    id: (0, import_node_crypto3.randomUUID)(),
     name: `Transcript of ${title}.md`,
     kind: "transcript",
     content: formatTranscriptMarkdown(title, messages)
@@ -7989,30 +8227,34 @@ async function forkThreadWorktree(input, onSetupLine) {
       repoPath: from.repoPath,
       agent: input.agent ?? from.agent,
       autonomy: from.autonomy,
+      model: from.model,
+      fast: from.fast,
+      planMode: from.planMode,
       title: input.title?.trim() || void 0,
-      parentThreadId: from.id
+      parentThreadId: from.id,
+      attachments: [attachment]
     },
     onSetupLine
   );
-  return updateThread(thread.id, { attachments: [attachment] });
+  return thread;
 }
 
 // src/threads/adopt.ts
 var import_node_child_process = require("child_process");
-var import_node_fs20 = require("fs");
+var import_node_fs21 = require("fs");
 var import_node_os9 = require("os");
-var import_node_path19 = require("path");
+var import_node_path20 = require("path");
 var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
 init_worktree();
 init_thread_store();
-var CONDUCTOR_APP_SUPPORT = (0, import_node_path19.join)(
+var CONDUCTOR_APP_SUPPORT = (0, import_node_path20.join)(
   process.env.HOME ?? "",
   "Library",
   "Application Support",
   "com.conductor.app"
 );
-var CONDUCTOR_DB = (0, import_node_path19.join)(CONDUCTOR_APP_SUPPORT, "conductor.db");
-var CURSOR_SDK_STORE = (0, import_node_path19.join)(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
+var CONDUCTOR_DB = (0, import_node_path20.join)(CONDUCTOR_APP_SUPPORT, "conductor.db");
+var CURSOR_SDK_STORE = (0, import_node_path20.join)(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
 function mapAgentType(raw) {
   if (!raw) return null;
   const v = raw.toLowerCase();
@@ -8024,21 +8266,21 @@ function mapAgentType(raw) {
   return null;
 }
 function resolveConductorCursorAgentId(workspacePath) {
-  if (!workspacePath || !(0, import_node_fs20.existsSync)(CURSOR_SDK_STORE)) return null;
+  if (!workspacePath || !(0, import_node_fs21.existsSync)(CURSOR_SDK_STORE)) return null;
   const normalized = workspacePath.replace(/\/$/, "");
   let best = null;
   let hashes;
   try {
-    hashes = (0, import_node_fs20.readdirSync)(CURSOR_SDK_STORE);
+    hashes = (0, import_node_fs21.readdirSync)(CURSOR_SDK_STORE);
   } catch {
     return null;
   }
   for (const hash of hashes) {
-    const agentsFile = (0, import_node_path19.join)(CURSOR_SDK_STORE, hash, "agents.ndjson");
-    if (!(0, import_node_fs20.existsSync)(agentsFile)) continue;
+    const agentsFile = (0, import_node_path20.join)(CURSOR_SDK_STORE, hash, "agents.ndjson");
+    if (!(0, import_node_fs21.existsSync)(agentsFile)) continue;
     let text;
     try {
-      text = (0, import_node_fs20.readFileSync)(agentsFile, "utf8");
+      text = (0, import_node_fs21.readFileSync)(agentsFile, "utf8");
     } catch {
       continue;
     }
@@ -8062,7 +8304,7 @@ function resolveConductorCursorAgentId(workspacePath) {
   return best?.agentId ?? null;
 }
 async function adoptThread(input) {
-  if (!(0, import_node_fs20.existsSync)(input.worktreePath)) {
+  if (!(0, import_node_fs21.existsSync)(input.worktreePath)) {
     throw new Error(`Worktree not found: ${input.worktreePath}`);
   }
   const repoPath = await resolveRepoRoot(input.worktreePath);
@@ -8089,18 +8331,18 @@ function conductorDbPath() {
   return CONDUCTOR_DB;
 }
 function listConductorWorkspaces() {
-  if (!(0, import_node_fs20.existsSync)(CONDUCTOR_DB)) {
+  if (!(0, import_node_fs21.existsSync)(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = (0, import_node_fs20.mkdtempSync)((0, import_node_path19.join)((0, import_node_os9.tmpdir)(), "sideboard-conductor-"));
-  const snapshot = (0, import_node_path19.join)(tmp, "conductor.db");
+  const tmp = (0, import_node_fs21.mkdtempSync)((0, import_node_path20.join)((0, import_node_os9.tmpdir)(), "sideboard-conductor-"));
+  const snapshot = (0, import_node_path20.join)(tmp, "conductor.db");
   try {
-    (0, import_node_fs20.copyFileSync)(CONDUCTOR_DB, snapshot);
+    (0, import_node_fs21.copyFileSync)(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if ((0, import_node_fs20.existsSync)(src)) {
+      if ((0, import_node_fs21.existsSync)(src)) {
         try {
-          (0, import_node_fs20.copyFileSync)(src, `${snapshot}${suffix}`);
+          (0, import_node_fs21.copyFileSync)(src, `${snapshot}${suffix}`);
         } catch {
         }
       }
@@ -8176,22 +8418,22 @@ function listConductorWorkspaces() {
       db.close();
     }
   } finally {
-    (0, import_node_fs20.rmSync)(tmp, { recursive: true, force: true });
+    (0, import_node_fs21.rmSync)(tmp, { recursive: true, force: true });
   }
 }
 function importConductorWorkspace(workspaceId) {
-  if (!(0, import_node_fs20.existsSync)(CONDUCTOR_DB)) {
+  if (!(0, import_node_fs21.existsSync)(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = (0, import_node_fs20.mkdtempSync)((0, import_node_path19.join)((0, import_node_os9.tmpdir)(), "sideboard-conductor-"));
-  const snapshot = (0, import_node_path19.join)(tmp, "conductor.db");
+  const tmp = (0, import_node_fs21.mkdtempSync)((0, import_node_path20.join)((0, import_node_os9.tmpdir)(), "sideboard-conductor-"));
+  const snapshot = (0, import_node_path20.join)(tmp, "conductor.db");
   try {
-    (0, import_node_fs20.copyFileSync)(CONDUCTOR_DB, snapshot);
+    (0, import_node_fs21.copyFileSync)(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if ((0, import_node_fs20.existsSync)(src)) {
+      if ((0, import_node_fs21.existsSync)(src)) {
         try {
-          (0, import_node_fs20.copyFileSync)(src, `${snapshot}${suffix}`);
+          (0, import_node_fs21.copyFileSync)(src, `${snapshot}${suffix}`);
         } catch {
         }
       }
@@ -8209,7 +8451,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_fs20.existsSync)(worktreePath)) {
+      if (!(0, import_node_fs21.existsSync)(worktreePath)) {
         throw new Error(`Conductor worktree missing on disk: ${worktreePath}`);
       }
       let sessionId = null;
@@ -8272,7 +8514,7 @@ function importConductorWorkspace(workspaceId) {
       db.close();
     }
   } finally {
-    (0, import_node_fs20.rmSync)(tmp, { recursive: true, force: true });
+    (0, import_node_fs21.rmSync)(tmp, { recursive: true, force: true });
   }
 }
 async function importConductorWorkspaceAsync(workspaceId) {
@@ -8281,13 +8523,13 @@ async function importConductorWorkspaceAsync(workspaceId) {
 
 // src/orchestrator/orchestrator.ts
 var import_node_events = require("events");
-var import_node_fs23 = require("fs");
+var import_node_fs24 = require("fs");
 init_agents();
 init_worktree();
 
 // src/git/orphan-cleanup.ts
-var import_node_fs21 = require("fs");
-var import_node_path20 = require("path");
+var import_node_fs22 = require("fs");
+var import_node_path21 = require("path");
 init_worktree();
 init_thread_store();
 init_paths();
@@ -8302,9 +8544,9 @@ async function findOrphanWorktrees(repoPaths) {
     repoPaths?.length ? repoPaths : threads.map((t) => t.repoPath).filter(Boolean)
   );
   const homeRoot = sideboardWorkspacesDir();
-  if ((0, import_node_fs21.existsSync)(homeRoot)) {
+  if ((0, import_node_fs22.existsSync)(homeRoot)) {
     try {
-      for (const entry of (0, import_node_fs21.readdirSync)(homeRoot, { withFileTypes: true })) {
+      for (const entry of (0, import_node_fs22.readdirSync)(homeRoot, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
         void entry;
       }
@@ -8314,7 +8556,7 @@ async function findOrphanWorktrees(repoPaths) {
   const orphans = [];
   const seen = /* @__PURE__ */ new Set();
   for (const repoPath of repos) {
-    if (!repoPath || !(0, import_node_fs21.existsSync)(repoPath)) continue;
+    if (!repoPath || !(0, import_node_fs22.existsSync)(repoPath)) continue;
     try {
       const wts = await listWorktrees(repoPath);
       for (const wt of wts) {
@@ -8325,7 +8567,7 @@ async function findOrphanWorktrees(repoPaths) {
         seen.add(path);
         let mtimeMs = 0;
         try {
-          mtimeMs = (0, import_node_fs21.statSync)(path).mtimeMs;
+          mtimeMs = (0, import_node_fs22.statSync)(path).mtimeMs;
         } catch {
           mtimeMs = 0;
         }
@@ -8335,16 +8577,16 @@ async function findOrphanWorktrees(repoPaths) {
     }
     try {
       const root = worktreesRoot(repoPath);
-      if ((0, import_node_fs21.existsSync)(root)) {
-        for (const entry of (0, import_node_fs21.readdirSync)(root, { withFileTypes: true })) {
+      if ((0, import_node_fs22.existsSync)(root)) {
+        for (const entry of (0, import_node_fs22.readdirSync)(root, { withFileTypes: true })) {
           if (!entry.isDirectory()) continue;
-          const path = (0, import_node_path20.join)(root, entry.name).replace(/\/$/, "");
+          const path = (0, import_node_path21.join)(root, entry.name).replace(/\/$/, "");
           if (known.has(path) || seen.has(path)) continue;
-          if (!(0, import_node_fs21.existsSync)((0, import_node_path20.join)(path, ".git"))) continue;
+          if (!(0, import_node_fs22.existsSync)((0, import_node_path21.join)(path, ".git"))) continue;
           seen.add(path);
           let mtimeMs = 0;
           try {
-            mtimeMs = (0, import_node_fs21.statSync)(path).mtimeMs;
+            mtimeMs = (0, import_node_fs22.statSync)(path).mtimeMs;
           } catch {
             mtimeMs = Date.now();
           }
@@ -8490,8 +8732,8 @@ async function applyThreadIntoMain(thread, opts) {
 }
 
 // src/git/clone-repo.ts
-var import_node_fs22 = require("fs");
-var import_node_path21 = require("path");
+var import_node_fs23 = require("fs");
+var import_node_path22 = require("path");
 var import_execa6 = require("execa");
 init_paths();
 init_workspaces();
@@ -8501,12 +8743,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_path21.basename)(url.replace(/\/$/, "").replace(/\.git$/, ""));
+    const leaf = (0, import_node_path22.basename)(url.replace(/\/$/, "").replace(/\.git$/, ""));
     name = leaf || "repo";
   }
   name = name.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "repo";
-  const dest = (0, import_node_path21.join)(sideboardReposDir(), name);
-  if ((0, import_node_fs22.existsSync)(dest)) {
+  const dest = (0, import_node_path22.join)(sideboardReposDir(), name);
+  if ((0, import_node_fs23.existsSync)(dest)) {
     const repoPath2 = await resolveRepoRoot(dest);
     const workspace2 = await ensureWorkspace(repoPath2);
     return { repoPath: repoPath2, workspace: workspace2 };
@@ -8618,7 +8860,7 @@ var Orchestrator = class {
         }
         continue;
       }
-      if (!(0, import_node_fs23.existsSync)(thread.worktreePath)) {
+      if (!(0, import_node_fs24.existsSync)(thread.worktreePath)) {
         setStatus(thread.id, "broken", "Worktree missing on disk");
         this.emit({ type: "status_changed", threadId: thread.id, status: "broken" });
         continue;
@@ -9430,6 +9672,23 @@ var Orchestrator = class {
   setAttachments(threadRef, attachments) {
     return updateThread(this.requireThread(threadRef).id, { attachments });
   }
+  /**
+   * Stage OS / worktree files into composer attachments (copies external files
+   * into `.sideboard/attachments/` so agents can Read images and binaries).
+   */
+  attachComposerFiles(threadRef, opts) {
+    const thread = this.requireThread(threadRef);
+    const fromAbs = stageAbsolutePathsAsAttachments(
+      thread.worktreePath,
+      opts.absolutePaths ?? []
+    );
+    const fromRel = attachmentsFromWorktreePaths(
+      thread.worktreePath,
+      opts.relativePaths ?? []
+    );
+    const fromBuf = stageBuffersAsAttachments(thread.worktreePath, opts.buffers ?? []);
+    return [...fromAbs, ...fromRel, ...fromBuf];
+  }
   listWorktreeChats(threadRef) {
     const thread = this.requireThread(threadRef);
     return threadsSharingWorktree(thread.worktreePath);
@@ -9489,7 +9748,7 @@ var Orchestrator = class {
       updateThread(thread.id, { worktreePath: globalAgentCwd2() });
       return setStatus(thread.id, "idle");
     }
-    if (!(0, import_node_fs23.existsSync)(thread.worktreePath)) {
+    if (!(0, import_node_fs24.existsSync)(thread.worktreePath)) {
       const { createThreadWorktree: createThreadWorktree2 } = await Promise.resolve().then(() => (init_worktree(), worktree_exports));
       const { execa: execa7 } = await import("execa");
       const slug = thread.worktreePath.split("/").pop();
@@ -9591,7 +9850,7 @@ init_coordinator_prompt();
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 var import_zod = require("zod");
-var import_node_path22 = require("path");
+var import_node_path23 = require("path");
 init_worktree();
 init_global_workspace();
 
@@ -9639,7 +9898,7 @@ async function startMcpServer() {
     async () => {
       const threads = orch.getThreads(true);
       const lines = threads.map((t) => {
-        const repo = t.repoPath === GLOBAL_WORKSPACE_ID ? "Orchestration" : (0, import_node_path22.basename)(t.repoPath) || t.repoPath;
+        const repo = t.repoPath === GLOBAL_WORKSPACE_ID ? "Orchestration" : (0, import_node_path23.basename)(t.repoPath) || t.repoPath;
         return `${t.id.slice(0, 8)}  ${t.status.padEnd(9)}  ${t.agent.padEnd(8)}  ${repo}  ${t.sourceType}:${t.sourceRef}  ${t.title}  sideboard://thread/${t.id}${t.devPort ? `  http://localhost:${t.devPort}` : ""}`;
       });
       return {
@@ -10535,6 +10794,9 @@ init_injected_mcp();
   applyAppEnvironment,
   applyCompaction,
   applyThreadIntoMain,
+  attachmentFromAbsolutePath,
+  attachmentsFromBuffers,
+  attachmentsFromWorktreePaths,
   autoCleanupOrphansEnabled,
   autoRenameBranchEnabled,
   autoRunAfterSetupEnabled,
@@ -10657,6 +10919,7 @@ init_injected_mcp();
   isGhRateLimitError,
   isGlobalRepoPath,
   isGlobalThread,
+  isImageFilePath,
   isLinearConnected,
   isOrchestratorThread,
   isPlaceholderBranch,
@@ -10745,6 +11008,8 @@ init_injected_mcp();
   slugify,
   spawnAgentTurn,
   splitForCompaction,
+  stageAbsolutePathsAsAttachments,
+  stageBuffersAsAttachments,
   startDevServer,
   startMcpServer,
   startOrchestration,