@astrosheep/keiyaku 4.5.11 → 4.5.13

package/build/src/task/mutation-result.js

@@ -1,16 +1,23 @@
-import { isTaskSegment, formatTaskId, parseTaskId } from "./identity.js";
+import { isTaskSegment, canonicalTaskId, parseTaskId } from "./identity.js";
 import { z } from "zod";
 const nonblankTextSchema = z.string().refine((value) => value.trim() !== "");
+function withoutUndefined(value, keys) {
+    const result = { ...value };
+    for (const key of keys) {
+        const field = result[key];
+        delete result[key];
+        if (field !== undefined)
+            result[key] = field;
+    }
+    return result;
+}
 const timestampSchema = z.string().refine((value) => {
     const parsed = Date.parse(value);
     return Number.isFinite(parsed) && new Date(parsed).toISOString() === value;
 }, "expected canonical UTC timestamp");
 export const taskMutationIdSchema = z.string().transform((value, context) => {
     try {
-        const id = formatTaskId(parseTaskId(value));
-        if (id !== value)
-            throw new Error("not canonical");
-        return id;
+        return canonicalTaskId(value);
     }
     catch {
         context.addIssue({ code: "custom", message: "expected canonical TaskId" });
@@ -26,6 +33,9 @@ const taskPrioritySchema = z.union([z.literal(0), z.literal(1), z.literal(2), z.
 const taskRetrySchema = z
     .object({ kind: z.literal("retry"), reason: z.enum(["busy", "concurrent-modification"]) })
     .strict();
+const taskCleanupFailureSchema = z
+    .object({ kind: z.literal("lock-release-failed"), diagnostics: z.array(z.string()) })
+    .strict();
 const taskViewSchema = z
     .object({
     id: taskMutationIdSchema,
@@ -75,7 +85,10 @@ const taskRefusalSchema = z.union([
     z.object({ kind: z.literal("invalid-composition"), diagnostics: z.array(compositionDiagnosticSchema) }).strict(),
 ]);
 export const taskMutationResultSchema = z.union([
-    z.object({ kind: z.literal("accepted"), value: taskViewSchema }).strict(),
+    z
+        .object({ kind: z.literal("accepted"), value: taskViewSchema, cleanup: taskCleanupFailureSchema.optional() })
+        .strict()
+        .transform((value) => withoutUndefined(value, ["cleanup"])),
     z.object({ kind: z.literal("refused"), refusal: taskRefusalSchema }).strict(),
     taskRetrySchema,
 ]);
@@ -84,8 +97,10 @@ export const taskUpdateResultSchema = z.union([
         .object({
         kind: z.literal("accepted"),
         value: z.object({ task: taskViewSchema, documentDiff: z.string() }).strict(),
+        cleanup: taskCleanupFailureSchema.optional(),
     })
-        .strict(),
+        .strict()
+        .transform((value) => withoutUndefined(value, ["cleanup"])),
     z.object({ kind: z.literal("refused"), refusal: taskRefusalSchema }).strict(),
     taskRetrySchema,
 ]);
@@ -110,7 +125,15 @@ export const taskCompositionResultSchema = z.union([
             .strict()),
     })
         .strict(),
-    z.object({ kind: z.literal("accepted"), ...compositionFactsSchema, documentChanges: documentChangesSchema }).strict(),
+    z
+        .object({
+        kind: z.literal("accepted"),
+        ...compositionFactsSchema,
+        documentChanges: documentChangesSchema,
+        cleanup: taskCleanupFailureSchema.optional(),
+    })
+        .strict()
+        .transform((value) => withoutUndefined(value, ["cleanup"])),
     z
         .object({
         kind: z.literal("refused"),
@@ -124,10 +147,12 @@ export const taskCompositionResultSchema = z.union([
         kind: z.literal("incomplete"),
         ...compositionFactsSchema,
         documentChanges: documentChangesSchema,
+        cleanup: taskCleanupFailureSchema.optional(),
         stopped: z.union([taskRefusalSchema, taskRetrySchema]),
         draft: z.string(),
     })
-        .strict(),
+        .strict()
+        .transform((value) => withoutUndefined(value, ["cleanup"])),
 ]);
 export const taskMutationExecutionResultSchema = z.union([
     taskBatchResultSchema,

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

@@ -1,5 +1,5 @@
 import { type WorldRoot } from "../world.js";
-import { type ErasedRequestCommand, type RequestCommand } from "../akuma/request-wire.js";
+import { type ErasedRequestCommand, type RequestProtocol, type ServiceRequestCommand } from "../akuma/request-wire.js";
 import { type TaskBatchResult, type TaskMutationResult, type TaskUpdateResult } from "./operations.js";
 import { type TaskCompositionResult } from "./compose.js";
 import { type TaskMutationExecutionResult } from "./mutation-result.js";
@@ -7,7 +7,6 @@ import { z } from "zod";
 export type { TaskMutationExecutionResult } from "./mutation-result.js";
 export declare const TASK_MUTATION_ACTIONS: readonly ["task.add", "task.addDocument", "task.compose", "task.done", "task.drop", "task.hold", "task.resume", "task.start", "task.stop", "task.update"];
 export type TaskMutationAction = (typeof TASK_MUTATION_ACTIONS)[number];
-export declare function isTaskMutationAction(value: unknown): value is TaskMutationAction;
 declare const taskRequestSchemas: {
     readonly "task.add": z.ZodPipe<z.ZodObject<{
         input: z.ZodObject<{
@@ -537,14 +536,10 @@ export type TaskMutationRequestPort = Readonly<{
         signal: AbortSignal;
     }>): Promise<TaskMutationExecutionResult>;
 }>;
-type TaskMutationExecutionContext = Readonly<{
-    requester: string;
-    signal: AbortSignal;
-    upstream: TaskMutationRequestPort;
-}>;
 /** Task owns forwarded mutation payload, live result, and durable service evidence. */
-export declare function taskMutationRequestCommand(action: TaskMutationAction): RequestCommand<TaskMutationBodyRequest, TaskMutationExecutionResult, TaskMutationService, ForwardedTaskReference, TaskMutationExecutionContext>;
-export declare function taskMutationRequestCommands(): Readonly<Record<TaskMutationAction, ErasedRequestCommand>>;
+export declare function taskMutationRequestProtocol(action: TaskMutationAction): RequestProtocol<TaskMutationBodyRequest, TaskMutationExecutionResult, ForwardedTaskReference>;
+export declare function taskMutationRequestCommand(action: TaskMutationAction, port: TaskMutationRequestPort): ServiceRequestCommand<TaskMutationBodyRequest, TaskMutationExecutionResult, TaskMutationService, ForwardedTaskReference>;
+export declare function taskMutationRequestCommands(port: TaskMutationRequestPort): Readonly<Record<TaskMutationAction, ErasedRequestCommand>>;
 export declare function requestForwardedTask<Request extends TaskMutationRequest>(input: Readonly<{
     directory: string;
     id?: never;

package/build/src/task/mutation.js

@@ -1,7 +1,6 @@
-/* eslint-disable max-lines -- Task owns one coherent forwarded mutation boundary. */
 import { World } from "../world.js";
 import { requestBodyCommand } from "../akuma/request-rendezvous.js";
-import { eraseRequestCommand } from "../akuma/request-wire.js";
+import { eraseRequestCommand, } from "../akuma/request-wire.js";
 import { addTask, addTaskDocument, batchTasks, lifecycleTask, updateTask, } from "./operations.js";
 import { composeTasks } from "./compose.js";
 import { isTaskSegment } from "./identity.js";
@@ -19,10 +18,6 @@ export const TASK_MUTATION_ACTIONS = Object.freeze([
     "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);
-}
 const nonblankTextSchema = z.string().refine((value) => value.trim() !== "");
 const namespaceSchema = z.array(z.string().refine(isTaskSegment)).readonly();
 const taskIdsBaseSchema = z.array(taskMutationIdSchema).superRefine((ids, context) => {
@@ -141,30 +136,6 @@ export const taskMutationServiceSchema = z.object({ action: z.enum(TASK_MUTATION
 export const forwardedTaskReferenceSchema = z
     .object({ kind: z.literal("served-reference"), action: z.enum(TASK_MUTATION_ACTIONS) })
     .strict();
-function decodeTaskMutationExecutionContext(value) {
-    const context = resultRecord(value);
-    if (context === null ||
-        typeof context.requester !== "string" ||
-        context.requester.trim() === "" ||
-        !isAbortSignal(context.signal) ||
-        !isTaskMutationRequestPort(context.upstream))
-        throw new Error("invalid Task execution context");
-    return { requester: context.requester, signal: context.signal, upstream: context.upstream };
-}
-function isAbortSignal(value) {
-    return (value !== null &&
-        typeof value === "object" &&
-        typeof value.throwIfAborted === "function");
-}
-function isTaskMutationRequestPort(value) {
-    const port = resultRecord(value);
-    return port !== null && typeof port.task === "function";
-}
-function resultRecord(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : null;
-}
 function decodeTaskBodyRequest(action, value) {
     const parsed = taskBodyRequestSchemas[action].safeParse(value);
     return parsed.success ? parsed.data : null;
@@ -182,7 +153,7 @@ function decodeTaskReference(action, value) {
     return parsed.data;
 }
 /** Task owns forwarded mutation payload, live result, and durable service evidence. */
-export function taskMutationRequestCommand(action) {
+export function taskMutationRequestProtocol(action) {
     return {
         action,
         encodeRequest: (input) => {
@@ -197,39 +168,33 @@ export function taskMutationRequestCommand(action) {
             }
             return result;
         },
+        decodeReference: (reference) => decodeTaskReference(action, reference),
+        isPermitted: (allowed) => allowed.includes(action),
+    };
+}
+export function taskMutationRequestCommand(action, port) {
+    return {
+        completion: "service",
+        protocol: taskMutationRequestProtocol(action),
         encodeService: (service) => decodeTaskService(action, service),
         decodeService: (service) => decodeTaskService(action, service),
         projectService: (service) => decodeTaskReference(action, { kind: "served-reference", action: service.action }),
-        decodeReference: (reference) => decodeTaskReference(action, reference),
-        isPermitted: (allowed) => allowed.includes(action),
-        decodeExecutionContext: decodeTaskMutationExecutionContext,
-        execute: async (request, context) => {
+        execute: async (request, facts) => {
             const world = await World.prove(request.world);
             return {
-                result: await context.upstream.task({
+                result: await port.task({
                     world,
                     request: request.request,
-                    requester: context.requester,
-                    signal: context.signal,
+                    requester: facts.requester,
+                    signal: facts.signal,
                 }),
                 service: { action: request.request.action },
             };
         },
     };
 }
-export function taskMutationRequestCommands() {
-    return {
-        "task.add": eraseRequestCommand(taskMutationRequestCommand("task.add")),
-        "task.addDocument": eraseRequestCommand(taskMutationRequestCommand("task.addDocument")),
-        "task.compose": eraseRequestCommand(taskMutationRequestCommand("task.compose")),
-        "task.done": eraseRequestCommand(taskMutationRequestCommand("task.done")),
-        "task.drop": eraseRequestCommand(taskMutationRequestCommand("task.drop")),
-        "task.hold": eraseRequestCommand(taskMutationRequestCommand("task.hold")),
-        "task.resume": eraseRequestCommand(taskMutationRequestCommand("task.resume")),
-        "task.start": eraseRequestCommand(taskMutationRequestCommand("task.start")),
-        "task.stop": eraseRequestCommand(taskMutationRequestCommand("task.stop")),
-        "task.update": eraseRequestCommand(taskMutationRequestCommand("task.update")),
-    };
+export function taskMutationRequestCommands(port) {
+    return Object.fromEntries(TASK_MUTATION_ACTIONS.map((action) => [action, eraseRequestCommand(taskMutationRequestCommand(action, port))]));
 }
 function taskResultForRequest(request, value) {
     const schema = request.action === "task.compose"
@@ -245,7 +210,7 @@ export async function requestForwardedTask(input) {
     const response = await requestBodyCommand({
         directory: input.directory,
         ...(input.id === undefined ? {} : { id: input.id }),
-        command: taskMutationRequestCommand(input.request.action),
+        command: taskMutationRequestProtocol(input.request.action),
         value: { world: input.world, request: input.request },
         ...(input.signal === undefined ? {} : { signal: input.signal }),
     });

package/build/src/task/operation-types.d.ts

@@ -0,0 +1,114 @@
+import type { TaskDocument, TaskPriority, TaskState } from "./document.js";
+import type { TaskId } from "./identity.js";
+export type TaskView = Readonly<TaskDocument & {
+    namespace: readonly string[];
+}>;
+export type TaskCleanupFailure = Readonly<{
+    kind: "lock-release-failed";
+    diagnostics: readonly string[];
+}>;
+export type TaskCompositionDiagnostic = Readonly<{
+    line: number;
+    reason: string;
+    token: string;
+}>;
+export type TaskRefusal = Readonly<{
+    kind: "task-missing";
+    taskId: TaskId;
+}> | Readonly<{
+    kind: "invalid-lifecycle-transition";
+    taskId: TaskId;
+    state: TaskState;
+    verb: TaskLifecycleVerb;
+}> | Readonly<{
+    kind: "invalid-graph";
+    diagnostic: string;
+}> | Readonly<{
+    kind: "invalid-namespace-context";
+    path: string;
+}> | Readonly<{
+    kind: "relation-owned-by-other";
+    taskId: TaskId;
+    related: TaskId;
+    declaringTask: TaskId;
+}> | Readonly<{
+    kind: "invalid-composition";
+    diagnostics: readonly TaskCompositionDiagnostic[];
+}>;
+export type TaskRetry = "busy" | "concurrent-modification";
+export type TaskOutcome<A> = Readonly<{
+    kind: "accepted";
+    value: A;
+    cleanup?: TaskCleanupFailure;
+}> | Readonly<{
+    kind: "refused";
+    refusal: TaskRefusal;
+}> | Readonly<{
+    kind: "retry";
+    reason: TaskRetry;
+}>;
+export type TaskMutationResult = TaskOutcome<TaskView>;
+export type TaskUpdateResult = TaskOutcome<Readonly<{
+    task: TaskView;
+    documentDiff: string;
+}>>;
+export type TaskLifecycleVerb = "start" | "stop" | "hold" | "resume" | "done" | "drop";
+export type TaskBatchResult = Readonly<{
+    items: readonly Readonly<{
+        id: TaskId;
+        outcome: TaskMutationResult;
+    }>[];
+}>;
+export type SettledTaskAction = "done";
+export type SettledTaskResult = Readonly<{
+    kind: "changed";
+    task: TaskView;
+    action: SettledTaskAction;
+    cleanup?: TaskCleanupFailure;
+}> | Readonly<{
+    kind: "unchanged";
+}> | Readonly<{
+    kind: "refused";
+    refusal: TaskRefusal;
+}> | Readonly<{
+    kind: "retry";
+    reason: TaskRetry;
+}>;
+export type AddTaskInput = Readonly<{
+    title: string;
+    namespace?: readonly string[];
+    body?: string;
+    note?: string;
+    state?: TaskState;
+    priority?: TaskPriority;
+    needs?: readonly TaskId[];
+    parent?: TaskId | null;
+    supersedes?: readonly TaskId[];
+    relates?: readonly TaskId[];
+    actor?: string;
+    signal?: AbortSignal;
+}>;
+export type AddTaskDocumentInput = Readonly<{
+    markdown: string;
+    namespace?: readonly string[];
+    actor?: string;
+    signal?: AbortSignal;
+}>;
+export type UpdateTaskInput = Readonly<{
+    title?: string;
+    body?: string;
+    appendBody?: string;
+    note?: string;
+    priority?: TaskPriority;
+    needs?: readonly TaskId[];
+    addNeeds?: readonly TaskId[];
+    dropNeeds?: readonly TaskId[];
+    parent?: TaskId | null;
+    supersedes?: readonly TaskId[];
+    addSupersedes?: readonly TaskId[];
+    dropSupersedes?: readonly TaskId[];
+    relates?: readonly TaskId[];
+    addRelates?: readonly TaskId[];
+    dropRelates?: readonly TaskId[];
+    signal?: AbortSignal;
+}>;

package/build/src/task/operation-types.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,127 +1,20 @@
 import { type BlockedTaskRow, type TaskBoardObservation, type TaskDetailFacts, type TaskRow } from "./board.js";
-import { type TaskDocument, type TaskPriority, type TaskState } from "./document.js";
 import { type TaskId } from "./identity.js";
 import type { WorldRoot } from "../world.js";
 import { type TaskPage, type TaskQueryExpression, type TaskQueryRow, type TaskQuerySort } from "./query.js";
-export type TaskView = Readonly<TaskDocument & {
-    namespace: readonly string[];
-}>;
+export { advanceTaskTimestamp, taskView } from "./view.js";
+export type { AddTaskDocumentInput, AddTaskInput, TaskCleanupFailure, SettledTaskAction, SettledTaskResult, TaskBatchResult, TaskCompositionDiagnostic, TaskLifecycleVerb, TaskMutationResult, TaskOutcome, TaskRefusal, TaskRetry, TaskUpdateResult, TaskView, UpdateTaskInput, } from "./operation-types.js";
+import type { AddTaskDocumentInput, AddTaskInput, TaskMutationResult, TaskOutcome, TaskUpdateResult, TaskView, UpdateTaskInput } from "./operation-types.js";
 export declare function nukeTask(world: WorldRoot, options?: Readonly<{
     timeoutMs?: number;
 }>): Promise<void>;
-export type TaskCompositionDiagnostic = Readonly<{
-    line: number;
-    reason: string;
-    token: string;
-}>;
-export type TaskRefusal = Readonly<{
-    kind: "task-missing";
-    taskId: TaskId;
-}> | Readonly<{
-    kind: "invalid-lifecycle-transition";
-    taskId: TaskId;
-    state: TaskState;
-    verb: TaskLifecycleVerb;
-}> | Readonly<{
-    kind: "invalid-graph";
-    diagnostic: string;
-}> | Readonly<{
-    kind: "invalid-namespace-context";
-    path: string;
-}> | Readonly<{
-    kind: "relation-owned-by-other";
-    taskId: TaskId;
-    related: TaskId;
-    declaringTask: TaskId;
-}> | Readonly<{
-    kind: "invalid-composition";
-    diagnostics: readonly TaskCompositionDiagnostic[];
-}>;
-export type TaskRetry = "busy" | "concurrent-modification";
-export type TaskOutcome<A> = Readonly<{
-    kind: "accepted";
-    value: A;
-}> | Readonly<{
-    kind: "refused";
-    refusal: TaskRefusal;
-}> | Readonly<{
-    kind: "retry";
-    reason: TaskRetry;
-}>;
-export type TaskMutationResult = TaskOutcome<TaskView>;
-export type TaskUpdateResult = TaskOutcome<Readonly<{
-    task: TaskView;
-    documentDiff: string;
-}>>;
-export type TaskLifecycleVerb = "start" | "stop" | "hold" | "resume" | "done" | "drop";
-export type TaskBatchResult = Readonly<{
-    items: readonly Readonly<{
-        id: TaskId;
-        outcome: TaskMutationResult;
-    }>[];
-}>;
-export type SettledTaskAction = "done";
-export type SettledTaskResult = Readonly<{
-    kind: "changed";
-    task: TaskView;
-    action: SettledTaskAction;
-}> | Readonly<{
-    kind: "unchanged";
-}> | Readonly<{
-    kind: "refused";
-    refusal: TaskRefusal;
-}> | Readonly<{
-    kind: "retry";
-    reason: TaskRetry;
-}>;
-export type AddTaskInput = Readonly<{
-    title: string;
-    namespace?: readonly string[];
-    body?: string;
-    note?: string;
-    state?: TaskState;
-    priority?: TaskPriority;
-    needs?: readonly TaskId[];
-    parent?: TaskId | null;
-    supersedes?: readonly TaskId[];
-    relates?: readonly TaskId[];
-    actor?: string;
-    signal?: AbortSignal;
-}>;
-export type AddTaskDocumentInput = Readonly<{
-    markdown: string;
-    namespace?: readonly string[];
-    actor?: string;
-    signal?: AbortSignal;
-}>;
-export type UpdateTaskInput = Readonly<{
-    title?: string;
-    body?: string;
-    appendBody?: string;
-    note?: string;
-    priority?: TaskPriority;
-    needs?: readonly TaskId[];
-    addNeeds?: readonly TaskId[];
-    dropNeeds?: readonly TaskId[];
-    parent?: TaskId | null;
-    supersedes?: readonly TaskId[];
-    addSupersedes?: readonly TaskId[];
-    dropSupersedes?: readonly TaskId[];
-    relates?: readonly TaskId[];
-    addRelates?: readonly TaskId[];
-    dropRelates?: readonly TaskId[];
-    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 type { TaskState } from "./document.js";
 export declare function addTask(world: WorldRoot, input: AddTaskInput): Promise<TaskMutationResult>;
 export declare function addTaskDocument(world: WorldRoot, input: AddTaskDocumentInput): Promise<TaskMutationResult>;
 export declare function updateTask(world: WorldRoot, id: TaskId, input: UpdateTaskInput): Promise<TaskUpdateResult>;
-export 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 settleTask(world: WorldRoot, id: TaskId): Promise<SettledTaskResult>;
+export { batchTasks, lifecycleTask, settleTask } from "./lifecycle-operations.js";
 export declare function listTasks(world: WorldRoot, namespace: readonly string[] | undefined, selection: "active" | "closed" | "all", scope?: "namespace" | "world", limit?: number): Promise<TaskOutcome<TaskPage<TaskRow>>>;
+export declare function readTaskDetail(world: WorldRoot, id: TaskId): Promise<TaskDetailFacts | null>;
 export declare function readTaskDetails(world: WorldRoot, ids: readonly TaskId[]): Promise<TaskOutcome<readonly TaskDetailFacts[]>>;
 export declare function observeTaskDetails(world: WorldRoot, ids: readonly TaskId[]): Promise<TaskOutcome<readonly (Omit<TaskDetailFacts, "task"> & Readonly<{
     task: TaskView;