@astrosheep/keiyaku 2.9.8 → 2.9.10

package/build/core/settlement/claim-delivery.js

@@ -1,242 +1,69 @@
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
 import { FlowError } from "../../flow-error.js";
-import { syncDirectory } from "../../fs/durability.js";
-import { createGit, errorContainsAnyPattern, MISSING_HEAD_PATTERNS, wrapGitError } from "../../git/core.js";
-import { readLedger } from "../ledger.js";
+import { createGit, errorContainsAnyPattern, MISSING_HEAD_PATTERNS, runGitProcess } from "../../git/core.js";
 import { shortCommitHash } from "../../git/commits.js";
-import { commissionTarget, latestBase } from "../status/drift.js";
-import { settleTaskBoardForLanding } from "../task/index.js";
-import { stableRepoRoot } from "../worktree-path.js";
-const CLAIM_RECEIPTS_FILE = "claim-receipts.jsonl";
-async function appendClaimReceipt(cwd, receipt, restoreIfMissing = "") {
-    const receiptPath = path.join(await stableRepoRoot(cwd), ".keiyaku", CLAIM_RECEIPTS_FILE);
-    let handle;
-    let created = false;
+import { assertHonestClaimEvidence, buildHonestClaimMerge, } from "../repository-ledger/claim-evidence.js";
+async function successfulGit(cwd, args, input) {
+    const result = await runGitProcess(cwd, args, input === undefined ? undefined : { input });
+    if (result.status !== 0 || result.error) {
+        const detail = result.stderr.trim() || result.error?.message || `exit ${String(result.status)}`;
+        throw new FlowError(args[0] === "merge-tree" ? "CLOSE_MERGE_CONFLICT" : "INTERNAL_STATE", `git ${args.join(" ")} failed: ${detail}`, { cause: result.error });
+    }
+    return result.stdout.trim();
+}
+/** Build unreachable claim objects using only the approved frozen coordinates. */
+export async function buildClaimLanding(input) {
     try {
-        handle = await fs.open(receiptPath, "ax");
-        created = true;
+        const built = await buildHonestClaimMerge(input);
+        return { ...input.coordinates, ...built };
     }
     catch (error) {
-        if (error.code !== "EEXIST")
-            throw error;
-        handle = await fs.open(receiptPath, "a");
-    }
-    try {
-        await handle.writeFile(`${created ? restoreIfMissing : ""}${JSON.stringify(receipt)}\n`, "utf8");
-        await handle.sync();
+        const message = error instanceof Error ? error.message : String(error);
+        throw new FlowError(message.includes("not conflict-free") ? "CLOSE_MERGE_CONFLICT" : "INTERNAL_STATE", message, { cause: error });
     }
-    finally {
-        await handle.close();
-    }
-    await syncDirectory(path.dirname(receiptPath));
 }
 export async function resolveCommit(cwd, rev) {
-    const git = createGit(cwd);
-    try {
-        return (await git.raw(["rev-parse", "--verify", `${rev}^{commit}`])).trim();
-    }
-    catch (error) {
-        throw wrapGitError(`rev-parse ${rev}`, error, cwd);
-    }
+    return await successfulGit(cwd, ["rev-parse", "--verify", `${rev}^{commit}`]);
 }
 export async function resolveCommitOrNull(cwd, rev) {
-    const git = createGit(cwd);
-    try {
-        return (await git.raw(["rev-parse", "--verify", `${rev}^{commit}`])).trim();
-    }
-    catch (error) {
-        if (errorContainsAnyPattern(error, MISSING_HEAD_PATTERNS))
-            return null;
-        throw wrapGitError(`rev-parse ${rev}`, error, cwd);
-    }
+    const result = await runGitProcess(cwd, ["rev-parse", "--verify", `${rev}^{commit}`]);
+    if (result.status === 0 && !result.error)
+        return result.stdout.trim();
+    if (errorContainsAnyPattern(result.stderr, MISSING_HEAD_PATTERNS))
+        return null;
+    const detail = result.stderr.trim() || result.error?.message || `exit ${String(result.status)}`;
+    throw new FlowError("INTERNAL_STATE", `git rev-parse ${rev} failed: ${detail}`, { cause: result.error });
+}
+/** Prove parent order and tree identity independently of mutable refs. */
+export async function proveClaimLanding(cwd, landing) {
+    await assertHonestClaimEvidence(cwd, landing);
 }
 /** Display path for preview cleanup effects; delivery owns path mechanics. */
 export function relativeDisplayPath(from, to) {
-    return path.relative(from, to) || ".";
+    return (to.startsWith(from) ? to.slice(from.length).replace(/^\//, "") : to) || ".";
 }
-/**
- * Find the worktree path that currently has `branch` checked out.
- * Parses `git worktree list --porcelain -z` so linked worktrees are visible
- * even when claim cwd is a different worktree (real Keiyaku topology).
- */
-async function findWorktreePathForBranch(cwd, branch) {
-    const git = createGit(cwd);
-    let output;
-    try {
-        output = await git.raw(["worktree", "list", "--porcelain", "-z"]);
-    }
-    catch (error) {
-        throw wrapGitError("worktree list --porcelain -z", error, cwd);
-    }
-    const expected = `refs/heads/${branch}`;
-    let currentPath;
+async function findWorktreePathForRef(cwd, target) {
+    const output = await successfulGit(cwd, ["worktree", "list", "--porcelain", "-z"]);
+    let worktree;
     for (const field of output.split("\0")) {
-        if (field.startsWith("worktree ")) {
-            currentPath = field.slice("worktree ".length);
-            continue;
-        }
-        if (field.startsWith("branch ") && field.slice("branch ".length) === expected) {
-            return currentPath;
-        }
+        if (field.startsWith("worktree "))
+            worktree = field.slice("worktree ".length);
+        if (field === `branch ${target}`)
+            return worktree;
     }
     return undefined;
 }
-async function listChangedPaths(cwd, oldHead, mergeCommit) {
-    const git = createGit(cwd);
-    try {
-        const output = await git.raw(["diff", "--name-only", "-z", oldHead, mergeCommit]);
-        return output.split("\0").filter((entry) => entry.length > 0);
-    }
-    catch (error) {
-        throw wrapGitError(`diff --name-only -z ${oldHead} ${mergeCommit}`, error, cwd);
-    }
-}
-/**
- * Among candidate merge paths, return those that are dirty/untracked in the target worktree.
- * Must run while HEAD/index still share oldHead (pre-CAS). Uses porcelain -z only — never prose.
- */
-async function listBlockingPaths(worktreePath, candidates) {
-    if (candidates.length === 0)
-        return [];
-    const candidateSet = new Set(candidates);
-    const git = createGit(worktreePath);
-    let output;
-    try {
-        output = await git.raw([
-            "status",
-            "--porcelain",
-            "-z",
-            "--untracked-files=all",
-            "--",
-            ...candidates,
-        ]);
-    }
-    catch (error) {
-        throw wrapGitError("status --porcelain -z --untracked-files=all", error, worktreePath);
-    }
-    const dirty = new Set();
-    for (const part of output.split("\0")) {
-        if (part.length < 3)
-            continue;
-        // porcelain -z: "XYpath" (no space) or legacy "XY path"
-        const pathEntry = part[2] === " " ? part.slice(3) : part.slice(2);
-        if (pathEntry.length > 0 && candidateSet.has(pathEntry)) {
-            dirty.add(pathEntry);
-        }
-    }
-    return candidates.filter((candidate) => dirty.has(candidate));
-}
-function buildReconcileWarning(input) {
-    const blocking = input.blockingPaths.length > 0
-        ? input.blockingPaths.map((entry) => `- ${entry}`).join("\n")
-        : "- (none identified)";
-    return [
-        `Target worktree ${input.worktreePath} remains behind after claim advanced '${input.targetBranch}' to ${shortCommitHash(input.mergeCommit)}.`,
-        "The branch ref advanced while that worktree was not reconciled.",
-        "Blocking paths:",
-        blocking,
-    ].join("\n");
-}
-/**
- * Snapshot real blockers BEFORE CAS while target worktree HEAD/index still match oldHead.
- * Post-CAS porcelain is useless: every merge path looks like ghost dirt.
- */
-async function snapshotPreCasBlockers(input) {
-    const worktreePath = await findWorktreePathForBranch(input.cwd, input.targetBranch);
-    if (!worktreePath)
-        return undefined;
-    // Claim reconciles the common task board itself after CAS. Task paths are
-    // therefore never target-worktree blockers and must not enter this snapshot.
-    const changedPaths = (await listChangedPaths(input.cwd, input.oldHead, input.mergeCommit))
-        .filter((entry) => !entry.startsWith(".keiyaku/tasks/"));
-    const blockingPaths = await listBlockingPaths(worktreePath, changedPaths);
-    return { worktreePath, blockingPaths };
-}
-/**
- * After CAS, attempt two-tree read-tree on the pre-identified target worktree.
- * - No snapshot (target not checked out) → ref-only, no warning.
- * - read-tree success → no warnings.
- * - read-tree reject → soft-fail using pre-CAS blocker snapshot; never throw/reset.
- */
-async function reconcileAfterCas(input) {
-    if (!input.snapshot)
+/** Align a checked-out target after the atomic claim. Failure leaves authority intact. */
+export async function replayClaimTargetWorktree(cwd, landing) {
+    const worktree = await findWorktreePathForRef(cwd, landing.target);
+    if (!worktree)
         return [];
-    const targetGit = createGit(input.snapshot.worktreePath);
     try {
-        // The lock-held single-board settlement has already aligned task files and
-        // index entries to the accepted merge. Reconcile only the remaining tree.
-        await targetGit.raw(["read-tree", "-m", "-u", input.oldHead, input.mergeCommit]);
+        await createGit(worktree).raw(["read-tree", "-m", "-u", landing.targetHead, landing.mergeCommit]);
         return [];
     }
     catch {
         return [
-            buildReconcileWarning({
-                worktreePath: input.snapshot.worktreePath,
-                targetBranch: input.targetBranch,
-                mergeCommit: input.mergeCommit,
-                blockingPaths: input.snapshot.blockingPaths,
-            }),
+            `Target worktree ${worktree} remains behind after claim advanced '${landing.target.slice("refs/heads/".length)}' to ${shortCommitHash(landing.mergeCommit)}.`,
         ];
     }
 }
-export async function defaultMergeDelivery(input) {
-    const ledger = await readLedger(input.cwd, input.contractId);
-    if (!ledger) {
-        throw new FlowError("INTERNAL_STATE", `cannot claim ${input.contractId}: ledger missing`);
-    }
-    const commission = commissionTarget(ledger.entries);
-    if (!commission) {
-        throw new FlowError("INTERNAL_STATE", `cannot claim ${input.contractId}: missing commission target`);
-    }
-    const targetHead = await resolveCommitOrNull(input.cwd, commission.ref);
-    if (!targetHead) {
-        throw new FlowError("INTERNAL_STATE", `cannot claim ${input.contractId}: commission target ${commission.ref} does not resolve`);
-    }
-    const branch = `keiyaku/${input.contractId}`;
-    const deliveryHead = await resolveCommit(input.cwd, branch);
-    const base = latestBase(ledger.entries);
-    if (!base)
-        throw new FlowError("INTERNAL_STATE", `cannot claim ${input.contractId}: missing ledger base`);
-    let receiptStreamBeforeCas = "";
-    if (!input.writeClaimReceipt) {
-        const receiptPath = path.join(await stableRepoRoot(input.cwd), ".keiyaku", CLAIM_RECEIPTS_FILE);
-        try {
-            receiptStreamBeforeCas = await fs.readFile(receiptPath, "utf8");
-        }
-        catch (error) {
-            if (error.code !== "ENOENT")
-                throw error;
-        }
-    }
-    let preCasSnapshot;
-    const merged = await settleTaskBoardForLanding({
-        cwd: input.cwd,
-        contractId: input.contractId,
-        baseCommit: base,
-        targetRef: commission.ref,
-        targetBranch: commission.branch,
-        targetHead,
-        deliveryHead,
-        beforeCas: async (mergeCommit, oldHead) => {
-            preCasSnapshot = await snapshotPreCasBlockers({ cwd: input.cwd, targetBranch: commission.branch, oldHead, mergeCommit });
-        },
-        afterCas: async (mergeCommit, oldHead) => reconcileAfterCas({ contractId: input.contractId, targetBranch: commission.branch, oldHead, mergeCommit, snapshot: preCasSnapshot }),
-        publishLedger: input.publishClaim,
-    });
-    const receiptWarnings = [];
-    if (merged.oldHead !== undefined) {
-        try {
-            const receipt = { kind: "receipt", oldHead: merged.oldHead, newHead: merged.mergeCommit, contract: input.contractId };
-            if (input.writeClaimReceipt)
-                await input.writeClaimReceipt(input.cwd, receipt);
-            else
-                await appendClaimReceipt(input.cwd, receipt, receiptStreamBeforeCas);
-        }
-        catch {
-            receiptWarnings.push("Claim receipt was not recorded after the target branch update; this movement will appear as an unreceipted FACT until manually recorded.");
-        }
-    }
-    const warnings = [...receiptWarnings, ...(merged.warnings ?? [])];
-    return warnings.length > 0 ? { mergeCommit: merged.mergeCommit, warnings } : { mergeCommit: merged.mergeCommit };
-}