@astrosheep/keiyaku 2.9.9 → 2.9.11

package/build/core/worktree-path.js

@@ -1,14 +1,61 @@
 import * as path from "node:path";
 import * as fs from "node:fs/promises";
 import { FlowError } from "../flow-error.js";
-import { createGit, wrapGitError } from "../git/core.js";
-import { readLedger } from "./ledger.js";
-import { readLedgerSnapshot } from "./ledger-batch.js";
-import { deriveContractState, isTerminalState } from "./status/lifecycle.js";
+import { createGit, runGitProcess, wrapGitError } from "../git/core.js";
+import { resolveLocalBranchHead } from "../git/refs.js";
+import { readCurrentContractLifecycle } from "./repository-ledger/read-model.js";
 import { normalizeFilesystemCoordinate } from "../fs/path-coordinate.js";
 import { gitCommonRootPath, resolveGitCommonRoot } from "../git/path-coordinate.js";
-export function findBindEntry(entries) {
-    return entries.find((entry) => entry.kind === "bind");
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+/** Reconstruct the public terminal-cleanup fact from its independent replay receipts. */
+export function terminalCleanupFacts(worktreeValue, deliveryRefValue) {
+    const worktree = record(worktreeValue);
+    const delivery = record(deliveryRefValue);
+    if (!worktree || !Array.isArray(worktree.absent) || !delivery)
+        return undefined;
+    const absent = worktree.absent.filter((item) => item === "worktree");
+    const base = {
+        absent,
+        ...(typeof worktree.removedWorktreePath === "string" ? { removedWorktreePath: worktree.removedWorktreePath } : {}),
+    };
+    const failure = record(worktree.worktreeRemoveFailure);
+    if (failure && typeof failure.path === "string" && typeof failure.reason === "string") {
+        base.worktreeRemoveFailure = { path: failure.path, reason: failure.reason };
+    }
+    if (delivery.status === "aligned"
+        && typeof delivery.ref === "string"
+        && delivery.expected === "absent"
+        && delivery.observed === "absent") {
+        return { ...base, deliveryRef: { status: "aligned", ref: delivery.ref, expected: "absent", observed: "absent" } };
+    }
+    const mismatch = record(delivery.mismatch);
+    const observed = record(mismatch?.observed);
+    if (delivery.status === "mismatch"
+        && mismatch?.kind === "projected-surface-mismatch"
+        && mismatch.surface === "delivery-ref"
+        && typeof mismatch.ref === "string"
+        && mismatch.expected === "absent"
+        && observed?.state === "present"
+        && typeof observed.head === "string") {
+        return {
+            ...base,
+            deliveryRef: {
+                status: "mismatch",
+                mismatch: {
+                    kind: "projected-surface-mismatch",
+                    surface: "delivery-ref",
+                    ref: mismatch.ref,
+                    expected: "absent",
+                    observed: { state: "present", head: observed.head },
+                },
+            },
+        };
+    }
+    return undefined;
 }
 function parseWorktreeListPorcelainZ(output) {
     const listings = [];
@@ -28,7 +75,16 @@ function parseWorktreeListPorcelainZ(output) {
         listings.push(current);
     return listings;
 }
-async function listWorktrees(cwd) {
+async function listWorktrees(cwd, signal) {
+    if (signal) {
+        const result = await runGitProcess(cwd, ["worktree", "list", "--porcelain", "-z"], { signal });
+        if (result.error || result.status !== 0) {
+            if (result.error?.name === "AbortError")
+                throw result.error;
+            throw wrapGitError("worktree list --porcelain -z", result.error ?? new Error(result.stderr || `exit ${String(result.status)}`), cwd);
+        }
+        return parseWorktreeListPorcelainZ(result.stdout);
+    }
     const git = createGit(cwd);
     try {
         return parseWorktreeListPorcelainZ(await git.raw(["worktree", "list", "--porcelain", "-z"]));
@@ -80,16 +136,19 @@ function contractWorktreePathFromStableRoot(stableRoot, contractId, bind) {
     return path.join(stableRoot, ".keiyaku", "wt", bind?.data.place ?? contractId);
 }
 export async function contractWorktreePath(cwd, contractId) {
-    const ledger = await readLedger(cwd, contractId);
-    const bind = ledger ? findBindEntry(ledger.entries) : undefined;
-    return await contractWorktreePathFromBind(cwd, contractId, bind);
+    const stableRoot = await stableRepoRoot(cwd);
+    const outcome = await readCurrentContractLifecycle(stableRoot, contractId);
+    return path.join(stableRoot, ".keiyaku", "wt", outcome.status === "healthy" || outcome.status === "diseased"
+        ? outcome.model.resources.worktree?.place ?? contractId
+        : contractId);
 }
 export async function requireContractWorktreePath(cwd, contractId) {
-    const ledger = await readLedger(cwd, contractId);
-    if (!ledger) {
+    const stableRoot = await stableRepoRoot(cwd);
+    const outcome = await readCurrentContractLifecycle(stableRoot, contractId);
+    if (outcome.status !== "healthy" || !outcome.model.resources.worktree) {
         throw new FlowError("INTERNAL_STATE", `contract ${contractId} not found`);
     }
-    return await contractWorktreePathFromBind(cwd, contractId, findBindEntry(ledger.entries));
+    return path.join(stableRoot, ".keiyaku", "wt", outcome.model.resources.worktree.place);
 }
 async function findContractWorktree(cwd, contractId) {
     const expectedBranch = `refs/heads/keiyaku/${contractId}`;
@@ -108,21 +167,53 @@ export async function findContractWorktreePath(cwd, contractId) {
 }
 export async function findRegisteredContractWorktreePath(cwd, contractId) {
     const stableRoot = await stableRepoRoot(cwd);
-    const ledger = await readLedger(stableRoot, contractId);
-    const bind = ledger ? findBindEntry(ledger.entries) : undefined;
-    if (!bind || bind.data.workspace !== "worktree")
+    const outcome = await readCurrentContractLifecycle(stableRoot, contractId);
+    if (outcome.status !== "healthy" || outcome.model.resources.worktree?.state !== "held")
         return undefined;
-    let expected;
-    try {
-        expected = await fs.realpath(contractWorktreePathFromStableRoot(stableRoot, contractId, bind));
-    }
-    catch {
+    return findRegisteredContractWorktreePathFromModel(stableRoot, outcome.model);
+}
+export async function findRegisteredContractWorktreePathFromModel(stableRoot, model) {
+    const worktree = model.resources.worktree;
+    if (!worktree)
         return undefined;
+    const expected = path.join(stableRoot, ".keiyaku", "wt", worktree.place);
+    for (const registered of await listWorktrees(stableRoot)) {
+        if (registered.branch !== model.resources.deliveryRef)
+            continue;
+        try {
+            if (normalizeFilesystemCoordinate(await fs.realpath(registered.path)) === normalizeFilesystemCoordinate(await fs.realpath(expected))) {
+                return await fs.realpath(registered.path);
+            }
+        }
+        catch { /* stale registration is not lifecycle evidence */ }
     }
+    return undefined;
+}
+async function findRegisteredContractWorktreePathFromBind(stableRoot, contractId, _bind) {
+    const expectedBranch = `refs/heads/keiyaku/${contractId}`;
     for (const worktree of await listWorktrees(stableRoot)) {
+        let ownsBranch = worktree.branch === expectedBranch;
+        if (!ownsBranch && !worktree.branch) {
+            for (const statePath of ["rebase-merge/head-name", "rebase-apply/head-name"]) {
+                try {
+                    const gitPath = (await createGit(worktree.path).raw(["rev-parse", "--git-path", statePath])).trim();
+                    if ((await fs.readFile(gitPath, "utf8")).trim() === expectedBranch) {
+                        ownsBranch = true;
+                        break;
+                    }
+                }
+                catch {
+                    // No owned rebase coordinate at this registered worktree.
+                }
+            }
+        }
+        if (!ownsBranch)
+            continue;
         try {
-            if (await fs.realpath(worktree.path) === expected)
-                return worktree.path;
+            const dotGit = await fs.stat(path.join(worktree.path, ".git"));
+            if (dotGit.isDirectory())
+                continue;
+            return await fs.realpath(worktree.path);
         }
         catch {
             // A stale Git registration is not an engine-owned worktree fact.
@@ -130,12 +221,21 @@ export async function findRegisteredContractWorktreePath(cwd, contractId) {
     }
     return undefined;
 }
-/**
- * Delivery coordinate for dirty admission and KEIYAKU.md render: the linked
- * contract worktree when Git registers one, otherwise cwd (workspace here).
- */
-export async function resolveContractDeliveryCwd(cwd, contractId) {
-    return (await findContractWorktreePath(cwd, contractId)) ?? cwd;
+/** Prove the sole carrier target from stable-root, bind, and Git registration facts. */
+export async function resolveContractCarrierTarget(stableRoot, contractId, bind) {
+    if (bind.data.workspace === "here") {
+        const root = await fs.realpath(stableRoot);
+        return { status: "available", root, path: path.join(root, ".keiyaku", "KEIYAKU.md"), workspace: "here" };
+    }
+    const root = await findRegisteredContractWorktreePathFromBind(stableRoot, contractId, bind);
+    if (!root) {
+        return {
+            status: "unavailable",
+            workspace: "worktree",
+            reason: `contract ${contractId} has no verified registered engine worktree`,
+        };
+    }
+    return { status: "available", root, path: path.join(root, ".keiyaku", "KEIYAKU.md"), workspace: "worktree" };
 }
 /**
  * Resolve the contract id for an engine-owned bound worktree containing cwd.
@@ -144,10 +244,29 @@ export async function resolveContractDeliveryCwd(cwd, contractId) {
  */
 async function contractIdForEngineOwnedWorktree(cwd, options) {
     const stableRoot = options.stableRoot ?? await stableRepoRoot(cwd);
+    const candidate = await contractIdentityFromWorktreeWitness(cwd, stableRoot);
+    if (!candidate)
+        return undefined;
+    const outcome = await readCurrentContractLifecycle(stableRoot, candidate.contractId);
+    if (outcome.status !== "healthy" || !outcome.model.resources.worktree)
+        return undefined;
+    if (options.requireActive && ["claimed", "forfeited"].includes(outcome.model.phase))
+        return undefined;
+    let expectedWorktree;
+    try {
+        expectedWorktree = await fs.realpath(path.join(stableRoot, ".keiyaku", "wt", outcome.model.resources.worktree.place));
+    }
+    catch {
+        return undefined;
+    }
+    return candidate.path === expectedWorktree ? candidate.contractId : undefined;
+}
+/** Resolve only Git's local registered-worktree witness; lifecycle facts must verify it separately. */
+export async function contractIdentityFromWorktreeWitness(cwd, stableRoot, signal) {
     const canonicalCwd = await fs.realpath(cwd);
+    const branchPrefix = "refs/heads/keiyaku/";
     const candidates = [];
-    for (const worktree of await listWorktrees(stableRoot)) {
-        const branchPrefix = "refs/heads/keiyaku/";
+    for (const worktree of await listWorktrees(stableRoot, signal)) {
         if (!worktree.branch?.startsWith(branchPrefix))
             continue;
         let canonicalWorktree;
@@ -162,27 +281,10 @@ async function contractIdForEngineOwnedWorktree(cwd, options) {
         candidates.push({
             contractId: worktree.branch.slice(branchPrefix.length),
             path: canonicalWorktree,
+            branch: worktree.branch,
         });
     }
-    const candidate = candidates.sort((left, right) => right.path.length - left.path.length)[0];
-    if (!candidate)
-        return undefined;
-    const ledger = await readLedgerSnapshot(stableRoot, candidate.contractId);
-    if (!ledger)
-        return undefined;
-    if (options.requireActive && isTerminalState(deriveContractState(ledger.entries)))
-        return undefined;
-    const bind = findBindEntry(ledger.entries);
-    if (!bind || bind.data.workspace !== "worktree")
-        return undefined;
-    let expectedWorktree;
-    try {
-        expectedWorktree = await fs.realpath(contractWorktreePathFromStableRoot(stableRoot, candidate.contractId, bind));
-    }
-    catch {
-        return undefined;
-    }
-    return candidate.path === expectedWorktree ? candidate.contractId : undefined;
+    return candidates.sort((left, right) => right.path.length - left.path.length || left.contractId.localeCompare(right.contractId))[0];
 }
 /**
  * Resolve the contract bound by an engine-owned worktree containing cwd,
@@ -196,12 +298,48 @@ export async function contractBoundByEngineWorktree(cwd, stableRoot) {
 export async function activeContractBoundByEngineWorktree(cwd, stableRoot) {
     return contractIdForEngineOwnedWorktree(cwd, { requireActive: true, stableRoot });
 }
-export async function cleanupContractWorkspace(cwd, contractId) {
+/**
+ * Verify a worktree binding against a folded current-ledger model. Git's
+ * registration is only a physical witness here; it cannot create lifecycle
+ * state or select a contract absent from the supplied read model.
+ */
+export async function currentContractBoundByWorktreeWitness(input) {
+    let canonicalCwd;
+    try {
+        canonicalCwd = await fs.realpath(input.cwd);
+    }
+    catch {
+        return undefined;
+    }
+    const registeredWorktrees = await listWorktrees(input.stableRoot);
+    const candidates = [];
+    for (const model of input.contracts) {
+        const worktree = model.resources.worktree;
+        if (!worktree || worktree.state !== "held")
+            continue;
+        const expectedPath = path.join(input.stableRoot, ".keiyaku", "wt", worktree.place);
+        let canonicalExpectedPath;
+        try {
+            canonicalExpectedPath = await fs.realpath(expectedPath);
+        }
+        catch {
+            continue;
+        }
+        if (!worktreeContainsCoordinate(canonicalExpectedPath, canonicalCwd))
+            continue;
+        const registered = registeredWorktrees.some((candidate) => candidate.branch === model.resources.deliveryRef &&
+            normalizeFilesystemCoordinate(candidate.path) === normalizeFilesystemCoordinate(canonicalExpectedPath));
+        if (registered)
+            candidates.push({ contract: model.contract, path: canonicalExpectedPath });
+    }
+    candidates.sort((left, right) => right.path.length - left.path.length || left.contract.localeCompare(right.contract));
+    return candidates[0]?.contract;
+}
+/** Remove only the derived linked worktree. Authoritative refs are outside this adapter. */
+export async function cleanupContractWorkspace(cwd, lifecycle) {
     const stableRoot = await stableRepoRoot(cwd);
     const git = createGit(stableRoot);
-    const branch = `keiyaku/${contractId}`;
-    const worktree = await findContractWorktree(stableRoot, contractId);
-    const worktreePath = worktree.path;
+    const worktreePath = await findRegisteredContractWorktreePathFromModel(stableRoot, lifecycle);
     const facts = { absent: [] };
     if (worktreePath) {
         try {
@@ -215,28 +353,23 @@ export async function cleanupContractWorkspace(cwd, contractId) {
     else {
         facts.absent.push("worktree");
     }
-    if (worktree.primary) {
-        facts.absent.push("branch");
-        return facts;
-    }
-    let branchRef;
-    try {
-        branchRef = (await git.raw(["for-each-ref", "--format=%(refname)", `refs/heads/${branch}`])).trim();
-    }
-    catch (error) {
-        throw wrapGitError(`for-each-ref refs/heads/${branch}`, error, stableRoot);
-    }
-    if (branchRef !== `refs/heads/${branch}`) {
-        facts.absent.push("branch");
-    }
-    else {
-        try {
-            await git.raw(["branch", "-D", branch]);
-            facts.deletedBranch = branch;
-        }
-        catch (error) {
-            facts.branchDeleteFailure = { name: branch, reason: wrapGitError(`branch -D ${branch}`, error, stableRoot).message };
-        }
-    }
     return facts;
 }
+/** Observe the terminal transaction's expected delivery-ref absence without reconciling it. */
+export async function observeTerminalDeliveryRef(cwd, contractId) {
+    const stableRoot = await stableRepoRoot(cwd);
+    const ref = `refs/heads/keiyaku/${contractId}`;
+    const observed = await resolveLocalBranchHead(stableRoot, ref);
+    if (!observed)
+        return { status: "aligned", ref, expected: "absent", observed: "absent" };
+    return {
+        status: "mismatch",
+        mismatch: {
+            kind: "projected-surface-mismatch",
+            surface: "delivery-ref",
+            ref,
+            expected: "absent",
+            observed: { state: "present", head: observed.head },
+        },
+    };
+}

package/build/flow-error.js

@@ -64,6 +64,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 "TASK_AMBIGUOUS":
+            return ["Pass one complete task coordinate from the listed candidates."];
         case "UNKNOWN_COMMAND":
             return ["Run `keiyaku --help` to inspect available commands."];
         case "EMPTY_PARAM":
@@ -77,13 +79,11 @@ export function resolveFlowErrorHints(code, context, facts) {
         case "MISSING_PROTOCOL_FILES":
             return ["Required protocol file is missing (`KEIYAKU.md`)."];
         case "CLOSE_MERGE_CONFLICT":
-            return [`Open a Keiyaku recovery session with \`keiyaku ${context.renewToolName} --resolve\`.`];
+            return [];
         case "RENEW_COORDINATE_DRIFT":
             return [`Restore the delivery to its ledger-recorded history with Git reflog, then retry \`keiyaku ${context.renewToolName}\`.`];
-        case "RENEW_SESSION_OPEN":
-            return [`Continue the owned rewrite with \`keiyaku ${context.renewToolName} --continue\`, or restore it with \`keiyaku ${context.renewToolName} --abort\`.`];
-        case "RENEW_SESSION_NOT_FOUND":
-            return [`No recovery session is open; run \`keiyaku ${context.renewToolName}\` normally.`];
+        case "RENEW_SCRATCH_NOT_FOUND":
+            return [`No renew conflict scratch is open; run \`keiyaku ${context.renewToolName}\` normally.`];
         case "CLOSE_QUALITY_GATE_FAILED":
             return [`CLAIM denied: a configured verification command failed. Use \`${context.arcToolName}\` after addressing the failure before petitioning again.`];
         case "INVALID_BRANCH_TITLE":
@@ -95,9 +95,9 @@ export function resolveFlowErrorHints(code, context, facts) {
         case "FROM_DRAFT_NOT_FOUND":
             return ["The path in `from_draft` does not exist. `from_draft` must reference an existing file path (absolute or relative to `cwd`)."];
         case "INVALID_KEIYAKU_DRAFT":
-            return ["Invalid draft/input. Use a `# <title>` heading with non-empty `## Objective` and `## Scope` sections (or the equivalent shape in `from_draft`)."];
+            return ["Invalid draft/input. Use a `# <title>` heading with non-empty `## Context`, `## Objective`, `## Design`, `## Scope`, `## Criteria`, and `## Verification` sections (or the equivalent shape in `from_draft`)."];
         case "BIND_TASK_INCOMPLETE":
-            return ["Task supplies name/objective defaults; pipe only the missing sections as partial contract Markdown on stdin."];
+            return ["Task supplies title/objective defaults; pipe only the missing sections as partial contract Markdown on stdin."];
         case "KEIYAKU_FILE_EXISTS":
             return [`\`${context.bindToolName}\` requires a clean slate. \`KEIYAKU.md\` must be removed before starting.`];
         case "DETACHED_HEAD":

package/build/generated/version.js

@@ -1,3 +1,3 @@
 // Generated into build output by scripts/build.mjs
-export const VERSION = "2.9.9";
-export const GIT_HASH = "79df272";
+export const VERSION = "2.9.11";
+export const GIT_HASH = "4384d75";

package/build/git/core.js

@@ -4,6 +4,28 @@ import { normalizeFilesystemCoordinate } from "../fs/path-coordinate.js";
 import { getConfig } from "../config/env.js";
 import { appendDebugBlock } from "../telemetry/debug-log.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 = [
@@ -12,6 +34,10 @@ export const MISSING_HEAD_PATTERNS = [
     "unknown revision or path not in the working tree",
     "bad revision 'HEAD'",
 ];
+/** Accept only a complete object id from either supported Git object format. */
+export function isFullGitObjectId(value) {
+    return /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/i.test(value);
+}
 /** Git is an optional adapter for directory-local product surfaces. */
 export function isGitExecutableUnavailable(error) {
     const source = (error ?? {});
@@ -94,11 +120,18 @@ export function createGit(cwd) {
     const git = simpleGit(normalizeFilesystemCoordinate(cwd), {
         timeout: { block: timeoutMs, stdErr: true, stdOut: true },
     });
-    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 ?? "");
+    // 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 ?? "",
+    });
     return git;
 }
 /**
@@ -107,7 +140,8 @@ export function createGit(cwd) {
  * 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 runGitProcess(cwd, args, options) {
+export async function runGitProcessBytes(cwd, args, options) {
+    options?.signal?.throwIfAborted();
     const timeoutMs = resolveGitTimeoutMs();
     const env = gitProcessEnv(options?.env);
     return await new Promise((resolve) => {
@@ -121,19 +155,35 @@ export async function runGitProcess(cwd, args, options) {
         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) {
-            child.stdin.end(options.input, "utf8");
+            if (typeof options.input === "string")
+                child.stdin.end(options.input, "utf8");
+            else
+                child.stdin.end(options.input);
         }
         else {
             child.stdin.end();
@@ -142,15 +192,17 @@ export async function runGitProcess(cwd, args, options) {
         child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
         child.on("error", (error) => {
             finish({
-                stdout: Buffer.concat(stdoutChunks).toString("utf8"),
-                stderr: Buffer.concat(stderrChunks).toString("utf8"),
+                stdout: Buffer.concat(stdoutChunks),
+                stderr: Buffer.concat(stderrChunks),
                 status: null,
                 error,
             });
         });
-        child.on("close", (code, signal) => {
-            const stdout = Buffer.concat(stdoutChunks).toString("utf8");
-            const stderr = Buffer.concat(stderrChunks).toString("utf8");
+        child.on("close", async (code, signal) => {
+            if (terminationPromise)
+                await terminationPromise;
+            const stdout = Buffer.concat(stdoutChunks);
+            const stderr = Buffer.concat(stderrChunks);
             if (timedOut) {
                 finish({
                     stdout,
@@ -165,7 +217,9 @@ export async function runGitProcess(cwd, args, options) {
                     stdout,
                     stderr,
                     status: null,
-                    error: new Error(`git exited from signal ${signal}`),
+                    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;
             }
@@ -173,3 +227,12 @@ export async function runGitProcess(cwd, args, options) {
         });
     });
 }
+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 } : {}),
+    };
+}