@astrosheep/keiyaku 4.6.8 → 4.6.9

package/build/src/debt/mutation.js

@@ -0,0 +1,223 @@
+import { World } from "../world.js";
+import { requestBodyCommand } from "../akuma/request-rendezvous.js";
+import { eraseRequestCommand, } from "../akuma/request-wire.js";
+import { debtIdsSchema, debtNamespaceSchema } from "./identity.js";
+import { debtNonblankTextSchema, debtStateSchema, debtPrioritySchema } from "./document.js";
+import { debtBatchResultSchema, debtMutationIdSchema, debtMutationResultSchema, debtUpdateResultSchema, } from "./mutation-result.js";
+import { z } from "zod";
+export const DEBT_MUTATION_ACTIONS = Object.freeze([
+    "debt.add",
+    "debt.addDocument",
+    "debt.done",
+    "debt.drop",
+    "debt.update",
+]);
+const debtMutationActionSchema = z.enum(DEBT_MUTATION_ACTIONS);
+const nonemptyDebtIdsSchema = debtIdsSchema.unwrap().min(1).readonly();
+const addInputSchema = z
+    .object({
+    title: debtNonblankTextSchema,
+    namespace: debtNamespaceSchema,
+    body: z.string().optional(),
+    note: z.string().optional(),
+    state: debtStateSchema.optional(),
+    priority: debtPrioritySchema.optional(),
+    needs: debtIdsSchema.optional(),
+    parent: debtMutationIdSchema.nullable().optional(),
+    supersedes: debtIdsSchema.optional(),
+    relates: debtIdsSchema.optional(),
+})
+    .strict();
+const updateInputSchema = z
+    .object({
+    title: debtNonblankTextSchema.optional(),
+    body: z.string().optional(),
+    appendBody: z.string().optional(),
+    note: z.string().optional(),
+    priority: debtPrioritySchema.optional(),
+    needs: debtIdsSchema.optional(),
+    addNeeds: debtIdsSchema.optional(),
+    dropNeeds: debtIdsSchema.optional(),
+    parent: debtMutationIdSchema.nullable().optional(),
+    supersedes: debtIdsSchema.optional(),
+    addSupersedes: debtIdsSchema.optional(),
+    dropSupersedes: debtIdsSchema.optional(),
+    relates: debtIdsSchema.optional(),
+    addRelates: debtIdsSchema.optional(),
+    dropRelates: debtIdsSchema.optional(),
+})
+    .strict()
+    .superRefine((input, context) => {
+    if (input.body !== undefined && input.appendBody !== undefined)
+        context.addIssue({ code: "custom", message: "body and appendBody are mutually exclusive" });
+    if (Object.values(input).every((value) => value === undefined))
+        context.addIssue({ code: "custom", message: "update requires at least one field change" });
+});
+const addRequestSchema = z
+    .object({ input: addInputSchema })
+    .strict()
+    .transform(({ input }) => ({ action: "debt.add", input }));
+const addDocumentRequestSchema = z
+    .object({ input: z.object({ markdown: z.string(), namespace: debtNamespaceSchema }).strict() })
+    .strict()
+    .transform(({ input }) => ({ action: "debt.addDocument", input }));
+const updateRequestSchema = z
+    .object({ id: debtMutationIdSchema, input: updateInputSchema })
+    .strict()
+    .transform((request) => ({ action: "debt.update", ...request }));
+const terminalRequestSchema = (action) => z.union([
+    z
+        .object({ id: debtMutationIdSchema, note: z.string().optional() })
+        .strict()
+        .transform(({ id, note }) => ({ action, id, ...(note === undefined ? {} : { note }) })),
+    z
+        .object({ ids: nonemptyDebtIdsSchema, note: z.string().optional() })
+        .strict()
+        .transform(({ ids, note }) => ({ action, ids, ...(note === undefined ? {} : { note }) })),
+]);
+const debtRequestSchemas = {
+    "debt.add": addRequestSchema,
+    "debt.addDocument": addDocumentRequestSchema,
+    "debt.done": terminalRequestSchema("debt.done"),
+    "debt.drop": terminalRequestSchema("debt.drop"),
+    "debt.update": updateRequestSchema,
+};
+const worldPathSchema = z.string().min(1);
+const debtBodyRequestSchema = z
+    .object({ world: worldPathSchema, request: z.union(Object.values(debtRequestSchemas)) })
+    .strict();
+const debtMutationServiceSchema = z.object({ action: debtMutationActionSchema }).strict();
+export const forwardedDebtReferenceSchema = z
+    .object({ kind: z.literal("served-reference"), action: debtMutationActionSchema })
+    .strict();
+function decodeDebtBodyRequest(action, value) {
+    const parsed = debtBodyRequestSchema.extend({ request: debtRequestSchemas[action] }).safeParse(value);
+    return parsed.success ? parsed.data : null;
+}
+function decodeDebtService(action, value) {
+    const parsed = debtMutationServiceSchema.safeParse(value);
+    if (!parsed.success || parsed.data.action !== action)
+        throw new Error(`malformed stored Debt service evidence for ${action}`);
+    return parsed.data;
+}
+function decodeDebtReference(action, value) {
+    const parsed = forwardedDebtReferenceSchema.safeParse(value);
+    if (!parsed.success || parsed.data.action !== action)
+        throw new Error(`malformed Debt service reference for ${action}`);
+    return parsed.data;
+}
+/** Debt owns forwarded mutation payload, live result, and durable service evidence. */
+export function debtMutationRequestProtocol(action, batch) {
+    return {
+        action,
+        encodeRequest: (input) => {
+            const { action: _action, ...request } = input.request;
+            return { world: input.world, request };
+        },
+        decodeRequest: (value) => decodeDebtBodyRequest(action, value),
+        encodeResult: (result) => result,
+        decodeResult: (result) => {
+            const schema = action === "debt.update"
+                ? debtUpdateResultSchema
+                : batch === undefined
+                    ? z.union([debtMutationResultSchema, debtBatchResultSchema])
+                    : batch
+                        ? debtBatchResultSchema
+                        : debtMutationResultSchema;
+            const parsed = schema.safeParse(result);
+            if (!parsed.success)
+                throw new Error(`transport integrity: Debt ${action} returned an invalid live result`);
+            return parsed.data;
+        },
+        decodeReference: (reference) => decodeDebtReference(action, reference),
+        isPermitted: (allowed) => allowed.includes(action),
+    };
+}
+export function debtMutationRequestCommand(action, port) {
+    return {
+        completion: "service",
+        protocol: debtMutationRequestProtocol(action),
+        encodeService: (service) => service,
+        decodeService: (service) => decodeDebtService(action, service),
+        projectService: (service) => ({ kind: "served-reference", action: service.action }),
+        execute: async (request, facts) => {
+            const world = await World.prove(request.world);
+            const action = request.request.action;
+            let result;
+            switch (action) {
+                case "debt.add":
+                    result = await port.add({
+                        world,
+                        options: addDebtOptions(request.request.input, facts.requester, facts.signal),
+                    });
+                    break;
+                case "debt.addDocument":
+                    result = await port.addDocument({
+                        world,
+                        document: { ...request.request.input, actor: facts.requester, signal: facts.signal },
+                    });
+                    break;
+                case "debt.update":
+                    result = await port.update({
+                        world,
+                        id: request.request.id,
+                        options: updateDebtOptions(request.request.input, facts.signal),
+                    });
+                    break;
+                case "debt.done":
+                case "debt.drop": {
+                    const verb = action.slice("debt.".length);
+                    const note = "note" in request.request ? request.request.note : undefined;
+                    result =
+                        "ids" in request.request
+                            ? await port.batch({
+                                world,
+                                verb,
+                                ids: request.request.ids,
+                                ...(note === undefined ? {} : { note }),
+                                signal: facts.signal,
+                            })
+                            : await port.lifecycle({
+                                world,
+                                verb,
+                                id: request.request.id,
+                                ...(note === undefined ? {} : { note }),
+                                signal: facts.signal,
+                            });
+                    break;
+                }
+            }
+            return { kind: "served", result, service: { action } };
+        },
+    };
+}
+export function debtMutationRequestCommands(port) {
+    return Object.fromEntries(DEBT_MUTATION_ACTIONS.map((action) => [action, eraseRequestCommand(debtMutationRequestCommand(action, port))]));
+}
+export async function requestForwardedDebt(input) {
+    const response = await requestBodyCommand({
+        directory: input.directory,
+        ...(input.id === undefined ? {} : { id: input.id }),
+        command: debtMutationRequestProtocol(input.request.action, "ids" in input.request),
+        value: { world: input.world, request: input.request },
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+    });
+    if (response.kind === "reference")
+        return response.reference;
+    return response.result;
+}
+/** Absent optional fields are omitted, never republished as an explicit undefined. */
+function definedFields(fields, additions = {}) {
+    const selected = {};
+    for (const [key, value] of Object.entries({ ...fields, ...additions })) {
+        if (value !== undefined)
+            selected[key] = value;
+    }
+    return selected;
+}
+function addDebtOptions(input, actor, signal) {
+    return definedFields(input, { actor, signal });
+}
+function updateDebtOptions(input, signal) {
+    return definedFields(input, { signal });
+}

