@astrosheep/keiyaku 4.0.2 → 4.0.4

package/build/src/protocol/bind.js

@@ -1,15 +1,8 @@
 import { normalizeTargetBranch, observeBindCoordinates } from "../git/observe.js";
 import { gitObjectIdForSnapshot } from "../git/identity.js";
-import { contractIdFromSegment } from "../core/facts/types.js";
 import { decideBind } from "../core/verbs/bind.js";
 import { admitIntent } from "./intent.js";
 import { complete } from "./outcome.js";
-import { fitIdentityStem, normalizeIdentityStem } from "../identity/normalize.js";
-const COLLISION_ATTEMPTS = 3;
-function contractIdFor(title, suffix) {
-    const stem = fitIdentityStem({ stem: normalizeIdentityStem({ source: title }) || "contract", maxBytes: 48 });
-    return contractIdFromSegment(suffix === undefined ? stem : `${stem}-${suffix}`);
-}
 async function bindPreparation(input, target, seed) {
     if (input.verification.kind === "refused") {
         return { kind: "prepared", input: { ...seed, preparation: input.verification } };
@@ -50,7 +43,8 @@ export async function bindOperation(input) {
         target = normalized;
     }
     const at = new Date().toISOString();
-    const attempt = async (id) => complete(await admitIntent(input.channel, input.scope, {
+    const id = input.contractId;
+    return complete(await admitIntent(input.channel, input.scope, {
         contractId: id,
         ...(input.actor === undefined ? {} : { actor: input.actor }),
         at,
@@ -59,12 +53,4 @@ export async function bindOperation(input) {
         prepareInput: async (_observation, original) => bindPreparation(input, target, original),
         ...(input.decorateOffer === undefined ? {} : { decorateOffer: input.decorateOffer }),
     }), { contractId: id });
-    if (input.contractId !== undefined)
-        return attempt(input.contractId);
-    let result = await attempt(contractIdFor(input.title));
-    for (let collision = 0; collision < COLLISION_ATTEMPTS && result.kind === "refused" && result.refusal.kind === "contract-exists"; collision += 1) {
-        result = await attempt(contractIdFor(input.title, randomBytes(8).toString("hex")));
-    }
-    return result;
 }
-import { randomBytes } from "node:crypto";

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

@@ -90,6 +90,7 @@ export type AuditReport = Readonly<{
 export type VerificationReuse = CurrentVerifiedAttestation;
 export type DocumentDerivation = Readonly<{
     document: DocumentKey;
+    bytes: string;
     title: string;
     verification: VerificationDeclarationPreparation;
 }>;
@@ -155,7 +156,7 @@ export type DeliverValue = DeliveryIdentity & Readonly<{
     leak?: WorktreeLeak;
 }>;
 type DeliverOperationInput = MutationOperationInput & Readonly<{
-    deriveDocument?: (state: ContractState) => DocumentDerivation;
+    deriveDocument: (state: ContractState) => DocumentDerivation;
     message?: string;
     requireBranchesToBeUpToDate: boolean;
     includeDirty: boolean;
@@ -169,6 +170,8 @@ export declare function prepareDelivery(repository: GitRepository, stage: Readon
     }>;
 }>, input: Readonly<{
     title: string;
+    document: string;
+    actor?: ActorId;
     message?: string;
     requireBranchesToBeUpToDate?: boolean;
     includeDirty?: boolean;

package/build/src/protocol/operations.js

@@ -1,5 +1,5 @@
 import { materializeIntegrationSnapshot, planIntegration, readDeliveryDiff, readDeliveryScope, worktreeChangeId, } from "../git/integration.js";
-import { captureTender, dirtyTenderDelta, dirtyTenderRefusal, materializeTenderSnapshot, } from "../git/tender.js";
+import { captureTender, dirtyTenderDelta, dirtyTenderRefusal, materializeTenderSnapshot, prepareDeliveryCommitMetadata, } from "../git/tender.js";
 import { currentBranch, extendContractsForAdmissionAt, observeContractAt, observeContractWorld, observeContractsForAdmissionAt, } from "../git/observe.js";
 import { reconcile, reconcileBatch, reconcileObservationFailure, } from "../git/reconcile.js";
 import { NoGitWorldError, repositoryAt } from "../git/repository.js";
@@ -188,22 +188,22 @@ export async function prepareDelivery(repository, stage, input) {
     if ((tender.data.dirty && input.includeDirty !== true) || tender.data.changes.submodules.length > 0) {
         return { kind: "refused", refusal: await dirtyTenderRefusal(repository, contractId, tender.data) };
     }
-    const tenderSnapshot = await materializeTenderSnapshot(repository, tender.data, {
+    const commit = await prepareDeliveryCommitMetadata(repository, {
         contractId,
         title: input.title,
+        document: input.document,
+        at: tender.data.at,
+        ...(input.actor === undefined ? {} : { actor: input.actor }),
         ...(input.message === undefined ? {} : { message: input.message }),
     });
+    const tenderSnapshot = await materializeTenderSnapshot(repository, tender.data, commit);
     const requireBranchesToBeUpToDate = input.requireBranchesToBeUpToDate ?? false;
     const integration = await planIntegration(repository, { contractId, coordinates }, { ...tender.data, head: tenderSnapshot }, requireBranchesToBeUpToDate);
     if (integration.kind === "refused")
         return integration;
     const integrationSnapshot = coordinates.target === undefined
         ? tenderSnapshot
-        : await materializeIntegrationSnapshot(repository, integration.data.tree, integration.data.predecessor, {
-            contractId,
-            title: input.title,
-            ...(input.message === undefined ? {} : { message: input.message }),
-        });
+        : await materializeIntegrationSnapshot(repository, integration.data.tree, integration.data.predecessor, commit);
     return {
         kind: "prepared",
         data: {
@@ -276,6 +276,8 @@ async function deliverAttempt(input, attempt) {
             coordinates: state.coordinates,
         }, {
             title: derivation.title,
+            document: derivation.bytes,
+            ...(input.actor === undefined ? {} : { actor: input.actor }),
             ...(input.message === undefined ? {} : { message: input.message }),
             requireBranchesToBeUpToDate: input.requireBranchesToBeUpToDate,
             includeDirty: input.includeDirty,
@@ -589,6 +591,25 @@ async function auditTargetAnswer(repository, state, candidate) {
         candidate: candidate.integration.snapshot,
     });
 }
+function blockedAudit(refusal) {
+    return {
+        candidate: { kind: "blocked", refusal },
+        verification: { kind: "not-run" },
+        target: { kind: "not-observed" },
+    };
+}
+function completedAudit(state, verified, value) {
+    const obligations = {
+        ...(verified?.cleanup === undefined ? {} : { cleanup: verified.cleanup }),
+        ...(verified?.leak === undefined ? {} : { leak: verified.leak }),
+    };
+    return verified?.admission === undefined
+        ? accepted(state, [], value, undefined, obligations)
+        : {
+            ...admitted(verified.admission, value),
+            ...obligations,
+        };
+}
 export async function auditOperation(input) {
     const observed = await observeContractsForAdmissionAt(input.scope, input.channel, [input.contractId]);
     const state = activeContract(observed.decision, input.contractId);
@@ -603,11 +624,7 @@ export async function auditOperation(input) {
     }
     const workspace = await auditWorkspace(input.scope, state);
     if (workspace.kind === "unappointed") {
-        return accepted(state, [], {
-            candidate: { kind: "blocked", refusal: { kind: "worktree-missing", contractId: state.id } },
-            verification: { kind: "not-run" },
-            target: { kind: "not-observed" },
-        });
+        return accepted(state, [], blockedAudit({ kind: "worktree-missing", contractId: state.id }));
     }
     const prepared = await prepareDelivery(input.scope, {
         contractId: state.id,
@@ -615,15 +632,13 @@ export async function auditOperation(input) {
         ...(workspace.appointment === undefined ? {} : { appointment: workspace.appointment }),
     }, {
         title: derivation.title,
+        document: derivation.bytes,
+        ...(input.actor === undefined ? {} : { actor: input.actor }),
         requireBranchesToBeUpToDate: input.requireBranchesToBeUpToDate ?? false,
         includeDirty: input.includeDirty ?? false,
     });
     if (prepared.kind === "refused") {
-        return accepted(state, [], {
-            candidate: { kind: "blocked", refusal: prepared.refusal },
-            verification: { kind: "not-run" },
-            target: { kind: "not-observed" },
-        });
+        return accepted(state, [], blockedAudit(prepared.refusal));
     }
     const verified = derivation.verification.data === null
         ? undefined
@@ -638,16 +653,7 @@ export async function auditOperation(input) {
             : await auditTargetAnswer(input.scope, state, prepared.data),
         ...(delivery === undefined ? {} : { delivery }),
     };
-    const obligations = {
-        ...(verified?.cleanup === undefined ? {} : { cleanup: verified.cleanup }),
-        ...(verified?.leak === undefined ? {} : { leak: verified.leak }),
-    };
-    return verified?.admission === undefined
-        ? accepted(state, [], value, undefined, obligations)
-        : {
-            ...admitted(verified.admission, value),
-            ...obligations,
-        };
+    return completedAudit(state, verified, value);
 }
 export async function reconcileOperation(input) {
     try {

package/build/src/protocol/read/status.d.ts

@@ -46,6 +46,8 @@ export type ContractObservation = Readonly<{
 }>;
 export declare function phaseAtFor(state: Pick<ContractState, "terminal" | "delivery" | "bound">, bindAt: string): string;
 /** Build the Contract board from one immutable git observation. */
-export declare function readContractBoard(observation: GitReadObservation): Promise<ContractBoard>;
+export declare function readContractBoard(observation: GitReadObservation, selected?: ContractId): Promise<ContractBoard>;
+/** Observe one Contract and its target from one fresh ref epoch. */
+export declare function readContractObservation(observation: GitReadObservation, id: ContractId): Promise<ContractObservation>;
 /** Observe one Contract and its target from one fresh ref epoch. */
 export declare function readContractObservationAt(repository: GitRepository, channel: GitDecodeChannel, id: ContractId): Promise<ContractObservation>;

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

@@ -76,7 +76,15 @@ async function rowFor(repository, state, bindAt, targetObservation, register) {
     };
 }
 /** Build the Contract board from one immutable git observation. */
-export async function readContractBoard(observation) {
+export async function readContractBoard(observation, selected) {
+    if (selected !== undefined) {
+        const contract = await readContractObservation(observation, selected);
+        return {
+            root: observation.repository.primaryWorktree,
+            state: observation.snapshot.commit,
+            rows: contract.kind === "missing" ? [] : [contract.row],
+        };
+    }
     const observed = await observeActiveContractWorld(observation);
     const register = await readPlaceRegister(observation.repository);
     const rows = [];
@@ -90,18 +98,20 @@ export async function readContractBoard(observation) {
     return { root: observation.repository.primaryWorktree, state: observed.snapshot, rows: await Promise.all(rows) };
 }
 /** Observe one Contract and its target from one fresh ref epoch. */
+export async function readContractObservation(observation, id) {
+    const observed = await observeContractsForAdmissionInObservationAt(observation, [id]);
+    const record = observed.journals.get(id);
+    if (record === undefined)
+        throw new Error(`missing requested Contract observation: ${id}`);
+    const state = record.state;
+    return state === null
+        ? { kind: "missing", id }
+        : {
+            kind: "present",
+            row: await rowFor(observation.repository, state, record.entries[0].at, await observeDeliveryTargetAt(observation, state), await readPlaceRegister(observation.repository)),
+        };
+}
+/** Observe one Contract and its target from one fresh ref epoch. */
 export async function readContractObservationAt(repository, channel, id) {
-    return withContractReadObservationAt(repository, channel, id, async (observation) => {
-        const observed = await observeContractsForAdmissionInObservationAt(observation, [id]);
-        const record = observed.journals.get(id);
-        if (record === undefined)
-            throw new Error(`missing requested Contract observation: ${id}`);
-        const state = record.state;
-        return state === null
-            ? { kind: "missing", id }
-            : {
-                kind: "present",
-                row: await rowFor(observation.repository, state, record.entries[0].at, await observeDeliveryTargetAt(observation, state), await readPlaceRegister(observation.repository)),
-            };
-    });
+    return withContractReadObservationAt(repository, channel, id, async (observation) => await readContractObservation(observation, id));
 }

package/build/src/runtime/proc/run.d.ts

@@ -51,6 +51,7 @@ export type OwnedProcess = Readonly<{
 export declare function terminateOwnedProcess(child: ChildProcess, force?: boolean): Promise<void>;
 export declare function spawnDetachedProcess(input: DetachedProcessInput): Promise<OwnedProcess>;
 export declare function runProcess(input: ProcessInput): Promise<ProcessOutcome>;
+export declare function runCrossPlatformProcess(input: ProcessInput): Promise<ProcessOutcome>;
 export declare function runProcessToExit(input: ProcessLaunch): Promise<ProcessOutcome>;
 export declare function consumeProcessStdout(input: ProcessInput, consume: (chunk: Buffer) => void): Promise<ProcessConsumption>;
 export {};

package/build/src/runtime/proc/run.js

@@ -2,6 +2,7 @@ import { execFile, spawn } from "node:child_process";
 import { open } from "node:fs/promises";
 import { setTimeout as delay } from "node:timers/promises";
 import { promisify } from "node:util";
+import crossSpawn from "cross-spawn";
 const TERMINATION_GRACE_MS = 250;
 const STREAM_TAIL_BYTES = 16 * 1024;
 function tailCapture(limit) {
@@ -138,10 +139,10 @@ function terminalOutcome(code, stdout, stderr, consuming) {
         truncated: (consuming ? false : stdout.truncated) || stderr.truncated,
     };
 }
-async function executeProcess(input, timeoutMs, consumeStdout) {
+async function executeProcess(input, timeoutMs, consumeStdout, spawnProcess = spawn) {
     if (input.signal?.aborted === true)
         return { outcome: { kind: "cancelled" }, pid: null };
-    const child = spawn(input.argv[0], input.argv.slice(1), {
+    const child = spawnProcess(input.argv[0], input.argv.slice(1), {
         cwd: input.cwd,
         env: input.env,
         detached: true,
@@ -223,6 +224,12 @@ export async function runProcess(input) {
         throw new Error("buffered process produced a stream consumer error");
     return result.outcome;
 }
+export async function runCrossPlatformProcess(input) {
+    const result = await executeProcess(input, input.timeoutMs, undefined, crossSpawn);
+    if (result.outcome.kind === "stream-error")
+        throw new Error("buffered process produced a stream consumer error");
+    return result.outcome;
+}
 export async function runProcessToExit(input) {
     const result = await executeProcess(input, undefined);
     if (result.outcome.kind === "stream-error")

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

@@ -29,6 +29,7 @@ export declare function deferredTaskHolderSettlement(input: Readonly<{
     taskId: TaskId;
     diagnostic: string;
 }>): SettlementReport;
+export declare function contractNamespace(id: ContractId): readonly [string];
 export type SettlementInput = Readonly<{
     repository: GitRepository;
     channel: GitDecodeChannel;

package/build/src/settlement/settle.js

@@ -7,6 +7,9 @@ import { World } from "../world.js";
 export function deferredTaskHolderSettlement(input) {
     return { actions: [], lags: [{ kind: "settlement-failed", surface: "task-holder", ...input }] };
 }
+export function contractNamespace(id) {
+    return [contractSegment(id)];
+}
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -79,7 +82,7 @@ async function settleNamespace(state, effects, actions, lags) {
             actions.push({
                 kind: "namespace-context",
                 path: effect.path,
-                action: await repairNamespaceContext(world, [contractSegment(state.id)]),
+                action: await repairNamespaceContext(world, contractNamespace(state.id)),
             });
         }
         catch (error) {

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

@@ -54,11 +54,20 @@ export type TaskDoctorIssue = Readonly<{
     relation: "needs" | "parent" | "supersedes";
     tasks: readonly TaskId[];
 }>;
+export declare function taskRef(board: TaskBoard, id: TaskId): TaskRef;
+export type TaskRelationProjection = Readonly<{
+    children(id: TaskId): readonly TaskRef[];
+    blocks(id: TaskId): readonly TaskRef[];
+    supersededBy(id: TaskId): readonly TaskRef[];
+    related(id: TaskId): readonly TaskRef[];
+}>;
+export declare function createTaskRelations(board: TaskBoard): TaskRelationProjection;
 export declare function taskDisposition(board: TaskBoard, task: TaskDocument): TaskDisposition;
-export declare function projectDetailFacts(board: TaskBoard, id: TaskId): TaskDetailFacts | null;
+export declare function taskBlocked(board: TaskBoard, task: TaskDocument): boolean;
+export declare function projectDetailFacts(board: TaskBoard, id: TaskId, relations: TaskRelationProjection): TaskDetailFacts | null;
 export declare function projectRows(board: TaskBoard, scope: readonly string[] | null, selection: "active" | "closed" | "all"): readonly TaskRow[];
 export declare function projectReady(board: TaskBoard, scope: readonly string[] | null): readonly TaskRow[];
-export declare function projectBlocked(board: TaskBoard, scope: readonly string[] | null): readonly BlockedTaskRow[];
+export declare function projectBlocked(board: TaskBoard, scope: readonly string[] | null, relations: TaskRelationProjection): readonly BlockedTaskRow[];
 export declare function projectStatusRows(board: TaskBoard, scope: readonly string[] | null): (Readonly<{
     id: TaskId;
     title: string;
@@ -77,7 +86,13 @@ export declare function projectStatusRows(board: TaskBoard, scope: readonly stri
     priority: TaskPriority;
     disposition: TaskDisposition;
 })[];
+export type TaskBoardObservation = Readonly<{
+    statusRows: ReturnType<typeof projectStatusRows>;
+    selectNamespace(namespace: readonly string[]): readonly TaskRow[];
+    selectCreatedBy(createdBy: string): readonly TaskRow[];
+}>;
+export declare function projectTaskBoardObservation(board: TaskBoard): TaskBoardObservation;
 export declare function relationProblem(board: TaskBoard, before: TaskDocument | null, after: TaskDocument): string | null;
 export declare function diagnoseBoard(board: TaskBoard): readonly TaskDoctorIssue[];
-export declare function buildTree(board: TaskBoard, root: TaskId): TaskTreeNode | null;
+export declare function buildTree(board: TaskBoard, root: TaskId, relations: TaskRelationProjection): TaskTreeNode | null;
 export {};

package/build/src/task/board.js

@@ -1,42 +1,81 @@
 import { parseTaskId, sameNamespace } from "./identity.js";
 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)));
-function taskRef(board, 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 };
 }
-function outgoing(document, relation) { return document[relation]; }
-function reverse(board, id, relation) {
-    return sorted([...board.tasks.values()].filter((task) => outgoing(task, relation).includes(id)).map((task) => taskRef(board, task.id)));
+function append(index, key, value) {
+    const values = index.get(key);
+    if (values === undefined)
+        index.set(key, [value]);
+    else
+        values.push(value);
 }
-function children(board, id) {
-    return sorted([...board.tasks.values()].filter((task) => task.parent === id).map((task) => taskRef(board, task.id)));
+function freezeRefs(board, index) {
+    return new Map([...index].map(([id, targets]) => [id, sorted(targets.map((target) => taskRef(board, target)))]));
 }
-function related(board, task) {
-    const ids = new Set(task.relates);
-    for (const candidate of board.tasks.values())
-        if (candidate.relates.includes(task.id))
-            ids.add(candidate.id);
-    return sorted([...ids].map((id) => taskRef(board, id)));
+export function createTaskRelations(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);
+    }
+    const childRefs = freezeRefs(board, children);
+    const blockRefs = freezeRefs(board, blocks);
+    const successorRefs = freezeRefs(board, supersededBy);
+    const incomingRefs = freezeRefs(board, incoming);
+    return {
+        children: (id) => childRefs.get(id) ?? none,
+        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 ?? []);
+            for (const ref of incomingRefs.get(id) ?? none)
+                ids.add(ref.id);
+            return ids.size === 0 ? none : sorted([...ids].map((related) => taskRef(board, related)));
+        },
+    };
+}
+function needReleased(board, id) {
+    const target = board.tasks.get(id);
+    return target !== undefined && terminal(target.state);
+}
+function hasUnresolvedNeeds(board, task) {
+    return task.needs.some((id) => !needReleased(board, id));
 }
 export function taskDisposition(board, task) {
     if (task.state !== "open")
         return task.state;
-    return task.needs.every((id) => { const target = board.tasks.get(id); return target !== undefined && terminal(target.state); }) ? "ready" : "blocked";
+    return hasUnresolvedNeeds(board, task) ? "blocked" : "ready";
 }
-export function projectDetailFacts(board, id) {
+export function taskBlocked(board, task) {
+    return (task.state === "open" || task.state === "in_progress") && hasUnresolvedNeeds(board, task);
+}
+export function projectDetailFacts(board, id, relations) {
     const task = board.tasks.get(id);
     if (task === undefined)
         return null;
-    const needs = task.needs.map((need) => ({ ...taskRef(board, need), released: board.tasks.has(need) && terminal(board.tasks.get(need).state) }));
+    const needs = task.needs.map((need) => ({ ...taskRef(board, need), released: needReleased(board, need) }));
     return {
         task,
         needs,
         blockers: needs.filter((need) => !need.released).map(({ released: _released, ...ref }) => ref),
-        blocks: reverse(board, id, "needs"),
-        parent: task.parent === null ? null : taskRef(board, task.parent), children: children(board, id),
-        supersedes: task.supersedes.map((target) => taskRef(board, target)), supersededBy: reverse(board, id, "supersedes"),
-        related: related(board, task),
+        blocks: relations.blocks(id),
+        parent: task.parent === null ? null : taskRef(board, task.parent), children: relations.children(id),
+        supersedes: task.supersedes.map((target) => taskRef(board, target)), supersededBy: relations.supersededBy(id),
+        related: relations.related(id),
     };
 }
 function inScope(task, scope) { return scope === null || sameNamespace(parseTaskId(task.id).namespace, scope); }
@@ -50,21 +89,29 @@ export function projectRows(board, scope, selection) {
 export function projectReady(board, scope) {
     return projectRows(board, scope, "active").filter((row) => row.disposition === "ready");
 }
-export function projectBlocked(board, scope) {
+export function projectBlocked(board, scope, relations) {
     return projectRows(board, scope, "active").flatMap((row) => {
-        if (row.state !== "open" && row.state !== "in_progress")
+        if (!taskBlocked(board, board.tasks.get(row.id)))
             return [];
-        const blockers = projectDetailFacts(board, row.id).blockers;
-        return blockers.length === 0 ? [] : [{ ...row, blockers }];
+        return [{ ...row, blockers: projectDetailFacts(board, row.id, relations).blockers }];
     });
 }
 export function projectStatusRows(board, scope) {
-    const blockers = new Map(projectBlocked(board, scope).map((row) => [row.id, row.blockers]));
+    const relations = createTaskRelations(board);
+    const blockers = new Map(projectBlocked(board, scope, relations).map((row) => [row.id, row.blockers]));
     return projectRows(board, scope, "all").map((row) => {
         const unresolved = blockers.get(row.id);
         return unresolved === undefined ? row : { ...row, blockers: unresolved };
     });
 }
+export function projectTaskBoardObservation(board) {
+    const rows = projectRows(board, null, "all");
+    return {
+        statusRows: projectStatusRows(board, null),
+        selectNamespace: (namespace) => projectRows(board, namespace, "all"),
+        selectCreatedBy: (createdBy) => rows.filter((row) => board.tasks.get(row.id)?.createdBy === createdBy),
+    };
+}
 function relationIds(task, relation) {
     return relation === "parent" ? task.parent === null ? [] : [task.parent] : task[relation];
 }
@@ -147,7 +194,7 @@ export function diagnoseBoard(board) {
     }
     return issues;
 }
-export function buildTree(board, root) {
+export function buildTree(board, root, relations) {
     if (!board.tasks.has(root))
         return null;
     const walk = (id, path) => {
@@ -156,7 +203,7 @@ export function buildTree(board, root) {
         const node = { task: { ...ref, priority: task?.priority ?? null } };
         if (path.includes(id))
             return { ...node, cycle: true, children: [] };
-        return { ...node, children: children(board, id).map((child) => walk(child.id, [...path, id])) };
+        return { ...node, children: relations.children(id).map((child) => walk(child.id, [...path, id])) };
     };
     return walk(root, []);
 }

package/build/src/task/index.d.ts

@@ -5,7 +5,7 @@ import { type TaskCompositionResult } from "./compose.js";
 import { TaskAuthorityCorruptionError, type TaskPriority, type TaskState } from "./document.js";
 import { type TaskId } from "./identity.js";
 import { type AddTaskDocumentInput, type AddTaskInput, type TaskBatchResult, type TaskMutationResult, type TaskOutcome, type TaskRefusal, type TaskRetry, type TaskUpdateResult, type TaskView, type UpdateTaskInput } from "./operations.js";
-import { type TaskPage, type TaskQueryExpression, type TaskQueryPredicate, type TaskQueryRow, type TaskQuerySort } from "./query.js";
+import { TASK_RELATION_PREDICATE_FIELDS, type TaskPage, type TaskQueryExpression, type TaskQueryPredicate, type TaskQueryRow, type TaskQuerySort, type TaskRelationPredicateField } from "./query.js";
 export type TaskDetail = Omit<TaskDetailFacts, "task"> & Readonly<{
     task: TaskView;
 }>;
@@ -17,8 +17,8 @@ export type TaskDoctorReport = Readonly<{
     issues: readonly TaskDoctorIssue[];
 }>;
 export type TaskDecompositionTree = TaskOutcome<TaskTreeNode>;
-export type { AddTaskDocumentInput, AddTaskInput, BlockedTaskRow, TaskBatchResult, TaskCompositionResult, TaskDoctorIssue, TaskId, TaskMutationResult, TaskOutcome, TaskPriority, TaskRef, TaskRefusal, TaskRetry, TaskRow, TaskState, TaskTreeNode, TaskUpdateResult, TaskView, UpdateTaskInput, TaskPage, TaskQueryExpression, TaskQueryPredicate, TaskQueryRow, TaskQuerySort };
-export { TaskAuthorityCorruptionError };
+export type { AddTaskDocumentInput, AddTaskInput, BlockedTaskRow, TaskBatchResult, TaskCompositionResult, TaskDoctorIssue, TaskId, TaskMutationResult, TaskOutcome, TaskPriority, TaskRef, TaskRefusal, TaskRetry, TaskRow, TaskState, TaskTreeNode, TaskUpdateResult, TaskView, UpdateTaskInput, TaskPage, TaskQueryExpression, TaskQueryPredicate, TaskQueryRow, TaskQuerySort, TaskRelationPredicateField, };
+export { TaskAuthorityCorruptionError, TASK_RELATION_PREDICATE_FIELDS };
 declare class TaskHandle {
     readonly id: TaskId;
     private readonly world;

package/build/src/task/index.js

@@ -1,11 +1,11 @@
-import { buildTree, diagnoseBoard, projectDetailFacts } from "./board.js";
+import { buildTree, createTaskRelations, diagnoseBoard, projectDetailFacts, } from "./board.js";
 import { composeTasks } from "./compose.js";
 import { TaskAuthorityCorruptionError } from "./document.js";
 import { isTaskSegment, parseTaskId } from "./identity.js";
 import { addTask, addTaskDocument, batchTasks, blockedTasks, currentNamespace, lifecycleTask, listTasks, queryTasks, readyTasks, setCurrentNamespace, taskView, updateTask, } from "./operations.js";
 import { readBoard } from "./store.js";
-import { isValidTaskLimit, normalizeTaskQuery, MAX_TASK_LIMIT, DEFAULT_TASK_LIMIT } from "./query.js";
-export { TaskAuthorityCorruptionError };
+import { isValidTaskLimit, normalizeTaskQuery, TASK_RELATION_PREDICATE_FIELDS, MAX_TASK_LIMIT, DEFAULT_TASK_LIMIT, } from "./query.js";
+export { TaskAuthorityCorruptionError, TASK_RELATION_PREDICATE_FIELDS };
 function record(value, label) {
     if (typeof value !== "object" || value === null || Array.isArray(value))
         throw new TypeError(`${label} must be an object`);
@@ -139,13 +139,15 @@ class TaskHandle {
         this.world = world;
     }
     async read() {
-        const facts = projectDetailFacts((await readBoard(this.world)).board, this.id);
+        const board = (await readBoard(this.world)).board;
+        const facts = projectDetailFacts(board, this.id, createTaskRelations(board));
         return facts === null ? null : { ...facts, task: taskView(facts.task) };
     }
     async tree() {
         if (arguments.length > 0)
             throw new TypeError("tree accepts no input");
-        const node = buildTree((await readBoard(this.world)).board, this.id);
+        const board = (await readBoard(this.world)).board;
+        const node = buildTree(board, this.id, createTaskRelations(board));
         return node === null ? { kind: "refused", refusal: { kind: "task-missing", taskId: this.id } } : { kind: "accepted", value: node };
     }
     update(input) { return updateTask(this.world, this.id, updateInput(input)); }

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

@@ -1,4 +1,4 @@
-import { type BlockedTaskRow, type TaskRow } from "./board.js";
+import { type BlockedTaskRow, type TaskBoardObservation, type TaskRow } from "./board.js";
 import { type TaskDocument, type TaskPriority, type TaskState } from "./document.js";
 import { type TaskId } from "./identity.js";
 import type { WorldRoot } from "../world.js";
@@ -116,24 +116,7 @@ export declare function readyTasks(world: WorldRoot, scope?: "namespace" | "worl
 export declare function blockedTasks(world: WorldRoot, scope?: "namespace" | "world", parent?: TaskId, limit?: number): Promise<TaskOutcome<TaskPage<BlockedTaskRow>>>;
 export declare function queryTasks(world: WorldRoot, expression: TaskQueryExpression, scope?: "namespace" | "world", sort?: TaskQuerySort, limit?: number): Promise<TaskOutcome<TaskPage<TaskQueryRow>>>;
 /** Internal composite observation from one complete Task board read. */
-export declare function observeTaskStatusRows(world: WorldRoot): Promise<(Readonly<{
-    id: TaskId;
-    title: string;
-    state: TaskState;
-    priority: TaskPriority;
-    disposition: import("./board.js").TaskDisposition;
-}> | {
-    blockers: readonly Readonly<{
-        id: TaskId;
-        title: string | null;
-        state: TaskState | "missing";
-    }>[];
-    id: TaskId;
-    title: string;
-    state: TaskState;
-    priority: TaskPriority;
-    disposition: import("./board.js").TaskDisposition;
-})[]>;
+export declare function observeTaskBoard(world: WorldRoot): Promise<TaskBoardObservation>;
 /** Internal identity catalog from one complete Task board read. */
 export declare function observeTaskCatalogRows(world: WorldRoot): Promise<readonly TaskRow[]>;
 export declare function setCurrentNamespace(world: WorldRoot, namespace: readonly string[]): Promise<void>;