@sideboard-ai/core 0.1.51 → 0.1.53

package/dist/{chunk-ZH5QZ4CR.js → chunk-DZFH2KLT.js}

@@ -1,6 +1,9 @@
+import {
+  isWorkspaceScratchPath
+} from "./chunk-FKOIHGKV.js";
 import {
   listThreads
-} from "./chunk-O6W3P7V3.js";
+} from "./chunk-TSRXOSVD.js";
 import {
   worktreesRoot
 } from "./chunk-M37RITA6.js";
@@ -970,6 +973,206 @@ function buildMergeGateChecks(gate, opts = {}) {
   return rows;
 }
 
+// src/git/stack.ts
+var cachedStatus = null;
+var STATUS_TTL_MS = 6e4;
+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");
+  }
+}
+
 // src/git/worktree.ts
 async function lookupGithubGraphqlReset(cwd) {
   const result = await gh(["api", "rate_limit"], cwd, { reject: false });
@@ -1646,6 +1849,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 = join(worktreesRoot(opts.repoPath), opts.slug);
+  if (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
@@ -1685,8 +1934,7 @@ async function isDirty(worktreePath) {
   return false;
 }
 function isSideboardScratchPath(relativePath) {
-  const p = relativePath.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/$/, "");
-  return p === ".sideboard/attachments" || p.startsWith(".sideboard/attachments/");
+  return isWorkspaceScratchPath(relativePath);
 }
 function porcelainStatusPath(line) {
   const rest = line.length >= 3 ? line.slice(3) : "";
@@ -1714,7 +1962,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()) {
@@ -1722,16 +1970,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);
@@ -1753,10 +2014,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 {
     }
@@ -1910,6 +2171,17 @@ export {
   extractGhErrorDetail,
   formatGhLandError,
   formatIpcInvokeError,
+  detectGhStack,
+  resetGhStackDetectCache,
+  parseGhStackViewJson,
+  stackMergeReadiness,
+  getPrStack,
+  isInPrStack,
+  mergePrStack,
+  initPrStack,
+  addPrStackLayer,
+  submitPrStack,
+  checkoutPrStackLayer,
   slugify,
   resolveRepoRoot,
   parseGithubSlugFromRemoteUrl,
@@ -1931,6 +2203,7 @@ export {
   fetchPrHead,
   resolveWorktreeStartPoint,
   createThreadWorktree,
+  createExistingBranchWorktree,
   removeWorktree,
   listWorktrees,
   isDirty,

package/dist/chunk-FKOIHGKV.js

@@ -0,0 +1,21 @@
+// src/paths/workspace-scratch.ts
+var ATTACHMENTS_DIR = ".context/attachments";
+var LEGACY_ATTACHMENTS_DIR = ".sideboard/attachments";
+var ATTACHMENTS_GITIGNORE = `# Sideboard / workspace attachments (local only)
+*
+!.gitignore
+`;
+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/");
+}
+
+export {
+  ATTACHMENTS_DIR,
+  LEGACY_ATTACHMENTS_DIR,
+  attachmentsGitignoreBody,
+  isWorkspaceScratchPath
+};

package/dist/{chunk-E4VVEKAM.js → chunk-GNML24AW.js}

@@ -1,10 +1,10 @@
 import {
   isGlobalRepoPath
-} from "./chunk-O5DOO7DP.js";
+} from "./chunk-XX5BB7NV.js";
 import {
   ensureGhPreferOrigin,
   resolveRepoRoot
-} from "./chunk-ZH5QZ4CR.js";
+} from "./chunk-DZFH2KLT.js";
 import {
   appDataDir
 } from "./chunk-M37RITA6.js";

package/dist/{chunk-EOYDCKQC.js → chunk-HLEX5AQ6.js}

@@ -41,6 +41,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,
@@ -65,6 +67,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 ?? [],

package/dist/{chunk-K3WMKGFY.js → chunk-LRLKJM3O.js}

