@astrosheep/keiyaku 4.5.29 → 4.6.2

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

@@ -1,42 +1,12 @@
 import type { WorldRoot } from "../world.js";
-import { type TaskCompositionAlias, type TaskCompositionBodyPreview } from "./compose-language.js";
-import { type TaskId } from "./identity.js";
-import type { TaskCleanupFailure, TaskRefusal, TaskRetry } from "./operations.js";
-export type { TaskCompositionAlias, TaskCompositionBodyPreview } from "./compose-language.js";
+import type { TaskCompositionResult } from "./mutation-result.js";
+import { type AcceptedComposition } from "./compose-language.js";
+export type { TaskCompositionAdmission, TaskCompositionBodyPreview, TaskCompositionPlanAlias, TaskCompositionPlanOrder, } from "./compose-language.js";
+export type { TaskCompositionAlias } from "./compose-language.js";
 export { taskCompositionNamespaceHeader } from "./compose-language.js";
-export type TaskDocumentChange = Readonly<{
-    taskId: TaskId;
-    kind: "created" | "updated";
-    documentDiff: string;
-}>;
-export type TaskCompositionFacts = Readonly<{
-    aliases: readonly TaskCompositionAlias[];
-    admissionOrder: readonly TaskId[];
-}>;
-export type TaskCompositionResult = Readonly<{
-    kind: "planned";
-    aliases: readonly TaskCompositionAlias[];
-    admissionOrder: readonly TaskId[];
-    bodies: readonly TaskCompositionBodyPreview[];
-}> | Readonly<{
-    kind: "accepted";
-    documentChanges: readonly TaskDocumentChange[];
-    cleanup?: TaskCleanupFailure;
-} & TaskCompositionFacts> | Readonly<{
-    kind: "refused";
-    refusal: Extract<TaskRefusal, {
-        kind: "invalid-composition";
-    }>;
-}> | (Readonly<{
-    kind: "incomplete";
-    documentChanges: readonly TaskDocumentChange[];
-    cleanup?: TaskCleanupFailure;
-    stopped: TaskRefusal | Readonly<{
-        kind: "retry";
-        reason: TaskRetry;
-    }>;
-    draft: string;
-}> & TaskCompositionFacts);
+export type TaskDocumentChange = Readonly<AcceptedComposition["documentChanges"][number]>;
+export type TaskCompositionFacts = Readonly<Pick<AcceptedComposition, "aliases" | "admissionOrder" | "admissions">>;
+export type { TaskCompositionResult } from "./mutation-result.js";
 export declare function composeTasks(input: Readonly<{
     world: WorldRoot;
     markdown: string;

package/build/src/task/compose.js

@@ -11,7 +11,7 @@ function currentTimestamp() {
     return new Date().toISOString();
 }
 function facts(plan) {
-    return { aliases: plan.aliases, admissionOrder: plan.admissionOrder };
+    return { aliases: plan.aliases, admissionOrder: plan.admissionOrder, admissions: plannedResult(plan).admissions };
 }
 function reference(id, remainingAliases) {
     const alias = remainingAliases.get(id);
@@ -56,7 +56,25 @@ function recoveryDraft(namespace, remaining) {
     return `${lines.join("\n")}\n`;
 }
 function plannedResult(plan) {
-    return { kind: "planned", ...facts(plan), bodies: plan.bodies };
+    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 {

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

@@ -34,6 +34,5 @@ export declare const createdTaskObservationSchema: z.ZodUnion<readonly [z.ZodObj
 }, z.core.$strict>]>;
 export type CreatedTaskObservation = z.infer<typeof createdTaskObservationSchema>;
 export declare const EMPTY_CREATED_TASK_OBSERVATION: CreatedTaskObservation;
-export declare function parseCreatedTaskObservation(value: unknown): CreatedTaskObservation;
 /** Project Task board rows created by each identity, preserving input order. */
 export declare function observeCreatedTaskObservations(world: WorldRoot, createdByIds: readonly string[]): Promise<readonly CreatedTaskObservation[]>;

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

@@ -6,9 +6,6 @@ export const createdTaskObservationSchema = z.union([
     z.object({ kind: z.literal("failed"), diagnostic: z.string() }).strict(),
 ]);
 export const EMPTY_CREATED_TASK_OBSERVATION = { kind: "present", rows: [] };
-export function parseCreatedTaskObservation(value) {
-    return createdTaskObservationSchema.parse(value);
-}
 function observationDiagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -22,5 +19,5 @@ export async function observeCreatedTaskObservations(world, createdByIds) {
         const failed = { kind: "failed", diagnostic: observationDiagnostic(error) };
         return createdByIds.map(() => failed);
     }
-    return createdByIds.map((createdBy) => parseCreatedTaskObservation({ kind: "present", rows: board.selectCreatedBy(createdBy) }));
+    return createdByIds.map((createdBy) => ({ kind: "present", rows: board.selectCreatedBy(createdBy) }));
 }

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

@@ -1,6 +1,16 @@
+import { z } from "zod";
 import { type TaskCoordinate, type TaskId } from "./identity.js";
-export type TaskState = "open" | "in_progress" | "on_hold" | "done" | "drop";
-export type TaskPriority = 0 | 1 | 2 | 3;
+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;

package/build/src/task/document.js

@@ -1,5 +1,9 @@
 import { isMap, parseDocument, stringify } from "yaml";
+import { z } from "zod";
 import { formatTaskId, parseTaskId } from "./identity.js";
+export const taskNonblankTextSchema = z.string().refine((value) => value.trim() !== "");
+export const taskStateSchema = z.enum(["open", "in_progress", "on_hold", "done", "drop"]);
+export const taskPrioritySchema = z.union([z.literal(0), z.literal(1), z.literal(2), z.literal(3)]);
 export class TaskAuthorityCorruptionError extends Error {
     /** The Task document whose bytes failed decode, when the reader knew its coordinate. */
     coordinate;

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

@@ -1,15 +1,18 @@
+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_LOCK_ID_BYTES: number;
 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;

package/build/src/task/identity.js

@@ -1,14 +1,14 @@
+import { z } from "zod";
 import { join } from "node:path";
 import { randomBytes } from "node:crypto";
 import { contractSegment } from "../core/facts/types.js";
 import { identityCoordinate, identitySegments } from "../identity/coordinates.js";
-import { normalizeIdentityStem } from "../identity/normalize.js";
+import { fitIdentityStem, normalizeIdentityStem } from "../identity/normalize.js";
 const STEM_CODE_POINTS = 32;
 const TASK_FILENAME_BYTES = 255;
 const TASK_EXTENSION_BYTES = Buffer.byteLength(".md");
 const TASK_LOCK_EXTENSION_BYTES = Buffer.byteLength(".sqlite");
 const GENERATED_SUFFIX = "-0000";
-export const TASK_LOCK_ID_BYTES = TASK_FILENAME_BYTES - TASK_LOCK_EXTENSION_BYTES;
 export const TASK_LOCAL_ID_BYTES = TASK_FILENAME_BYTES - TASK_EXTENSION_BYTES - TASK_LOCK_EXTENSION_BYTES - Buffer.byteLength(GENERATED_SUFFIX);
 const GENERATED_STEM_BYTES = TASK_LOCAL_ID_BYTES - Buffer.byteLength(GENERATED_SUFFIX);
 const WINDOWS_RESERVED = /^(?:con|prn|aux|nul|clock\$|com[1-9]|lpt[1-9])(?:\..*)?$/iu;
@@ -42,6 +42,23 @@ export function canonicalTaskId(value) {
         throw new TypeError("task ID is not canonical");
     return id;
 }
+export const taskIdSchema = z.string().transform((value, context) => {
+    try {
+        return canonicalTaskId(value);
+    }
+    catch {
+        context.addIssue({ code: "custom", message: "expected canonical TaskId" });
+        return z.NEVER;
+    }
+});
+export const taskNamespaceSchema = z.array(z.string().refine(isTaskSegment)).readonly();
+export const taskIdsSchema = z
+    .array(taskIdSchema)
+    .superRefine((ids, context) => {
+    if (new Set(ids).size !== ids.length)
+        context.addIssue({ code: "custom", message: "TaskIds must be unique" });
+})
+    .readonly();
 export function contractNamespace(id) {
     return ["kei", contractSegment(id)];
 }
@@ -64,31 +81,18 @@ export function deriveLocalStem(title) {
         fitted += `-${word}`;
         count = candidate;
     }
-    return fitPhysicalStem(fitted);
+    return fitIdentityStem({ stem: fitted, maxBytes: GENERATED_STEM_BYTES });
 }
 export function allocateLocalId(stem, occupied) {
     const seed = randomBytes(2).readUInt16BE(0);
     for (let offset = 0; offset <= 0xffff; offset += 1) {
         const suffix = ((seed + offset) & 0xffff).toString(16).padStart(4, "0");
-        const candidate = `${fitPhysicalStem(stem, suffix)}-${suffix}`;
+        const candidate = fitIdentityStem({ stem, maxBytes: TASK_LOCAL_ID_BYTES, suffix });
         if (!occupied.has(candidate))
             return candidate;
     }
     throw new Error("task identity hexadecimal suffix space exhausted");
 }
-function fitPhysicalStem(stem, suffix) {
-    const maxBytes = suffix === undefined ? GENERATED_STEM_BYTES : TASK_LOCAL_ID_BYTES - Buffer.byteLength(`-${suffix}`);
-    let result = "";
-    for (const segment of new Intl.Segmenter("und", { granularity: "grapheme" }).segment(stem)) {
-        if (Buffer.byteLength(result + segment.segment) > maxBytes)
-            break;
-        result += segment.segment;
-    }
-    result = result.replace(/-+$/u, "");
-    if (result.length === 0)
-        throw new TypeError("task title cannot fit the physical filename budget");
-    return result;
-}
 export function physicalTaskSegment(segment, maxBytes = TASK_LOCAL_ID_BYTES) {
     if (Buffer.byteLength(segment) <= maxBytes && !WINDOWS_RESERVED.test(segment))
         return segment;

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

@@ -1,8 +1,10 @@
 import type { WorldRoot } from "../world.js";
-import { type ExecutionContext, type LibraryExecution } from "../akuma/requests.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 TaskCompositionBodyPreview, type TaskCompositionResult } from "./compose.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";
@@ -13,26 +15,42 @@ export type TaskDetail = Omit<TaskDetailFacts, "task"> & Readonly<{
 export type TaskList = TaskOutcome<TaskPage<TaskRow>>;
 export type BlockedTaskList = TaskOutcome<TaskPage<BlockedTaskRow>>;
 export type TaskQueryResult = TaskOutcome<TaskPage<TaskQueryRow>>;
-export type TaskContextSource = "default-root" | "contract-installed" | "local-override";
-export type ResolvedNamespaceContext = Readonly<{
-    namespace: readonly string[];
-    source: TaskContextSource;
-}>;
+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, TaskCompositionBodyPreview, TaskCompositionResult, TaskDoctorIssue, TaskId, TaskMutationResult, TaskOutcome, TaskPriority, TaskRef, TaskRefusal, TaskRetry, TaskRow, TaskState, TaskTreeNode, TaskUpdateResult, TaskView, UpdateTaskInput, TaskPage, TaskQueryExpression, TaskQueryPredicate, TaskQueryRow, TaskQuerySort, TaskRelationPredicateField, };
+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 { taskRowViewLimit } from "./input.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 execution;
-    constructor(id: TaskId, world: WorldRoot, execution: ExecutionContext);
+    private readonly operations;
+    constructor(id: TaskId, world: WorldRoot, operations: TaskOperations);
     read(): Promise<TaskDetail | null>;
     tree(): Promise<TaskDecompositionTree>;
     update(input: UpdateTaskInput): Promise<TaskUpdateResult>;
@@ -61,8 +79,8 @@ declare class TaskHandle {
 export type Task = TaskHandle;
 declare class TasksHandle {
     private readonly world;
-    private readonly execution;
     readonly root: WorldRoot;
+    private readonly operations;
     constructor(world: WorldRoot, execution: ExecutionContext);
     task(input: Readonly<{
         id: string;
@@ -96,7 +114,7 @@ declare class TasksHandle {
     }>): Promise<TaskQueryResult>;
     doctor(): Promise<TaskDoctorReport>;
     batch(input: Readonly<{
-        verb: "start" | "done" | "drop" | "hold";
+        verb: "start" | "stop" | "done" | "drop" | "hold" | "resume";
         ids: readonly string[];
         note?: string;
         signal?: AbortSignal;
@@ -110,9 +128,11 @@ declare class TasksHandle {
     }>): Promise<TaskCompositionResult>;
 }
 export type Tasks = TasksHandle;
-type TasksOfInput = Readonly<{
-    execution?: LibraryExecution;
-}>;
+/**
+ * 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, input?: TasksOfInput): Tasks;
+    of(world: WorldRoot): Tasks;
 }>;

package/build/src/task/index.js

@@ -1,15 +1,19 @@
-import { executionChannel, libraryExecution, localExecutionContext, } from "../akuma/requests.js";
-import { requestForwardedTask } from "./mutation.js";
+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 { readBoard } from "./store.js";
 import { actor, addInput, closed, namespace, record, signal, sort, taskRowViewLimit, taskId as id, taskIds, text, updateInput, } from "./input.js";
-import { normalizeTaskQuery, TASK_RELATION_PREDICATE_FIELDS, } from "./query.js";
+import { normalizeTaskQuery, taskQuerySelection, TASK_RELATION_PREDICATE_FIELDS, } from "./query.js";
 export { TaskAuthorityCorruptionError, TASK_RELATION_PREDICATE_FIELDS };
 export { observeRecentTaskStatus } from "./catalog.js";
 export { taskRowViewLimit } from "./input.js";
+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,
@@ -18,14 +22,66 @@ function forwardTask(directory, world, request, signal) {
         ...(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;
-    execution;
-    constructor(id, world, execution) {
+    operations;
+    constructor(id, world, operations) {
         this.id = id;
         this.world = world;
-        this.execution = execution;
+        this.operations = operations;
     }
     async read() {
         const facts = await readTaskDetail(this.world, this.id);
@@ -41,37 +97,13 @@ class TaskHandle {
             : { kind: "accepted", value: node };
     }
     update(input) {
-        const values = updateInput(input);
-        const { signal: abort, ...request } = values;
-        const channel = executionChannel(this.execution);
-        if (channel.kind === "body-request") {
-            return forwardTask(channel.directory, this.world, { action: "task.update", id: this.id, input: request }, abort);
-        }
-        return updateTask(this.world, this.id, values);
+        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;
-        const abort = signal(value.signal);
-        const channel = executionChannel(this.execution);
-        if (channel.kind === "body-request") {
-            switch (verb) {
-                case "start":
-                    return forwardTask(channel.directory, this.world, { action: "task.start", id: this.id }, abort);
-                case "stop":
-                    return forwardTask(channel.directory, this.world, { action: "task.stop", id: this.id }, abort);
-                case "hold":
-                    return forwardTask(channel.directory, this.world, { action: "task.hold", id: this.id }, abort);
-                case "resume":
-                    return forwardTask(channel.directory, this.world, { action: "task.resume", id: this.id }, abort);
-                case "done":
-                    return forwardTask(channel.directory, this.world, { action: "task.done", id: this.id, ...(note === undefined ? {} : { note }) }, abort);
-                case "drop":
-                    return forwardTask(channel.directory, this.world, { action: "task.drop", id: this.id, ...(note === undefined ? {} : { note }) }, abort);
-            }
-        }
-        return lifecycleTask(this.world, this.id, verb, abort, note);
+        return this.operations.lifecycle(this.id, verb, note, signal(value.signal));
     }
     start(input) {
         return this.lifecycle("start", input);
@@ -94,26 +126,20 @@ class TaskHandle {
 }
 class TasksHandle {
     world;
-    execution;
     root;
+    operations;
     constructor(world, execution) {
         this.world = world;
-        this.execution = execution;
         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.execution);
+        return new TaskHandle(id(v.id), this.world, this.operations);
     }
     add(input) {
-        const values = addInput(input);
-        const { actor: _actor, signal: abort, namespace: selected, ...request } = values;
-        const channel = executionChannel(this.execution);
-        if (channel.kind === "body-request") {
-            return forwardTask(channel.directory, this.world, { action: "task.add", input: { ...request, namespace: selected ?? [] } }, abort);
-        }
-        return addTask(this.world, values);
+        return this.operations.add(addInput(input));
     }
     addDocument(input) {
         const v = record(input, "addDocument input");
@@ -122,17 +148,12 @@ class TasksHandle {
         if (markdown === undefined)
             throw new TypeError("markdown is required");
         const ns = namespace(v.namespace), createdBy = actor(v.actor), abort = signal(v.signal);
-        const local = {
+        return this.operations.addDocument({
             markdown,
             ...(ns === undefined ? {} : { namespace: ns }),
             ...(createdBy === undefined ? {} : { actor: createdBy }),
             ...(abort === undefined ? {} : { signal: abort }),
-        };
-        const channel = executionChannel(this.execution);
-        if (channel.kind === "body-request") {
-            return forwardTask(channel.directory, this.world, { action: "task.addDocument", input: { markdown, namespace: ns ?? [] } }, abort);
-        }
-        return addTaskDocument(this.world, local);
+        });
     }
     async list(input = {}) {
         const v = record(input, "list input");
@@ -167,15 +188,7 @@ class TasksHandle {
         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 expression = v.where === undefined ? taskQuerySelection() : normalizeTaskQuery(v.where);
         const selected = namespace(v.namespace);
         const selectedLimit = taskRowViewLimit(v.limit);
         return queryTasks({
@@ -194,7 +207,12 @@ class TasksHandle {
         const v = record(input, "batch input");
         closed(v, ["verb", "ids", "note", "signal"], "batch input");
         const verb = v.verb;
-        if (verb !== "start" && verb !== "done" && verb !== "drop" && verb !== "hold")
+        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)
@@ -202,21 +220,7 @@ class TasksHandle {
         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");
-        const abort = signal(v.signal);
-        const channel = executionChannel(this.execution);
-        if (channel.kind === "body-request") {
-            switch (verb) {
-                case "start":
-                    return forwardTask(channel.directory, this.world, { action: "task.start", ids }, abort);
-                case "hold":
-                    return forwardTask(channel.directory, this.world, { action: "task.hold", ids }, abort);
-                case "done":
-                    return forwardTask(channel.directory, this.world, { action: "task.done", ids, ...(note === undefined ? {} : { note }) }, abort);
-                case "drop":
-                    return forwardTask(channel.directory, this.world, { action: "task.drop", ids, ...(note === undefined ? {} : { note }) }, abort);
-            }
-        }
-        return batchTasks(this.world, verb, ids, abort, note);
+        return this.operations.batch(verb, ids, note, signal(v.signal));
     }
     compose(input) {
         const v = record(input, "compose input");
@@ -229,33 +233,36 @@ class TasksHandle {
         const selected = namespace(v.namespace);
         const selectedSignal = signal(v.signal);
         const selectedActor = actor(v.actor);
-        const local = {
-            world: this.world,
+        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,
-            ...(selectedSignal === undefined ? {} : { signal: selectedSignal }),
+            ...(selected === undefined ? {} : { namespace: selected }),
             ...(selectedActor === undefined ? {} : { actor: selectedActor }),
-            ...(selected === undefined ? {} : { defaultNamespace: selected }),
-            planOnly: v.plan === true,
-        };
-        const channel = executionChannel(this.execution);
-        if (channel.kind === "body-request" && v.plan !== true) {
-            return forwardTask(channel.directory, this.world, { action: "task.compose", markdown, namespace: selected ?? [] }, selectedSignal);
-        }
-        return composeTasks(local);
+            ...(selectedSignal === undefined ? {} : { signal: selectedSignal }),
+        });
     }
 }
-function tasksOfExecution(input) {
-    if (input === undefined)
-        return localExecutionContext();
-    const values = record(input, "Tasks.of input");
-    closed(values, ["execution"], "Tasks.of input");
-    return values.execution === undefined ? localExecutionContext() : libraryExecution(values.execution);
+/**
+ * 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, input) {
-        const execution = tasksOfExecution(input);
-        if (typeof world !== "string")
-            throw new TypeError("Tasks.of world must be a WorldRoot");
-        return new TasksHandle(world, execution);
+    of(world) {
+        return tasksWithExecution(world, localExecutionContext());
     },
 });

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

@@ -2,5 +2,5 @@ import { type SettledTaskResult, type TaskBatchResult, type TaskLifecycleVerb, t
 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: "start" | "done" | "drop" | "hold", ids: readonly TaskId[], signal?: AbortSignal, note?: string): Promise<TaskBatchResult>;
+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>;