@sideboard-ai/core 0.1.50 → 0.1.52

package/dist/index.js

@@ -4,7 +4,7 @@ import {
   listWorkspaces,
   removeWorkspace,
   syncWorkspacesFromThreads
-} from "./chunk-3NAS4MWH.js";
+} from "./chunk-GNML24AW.js";
 import {
   CLOUD_COORDINATOR_BUSY_REPLY,
   CLOUD_COORDINATOR_STOPPED_REPLY,
@@ -24,7 +24,7 @@ import {
   orchestratorSessionPoisonedByBuiltins,
   parseForceStopMessage,
   takenTeamSlugsForOrchestration
-} from "./chunk-5WYEJ3F3.js";
+} from "./chunk-XX5BB7NV.js";
 import {
   BRIGHTSY_MCP_ALLOWED_TOOLS,
   CLAUDE_MODEL_CATALOG,
@@ -70,7 +70,7 @@ import {
   resolveQuotaFallbackAgent,
   sanitizeMcpServerName,
   writeInjectedMcpConfig
-} from "./chunk-SS34TVSY.js";
+} from "./chunk-D3METLRW.js";
 import {
   ORCHESTRATOR_AGENT_KINDS,
   assertOrchestratorCapableAgent,
@@ -88,7 +88,18 @@ import {
   loadBrightsyConfig,
   saveBrightsyConfig,
   switchBrightsyAccount
-} from "./chunk-ILQK4P5R.js";
+} from "./chunk-BXJ76RHF.js";
+import {
+  LEGACY_PLAN_FILE_REL,
+  PLAN_FILE_NAME,
+  PLAN_FILE_REL,
+  extractPresentedPlan,
+  isPresentPlanToolName,
+  planFileAbs,
+  readPlanFile,
+  resolvePlanMarkdown,
+  writePlanFile
+} from "./chunk-QTUESPAW.js";
 import {
   cursorSdkMessageToEvents,
   fallbackTurnFailDetail,
@@ -144,17 +155,21 @@ import {
   enrichWorkspacesWithGithub,
   ensureGlobalCoordinatorCwd,
   formatWorkspaceInventory
-} from "./chunk-ZQCQIWIP.js";
+} from "./chunk-LRLKJM3O.js";
 import {
   FAMOUS_SOCCER_TEAMS,
+  addPrStackLayer,
   allocateTeamName,
   allocateTeamSlug,
   branchDisplayLabel,
+  checkoutPrStackLayer,
   collectTakenTeamSlugs,
   commitAll,
+  createExistingBranchWorktree,
   createOrUpdatePr,
   createThreadWorktree,
   currentBranch,
+  detectGhStack,
   detectLocalMergeConflicts,
   ensureGhPreferOrigin,
   extractGhErrorDetail,
@@ -166,21 +181,28 @@ import {
   getPrChecks,
   getPrDetails,
   getPrMeta,
+  getPrStack,
   ghHeadRef,
   ghRepoSelectArgs,
+  initPrStack,
   isDirty,
   isGhRateLimitError,
+  isInPrStack,
   isPlaceholderBranch,
+  isSideboardScratchPath,
   listBranches,
   listPrs,
   listWorktrees,
   lookupSoccerTeam,
   mergePr,
+  mergePrStack,
   normalizeWorktreePath,
   originGhRepoEnv,
+  parseGhStackViewJson,
   parseGithubSlugFromRemoteUrl,
   pushBranch,
   removeWorktree,
+  resetGhStackDetectCache,
   resolveDefaultBranch,
   resolveDiffBaseRef,
   resolveGithubRepoSlug,
@@ -188,13 +210,21 @@ import {
   resolveRepoRoot,
   resolveWorktreeStartPoint,
   slugify,
+  stackMergeReadiness,
+  submitPrStack,
   suggestSlug,
   takenSlugsFromThread,
   threadDisplayLabel,
   worktreeDisplayLabel,
   worktreeDisplayLabelForGroup,
   worktreeNameFromPath
-} from "./chunk-FV6FN6V5.js";
+} from "./chunk-DZFH2KLT.js";
+import {
+  ATTACHMENTS_DIR,
+  LEGACY_ATTACHMENTS_DIR,
+  attachmentsGitignoreBody,
+  isWorkspaceScratchPath
+} from "./chunk-FKOIHGKV.js";
 import {
   appendMessage,
   createEmptyThread,
@@ -208,7 +238,7 @@ import {
   updateThread,
   withThreadLock,
   writeThread
-} from "./chunk-O6W3P7V3.js";
+} from "./chunk-TSRXOSVD.js";
 import {
   THINKING_EFFORTS,
   isThinkingEffort,
@@ -243,8 +273,9 @@ import {
   ensureAgentPath,
   gh,
   git,
+  resolveGhAuthToken,
   run
-} from "./chunk-AJ6ROGD7.js";
+} from "./chunk-7LNGIP3X.js";
 
 // src/integrations/github.ts
 async function getGitHubStatus() {
@@ -456,6 +487,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";
   }
@@ -655,9 +689,9 @@ async function spawnAgentTurn(thread, input, onEvent) {
       `Cannot spawn ${thread.agent}: thread ${thread.id} has no worktreePath`
     );
   }