@@ -1,6 +1,6 @@
 import {
   resolveGithubRepoSlug
-} from "./chunk-ZH5QZ4CR.js";
+} from "./chunk-DZFH2KLT.js";
 import {
   globalAgentCwd,
   sideboardReposDir
@@ -42,6 +42,7 @@ var COORDINATOR_TOOL_PLAYBOOK = [
   "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:",

package/dist/chunk-N5PM7HGQ.js

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+
+import {
+  ATTACHMENTS_DIR,
+  LEGACY_ATTACHMENTS_DIR,
+  attachmentsGitignoreBody
+} from "./chunk-B3SJXYIJ.js";
+
+// src/plan/plan-file.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+
+// src/plan/plan-present.ts
+var PLAN_FILE_REL = `${ATTACHMENTS_DIR}/plan.md`;
+var PLAN_FILE_NAME = "plan.md";
+var LEGACY_PLAN_FILE_REL = ".sideboard/plan.md";
+function asRecord(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 = asRecord(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;
+}
+
+// src/plan/plan-file.ts
+function ensureAttachmentsGitignore(worktreePath) {
+  const gitignoreAbs = join(worktreePath, ATTACHMENTS_DIR, ".gitignore");
+  if (existsSync(gitignoreAbs)) return;
+  mkdirSync(dirname(gitignoreAbs), { recursive: true });
+  writeFileSync(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
+}
+function planFileAbs(worktreePath) {
+  return join(worktreePath, PLAN_FILE_REL);
+}
+function readTextIfPresent(abs) {
+  if (!existsSync(abs)) return null;
+  try {
+    const content = readFileSync(abs, "utf8");
+    return content.trim() ? content : null;
+  } catch {
+    return null;
+  }
+}
+function readPlanFile(worktreePath) {
+  return readTextIfPresent(planFileAbs(worktreePath)) ?? readTextIfPresent(join(worktreePath, `${LEGACY_ATTACHMENTS_DIR}/plan.md`)) ?? readTextIfPresent(join(worktreePath, LEGACY_PLAN_FILE_REL));
+}
+function writePlanFile(worktreePath, content) {
+  ensureAttachmentsGitignore(worktreePath);
+  const abs = planFileAbs(worktreePath);
+  mkdirSync(dirname(abs), { recursive: true });
+  const body = content.trimEnd() + (content.endsWith("\n") ? "" : "\n");
+  writeFileSync(abs, body, "utf8");
+  return PLAN_FILE_REL;
+}
+
+export {
+  PLAN_FILE_REL,
+  PLAN_FILE_NAME,
+  LEGACY_PLAN_FILE_REL,
+  isPresentPlanToolName,
+  extractPresentedPlan,
+  resolvePlanMarkdown,
+  planFileAbs,
+  readPlanFile,
+  writePlanFile
+};

package/dist/chunk-QTUESPAW.js

@@ -0,0 +1,101 @@
+import {
+  ATTACHMENTS_DIR,
+  LEGACY_ATTACHMENTS_DIR,
+  attachmentsGitignoreBody
+} from "./chunk-FKOIHGKV.js";
+
+// src/plan/plan-file.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+
+// src/plan/plan-present.ts
+var PLAN_FILE_REL = `${ATTACHMENTS_DIR}/plan.md`;
+var PLAN_FILE_NAME = "plan.md";
+var LEGACY_PLAN_FILE_REL = ".sideboard/plan.md";
+function asRecord(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 = asRecord(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;
+}
+
+// src/plan/plan-file.ts
+function ensureAttachmentsGitignore(worktreePath) {
+  const gitignoreAbs = join(worktreePath, ATTACHMENTS_DIR, ".gitignore");
+  if (existsSync(gitignoreAbs)) return;
+  mkdirSync(dirname(gitignoreAbs), { recursive: true });
+  writeFileSync(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
+}
+function planFileAbs(worktreePath) {
+  return join(worktreePath, PLAN_FILE_REL);
+}
+function readTextIfPresent(abs) {
+  if (!existsSync(abs)) return null;
+  try {
+    const content = readFileSync(abs, "utf8");
+    return content.trim() ? content : null;
+  } catch {
+    return null;
+  }
+}
+function readPlanFile(worktreePath) {
+  return readTextIfPresent(planFileAbs(worktreePath)) ?? readTextIfPresent(join(worktreePath, `${LEGACY_ATTACHMENTS_DIR}/plan.md`)) ?? readTextIfPresent(join(worktreePath, LEGACY_PLAN_FILE_REL));
+}
+function writePlanFile(worktreePath, content) {
+  ensureAttachmentsGitignore(worktreePath);
+  const abs = planFileAbs(worktreePath);
+  mkdirSync(dirname(abs), { recursive: true });
+  const body = content.trimEnd() + (content.endsWith("\n") ? "" : "\n");
+  writeFileSync(abs, body, "utf8");
+  return PLAN_FILE_REL;
+}
+
+export {
+  PLAN_FILE_REL,
+  PLAN_FILE_NAME,
+  LEGACY_PLAN_FILE_REL,
+  isPresentPlanToolName,
+  extractPresentedPlan,
+  resolvePlanMarkdown,
+  planFileAbs,
+  readPlanFile,
+  writePlanFile
+};

package/dist/{chunk-O6W3P7V3.js → chunk-TSRXOSVD.js}

@@ -39,6 +39,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,
@@ -63,6 +65,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 ?? [],

package/dist/{chunk-F4Q3IM6V.js → chunk-UEAHMGHW.js}

@@ -2,7 +2,7 @@
 
 import {
   resolveGithubRepoSlug
-} from "./chunk-XRSAGVRW.js";
+} from "./chunk-XOU6HNQJ.js";
 import {
   globalAgentCwd,
   sideboardReposDir
@@ -44,6 +44,7 @@ var COORDINATOR_TOOL_PLAYBOOK = [
   "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:",

package/dist/{chunk-J5JTEJ5O.js → chunk-VG22SETP.js}

@@ -60,6 +60,11 @@ function summarizeTurnStderr(tail, maxChars = 500) {
   if (joined.length <= maxChars) return joined;
   return joined.slice(joined.length - maxChars);
 }
+function looksLikeInvalidAgentSession(text) {
+  const lower = text.trim().toLowerCase();
+  if (!lower) return false;
+  return /session not found/.test(lower) || /no conversation found/.test(lower) || /conversation .+ not found/.test(lower) || /thread .+ not found/.test(lower) || /unknown session/.test(lower) || /invalid session/.test(lower) || /session .+ (missing|expired|deleted|gone)/.test(lower) || /cannot resume/.test(lower) || /failed to (load|resume|open) session/.test(lower);
+}
 function looksLikeAgentFailureMessage(text) {
   const lower = text.trim().toLowerCase();
   if (!lower) return false;
@@ -212,6 +217,7 @@ export {
   extractJsonErrorMessage,
   pushTurnStderr,
   summarizeTurnStderr,
+  looksLikeInvalidAgentSession,
   looksLikeAgentFailureMessage,
   fallbackTurnFailDetail,
   humanizeAgentFailDetail,