package/build/src/debt/operation-types.d.ts

@@ -0,0 +1,71 @@
+import type { DebtPriority, DebtState } from "./document.js";
+import type { DebtId } from "./identity.js";
+import type { DebtCleanupFailure, DebtRefusal, DebtRetry, DebtView } from "./mutation-result.js";
+export type { DebtView, DebtCleanupFailure, DebtRefusal, DebtRetry, DebtMutationResult, DebtUpdateResult, DebtBatchResult, } from "./mutation-result.js";
+export type DebtOutcome<A> = Readonly<{
+    kind: "accepted";
+    value: A;
+    cleanup?: DebtCleanupFailure;
+}> | Readonly<{
+    kind: "refused";
+    refusal: DebtRefusal;
+}> | Readonly<{
+    kind: "retry";
+    reason: DebtRetry;
+}>;
+export type DebtLifecycleVerb = Extract<DebtRefusal, {
+    kind: "invalid-lifecycle-transition";
+}>["verb"];
+export type SettledDebtAction = "done";
+export type SettledDebtResult = Readonly<{
+    kind: "changed";
+    debt: DebtView;
+    action: SettledDebtAction;
+    cleanup?: DebtCleanupFailure;
+}> | Readonly<{
+    kind: "unchanged";
+}> | Readonly<{
+    kind: "refused";
+    refusal: DebtRefusal;
+}> | Readonly<{
+    kind: "retry";
+    reason: DebtRetry;
+}>;
+export type AddDebtInput = Readonly<{
+    title: string;
+    namespace?: readonly string[];
+    body?: string;
+    note?: string;
+    state?: DebtState;
+    priority?: DebtPriority;
+    needs?: readonly DebtId[];
+    parent?: DebtId | null;
+    supersedes?: readonly DebtId[];
+    relates?: readonly DebtId[];
+    actor?: string;
+    signal?: AbortSignal;
+}>;
+export type AddDebtDocumentInput = Readonly<{
+    markdown: string;
+    namespace?: readonly string[];
+    actor?: string;
+    signal?: AbortSignal;
+}>;
+export type UpdateDebtInput = Readonly<{
+    title?: string;
+    body?: string;
+    appendBody?: string;
+    note?: string;
+    priority?: DebtPriority;
+    needs?: readonly DebtId[];
+    addNeeds?: readonly DebtId[];
+    dropNeeds?: readonly DebtId[];
+    parent?: DebtId | null;
+    supersedes?: readonly DebtId[];
+    addSupersedes?: readonly DebtId[];
+    dropSupersedes?: readonly DebtId[];
+    relates?: readonly DebtId[];
+    addRelates?: readonly DebtId[];
+    dropRelates?: readonly DebtId[];
+    signal?: AbortSignal;
+}>;

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

