@astrosheep/keiyaku 2.9.9 → 2.9.10

package/build/core/bind.js

@@ -2,78 +2,25 @@ import * as crypto from "node:crypto";
 import { assertSettingsKnobUsable } from "../config/settings/disease.js";
 import { loadKeiyakuSettings } from "../config/settings/loader.js";
 import { FlowError } from "../flow-error.js";
-import { activeLedgerRef, appendEntry, appendWithRetry, readLedger } from "./ledger.js";
+import { lookupCurrentContract, readRepositoryLifecycle, } from "./repository-ledger/read-model.js";
+import { repositoryDeliveryRef, } from "./repository-ledger/codec.js";
+import { publishBindTransaction, } from "./repository-ledger/write-transaction.js";
+import { bindEffectiveScope } from "./repository-ledger/fold.js";
+import { activeWorkspaceHereContracts } from "./repository-ledger/inventory.js";
 import { describeMissingBindSections, materializeBindDraft, mergeBindDraft, missingBindDraftSections, parseBindDraft, parsePartialBindDraft, renderBindDraft, renderMissingBindSectionsTemplate, } from "./draft.js";
 import { assertValidContractId, buildContractId, isCommissionId } from "./ids.js";
-import { previewScopeRegistration, registerScope, releaseScope } from "./registry.js";
+import { admitScopeRegistration, } from "./registry.js";
 import { resolveDefaultBranch } from "./status/drift.js";
 import { normalizeTargetRef } from "./target-ref.js";
-import { previewTaskBoardForBind, reconcileTaskForfeit, settleTaskBoardForBind } from "./task/index.js";
-import { bootstrapEntryDataFromObservation, isBootstrapSuccess, runWorktreeBootstrap, } from "./worktree-bootstrap.js";
-import { contractWorktreePathFromBind, stableRepoRoot } from "./worktree-path.js";
-import { allocateWorktreePlace, cleanupCreatedBindResources, createContractBranch, defaultCreateWorktree, materializeContractView, resolveTreeRoot, } from "./bind-workspace.js";
-class BindLedgerCollisionError extends Error {
-    contractId;
-    constructor(contractId) {
-        super(`contract ledger already exists for ${contractId}`);
-        this.contractId = contractId;
-        this.name = "BindLedgerCollisionError";
-    }
-}
+import { previewTaskBoardForBind, readTaskNamespaces, replayPreparedTaskBindLocked, withPreparedTaskBind, } from "./task/index.js";
+import { stableRepoRoot } from "./worktree-path.js";
+import { allocateWorktreePlaceFromRead, } from "./bind-workspace.js";
+import { committedOrThrow, reconcileCommittedBind, revalidateBindAuthority } from "./bind-reconciliation.js";
+import { allocateTaskNamespace, taskNamespaceFromScope, taskNamespaceScope } from "./task/coordinate.js";
+export { reconcileBindContract } from "./bind-reconciliation.js";
 function randomBytesDefault() {
     return [...crypto.randomBytes(10)];
 }
-async function appendBindFailedForfeit(cwd, id, actor, at) {
-    const forfeit = {
-        v: 1,
-        kind: "forfeit",
-        contract: id,
-        at,
-        actor,
-        data: {
-            reason: "bind-failed",
-            by: actor,
-        },
-    };
-    const stableRoot = await stableRepoRoot(cwd);
-    await reconcileTaskForfeit({
-        cwd: stableRoot,
-        contractId: id,
-        publishLedger: async () => {
-            const result = await appendWithRetry(stableRoot, activeLedgerRef(id), () => forfeit, { maxRetries: 1 });
-            if (!result.ok) {
-                throw new FlowError("INTERNAL_STATE", `BIND_FAILURE_FORFEIT_FAILED: failed to append bind-failed forfeit for ${id}: ${result.reason}`);
-            }
-            return result;
-        },
-    });
-}
-async function appendBootstrapEntry(cwd, id, actor, at, data) {
-    const entry = {
-        v: 1,
-        kind: "bootstrap",
-        contract: id,
-        at,
-        actor,
-        data,
-    };
-    // Bootstrap is legal only at index 1 immediately after the planned bind.
-    // If another entry advanced during bootstrap execution, abort rather than
-    // CAS-retrying into a late (corrupt) position.
-    const result = await appendWithRetry(cwd, activeLedgerRef(id), (_currentHead, currentEntries) => {
-        if (currentEntries.length !== 1)
-            return null;
-        const only = currentEntries[0];
-        if (!only || only.kind !== "bind" || only.contract !== id || !only.data.bootstrap) {
-            return null;
-        }
-        return entry;
-    });
-    if (!result.ok) {
-        throw new FlowError("INTERNAL_STATE", `BIND_BOOTSTRAP_APPEND_FAILED: failed to append bootstrap entry for ${id}: ${result.reason}`);
-    }
-    return result.head;
-}
 function resolvedBootstrapPlan(settings) {
     if (!settings)
         return undefined;
@@ -82,33 +29,55 @@ function resolvedBootstrapPlan(settings) {
         timeoutMs: settings.timeoutMs,
     };
 }
