@astrosheep/keiyaku 2.9.12 → 2.9.13

package/build/flow-error.js

@@ -55,6 +55,12 @@ export function resolveFlowErrorHints(code, context, facts) {
     if (facts?.kind === "projection_wake_failure") {
         return [];
     }
+    if (facts?.kind === "task_contract_workspace") {
+        return ["Select an active contract with a materialized workspace, or retry from the desired checkout with -C."];
+    }
+    if (facts?.kind === "carrier_dispatch_refusal") {
+        return [facts.recoveryCommand];
+    }
     switch (code) {
         case "NOT_GIT_REPO":
             return ["The provided `cwd` is not a git repository."];
@@ -64,6 +70,8 @@ export function resolveFlowErrorHints(code, context, facts) {
             return [`Next: open an arc with \`${context.arcToolName}\`, then use \`${context.renewToolName}\` when delivery must follow the current base, or \`${context.closeToolName}\` to settle it.`];
         case "CONTRACT_AMBIGUOUS":
             return ["Address a specific contract workspace, or use `call --bare` to run without contract attachment."];
+        case "CONTRACT_WORKSPACE_UNAVAILABLE":
+            return [];
         case "TASK_AMBIGUOUS":
             return ["Pass one complete task coordinate from the listed candidates."];
         case "UNKNOWN_COMMAND":
@@ -108,7 +116,7 @@ export function resolveFlowErrorHints(code, context, facts) {
         case "DETACHED_HEAD":
             return ["Repository is in detached HEAD state. Address an active contract workspace before retrying."];
         case "INVALID_RESPONSE_PATH":
-            return ["`keiyaku revive ARTIFACT_ID` needs a valid previous Keiyaku response artifact that includes complete provenance plus `session` and `subagent_name`."];
+            return ["`keiyaku fork ARTIFACT_ID` needs a valid previous Keiyaku response artifact that includes complete provenance plus `session` and `subagent_name`."];
         case "INVALID_CLOSE_INTENT":
             return ["Invalid close intent. Valid values are `CLAIM` and `FORFEIT`."];
         case "INVALID_SETTINGS":

package/build/generated/version.js

@@ -1,3 +1,3 @@
 // Generated into build output by scripts/build.mjs
-export const VERSION = "2.9.12";
-export const GIT_HASH = "25d9570";
+export const VERSION = "2.9.13";
+export const GIT_HASH = "0971934";

package/build/git/branches.js

@@ -1,29 +1,37 @@
-import { simpleGit } from "simple-git";
 import { FlowError } from "../flow-error.js";
-import { normalizeFilesystemCoordinate } from "../fs/path-coordinate.js";
-import { createGit, errorContainsAnyPattern, isGitExecutableUnavailable, NOT_GIT_REPOSITORY_PATTERNS, wrapGitError, } from "./core.js";
+import { errorContainsAnyPattern, isGitExecutableUnavailable, NOT_GIT_REPOSITORY_PATTERNS, wrapGitError, } from "./core.js";
+import { runGitOrThrow, runGitProcess } from "./process.js";
+async function gitOutput(cwd, args, label) {
+    try {
+        return (await runGitOrThrow(cwd, args)).stdout;
+    }
+    catch (error) {
+        throw wrapGitError(label, error, cwd);
+    }
+}
+function processFailure(result) {
+    return result.error ?? Object.assign(new Error(`git exited with status ${result.status ?? "unknown"}`), {
+        stdout: result.stdout,
+        stderr: result.stderr,
+        status: result.status,
+    });
+}
 export async function observeGitRepository(cwd) {
     try {
-        const git = simpleGit(normalizeFilesystemCoordinate(cwd));
-        git.env("GIT_TERMINAL_PROMPT", "0");
-        git.env("GCM_INTERACTIVE", "Never");
-        git.env("GIT_MERGE_AUTOEDIT", "no");
-        git.env("LC_ALL", "C");
-        git.env("PATH", process.env.PATH ?? "");
-        const output = await git.raw(["rev-parse", "--is-inside-work-tree", "--is-bare-repository"]);
-        const [insideWorktree, bare] = output.trim().split(/\r?\n/);
+        const output = await runGitOrThrow(cwd, ["rev-parse", "--is-inside-work-tree", "--is-bare-repository"]);
+        const [insideWorktree, bare] = output.stdout.trim().split(/\r?\n/);
         return {
             capability: "available",
             coordinate: insideWorktree === "true" && bare !== "true" ? "repository" : "non-repository",
         };
     }
-    catch (err) {
-        if (isGitExecutableUnavailable(err))
+    catch (error) {
+        if (isGitExecutableUnavailable(error))
             return { capability: "unavailable" };
-        if (errorContainsAnyPattern(err, NOT_GIT_REPOSITORY_PATTERNS)) {
+        if (errorContainsAnyPattern(error, NOT_GIT_REPOSITORY_PATTERNS)) {
             return { capability: "available", coordinate: "non-repository" };
         }
-        return { capability: "unknown", error: wrapGitError("check-is-repo", err, cwd) };
+        return { capability: "unknown", error: wrapGitError("check-is-repo", error, cwd) };
     }
 }
 export function assertGitObservation(observation, operation) {
@@ -40,74 +48,37 @@ export async function requireGitRepository(cwd, operation) {
     }
 }
 export async function getCurrentBranch(cwd) {
-    const git = createGit(cwd);
-    let status;
-    try {
-        status = await git.status();
-    }
-    catch (err) {
-        throw wrapGitError("status", err, cwd);
+    const symbolic = await runGitProcess(cwd, ["symbolic-ref", "--quiet", "--short", "HEAD"]);
+    if (symbolic.error || (symbolic.status !== 0 && symbolic.status !== 1)) {
+        throw wrapGitError("symbolic-ref --quiet --short HEAD", processFailure(symbolic), cwd);
     }
-    if (!status.current) {
+    if (symbolic.status === 1 || !symbolic.stdout.trim()) {
         throw new FlowError("DETACHED_HEAD", "Detached HEAD or no branch found");
     }
-    return status.current;
+    const head = await runGitProcess(cwd, ["rev-parse", "--verify", "--quiet", "HEAD"]);
+    if (head.error || (head.status !== 0 && head.status !== 1)) {
+        throw wrapGitError("rev-parse --verify HEAD", processFailure(head), cwd);
+    }
+    if (head.status === 0)
+        return symbolic.stdout.trim();
+    throw new FlowError("DETACHED_HEAD", "Detached HEAD or no branch found");
 }
 export async function listLocalBranches(cwd) {
-    const git = createGit(cwd);
-    let branches;
-    try {
-        branches = await git.branchLocal();
-    }
-    catch (err) {
-        throw wrapGitError("branch --list", err, cwd);
-    }
-    return branches.all;
+    const output = await gitOutput(cwd, ["for-each-ref", "--format=%(refname:short)", "refs/heads"], "branch --list");
+    return output.split(/\r?\n/).filter((branch) => branch.length > 0);
 }
 export async function createAndSwitchBranch(cwd, branchName) {
-    const git = createGit(cwd);
-    try {
-        await git.raw(["switch", "-c", branchName]);
-    }
-    catch (err) {
-        throw wrapGitError(`switch -c ${branchName}`, err, cwd);
-    }
+    await gitOutput(cwd, ["switch", "-c", branchName], `switch -c ${branchName}`);
 }
 export async function switchBranch(cwd, branchName) {
-    const git = createGit(cwd);
-    try {
-        await git.raw(["switch", branchName]);
-    }
-    catch (err) {
-        throw wrapGitError(`switch ${branchName}`, err, cwd);
-    }
+    await gitOutput(cwd, ["switch", branchName], `switch ${branchName}`);
 }
 export async function deleteBranch(cwd, branchName, force = false) {
-    const git = createGit(cwd);
-    try {
-        await git.deleteLocalBranch(branchName, force);
-    }
-    catch (err) {
-        throw wrapGitError(`branch -d${force ? " -D" : ""} ${branchName}`, err, cwd);
-    }
+    await gitOutput(cwd, ["branch", force ? "-D" : "-d", branchName], `branch -d${force ? " -D" : ""} ${branchName}`);
 }
 export async function hasLocalBranch(cwd, branchName) {
-    const git = createGit(cwd);
-    let branches;
-    try {
-        branches = await git.branchLocal();
-    }
-    catch (err) {
-        throw wrapGitError("branch --list", err, cwd);
-    }
-    return branches.all.includes(branchName);
+    return (await listLocalBranches(cwd)).includes(branchName);
 }
 export async function assertValidBranchName(cwd, branchName) {
-    const git = createGit(cwd);
-    try {
-        await git.raw(["check-ref-format", "--branch", branchName]);
-    }
-    catch (err) {
-        throw wrapGitError(`check-ref-format --branch ${branchName}`, err, cwd);
-    }
+    await gitOutput(cwd, ["check-ref-format", "--branch", branchName], `check-ref-format --branch ${branchName}`);
 }

package/build/git/commits.js

@@ -1,35 +1,107 @@
 import { FlowError } from "../flow-error.js";
-import { createGit, wrapGitError } from "./core.js";
+import { isFullGitObjectId, runGitProcess, wrapGitError, } from "./core.js";
+import { runGitOrThrow } from "./process.js";
+const COMMIT_COORDINATE_FORMAT = "format:%H%x00%T%x00%P";
+/**
+ * Resolve one revision to a peeled commit coordinate through a single argv-safe,
+ * non-walking Git query. Ordinary commits and annotated tags share the peeled tip.
+ * Missing revisions, non-commit terminal objects, malformed output, and process
+ * failures stay distinguishable without matching localized presentation text.
+ */
+export async function readCommitCoordinate(cwd, revision) {
+    const result = await runGitProcess(cwd, [
+        "log",
+        "--no-walk",
+        "-1",
+        `--format=${COMMIT_COORDINATE_FORMAT}`,
+        "--end-of-options",
+        revision,
+        "--",
+    ]);
+    if (result.error) {
+        return { status: "failed", revision, error: result.error, result };
+    }
+    if (result.status !== 0) {
+        return { status: "missing", revision };
+    }
+    const raw = result.stdout.replace(/(?:\r?\n)+$/, "");
+    if (raw.length === 0) {
+        return { status: "non-commit", revision };
+    }
+    const fields = raw.split("\0");
+    if (fields.length !== 3) {
+        return {
+            status: "malformed",
+            revision,
+            detail: `expected 3 NUL fields, received ${fields.length}`,
+        };
+    }
+    const [commit, tree, parentsField] = fields;
+    if (!isFullGitObjectId(commit) || !isFullGitObjectId(tree)) {
+        return {
+            status: "malformed",
+            revision,
+            detail: "commit or tree field is not a full object id",
+        };
+    }
+    const parents = parentsField.trim().length === 0
+        ? []
+        : parentsField.trim().split(/\s+/).filter((part) => part.length > 0);
+    if (parents.some((parent) => !isFullGitObjectId(parent))) {
+        return {
+            status: "malformed",
+            revision,
+            detail: "parent field contains a non-object id",
+        };
+    }
+    return { status: "ok", coordinate: { commit, tree, parents } };
+}
+/** Map a failed coordinate read into a wrapped Git error for throw-style callers. */
+export function commitCoordinateFailureError(read, cwd) {
+    if (read.status === "failed") {
+        const failure = read.error ?? Object.assign(new Error(read.result.stderr || `git log --no-walk exited ${read.result.status}`), {
+            stderr: read.result.stderr,
+            stdout: read.result.stdout,
+        });
+        return wrapGitError(`log --no-walk coordinate ${read.revision}`, failure, cwd);
+    }
+    if (read.status === "missing") {
+        return wrapGitError(`log --no-walk coordinate ${read.revision}`, Object.assign(new Error(`revision '${read.revision}' does not resolve`), { stderr: "" }), cwd);
+    }
+    if (read.status === "non-commit") {
+        return wrapGitError(`log --no-walk coordinate ${read.revision}`, Object.assign(new Error(`revision '${read.revision}' does not resolve to a commit`), { stderr: "" }), cwd);
+    }
+    return wrapGitError(`log --no-walk coordinate ${read.revision}`, Object.assign(new Error(`malformed commit coordinate for '${read.revision}': ${read.detail}`), { stderr: "" }), cwd);
+}
+/** Require a resolved coordinate or throw a wrapped Git error. */
+export async function requireCommitCoordinate(cwd, revision) {
+    const read = await readCommitCoordinate(cwd, revision);
+    if (read.status === "ok")
+        return read.coordinate;
+    throw commitCoordinateFailureError(read, cwd);
+}
 export function shortCommitHash(hash) {
     return hash.slice(0, 12);
 }
 export async function resolveCommitRef(cwd, ref) {
-    const git = createGit(cwd);
-    try {
-        const output = await git.raw(["rev-parse", "--verify", `${ref}^{commit}`]);
-        return output.trim();
-    }
-    catch (error) {
-        throw new FlowError("INVALID_COMMIT", `commit '${ref}' does not resolve to a commit`, { cause: error });
+    const read = await readCommitCoordinate(cwd, ref);
+    if (read.status !== "ok") {
+        throw new FlowError("INVALID_COMMIT", `commit '${ref}' does not resolve to a commit`, {
+            cause: read.status === "failed" ? read.error : undefined,
+        });
     }
+    return read.coordinate.commit;
 }
 export async function isCommitReachableFromHead(cwd, commit) {
     return isCommitAncestor(cwd, commit, "HEAD");
 }
 export async function isCommitAncestor(cwd, ancestor, descendant) {
-    const git = createGit(cwd);
-    try {
-        await git.raw(["merge-base", "--is-ancestor", ancestor, descendant]);
-        return true;
-    }
-    catch {
-        return false;
-    }
+    const result = await runGitProcess(cwd, ["merge-base", "--is-ancestor", ancestor, descendant]);
+    return result.status === 0 && result.error === undefined;
 }
 export async function getHeadCommitHash(cwd) {
-    const git = createGit(cwd);
     try {
-        const output = await git.raw(["rev-parse", "HEAD"]);
+        const output = (await runGitOrThrow(cwd, ["rev-parse", "HEAD"])).stdout;
         return output.trim();
     }
     catch (error) {
@@ -62,16 +134,15 @@ export async function resolveCommitRefs(cwd, refs) {
 export async function renderCommitStatPreview(cwd, commits) {
     if (commits.length === 0)
         return "No delivery commits recorded.";
-    const git = createGit(cwd);
     try {
-        const chunks = await Promise.all(commits.map(async (commit) => (await git.raw([
+        const chunks = await Promise.all(commits.map(async (commit) => (await runGitOrThrow(cwd, [
             "show",
             "--stat",
             "--summary",
             "--format=commit %H%n%s",
             "--no-renames",
             commit,
-        ])).trim()));
+        ])).stdout.trim()));
         return chunks.filter((chunk) => chunk.length > 0).join("\n\n");
     }
     catch (error) {

package/build/git/core.js

@@ -1,31 +1,10 @@
-import { spawn } from "node:child_process";
 import { simpleGit } from "simple-git";
+import { existsSync } from "node:fs";
 import { normalizeFilesystemCoordinate } from "../fs/path-coordinate.js";
-import { getConfig } from "../config/env.js";
 import { appendDebugBlock } from "../telemetry/debug-log.js";
+import { gitProcessEnv, resolveGitExecutable, resolveGitTimeoutMs } from "./process.js";
+export { GIT_ABORT_FORCE_KILL_MS, gitProcessEnv, openGitProcess, resolveGitExecutable, resolveGitTimeoutMs, runGitOrThrow, runGitProcess, runGitProcessBytes, terminateGitChild, } from "./process.js";
 const GIT_ERROR_COMPACT_MAX_CHARS = 4000;
-export const GIT_ABORT_FORCE_KILL_MS = 250;
-/** Terminate one non-detached Git child and wait until Node drains its stdio close. */
-export async function terminateGitChild(child, closed, graceMs = GIT_ABORT_FORCE_KILL_MS) {
-    if (child.exitCode === null && child.signalCode === null)
-        child.kill("SIGTERM");
-    let grace;
-    const exited = await Promise.race([
-        closed.then(() => true),
-        new Promise((resolve) => {
-            grace = setTimeout(() => resolve(false), graceMs);
-            grace.unref();
-        }),
-    ]);
-    if (grace)
-        clearTimeout(grace);
-    // Only the close event proves process exit and stdio drain. `killed` and
-    // `signalCode` merely report signal delivery and can be set while a handler
-    // keeps the child alive.
-    if (!exited)
-        child.kill("SIGKILL");
-    await closed;
-}
 export const MISSING_GIT_CONFIG_PATTERNS = ["No such section or key"];
 export const NOT_GIT_REPOSITORY_PATTERNS = ["not a git repository"];
 export const MISSING_HEAD_PATTERNS = [
@@ -41,8 +20,9 @@ export function isFullGitObjectId(value) {
 /** Git is an optional adapter for directory-local product surfaces. */
 export function isGitExecutableUnavailable(error) {
     const source = (error ?? {});
-    if (source.code === "ENOENT")
-        return true;
+    if (source.code === "ENOENT") {
+        return typeof source.gitCwd !== "string" || existsSync(source.gitCwd);
+    }
     const message = typeof source.message === "string" ? source.message : String(error);
     return /spawn\s+git\s+ENOENT|git(?:\.exe)?["']?\s*:\s*(?:not found|no such file)/i.test(message);
 }
@@ -93,146 +73,14 @@ export function wrapGitError(commandLabel, err, cwd) {
     }
     return wrapped;
 }
-/** Configured Git timeout, with a bootstrap-safe default before env loads. */
-export function resolveGitTimeoutMs() {
-    try {
-        return getConfig().git.timeoutMs;
-    }
-    catch {
-        // Git coordinates and early probes remain usable before config bootstrap.
-        return 60_000;
-    }
-}
-/** Non-interactive Git process environment shared by one-shot and streaming gates. */
-export function gitProcessEnv(extra) {
-    return {
-        ...process.env,
-        ...extra,
-        GIT_TERMINAL_PROMPT: "0",
-        GCM_INTERACTIVE: "Never",
-        GIT_MERGE_AUTOEDIT: "no",
-        LC_ALL: "C",
-        PATH: extra?.PATH ?? process.env.PATH ?? "",
-    };
-}
 export function createGit(cwd) {
     const timeoutMs = resolveGitTimeoutMs();
     const git = simpleGit(normalizeFilesystemCoordinate(cwd), {
+        binary: resolveGitExecutable(),
         timeout: { block: timeoutMs, stdErr: true, stdOut: true },
+        unsafe: { allowUnsafeCustomBinary: true },
     });
     // simple-git replaces its child environment when configured through env().
-    // Preserve trace controls explicitly without admitting unrelated ambient Git
-    // behavior such as a pager into command execution.
-    const traceEnvironment = Object.fromEntries(Object.entries(process.env).filter(([key]) => key.startsWith("GIT_TRACE2")));
-    git.env({
-        ...traceEnvironment,
-        GIT_TERMINAL_PROMPT: "0",
-        GCM_INTERACTIVE: "Never",
-        GIT_MERGE_AUTOEDIT: "no",
-        LC_ALL: "C",
-        PATH: process.env.PATH ?? "",
-    });
+    git.env(gitProcessEnv());
     return git;
 }
-/**
- * Asynchronous one-shot Git process boundary that preserves stdout/stderr/status facts.
- * Prefer `createGit` when non-zero exits are fatal; use this when callers need
- * soft status codes or stdin (simple-git drops empty-stderr non-zero exits).
- * Long-lived multi-request stdin/stdout sessions use `openGitStreamingBatch`.
- */
-export async function runGitProcessBytes(cwd, args, options) {
-    options?.signal?.throwIfAborted();
-    const timeoutMs = resolveGitTimeoutMs();
-    const env = gitProcessEnv(options?.env);
-    return await new Promise((resolve) => {
-        const child = spawn("git", [...args], {
-            cwd: normalizeFilesystemCoordinate(cwd),
-            env,
-            shell: false,
-            stdio: ["pipe", "pipe", "pipe"],
-        });
-        const stdoutChunks = [];
-        const stderrChunks = [];
-        let settled = false;
-        let timedOut = false;
-        let aborting = false;
-        let terminationPromise;
-        const closed = new Promise((resolveClosed) => child.once("close", () => resolveClosed()));
-        const finish = (result) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timeout);
-            options?.signal?.removeEventListener("abort", abort);
-            resolve(result);
-        };
-        const abort = () => {
-            if (aborting)
-                return;
-            aborting = true;
-            terminationPromise = terminateGitChild(child, closed);
-        };
-        options?.signal?.addEventListener("abort", abort, { once: true });
-        if (options?.signal?.aborted)
-            abort();
-        const timeout = setTimeout(() => {
-            timedOut = true;
-            child.kill("SIGKILL");
-        }, timeoutMs);
-        if (options?.input !== undefined) {
-            if (typeof options.input === "string")
-                child.stdin.end(options.input, "utf8");
-            else
-                child.stdin.end(options.input);
-        }
-        else {
-            child.stdin.end();
-        }
-        child.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
-        child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
-        child.on("error", (error) => {
-            finish({
-                stdout: Buffer.concat(stdoutChunks),
-                stderr: Buffer.concat(stderrChunks),
-                status: null,
-                error,
-            });
-        });
-        child.on("close", async (code, signal) => {
-            if (terminationPromise)
-                await terminationPromise;
-            const stdout = Buffer.concat(stdoutChunks);
-            const stderr = Buffer.concat(stderrChunks);
-            if (timedOut) {
-                finish({
-                    stdout,
-                    stderr,
-                    status: null,
-                    error: new Error("git timed out"),
-                });
-                return;
-            }
-            if (signal) {
-                finish({
-                    stdout,
-                    stderr,
-                    status: null,
-                    error: options?.signal?.aborted
-                        ? options.signal.reason instanceof Error ? options.signal.reason : new DOMException("The operation was aborted", "AbortError")
-                        : new Error(`git exited from signal ${signal}`),
-                });
-                return;
-            }
-            finish({ stdout, stderr, status: code });
-        });
-    });
-}
-export async function runGitProcess(cwd, args, options) {
-    const result = await runGitProcessBytes(cwd, args, options);
-    return {
-        stdout: result.stdout.toString("utf8"),
-        stderr: result.stderr.toString("utf8"),
-        status: result.status,
-        ...(result.error ? { error: result.error } : {}),
-    };
-}

package/build/git/diff/preview.js

@@ -1,15 +1,15 @@
-import { createGit, wrapGitError } from "../core.js";
+import { wrapGitError } from "../core.js";
+import { runGitOrThrow } from "../process.js";
 import { diffPathspecArgs } from "./pathspec.js";
 export async function getDiffStats(cwd, baseBranch, options = {}) {
-    const git = createGit(cwd);
     let rawNumStat;
     try {
-        rawNumStat = await git.raw([
+        rawNumStat = (await runGitOrThrow(cwd, [
             "diff",
             "--numstat",
             `${baseBranch}...HEAD`,
             ...diffPathspecArgs({ excludePaths: options.excludePaths }),
-        ]);
+        ])).stdout;
     }
     catch (err) {
         throw wrapGitError(`diff --numstat ${baseBranch}...HEAD`, err, cwd);

package/build/git/diff/read.js

@@ -1,4 +1,5 @@
-import { createGit, wrapGitError } from "../core.js";
+import { wrapGitError } from "../core.js";
+import { runGitOrThrow } from "../process.js";
 import { diffPathspecArgs } from "./pathspec.js";
 import { isMissingBaseRevisionError, splitDiffByFile, totalJoinedLength, truncateDiffBlockToCharBudget, truncateDiffSectionByLineCount, truncateTextWithFooter, } from "./parsers.js";
 function normalizeDiffTarget(target) {
@@ -66,7 +67,6 @@ function renderPatchDiff(output, options) {
     return renderedSections.join("\n\n").trim() || "No diff.";
 }
 export async function readDiff(cwd, target, format, options = {}) {
-    const git = createGit(cwd);
     const formattedTarget = formatDiffTarget(target);
     try {
         if (format === "stat") {
@@ -75,7 +75,7 @@ export async function readDiff(cwd, target, format, options = {}) {
             const args = statVariant === "numstat"
                 ? ["diff", "--numstat", ...normalizeDiffTarget(target), ...pathspec]
                 : ["diff", "--stat=120,80", "--compact-summary", ...normalizeDiffTarget(target), ...pathspec];
-            const output = await git.raw(args);
+            const output = (await runGitOrThrow(cwd, args)).stdout;
             if (statVariant !== "summary") {
                 return output.trim() || "No diff.";
             }
@@ -88,7 +88,7 @@ export async function readDiff(cwd, target, format, options = {}) {
             }
             return truncateTextWithFooter(trimmed, maxChars, trimmed.length - maxChars);
         }
-        const output = await git.raw(buildPatchCommand(target, options));
+        const output = (await runGitOrThrow(cwd, buildPatchCommand(target, options))).stdout;
         return renderPatchDiff(output, options);
     }
     catch (error) {

package/build/git/diff/structured.js

@@ -1,4 +1,5 @@
-import { createGit, wrapGitError } from "../core.js";
+import { wrapGitError } from "../core.js";
+import { runGitOrThrow } from "../process.js";
 import { diffPathspecArgs } from "./pathspec.js";
 import { parseHunkRange, parseUnifiedHunks, splitDiffByFile } from "./parsers.js";
 function parseRawDiff(output) {
@@ -88,14 +89,13 @@ function parsePatchHunks(section) {
     });
 }
 export async function readStructuredDiff(cwd, from, to, options = {}) {
-    const git = createGit(cwd);
     const range = `${from}..${to}`;
     const pathspec = diffPathspecArgs({ excludePaths: options.excludePaths });
     try {
         const [raw, numstat, patch] = await Promise.all([
-            git.raw(["diff", "--raw", "-z", "--find-renames", range, ...pathspec]),
-            git.raw(["diff", "--numstat", "-z", "--find-renames", range, ...pathspec]),
-            git.raw(["diff", "--no-color", "--no-ext-diff", "--unified=3", "--find-renames", range, ...pathspec]),
+            runGitOrThrow(cwd, ["diff", "--raw", "-z", "--find-renames", range, ...pathspec]).then((result) => result.stdout),
+            runGitOrThrow(cwd, ["diff", "--numstat", "-z", "--find-renames", range, ...pathspec]).then((result) => result.stdout),
+            runGitOrThrow(cwd, ["diff", "--no-color", "--no-ext-diff", "--unified=3", "--find-renames", range, ...pathspec]).then((result) => result.stdout),
         ]);
         const rawFiles = parseRawDiff(raw);
         const stats = parseNumstat(numstat);