@astrosheep/keiyaku 2.8.4 → 2.9.0

package/build/core/claim-delivery.js

@@ -0,0 +1,247 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { FlowError } from "../flow-error.js";
+import { createGit, errorContainsAnyPattern, MISSING_HEAD_PATTERNS, wrapGitError } from "../git/core.js";
+import { readLedger } from "./ledger.js";
+import { shortCommitHash } from "../git/commits.js";
+import { commissionTarget, latestBase } from "./status/drift.js";
+import { settleTaskBoardForLanding } from "./task-contract.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;
+    try {
+        handle = await fs.open(receiptPath, "ax");
+        created = true;
+    }
+    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();
+    }
+    finally {
+        await handle.close();
+    }
+    const directory = await fs.open(path.dirname(receiptPath), "r");
+    try {
+        await directory.sync();
+    }
+    finally {
+        await directory.close();
+    }
+}
+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);
+    }
+}
+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);
+    }
+}
+/** Display path for preview cleanup effects; delivery owns path mechanics. */
+export function relativeDisplayPath(from, to) {
+    return path.relative(from, 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;
+    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;
+        }
+    }
+    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)
+        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]);
+        return [];
+    }
+    catch {
+        return [
+            buildReconcileWarning({
+                worktreePath: input.snapshot.worktreePath,
+                targetBranch: input.targetBranch,
+                mergeCommit: input.mergeCommit,
+                blockingPaths: input.snapshot.blockingPaths,
+            }),
+        ];
+    }
+}
+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 };
+}

package/build/core/claim.js

@@ -1,32 +1,11 @@
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
 import { FlowError } from "../flow-error.js";
-import { createGit, errorContainsAnyPattern, MISSING_HEAD_PATTERNS, wrapGitError } from "../git/core.js";
 import { activeLedgerRef, appendWithRetry, readLedger } from "./ledger.js";
-import { assertClaimQueueHead, readQueueReadModel } from "./queue_v2.js";
+import { assertClaimQueueHead, readQueueReadModel } from "./queue.js";
 import { releaseScope } from "./registry.js";
-import { shortCommitHash } from "./render.js";
-import { commissionTarget, deriveContractState, latestBase } from "./status.js";
+import { deriveContractState } from "./status/lifecycle.js";
+import { commissionTarget, latestBase } from "./status/drift.js";
 import { cleanupContractWorkspace, findContractWorktreePath, stableRepoRoot } from "./worktree-path.js";
