@astrosheep/keiyaku 4.6.3 → 4.6.6

package/build/src/task/catalog.js

@@ -41,7 +41,7 @@ async function catalogRow(world, task, documents) {
         ...(blockers.length === 0 ? {} : { blockers }),
     };
 }
-async function recentTaskStatus(world, input) {
+export async function observeRecentTaskStatus(world, input = {}) {
     const { namespace } = input;
     if (namespace !== undefined && !namespace.every(isTaskSegment)) {
         throw new TypeError("namespace must contain canonical segments");
@@ -57,6 +57,3 @@ async function recentTaskStatus(world, input) {
         hasMore: documents.hasMore,
     };
 }
-export async function observeRecentTaskStatus(world, input = {}) {
-    return recentTaskStatus(world, input);
-}

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

@@ -3,7 +3,6 @@ import type { TaskCompositionResult } from "./mutation-result.js";
 import { type AcceptedComposition } from "./compose-language.js";
 export type { TaskCompositionAdmission, TaskCompositionBodyPreview, TaskCompositionPlanAlias, TaskCompositionPlanOrder, } from "./compose-language.js";
 export type { TaskCompositionAlias } from "./compose-language.js";
-export { taskCompositionNamespaceHeader } from "./compose-language.js";
 export type TaskDocumentChange = Readonly<AcceptedComposition["documentChanges"][number]>;
 export type TaskCompositionFacts = Readonly<Pick<AcceptedComposition, "aliases" | "admissionOrder" | "admissions">>;
 export type { TaskCompositionResult } from "./mutation-result.js";

package/build/src/task/compose.js

@@ -3,7 +3,6 @@ import { planTaskComposition, } from "./compose-language.js";
 import { serializeTaskDocument } from "./document.js";
 import { parseTaskId, taskAuthorityPath } from "./identity.js";
 import { readBoard, replaceAuthority, withTaskLocks } from "./store.js";
-export { taskCompositionNamespaceHeader } from "./compose-language.js";
 function refusal(diagnostics) {
     return { kind: "refused", refusal: { kind: "invalid-composition", diagnostics } };
 }

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

@@ -19,4 +19,3 @@ export declare function resolveTaskNamespaceContext(input: NamespaceContextInput
     kind: "invalid-namespace-context";
     path: string;
 }>>;
-export declare function writeTaskNamespaceContext(directory: string, value: readonly string[]): Promise<void>;

package/build/src/task/context.js

@@ -101,6 +101,3 @@ export async function resolveTaskNamespaceContext(input) {
         current = resolvedParent;
     }
 }
-export async function writeTaskNamespaceContext(directory, value) {
-    await installNamespaceContext(directory, value);
-}

package/build/src/task/created-observation.d.ts

@@ -34,5 +34,9 @@ export declare const createdTaskObservationSchema: z.ZodUnion<readonly [z.ZodObj
 }, z.core.$strict>]>;
 export type CreatedTaskObservation = z.infer<typeof createdTaskObservationSchema>;
 export declare const EMPTY_CREATED_TASK_OBSERVATION: CreatedTaskObservation;
