@astrosheep/keiyaku 4.0.4 → 4.0.6

package/build/src/task/index.js

@@ -1,136 +1,11 @@
 import { buildTree, createTaskRelations, diagnoseBoard, projectDetailFacts, } from "./board.js";
 import { composeTasks } from "./compose.js";
 import { TaskAuthorityCorruptionError } from "./document.js";
-import { isTaskSegment, parseTaskId } from "./identity.js";
-import { addTask, addTaskDocument, batchTasks, blockedTasks, currentNamespace, lifecycleTask, listTasks, queryTasks, readyTasks, setCurrentNamespace, taskView, updateTask, } from "./operations.js";
+import { addTask, addTaskDocument, batchTasks, blockedTasks, lifecycleTask, listTasks, queryTasks, readyTasks, taskView, updateTask, } from "./operations.js";
 import { readBoard } from "./store.js";
-import { isValidTaskLimit, normalizeTaskQuery, TASK_RELATION_PREDICATE_FIELDS, MAX_TASK_LIMIT, DEFAULT_TASK_LIMIT, } from "./query.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 };
-function record(value, label) {
-    if (typeof value !== "object" || value === null || Array.isArray(value))
-        throw new TypeError(`${label} must be an object`);
-    return value;
-}
-function closed(value, allowed, label) {
-    for (const key of Object.keys(value))
-        if (!allowed.includes(key))
-            throw new TypeError(`${label} has unknown field: ${key}`);
-}
-function id(value) { if (typeof value !== "string")
-    throw new TypeError("task ID must be a string"); parseTaskId(value); return value; }
-function signal(value) {
-    if (value === undefined)
-        return undefined;
-    if (!(value instanceof AbortSignal))
-        throw new TypeError("signal must be an AbortSignal");
-    return value;
-}
-function strings(value, label) {
-    if (value === undefined)
-        return undefined;
-    if (!Array.isArray(value) || !value.every((item) => typeof item === "string"))
-        throw new TypeError(`${label} must be an array of strings`);
-    return value;
-}
-function taskIds(value, label) {
-    const values = strings(value, label)?.map(id);
-    if (values !== undefined && new Set(values).size !== values.length)
-        throw new TypeError(`${label} must not contain duplicates`);
-    return values;
-}
-function namespace(value) {
-    const values = strings(value, "namespace");
-    if (values === undefined)
-        return undefined;
-    if (!values.every(isTaskSegment))
-        throw new TypeError("namespace must contain canonical segments");
-    return values;
-}
-function text(value, label) { if (value === undefined)
-    return undefined; if (typeof value !== "string")
-    throw new TypeError(`${label} must be a string`); return value; }
-function actor(value) {
-    if (value === undefined)
-        return undefined;
-    if (typeof value !== "string" || value.trim().length === 0)
-        throw new TypeError("actor must be a nonblank string");
-    return value;
-}
-function priority(value) { if (value === undefined)
-    return undefined; if (!Number.isInteger(value) || typeof value !== "number" || value < 0 || value > 3)
-    throw new TypeError("priority must be 0..3"); return value; }
-function limit(value) { if (value === undefined)
-    return undefined; if (typeof value !== "number" || !isValidTaskLimit(value))
-    throw new TypeError(`limit must be an integer from 1 to ${MAX_TASK_LIMIT}`); return value; }
-function sort(value) {
-    if (value === undefined)
-        return undefined;
-    if (value !== "priority" && value !== "created" && value !== "updated" && value !== "id")
-        throw new TypeError("sort is invalid");
-    return value;
-}
-function state(value) {
-    if (value === undefined)
-        return undefined;
-    if (value !== "open" && value !== "in_progress" && value !== "on_hold" && value !== "done" && value !== "drop")
-        throw new TypeError("state is invalid");
-    return value;
-}
-function nullableId(value) { return value === undefined || value === null ? value : id(value); }
-function addInput(input) {
-    const v = record(input, "add input");
-    closed(v, ["title", "namespace", "body", "note", "state", "priority", "needs", "parent", "supersedes", "relates", "actor", "signal"], "add input");
-    const title = text(v.title, "title");
-    if (title === undefined || title.trim() === "")
-        throw new TypeError("title is required");
-    const ns = namespace(v.namespace), body = text(v.body, "body"), note = text(v.note, "note"), initialState = state(v.state), pri = priority(v.priority);
-    const needs = taskIds(v.needs, "needs"), parent = nullableId(v.parent), supersedes = taskIds(v.supersedes, "supersedes"), relates = taskIds(v.relates, "relates");
-    const createdBy = actor(v.actor), abort = signal(v.signal);
-    return { title, ...(ns === undefined ? {} : { namespace: ns }), ...(body === undefined ? {} : { body }), ...(note === undefined ? {} : { note }),
-        ...(initialState === undefined ? {} : { state: initialState }), ...(pri === undefined ? {} : { priority: pri }),
-        ...(needs === undefined ? {} : { needs }), ...(parent === undefined ? {} : { parent }),
-        ...(supersedes === undefined ? {} : { supersedes }), ...(relates === undefined ? {} : { relates }),
-        ...(createdBy === undefined ? {} : { actor: createdBy }),
-        ...(abort === undefined ? {} : { signal: abort }) };
-}
-function updateInput(input) {
-    const v = record(input, "update input");
-    closed(v, ["title", "body", "appendBody", "note", "priority", "needs", "addNeeds", "dropNeeds", "parent", "supersedes", "addSupersedes", "dropSupersedes", "relates", "addRelates", "dropRelates", "signal"], "update input");
-    if (v.body !== undefined && v.appendBody !== undefined)
-        throw new TypeError("body and appendBody are mutually exclusive");
-    const result = {};
-    const title = text(v.title, "title");
-    if (title !== undefined) {
-        if (title.trim().length === 0)
-            throw new TypeError("title must be nonblank");
-        result.title = title;
-    }
-    const body = text(v.body, "body");
-    if (body !== undefined)
-        result.body = body;
-    const appendBody = text(v.appendBody, "appendBody");
-    if (appendBody !== undefined)
-        result.appendBody = appendBody;
-    const note = text(v.note, "note");
-    if (note !== undefined)
-        result.note = note;
-    const pri = priority(v.priority);
-    if (pri !== undefined)
-        result.priority = pri;
-    for (const [key, value] of [["needs", taskIds(v.needs, "needs")], ["addNeeds", taskIds(v.addNeeds, "addNeeds")], ["dropNeeds", taskIds(v.dropNeeds, "dropNeeds")], ["supersedes", taskIds(v.supersedes, "supersedes")], ["addSupersedes", taskIds(v.addSupersedes, "addSupersedes")], ["dropSupersedes", taskIds(v.dropSupersedes, "dropSupersedes")], ["relates", taskIds(v.relates, "relates")], ["addRelates", taskIds(v.addRelates, "addRelates")], ["dropRelates", taskIds(v.dropRelates, "dropRelates")]])
-        if (value !== undefined)
-            result[key] = value;
-    const parent = nullableId(v.parent);
-    if (parent !== undefined)
-        result.parent = parent;
-    const abort = signal(v.signal);
-    if (abort !== undefined)
-        result.signal = abort;
-    const update = result;
-    if (Object.keys(result).filter((key) => key !== "signal").length === 0)
-        throw new TypeError("update requires at least one field change");
-    return update;
-}
 class TaskHandle {
     id;
     world;
@@ -171,33 +46,30 @@ class TasksHandle {
         this.world = world;
         this.root = world;
     }
-    async namespace() { const value = await currentNamespace(this.world); return "kind" in value ? { kind: "refused", refusal: value } : { kind: "accepted", value }; }
-    async setNamespace(input) { const v = record(input, "setNamespace input"); closed(v, ["namespace"], "setNamespace input"); const ns = namespace(v.namespace); if (ns === undefined)
-        throw new TypeError("namespace is required"); await setCurrentNamespace(this.world, ns); }
     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", "limit"], "list input"); if (v.selection !== undefined && v.selection !== "active" && v.selection !== "closed" && v.selection !== "all")
+    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, v.selection ?? "active", v.scope, limit(v.limit) ?? DEFAULT_TASK_LIMIT); }
-    async ready(input = {}) { const v = record(input, "ready input"); closed(v, ["scope", "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, v.scope, parent, limit(v.limit) ?? DEFAULT_TASK_LIMIT); }
-    async blocked(input = {}) { const v = record(input, "blocked input"); closed(v, ["scope", "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, v.scope, parent, limit(v.limit) ?? DEFAULT_TASK_LIMIT); }
-    async query(input = {}) { const v = record(input, "query input"); closed(v, ["where", "scope", "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); return queryTasks(this.world, expression, v.scope, sort(v.sort) ?? "priority", limit(v.limit) ?? DEFAULT_TASK_LIMIT); }
+        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", "actor", "signal"], "compose input"); const markdown = text(v.markdown, "markdown"); if (markdown === undefined)
-        throw new TypeError("markdown is required"); return composeTasks(this.world, markdown, signal(v.signal), actor(v.actor)); }
+    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(root) {
-        if (typeof root !== "string")
-            throw new TypeError("Tasks.of root must be a WorldRoot");
-        return new TasksHandle(root);
+    of(world) {
+        if (typeof world !== "string")
+            throw new TypeError("Tasks.of world must be a WorldRoot");
+        return new TasksHandle(world);
     },
 });

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

@@ -0,0 +1,18 @@
+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";
+export declare function record(value: unknown, label: string): Record<string, unknown>;
+export declare function closed(value: Record<string, unknown>, allowed: readonly string[], label: string): void;
+export declare function taskId(value: unknown): TaskId;
+export declare function signal(value: unknown): AbortSignal | undefined;
+export declare function taskIds(value: unknown, label: string): readonly TaskId[] | undefined;
+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;
+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

@@ -0,0 +1,189 @@
+import { isTaskSegment, parseTaskId } from "./identity.js";
+import { isValidTaskLimit, MAX_TASK_LIMIT } from "./query.js";
+export function record(value, label) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new TypeError(`${label} must be an object`);
+    }
+    return value;
+}
+export function closed(value, allowed, label) {
+    for (const key of Object.keys(value)) {
+        if (!allowed.includes(key))
+            throw new TypeError(`${label} has unknown field: ${key}`);
+    }
+}
+export function taskId(value) {
+    if (typeof value !== "string")
+        throw new TypeError("task ID must be a string");
+    parseTaskId(value);
+    return value;
+}
+export function signal(value) {
+    if (value === undefined)
+        return undefined;
+    if (!(value instanceof AbortSignal))
+        throw new TypeError("signal must be an AbortSignal");
+    return value;
+}
+function strings(value, label) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) {
+        throw new TypeError(`${label} must be an array of strings`);
+    }
+    return value;
+}
+export function taskIds(value, label) {
+    const values = strings(value, label)?.map(taskId);
+    if (values !== undefined && new Set(values).size !== values.length) {
+        throw new TypeError(`${label} must not contain duplicates`);
+    }
+    return values;
+}
+export function namespace(value) {
+    const values = strings(value, "namespace");
+    if (values === undefined)
+        return undefined;
+    if (!values.every(isTaskSegment))
+        throw new TypeError("namespace must contain canonical segments");
+    return values;
+}
+export function text(value, label) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string")
+        throw new TypeError(`${label} must be a string`);
+    return value;
+}
+export function actor(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new TypeError("actor must be a nonblank string");
+    }
+    return value;
+}
+export function priority(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Number.isInteger(value) || typeof value !== "number" || value < 0 || value > 3) {
+        throw new TypeError("priority must be 0..3");
+    }
+    return value;
+}
+export function limit(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "number" || !isValidTaskLimit(value)) {
+        throw new TypeError(`limit must be an integer from 1 to ${MAX_TASK_LIMIT}`);
+    }
+    return value;
+}
+export function sort(value) {
+    if (value === undefined)
+        return undefined;
+    if (value !== "priority" && value !== "created" && value !== "updated" && value !== "id") {
+        throw new TypeError("sort is invalid");
+    }
+    return value;
+}
+export function state(value) {
+    if (value === undefined)
+        return undefined;
+    if (value !== "open" && value !== "in_progress" && value !== "on_hold"
+        && value !== "done" && value !== "drop") {
+        throw new TypeError("state is invalid");
+    }
+    return value;
+}
+function nullableId(value) {
+    return value === undefined || value === null ? value : taskId(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",
+    ], "add input");
+    const title = text(value.title, "title");
+    if (title === undefined || title.trim() === "")
+        throw new TypeError("title is required");
+    const selectedNamespace = namespace(value.namespace);
+    const body = text(value.body, "body");
+    const note = text(value.note, "note");
+    const initialState = state(value.state);
+    const selectedPriority = priority(value.priority);
+    const needs = taskIds(value.needs, "needs");
+    const parent = nullableId(value.parent);
+    const supersedes = taskIds(value.supersedes, "supersedes");
+    const relates = taskIds(value.relates, "relates");
+    const createdBy = actor(value.actor);
+    const abort = signal(value.signal);
+    return {
+        title,
+        ...(selectedNamespace === undefined ? {} : { namespace: selectedNamespace }),
+        ...(body === undefined ? {} : { body }),
+        ...(note === undefined ? {} : { note }),
+        ...(initialState === undefined ? {} : { state: initialState }),
+        ...(selectedPriority === undefined ? {} : { priority: selectedPriority }),
+        ...(needs === undefined ? {} : { needs }),
+        ...(parent === undefined ? {} : { parent }),
+        ...(supersedes === undefined ? {} : { supersedes }),
+        ...(relates === undefined ? {} : { relates }),
+        ...(createdBy === undefined ? {} : { actor: createdBy }),
+        ...(abort === undefined ? {} : { signal: abort }),
+    };
+}
+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",
+    ], "update input");
+    if (value.body !== undefined && value.appendBody !== undefined) {
+        throw new TypeError("body and appendBody are mutually exclusive");
+    }
+    const result = {};
+    const title = text(value.title, "title");
+    if (title !== undefined) {
+        if (title.trim().length === 0)
+            throw new TypeError("title must be nonblank");
+        result.title = title;
+    }
+    const body = text(value.body, "body");
+    if (body !== undefined)
+        result.body = body;
+    const appendBody = text(value.appendBody, "appendBody");
+    if (appendBody !== undefined)
+        result.appendBody = appendBody;
+    const note = text(value.note, "note");
+    if (note !== undefined)
+        result.note = note;
+    const selectedPriority = priority(value.priority);
+    if (selectedPriority !== undefined)
+        result.priority = selectedPriority;
+    for (const [key, ids] of [
+        ["needs", taskIds(value.needs, "needs")],
+        ["addNeeds", taskIds(value.addNeeds, "addNeeds")],
+        ["dropNeeds", taskIds(value.dropNeeds, "dropNeeds")],
+        ["supersedes", taskIds(value.supersedes, "supersedes")],
+        ["addSupersedes", taskIds(value.addSupersedes, "addSupersedes")],
+        ["dropSupersedes", taskIds(value.dropSupersedes, "dropSupersedes")],
+        ["relates", taskIds(value.relates, "relates")],
+        ["addRelates", taskIds(value.addRelates, "addRelates")],
+        ["dropRelates", taskIds(value.dropRelates, "dropRelates")],
+    ])
+        if (ids !== undefined)
+            result[key] = ids;
+    const parent = nullableId(value.parent);
+    if (parent !== undefined)
+        result.parent = parent;
+    const abort = signal(value.signal);
+    if (abort !== undefined)
+        result.signal = abort;
+    if (Object.keys(result).filter((key) => key !== "signal").length === 0) {
+        throw new TypeError("update requires at least one field change");
+    }
+    return result;
+}

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