-  const { isGlobalThread: isGlobalThread2 } = await import("./global-workspace-KSR3E63K.js");
+  const { isGlobalThread: isGlobalThread2 } = await import("./global-workspace-MSX2K27Y.js");
   if (isGlobalThread2(thread)) {
-    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("./coordinator-prompt-SPGDT7J5.js");
+    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("./coordinator-prompt-S6JZD5EF.js");
     ensureGlobalCoordinatorCwd2();
   }
   if (isOrchestratorThread(thread)) {
@@ -1496,7 +1530,7 @@ async function listUntrackedPaths(worktreePath) {
     worktreePath,
     { reject: false }
   );
-  return stdout.split("\0").filter(Boolean);
+  return stdout.split("\0").filter(Boolean).filter((p) => !isSideboardScratchPath(p));
 }
 async function listUntrackedFiles(worktreePath, maxHunk) {
   const paths = await listUntrackedPaths(worktreePath);
@@ -2179,11 +2213,6 @@ var IMAGE_MIME_BY_EXT = {
   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) {
@@ -2201,7 +2230,7 @@ function ensureAttachmentsDir(worktreePath) {
   mkdirSync3(dir, { recursive: true });
   const gi = join6(dir, ".gitignore");
   if (!existsSync6(gi)) {
-    writeFileSync2(gi, ATTACHMENTS_GITIGNORE, "utf8");
+    writeFileSync2(gi, attachmentsGitignoreBody(), "utf8");
   }
   return dir;
 }
@@ -2781,7 +2810,7 @@ async function previewLand(thread) {
   const target = await resolveDefaultBranch(thread.repoPath);
   if (thread.branchName === target || thread.branchName === "main" || thread.branchName === "master") {
   }
-  const { stdout: head } = await import("./run-LF6E5IKL.js").then(
+  const { stdout: head } = await import("./run-ZJKYHXGN.js").then(
     ({ git: git2 }) => git2(["rev-parse", "--abbrev-ref", "HEAD"], thread.worktreePath)
   );
   const current = head.trim();
@@ -2820,7 +2849,7 @@ async function confirmLand(thread, opts) {
   if (preview.dirty) {
     committed = await commitAll(thread.worktreePath, meta.commitMessage);
   }
-  const { git: git2 } = await import("./run-LF6E5IKL.js");
+  const { git: git2 } = await import("./run-ZJKYHXGN.js");
   const { stdout: headOut } = await git2(
     ["rev-parse", "--abbrev-ref", "HEAD"],
     thread.worktreePath,
@@ -2851,7 +2880,7 @@ async function confirmLand(thread, opts) {
 
 // src/threads/create.ts
 import { existsSync as existsSync7 } from "fs";
-async function createThread(input, onSetupLine) {
+async function createThread(input, _onSetupLine) {
   await requireAgent(input.agent);
   const repoPath = await resolveRepoRoot(input.repoPath);
   if (!existsSync7(repoPath)) {
@@ -2909,26 +2938,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-3P4N6KHC.js");
+  const { getAdapter: getAdapter2 } = await import("./agents-YKSS6VBO.js");
   await requireAgent(agent, { requireLinear: true });
   const adapter = getAdapter2(agent);
   if (!adapter.listLinearIssues) {
@@ -2971,7 +2984,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) {
@@ -3084,11 +3099,305 @@ async function forkThreadWorktree(input, onSetupLine) {
   return thread;
 }
 
+// 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 };
+}
+function stackAgentDefaultsFrom(input) {
+  return {
+    agent: input.agent,
+    autonomy: input.autonomy,
+    model: input.model,
+    effort: input.effort,
+    fast: input.fast,
+    planMode: input.planMode
+  };
+}
+
 // src/threads/adopt.ts
 import { execFileSync } from "child_process";
 import {
   copyFileSync as copyFileSync3,
-  existsSync as existsSync8,
+  existsSync as existsSync9,
   mkdtempSync,
   readdirSync as readdirSync3,
   readFileSync as readFileSync7,
@@ -3116,7 +3425,7 @@ function mapAgentType(raw) {
   return null;
 }
 function resolveConductorCursorAgentId(workspacePath) {
-  if (!workspacePath || !existsSync8(CURSOR_SDK_STORE)) return null;
+  if (!workspacePath || !existsSync9(CURSOR_SDK_STORE)) return null;
   const normalized = workspacePath.replace(/\/$/, "");
   let best = null;
   let hashes;
@@ -3127,7 +3436,7 @@ function resolveConductorCursorAgentId(workspacePath) {
   }
   for (const hash of hashes) {
     const agentsFile = join7(CURSOR_SDK_STORE, hash, "agents.ndjson");
-    if (!existsSync8(agentsFile)) continue;
+    if (!existsSync9(agentsFile)) continue;
     let text;
     try {
       text = readFileSync7(agentsFile, "utf8");
@@ -3154,11 +3463,11 @@ function resolveConductorCursorAgentId(workspacePath) {
   return best?.agentId ?? null;
 }
 async function adoptThread(input) {
-  if (!existsSync8(input.worktreePath)) {
+  if (!existsSync9(input.worktreePath)) {
     throw new Error(`Worktree not found: ${input.worktreePath}`);
   }
   const repoPath = await resolveRepoRoot(input.worktreePath);
-  const { stdout: branch } = await import("./run-LF6E5IKL.js").then(
+  const { stdout: branch } = await import("./run-ZJKYHXGN.js").then(
     ({ git: git2 }) => git2(["rev-parse", "--abbrev-ref", "HEAD"], input.worktreePath)
   );
   const thread = createEmptyThread({
@@ -3173,7 +3482,7 @@ async function adoptThread(input) {
     messages: input.messages ?? []
   });
   writeThread(thread);
-  const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-UJX7JIGH.js");
+  const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-AYTBR6KQ.js");
   await ensureWorkspace2(repoPath);
   return thread;
 }
@@ -3181,7 +3490,7 @@ function conductorDbPath() {
   return CONDUCTOR_DB;
 }
 function listConductorWorkspaces() {
-  if (!existsSync8(CONDUCTOR_DB)) {
+  if (!existsSync9(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
   const tmp = mkdtempSync(join7(tmpdir(), "sideboard-conductor-"));
@@ -3190,7 +3499,7 @@ function listConductorWorkspaces() {
     copyFileSync3(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if (existsSync8(src)) {
+      if (existsSync9(src)) {
         try {
           copyFileSync3(src, `${snapshot}${suffix}`);
         } catch {
@@ -3272,7 +3581,7 @@ function listConductorWorkspaces() {
   }
 }
 function importConductorWorkspace(workspaceId) {
-  if (!existsSync8(CONDUCTOR_DB)) {
+  if (!existsSync9(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
   const tmp = mkdtempSync(join7(tmpdir(), "sideboard-conductor-"));
@@ -3281,7 +3590,7 @@ function importConductorWorkspace(workspaceId) {
     copyFileSync3(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if (existsSync8(src)) {
+      if (existsSync9(src)) {
         try {
           copyFileSync3(src, `${snapshot}${suffix}`);
         } catch {
@@ -3301,7 +3610,7 @@ function importConductorWorkspace(workspaceId) {
       ).get(workspaceId);
       if (!row) throw new Error(`Conductor workspace not found: ${workspaceId}`);
       const worktreePath = String(row.workspacePath);
-      if (!existsSync8(worktreePath)) {
+      if (!existsSync9(worktreePath)) {
         throw new Error(`Conductor worktree missing on disk: ${worktreePath}`);
       }
       let sessionId = null;
@@ -3373,10 +3682,10 @@ async function importConductorWorkspaceAsync(workspaceId) {
 
 // src/orchestrator/orchestrator.ts
 import { EventEmitter } from "events";
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 
 // src/git/orphan-cleanup.ts
-import { existsSync as existsSync9, readdirSync as readdirSync4, statSync as statSync5 } from "fs";
+import { existsSync as existsSync10, readdirSync as readdirSync4, statSync as statSync5 } from "fs";
 import { join as join8 } from "path";
 function isSideboardWorktreePath(path) {
   return path.includes("/.sideboard/worktrees/") || path.includes("/sideboard/workspaces/");
@@ -3388,7 +3697,7 @@ async function findOrphanWorktrees(repoPaths) {
     repoPaths?.length ? repoPaths : threads.map((t) => t.repoPath).filter(Boolean)
   );
   const homeRoot = sideboardWorkspacesDir();
-  if (existsSync9(homeRoot)) {
+  if (existsSync10(homeRoot)) {
     try {
       for (const entry of readdirSync4(homeRoot, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
@@ -3400,7 +3709,7 @@ async function findOrphanWorktrees(repoPaths) {
   const orphans = [];
   const seen = /* @__PURE__ */ new Set();
   for (const repoPath of repos) {
-    if (!repoPath || !existsSync9(repoPath)) continue;
+    if (!repoPath || !existsSync10(repoPath)) continue;
     try {
       const wts = await listWorktrees(repoPath);
       for (const wt of wts) {
@@ -3421,12 +3730,12 @@ async function findOrphanWorktrees(repoPaths) {
     }
     try {
       const root = worktreesRoot(repoPath);
-      if (existsSync9(root)) {
+      if (existsSync10(root)) {
         for (const entry of readdirSync4(root, { withFileTypes: true })) {
           if (!entry.isDirectory()) continue;
           const path = join8(root, entry.name).replace(/\/$/, "");
           if (known.has(path) || seen.has(path)) continue;
-          if (!existsSync9(join8(path, ".git"))) continue;
+          if (!existsSync10(join8(path, ".git"))) continue;
           seen.add(path);
           let mtimeMs = 0;
           try {
@@ -3575,7 +3884,7 @@ async function applyThreadIntoMain(thread, opts) {
 }
 
 // src/git/clone-repo.ts
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 import { basename as basename3, join as join9 } from "path";
 import { execa as execa5 } from "execa";
 async function cloneRepoIntoSideboard(opts) {
@@ -3588,7 +3897,7 @@ async function cloneRepoIntoSideboard(opts) {
   }
   name = name.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "repo";
   const dest = join9(sideboardReposDir(), name);
-  if (existsSync10(dest)) {
+  if (existsSync11(dest)) {
     const repoPath2 = await resolveRepoRoot(dest);
     const workspace2 = await ensureWorkspace(repoPath2);
     return { repoPath: repoPath2, workspace: workspace2 };
@@ -3606,7 +3915,7 @@ async function cloneRepoIntoSideboard(opts) {
 
 // src/review/request-review.ts
 import { randomUUID as randomUUID4 } from "crypto";
-import { existsSync as existsSync11, mkdirSync as mkdirSync4, readFileSync as readFileSync8, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync4, readFileSync as readFileSync8, writeFileSync as writeFileSync3 } from "fs";
 import { dirname as dirname3, join as join10 } from "path";
 
 // src/review/review-request-template.ts
@@ -3731,13 +4040,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_GITIGNORE2 = `# 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:"
@@ -3751,7 +4057,7 @@ function shouldRefreshReviewRequestTemplate(content) {
   return LEGACY_REVIEW_TEMPLATE_MARKERS.every((m) => trimmed.includes(m));
 }
 function readTextIfPresent(abs) {
-  if (!existsSync11(abs)) return null;
+  if (!existsSync12(abs)) return null;
   try {
     const content = readFileSync8(abs, "utf8");
     return content.trim() ? content : null;
@@ -3760,10 +4066,10 @@ function readTextIfPresent(abs) {
   }
 }
 function ensureAttachmentsGitignore(worktreePath) {
-  const gitignoreAbs = join10(worktreePath, ".sideboard", "attachments", ".gitignore");
-  if (existsSync11(gitignoreAbs)) return;
+  const gitignoreAbs = join10(worktreePath, ATTACHMENTS_DIR, ".gitignore");
+  if (existsSync12(gitignoreAbs)) return;
   mkdirSync4(dirname3(gitignoreAbs), { recursive: true });
-  writeFileSync3(gitignoreAbs, ATTACHMENTS_GITIGNORE2, "utf8");
+  writeFileSync3(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
 }
 function resolveReviewGuidelines(worktreePath) {
   const repoAbs = join10(worktreePath, REPO_REVIEW_PATH);
@@ -3786,6 +4092,16 @@ function resolveReviewGuidelines(worktreePath) {
       source: "local"
     };
   }
+  const legacyAbs = join10(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);
   mkdirSync4(dirname3(localAbs), { recursive: true });
   writeFileSync3(localAbs, REVIEW_REQUEST_TEMPLATE, "utf8");
@@ -3808,10 +4124,11 @@ function ensureReviewRequestFile(worktreePath) {
     };
   }
   const localAbs = join10(worktreePath, REVIEW_REQUEST_PATH);
-  const localContent = readTextIfPresent(localAbs);
+  const localContent = readTextIfPresent(localAbs) ?? readTextIfPresent(join10(worktreePath, LEGACY_REVIEW_REQUEST_PATH));
   if (localContent && !shouldRefreshReviewRequestTemplate(localContent)) {
+    const path = existsSync12(localAbs) ? REVIEW_REQUEST_PATH : LEGACY_REVIEW_REQUEST_PATH;
     return {
-      path: REVIEW_REQUEST_PATH,
+      path,
       name: REVIEW_REQUEST_NAME,
       content: localContent,
       source: "local"
@@ -3838,7 +4155,7 @@ function buildReviewRequestAttachment(content, opts) {
   };
 }
 function readExistingReviewRequestFile(worktreePath) {
-  return readTextIfPresent(join10(worktreePath, REPO_REVIEW_PATH)) ?? readTextIfPresent(join10(worktreePath, REVIEW_REQUEST_PATH));
+  return readTextIfPresent(join10(worktreePath, REPO_REVIEW_PATH)) ?? readTextIfPresent(join10(worktreePath, REVIEW_REQUEST_PATH)) ?? readTextIfPresent(join10(worktreePath, LEGACY_REVIEW_REQUEST_PATH));
 }
 async function requestReview(threadRef, send) {
   const from = findThreadByRef(threadRef);
@@ -4082,7 +4399,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;
@@ -4227,14 +4544,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: autoRunAfterSetupEnabled2 } = await import("./app-settings-LZP632KI.js");
     if (autoRunAfterSetupEnabled2()) {
       try {
@@ -4248,6 +4560,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);
@@ -4596,6 +4921,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)
       )) {
@@ -5077,6 +5415,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;
@@ -5139,14 +5553,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) {
@@ -5160,7 +5569,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);
@@ -5234,8 +5643,8 @@ var Orchestrator = class {
       updateThread(thread.id, { worktreePath: globalAgentCwd2() });
       return setStatus(thread.id, "idle");
     }
-    if (!existsSync12(thread.worktreePath)) {
-      const { createThreadWorktree: createThreadWorktree2 } = await import("./worktree-TEDAJ57S.js");
+    if (!existsSync13(thread.worktreePath)) {
+      const { createThreadWorktree: createThreadWorktree2 } = await import("./worktree-RWGL7FUV.js");
       const { execa: execa6 } = await import("execa");
       const slug = thread.worktreePath.split("/").pop();
       const dest = thread.worktreePath;
@@ -5320,7 +5729,7 @@ async function startOrchestration(opts) {
     sourceRef: "default",
     ...createOpts
   }).catch(async () => {
-    const { resolveDefaultBranch: resolveDefaultBranch2, resolveRepoRoot: resolveRepoRoot2 } = await import("./worktree-TEDAJ57S.js");
+    const { resolveDefaultBranch: resolveDefaultBranch2, resolveRepoRoot: resolveRepoRoot2 } = await import("./worktree-RWGL7FUV.js");
     const repo = await resolveRepoRoot2(repoPath);
     const def = await resolveDefaultBranch2(repo);
     return createThread({
@@ -5330,7 +5739,7 @@ async function startOrchestration(opts) {
       repoPath: repo
     });
   });
-  const { updateThread: upd } = await import("./thread-store-OV2X6PYO.js");
+  const { updateThread: upd } = await import("./thread-store-UJIGMI5J.js");
   const updated = upd(thread.id, {
     sourceType: "orchestration",
     sourceRef: goal
@@ -5341,6 +5750,104 @@ async function startOrchestration(opts) {
   return updated;
 }
 
+// src/plan/ask-user.ts
+function asRecord2(v) {
+  return v != null && typeof v === "object" && !Array.isArray(v) ? v : null;
+}
+function parseOptions(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const item of raw) {
+    if (typeof item === "string" && item.trim()) {
+      out.push({ label: item.trim() });
+      continue;
+    }
+    const o = asRecord2(item);
+    if (!o) continue;
+    const label = typeof o.label === "string" ? o.label.trim() : typeof o.text === "string" ? o.text.trim() : typeof o.title === "string" ? o.title.trim() : "";
+    if (!label) continue;
+    const description = typeof o.description === "string" && o.description.trim() ? o.description.trim() : void 0;
+    out.push({ label, description });
+  }
+  return out;
+}
+function parseOneQuestion(raw) {
+  const o = asRecord2(raw);
+  if (!o) return null;
+  const question = typeof o.question === "string" ? o.question.trim() : typeof o.text === "string" ? o.text.trim() : typeof o.prompt === "string" ? o.prompt.trim() : "";
+  if (!question) return null;
+  const options = parseOptions(o.options);
+  if (options.length < 1) return null;
+  const header = typeof o.header === "string" && o.header.trim() ? o.header.trim() : void 0;
+  const multiSelect = Boolean(o.multiSelect ?? o.multi_select);
+  return { question, header, multiSelect, options };
+}
+function parsePlanQuestionsInput(input) {
+  const root = asRecord2(input);
+  if (!root) return [];
+  const list = Array.isArray(root.questions) ? root.questions : Array.isArray(root.question) ? root.question : root.question || root.prompt ? [root] : [];
+  const out = [];
+  for (const item of list) {
+    const q = parseOneQuestion(item);
+    if (q) out.push(q);
+  }
+  return out;
+}
+var ASK_USER_TOOL_RE = /^(AskUserQuestion|ask_user|mcp__sideboard__ask_user)$/i;
+function isAskUserToolName(name) {
+  if (!name) return false;
+  const base = name.replace(/^mcp__sideboard__/i, "");
+  return ASK_USER_TOOL_RE.test(name) || /^ask_user$/i.test(base);
+}
+function extractPendingPlanQuestions(parts) {
+  if (!parts?.length) return null;
+  for (let i = parts.length - 1; i >= 0; i--) {
+    const p = parts[i];
+    if (p.type !== "tool" || !isAskUserToolName(p.name)) continue;
+    const questions = parsePlanQuestionsInput(p.input);
+    if (!questions.length) continue;
+    return {
+      id: p.id || `ask-${i}`,
+      questions,
+      source: p.name || "ask_user"
+    };
+  }
+  return null;
+}
+function formatPlanQuestionAnswers(questions, answers) {
+  const lines = ["Answers to your questions:"];
+  for (let i = 0; i < questions.length; i++) {
+    const q = questions[i];
+    const a = answers.find((x) => x.questionIndex === i);
+    const header = q.header ? `**${q.header}** \u2014 ` : "";
+    const parts = [];
+    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(`   \u2192 ${body}`);
+  }
+  return lines.join("\n");
+}
+function formatPlanQuestionsForChat(questions) {
+  const lines = ["### Questions for you", ""];
+  for (let i = 0; i < questions.length; i++) {
+    const q = questions[i];
+    const header = q.header ? `**${q.header}** \u2014 ` : "";
+    lines.push(`${i + 1}. ${header}${q.question}`);
+    for (let oi = 0; oi < q.options.length; oi++) {
+      const opt = q.options[oi];
+      const desc = opt.description?.trim();
+      lines.push(
+        desc ? `   - **${opt.label}** \u2014 ${desc}` : `   - **${opt.label}**`
+      );
+    }
+    lines.push("");
+  }
+  lines.push("_Answer in the composer below._");
+  return lines.join("\n").trimEnd();
+}
+
 // src/mcp/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -5452,6 +5959,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-6O7G4VPQ.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.",
@@ -6030,6 +6590,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.",
@@ -6383,6 +7063,7 @@ async function runCloudConnect(opts) {
   }
 }
 export {
+  ATTACHMENTS_DIR,
   BRIGHTSY_MCP_ALLOWED_TOOLS,
   BrightsySideboardApi,
   CLAUDE_MODEL_CATALOG,
@@ -6398,11 +7079,16 @@ export {
   FAMOUS_SOCCER_TEAMS,
   GLOBAL_WORKSPACE_ID,
   HARNESS_ENV_KEYS,
+  LEGACY_ATTACHMENTS_DIR,
+  LEGACY_PLAN_FILE_REL,
+  LEGACY_REVIEW_REQUEST_PATH,
   MAX_ANTHROPIC_CACHE_CONTROL_BLOCKS,
   ORCHESTRATOR_AGENT_KINDS,
   Orchestrator,
   PASTE_ATTACH_MIN_CHARS,
   PASTE_ATTACH_MIN_LINES,
+  PLAN_FILE_NAME,
+  PLAN_FILE_REL,
   PLAN_MODE_INSTRUCTION,
   REPO_REVIEW_NAME,
   REPO_REVIEW_PATH,
@@ -6412,6 +7098,8 @@ export {
   SIDEBOARD_FORCE_STOP,
   SIDEBOARD_MCP_ALLOWED_TOOLS,
   THINKING_EFFORTS,
+  addPrStackLayer,
+  addStackLayerFromThread,
   addWorkspace,
   adoptThread,
   allAdapters,
@@ -6430,6 +7118,7 @@ export {
   attachmentFromAbsolutePath,
   attachmentsFromBuffers,
   attachmentsFromWorktreePaths,
+  attachmentsGitignoreBody,
   autoCleanupOrphansEnabled,
   autoRenameBranchEnabled,
   autoRunAfterSetupEnabled,
@@ -6452,6 +7141,7 @@ export {
   caffeinateWhileRunningEnabled,
   captureLoginEnv,
   captureTurnBaseline,
+  checkoutPrStackLayer,
   childEnvWithAppSettings,
   claudeAdapter,
   claudeChromeEnabled,
@@ -6471,8 +7161,10 @@ export {
   countCacheControlBlocks,
   createChatTab,
   createEmptyThread,
+  createExistingBranchWorktree,
   createGlobalChat,
   createOrUpdatePr,
+  createPrStack,
   createThread,
   createThreadWorktree,
   currentBranch,
@@ -6482,6 +7174,7 @@ export {
   deleteBranchOnPurgeEnabled,
   deleteThreadRecord,
   detectAgents,
+  detectGhStack,
   detectLocalMergeConflicts,
   disconnectBrightsyTeam,
   discoverSkills,
@@ -6497,12 +7190,15 @@ export {
   estimateThreadChars,
   expandComposerPrompt,
   extractGhErrorDetail,
+  extractPendingPlanQuestions,
+  extractPresentedPlan,
   extractiveSummary,
   fetchPrHead,
   finalizeParts,
   findInvalidCacheControlTtlOrder,
   findOrphanWorktrees,
   findThreadByRef,
+  findThreadForStackLayer,
   flattenTurnInput,
   forkChatTab,
   forkMessageSlice,
@@ -6513,6 +7209,8 @@ export {
   formatGhLandError,
   formatIpcInvokeError,
   formatMessagesAsTranscript,
+  formatPlanQuestionAnswers,
+  formatPlanQuestionsForChat,
   formatRateLimitResetHint,
   formatRenameBranchDirective,
   formatTranscriptMarkdown,
@@ -6536,6 +7234,7 @@ export {
   getPrChecks,
   getPrDetails,
   getPrMeta,
+  getPrStack,
   getRepoSetupInfo,
   getRunMode,
   getRunScript,
@@ -6552,9 +7251,12 @@ export {
   healOrchestrationSoccerTitles,
   importConductorWorkspace,
   importConductorWorkspaceAsync,
+  initPrStack,
+  initStackFromThread,
   initializeGitRepository,
   inspectGitWorktree,
   installAgent,
+  isAskUserToolName,
   isBrightsyConnected,
   isBrightsyNdjsonLine,
   isCloudCoordinatorThread,
@@ -6564,13 +7266,17 @@ export {
   isGlobalRepoPath,
   isGlobalThread,
   isImageFilePath,
+  isInPrStack,
   isLinearConnected,
   isOrchestratorCapableAgent,
   isOrchestratorThread,
   isPidAlive,
   isPlaceholderBranch,
+  isPresentPlanToolName,
   isSessionQuotaLimit,
+  isSideboardScratchPath,
   isThinkingEffort,
+  isWorkspaceScratchPath,
   listAgentSetupInfo,
   listBranchCommits,
   listBranches,
@@ -6607,6 +7313,7 @@ export {
   mcpAllowTools,
   mcpAuthWarnings,
   mergePr,
+  mergePrStack,
   mergeUsage,
   nextPastedTextName,
   nextThinkingEffort,
@@ -6616,6 +7323,8 @@ export {
   normalizeTurnInput,
   normalizeWorktreePath,
   openInSystemTerminal,
+  openPrStackLayers,
+  openStackLayer,
   opencodeAdapter,
   orchestrationQuotaFallbackAgent,
   orchestrationQuotaOnLimit,
@@ -6624,15 +7333,19 @@ export {
   originGhRepoEnv,
   parseCursorRunnerLine,
   parseForceStopMessage,
+  parseGhStackViewJson,
   parseGithubSlugFromRemoteUrl,
   parseMcpList,
+  parsePlanQuestionsInput,
   parseSessionQuotaResetAt,
   partsToAssistantText,
   pastedTextStats,
   permissionMode,
+  planFileAbs,
   previewLand,
   pushBranch,
   readExistingReviewRequestFile,
+  readPlanFile,
   readSkillBody,
   readThread,
   readWorktreeFile,
@@ -6644,6 +7357,7 @@ export {
   repoSlug,
   requestReview,
   requireAgent,
+  resetGhStackDetectCache,
   resolveClaudeExecutable,
   resolveConductorCursorAgentId,
   resolveCursorModelId,
@@ -6651,7 +7365,9 @@ export {
   resolveDiffBaseRef,
   resolveEffectiveIssueSource,
   resolveFilesToCopy,
+  resolveGhAuthToken,
   resolveGithubRepoSlug,
+  resolvePlanMarkdown,
   resolvePrSelector,
   resolveQuotaFallbackAgent,
   resolveRepoRoot,
@@ -6679,12 +7395,16 @@ export {
   slugify,
   spawnAgentTurn,
   splitForCompaction,
+  stackAgentDefaultsFrom,
+  stackIdFrom,
+  stackMergeReadiness,
   stageAbsolutePathsAsAttachments,
   stageBuffersAsAttachments,
   startDevServer,
   startMcpServer,
   startOrchestration,
   stripBrightsyNdjsonNoise,
+  submitPrStack,
   suggestSlug,
   summarizeConversation,
   switchBrightsyAccount,
@@ -6720,6 +7440,7 @@ export {
   worktreeNameFromPath,
   worktreesRoot,
   writeInjectedMcpConfig,
+  writePlanFile,
   writeThread,
   writeWorktreeFile
 };