-/** Project Task board rows created by each identity, preserving input order. */
+/**
+ * Project Task 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[]>;

package/build/src/task/created-observation.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
-import { taskRowsSchema } from "./board.js";
-import { observeTaskBoard } from "./operations.js";
+import { createTaskRelations, projectCreatedByRows, taskRowsSchema } from "./board.js";
+import { readBoard } from "./store.js";
 export const createdTaskObservationSchema = z.union([
     z.object({ kind: z.literal("present"), rows: taskRowsSchema }).strict(),
     z.object({ kind: z.literal("failed"), diagnostic: z.string() }).strict(),
@@ -9,15 +9,22 @@ export const EMPTY_CREATED_TASK_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. */
+/**
+ * Project Task 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) {
+    if (createdByIds.length === 0)
+        return [];
     let board;
     try {
-        board = await observeTaskBoard(world);
+        board = (await readBoard(world)).board;
     }
     catch (error) {
         const failed = { kind: "failed", diagnostic: observationDiagnostic(error) };
         return createdByIds.map(() => failed);
     }
-    return createdByIds.map((createdBy) => ({ kind: "present", rows: board.selectCreatedBy(createdBy) }));
+    const rows = projectCreatedByRows(board, createTaskRelations(board), createdByIds);
+    return createdByIds.map((createdBy) => ({ kind: "present", rows: rows.get(createdBy) ?? [] }));
 }

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

@@ -26,7 +26,7 @@ export type { AddTaskDocumentInput, AddTaskInput, BlockedTaskRow, TaskBatchResul
 export type { LibraryExecution } from "../akuma/requests.js";
 export { TaskAuthorityCorruptionError, TASK_RELATION_PREDICATE_FIELDS };
 export { observeRecentTaskStatus, type RecentTaskStatusRow } from "./catalog.js";
-export { taskRowViewLimit } from "./input.js";
+export { boundedListLimit as taskRowViewLimit } from "../bounded-list.js";
 type ComposeValues = Readonly<{
     markdown: string;
     namespace?: readonly string[];

package/build/src/task/index.js

@@ -4,12 +4,13 @@ import { buildTree, createTaskRelations, diagnoseBoard, } from "./board.js";
 import { composeTasks, } from "./compose.js";
 import { TaskAuthorityCorruptionError } from "./document.js";
 import { addTask, addTaskDocument, batchTasks, blockedTasks, lifecycleTask, listTasks, queryTasks, readTaskDetail, readyTasks, taskView, updateTask, } from "./operations.js";
+import { boundedListLimit } from "../bounded-list.js";
 import { readBoard } from "./store.js";
-import { actor, addInput, closed, namespace, record, signal, sort, taskRowViewLimit, taskId as id, taskIds, text, updateInput, } from "./input.js";
+import { actor, addInput, closed, namespace, record, signal, sort, taskId as id, taskIds, text, updateInput, } from "./input.js";
 import { normalizeTaskQuery, taskQuerySelection, TASK_RELATION_PREDICATE_FIELDS, } from "./query.js";
 export { TaskAuthorityCorruptionError, TASK_RELATION_PREDICATE_FIELDS };
 export { observeRecentTaskStatus } from "./catalog.js";
-export { taskRowViewLimit } from "./input.js";
+export { boundedListLimit as taskRowViewLimit } from "../bounded-list.js";
 function taskRoute(execution) {
     const channel = executionChannel(execution);
     return channel.kind === "body-request" ? { kind: "forwarded", directory: channel.directory } : { kind: "local" };
@@ -162,7 +163,7 @@ class TasksHandle {
             throw new TypeError("selection must be active, closed, or all");
         if (v.scope !== undefined && v.scope !== "namespace" && v.scope !== "world")
             throw new TypeError("scope must be namespace or world");
-        const selectedLimit = taskRowViewLimit(v.limit);
+        const selectedLimit = boundedListLimit(v.limit);
         return listTasks(this.world, namespace(v.namespace), v.selection ?? "active", v.scope, selectedLimit);
     }
     async ready(input = {}) {
@@ -171,7 +172,7 @@ class TasksHandle {
         if (v.scope !== undefined && v.scope !== "namespace" && v.scope !== "world")
             throw new TypeError("scope must be namespace or world");
         const parent = v.parent === undefined ? undefined : id(v.parent);
-        const selectedLimit = taskRowViewLimit(v.limit);
+        const selectedLimit = boundedListLimit(v.limit);
         return readyTasks(this.world, namespace(v.namespace), v.scope, parent, selectedLimit);
     }
     async blocked(input = {}) {
@@ -180,7 +181,7 @@ class TasksHandle {
         if (v.scope !== undefined && v.scope !== "namespace" && v.scope !== "world")
             throw new TypeError("scope must be namespace or world");
         const parent = v.parent === undefined ? undefined : id(v.parent);
-        const selectedLimit = taskRowViewLimit(v.limit);
+        const selectedLimit = boundedListLimit(v.limit);
         return blockedTasks(this.world, namespace(v.namespace), v.scope, parent, selectedLimit);
     }
     async query(input = {}) {
@@ -190,7 +191,7 @@ class TasksHandle {
             throw new TypeError("scope must be namespace or world");
         const expression = v.where === undefined ? taskQuerySelection() : normalizeTaskQuery(v.where);
         const selected = namespace(v.namespace);
-        const selectedLimit = taskRowViewLimit(v.limit);
+        const selectedLimit = boundedListLimit(v.limit);
         return queryTasks({
             world: this.world,
             ...(selected === undefined ? {} : { namespace: selected }),

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

@@ -1,4 +1,3 @@
-import { type TaskPriority, type TaskState } from "./document.js";
 import { type TaskId } from "./identity.js";
 import type { AddTaskInput, UpdateTaskInput } from "./operations.js";
 import type { TaskQuerySort } from "./query.js";
@@ -10,11 +9,6 @@ export declare function taskIds(value: unknown, label: string): readonly TaskId[
 export declare function namespace(value: unknown): readonly string[] | undefined;
 export declare function text(value: unknown, label: string): string | undefined;
 export declare function actor(value: unknown): string | undefined;
-export declare function priority(value: unknown): TaskPriority | undefined;
-export declare function limit(value: unknown): number | undefined;
-/** Validates and supplies the shared bounded-list limit for Task row views. */
-export declare function taskRowViewLimit(value: unknown): number;
 export declare function sort(value: unknown): TaskQuerySort | undefined;