@@ -0,0 +1,28 @@
+import { type BlockedDebtRow, type DebtBoardObservation, type DebtDetailFacts, type DebtRow } from "./board.js";
+import { type DebtId } from "./identity.js";
+import type { WorldRoot } from "../world.js";
+import { type DebtPage, type DebtQueryExpression, type DebtQueryRow, type DebtQuerySort } from "./query.js";
+export { debtView } from "./view.js";
+export type { AddDebtDocumentInput, AddDebtInput, DebtCleanupFailure, SettledDebtResult, DebtBatchResult, DebtMutationResult, DebtOutcome, DebtRefusal, DebtRetry, DebtUpdateResult, DebtView, UpdateDebtInput, } from "./operation-types.js";
+import type { AddDebtDocumentInput, AddDebtInput, DebtMutationResult, DebtOutcome, DebtUpdateResult, UpdateDebtInput } from "./operation-types.js";
+export declare function nukeDebt(world: WorldRoot, options?: Readonly<{
+    timeoutMs?: number;
+    onRemoved?(count: number): void;
+}>): Promise<number>;
+export declare function addDebt(world: WorldRoot, input: AddDebtInput): Promise<DebtMutationResult>;
+export declare function addDebtDocument(world: WorldRoot, input: AddDebtDocumentInput): Promise<DebtMutationResult>;
+export declare function updateDebt(world: WorldRoot, id: DebtId, input: UpdateDebtInput): Promise<DebtUpdateResult>;
+export { batchDebts, lifecycleDebt, settleDebt } from "./lifecycle-operations.js";
+export declare function listDebts(world: WorldRoot, namespace: readonly string[] | undefined, selection: "active" | "closed" | "all", scope?: "namespace" | "world", limit?: number): Promise<DebtOutcome<DebtPage<DebtRow>>>;
+export declare function readDebtDetail(world: WorldRoot, id: DebtId): Promise<DebtDetailFacts | null>;
+export declare function readyDebts(world: WorldRoot, namespace: readonly string[] | undefined, scope?: "namespace" | "world", parent?: DebtId, limit?: number): Promise<DebtOutcome<DebtPage<DebtRow>>>;
+export declare function blockedDebts(world: WorldRoot, namespace: readonly string[] | undefined, scope?: "namespace" | "world", parent?: DebtId, limit?: number): Promise<DebtOutcome<DebtPage<BlockedDebtRow>>>;
+export declare function queryDebts(input: Readonly<{
+    world: WorldRoot;
+    namespace?: readonly string[];
+    expression: DebtQueryExpression;
+    scope?: "namespace" | "world";
+    sort?: DebtQuerySort;
+    limit?: number;
+}>): Promise<DebtOutcome<DebtPage<DebtQueryRow>>>;
+export declare function observeDebtBoard(world: WorldRoot): Promise<DebtBoardObservation>;

