@sideboard-ai/core 0.1.51 → 0.1.52

package/dist/mcp/run-stdio.cjs

@@ -481,6 +481,8 @@ function normalizeThread(raw) {
     agentPid: raw.agentPid ?? null,
     attachments: Array.isArray(raw.attachments) ? raw.attachments : [],
     prTitle: raw.prTitle ?? null,
+    stackId: raw.stackId ?? null,
+    stackLayer: raw.stackLayer ?? null,
     userSetTitle: Boolean(raw.userSetTitle),
     activeRuns: Array.isArray(raw.activeRuns) ? raw.activeRuns : [],
     quotaResumeAt: raw.quotaResumeAt ?? null,
@@ -505,6 +507,8 @@ function createEmptyThread(partial) {
     activeRuns: partial.activeRuns ?? [],
     prUrl: partial.prUrl ?? null,
     prTitle: partial.prTitle ?? null,
+    stackId: partial.stackId ?? null,
+    stackLayer: partial.stackLayer ?? null,
     userSetTitle: partial.userSetTitle ?? false,
     messages: partial.messages ?? [],
     attachments: partial.attachments ?? [],
@@ -1688,6 +1692,206 @@ var init_pr_gates = __esm({
   }
 });
 
+// src/git/stack.ts
+async function detectGhStack(cwd) {
+  const now = Date.now();
+  if (cachedStatus && now - cachedStatus.at < STATUS_TTL_MS) {
+    return cachedStatus.status;
+  }
+  const probe = await gh(["stack", "view", "--help"], cwd, { reject: false });
+  if (probe.exitCode === 0) {
+    const status2 = { available: true };
+    cachedStatus = { at: now, status: status2 };
+    return status2;
+  }
+  const err = `${probe.stderr}
+${probe.stdout}`;
+  const reason = /official extension|extension install|github\/gh-stack/i.test(err) ? "Install with: gh extension install github/gh-stack" : err.trim() || "gh stack is not available";
+  const status = { available: false, reason };
+  cachedStatus = { at: now, status };
+  return status;
+}
+function str(v) {
+  return typeof v === "string" ? v : v == null ? "" : String(v);
+}
+function num(v) {
+  if (typeof v === "number" && Number.isFinite(v)) return v;
+  if (typeof v === "string" && v.trim() && Number.isFinite(Number(v))) {
+    return Number(v);
+  }
+  return null;
+}
+function parseGhStackViewJson(raw) {
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!Array.isArray(data.branches) || data.branches.length === 0) return null;
+  const trunk = str(data.trunk) || "main";
+  const currentBranch2 = str(data.currentBranch);
+  const stackNumber = num(data.stackNumber) ?? num(data.number);
+  const layers = [];
+  for (let i = 0; i < data.branches.length; i++) {
+    const b = data.branches[i];
+    if (!b || typeof b !== "object") continue;
+    const name = str(b.name);
+    if (!name) continue;
+    const pr = b.pr && typeof b.pr === "object" ? b.pr : null;
+    layers.push({
+      position: i + 1,
+      branchName: name,
+      headSha: str(b.head) || void 0,
+      baseSha: str(b.base) || void 0,
+      isCurrent: Boolean(b.isCurrent) || name === currentBranch2,
+      isMerged: Boolean(b.isMerged),
+      isQueued: Boolean(b.isQueued),
+      needsRebase: Boolean(b.needsRebase),
+      prNumber: pr ? num(pr.number) : null,
+      prUrl: pr && str(pr.url) ? str(pr.url) : null,
+      prState: pr && str(pr.state) ? str(pr.state).toUpperCase() : null,
+      title: pr && str(pr.title) ? str(pr.title) : void 0
+    });
+  }
+  if (!layers.length) return null;
+  let currentIndex = layers.findIndex((l) => l.isCurrent);
+  if (currentIndex < 0 && currentBranch2) {
+    currentIndex = layers.findIndex((l) => l.branchName === currentBranch2);
+  }
+  const { readyToMerge, blockedReason } = stackMergeReadiness(layers, currentIndex);
+  return {
+    stackNumber,
+    trunk,
+    currentBranch: currentBranch2 || layers[currentIndex]?.branchName || layers[0].branchName,
+    layers,
+    currentIndex,
+    readyToMerge,
+    blockedReason
+  };
+}
+function stackMergeReadiness(layers, throughIndex) {
+  if (throughIndex < 0 || throughIndex >= layers.length) {
+    return { readyToMerge: false, blockedReason: "Not on a stack layer" };
+  }
+  for (let i = 0; i <= throughIndex; i++) {
+    const layer = layers[i];
+    if (layer.isMerged) continue;
+    if (!layer.prNumber) {
+      return {
+        readyToMerge: false,
+        blockedReason: `Layer ${layer.branchName} has no pull request yet`
+      };
+    }
+    if (layer.needsRebase) {
+      return {
+        readyToMerge: false,
+        blockedReason: `PR #${layer.prNumber} needs rebase`
+      };
+    }
+    const state = (layer.prState ?? "").toUpperCase();
+    if (state && state !== "OPEN" && state !== "QUEUED") {
+      return {
+        readyToMerge: false,
+        blockedReason: `PR #${layer.prNumber} is ${state}`
+      };
+    }
+  }
+  return { readyToMerge: true, blockedReason: null };
+}
+async function getPrStack(cwd) {
+  const status = await detectGhStack(cwd);
+  if (!status.available) return null;
+  const result = await gh(["stack", "view", "--json"], cwd, { reject: false });
+  if (result.exitCode === 2) return null;
+  if (result.exitCode !== 0) {
+    if (/not in a stack|no stack/i.test(`${result.stderr}
+${result.stdout}`)) {
+      return null;
+    }
+    if (result.exitCode === 9) return null;
+    return null;
+  }
+  const json = result.stdout.trim();
+  if (!json) return null;
+  return parseGhStackViewJson(json);
+}
+async function mergePrStack(cwd, opts) {
+  const status = await detectGhStack(cwd);
+  if (!status.available) {
+    throw new Error(status.reason);
+  }
+  const method = opts.method ?? "squash";
+  const methodFlag = method === "rebase" ? "--rebase" : method === "merge" ? "--merge" : "--squash";
+  const args = [
+    "stack",
+    "merge",
+    String(opts.through),
+    "--yes",
+    methodFlag
+  ];
+  const { exitCode, stderr, stdout } = await gh(args, cwd, { reject: false });
+  if (exitCode !== 0) {
+    throw new Error(stderr.trim() || stdout.trim() || "gh stack merge failed");
+  }
+  return { stdout };
+}
+async function initPrStack(cwd, branches, opts) {
+  if (!branches.length) throw new Error("initPrStack requires at least one branch name");
+  const status = await detectGhStack(cwd);
+  if (!status.available) throw new Error(status.reason);
+  const args = ["stack", "init"];
+  if (opts?.base) args.push("--base", opts.base);
+  args.push(...branches);
+  const { exitCode, stderr, stdout } = await gh(args, cwd, { reject: false });
+  if (exitCode !== 0) {
+    throw new Error(stderr.trim() || stdout.trim() || "gh stack init failed");
+  }
+}
+async function addPrStackLayer(cwd, branchName) {
+  if (!branchName.trim()) throw new Error("branch name required");
+  const status = await detectGhStack(cwd);
+  if (!status.available) throw new Error(status.reason);
+  const { exitCode, stderr, stdout } = await gh(
+    ["stack", "add", branchName.trim()],
+    cwd,
+    { reject: false }
+  );
+  if (exitCode !== 0) {
+    throw new Error(stderr.trim() || stdout.trim() || "gh stack add failed");
+  }
+}
+var cachedStatus, STATUS_TTL_MS;
+var init_stack = __esm({
+  "src/git/stack.ts"() {
+    "use strict";
+    init_run();
+    cachedStatus = null;
+    STATUS_TTL_MS = 6e4;
+  }
+});
+
+// src/paths/workspace-scratch.ts
+function attachmentsGitignoreBody() {
+  return ATTACHMENTS_GITIGNORE;
+}
+function isWorkspaceScratchPath(relativePath) {
+  const p = relativePath.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/$/, "");
+  return p === ATTACHMENTS_DIR || p.startsWith(`${ATTACHMENTS_DIR}/`) || p === LEGACY_ATTACHMENTS_DIR || p.startsWith(`${LEGACY_ATTACHMENTS_DIR}/`) || p === ".context" || p.startsWith(".context/");
+}
+var ATTACHMENTS_DIR, LEGACY_ATTACHMENTS_DIR, ATTACHMENTS_GITIGNORE;
+var init_workspace_scratch = __esm({
+  "src/paths/workspace-scratch.ts"() {
+    "use strict";
+    ATTACHMENTS_DIR = ".context/attachments";
+    LEGACY_ATTACHMENTS_DIR = ".sideboard/attachments";
+    ATTACHMENTS_GITIGNORE = `# Sideboard / workspace attachments (local only)
+*
+!.gitignore
+`;
+  }
+});
+
 // src/git/worktree.ts
 var worktree_exports = {};
 __export(worktree_exports, {
@@ -1697,6 +1901,7 @@ __export(worktree_exports, {
   branchDisplayLabel: () => branchDisplayLabel,
   collectTakenTeamSlugs: () => collectTakenTeamSlugs,
   commitAll: () => commitAll,
+  createExistingBranchWorktree: () => createExistingBranchWorktree,
   createOrUpdatePr: () => createOrUpdatePr,
   createThreadWorktree: () => createThreadWorktree,
   currentBranch: () => currentBranch,
@@ -2410,6 +2615,52 @@ ${add.stdout}`;
   await ensureGhPreferOrigin(worktreePath);
   return { branchName, worktreePath };
 }
+async function createExistingBranchWorktree(opts) {
+  const branchName = opts.branchName.trim();
+  if (!branchName) throw new Error("branch name required");
+  const worktreePath = (0, import_node_path5.join)(worktreesRoot(opts.repoPath), opts.slug);
+  if ((0, import_node_fs4.existsSync)(worktreePath)) {
+    throw new Error(`Worktree already exists at ${worktreePath}`);
+  }
+  await ensureGhPreferOrigin(opts.repoPath);
+  await git(["fetch", "origin", "--prune"], opts.repoPath, { reject: false });
+  if (!branchName.startsWith("origin/") && !branchName.startsWith("refs/")) {
+    await git(["fetch", "origin", branchName], opts.repoPath, { reject: false });
+  }
+  const existing = await listWorktrees(opts.repoPath);
+  const already = existing.find((w) => w.branch === branchName);
+  if (already?.path) {
+    throw new Error(
+      `Branch ${branchName} is already checked out at ${already.path}`
+    );
+  }
+  const startPoint = await resolveWorktreeStartPoint(opts.repoPath, branchName);
+  const add = await git(
+    ["worktree", "add", worktreePath, startPoint],
+    opts.repoPath,
+    { reject: false }
+  );
+  if (add.exitCode !== 0) {
+    const retry = await git(
+      ["worktree", "add", worktreePath, branchName],
+      opts.repoPath,
+      { reject: false }
+    );
+    if (retry.exitCode !== 0) {
+      throw new Error(
+        `Failed to create worktree for ${branchName}: ${retry.stderr.trim() || add.stderr.trim() || retry.stdout.trim() || add.stdout.trim() || `exit ${add.exitCode}`}`
+      );
+    }
+  }
+  const head = await git(["rev-parse", "--abbrev-ref", "HEAD"], worktreePath, {
+    reject: false
+  });
+  if (head.stdout.trim() === "HEAD" || head.stdout.trim() !== branchName) {
+    await git(["checkout", "-B", branchName], worktreePath, { reject: false });
+  }
+  await ensureGhPreferOrigin(worktreePath);
+  return { branchName, worktreePath };
+}
 async function removeWorktree(repoPath, worktreePath, opts) {
   await git(["worktree", "remove", "--force", worktreePath], repoPath, {
     reject: false
@@ -2449,8 +2700,7 @@ async function isDirty(worktreePath) {
   return false;
 }
 function isSideboardScratchPath(relativePath) {
-  const p = relativePath.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/$/, "");
-  return p === ".sideboard/attachments" || p.startsWith(".sideboard/attachments/");
+  return isWorkspaceScratchPath(relativePath);
 }
 function porcelainStatusPath(line) {
   const rest = line.length >= 3 ? line.slice(3) : "";
@@ -2478,7 +2728,7 @@ async function pushBranch(worktreePath, branchName) {
 }
 async function mergePr(cwd, selector, opts) {
   const slug = await resolveGithubRepoSlug(cwd);
-  const viewArgs = ["pr", "view", selector, "--json", "url,state,isDraft"];
+  const viewArgs = ["pr", "view", selector, "--json", "url,state,isDraft,number"];
   if (slug) viewArgs.push("--repo", slug);
   const before = await gh(viewArgs, cwd, { reject: false });
   if (before.exitCode !== 0 || !before.stdout.trim()) {
@@ -2486,16 +2736,29 @@ async function mergePr(cwd, selector, opts) {
   }
   let url = "";
   let isDraft = false;
+  let prNumber = null;
   try {
     const parsed = JSON.parse(before.stdout);
     url = String(parsed.url ?? "");
     isDraft = Boolean(parsed.isDraft);
+    prNumber = typeof parsed.number === "number" && Number.isFinite(parsed.number) ? parsed.number : null;
     if (String(parsed.state ?? "").toUpperCase() === "MERGED") {
       return { url, state: "MERGED" };
     }
   } catch {
     throw new Error("Could not parse pull request details");
   }
+  const stack = await getPrStack(cwd);
+  const stackLayer = stack && prNumber != null ? stack.layers.find((l) => l.prNumber === prNumber) : null;
+  if (stack && stackLayer && prNumber != null) {
+    const throughIndex = stack.layers.findIndex((l) => l.prNumber === prNumber);
+    const gate = stackMergeReadiness(stack.layers, throughIndex);
+    if (!gate.readyToMerge) {
+      throw new Error(gate.blockedReason || "Stack is not ready to merge");
+    }
+    await mergePrStack(cwd, { through: prNumber, method: opts?.method ?? "squash" });
+    return { url, state: "MERGED" };
+  }
   if (isDraft) {
     const readyArgs = ["pr", "ready", selector];
     if (slug) readyArgs.push("--repo", slug);
@@ -2517,10 +2780,10 @@ async function mergePr(cwd, selector, opts) {
   const after = await gh(viewArgs, cwd, { reject: false });
   if (after.exitCode === 0 && after.stdout.trim()) {
     try {
-      const parsed = JSON.parse(after.stdout);
+      const parsed = after.stdout ? JSON.parse(after.stdout) : null;
       return {
-        url: String(parsed.url ?? url),
-        state: String(parsed.state ?? "MERGED")
+        url: String(parsed?.url ?? url),
+        state: String(parsed?.state ?? "MERGED")
       };
     } catch {
     }
@@ -2668,7 +2931,9 @@ var init_worktree = __esm({
     init_gh_errors();
     init_run();
     init_pr_gates();
+    init_stack();
     init_teams();
+    init_workspace_scratch();
     init_worktree_labels();
   }
 });
@@ -3346,6 +3611,7 @@ var init_coordinator_prompt = __esm({
       "Discover:",
       "- list_workspaces \u2014 registered repos (path + github slug when known)",
       "- list_branches / list_prs / list_issues \u2014 pass repoPath from list_workspaces (issues: Linear API or GitHub Issues)",
+      "- get_pr_stack / open_pr_stack_layers / add_stack_layer / create_pr_stack \u2014 GitHub stacked PRs (`gh stack`); one worktree per layer",
       "- list_models \u2014 only when you need a specific model (rare); otherwise leave model unset = Auto",
       "- list_threads / get_thread \u2014 fleet status (what is going on)",
       "Workspaces:",
@@ -4331,7 +4597,9 @@ var init_injected_mcp = __esm({
     SIDEBOARD_ARTIFACT_MCP_ALLOWED_TOOLS = [
       "mcp__sideboard__present_artifact",
       "mcp__sideboard__present_schema",
-      "mcp__sideboard__present_files"
+      "mcp__sideboard__present_files",
+      "mcp__sideboard__ask_user",
+      "mcp__sideboard__present_plan"
     ];
     brightsyMcpCommandCache = null;
   }
@@ -4370,7 +4638,7 @@ var PLAN_MODE_INSTRUCTION;
 var init_types = __esm({
   "src/agents/types.ts"() {
     "use strict";
-    PLAN_MODE_INSTRUCTION = "Plan mode is active and must remain active until the user turns Plan mode off in the UI (or explicitly asks you to implement). Analyze the codebase, search and read files as needed, and produce or refine a clear implementation plan. Do not modify, create, or delete any files. Do not exit plan mode on your own.";
+    PLAN_MODE_INSTRUCTION = "Plan mode is active and must remain active until the user turns Plan mode off in the UI (or Approves / Hands off the plan). Analyze the codebase, search and read files as needed, and produce or refine a clear implementation plan. Do not modify, create, or delete any project files except via Sideboard MCP present_plan (writes .context/attachments/plan.md). When you need a clarifying decision (approach forks, auth choice, scope): (1) first write a short chat message that explains the decision and what each option means (tradeoffs, when to pick it) \u2014 do not leave the user staring at bare labels; (2) then call Sideboard MCP ask_user with the same options, including a description on every option. Sideboard shows questions in the composer and mirrors them in chat. After ask_user, wait for the user's next message with their answers before finalizing the plan. When the plan is ready for approval: (1) call present_plan with the full markdown plan (title + content) so Sideboard saves .context/attachments/plan.md and shows it in chat for Approve / Hand off / Copy; (2) Claude should also call ExitPlanMode after present_plan. Do not skip present_plan \u2014 the plan must be a markdown file, not only chat prose.";
   }
 });
 
@@ -6078,6 +6346,116 @@ var init_workspaces = __esm({
   }
 });
 
+// src/plan/plan-present.ts
+function asRecord2(v) {
+  return v != null && typeof v === "object" && !Array.isArray(v) ? v : null;
+}
+function isPresentPlanToolName(name) {
+  if (!name) return false;
+  return /present_plan$/i.test(name) || /^mcp__sideboard__present_plan$/i.test(name);
+}
+function extractPresentedPlan(parts) {
+  if (!parts?.length) return null;
+  for (let i = parts.length - 1; i >= 0; i--) {
+    const p = parts[i];
+    if (p.type !== "tool" || !isPresentPlanToolName(p.name)) continue;
+    const input = asRecord2(p.input) ?? {};
+    const content = typeof input.content === "string" ? input.content : typeof input.plan === "string" ? input.plan : typeof input.markdown === "string" ? input.markdown : "";
+    if (!content.trim()) continue;
+    const title = typeof input.title === "string" && input.title.trim() ? input.title.trim() : "Plan";
+    const path = typeof input.path === "string" && input.path.trim() ? input.path.trim() : PLAN_FILE_REL;
+    return { title, content: content.trim(), path, source: "present_plan" };
+  }
+  return null;
+}
+function resolvePlanMarkdown(opts) {
+  const fromTool = extractPresentedPlan(opts.parts);
+  if (fromTool) return fromTool;
+  const file = opts.fileContent?.trim();
+  if (file) {
+    return {
+      title: "Plan",
+      content: file,
+      path: PLAN_FILE_REL,
+      source: "exit_plan"
+    };
+  }
+  const text = opts.text?.trim();
+  if (text && text.length >= 80) {
+    return {
+      title: "Plan",
+      content: text,
+      path: PLAN_FILE_REL,
+      source: "text"
+    };
+  }
+  return null;
+}
+var PLAN_FILE_REL, PLAN_FILE_NAME, LEGACY_PLAN_FILE_REL;
+var init_plan_present = __esm({
+  "src/plan/plan-present.ts"() {
+    "use strict";
+    init_workspace_scratch();
+    PLAN_FILE_REL = `${ATTACHMENTS_DIR}/plan.md`;
+    PLAN_FILE_NAME = "plan.md";
+    LEGACY_PLAN_FILE_REL = ".sideboard/plan.md";
+  }
+});
+
+// src/plan/plan-file.ts
+var plan_file_exports = {};
+__export(plan_file_exports, {
+  LEGACY_PLAN_FILE_REL: () => LEGACY_PLAN_FILE_REL,
+  PLAN_FILE_NAME: () => PLAN_FILE_NAME,
+  PLAN_FILE_REL: () => PLAN_FILE_REL,
+  extractPresentedPlan: () => extractPresentedPlan,
+  isPresentPlanToolName: () => isPresentPlanToolName,
+  planFileAbs: () => planFileAbs,
+  readPlanFile: () => readPlanFile,
+  resolvePlanMarkdown: () => resolvePlanMarkdown,
+  writePlanFile: () => writePlanFile
+});
+function ensureAttachmentsGitignore2(worktreePath) {
+  const gitignoreAbs = (0, import_node_path24.join)(worktreePath, ATTACHMENTS_DIR, ".gitignore");
+  if ((0, import_node_fs26.existsSync)(gitignoreAbs)) return;
+  (0, import_node_fs26.mkdirSync)((0, import_node_path24.dirname)(gitignoreAbs), { recursive: true });
+  (0, import_node_fs26.writeFileSync)(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
+}
+function planFileAbs(worktreePath) {
+  return (0, import_node_path24.join)(worktreePath, PLAN_FILE_REL);
+}
+function readTextIfPresent2(abs) {
+  if (!(0, import_node_fs26.existsSync)(abs)) return null;
+  try {
+    const content = (0, import_node_fs26.readFileSync)(abs, "utf8");
+    return content.trim() ? content : null;
+  } catch {
+    return null;
+  }
+}
+function readPlanFile(worktreePath) {
+  return readTextIfPresent2(planFileAbs(worktreePath)) ?? readTextIfPresent2((0, import_node_path24.join)(worktreePath, `${LEGACY_ATTACHMENTS_DIR}/plan.md`)) ?? readTextIfPresent2((0, import_node_path24.join)(worktreePath, LEGACY_PLAN_FILE_REL));
+}
+function writePlanFile(worktreePath, content) {
+  ensureAttachmentsGitignore2(worktreePath);
+  const abs = planFileAbs(worktreePath);
+  (0, import_node_fs26.mkdirSync)((0, import_node_path24.dirname)(abs), { recursive: true });
+  const body = content.trimEnd() + (content.endsWith("\n") ? "" : "\n");
+  (0, import_node_fs26.writeFileSync)(abs, body, "utf8");
+  return PLAN_FILE_REL;
+}
+var import_node_fs26, import_node_path24;
+var init_plan_file = __esm({
+  "src/plan/plan-file.ts"() {
+    "use strict";
+    import_node_fs26 = require("fs");
+    import_node_path24 = require("path");
+    init_workspace_scratch();
+    init_plan_present();
+    init_plan_present();
+  }
+});
+
 // src/agents/cursor-recover.ts
 var cursor_recover_exports = {};
 __export(cursor_recover_exports, {
@@ -6086,10 +6464,10 @@ __export(cursor_recover_exports, {
 function recoverFinishedCursorRun(opts) {
   const agentId = opts.agentId.trim();
   if (!agentId) return null;
-  const runsPath = (0, import_node_path24.join)(appDataDir(), "cursor-sdk-store", "runs.ndjson");
-  if (!(0, import_node_fs25.existsSync)(runsPath)) return null;
+  const runsPath = (0, import_node_path25.join)(appDataDir(), "cursor-sdk-store", "runs.ndjson");
+  if (!(0, import_node_fs27.existsSync)(runsPath)) return null;
   try {
-    const lines = (0, import_node_fs25.readFileSync)(runsPath, "utf8").split("\n");
+    const lines = (0, import_node_fs27.readFileSync)(runsPath, "utf8").split("\n");
     let best = null;
     for (const line of lines) {
       const trimmed = line.trim();
@@ -6115,12 +6493,12 @@ function recoverFinishedCursorRun(opts) {
     return null;
   }
 }
-var import_node_fs25, import_node_path24;
+var import_node_fs27, import_node_path25;
 var init_cursor_recover = __esm({
   "src/agents/cursor-recover.ts"() {
     "use strict";
-    import_node_fs25 = require("fs");
-    import_node_path24 = require("path");
+    import_node_fs27 = require("fs");
+    import_node_path25 = require("path");
     init_paths();
   }
 });
@@ -6129,11 +6507,11 @@ var init_cursor_recover = __esm({
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 var import_zod = require("zod");
-var import_node_path25 = require("path");
+var import_node_path26 = require("path");
 
 // src/orchestrator/orchestrator.ts
 var import_node_events = require("events");
-var import_node_fs26 = require("fs");
+var import_node_fs28 = require("fs");
 init_error_detail();
 
 // src/agents/spawn.ts
@@ -6153,18 +6531,18 @@ function asRecord(input) {
   }
   return void 0;
 }
-function str(v) {
+function str2(v) {
   return typeof v === "string" && v.trim() ? v : void 0;
 }
 function toolDetail(name, input) {
   if (!input) return void 0;
-  const command = str(input.command) ?? str(input.cmd);
+  const command = str2(input.command) ?? str2(input.cmd);
   if (command) return command;
-  const path = str(input.file_path) ?? str(input.path) ?? str(input.filePath) ?? str(input.filename);
+  const path = str2(input.file_path) ?? str2(input.path) ?? str2(input.filePath) ?? str2(input.filename);
   if (path) return path;
-  const pattern = str(input.pattern) ?? str(input.glob) ?? str(input.glob_pattern);
+  const pattern = str2(input.pattern) ?? str2(input.glob) ?? str2(input.glob_pattern);
   if (pattern) return pattern;
-  const query = str(input.query) ?? str(input.prompt);
+  const query = str2(input.query) ?? str2(input.prompt);
   if (query) return query.length > 80 ? `${query.slice(0, 77)}\u2026` : query;
   try {
     const raw = JSON.stringify(input);
@@ -6177,23 +6555,26 @@ function toolDescription(name, input) {
   const n = name.replace(/^mcp__/, "").replace(/__/g, " \xB7 ");
   if (/^get_record_types$|recordTypes/i.test(name)) return "List record types";
   if (/connectedAgentRequest/i.test(name)) {
-    return str(input?.agent_id) ? `Ask connected agent` : "Ask connected agent";
+    return str2(input?.agent_id) ? `Ask connected agent` : "Ask connected agent";
   }
   if (/present_artifact$/i.test(name)) {
-    return str(input?.title) ? `Present ${str(input?.title)}` : "Present artifact";
+    return str2(input?.title) ? `Present ${str2(input?.title)}` : "Present artifact";
+  }
+  if (/present_plan$/i.test(name)) {
+    return str2(input?.title) ? `Plan ${str2(input?.title)}` : "Present plan";
   }
   if (/present_schema$/i.test(name)) {
-    return str(input?.title) ? `Schema ${str(input?.title)}` : "Present schema";
+    return str2(input?.title) ? `Schema ${str2(input?.title)}` : "Present schema";
   }
   if (/present_files$/i.test(name)) {
-    return str(input?.title) ? `Files ${str(input?.title)}` : "Present files";
+    return str2(input?.title) ? `Files ${str2(input?.title)}` : "Present files";
   }
   if (/^(create|update)_artifact$/i.test(name.replace(/^mcp__[^_]+__/, ""))) {
-    return str(input?.title) ? `Artifact ${str(input?.title)}` : "Artifact";
+    return str2(input?.title) ? `Artifact ${str2(input?.title)}` : "Artifact";
   }
   if (!input) return n;
-  if (/bash|shell|terminal/i.test(name) && str(input.command)) {
-    const cmd = str(input.command);
+  if (/bash|shell|terminal/i.test(name) && str2(input.command)) {
+    const cmd = str2(input.command);
     if (/git\s+fetch/i.test(cmd)) return "Fetch latest from origin and check status";
     if (/git\s+status/i.test(cmd)) return "Check git status";
     if (/git\s+log/i.test(cmd)) return "Inspect recent commits";
@@ -6202,11 +6583,11 @@ function toolDescription(name, input) {
     return "Run shell command";
   }
   if (/edit|write|apply/i.test(name)) {
-    const path = str(input.file_path) ?? str(input.path);
+    const path = str2(input.file_path) ?? str2(input.path);
     return path ? `Edit ${path.split("/").pop()}` : "Edit file";
   }
   if (/read/i.test(name)) {
-    const path = str(input.file_path) ?? str(input.path);
+    const path = str2(input.file_path) ?? str2(input.path);
     return path ? `Read ${path.split("/").pop()}` : "Read file";
   }
   if (/grep/i.test(name)) return "Search files";
@@ -6215,7 +6596,7 @@ function toolDescription(name, input) {
 }
 function toolFilePath(input) {
   if (!input) return void 0;
-  return str(input.file_path) ?? str(input.path) ?? str(input.filePath) ?? str(input.filename);
+  return str2(input.file_path) ?? str2(input.path) ?? str2(input.filePath) ?? str2(input.filename);
 }
 function countLines(text) {
   if (!text) return 0;
@@ -6223,8 +6604,8 @@ function countLines(text) {
 }
 function diffFromInput(input) {
   if (!input) return {};
-  const oldS = str(input.old_string) ?? str(input.oldString);
-  const newS = str(input.new_string) ?? str(input.newString) ?? str(input.content);
+  const oldS = str2(input.old_string) ?? str2(input.oldString);
+  const newS = str2(input.new_string) ?? str2(input.newString) ?? str2(input.content);
   if (oldS != null || newS != null) {
     return {
       additions: countLines(newS),
@@ -6486,6 +6867,7 @@ async function spawnAgentTurn(thread, input, onEvent) {
 // src/orchestrator/orchestrator.ts
 init_agents();
 init_worktree();
+init_stack();
 
 // src/hook/conductor.ts
 var import_node_fs13 = require("fs");
@@ -7121,7 +7503,7 @@ async function requireAgent(agent, opts) {
 init_worktree();
 init_thread_store();
 init_workspaces();
-async function createThread(input, onSetupLine) {
+async function createThread(input, _onSetupLine) {
   await requireAgent(input.agent);
   const repoPath = await resolveRepoRoot(input.repoPath);
   if (!(0, import_node_fs18.existsSync)(repoPath)) {
@@ -7131,10 +7513,10 @@ async function createThread(input, onSetupLine) {
   let sourceIsFork = false;
   let prUrl = null;
   if (input.sourceType === "pr") {
-    const num = Number(input.sourceRef.replace(/^#/, ""));
-    if (!Number.isFinite(num)) throw new Error(`Invalid PR number: ${input.sourceRef}`);
-    const pr = await getPr(repoPath, num);
-    if (!pr) throw new Error(`PR #${num} not found`);
+    const num2 = Number(input.sourceRef.replace(/^#/, ""));
+    if (!Number.isFinite(num2)) throw new Error(`Invalid PR number: ${input.sourceRef}`);
+    const pr = await getPr(repoPath, num2);
+    if (!pr) throw new Error(`PR #${num2} not found`);
     sourceIsFork = pr.isCrossRepository;
     prUrl = pr.url;
     const localFetchBranch = `sideboard-pr-${pr.number}`;
@@ -7179,22 +7561,6 @@ 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) {
@@ -7526,7 +7892,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) {
@@ -7724,15 +8092,13 @@ File: src/client/frontends/desktop/core/UserData.ts
 `;
 
 // src/review/request-review.ts
+init_workspace_scratch();
 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:"
@@ -7755,10 +8121,10 @@ function readTextIfPresent(abs) {
   }
 }
 function ensureAttachmentsGitignore(worktreePath) {
-  const gitignoreAbs = (0, import_node_path18.join)(worktreePath, ".sideboard", "attachments", ".gitignore");
+  const gitignoreAbs = (0, import_node_path18.join)(worktreePath, ATTACHMENTS_DIR, ".gitignore");
   if ((0, import_node_fs19.existsSync)(gitignoreAbs)) return;
   (0, import_node_fs19.mkdirSync)((0, import_node_path18.dirname)(gitignoreAbs), { recursive: true });
-  (0, import_node_fs19.writeFileSync)(gitignoreAbs, ATTACHMENTS_GITIGNORE, "utf8");
+  (0, import_node_fs19.writeFileSync)(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
 }
 function resolveReviewGuidelines(worktreePath) {
   const repoAbs = (0, import_node_path18.join)(worktreePath, REPO_REVIEW_PATH);
@@ -7781,6 +8147,16 @@ function resolveReviewGuidelines(worktreePath) {
       source: "local"
     };
   }
+  const legacyAbs = (0, import_node_path18.join)(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);
   (0, import_node_fs19.mkdirSync)((0, import_node_path18.dirname)(localAbs), { recursive: true });
   (0, import_node_fs19.writeFileSync)(localAbs, REVIEW_REQUEST_TEMPLATE, "utf8");
@@ -8260,16 +8636,305 @@ async function importConductorWorkspaceAsync(workspaceId) {
   return importConductorWorkspace(workspaceId);
 }
 
+// src/threads/stack-layers.ts
+var import_node_fs21 = require("fs");
+init_run();
+init_stack();
+init_worktree();
+init_thread_store();
+init_workspaces();
+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 && (0, import_node_fs21.existsSync)(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 (!(0, import_node_fs21.existsSync)(repoPath)) throw new Error(`Repo not found: ${repoPath}`);
+  if (!input.branches.length) throw new Error("At least one branch name required");
+  const status = await detectGhStack(repoPath);
+  if (!status.available) throw new Error(status.reason);
+  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) && (0, import_node_fs21.existsSync)(bootstrap.worktreePath)) {
+    try {
+      await removeWorktree(repoPath, bootstrap.worktreePath, {
+        deleteBranch: bootstrap.branchName
+      });
+    } catch {
+    }
+  }
+  return { stack, threads, createdThreadIds };
+}
+
 // src/land/land.ts
 init_worktree();
 
 // src/diff/diff.ts
-var import_node_fs21 = require("fs");
+var import_node_fs22 = require("fs");
 var import_node_path20 = require("path");
 init_run();
 init_worktree();
 async function inspectGitWorktree(worktreePath) {
-  if (!worktreePath || !(0, import_node_fs21.existsSync)(worktreePath)) return "missing_worktree";
+  if (!worktreePath || !(0, import_node_fs22.existsSync)(worktreePath)) return "missing_worktree";
   const check = await git(["rev-parse", "--is-inside-work-tree"], worktreePath, {
     reject: false
   });
@@ -8277,7 +8942,7 @@ async function inspectGitWorktree(worktreePath) {
   return "ok";
 }
 async function initializeGitRepository(worktreePath) {
-  if (!worktreePath || !(0, import_node_fs21.existsSync)(worktreePath)) {
+  if (!worktreePath || !(0, import_node_fs22.existsSync)(worktreePath)) {
     throw new Error("Worktree not found");
   }
   const status = await inspectGitWorktree(worktreePath);
@@ -8573,33 +9238,33 @@ async function getDiff(worktreePath, repoPath, opts) {
   let combinedDiff = "";
   let labelBase = base;
   if (scope === "staged") {
-    const [ns, num, diff] = await Promise.all([
+    const [ns, num2, diff] = await Promise.all([
       git(["diff", "--name-status", "--cached"], worktreePath, { reject: false }),
       git(["diff", "--numstat", "--cached"], worktreePath, { reject: false }),
       git(["diff", "--cached"], worktreePath, { reject: false })
     ]);
     nameStatus = ns.stdout;
-    numstat = num.stdout;
+    numstat = num2.stdout;
     combinedDiff = diff.stdout;
     labelBase = "staged";
   } else if (scope === "unstaged") {
-    const [ns, num, diff] = await Promise.all([
+    const [ns, num2, diff] = await Promise.all([
       git(["diff", "--name-status"], worktreePath, { reject: false }),
       git(["diff", "--numstat"], worktreePath, { reject: false }),
       git(["diff"], worktreePath, { reject: false })
     ]);
     nameStatus = ns.stdout;
-    numstat = num.stdout;
+    numstat = num2.stdout;
     combinedDiff = diff.stdout;
     labelBase = "unstaged";
   } else if (scope === "uncommitted") {
-    const [ns, num, diff] = await Promise.all([
+    const [ns, num2, diff] = await Promise.all([
       git(["diff", "--name-status", "HEAD"], worktreePath, { reject: false }),
       git(["diff", "--numstat", "HEAD"], worktreePath, { reject: false }),
       git(["diff", "HEAD"], worktreePath, { reject: false })
     ]);
     nameStatus = ns.stdout;
-    numstat = num.stdout;
+    numstat = num2.stdout;
     combinedDiff = diff.stdout;
     labelBase = "HEAD";
   } else if (scope === "last_turn") {
@@ -8618,34 +9283,34 @@ async function getDiff(worktreePath, repoPath, opts) {
         scopeStats
       };
     }
-    const [ns, num, diff] = await Promise.all([
+    const [ns, num2, diff] = await Promise.all([
       git(["diff", "--name-status", lastTurnBase], worktreePath, { reject: false }),
       git(["diff", "--numstat", lastTurnBase], worktreePath, { reject: false }),
       git(["diff", lastTurnBase], worktreePath, { reject: false })
     ]);
     nameStatus = ns.stdout;
-    numstat = num.stdout;
+    numstat = num2.stdout;
     combinedDiff = diff.stdout;
     labelBase = "last turn";
   } else if (scope === "commits" && commitSha) {
     const range = `${commitSha}^!`;
-    const [ns, num, diff] = await Promise.all([
+    const [ns, num2, diff] = await Promise.all([
       git(["diff", "--name-status", range], worktreePath, { reject: false }),
       git(["diff", "--numstat", range], worktreePath, { reject: false }),
       git(["diff", range], worktreePath, { reject: false })
     ]);
     nameStatus = ns.stdout;
-    numstat = num.stdout;
+    numstat = num2.stdout;
     combinedDiff = diff.stdout;
     labelBase = commitSha.slice(0, 7);
   } else {
-    const [ns, num, diff] = await Promise.all([
+    const [ns, num2, diff] = await Promise.all([
       git(["diff", "--name-status", mergeBase], worktreePath, { reject: false }),
       git(["diff", "--numstat", mergeBase], worktreePath, { reject: false }),
       git(["diff", mergeBase], worktreePath, { reject: false })
     ]);
     nameStatus = ns.stdout;
-    numstat = num.stdout;
+    numstat = num2.stdout;
     combinedDiff = diff.stdout;
     labelBase = base;
   }
@@ -8715,7 +9380,7 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? DEFAULT_UPLOAD_MAX_BYTES;
   const abs = (0, import_node_path20.join)(worktreePath, relativePath);
-  const st = (0, import_node_fs21.statSync)(abs);
+  const st = (0, import_node_fs22.statSync)(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
@@ -8724,7 +9389,7 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
       `File too large to upload (${st.size} bytes; max ${maxBytes})`
     );
   }
-  const buf = (0, import_node_fs21.readFileSync)(abs);
+  const buf = (0, import_node_fs22.readFileSync)(abs);
   return {
     path: relativePath,
     contentBase64: buf.toString("base64"),
@@ -8735,11 +9400,11 @@ function readWorktreeFile(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? 2e5;
   const abs = (0, import_node_path20.join)(worktreePath, relativePath);
-  const st = (0, import_node_fs21.statSync)(abs);
+  const st = (0, import_node_fs22.statSync)(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
-  const buf = (0, import_node_fs21.readFileSync)(abs);
+  const buf = (0, import_node_fs22.readFileSync)(abs);
   if (isImageRelativePath(relativePath)) {
     const maxImageBytes = Math.max(maxBytes, 15e6);
     const truncated2 = buf.length > maxImageBytes;
@@ -8783,8 +9448,8 @@ function assertSafeRelativePath(relativePath) {
 function writeWorktreeFile(worktreePath, relativePath, content) {
   assertSafeRelativePath(relativePath);
   const abs = (0, import_node_path20.join)(worktreePath, relativePath);
-  (0, import_node_fs21.mkdirSync)((0, import_node_path20.dirname)(abs), { recursive: true });
-  (0, import_node_fs21.writeFileSync)(abs, content, "utf8");
+  (0, import_node_fs22.mkdirSync)((0, import_node_path20.dirname)(abs), { recursive: true });
+  (0, import_node_fs22.writeFileSync)(abs, content, "utf8");
   return { path: relativePath };
 }
 async function getDiffSummary(worktreePath, repoPath, opts) {
@@ -8963,7 +9628,7 @@ async function confirmLand(thread, opts) {
 }
 
 // src/skills/discover.ts
-var import_node_fs22 = require("fs");
+var import_node_fs23 = require("fs");
 var import_node_os9 = require("os");
 var import_node_path21 = require("path");
 function toCommand(name) {
@@ -8997,7 +9662,7 @@ function parseFrontmatter(content) {
 }
 function readSkill(skillMd, source) {
   try {
-    const content = (0, import_node_fs22.readFileSync)(skillMd, "utf8");
+    const content = (0, import_node_fs23.readFileSync)(skillMd, "utf8");
     const { name: fmName, description } = parseFrontmatter(content);
     const dirName = skillMd.split("/").slice(-2, -1)[0] || "skill";
     const name = fmName || dirName;
@@ -9016,19 +9681,19 @@ function readSkill(skillMd, source) {
   }
 }
 function scanSkillsDir(dir, source, out) {
-  if (!(0, import_node_fs22.existsSync)(dir)) return;
+  if (!(0, import_node_fs23.existsSync)(dir)) return;
   let entries;
   try {
-    entries = (0, import_node_fs22.readdirSync)(dir);
+    entries = (0, import_node_fs23.readdirSync)(dir);
   } catch {
     return;
   }
   for (const entry of entries) {
     if (entry.startsWith(".")) continue;
     const skillMd = (0, import_node_path21.join)(dir, entry, "SKILL.md");
-    if (!(0, import_node_fs22.existsSync)(skillMd)) continue;
+    if (!(0, import_node_fs23.existsSync)(skillMd)) continue;
     try {
-      if (!(0, import_node_fs22.statSync)(skillMd).isFile()) continue;
+      if (!(0, import_node_fs23.statSync)(skillMd).isFile()) continue;
     } catch {
       continue;
     }
@@ -9037,12 +9702,12 @@ function scanSkillsDir(dir, source, out) {
   }
 }
 function scanClaudePluginSkills(pluginsRoot, out) {
-  if (!(0, import_node_fs22.existsSync)(pluginsRoot)) return;
+  if (!(0, import_node_fs23.existsSync)(pluginsRoot)) return;
   const walk = (dir, depth, lookingForSkillsDir) => {
     if (depth > 7) return;
     let entries;
     try {
-      entries = (0, import_node_fs22.readdirSync)(dir);
+      entries = (0, import_node_fs23.readdirSync)(dir);
     } catch {
       return;
     }
@@ -9054,7 +9719,7 @@ function scanClaudePluginSkills(pluginsRoot, out) {
       if (entry === "node_modules" || entry === ".git") continue;
       const full = (0, import_node_path21.join)(dir, entry);
       try {
-        if (!(0, import_node_fs22.statSync)(full).isDirectory()) continue;
+        if (!(0, import_node_fs23.statSync)(full).isDirectory()) continue;
       } catch {
         continue;
       }
@@ -9094,7 +9759,7 @@ function discoverSkills(worktreePath) {
   return [...byCommand.values()].sort((a, b) => a.command.localeCompare(b.command));
 }
 function readSkillBody(skillPath, maxChars = 12e3) {
-  const raw = (0, import_node_fs22.readFileSync)(skillPath, "utf8");
+  const raw = (0, import_node_fs23.readFileSync)(skillPath, "utf8");
   if (raw.startsWith("---")) {
     const end = raw.indexOf("\n---", 3);
     if (end >= 0) {
@@ -9187,9 +9852,10 @@ function expandComposerPrompt(worktreePath, prompt, opts) {
 }
 
 // src/composer/stage-files.ts
-var import_node_fs23 = require("fs");
+var import_node_fs24 = require("fs");
 var import_node_path22 = require("path");
 var import_node_crypto5 = require("crypto");
+init_workspace_scratch();
 var IMAGE_EXTENSIONS2 = /* @__PURE__ */ new Set([
   "png",
   "jpg",
@@ -9210,11 +9876,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) {
@@ -9229,21 +9890,21 @@ function imageMimeType(filePath) {
 }
 function ensureAttachmentsDir(worktreePath) {
   const dir = (0, import_node_path22.join)(worktreePath, ATTACHMENTS_DIR);
-  (0, import_node_fs23.mkdirSync)(dir, { recursive: true });
+  (0, import_node_fs24.mkdirSync)(dir, { recursive: true });
   const gi = (0, import_node_path22.join)(dir, ".gitignore");
-  if (!(0, import_node_fs23.existsSync)(gi)) {
-    (0, import_node_fs23.writeFileSync)(gi, ATTACHMENTS_GITIGNORE2, "utf8");
+  if (!(0, import_node_fs24.existsSync)(gi)) {
+    (0, import_node_fs24.writeFileSync)(gi, attachmentsGitignoreBody(), "utf8");
   }
   return dir;
 }
 function uniqueAttachmentName(dir, originalName) {
   const safe = originalName.replace(/[/\\]/g, "_") || "file";
-  if (!(0, import_node_fs23.existsSync)((0, import_node_path22.join)(dir, safe))) return safe;
+  if (!(0, import_node_fs24.existsSync)((0, import_node_path22.join)(dir, safe))) return safe;
   const ext = (0, import_node_path22.extname)(safe);
   const stem = ext ? safe.slice(0, -ext.length) : safe;
   for (let i = 1; i < 1e4; i++) {
     const candidate = `${stem}-${i}${ext}`;
-    if (!(0, import_node_fs23.existsSync)((0, import_node_path22.join)(dir, candidate))) return candidate;
+    if (!(0, import_node_fs24.existsSync)((0, import_node_path22.join)(dir, candidate))) return candidate;
   }
   return `${stem}-${(0, import_node_crypto5.randomUUID)()}${ext}`;
 }
@@ -9301,13 +9962,13 @@ function stageAbsolutePathsAsAttachments(worktreePath, absolutePaths) {
   for (const abs of absolutePaths) {
     const originalName = (0, import_node_path22.basename)(abs);
     try {
-      const st = (0, import_node_fs23.statSync)(abs);
+      const st = (0, import_node_fs24.statSync)(abs);
       if (!st.isFile()) continue;
       const name = uniqueAttachmentName(dir, originalName);
       const destAbs = (0, import_node_path22.join)(dir, name);
-      (0, import_node_fs23.copyFileSync)(abs, destAbs);
+      (0, import_node_fs24.copyFileSync)(abs, destAbs);
       const rel = `${ATTACHMENTS_DIR}/${name}`;
-      const buf = (0, import_node_fs23.readFileSync)(destAbs);
+      const buf = (0, import_node_fs24.readFileSync)(destAbs);
       out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
     } catch (err) {
       out.push({
@@ -9330,7 +9991,7 @@ function stageBuffersAsAttachments(worktreePath, buffers) {
       const buf = Buffer.from(item.dataBase64, "base64");
       const name = uniqueAttachmentName(dir, originalName);
       const destAbs = (0, import_node_path22.join)(dir, name);
-      (0, import_node_fs23.writeFileSync)(destAbs, buf);
+      (0, import_node_fs24.writeFileSync)(destAbs, buf);
       const rel = `${ATTACHMENTS_DIR}/${name}`;
       out.push(attachmentFromBuffer(name, buf, { path: rel }));
     } catch (err) {
@@ -9359,9 +10020,9 @@ function attachmentsFromWorktreePaths(worktreePath, relativePaths) {
     const name = (0, import_node_path22.basename)(rel);
     try {
       const abs = (0, import_node_path22.join)(worktreePath, rel);
-      const st = (0, import_node_fs23.statSync)(abs);
+      const st = (0, import_node_fs24.statSync)(abs);
       if (!st.isFile()) continue;
-      const buf = (0, import_node_fs23.readFileSync)(abs);
+      const buf = (0, import_node_fs24.readFileSync)(abs);
       out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
     } catch (err) {
       out.push({
@@ -9376,7 +10037,7 @@ function attachmentsFromWorktreePaths(worktreePath, relativePaths) {
 }
 
 // src/agents/instructions.ts
-var import_node_fs24 = require("fs");
+var import_node_fs25 = require("fs");
 var import_node_path23 = require("path");
 init_worktree_labels();
 function normPath2(p) {
@@ -9517,10 +10178,10 @@ function loadAgentInstructions(worktreePath, agent) {
   for (const rel of candidates) {
     if (seen.has(rel)) continue;
     const abs = (0, import_node_path23.join)(worktreePath, rel);
-    if (!(0, import_node_fs24.existsSync)(abs)) continue;
+    if (!(0, import_node_fs25.existsSync)(abs)) continue;
     try {
-      if (!(0, import_node_fs24.statSync)(abs).isFile()) continue;
-      let content = (0, import_node_fs24.readFileSync)(abs, "utf8");
+      if (!(0, import_node_fs25.statSync)(abs).isFile()) continue;
+      let content = (0, import_node_fs25.readFileSync)(abs, "utf8");
       if (!content.trim()) continue;
       if (content.length > MAX_CHARS_PER_FILE) {
         content = `${content.slice(0, MAX_CHARS_PER_FILE)}
@@ -9553,6 +10214,7 @@ function formatAgentInstructions(files) {
 
 // src/orchestrator/orchestrator.ts
 init_types();
+init_plan_file();
 init_settings();
 
 // src/threads/sync-branch.ts
@@ -9672,7 +10334,7 @@ var Orchestrator = class {
         }
         continue;
       }
-      if (!(0, import_node_fs26.existsSync)(thread.worktreePath)) {
+      if (!(0, import_node_fs28.existsSync)(thread.worktreePath)) {
         setStatus(thread.id, "broken", "Worktree missing on disk");
         this.emit({ type: "status_changed", threadId: thread.id, status: "broken" });
         continue;
@@ -9817,14 +10479,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 Promise.resolve().then(() => (init_app_settings(), app_settings_exports));
     if (autoRunAfterSetupEnabled2()) {
       try {
@@ -9838,6 +10495,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);
@@ -10186,6 +10856,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)
       )) {
@@ -10667,6 +11350,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;
@@ -10729,14 +11488,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) {
@@ -10750,7 +11504,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);
@@ -10824,7 +11578,7 @@ var Orchestrator = class {
       updateThread(thread.id, { worktreePath: globalAgentCwd2() });
       return setStatus(thread.id, "idle");
     }
-    if (!(0, import_node_fs26.existsSync)(thread.worktreePath)) {
+    if (!(0, import_node_fs28.existsSync)(thread.worktreePath)) {
       const { createThreadWorktree: createThreadWorktree2 } = await Promise.resolve().then(() => (init_worktree(), worktree_exports));
       const { execa: execa7 } = await import("execa");
       const slug = thread.worktreePath.split("/").pop();
@@ -11043,7 +11797,7 @@ async function startMcpServer() {
     async () => {
       const threads = orch.getThreads(true);
       const lines = threads.map((t) => {
-        const repo = t.repoPath === GLOBAL_WORKSPACE_ID ? "Orchestration" : (0, import_node_path25.basename)(t.repoPath) || t.repoPath;
+        const repo = t.repoPath === GLOBAL_WORKSPACE_ID ? "Orchestration" : (0, import_node_path26.basename)(t.repoPath) || t.repoPath;
         return `${t.id.slice(0, 8)}  ${t.status.padEnd(9)}  ${t.agent.padEnd(8)}  ${repo}  ${t.sourceType}:${t.sourceRef}  ${t.title}  sideboard://thread/${t.id}${t.devPort ? `  http://localhost:${t.devPort}` : ""}`;
       });
       return {
@@ -11105,6 +11859,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: import_zod.z.array(
+        import_zod.z.object({
+          question: import_zod.z.string().describe("Full question text ending with ?"),
+          header: import_zod.z.string().max(24).optional().describe("Short label shown above the question"),
+          multiSelect: import_zod.z.boolean().optional().describe("Allow selecting multiple options"),
+          options: import_zod.z.array(
+            import_zod.z.object({
+              label: import_zod.z.string(),
+              description: import_zod.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: import_zod.z.string().optional().describe("Short plan title (defaults to Plan)"),
+      content: import_zod.z.string().min(1).describe("Full plan markdown (headings, steps, risks, open questions)"),
+      thread_id: import_zod.z.string().optional().describe("Sideboard thread id when cwd is not the worktree")
+    },
+    async ({ title, content, thread_id }) => {
+      const { writePlanFile: writePlanFile2 } = await Promise.resolve().then(() => (init_plan_file(), plan_file_exports));
+      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.",
@@ -11683,6 +12490,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: import_zod.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: import_zod.z.string(),
+      layer: import_zod.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: import_zod.z.string(),
+      branchName: import_zod.z.string(),
+      title: import_zod.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: import_zod.z.string(),
+      branches: import_zod.z.array(import_zod.z.string()).min(1),
+      agent: import_zod.z.enum(["claude", "codex", "opencode", "brightsy", "cursor"]),
+      base: import_zod.z.string().optional(),
+      title: import_zod.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.",