-export declare function state(value: unknown): TaskState | undefined;
 export declare function addInput(input: unknown): AddTaskInput;
 export declare function updateInput(input: unknown): UpdateTaskInput;

package/build/src/task/input.js

@@ -1,5 +1,4 @@
 import { isTaskSegment, parseTaskId } from "./identity.js";
-import { boundedListLimit } from "../bounded-list.js";
 export function record(value, label) {
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
         throw new TypeError(`${label} must be an object`);
@@ -63,7 +62,7 @@ export function actor(value) {
     }
     return value;
 }
-export function priority(value) {
+function priority(value) {
     if (value === undefined)
         return undefined;
     if (!Number.isInteger(value) || typeof value !== "number" || value < 0 || value > 3) {
@@ -71,17 +70,6 @@ export function priority(value) {
     }
     return value;
 }
-export function limit(value) {
-    if (value === undefined)
-        return undefined;
-    if (typeof value !== "number")
-        throw new TypeError("limit must be a number");
-    return value;
-}
-/** Validates and supplies the shared bounded-list limit for Task row views. */
-export function taskRowViewLimit(value) {
-    return boundedListLimit(value);
-}
 export function sort(value) {
     if (value === undefined)
         return undefined;
@@ -90,7 +78,7 @@ export function sort(value) {
     }
     return value;
 }
-export function state(value) {
+function state(value) {
     if (value === undefined)
         return undefined;
     if (value !== "open" && value !== "in_progress" && value !== "on_hold" && value !== "done" && value !== "drop") {

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

@@ -4,7 +4,6 @@ import type { AddTaskDocumentInput, AddTaskInput, TaskBatchResult, TaskMutationR
 import type { TaskCompositionResult } from "./compose.js";
 import { type TaskMutationExecutionResult } from "./mutation-result.js";
 import { z } from "zod";
-export type { TaskMutationExecutionResult } from "./mutation-result.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"];
 declare const taskMutationActionSchema: z.ZodEnum<{
     "task.add": "task.add";
@@ -489,7 +488,7 @@ declare const taskBodyRequestSchema: z.ZodObject<{
     }>>]>)[]>;
 }, z.core.$strict>;
 export type TaskMutationBodyRequest = z.infer<typeof taskBodyRequestSchema>;
-export declare const taskMutationServiceSchema: z.ZodObject<{
+declare const taskMutationServiceSchema: z.ZodObject<{
     action: z.ZodEnum<{
         "task.add": "task.add";
         "task.addDocument": "task.addDocument";
@@ -503,7 +502,7 @@ export declare const taskMutationServiceSchema: z.ZodObject<{
         "task.update": "task.update";
     }>;
 }, z.core.$strict>;
-export type TaskMutationService = z.infer<typeof taskMutationServiceSchema>;
+type TaskMutationService = z.infer<typeof taskMutationServiceSchema>;
 export declare const forwardedTaskReferenceSchema: z.ZodObject<{
     kind: z.ZodLiteral<"served-reference">;
     action: z.ZodEnum<{
@@ -588,4 +587,4 @@ export declare function requestForwardedTask<Request extends TaskMutationRequest
     request: Request;
     signal?: AbortSignal;
 }>): Promise<TaskMutationResultForRequest<Request> | ForwardedTaskReference>;
-export declare function decodeTaskMutationRequest(action: TaskMutationAction, value: unknown): TaskMutationRequest;
+export {};

package/build/src/task/mutation.js

@@ -110,7 +110,7 @@ const worldPathSchema = z.string().min(1);
 const taskBodyRequestSchema = z
     .object({ world: worldPathSchema, request: z.union(Object.values(taskRequestSchemas)) })
     .strict();
-export const taskMutationServiceSchema = z.object({ action: taskMutationActionSchema }).strict();
+const taskMutationServiceSchema = z.object({ action: taskMutationActionSchema }).strict();
 export const forwardedTaskReferenceSchema = z
     .object({ kind: z.literal("served-reference"), action: taskMutationActionSchema })
     .strict();
@@ -245,46 +245,18 @@ export async function requestForwardedTask(input) {
         return response.reference;
     return response.result;
 }
-export function decodeTaskMutationRequest(action, value) {
-    const parsed = taskRequestSchemas[action].safeParse(value);
-    if (!parsed.success)
-        throw new TypeError(`invalid ${action} request`);
-    return parsed.data;
+/** Absent optional fields are omitted, never republished as an explicit undefined. */
+function definedFields(fields, additions = {}) {
+    const selected = {};
+    for (const [key, value] of Object.entries({ ...fields, ...additions })) {
+        if (value !== undefined)
+            selected[key] = value;
+    }
+    return selected;
 }
 function addTaskOptions(input, actor, signal) {
-    const { body, note, state, priority, needs, parent, supersedes, relates, ...required } = input;
-    return {
-        ...required,
-        actor,
-        ...(body === undefined ? {} : { body }),
-        ...(note === undefined ? {} : { note }),
-        ...(state === undefined ? {} : { state }),
-        ...(priority === undefined ? {} : { priority }),
-        ...(needs === undefined ? {} : { needs }),
-        ...(parent === undefined ? {} : { parent }),
-        ...(supersedes === undefined ? {} : { supersedes }),
-        ...(relates === undefined ? {} : { relates }),
-        ...(signal === undefined ? {} : { signal }),
-    };
+    return definedFields(input, { actor, signal });
 }
 function updateTaskOptions(input, signal) {
-    const { title, body, appendBody, note, priority, needs, addNeeds, dropNeeds, parent, supersedes, addSupersedes, dropSupersedes, relates, addRelates, dropRelates, } = input;
-    return {
-        ...(title === undefined ? {} : { title }),
-        ...(body === undefined ? {} : { body }),
-        ...(appendBody === undefined ? {} : { appendBody }),
-        ...(note === undefined ? {} : { note }),
-        ...(priority === undefined ? {} : { priority }),
-        ...(needs === undefined ? {} : { needs }),
-        ...(addNeeds === undefined ? {} : { addNeeds }),
-        ...(dropNeeds === undefined ? {} : { dropNeeds }),
-        ...(parent === undefined ? {} : { parent }),
-        ...(supersedes === undefined ? {} : { supersedes }),
-        ...(addSupersedes === undefined ? {} : { addSupersedes }),
-        ...(dropSupersedes === undefined ? {} : { dropSupersedes }),
-        ...(relates === undefined ? {} : { relates }),
-        ...(addRelates === undefined ? {} : { addRelates }),
-        ...(dropRelates === undefined ? {} : { dropRelates }),
-        ...(signal === undefined ? {} : { signal }),
-    };
+    return definedFields(input, { signal });
 }

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

@@ -3,23 +3,18 @@ import { type TaskId } from "./identity.js";
 import type { WorldRoot } from "../world.js";
 import { type TaskPage, type TaskQueryExpression, type TaskQueryRow, type TaskQuerySort } from "./query.js";
 export { advanceTaskTimestamp, taskView } from "./view.js";
-export type { AddTaskDocumentInput, AddTaskInput, TaskCleanupFailure, SettledTaskAction, SettledTaskResult, TaskBatchResult, TaskCompositionDiagnostic, TaskLifecycleVerb, TaskMutationResult, TaskOutcome, TaskRefusal, TaskRetry, TaskUpdateResult, TaskView, UpdateTaskInput, } from "./operation-types.js";
-import type { AddTaskDocumentInput, AddTaskInput, TaskMutationResult, TaskOutcome, TaskUpdateResult, TaskView, UpdateTaskInput } from "./operation-types.js";
+export type { AddTaskDocumentInput, AddTaskInput, TaskCleanupFailure, SettledTaskResult, TaskBatchResult, TaskCompositionDiagnostic, TaskMutationResult, TaskOutcome, TaskRefusal, TaskRetry, TaskUpdateResult, TaskView, UpdateTaskInput, } from "./operation-types.js";
+import type { AddTaskDocumentInput, AddTaskInput, TaskMutationResult, TaskOutcome, TaskUpdateResult, UpdateTaskInput } from "./operation-types.js";
 export declare function nukeTask(world: WorldRoot, options?: Readonly<{
     timeoutMs?: number;
     onRemoved?(count: number): void;
 }>): Promise<number>;
-export type { TaskState } from "./document.js";
 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>;
 export { batchTasks, lifecycleTask, settleTask } from "./lifecycle-operations.js";
 export declare function listTasks(world: WorldRoot, namespace: readonly string[] | undefined, selection: "active" | "closed" | "all", scope?: "namespace" | "world", limit?: number): Promise<TaskOutcome<TaskPage<TaskRow>>>;
 export declare function readTaskDetail(world: WorldRoot, id: TaskId): Promise<TaskDetailFacts | null>;
-export declare function readTaskDetails(world: WorldRoot, ids: readonly TaskId[]): Promise<TaskOutcome<readonly TaskDetailFacts[]>>;
-export declare function observeTaskDetails(world: WorldRoot, ids: readonly TaskId[]): Promise<TaskOutcome<readonly (Omit<TaskDetailFacts, "task"> & Readonly<{
-    task: TaskView;
-}>)[]>>;
 export declare function readyTasks(world: WorldRoot, namespace: readonly string[] | undefined, scope?: "namespace" | "world", parent?: TaskId, limit?: number): Promise<TaskOutcome<TaskPage<TaskRow>>>;
 export declare function blockedTasks(world: WorldRoot, namespace: readonly string[] | undefined, scope?: "namespace" | "world", parent?: TaskId, limit?: number): Promise<TaskOutcome<TaskPage<BlockedTaskRow>>>;
 export declare function queryTasks(input: Readonly<{

package/build/src/task/operations.js

@@ -4,8 +4,7 @@ import { createTaskRelations, projectOwnedDetailFacts, projectTaskBoardObservati
 import { parseTaskCreationDocument, serializeTaskDocument, } from "./document.js";
 import { allocateLocalId, deriveLocalStem, formatTaskId } from "./identity.js";
 import { nukeTaskAuthority, readBoard, readTaskDocument, replaceAuthority, withTaskLocks } from "./store.js";
-import { projectBoundedList } from "../bounded-list.js";
-import { taskRowViewLimit } from "./input.js";
+import { boundedListLimit, projectBoundedList } from "../bounded-list.js";
 import { projectQuery, projectQueryRows, queryUnderTargets, underExpression, } from "./query.js";
 import { advanceTaskTimestamp, taskView } from "./view.js";
 export { advanceTaskTimestamp, taskView } from "./view.js";
@@ -184,7 +183,7 @@ function readScope(namespace, scope) {
     return scope === "world" ? null : (namespace ?? []);
 }
 export async function listTasks(world, namespace, selection, scope, limit) {
-    const selectedLimit = taskRowViewLimit(limit);
+    const selectedLimit = boundedListLimit(limit);
     const selected = readScope(namespace, scope);
     const board = (await readBoard(world)).board;
     return {
@@ -212,62 +211,51 @@ export async function readTaskDetail(world, id) {
     }
     return projectOwnedDetailFacts({ tasks: selected }, id);
 }
-export async function readTaskDetails(world, ids) {
-    const details = [];
-    for (const id of ids) {
-        const detail = await readTaskDetail(world, id);
-        if (detail === null)
-            return { kind: "refused", refusal: { kind: "task-missing", taskId: id } };
-        details.push(detail);
-    }
-    return { kind: "accepted", value: details };
-}
-export async function observeTaskDetails(world, ids) {
-    const observed = await readTaskDetails(world, ids);
-    if (observed.kind !== "accepted")
-        return observed;
-    return { kind: "accepted", value: observed.value.map((facts) => ({ ...facts, task: taskView(facts.task) })) };
+/** One board observation and predicate projection shared by the ready and blocked views. */
+async function readTaskQueryContext(input) {
+    const board = (await readBoard(input.world)).board;
+    if (input.parent !== undefined && !board.tasks.has(input.parent))
+        return { kind: "refused", refusal: { kind: "task-missing", taskId: input.parent } };
+    const relations = createTaskRelations(board);
+    const scope = readScope(input.namespace, input.scope);
+    const predicate = {
+        kind: "predicate",
+        predicate: { field: input.field, operator: "=", value: true },
+    };
+    return {
+        kind: "accepted",
+        value: {
+            limit: boundedListLimit(input.limit),
+            board,
+            scope,
+            relations,
+            rows: projectQueryRows(board, relations, {
+                scope,
+                expression: input.parent === undefined ? predicate : { kind: "and", terms: [predicate, underExpression(input.parent)] },
+            }),
+        },
+    };
 }
 export async function readyTasks(world, namespace, scope, parent, limit) {
-    const selectedLimit = taskRowViewLimit(limit);
-    const selected = readScope(namespace, scope);
-    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 = projectQueryRows(board, relations, {
-        scope: selected,
-        expression,
-    });
-    const rows = selectedRows.map(({ parent: _parent, needs: _needs, blocks: _blocks, createdAt: _createdAt, ...row }) => row);
-    return { kind: "accepted", value: projectBoundedList(rows, selectedLimit) };
+    const queried = await readTaskQueryContext({ world, field: "ready", namespace, scope, parent, limit });
+    if (queried.kind !== "accepted")
+        return queried;
+    const rows = queried.value.rows.map(({ parent: _parent, needs: _needs, blocks: _blocks, createdAt: _createdAt, ...row }) => row);
+    return { kind: "accepted", value: projectBoundedList(rows, queried.value.limit) };
 }
 export async function blockedTasks(world, namespace, scope, parent, limit) {
-    const selectedLimit = taskRowViewLimit(limit);
-    const selected = readScope(namespace, scope);
-    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 = projectQueryRows(board, relations, {
-        scope: selected,
-        expression,
-    });
-    const ids = new Set(selectedRows.map((row) => row.id));
+    const queried = await readTaskQueryContext({ world, field: "blocked", namespace, scope, parent, limit });
+    if (queried.kind !== "accepted")
+        return queried;
+    const { board, scope: selected, relations, limit: selectedLimit, rows } = queried.value;
+    const ids = new Set(rows.map((row) => row.id));
     return {
         kind: "accepted",
         value: projectBoundedList(projectBlocked(board, selected, relations).filter((row) => ids.has(row.id)), selectedLimit),
     };
 }
 export async function queryTasks(input) {
-    const selectedLimit = taskRowViewLimit(input.limit);
+    const selectedLimit = boundedListLimit(input.limit);
     const selected = readScope(input.namespace, input.scope);
     const board = (await readBoard(input.world)).board;
     const relations = createTaskRelations(board);

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

@@ -4,7 +4,6 @@ import type { TaskBoard, TaskRef, TaskRelationProjection, TaskRow } from "./boar
 import { type BoundedList } from "../bounded-list.js";
 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";
     operator: "=" | "!=";

package/build/src/task/query.js

@@ -2,9 +2,6 @@ import { formatTaskId, parseTaskId, sameNamespace } from "./identity.js";
 import { projectTaskRow, taskBlocked, taskDisposition, taskRef } from "./board.js";
 import { projectBoundedList } from "../bounded-list.js";
 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) {
@@ -129,7 +126,7 @@ export function normalizeTaskQueryPredicate(value) {
         case "updated":
             return normalizeTimestampPredicate(input, "updated", operator);
         default:
-            if (isTaskRelationPredicateField(field))
+            if (field === "under" || field === "needs" || field === "blocks")
                 return normalizeRelationPredicate(input, field, operator);
             return invalidPredicate(`unknown query field: ${field}`, "field");
     }

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

@@ -7,7 +7,6 @@ export type BoardSnapshot = Readonly<{
     board: TaskBoard;
     bytes: ReadonlyMap<TaskId, Uint8Array>;
 }>;
-export declare const DEFAULT_TASK_LOCK_TIMEOUT_MS = 3000;
 export declare function readBoard(world: WorldRoot): Promise<BoardSnapshot>;
 export declare function readRecentTaskDocuments(world: WorldRoot, input: Readonly<{
     namespace?: readonly string[];
@@ -33,4 +32,3 @@ export declare function withTaskLocks<T>(input: Readonly<{
     timeoutMs?: number;
     signal?: AbortSignal;
 }>, action: () => Promise<T>): Promise<T | "busy">;
-export declare function authorityPath(world: WorldRoot, id: TaskId): string;

package/build/src/task/store.js

@@ -7,7 +7,7 @@ import { syncDirectory } from "../coordination/durable-file.js";
 import { boundedListLimit, projectBoundedList } from "../bounded-list.js";
 import { parseTaskDocument } from "./document.js";
 import { formatTaskId, parseTaskId, physicalTaskSegment, TASK_LOCAL_ID_BYTES, sameNamespace, taskAuthorityPath, } from "./identity.js";
-export const DEFAULT_TASK_LOCK_TIMEOUT_MS = 3_000;
+const DEFAULT_TASK_LOCK_TIMEOUT_MS = 3_000;
 function tasksDirectory(world) {
     return resolve(world, ".keiyaku", "tasks");
 }
@@ -130,16 +130,35 @@ async function removeEmptyTaskDirectories(directory, removeSelf) {
 }
 export async function readBoard(world) {
     const directory = tasksDirectory(world);
+    const paths = await authorityFiles(directory);
+    const reads = new Array(paths.length);
+    let next = 0;
+    const worker = async () => {
+        while (next < paths.length) {
+            const index = next++;
+            const path = paths[index];
+            try {
+                const stat = await lstat(path);
+                if (!stat.isFile() || stat.isSymbolicLink()) {
+                    throw new Error(`Task authority is not a regular file: ${path}`);
+                }
+                const coordinate = coordinateFromPath(directory, path);
+                reads[index] = { kind: "read", coordinate, source: await readFile(path) };
+            }
+            catch (error) {
+                reads[index] = { kind: "failed", error };
+            }
+        }
+    };
+    // Drain all owned reads; authority and errors are then judged in canonical path order.
+    await Promise.all(Array.from({ length: Math.min(8, paths.length) }, worker));
     const tasks = new Map();
     const bytes = new Map();
-    for (const path of await authorityFiles(directory)) {
-        const stat = await lstat(path);
-        if (!stat.isFile() || stat.isSymbolicLink()) {
-            throw new Error(`Task authority is not a regular file: ${path}`);
-        }
-        const coordinate = coordinateFromPath(directory, path);
+    for (const read of reads) {
+        if (read.kind === "failed")
+            throw read.error;
+        const { coordinate, source } = read;
         const id = formatTaskId(coordinate);
-        const source = await readFile(path);
         tasks.set(id, parseTaskDocument(source, coordinate));
         bytes.set(id, source);
     }
@@ -315,6 +334,3 @@ export async function withTaskLocks(input, action) {
     }
     return result;
 }
-export function authorityPath(world, id) {
-    return taskAuthorityPath(tasksDirectory(world), parseTaskId(id));
-}

package/build/src/verification/declaration.js

@@ -1,9 +1,10 @@
 import { gate } from "../core/facts/types.js";
 export const VERIFIED = gate("verified");
 export function prepareVerificationDeclaration(input) {
-    if (input.definition !== null || !input.gates.includes(VERIFIED)) {
+    if (!input.gates.includes(VERIFIED))
+        return { kind: "prepared", data: null };
+    if (input.definition !== null)
         return { kind: "prepared", data: input.definition };
-    }
     return {
         kind: "refused",
         refusal: {

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

@@ -1,4 +1,4 @@
-import type { SnapshotId } from "../core/facts/types.js";
+import type { ContractId, 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/process.js";
@@ -51,8 +51,9 @@ export type VerificationExecution = Readonly<{
 export type ExecuteVerificationInput = Readonly<{
     repository: GitRepository;
     candidate: SnapshotId;
+    contractId: ContractId;
     declarations: readonly VerificationDeclaration[];
-    materializeScratchCandidate: (repository: GitRepository, candidate: SnapshotId) => Promise<MaterializedScratchCandidate>;
+    materializeScratchCandidate: (repository: GitRepository, candidate: SnapshotId, contract: ContractId) => Promise<MaterializedScratchCandidate>;
     projectSettings: (root: string) => Promise<Settings>;
     observe?: (event: VerificationObservation) => void;
     signal?: AbortSignal;