package/build/src/{task → debt}/operations.js

@@ -1,17 +1,17 @@
 import { SqliteTransactionLockError } from "../coordination/sqlite-transaction-lock.js";
 import { documentDiff } from "../markdown/diff.js";
-import { createTaskRelations, projectOwnedDetailFacts, projectTaskBoardObservation, relationProblem, projectBlocked, projectRows, occupiedLocalIds, } from "./board.js";
-import { parseTaskCreationDocument, serializeTaskDocument, } from "./document.js";
-import { allocateLocalId, deriveLocalStem, formatTaskId } from "./identity.js";
-import { nukeTaskAuthority, readBoard, readTaskDocument, replaceAuthority, withTaskLocks } from "./store.js";
+import { createDebtRelations, projectOwnedDetailFacts, projectDebtBoardObservation, relationProblem, projectBlocked, projectRows, occupiedLocalIds, } from "./board.js";
+import { parseDebtCreationDocument, serializeDebtDocument, } from "./document.js";
+import { allocateLocalId, deriveLocalStem, formatDebtId } from "./identity.js";
+import { nukeDebtAuthority, readBoard, readDebtDocument, replaceAuthority, withDebtLocks } from "./store.js";
 import { boundedListLimit, projectBoundedList } from "../bounded-list.js";
 import { projectQuery, projectQueryRows, queryUnderTargets, underExpression, } from "./query.js";
