@astrosheep/keiyaku 4.0.3 → 4.0.5

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

@@ -0,0 +1,39 @@
+import type { WorldRoot } from "../world.js";
+import type { TaskCompositionResult } from "./compose.js";
+import type { AddTaskDocumentInput, AddTaskInput, TaskBatchResult, TaskMutationResult, TaskUpdateResult, UpdateTaskInput } from "./operations.js";
+import type { TaskId } from "./identity.js";
+export declare const TASK_MUTATION_ACTIONS: readonly ["task.add", "task.addDocument", "task.compose", "task.done", "task.drop", "task.hold", "task.resume", "task.start", "task.stop", "task.update"];
+export type TaskMutationAction = (typeof TASK_MUTATION_ACTIONS)[number];
+export declare function isTaskMutationAction(value: unknown): value is TaskMutationAction;
+export type TaskMutationRequest = Readonly<{
+    action: "task.add";
+    input: Omit<AddTaskInput, "actor" | "signal">;
+}> | Readonly<{
+    action: "task.addDocument";
+    input: Omit<AddTaskDocumentInput, "actor" | "signal">;
+}> | Readonly<{
+    action: "task.compose";
+    markdown: string;
+}> | Readonly<{
+    action: "task.update";
+    id: TaskId;
+    input: Omit<UpdateTaskInput, "signal">;
+}> | Readonly<{
+    action: "task.start" | "task.stop" | "task.resume";
+    id: TaskId;
+}> | Readonly<{
+    action: "task.hold";
+    ids: readonly TaskId[];
+}> | Readonly<{
+    action: "task.done" | "task.drop";
+    ids: readonly TaskId[];
+    note?: string;
+}>;
+export type TaskMutationExecutionResult = TaskMutationResult | TaskUpdateResult | TaskBatchResult | TaskCompositionResult;
+export declare function decodeTaskMutationRequest(action: TaskMutationAction, value: unknown): TaskMutationRequest;
+export declare function executeTaskMutation(input: Readonly<{
+    world: WorldRoot;
+    request: TaskMutationRequest;
+    requester: string;
+    signal?: AbortSignal;
+}>): Promise<TaskMutationExecutionResult>;

package/build/src/task/mutation.js

