@astrosheep/keiyaku 4.1.0 → 4.1.2

package/build/src/task/document.js

@@ -1,10 +1,25 @@
 import { isMap, parseDocument, stringify } from "yaml";
 import { formatTaskId, parseTaskId } from "./identity.js";
 export class TaskAuthorityCorruptionError extends Error {
-    constructor(message, options) { super(message, options); this.name = "TaskAuthorityCorruptionError"; }
+    constructor(message, options) {
+        super(message, options);
+        this.name = "TaskAuthorityCorruptionError";
+    }
 }
 const STATES = new Set(["open", "in_progress", "on_hold", "done", "drop"]);
-const REQUIRED_STORED_KEYS = ["id", "title", "state", "priority", "needs", "parent", "supersedes", "relates", "note", "createdAt", "updatedAt"];
+const REQUIRED_STORED_KEYS = [
+    "id",
+    "title",
+    "state",
+    "priority",
+    "needs",
+    "parent",
+    "supersedes",
+    "relates",
+    "note",
+    "createdAt",
+    "updatedAt",
+];
 const STORED_KEYS = [...REQUIRED_STORED_KEYS, "createdBy"];
 const CREATION_KEYS = ["title", "state", "priority", "needs", "parent", "supersedes", "relates", "note"];
 function frontMatter(markdown, fail) {
@@ -92,7 +107,9 @@ function fields(value, body, fail) {
     };
 }
 export function parseTaskDocument(bytes, expected) {
-    const fail = (message, cause) => { throw new TaskAuthorityCorruptionError(message, cause === undefined ? {} : { cause }); };
+    const fail = (message, cause) => {
+        throw new TaskAuthorityCorruptionError(message, cause === undefined ? {} : { cause });
+    };
     const { value, body } = frontMatter(Buffer.from(bytes).toString("utf8"), fail);
     closed(value, STORED_KEYS, REQUIRED_STORED_KEYS, fail);
     const id = taskId(value.id, "id", fail);
@@ -102,27 +119,46 @@ export function parseTaskDocument(bytes, expected) {
     if (Date.parse(updatedAt) < Date.parse(createdAt))
         fail("updatedAt must not precede createdAt");
     return {
-        id, state: state(value.state, fail), createdAt, updatedAt, ...fields(value, body, fail),
+        id,
+        state: state(value.state, fail),
+        createdAt,
+        updatedAt,
+        ...fields(value, body, fail),
         ...(Object.hasOwn(value, "createdBy") ? { createdBy: createdBy(value.createdBy, fail) } : {}),
     };
 }
 export function parseTaskCreationDocument(markdown) {
-    const fail = (message) => { throw new TypeError(message); };
+    const fail = (message) => {
+        throw new TypeError(message);
+    };
     const { value, body } = frontMatter(markdown, fail);
     closed(value, CREATION_KEYS, ["title"], fail);
     const complete = {
-        state: "open", priority: 2, needs: [], parent: null, supersedes: [], relates: [], note: "",
+        state: "open",
+        priority: 2,
+        needs: [],
+        parent: null,
+        supersedes: [],
+        relates: [],
+        note: "",
         ...value,
     };
     return { state: state(complete.state, fail), ...fields(complete, body, fail) };
 }
 export function serializeTaskDocument(document) {
     const value = {
-        id: document.id, title: document.title, state: document.state, priority: document.priority,
-        needs: [...document.needs], parent: document.parent, supersedes: [...document.supersedes],
-        relates: [...document.relates], note: document.note,
+        id: document.id,
+        title: document.title,
+        state: document.state,
+        priority: document.priority,
+        needs: [...document.needs],
+        parent: document.parent,
+        supersedes: [...document.supersedes],
+        relates: [...document.relates],
+        note: document.note,
         ...(document.createdBy === undefined ? {} : { createdBy: document.createdBy }),
-        createdAt: document.createdAt, updatedAt: document.updatedAt,
+        createdAt: document.createdAt,
+        updatedAt: document.updatedAt,
     };
     return Buffer.from(`---\n${stringify(value, { lineWidth: 0 })}---\n${document.body}`);
 }

package/build/src/task/identity.js

@@ -3,8 +3,11 @@ import { identityCoordinate, identitySegments } from "../identity/coordinates.js
 import { normalizeIdentityStem } from "../identity/normalize.js";
 const STEM_CODE_POINTS = 32;
 export function isTaskSegment(value) {
-    return value.length > 0 && value !== "." && value !== ".." && !value.includes("/")
-        && normalizeIdentityStem({ source: value }) === value;
+    return (value.length > 0 &&
+        value !== "." &&
+        value !== ".." &&
+        !value.includes("/") &&
+        normalizeIdentityStem({ source: value }) === value);
 }
 export function parseTaskId(value) {
     let segments;

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

@@ -19,7 +19,6 @@ export type TaskDoctorReport = Readonly<{
 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, TaskRelationPredicateField, };
 export { TaskAuthorityCorruptionError, TASK_RELATION_PREDICATE_FIELDS };
-export declare function observeTaskDetails(world: WorldRoot, ids: readonly TaskId[]): Promise<TaskOutcome<readonly TaskDetail[]>>;
 declare class TaskHandle {
     readonly id: TaskId;
     private readonly world;

package/build/src/task/index.js

@@ -1,17 +1,11 @@
 import { buildTree, createTaskRelations, diagnoseBoard, projectDetailFacts, } from "./board.js";
 import { composeTasks } from "./compose.js";
 import { TaskAuthorityCorruptionError } from "./document.js";
-import { addTask, addTaskDocument, batchTasks, blockedTasks, lifecycleTask, listTasks, queryTasks, readTaskDetails, readyTasks, taskView, updateTask, } from "./operations.js";
+import { addTask, addTaskDocument, batchTasks, blockedTasks, lifecycleTask, listTasks, queryTasks, readyTasks, taskView, updateTask, } from "./operations.js";
 import { readBoard } from "./store.js";
 import { actor, addInput, closed, limit, namespace, record, signal, sort, taskId as id, taskIds, text, updateInput, } from "./input.js";
 import { normalizeTaskQuery, TASK_RELATION_PREDICATE_FIELDS, DEFAULT_TASK_LIMIT, } from "./query.js";
 export { TaskAuthorityCorruptionError, TASK_RELATION_PREDICATE_FIELDS };
-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) })) };
-}
 class TaskHandle {
     id;
     world;
@@ -29,21 +23,37 @@ class TaskHandle {
             throw new TypeError("tree accepts no input");
         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 };
+        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));
     }
