@sideboard-ai/core 0.1.51 → 0.1.52

package/dist/mcp/run-stdio.js

@@ -15,14 +15,19 @@ import {
   pushTurnStderr,
   resolveQuotaFallbackAgent,
   summarizeTurnStderr
-} from "../chunk-7EUWSBWR.js";
+} from "../chunk-6QTZVJ7A.js";
 import "../chunk-H6GGDLYS.js";
 import {
   addWorkspace,
   ensureWorkspace,
   removeWorkspace,
   syncWorkspacesFromThreads
-} from "../chunk-QN7XNQAT.js";
+} from "../chunk-YDXQ72MD.js";
+import {
+  extractPresentedPlan,
+  readPlanFile,
+  writePlanFile
+} from "../chunk-N5PM7HGQ.js";
 import {
   childEnvWithAppSettings,
   getLinearApiKey,
@@ -41,7 +46,7 @@ import {
   isGlobalThread,
   isOrchestratorThread,
   orchestratorSessionPoisonedByBuiltins
-} from "../chunk-YFJ4FG2P.js";
+} from "../chunk-YOWIYAVA.js";
 import {
   assertOrchestratorCapableAgent
 } from "../chunk-S2LL5HA4.js";
@@ -50,19 +55,24 @@ import {
   coordinatorTurnReminder,
   enrichWorkspacesWithGithub,
   ensureGlobalCoordinatorCwd
-} from "../chunk-F4Q3IM6V.js";
+} from "../chunk-UEAHMGHW.js";
 import {
+  addPrStackLayer,
   allocateTeamName,
   allocateTeamSlug,
   commitAll,
+  createExistingBranchWorktree,
   createOrUpdatePr,
   createThreadWorktree,
+  detectGhStack,
   fetchPrHead,
   formatGhLandError,
   getPr,
   getPrChecks,
   getPrDetails,
   getPrMeta,
+  getPrStack,
+  initPrStack,
   isDirty,
   isPlaceholderBranch,
   isSideboardScratchPath,
@@ -82,7 +92,12 @@ import {
   takenSlugsFromThread,
   threadDisplayLabel,
   worktreeNameFromPath
-} from "../chunk-XRSAGVRW.js";
+} from "../chunk-XOU6HNQJ.js";
+import {
+  ATTACHMENTS_DIR,
+  LEGACY_ATTACHMENTS_DIR,
+  attachmentsGitignoreBody
+} from "../chunk-B3SJXYIJ.js";
 import {
   appendMessage,
   createEmptyThread,
@@ -94,7 +109,7 @@ import {
   updateThread,
   withThreadLock,
   writeThread
-} from "../chunk-EOYDCKQC.js";
+} from "../chunk-HLEX5AQ6.js";
 import {
   ensureAgentPath,
   gh,
@@ -119,7 +134,7 @@ import { basename as basename4 } from "path";
 
 // src/orchestrator/orchestrator.ts
 import { EventEmitter } from "events";
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 
 // src/agents/spawn.ts
 import { createInterface } from "readline";
@@ -161,6 +176,9 @@ function toolDescription(name, input) {
   if (/present_artifact$/i.test(name)) {
     return str(input?.title) ? `Present ${str(input?.title)}` : "Present artifact";
   }
+  if (/present_plan$/i.test(name)) {
+    return str(input?.title) ? `Plan ${str(input?.title)}` : "Present plan";
+  }
   if (/present_schema$/i.test(name)) {
     return str(input?.title) ? `Schema ${str(input?.title)}` : "Present schema";
   }
@@ -357,9 +375,9 @@ async function spawnAgentTurn(thread, input, onEvent) {
       `Cannot spawn ${thread.agent}: thread ${thread.id} has no worktreePath`
     );
   }
-  const { isGlobalThread: isGlobalThread2 } = await import("../global-workspace-OJEPGDXA.js");
+  const { isGlobalThread: isGlobalThread2 } = await import("../global-workspace-EV4G2WMQ.js");
   if (isGlobalThread2(thread)) {
-    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("../coordinator-prompt-7HHJRO7B.js");
+    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("../coordinator-prompt-6FXVTSFN.js");
     ensureGlobalCoordinatorCwd2();
   }
   if (isOrchestratorThread(thread)) {
@@ -1083,7 +1101,7 @@ async function requireAgent(agent, opts) {
 }
 
 // src/threads/create.ts
-async function createThread(input, onSetupLine) {
+async function createThread(input, _onSetupLine) {
   await requireAgent(input.agent);
   const repoPath = await resolveRepoRoot(input.repoPath);
   if (!existsSync5(repoPath)) {
@@ -1141,26 +1159,10 @@ async function createThread(input, onSetupLine) {
   });
   writeThread(thread);
   await ensureWorkspace(repoPath);
-  try {
-    let setup = await runSetupScript(repoPath, worktreePath, onSetupLine);
-    if (!setup.ran) {
-      setup = await runCursorWorktreeSetup(repoPath, worktreePath, onSetupLine);
-    }
-    if (setup.ran && setup.exitCode !== 0 && setup.exitCode !== null) {
-      updateThread(thread.id, {
-        lastError: `Setup exited ${setup.exitCode} (thread is still usable)`
-      });
-    }
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    updateThread(thread.id, {
-      lastError: `Setup failed: ${message}`
-    });
-  }
   return readThread(thread.id) ?? thread;
 }
 async function listLinearIssues(agent, repoPath) {
-  const { getAdapter: getAdapter2 } = await import("../agents-HIEJL3UV.js");
+  const { getAdapter: getAdapter2 } = await import("../agents-ON6RKKND.js");
   await requireAgent(agent, { requireLinear: true });
   const adapter = getAdapter2(agent);
   if (!adapter.listLinearIssues) {
@@ -1477,7 +1479,9 @@ function worktreeBindingFrom(from) {
     sourceIsFork: from.sourceIsFork,
     parentThreadId: from.parentThreadId,
     prUrl: from.prUrl,
-    prTitle: from.prTitle
+    prTitle: from.prTitle,
+    stackId: from.stackId,
+    stackLayer: from.stackLayer
   };
 }
 function threadsSharingWorktree(worktreePath) {
@@ -1675,13 +1679,10 @@ File: src/client/frontends/desktop/core/UserData.ts
 // src/review/request-review.ts
 var REPO_REVIEW_PATH = ".sideboard/review.md";
 var REPO_REVIEW_NAME = "review.md";
-var REVIEW_REQUEST_PATH = ".sideboard/attachments/Review request.md";
+var REVIEW_REQUEST_PATH = `${ATTACHMENTS_DIR}/Review request.md`;
+var LEGACY_REVIEW_REQUEST_PATH = `${LEGACY_ATTACHMENTS_DIR}/Review request.md`;
 var REVIEW_REQUEST_NAME = "Review request.md";
 var REVIEW_REQUEST_PREFILL = "Review.";
-var ATTACHMENTS_GITIGNORE = `# Sideboard review / composer attachments (local only)
-*
-!.gitignore
-`;
 var LEGACY_REVIEW_TEMPLATE_MARKERS = [
   "You are acting as a reviewer for a proposed code change made by another engineer.",
   "HOW MANY FINDINGS TO RETURN:"
@@ -1704,10 +1705,10 @@ function readTextIfPresent(abs) {
   }
 }
 function ensureAttachmentsGitignore(worktreePath) {
-  const gitignoreAbs = join5(worktreePath, ".sideboard", "attachments", ".gitignore");
+  const gitignoreAbs = join5(worktreePath, ATTACHMENTS_DIR, ".gitignore");
   if (existsSync6(gitignoreAbs)) return;
   mkdirSync2(dirname2(gitignoreAbs), { recursive: true });
-  writeFileSync(gitignoreAbs, ATTACHMENTS_GITIGNORE, "utf8");
+  writeFileSync(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
 }
 function resolveReviewGuidelines(worktreePath) {
   const repoAbs = join5(worktreePath, REPO_REVIEW_PATH);
@@ -1730,6 +1731,16 @@ function resolveReviewGuidelines(worktreePath) {
       source: "local"
     };
   }
+  const legacyAbs = join5(worktreePath, LEGACY_REVIEW_REQUEST_PATH);
+  const legacyContent = readTextIfPresent(legacyAbs);
+  if (legacyContent && !shouldRefreshReviewRequestTemplate(legacyContent)) {
+    return {
+      path: LEGACY_REVIEW_REQUEST_PATH,
+      name: REVIEW_REQUEST_NAME,
+      content: legacyContent,
+      source: "local"
+    };
+  }
   ensureAttachmentsGitignore(worktreePath);
   mkdirSync2(dirname2(localAbs), { recursive: true });
   writeFileSync(localAbs, REVIEW_REQUEST_TEMPLATE, "utf8");
@@ -2013,7 +2024,7 @@ async function adoptThread(input) {
     messages: input.messages ?? []
   });
   writeThread(thread);
-  const { ensureWorkspace: ensureWorkspace2 } = await import("../workspaces-MUU7RGVV.js");
+  const { ensureWorkspace: ensureWorkspace2 } = await import("../workspaces-3RQQZQRO.js");
   await ensureWorkspace2(repoPath);
   return thread;
 }
@@ -2208,11 +2219,295 @@ async function importConductorWorkspaceAsync(workspaceId) {
   return importConductorWorkspace(workspaceId);
 }
 
+// src/threads/stack-layers.ts
+import { existsSync as existsSync8 } from "fs";
+function stackIdFrom(stack) {
+  if (stack.stackNumber != null) return `gh-stack-${stack.stackNumber}`;
+  const key = stack.layers.map((l) => l.branchName).join("|");
+  if (!key) return null;
+  return `gh-stack-local-${hashShort(key)}`;
+}
+function hashShort(s) {
+  let h = 0;
+  for (let i = 0; i < s.length; i++) h = h * 31 + s.charCodeAt(i) | 0;
+  return Math.abs(h).toString(36);
+}
+function requireThread3(idOrRef) {
+  const thread = findThreadByRef(idOrRef) ?? readThread(idOrRef);
+  if (!thread) throw new Error(`Thread not found: ${idOrRef}`);
+  return thread;
+}
+function sanitizeSlugPart(name) {
+  return name.trim().replace(/^refs\/heads\//, "").replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48) || "layer";
+}
+function layerSlug(stackId, layer) {
+  const stackPart = stackId.replace(/^gh-stack-/, "s");
+  return sanitizeSlugPart(`${stackPart}-L${layer.position}-${layer.branchName}`);
+}
+function findThreadForStackLayer(repoPath, stackId, layer) {
+  const threads = listThreads({ includeArchived: false }).filter(
+    (t) => t.repoPath === repoPath && t.stackId === stackId
+  );
+  const byLayer = threads.find((t) => t.stackLayer === layer.position);
+  if (byLayer) return byLayer;
+  return threads.find((t) => t.branchName === layer.branchName) ?? listThreads({ includeArchived: false }).find(
+    (t) => t.repoPath === repoPath && t.branchName === layer.branchName
+  ) ?? null;
+}
+async function openStackLayer(input, _onSetupLine) {
+  await requireAgent(input.agent);
+  const repoPath = await resolveRepoRoot(input.repoPath);
+  const stackId = stackIdFrom(input.stack);
+  if (!stackId) throw new Error("Cannot open stack layer without a stack id");
+  const existing = findThreadForStackLayer(repoPath, stackId, input.layer);
+  if (existing) {
+    const patch = {};
+    if (existing.stackId !== stackId) patch.stackId = stackId;
+    if (existing.stackLayer !== input.layer.position) {
+      patch.stackLayer = input.layer.position;
+    }
+    if (input.layer.prUrl && existing.prUrl !== input.layer.prUrl) {
+      patch.prUrl = input.layer.prUrl;
+    }
+    if (input.layer.title && existing.prTitle !== input.layer.title) {
+      patch.prTitle = input.layer.title;
+    }
+    if (Object.keys(patch).length > 0) updateThread(existing.id, patch);
+    return {
+      thread: readThread(existing.id) ?? existing,
+      createdWorktree: false
+    };
+  }
+  let worktreePath = null;
+  let branchName = input.layer.branchName;
+  let createdWorktree = false;
+  const trees = await listWorktrees(repoPath);
+  const checkedOut = trees.find((w) => w.branch === branchName);
+  if (checkedOut?.path && existsSync8(checkedOut.path)) {
+    if (input.reuseExistingWorktree !== false) {
+      worktreePath = checkedOut.path;
+    } else {
+      throw new Error(
+        `Branch ${branchName} is already checked out at ${checkedOut.path}`
+      );
+    }
+  }
+  if (!worktreePath) {
+    const slug = layerSlug(stackId, input.layer);
+    const created = await createExistingBranchWorktree({
+      repoPath,
+      branchName,
+      slug
+    });
+    worktreePath = created.worktreePath;
+    branchName = created.branchName;
+    copyConfiguredFiles(repoPath, worktreePath);
+    createdWorktree = true;
+  }
+  const title = input.layer.title?.trim() || (input.layer.prNumber != null ? `PR #${input.layer.prNumber}` : input.layer.branchName);
+  const thread = createEmptyThread({
+    title,
+    userSetTitle: Boolean(input.layer.title?.trim()),
+    sourceType: input.layer.prNumber != null ? "pr" : "branch",
+    sourceRef: input.layer.prNumber != null ? String(input.layer.prNumber) : input.layer.branchName,
+    branchName,
+    worktreePath,
+    repoPath,
+    agent: input.agent,
+    autonomy: input.autonomy ?? "default",
+    model: input.model ?? null,
+    effort: input.effort ?? "high",
+    fast: Boolean(input.fast),
+    planMode: Boolean(input.planMode),
+    parentThreadId: input.parentThreadId ?? null,
+    status: "idle",
+    prUrl: input.layer.prUrl,
+    prTitle: input.layer.title ?? null,
+    stackId,
+    stackLayer: input.layer.position
+  });
+  writeThread(thread);
+  await ensureWorkspace(repoPath);
+  return { thread: readThread(thread.id) ?? thread, createdWorktree };
+}
+async function openPrStackLayers(input, onSetupLine) {
+  const from = requireThread3(input.threadRef);
+  if (!from.worktreePath?.trim() || !from.repoPath?.trim()) {
+    throw new Error("Thread has no worktree");
+  }
+  const stack = await getPrStack(from.worktreePath);
+  if (!stack) throw new Error("Current branch is not part of a GitHub PR stack");
+  const layers = input.layer != null ? stack.layers.filter((l) => l.position === input.layer) : stack.layers;
+  if (!layers.length) {
+    throw new Error(
+      input.layer != null ? `No stack layer at position ${input.layer}` : "Stack has no layers"
+    );
+  }
+  const threads = [];
+  const createdThreadIds = [];
+  for (const layer of layers) {
+    const { thread, createdWorktree } = await openStackLayer(
+      {
+        repoPath: from.repoPath,
+        stack,
+        layer,
+        agent: from.agent,
+        autonomy: from.autonomy,
+        model: from.model,
+        effort: from.effort,
+        fast: from.fast,
+        planMode: from.planMode,
+        parentThreadId: from.id
+      },
+      onSetupLine
+    );
+    threads.push(thread);
+    if (createdWorktree) createdThreadIds.push(thread.id);
+  }
+  const stackId = stackIdFrom(stack);
+  const current = stack.layers[stack.currentIndex];
+  if (stackId) {
+    updateThread(from.id, {
+      stackId,
+      stackLayer: current?.position ?? from.stackLayer
+    });
+  }
+  return { stack, threads, createdThreadIds };
+}
+async function addStackLayerFromThread(input, onSetupLine) {
+  const from = requireThread3(input.threadRef);
+  if (!from.worktreePath?.trim() || !from.repoPath?.trim()) {
+    throw new Error("Thread has no worktree");
+  }
+  const status = await detectGhStack(from.worktreePath);
+  if (!status.available) throw new Error(status.reason);
+  await addPrStackLayer(from.worktreePath, input.branchName);
+  const stack = await getPrStack(from.worktreePath);
+  if (!stack) throw new Error("Stack not found after adding layer");
+  const layer = stack.layers.find((l) => l.branchName === input.branchName.trim()) ?? stack.layers[stack.layers.length - 1];
+  if (!layer) throw new Error("New stack layer not found");
+  if (input.title?.trim()) {
+    layer.title = input.title.trim();
+  }
+  const thread = await openStackLayer(
+    {
+      repoPath: from.repoPath,
+      stack,
+      layer,
+      agent: from.agent,
+      autonomy: from.autonomy,
+      model: from.model,
+      effort: from.effort,
+      fast: from.fast,
+      planMode: from.planMode,
+      parentThreadId: from.id
+    },
+    onSetupLine
+  );
+  return { stack, thread: thread.thread, createdWorktree: thread.createdWorktree };
+}
+async function initStackFromThread(input, onSetupLine) {
+  const from = requireThread3(input.threadRef);
+  if (!from.worktreePath?.trim() || !from.branchName?.trim() || !from.repoPath?.trim()) {
+    throw new Error("Thread has no worktree/branch");
+  }
+  const status = await detectGhStack(from.worktreePath);
+  if (!status.available) throw new Error(status.reason);
+  const branches = [
+    from.branchName,
+    ...(input.additionalBranches ?? []).map((b) => b.trim()).filter(Boolean)
+  ];
+  await initPrStack(from.worktreePath, branches, {
+    base: input.base ?? await resolveDefaultBranch(from.repoPath)
+  });
+  return openPrStackLayers({ threadRef: from.id }, onSetupLine);
+}
+async function createPrStack(input, onSetupLine) {
+  await requireAgent(input.agent);
+  const repoPath = await resolveRepoRoot(input.repoPath);
+  if (!existsSync8(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);
+  const team = allocateTeamSlug(repoPath);
+  const base = input.base ?? await resolveDefaultBranch(repoPath);
+  const bootstrap = await createThreadWorktree({
+    repoPath,
+    sourceRef: base,
+    slug: `${team.slug}-stack-init`
+  });
+  copyConfiguredFiles(repoPath, bootstrap.worktreePath);
+  try {
+    await initPrStack(bootstrap.worktreePath, input.branches, { base });
+    const bottom = input.branches[0];
+    const co = await git(["checkout", bottom], bootstrap.worktreePath, {
+      reject: false
+    });
+    if (co.exitCode !== 0) {
+      throw new Error(
+        co.stderr.trim() || co.stdout.trim() || `Could not check out ${bottom} after stack init`
+      );
+    }
+  } catch (err) {
+    try {
+      await removeWorktree(repoPath, bootstrap.worktreePath, {
+        deleteBranch: bootstrap.branchName
+      });
+    } catch {
+    }
+    throw err;
+  }
+  const stack = await getPrStack(bootstrap.worktreePath);
+  if (!stack) {
+    try {
+      await removeWorktree(repoPath, bootstrap.worktreePath, {
+        deleteBranch: bootstrap.branchName
+      });
+    } catch {
+    }
+    throw new Error("Stack init succeeded but gh stack view returned no stack");
+  }
+  const threads = [];
+  const createdThreadIds = [];
+  for (const layer of stack.layers) {
+    const title = layer.position === 1 && input.title?.trim() ? input.title.trim() : layer.title;
+    const opened = await openStackLayer(
+      {
+        repoPath,
+        stack,
+        layer: title ? { ...layer, title } : layer,
+        agent: input.agent,
+        autonomy: input.autonomy,
+        model: input.model,
+        effort: input.effort,
+        fast: input.fast,
+        planMode: input.planMode,
+        reuseExistingWorktree: true
+      },
+      onSetupLine
+    );
+    threads.push(opened.thread);
+    if (opened.createdWorktree || opened.thread.worktreePath === bootstrap.worktreePath) {
+      createdThreadIds.push(opened.thread.id);
+    }
+  }
+  const claimed = new Set(threads.map((t) => t.worktreePath));
+  if (!claimed.has(bootstrap.worktreePath) && existsSync8(bootstrap.worktreePath)) {
+    try {
+      await removeWorktree(repoPath, bootstrap.worktreePath, {
+        deleteBranch: bootstrap.branchName
+      });
+    } catch {
+    }
+  }
+  return { stack, threads, createdThreadIds };
+}
+
 // src/diff/diff.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync5, statSync as statSync2, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync3, readFileSync as readFileSync5, statSync as statSync2, writeFileSync as writeFileSync2 } from "fs";
 import { dirname as dirname3, join as join7 } from "path";
 async function inspectGitWorktree(worktreePath) {
-  if (!worktreePath || !existsSync8(worktreePath)) return "missing_worktree";
+  if (!worktreePath || !existsSync9(worktreePath)) return "missing_worktree";
   const check = await git(["rev-parse", "--is-inside-work-tree"], worktreePath, {
     reject: false
   });
@@ -2220,7 +2515,7 @@ async function inspectGitWorktree(worktreePath) {
   return "ok";
 }
 async function initializeGitRepository(worktreePath) {
-  if (!worktreePath || !existsSync8(worktreePath)) {
+  if (!worktreePath || !existsSync9(worktreePath)) {
     throw new Error("Worktree not found");
   }
   const status = await inspectGitWorktree(worktreePath);
@@ -2904,7 +3199,7 @@ async function confirmLand(thread, opts) {
 }
 
 // src/skills/discover.ts
-import { existsSync as existsSync9, readdirSync as readdirSync4, readFileSync as readFileSync6, statSync as statSync3 } from "fs";
+import { existsSync as existsSync10, readdirSync as readdirSync4, readFileSync as readFileSync6, statSync as statSync3 } from "fs";
 import { homedir } from "os";
 import { join as join8 } from "path";
 function toCommand(name) {
@@ -2957,7 +3252,7 @@ function readSkill(skillMd, source) {
   }
 }
 function scanSkillsDir(dir, source, out) {
-  if (!existsSync9(dir)) return;
+  if (!existsSync10(dir)) return;
   let entries;
   try {
     entries = readdirSync4(dir);
@@ -2967,7 +3262,7 @@ function scanSkillsDir(dir, source, out) {
   for (const entry of entries) {
     if (entry.startsWith(".")) continue;
     const skillMd = join8(dir, entry, "SKILL.md");
-    if (!existsSync9(skillMd)) continue;
+    if (!existsSync10(skillMd)) continue;
     try {
       if (!statSync3(skillMd).isFile()) continue;
     } catch {
@@ -2978,7 +3273,7 @@ function scanSkillsDir(dir, source, out) {
   }
 }
 function scanClaudePluginSkills(pluginsRoot, out) {
-  if (!existsSync9(pluginsRoot)) return;
+  if (!existsSync10(pluginsRoot)) return;
   const walk = (dir, depth, lookingForSkillsDir) => {
     if (depth > 7) return;
     let entries;
@@ -3128,7 +3423,7 @@ function expandComposerPrompt(worktreePath, prompt, opts) {
 }
 
 // src/composer/stage-files.ts
-import { copyFileSync as copyFileSync3, existsSync as existsSync10, mkdirSync as mkdirSync4, readFileSync as readFileSync7, statSync as statSync4, writeFileSync as writeFileSync3 } from "fs";
+import { copyFileSync as copyFileSync3, existsSync as existsSync11, mkdirSync as mkdirSync4, readFileSync as readFileSync7, statSync as statSync4, writeFileSync as writeFileSync3 } from "fs";
 import { basename as basename3, extname, join as join9 } from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 var IMAGE_EXTENSIONS2 = /* @__PURE__ */ new Set([
@@ -3151,11 +3446,6 @@ var IMAGE_MIME_BY_EXT = {
   bmp: "image/bmp",
   ico: "image/x-icon"
 };
-var ATTACHMENTS_DIR = ".sideboard/attachments";
-var ATTACHMENTS_GITIGNORE2 = `# Sideboard review / composer attachments (local only)
-*
-!.gitignore
-`;
 var MAX_INLINE_BYTES = 4e5;
 var MAX_PREVIEW_BYTES = 5e6;
 function fileExtension(filePath) {
@@ -3172,19 +3462,19 @@ function ensureAttachmentsDir(worktreePath) {
   const dir = join9(worktreePath, ATTACHMENTS_DIR);
   mkdirSync4(dir, { recursive: true });
   const gi = join9(dir, ".gitignore");
-  if (!existsSync10(gi)) {
-    writeFileSync3(gi, ATTACHMENTS_GITIGNORE2, "utf8");
+  if (!existsSync11(gi)) {
+    writeFileSync3(gi, attachmentsGitignoreBody(), "utf8");
   }
   return dir;
 }
 function uniqueAttachmentName(dir, originalName) {
   const safe = originalName.replace(/[/\\]/g, "_") || "file";
-  if (!existsSync10(join9(dir, safe))) return safe;
+  if (!existsSync11(join9(dir, safe))) return safe;
   const ext = extname(safe);
   const stem = ext ? safe.slice(0, -ext.length) : safe;
   for (let i = 1; i < 1e4; i++) {
     const candidate = `${stem}-${i}${ext}`;
-    if (!existsSync10(join9(dir, candidate))) return candidate;
+    if (!existsSync11(join9(dir, candidate))) return candidate;
   }
   return `${stem}-${randomUUID4()}${ext}`;
 }
@@ -3317,7 +3607,7 @@ function attachmentsFromWorktreePaths(worktreePath, relativePaths) {
 }
 
 // src/agents/instructions.ts
-import { existsSync as existsSync11, readFileSync as readFileSync8, statSync as statSync5 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync8, statSync as statSync5 } from "fs";
 import { join as join10 } from "path";
 function normPath(p) {
   return p.replace(/\/+$/, "");
@@ -3457,7 +3747,7 @@ function loadAgentInstructions(worktreePath, agent) {
   for (const rel of candidates) {
     if (seen.has(rel)) continue;
     const abs = join10(worktreePath, rel);
-    if (!existsSync11(abs)) continue;
+    if (!existsSync12(abs)) continue;
     try {
       if (!statSync5(abs).isFile()) continue;
       let content = readFileSync8(abs, "utf8");
@@ -3602,7 +3892,7 @@ var Orchestrator = class {
         }
         continue;
       }
-      if (!existsSync12(thread.worktreePath)) {
+      if (!existsSync13(thread.worktreePath)) {
         setStatus(thread.id, "broken", "Worktree missing on disk");
         this.emit({ type: "status_changed", threadId: thread.id, status: "broken" });
         continue;
@@ -3747,14 +4037,9 @@ var Orchestrator = class {
     return findThreadByRef(idOrRef) ?? readThread(idOrRef);
   }
   async createThread(input) {
-    let thread = await createThread(input, (line) => {
-      this.emit({
-        type: "turn_output",
-        threadId: "pending",
-        event: { type: "stdout", data: line }
-      });
-    });
+    let thread = await createThread(input);
     this.emit({ type: "status_changed", threadId: thread.id, status: thread.status });
+    await this.runSetupAfterCreate(thread.id);
     const { autoRunAfterSetupEnabled } = await import("../app-settings-7XVDQJ7F.js");
     if (autoRunAfterSetupEnabled()) {
       try {
@@ -3768,6 +4053,19 @@ var Orchestrator = class {
     }
     return thread;
   }
+  /** Run workspace setup after a new worktree is created (no-op if none configured). */
+  async runSetupAfterCreate(threadId) {
+    try {
+      await this.runSetup(threadId);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (/no setup script/i.test(message)) return;
+      if (/already running/i.test(message)) return;
+      updateThread(threadId, {
+        lastError: `Setup failed: ${message}`
+      });
+    }
+  }
   listWorkspaces() {
     const fromThreads = listThreads({ includeArchived: false }).map((t) => t.repoPath);
     return syncWorkspacesFromThreads(fromThreads);
@@ -4116,6 +4414,19 @@ var Orchestrator = class {
         });
       }
       const afterTurn = this.requireThread(threadId);
+      if (afterTurn.planMode && afterTurn.worktreePath?.trim()) {
+        const presented = extractPresentedPlan(parts);
+        const exited = parts.some(
+          (p) => p.type === "tool" && /exitplanmode/i.test(p.name)
+        );
+        if (presented?.content) {
+          writePlanFile(afterTurn.worktreePath, presented.content);
+        } else if (exited || chatText && chatText.trim().length >= 400) {
+          if (!readPlanFile(afterTurn.worktreePath) && chatText?.trim()) {
+            writePlanFile(afterTurn.worktreePath, chatText.trim());
+          }
+        }
+      }
       if (afterTurn.planMode && afterTurn.agent === "claude" && parts.some(
         (p) => p.type === "tool" && /exitplanmode/i.test(p.name)
       )) {
@@ -4597,6 +4908,82 @@ var Orchestrator = class {
     }
     return meta;
   }
+  async getPrStack(threadRef) {
+    const thread = this.requireThread(threadRef);
+    if (!thread.worktreePath?.trim()) return null;
+    const stack = await getPrStack(thread.worktreePath);
+    if (!stack) return null;
+    const current = stack.currentIndex >= 0 ? stack.layers[stack.currentIndex] : null;
+    const patch = {};
+    if (stack.stackNumber != null) {
+      const id = `gh-stack-${stack.stackNumber}`;
+      if (thread.stackId !== id) patch.stackId = id;
+    }
+    if (current?.position != null && thread.stackLayer !== current.position) {
+      patch.stackLayer = current.position;
+    }
+    if (current?.prUrl && current.prUrl !== thread.prUrl) patch.prUrl = current.prUrl;
+    if (current?.title && current.title !== thread.prTitle) patch.prTitle = current.title;
+    if (current?.branchName && current.branchName !== thread.branchName) {
+      patch.branchName = current.branchName;
+    }
+    if (Object.keys(patch).length > 0) updateThread(thread.id, patch);
+    return stack;
+  }
+  /** Open worktrees for all (or one) stack layers discovered from a thread. */
+  async openPrStackLayers(threadRef, opts) {
+    const result = await openPrStackLayers({ threadRef, layer: opts?.layer });
+    for (const t of result.threads) {
+      this.emit({ type: "status_changed", threadId: t.id, status: t.status });
+    }
+    for (const id of result.createdThreadIds) {
+      await this.runSetupAfterCreate(id);
+    }
+    return { stack: result.stack, threads: result.threads };
+  }
+  /** Add a branch on top of the thread's stack and open its worktree. */
+  async addStackLayer(threadRef, branchName, opts) {
+    const result = await addStackLayerFromThread({
+      threadRef,
+      branchName,
+      title: opts?.title
+    });
+    this.emit({
+      type: "status_changed",
+      threadId: result.thread.id,
+      status: result.thread.status
+    });
+    if (result.createdWorktree) {
+      await this.runSetupAfterCreate(result.thread.id);
+    }
+    return { stack: result.stack, thread: result.thread };
+  }
+  /** Initialize a stack from the current thread branch (optional extra layers). */
+  async initStackFromThread(threadRef, opts) {
+    const result = await initStackFromThread({
+      threadRef,
+      additionalBranches: opts?.additionalBranches,
+      base: opts?.base
+    });
+    for (const t of result.threads) {
+      this.emit({ type: "status_changed", threadId: t.id, status: t.status });
+    }
+    for (const id of result.createdThreadIds) {
+      await this.runSetupAfterCreate(id);
+    }
+    return { stack: result.stack, threads: result.threads };
+  }
+  /** Create a new multi-layer stack with one worktree per layer. */
+  async createPrStack(input) {
+    const result = await createPrStack(input);
+    for (const t of result.threads) {
+      this.emit({ type: "status_changed", threadId: t.id, status: t.status });
+    }
+    for (const id of result.createdThreadIds) {
+      await this.runSetupAfterCreate(id);
+    }
+    return { stack: result.stack, threads: result.threads };
+  }
   async getPrDetails(threadRef) {
     const { thread, selector, cwd } = await this.withPrSelector(threadRef);
     if (!selector) return null;
@@ -4659,14 +5046,9 @@ var Orchestrator = class {
     return forkChatTab(input);
   }
   async forkThreadWorktree(input) {
-    const thread = await forkThreadWorktree(input, (line) => {
-      this.emit({
-        type: "turn_output",
-        threadId: "pending",
-        event: { type: "stdout", data: line }
-      });
-    });
+    const thread = await forkThreadWorktree(input);
     this.emit({ type: "status_changed", threadId: thread.id, status: thread.status });
+    await this.runSetupAfterCreate(thread.id);
     return thread;
   }
   renameThread(threadRef, title) {
@@ -4680,7 +5062,7 @@ var Orchestrator = class {
   }
   /**
    * Stage OS / worktree files into composer attachments (copies external files
-   * into `.sideboard/attachments/` so agents can Read images and binaries).
+   * into `.context/attachments/` so agents can Read images and binaries).
    */
   attachComposerFiles(threadRef, opts) {
     const thread = this.requireThread(threadRef);
@@ -4754,8 +5136,8 @@ var Orchestrator = class {
       updateThread(thread.id, { worktreePath: globalAgentCwd() });
       return setStatus(thread.id, "idle");
     }
-    if (!existsSync12(thread.worktreePath)) {
-      const { createThreadWorktree: createThreadWorktree2 } = await import("../worktree-DVNDMWZ7.js");
+    if (!existsSync13(thread.worktreePath)) {
+      const { createThreadWorktree: createThreadWorktree2 } = await import("../worktree-5KEQWSAF.js");
       const { execa: execa6 } = await import("execa");
       const slug = thread.worktreePath.split("/").pop();
       const dest = thread.worktreePath;
@@ -5021,6 +5403,59 @@ async function startMcpServer() {
       return { content: [{ type: "text", text: JSON.stringify(payload) }] };
     }
   );
+  server.tool(
+    "ask_user",
+    "Ask the user clarifying multiple-choice questions in Sideboard\u2019s composer (plan mode). Before calling, write a short chat message explaining the decision and what each option means. Include a description on every option. Use for approach forks and requirements \u2014 not for \u201Cis the plan ready?\u201D. After calling, stop and wait for their next message with answers.",
+    {
+      questions: z.array(
+        z.object({
+          question: z.string().describe("Full question text ending with ?"),
+          header: z.string().max(24).optional().describe("Short label shown above the question"),
+          multiSelect: z.boolean().optional().describe("Allow selecting multiple options"),
+          options: z.array(
+            z.object({
+              label: z.string(),
+              description: z.string().optional().describe("What this option means / when to choose it (strongly preferred)")
+            })
+          ).min(2).max(6).describe("2\u20136 choices (Sideboard also offers Other)")
+        })
+      ).min(1).max(4).describe("1\u20134 questions")
+    },
+    async ({ questions }) => {
+      const payload = {
+        ok: true,
+        questions,
+        message: "Questions shown in Sideboard\u2019s composer. Wait for the user\u2019s next message with their answers before continuing."
+      };
+      return { content: [{ type: "text", text: JSON.stringify(payload) }] };
+    }
+  );
+  server.tool(
+    "present_plan",
+    "Save the implementation plan as markdown to .context/attachments/plan.md and show it in Sideboard chat for user approval (Copy / Hand off / Approve). Call this when the plan is ready \u2014 required in plan mode. Pass the full plan body in content. Then Claude should call ExitPlanMode.",
+    {
+      title: z.string().optional().describe("Short plan title (defaults to Plan)"),
+      content: z.string().min(1).describe("Full plan markdown (headings, steps, risks, open questions)"),
+      thread_id: z.string().optional().describe("Sideboard thread id when cwd is not the worktree")
+    },
+    async ({ title, content, thread_id }) => {
+      const { writePlanFile: writePlanFile2 } = await import("../plan-file-PHVKUAEE.js");
+      let root = process.cwd();
+      if (thread_id?.trim()) {
+        const t = orch.getThread(thread_id.trim());
+        if (t?.worktreePath?.trim()) root = t.worktreePath;
+      }
+      const path = writePlanFile2(root, content);
+      const payload = {
+        ok: true,
+        path,
+        title: title?.trim() || "Plan",
+        content,
+        message: "Plan saved to .context/attachments/plan.md and shown in Sideboard chat for approval."
+      };
+      return { content: [{ type: "text", text: JSON.stringify(payload) }] };
+    }
+  );
   server.tool(
     "present_schema",
     "Open Sideboard\u2019s schema-driven CMS side column (filterable table and/or form). Pass JSON Schema + schemaUi (Brightsy extensions supported). Use datasource=brightsy with resource_id (record type UUID) when logged into Brightsy; use datasource=inline with embedded resource/records for any other source.",
@@ -5599,6 +6034,126 @@ async function startMcpServer() {
       };
     }
   );
+  server.tool(
+    "get_pr_stack",
+    "Load the GitHub PR stack for a thread worktree (`gh stack view --json`). Returns null JSON when the branch is not stacked. Prefer this before mergePr on stacked PRs.",
+    { ref: z.string() },
+    async ({ ref }) => {
+      const stack = await orch.getPrStack(ref);
+      return {
+        content: [{ type: "text", text: JSON.stringify(stack, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "open_pr_stack_layers",
+    "Materialize one worktree+thread per stack layer (or a single 1-based layer). Pass a thread ref already on the stack.",
+    {
+      ref: z.string(),
+      layer: z.number().int().positive().optional()
+    },
+    async ({ ref, layer }) => {
+      const result = await orch.openPrStackLayers(ref, { layer });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                stackNumber: result.stack.stackNumber,
+                trunk: result.stack.trunk,
+                threads: result.threads.map((t) => ({
+                  id: t.id,
+                  title: t.title,
+                  branchName: t.branchName,
+                  stackLayer: t.stackLayer,
+                  worktreePath: t.worktreePath,
+                  prUrl: t.prUrl,
+                  link: `sideboard://thread/${t.id}`
+                }))
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "add_stack_layer",
+    "Add a branch on top of the current stack (`gh stack add`) and open a worktree+thread for it.",
+    {
+      ref: z.string(),
+      branchName: z.string(),
+      title: z.string().optional()
+    },
+    async ({ ref, branchName, title }) => {
+      const result = await orch.addStackLayer(ref, branchName, { title });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                id: result.thread.id,
+                title: result.thread.title,
+                branchName: result.thread.branchName,
+                stackLayer: result.thread.stackLayer,
+                worktreePath: result.thread.worktreePath,
+                link: `sideboard://thread/${result.thread.id}`
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "create_pr_stack",
+    "Create a new GitHub PR stack with one Sideboard worktree per layer (bottom\u2192top branch names). Requires `gh extension install github/gh-stack`.",
+    {
+      repoPath: z.string(),
+      branches: z.array(z.string()).min(1),
+      agent: z.enum(["claude", "codex", "opencode", "brightsy", "cursor"]),
+      base: z.string().optional(),
+      title: z.string().optional()
+    },
+    async (args) => {
+      const result = await orch.createPrStack({
+        repoPath: args.repoPath,
+        branches: args.branches,
+        agent: args.agent,
+        base: args.base,
+        title: args.title
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                stackNumber: result.stack.stackNumber,
+                trunk: result.stack.trunk,
+                threads: result.threads.map((t) => ({
+                  id: t.id,
+                  title: t.title,
+                  branchName: t.branchName,
+                  stackLayer: t.stackLayer,
+                  worktreePath: t.worktreePath,
+                  link: `sideboard://thread/${t.id}`
+                }))
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  );
   server.tool(
     "list_issues",
     "List issues from Sideboard Account connections (Linear API or GitHub Issues; Linear\u2192GitHub fallback when Linear is not connected). Pass repoPath from list_workspaces \u2014 GitHub Issues are scoped to that repo. Then create_thread with sourceType=ticket.",