@sideboard-ai/core 0.1.66 → 0.1.68

package/dist/mcp/run-stdio.js

@@ -16,14 +16,14 @@ import {
   resolveQuotaFallbackAgent,
   sideboardMcpProfile,
   summarizeTurnStderr
-} from "../chunk-BBEH2CJE.js";
-import "../chunk-EVD4KNKR.js";
+} from "../chunk-47RBLBRK.js";
+import "../chunk-VROPG6QF.js";
 import {
   addWorkspace,
   ensureWorkspace,
   removeWorkspace,
   syncWorkspacesFromThreads
-} from "../chunk-HTOTTJJX.js";
+} from "../chunk-QQC2D4MY.js";
 import {
   extractPresentedPlan,
   readPlanFile,
@@ -38,13 +38,13 @@ import {
   isGlobalThread,
   isOrchestratorThread,
   orchestratorSessionPoisonedByBuiltins
-} from "../chunk-DNPP7QMK.js";
+} from "../chunk-OICHV4DH.js";
 import {
   coordinatorSystemPrompt,
   coordinatorTurnReminder,
   enrichWorkspacesWithGithub,
   ensureGlobalCoordinatorCwd
-} from "../chunk-LRBRQFBU.js";
+} from "../chunk-N5LMEP65.js";
 import {
   addPrStackLayer,
   allocateTeamName,
@@ -81,7 +81,7 @@ import {
   takenSlugsFromThread,
   threadDisplayLabel,
   worktreeNameFromPath
-} from "../chunk-I2KGRAXC.js";
+} from "../chunk-REKGFVUX.js";
 import {
   ATTACHMENTS_DIR,
   LEGACY_ATTACHMENTS_DIR,
@@ -105,7 +105,7 @@ import {
   gh,
   git,
   run
-} from "../chunk-5AG5BUQN.js";
+} from "../chunk-AE5VBOFE.js";
 import {
   childEnvWithAppSettings,
   getLinearApiKey,
@@ -391,9 +391,9 @@ async function spawnAgentTurn(thread, input, onEvent) {
       `Cannot spawn ${thread.agent}: thread ${thread.id} has no worktreePath`
     );
   }
