@sideboard-ai/core 0.1.50 → 0.1.52

package/dist/index.cjs

@@ -916,6 +916,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,
@@ -940,6 +942,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 ?? [],
@@ -2044,6 +2048,7 @@ var run_exports = {};
 __export(run_exports, {
   gh: () => gh,
   git: () => git,
+  resolveGhAuthToken: () => resolveGhAuthToken,
   run: () => run
 });
 async function run(file, args, opts) {
@@ -2072,11 +2077,28 @@ async function run(file, args, opts) {
   }
 }
 async function git(args, cwd, opts) {
-  return run("git", args, { cwd, reject: opts?.reject });
+  const prefix = [];
+  if (opts?.config) {
+    for (const [key, value] of Object.entries(opts.config)) {
+      if (!key) continue;
+      prefix.push("-c", `${key}=${value}`);
+    }
+  }
+  return run("git", [...prefix, ...args], {
+    cwd,
+    reject: opts?.reject,
+    env: opts?.env
+  });
 }
 async function gh(args, cwd, opts) {
   return run("gh", args, { cwd, reject: opts?.reject });
 }
+async function resolveGhAuthToken(cwd) {
+  const result = await gh(["auth", "token"], cwd, { reject: false });
+  if (result.exitCode !== 0) return null;
+  const token = result.stdout.trim();
+  return token || null;
+}
 var import_execa;
 var init_run = __esm({
   "src/git/run.ts"() {
@@ -2178,6 +2200,234 @@ 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 resetGhStackDetectCache() {
+  cachedStatus = null;
+}
+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 isInPrStack(cwd) {
+  return Boolean(await getPrStack(cwd));
+}
+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");
+  }
+}
+async function submitPrStack(cwd, opts) {
+  const status = await detectGhStack(cwd);
+  if (!status.available) throw new Error(status.reason);
+  const args = ["stack", "submit", "--auto"];
+  if (opts?.open) args.push("--open");
+  const { exitCode, stderr, stdout } = await gh(args, cwd, { reject: false });
+  if (exitCode !== 0) {
+    throw new Error(stderr.trim() || stdout.trim() || "gh stack submit failed");
+  }
+}
+async function checkoutPrStackLayer(cwd, target) {
+  const status = await detectGhStack(cwd);
+  if (!status.available) throw new Error(status.reason);
+  const { exitCode, stderr, stdout } = await gh(
+    ["stack", "checkout", String(target)],
+    cwd,
+    { reject: false }
+  );
+  if (exitCode !== 0) {
+    throw new Error(stderr.trim() || stdout.trim() || "gh stack checkout 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, {
@@ -2187,6 +2437,7 @@ __export(worktree_exports, {
   branchDisplayLabel: () => branchDisplayLabel,
   collectTakenTeamSlugs: () => collectTakenTeamSlugs,
   commitAll: () => commitAll,
+  createExistingBranchWorktree: () => createExistingBranchWorktree,
   createOrUpdatePr: () => createOrUpdatePr,
   createThreadWorktree: () => createThreadWorktree,
   currentBranch: () => currentBranch,
@@ -2201,6 +2452,7 @@ __export(worktree_exports, {
   ghRepoSelectArgs: () => ghRepoSelectArgs,
   isDirty: () => isDirty,
   isPlaceholderBranch: () => isPlaceholderBranch,
+  isSideboardScratchPath: () => isSideboardScratchPath,
   listBranches: () => listBranches,
   listPrs: () => listPrs,
   listWorktrees: () => listWorktrees,
@@ -2730,18 +2982,31 @@ async function fetchPrHead(repoPath, number, localBranch) {
   const slug = await resolveGithubRepoSlug(repoPath);
   const refspec = `+pull/${number}/head:${localBranch}`;
   const errors = [];
-  const tryFetch = async (remote) => {
-    const result = await git(["fetch", remote, refspec], repoPath, {
-      reject: false
-    });
+  const httpsRemote = slug ? `https://github.com/${slug}.git` : null;
+  const tryFetch = async (remote, opts) => {
+    const label = opts?.ghAuth ? `${remote} (gh auth)` : remote;
+    const gitOpts = { reject: false };
+    if (opts?.ghAuth) {
+      const token = await resolveGhAuthToken(repoPath);
+      if (!token) {
+        errors.push(`${label}: gh auth token unavailable`);
+        return false;
+      }
+      gitOpts.env = { GIT_TERMINAL_PROMPT: "0" };
+      gitOpts.config = {
+        "http.extraHeader": `AUTHORIZATION: bearer ${token}`
+      };
+    }
+    const result = await git(["fetch", remote, refspec], repoPath, gitOpts);
     if (result.exitCode === 0) return true;
     const detail = (result.stderr || result.stdout).trim();
-    if (detail) errors.push(`${remote}: ${detail}`);
+    if (detail) errors.push(`${label}: ${detail}`);
     return false;
   };
   let fetched = await tryFetch("origin");
-  if (!fetched && slug) {
-    fetched = await tryFetch(`https://github.com/${slug}.git`);
+  if (!fetched && httpsRemote) {
+    fetched = await tryFetch(httpsRemote);
+    if (!fetched) fetched = await tryFetch(httpsRemote, { ghAuth: true });
   }
   const localOk = async () => {
     const verify = await git(["rev-parse", "--verify", localBranch], repoPath, {
@@ -2770,18 +3035,28 @@ async function fetchPrHead(repoPath, number, localBranch) {
       }
     }
     if (oid) {
-      const ensureOid = async (remote) => {
-        const got = await git(["fetch", remote, oid], repoPath, {
-          reject: false
-        });
+      const ensureOid = async (remote, opts) => {
+        const gitOpts = { reject: false };
+        if (opts?.ghAuth) {
+          const token = await resolveGhAuthToken(repoPath);
+          if (!token) return false;
+          gitOpts.env = { GIT_TERMINAL_PROMPT: "0" };
+          gitOpts.config = {
+            "http.extraHeader": `AUTHORIZATION: bearer ${token}`
+          };
+        }
+        const got = await git(["fetch", remote, oid], repoPath, gitOpts);
         return got.exitCode === 0;
       };
       let haveObject = (await git(["cat-file", "-e", `${oid}^{commit}`], repoPath, {
         reject: false
       })).exitCode === 0;
       if (!haveObject) haveObject = await ensureOid("origin");
-      if (!haveObject && slug) {
-        haveObject = await ensureOid(`https://github.com/${slug}.git`);
+      if (!haveObject && httpsRemote) {
+        haveObject = await ensureOid(httpsRemote);
+        if (!haveObject) {
+          haveObject = await ensureOid(httpsRemote, { ghAuth: true });
+        }
       }
       if (haveObject) {
         const branched = await git(["branch", "-f", localBranch, oid], repoPath, {
@@ -2876,6 +3151,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_path6.join)(worktreesRoot(opts.repoPath), opts.slug);
+  if ((0, import_node_fs5.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
@@ -2905,8 +3226,27 @@ async function listWorktrees(repoPath) {
   return entries;
 }
 async function isDirty(worktreePath) {
-  const { stdout } = await git(["status", "--porcelain"], worktreePath);
-  return stdout.trim().length > 0;
+  const { stdout } = await git(["status", "--porcelain", "-uall"], worktreePath);
+  for (const line of stdout.split("\n")) {
+    if (!line.trim()) continue;
+    const rel = porcelainStatusPath(line);
+    if (!rel || isSideboardScratchPath(rel)) continue;
+    return true;
+  }
+  return false;
+}
+function isSideboardScratchPath(relativePath) {
+  return isWorkspaceScratchPath(relativePath);
+}
+function porcelainStatusPath(line) {
+  const rest = line.length >= 3 ? line.slice(3) : "";
+  if (!rest) return "";
+  const arrow = rest.lastIndexOf(" -> ");
+  const raw = arrow >= 0 ? rest.slice(arrow + 4) : rest;
+  if (raw.startsWith('"') && raw.endsWith('"')) {
+    return raw.slice(1, -1).replace(/\\([\\"])/g, "$1");
+  }
+  return raw;
 }
 async function currentBranch(worktreePath) {
   const { stdout } = await git(["rev-parse", "--abbrev-ref", "HEAD"], worktreePath);
@@ -2924,7 +3264,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()) {
@@ -2932,16 +3272,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);
@@ -2963,10 +3316,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 {
     }
@@ -3114,7 +3467,9 @@ var init_worktree = __esm({
     init_gh_errors();
     init_run();
     init_pr_gates();
+    init_stack();
     init_teams();
+    init_workspace_scratch();
     init_worktree_labels();
   }
 });
@@ -3240,6 +3595,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:",
@@ -4651,7 +5007,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"
     ];
     BRIGHTSY_MCP_ALLOWED_TOOLS = [
       "mcp__brightsy",
@@ -4694,7 +5052,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.";
   }
 });
 
@@ -6283,6 +6641,116 @@ var init_agents = __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, {
@@ -6291,10 +6759,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();
@@ -6320,12 +6788,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();
   }
 });
@@ -6364,6 +6832,7 @@ var init_title = __esm({
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  ATTACHMENTS_DIR: () => ATTACHMENTS_DIR,
   BRIGHTSY_MCP_ALLOWED_TOOLS: () => BRIGHTSY_MCP_ALLOWED_TOOLS,
   BrightsySideboardApi: () => BrightsySideboardApi,
   CLAUDE_MODEL_CATALOG: () => CLAUDE_MODEL_CATALOG,
@@ -6379,11 +6848,16 @@ __export(index_exports, {
   FAMOUS_SOCCER_TEAMS: () => FAMOUS_SOCCER_TEAMS,
   GLOBAL_WORKSPACE_ID: () => GLOBAL_WORKSPACE_ID,
   HARNESS_ENV_KEYS: () => HARNESS_ENV_KEYS,
+  LEGACY_ATTACHMENTS_DIR: () => LEGACY_ATTACHMENTS_DIR,
+  LEGACY_PLAN_FILE_REL: () => LEGACY_PLAN_FILE_REL,
+  LEGACY_REVIEW_REQUEST_PATH: () => LEGACY_REVIEW_REQUEST_PATH,
   MAX_ANTHROPIC_CACHE_CONTROL_BLOCKS: () => MAX_ANTHROPIC_CACHE_CONTROL_BLOCKS,
   ORCHESTRATOR_AGENT_KINDS: () => ORCHESTRATOR_AGENT_KINDS,
   Orchestrator: () => Orchestrator,
   PASTE_ATTACH_MIN_CHARS: () => PASTE_ATTACH_MIN_CHARS,
   PASTE_ATTACH_MIN_LINES: () => PASTE_ATTACH_MIN_LINES,
+  PLAN_FILE_NAME: () => PLAN_FILE_NAME,
+  PLAN_FILE_REL: () => PLAN_FILE_REL,
   PLAN_MODE_INSTRUCTION: () => PLAN_MODE_INSTRUCTION,
   REPO_REVIEW_NAME: () => REPO_REVIEW_NAME,
   REPO_REVIEW_PATH: () => REPO_REVIEW_PATH,
@@ -6393,6 +6867,8 @@ __export(index_exports, {
   SIDEBOARD_FORCE_STOP: () => SIDEBOARD_FORCE_STOP,
   SIDEBOARD_MCP_ALLOWED_TOOLS: () => SIDEBOARD_MCP_ALLOWED_TOOLS,
   THINKING_EFFORTS: () => THINKING_EFFORTS,
+  addPrStackLayer: () => addPrStackLayer,
+  addStackLayerFromThread: () => addStackLayerFromThread,
   addWorkspace: () => addWorkspace,
   adoptThread: () => adoptThread,
   allAdapters: () => allAdapters,
@@ -6411,6 +6887,7 @@ __export(index_exports, {
   attachmentFromAbsolutePath: () => attachmentFromAbsolutePath,
   attachmentsFromBuffers: () => attachmentsFromBuffers,
   attachmentsFromWorktreePaths: () => attachmentsFromWorktreePaths,
+  attachmentsGitignoreBody: () => attachmentsGitignoreBody,
   autoCleanupOrphansEnabled: () => autoCleanupOrphansEnabled,
   autoRenameBranchEnabled: () => autoRenameBranchEnabled,
   autoRunAfterSetupEnabled: () => autoRunAfterSetupEnabled,
@@ -6433,6 +6910,7 @@ __export(index_exports, {
   caffeinateWhileRunningEnabled: () => caffeinateWhileRunningEnabled,
   captureLoginEnv: () => captureLoginEnv,
   captureTurnBaseline: () => captureTurnBaseline,
+  checkoutPrStackLayer: () => checkoutPrStackLayer,
   childEnvWithAppSettings: () => childEnvWithAppSettings,
   claudeAdapter: () => claudeAdapter,
   claudeChromeEnabled: () => claudeChromeEnabled,
@@ -6452,8 +6930,10 @@ __export(index_exports, {
   countCacheControlBlocks: () => countCacheControlBlocks,
   createChatTab: () => createChatTab,
   createEmptyThread: () => createEmptyThread,
+  createExistingBranchWorktree: () => createExistingBranchWorktree,
   createGlobalChat: () => createGlobalChat,
   createOrUpdatePr: () => createOrUpdatePr,
+  createPrStack: () => createPrStack,
   createThread: () => createThread,
   createThreadWorktree: () => createThreadWorktree,
   currentBranch: () => currentBranch,
@@ -6463,6 +6943,7 @@ __export(index_exports, {
   deleteBranchOnPurgeEnabled: () => deleteBranchOnPurgeEnabled,
   deleteThreadRecord: () => deleteThreadRecord,
   detectAgents: () => detectAgents,
+  detectGhStack: () => detectGhStack,
   detectLocalMergeConflicts: () => detectLocalMergeConflicts,
   disconnectBrightsyTeam: () => disconnectBrightsyTeam,
   discoverSkills: () => discoverSkills,
@@ -6478,12 +6959,15 @@ __export(index_exports, {
   estimateThreadChars: () => estimateThreadChars,
   expandComposerPrompt: () => expandComposerPrompt,
   extractGhErrorDetail: () => extractGhErrorDetail,
+  extractPendingPlanQuestions: () => extractPendingPlanQuestions,
+  extractPresentedPlan: () => extractPresentedPlan,
   extractiveSummary: () => extractiveSummary,
   fetchPrHead: () => fetchPrHead,
   finalizeParts: () => finalizeParts,
   findInvalidCacheControlTtlOrder: () => findInvalidCacheControlTtlOrder,
   findOrphanWorktrees: () => findOrphanWorktrees,
   findThreadByRef: () => findThreadByRef,
+  findThreadForStackLayer: () => findThreadForStackLayer,
   flattenTurnInput: () => flattenTurnInput,
   forkChatTab: () => forkChatTab,
   forkMessageSlice: () => forkMessageSlice,
@@ -6494,6 +6978,8 @@ __export(index_exports, {
   formatGhLandError: () => formatGhLandError,
   formatIpcInvokeError: () => formatIpcInvokeError,
   formatMessagesAsTranscript: () => formatMessagesAsTranscript,
+  formatPlanQuestionAnswers: () => formatPlanQuestionAnswers,
+  formatPlanQuestionsForChat: () => formatPlanQuestionsForChat,
   formatRateLimitResetHint: () => formatRateLimitResetHint,
   formatRenameBranchDirective: () => formatRenameBranchDirective,
   formatTranscriptMarkdown: () => formatTranscriptMarkdown,
@@ -6517,6 +7003,7 @@ __export(index_exports, {
   getPrChecks: () => getPrChecks,
   getPrDetails: () => getPrDetails,
   getPrMeta: () => getPrMeta,
+  getPrStack: () => getPrStack,
   getRepoSetupInfo: () => getRepoSetupInfo,
   getRunMode: () => getRunMode,
   getRunScript: () => getRunScript,
@@ -6533,9 +7020,12 @@ __export(index_exports, {
   healOrchestrationSoccerTitles: () => healOrchestrationSoccerTitles,
   importConductorWorkspace: () => importConductorWorkspace,
   importConductorWorkspaceAsync: () => importConductorWorkspaceAsync,
+  initPrStack: () => initPrStack,
+  initStackFromThread: () => initStackFromThread,
   initializeGitRepository: () => initializeGitRepository,
   inspectGitWorktree: () => inspectGitWorktree,
   installAgent: () => installAgent,
+  isAskUserToolName: () => isAskUserToolName,
   isBrightsyConnected: () => isBrightsyConnected,
   isBrightsyNdjsonLine: () => isBrightsyNdjsonLine,
   isCloudCoordinatorThread: () => isCloudCoordinatorThread,
@@ -6545,13 +7035,17 @@ __export(index_exports, {
   isGlobalRepoPath: () => isGlobalRepoPath,
   isGlobalThread: () => isGlobalThread,
   isImageFilePath: () => isImageFilePath,
+  isInPrStack: () => isInPrStack,
   isLinearConnected: () => isLinearConnected,
   isOrchestratorCapableAgent: () => isOrchestratorCapableAgent,
   isOrchestratorThread: () => isOrchestratorThread,
   isPidAlive: () => isPidAlive,
   isPlaceholderBranch: () => isPlaceholderBranch,
+  isPresentPlanToolName: () => isPresentPlanToolName,
   isSessionQuotaLimit: () => isSessionQuotaLimit,
+  isSideboardScratchPath: () => isSideboardScratchPath,
   isThinkingEffort: () => isThinkingEffort,
+  isWorkspaceScratchPath: () => isWorkspaceScratchPath,
   listAgentSetupInfo: () => listAgentSetupInfo,
   listBranchCommits: () => listBranchCommits,
   listBranches: () => listBranches,
@@ -6588,6 +7082,7 @@ __export(index_exports, {
   mcpAllowTools: () => mcpAllowTools,
   mcpAuthWarnings: () => mcpAuthWarnings,
   mergePr: () => mergePr,
+  mergePrStack: () => mergePrStack,
   mergeUsage: () => mergeUsage,
   nextPastedTextName: () => nextPastedTextName,
   nextThinkingEffort: () => nextThinkingEffort,
@@ -6597,6 +7092,8 @@ __export(index_exports, {
   normalizeTurnInput: () => normalizeTurnInput,
   normalizeWorktreePath: () => normalizeWorktreePath,
   openInSystemTerminal: () => openInSystemTerminal,
+  openPrStackLayers: () => openPrStackLayers,
+  openStackLayer: () => openStackLayer,
   opencodeAdapter: () => opencodeAdapter,
   orchestrationQuotaFallbackAgent: () => orchestrationQuotaFallbackAgent,
   orchestrationQuotaOnLimit: () => orchestrationQuotaOnLimit,
@@ -6605,15 +7102,19 @@ __export(index_exports, {
   originGhRepoEnv: () => originGhRepoEnv,
   parseCursorRunnerLine: () => parseCursorRunnerLine,
   parseForceStopMessage: () => parseForceStopMessage,
+  parseGhStackViewJson: () => parseGhStackViewJson,
   parseGithubSlugFromRemoteUrl: () => parseGithubSlugFromRemoteUrl,
   parseMcpList: () => parseMcpList,
+  parsePlanQuestionsInput: () => parsePlanQuestionsInput,
   parseSessionQuotaResetAt: () => parseSessionQuotaResetAt,
   partsToAssistantText: () => partsToAssistantText,
   pastedTextStats: () => pastedTextStats,
   permissionMode: () => permissionMode,
+  planFileAbs: () => planFileAbs,
   previewLand: () => previewLand,
   pushBranch: () => pushBranch,
   readExistingReviewRequestFile: () => readExistingReviewRequestFile,
+  readPlanFile: () => readPlanFile,
   readSkillBody: () => readSkillBody,
   readThread: () => readThread,
   readWorktreeFile: () => readWorktreeFile,
@@ -6625,6 +7126,7 @@ __export(index_exports, {
   repoSlug: () => repoSlug,
   requestReview: () => requestReview,
   requireAgent: () => requireAgent,
+  resetGhStackDetectCache: () => resetGhStackDetectCache,
   resolveClaudeExecutable: () => resolveClaudeExecutable,
   resolveConductorCursorAgentId: () => resolveConductorCursorAgentId,
   resolveCursorModelId: () => resolveCursorModelId,
@@ -6632,7 +7134,9 @@ __export(index_exports, {
   resolveDiffBaseRef: () => resolveDiffBaseRef,
   resolveEffectiveIssueSource: () => resolveEffectiveIssueSource,
   resolveFilesToCopy: () => resolveFilesToCopy,
+  resolveGhAuthToken: () => resolveGhAuthToken,
   resolveGithubRepoSlug: () => resolveGithubRepoSlug,
+  resolvePlanMarkdown: () => resolvePlanMarkdown,
   resolvePrSelector: () => resolvePrSelector,
   resolveQuotaFallbackAgent: () => resolveQuotaFallbackAgent,
   resolveRepoRoot: () => resolveRepoRoot,
@@ -6660,12 +7164,16 @@ __export(index_exports, {
   slugify: () => slugify,
   spawnAgentTurn: () => spawnAgentTurn,
   splitForCompaction: () => splitForCompaction,
+  stackAgentDefaultsFrom: () => stackAgentDefaultsFrom,
+  stackIdFrom: () => stackIdFrom,
+  stackMergeReadiness: () => stackMergeReadiness,
   stageAbsolutePathsAsAttachments: () => stageAbsolutePathsAsAttachments,
   stageBuffersAsAttachments: () => stageBuffersAsAttachments,
   startDevServer: () => startDevServer,
   startMcpServer: () => startMcpServer,
   startOrchestration: () => startOrchestration,
   stripBrightsyNdjsonNoise: () => stripBrightsyNdjsonNoise,
+  submitPrStack: () => submitPrStack,
   suggestSlug: () => suggestSlug,
   summarizeConversation: () => summarizeConversation,
   switchBrightsyAccount: () => switchBrightsyAccount,
@@ -6701,6 +7209,7 @@ __export(index_exports, {
   worktreeNameFromPath: () => worktreeNameFromPath,
   worktreesRoot: () => worktreesRoot,
   writeInjectedMcpConfig: () => writeInjectedMcpConfig,
+  writePlanFile: () => writePlanFile,
   writeThread: () => writeThread,
   writeWorktreeFile: () => writeWorktreeFile
 });
@@ -6714,6 +7223,7 @@ init_global_workspace();
 init_run();
 init_gh_errors();
 init_worktree();
+init_stack();
 
 // src/integrations/github.ts
 init_run();
@@ -6910,18 +7420,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);
@@ -6934,23 +7444,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";
@@ -6959,11 +7472,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";
@@ -6972,7 +7485,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;
@@ -6980,8 +7493,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),
@@ -7990,7 +8503,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);
@@ -8148,33 +8661,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") {
@@ -8193,34 +8706,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;
   }
@@ -8653,6 +9166,7 @@ function buildDiffCommentAttachment(input) {
 var import_node_fs19 = require("fs");
 var import_node_path19 = require("path");
 var import_node_crypto2 = require("crypto");
+init_workspace_scratch();
 var IMAGE_EXTENSIONS2 = /* @__PURE__ */ new Set([
   "png",
   "jpg",
@@ -8673,11 +9187,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) {
@@ -8695,7 +9204,7 @@ function ensureAttachmentsDir(worktreePath) {
   (0, import_node_fs19.mkdirSync)(dir, { recursive: true });
   const gi = (0, import_node_path19.join)(dir, ".gitignore");
   if (!(0, import_node_fs19.existsSync)(gi)) {
-    (0, import_node_fs19.writeFileSync)(gi, ATTACHMENTS_GITIGNORE, "utf8");
+    (0, import_node_fs19.writeFileSync)(gi, attachmentsGitignoreBody(), "utf8");
   }
   return dir;
 }
@@ -9355,7 +9864,7 @@ var import_node_fs20 = require("fs");
 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_fs20.existsSync)(repoPath)) {
@@ -9365,10 +9874,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}`;
@@ -9413,22 +9922,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) {
@@ -9481,7 +9974,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) {
@@ -9596,9 +10091,308 @@ async function forkThreadWorktree(input, onSetupLine) {
   return thread;
 }
 
+// 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 };
+}
+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
 var import_node_child_process = require("child_process");
-var import_node_fs21 = require("fs");
+var import_node_fs22 = require("fs");
 var import_node_os9 = require("os");
 var import_node_path20 = require("path");
 var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
@@ -9623,21 +10417,21 @@ function mapAgentType(raw) {
   return null;
 }
 function resolveConductorCursorAgentId(workspacePath) {
-  if (!workspacePath || !(0, import_node_fs21.existsSync)(CURSOR_SDK_STORE)) return null;
+  if (!workspacePath || !(0, import_node_fs22.existsSync)(CURSOR_SDK_STORE)) return null;
   const normalized = workspacePath.replace(/\/$/, "");
   let best = null;
   let hashes;
   try {
-    hashes = (0, import_node_fs21.readdirSync)(CURSOR_SDK_STORE);
+    hashes = (0, import_node_fs22.readdirSync)(CURSOR_SDK_STORE);
   } catch {
     return null;
   }
   for (const hash of hashes) {
     const agentsFile = (0, import_node_path20.join)(CURSOR_SDK_STORE, hash, "agents.ndjson");
-    if (!(0, import_node_fs21.existsSync)(agentsFile)) continue;
+    if (!(0, import_node_fs22.existsSync)(agentsFile)) continue;
     let text;
     try {
-      text = (0, import_node_fs21.readFileSync)(agentsFile, "utf8");
+      text = (0, import_node_fs22.readFileSync)(agentsFile, "utf8");
     } catch {
       continue;
     }
@@ -9661,7 +10455,7 @@ function resolveConductorCursorAgentId(workspacePath) {
   return best?.agentId ?? null;
 }
 async function adoptThread(input) {
-  if (!(0, import_node_fs21.existsSync)(input.worktreePath)) {
+  if (!(0, import_node_fs22.existsSync)(input.worktreePath)) {
     throw new Error(`Worktree not found: ${input.worktreePath}`);
   }
   const repoPath = await resolveRepoRoot(input.worktreePath);
@@ -9688,18 +10482,18 @@ function conductorDbPath() {
   return CONDUCTOR_DB;
 }
 function listConductorWorkspaces() {
-  if (!(0, import_node_fs21.existsSync)(CONDUCTOR_DB)) {
+  if (!(0, import_node_fs22.existsSync)(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = (0, import_node_fs21.mkdtempSync)((0, import_node_path20.join)((0, import_node_os9.tmpdir)(), "sideboard-conductor-"));
+  const tmp = (0, import_node_fs22.mkdtempSync)((0, import_node_path20.join)((0, import_node_os9.tmpdir)(), "sideboard-conductor-"));
   const snapshot = (0, import_node_path20.join)(tmp, "conductor.db");
   try {
-    (0, import_node_fs21.copyFileSync)(CONDUCTOR_DB, snapshot);
+    (0, import_node_fs22.copyFileSync)(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if ((0, import_node_fs21.existsSync)(src)) {
+      if ((0, import_node_fs22.existsSync)(src)) {
         try {
-          (0, import_node_fs21.copyFileSync)(src, `${snapshot}${suffix}`);
+          (0, import_node_fs22.copyFileSync)(src, `${snapshot}${suffix}`);
         } catch {
         }
       }
@@ -9775,22 +10569,22 @@ function listConductorWorkspaces() {
       db.close();
     }
   } finally {
-    (0, import_node_fs21.rmSync)(tmp, { recursive: true, force: true });
+    (0, import_node_fs22.rmSync)(tmp, { recursive: true, force: true });
   }
 }
 function importConductorWorkspace(workspaceId) {
-  if (!(0, import_node_fs21.existsSync)(CONDUCTOR_DB)) {
+  if (!(0, import_node_fs22.existsSync)(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = (0, import_node_fs21.mkdtempSync)((0, import_node_path20.join)((0, import_node_os9.tmpdir)(), "sideboard-conductor-"));
+  const tmp = (0, import_node_fs22.mkdtempSync)((0, import_node_path20.join)((0, import_node_os9.tmpdir)(), "sideboard-conductor-"));
   const snapshot = (0, import_node_path20.join)(tmp, "conductor.db");
   try {
-    (0, import_node_fs21.copyFileSync)(CONDUCTOR_DB, snapshot);
+    (0, import_node_fs22.copyFileSync)(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if ((0, import_node_fs21.existsSync)(src)) {
+      if ((0, import_node_fs22.existsSync)(src)) {
         try {
-          (0, import_node_fs21.copyFileSync)(src, `${snapshot}${suffix}`);
+          (0, import_node_fs22.copyFileSync)(src, `${snapshot}${suffix}`);
         } catch {
         }
       }
@@ -9808,7 +10602,7 @@ function importConductorWorkspace(workspaceId) {
       ).get(workspaceId);
       if (!row) throw new Error(`Conductor workspace not found: ${workspaceId}`);
       const worktreePath = String(row.workspacePath);
-      if (!(0, import_node_fs21.existsSync)(worktreePath)) {
+      if (!(0, import_node_fs22.existsSync)(worktreePath)) {
         throw new Error(`Conductor worktree missing on disk: ${worktreePath}`);
       }
       let sessionId = null;
@@ -9871,7 +10665,7 @@ function importConductorWorkspace(workspaceId) {
       db.close();
     }
   } finally {
-    (0, import_node_fs21.rmSync)(tmp, { recursive: true, force: true });
+    (0, import_node_fs22.rmSync)(tmp, { recursive: true, force: true });
   }
 }
 async function importConductorWorkspaceAsync(workspaceId) {
@@ -9880,13 +10674,14 @@ async function importConductorWorkspaceAsync(workspaceId) {
 
 // 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();
 init_agents();
 init_worktree();
+init_stack();
 
 // src/git/orphan-cleanup.ts
-var import_node_fs22 = require("fs");
+var import_node_fs23 = require("fs");
 var import_node_path21 = require("path");
 init_worktree();
 init_thread_store();
@@ -9902,9 +10697,9 @@ async function findOrphanWorktrees(repoPaths) {
     repoPaths?.length ? repoPaths : threads.map((t) => t.repoPath).filter(Boolean)
   );
   const homeRoot = sideboardWorkspacesDir();
-  if ((0, import_node_fs22.existsSync)(homeRoot)) {
+  if ((0, import_node_fs23.existsSync)(homeRoot)) {
     try {
-      for (const entry of (0, import_node_fs22.readdirSync)(homeRoot, { withFileTypes: true })) {
+      for (const entry of (0, import_node_fs23.readdirSync)(homeRoot, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
         void entry;
       }
@@ -9914,7 +10709,7 @@ async function findOrphanWorktrees(repoPaths) {
   const orphans = [];
   const seen = /* @__PURE__ */ new Set();
   for (const repoPath of repos) {
-    if (!repoPath || !(0, import_node_fs22.existsSync)(repoPath)) continue;
+    if (!repoPath || !(0, import_node_fs23.existsSync)(repoPath)) continue;
     try {
       const wts = await listWorktrees(repoPath);
       for (const wt of wts) {
@@ -9925,7 +10720,7 @@ async function findOrphanWorktrees(repoPaths) {
         seen.add(path);
         let mtimeMs = 0;
         try {
-          mtimeMs = (0, import_node_fs22.statSync)(path).mtimeMs;
+          mtimeMs = (0, import_node_fs23.statSync)(path).mtimeMs;
         } catch {
           mtimeMs = 0;
         }
@@ -9935,16 +10730,16 @@ async function findOrphanWorktrees(repoPaths) {
     }
     try {
       const root = worktreesRoot(repoPath);
-      if ((0, import_node_fs22.existsSync)(root)) {
-        for (const entry of (0, import_node_fs22.readdirSync)(root, { withFileTypes: true })) {
+      if ((0, import_node_fs23.existsSync)(root)) {
+        for (const entry of (0, import_node_fs23.readdirSync)(root, { withFileTypes: true })) {
           if (!entry.isDirectory()) continue;
           const path = (0, import_node_path21.join)(root, entry.name).replace(/\/$/, "");
           if (known.has(path) || seen.has(path)) continue;
-          if (!(0, import_node_fs22.existsSync)((0, import_node_path21.join)(path, ".git"))) continue;
+          if (!(0, import_node_fs23.existsSync)((0, import_node_path21.join)(path, ".git"))) continue;
           seen.add(path);
           let mtimeMs = 0;
           try {
-            mtimeMs = (0, import_node_fs22.statSync)(path).mtimeMs;
+            mtimeMs = (0, import_node_fs23.statSync)(path).mtimeMs;
           } catch {
             mtimeMs = Date.now();
           }
@@ -10090,7 +10885,7 @@ async function applyThreadIntoMain(thread, opts) {
 }
 
 // src/git/clone-repo.ts
-var import_node_fs23 = require("fs");
+var import_node_fs24 = require("fs");
 var import_node_path22 = require("path");
 var import_execa6 = require("execa");
 init_paths();
@@ -10106,7 +10901,7 @@ async function cloneRepoIntoSideboard(opts) {
   }
   name = name.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "repo";
   const dest = (0, import_node_path22.join)(sideboardReposDir(), name);
-  if ((0, import_node_fs23.existsSync)(dest)) {
+  if ((0, import_node_fs24.existsSync)(dest)) {
     const repoPath2 = await resolveRepoRoot(dest);
     const workspace2 = await ensureWorkspace(repoPath2);
     return { repoPath: repoPath2, workspace: workspace2 };
@@ -10128,7 +10923,7 @@ init_orchestrator_capable();
 
 // src/review/request-review.ts
 var import_node_crypto5 = require("crypto");
-var import_node_fs24 = require("fs");
+var import_node_fs25 = require("fs");
 var import_node_path23 = require("path");
 init_global_workspace();
 init_thread_store();
@@ -10253,15 +11048,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_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:"
@@ -10275,19 +11068,19 @@ function shouldRefreshReviewRequestTemplate(content) {
   return LEGACY_REVIEW_TEMPLATE_MARKERS.every((m) => trimmed.includes(m));
 }
 function readTextIfPresent(abs) {
-  if (!(0, import_node_fs24.existsSync)(abs)) return null;
+  if (!(0, import_node_fs25.existsSync)(abs)) return null;
   try {
-    const content = (0, import_node_fs24.readFileSync)(abs, "utf8");
+    const content = (0, import_node_fs25.readFileSync)(abs, "utf8");
     return content.trim() ? content : null;
   } catch {
     return null;
   }
 }
 function ensureAttachmentsGitignore(worktreePath) {
-  const gitignoreAbs = (0, import_node_path23.join)(worktreePath, ".sideboard", "attachments", ".gitignore");
-  if ((0, import_node_fs24.existsSync)(gitignoreAbs)) return;
-  (0, import_node_fs24.mkdirSync)((0, import_node_path23.dirname)(gitignoreAbs), { recursive: true });
-  (0, import_node_fs24.writeFileSync)(gitignoreAbs, ATTACHMENTS_GITIGNORE2, "utf8");
+  const gitignoreAbs = (0, import_node_path23.join)(worktreePath, ATTACHMENTS_DIR, ".gitignore");
+  if ((0, import_node_fs25.existsSync)(gitignoreAbs)) return;
+  (0, import_node_fs25.mkdirSync)((0, import_node_path23.dirname)(gitignoreAbs), { recursive: true });
+  (0, import_node_fs25.writeFileSync)(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
 }
 function resolveReviewGuidelines(worktreePath) {
   const repoAbs = (0, import_node_path23.join)(worktreePath, REPO_REVIEW_PATH);
@@ -10310,9 +11103,19 @@ function resolveReviewGuidelines(worktreePath) {
       source: "local"
     };
   }
+  const legacyAbs = (0, import_node_path23.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_fs24.mkdirSync)((0, import_node_path23.dirname)(localAbs), { recursive: true });
-  (0, import_node_fs24.writeFileSync)(localAbs, REVIEW_REQUEST_TEMPLATE, "utf8");
+  (0, import_node_fs25.mkdirSync)((0, import_node_path23.dirname)(localAbs), { recursive: true });
+  (0, import_node_fs25.writeFileSync)(localAbs, REVIEW_REQUEST_TEMPLATE, "utf8");
   return {
     path: REVIEW_REQUEST_PATH,
     name: REVIEW_REQUEST_NAME,
@@ -10332,17 +11135,18 @@ function ensureReviewRequestFile(worktreePath) {
     };
   }
   const localAbs = (0, import_node_path23.join)(worktreePath, REVIEW_REQUEST_PATH);
-  const localContent = readTextIfPresent(localAbs);
+  const localContent = readTextIfPresent(localAbs) ?? readTextIfPresent((0, import_node_path23.join)(worktreePath, LEGACY_REVIEW_REQUEST_PATH));
   if (localContent && !shouldRefreshReviewRequestTemplate(localContent)) {
+    const path = (0, import_node_fs25.existsSync)(localAbs) ? REVIEW_REQUEST_PATH : LEGACY_REVIEW_REQUEST_PATH;
     return {
-      path: REVIEW_REQUEST_PATH,
+      path,
       name: REVIEW_REQUEST_NAME,
       content: localContent,
       source: "local"
     };
   }
-  (0, import_node_fs24.mkdirSync)((0, import_node_path23.dirname)(repoAbs), { recursive: true });
-  (0, import_node_fs24.writeFileSync)(repoAbs, REVIEW_REQUEST_TEMPLATE, "utf8");
+  (0, import_node_fs25.mkdirSync)((0, import_node_path23.dirname)(repoAbs), { recursive: true });
+  (0, import_node_fs25.writeFileSync)(repoAbs, REVIEW_REQUEST_TEMPLATE, "utf8");
   return {
     path: REPO_REVIEW_PATH,
     name: REPO_REVIEW_NAME,
@@ -10362,7 +11166,7 @@ function buildReviewRequestAttachment(content, opts) {
   };
 }
 function readExistingReviewRequestFile(worktreePath) {
-  return readTextIfPresent((0, import_node_path23.join)(worktreePath, REPO_REVIEW_PATH)) ?? readTextIfPresent((0, import_node_path23.join)(worktreePath, REVIEW_REQUEST_PATH));
+  return readTextIfPresent((0, import_node_path23.join)(worktreePath, REPO_REVIEW_PATH)) ?? readTextIfPresent((0, import_node_path23.join)(worktreePath, REVIEW_REQUEST_PATH)) ?? readTextIfPresent((0, import_node_path23.join)(worktreePath, LEGACY_REVIEW_REQUEST_PATH));
 }
 async function requestReview(threadRef, send) {
   const from = findThreadByRef(threadRef);
@@ -10501,6 +11305,7 @@ function createQuotaFailoverChat(from, fallbackAgent, limitText) {
 
 // src/orchestrator/orchestrator.ts
 init_types();
+init_plan_file();
 init_settings();
 
 // src/threads/sync-branch.ts
@@ -10620,7 +11425,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;
@@ -10765,14 +11570,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 {
@@ -10786,6 +11586,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);
@@ -11134,6 +11947,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)
       )) {
@@ -11615,6 +12441,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;
@@ -11677,14 +12579,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) {
@@ -11698,7 +12595,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);
@@ -11772,7 +12669,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();
@@ -11880,13 +12777,116 @@ async function startOrchestration(opts) {
 }
 
 // src/index.ts
+init_workspace_scratch();
+
+// src/plan/ask-user.ts
+function asRecord3(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 = asRecord3(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 = asRecord3(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 = asRecord3(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/index.ts
+init_plan_present();
+init_plan_file();
 init_coordinator_prompt();
 
 // src/mcp/server.ts
 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");
 init_worktree();
 init_global_workspace();
 init_list_models();
@@ -11935,7 +12935,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 {
@@ -11997,6 +12997,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.",
@@ -12575,6 +13628,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.",
@@ -12944,6 +14117,7 @@ init_connected_teams();
 init_injected_mcp();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ATTACHMENTS_DIR,
   BRIGHTSY_MCP_ALLOWED_TOOLS,
   BrightsySideboardApi,
   CLAUDE_MODEL_CATALOG,
@@ -12959,11 +14133,16 @@ init_injected_mcp();
   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,
@@ -12973,6 +14152,8 @@ init_injected_mcp();
   SIDEBOARD_FORCE_STOP,
   SIDEBOARD_MCP_ALLOWED_TOOLS,
   THINKING_EFFORTS,
+  addPrStackLayer,
+  addStackLayerFromThread,
   addWorkspace,
   adoptThread,
   allAdapters,
@@ -12991,6 +14172,7 @@ init_injected_mcp();
   attachmentFromAbsolutePath,
   attachmentsFromBuffers,
   attachmentsFromWorktreePaths,
+  attachmentsGitignoreBody,
   autoCleanupOrphansEnabled,
   autoRenameBranchEnabled,
   autoRunAfterSetupEnabled,
@@ -13013,6 +14195,7 @@ init_injected_mcp();
   caffeinateWhileRunningEnabled,
   captureLoginEnv,
   captureTurnBaseline,
+  checkoutPrStackLayer,
   childEnvWithAppSettings,
   claudeAdapter,
   claudeChromeEnabled,
@@ -13032,8 +14215,10 @@ init_injected_mcp();
   countCacheControlBlocks,
   createChatTab,
   createEmptyThread,
+  createExistingBranchWorktree,
   createGlobalChat,
   createOrUpdatePr,
+  createPrStack,
   createThread,
   createThreadWorktree,
   currentBranch,
@@ -13043,6 +14228,7 @@ init_injected_mcp();
   deleteBranchOnPurgeEnabled,
   deleteThreadRecord,
   detectAgents,
+  detectGhStack,
   detectLocalMergeConflicts,
   disconnectBrightsyTeam,
   discoverSkills,
@@ -13058,12 +14244,15 @@ init_injected_mcp();
   estimateThreadChars,
   expandComposerPrompt,
   extractGhErrorDetail,
+  extractPendingPlanQuestions,
+  extractPresentedPlan,
   extractiveSummary,
   fetchPrHead,
   finalizeParts,
   findInvalidCacheControlTtlOrder,
   findOrphanWorktrees,
   findThreadByRef,
+  findThreadForStackLayer,
   flattenTurnInput,
   forkChatTab,
   forkMessageSlice,
@@ -13074,6 +14263,8 @@ init_injected_mcp();
   formatGhLandError,
   formatIpcInvokeError,
   formatMessagesAsTranscript,
+  formatPlanQuestionAnswers,
+  formatPlanQuestionsForChat,
   formatRateLimitResetHint,
   formatRenameBranchDirective,
   formatTranscriptMarkdown,
@@ -13097,6 +14288,7 @@ init_injected_mcp();
   getPrChecks,
   getPrDetails,
   getPrMeta,
+  getPrStack,
   getRepoSetupInfo,
   getRunMode,
   getRunScript,
@@ -13113,9 +14305,12 @@ init_injected_mcp();
   healOrchestrationSoccerTitles,
   importConductorWorkspace,
   importConductorWorkspaceAsync,
+  initPrStack,
+  initStackFromThread,
   initializeGitRepository,
   inspectGitWorktree,
   installAgent,
+  isAskUserToolName,
   isBrightsyConnected,
   isBrightsyNdjsonLine,
   isCloudCoordinatorThread,
@@ -13125,13 +14320,17 @@ init_injected_mcp();
   isGlobalRepoPath,
   isGlobalThread,
   isImageFilePath,
+  isInPrStack,
   isLinearConnected,
   isOrchestratorCapableAgent,
   isOrchestratorThread,
   isPidAlive,
   isPlaceholderBranch,
+  isPresentPlanToolName,
   isSessionQuotaLimit,
+  isSideboardScratchPath,
   isThinkingEffort,
+  isWorkspaceScratchPath,
   listAgentSetupInfo,
   listBranchCommits,
   listBranches,
@@ -13168,6 +14367,7 @@ init_injected_mcp();
   mcpAllowTools,
   mcpAuthWarnings,
   mergePr,
+  mergePrStack,
   mergeUsage,
   nextPastedTextName,
   nextThinkingEffort,
@@ -13177,6 +14377,8 @@ init_injected_mcp();
   normalizeTurnInput,
   normalizeWorktreePath,
   openInSystemTerminal,
+  openPrStackLayers,
+  openStackLayer,
   opencodeAdapter,
   orchestrationQuotaFallbackAgent,
   orchestrationQuotaOnLimit,
@@ -13185,15 +14387,19 @@ init_injected_mcp();
   originGhRepoEnv,
   parseCursorRunnerLine,
   parseForceStopMessage,
+  parseGhStackViewJson,
   parseGithubSlugFromRemoteUrl,
   parseMcpList,
+  parsePlanQuestionsInput,
   parseSessionQuotaResetAt,
   partsToAssistantText,
   pastedTextStats,
   permissionMode,
+  planFileAbs,
   previewLand,
   pushBranch,
   readExistingReviewRequestFile,
+  readPlanFile,
   readSkillBody,
   readThread,
   readWorktreeFile,
@@ -13205,6 +14411,7 @@ init_injected_mcp();
   repoSlug,
   requestReview,
   requireAgent,
+  resetGhStackDetectCache,
   resolveClaudeExecutable,
   resolveConductorCursorAgentId,
   resolveCursorModelId,
@@ -13212,7 +14419,9 @@ init_injected_mcp();
   resolveDiffBaseRef,
   resolveEffectiveIssueSource,
   resolveFilesToCopy,
+  resolveGhAuthToken,
   resolveGithubRepoSlug,
+  resolvePlanMarkdown,
   resolvePrSelector,
   resolveQuotaFallbackAgent,
   resolveRepoRoot,
@@ -13240,12 +14449,16 @@ init_injected_mcp();
   slugify,
   spawnAgentTurn,
   splitForCompaction,
+  stackAgentDefaultsFrom,
+  stackIdFrom,
+  stackMergeReadiness,
   stageAbsolutePathsAsAttachments,
   stageBuffersAsAttachments,
   startDevServer,
   startMcpServer,
   startOrchestration,
   stripBrightsyNdjsonNoise,
+  submitPrStack,
   suggestSlug,
   summarizeConversation,
   switchBrightsyAccount,
@@ -13281,6 +14494,7 @@ init_injected_mcp();
   worktreeNameFromPath,
   worktreesRoot,
   writeInjectedMcpConfig,
+  writePlanFile,
   writeThread,
   writeWorktreeFile
 });