@astrosheep/keiyaku 4.6.8 → 4.6.9

package/build/src/task/compose.js

@@ -1,189 +0,0 @@
-import { documentDiff } from "../markdown/diff.js";
-import { planTaskComposition, } from "./compose-language.js";
-import { serializeTaskDocument } from "./document.js";
-import { parseTaskId, taskAuthorityPath } from "./identity.js";
-import { readBoard, replaceAuthority, withTaskLocks } from "./store.js";
-function refusal(diagnostics) {
-    return { kind: "refused", refusal: { kind: "invalid-composition", diagnostics } };
-}
-function currentTimestamp() {
-    return new Date().toISOString();
-}
-function facts(plan) {
-    return { aliases: plan.aliases, admissionOrder: plan.admissionOrder, admissions: plannedResult(plan).admissions };
-}
-function reference(id, remainingAliases) {
-    const alias = remainingAliases.get(id);
-    return alias === undefined ? `@${id}` : `^${alias}`;
-}
-function bodyToken(body) {
-    const lines = new Set(body.split(/\r\n|\n|\r/u));
-    for (let suffix = 0; Number.isSafeInteger(suffix); suffix += 1) {
-        const token = suffix === 0 ? "END_BODY" : `END_BODY_${suffix}`;
-        if (token.length > 32)
-            break;
-        if (!lines.has(token))
-            return token;
-    }
-    throw new Error("compose recovery body token space exhausted");
-}
-function taskDraft(task, remainingAliases) {
-    const document = task.after;
-    const lines = [task.kind === "new" ? `+ ${document.title}` : `@${document.id}`];
-    if (task.kind === "new" && task.alias !== undefined)
-        lines.push(`as = ${task.alias}`);
-    if (task.kind === "new")
-        lines.push(`state = ${document.state}`);
-    lines.push(`pri = ${document.priority}`, `needs = ${document.needs.map((id) => reference(id, remainingAliases)).join(", ")}`, `parent = ${document.parent === null ? "" : reference(document.parent, remainingAliases)}`, `supersedes = ${document.supersedes.map((id) => reference(id, remainingAliases)).join(", ")}`, `relates = ${document.relates.map((id) => reference(id, remainingAliases)).join(", ")}`);
-    if (document.body === "")
-        lines.push("body =");
-    else {
-        const token = bodyToken(document.body);
-        lines.push(`body <<${token}`, document.body, token);
-    }
-    return lines;
-}
-function recoveryDraft(namespace, remaining) {
-    const aliases = new Map();
-    for (const task of remaining) {
-        if (task.kind === "new" && task.alias !== undefined)
-            aliases.set(task.after.id, task.alias);
-    }
-    const lines = [`ns=${namespace.length === 0 ? "/" : namespace.join("/")}`];
-    for (const task of remaining)
-        lines.push("", ...taskDraft(task, aliases));
-    return `${lines.join("\n")}\n`;
-}
-function plannedResult(plan) {
-    const positions = new Map(plan.tasks.map((task) => [task.after.id, task.index + 1]));
-    return {
-        kind: "planned",
-        aliases: plan.aliases.map(({ alias, taskId }) => ({ alias, position: positions.get(taskId) })),
-        admissionOrder: plan.tasks.map((task) => ({
-            position: task.index + 1,
-            ...(task.kind === "existing" ? { taskId: task.after.id } : {}),
-            ...(task.alias === undefined ? {} : { alias: task.alias }),
-        })),
-        admissions: plan.admissions.map((admission) => admission.kind === "new"
-            ? {
-                position: admission.position,
-                kind: "new",
-                ...(admission.alias === undefined ? {} : { alias: admission.alias }),
-                title: admission.title,
-            }
-            : { position: admission.position, kind: "existing", taskId: admission.taskId, title: admission.title }),
-        bodies: plan.bodies,
-    };
-}
-function physicalPlanDiagnostics(plan) {
-    try {
-        taskAuthorityPath("", { namespace: plan.namespace, localId: "placeholder" });
-        for (const task of plan.tasks)
-            taskAuthorityPath("", parseTaskId(task.after.id));
-        return [];
-    }
-    catch (error) {
-        return [
-            { line: 1, reason: error instanceof Error ? error.message : String(error), token: plan.namespace.join("/") },
-        ];
-    }
-}
-function planAgainst(markdown, board, namespace, at, actor) {
-    return planTaskComposition({ markdown, board, namespace, at, ...(actor === undefined ? {} : { actor }) });
-}
-async function admitPlan(world, snapshot, plan, signal) {
-    const changes = [];
-    for (let index = 0; index < plan.tasks.length; index += 1) {
-        signal?.throwIfAborted();
-        const item = plan.tasks[index];
-        const beforeBytes = item.before === null ? null : (snapshot.bytes.get(item.after.id) ?? null);
-        const afterBytes = serializeTaskDocument(item.after);
-        const before = beforeBytes === null ? "" : Buffer.from(beforeBytes).toString("utf8");
-        const after = Buffer.from(afterBytes).toString("utf8");
-        const replaced = await replaceAuthority({
-            world,
-            id: item.after.id,
-            expected: beforeBytes,
-            next: afterBytes,
-        });
-        if (replaced !== "replaced") {
-            return {
-                kind: "incomplete",
-                ...facts(plan),
-                documentChanges: changes,
-                stopped: { kind: "retry", reason: "concurrent-modification" },
-                draft: recoveryDraft(plan.namespace, plan.tasks.slice(index)),
-            };
-        }
-        const label = `${item.after.id}.md`;
-        changes.push({
-            taskId: item.after.id,
-            kind: item.before === null ? "created" : "updated",
-            documentDiff: documentDiff(label, label, before, after),
-        });
-    }
-    return { kind: "accepted", ...facts(plan), documentChanges: changes };
-}
-async function composeUnderLocks(input) {
-    const snapshot = await readBoard(input.world);
-    const planned = planAgainst(input.markdown, snapshot.board, input.namespace, input.at, input.actor);
-    if (planned.kind === "refused")
-        return refusal(planned.diagnostics);
-    return await withTaskLocks({
-        world: input.world,
-        allocation: false,
-        ids: planned.plan.admissionOrder,
-        ...(input.signal === undefined ? {} : { signal: input.signal }),
-    }, async () => {
-        const fresh = await readBoard(input.world);
-        const replanned = planAgainst(input.markdown, fresh.board, input.namespace, input.at, input.actor);
-        if (replanned.kind === "refused")
-            return refusal(replanned.diagnostics);
-        return await admitPlan(input.world, fresh, replanned.plan, input.signal);
-    });
-}
-function composeInput(input) {
-    return input;
-}
-export async function composeTasks(input) {
-    const { world, markdown, signal, actor, defaultNamespace = [], planOnly = false } = input;
-    try {
-        const at = currentTimestamp();
-        const initial = await readBoard(world);
-        const initialPlan = planAgainst(markdown, initial.board, defaultNamespace, at, actor);
-        if (initialPlan.kind === "refused")
-            return refusal(initialPlan.diagnostics);
-        const physicalDiagnostics = physicalPlanDiagnostics(initialPlan.plan);
-        if (physicalDiagnostics.length > 0)
-            return refusal(physicalDiagnostics);
-        if (planOnly)
-            return plannedResult(initialPlan.plan);
-        const request = composeInput({
-            world,
-            markdown,
-            namespace: defaultNamespace,
-            at,
-            ...(actor === undefined ? {} : { actor }),
-            ...(signal === undefined ? {} : { signal }),
-        });
-        const allocation = initialPlan.plan.tasks.some((task) => task.kind === "new");
-        const admitted = allocation
-            ? await withTaskLocks({ world, allocation: true, ids: [], ...(signal === undefined ? {} : { signal }) }, async () => await composeUnderLocks(request))
-            : await composeUnderLocks(request);
-        if (admitted !== "busy")
-            return admitted;
-        return {
-            kind: "incomplete",
-            ...facts(initialPlan.plan),
-            documentChanges: [],
-            stopped: { kind: "retry", reason: "busy" },
-            draft: recoveryDraft(initialPlan.plan.namespace, initialPlan.plan.tasks),
-        };
-    }
-    catch (error) {
-        if (error instanceof TypeError &&
-            /task identity (?:cannot fit the physical filename budget|contains a Windows-reserved physical segment)/u.test(error.message))
-            return refusal([{ line: 1, reason: error.message, token: defaultNamespace.join("/") }]);
-        throw error;
-    }
-}

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

