pi-jar 0.1.6 → 0.1.8

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;
@@ -13,7 +15,11 @@ const MAX_DIFF_MIDDLE_LINES = 4_000;
 export type ChangeStatus = "added" | "modified" | "deleted";
 export interface FileChange { path: string; rel: string; status: ChangeStatus; before: string; after: string; added: number; removed: number; diff?: DiffOp[] | null }
 export type DiffOp = { op: " " | "+" | "-"; text: string };
-export type DiffRow = { kind: "hunk" | "context" | "add" | "remove" | "note"; text: string; oldLine?: number; newLine?: number };
+/** `hidden` counts unchanged lines skipped before a hunk; `pair` is the aligned replacement line for intraline diffs. */
+export type DiffRow = { kind: "hunk" | "context" | "add" | "remove" | "note"; text: string; oldLine?: number; newLine?: number; hidden?: number; pair?: string };
+export type SplitSide = { line: number; text: string; changed: boolean };
+/** One aligned Original/Updated row: a replacement run pairs its k-th removed and k-th added line. */
+export type SplitRow = { kind: "hunk"; text: string; hidden: number } | { kind: "pair"; left?: SplitSide; right?: SplitSide };
 
 /** Text content, `null` when the file is missing, or `undefined` when it cannot be tracked. */
 function readText(path: string): string | null | undefined {
@@ -27,6 +33,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 +86,220 @@ 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++;
-      if (next < ops.length && next - to <= context * 2) { to = next; continue; }
+      while (next < ops.length && ops[next]!.op === " ") next++;
+      // Merge when the unchanged gap fits inside both hunks' context (adjacent changes at context 0).
+      if (next < ops.length && next - to - 1 <= 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;
+}
+
+const linePositions = (ops: readonly DiffOp[]) => {
+  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);
+  }
+  return positions;
+};
+
+/**
+ * Replacement runs (maximal non-context spans) as flat typed arrays, independent of context:
+ * `order[start..start+removes)` lists the run's removed ops and the rest its added ops, so the
+ * k-th removal pairs with the k-th addition. `split` prefixes aligned rows (a run takes max(r, a)).
+ */
+type RunLayout = { start: Uint32Array; removes: Uint32Array; length: Uint32Array; order: Uint32Array; ordinal: Uint32Array; split: Uint32Array };
+const runCache = new WeakMap<readonly DiffOp[], RunLayout>();
+
+const runLayout = (ops: readonly DiffOp[]): RunLayout => {
+  const cached = runCache.get(ops);
+  if (cached) return cached;
+  const n = ops.length;
+  const layout: RunLayout = { start: new Uint32Array(n), removes: new Uint32Array(n), length: new Uint32Array(n),
+    order: new Uint32Array(n), ordinal: new Uint32Array(n), split: new Uint32Array(n + 1) };
+  const { start, removes, length, order, ordinal, split } = layout;
+  for (let at = 0; at < n;) {
+    if (ops[at]!.op === " ") { order[at] = at; split[at + 1] = split[at]! + 1; at++; continue; }
+    let end = at;
+    while (end < n && ops[end]!.op !== " ") end++;
+    let r = 0, a = 0;
+    for (let i = at; i < end; i++) if (ops[i]!.op === "-") { ordinal[i] = r; order[at + r++] = i; }
+    for (let i = at; i < end; i++) if (ops[i]!.op === "+") { ordinal[i] = a; order[at + r + a++] = i; }
+    for (let i = at; i < end; i++) { start[i] = at; removes[i] = r; length[i] = end - at; split[i + 1] = split[at]!; }
+    split[at + 1] = split[at]! + Math.max(r, a);
+    for (let i = at + 1; i < end; i++) split[i + 1] = split[at + 1]!;
+    at = end;
+  }
+  runCache.set(ops, layout);
+  return layout;
+};
+
+/** The aligned counterpart of a changed op (k-th removal ↔ k-th addition in its run), if any. */
+const partner = (ops: readonly DiffOp[], at: number): number | undefined => {
+  const { start, removes, length, order, ordinal } = runLayout(ops);
+  const s = start[at]!, r = removes[at]!, a = length[at]! - r, k = ordinal[at]!;
+  if (ops[at]!.op === "-") return k < a ? order[s + r + k] : undefined;
+  return k < r ? order[s + k] : undefined;
+};
+
+/** 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;
+  const positions = linePositions(ops);
+  // 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: hunkHeader(positions, from, end), hidden: from - (layout.hunks[index - 1]?.end ?? 0) });
+    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]!;
+      const pair = op.op === " " ? undefined : partner(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]! } : {}),
+        ...(pair !== undefined ? { pair: ops[pair]!.text } : {}) });
+    }
+  }
+  return rows;
+}
+
+/** Git convention: an empty side (pure insertion/deletion) names the line before the change. */
+const hunkHeader = (positions: { old: Uint32Array; next: Uint32Array }, from: number, end: number) => {
+  const range = (lines: Uint32Array) => {
+    const count = lines[end]! - lines[from]!;
+    return `${count ? lines[from]! : lines[from]! - 1},${count}`;
+  };
+  return `@@ -${range(positions.old)} +${range(positions.next)} @@`;
+};
+
+type SplitHunk = DiffHunk & { split: number };
+const splitCache = new WeakMap<readonly DiffOp[], { context: number; hunks: SplitHunk[]; offsets: number[]; rows: number }>();
+
+const splitLayout = (ops: readonly DiffOp[], context: number) => {
+  const cached = splitCache.get(ops);
+  if (cached?.context === context) return cached;
+  if (hunkCache.get(ops)?.context !== context) diffHunkOffsets(ops, context);
+  const { split } = runLayout(ops);
+  const hunks: SplitHunk[] = [];
+  let rows = 0;
+  // Hunks start and end on context ops, so a replacement run never straddles two hunks.
+  for (const hunk of hunkCache.get(ops)!.hunks) {
+    hunks.push({ ...hunk, split: rows });
+    rows += 1 + split[hunk.end]! - split[hunk.from]!;
+  }
+  const layout = { context, hunks, offsets: hunks.map(hunk => hunk.split), rows };
+  splitCache.set(ops, layout);
+  return layout;
+};
+
+/** Aligned side-by-side row offsets of each hunk header. */
+export function diffSplitHunkOffsets(ops: readonly DiffOp[], context = 3): number[] {
+  return splitLayout(ops, context).offsets.slice();
+}
+
+export function diffSplitRowCount(ops: readonly DiffOp[], context = 3): number {
+  return splitLayout(ops, context).rows;
+}
+
+/** Window of aligned Original/Updated rows; like `diffRowsWindow`, it visits only visible operations. */
+export function diffSplitRowsWindow(ops: readonly DiffOp[], context = 3, offset = 0, limit = Number.MAX_SAFE_INTEGER): SplitRow[] {
+  const rows: SplitRow[] = [];
+  const firstRow = Math.max(0, offset);
+  const lastRow = firstRow + Math.max(0, limit);
+  const layout = splitLayout(ops, context);
+  if (firstRow >= layout.rows || lastRow <= firstRow) return rows;
+  const positions = linePositions(ops);
+  const { split, order, removes, length } = runLayout(ops);
+  const size = (hunk: SplitHunk) => 1 + split[hunk.end]! - split[hunk.from]!;
+  let lo = 0, hi = layout.hunks.length;
+  while (lo < hi) {
+    const mid = (lo + hi) >>> 1;
+    if (layout.hunks[mid]!.split + size(layout.hunks[mid]!) <= firstRow) lo = mid + 1;
+    else hi = mid;
+  }
+  for (let index = lo; index < layout.hunks.length; index++) {
+    const hunk = layout.hunks[index]!;
+    if (hunk.split >= lastRow) break;
+    if (hunk.split >= firstRow) rows.push({ kind: "hunk", text: hunkHeader(positions, hunk.from, hunk.end), hidden: hunk.from - (layout.hunks[index - 1]?.end ?? 0) });
+    const visibleFrom = Math.max(0, firstRow - hunk.split - 1);
+    const visibleEnd = Math.min(size(hunk) - 1, lastRow - hunk.split - 1);
+    for (let row = visibleFrom; row < visibleEnd; row++) {
+      const target = split[hunk.from]! + row;
+      // First op whose aligned-row interval contains target; only run starts carry run rows.
+      let low = hunk.from, high = hunk.end - 1;
+      while (low < high) {
+        const mid = (low + high) >>> 1;
+        if (split[mid + 1]! > target) high = mid; else low = mid + 1;
+      }
+      const op = ops[low]!;
+      if (op.op === " ") {
+        rows.push({ kind: "pair", left: { line: positions.old[low]!, text: op.text, changed: false }, right: { line: positions.next[low]!, text: op.text, changed: false } });
+        continue;
+      }
+      const k = target - split[low]!, r = removes[low]!, a = length[low]! - r;
+      const removed = k < r ? order[low + k]! : undefined;
+      const added = k < a ? order[low + r + k]! : undefined;
+      rows.push({ kind: "pair",
+        ...(removed !== undefined ? { left: { line: positions.old[removed]!, text: ops[removed]!.text, changed: true } } : {}),
+        ...(added !== undefined ? { right: { line: positions.next[added]!, text: ops[added]!.text, changed: true } } : {}) });
     }
-    index = end;
   }
   return rows;
 }