-const CLAIM_RECEIPTS_FILE = "claim-receipts.jsonl";
-async function appendClaimReceipt(cwd, receipt) {
-    const receiptPath = path.join(await stableRepoRoot(cwd), ".keiyaku", CLAIM_RECEIPTS_FILE);
-    const handle = await fs.open(receiptPath, "a");
-    try {
-        await handle.writeFile(`${JSON.stringify(receipt)}\n`, "utf8");
-        await handle.sync();
-    }
-    finally {
-        await handle.close();
-    }
-    const directory = await fs.open(path.dirname(receiptPath), "r");
-    try {
-        await directory.sync();
-    }
-    finally {
-        await directory.close();
-    }
-}
+import { defaultMergeDelivery, relativeDisplayPath, resolveCommit, resolveCommitOrNull, } from "./claim-delivery.js";
 async function cleanupClaim(cwd, contractId, actor, at) {
     const stableRoot = await stableRepoRoot(cwd);
     await releaseScope(stableRoot, { contractId, actor, at });
@@ -35,240 +14,6 @@ async function cleanupClaim(cwd, contractId, actor, at) {
 function findClaim(entries) {
     return entries.find((entry) => entry.kind === "claim");
 }
-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);
-    }
-}
-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);
-    }
-}
-async function isAncestor(cwd, ancestor, descendant) {
-    const git = createGit(cwd);
-    try {
-        return (await git.raw(["merge-base", ancestor, descendant])).trim() === ancestor;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * 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;
-    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;
-        }
-    }
-    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;
-    const changedPaths = await listChangedPaths(input.cwd, input.oldHead, input.mergeCommit);
-    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)
-        return [];
-    const targetGit = createGit(input.snapshot.worktreePath);
-    try {
-        await targetGit.raw(["read-tree", "-m", "-u", input.oldHead, input.mergeCommit]);
-        return [];
-    }
-    catch {
-        return [
-            buildReconcileWarning({
-                worktreePath: input.snapshot.worktreePath,
-                targetBranch: input.targetBranch,
-                mergeCommit: input.mergeCommit,
-                blockingPaths: input.snapshot.blockingPaths,
-            }),
-        ];
-    }
-}
-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);
-    if (deliveryHead !== targetHead && await isAncestor(input.cwd, deliveryHead, targetHead)) {
-        return { mergeCommit: targetHead };
-    }
-    const git = createGit(input.cwd);
-    let tree;
-    try {
-        tree = (await git.raw(["merge-tree", "--write-tree", targetHead, deliveryHead])).trim();
-    }
-    catch (error) {
-        throw new FlowError("CLOSE_MERGE_CONFLICT", `claim merge conflict for ${input.contractId} into ${commission.branch}`, { cause: error });
-    }
-    let mergeCommit;
-    try {
-        mergeCommit = (await git.raw([
-            "commit-tree",
-            tree,
-            "-p",
-            targetHead,
-            "-p",
-            deliveryHead,
-            "-m",
-            `keiyaku: claim ${input.contractId}`,
-            "-m",
-            `Merge contract ${input.contractId} into ${commission.branch}.`,
-        ])).trim();
-    }
-    catch (error) {
-        throw wrapGitError(`commit-tree claim ${input.contractId}`, error, input.cwd);
-    }
-    // Pre-CAS: locate target worktree and snapshot real blockers while HEAD/index still share oldHead.
-    const preCasSnapshot = await snapshotPreCasBlockers({
-        cwd: input.cwd,
-        targetBranch: commission.branch,
-        oldHead: targetHead,
-        mergeCommit,
-    });
-    try {
-        await git.raw(["update-ref", commission.ref, mergeCommit, targetHead]);
-    }
-    catch (error) {
-        const currentHead = await resolveCommit(input.cwd, commission.ref);
-        if (await isAncestor(input.cwd, deliveryHead, currentHead)) {
-            return { mergeCommit: currentHead };
-        }
-        throw new FlowError("CONCURRENT_MODIFICATION", `target branch ${commission.branch} moved while claiming ${input.contractId}`, { cause: error });
-    }
-    // The target ref is authoritative. Receipt failure cannot undo its CAS.
-    const receiptWarnings = [];
-    try {
-        await (input.writeClaimReceipt ?? appendClaimReceipt)(input.cwd, {
-            kind: "receipt",
-            oldHead: targetHead,
-            newHead: mergeCommit,
-            contract: input.contractId,
-        });
-    }
-    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 = await reconcileAfterCas({
-        contractId: input.contractId,
-        targetBranch: commission.branch,
-        oldHead: targetHead,
-        mergeCommit,
-        snapshot: preCasSnapshot,
-    });
-    return [...receiptWarnings, ...warnings].length > 0
-        ? { mergeCommit, warnings: [...receiptWarnings, ...warnings] }
-        : { mergeCommit };
-}
 function assertClaimableFromLedger(contractId, ledger) {
     if (!ledger) {
         throw new FlowError("INTERNAL_STATE", `contract ${contractId} not found`);
@@ -284,6 +29,24 @@ function assertClaimableFromLedger(contractId, ledger) {
     }
     throw new FlowError("INTERNAL_STATE", `contract ${contractId} cannot claim from state ${state.state}`);
 }
+async function publishClaimLedger(input) {
+    const result = await appendWithRetry(input.cwd, activeLedgerRef(input.contractId), (_head, entries) => {
+        if (entries.some((entry) => entry.kind === "claim"))
+            return null;
+        const entry = {
+            v: 1,
+            kind: "claim",
+            contract: input.contractId,
+            at: input.at,
+            actor: input.actor,
+            data: { mergeCommit: input.mergeCommit },
+        };
+        return entry;
+    });
+    if (!result.ok && result.reason !== "aborted") {
+        throw new FlowError("INTERNAL_STATE", `failed to append claim for ${input.contractId}: ${result.reason}`);
+    }
+}
 export async function previewClaimContract(input) {
     const model = await readQueueReadModel(input.cwd);
     const membership = assertClaimQueueHead(model, input.contractId);
@@ -325,7 +88,7 @@ export async function previewClaimContract(input) {
         ...(deliveryHead ? { deliveryHead } : {}),
         cleanupEffects: [
             `release registry scope for ${input.contractId}`,
-            cleanupPath ? `remove worktree ${path.relative(input.cwd, cleanupPath) || "."} when present` : "no linked worktree to remove",
+            cleanupPath ? `remove worktree ${relativeDisplayPath(input.cwd, cleanupPath)} when present` : "no linked worktree to remove",
             `delete branch keiyaku/${input.contractId} when present`,
         ],
     };
@@ -350,32 +113,31 @@ export async function claimContract(input) {
     let mergeCommit = existingClaim?.data.mergeCommit;
     let warnings;
     if (!mergeCommit) {
+        const usesDefaultMerger = input.mergeDelivery === undefined;
         const mergeDelivery = input.mergeDelivery ?? defaultMergeDelivery;
+        const publishClaim = async (acceptedMergeCommit) => publishClaimLedger({
+            cwd: input.cwd,
+            contractId: input.contractId,
+            actor: input.actor,
+            at,
+            mergeCommit: acceptedMergeCommit,
+        });
         // mergeDelivery must be idempotent: if a prior attempt merged delivery but
         // crashed before appending claim, a retry must return the existing merge
         // receipt without creating a second merge effect.
-        const merged = await mergeDelivery({ cwd: input.cwd, contractId: input.contractId, writeClaimReceipt: input.writeClaimReceipt });
+        const merged = await mergeDelivery({
+            cwd: input.cwd,
+            contractId: input.contractId,
+            writeClaimReceipt: input.writeClaimReceipt,
+            ...(usesDefaultMerger ? { publishClaim } : {}),
+        });
         await input.afterMerge?.(merged);
         mergeCommit = merged.mergeCommit;
         if (merged.warnings && merged.warnings.length > 0) {
             warnings = [...merged.warnings];
         }
-        const result = await appendWithRetry(input.cwd, activeLedgerRef(input.contractId), (_head, entries) => {
-            if (entries.some((entry) => entry.kind === "claim"))
-                return null;
-            const entry = {
-                v: 1,
-                kind: "claim",
-                contract: input.contractId,
-                at,
-                actor: input.actor,
-                data: { mergeCommit: mergeCommit },
-            };
-            return entry;
-        });
-        if (!result.ok && result.reason !== "aborted") {
-            throw new FlowError("INTERNAL_STATE", `failed to append claim for ${input.contractId}: ${result.reason}`);
-        }
+        if (!usesDefaultMerger)
+            await publishClaim(mergeCommit);
     }
     // Claim entry naturally removes membership; no dequeue record.
     const cleanup = await cleanupClaim(input.cwd, input.contractId, input.actor, at);

package/build/core/context.js

@@ -5,7 +5,8 @@ import { createGit, errorContainsAnyPattern, MISSING_HEAD_PATTERNS, wrapGitError
 import { getCurrentBranch, listLocalBranches } from "../git/branches.js";
 import { readLedger } from "./ledger.js";
 import { listContractIds } from "./ledger.js";
-import { deriveContractState, isTerminalState, latestBase } from "./status.js";
+import { deriveContractState, isTerminalState } from "./status/lifecycle.js";
+import { latestBase } from "./status/drift.js";
 import { activeContractIdForWorktreeDir } from "./worktree-path.js";
 function isOperableLedger(entries) {
     const state = deriveContractState(entries);