-  const { isGlobalThread: isGlobalThread2 } = await import("../global-workspace-5PM5LA6E.js");
+  const { isGlobalThread: isGlobalThread2 } = await import("../global-workspace-Z6GF7D2K.js");
   if (isGlobalThread2(thread)) {
-    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("../coordinator-prompt-E5UGSJES.js");
+    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("../coordinator-prompt-YZYZ5P6P.js");
     ensureGlobalCoordinatorCwd2(
       isOrchestratorThread(thread) ? { orchestratorThreadId: thread.id } : void 0
     );
@@ -1209,7 +1209,7 @@ async function createThread(input, _onSetupLine) {
   return readThread(thread.id) ?? thread;
 }
 async function listLinearIssues(agent, repoPath) {
-  const { getAdapter: getAdapter2 } = await import("../agents-MD7SCFYX.js");
+  const { getAdapter: getAdapter2 } = await import("../agents-PE3RHQS5.js");
   await requireAgent(agent, { requireLinear: true });
   const adapter = getAdapter2(agent);
   if (!adapter.listLinearIssues) {
@@ -2058,7 +2058,7 @@ async function adoptThread(input) {
     throw new Error(`Worktree not found: ${input.worktreePath}`);
   }
   const repoPath = await resolveRepoRoot(input.worktreePath);
-  const { stdout: branch } = await import("../run-74S2NZWB.js").then(
+  const { stdout: branch } = await import("../run-A4RHY7HH.js").then(
     ({ git: git2 }) => git2(["rev-parse", "--abbrev-ref", "HEAD"], input.worktreePath)
   );
   const thread = createEmptyThread({
@@ -2073,7 +2073,7 @@ async function adoptThread(input) {
     messages: input.messages ?? []
   });
   writeThread(thread);
-  const { ensureWorkspace: ensureWorkspace2 } = await import("../workspaces-RXFXQRRF.js");
+  const { ensureWorkspace: ensureWorkspace2 } = await import("../workspaces-O6EZGKQK.js");
   await ensureWorkspace2(repoPath);
   return thread;
 }
@@ -2630,24 +2630,25 @@ function capPatch(patch, maxHunk) {
 
 \u2026 truncated (${patch.length - maxHunk} more chars)`;
 }
+var mergeBaseCache = /* @__PURE__ */ new Map();
+var MERGE_BASE_TTL_MS = 45e3;
 async function resolveMergeBase(worktreePath, base, repoPath) {
   const baseRef = await resolveDiffBaseRef(worktreePath, base, repoPath);
+  const cacheKey = `${worktreePath}\0${baseRef}`;
+  const hit = mergeBaseCache.get(cacheKey);
+  if (hit && Date.now() - hit.at < MERGE_BASE_TTL_MS) return hit.value;
   const { stdout } = await git(["merge-base", baseRef, "HEAD"], worktreePath, {
     reject: false
   });
-  const mb = stdout.trim();
-  return mb || baseRef;
+  const mb = stdout.trim() || baseRef;
+  mergeBaseCache.set(cacheKey, { at: Date.now(), value: mb });
+  return mb;
 }
 async function countUnpushedCommits(worktreePath) {
   const head = await git(["rev-parse", "--abbrev-ref", "HEAD"], worktreePath, {
     reject: false
   });
   const branch = head.stdout.trim();
-  if (branch && branch !== "HEAD") {
-    await git(["fetch", "origin", branch, "--quiet"], worktreePath, {
-      reject: false
-    });
-  }
   const upstream = await git(
     ["rev-list", "--count", "@{upstream}..HEAD"],
     worktreePath,
@@ -2680,11 +2681,37 @@ function splitCombinedDiff(stdout) {
   }
   return map;
 }
+function syntheticAddPatch(path, content, maxHunk) {
+  const lines = content.split("\n");
+  const body = lines.map((l) => `+${l}`).join("\n");
+  const header = `diff --git a/${path} b/${path}
+new file mode 100644
+--- /dev/null
++++ b/${path}
+@@ -0,0 +1,${lines.length} @@
+`;
+  return {
+    path,
+    status: "A",
+    patch: capPatch(`${header}${body}`, maxHunk),
+    additions: lines.length,
+    deletions: 0
+  };
+}
 async function untrackedPatch(worktreePath, path, maxHunk) {
+  const abs = join7(worktreePath, path);
+  try {
+    const st = statSync2(abs);
+    if (st.isFile() && st.size > maxHunk) {
+      const buf = readFileSync5(abs).subarray(0, maxHunk);
+      return syntheticAddPatch(path, buf.toString("utf8"), maxHunk);
+    }
+  } catch {
+  }
   const { stdout: patch } = await git(
-    ["diff", "--no-index", "--", "/dev/null", path],
+    ["diff", "--no-ext-diff", "--no-color", "--no-index", "--", "/dev/null", path],
     worktreePath,
-    { reject: false }
+    { reject: false, timeoutMs: 4e3 }
   );
   const normalized = patch.replace(/^diff --git a\/.+? b\/.+?$/m, `diff --git a/${path} b/${path}`).replace(/^--- .*$/m, "--- /dev/null").replace(/^\+\+\+ .*$/m, `+++ b/${path}`);
   const addLines = normalized.split("\n").filter((l) => l.startsWith("+") && !l.startsWith("+++")).length;
@@ -2696,22 +2723,97 @@ async function untrackedPatch(worktreePath, path, maxHunk) {
     deletions: 0
   };
 }
-async function listUntrackedPaths(worktreePath) {
-  const { stdout } = await git(
-    ["ls-files", "-z", "--others", "--exclude-standard"],
-    worktreePath,
-    { reject: false }
-  );
+async function listUntrackedPaths(worktreePath, path) {
+  const args = ["ls-files", "-z", "--others", "--exclude-standard"];
+  if (path) args.push("--", path);
+  const { stdout } = await git(args, worktreePath, { reject: false });
   return stdout.split("\0").filter(Boolean).filter((p) => !isSideboardScratchPath(p));
 }
-async function listUntrackedFiles(worktreePath, maxHunk) {
-  const paths = await listUntrackedPaths(worktreePath);
-  if (paths.length === 0) return [];
-  return Promise.all(paths.map((path) => untrackedPatch(worktreePath, path, maxHunk)));
+async function listUntrackedFiles(worktreePath, maxHunk, paths) {
+  const list = paths ?? await listUntrackedPaths(worktreePath);
+  if (list.length === 0) return [];
+  return Promise.all(list.map((path) => untrackedPatch(worktreePath, path, maxHunk)));
+}
+function untrackedStubs(paths) {
+  return paths.map((path) => ({
+    path,
+    status: "A",
+    patch: "",
+    additions: 0,
+    deletions: 0
+  }));
+}
+function pathspec(path) {
+  return path ? ["--", path] : [];
+}
+function gitDiff(args, cwd, opts) {
+  return git(["diff", "--no-ext-diff", "--no-color", ...args], cwd, {
+    reject: false,
+    timeoutMs: opts?.timeoutMs
+  });
+}
+function fileFromPatch(path, patch, maxHunk) {
+  let status = "M";
+  if (/^new file mode /m.test(patch) || /^--- \/dev\/null/m.test(patch)) {
+    status = "A";
+  } else if (/^deleted file mode /m.test(patch) || /^\+\+\+ \/dev\/null/m.test(patch)) {
+    status = "D";
+  } else if (/^rename from /m.test(patch)) {
+    status = "R";
+  }
+  const additions = patch.split("\n").filter((l) => l.startsWith("+") && !l.startsWith("+++")).length;
+  const deletions = patch.split("\n").filter((l) => l.startsWith("-") && !l.startsWith("---")).length;
+  return {
+    path,
+    status,
+    patch: capPatch(patch, maxHunk),
+    additions,
+    deletions
+  };
+}
+async function gitDiffParts(worktreePath, diffArgs, includePatches, path) {
+  const extra = pathspec(path);
+  if (includePatches) {
+    const diff = await gitDiff([...diffArgs, ...extra], worktreePath, {
+      timeoutMs: 4e3
+    });
+    return { nameStatus: "", numstat: "", combinedDiff: diff.stdout };
+  }
+  const [ns, num] = await Promise.all([
+    gitDiff(["--name-status", ...diffArgs, ...extra], worktreePath),
+    gitDiff(["--numstat", ...diffArgs, ...extra], worktreePath)
+  ]);
+  return {
+    nameStatus: ns.stdout,
+    numstat: num.stdout,
+    combinedDiff: ""
+  };
+}
+function formatStat(files) {
+  if (files.length === 0) return "(no changes)";
+  const additions = files.reduce((n2, f) => n2 + (f.additions ?? 0), 0);
+  const deletions = files.reduce((n2, f) => n2 + (f.deletions ?? 0), 0);
+  const n = files.length;
+  return `${n} file${n === 1 ? "" : "s"} changed, ${additions} insertions(+), ${deletions} deletions(-)`;
+}
+function emptyScopeStats() {
+  const z2 = emptyStat();
+  return {
+    commits: z2,
+    uncommitted: z2,
+    staged: z2,
+    unstaged: z2,
+    last_turn: z2
+  };
 }
 function filesFromDiff(nameStatus, numstat, combinedDiff, maxHunk) {
-  const counts = parseNumstat(numstat);
   const patches = splitCombinedDiff(combinedDiff);
+  if (!nameStatus.trim() && patches.size > 0) {
+    return [...patches.entries()].map(
+      ([path, patch]) => fileFromPatch(path, patch, maxHunk)
+    );
+  }
+  const counts = parseNumstat(numstat);
   const files = [];
   for (const { status, path } of parseNameStatus(nameStatus)) {
     const n = counts.get(path);
@@ -2733,11 +2835,11 @@ async function computeScopeStats(worktreePath, mergeBase, lastTurnBase, untracke
     { stdout: unstagedNum },
     lastTurnNum
   ] = await Promise.all([
-    mergeBase ? git(["diff", "--numstat", mergeBase], worktreePath, { reject: false }) : Promise.resolve({ stdout: "" }),
-    git(["diff", "--numstat", "HEAD"], worktreePath, { reject: false }),
-    git(["diff", "--numstat", "--cached"], worktreePath, { reject: false }),
-    git(["diff", "--numstat"], worktreePath, { reject: false }),
-    lastTurnBase ? git(["diff", "--numstat", lastTurnBase], worktreePath, { reject: false }) : Promise.resolve({ stdout: "" })
+    mergeBase ? gitDiff(["--numstat", mergeBase], worktreePath) : Promise.resolve({ stdout: "" }),
+    gitDiff(["--numstat", "HEAD"], worktreePath),
+    gitDiff(["--numstat", "--cached"], worktreePath),
+    gitDiff(["--numstat"], worktreePath),
+    lastTurnBase ? gitDiff(["--numstat", lastTurnBase], worktreePath) : Promise.resolve({ stdout: "" })
   ]);
   return {
     commits: mergeBase ? statFromNumstat(commitsNum, untrackedCount) : emptyStat(),
@@ -2756,7 +2858,7 @@ async function listBranchCommits(worktreePath, repoPath, opts) {
   if (head.exitCode !== 0) return [];
   let base = opts?.base;
   try {
-    base = base ?? await resolveDefaultBranch(repoPath);
+    base = base ?? await resolveDefaultBranch(repoPath, { network: false });
   } catch {
     base = "HEAD";
   }
@@ -2786,7 +2888,121 @@ async function listBranchCommits(worktreePath, repoPath, opts) {
   }
   return commits;
 }
+var SHA_RE = /^[0-9a-f]{7,40}$/i;
+function emptyPathDiff(scope, base, hasLastTurnBase, commitSha = null) {
+  return {
+    scope,
+    commitSha: scope === "commits" ? commitSha : null,
+    base,
+    files: [],
+    stat: formatStat([]),
+    dirty: false,
+    unpushed: 0,
+    hasLastTurnBase,
+    commits: [],
+    scopeStats: emptyScopeStats()
+  };
+}
+async function getPathDiff(worktreePath, repoPath, opts) {
+  const { path, scope, commitSha, lastTurnBase, hasLastTurnBase, includePatches, maxHunk } = opts;
+  if (scope === "last_turn" && !lastTurnBase) {
+    return emptyPathDiff(scope, "last turn", false);
+  }
+  let diffArgs;
+  let labelBase;
+  if (scope === "staged") {
+    diffArgs = ["--cached"];
+    labelBase = "staged";
+  } else if (scope === "unstaged") {
+    diffArgs = [];
+    labelBase = "unstaged";
+  } else if (scope === "uncommitted") {
+    diffArgs = ["HEAD"];
+    labelBase = "HEAD";
+  } else if (scope === "last_turn") {
+    diffArgs = [lastTurnBase];
+    labelBase = "last turn";
+  } else if (scope === "commits" && commitSha) {
+    diffArgs = [`${commitSha}^!`];
+    labelBase = commitSha.slice(0, 7);
+  } else if (scope === "commits" && opts.base && SHA_RE.test(opts.base)) {
+    diffArgs = [opts.base];
+    labelBase = opts.base.slice(0, 7);
+  } else if (scope === "commits") {
+    let base = opts.base;
+    try {
+      base = base ?? await resolveDefaultBranch(repoPath, { network: false });
+    } catch {
+      base = "HEAD";
+    }
+    const mergeBase = await resolveMergeBase(worktreePath, base, repoPath);
+    diffArgs = [mergeBase];
+    labelBase = mergeBase;
+  } else {
+    diffArgs = ["HEAD"];
+    labelBase = "HEAD";
+  }
+  const diff = await gitDiff(
+    includePatches ? [...diffArgs, "--", path] : ["--name-status", ...diffArgs, "--", path],
+    worktreePath,
+    { timeoutMs: 4e3 }
+  );
+  const filesMap = /* @__PURE__ */ new Map();
+  if (includePatches) {
+    const parsed = filesFromDiff("", "", diff.stdout, maxHunk);
+    for (const file of parsed) filesMap.set(file.path, file);
+    if (diff.stdout.trim() && !filesMap.has(path)) {
+      filesMap.set(path, fileFromPatch(path, diff.stdout, maxHunk));
+    }
+  } else {
+    for (const file of filesFromDiff(diff.stdout, "", "", maxHunk)) {
+      filesMap.set(file.path, file);
+    }
+  }
+  if (filesMap.size === 0) {
+    const maybe = await listUntrackedPaths(worktreePath, path);
+    if (maybe.length > 0) {
+      const extra = includePatches ? await listUntrackedFiles(worktreePath, maxHunk, maybe) : untrackedStubs(maybe);
+      for (const file of extra) filesMap.set(file.path, file);
+    }
+  }
+  const files = [...filesMap.values()].sort((a, b) => a.path.localeCompare(b.path));
+  return {
+    scope,
+    commitSha: scope === "commits" ? commitSha : null,
+    base: labelBase,
+    files,
+    stat: formatStat(files),
+    dirty: files.length > 0,
+    unpushed: 0,
+    hasLastTurnBase,
+    commits: [],
+    scopeStats: emptyScopeStats(),
+    mergeBase: SHA_RE.test(diffArgs[0] ?? "") ? diffArgs[0] : null
+  };
+}
 async function getDiff(worktreePath, repoPath, opts) {
+  const maxHunk = opts?.maxHunkChars ?? 8e3;
+  const scope = opts?.scope ?? "commits";
+  const lastTurnBase = opts?.lastTurnBase?.trim() || null;
+  const hasLastTurnBase = Boolean(lastTurnBase);
+  const commitSha = opts?.commitSha?.trim() || null;
+  const includePatches = opts?.includePatches ?? true;
+  const pathFilter = opts?.path?.trim() || null;
+  const fileOnly = Boolean(pathFilter);
+  const includeMeta = (opts?.includeMeta ?? true) && !fileOnly;
+  if (fileOnly && pathFilter && !includeMeta) {
+    return getPathDiff(worktreePath, repoPath, {
+      path: pathFilter,
+      scope,
+      commitSha,
+      lastTurnBase,
+      hasLastTurnBase,
+      base: opts?.base,
+      includePatches,
+      maxHunk
+    });
+  }
   const status = await inspectGitWorktree(worktreePath);
   if (status === "missing_worktree") {
     throw new Error("Worktree not found");
@@ -2794,18 +3010,19 @@ async function getDiff(worktreePath, repoPath, opts) {
   if (status === "not_git") {
     throw new Error("Not a Git repository");
   }
-  const maxHunk = opts?.maxHunkChars ?? 8e3;
-  const scope = opts?.scope ?? "commits";
-  const lastTurnBase = opts?.lastTurnBase?.trim() || null;
-  const hasLastTurnBase = Boolean(lastTurnBase);
-  const commitSha = opts?.commitSha?.trim() || null;
-  const head = await git(["rev-parse", "--verify", "HEAD"], worktreePath, {
+  const wantUntracked = opts?.includeUntracked !== void 0 ? opts.includeUntracked : !fileOnly && (scope === "commits" && !commitSha || scope === "uncommitted" || scope === "unstaged" || scope === "last_turn");
+  const needsMergeBase = scope === "commits" && !commitSha || includeMeta;
+  const headP = git(["rev-parse", "--verify", "HEAD"], worktreePath, {
     reject: false
   });
+  const untrackedP = wantUntracked ? listUntrackedPaths(worktreePath, pathFilter) : Promise.resolve([]);
+  const head = await headP;
   const hasHead = head.exitCode === 0;
-  const untrackedPaths = await listUntrackedPaths(worktreePath);
   if (!hasHead) {
-    const files2 = scope === "staged" ? [] : (await listUntrackedFiles(worktreePath, maxHunk)).sort(
+    const untrackedPaths2 = await untrackedP;
+    const files2 = scope === "staged" ? [] : includePatches ? (await listUntrackedFiles(worktreePath, maxHunk, untrackedPaths2)).sort(
+      (a, b) => a.path.localeCompare(b.path)
+    ) : untrackedStubs(untrackedPaths2).sort(
       (a, b) => a.path.localeCompare(b.path)
     );
     const untrackedStat = {
@@ -2819,7 +3036,7 @@ async function getDiff(worktreePath, repoPath, opts) {
       commitSha: null,
       base: "(no commits)",
       files: files2,
-      stat: files2.length ? files2.map((f) => ` ${f.path} | untracked`).join("\n") : "(no changes)",
+      stat: formatStat(files2),
       dirty: files2.length > 0,
       unpushed: 0,
       hasLastTurnBase,
@@ -2833,137 +3050,122 @@ async function getDiff(worktreePath, repoPath, opts) {
       }
     };
   }
-  let base = opts?.base;
-  try {
-    base = base ?? await resolveDefaultBranch(repoPath);
-  } catch {
-    base = "HEAD";
-  }
-  base = await resolveDiffBaseRef(worktreePath, base, repoPath);
-  if (base.startsWith("origin/")) {
-    const short = base.slice("origin/".length);
-    await git(["fetch", "origin", short, "--quiet"], worktreePath, {
-      reject: false
-    });
-    base = await resolveDiffBaseRef(worktreePath, short, repoPath);
+  let mergeBase = "HEAD";
+  let baseLabel = "HEAD";
+  if (needsMergeBase) {
+    let base = opts?.base;
+    try {
+      base = base ?? await resolveDefaultBranch(repoPath, { network: false });
+    } catch {
+      base = "HEAD";
+    }
+    mergeBase = await resolveMergeBase(worktreePath, base, repoPath);
+    baseLabel = await resolveDiffBaseRef(worktreePath, base, repoPath);
+  }
+  const includeUntracked = wantUntracked;
+  const metaPromise = includeMeta ? Promise.all([
+    computeScopeStats(
+      worktreePath,
+      mergeBase,
+      lastTurnBase,
+      // Cheap: don't wait on the untracked walk just to pad the badge.
+      0
+    ),
+    listBranchCommits(worktreePath, repoPath, { base: baseLabel }),
+    isDirty(worktreePath),
+    countUnpushedCommits(worktreePath)
+  ]).then(([scopeStats, commits, dirty, unpushed]) => ({
+    scopeStats,
+    commits,
+    dirty,
+    unpushed
+  })) : Promise.resolve({
+    scopeStats: emptyScopeStats(),
+    commits: [],
+    dirty: false,
+    unpushed: 0
+  });
+  if (scope === "last_turn" && !lastTurnBase) {
+    const meta2 = await metaPromise;
+    return {
+      scope,
+      commitSha: null,
+      base: "last turn",
+      files: [],
+      stat: "(no last agent turn)",
+      dirty: meta2.dirty,
+      unpushed: meta2.unpushed,
+      hasLastTurnBase: false,
+      commits: meta2.commits,
+      scopeStats: meta2.scopeStats
+    };
   }
-  const mergeBase = await resolveMergeBase(worktreePath, base, repoPath);
-  const scopeStats = await computeScopeStats(
-    worktreePath,
-    mergeBase,
-    lastTurnBase,
-    untrackedPaths.length
-  );
-  const includeUntracked = scope === "commits" && !commitSha || scope === "uncommitted" || scope === "unstaged" || scope === "last_turn";
-  let nameStatus = "";
-  let numstat = "";
-  let combinedDiff = "";
-  let labelBase = base;
+  let diffArgs;
+  let labelBase = baseLabel;
   if (scope === "staged") {
-    const [ns, num, 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;
-    combinedDiff = diff.stdout;
+    diffArgs = ["--cached"];
     labelBase = "staged";
   } else if (scope === "unstaged") {
-    const [ns, num, 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;
-    combinedDiff = diff.stdout;
+    diffArgs = [];
     labelBase = "unstaged";
   } else if (scope === "uncommitted") {
-    const [ns, num, 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;
-    combinedDiff = diff.stdout;
+    diffArgs = ["HEAD"];
     labelBase = "HEAD";
   } else if (scope === "last_turn") {
-    if (!lastTurnBase) {
-      const commits2 = await listBranchCommits(worktreePath, repoPath, { base });
-      return {
-        scope,
-        commitSha: null,
-        base: "last turn",
-        files: [],
-        stat: "(no last agent turn)",
-        dirty: await isDirty(worktreePath),
-        unpushed: await countUnpushedCommits(worktreePath),
-        hasLastTurnBase: false,
-        commits: commits2,
-        scopeStats
-      };
-    }
-    const [ns, num, 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;
-    combinedDiff = diff.stdout;
+    diffArgs = [lastTurnBase];
     labelBase = "last turn";
   } else if (scope === "commits" && commitSha) {
-    const range = `${commitSha}^!`;
-    const [ns, num, 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;
-    combinedDiff = diff.stdout;
+    diffArgs = [`${commitSha}^!`];
     labelBase = commitSha.slice(0, 7);
   } else {
-    const [ns, num, 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;
-    combinedDiff = diff.stdout;
-    labelBase = base;
-  }
-  const commits = await listBranchCommits(worktreePath, repoPath, { base });
+    diffArgs = [mergeBase];
+    labelBase = baseLabel;
+  }
+  const partsPromise = gitDiffParts(
+    worktreePath,
+    diffArgs,
+    includePatches,
+    pathFilter
+  );
+  const [parts, meta, untrackedPaths] = await Promise.all([
+    partsPromise,
+    metaPromise,
+    untrackedP
+  ]);
   const filesMap = /* @__PURE__ */ new Map();
-  for (const file of filesFromDiff(nameStatus, numstat, combinedDiff, maxHunk)) {
+  for (const file of filesFromDiff(
+    parts.nameStatus,
+    parts.numstat,
+    parts.combinedDiff,
+    maxHunk
+  )) {
     filesMap.set(file.path, file);
   }
   if (includeUntracked) {
-    const untrackedFiles = await listUntrackedFiles(worktreePath, maxHunk);
-    for (const file of untrackedFiles) {
+    const extra = includePatches ? await listUntrackedFiles(worktreePath, maxHunk, untrackedPaths) : untrackedStubs(untrackedPaths);
+    for (const file of extra) {
       if (!filesMap.has(file.path)) filesMap.set(file.path, file);
     }
+  } else if (fileOnly && pathFilter && !filesMap.has(pathFilter)) {
+    const maybe = await listUntrackedPaths(worktreePath, pathFilter);
+    if (maybe.length > 0) {
+      const extra = includePatches ? await listUntrackedFiles(worktreePath, maxHunk, maybe) : untrackedStubs(maybe);
+      for (const file of extra) filesMap.set(file.path, file);
+    }
   }
   const files = [...filesMap.values()].sort((a, b) => a.path.localeCompare(b.path));
-  const { stdout: statOut } = await git(
-    scope === "staged" ? ["diff", "--stat", "--cached"] : scope === "unstaged" ? ["diff", "--stat"] : scope === "uncommitted" ? ["diff", "--stat", "HEAD"] : scope === "last_turn" && lastTurnBase ? ["diff", "--stat", lastTurnBase] : scope === "commits" && commitSha ? ["diff", "--stat", `${commitSha}^!`] : ["diff", "--stat", mergeBase],
-    worktreePath,
-    { reject: false }
-  );
   return {
     scope,
     commitSha: scope === "commits" ? commitSha : null,
     base: labelBase,
     files,
-    stat: statOut.trim() || (files.length ? `${files.length} file(s)` : "(no changes)"),
-    dirty: await isDirty(worktreePath),
-    unpushed: await countUnpushedCommits(worktreePath),
+    stat: formatStat(files),
+    dirty: fileOnly || !includeMeta ? files.length > 0 : meta.dirty,
+    unpushed: meta.unpushed,
     hasLastTurnBase,
-    commits,
-    scopeStats
+    commits: meta.commits,
+    scopeStats: meta.scopeStats,
+    mergeBase: needsMergeBase ? mergeBase : null
   };
 }
 async function listWorktreeFiles(worktreePath, opts) {
@@ -3179,7 +3381,7 @@ async function previewLand(thread) {
   const target = await resolveDefaultBranch(thread.repoPath);
   if (thread.branchName === target || thread.branchName === "main" || thread.branchName === "master") {
   }
-  const { stdout: head } = await import("../run-74S2NZWB.js").then(
+  const { stdout: head } = await import("../run-A4RHY7HH.js").then(
     ({ git: git2 }) => git2(["rev-parse", "--abbrev-ref", "HEAD"], thread.worktreePath)
   );
   const current = head.trim();
@@ -3218,7 +3420,7 @@ async function confirmLand(thread, opts) {
   if (preview.dirty) {
     committed = await commitAll(thread.worktreePath, meta.commitMessage);
   }
-  const { git: git2 } = await import("../run-74S2NZWB.js");
+  const { git: git2 } = await import("../run-A4RHY7HH.js");
   const { stdout: headOut } = await git2(
     ["rev-parse", "--abbrev-ref", "HEAD"],
     thread.worktreePath,
@@ -4902,6 +5104,11 @@ var Orchestrator = class {
     return getDiff(thread.worktreePath, thread.repoPath, {
       scope: opts?.scope,
       commitSha: opts?.commitSha,
+      base: opts?.base,
+      includePatches: opts?.includePatches,
+      includeMeta: opts?.includeMeta,
+      includeUntracked: opts?.includeUntracked,
+      path: opts?.path,
       lastTurnBase: this.turnBaselines.get(thread.id) ?? null
     });
   }
@@ -5253,7 +5460,7 @@ var Orchestrator = class {
     this.emit({ type: "status_changed", threadId: archived.id, status: "archived" });
     if (thread.repoPath && !isGlobalRepoPath(thread.repoPath)) {
       try {
-        const { ensureWorkspace: ensureWorkspace2 } = await import("../workspaces-RXFXQRRF.js");
+        const { ensureWorkspace: ensureWorkspace2 } = await import("../workspaces-O6EZGKQK.js");
         await ensureWorkspace2(thread.repoPath);
       } catch {
       }
@@ -5295,7 +5502,7 @@ var Orchestrator = class {
       return restored2;
     }
     if (!existsSync13(thread.worktreePath)) {
-      const { createThreadWorktree: createThreadWorktree2 } = await import("../worktree-S2N63FLV.js");
+      const { createThreadWorktree: createThreadWorktree2 } = await import("../worktree-VDXLUOWR.js");
       const { execa: execa6 } = await import("execa");
       const slug = thread.worktreePath.split("/").pop();
       const dest = thread.worktreePath;