-function bootstrapProgressLine(command) {
-    return `bootstrap » ${command.join(" ")}`;
+function bindDraftWithTaskNamespace(draft, read, persistedNamespaces) {
+    const declared = draft.scope.flatMap((term) => {
+        const namespace = taskNamespaceFromScope(term);
+        return namespace ? [namespace] : [];
+    });
+    if (declared.length > 1)
+        throw new FlowError("INVALID_TARGET", "bind scope must carry exactly one contract task namespace");
+    const occupied = new Set(read.contracts.flatMap((contract) => contract.effectiveScope.flatMap((term) => {
+        const namespace = taskNamespaceFromScope(term);
+        return namespace ? [namespace] : [];
+    })));
+    for (const namespace of persistedNamespaces)
+        occupied.add(namespace);
+    if (declared.length === 1) {
+        if (occupied.has(declared[0]))
+            throw new FlowError("INVALID_TARGET", `task namespace ${declared[0]} is already occupied`);
+        return draft;
+    }
+    const namespace = allocateTaskNamespace(draft.title, occupied);
+    return { ...draft, scope: [...draft.scope, taskNamespaceScope(namespace)] };
 }
 function makeBindEntry(input) {
+    const common = {
+        title: input.draft.title,
+        context: input.draft.context,
+        objective: input.draft.objective,
+        design: input.draft.design,
+        scope: input.draft.scope,
+        criteria: input.draft.criteria,
+        verification: input.draft.verification,
+        extensions: input.draft.extensions,
+        base: input.base,
+        target: input.target,
+        ...(input.after.length > 0 ? { after: input.after } : {}),
+        ...(input.taskIds ? { taskIds: [...input.taskIds] } : {}),
+    };
     return {
-        v: 1,
+        v: 2,
         kind: "bind",
         contract: input.id,
         at: input.at,
         actor: input.actor,
-        data: {
-            name: input.draft.name,
-            objective: input.draft.objective,
-            scope: input.draft.scope,
-            checks: input.draft.checks,
-            extensions: input.draft.extensions,
-            base: input.base,
-            target: input.target,
-            workspace: input.workspace,
-            after: input.after,
-            ...(input.workspace === "worktree" ? { place: input.place ?? null } : {}),
-            ...(input.bootstrap ? { bootstrap: input.bootstrap } : {}),
-        },
+        data: input.workspace === "worktree"
+            ? { ...common, workspace: "worktree", place: input.place, ...(input.bootstrap ? { bootstrap: input.bootstrap } : {}) }
+            : { ...common, workspace: "here" },
     };
 }
 function taskBindDefaults(task) {
-    const defaults = { name: task.title };
+    const defaults = { title: task.title };
     const objective = task.body.trim();
     if (objective.length > 0)
         defaults.objective = objective;
@@ -126,7 +95,7 @@ function incompleteTaskBindError(taskId, missing) {
     return new FlowError("BIND_TASK_INCOMPLETE", message);
 }
 /**
- * Section-level merge for `bind --task`: task title/body are name/objective
+ * Section-level merge for `bind --task`: task title/body are title/objective
  * defaults; stdin partial markdown sections override. Missing required sections
  * fail with a paste-ready partial heredoc template.
  */
@@ -138,7 +107,7 @@ export function composeTaskBindDraft(input) {
     }
     return materializeBindDraft(merged);
 }
-async function validateBindAfter(cwd, after) {
+function validateBindAfter(read, after) {
     const unique = new Set();
     for (const contractId of after) {
         if (unique.has(contractId)) {
@@ -148,20 +117,44 @@ async function validateBindAfter(cwd, after) {
         if (!isCommissionId(contractId)) {
             throw new FlowError("INVALID_TARGET", `after contract ${contractId} is not a valid contract id`);
         }
-        if (!await readLedger(cwd, contractId)) {
-            throw new FlowError("INVALID_TARGET", `after contract ${contractId} does not exist`);
+        const outcome = lookupCurrentContract(read, contractId);
+        if (outcome.status !== "healthy") {
+            throw new FlowError("INVALID_TARGET", `after contract ${contractId} is not a healthy terminal contract`);
         }
+        if (!["claimed", "forfeited"].includes(outcome.model.phase)) {
+            throw new FlowError("INVALID_TARGET", `after contract ${contractId} is not terminal`);
+        }
+    }
+}
+function assertContractAbsent(read, contractId) {
+    const outcome = lookupCurrentContract(read, contractId);
+    if (outcome.status === "absent")
+        return;
+    if (outcome.status === "indeterminate") {
+        throw new FlowError("INTERNAL_STATE", `BIND_ADMISSION_INDETERMINATE: cannot prove contract ${contractId} absent`);
     }
+    throw new FlowError("CONCURRENT_MODIFICATION", `CONTRACT_ID_COLLISION: contract ${contractId} already exists`);
+}
+function admitWorkspaceOccupancy(read, workspace) {
+    if (workspace === "worktree")
+        return;
+    const occupants = activeWorkspaceHereContracts(read);
+    if (occupants.length === 0)
+        return;
+    throw new FlowError("INVALID_TARGET", `workspace here is occupied by nonterminal contract ${occupants.join(", ")}`);
 }
 /**
  * The common read-only bind admission candidate. Mutation uses this candidate
  * before task settlement; preview stops after it has observed all admission
  * facts and rendered the canonical draft.
  */
-async function admitBindCandidate(input, draft) {
-    const id = buildContractId({ name: draft.name, nowMs: input.nowMs, randomBytes: input.randomBytes });
+async function admitBindCandidate(input, draft, read) {
+    draft = bindDraftWithTaskNamespace(draft, read, await readTaskNamespaces(input.cwd));
+    admitWorkspaceOccupancy(read, input.workspace);
+    const id = buildContractId({ title: draft.title, nowMs: input.nowMs, randomBytes: input.randomBytes });
     await assertValidContractId(input.cwd, id);
-    await validateBindAfter(input.cwd, input.after);
+    assertContractAbsent(read, id);
+    validateBindAfter(read, input.after);
     const provisionalEntry = makeBindEntry({
         id,
         at: new Date(input.nowMs).toISOString(),
@@ -175,14 +168,14 @@ async function admitBindCandidate(input, draft) {
         workspace: input.workspace,
         place: input.place,
         bootstrap: input.bootstrapPlan,
+        taskIds: input.taskIds ? [...input.taskIds] : undefined,
     });
-    const tree = await resolveTreeRoot(input.cwd, input.workspace, id, provisionalEntry);
-    const scopeOverlaps = await previewScopeRegistration(input.cwd, {
+    const scopeOverlaps = await admitScopeRegistration(input.cwd, {
         contractId: id,
-        scope: draft.scope,
-        tree,
+        scope: bindEffectiveScope(provisionalEntry),
+        tree: input.base,
         exclusive: input.exclusive,
-    });
+    }, read);
     return {
         id,
         draft,
@@ -209,8 +202,9 @@ export async function previewBindContract(input) {
         assertSettingsKnobUsable(loadedSettings, "worktreeBootstrap");
         bootstrapPlan = resolvedBootstrapPlan(loadedSettings.knobs?.worktreeBootstrap);
     }
+    const read = await readRepositoryLifecycle(input.cwd);
     const randomBytes = input.randomBytes?.(0) ?? randomBytesDefault();
-    const place = workspace === "worktree" ? await allocateWorktreePlace(input.cwd, randomBytes) : undefined;
+    const place = workspace === "worktree" ? allocateWorktreePlaceFromRead(read, randomBytes) : undefined;
     const taskAdmission = isTaskBound
         ? await previewTaskBoardForBind({ cwd: input.cwd, taskIds: input.taskIds })
         : { tasks: [] };
@@ -229,205 +223,180 @@ export async function previewBindContract(input) {
         target,
         bootstrapPlan,
         place,
-    }, draft);
+        ...(isTaskBound ? { taskIds: input.taskIds } : {}),
+    }, draft, read);
 }
 export async function bindContract(input) {
+    const stableRoot = await stableRepoRoot(input.cwd);
     const isTaskBound = input.taskIds !== undefined && input.taskIds.length > 0;
     const ordinaryDraft = !isTaskBound ? parseBindDraft(input.draft) : undefined;
     const workspace = input.workspace ?? "here";
     const at = new Date(input.nowMs).toISOString();
-    const defaultBranch = await resolveDefaultBranch(input.cwd);
-    if (!defaultBranch) {
+    const after = input.after ?? [];
+    const defaultBranch = await resolveDefaultBranch(stableRoot);
+    if (!defaultBranch)
         throw new FlowError("INTERNAL_STATE", "cannot bind: no default branch");
-    }
     const target = normalizeTargetRef(defaultBranch.branch);
-    const loadedSettings = await loadKeiyakuSettings(input.cwd);
+    const publishBind = input.dependencies?.publishBind ?? publishBindTransaction;
+    const persistedTaskNamespaces = await readTaskNamespaces(stableRoot);
+    const loadedSettings = await loadKeiyakuSettings(stableRoot);
     let bootstrapPlan;
     if (workspace === "worktree") {
         assertSettingsKnobUsable(loadedSettings, "worktreeBootstrap");
         bootstrapPlan = resolvedBootstrapPlan(loadedSettings.knobs?.worktreeBootstrap);
     }
-    const collidedIds = [];
-    for (let attempt = 0; attempt < 2; attempt += 1) {
-        const randomBytes = input.randomBytes?.(attempt) ?? randomBytesDefault();
-        const place = workspace === "worktree" ? await allocateWorktreePlace(input.cwd, randomBytes) : undefined;
-        let settlement;
-        try {
-            const prepare = async (draft) => {
-                const candidate = await admitBindCandidate({
-                    cwd: input.cwd,
-                    actor: input.actor,
-                    nowMs: input.nowMs,
-                    after: input.after ?? [],
-                    exclusive: input.exclusive,
-                    workspace,
-                    randomBytes,
-                    base: defaultBranch.head,
-                    target,
-                    bootstrapPlan,
-                    place,
-                }, draft);
-                const id = candidate.id;
-                const ref = activeLedgerRef(id);
-                return {
-                    contractId: id,
-                    publishLedger: async (base) => {
-                        const entry = makeBindEntry({
-                            id,
-                            at,
-                            actor: input.actor,
-                            draft,
-                            base,
-                            target,
-                            after: input.after ?? [],
-                            workspace,
-                            place,
-                            bootstrap: bootstrapPlan,
-                        });
-                        const appended = await appendEntry(input.cwd, ref, entry, null);
-                        if (!appended.ok)
-                            throw new BindLedgerCollisionError(id);
-                        return { entry, appended };
-                    },
-                };
-            };
-            settlement = !isTaskBound
-                ? await (async () => {
-                    const prepared = await prepare(ordinaryDraft);
-                    return settleTaskBoardForBind({ cwd: input.cwd, signal: input.signal, ...prepared });
-                })()
-                : await (async () => {
-                    return settleTaskBoardForBind({
-                        cwd: input.cwd,
-                        taskIds: input.taskIds,
-                        signal: input.signal,
-                        prepare: async (tasks) => prepare(composeTaskBindDraft({ task: tasks[0], draft: input.draft })),
-                    });
-                })();
-        }
-        catch (error) {
-            if (error instanceof BindLedgerCollisionError) {
-                // The selected task's locked snapshot chose this attempted identity.
-                // Record the concrete id only when preparation reached publication.
-                collidedIds.push(error.contractId);
+    let selectedDraft;
+    let selectedPlace;
+    let selectedId;
+    const selectCandidate = async (draft, read) => {
+        admitWorkspaceOccupancy(read, workspace);
+        const collided = [];
+        for (let attempt = 0; attempt < 2; attempt += 1) {
+            const randomBytes = input.randomBytes?.(attempt) ?? randomBytesDefault();
+            const place = workspace === "worktree" ? allocateWorktreePlaceFromRead(read, randomBytes) : undefined;
+            const id = buildContractId({ title: draft.title, nowMs: input.nowMs, randomBytes });
+            const outcome = lookupCurrentContract(read, id);
+            if (outcome.status === "indeterminate")
+                assertContractAbsent(read, id);
+            if (outcome.status !== "absent") {
+                collided.push(id);
                 continue;
             }
-            throw error;
+            await assertValidContractId(stableRoot, id);
+            selectedDraft = bindDraftWithTaskNamespace(draft, read, persistedTaskNamespaces);
+            selectedPlace = place;
+            selectedId = id;
+            return { contractId: id, at };
         }
-        const { entry, appended } = settlement.ledger;
-        const id = settlement.contractId;
-        const ref = activeLedgerRef(id);
-        const base = settlement.boardCommit;
-        const resources = { id };
-        const branch = `keiyaku/${id}`;
-        const worktreePath = await contractWorktreePathFromBind(input.cwd, id, entry);
-        const targetRoot = workspace === "here" ? input.cwd : worktreePath;
-        let ledgerHead = appended.head;
-        let bootstrapRecorded = false;
-        let registryRegistered = false;
-        try {
-            const tree = await resolveTreeRoot(input.cwd, workspace, id, entry);
-            const registration = await registerScope(input.cwd, {
-                contractId: id,
-                scope: entry.data.scope,
-                tree,
-                actor: input.actor,
-                at,
-                exclusive: input.exclusive,
-            });
-            registryRegistered = true;
-            if (workspace === "worktree") {
-                await createContractBranch(input.cwd, branch, base);
-                resources.branch = branch;
-                await (input.createWorktree ?? defaultCreateWorktree)({
-                    cwd: input.cwd,
-                    id,
-                    branch,
-                    base,
-                    worktreePath,
-                });
-                resources.worktreePath = worktreePath;
-            }
-            if (bootstrapPlan) {
-                input.onProgress?.(bootstrapProgressLine(bootstrapPlan.command));
-                const runner = input.bootstrapRunner ?? runWorktreeBootstrap;
-                const observation = await runner({ cwd: worktreePath, plan: bootstrapPlan }, input.bootstrapDependencies);
-                ledgerHead = await appendBootstrapEntry(input.cwd, id, input.actor, at, bootstrapEntryDataFromObservation(observation));
-                bootstrapRecorded = true;
-                if (!isBootstrapSuccess(observation)) {
-                    throw new FlowError("INTERNAL_STATE", `BIND_BOOTSTRAP_FAILED: worktree bootstrap failed with ${observation.result.kind}`);
+        throw new FlowError("CONCURRENT_MODIFICATION", `CONTRACT_ID_COLLISION: contract id collision after two attempts: ${collided.join(", ")}`);
+    };
+    let entry;
+    let admittedScopeOverlaps = [];
+    let preparedTask;
+    if (isTaskBound) {
+        let lockedRead;
+        const settled = await withPreparedTaskBind({
+            cwd: stableRoot,
+            taskIds: input.taskIds,
+            signal: input.signal,
+            prepare: async (tasks) => {
+                lockedRead = await readRepositoryLifecycle(stableRoot);
+                validateBindAfter(lockedRead, after);
+                return await selectCandidate(composeTaskBindDraft({ task: tasks[0], draft: input.draft }), lockedRead);
+            },
+            transact: async (prepared, taskTransaction) => {
+                if (prepared.boardRef !== target) {
+                    throw new FlowError("CONCURRENT_MODIFICATION", "locked task-board ref does not match the selected bind target");
                 }
+                let attemptRead = lockedRead;
+                let lastRefusal;
+                for (let attempt = 0; attempt < 4; attempt += 1) {
+                    admitWorkspaceOccupancy(attemptRead, workspace);
+                    validateBindAfter(attemptRead, after);
+                    assertContractAbsent(attemptRead, selectedId);
+                    selectedPlace = workspace === "worktree"
+                        ? allocateWorktreePlaceFromRead(attemptRead, input.randomBytes?.(attempt) ?? randomBytesDefault())
+                        : undefined;
+                    entry = makeBindEntry({
+                        id: selectedId, at, actor: input.actor, draft: selectedDraft, base: prepared.entryBase,
+                        target, after, workspace, place: selectedPlace, bootstrap: bootstrapPlan, taskIds: prepared.taskIds,
+                    });
+                    admittedScopeOverlaps = await admitScopeRegistration(stableRoot, {
+                        contractId: entry.contract,
+                        scope: bindEffectiveScope(entry),
+                        tree: entry.data.base,
+                        ...(input.exclusive === undefined ? {} : { exclusive: input.exclusive }),
+                    }, attemptRead);
+                    await revalidateBindAuthority({
+                        cwd: stableRoot,
+                        target,
+                        targetHead: prepared.expectedHead,
+                        deliveryRef: repositoryDeliveryRef(entry.contract),
+                    });
+                    const written = await publishBind({
+                        cwd: stableRoot,
+                        entry,
+                        expectedLedgerHead: attemptRead.observedLedgerHead,
+                        delivery: { ref: repositoryDeliveryRef(entry.contract), head: prepared.entryBase },
+                        taskBoard: prepared.taskBoard,
+                    });
+                    if (written.family === "committed") {
+                        try {
+                            await replayPreparedTaskBindLocked(taskTransaction, prepared);
+                        }
+                        catch {
+                            // Authority is already committed. The ordinary derived replay
+                            // below owns truthful retry/contained classification.
+                        }
+                        return written;
+                    }
+                    if (written.family === "indeterminate")
+                        committedOrThrow(written, "BIND_TRANSACTION");
+                    lastRefusal = written;
+                    attemptRead = await readRepositoryLifecycle(stableRoot);
+                }
+                return lastRefusal;
+            },
+        });
+        preparedTask = settled.preparation;
+        committedOrThrow(settled.result, "BIND_TRANSACTION");
+    }
+    else {
+        let committed;
+        for (let attempt = 0; attempt < 4; attempt += 1) {
+            const [read, branch] = await Promise.all([
+                readRepositoryLifecycle(stableRoot),
+                resolveDefaultBranch(stableRoot),
+            ]);
+            if (!branch || normalizeTargetRef(branch.branch) !== target) {
+                throw new FlowError("CONCURRENT_MODIFICATION", "bind target changed during admission");
             }
-            const ledger = await readLedger(input.cwd, id);
-            if (!ledger)
-                throw new FlowError("INTERNAL_STATE", `LEDGER_MISSING: ledger missing immediately after bind for ${id}`);
-            resources.keiyakuPath = await materializeContractView({
-                targetRoot,
-                id,
-                entries: ledger.entries,
+            validateBindAfter(read, after);
+            await selectCandidate(ordinaryDraft, read);
+            entry = makeBindEntry({
+                id: selectedId, at, actor: input.actor, draft: selectedDraft, base: branch.head,
+                target, after, workspace, place: selectedPlace, bootstrap: bootstrapPlan,
             });
-            return {
-                id,
-                ref,
+            admittedScopeOverlaps = await admitScopeRegistration(stableRoot, {
+                contractId: entry.contract,
+                scope: bindEffectiveScope(entry),
+                tree: entry.data.base,
+                ...(input.exclusive === undefined ? {} : { exclusive: input.exclusive }),
+            }, read);
+            await revalidateBindAuthority({
+                cwd: stableRoot,
                 target,
-                place: workspace === "worktree" ? entry.data.place ?? null : null,
-                branch: workspace === "worktree" ? branch : undefined,
-                worktreePath: targetRoot,
-                workspace,
-                ledgerHead,
-                scopeOverlaps: registration.overlaps,
-            };
-        }
-        catch (error) {
-            // Bootstrap failure order is strict: bootstrap entry (already appended) →
-            // forfeit(bind-failed) → cleanup. Cleanup cold facts cannot convert success.
-            const cleanupFailures = [];
-            if (!bootstrapRecorded) {
-                // Non-bootstrap failure: cleanup first remains compatible with prior path,
-                // then forfeit. When bootstrap already recorded its failed fact, forfeit
-                // must precede cleanup.
-                cleanupFailures.push(...(await cleanupCreatedBindResources(input.cwd, resources)));
-                try {
-                    await appendBindFailedForfeit(input.cwd, id, input.actor, at);
-                }
-                catch (forfeitError) {
-                    cleanupFailures.push(forfeitError instanceof Error ? forfeitError.message : String(forfeitError));
-                }
-            }
-            else {
-                try {
-                    await appendBindFailedForfeit(input.cwd, id, input.actor, at);
-                }
-                catch (forfeitError) {
-                    cleanupFailures.push(forfeitError instanceof Error ? forfeitError.message : String(forfeitError));
-                }
-                cleanupFailures.push(...(await cleanupCreatedBindResources(input.cwd, resources)));
-            }
-            if (registryRegistered) {
-                try {
-                    await releaseScope(input.cwd, { contractId: id, actor: input.actor, at });
-                }
-                catch (releaseError) {
-                    cleanupFailures.push(releaseError instanceof Error ? releaseError.message : String(releaseError));
-                }
-            }
-            if (error instanceof FlowError && error.code === "ACTIVE_KEIYAKU_EXISTS") {
-                const message = [
-                    `bind rejected and forfeited as ${id}: ${error.message}`,
-                    cleanupFailures.length > 0 ? `cleanup failed: ${cleanupFailures.join("; ")}` : "",
-                ]
-                    .filter(Boolean)
-                    .join("; ");
-                throw new FlowError("ACTIVE_KEIYAKU_EXISTS", message, { cause: error });
+                targetHead: branch.head,
+                deliveryRef: repositoryDeliveryRef(entry.contract),
+            });
+            const bindWrite = await publishBind({
+                cwd: stableRoot,
+                entry,
+                expectedLedgerHead: read.observedLedgerHead,
+                delivery: { ref: repositoryDeliveryRef(entry.contract), head: entry.data.base },
+            });
+            if (bindWrite.family === "committed") {
+                committed = bindWrite;
+                break;
             }
-            const message = [
-                `bind failed for ${id}: ${error instanceof Error ? error.message : String(error)}`,
-                cleanupFailures.length > 0 ? `cleanup failed: ${cleanupFailures.join("; ")}` : "",
-            ]
-                .filter(Boolean)
-                .join("; ");
-            throw new FlowError("INTERNAL_STATE", `BIND_WORKSPACE_FAILED: ${message}`, { cause: error });
+            if (bindWrite.family === "indeterminate")
+                committedOrThrow(bindWrite, "BIND_TRANSACTION");
+        }
+        if (!committed) {
+            throw new FlowError("CONCURRENT_MODIFICATION", "BIND_TRANSACTION_REFUSED: repository authority changed during four bind attempts");
         }
     }
-    throw new FlowError("CONCURRENT_MODIFICATION", `CONTRACT_ID_COLLISION: contract id collision after two attempts: ${collidedIds.join(", ")}`);
+    return await reconcileCommittedBind({
+        cwd: stableRoot,
+        contractId: entry.contract,
+        actor: input.actor,
+        nowMs: input.nowMs,
+        ...(input.signal ? { signal: input.signal } : {}),
+        ...(input.createWorktree ? { createWorktree: input.createWorktree } : {}),
+        ...(input.onProgress ? { onProgress: input.onProgress } : {}),
+        ...(input.bootstrapRunner ? { bootstrapRunner: input.bootstrapRunner } : {}),
+        ...(input.bootstrapDependencies ? { bootstrapDependencies: input.bootstrapDependencies } : {}),
+        ...(preparedTask ? { preparedTask } : {}),
+        dependencies: input.dependencies,
+    }, admittedScopeOverlaps);
 }

package/build/core/call/call.js

@@ -83,6 +83,7 @@ export async function runCall(input) {
         mode: input.mode ?? "call",
         repoCwd,
         reviveBinding: reviveArtifact?.provenance.binding,
+        signal: input.signal,
     });
     return await withResolvedAddress(keiyakuContext.address, async () => {
         const executionCwd = keiyakuContext.effectiveCwd;