@@ -1,39 +0,0 @@
-import { z } from "zod";
-import { type TaskCoordinate, type TaskId } from "./identity.js";
-export declare const taskNonblankTextSchema: z.ZodString;
-export declare const taskStateSchema: z.ZodEnum<{
-    open: "open";
-    in_progress: "in_progress";
-    on_hold: "on_hold";
-    done: "done";
-    drop: "drop";
-}>;
-export declare const taskPrioritySchema: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
-export type TaskState = z.infer<typeof taskStateSchema>;
-export type TaskPriority = z.infer<typeof taskPrioritySchema>;
-export type TaskDocument = Readonly<{
-    id: TaskId;
-    title: string;
-    state: TaskState;
-    priority: TaskPriority;
-    needs: readonly TaskId[];
-    parent: TaskId | null;
-    supersedes: readonly TaskId[];
-    relates: readonly TaskId[];
-    note: string;
-    createdBy?: string;
-    createdAt: string;
-    updatedAt: string;
-    body: string;
-}>;
-export type TaskCreationDocument = Omit<TaskDocument, "id" | "createdBy" | "createdAt" | "updatedAt">;
-export declare class TaskAuthorityCorruptionError extends Error {
-    /** The Task document whose bytes failed decode, when the reader knew its coordinate. */
-    readonly coordinate?: TaskId;
-    constructor(message: string, options?: ErrorOptions & {
-        coordinate?: TaskId;
-    });
-}
-export declare function parseTaskDocument(bytes: Uint8Array, expected: TaskCoordinate): TaskDocument;
-export declare function parseTaskCreationDocument(markdown: string): TaskCreationDocument;
-export declare function serializeTaskDocument(document: TaskDocument): Uint8Array;

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

