pi-jar 0.1.5 → 0.1.7

package/src/changes.ts

@@ -6,6 +6,8 @@ export const MAX_TRACKED_BYTES = 1024 * 1024;
 export const MAX_TRACKED_FILES = 200;
 /** Bound total retained baselines so a long editing session cannot pin hundreds of MiB. */
 export const MAX_TRACKED_TOTAL_BYTES = 8 * 1024 * 1024;
+/** Explicit full-review choice supports bounded matrix-free previews beyond the exact-diff budget. */
+export const MAX_REVIEW_DIFF_LINES = 100_000;
 /** Keep the quadratic fallback small; larger edits render a summary instead of allocating a huge matrix. */
 const MAX_DIFF_CELLS = 500_000;
 const MAX_DIFF_MIDDLE_LINES = 4_000;
@@ -27,6 +29,29 @@ function readText(path: string): string | null | undefined {
 
 const splitLines = (text: string) => text === "" ? [] : text.replace(/\r\n/g, "\n").replace(/\n$/, "").split("\n");
 
+export function diffLineCount(text: string): number {
+  if (!text) return 0;
+  let count = 1;
+  for (let index = 0; index < text.length; index++) if (text.charCodeAt(index) === 10) count++;
+  if (text.endsWith("\n")) count--;
+  return count;
+}
+
+/** Safe O(n) fallback that preserves common prefix/suffix and clearly marks coarse replacements. */
+export function coarseLineDiff(before: string, after: string): DiffOp[] {
+  const a = splitLines(before), b = splitLines(after);
+  let start = 0;
+  while (start < a.length && start < b.length && a[start] === b[start]) start++;
+  let endA = a.length, endB = b.length;
+  while (endA > start && endB > start && a[endA - 1] === b[endB - 1]) { endA--; endB--; }
+  return [
+    ...a.slice(0, start).map(text => ({ op: " " as const, text })),
+    ...a.slice(start, endA).map(text => ({ op: "-" as const, text })),
+    ...b.slice(start, endB).map(text => ({ op: "+" as const, text })),
+    ...a.slice(endA).map(text => ({ op: " " as const, text }))
+  ];
+}
+
 /** Line diff: trims the common prefix/suffix, then an LCS over the changed middle. */
 export function lineDiff(before: string, after: string): DiffOp[] | undefined {
   const a = splitLines(before), b = splitLines(after);
@@ -57,38 +82,89 @@ export function lineDiff(before: string, after: string): DiffOp[] | undefined {
 
 /** Unified hunks with `context` lines around each change. */
 export function diffRows(ops: readonly DiffOp[], context = 3): DiffRow[] {
-  const rows: DiffRow[] = [];
-  const changed = ops.map((op) => op.op !== " ");
-  let oldLine = 1, newLine = 1;
-  const positions = ops.map((op) => {
-    const at = { oldLine, newLine };
-    if (op.op !== "+") oldLine++;
-    if (op.op !== "-") newLine++;
-    return at;
-  });
-  let index = 0;
+  return diffRowsWindow(ops, context, 0, Number.MAX_SAFE_INTEGER);
+}
+
+const linePositionCache = new WeakMap<readonly DiffOp[], { old: Uint32Array; next: Uint32Array }>();
+
+type DiffHunk = { from: number; end: number; offset: number };
+const hunkCache = new WeakMap<readonly DiffOp[], { context: number; offsets: number[]; rows: number; hunks: DiffHunk[] }>();
+
+/** Logical rendered row offsets for hunk navigation, without materializing unchanged rows. */
+export function diffHunkOffsets(ops: readonly DiffOp[], context = 3): number[] {
+  const cached = hunkCache.get(ops);
+  if (cached?.context === context) return cached.offsets.slice();
+  const offsets: number[] = [];
+  const hunks: DiffHunk[] = [];
+  let rendered = 0, index = 0;
   while (index < ops.length) {
-    if (!changed[index]) { index++; continue; }
+    if (ops[index]!.op === " ") { index++; continue; }
     const from = Math.max(0, index - context);
     let to = index;
-    // Extend the hunk while the next change is within 2 × context lines.
     while (to < ops.length) {
       let next = to + 1;
-      while (next < ops.length && !changed[next]) next++;
+      while (next < ops.length && ops[next]!.op === " ") next++;
       if (next < ops.length && next - to <= context * 2) { to = next; continue; }
       break;
     }
     const end = Math.min(ops.length, to + context + 1);
-    const slice = ops.slice(from, end);
-    const oldCount = slice.filter((op) => op.op !== "+").length;
-    const newCount = slice.filter((op) => op.op !== "-").length;
-    rows.push({ kind: "hunk", text: `@@ -${positions[from]!.oldLine},${oldCount} +${positions[from]!.newLine},${newCount} @@` });
-    for (let at = from; at < end; at++) {
+    offsets.push(rendered);
+    hunks.push({ from, end, offset: rendered });
+    rendered += 1 + end - from;
+    index = end;
+  }
+  hunkCache.set(ops, { context, offsets, rows: rendered, hunks });
+  return offsets.slice();
+}
+
+export function diffRowCount(ops: readonly DiffOp[], context = 3): number {
+  if (hunkCache.get(ops)?.context !== context) diffHunkOffsets(ops, context);
+  return hunkCache.get(ops)!.rows;
+}
+
+/** Compute only the requested output window; diff operations stay indexed without a second full row array. */
+export function diffRowsWindow(ops: readonly DiffOp[], context = 3, offset = 0, limit = Number.MAX_SAFE_INTEGER): DiffRow[] {
+  const rows: DiffRow[] = [];
+  const firstRow = Math.max(0, offset);
+  const lastRow = firstRow + Math.max(0, limit);
+  if (hunkCache.get(ops)?.context !== context) diffHunkOffsets(ops, context);
+  const layout = hunkCache.get(ops)!;
+  if (firstRow >= layout.rows || lastRow <= firstRow) return rows;
+  let positions = linePositionCache.get(ops);
+  if (!positions) {
+    const old = new Uint32Array(ops.length + 1), next = new Uint32Array(ops.length + 1);
+    let oldLine = 1, newLine = 1;
+    for (let at = 0; at < ops.length; at++) {
+      const op = ops[at]!;
+      old[at] = oldLine; next[at] = newLine;
+      if (op.op !== "+") oldLine++;
+      if (op.op !== "-") newLine++;
+    }
+    old[ops.length] = oldLine;
+    next[ops.length] = newLine;
+    positions = { old, next };
+    linePositionCache.set(ops, positions);
+  }
+  // Binary-search the first intersecting hunk, then visit only visible operations. In
+  // particular, a 100k-line replacement must not slice/filter/allocate 100k rows per frame.
+  let lo = 0, hi = layout.hunks.length;
+  while (lo < hi) {
+    const mid = (lo + hi) >>> 1;
+    const hunk = layout.hunks[mid]!;
+    if (hunk.offset + 1 + hunk.end - hunk.from <= firstRow) lo = mid + 1;
+    else hi = mid;
+  }
+  for (let index = lo; index < layout.hunks.length; index++) {
+    const { from, end, offset: start } = layout.hunks[index]!;
+    if (start >= lastRow) break;
+    if (start >= firstRow) rows.push({ kind: "hunk", text: `@@ -${positions.old[from]!},${positions.old[end]! - positions.old[from]!} +${positions.next[from]!},${positions.next[end]! - positions.next[from]!} @@` });
+    const visibleFrom = from + Math.max(0, firstRow - start - 1);
+    const visibleEnd = Math.min(end, from + lastRow - start - 1);
+    for (let at = visibleFrom; at < visibleEnd; at++) {
       const op = ops[at]!;
       rows.push({ kind: op.op === "+" ? "add" : op.op === "-" ? "remove" : "context", text: op.text,
-        ...(op.op !== "+" ? { oldLine: positions[at]!.oldLine } : {}), ...(op.op !== "-" ? { newLine: positions[at]!.newLine } : {}) });
+        ...(op.op !== "+" ? { oldLine: positions.old[at]! } : {}), ...(op.op !== "-" ? { newLine: positions.next[at]! } : {}) });
     }
-    index = end;
   }
   return rows;
 }
@@ -174,13 +250,9 @@ export class ChangeTracker {
       if (now === undefined) { this.drop(path); continue; }
       if (now === before) { this.dirty.delete(path); continue; }
       const ops = lineDiff(before ?? "", now ?? "");
+      const summaryOps = ops ?? coarseLineDiff(before ?? "", now ?? "");
       let added = 0, removed = 0;
-      if (ops) {
-        for (const op of ops) { if (op.op === "+") added++; else if (op.op === "-") removed++; }
-      } else {
-        added = splitLines(now ?? "").length;
-        removed = splitLines(before ?? "").length;
-      }
+      for (const op of summaryOps) { if (op.op === "+") added++; else if (op.op === "-") removed++; }
       const rel = relative(this.cwd(), path);
       const change: FileChange = {
         path, rel: rel && !rel.startsWith("..") ? rel : path,

package/src/commit.ts

@@ -4,6 +4,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { ModelRoleManager } from "./model-roles.ts";
 import { askRole, type SideUsage } from "./side-model.ts";
+import { runProcess } from "./async-process.ts";
 
 const DIFF_LIMIT = 60_000;
 
@@ -27,13 +28,11 @@ export function commitPrompt(stat: string, diff: string, log: string, hint: stri
 }
 
 /** `/jar commit [note]`: draft a message for the staged changes with the commit role, review it, commit. Never pushes. */
-export async function jarCommit(pi: ExtensionAPI, ctx: ExtensionContext, roles: ModelRoleManager, usage: SideUsage | undefined, hint = ""): Promise<void> {
+export async function jarCommit(_pi: ExtensionAPI, ctx: ExtensionContext, roles: ModelRoleManager, usage: SideUsage | undefined, hint = ""): Promise<void> {
   if (!ctx.hasUI) { ctx.ui.notify("/jar commit needs the interactive UI to review the message", "warning"); return; }
-  const git = async (...args: string[]) => {
-    const result = await pi.exec("git", args, { cwd: ctx.cwd, timeout: 20_000 });
-    if (result.code !== 0) throw new Error(`git ${args[0]}: ${(result.stderr || result.stdout).trim() || "exit " + result.code}`);
-    return result.stdout;
-  };
+  const git = async (...args: string[]) => (await runProcess(process.env.PI_JAR_GIT_PATH?.trim() || "git", args, {
+    cwd: ctx.cwd, signal: ctx.signal, timeoutMs: 20_000, maxOutputBytes: 64 * 1024 * 1024
+  })).toString("utf8");
   try {
     await git("rev-parse", "--is-inside-work-tree");
     let stat = await git("diff", "--cached", "--stat");

package/src/compact-tools.ts

@@ -8,7 +8,7 @@ import {
   type ExtensionAPI,
   type ExtensionContext
 } from "@earendil-works/pi-coding-agent";
-import { Text } from "@earendil-works/pi-tui";
+import { Box, Container, Text } from "@earendil-works/pi-tui";
 
 type ToolResult = { content: Array<{ type: string; text?: string }>; details?: unknown };
 
@@ -67,6 +67,61 @@ function boundedLineCount(text: string, limit = SUMMARY_SCAN_CHARS): { lines: nu
 
 const expandHint = " · [ expand ] Ctrl+O";
 
+/** Streaming arguments arrive partially: a field can be missing or not yet a string. */
+const str = (value: unknown): string => typeof value === "string" ? value : "";
+
+type CardTheme = { bg(color: "toolPendingBg" | "toolErrorBg" | "toolSuccessBg", text: string): string };
+interface CardContext { state?: { compactCard?: Box }; isPartial?: boolean; isError?: boolean; lastComponent?: unknown }
+/**
+ * Pi's edit tool renders its own framing (`renderShell: "self"`) so its expanded diff can own the
+ * background. Collapsed, pi-jar draws the same padded, state-colored box Pi gives read/write, with the
+ * call line and result summary in one card; the result renderer then contributes nothing.
+ */
+function compactCard(theme: CardTheme, context: CardContext, header: Text): Box | Text {
+  if (!context.state) return header;
+  const card = context.state.compactCard ??= new Box(1, 1);
+  const color = context.isPartial !== false ? "toolPendingBg" : context.isError ? "toolErrorBg" : "toolSuccessBg";
+  card.setBgFn((text) => theme.bg(color, text));
+  card.clear();
+  card.addChild(header);
+  return card;
+}
+function intoCard(context: CardContext, line: Text): Container | Text {
+  const card = context.state?.compactCard;
+  if (!card) return line;
+  card.addChild(line);
+  const empty = context.lastComponent instanceof Container && !(context.lastComponent instanceof Box) ? context.lastComponent : new Container();
+  empty.clear();
+  return empty;
+}
+
+/** One collapsed edit result line: +/− counts from the diff, or the tool's own message. */
+function editSummary(result: ToolResult, isPartial: boolean | undefined, theme: { fg(color: string, text: string): string }): Text {
+  if (isPartial) return new Text(theme.fg("warning", "editing…"), 0, 0);
+  const details = result.details as { diff?: string } | undefined;
+  const diff = details?.diff ?? "";
+  if (!diff) {
+    const text = summarizeResult(result).sample;
+    return new Text(theme.fg(text.startsWith("Error") ? "error" : "success", compactText(text || "applied", 96)), 0, 0);
+  }
+  if (diff.length > DIFF_SCAN_CHARS) return new Text(theme.fg("muted", `large diff${expandHint}`), 0, 0);
+  let counts = diffCountCache.get(details!);
+  if (counts?.diff !== diff) {
+    counts = { diff, additions: 0, removals: 0 };
+    for (let start = 0; start < diff.length;) {
+      const end = diff.indexOf("\n", start);
+      const stop = end < 0 ? diff.length : end;
+      const first = diff[start];
+      if (first === "+" && !diff.startsWith("+++", start)) counts.additions++;
+      else if (first === "-" && !diff.startsWith("---", start)) counts.removals++;
+      start = stop + 1;
+    }
+    diffCountCache.set(details!, counts);
+  }
+  return new Text(theme.fg("success", `+${counts.additions}`) + theme.fg("dim", " / ")
+    + theme.fg("error", `-${counts.removals}`) + theme.fg("dim", expandHint), 0, 0);
+}
+
 /**
  * Whitespace-collapsed, trimmed text cut to `max` characters. Only a bounded prefix is scanned: a call
  * card re-renders on every streamed argument delta, so collapsing a whole heredoc each time was O(n²).
@@ -114,10 +169,10 @@ export function installCompactBuiltinTools(pi: ExtensionAPI): void {
     ...read,
     renderCall(args, theme, context) {
       if (context.expanded && read.renderCall) return read.renderCall(args, theme, context);
-      const range = args.offset || args.limit
+      const range = args?.offset || args?.limit
         ? theme.fg("dim", ` · ${args.offset ?? 1}${args.limit ? `+${args.limit}` : ""}`)
         : "";
-      return new Text(theme.fg("toolTitle", theme.bold("read ")) + theme.fg("accent", args.path) + range, 0, 0);
+      return new Text(theme.fg("toolTitle", theme.bold("read ")) + theme.fg("accent", str(args?.path)) + range, 0, 0);
     },
     renderResult(result, options, theme, context) {
       if (options.expanded && read.renderResult) return read.renderResult(result, options, theme, context);
@@ -135,7 +190,7 @@ export function installCompactBuiltinTools(pi: ExtensionAPI): void {
     },
     renderCall(args, theme, context) {
       if (context.expanded && bash.renderCall) return bash.renderCall(args, theme, context);
-      return new Text(theme.fg("toolTitle", theme.bold("$ ")) + theme.fg("accent", compactText(args.command, 88)), 0, 0);
+      return new Text(theme.fg("toolTitle", theme.bold("$ ")) + theme.fg("accent", compactText(str(args?.command), 88)), 0, 0);
     },
     renderResult(result, options, theme, context) {
       if (options.expanded && bash.renderResult) return bash.renderResult(result as Parameters<NonNullable<typeof bash.renderResult>>[0], options, theme, context);
@@ -156,30 +211,12 @@ export function installCompactBuiltinTools(pi: ExtensionAPI): void {
     ...edit,
     renderCall(args, theme, context) {
       if (context.expanded && edit.renderCall) return edit.renderCall(args, theme, context);
-      return new Text(theme.fg("toolTitle", theme.bold("edit ")) + theme.fg("accent", args.path), 0, 0);
+      const path = str(args?.path) || str((args as { file_path?: unknown } | undefined)?.file_path);
+      return compactCard(theme, context, new Text(theme.fg("toolTitle", theme.bold("edit ")) + theme.fg("accent", path), 0, 0));
     },
     renderResult(result, options, theme, context) {
       if (options.expanded && edit.renderResult) return edit.renderResult(result, options, theme, context);
-      if (options.isPartial) return new Text(theme.fg("warning", "editing…"), 0, 0);
-      const details = result.details as { diff?: string } | undefined;
-      const diff = details?.diff ?? "";
-      if (!diff) {
-        const summary = summarizeResult(result);
-        const text = summary.sample;
-        return new Text(theme.fg(text.startsWith("Error") ? "error" : "success", compactText(text || "applied", 96)), 0, 0);
-      }
-      if (diff.length > DIFF_SCAN_CHARS) return new Text(theme.fg("muted", `large diff${expandHint}`), 0, 0);
-      let counts = diffCountCache.get(details!);
-      if (counts?.diff !== diff) {
-        counts = { diff, additions: 0, removals: 0 };
-        for (const line of diff.split("\n")) {
-          if (line.startsWith("+") && !line.startsWith("+++")) counts.additions++;
-          else if (line.startsWith("-") && !line.startsWith("---")) counts.removals++;
-        }
-        diffCountCache.set(details!, counts);
-      }
-      return new Text(theme.fg("success", `+${counts.additions}`) + theme.fg("dim", " / ")
-        + theme.fg("error", `-${counts.removals}`) + theme.fg("dim", expandHint), 0, 0);
+      return intoCard(context, editSummary(result, options.isPartial, theme));
     }
   });
 
@@ -187,13 +224,14 @@ export function installCompactBuiltinTools(pi: ExtensionAPI): void {
     ...write,
     renderCall(args, theme, context) {
       if (context.expanded && write.renderCall) return write.renderCall(args, theme, context);
+      const content = str(args?.content);
       let count = args && typeof args === "object" ? writeCountCache.get(args as object) : undefined;
       if (!count) {
-        count = boundedLineCount(args.content);
+        count = boundedLineCount(content);
         if (args && typeof args === "object") writeCountCache.set(args as object, count);
       }
-      return new Text(theme.fg("toolTitle", theme.bold("write ")) + theme.fg("accent", args.path)
-        + theme.fg("dim", ` · ${count.lines}${count.truncated ? "+" : ""} lines`), 0, 0);
+      return new Text(theme.fg("toolTitle", theme.bold("write ")) + theme.fg("accent", str(args?.path))
+        + theme.fg("dim", ` · ${count.lines}${count.truncated ? "+" : ""} line${count.lines === 1 && !count.truncated ? "" : "s"}`), 0, 0);
     },
     renderResult(result, options, theme, context) {
       if (options.expanded && write.renderResult) return write.renderResult(result, options, theme, context);

package/src/delegate-worktree.ts

@@ -1,7 +1,6 @@
-import { execFileSync } from "node:child_process";
+import { runProcess } from "./async-process.ts";
 import {
   chmodSync,
-  cpSync,
   existsSync,
   lstatSync,
   mkdirSync,
@@ -13,10 +12,10 @@ import {
   renameSync,
   rmdirSync,
   writeFileSync,
-  symlinkSync,
   unlinkSync,
   type Stats
 } from "node:fs";
+import { chmod, mkdir, readFile, readlink, rm, symlink, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { homedir, tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
@@ -25,6 +24,10 @@ import { MAX_TRACKED_BYTES, type ChangeTracker } from "./changes.ts";
 /** Present only in writable delegated children. The child extension treats this as its filesystem boundary. */
 export const CHILD_WORKTREE_ENV = "PI_JAR_WORKTREE_ROOT";
 const MAX_GIT_OUTPUT = 64 * 1024 * 1024;
+const GIT_TIMEOUT_MS = 30_000;
+/** Set PI_JAR_GIT_PATH to bypass wrappers such as git-ai for pi-jar's internal plumbing. */
+export const GIT_EXECUTABLE_ENV = "PI_JAR_GIT_PATH";
+const gitExecutable = () => process.env[GIT_EXECUTABLE_ENV]?.trim() || "git";
 
 export interface DelegateWorktree {
   /** Git repository root in the parent workspace. */
@@ -42,19 +45,14 @@ export interface DelegateWorktree {
 const safeGitArgs = (cwd: string, args: string[]) => ["-C", cwd, "--literal-pathspecs", "-c", "core.hooksPath=/dev/null",
   "-c", "core.fsmonitor=false", ...args];
 
-const gitText = (cwd: string, args: string[], input?: string | Buffer): string =>
-  execFileSync("git", safeGitArgs(cwd, args), {
-    encoding: "utf8",
-    ...(input === undefined ? {} : { input }),
-    maxBuffer: MAX_GIT_OUTPUT,
-    stdio: ["pipe", "pipe", "pipe"]
-  });
+const gitText = async (cwd: string, args: string[], input?: string | Buffer, signal?: AbortSignal): Promise<string> =>
+  (await runProcess(gitExecutable(), safeGitArgs(cwd, args), {
+    cwd, input, signal, timeoutMs: GIT_TIMEOUT_MS, maxOutputBytes: MAX_GIT_OUTPUT
+  })).toString("utf8");
 
-const gitBuffer = (cwd: string, args: string[]): Buffer =>
-  execFileSync("git", safeGitArgs(cwd, args), {
-    encoding: null,
-    maxBuffer: MAX_GIT_OUTPUT,
-    stdio: ["ignore", "pipe", "pipe"]
+const gitBuffer = (cwd: string, args: string[], signal?: AbortSignal): Promise<Buffer> =>
+  runProcess(gitExecutable(), safeGitArgs(cwd, args), {
+    cwd, signal, timeoutMs: GIT_TIMEOUT_MS, maxOutputBytes: MAX_GIT_OUTPUT
   });
 
 const nulList = (value: string): string[] => value.split("\0").filter(Boolean);
@@ -144,13 +142,16 @@ function canonicalWorkspacePathAllowed(root: string, lexical: string): boolean {
   } catch { return false; }
 }
 
-const copyInto = (fromRoot: string, toRoot: string, rel: string): void => {
-  const from = resolve(fromRoot, rel);
-  const to = resolve(toRoot, rel);
-  if (!safeFilePath(fromRoot, rel) || !safeFilePath(toRoot, rel)) throw new Error("unsafe worktree path: " + rel);
-  mkdirSync(dirname(to), { recursive: true });
-  if (lstatSync(from).isSymbolicLink()) symlinkSync(readlinkSync(from), to);
-  else cpSync(from, to, { force: true, dereference: false });
+const writeSnapshot = async (root: string, rel: string, bytes: Buffer, stat: Stats): Promise<void> => {
+  const to = resolve(root, rel);
+  if (!safeFilePath(root, rel)) throw new Error("unsafe worktree path: " + rel);
+  await mkdir(dirname(to), { recursive: true });
+  // Use the bytes we hashed, not a second copy of a source the user may edit during the await.
+  if (stat.isSymbolicLink()) await symlink(bytes.toString(), to);
+  else {
+    await writeFile(to, bytes, { mode: stat.mode & 0o777 });
+    await chmod(to, stat.mode & 0o777);
+  }
 };
 
 /**
@@ -158,9 +159,9 @@ const copyInto = (fromRoot: string, toRoot: string, rel: string): void => {
  * parent's tracked modifications plus non-ignored untracked files. The parent index/branch is not
  * touched. That baseline lets multiple children run against the exact same starting filesystem.
  */
-export function createDelegateWorktree(cwd: string): DelegateWorktree {
+export async function createDelegateWorktree(cwd: string, signal?: AbortSignal): Promise<DelegateWorktree> {
   const requested = realpathSync(cwd);
-  const repoRoot = realpathSync(gitText(requested, ["rev-parse", "--show-toplevel"]).trim());
+  const repoRoot = realpathSync((await gitText(requested, ["rev-parse", "--show-toplevel"], undefined, signal)).trim());
   if (!inside(repoRoot, requested)) throw new Error("working directory is outside the git repository");
   const relCwd = relative(repoRoot, requested);
   const tempRoot = realpathSync(mkdtempSync(join(tmpdir(), "pi-jar-worktree-")));
@@ -168,61 +169,67 @@ export function createDelegateWorktree(cwd: string): DelegateWorktree {
   let added = false;
   try {
     // Never checkout/add: they execute clean/smudge filters and alter byte baselines.
-    gitText(repoRoot, ["worktree", "add", "--no-checkout", "--detach", root, "HEAD"]);
+    await gitText(repoRoot, ["worktree", "add", "--no-checkout", "--detach", root, "HEAD"], undefined, signal);
     added = true;
-    gitText(root, ["read-tree", "--empty"]);
-    const paths = new Set(nulList(gitText(repoRoot, ["ls-files", "--cached", "--others", "--exclude-standard", "-z"])));
+    await gitText(root, ["read-tree", "--empty"], undefined, signal);
+    const paths = new Set(nulList(await gitText(repoRoot, ["ls-files", "--cached", "--others", "--exclude-standard", "-z"], undefined, signal)));
     for (const rel of paths) {
       if (!safeFilePath(repoRoot, rel)) throw new Error("unsafe snapshot path: " + rel);
       const source = resolve(repoRoot, rel);
       const stat = statIfPresent(source);
       if (!stat) continue;
       if (!stat.isFile() && !stat.isSymbolicLink()) throw new Error("unsupported snapshot file: " + rel);
-      const bytes = stat.isSymbolicLink() ? Buffer.from(readlinkSync(source)) : readFileSync(source);
-      const oid = gitText(root, ["hash-object", "-w", "--no-filters", "--stdin"], bytes).trim();
+      const bytes = stat.isSymbolicLink() ? Buffer.from(await readlink(source)) : await readFile(source);
+      const oid = (await gitText(root, ["hash-object", "-w", "--no-filters", "--stdin"], bytes, signal)).trim();
       const mode = stat.isSymbolicLink() ? "120000" : (stat.mode & 0o111) ? "100755" : "100644";
-      gitText(root, ["update-index", "--add", "--cacheinfo", mode, oid, rel]);
-      copyInto(repoRoot, root, rel);
+      await gitText(root, ["update-index", "--add", "--cacheinfo", mode, oid, rel], undefined, signal);
+      signal?.throwIfAborted();
+      await writeSnapshot(root, rel, bytes, stat);
     }
-    const tree = gitText(root, ["write-tree"]).trim();
-    const baseline = gitText(root, ["-c", "user.name=pi-jar", "-c", "user.email=pi-jar@local",
-      "commit-tree", "--no-gpg-sign", tree, "-p", "HEAD", "-m", "pi-jar delegate baseline"]).trim();
-    gitText(root, ["update-ref", "HEAD", baseline]);
+    const tree = (await gitText(root, ["write-tree"], undefined, signal)).trim();
+    const baseline = (await gitText(root, ["-c", "user.name=pi-jar", "-c", "user.email=pi-jar@local",
+      "commit-tree", "--no-gpg-sign", tree, "-p", "HEAD", "-m", "pi-jar delegate baseline"], undefined, signal)).trim();
+    await gitText(root, ["update-ref", "HEAD", baseline], undefined, signal);
     const childCwd = relCwd ? resolve(root, relCwd) : root;
     if (!workspacePathAllowed(root, root, childCwd)) throw new Error("unsafe child working directory");
     if (!existsSync(childCwd)) mkdirSync(childCwd, { recursive: true });
     return { repoRoot, root, cwd: childCwd, baseline, tempRoot };
   } catch (error) {
     if (added) {
-      try { gitText(repoRoot, ["worktree", "remove", "--force", root]); } catch { /* best effort */ }
+      try { await gitText(repoRoot, ["worktree", "remove", "--force", root]); } catch { /* best effort */ }
     }
-    rmSync(tempRoot, { recursive: true, force: true });
+    await rm(tempRoot, { recursive: true, force: true });
     throw error;
   }
 }
 
 /** Files whose final worktree state differs from the snapshot, including new untracked files. */
-export function worktreeChangedFiles(worktree: DelegateWorktree): string[] {
-  const baselinePaths = nulList(gitText(worktree.root, ["ls-tree", "-r", "--name-only", "-z", worktree.baseline]));
-  const currentPaths = nulList(gitText(worktree.root, ["ls-files", "--cached", "--others", "--exclude-standard", "-z"]));
-  return [...new Set([...baselinePaths, ...currentPaths])]
-    .filter(rel => !parentMatchesBaseline(worktree, worktree.root, rel)).sort();
+export async function worktreeChangedFiles(worktree: DelegateWorktree, signal?: AbortSignal): Promise<string[]> {
+  const baselinePaths = nulList(await gitText(worktree.root, ["ls-tree", "-r", "--name-only", "-z", worktree.baseline], undefined, signal));
+  const currentPaths = nulList(await gitText(worktree.root, ["ls-files", "--cached", "--others", "--exclude-standard", "-z"], undefined, signal));
+  const changed: string[] = [];
+  for (const rel of new Set([...baselinePaths, ...currentPaths])) {
+    if (!await parentMatchesBaseline(worktree, worktree.root, rel, signal)) changed.push(rel);
+  }
+  return changed.sort();
 }
 
 type BaselineEntry = { mode: string; content: Buffer } | null;
 
-const baselineEntry = (worktree: DelegateWorktree, rel: string): BaselineEntry => {
-  const line = gitText(worktree.root, ["ls-tree", "-z", worktree.baseline, "--", rel]);
+const baselineEntry = async (worktree: DelegateWorktree, rel: string, signal?: AbortSignal): Promise<BaselineEntry> => {
+  const line = await gitText(worktree.root, ["ls-tree", "-z", worktree.baseline, "--", rel], undefined, signal);
   if (!line || line.slice(line.indexOf("\t") + 1, -1) !== rel) return null;
   const [mode, type, oid] = line.slice(0, line.indexOf("\t")).split(" ");
   if (type !== "blob" || !mode || !oid) throw new Error("unsupported baseline entry: " + rel);
-  return { mode, content: gitBuffer(worktree.root, ["cat-file", "blob", oid]) };
+  return { mode, content: await gitBuffer(worktree.root, ["cat-file", "blob", oid], signal) };
 };
 
-const parentMatchesBaseline = (worktree: DelegateWorktree, parentRoot: string, rel: string): boolean => {
+const parentMatchesBaseline = async (worktree: DelegateWorktree, parentRoot: string, rel: string, signal?: AbortSignal): Promise<boolean> =>
+  matchesBaseline(await baselineEntry(worktree, rel, signal), parentRoot, rel);
+
+const matchesBaseline = (baseline: BaselineEntry, parentRoot: string, rel: string): boolean => {
   const target = resolve(parentRoot, rel);
   if (!safeFilePath(parentRoot, rel)) return false;
-  const baseline = baselineEntry(worktree, rel);
   const stat = statIfPresent(target);
   if (!baseline) return !stat;
   if (!stat) return false;
@@ -245,17 +252,20 @@ const reviewableBytes = (bytes: Buffer): boolean => bytes.length <= MAX_TRACKED_
  * Copy a completed child's changed files back to the parent only when every target still equals the
  * baseline snapshot. The parent is therefore never overwritten after another actor changed a file.
  */
-export function applyDelegateWorktree(worktree: DelegateWorktree, parentCwd: string, files: readonly string[],
-  tracker?: ChangeTracker): string[] {
-  const parentRoot = realpathSync(gitText(parentCwd, ["rev-parse", "--show-toplevel"]).trim());
+export async function applyDelegateWorktree(worktree: DelegateWorktree, parentCwd: string, files: readonly string[],
+  tracker?: ChangeTracker, signal?: AbortSignal): Promise<string[]> {
+  const parentRoot = realpathSync((await gitText(parentCwd, ["rev-parse", "--show-toplevel"], undefined, signal)).trim());
   if (parentRoot !== worktree.repoRoot) throw new Error("parent repository changed while subagent was running");
   // Review identities follow the caller's cwd spelling (e.g. /var rather than /private/var).
   const reviewRoot = resolve(parentCwd, relative(realpathSync(parentCwd), parentRoot));
+  const baselines = new Map<string, BaselineEntry>();
   for (const rel of files) {
     if (!safeFilePath(parentRoot, rel) || statIfPresent(resolve(parentRoot, rel))?.isSymbolicLink()) {
       throw new Error("unsafe parent changed path: " + rel);
     }
-    if (!parentMatchesBaseline(worktree, parentRoot, rel)) {
+    const baseline = await baselineEntry(worktree, rel, signal);
+    baselines.set(rel, baseline);
+    if (!matchesBaseline(baseline, parentRoot, rel)) {
       throw new Error(`parent changed since delegation started: ${rel}`);
     }
     const parentStat = statIfPresent(resolve(parentRoot, rel));
@@ -315,10 +325,15 @@ export function applyDelegateWorktree(worktree: DelegateWorktree, parentCwd: str
         chmodSync(entry.replacement, after.mode & 0o777);
       }
     }
+    // No await after entering the atomic apply/rollback section: asynchronous Git calls between
+    // replacements would let parent edits or a session switch interleave with partial application.
+    signal?.throwIfAborted();
     for (const entry of staged) {
-      if (!safeFilePath(parentRoot, entry.rel) || !parentMatchesBaseline(worktree, parentRoot, entry.rel)) {
+      if (!safeFilePath(parentRoot, entry.rel) || !matchesBaseline(baselines.get(entry.rel)!, parentRoot, entry.rel)) {
         throw new Error("parent changed while preparing finalization: " + entry.rel);
       }
+    }
+    for (const entry of staged) {
       if (entry.replacement) renameSync(entry.replacement, entry.target);
       else if (statIfPresent(entry.target)) unlinkSync(entry.target);
       applied.push(entry);
@@ -349,12 +364,12 @@ export class WorktreeApplyError extends Error {
 }
 
 /** Remove a disposable worktree and its dangling snapshot commit reference. */
-export function disposeDelegateWorktree(worktree: DelegateWorktree): void {
-  try { gitText(worktree.repoRoot, ["worktree", "remove", "--force", worktree.root]); }
+export async function disposeDelegateWorktree(worktree: DelegateWorktree, signal?: AbortSignal): Promise<void> {
+  try { await gitText(worktree.repoRoot, ["worktree", "remove", "--force", worktree.root], undefined, signal); }
   catch {
-    rmSync(worktree.tempRoot, { recursive: true, force: true });
-    try { gitText(worktree.repoRoot, ["worktree", "prune"]); } catch { /* best effort */ }
+    await rm(worktree.tempRoot, { recursive: true, force: true });
+    try { await gitText(worktree.repoRoot, ["worktree", "prune"], undefined, signal); } catch { /* best effort */ }
     return;
   }
-  rmSync(worktree.tempRoot, { recursive: true, force: true });
+  await rm(worktree.tempRoot, { recursive: true, force: true });
 }