@@ -0,0 +1,44 @@
+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" | "namespace"> & Readonly<{
+        namespace: readonly string[];
+    }>;
+}> | Readonly<{
+    action: "task.addDocument";
+    input: Omit<AddTaskDocumentInput, "actor" | "signal" | "namespace"> & Readonly<{
+        namespace: readonly string[];
+    }>;
+}> | Readonly<{
+    action: "task.compose";
+    markdown: string;
+    namespace: readonly 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,93 @@
+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",
+]);
+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");
+            const decoded = addInput(raw);
+            if (decoded.namespace === undefined)
+                throw new TypeError("task.add request namespace is required");
+            return { action, input: { ...decoded, namespace: decoded.namespace } };
+        }
+        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);
+            if (selected === undefined)
+                throw new TypeError("task.addDocument request namespace is required");
+            return { action, input: { markdown, namespace: selected } };
+        }
+        case "task.compose": {
+            const input = mutationObject(value, ["markdown", "namespace"], "task.compose request");
+            const markdown = text(input.markdown, "markdown");
+            if (markdown === undefined)
+                throw new TypeError("markdown is required");
+            const selected = namespace(input.namespace);
+            if (selected === undefined)
+                throw new TypeError("task.compose request namespace is required");
+            return { action, markdown, namespace: selected };
+        }
+        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 } = await import("./index.js");
+    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, 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,6 +6,7 @@ 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 type TaskRefusal = Readonly<{
     kind: "task-missing";
     taskId: TaskId;
@@ -105,19 +106,26 @@ 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>;
 export declare function lifecycleTask(world: WorldRoot, id: TaskId, verb: TaskLifecycleVerb, signal?: AbortSignal, note?: string): Promise<TaskMutationResult>;
 export declare function batchTasks(world: WorldRoot, verb: "done" | "drop" | "hold", ids: readonly TaskId[], signal?: AbortSignal, note?: string): Promise<TaskBatchResult>;
 export declare function settleTask(world: WorldRoot, id: TaskId): Promise<SettledTaskResult>;
-export declare function listTasks(world: WorldRoot, selection: "active" | "closed" | "all", scope?: "namespace" | "world", limit?: number): Promise<TaskOutcome<TaskPage<TaskRow>>>;
-export declare function readyTasks(world: WorldRoot, scope?: "namespace" | "world", parent?: TaskId, limit?: number): Promise<TaskOutcome<TaskPage<TaskRow>>>;
-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>>>;
+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 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<{
+    world: WorldRoot;
+    namespace?: readonly string[];
+    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 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>;
-export declare function currentNamespace(world: WorldRoot): Promise<readonly string[] | TaskRefusal>;