@@ -1,21 +0,0 @@
-import { z } from "zod";
-import { type ContractId } from "../core/facts/types.js";
-export type TaskId = `task/${string}`;
-export type TaskCoordinate = Readonly<{
-    namespace: readonly string[];
-    localId: string;
-}>;
-export declare const TASK_LOCAL_ID_BYTES: number;
-export declare function isTaskSegment(value: string): boolean;
-export declare function parseTaskId(value: string): TaskCoordinate;
-export declare function formatTaskId(coordinate: TaskCoordinate): TaskId;
-export declare function canonicalTaskId(value: string): TaskId;
-export declare const taskIdSchema: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
-export declare const taskNamespaceSchema: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-export declare const taskIdsSchema: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>>;
-export declare function contractNamespace(id: ContractId): readonly string[];
-export declare function taskAuthorityPath(tasksDirectory: string, coordinate: TaskCoordinate): string;
-export declare function deriveLocalStem(title: string): string;
-export declare function allocateLocalId(stem: string, occupied: ReadonlySet<string>): string;
-export declare function physicalTaskSegment(segment: string, maxBytes?: number): string;
-export declare function sameNamespace(left: readonly string[], right: readonly string[]): boolean;

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

@@ -1,138 +0,0 @@
-import type { WorldRoot } from "../world.js";
-import type { NamespaceContextSource, ResolvedNamespaceContext } from "./context.js";
-import { type ExecutionContext } from "../akuma/requests.js";
-import { type TaskLifecycleVerb } from "./mutation.js";
-export type { WorldRoot } from "../world.js";
-import { type BlockedTaskRow, type TaskDetailFacts, type TaskDoctorIssue, type TaskRef, type TaskRow, type TaskTreeNode } from "./board.js";
-import { type TaskCompositionAlias, type TaskCompositionAdmission, type TaskCompositionBodyPreview, type TaskCompositionPlanAlias, type TaskCompositionPlanOrder, type TaskCompositionResult } from "./compose.js";
-import { TaskAuthorityCorruptionError, type TaskPriority, type TaskState } from "./document.js";
-import type { TaskId } from "./identity.js";
-import { type AddTaskDocumentInput, type AddTaskInput, type TaskBatchResult, type TaskCleanupFailure, type TaskCompositionDiagnostic, type TaskMutationResult, type TaskOutcome, type TaskRefusal, type TaskRetry, type TaskUpdateResult, type TaskView, type UpdateTaskInput } from "./operations.js";
-import { TASK_RELATION_PREDICATE_FIELDS, type TaskPage, type TaskQueryExpression, type TaskQueryPredicate, type TaskQueryRow, type TaskQuerySort, type TaskRelationPredicateField } from "./query.js";
-export type TaskDetail = Omit<TaskDetailFacts, "task"> & Readonly<{
-    task: TaskView;
-}>;
-export type TaskList = TaskOutcome<TaskPage<TaskRow>>;
-export type BlockedTaskList = TaskOutcome<TaskPage<BlockedTaskRow>>;
-export type TaskQueryResult = TaskOutcome<TaskPage<TaskQueryRow>>;
-export type TaskContextSource = NamespaceContextSource;
-export type { ResolvedNamespaceContext };
-export type TaskContextResult = TaskOutcome<ResolvedNamespaceContext>;
-export type TaskDoctorReport = Readonly<{
-    issues: readonly TaskDoctorIssue[];
-}>;
-export type TaskDecompositionTree = TaskOutcome<TaskTreeNode>;
-export type { AddTaskDocumentInput, AddTaskInput, BlockedTaskRow, TaskBatchResult, TaskCleanupFailure, TaskCompositionDiagnostic, TaskCompositionAlias, TaskCompositionAdmission, TaskCompositionBodyPreview, TaskCompositionPlanAlias, TaskCompositionPlanOrder, TaskCompositionResult, TaskDoctorIssue, TaskId, TaskMutationResult, TaskOutcome, TaskPriority, TaskRef, TaskRefusal, TaskRetry, TaskRow, TaskState, TaskTreeNode, TaskUpdateResult, TaskView, UpdateTaskInput, TaskPage, TaskQueryExpression, TaskQueryPredicate, TaskQueryRow, TaskQuerySort, TaskRelationPredicateField, };
-export type { LibraryExecution } from "../akuma/requests.js";
-export { TaskAuthorityCorruptionError, TASK_RELATION_PREDICATE_FIELDS };
-export { observeRecentTaskStatus, type RecentTaskStatusRow } from "./catalog.js";
-export { boundedListLimit as taskRowViewLimit } from "../bounded-list.js";
-type ComposeValues = Readonly<{
-    markdown: string;
-    namespace?: readonly string[];
-    actor?: string;
-    signal?: AbortSignal;
-}>;
-/**
- * The one bound operation table for a captured route. Each entry either calls the
- * local Task operations directly or sends the same validated values as the one
- * forwarded request shape. Validation stays in the handle methods.
- */
-type TaskOperations = Readonly<{
-    add(values: AddTaskInput): Promise<TaskMutationResult>;
-    addDocument(values: AddTaskDocumentInput): Promise<TaskMutationResult>;
-    compose(values: ComposeValues): Promise<TaskCompositionResult>;
-    update(id: TaskId, values: UpdateTaskInput): Promise<TaskUpdateResult>;
-    lifecycle(id: TaskId, verb: TaskLifecycleVerb, note: string | undefined, signal?: AbortSignal): Promise<TaskMutationResult>;
-    batch(verb: TaskLifecycleVerb, ids: readonly TaskId[], note: string | undefined, signal?: AbortSignal): Promise<TaskBatchResult>;
-}>;
-declare class TaskHandle {
-    readonly id: TaskId;
-    private readonly world;
-    private readonly operations;
-    constructor(id: TaskId, world: WorldRoot, operations: TaskOperations);
-    read(): Promise<TaskDetail | null>;
-    tree(): Promise<TaskDecompositionTree>;
-    update(input: UpdateTaskInput): Promise<TaskUpdateResult>;
-    private lifecycle;
-    start(input?: {
-        signal?: AbortSignal;
-    }): Promise<TaskMutationResult>;
-    stop(input?: {
-        signal?: AbortSignal;
-    }): Promise<TaskMutationResult>;
-    hold(input?: {
-        signal?: AbortSignal;
-    }): Promise<TaskMutationResult>;
-    resume(input?: {
-        signal?: AbortSignal;
-    }): Promise<TaskMutationResult>;
-    done(input?: {
-        note?: string;
-        signal?: AbortSignal;
-    }): Promise<TaskMutationResult>;
-    drop(input?: {
-        note?: string;
-        signal?: AbortSignal;
-    }): Promise<TaskMutationResult>;
-}
-export type Task = TaskHandle;
-declare class TasksHandle {
-    private readonly world;
-    readonly root: WorldRoot;
-    private readonly operations;
-    constructor(world: WorldRoot, execution: ExecutionContext);
-    task(input: Readonly<{
-        id: string;
-    }>): Task;
-    add(input: AddTaskInput): Promise<TaskMutationResult>;
-    addDocument(input: AddTaskDocumentInput): Promise<TaskMutationResult>;
-    list(input?: Readonly<{
-        selection?: "active" | "closed" | "all";
-        scope?: "namespace" | "world";
-        namespace?: readonly string[];
-        limit?: number;
-    }>): Promise<TaskList>;
-    ready(input?: Readonly<{
-        scope?: "namespace" | "world";
-        namespace?: readonly string[];
-        parent?: string;
-        limit?: number;
-    }>): Promise<TaskList>;
-    blocked(input?: Readonly<{
-        scope?: "namespace" | "world";
-        namespace?: readonly string[];
-        parent?: string;
-        limit?: number;
-    }>): Promise<BlockedTaskList>;
-    query(input?: Readonly<{
-        where?: TaskQueryExpression;
-        scope?: "namespace" | "world";
-        namespace?: readonly string[];
-        sort?: TaskQuerySort;
-        limit?: number;
-    }>): Promise<TaskQueryResult>;
-    doctor(): Promise<TaskDoctorReport>;
-    batch(input: Readonly<{
-        verb: "start" | "stop" | "done" | "drop" | "hold" | "resume";
-        ids: readonly string[];
-        note?: string;
-        signal?: AbortSignal;
-    }>): Promise<TaskBatchResult>;
-    compose(input: Readonly<{
-        markdown: string;
-        namespace?: readonly string[];
-        actor?: string;
-        signal?: AbortSignal;
-        plan?: boolean;
-    }>): Promise<TaskCompositionResult>;
-}
-export type Tasks = TasksHandle;
-/**
- * The one Tasks composition. Public `of` fixes local execution; CLI and Body pass their captured
- * internal channel through `tasksWithExecution` instead of a second constructor.
- */
-export declare function tasksWithExecution(world: WorldRoot, execution: ExecutionContext): Tasks;
-export declare const Tasks: Readonly<{
-    of(world: WorldRoot): Tasks;
-}>;

