@astrosheep/keiyaku 4.6.8 → 4.6.9

package/build/src/library/outcome.js

@@ -22,7 +22,7 @@ import { regionOverlapSchema } from "./region.js";
 // One invocation-wide tagged Effect carrier
 // ---------------------------------------------------------------------------
 const reconciliationEffectSchema = z.union([reconcileEffectSchema, contractFileEffectSchema]);
-const resetOwnerSchema = z.enum(["akuma", "git", "task", "world"]);
+const resetOwnerSchema = z.enum(["akuma", "git", "debt", "world"]);
 const resetEffectFields = { world: z.string().min(1), owner: resetOwnerSchema, diagnostic: z.string().min(1) };
 const resetEffectSchema = z.union([
     z.object({ kind: z.literal("reset-owner-stopped"), ...resetEffectFields }).strict(),
@@ -158,7 +158,7 @@ export function project(operation, snapshot, projection) {
         if (operation !== "nuke")
             throw new Error("reset projection requires nuke");
         const effects = snapshot.effects.filter((effect) => effect.kind === "reset-owner-stopped" || effect.kind === "reset-residue");
-        const value = { removed: snapshot.reset?.removed ?? { refs: 0, worktrees: 0, tasks: 0 } };
+        const value = { removed: snapshot.reset?.removed ?? { refs: 0, worktrees: 0, debts: 0 } };
         const base = { operation, world: projection.world, effects, pending: projectPending(operation, value, effects) };
         if (projection.kind === "failed")
             return {
@@ -404,7 +404,7 @@ const resetCountsSchema = z
     .object({
     refs: z.number().int().nonnegative(),
     worktrees: z.number().int().nonnegative(),
-    tasks: z.number().int().nonnegative(),
+    debts: z.number().int().nonnegative(),
 })
     .strict();
 const resetValueSchema = z.object({ removed: resetCountsSchema }).strict();

package/build/src/library/selection.d.ts

@@ -1,5 +1,4 @@
 import { type AskObserver } from "../akuma/akuma-selection-execution.js";
-import { type WaitObserver } from "../akuma/akuma-wait.js";
 import { type AkumaStatus } from "../akuma/akuma.js";
 import { type ActivityHistory, type OutcomeRow } from "../akuma/projection.js";
 import { type ExecutionContext } from "../akuma/requests.js";
@@ -28,7 +27,7 @@ type SelectionWaitMode = Readonly<{
 export type SelectionSeam = Readonly<{
     addressOne(input: UncheckedSelectionAddress): Promise<AddressedAkuma>;
     addressSet(input: UncheckedSelectionAddress): Promise<AddressedAkumaSet>;
-    wait(addressed: AddressedAkumaSet, mode: SelectionWaitMode, observer?: WaitObserver): Promise<AkumaWaitResult>;
+    wait(addressed: AddressedAkumaSet, mode: SelectionWaitMode): Promise<AkumaWaitResult>;
     kill(addressed: AddressedAkumaSet, signal?: AbortSignal): Promise<AkumaKillResult>;
     tell(addressed: AddressedAkuma, input: AkumaTellInput, signal?: AbortSignal): Promise<AkumaTellResult>;
     ask<T>(addressed: AddressedAkuma, input: AkumaAskInput<T>, signal?: AbortSignal): Promise<AkumaAskResult<T>>;
@@ -38,8 +37,6 @@ export type AkumaWaitInput = AkumaSetAddressInput & Readonly<{
     completion?: "any" | "all";
     timeoutMs?: number;
     signal?: AbortSignal;
-    /** The existing optional live-observation seam, validated here like Ask's. */
-    observe?: WaitObserver;
 }>;
 export type AkumaTellInput = AkumaAddressInput & Readonly<{
     body: string;

package/build/src/library/selection.js

@@ -3,16 +3,15 @@ import { withoutReportedChanges } from "../akuma/projection.js";
 import { AkumaNotBornError, AkumaObservationError } from "../akuma/akuma-errors.js";
 import { AkumaOwner } from "../akuma/akuma-owner.js";
 import { decodeAskObservation, executeAskAkuma, executeKillAkuma, executeTellAkuma, } from "../akuma/akuma-selection-execution.js";
-import { executeWaitAkuma, } from "../akuma/akuma-wait.js";
+import { executeWaitAkuma } from "../akuma/akuma-wait.js";
 import { parsePublicHistoryId } from "../akuma/identity.js";
 import { executionChannel } from "../akuma/requests.js";
 import { schemaJsonText } from "../akuma/schema.js";
 import { requestForwardedSelectionAsk, requestForwardedSelectionKill, requestForwardedSelectionTell, requestForwardedSelectionWait, } from "../akuma/selection-request.js";
-import { readAliases } from "../alias/index.js";
 import { observeDispatchAssociations } from "../dispatch/index.js";
 import { observeContractAt } from "../git/observe.js";
 import { withGitDecodeChannel } from "../git/read-observation.js";
-import { observeCreatedTaskObservations } from "../task/created-observation.js";
+import { observeCreatedDebtObservations } from "../debt/created-observation.js";
 import { outcomePluginObserver, stderrPluginDiagnostic } from "../plugin/akuma-signals.js";
 import { addressAkuma, addressAkumaSet, resolveAkuma, resolveAkumaSet, } from "./address.js";
 import { requireInput } from "./input.js";
@@ -60,7 +59,7 @@ function localSelection(reportDiagnostic) {
     return {
         addressOne: addressAkuma,
         addressSet: addressAkumaSet,
-        wait: async (addressed, mode, observer) => await localWait(addressed, { ...mode, ...(observer === undefined ? {} : { observer }) }, reportDiagnostic),
+        wait: async (addressed, mode) => await localWait(addressed, mode, reportDiagnostic),
         kill: async (addressed, abort) => await executeKillAkuma({
             path: addressed.path,
             ids: addressed.orderedIds,
@@ -136,43 +135,19 @@ function placementDischarged(repo) {
 async function composeObservation(status, contract, discharged) {
     return (await discharged(contract)) ? { ...status, timeline: withoutReportedChanges(status.timeline) } : status;
 }
-async function createdTasksFor(path, statuses) {
-    return await observeCreatedTaskObservations(path, statuses.map((status) => status.id));
-}
-/**
- * One wait's identity-fact resolver: the alias bound to an Akuma in its world and
- * its Dispatch association. The alias index is read once, on the first observed
- * Akuma, and each Akuma's alias is the first binding the canonical order offers.
- * Alias bindings and selected Dispatch associations are read once for this live
- * stage. Final result composition owns a separate, fresh Dispatch observation.
- */
-function waitIdentityFacts(path, repo, selected) {
-    let aliases;
-    let contracts;
-    return async (id) => {
-        if (aliases === undefined) {
-            const bound = new Map();
-            for (const binding of await readAliases(path)) {
-                if (!bound.has(binding.akuId))
-                    bound.set(binding.akuId, binding.alias);
-            }
-            aliases = bound;
-        }
-        contracts ??= await dispatchAssociations(repo, selected);
-        const alias = aliases.get(id);
-        return { ...(alias === undefined ? {} : { alias }), contract: contracts.get(id) };
-    };
+async function createdDebtsFor(path, statuses) {
+    return await observeCreatedDebtObservations(path, statuses.map((status) => status.id));
 }
 async function observeAkuma(status, path, repo) {
     return (await composeAkumaAssociations([status], path, repo))[0];
 }
 /**
  * The one upper composition of association-free native status evidence into its
- * public observation shape. It reads Alias-independent Dispatch and Task
+ * public observation shape. It reads Alias-independent Dispatch and Debt
  * associations after the lower values, never before or inside them.
  */
 async function composeAkumaAssociations(statuses, path, repo) {
-    const created = await createdTasksFor(path, statuses);
+    const created = await createdDebtsFor(path, statuses);
     const discharged = placementDischarged(repo);
     const contracts = await dispatchAssociations(repo, statuses.map((status) => status.id));
     return await Promise.all(statuses.map(async (status, index) => {
@@ -180,7 +155,7 @@ async function composeAkumaAssociations(statuses, path, repo) {
         return {
             status: await composeObservation(status, contract, discharged),
             contract,
-            createdTasks: created[index],
+            createdDebts: created[index],
         };
     }));
 }
@@ -214,7 +189,7 @@ async function composeWaitResult(path, repo, result) {
 }
 /**
  * Re-attach upper associations after a wait result crosses a forwarded
- * boundary; the serving side must observe its own Dispatch and Task state.
+ * boundary; the serving side must observe its own Dispatch and Debt state.
  */
 async function attachWaitAssociations(path, repo, result) {
     return await composeWaitResult(path, repo, {
@@ -273,10 +248,6 @@ async function localWait(addressed, input, reportDiagnostic) {
             outcomeObserved: outcomePluginObserver({ world: addressed.path, reportDiagnostic }),
             ...(input.timeoutMs === undefined ? {} : { timeoutMs: input.timeoutMs }),
             ...(input.signal === undefined ? {} : { signal: input.signal }),
-            identity: waitIdentityFacts(addressed.path, input.repo, addressed.orderedIds),
-            selectionOrder: addressed.orderedIds,
-            ...(input.observer?.selected === undefined ? {} : { onSelected: input.observer.selected }),
-            ...(input.observer?.observe === undefined ? {} : { observe: input.observer.observe }),
         }));
     }
     catch (error) {
@@ -285,35 +256,13 @@ async function localWait(addressed, input, reportDiagnostic) {
         throw observationError(addressed.orderedIds[0], error);
     }
 }
-function waitObserver(value) {
-    if (value === undefined)
-        return undefined;
-    if (typeof value !== "object" || value === null || Array.isArray(value))
-        throw new TypeError("observe must be a WaitObserver");
-    const record = value;
-    for (const key of Object.keys(record)) {
-        if (key !== "selected" && key !== "observe")
-            throw new TypeError(`observe has unknown field: ${key}`);
-        if (record[key] !== undefined && typeof record[key] !== "function")
-            throw new TypeError(`observe.${key} must be a function`);
-    }
-    return {
-        ...(record.selected === undefined
-            ? {}
-            : { selected: record.selected }),
-        ...(record.observe === undefined
-            ? {}
-            : { observe: record.observe }),
-    };
-}
 export async function waitAkumaOn(seam, input) {
     const values = requireInput(input, "Akumas.wait input");
     for (const key of Object.keys(values)) {
-        if (!["path", "akuma", "repo", "completion", "timeoutMs", "signal", "observe"].includes(key)) {
+        if (!["path", "akuma", "repo", "completion", "timeoutMs", "signal"].includes(key)) {
             throw new TypeError(`Akumas.wait input has unknown field: ${key}`);
         }
     }
-    const observer = waitObserver(values.observe);
     const selected = completionMode(values.completion);
     const timeoutMs = timeout(values.timeoutMs);
     const callerSignal = signal(values.signal);
@@ -324,7 +273,7 @@ export async function waitAkumaOn(seam, input) {
         ...(timeoutMs === undefined ? {} : { timeoutMs }),
         ...(callerSignal === undefined ? {} : { signal: callerSignal }),
         ...(repo === undefined ? {} : { repo }),
-    }, observer);
+    });
 }
 export async function killAkumaOn(seam, input) {
     const values = requireInput(input, "Akumas.kill input");

package/build/src/plugin/public.d.ts

@@ -54,6 +54,11 @@ export type PluginSignalMap = Readonly<{
         historyId: string;
         observer?: string;
     }>;
+    "akuma.turn-started": Readonly<{
+        akumaId: string;
+        turnSequence: number;
+        initiator?: string;
+    }>;
     "akuma.turn-outcome": Readonly<{
         akumaId: string;
         bodySequence: number;

package/build/src/plugin/runtime.js

@@ -7,6 +7,7 @@ const DIAGNOSTIC_LIMIT = 500;
 const PLUGIN_ATTEMPT_TIMEOUT_MS = 5_000;
 const PLUGIN_NAMESPACE = "plugins";
 const SQUARE_PLUGIN_PACKAGE = "@astrosheep/keiyaku-plugin-square";
+const BUNDLED_PLUGIN_PACKAGES = new Set([SQUARE_PLUGIN_PACKAGE, "@astrosheep/keiyaku-plugin-paseo"]);
 const BUILTIN_PLUGINS = Object.freeze([
     Object.freeze({ id: "square", package: SQUARE_PLUGIN_PACKAGE, config: undefined }),
 ]);
@@ -206,6 +207,7 @@ const SIGNAL_KINDS = Object.freeze({
     "akuma.initiating": true,
     "akuma.born": true,
     "akuma.outcome-observed": true,
+    "akuma.turn-started": true,
     "akuma.turn-outcome": true,
     "akuma.body-ended": true,
 });
@@ -245,7 +247,7 @@ function sourceUrl(world, packageName) {
     return null;
 }
 async function importFromWorld(world, packageName) {
-    if (packageName === SQUARE_PLUGIN_PACKAGE)
+    if (BUNDLED_PLUGIN_PACKAGES.has(packageName))
         return (await import(packageName));
     const direct = sourceUrl(world, packageName);
     if (direct !== null)

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 {};

package/build/src/settlement/holder.js

@@ -4,20 +4,26 @@ import { contractId } from "../core/facts/types.js";
 import { GIT_REF, updateGitTree, updateRefsAtomically, writeBlob, writeStateCommit } from "../git/repository.js";
 import { confirmPrivateStatePublication } from "../git/private-state-seat.js";
 import { withGitTargetedReadObservation, } from "../git/read-observation.js";
-import { parseTaskId } from "../task/identity.js";
-import { acquireTaskSettlementFence } from "./fence.js";
+import { parseDebtId } from "../debt/identity.js";
+import { acquireDebtSettlementFence } from "./fence.js";
+// The private persisted spelling predates the product rename. Keep its bytes
+// and path stable so an existing held association still settles after upgrade.
 const HOLDER_ROOT = "settlement/task-holders";
 const HOLDER_PREFIX = `${HOLDER_ROOT}/`;
 const HOLDER_SUFFIX = ".json";
-export function taskHolderObservationSelection() {
+export function debtHolderObservationSelection() {
     return { subtrees: [HOLDER_ROOT] };
 }
-function holderPath(taskId) {
-    const digest = createHash("sha256").update(taskId).digest("hex");
+function storedIdentity(debtId) {
+    return `task/${debtId.slice("debt/".length)}`;
+}
+function holderPath(debtId) {
+    const digest = createHash("sha256").update(storedIdentity(debtId)).digest("hex");
     return `${HOLDER_PREFIX}${digest}${HOLDER_SUFFIX}`;
 }
 function canonicalBytes(holder) {
-    return Buffer.from(`${JSON.stringify(holder)}\n`);
+    const { version, debtId, contractId, disposition } = holder;
+    return Buffer.from(`${JSON.stringify({ version, taskId: storedIdentity(debtId), contractId, disposition })}\n`);
 }
 function corruption(message, cause) {
     throw new AuthorityCorruptionError(message, cause === undefined ? {} : { cause });
@@ -27,67 +33,67 @@ function decodeHolder(path, bytes) {
     try {
         const text = Buffer.from(bytes).toString("utf8");
         if (!text.endsWith("\n") || text.slice(0, -1).includes("\n"))
-            corruption(`TaskHolder is not one canonical JSON line: ${path}`);
+            corruption(`DebtHolder is not one canonical JSON line: ${path}`);
         value = JSON.parse(text);
     }
     catch (error) {
         if (error instanceof AuthorityCorruptionError)
             throw error;
-        return corruption(`invalid TaskHolder JSON: ${path}`, error);
+        return corruption(`invalid DebtHolder JSON: ${path}`, error);
     }
     if (typeof value !== "object" || value === null || Array.isArray(value))
-        corruption(`TaskHolder must be an object: ${path}`);
+        corruption(`DebtHolder must be an object: ${path}`);
     const record = value;
     const keys = Object.keys(record);
     if (keys.length !== 4 || keys.some((key) => !["version", "taskId", "contractId", "disposition"].includes(key))) {
-        corruption(`TaskHolder has invalid fields: ${path}`);
+        corruption(`DebtHolder has invalid fields: ${path}`);
     }
     if (record.version !== 1)
-        corruption(`TaskHolder version must be 1: ${path}`);
-    if (typeof record.taskId !== "string")
-        corruption(`TaskHolder taskId is invalid: ${path}`);
+        corruption(`DebtHolder version must be 1: ${path}`);
+    if (typeof record.taskId !== "string" || !record.taskId.startsWith("task/"))
+        corruption(`DebtHolder identity is invalid: ${path}`);
     if (typeof record.contractId !== "string")
-        corruption(`TaskHolder contractId is invalid: ${path}`);
-    let taskId;
+        corruption(`DebtHolder contractId is invalid: ${path}`);
+    let debtId;
     let owner;
     try {
-        parseTaskId(record.taskId);
-        taskId = record.taskId;
+        debtId = `debt/${record.taskId.slice("task/".length)}`;
+        parseDebtId(debtId);
         owner = contractId(record.contractId);
     }
     catch (error) {
-        return corruption(`TaskHolder identity is invalid: ${path}`, error);
+        return corruption(`DebtHolder identity is invalid: ${path}`, error);
     }
     if (record.disposition !== "held" && record.disposition !== "released") {
-        corruption(`TaskHolder disposition is invalid: ${path}`);
+        corruption(`DebtHolder disposition is invalid: ${path}`);
     }
-    const holder = { version: 1, taskId, contractId: owner, disposition: record.disposition };
-    if (holderPath(taskId) !== path)
-        corruption(`TaskHolder path does not match taskId: ${path}`);
+    const holder = { version: 1, debtId, contractId: owner, disposition: record.disposition };
+    if (holderPath(debtId) !== path)
+        corruption(`DebtHolder path does not match debtId: ${path}`);
     if (!Buffer.from(canonicalBytes(holder)).equals(Buffer.from(bytes)))
-        corruption(`TaskHolder bytes are not canonical: ${path}`);
+        corruption(`DebtHolder bytes are not canonical: ${path}`);
     return holder;
 }
-function projectTaskHolders(holders) {
+function projectDebtHolders(holders) {
     const projection = new Map();
     for (const holder of holders) {
         if (projection.has(holder.contractId)) {
-            corruption(`Contract has multiple current TaskHolders: ${holder.contractId}`);
+            corruption(`Contract has multiple current DebtHolders: ${holder.contractId}`);
         }
         projection.set(holder.contractId, holder);
     }
     return projection;
 }
 function update(holder) {
-    return { path: holderPath(holder.taskId), bytes: canonicalBytes(holder) };
+    return { path: holderPath(holder.debtId), bytes: canonicalBytes(holder) };
 }
-export function claimTaskHolder(taskId, owner) {
-    return update({ version: 1, taskId, contractId: owner, disposition: "held" });
+export function claimDebtHolder(debtId, owner) {
+    return update({ version: 1, debtId, contractId: owner, disposition: "held" });
 }
 function detail(error) {
     return error instanceof Error ? error.message : String(error);
 }
-function finishTaskHolderAdmission(taskId, result, close) {
+function finishDebtHolderAdmission(debtId, result, close) {
     try {
         close();
         return { kind: "completed", result };
@@ -95,11 +101,11 @@ function finishTaskHolderAdmission(taskId, result, close) {
     catch (error) {
         if (result.kind !== "accepted")
             throw error;
-        return { kind: "accepted-release-failed", result, taskId, diagnostic: detail(error) };
+        return { kind: "accepted-release-failed", result, debtId, diagnostic: detail(error) };
     }
 }
-export async function admitWithTaskHolderFence(repository, taskId, action) {
-    const held = await acquireTaskSettlementFence(repository, taskId);
+export async function admitWithDebtHolderFence(repository, debtId, action) {
+    const held = await acquireDebtSettlementFence(repository, debtId);
     let result;
     try {
         result = await action();
@@ -113,19 +119,19 @@ export async function admitWithTaskHolderFence(repository, taskId, action) {
         }
         throw error;
     }
-    return finishTaskHolderAdmission(taskId, result, () => held.close());
+    return finishDebtHolderAdmission(debtId, result, () => held.close());
 }
-export async function releaseTaskHolder(channel, observation, owner) {
-    const current = (await readTaskHolderProjectionFromDecision(channel, observation)).get(owner) ?? null;
+export async function releaseDebtHolder(channel, observation, owner) {
+    const current = (await readDebtHolderProjectionFromDecision(channel, observation)).get(owner) ?? null;
     return current === null || current.disposition !== "held" ? null : update({ ...current, disposition: "released" });
 }
 async function releasedHolderIsCurrent(repository, channel, owner, expected) {
-    const current = (await observeTaskHolderProjection(repository, channel)).get(owner) ?? null;
+    const current = (await observeDebtHolderProjection(repository, channel)).get(owner) ?? null;
     return current?.disposition === "released" && Buffer.from(canonicalBytes(current)).equals(expected);
 }
 /** Publish the released holder against the same frozen observation that decided the release. */
-export async function publishTaskHolderRelease(repository, channel, observation, owner, seat) {
-    const release = await releaseTaskHolder(channel, observation, owner);
+export async function publishDebtHolderRelease(repository, channel, observation, owner, seat) {
+    const release = await releaseDebtHolder(channel, observation, owner);
     if (release === null)
         return { kind: "not-held" };
     const tree = await updateGitTree(repository, observation.admission.snapshot.tree, new Map([[release.path, { oid: await writeBlob(repository, release.bytes) }]]));
@@ -133,7 +139,7 @@ export async function publishTaskHolderRelease(repository, channel, observation,
         repository,
         tree,
         parent: observation.admission.snapshot.commit,
-        message: `release held Task completion: ${owner}`,
+        message: `release held Debt completion: ${owner}`,
     });
     const publication = await updateRefsAtomically(repository, [
         {
@@ -154,10 +160,10 @@ export async function publishTaskHolderRelease(repository, channel, observation,
         kind: "non-published",
         diagnostic: publication.kind === "non-published"
             ? detail(publication.error)
-            : "Task holder release publication state is unknown",
+            : "Debt holder release publication state is unknown",
     };
 }
-export async function readTaskHolderProjectionFromDecision(channel, observation) {
+export async function readDebtHolderProjectionFromDecision(channel, observation) {
     const read = {
         snapshot: observation.admission.snapshot,
         readBlobs: async (oids) => {
@@ -168,29 +174,29 @@ export async function readTaskHolderProjectionFromDecision(channel, observation)
                     blobs.set(oid, object);
                 else {
                     if (object.type !== "blob")
-                        corruption(`TaskHolder Git object is not a blob: ${oid}`);
+                        corruption(`DebtHolder Git object is not a blob: ${oid}`);
                     blobs.set(oid, { kind: "present", bytes: object.bytes });
                 }
             }
             return blobs;
         },
     };
-    return projectTaskHolders(await readTaskHoldersAt(read));
+    return projectDebtHolders(await readDebtHoldersAt(read));
 }
-function observeTaskHolderProjection(repository, channel) {
-    return withGitTargetedReadObservation(repository, channel, taskHolderObservationSelection(), readTaskHolderProjectionAt);
+function observeDebtHolderProjection(repository, channel) {
+    return withGitTargetedReadObservation(repository, channel, debtHolderObservationSelection(), readDebtHolderProjectionAt);
 }
-async function heldTaskForContract(repository, channel, owner) {
-    const holder = (await observeTaskHolderProjection(repository, channel)).get(owner) ?? null;
-    return holder?.disposition === "held" ? holder.taskId : null;
+async function heldDebtForContract(repository, channel, owner) {
+    const holder = (await observeDebtHolderProjection(repository, channel)).get(owner) ?? null;
+    return holder?.disposition === "held" ? holder.debtId : null;
 }
-export async function releaseTaskHolderWithFence(repository, channel, owner, action) {
-    const taskId = await heldTaskForContract(repository, channel, owner);
-    return taskId === null
+export async function releaseDebtHolderWithFence(repository, channel, owner, action) {
+    const debtId = await heldDebtForContract(repository, channel, owner);
+    return debtId === null
         ? { kind: "completed", result: await action() }
-        : admitWithTaskHolderFence(repository, taskId, action);
+        : admitWithDebtHolderFence(repository, debtId, action);
 }
-export async function readTaskHoldersAt(observation) {
+export async function readDebtHoldersAt(observation) {
     const entries = [...observation.snapshot.paths].filter(([path, entry]) => path.startsWith(HOLDER_PREFIX) && entry.type === "blob");
     const blobs = await observation.readBlobs(entries.map(([, entry]) => entry.oid));
     const holders = [];
@@ -198,26 +204,26 @@ export async function readTaskHoldersAt(observation) {
     for (const [path, entry] of observation.snapshot.paths) {
         if (path === HOLDER_ROOT) {
             if (entry.type !== "tree")
-                corruption(`TaskHolder authority root is not a tree: ${path}`);
+                corruption(`DebtHolder authority root is not a tree: ${path}`);
             continue;
         }
         if (!path.startsWith(HOLDER_PREFIX))
             continue;
         if (!path.endsWith(HOLDER_SUFFIX))
-            corruption(`unexpected TaskHolder authority path: ${path}`);
+            corruption(`unexpected DebtHolder authority path: ${path}`);
         if (entry.type !== "blob")
-            corruption(`TaskHolder path is not a blob: ${path}`);
+            corruption(`DebtHolder path is not a blob: ${path}`);
         const result = blobs.get(entry.oid);
         if (result?.kind !== "present")
-            corruption(`missing TaskHolder Git object: ${path}`);
+            corruption(`missing DebtHolder Git object: ${path}`);
         const holder = decodeHolder(path, result.bytes);
-        if (seen.has(holder.taskId))
-            corruption(`duplicate TaskHolder identity: ${holder.taskId}`);
-        seen.add(holder.taskId);
+        if (seen.has(holder.debtId))
+            corruption(`duplicate DebtHolder identity: ${holder.debtId}`);
+        seen.add(holder.debtId);
         holders.push(holder);
     }
-    return holders.sort((left, right) => Buffer.compare(Buffer.from(left.taskId), Buffer.from(right.taskId)));
+    return holders.sort((left, right) => Buffer.compare(Buffer.from(left.debtId), Buffer.from(right.debtId)));
 }
-export async function readTaskHolderProjectionAt(observation) {
-    return projectTaskHolders(await readTaskHoldersAt(observation));
+export async function readDebtHolderProjectionAt(observation) {
+    return projectDebtHolders(await readDebtHoldersAt(observation));
 }

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

@@ -5,19 +5,19 @@ import type { GitDecodeChannel } from "../git/read-observation.js";
 import type { Effect } from "../git/reconcile.js";
 import { type GitRepository } from "../git/process.js";
 export declare const settlementActionSchema: z.ZodObject<{
-    kind: z.ZodLiteral<"task">;
-    taskId: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
+    kind: z.ZodLiteral<"debt">;
+    debtId: z.ZodPipe<z.ZodString, z.ZodTransform<`debt/${string}`, string>>;
     action: z.ZodLiteral<"done">;
 }, z.core.$strict>;
 export type SettlementAction = z.infer<typeof settlementActionSchema>;
 export declare const settlementLagSchema: z.ZodObject<{
     kind: z.ZodLiteral<"settlement-failed">;
     surface: z.ZodEnum<{
-        task: "task";
-        "task-holder": "task-holder";
+        debt: "debt";
+        "debt-holder": "debt-holder";
     }>;
     contractId: z.ZodPipe<z.ZodString, z.ZodTransform<ContractId, string>>;
-    taskId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
+    debtId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`debt/${string}`, string>>>;
     path: z.ZodOptional<z.ZodString>;
     diagnostic: z.ZodString;
 }, z.core.$strict>;