@@ -0,0 +1,85 @@
+import { addInput, closed, namespace, record, taskId, taskIds, text, updateInput } from "./input.js";
+import { Tasks } from "./index.js";
+export const TASK_MUTATION_ACTIONS = Object.freeze([
+    "task.add", "task.addDocument", "task.compose", "task.done", "task.drop",
+    "task.hold", "task.resume", "task.start", "task.stop", "task.update",
+]);
+const TASK_MUTATION_ACTION_SET = new Set(TASK_MUTATION_ACTIONS);
+export function isTaskMutationAction(value) {
+    return typeof value === "string" && TASK_MUTATION_ACTION_SET.has(value);
+}
+function mutationObject(value, keys, label) {
+    const decoded = record(value, label);
+    closed(decoded, keys, label);
+    return decoded;
+}
+export function decodeTaskMutationRequest(action, value) {
+    switch (action) {
+        case "task.add": {
+            const input = mutationObject(value, ["input"], "task.add request");
+            const raw = mutationObject(input.input, [
+                "title", "namespace", "body", "note", "state", "priority", "needs", "parent", "supersedes", "relates",
+            ], "task.add input");
+            return { action, input: addInput(raw) };
+        }
+        case "task.addDocument": {
+            const input = mutationObject(value, ["input"], "task.addDocument request");
+            const raw = mutationObject(input.input, ["markdown", "namespace"], "task.addDocument input");
+            const markdown = text(raw.markdown, "markdown");
+            if (markdown === undefined)
+                throw new TypeError("markdown is required");
+            const selected = namespace(raw.namespace);
+            return { action, input: { markdown, ...(selected === undefined ? {} : { namespace: selected }) } };
+        }
+        case "task.compose": {
+            const input = mutationObject(value, ["markdown"], "task.compose request");
+            const markdown = text(input.markdown, "markdown");
+            if (markdown === undefined)
+                throw new TypeError("markdown is required");
+            return { action, markdown };
+        }
+        case "task.update": {
+            const request = mutationObject(value, ["id", "input"], "task.update request");
+            const raw = mutationObject(request.input, [
+                "title", "body", "appendBody", "note", "priority", "needs", "addNeeds", "dropNeeds", "parent",
+                "supersedes", "addSupersedes", "dropSupersedes", "relates", "addRelates", "dropRelates",
+            ], "task.update input");
+            return { action, id: taskId(request.id), input: updateInput(raw) };
+        }
+        case "task.start":
+        case "task.stop":
+        case "task.resume": {
+            const request = mutationObject(value, ["id"], `${action} request`);
+            return { action, id: taskId(request.id) };
+        }
+        case "task.hold": {
+            const request = mutationObject(value, ["ids"], "task.hold request");
+            return { action, ids: taskIds(request.ids, "ids") ?? [] };
+        }
+        case "task.done":
+        case "task.drop": {
+            const request = mutationObject(value, ["ids", "note"], `${action} request`);
+            const note = text(request.note, "note");
+            return { action, ids: taskIds(request.ids, "ids") ?? [], ...(note === undefined ? {} : { note }) };
+        }
+    }
+}
+export async function executeTaskMutation(input) {
+    const tasks = Tasks.of(input.world);
+    const { request, signal } = input;
+    const withSignal = signal === undefined ? {} : { signal };
+    switch (request.action) {
+        case "task.add": return await tasks.add({ ...request.input, actor: input.requester, ...withSignal });
+        case "task.addDocument": return await tasks.addDocument({ ...request.input, actor: input.requester, ...withSignal });
+        case "task.compose": return await tasks.compose({ markdown: request.markdown, actor: input.requester, ...withSignal });
+        case "task.update": return await tasks.task({ id: request.id }).update({ ...request.input, ...withSignal });
+        case "task.start": return await tasks.task({ id: request.id }).start(withSignal);
+        case "task.stop": return await tasks.task({ id: request.id }).stop(withSignal);
+        case "task.resume": return await tasks.task({ id: request.id }).resume(withSignal);
+        case "task.hold": return await tasks.batch({ verb: "hold", ids: request.ids, ...withSignal });
+        case "task.done": return await tasks.batch({ verb: "done", ids: request.ids, ...withSignal,
+            ...(request.note === undefined ? {} : { note: request.note }) });
+        case "task.drop": return await tasks.batch({ verb: "drop", ids: request.ids, ...withSignal,
+            ...(request.note === undefined ? {} : { note: request.note }) });
+    }
+}

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";
@@ -105,6 +105,8 @@ export type UpdateTaskInput = Readonly<{
     signal?: AbortSignal;
 }>;
 export declare function taskView(document: TaskDocument): TaskView;
+/** Internal Task timestamp rule shared by ordinary mutations and compose. */
+export declare function advanceTaskTimestamp(previous: string, candidate: string): string;
 export declare function addTask(world: WorldRoot, input: AddTaskInput): Promise<TaskMutationResult>;
 export declare function addTaskDocument(world: WorldRoot, input: AddTaskDocumentInput): Promise<TaskMutationResult>;
 export declare function updateTask(world: WorldRoot, id: TaskId, input: UpdateTaskInput): Promise<TaskUpdateResult>;
@@ -116,24 +118,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>;

package/build/src/task/operations.js

@@ -1,7 +1,7 @@
 import { resolve } from "node:path";
 import { documentDiff } from "../markdown/diff.js";
 import { installNamespaceContext, readNamespaceContext } from "./context.js";
-import { relationProblem, projectBlocked, projectRows, projectStatusRows } from "./board.js";
+import { createTaskRelations, projectTaskBoardObservation, relationProblem, projectBlocked, projectRows, } from "./board.js";
 import { parseTaskCreationDocument, serializeTaskDocument } from "./document.js";
 import { allocateLocalId, deriveLocalStem, formatTaskId, parseTaskId, sameNamespace } from "./identity.js";
 import { authorityPath, readBoard, replaceAuthority, withTaskLocks, } from "./store.js";