package/build/src/task/index.js

@@ -1,269 +0,0 @@
-import { executionChannel, localExecutionContext } from "../akuma/requests.js";
-import { requestForwardedTask, } from "./mutation.js";
-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, 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 { 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" };
-}
-function forwardTask(directory, world, request, signal) {
-    return requestForwardedTask({
-        directory,
-        world,
-        request,
-        ...(signal === undefined ? {} : { signal }),
-    });
-}
-/** The single lifecycle request shapes, keyed once by verb instead of switched per handle. */
-const SINGLE_LIFECYCLE = {
-    start: (id) => ({ action: "task.start", id }),
-    stop: (id) => ({ action: "task.stop", id }),
-    hold: (id) => ({ action: "task.hold", id }),
-    resume: (id) => ({ action: "task.resume", id }),
-    done: (id, note) => ({ action: "task.done", id, ...(note === undefined ? {} : { note }) }),
-    drop: (id, note) => ({ action: "task.drop", id, ...(note === undefined ? {} : { note }) }),
-};
-/** The batch lifecycle request shapes for the same verbs. */
-const BATCH_LIFECYCLE = {
-    start: (ids) => ({ action: "task.start", ids }),
-    stop: (ids) => ({ action: "task.stop", ids }),
-    hold: (ids) => ({ action: "task.hold", ids }),
-    resume: (ids) => ({ action: "task.resume", ids }),
-    done: (ids, note) => ({ action: "task.done", ids, ...(note === undefined ? {} : { note }) }),
-    drop: (ids, note) => ({ action: "task.drop", ids, ...(note === undefined ? {} : { note }) }),
-};
-function taskOperations(world, route) {
-    if (route.kind === "forwarded") {
-        const { directory } = route;
-        return {
-            add: (values) => {
-                const { actor: _actor, signal, namespace: selected, ...request } = values;
-                return forwardTask(directory, world, { action: "task.add", input: { ...request, namespace: selected ?? [] } }, signal);
-            },
-            addDocument: (values) => forwardTask(directory, world, { action: "task.addDocument", input: { markdown: values.markdown, namespace: values.namespace ?? [] } }, values.signal),
-            compose: (values) => forwardTask(directory, world, { action: "task.compose", markdown: values.markdown, namespace: values.namespace ?? [] }, values.signal),
-            update: (id, values) => {
-                const { signal, ...request } = values;
-                return forwardTask(directory, world, { action: "task.update", id, input: request }, signal);
-            },
-            lifecycle: (id, verb, note, signal) => forwardTask(directory, world, SINGLE_LIFECYCLE[verb](id, note), signal),
-            batch: (verb, ids, note, signal) => forwardTask(directory, world, BATCH_LIFECYCLE[verb](ids, note), signal),
-        };
-    }
-    return {
-        add: (values) => addTask(world, values),
-        addDocument: (values) => addTaskDocument(world, values),
-        compose: (values) => composeTasks({
-            world,
-            markdown: values.markdown,
-            ...(values.signal === undefined ? {} : { signal: values.signal }),
-            ...(values.actor === undefined ? {} : { actor: values.actor }),
-            ...(values.namespace === undefined ? {} : { defaultNamespace: values.namespace }),
-            planOnly: false,
-        }),
-        update: (id, values) => updateTask(world, id, values),
-        lifecycle: (id, verb, note, signal) => lifecycleTask(world, id, verb, signal, note),
-        batch: (verb, ids, note, signal) => batchTasks(world, verb, ids, signal, note),
-    };
-}
-class TaskHandle {
-    id;
-    world;
-    operations;
-    constructor(id, world, operations) {
-        this.id = id;
-        this.world = world;
-        this.operations = operations;
-    }
-    async read() {
-        const facts = await readTaskDetail(this.world, this.id);
-        return facts === null ? null : { ...facts, task: taskView(facts.task) };
-    }
-    async tree() {
-        if (arguments.length > 0)
-            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 };
-    }
-    update(input) {
-        return this.operations.update(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 this.operations.lifecycle(this.id, verb, note, signal(value.signal));
-    }
-    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;
-    root;
-    operations;
-    constructor(world, execution) {
-        this.world = world;
-        this.root = world;
-        this.operations = taskOperations(world, taskRoute(execution));
-    }
-    task(input) {
-        const v = record(input, "task input");
-        closed(v, ["id"], "task input");
-        return new TaskHandle(id(v.id), this.world, this.operations);
-    }
-    add(input) {
-        return this.operations.add(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 this.operations.addDocument({
-            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");
-        const selectedLimit = boundedListLimit(v.limit);
-        return listTasks(this.world, namespace(v.namespace), v.selection ?? "active", v.scope, selectedLimit);
-    }
-    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);
-        const selectedLimit = boundedListLimit(v.limit);
-        return readyTasks(this.world, namespace(v.namespace), v.scope, parent, selectedLimit);
-    }
-    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);
-        const selectedLimit = boundedListLimit(v.limit);
-        return blockedTasks(this.world, namespace(v.namespace), v.scope, parent, selectedLimit);
-    }
-    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 ? taskQuerySelection() : normalizeTaskQuery(v.where);
-        const selected = namespace(v.namespace);
-        const selectedLimit = boundedListLimit(v.limit);
-        return queryTasks({
-            world: this.world,
-            ...(selected === undefined ? {} : { namespace: selected }),
-            expression,
-            ...(v.scope === undefined ? {} : { scope: v.scope }),
-            sort: sort(v.sort) ?? "priority",
-            limit: selectedLimit,
-        });
-    }
-    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 !== "start" &&
-            verb !== "stop" &&
-            verb !== "done" &&
-            verb !== "drop" &&
-            verb !== "hold" &&
-            verb !== "resume")
-            throw new TypeError("batch verb is invalid");
-        const ids = taskIds(v.ids, "ids");
-        if (ids === undefined || ids.length === 0)
-            throw new TypeError("ids requires at least one TaskId");
-        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 this.operations.batch(verb, ids, note, signal(v.signal));
-    }
-    compose(input) {
-        const v = record(input, "compose input");
-        closed(v, ["markdown", "namespace", "actor", "signal", "plan"], "compose input");
-        const markdown = text(v.markdown, "markdown");
-        if (markdown === undefined)
-            throw new TypeError("markdown is required");
-        if (v.plan !== undefined && typeof v.plan !== "boolean")
-            throw new TypeError("plan must be a boolean");
-        const selected = namespace(v.namespace);
-        const selectedSignal = signal(v.signal);
-        const selectedActor = actor(v.actor);
-        if (v.plan === true) {
-            // A dry-run plan never leaves the process: it composes locally on any route.
-            return composeTasks({
-                world: this.world,
-                markdown,
-                ...(selectedSignal === undefined ? {} : { signal: selectedSignal }),
-                ...(selectedActor === undefined ? {} : { actor: selectedActor }),
-                ...(selected === undefined ? {} : { defaultNamespace: selected }),
-                planOnly: true,
-            });
-        }
-        return this.operations.compose({
-            markdown,
-            ...(selected === undefined ? {} : { namespace: selected }),
-            ...(selectedActor === undefined ? {} : { actor: selectedActor }),
-            ...(selectedSignal === undefined ? {} : { signal: selectedSignal }),
-        });
-    }
-}
-/**
- * The one Tasks composition. Public `of` fixes local execution; CLI and Body pass their captured
- * internal channel through `tasksWithExecution` instead of a second constructor.
- */
-export function tasksWithExecution(world, execution) {
-    if (typeof world !== "string")
-        throw new TypeError("Tasks.of world must be a WorldRoot");
-    return new TasksHandle(world, execution);
-}
-export const Tasks = Object.freeze({
-    of(world) {
-        return tasksWithExecution(world, localExecutionContext());
-    },
-});

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

@@ -1,6 +0,0 @@
-import { type SettledTaskResult, type TaskBatchResult, type TaskLifecycleVerb, type TaskMutationResult } from "./operation-types.js";
-import type { TaskId } from "./identity.js";
-import type { WorldRoot } from "../world.js";
-export declare function lifecycleTask(world: WorldRoot, id: TaskId, verb: TaskLifecycleVerb, signal?: AbortSignal, note?: string): Promise<TaskMutationResult>;
-export declare function batchTasks(world: WorldRoot, verb: TaskLifecycleVerb, ids: readonly TaskId[], signal?: AbortSignal, note?: string): Promise<TaskBatchResult>;
-export declare function settleTask(world: WorldRoot, id: TaskId): Promise<SettledTaskResult>;