-import { advanceTaskTimestamp, taskView } from "./view.js";
-export { advanceTaskTimestamp, taskView } from "./view.js";
-export async function nukeTask(world, options) {
-    const result = await nukeTaskAuthority(world, options);
+import { advanceDebtTimestamp, debtView } from "./view.js";
+export { debtView } from "./view.js";
+export async function nukeDebt(world, options) {
+    const result = await nukeDebtAuthority(world, options);
     if (result === "busy")
-        throw new SqliteTransactionLockError("Task reset lock contention", "timeout");
+        throw new SqliteTransactionLockError("Debt reset lock contention", "timeout");
     return result;
 }
 function refused(refusal) {
@@ -23,26 +23,25 @@ function retry(reason) {
 function currentTimestamp() {
     return new Date().toISOString();
 }
-/** Internal Task timestamp rule shared by ordinary mutations and compose. */
 function addDocument(base, namespace, board, at, actor) {
     const localId = allocateLocalId(deriveLocalStem(base.title), occupiedLocalIds(board, namespace));
     return {
         ...base,
-        id: formatTaskId({ namespace, localId }),
+        id: formatDebtId({ namespace, localId }),
         ...(actor === undefined ? {} : { createdBy: actor }),
         createdAt: at,
         updatedAt: at,
     };
 }
 function boardWith(board, document) {
-    const tasks = new Map(board.tasks);
-    tasks.set(document.id, document);
-    return { tasks };
+    const debts = new Map(board.debts);
+    debts.set(document.id, document);
+    return { debts };
 }
 async function create(world, base, namespace, signal, actor) {
     let result;
     try {
-        result = await withTaskLocks({ world, allocation: true, ids: [], ...(signal === undefined ? {} : { signal }) }, async () => {
+        result = await withDebtLocks({ world, allocation: true, ids: [], ...(signal === undefined ? {} : { signal }) }, async () => {
             const snapshot = await readBoard(world), next = addDocument(base, namespace, snapshot.board, currentTimestamp(), actor);
             const problem = relationProblem(boardWith(snapshot.board, next), null, next);
             if (problem !== null)
@@ -51,22 +50,22 @@ async function create(world, base, namespace, signal, actor) {
                 world,
                 id: next.id,
                 expected: null,
-                next: serializeTaskDocument(next),
+                next: serializeDebtDocument(next),
             });
             return replaced === "replaced"
-                ? { kind: "accepted", value: taskView(next) }
+                ? { kind: "accepted", value: debtView(next) }
                 : retry("concurrent-modification");
         });
     }
     catch (error) {
         if (error instanceof TypeError &&
-            /task identity (?:cannot fit the physical filename budget|contains a Windows-reserved physical segment)/u.test(error.message))
+            /debt identity (?:cannot fit the physical filename budget|contains a Windows-reserved physical segment)/u.test(error.message))
             return refused({ kind: "invalid-namespace-context", path: namespace.join("/") });
         throw error;
     }
     return result === "busy" ? retry("busy") : result;
 }
-export async function addTask(world, input) {
+export async function addDebt(world, input) {
     const namespace = input.namespace ?? [];
     return create(world, {
         title: input.title,
@@ -80,9 +79,9 @@ export async function addTask(world, input) {
         relates: input.relates ?? [],
     }, namespace, input.signal, input.actor);
 }
-export async function addTaskDocument(world, input) {
+export async function addDebtDocument(world, input) {
     const namespace = input.namespace ?? [];
-    return create(world, parseTaskCreationDocument(input.markdown), namespace, input.signal, input.actor);
+    return create(world, parseDebtCreationDocument(input.markdown), namespace, input.signal, input.actor);
 }
 function listChange(current, replacement, additions, removals) {
     const next = [...(replacement ?? current)];
@@ -92,9 +91,9 @@ function listChange(current, replacement, additions, removals) {
     return next.filter((id) => !(removals ?? []).includes(id));
 }
 function relatedOwner(board, id, target) {
-    return board.tasks.get(target)?.relates.includes(id) ? target : null;
+    return board.debts.get(target)?.relates.includes(id) ? target : null;
 }
-function appendTaskBody(current, addition) {
+function appendDebtBody(current, addition) {
     if (current.length === 0 || addition.length === 0 || current.endsWith("\n") || addition.startsWith("\n")) {
         return current + addition;
     }
@@ -105,12 +104,12 @@ function updateDocument(board, current, input) {
         if (!current.relates.includes(related)) {
             const owner = relatedOwner(board, current.id, related);
             if (owner !== null)
-                return { kind: "relation-owned-by-other", taskId: current.id, related, declaringTask: owner };
+                return { kind: "relation-owned-by-other", debtId: current.id, related, declaringDebt: owner };
         }
     return {
         ...current,
         ...(input.title === undefined ? {} : { title: input.title }),
-        body: input.body ?? (input.appendBody === undefined ? current.body : appendTaskBody(current.body, input.appendBody)),
+        body: input.body ?? (input.appendBody === undefined ? current.body : appendDebtBody(current.body, input.appendBody)),
         ...(input.note === undefined ? {} : { note: input.note }),
         ...(input.priority === undefined ? {} : { priority: input.priority }),
         needs: listChange(current.needs, input.needs, input.addNeeds, input.dropNeeds),
@@ -141,11 +140,11 @@ function updateFieldChanges(current, next, input) {
     }
     return changes;
 }
-export async function updateTask(world, id, input) {
-    const result = await withTaskLocks({ world, allocation: false, ids: [id], ...(input.signal === undefined ? {} : { signal: input.signal }) }, async () => {
-        const snapshot = await readBoard(world), current = snapshot.board.tasks.get(id);
+export async function updateDebt(world, id, input) {
+    const result = await withDebtLocks({ world, allocation: false, ids: [id], ...(input.signal === undefined ? {} : { signal: input.signal }) }, async () => {
+        const snapshot = await readBoard(world), current = snapshot.board.debts.get(id);
         if (current === undefined)
-            return { kind: "refused", refusal: { kind: "task-missing", taskId: id } };
+            return { kind: "refused", refusal: { kind: "debt-missing", debtId: id } };
         const candidate = updateDocument(snapshot.board, current, input);
         if ("kind" in candidate)
             return { kind: "refused", refusal: candidate };
@@ -154,13 +153,13 @@ export async function updateTask(world, id, input) {
             return { kind: "refused", refusal: { kind: "invalid-graph", diagnostic: problem } };
         const predecessor = snapshot.bytes.get(id);
         const before = Buffer.from(predecessor).toString("utf8");
-        const changed = !Buffer.from(serializeTaskDocument(candidate)).equals(Buffer.from(predecessor));
+        const changed = !Buffer.from(serializeDebtDocument(candidate)).equals(Buffer.from(predecessor));
         let next = candidate;
         if (changed) {
             const at = currentTimestamp();
-            next = { ...candidate, updatedAt: advanceTaskTimestamp(current.updatedAt, at) };
+            next = { ...candidate, updatedAt: advanceDebtTimestamp(current.updatedAt, at) };
         }
-        const afterBytes = serializeTaskDocument(next);
+        const afterBytes = serializeDebtDocument(next);
         const after = Buffer.from(afterBytes).toString("utf8");
         if (before !== after &&
             (await replaceAuthority({ world, id, expected: predecessor, next: afterBytes })) !== "replaced") {
@@ -170,7 +169,7 @@ export async function updateTask(world, id, input) {
         return {
             kind: "accepted",
             value: {
-                task: taskView(next),
+                debt: debtView(next),
                 documentDiff: documentDiff(label, label, before, after),
                 changedFields: updateFieldChanges(current, next, input),
             },
@@ -178,45 +177,45 @@ export async function updateTask(world, id, input) {
     });
     return result === "busy" ? { kind: "retry", reason: "busy" } : result;
 }
-export { batchTasks, lifecycleTask, settleTask } from "./lifecycle-operations.js";
+export { batchDebts, lifecycleDebt, settleDebt } from "./lifecycle-operations.js";
 function readScope(namespace, scope) {
     return scope === "world" ? null : (namespace ?? []);
 }
-export async function listTasks(world, namespace, selection, scope, limit) {
+export async function listDebts(world, namespace, selection, scope, limit) {
     const selectedLimit = boundedListLimit(limit);
     const selected = readScope(namespace, scope);
     const board = (await readBoard(world)).board;
     return {
         kind: "accepted",
-        value: projectBoundedList(projectRows(board, createTaskRelations(board), selected, selection), selectedLimit),
+        value: projectBoundedList(projectRows(board, createDebtRelations(board), selected, selection), selectedLimit),
     };
 }
-export async function readTaskDetail(world, id) {
-    const task = await readTaskDocument(world, id);
-    if (task === undefined)
+export async function readDebtDetail(world, id) {
+    const debt = await readDebtDocument(world, id);
+    if (debt === undefined)
         return null;
-    const selected = new Map([[id, task]]);
+    const selected = new Map([[id, debt]]);
     const references = [
-        ...task.needs,
-        ...(task.parent === null ? [] : [task.parent]),
-        ...task.supersedes,
-        ...task.relates,
+        ...debt.needs,
+        ...(debt.parent === null ? [] : [debt.parent]),
+        ...debt.supersedes,
+        ...debt.relates,
     ];
     for (const reference of references) {
         if (selected.has(reference))
             continue;
-        const document = await readTaskDocument(world, reference);
+        const document = await readDebtDocument(world, reference);
         if (document !== undefined)
             selected.set(reference, document);
     }
-    return projectOwnedDetailFacts({ tasks: selected }, id);
+    return projectOwnedDetailFacts({ debts: selected }, id);
 }
 /** One board observation and predicate projection shared by the ready and blocked views. */
-async function readTaskQueryContext(input) {
+async function readDebtQueryContext(input) {
     const board = (await readBoard(input.world)).board;
-    if (input.parent !== undefined && !board.tasks.has(input.parent))
-        return { kind: "refused", refusal: { kind: "task-missing", taskId: input.parent } };
-    const relations = createTaskRelations(board);
+    if (input.parent !== undefined && !board.debts.has(input.parent))
+        return { kind: "refused", refusal: { kind: "debt-missing", debtId: input.parent } };
+    const relations = createDebtRelations(board);
     const scope = readScope(input.namespace, input.scope);
     const predicate = {
         kind: "predicate",
@@ -236,15 +235,15 @@ async function readTaskQueryContext(input) {
         },
     };
 }
-export async function readyTasks(world, namespace, scope, parent, limit) {
-    const queried = await readTaskQueryContext({ world, field: "ready", namespace, scope, parent, limit });
+export async function readyDebts(world, namespace, scope, parent, limit) {
+    const queried = await readDebtQueryContext({ world, field: "ready", namespace, scope, parent, limit });
     if (queried.kind !== "accepted")
         return queried;
     const rows = queried.value.rows.map(({ parent: _parent, needs: _needs, blocks: _blocks, createdAt: _createdAt, ...row }) => row);
     return { kind: "accepted", value: projectBoundedList(rows, queried.value.limit) };
 }
-export async function blockedTasks(world, namespace, scope, parent, limit) {
-    const queried = await readTaskQueryContext({ world, field: "blocked", namespace, scope, parent, limit });
+export async function blockedDebts(world, namespace, scope, parent, limit) {
+    const queried = await readDebtQueryContext({ world, field: "blocked", namespace, scope, parent, limit });
     if (queried.kind !== "accepted")
         return queried;
     const { board, scope: selected, relations, limit: selectedLimit, rows } = queried.value;
@@ -254,14 +253,14 @@ export async function blockedTasks(world, namespace, scope, parent, limit) {
         value: projectBoundedList(projectBlocked(board, selected, relations).filter((row) => ids.has(row.id)), selectedLimit),
     };
 }
-export async function queryTasks(input) {
+export async function queryDebts(input) {
     const selectedLimit = boundedListLimit(input.limit);
     const selected = readScope(input.namespace, input.scope);
     const board = (await readBoard(input.world)).board;
-    const relations = createTaskRelations(board);
+    const relations = createDebtRelations(board);
     for (const target of queryUnderTargets(input.expression))
-        if (!board.tasks.has(target)) {
-            return { kind: "refused", refusal: { kind: "task-missing", taskId: target } };
+        if (!board.debts.has(target)) {
+            return { kind: "refused", refusal: { kind: "debt-missing", debtId: target } };
         }
     return {
         kind: "accepted",
@@ -273,6 +272,6 @@ export async function queryTasks(input) {
         }),
     };
 }
-export async function observeTaskBoard(world) {
-    return projectTaskBoardObservation((await readBoard(world)).board);
+export async function observeDebtBoard(world) {
+    return projectDebtBoardObservation((await readBoard(world)).board);
 }