@@ -24,10 +24,14 @@ function occupied(board, namespace) {
         return sameNamespace(coordinate.namespace, namespace) ? [coordinate.localId] : [];
     }));
 }
-function currentTimestamp() { return new Date().toISOString(); }
-function advancedTimestamp(previous) {
-    const current = currentTimestamp();
-    return current > previous ? current : new Date(Date.parse(previous) + 1).toISOString();
+function currentTimestamp() {
+    return new Date().toISOString();
+}
+/** Internal Task timestamp rule shared by ordinary mutations and compose. */
+export function advanceTaskTimestamp(previous, candidate) {
+    return candidate > previous
+        ? candidate
+        : new Date(Date.parse(previous) + 1).toISOString();
 }
 function addDocument(base, namespace, board, at, actor) {
     const localId = allocateLocalId(deriveLocalStem(base.title), occupied(board, namespace));
@@ -108,12 +112,20 @@ export async function updateTask(world, id, input) {
         const problem = relationProblem(boardWith(snapshot.board, candidate), current, candidate);
         if (problem !== null)
             return { kind: "refused", refusal: { kind: "invalid-graph", diagnostic: problem } };
-        const predecessor = snapshot.bytes.get(id), before = Buffer.from(predecessor).toString("utf8");
+        const predecessor = snapshot.bytes.get(id);
+        const before = Buffer.from(predecessor).toString("utf8");
         const changed = !Buffer.from(serializeTaskDocument(candidate)).equals(Buffer.from(predecessor));
-        const next = changed ? { ...candidate, updatedAt: advancedTimestamp(current.updatedAt) } : candidate;
-        const afterBytes = serializeTaskDocument(next), after = Buffer.from(afterBytes).toString("utf8");
-        if (before !== after && await replaceAuthority({ path: authorityPath(world, id), expected: predecessor, next: afterBytes }) !== "replaced")
+        let next = candidate;
+        if (changed) {
+            const at = currentTimestamp();
+            next = { ...candidate, updatedAt: advanceTaskTimestamp(current.updatedAt, at) };
+        }
+        const afterBytes = serializeTaskDocument(next);
+        const after = Buffer.from(afterBytes).toString("utf8");
+        if (before !== after
+            && await replaceAuthority({ path: authorityPath(world, id), expected: predecessor, next: afterBytes }) !== "replaced") {
             return { kind: "retry", reason: "concurrent-modification" };
+        }
         const label = `${id}.md`;
         return { kind: "accepted", value: { task: taskView(next), documentDiff: documentDiff(label, label, before, after) } };
     });
@@ -130,9 +142,16 @@ export async function lifecycleTask(world, id, verb, signal, note) {
         if (current === undefined)
             return refused({ kind: "task-missing", taskId: id });
         const state = TRANSITIONS[verb][current.state];
-        if (state === undefined)
+        if (state === undefined) {
             return refused({ kind: "invalid-lifecycle-transition", taskId: id, state: current.state, verb });
-        const next = { ...current, state, ...(note === undefined ? {} : { note }), updatedAt: advancedTimestamp(current.updatedAt) };
+        }
+        const at = currentTimestamp();
+        const next = {
+            ...current,
+            state,
+            ...(note === undefined ? {} : { note }),
+            updatedAt: advanceTaskTimestamp(current.updatedAt, at),
+        };
         const bytes = serializeTaskDocument(next);
         return await replaceAuthority({ path: authorityPath(world, id), expected: snapshot.bytes.get(id), next: bytes }) === "replaced"
             ? { kind: "accepted", value: taskView(next) } : retry("concurrent-modification");
@@ -157,7 +176,12 @@ export async function settleTask(world, id) {
         if (current.state === "drop") {
             return { kind: "refused", refusal: { kind: "invalid-lifecycle-transition", taskId: id, state: current.state, verb: "done" } };
         }
-        const next = { ...current, state: "done", updatedAt: advancedTimestamp(current.updatedAt) };
+        const at = currentTimestamp();
+        const next = {
+            ...current,
+            state: "done",
+            updatedAt: advanceTaskTimestamp(current.updatedAt, at),
+        };
         const replaced = await replaceAuthority({ path: authorityPath(world, id), expected: snapshot.bytes.get(id), next: serializeTaskDocument(next) });
         return replaced === "replaced"
             ? { kind: "changed", task: taskView(next), action: "done" }
@@ -183,9 +207,14 @@ export async function readyTasks(world, scope, parent, limit = DEFAULT_TASK_LIMI
     const board = (await readBoard(world)).board;
     if (parent !== undefined && !board.tasks.has(parent))
         return { kind: "refused", refusal: { kind: "task-missing", taskId: parent } };
+    const relations = createTaskRelations(board);
     const ready = { kind: "predicate", predicate: { field: "ready", operator: "=", value: true } };
     const expression = parent === undefined ? ready : { kind: "and", terms: [ready, underExpression(parent)] };
-    const selectedRows = projectQuery(board, selected, expression, "priority", Math.max(1, board.tasks.size)).rows;
+    const selectedRows = projectQuery(board, relations, {
+        scope: selected,
+        expression,
+        limit: Math.max(1, board.tasks.size),
+    }).rows;
     const rows = selectedRows.map(({ parent: _parent, needs: _needs, blocks: _blocks, createdAt: _createdAt, updatedAt: _updatedAt, ...row }) => row);
     return { kind: "accepted", value: projectPage(rows, limit) };
 }
@@ -196,26 +225,43 @@ export async function blockedTasks(world, scope, parent, limit = DEFAULT_TASK_LI
     const board = (await readBoard(world)).board;
     if (parent !== undefined && !board.tasks.has(parent))
         return { kind: "refused", refusal: { kind: "task-missing", taskId: parent } };
+    const relations = createTaskRelations(board);
     const blocked = { kind: "predicate", predicate: { field: "blocked", operator: "=", value: true } };
     const expression = parent === undefined ? blocked : { kind: "and", terms: [blocked, underExpression(parent)] };
-    const selectedRows = projectQuery(board, selected, expression, "priority", Math.max(1, board.tasks.size)).rows;
+    const selectedRows = projectQuery(board, relations, {
+        scope: selected,
+        expression,
+        limit: Math.max(1, board.tasks.size),
+    }).rows;
     const ids = new Set(selectedRows.map((row) => row.id));
-    return { kind: "accepted", value: projectPage(projectBlocked(board, selected).filter((row) => ids.has(row.id)), limit) };
+    return {
+        kind: "accepted",
+        value: projectPage(projectBlocked(board, selected, relations).filter((row) => ids.has(row.id)), limit),
+    };
 }
 export async function queryTasks(world, expression, scope, sort = "priority", limit = DEFAULT_TASK_LIMIT) {
     const selected = await readScope(world, scope);
     if (selected !== null && !Array.isArray(selected))
         return { kind: "refused", refusal: selected };
     const board = (await readBoard(world)).board;
+    const relations = createTaskRelations(board);
     for (const target of queryUnderTargets(expression))
         if (!board.tasks.has(target)) {
             return { kind: "refused", refusal: { kind: "task-missing", taskId: target } };
         }
-    return { kind: "accepted", value: projectQuery(board, selected, expression, sort, limit) };
+    return {
+        kind: "accepted",
+        value: projectQuery(board, relations, {
+            scope: selected,
+            expression,
+            sort,
+            limit,
+        }),
+    };
 }
 /** Internal composite observation from one complete Task board read. */
-export async function observeTaskStatusRows(world) {
-    return projectStatusRows((await readBoard(world)).board, null);
+export async function observeTaskBoard(world) {
+    return projectTaskBoardObservation((await readBoard(world)).board);
 }
 /** Internal identity catalog from one complete Task board read. */
 export async function observeTaskCatalogRows(world) {

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

@@ -1,8 +1,10 @@
 import type { TaskPriority, TaskState } from "./document.js";
 import { type TaskId } from "./identity.js";
-import type { BlockedTaskRow, TaskBoard, TaskRef, TaskRow } from "./board.js";
+import type { BlockedTaskRow, TaskBoard, TaskRef, TaskRelationProjection, TaskRow } from "./board.js";
 export declare const DEFAULT_TASK_LIMIT = 100;
 export declare const MAX_TASK_LIMIT = 1000;
+export declare const TASK_RELATION_PREDICATE_FIELDS: readonly ["under", "needs", "blocks"];
+export type TaskRelationPredicateField = (typeof TASK_RELATION_PREDICATE_FIELDS)[number];
 export type TaskQueryComparison = "=" | "!=" | "<" | "<=" | ">" | ">=" | "~";
 export type TaskQueryPredicate = Readonly<{
     field: "state";
@@ -58,7 +60,12 @@ export type TaskPage<Row> = Readonly<{
     truncated: boolean;
 }>;
 export declare function normalizeTaskQuery(value: unknown): TaskQueryExpression;
-export declare function projectQuery(board: TaskBoard, scope: readonly string[] | null, expression: TaskQueryExpression, sort?: TaskQuerySort, limit?: number): TaskPage<TaskQueryRow>;
+export declare function projectQuery(board: TaskBoard, relations: TaskRelationProjection, input: Readonly<{
+    scope: readonly string[] | null;
+    expression: TaskQueryExpression;
+    sort?: TaskQuerySort;
+    limit?: number;
+}>): TaskPage<TaskQueryRow>;
 export declare function projectPage<Row>(rows: readonly Row[], limit?: number): TaskPage<Row>;
 export declare function underExpression(parent: TaskId): TaskQueryExpression;
 export declare function queryUnderTargets(expression: TaskQueryExpression): readonly TaskId[];

package/build/src/task/query.js

@@ -1,7 +1,11 @@
 import { formatTaskId, parseTaskId, sameNamespace } from "./identity.js";
-import { taskDisposition } from "./board.js";
+import { taskBlocked, taskDisposition, taskRef } from "./board.js";
 export const DEFAULT_TASK_LIMIT = 100;
 export const MAX_TASK_LIMIT = 1_000;
+export const TASK_RELATION_PREDICATE_FIELDS = ["under", "needs", "blocks"];
+function isTaskRelationPredicateField(value) {
+    return TASK_RELATION_PREDICATE_FIELDS.includes(value);
+}
 const states = ["open", "in_progress", "on_hold", "done", "drop"];
 const comparisons = ["=", "!=", "<", "<=", ">", ">=", "~"];
 function fail(message) { throw new TypeError(message); }
@@ -97,14 +101,14 @@ function predicate(value) {
         case "title": return normalizeTextPredicate(input, "title", operator);
         case "id": return normalizeTextPredicate(input, "id", operator);
         case "parent": return normalizeParentPredicate(input, operator);
-        case "under": return normalizeRelationPredicate(input, "under", operator);
-        case "needs": return normalizeRelationPredicate(input, "needs", operator);
-        case "blocks": return normalizeRelationPredicate(input, "blocks", operator);
         case "ready": return normalizeBooleanPredicate(input, "ready", operator);
         case "blocked": return normalizeBooleanPredicate(input, "blocked", operator);
         case "created": return normalizeTimestampPredicate(input, "created", operator);
         case "updated": return normalizeTimestampPredicate(input, "updated", operator);
-        default: return fail(`unknown query field: ${field}`);
+        default:
+            if (isTaskRelationPredicateField(field))
+                return normalizeRelationPredicate(input, field, operator);
+            return fail(`unknown query field: ${field}`);
     }
 }
 export function normalizeTaskQuery(value) {
@@ -139,46 +143,24 @@ function compare(left, operator, right) {
     return left >= right;
 }
 function membership(left, operator, right) { return operator === "=" ? left === right : left !== right; }
-function indexChildren(board) {
-    const children = new Map();
-    for (const task of board.tasks.values()) {
-        if (task.parent === null)
-            continue;
-        const siblings = children.get(task.parent) ?? [];
-        siblings.push(task.id);
-        children.set(task.parent, siblings);
-    }
-    return children;
-}
-function indexReverseNeeds(board) {
-    const reverse = new Map();
-    for (const task of board.tasks.values()) {
-        for (const need of task.needs) {
-            const blockers = reverse.get(need) ?? new Set();
-            blockers.add(task.id);
-            reverse.set(need, blockers);
-        }
-    }
-    return reverse;
-}
-function descendants(children, parent) {
+function descendants(relations, parent) {
     const result = new Set(), pending = [parent];
     while (pending.length > 0) {
         const current = pending.shift();
-        for (const child of children.get(current) ?? []) {
-            if (result.has(child))
+        for (const child of relations.children(current)) {
+            if (result.has(child.id))
                 continue;
-            result.add(child);
-            pending.push(child);
+            result.add(child.id);
+            pending.push(child.id);
         }
     }
     return result;
 }
-function relation(board, reverseNeeds, id, field, target) {
+function relation(board, relations, id, field, target) {
     const task = board.tasks.get(id);
     if (task === undefined)
         return false;
-    return field === "needs" ? task.needs.includes(target) : reverseNeeds.get(target)?.has(id) === true;
+    return field === "needs" ? task.needs.includes(target) : relations.blocks(id).some((ref) => ref.id === target);
 }
 function matchText(left, operator, right) {
     return operator === "~" ? left.includes(right) : compare(left, operator, right);
@@ -186,18 +168,7 @@ function matchText(left, operator, right) {
 function matchRelation(selected, operator) {
     return operator === "=" ? selected : !selected;
 }
-function isBlocked(board, task) {
-    const active = task.state === "open" || task.state === "in_progress";
-    return active && task.needs.some((need) => {
-        const target = board.tasks.get(need);
-        return target === undefined || (target.state !== "done" && target.state !== "drop");
-    });
-}
-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 matchesPredicate(board, reverseNeeds, task, value, under) {
+function matchesPredicate(board, relations, task, value, under) {
     switch (value.field) {
         case "state": return compare(task.state, value.operator, value.value);
         case "priority": return compare(task.priority, value.operator, value.value);
@@ -205,32 +176,30 @@ function matchesPredicate(board, reverseNeeds, task, value, under) {
         case "id": return matchText(task.id, value.operator, value.value);
         case "parent": return compare(task.parent ?? "", value.operator, value.value ?? "");
         case "under": return matchRelation(under.get(value.value)?.has(task.id) === true, value.operator);
-        case "needs": return matchRelation(relation(board, reverseNeeds, task.id, "needs", value.value), value.operator);
-        case "blocks": return matchRelation(relation(board, reverseNeeds, task.id, "blocks", value.value), value.operator);
+        case "needs": return matchRelation(relation(board, relations, task.id, "needs", value.value), value.operator);
+        case "blocks": return matchRelation(relation(board, relations, task.id, "blocks", value.value), value.operator);
         case "ready": return membership(taskDisposition(board, task) === "ready", value.operator, value.value);
-        case "blocked": return membership(isBlocked(board, task), value.operator, value.value);
+        case "blocked": return membership(taskBlocked(board, task), value.operator, value.value);
         case "created": return compare(task.createdAt, value.operator, value.value);
         case "updated": return compare(task.updatedAt, value.operator, value.value);
     }
 }
-function matches(board, reverseNeeds, task, expression, under) {
+function matches(board, relations, task, expression, under) {
     if (expression.kind === "not")
-        return !matches(board, reverseNeeds, task, expression.term, under);
+        return !matches(board, relations, task, expression.term, under);
     if (expression.kind !== "predicate") {
         return expression.kind === "and"
-            ? expression.terms.every((term) => matches(board, reverseNeeds, task, term, under))
-            : expression.terms.some((term) => matches(board, reverseNeeds, task, term, under));
+            ? expression.terms.every((term) => matches(board, relations, task, term, under))
+            : expression.terms.some((term) => matches(board, relations, task, term, under));
     }
-    return matchesPredicate(board, reverseNeeds, task, expression.predicate, under);
+    return matchesPredicate(board, relations, task, expression.predicate, under);
 }
-function row(board, reverseNeeds, task) {
+function row(board, relations, task) {
     return {
         id: task.id, title: task.title, state: task.state, priority: task.priority, disposition: taskDisposition(board, task),
         parent: task.parent,
         needs: task.needs.map((need) => taskRef(board, need)),
-        blocks: [...(reverseNeeds.get(task.id) ?? [])]
-            .sort((left, right) => Buffer.compare(Buffer.from(left), Buffer.from(right)))
-            .map((id) => taskRef(board, id)),
+        blocks: relations.blocks(task.id),
         createdAt: task.createdAt, updatedAt: task.updatedAt,
     };
 }
@@ -245,13 +214,12 @@ function sortTasks(tasks, sort) {
         return (sort === "updated" ? -compared : compared) || tie;
     });
 }
-export function projectQuery(board, scope, expression, sort = "priority", limit = DEFAULT_TASK_LIMIT) {
-    const children = indexChildren(board);
-    const reverseNeeds = indexReverseNeeds(board);
-    const under = new Map(queryUnderTargets(expression).map((target) => [target, descendants(children, target)]));
+export function projectQuery(board, relations, input) {
+    const { scope, expression, sort = "priority", limit = DEFAULT_TASK_LIMIT } = input;
+    const under = new Map(queryUnderTargets(expression).map((target) => [target, descendants(relations, target)]));
     const selected = sortTasks([...board.tasks.values()].filter((task) => scope === null || sameNamespace(parseTaskId(task.id).namespace, scope))
-        .filter((task) => matches(board, reverseNeeds, task, expression, under)), sort);
-    const rows = selected.slice(0, limit).map((task) => row(board, reverseNeeds, task));
+        .filter((task) => matches(board, relations, task, expression, under)), sort);
+    const rows = selected.slice(0, limit).map((task) => row(board, relations, task));
     return { rows, total: selected.length, returned: rows.length, truncated: rows.length < selected.length };
 }
 export function projectPage(rows, limit = DEFAULT_TASK_LIMIT) {

package/build/src/task/store.js

@@ -34,8 +34,6 @@ async function authorityFiles(directory) {
             files.push(...await authorityFiles(path));
         else if (entry.isFile() && entry.name.endsWith(".md"))
             files.push(path);
-        else
-            throw new Error(`unexpected Task authority entry: ${path}`);
     }
     return files.sort((a, b) => Buffer.compare(Buffer.from(a), Buffer.from(b)));
 }

package/build/src/verification/execution.d.ts

@@ -1,7 +1,7 @@
 import type { SnapshotId } from "../core/facts/types.js";
 import { type HookFailure } from "../git/hooks.js";
 import type { MaterializedScratchCandidate, WorktreeLeak } from "../git/scratch.js";
-import type { GitRepository } from "../git/repository.js";
+import type { GitRepository } from "../git/process.js";
 import type { Settings } from "../settings.js";
 import type { VerificationDeclaration } from "./declaration.js";
 type VerificationVerdict = "satisfied" | "unsatisfied";

package/build/src/verification/execution.js

@@ -1,4 +1,5 @@
-import { runHookCommands, worktreeHooksFrom } from "../git/hooks.js";
+import { runHookCommands } from "../git/hooks.js";
+import { worktreeHooksFrom } from "../library/configuration.js";
 import { runProcess } from "../runtime/proc/run.js";
 const SUMMARY_BYTES = 32 * 1024;
 function argvFor(declaration) {

package/build/src/workspace-place.d.ts

@@ -1,5 +1,5 @@
 import { type ContractId } from "./core/facts/types.js";
-import type { GitRepository } from "./git/repository.js";
+import type { GitRepository } from "./git/process.js";
 export declare const CONTRACT_PLACES: readonly string[];
 export type Place = string & {
     readonly [placeBrand]: "Place";
@@ -27,15 +27,12 @@ export type ManagedWorktreeAppointment = Readonly<{
 export declare function placeRegisterPath(repository: GitRepository): string;
 export declare function place(value: string): Place;
 export declare function nextPlace(current?: Place): Place;
-export declare function firstFreePlace(register: PlaceRegister): Place;
 export declare function canonicalPlaceRegister(register: PlaceRegister): string;
 export declare function decodePlaceRegister(path: string, bytes: string): PlaceRegister;
 export declare function emptyPlaceRegister(): PlaceRegister;
 export declare function readPlaceRegister(repository: GitRepository): Promise<PlaceRegister>;
 export declare function appointmentFor(register: PlaceRegister, contract: ContractId): PlaceAppointment | undefined;
 export declare function appointManagedWorktrees(repository: GitRepository, contracts: readonly ContractId[]): Promise<PlaceRegister>;
-export declare function appointManagedWorktree(repository: GitRepository, contract: ContractId): Promise<PlaceAppointment>;
 export declare function releaseManagedWorktrees(repository: GitRepository, contracts: readonly ContractId[]): Promise<void>;
-export declare function releaseManagedWorktree(repository: GitRepository, contract: ContractId): Promise<void>;
 export declare function readManagedWorktreeAppointment(repository: GitRepository, contract: ContractId, register?: PlaceRegister): Promise<ManagedWorktreeAppointment>;
 export {};

package/build/src/workspace-place.js

@@ -230,12 +230,6 @@ export function nextPlace(current) {
         ? composePlace(CONTRACT_PLACES[index + 1], parsed.generation)
         : composePlace(CONTRACT_PLACES[0], parsed.generation + 1n);
 }
-export function firstFreePlace(register) {
-    for (let candidate = nextPlace();; candidate = nextPlace(candidate)) {
-        if (!register.byPlace.has(candidate))
-            return candidate;
-    }
-}
 export function canonicalPlaceRegister(register) {
     const appointments = Object.fromEntries(register.appointments
         .slice()
@@ -354,12 +348,6 @@ function withAppointments(register, contracts) {
 export async function appointManagedWorktrees(repository, contracts) {
     return await mutatePlaceRegister(repository, (current) => withAppointments(current, contracts));
 }
-export async function appointManagedWorktree(repository, contract) {
-    const appointed = appointmentFor(await appointManagedWorktrees(repository, [contract]), contract);
-    if (appointed === undefined)
-        throw new Error(`Place appointment was not recorded: ${contract}`);
-    return appointed;
-}
 export async function releaseManagedWorktrees(repository, contracts) {
     if (contracts.length === 0)
         return;
@@ -369,9 +357,6 @@ export async function releaseManagedWorktrees(repository, contracts) {
         return kept.length === current.appointments.length ? current : indexedRegister(kept);
     });
 }
-export async function releaseManagedWorktree(repository, contract) {
-    await releaseManagedWorktrees(repository, [contract]);
-}
 export async function readManagedWorktreeAppointment(repository, contract, register) {
     try {
         const snapshot = register ?? await readPlaceRegister(repository);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/keiyaku",
-  "version": "4.0.3",
+  "version": "4.0.5",
   "files": [
     "build"
   ],
@@ -36,13 +36,14 @@
     "review:model-impact": "node --import tsx scripts/model-change-impact.ts",
     "test": "npm run build && npm run test:architecture && npm run test:maintainability && npm run test:reachability && node --import tsx scripts/run-tests.mjs",
     "test:architecture": "node --import tsx scripts/check-architecture.ts",
-    "test:e2e": "npm run build && node --import tsx --test tests/packaged-cli.e2e.ts",
+    "test:e2e": "npm run build && node scripts/run-tests.mjs tests/packaged-cli.e2e.ts",
     "test:maintainability": "node scripts/check-maintainability.js",
-    "test:focused": "node --import tsx --test --test-reporter=dot",
+    "test:focused": "node scripts/run-tests.mjs",
     "test:reachability": "knip --include files,dependencies,unlisted,unresolved,duplicates",
     "test:typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "devDependencies": {
+    "@types/cross-spawn": "^6.0.6",
     "@types/node": "^25.0.0",
     "@typescript-eslint/parser": "^8.66.0",
     "eslint": "^9.39.5",
@@ -55,6 +56,7 @@
     "@anthropic-ai/claude-agent-sdk": "^0.3.226",
     "@earendil-works/pi-coding-agent": "0.80.10",
     "@opencode-ai/sdk": "1.18.3",
+    "cross-spawn": "^7.0.6",
     "diff": "^8.0.4",
     "yaml": "^2.9.0"
   },