-    update(input) { return updateTask(this.world, this.id, updateInput(input)); }
     lifecycle(verb, input) {
         const value = record(input ?? {}, `${verb} input`);
         closed(value, verb === "drop" || verb === "done" ? ["note", "signal"] : ["signal"], `${verb} input`);
         const note = verb === "drop" || verb === "done" ? text(value.note, "note") : undefined;
         return lifecycleTask(this.world, this.id, verb, signal(value.signal), note);
     }
-    start(input) { return this.lifecycle("start", input); }
-    stop(input) { return this.lifecycle("stop", input); }
-    hold(input) { return this.lifecycle("hold", input); }
-    resume(input) { return this.lifecycle("resume", input); }
-    done(input) { return this.lifecycle("done", input); }
-    drop(input) { return this.lifecycle("drop", input); }
+    start(input) {
+        return this.lifecycle("start", input);
+    }
+    stop(input) {
+        return this.lifecycle("stop", input);
+    }
+    hold(input) {
+        return this.lifecycle("hold", input);
+    }
+    resume(input) {
+        return this.lifecycle("resume", input);
+    }
+    done(input) {
+        return this.lifecycle("done", input);
+    }
+    drop(input) {
+        return this.lifecycle("drop", input);
+    }
 }
 class TasksHandle {
     world;
@@ -52,25 +62,100 @@ class TasksHandle {
         this.world = world;
         this.root = world;
     }
-    task(input) { const v = record(input, "task input"); closed(v, ["id"], "task input"); return new TaskHandle(id(v.id), this.world); }
-    add(input) { return addTask(this.world, addInput(input)); }
-    addDocument(input) { const v = record(input, "addDocument input"); closed(v, ["markdown", "namespace", "actor", "signal"], "addDocument input"); const markdown = text(v.markdown, "markdown"); if (markdown === undefined)
-        throw new TypeError("markdown is required"); const ns = namespace(v.namespace), createdBy = actor(v.actor), abort = signal(v.signal); return addTaskDocument(this.world, { markdown, ...(ns === undefined ? {} : { namespace: ns }), ...(createdBy === undefined ? {} : { actor: createdBy }), ...(abort === undefined ? {} : { signal: abort }) }); }
-    async list(input = {}) { const v = record(input, "list input"); closed(v, ["selection", "scope", "namespace", "limit"], "list input"); if (v.selection !== undefined && v.selection !== "active" && v.selection !== "closed" && v.selection !== "all")
-        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"); return listTasks(this.world, namespace(v.namespace), v.selection ?? "active", v.scope, limit(v.limit) ?? DEFAULT_TASK_LIMIT); }
-    async ready(input = {}) { const v = record(input, "ready input"); closed(v, ["scope", "namespace", "parent", "limit"], "ready input"); 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); return readyTasks(this.world, namespace(v.namespace), v.scope, parent, limit(v.limit) ?? DEFAULT_TASK_LIMIT); }
-    async blocked(input = {}) { const v = record(input, "blocked input"); closed(v, ["scope", "namespace", "parent", "limit"], "blocked input"); 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); return blockedTasks(this.world, namespace(v.namespace), v.scope, parent, limit(v.limit) ?? DEFAULT_TASK_LIMIT); }
-    async query(input = {}) { const v = record(input, "query input"); closed(v, ["where", "scope", "namespace", "sort", "limit"], "query input"); if (v.scope !== undefined && v.scope !== "namespace" && v.scope !== "world")
-        throw new TypeError("scope must be namespace or world"); const expression = v.where === undefined ? { kind: "and", terms: [{ kind: "predicate", predicate: { field: "state", operator: "!=", value: "done" } }, { kind: "predicate", predicate: { field: "state", operator: "!=", value: "drop" } }] } : normalizeTaskQuery(v.where); const selected = namespace(v.namespace); return queryTasks({ world: this.world, ...(selected === undefined ? {} : { namespace: selected }), expression, ...(v.scope === undefined ? {} : { scope: v.scope }), sort: sort(v.sort) ?? "priority", limit: limit(v.limit) ?? DEFAULT_TASK_LIMIT }); }
-    async doctor() { return { issues: diagnoseBoard((await readBoard(this.world)).board) }; }
-    batch(input) { const v = record(input, "batch input"); closed(v, ["verb", "ids", "note", "signal"], "batch input"); const verb = v.verb; if (verb !== "done" && verb !== "drop" && verb !== "hold")
-        throw new TypeError("batch verb is invalid"); const note = text(v.note, "note"); if (note !== undefined && verb !== "done" && verb !== "drop")
-        throw new TypeError("batch note is valid only for done or drop"); return batchTasks(this.world, verb, taskIds(v.ids, "ids") ?? [], signal(v.signal), note); }
-    compose(input) { const v = record(input, "compose input"); closed(v, ["markdown", "namespace", "actor", "signal"], "compose input"); const markdown = text(v.markdown, "markdown"); if (markdown === undefined)
-        throw new TypeError("markdown is required"); const selected = namespace(v.namespace); return composeTasks(this.world, markdown, signal(v.signal), actor(v.actor), selected); }
+    task(input) {
+        const v = record(input, "task input");
+        closed(v, ["id"], "task input");
+        return new TaskHandle(id(v.id), this.world);
+    }
+    add(input) {
+        return addTask(this.world, addInput(input));
+    }
+    addDocument(input) {
+        const v = record(input, "addDocument input");
+        closed(v, ["markdown", "namespace", "actor", "signal"], "addDocument input");
+        const markdown = text(v.markdown, "markdown");
+        if (markdown === undefined)
+            throw new TypeError("markdown is required");
+        const ns = namespace(v.namespace), createdBy = actor(v.actor), abort = signal(v.signal);
+        return addTaskDocument(this.world, {
+            markdown,
+            ...(ns === undefined ? {} : { namespace: ns }),
+            ...(createdBy === undefined ? {} : { actor: createdBy }),
+            ...(abort === undefined ? {} : { signal: abort }),
+        });
+    }
+    async list(input = {}) {
+        const v = record(input, "list input");
+        closed(v, ["selection", "scope", "namespace", "limit"], "list input");
+        if (v.selection !== undefined && v.selection !== "active" && v.selection !== "closed" && v.selection !== "all")
+            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");
+        return listTasks(this.world, namespace(v.namespace), v.selection ?? "active", v.scope, limit(v.limit) ?? DEFAULT_TASK_LIMIT);
+    }
+    async ready(input = {}) {
+        const v = record(input, "ready input");
+        closed(v, ["scope", "namespace", "parent", "limit"], "ready input");
+        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);
+        return readyTasks(this.world, namespace(v.namespace), v.scope, parent, limit(v.limit) ?? DEFAULT_TASK_LIMIT);
+    }
+    async blocked(input = {}) {
+        const v = record(input, "blocked input");
+        closed(v, ["scope", "namespace", "parent", "limit"], "blocked input");
+        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);
+        return blockedTasks(this.world, namespace(v.namespace), v.scope, parent, limit(v.limit) ?? DEFAULT_TASK_LIMIT);
+    }
+    async query(input = {}) {
+        const v = record(input, "query input");
+        closed(v, ["where", "scope", "namespace", "sort", "limit"], "query input");
+        if (v.scope !== undefined && v.scope !== "namespace" && v.scope !== "world")
+            throw new TypeError("scope must be namespace or world");
+        const expression = v.where === undefined
+            ? {
+                kind: "and",
+                terms: [
+                    { kind: "predicate", predicate: { field: "state", operator: "!=", value: "done" } },
+                    { kind: "predicate", predicate: { field: "state", operator: "!=", value: "drop" } },
+                ],
+            }
+            : normalizeTaskQuery(v.where);
+        const selected = namespace(v.namespace);
+        return queryTasks({
+            world: this.world,
+            ...(selected === undefined ? {} : { namespace: selected }),
+            expression,
+            ...(v.scope === undefined ? {} : { scope: v.scope }),
+            sort: sort(v.sort) ?? "priority",
+            limit: limit(v.limit) ?? DEFAULT_TASK_LIMIT,
+        });
+    }
+    async doctor() {
+        return { issues: diagnoseBoard((await readBoard(this.world)).board) };
+    }
+    batch(input) {
+        const v = record(input, "batch input");
+        closed(v, ["verb", "ids", "note", "signal"], "batch input");
+        const verb = v.verb;
+        if (verb !== "done" && verb !== "drop" && verb !== "hold")
+            throw new TypeError("batch verb is invalid");
+        const note = text(v.note, "note");
+        if (note !== undefined && verb !== "done" && verb !== "drop")
+            throw new TypeError("batch note is valid only for done or drop");
+        return batchTasks(this.world, verb, taskIds(v.ids, "ids") ?? [], signal(v.signal), note);
+    }
+    compose(input) {
+        const v = record(input, "compose input");
+        closed(v, ["markdown", "namespace", "actor", "signal"], "compose input");
+        const markdown = text(v.markdown, "markdown");
+        if (markdown === undefined)
+            throw new TypeError("markdown is required");
+        const selected = namespace(v.namespace);
+        return composeTasks(this.world, markdown, signal(v.signal), actor(v.actor), selected);
+    }
 }
 export const Tasks = Object.freeze({
     of(world) {

package/build/src/task/input.js

@@ -90,8 +90,7 @@ export function sort(value) {
 export function state(value) {
     if (value === undefined)
         return undefined;
-    if (value !== "open" && value !== "in_progress" && value !== "on_hold"
-        && value !== "done" && value !== "drop") {
+    if (value !== "open" && value !== "in_progress" && value !== "on_hold" && value !== "done" && value !== "drop") {
         throw new TypeError("state is invalid");
     }
     return value;
@@ -102,8 +101,18 @@ function nullableId(value) {
 export function addInput(input) {
     const value = record(input, "add input");
     closed(value, [
-        "title", "namespace", "body", "note", "state", "priority", "needs", "parent",
-        "supersedes", "relates", "actor", "signal",
+        "title",
+        "namespace",
+        "body",
+        "note",
+        "state",
+        "priority",
+        "needs",
+        "parent",
+        "supersedes",
+        "relates",
+        "actor",
+        "signal",
     ], "add input");
     const title = text(value.title, "title");
     if (title === undefined || title.trim() === "")
@@ -137,9 +146,22 @@ export function addInput(input) {
 export function updateInput(input) {
     const value = record(input, "update input");
     closed(value, [
-        "title", "body", "appendBody", "note", "priority", "needs", "addNeeds", "dropNeeds",
-        "parent", "supersedes", "addSupersedes", "dropSupersedes", "relates", "addRelates",
-        "dropRelates", "signal",
+        "title",
+        "body",
+        "appendBody",
+        "note",
+        "priority",
+        "needs",
+        "addNeeds",
+        "dropNeeds",
+        "parent",
+        "supersedes",
+        "addSupersedes",
+        "dropSupersedes",
+        "relates",
+        "addRelates",
+        "dropRelates",
+        "signal",
     ], "update input");
     if (value.body !== undefined && value.appendBody !== undefined) {
         throw new TypeError("body and appendBody are mutually exclusive");

package/build/src/task/mutation.js

@@ -1,7 +1,15 @@
 import { addInput, closed, namespace, record, taskId, taskIds, text, updateInput } from "./input.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",
+    "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) {
@@ -16,9 +24,7 @@ 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");
+            const raw = mutationObject(input.input, ["title", "namespace", "body", "note", "state", "priority", "needs", "parent", "supersedes", "relates"], "task.add input");
             const decoded = addInput(raw);
             if (decoded.namespace === undefined)
                 throw new TypeError("task.add request namespace is required");
@@ -48,8 +54,21 @@ export function decodeTaskMutationRequest(action, value) {
         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",
+                "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) };
         }
@@ -77,17 +96,40 @@ export async function executeTaskMutation(input) {
     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, namespace: request.namespace, 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 }) });
+        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,
+                namespace: request.namespace,
+                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

@@ -6,7 +6,9 @@ import { type TaskPage, type TaskQueryExpression, type TaskQueryRow, type TaskQu
 export type TaskView = Readonly<TaskDocument & {
     namespace: readonly string[];
 }>;
-export declare function nukeTask(world: WorldRoot): Promise<void>;
+export declare function nukeTask(world: WorldRoot, options?: Readonly<{
+    timeoutMs?: number;
+}>): Promise<void>;
 export type TaskRefusal = Readonly<{
     kind: "task-missing";
     taskId: TaskId;
@@ -116,6 +118,9 @@ export declare function batchTasks(world: WorldRoot, verb: "done" | "drop" | "ho
 export declare function settleTask(world: WorldRoot, id: TaskId): Promise<SettledTaskResult>;
 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 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<{