@astrosheep/keiyaku 4.6.7 → 4.6.9

package/build/src/protocol/operations.d.ts

@@ -2,7 +2,6 @@ import { z } from "zod";
 import type { DecideInput, OfferDecision } from "../core/decide.js";
 import type { ActorId, ContractId, ContractState, DeliverData, DocumentKey, JournalEntry, SnapshotId } from "../core/facts/types.js";
 import type { IntegrationPreparationRefusal } from "../git/integration.js";
-import { type PrivateStateSeatOutcome } from "../git/private-state-seat.js";
 import type { GitRepository } from "../git/process.js";
 import { type GitDecodeChannel } from "../git/read-observation.js";
 import type { WorktreeLeak } from "../git/scratch.js";
@@ -389,8 +388,8 @@ export declare const intentRefusalSchema: z.ZodUnion<readonly [z.ZodObject<{
     }, z.core.$strict>>>;
 }, z.core.$strict>]>, z.ZodObject<{
     kind: z.ZodEnum<{
-        "unborn-head": "unborn-head";
         "target-missing": "target-missing";
+        "unborn-head": "unborn-head";
         "invalid-target": "invalid-target";
     }>;
 }, z.core.$strict>, z.ZodObject<{
@@ -630,7 +629,6 @@ export type AttemptDecision<Value, Refusal = IntentRefusal> = (AcceptedAdmission
     kind: "publication-failed";
 }>;
 export declare function timestamp(): string;
-export declare function attemptDecisionWithSeatClose<Value, Refusal = IntentRefusal>(outcome: PrivateStateSeatOutcome<AttemptDecision<Value, Refusal>>): AttemptDecision<Value, Refusal>;
 export declare function unpackVerificationOutcome(verification: VerificationResult): Readonly<{
     cleanup?: VerificationCleanupFailure;
     leak?: WorktreeLeak;

package/build/src/protocol/operations.js

@@ -4,7 +4,6 @@ import { gate } from "../core/facts/types.js";
 import { changeIdSchema, contractIdSchema, snapshotIdSchema } from "../git/identity.js";
 import { integrationPreparationRefusalSchema, readDeliveryDiff } from "../git/integration.js";
 import { currentBranch, observeContractAt } from "../git/observe.js";
-import { appendPrivateStateSeatClose, mergePrivateStateSeatClose, } from "../git/private-state-seat.js";
 import { withGitReadObservation } from "../git/read-observation.js";
 import { repositoryAt } from "../git/repository.js";
 import { checkoutNotFollowableRefusalSchema } from "../git/target-placement.js";
@@ -216,13 +215,6 @@ export const placementStopSchema = z.union([
 export function timestamp() {
     return new Date().toISOString();
 }
-export function attemptDecisionWithSeatClose(outcome) {
-    return mergePrivateStateSeatClose(outcome, (value, closeLag) => {
-        if (value.kind !== "accepted")
-            throw new Error(closeLag.diagnostic);
-        return { ...value, seatClose: appendPrivateStateSeatClose(value.seatClose, closeLag) };
-    });
-}
 function stepStop(result) {
     if (result.kind === "accepted")
         return undefined;

package/build/src/protocol/outcome.d.ts

@@ -1,7 +1,7 @@
 import type { ContractHead, ContractState, JournalEntry } from "../core/facts/types.js";
 import type { WorktreeLeak } from "../git/scratch.js";
 import type { ReconcileResult } from "../git/reconcile.js";
-import { type PrivateStateSeatCloseLag, type PrivateStateSeatOutcome } from "../git/private-state-seat.js";
+import type { PrivateStateSeatCloseLag } from "../git/private-state-seat.js";
 import type { AcceptedAdmission } from "./attempt.js";
 import type { VerificationCleanupFailure } from "./intent.js";
 import type { ProtocolResult, ProtocolTerminal } from "./run.js";
@@ -38,5 +38,4 @@ export type IntentOutcome<Value, Refusal = never> = Readonly<{
 export declare function accepted<Value, Refusal = never>(state: ContractState, facts: readonly JournalEntry[], value: Value, physical?: ReconcileResult, obligations?: AcceptedObligations): IntentOutcome<Value, Refusal>;
 export declare function admitted<Value, Refusal = never>(admission: AcceptedProtocolStep, value: Value): IntentOutcome<Value, Refusal>;
 export declare function complete<Value, Refusal>(result: ProtocolResult<Refusal>, value: Value): IntentOutcome<Value, Refusal>;
-export declare function intentOutcomeWithSeatClose<Value, Refusal>(outcome: PrivateStateSeatOutcome<IntentOutcome<Value, Refusal>>): IntentOutcome<Value, Refusal>;
 export {};

package/build/src/protocol/outcome.js

@@ -1,4 +1,3 @@
-import { appendPrivateStateSeatClose, mergePrivateStateSeatClose, } from "../git/private-state-seat.js";
 export function accepted(state, facts, value, physical, obligations) {
     if (state.head === null)
         throw new Error("accepted contract is missing its journal head");
@@ -16,12 +15,8 @@ export function accepted(state, facts, value, physical, obligations) {
 function seatCloseObligations(seatClose) {
     return seatClose === undefined || seatClose.length === 0 ? {} : { seatClose };
 }
-function admissionObligations(admission) {
-    const seatClose = admission.seatClose;
-    return seatClose === undefined || seatClose.length === 0 ? undefined : { seatClose };
-}
 export function admitted(admission, value) {
-    return accepted(admission.state, admission.facts, value, admission.physical, admissionObligations(admission));
+    return accepted(admission.state, admission.facts, value, admission.physical, admission.seatClose === undefined ? undefined : { seatClose: admission.seatClose });
 }
 export function complete(result, value) {
     if (result.kind === "refused")
@@ -30,10 +25,3 @@ export function complete(result, value) {
         return { kind: "retry", reason: result };
     return admitted(result, value);
 }
-export function intentOutcomeWithSeatClose(outcome) {
-    return mergePrivateStateSeatClose(outcome, (value, closeLag) => {
-        if (value.kind !== "accepted")
-            throw new Error(closeLag.diagnostic);
-        return { ...value, seatClose: appendPrivateStateSeatClose(value.seatClose, closeLag) };
-    });
-}

package/build/src/protocol/placement.js

@@ -3,12 +3,12 @@ import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { contractState } from "../core/facts/observation.js";
 import { decidePlacement } from "../core/verbs/placement.js";
 import { observeContractsForAdmissionAt, observeGitForAdmissionAt } from "../git/observe.js";
-import { appendPrivateStateSeatClose, mergePrivateStateSeatClose, withPrivateStatePublicationSeat, } from "../git/private-state-seat.js";
+import { withPrivateStatePublicationSeat } from "../git/private-state-seat.js";
 import { reconcileEffectFailure } from "../git/reconcile.js";
 import { GitPlumbingError } from "../git/process.js";
 import { acquireTargetPlacementFence, followTargetPlacement, prepareTargetPlacement, prepareTargetPlacementChanges, observeTargetHead, observedTreeEqualsCandidate, } from "../git/target-placement.js";
 import { admitDecidedOffer, mintAttempts } from "./attempt.js";
-import { prepareProtocolAttempt, runProtocol } from "./run.js";
+import { prepareProtocolAttempt, protocolSeatClose, runProtocol, } from "./run.js";
 export { observeTargetPlacement } from "../git/target-placement.js";
 export async function observeIntegrationTargetMovement(repository, state) {
     const target = state.coordinates.target;
@@ -39,13 +39,6 @@ function expectedOperationalDiagnostic(error) {
 function expectedPlacementFailure(error) {
     return { kind: "placement-failed", diagnostic: expectedOperationalDiagnostic(error) };
 }
-function placementResultWithSeatClose(outcome) {
-    return mergePrivateStateSeatClose(outcome, (value, closeLag) => {
-        if (value.kind !== "accepted")
-            throw new Error(closeLag.diagnostic);
-        return { ...value, seatClose: appendPrivateStateSeatClose(value.seatClose, closeLag) };
-    });
-}
 async function placementChangesHint(repository, channel, contractId) {
     const observation = await observeContractsForAdmissionAt(repository, channel, [contractId]);
     const state = contractState(observation.decision, contractId);
@@ -63,7 +56,7 @@ async function runFencedPlacement(repository, input, protocol) {
             (changes?.predecessor !== movement.expectedOid || changes.candidate !== movement.newOid))
             changes = await prepareTargetPlacementChanges(repository, movement);
         let preparedPhysical;
-        const result = placementResultWithSeatClose(await withPrivateStatePublicationSeat(repository, async (seat) => {
+        const result = protocolSeatClose(await withPrivateStatePublicationSeat(repository, async (seat) => {
             // The hint carries no acceptance authority. Form a fresh semantic offer under the seat.
             const prepared = await prepareProtocolAttempt(protocol, protocol.attempts[index]);
             if (prepared.kind !== "offered")

package/build/src/protocol/read/status.js

@@ -57,9 +57,6 @@ function appointedWorkspace(repository, register, state) {
         ? undefined
         : { contractId: state.id, place: appointed.place, workspace: worktreePath(repository, appointed.place) };
 }
-async function readSelectedHandoffs(observation, workspaces) {
-    return await readConflictHandoffs(observation.repository, observation.readBlobs, workspaces.flatMap((workspace) => (workspace === undefined ? [] : [workspace])));
-}
 async function managedWorkspaceFacts(repository, state, appointed, targetObservation, handoff) {
     if (appointed === undefined) {
         return {
@@ -101,10 +98,10 @@ function afterEdges(state, endpoints) {
         endpoint: afterEndpoint(endpoints.get(contractId)),
     }));
 }
-function reverseDependents(id, rows) {
-    return rows
-        .filter((row) => row.disposition === "active" && row.after.some((edge) => edge.contractId === id))
-        .map((row) => ({ contractId: row.id, phase: row.phase }))
+function reverseDependents(id, states) {
+    return states
+        .filter(({ state }) => state.terminal === null && state.terms.after.includes(id))
+        .map(({ state }) => ({ contractId: state.id, phase: phaseFor(state) }))
         .sort((left, right) => left.contractId.localeCompare(right.contractId));
 }
 async function rowFor(input) {
@@ -148,6 +145,25 @@ async function afterEndpointMap(observation, known, ids) {
     const extra = await observeContractsForAdmissionInObservationAt(observation, missing);
     return new Map([...known, ...[...extra.journals].map(([id, record]) => [id, record.state])]);
 }
+async function hydrateRows(observation, states, endpoints, dependentStates = []) {
+    const register = await readPlaceRegister(observation.repository);
+    const selected = states.map((value) => ({
+        ...value,
+        workspace: appointedWorkspace(observation.repository, register, value.state),
+    }));
+    const handoffs = await readConflictHandoffs(observation.repository, observation.readBlobs, selected.flatMap(({ workspace }) => (workspace === undefined ? [] : [workspace])));
+    return await Promise.all(selected.map(async ({ state, bindAt, lastJournalAt, workspace }) => await rowFor({
+        repository: observation.repository,
+        state,
+        bindAt,
+        lastJournalAt,
+        targetObservation: await observeDeliveryTargetAt(observation, state),
+        workspace,
+        handoff: handoffs.get(state.id),
+        after: afterEdges(state, endpoints),
+        dependents: reverseDependents(state.id, dependentStates),
+    })));
+}
 /** Build the Contract board from one immutable git observation. */
 export async function readContractBoard(observation, include) {
     const observedAt = new Date().toISOString();
@@ -165,29 +181,8 @@ export async function readContractBoard(observation, include) {
             endpoints = new Map(await afterEndpointMap(observation, endpoints, record.state.terms.after));
         }
     }
-    const register = await readPlaceRegister(observation.repository);
-    const selected = [...contracts.values()].flatMap((value) => value.state === null
-        ? []
-        : [
-            {
-                ...value,
-                state: value.state,
-                workspace: appointedWorkspace(observation.repository, register, value.state),
-            },
-        ]);
-    const handoffs = await readSelectedHandoffs(observation, selected.map(({ workspace }) => workspace));
-    const projected = await Promise.all(selected.map(async ({ state, entries, workspace }) => await rowFor({
-        repository: observation.repository,
-        state,
-        bindAt: entries[0].at,
-        lastJournalAt: lastJournalAtFor(entries),
-        targetObservation: await observeDeliveryTargetAt(observation, state),
-        workspace,
-        handoff: handoffs.get(state.id),
-        after: afterEdges(state, endpoints),
-        dependents: [],
-    })));
-    const rows = projected.map((row) => ({ ...row, dependents: reverseDependents(row.id, projected) }));
+    const selected = selectedContractStates(contracts);
+    const rows = await hydrateRows(observation, selected, endpoints, selected);
     return {
         root: observation.repository.primaryWorktree,
         state: observed.snapshot,
@@ -199,8 +194,8 @@ function compareRecentContracts(left, right) {
     return (right.lastJournalAt.localeCompare(left.lastJournalAt) ||
         Buffer.compare(Buffer.from(left.state.id), Buffer.from(right.state.id)));
 }
-function activeContractStates(contracts) {
-    return [...contracts.values()].flatMap((record) => record.state === null || record.state.terminal !== null
+function selectedContractStates(contracts) {
+    return [...contracts.values()].flatMap((record) => record.state === null
         ? []
         : [
             {
@@ -210,37 +205,15 @@ function activeContractStates(contracts) {
             },
         ]);
 }
-function reverseDependentsFromStates(id, states) {
-    return states
-        .filter(({ state }) => state.terms.after.includes(id))
-        .map(({ state }) => ({ contractId: state.id, phase: phaseFor(state) }))
-        .sort((left, right) => left.contractId.localeCompare(right.contractId));
-}
 /** Observe a bounded recent active Contract catalogue from one immutable git observation. */
 export async function readContractCatalogue(observation, limit) {
     const observedAt = new Date().toISOString();
     const observed = await observeActiveContractWorld(observation);
-    const active = activeContractStates(observed.contracts);
+    const active = selectedContractStates(observed.contracts).filter(({ state }) => state.terminal === null);
     const selected = projectBoundedList([...active].sort(compareRecentContracts), limit);
     const afterIds = selected.rows.flatMap(({ state }) => state.terms.after);
     const endpoints = await afterEndpointMap(observation, new Map(observed.eligibility), afterIds);
-    const register = await readPlaceRegister(observation.repository);
-    const selectedWorkspaces = selected.rows.map((value) => ({
-        ...value,
-        workspace: appointedWorkspace(observation.repository, register, value.state),
-    }));
-    const handoffs = await readSelectedHandoffs(observation, selectedWorkspaces.map(({ workspace }) => workspace));
-    const rows = await Promise.all(selectedWorkspaces.map(async ({ state, bindAt, lastJournalAt, workspace }) => await rowFor({
-        repository: observation.repository,
-        state,
-        bindAt,
-        lastJournalAt,
-        targetObservation: await observeDeliveryTargetAt(observation, state),
-        workspace,
-        handoff: handoffs.get(state.id),
-        after: afterEdges(state, endpoints),
-        dependents: reverseDependentsFromStates(state.id, active),
-    })));
+    const rows = await hydrateRows(observation, selected.rows, endpoints, active);
     return {
         root: observation.repository.primaryWorktree,
         state: observed.snapshot,
@@ -270,22 +243,10 @@ export async function readContractObservation(observation, id) {
     if (state === null)
         return { kind: "missing", id };
     const endpoints = await afterEndpointMap(observation, new Map([[id, state]]), state.terms.after);
-    const register = await readPlaceRegister(observation.repository);
-    const workspace = appointedWorkspace(observation.repository, register, state);
-    const handoffs = await readSelectedHandoffs(observation, [workspace]);
+    const rows = await hydrateRows(observation, selectedContractStates(observed.journals), endpoints);
     return {
         kind: "present",
-        row: await rowFor({
-            repository: observation.repository,
-            state,
-            bindAt: record.entries[0].at,
-            lastJournalAt: lastJournalAtFor(record.entries),
-            targetObservation: await observeDeliveryTargetAt(observation, state),
-            workspace,
-            handoff: handoffs.get(state.id),
-            after: afterEdges(state, endpoints),
-            dependents: [],
-        }),
+        row: rows[0],
     };
 }
 /** Observe one Contract and its target from one fresh ref epoch. */

package/build/src/protocol/reintegrate.js

@@ -2,18 +2,11 @@ import { contractState } from "../core/facts/observation.js";
 import { decideReintegrate } from "../core/verbs/reintegrate.js";
 import { materializeReintegrationSnapshot, persistedTender, planIntegration, reusableIntegrationSnapshot, } from "../git/integration.js";
 import { observeContractsForAdmissionAt } from "../git/observe.js";
-import { appendPrivateStateSeatClose, mergePrivateStateSeatClose, withPrivateStatePublicationSeat, } from "../git/private-state-seat.js";
+import { withPrivateStatePublicationSeat } from "../git/private-state-seat.js";
 import { admitDecidedOffer, mintAttempts } from "./attempt.js";
 import { recordedIntegrationSnapshots, timestamp } from "./operations.js";
-import { externalPreparation, STALE_PRIVATE_STATE_PREPARATION, } from "./run.js";
+import { externalPreparation, protocolSeatClose, STALE_PRIVATE_STATE_PREPARATION, } from "./run.js";
 import { runUnderTargetPlacementFence } from "./placement.js";
-function reintegrationResultWithSeatClose(outcome) {
-    return mergePrivateStateSeatClose(outcome, (value, closeLag) => {
-        if (value.kind !== "accepted")
-            throw new Error(closeLag.diagnostic);
-        return { ...value, seatClose: appendPrivateStateSeatClose(value.seatClose, closeLag) };
-    });
-}
 /** Plan and materialize the target-specific reintegration artifacts outside the publication seat. */
 async function prepareExternalReintegration(input) {
     return await externalPreparation({ ...input, scope: input.repository }, (observation, state) => planReintegrationArtifacts(input, state, recordedIntegrationSnapshots(observation.journals.get(state.id)?.entries ?? [])));
@@ -54,7 +47,7 @@ async function runReintegration(input) {
     for (let index = 0; index < attempts.length; index += 1) {
         const attempt = attempts[index];
         const external = await prepareExternalReintegration(input);
-        const result = reintegrationResultWithSeatClose(await withPrivateStatePublicationSeat(input.repository, async (seat) => {
+        const result = protocolSeatClose(await withPrivateStatePublicationSeat(input.repository, async (seat) => {
             const observation = await observeContractsForAdmissionAt(input.repository, input.channel, [input.contractId]);
             const assembled = assembleReintegrationAttempt(input, observation, external);
             if (assembled.kind === "stale")

package/build/src/protocol/review.js

@@ -4,14 +4,14 @@ import { worktreeChangeId } from "../git/integration.js";
 import { captureTender, dirtyTenderDelta, dirtyTenderRefusal } from "../git/tender.js";
 import { observeContractsForAdmissionAt } from "../git/observe.js";
 import { unmergedWorkspacePaths, worktreePath } from "../git/workspace.js";
-import { externalPreparation, privateStateSeatAttempt, runBoundedAttempts, sameWorktreeWitness, STALE_PRIVATE_STATE_PREPARATION, } from "./run.js";
+import { externalPreparation, privateStateSeatAttempt, protocolSeatClose, runBoundedAttempts, sameWorktreeWitness, STALE_PRIVATE_STATE_PREPARATION, } from "./run.js";
 import { dependencyKeySet } from "../core/subject.js";
 import { contractState } from "../core/facts/observation.js";
 import { gate } from "../core/facts/types.js";
 import { decideAttestation } from "../core/verbs/attestation.js";
 import { admitDecidedOffer, mintAttempts } from "./attempt.js";
 import { appointmentFor, readPlaceRegister } from "../workspace-place.js";
-import { attemptDecisionWithSeatClose, timestamp } from "./operations.js";
+import { timestamp } from "./operations.js";
 const REVIEWED = gate("reviewed");
 const reviewWorkspaceEvidenceSchema = workspaceDirtyDeltaSchema
     .extend({ unmergedPaths: z.array(z.string().refine((value) => value.trim() !== "")).readonly() })
@@ -153,7 +153,7 @@ async function reviewAttempt(input, attempt) {
         if (assembled.kind === "stale")
             return STALE_PRIVATE_STATE_PREPARATION;
         return await decideAndAdmitReview(input, attempt, seat, observation, assembled);
-    }, attemptDecisionWithSeatClose);
+    }, protocolSeatClose);
 }
 export async function admitReviewOperation(input) {
     const result = await runBoundedAttempts(mintAttempts({ entryCount: 1 }), (attempt) => reviewAttempt(input, attempt));

package/build/src/protocol/run.d.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import type { ProtocolProgress } from "./progress.js";
 import { type GitDecisionObservation } from "../git/observe.js";
-import { type PrivateStatePublicationSeat, type PrivateStateSeatOutcome } from "../git/private-state-seat.js";
+import { type PrivateStatePublicationSeat, type PrivateStateSeatCloseLag, type PrivateStateSeatOutcome } from "../git/private-state-seat.js";
 import type { GitDecodeChannel, GitTreeSelection } from "../git/read-observation.js";
 import type { GitRepository } from "../git/process.js";
 import { type GitRefAssertion } from "../git/repository.js";
@@ -177,6 +177,10 @@ export declare function externalPreparation<Artifacts>(input: Readonly<{
     artifacts: Artifacts;
 }>>;
 export declare function privateStateSeatAttempt<T>(repository: GitRepository, action: (seat: PrivateStatePublicationSeat) => Promise<T>, wrap: (outcome: PrivateStateSeatOutcome<T>) => T): Promise<T | AttemptTerminal>;
+export declare function protocolSeatClose<T extends Readonly<{
+    kind: string;
+    seatClose?: readonly PrivateStateSeatCloseLag[];
+}>>(outcome: PrivateStateSeatOutcome<T>): T;
 /** Form one decided offer without admitting or reinterpreting it. */
 export declare function prepareProtocolAttempt<Input extends Readonly<{
     contractId: ContractId;

package/build/src/protocol/run.js

@@ -122,7 +122,7 @@ async function admitDecidedProtocolOffer(admission, primaryContract, seat, decis
         assertions: decided.assertions,
     });
 }
-function protocolAttemptWithSeatClose(outcome) {
+export function protocolSeatClose(outcome) {
     return mergePrivateStateSeatClose(outcome, (value, closeLag) => {
         if (value.kind !== "accepted")
             throw new Error(closeLag.diagnostic);
@@ -137,7 +137,7 @@ async function runDirectProtocolAttempt(input, attempt) {
             input: input.input,
             assertions: [],
         });
-    }, protocolAttemptWithSeatClose);
+    }, protocolSeatClose);
 }
 /**
  * One full attempt: repeatable preparation outside custody, then a single in-custody cycle of
@@ -160,7 +160,7 @@ async function runSplitProtocolAttempt(input, attempt) {
             input: assembled.input,
             assertions,
         });
-    }, protocolAttemptWithSeatClose);
+    }, protocolSeatClose);
 }
 /** Form one decided offer without admitting or reinterpreting it. */
 export async function prepareProtocolAttempt(input, baseAttempt) {

package/build/src/settlement/fence.d.ts

@@ -1,5 +1,5 @@
 import { type HeldSqliteTransactionLock } from "../coordination/sqlite-transaction-lock.js";
 import type { GitRepository } from "../git/process.js";
-import type { TaskId } from "../task/identity.js";
-export declare function settlementFencePath(repository: GitRepository, taskId: TaskId): string;
-export declare function acquireTaskSettlementFence(repository: GitRepository, taskId: TaskId): Promise<HeldSqliteTransactionLock>;
+import type { DebtId } from "../debt/identity.js";
+export declare function settlementFencePath(repository: GitRepository, debtId: DebtId): string;
+export declare function acquireDebtSettlementFence(repository: GitRepository, debtId: DebtId): Promise<HeldSqliteTransactionLock>;

package/build/src/settlement/fence.js

@@ -2,13 +2,13 @@ import { createHash } from "node:crypto";
 import { resolve } from "node:path";
 import { acquireSqliteTransactionLock, } from "../coordination/sqlite-transaction-lock.js";
 import { commonGitDirectory } from "../git/repository.js";
-export function settlementFencePath(repository, taskId) {
-    const locator = createHash("sha256").update(taskId).digest("hex");
+export function settlementFencePath(repository, debtId) {
+    const locator = createHash("sha256").update(debtId).digest("hex");
     return resolve(commonGitDirectory(repository), "keiyaku", "locks", "settlement", `${locator}.sqlite`);
 }
-export function acquireTaskSettlementFence(repository, taskId) {
+export function acquireDebtSettlementFence(repository, debtId) {
     return acquireSqliteTransactionLock({
-        path: settlementFencePath(repository, taskId),
+        path: settlementFencePath(repository, debtId),
         mode: "immediate",
     });
 }

package/build/src/settlement/holder.d.ts

@@ -4,31 +4,31 @@ import type { GitDecisionObservation } from "../git/observe.js";
 import { type PrivateStatePublicationSeat } from "../git/private-state-seat.js";
 import type { GitRepository } from "../git/process.js";
 import { type GitDecodeChannel, type GitReadObservation, type GitTreeSelection } from "../git/read-observation.js";
-import { type TaskId } from "../task/identity.js";
-export declare function taskHolderObservationSelection(): GitTreeSelection;
-export type TaskHolder = Readonly<{
+import { type DebtId } from "../debt/identity.js";
+export declare function debtHolderObservationSelection(): GitTreeSelection;
+export type DebtHolder = Readonly<{
     version: 1;
-    taskId: TaskId;
+    debtId: DebtId;
     contractId: ContractId;
     disposition: "held" | "released";
 }>;
-export type TaskHolderProjection = ReadonlyMap<ContractId, TaskHolder>;
-export declare function claimTaskHolder(taskId: TaskId, owner: ContractId): TreeUpdate;
+export type DebtHolderProjection = ReadonlyMap<ContractId, DebtHolder>;
+export declare function claimDebtHolder(debtId: DebtId, owner: ContractId): TreeUpdate;
 type AdmissionOutcome = Readonly<{
     kind: string;
 }>;
-type TaskHolderAdmission<T extends AdmissionOutcome> = Readonly<{
+type DebtHolderAdmission<T extends AdmissionOutcome> = Readonly<{
     kind: "completed";
     result: T;
 }> | Readonly<{
     kind: "accepted-release-failed";
     result: T;
-    taskId: TaskId;
+    debtId: DebtId;
     diagnostic: string;
 }>;
-export declare function admitWithTaskHolderFence<T extends AdmissionOutcome>(repository: GitRepository, taskId: TaskId, action: () => T | Promise<T>): Promise<TaskHolderAdmission<T>>;
-export declare function releaseTaskHolder(channel: GitDecodeChannel, observation: GitDecisionObservation, owner: ContractId): Promise<TreeUpdate | null>;
-type TaskHolderReleasePublication = Readonly<{
+export declare function admitWithDebtHolderFence<T extends AdmissionOutcome>(repository: GitRepository, debtId: DebtId, action: () => T | Promise<T>): Promise<DebtHolderAdmission<T>>;
+export declare function releaseDebtHolder(channel: GitDecodeChannel, observation: GitDecisionObservation, owner: ContractId): Promise<TreeUpdate | null>;
+type DebtHolderReleasePublication = Readonly<{
     kind: "released";
 }> | Readonly<{
     kind: "not-held";
@@ -37,9 +37,9 @@ type TaskHolderReleasePublication = Readonly<{
     diagnostic: string;
 }>;
 /** Publish the released holder against the same frozen observation that decided the release. */
-export declare function publishTaskHolderRelease(repository: GitRepository, channel: GitDecodeChannel, observation: GitDecisionObservation, owner: ContractId, seat: PrivateStatePublicationSeat): Promise<TaskHolderReleasePublication>;
-export declare function readTaskHolderProjectionFromDecision(channel: GitDecodeChannel, observation: GitDecisionObservation): Promise<TaskHolderProjection>;
-export declare function releaseTaskHolderWithFence<T extends AdmissionOutcome>(repository: GitRepository, channel: GitDecodeChannel, owner: ContractId, action: () => T | Promise<T>): Promise<TaskHolderAdmission<T>>;
-export declare function readTaskHoldersAt(observation: Pick<GitReadObservation, "snapshot" | "readBlobs">): Promise<readonly TaskHolder[]>;
-export declare function readTaskHolderProjectionAt(observation: GitReadObservation): Promise<TaskHolderProjection>;
+export declare function publishDebtHolderRelease(repository: GitRepository, channel: GitDecodeChannel, observation: GitDecisionObservation, owner: ContractId, seat: PrivateStatePublicationSeat): Promise<DebtHolderReleasePublication>;
+export declare function readDebtHolderProjectionFromDecision(channel: GitDecodeChannel, observation: GitDecisionObservation): Promise<DebtHolderProjection>;
+export declare function releaseDebtHolderWithFence<T extends AdmissionOutcome>(repository: GitRepository, channel: GitDecodeChannel, owner: ContractId, action: () => T | Promise<T>): Promise<DebtHolderAdmission<T>>;
+export declare function readDebtHoldersAt(observation: Pick<GitReadObservation, "snapshot" | "readBlobs">): Promise<readonly DebtHolder[]>;
+export declare function readDebtHolderProjectionAt(observation: GitReadObservation): Promise<DebtHolderProjection>;
 export {};