@astrosheep/keiyaku 4.6.3 → 4.6.6

package/build/src/git/tender.js

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { access } from "node:fs/promises";
 import { gitObjectIdForSnapshot, mintSnapshotId } from "./identity.js";
 import { decodeGitNumstat, registeredWorktreePaths } from "./repository.js";
-import { GitPlumbingError, runGit, runGitWithEnvironment } from "./process.js";
+import { executeGit, GitPlumbingError } from "./process.js";
 import { captureWorkspaceTree, unmergedWorkspacePaths, workspaceMergeHead, worktreePath } from "./workspace.js";
 export const worktreeMissingRefusalSchema = z
     .object({ kind: z.literal("worktree-missing"), contractId: contractIdSchema })
@@ -69,7 +69,7 @@ export async function captureTender(repository, input) {
     };
 }
 async function dirtyShortStat(repository, tender) {
-    return decodeGitNumstat(await runGit(repository, ["diff", "--numstat", "-z", gitObjectIdForSnapshot(tender.head), tender.tree]));
+    return decodeGitNumstat(await executeGit(repository, ["diff", "--numstat", "-z", gitObjectIdForSnapshot(tender.head), tender.tree]));
 }
 export async function dirtyTenderRefusal(repository, contractId, tender) {
     return {
@@ -87,7 +87,7 @@ export async function dirtyTenderDelta(repository, tender) {
 }
 async function effectiveConfig(repository, key) {
     try {
-        const value = (await runGit(repository, ["config", "--get", key])).toString("utf8").trim();
+        const value = (await executeGit(repository, ["config", "--get", key])).toString("utf8").trim();
         return value.length === 0 ? undefined : value;
     }
     catch (error) {
@@ -119,22 +119,29 @@ export async function prepareDeliveryCommitMetadata(repository, input) {
         identity,
     };
 }
-/** Materialize the tender tree when it contains admitted dirty workspace bytes. */
-export async function materializeTenderSnapshot(repository, tender, commit) {
-    if (!tender.dirty && tender.mergeHead === undefined)
-        return tender.head;
-    const parents = ["-p", gitObjectIdForSnapshot(tender.head)];
-    if (tender.mergeHead !== undefined)
-        parents.push("-p", gitObjectIdForSnapshot(tender.mergeHead));
-    const oid = (await runGitWithEnvironment(repository, ["commit-tree", tender.tree, ...parents], commit.message, {
+/** The Git identity environment for one delivery snapshot commit. */
+export function deliveryEnvironment(commit) {
+    return {
         GIT_AUTHOR_NAME: commit.identity.name,
         GIT_AUTHOR_EMAIL: commit.identity.email,
         GIT_COMMITTER_NAME: commit.identity.name,
         GIT_COMMITTER_EMAIL: commit.identity.email,
         GIT_AUTHOR_DATE: commit.at,
         GIT_COMMITTER_DATE: commit.at,
-    }))
+    };
+}
+/** Materialize one delivery snapshot commit over the given parents. */
+export async function materializeSnapshotCommit(repository, tree, parents, message, environment) {
+    const args = parents.flatMap((parent) => ["-p", gitObjectIdForSnapshot(parent)]);
+    const oid = (await executeGit(repository, ["commit-tree", tree, ...args], message, environment))
         .toString("utf8")
         .trim();
     return mintSnapshotId(oid);
 }
+/** Materialize the tender tree when it contains admitted dirty workspace bytes. */
+export async function materializeTenderSnapshot(repository, tender, commit) {
+    if (!tender.dirty && tender.mergeHead === undefined)
+        return tender.head;
+    const parents = tender.mergeHead === undefined ? [tender.head] : [tender.head, tender.mergeHead];
+    return await materializeSnapshotCommit(repository, tender.tree, parents, commit.message, deliveryEnvironment(commit));
+}

package/build/src/git/terminal-reconcile.js

@@ -3,7 +3,7 @@ import { isKeiyakuOwnedRef, readRef, writeCommit } from "./repository.js";
 import { gitObjectIdForSnapshot, mintSnapshotId } from "./identity.js";
 import { runDestroyHooks } from "./hooks.js";
 import { terminalSealExpectations as decodeTerminalSealExpectations, terminalSealSnapshots, observeTerminalWorkspace, } from "./terminal-seal.js";
-import { GitPlumbingError, runGit } from "./process.js";
+import { GitPlumbingError, executeGit } from "./process.js";
 import { worktreePath } from "./workspace.js";
 async function pathExists(path) {
     try {
@@ -16,29 +16,38 @@ async function pathExists(path) {
         throw error;
     }
 }
+/** Attempt removal once. Retention is a lag carrying its reason; no effect claims the worktree state after it. */
 async function removeTerminalWorktree(repository, topology, path) {
     const registered = topology.paths.has(path);
     if (!registered) {
-        return { retained: await pathExists(path) };
+        return (await pathExists(path)) ? { retainedLag: { kind: "worktree-retained", path } } : {};
     }
     const present = await pathExists(path);
     try {
-        await runGit(repository, ["worktree", "remove", ...(present ? ["--force"] : []), path]);
+        await executeGit(repository, ["worktree", "remove", ...(present ? ["--force"] : []), path]);
     }
     catch (error) {
         if (!(error instanceof GitPlumbingError))
             throw error;
-        return { effect: { kind: "worktree", path, action: "unchanged" }, retained: true };
+        return { retainedLag: { kind: "worktree-retained", path, diagnostic: error.message } };
     }
     topology.paths.delete(path);
-    const retained = await pathExists(path);
-    return { effect: { kind: "worktree", path, action: retained ? "unchanged" : "removed" }, retained };
+    if (await pathExists(path)) {
+        return {
+            retainedLag: {
+                kind: "worktree-retained",
+                path,
+                diagnostic: `Git reported worktree removal but the path remains: ${path}`,
+            },
+        };
+    }
+    return { effect: { kind: "worktree", path, action: "removed" } };
 }
 export async function updateRef(repository, ref, desired) {
     const before = await readRef(repository, ref);
     if (before === desired)
         return { kind: "ref", name: ref, action: "unchanged", before, after: desired };
-    await runGit(repository, [
+    await executeGit(repository, [
         "update-ref",
         "--no-deref",
         ref,
@@ -51,7 +60,7 @@ export async function removeRef(repository, ref) {
     const before = await readRef(repository, ref);
     if (before === null)
         return { kind: "ref", name: ref, action: "unchanged", before: null, after: null };
-    await runGit(repository, ["update-ref", "--no-deref", "-d", ref, before]);
+    await executeGit(repository, ["update-ref", "--no-deref", "-d", ref, before]);
     return { kind: "ref", name: ref, action: "removed", before, after: null };
 }
 async function removeRefWithCustody(repository, ref, custodian, expectedCustodian) {
@@ -61,7 +70,7 @@ async function removeRefWithCustody(repository, ref, custodian, expectedCustodia
     if ((await readRef(repository, custodian)) !== expectedCustodian) {
         return { kind: "ref", name: ref, action: "unchanged", before, after: before };
     }
-    await runGit(repository, ["update-ref", "--stdin", "--no-deref"], [
+    await executeGit(repository, ["update-ref", "--stdin", "--no-deref"], [
         "start",
         `verify ${custodian} ${gitObjectIdForSnapshot(expectedCustodian)}`,
         `delete ${ref} ${before}`,
@@ -75,7 +84,7 @@ function retainedRefEffect(ref, snapshot) {
     return { kind: "ref", name: ref, action: "unchanged", before: snapshot, after: snapshot };
 }
 async function refRows(repository) {
-    const output = (await runGit(repository, ["for-each-ref", "--format=%(refname)%00%(objectname)"])).toString("utf8");
+    const output = (await executeGit(repository, ["for-each-ref", "--format=%(refname)%00%(objectname)"])).toString("utf8");
     if (output.length === 0)
         return [];
     return output
@@ -90,7 +99,7 @@ async function refRows(repository) {
 }
 async function commitIsAncestor(repository, ancestor, descendant) {
     try {
-        await runGit(repository, ["merge-base", "--is-ancestor", gitObjectIdForSnapshot(ancestor), descendant]);
+        await executeGit(repository, ["merge-base", "--is-ancestor", gitObjectIdForSnapshot(ancestor), descendant]);
         return true;
     }
     catch (error) {
@@ -181,8 +190,10 @@ async function removeSealedTerminalWorktree({ repository, topology, path, state,
         }
     }
     const removal = await removeTerminalWorktree(repository, topology, path);
-    if (removal.retained)
-        return retainTerminalWorktree(path, { kind: "worktree-retained", path }, acc);
+    if (removal.retainedLag !== undefined) {
+        acc.recordLag(removal.retainedLag);
+        return complete(acc.effects, acc.lag, acc.hookRuns);
+    }
     if (removal.effect !== undefined)
         acc.recordEffect(removal.effect);
     return null;

package/build/src/git/terminal-seal.d.ts

@@ -3,7 +3,6 @@ import type { ContractState, SnapshotId } from "../core/facts/types.js";
 import { type GitObjectId } from "./identity.js";
 import type { GitOid } from "./repository.js";
 import { type GitRepository } from "./process.js";
-import { captureWorkspaceTree } from "./workspace.js";
 export declare const unsealedBytesSchema: z.ZodObject<{
     kind: z.ZodLiteral<"unsealed-bytes">;
     path: z.ZodString;
@@ -16,25 +15,23 @@ export type TerminalSealExpectations = Readonly<{
     trees: readonly GitObjectId[];
     treeBySnapshot: ReadonlyMap<SnapshotId, GitObjectId>;
 }>;
-export type TerminalSealObject = Readonly<{
+type TerminalSealObject = Readonly<{
     kind: "present";
     type: string;
     bytes: Buffer;
 }> | Readonly<{
     kind: "missing";
 }>;
-type WorkspaceTree = Awaited<ReturnType<typeof captureWorkspaceTree>>;
 export type TerminalWorkspace = Readonly<{
     tree: GitObjectId;
     head: SnapshotId;
     submodules: readonly string[];
 }>;
-export type TerminalWorkspaceObservation = Readonly<{
+type TerminalWorkspaceObservation = Readonly<{
     workspace: TerminalWorkspace;
     unsealed: UnsealedBytes | null;
 }>;
 export declare function terminalSealSnapshots(state: ContractState): readonly SnapshotId[];
 export declare function terminalSealExpectations(state: ContractState, objects: ReadonlyMap<GitOid, TerminalSealObject>): TerminalSealExpectations;
-export declare function unsealedWorkspaceBytes(repository: GitRepository, path: string, expected: TerminalSealExpectations, workspace: WorkspaceTree): Promise<UnsealedBytes | null>;
 export declare function observeTerminalWorkspace(repository: GitRepository, path: string, expected: TerminalSealExpectations): Promise<TerminalWorkspaceObservation>;
 export {};

package/build/src/git/terminal-seal.js

@@ -1,7 +1,7 @@
 import { mintedSnapshotInputSchema } from "./identity.js";
 import { z } from "zod";
 import { gitObjectId, gitObjectIdForSnapshot, mintSnapshotId } from "./identity.js";
-import { runGit } from "./process.js";
+import { executeGit } from "./process.js";
 import { captureWorkspaceTree } from "./workspace.js";
 export const unsealedBytesSchema = z
     .object({
@@ -71,12 +71,14 @@ export function terminalSealExpectations(state, objects) {
     };
 }
 async function changedPaths(repository, left, right) {
-    const fields = (await runGit(repository, ["diff", "--name-only", "-z", left, right])).toString("utf8").split("\0");
+    const fields = (await executeGit(repository, ["diff", "--name-only", "-z", left, right]))
+        .toString("utf8")
+        .split("\0");
     if (fields.at(-1) !== "")
         throw new Error("Git tree diff paths are not NUL terminated");
     return fields.slice(0, -1).sort();
 }
-export async function unsealedWorkspaceBytes(repository, path, expected, workspace) {
+async function unsealedWorkspaceBytes(repository, path, expected, workspace) {
     const headIsSealed = expected.heads.includes(workspace.head);
     if (workspace.changes.submodules.length > 0) {
         return {

package/build/src/git/workspace.d.ts

@@ -2,8 +2,9 @@ import { z } from "zod";
 import type { ContractId, SnapshotId } from "../core/facts/types.js";
 import { type GitObjectId } from "./identity.js";
 import { type GitRepository } from "./process.js";
+import type { GitReadObservation } from "./read-observation.js";
 import type { ContractWorkspaceLocation } from "../workspace-place.js";
-export type WorkspaceChanges = Readonly<{
+type WorkspaceChanges = Readonly<{
     staged: readonly string[];
     unstaged: readonly string[];
     untracked: readonly string[];
@@ -19,7 +20,7 @@ export type WorkspaceTree = Readonly<{
 export declare function worktreePath(repository: GitRepository, place: string): string;
 /** Check out a captured candidate tree in the appointed detached worktree. */
 export declare function checkoutDetachedSnapshot(repository: GitRepository, workspace: string, snapshot: SnapshotId): Promise<void>;
-export type DependentWorktreeFollow = Readonly<{
+type DependentWorktreeFollow = Readonly<{
     kind: "followed";
     before: SnapshotId;
     after: SnapshotId;
@@ -42,7 +43,7 @@ export declare function workspaceMergeHead(repository: GitRepository, workspace:
 export declare function workspaceMergeStatePresent(repository: GitRepository, workspace: string): Promise<boolean>;
 /** Sorted unique unmerged index paths from porcelain status. */
 export declare function unmergedWorkspacePaths(repository: GitRepository, workspace: string): Promise<readonly string[]>;
-export type WorkspaceChangeCounts = Readonly<{
+type WorkspaceChangeCounts = Readonly<{
     staged: number;
     unstaged: number;
     untracked: number;
@@ -55,7 +56,7 @@ export declare const conflictRecoverySchema: z.ZodObject<{
 }, z.core.$strict>;
 type ConflictRecovery = z.infer<typeof conflictRecoverySchema>;
 export declare const conflictRecovery: ConflictRecovery;
-export type ContractWorkspaceMerge = Readonly<{
+type ContractWorkspaceMerge = Readonly<{
     head: SnapshotId;
     unmergedPaths: readonly string[];
     handoffBase?: SnapshotId;
@@ -100,7 +101,16 @@ export declare function observeWorkspace(repository: GitRepository, location: Co
 export declare function observeTargetLag(repository: GitRepository, workspace: string, head: SnapshotId | null | undefined): Promise<ContractTargetLag>;
 /** Capture tracked and untracked workspace bytes without changing its real index. */
 export declare function captureWorkspaceTree(repository: GitRepository, workspace: string): Promise<WorkspaceTree>;
-export type HandoffRetirement = Readonly<{
+export type HandoffReceiptCoordinate = Readonly<{
+    contractId: ContractId;
+    place: string;
+    workspace: string;
+}>;
+export type ConflictHandoff = Readonly<{
+    base: SnapshotId;
+    mergeHead: SnapshotId;
+}>;
+type HandoffRetirement = Readonly<{
     kind: "absent" | "active" | "orphan-retired" | "retired";
 }> | Readonly<{
     kind: "retained";
@@ -113,14 +123,8 @@ export declare function recordConflictHandoff(repository: GitRepository, input:
     head: SnapshotId;
     mergeHead: SnapshotId;
 }>): Promise<void>;
-export declare function conflictHandoffFor(repository: GitRepository, input: Readonly<{
-    contractId: ContractId;
-    place: string;
-    workspace: string;
-}>): Promise<Readonly<{
-    base: SnapshotId;
-    mergeHead: SnapshotId;
-}> | undefined>;
+/** Read selected handoff refs once and decode their receipts through the call's blob channel. */
+export declare function readConflictHandoffs(repository: GitRepository, readBlobs: GitReadObservation["readBlobs"], coordinates: readonly HandoffReceiptCoordinate[]): Promise<ReadonlyMap<ContractId, ConflictHandoff>>;
 export declare function retireConflictHandoff(repository: GitRepository, input: Readonly<{
     contractId: ContractId;
     place: string;

package/build/src/git/workspace.js

@@ -2,20 +2,21 @@ import { z } from "zod";
 import { access, mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
+import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { contractPhysicalName, gitObjectId, mintSnapshotId } from "./identity.js";
-import { GitPlumbingError, runGit, runGitWithEnvironment } from "./process.js";
-import { HANDOFF_RECEIPT_REF_NAMESPACE, readBlob, readRef, worktreeGitDirectory, writeBlob } from "./repository.js";
+import { executeGit, GitPlumbingError } from "./process.js";
+import { HANDOFF_RECEIPT_REF_NAMESPACE, readBlob, readRef, readRefs, worktreeGitDirectory, writeBlob, } from "./repository.js";
 const WORKTREE_DIRECTORY = [".keiyaku", "wt"];
 export function worktreePath(repository, place) {
     return resolve(repository.primaryWorktree, ...WORKTREE_DIRECTORY, place);
 }
 /** Check out a captured candidate tree in the appointed detached worktree. */
 export async function checkoutDetachedSnapshot(repository, workspace, snapshot) {
-    await runGit(repository, ["-C", workspace, "checkout", "--quiet", "--force", "--detach", gitObjectId(snapshot)]);
+    await executeGit(repository, ["-C", workspace, "checkout", "--quiet", "--force", "--detach", gitObjectId(snapshot)]);
 }
 async function workspaceRevision(repository, workspace, revision) {
     try {
-        const value = (await runGit(repository, ["-C", workspace, "rev-parse", "--verify", "--quiet", revision]))
+        const value = (await executeGit(repository, ["-C", workspace, "rev-parse", "--verify", "--quiet", revision]))
             .toString("utf8")
             .trim();
         return value.length === 0 ? null : mintSnapshotId(value);
@@ -37,7 +38,7 @@ async function workspaceOperationState(repository, workspace, gitDirectory) {
             return false;
         }
     }));
-    const unmerged = (await runGit(repository, ["-C", workspace, "ls-files", "--unmerged", "-z"])).length > 0;
+    const unmerged = (await executeGit(repository, ["-C", workspace, "ls-files", "--unmerged", "-z"])).length > 0;
     return { other: other.some(Boolean), unmerged };
 }
 /** Follow a dependency baseline only through a clean, detached fast-forward. */
@@ -58,7 +59,7 @@ export async function followDependentManagedWorktree(repository, workspace, targ
             ...status.unmergedPaths,
         ]),
     ].sort();
-    const attached = await runGit(repository, ["-C", workspace, "symbolic-ref", "--quiet", "HEAD"]).then(() => true, (error) => {
+    const attached = await executeGit(repository, ["-C", workspace, "symbolic-ref", "--quiet", "HEAD"]).then(() => true, (error) => {
         if (error instanceof GitPlumbingError && error.status === 1)
             return false;
         throw error;
@@ -72,7 +73,7 @@ export async function followDependentManagedWorktree(repository, workspace, targ
         return { kind: "unchanged" };
     let ancestor = false;
     try {
-        await runGit(repository, ["merge-base", "--is-ancestor", gitObjectId(head), gitObjectId(target)]);
+        await executeGit(repository, ["merge-base", "--is-ancestor", gitObjectId(head), gitObjectId(target)]);
         ancestor = true;
     }
     catch (error) {
@@ -81,17 +82,26 @@ export async function followDependentManagedWorktree(repository, workspace, targ
     }
     if (!ancestor)
         return { kind: "retained", head, reason: "head-moved", paths };
-    await runGit(repository, ["-C", workspace, "checkout", "--quiet", "--detach", gitObjectId(target)]);
+    await executeGit(repository, ["-C", workspace, "checkout", "--quiet", "--detach", gitObjectId(target)]);
     return { kind: "followed", before: head, after: target };
 }
 export async function withPrivateGitIndex(action) {
     const directory = await mkdtemp(join(tmpdir(), "keiyaku-v4-index-"));
+    let value;
     try {
-        return await action({ GIT_INDEX_FILE: join(directory, "index") });
+        value = await action({ GIT_INDEX_FILE: join(directory, "index") });
     }
-    finally {
-        await rm(directory, { recursive: true, force: true });
+    catch (error) {
+        try {
+            await rm(directory, { recursive: true, force: true });
+        }
+        catch (cleanup) {
+            throw new AggregateError([error, cleanup], "Private Git index capture and cleanup failed");
+        }
+        throw error;
     }
+    await rm(directory, { recursive: true, force: true });
+    return value;
 }
 function fields(record, count) {
     const result = [];
@@ -107,15 +117,7 @@ function fields(record, count) {
     return result;
 }
 async function workspaceStatus(repository, workspace) {
-    const records = (await runGit(repository, [
-        "-C",
-        workspace,
-        "status",
-        "--porcelain=v2",
-        "-z",
-        "--untracked-files=all",
-        "--ignore-submodules=none",
-    ]))
+    const records = (await executeGit(repository, ["-C", workspace, "status", "--porcelain=v2", "-z", "--untracked-files=all", "--ignore-submodules=none"], undefined, { GIT_OPTIONAL_LOCKS: "0" }))
         .toString("utf8")
         .split("\0");
     const staged = new Set();
@@ -172,7 +174,7 @@ async function workspaceChanges(repository, workspace) {
 /** Observe MERGE_HEAD in an appointed workspace, or undefined when absent. */
 export async function workspaceMergeHead(repository, workspace) {
     try {
-        return mintSnapshotId((await runGit(repository, ["-C", workspace, "rev-parse", "-q", "--verify", "MERGE_HEAD"]))
+        return mintSnapshotId((await executeGit(repository, ["-C", workspace, "rev-parse", "-q", "--verify", "MERGE_HEAD"]))
             .toString("utf8")
             .trim());
     }
@@ -250,7 +252,7 @@ export async function observeTargetLag(repository, workspace, head) {
     if (head === null)
         return { kind: "unknown", subject };
     try {
-        const text = (await runGit(repository, ["-C", workspace, "rev-list", "--count", `HEAD..${head}`]))
+        const text = (await executeGit(repository, ["-C", workspace, "rev-list", "--count", `HEAD..${head}`]))
             .toString("utf8")
             .trim();
         if (!/^[0-9]+$/u.test(text))
@@ -265,7 +267,7 @@ export async function observeTargetLag(repository, workspace, head) {
 }
 /** Capture tracked and untracked workspace bytes without changing its real index. */
 export async function captureWorkspaceTree(repository, workspace) {
-    const identities = (await runGit(repository, ["-C", workspace, "show", "-s", "--format=%H%n%T%n%cI", "HEAD"]))
+    const identities = (await executeGit(repository, ["-C", workspace, "show", "-s", "--format=%H%n%T%n%cI", "HEAD"]))
         .toString("utf8")
         .split("\n");
     if (identities.length !== 4 ||
@@ -285,10 +287,10 @@ export async function captureWorkspaceTree(repository, workspace) {
     if (!dirty)
         return { tree, head, at, dirty, changes };
     return await withPrivateGitIndex(async (environment) => {
-        await runGitWithEnvironment(repository, ["-C", workspace, "read-tree", "HEAD"], undefined, environment);
-        await runGitWithEnvironment(repository, ["-C", workspace, "add", "--all"], undefined, environment);
+        await executeGit(repository, ["-C", workspace, "-c", "core.splitIndex=false", "read-tree", gitObjectId(head)], undefined, environment);
+        await executeGit(repository, ["-C", workspace, "-c", "core.splitIndex=false", "add", "--all"], undefined, environment);
         return {
-            tree: gitObjectId((await runGitWithEnvironment(repository, ["-C", workspace, "write-tree"], undefined, environment))
+            tree: gitObjectId((await executeGit(repository, ["-C", workspace, "-c", "core.splitIndex=false", "write-tree"], undefined, environment))
                 .toString("utf8")
                 .trim(), "workspace tree"),
             head,
@@ -320,6 +322,11 @@ function receiptFor(value) {
         mergeHead: mintSnapshotId(record.mergeHead),
     };
 }
+function receiptMatches(receipt, coordinate) {
+    return (receipt.contractId === coordinate.contractId &&
+        receipt.place === coordinate.place &&
+        receipt.workspace === resolve(coordinate.workspace));
+}
 async function storedHandoffReceipt(repository, contractId, place) {
     const ref = handoffRefFor(contractId, place);
     const oid = await readRef(repository, ref);
@@ -329,7 +336,7 @@ async function storedHandoffReceipt(repository, contractId, place) {
     return { receipt, ref, oid };
 }
 async function removeHandoffReceipt(repository, stored) {
-    await runGit(repository, ["update-ref", "--no-deref", "-d", stored.ref, stored.oid]);
+    await executeGit(repository, ["update-ref", "--no-deref", "-d", stored.ref, stored.oid]);
 }
 export async function recordConflictHandoff(repository, input) {
     const ref = handoffRefFor(input.contractId, input.place);
@@ -345,27 +352,37 @@ export async function recordConflictHandoff(repository, input) {
         mergeHead: input.mergeHead,
     };
     const oid = await writeBlob(repository, `${JSON.stringify(receipt)}\n`);
-    await runGit(repository, ["update-ref", "--no-deref", ref, oid, "0".repeat(oid.length)]);
+    await executeGit(repository, ["update-ref", "--no-deref", ref, oid, "0".repeat(oid.length)]);
 }
-export async function conflictHandoffFor(repository, input) {
-    const stored = await storedHandoffReceipt(repository, input.contractId, input.place);
-    if (stored === null)
-        return undefined;
-    if (stored.receipt.contractId !== input.contractId ||
-        stored.receipt.place !== input.place ||
-        stored.receipt.workspace !== resolve(input.workspace)) {
-        return undefined;
+/** Read selected handoff refs once and decode their receipts through the call's blob channel. */
+export async function readConflictHandoffs(repository, readBlobs, coordinates) {
+    const byRef = new Map();
+    for (const coordinate of coordinates)
+        byRef.set(handoffRefFor(coordinate.contractId, coordinate.place), coordinate);
+    if (byRef.size === 0)
+        return new Map();
+    const resolved = await readRefs(repository, [...byRef.keys()]);
+    const present = [...resolved].flatMap(([ref, oid]) => (oid === null ? [] : [{ ref, oid }]));
+    const blobs = await readBlobs(present.map(({ oid }) => oid));
+    const handoffs = new Map();
+    for (const { ref, oid } of present) {
+        const result = blobs.get(oid);
+        if (result?.kind !== "present")
+            throw new AuthorityCorruptionError(`Git handoff receipt is missing: ${ref}`);
+        const receipt = receiptFor(JSON.parse(result.bytes.toString("utf8")));
+        const coordinate = byRef.get(ref);
+        if (!receiptMatches(receipt, coordinate))
+            continue;
+        handoffs.set(coordinate.contractId, { base: receipt.head, mergeHead: receipt.mergeHead });
     }
-    return { base: stored.receipt.head, mergeHead: stored.receipt.mergeHead };
+    return handoffs;
 }
 export async function retireConflictHandoff(repository, input) {
     const stored = await storedHandoffReceipt(repository, input.contractId, input.place);
     if (stored === null)
         return { kind: "absent" };
     const { receipt } = stored;
-    if (receipt.contractId !== input.contractId ||
-        receipt.place !== input.place ||
-        receipt.workspace !== resolve(input.workspace)) {
+    if (!receiptMatches(receipt, input)) {
         return { kind: "retained", reason: "receipt-mismatch" };
     }
     const gitDirectory = await worktreeGitDirectory(repository, input.workspace);
@@ -389,7 +406,7 @@ export async function retireConflictHandoff(repository, input) {
     }
     if (!input.consume)
         return { kind: "active" };
-    await runGit(repository, ["-C", input.workspace, "merge", "--quit"]);
+    await executeGit(repository, ["-C", input.workspace, "merge", "--quit"]);
     await removeHandoffReceipt(repository, stored);
     return { kind: "retired" };
 }

package/build/src/kanshi/index.d.ts

@@ -1,5 +1,5 @@
-export { kanshi, observeKanshi } from "./read.js";
+export { kanshi, kanshiCategory, observeKanshi } from "./read.js";
 export { selectKanshi, selectRegion } from "./select.js";
 export type { KanshiInput } from "./read.js";
-export type { AkumaKanshiRow, AkumaKanshiWorld, ContractEndpointObservation, ContractHolderObservation, ContractKanshiBoard, ContractKanshiRow, KanshiReport, Section, TaskKanshiRow, TaskKanshiWorld, KanshiRegionSelection, RegionDeclaration, RegionOverlap, RegionRead, } from "./report.js";
+export type { AkumaKanshiRow, AkumaKanshiWorld, ContractEndpointObservation, ContractHolderObservation, ContractKanshiBoard, ContractKanshiRow, KanshiCategoryReport, KanshiReport, Section, TaskKanshiRow, TaskKanshiWorld, KanshiRegionSelection, RegionDeclaration, RegionOverlap, RegionRead, } from "./report.js";
 export type { KanshiSelection } from "./select.js";

package/build/src/kanshi/index.js

@@ -1,2 +1,2 @@
-export { kanshi, observeKanshi } from "./read.js";
+export { kanshi, kanshiCategory, observeKanshi } from "./read.js";
 export { selectKanshi, selectRegion } from "./select.js";

package/build/src/kanshi/read.d.ts

@@ -2,7 +2,7 @@ import { type AliasBinding } from "../alias/index.js";
 import { Repo } from "../library/repo.js";
 import type { ContractBoard } from "../protocol/read/status.js";
 import type { WorldRoot } from "../world.js";
-import type { KanshiRegionSelection, KanshiReport, Section } from "./report.js";
+import type { KanshiCategoryReport, KanshiRegionSelection, KanshiReport, Section } from "./report.js";
 export type KanshiInput = Readonly<{
     world: WorldRoot | null;
     repo?: Repo;
@@ -15,3 +15,10 @@ export type KanshiObservation = Readonly<{
 }>;
 export declare function observeKanshi(input: KanshiInput): Promise<KanshiObservation>;
 export declare function kanshi(input: KanshiInput): Promise<KanshiReport>;
+export type KanshiCategoryInput = Readonly<{
+    world: WorldRoot | null;
+    repo?: Repo;
+    category: KanshiCategoryReport["category"];
+    limit?: number;
+}>;
+export declare function kanshiCategory(input: KanshiCategoryInput): Promise<KanshiCategoryReport>;