@@ -174,13 +385,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/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,41 @@ 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);
+  }
+};
+
+// Each git call has its own GIT_TIMEOUT_MS deadline, so bound the work per batched call.
+const HASH_BATCH_FILES = 1000;
+const HASH_BATCH_BYTES = 128 * 1024 * 1024;
+
+/** Object ids for regular files, in order, from bounded `hash-object --stdin-paths` chunks. */
+const hashPaths = async (root: string, files: readonly { path: string; size: number }[], write: boolean,
+  signal?: AbortSignal): Promise<string[]> => {
+  const oids: string[] = [];
+  for (let start = 0; start < files.length;) {
+    let end = start;
+    let bytes = 0;
+    // A file larger than the byte budget still gets its own chunk, matching per-file hashing.
+    while (end < files.length && end - start < HASH_BATCH_FILES && (end === start || bytes + files[end]!.size <= HASH_BATCH_BYTES)) {
+      bytes += files[end++]!.size;
+    }
+    const chunk = files.slice(start, end);
+    const output = (await gitText(root, ["hash-object", ...(write ? ["-w"] : []), "--no-filters", "--stdin-paths"],
+      chunk.map(file => file.path).join("\n") + "\n", signal)).split("\n").filter(Boolean);
+    if (output.length !== chunk.length) throw new Error("git hash-object returned incomplete hashes");
+    oids.push(...output);
+    start = end;
+  }
+  return oids;
 };
 
 /**
@@ -158,9 +184,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 +194,104 @@ 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)));
+    // Git process startup (often behind wrappers such as git-ai) dominates setup time, so hash
+    // and stage in bounded batches rather than two git processes per repository file.
+    const entries: { rel: string; mode: string; oid: string }[] = [];
+    const batched: { entry: (typeof entries)[number]; path: string; size: number }[] = [];
     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 mode = stat.isSymbolicLink() ? "120000" : (stat.mode & 0o111) ? "100755" : "100644";
-      gitText(root, ["update-index", "--add", "--cacheinfo", mode, oid, rel]);
-      copyInto(repoRoot, root, rel);
+      const bytes = stat.isSymbolicLink() ? Buffer.from(await readlink(source)) : await readFile(source);
+      signal?.throwIfAborted();
+      await writeSnapshot(root, rel, bytes, stat);
+      const entry = { rel, mode: stat.isSymbolicLink() ? "120000" : (stat.mode & 0o111) ? "100755" : "100644", oid: "" };
+      entries.push(entry);
+      // The private copy holds exactly the bytes read above. Hashing it by path would follow a
+      // symlink, and --stdin-paths is line-based, so those entries hash their bytes directly.
+      const path = resolve(root, rel);
+      if (stat.isSymbolicLink() || path.includes("\n")) {
+        entry.oid = (await gitText(root, ["hash-object", "-w", "--no-filters", "--stdin"], bytes, signal)).trim();
+      } else batched.push({ entry, path, size: bytes.length });
     }
-    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 oids = await hashPaths(root, batched, true, signal);
+    batched.forEach((item, index) => { item.entry.oid = oids[index]!; });
+    if (entries.length) {
+      await gitText(root, ["update-index", "-z", "--index-info"],
+        entries.map(entry => `${entry.mode} ${entry.oid}\t${entry.rel}\0`).join(""), signal);
+    }
+    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 baseline = new Map<string, { mode: string; oid: string }>();
+  for (const record of nulList(await gitText(worktree.root, ["ls-tree", "-r", "-z", worktree.baseline], undefined, signal))) {
+    const tab = record.indexOf("\t");
+    const [mode, type, oid] = record.slice(0, tab).split(" ");
+    if (type !== "blob" || !mode || !oid) throw new Error("unsupported baseline entry: " + record.slice(tab + 1));
+    baseline.set(record.slice(tab + 1), { mode, oid });
+  }
+  const currentPaths = nulList(await gitText(worktree.root, ["ls-files", "--cached", "--others", "--exclude-standard", "-z"], undefined, signal));
+  const changed: string[] = [];
+  // Compare object ids from bounded hash-object batches instead of two git processes per file.
+  const batched: { rel: string; oid: string; path: string; size: number }[] = [];
+  const hashBytes = async (bytes: Buffer) => (await gitText(worktree.root, ["hash-object", "--no-filters", "--stdin"], bytes, signal)).trim();
+  for (const rel of new Set([...baseline.keys(), ...currentPaths])) {
+    const entry = baseline.get(rel);
+    const target = resolve(worktree.root, rel);
+    if (!safeFilePath(worktree.root, rel)) { changed.push(rel); continue; }
+    const stat = statIfPresent(target);
+    if (!entry || !stat) {
+      if (entry || stat) changed.push(rel);
+      continue;
+    }
+    if (entry.mode === "120000") {
+      if (!stat.isSymbolicLink() || await hashBytes(Buffer.from(await readlink(target))) !== entry.oid) changed.push(rel);
+      continue;
+    }
+    if (!stat.isFile() || (entry.mode === "100755") !== ((stat.mode & 0o111) !== 0)) changed.push(rel);
+    else if (target.includes("\n")) { if (await hashBytes(await readFile(target)) !== entry.oid) changed.push(rel); }
+    else batched.push({ rel, oid: entry.oid, path: target, size: stat.size });
+  }
+  const oids = await hashPaths(worktree.root, batched, false, signal);
+  batched.forEach((item, index) => { if (oids[index] !== item.oid) changed.push(item.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 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 +314,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 +387,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 +426,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 });
 }