@astrosheep/keiyaku 4.6.7 → 4.6.9

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

@@ -0,0 +1,160 @@
+import { type DebtDocument, type DebtPriority, type DebtState } from "./document.js";
+import { type DebtId } from "./identity.js";
+import { z } from "zod";
+import { type BoundedList } from "../bounded-list.js";
+export type DebtRef = Readonly<{
+    id: DebtId;
+    title: string | null;
+    state: DebtState | "missing";
+}>;
+export declare const debtRowSchema: z.ZodObject<{
+    id: z.ZodPipe<z.ZodString, z.ZodTransform<`debt/${string}`, string>>;
+    title: z.ZodString;
+    state: z.ZodEnum<{
+        open: "open";
+        done: "done";
+        drop: "drop";
+    }>;
+    priority: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
+    disposition: z.ZodEnum<{
+        done: "done";
+        drop: "drop";
+        ready: "ready";
+        blocked: "blocked";
+    }>;
+    updatedAt: z.ZodString;
+    bodyPresent: z.ZodBoolean;
+    children: z.ZodOptional<z.ZodObject<{
+        live: z.ZodNumber;
+        total: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const debtRowsSchema: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+    id: z.ZodPipe<z.ZodString, z.ZodTransform<`debt/${string}`, string>>;
+    title: z.ZodString;
+    state: z.ZodEnum<{
+        open: "open";
+        done: "done";
+        drop: "drop";
+    }>;
+    priority: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
+    disposition: z.ZodEnum<{
+        done: "done";
+        drop: "drop";
+        ready: "ready";
+        blocked: "blocked";
+    }>;
+    updatedAt: z.ZodString;
+    bodyPresent: z.ZodBoolean;
+    children: z.ZodOptional<z.ZodObject<{
+        live: z.ZodNumber;
+        total: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>>>;
+export type DebtDisposition = z.infer<typeof debtRowSchema>["disposition"];
+export type DebtRow = z.infer<typeof debtRowSchema>;
+export type BlockedDebtRow = DebtRow & Readonly<{
+    blockers: readonly DebtRef[];
+}>;
+export type DebtDetailFacts = Readonly<{
+    debt: DebtDocument;
+    needs: readonly (DebtRef & Readonly<{
+        released: boolean;
+    }>)[];
+    blockers: readonly DebtRef[];
+    blocks: readonly DebtRef[];
+    parent: DebtRef | null;
+    children: readonly DebtRef[];
+    supersedes: readonly DebtRef[];
+    supersededBy: readonly DebtRef[];
+    related: readonly DebtRef[];
+}>;
+export type DebtTreeNode = Readonly<{
+    debt: DebtRef & Readonly<{
+        priority: DebtPriority | null;
+    }>;
+    cycle?: true;
+    children: readonly DebtTreeNode[];
+}>;
+export type DebtBoard = Readonly<{
+    debts: ReadonlyMap<DebtId, DebtDocument>;
+}>;
+/** The local ids occupied across one namespace of the current board. */
+export declare function occupiedLocalIds(board: DebtBoard, namespace: readonly string[]): Set<string>;
+type DebtRelation = "needs" | "parent" | "supersedes" | "relates";
+export type DebtDoctorIssue = Readonly<{
+    kind: "missing-target";
+    debtId: DebtId;
+    relation: DebtRelation;
+    target: DebtId;
+}> | Readonly<{
+    kind: "self-relation";
+    debtId: DebtId;
+    relation: DebtRelation;
+}> | Readonly<{
+    kind: "cycle";
+    relation: "needs" | "parent" | "supersedes";
+    debts: readonly DebtId[];
+}>;
+export declare function debtRef(board: DebtBoard, id: DebtId): DebtRef;
+export type DebtRelationProjection = Readonly<{
+    children(id: DebtId): readonly DebtRef[];
+    blocks(id: DebtId): readonly DebtRef[];
+    supersededBy(id: DebtId): readonly DebtRef[];
+    related(id: DebtId): readonly DebtRef[];
+}>;
+export declare function createDebtRelations(board: DebtBoard): DebtRelationProjection;
+export declare function debtDisposition(board: DebtBoard, debt: DebtDocument): DebtDisposition;
+export declare function debtBlocked(board: DebtBoard, debt: DebtDocument): boolean;
+export declare function projectOwnedDetailFacts(board: DebtBoard, id: DebtId): DebtDetailFacts | null;
+export declare function projectDetailFacts(board: DebtBoard, id: DebtId, relations: DebtRelationProjection): DebtDetailFacts | null;
+export declare function projectDebtRow(board: DebtBoard, relations: DebtRelationProjection, debt: DebtDocument): DebtRow;
+export declare function projectRows(board: DebtBoard, relations: DebtRelationProjection, scope: readonly string[] | null, selection: "active" | "closed" | "all"): readonly DebtRow[];
+/**
+ * Rows for the identities that created work, grouped by creator. Only documents a
+ * requested identity created reach row projection, and each group keeps the
+ * established row order.
+ */
+export declare function projectCreatedByRows(board: DebtBoard, relations: DebtRelationProjection, createdByIds: readonly string[]): ReadonlyMap<string, readonly DebtRow[]>;
+export declare function projectBlocked(board: DebtBoard, scope: readonly string[] | null, relations: DebtRelationProjection): readonly BlockedDebtRow[];
+export declare function projectStatusRows(board: DebtBoard, relations: DebtRelationProjection, scope: readonly string[] | null): ({
+    id: `debt/${string}`;
+    title: string;
+    state: "open" | "done" | "drop";
+    priority: 0 | 1 | 2 | 3;
+    disposition: "done" | "drop" | "ready" | "blocked";
+    updatedAt: string;
+    bodyPresent: boolean;
+    children?: {
+        live: number;
+        total: number;
+    } | undefined;
+} | {
+    blockers: readonly Readonly<{
+        id: DebtId;
+        title: string | null;
+        state: DebtState | "missing";
+    }>[];
+    id: `debt/${string}`;
+    title: string;
+    state: "open" | "done" | "drop";
+    priority: 0 | 1 | 2 | 3;
+    disposition: "done" | "drop" | "ready" | "blocked";
+    updatedAt: string;
+    bodyPresent: boolean;
+    children?: {
+        live: number;
+        total: number;
+    } | undefined;
+})[];
+export type DebtBoardObservation = Readonly<{
+    statusRows: ReturnType<typeof projectStatusRows>;
+    selectRecentStatus(limit?: number): BoundedList<ReturnType<typeof projectStatusRows>[number]>;
+    selectNamespace(namespace: readonly string[]): readonly DebtRow[];
+    selectCreatedBy(createdBy: string): readonly DebtRow[];
+}>;
+export declare function projectDebtBoardObservation(board: DebtBoard): DebtBoardObservation;
+export declare function relationProblem(board: DebtBoard, before: DebtDocument | null, after: DebtDocument): string | null;
+export declare function diagnoseBoard(board: DebtBoard): readonly DebtDoctorIssue[];
+export declare function buildTree(board: DebtBoard, root: DebtId, relations: DebtRelationProjection): DebtTreeNode | null;
+export {};

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

@@ -1,16 +1,16 @@
-import { taskNonblankTextSchema, taskStateSchema, taskPrioritySchema, } from "./document.js";
-import { taskIdSchema, parseTaskId, sameNamespace } from "./identity.js";
+import { debtNonblankTextSchema, debtStateSchema, debtPrioritySchema, } from "./document.js";
+import { debtIdSchema, parseDebtId, sameNamespace } from "./identity.js";
 import { z } from "zod";
 import { boundedListLimit, projectBoundedList } from "../bounded-list.js";
-const taskRowTimestampSchema = z.string().refine((value) => Number.isFinite(Date.parse(value)), "expected timestamp");
-export const taskRowSchema = z
+const debtRowTimestampSchema = z.string().refine((value) => Number.isFinite(Date.parse(value)), "expected timestamp");
+export const debtRowSchema = z
     .object({
-    id: taskIdSchema,
-    title: taskNonblankTextSchema,
-    state: taskStateSchema,
-    priority: taskPrioritySchema,
-    disposition: z.enum(["ready", "blocked", "in_progress", "on_hold", "done", "drop"]),
-    updatedAt: taskRowTimestampSchema,
+    id: debtIdSchema,
+    title: debtNonblankTextSchema,
+    state: debtStateSchema,
+    priority: debtPrioritySchema,
+    disposition: z.enum(["ready", "blocked", "done", "drop"]),
+    updatedAt: debtRowTimestampSchema,
     bodyPresent: z.boolean(),
     children: z
         .object({ live: z.number().int().nonnegative(), total: z.number().int().nonnegative() })
@@ -18,20 +18,20 @@ export const taskRowSchema = z
         .optional(),
 })
     .strict();
-export const taskRowsSchema = z.array(taskRowSchema).readonly();
+export const debtRowsSchema = z.array(debtRowSchema).readonly();
 /** The local ids occupied across one namespace of the current board. */
 export function occupiedLocalIds(board, namespace) {
-    return new Set([...board.tasks.values()].flatMap((task) => {
-        const coordinate = parseTaskId(task.id);
+    return new Set([...board.debts.values()].flatMap((debt) => {
+        const coordinate = parseDebtId(debt.id);
         return sameNamespace(coordinate.namespace, namespace) ? [coordinate.localId] : [];
     }));
 }
 const terminal = (state) => state === "done" || state === "drop";
 const none = Object.freeze([]);
 const sorted = (values) => [...values].sort((a, b) => Buffer.compare(Buffer.from(a.id), Buffer.from(b.id)));
-export function taskRef(board, id) {
-    const task = board.tasks.get(id);
-    return task === undefined ? { id, title: null, state: "missing" } : { id, title: task.title, state: task.state };
+export function debtRef(board, id) {
+    const debt = board.debts.get(id);
+    return debt === undefined ? { id, title: null, state: "missing" } : { id, title: debt.title, state: debt.state };
 }
 function append(index, key, value) {
     const values = index.get(key);
@@ -41,22 +41,22 @@ function append(index, key, value) {
         values.push(value);
 }
 function freezeRefs(board, index) {
-    return new Map([...index].map(([id, targets]) => [id, sorted(targets.map((target) => taskRef(board, target)))]));
+    return new Map([...index].map(([id, targets]) => [id, sorted(targets.map((target) => debtRef(board, target)))]));
 }
-export function createTaskRelations(board) {
+export function createDebtRelations(board) {
     const children = new Map();
     const blocks = new Map();
     const supersededBy = new Map();
     const incoming = new Map();
-    for (const task of board.tasks.values()) {
-        if (task.parent !== null)
-            append(children, task.parent, task.id);
-        for (const need of task.needs)
-            append(blocks, need, task.id);
-        for (const target of task.supersedes)
-            append(supersededBy, target, task.id);
-        for (const target of task.relates)
-            append(incoming, target, task.id);
+    for (const debt of board.debts.values()) {
+        if (debt.parent !== null)
+            append(children, debt.parent, debt.id);
+        for (const need of debt.needs)
+            append(blocks, need, debt.id);
+        for (const target of debt.supersedes)
+            append(supersededBy, target, debt.id);
+        for (const target of debt.relates)
+            append(incoming, target, debt.id);
     }
     const childRefs = freezeRefs(board, children);
     const blockRefs = freezeRefs(board, blocks);
@@ -67,44 +67,44 @@ export function createTaskRelations(board) {
         blocks: (id) => blockRefs.get(id) ?? none,
         supersededBy: (id) => successorRefs.get(id) ?? none,
         related: (id) => {
-            const task = board.tasks.get(id);
-            const ids = new Set(task?.relates ?? []);
+            const debt = board.debts.get(id);
+            const ids = new Set(debt?.relates ?? []);
             for (const ref of incomingRefs.get(id) ?? none)
                 ids.add(ref.id);
-            return ids.size === 0 ? none : sorted([...ids].map((related) => taskRef(board, related)));
+            return ids.size === 0 ? none : sorted([...ids].map((related) => debtRef(board, related)));
         },
     };
 }
 function needReleased(board, id) {
-    const target = board.tasks.get(id);
+    const target = board.debts.get(id);
     return target !== undefined && terminal(target.state);
 }
-function hasUnresolvedNeeds(board, task) {
-    return task.needs.some((id) => !needReleased(board, id));
+function hasUnresolvedNeeds(board, debt) {
+    return debt.needs.some((id) => !needReleased(board, id));
 }
-export function taskDisposition(board, task) {
-    if (task.state !== "open")
-        return task.state;
-    return hasUnresolvedNeeds(board, task) ? "blocked" : "ready";
+export function debtDisposition(board, debt) {
+    if (debt.state !== "open")
+        return debt.state;
+    return hasUnresolvedNeeds(board, debt) ? "blocked" : "ready";
 }
-export function taskBlocked(board, task) {
-    return (task.state === "open" || task.state === "in_progress") && hasUnresolvedNeeds(board, task);
+export function debtBlocked(board, debt) {
+    return debt.state === "open" && hasUnresolvedNeeds(board, debt);
 }
 export function projectOwnedDetailFacts(board, id) {
-    const task = board.tasks.get(id);
-    if (task === undefined)
+    const debt = board.debts.get(id);
+    if (debt === undefined)
         return null;
-    const needs = task.needs.map((need) => ({ ...taskRef(board, need), released: needReleased(board, need) }));
+    const needs = debt.needs.map((need) => ({ ...debtRef(board, need), released: needReleased(board, need) }));
     return {
-        task,
+        debt,
         needs,
         blockers: needs.filter((need) => !need.released).map(({ released: _released, ...ref }) => ref),
         blocks: none,
-        parent: task.parent === null ? null : taskRef(board, task.parent),
+        parent: debt.parent === null ? null : debtRef(board, debt.parent),
         children: none,
-        supersedes: task.supersedes.map((target) => taskRef(board, target)),
+        supersedes: debt.supersedes.map((target) => debtRef(board, target)),
         supersededBy: none,
-        related: task.relates.length === 0 ? none : sorted(task.relates.map((target) => taskRef(board, target))),
+        related: debt.relates.length === 0 ? none : sorted(debt.relates.map((target) => debtRef(board, target))),
     };
 }
 export function projectDetailFacts(board, id, relations) {
@@ -119,33 +119,33 @@ export function projectDetailFacts(board, id, relations) {
         related: relations.related(id),
     };
 }
-function inScope(task, scope) {
-    return scope === null || sameNamespace(parseTaskId(task.id).namespace, scope);
+function inScope(debt, scope) {
+    return scope === null || sameNamespace(parseDebtId(debt.id).namespace, scope);
 }
-export function projectTaskRow(board, relations, task) {
-    const children = relations.children(task.id);
+export function projectDebtRow(board, relations, debt) {
+    const children = relations.children(debt.id);
     const total = children.length;
     const live = children.filter((child) => child.state !== "done" && child.state !== "drop").length;
     return {
-        id: task.id,
-        title: task.title,
-        state: task.state,
-        priority: task.priority,
-        disposition: taskDisposition(board, task),
-        updatedAt: task.updatedAt,
-        bodyPresent: task.body.length > 0,
+        id: debt.id,
+        title: debt.title,
+        state: debt.state,
+        priority: debt.priority,
+        disposition: debtDisposition(board, debt),
+        updatedAt: debt.updatedAt,
+        bodyPresent: debt.body.length > 0,
         ...(total === 0 ? {} : { children: { live, total } }),
     };
 }
 export function projectRows(board, relations, scope, selection) {
-    return [...board.tasks.values()]
-        .filter((task) => inScope(task, scope))
-        .filter((task) => selection === "all" || (selection === "closed") === terminal(task.state))
-        .map((task) => projectTaskRow(board, relations, task))
-        .sort(compareTaskRows);
+    return [...board.debts.values()]
+        .filter((debt) => inScope(debt, scope))
+        .filter((debt) => selection === "all" || (selection === "closed") === terminal(debt.state))
+        .map((debt) => projectDebtRow(board, relations, debt))
+        .sort(compareDebtRows);
 }
-/** The established Task row order: priority first, then canonical identity bytes. */
-function compareTaskRows(left, right) {
+/** The established Debt row order: priority first, then canonical identity bytes. */
+function compareDebtRows(left, right) {
     return left.priority - right.priority || Buffer.compare(Buffer.from(left.id), Buffer.from(right.id));
 }
 /**
@@ -156,13 +156,13 @@ function compareTaskRows(left, right) {
 export function projectCreatedByRows(board, relations, createdByIds) {
     const requested = new Set(createdByIds);
     const attributed = [];
-    for (const task of board.tasks.values()) {
-        const createdBy = task.createdBy;
+    for (const debt of board.debts.values()) {
+        const createdBy = debt.createdBy;
         if (createdBy === undefined || !requested.has(createdBy))
             continue;
-        attributed.push({ createdBy, row: projectTaskRow(board, relations, task) });
+        attributed.push({ createdBy, row: projectDebtRow(board, relations, debt) });
     }
-    attributed.sort((left, right) => compareTaskRows(left.row, right.row));
+    attributed.sort((left, right) => compareDebtRows(left.row, right.row));
     const grouped = new Map();
     for (const { createdBy, row } of attributed) {
         const rows = grouped.get(createdBy);
@@ -175,7 +175,7 @@ export function projectCreatedByRows(board, relations, createdByIds) {
 }
 export function projectBlocked(board, scope, relations) {
     return projectRows(board, relations, scope, "active").flatMap((row) => {
-        if (!taskBlocked(board, board.tasks.get(row.id)))
+        if (!debtBlocked(board, board.debts.get(row.id)))
             return [];
         return [{ ...row, blockers: projectDetailFacts(board, row.id, relations).blockers }];
     });
@@ -187,8 +187,8 @@ export function projectStatusRows(board, relations, scope) {
         return unresolved === undefined ? row : { ...row, blockers: unresolved };
     });
 }
-export function projectTaskBoardObservation(board) {
-    const relations = createTaskRelations(board);
+export function projectDebtBoardObservation(board) {
+    const relations = createDebtRelations(board);
     const rows = projectRows(board, relations, null, "all");
     const statusRows = projectStatusRows(board, relations, null);
     return {
@@ -198,11 +198,11 @@ export function projectTaskBoardObservation(board) {
             .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt) ||
             Buffer.compare(Buffer.from(left.id), Buffer.from(right.id))), boundedListLimit(limit)),
         selectNamespace: (namespace) => projectRows(board, relations, namespace, "all"),
-        selectCreatedBy: (createdBy) => rows.filter((row) => board.tasks.get(row.id)?.createdBy === createdBy),
+        selectCreatedBy: (createdBy) => rows.filter((row) => board.debts.get(row.id)?.createdBy === createdBy),
     };
 }
-function relationIds(task, relation) {
-    return relation === "parent" ? (task.parent === null ? [] : [task.parent]) : task[relation];
+function relationIds(debt, relation) {
+    return relation === "parent" ? (debt.parent === null ? [] : [debt.parent]) : debt[relation];
 }
 export function relationProblem(board, before, after) {
     for (const relation of ["needs", "parent", "supersedes", "relates"]) {
@@ -212,15 +212,15 @@ export function relationProblem(board, before, after) {
                 continue;
             if (target === after.id)
                 return `${after.id} has a self ${relation} relation`;
-            if (!board.tasks.has(target))
+            if (!board.debts.has(target))
                 return `${after.id} ${relation} target does not exist: ${target}`;
         }
     }
     return null;
 }
 function cycleComponents(board, relation) {
-    const ids = sorted([...board.tasks.keys()].map((id) => ({ id }))).map(({ id }) => id);
-    const edges = new Map(ids.map((id) => [id, relationIds(board.tasks.get(id), relation).filter((target) => board.tasks.has(target))]));
+    const ids = sorted([...board.debts.keys()].map((id) => ({ id }))).map(({ id }) => id);
+    const edges = new Map(ids.map((id) => [id, relationIds(board.debts.get(id), relation).filter((target) => board.debts.has(target))]));
     const reverse = new Map(ids.map((id) => [id, []]));
     for (const [id, targets] of edges)
         for (const target of targets)
@@ -268,28 +268,28 @@ function cycleComponents(board, relation) {
 }
 export function diagnoseBoard(board) {
     const issues = [];
-    for (const task of sorted(board.tasks.values()))
+    for (const debt of sorted(board.debts.values()))
         for (const relation of ["needs", "parent", "supersedes", "relates"]) {
-            for (const target of relationIds(task, relation)) {
-                if (target === task.id)
-                    issues.push({ kind: "self-relation", taskId: task.id, relation });
-                else if (!board.tasks.has(target))
-                    issues.push({ kind: "missing-target", taskId: task.id, relation, target });
+            for (const target of relationIds(debt, relation)) {
+                if (target === debt.id)
+                    issues.push({ kind: "self-relation", debtId: debt.id, relation });
+                else if (!board.debts.has(target))
+                    issues.push({ kind: "missing-target", debtId: debt.id, relation, target });
             }
         }
     for (const relation of ["needs", "parent", "supersedes"]) {
-        for (const tasks of cycleComponents(board, relation))
-            issues.push({ kind: "cycle", relation, tasks });
+        for (const debts of cycleComponents(board, relation))
+            issues.push({ kind: "cycle", relation, debts });
     }
     return issues;
 }
 export function buildTree(board, root, relations) {
-    if (!board.tasks.has(root))
+    if (!board.debts.has(root))
         return null;
     const walk = (id, path) => {
-        const ref = taskRef(board, id);
-        const task = board.tasks.get(id);
-        const node = { task: { ...ref, priority: task?.priority ?? null } };
+        const ref = debtRef(board, id);
+        const debt = board.debts.get(id);
+        const node = { debt: { ...ref, priority: debt?.priority ?? null } };
         if (path.includes(id))
             return { ...node, cycle: true, children: [] };
         return { ...node, children: relations.children(id).map((child) => walk(child.id, [...path, id])) };

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

@@ -0,0 +1,11 @@
+import type { BoundedList } from "../bounded-list.js";
+import type { DebtRef, DebtRow } from "./board.js";
+import type { WorldRoot } from "../world.js";
+export declare function parseDebtNamespaceSelector(value: string): readonly string[];
+export type RecentDebtStatusRow = DebtRow & Readonly<{
+    blockers?: readonly DebtRef[];
+}>;
+export declare function observeRecentDebtStatus(world: WorldRoot, input?: Readonly<{
+    namespace?: readonly string[];
+    limit?: number;
+}>): Promise<BoundedList<RecentDebtStatusRow>>;

package/build/src/debt/catalog.js

@@ -0,0 +1,59 @@
+import { isDebtSegment, parseDebtId } from "./identity.js";
+import { readRecentDebtDocuments, readDebtDocument } from "./store.js";
+export function parseDebtNamespaceSelector(value) {
+    if (value === "debt/")
+        return [];
+    if (!value.startsWith("debt/") || !value.endsWith("/")) {
+        throw new TypeError(`invalid Debt namespace selector: ${value}`);
+    }
+    const body = value.slice("debt/".length, -1);
+    const segments = body.split("/");
+    if (body.length === 0 || !segments.every(isDebtSegment)) {
+        throw new TypeError(`invalid Debt namespace selector: ${value}`);
+    }
+    return parseDebtId(`debt/${body}/placeholder`).namespace;
+}
+function terminal(debt) {
+    return debt?.state === "done" || debt?.state === "drop";
+}
+async function catalogRow(world, debt, documents) {
+    const needs = await Promise.all(debt.needs.map(async (id) => documents.get(id) ?? (await readDebtDocument(world, id))));
+    const blockers = [];
+    if (debt.state === "open") {
+        for (const [index, need] of needs.entries()) {
+            if (terminal(need))
+                continue;
+            blockers.push({ id: debt.needs[index], title: need?.title ?? null, state: need?.state ?? "missing" });
+        }
+    }
+    return {
+        id: debt.id,
+        title: debt.title,
+        state: debt.state,
+        priority: debt.priority,
+        disposition: debt.state === "open" && needs.some((need) => !terminal(need))
+            ? "blocked"
+            : debt.state === "open"
+                ? "ready"
+                : debt.state,
+        updatedAt: debt.updatedAt,
+        bodyPresent: debt.body.length > 0,
+        ...(blockers.length === 0 ? {} : { blockers }),
+    };
+}
+export async function observeRecentDebtStatus(world, input = {}) {
+    const { namespace } = input;
+    if (namespace !== undefined && !namespace.every(isDebtSegment)) {
+        throw new TypeError("namespace must contain canonical segments");
+    }
+    const documents = await readRecentDebtDocuments(world, {
+        ...(namespace === undefined ? {} : { namespace }),
+        selection: "active",
+        ...(input.limit === undefined ? {} : { limit: input.limit }),
+    });
+    const known = new Map(documents.rows.map((document) => [document.id, document]));
+    return {
+        rows: await Promise.all(documents.rows.map((document) => catalogRow(world, document, known))),
+        hasMore: documents.hasMore,
+    };
+}

package/build/src/{task → debt}/context.d.ts

@@ -15,7 +15,7 @@ export type ResolvedNamespaceContext = Readonly<{
 export declare function readNamespaceContext(coordinates: NamespaceContextInput): Promise<NamespaceContextRead>;
 export declare function installNamespaceContext(root: string, segments: readonly string[]): Promise<void>;
 export declare function repairNamespaceContext(root: string, segments: readonly string[]): Promise<"kept" | "installed">;
-export declare function resolveTaskNamespaceContext(input: NamespaceContextInput): Promise<ResolvedNamespaceContext | Readonly<{
+export declare function resolveDebtNamespaceContext(input: NamespaceContextInput): Promise<ResolvedNamespaceContext | Readonly<{
     kind: "invalid-namespace-context";
     path: string;
 }>>;

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

@@ -80,7 +80,7 @@ export async function repairNamespaceContext(root, segments) {
     await installNamespaceContext(root, segments);
     return "installed";
 }
-export async function resolveTaskNamespaceContext(input) {
+export async function resolveDebtNamespaceContext(input) {
     let current = input.directory;
     for (;;) {
         const selected = await readAtWithPath(current);

package/build/src/{task → debt}/created-observation.d.ts

@@ -1,21 +1,17 @@
 import type { WorldRoot } from "../world.js";
 import { z } from "zod";
-export declare const createdTaskObservationSchema: z.ZodUnion<readonly [z.ZodObject<{
+export declare const createdDebtObservationSchema: z.ZodUnion<readonly [z.ZodObject<{
     kind: z.ZodLiteral<"present">;
     rows: z.ZodReadonly<z.ZodArray<z.ZodObject<{
-        id: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
+        id: z.ZodPipe<z.ZodString, z.ZodTransform<`debt/${string}`, string>>;
         title: z.ZodString;
         state: z.ZodEnum<{
             open: "open";
-            in_progress: "in_progress";
-            on_hold: "on_hold";
             done: "done";
             drop: "drop";
         }>;
         priority: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
         disposition: z.ZodEnum<{
-            in_progress: "in_progress";
-            on_hold: "on_hold";
             done: "done";
             drop: "drop";
             ready: "ready";
@@ -32,11 +28,11 @@ export declare const createdTaskObservationSchema: z.ZodUnion<readonly [z.ZodObj
     kind: z.ZodLiteral<"failed">;
     diagnostic: z.ZodString;
 }, z.core.$strict>]>;
-export type CreatedTaskObservation = z.infer<typeof createdTaskObservationSchema>;
-export declare const EMPTY_CREATED_TASK_OBSERVATION: CreatedTaskObservation;
+export type CreatedDebtObservation = z.infer<typeof createdDebtObservationSchema>;
+export declare const EMPTY_CREATED_DEBT_OBSERVATION: CreatedDebtObservation;
 /**
- * Project Task board rows created by each identity, preserving input order. One complete
+ * Project Debt board rows created by each identity, preserving input order. One complete
  * board and one relationship projection answer every requested identity, and only the
  * documents those identities created reach row projection.
  */
-export declare function observeCreatedTaskObservations(world: WorldRoot, createdByIds: readonly string[]): Promise<readonly CreatedTaskObservation[]>;
+export declare function observeCreatedDebtObservations(world: WorldRoot, createdByIds: readonly string[]): Promise<readonly CreatedDebtObservation[]>;

package/build/src/{task → debt}/created-observation.js

@@ -1,20 +1,20 @@
 import { z } from "zod";
-import { createTaskRelations, projectCreatedByRows, taskRowsSchema } from "./board.js";
+import { createDebtRelations, projectCreatedByRows, debtRowsSchema } from "./board.js";
 import { readBoard } from "./store.js";
-export const createdTaskObservationSchema = z.union([
-    z.object({ kind: z.literal("present"), rows: taskRowsSchema }).strict(),
+export const createdDebtObservationSchema = z.union([
+    z.object({ kind: z.literal("present"), rows: debtRowsSchema }).strict(),
     z.object({ kind: z.literal("failed"), diagnostic: z.string() }).strict(),
 ]);
-export const EMPTY_CREATED_TASK_OBSERVATION = { kind: "present", rows: [] };
+export const EMPTY_CREATED_DEBT_OBSERVATION = { kind: "present", rows: [] };
 function observationDiagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
 /**
- * Project Task board rows created by each identity, preserving input order. One complete
+ * Project Debt board rows created by each identity, preserving input order. One complete
  * board and one relationship projection answer every requested identity, and only the
  * documents those identities created reach row projection.
  */
-export async function observeCreatedTaskObservations(world, createdByIds) {
+export async function observeCreatedDebtObservations(world, createdByIds) {
     if (createdByIds.length === 0)
         return [];
     let board;
@@ -25,6 +25,6 @@ export async function observeCreatedTaskObservations(world, createdByIds) {
         const failed = { kind: "failed", diagnostic: observationDiagnostic(error) };
         return createdByIds.map(() => failed);
     }
-    const rows = projectCreatedByRows(board, createTaskRelations(board), createdByIds);
+    const rows = projectCreatedByRows(board, createDebtRelations(board), createdByIds);
     return createdByIds.map((createdBy) => ({ kind: "present", rows: rows.get(createdBy) ?? [] }));
 }