@astrosheep/keiyaku 4.6.8 → 4.6.10

package/build/src/task/mutation.js

@@ -1,262 +0,0 @@
-import { World } from "../world.js";
-import { requestBodyCommand } from "../akuma/request-rendezvous.js";
-import { eraseRequestCommand, } from "../akuma/request-wire.js";
-import { taskIdsSchema, taskNamespaceSchema } from "./identity.js";
-import { taskNonblankTextSchema, taskStateSchema, taskPrioritySchema } from "./document.js";
-import { taskBatchResultSchema, taskCompositionResultSchema, taskMutationIdSchema, taskMutationResultSchema, taskUpdateResultSchema, } from "./mutation-result.js";
-import { z } from "zod";
-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 taskMutationActionSchema = z.enum(TASK_MUTATION_ACTIONS);
-const nonemptyTaskIdsSchema = taskIdsSchema.unwrap().min(1).readonly();
-const addInputSchema = z
-    .object({
-    title: taskNonblankTextSchema,
-    namespace: taskNamespaceSchema,
-    body: z.string().optional(),
-    note: z.string().optional(),
-    state: taskStateSchema.optional(),
-    priority: taskPrioritySchema.optional(),
-    needs: taskIdsSchema.optional(),
-    parent: taskMutationIdSchema.nullable().optional(),
-    supersedes: taskIdsSchema.optional(),
-    relates: taskIdsSchema.optional(),
-})
-    .strict();
-const updateInputSchema = z
-    .object({
-    title: taskNonblankTextSchema.optional(),
-    body: z.string().optional(),
-    appendBody: z.string().optional(),
-    note: z.string().optional(),
-    priority: taskPrioritySchema.optional(),
-    needs: taskIdsSchema.optional(),
-    addNeeds: taskIdsSchema.optional(),
-    dropNeeds: taskIdsSchema.optional(),
-    parent: taskMutationIdSchema.nullable().optional(),
-    supersedes: taskIdsSchema.optional(),
-    addSupersedes: taskIdsSchema.optional(),
-    dropSupersedes: taskIdsSchema.optional(),
-    relates: taskIdsSchema.optional(),
-    addRelates: taskIdsSchema.optional(),
-    dropRelates: taskIdsSchema.optional(),
-})
-    .strict()
-    .superRefine((input, context) => {
-    if (input.body !== undefined && input.appendBody !== undefined)
-        context.addIssue({ code: "custom", message: "body and appendBody are mutually exclusive" });
-    if (Object.values(input).every((value) => value === undefined))
-        context.addIssue({ code: "custom", message: "update requires at least one field change" });
-});
-const addRequestSchema = z
-    .object({ input: addInputSchema })
-    .strict()
-    .transform(({ input }) => ({ action: "task.add", input }));
-const addDocumentRequestSchema = z
-    .object({ input: z.object({ markdown: z.string(), namespace: taskNamespaceSchema }).strict() })
-    .strict()
-    .transform(({ input }) => ({ action: "task.addDocument", input }));
-const composeRequestSchema = z
-    .object({ markdown: z.string(), namespace: taskNamespaceSchema })
-    .strict()
-    .transform((request) => ({ action: "task.compose", ...request }));
-const updateRequestSchema = z
-    .object({ id: taskMutationIdSchema, input: updateInputSchema })
-    .strict()
-    .transform((request) => ({ action: "task.update", ...request }));
-const singleOrBatchRequestSchema = (action) => z.union([
-    z
-        .object({ id: taskMutationIdSchema })
-        .strict()
-        .transform(({ id }) => ({ action, id })),
-    z
-        .object({ ids: nonemptyTaskIdsSchema })
-        .strict()
-        .transform(({ ids }) => ({ action, ids })),
-]);
-const terminalRequestSchema = (action) => z.union([
-    z
-        .object({ id: taskMutationIdSchema, note: z.string().optional() })
-        .strict()
-        .transform(({ id, note }) => ({ action, id, ...(note === undefined ? {} : { note }) })),
-    z
-        .object({ ids: nonemptyTaskIdsSchema, note: z.string().optional() })
-        .strict()
-        .transform(({ ids, note }) => ({ action, ids, ...(note === undefined ? {} : { note }) })),
-]);
-const taskRequestSchemas = {
-    "task.add": addRequestSchema,
-    "task.addDocument": addDocumentRequestSchema,
-    "task.compose": composeRequestSchema,
-    "task.done": terminalRequestSchema("task.done"),
-    "task.drop": terminalRequestSchema("task.drop"),
-    "task.hold": singleOrBatchRequestSchema("task.hold"),
-    "task.resume": singleOrBatchRequestSchema("task.resume"),
-    "task.start": singleOrBatchRequestSchema("task.start"),
-    "task.stop": singleOrBatchRequestSchema("task.stop"),
-    "task.update": updateRequestSchema,
-};
-const worldPathSchema = z.string().min(1);
-const taskBodyRequestSchema = z
-    .object({ world: worldPathSchema, request: z.union(Object.values(taskRequestSchemas)) })
-    .strict();
-const taskMutationServiceSchema = z.object({ action: taskMutationActionSchema }).strict();
-export const forwardedTaskReferenceSchema = z
-    .object({ kind: z.literal("served-reference"), action: taskMutationActionSchema })
-    .strict();
-function decodeTaskBodyRequest(action, value) {
-    const parsed = taskBodyRequestSchema.extend({ request: taskRequestSchemas[action] }).safeParse(value);
-    return parsed.success ? parsed.data : null;
-}
-function decodeTaskService(action, value) {
-    const parsed = taskMutationServiceSchema.safeParse(value);
-    if (!parsed.success || parsed.data.action !== action)
-        throw new Error(`malformed stored Task service evidence for ${action}`);
-    return parsed.data;
-}
-function decodeTaskReference(action, value) {
-    const parsed = forwardedTaskReferenceSchema.safeParse(value);
-    if (!parsed.success || parsed.data.action !== action)
-        throw new Error(`malformed Task service reference for ${action}`);
-    return parsed.data;
-}
-/** Task owns forwarded mutation payload, live result, and durable service evidence. */
-export function taskMutationRequestProtocol(action, batch) {
-    return {
-        action,
-        encodeRequest: (input) => {
-            const { action: _action, ...request } = input.request;
-            return { world: input.world, request };
-        },
-        decodeRequest: (value) => decodeTaskBodyRequest(action, value),
-        encodeResult: (result) => result,
-        decodeResult: (result) => {
-            const schema = action === "task.compose"
-                ? taskCompositionResultSchema
-                : action === "task.update"
-                    ? taskUpdateResultSchema
-                    : batch === undefined
-                        ? z.union([taskMutationResultSchema, taskBatchResultSchema])
-                        : batch
-                            ? taskBatchResultSchema
-                            : taskMutationResultSchema;
-            const parsed = schema.safeParse(result);
-            if (!parsed.success)
-                throw new Error(`transport integrity: Task ${action} returned an invalid live result`);
-            return parsed.data;
-        },
-        decodeReference: (reference) => decodeTaskReference(action, reference),
-        isPermitted: (allowed) => allowed.includes(action),
-    };
-}
-export function taskMutationRequestCommand(action, port) {
-    return {
-        completion: "service",
-        protocol: taskMutationRequestProtocol(action),
-        encodeService: (service) => service,
-        decodeService: (service) => decodeTaskService(action, service),
-        projectService: (service) => ({ kind: "served-reference", action: service.action }),
-        execute: async (request, facts) => {
-            const world = await World.prove(request.world);
-            const action = request.request.action;
-            let result;
-            switch (action) {
-                case "task.add":
-                    result = await port.add({
-                        world,
-                        options: addTaskOptions(request.request.input, facts.requester, facts.signal),
-                    });
-                    break;
-                case "task.addDocument":
-                    result = await port.addDocument({
-                        world,
-                        document: { ...request.request.input, actor: facts.requester, signal: facts.signal },
-                    });
-                    break;
-                case "task.compose":
-                    result = await port.compose({
-                        world,
-                        markdown: request.request.markdown,
-                        defaultNamespace: request.request.namespace,
-                        actor: facts.requester,
-                        signal: facts.signal,
-                    });
-                    break;
-                case "task.update":
-                    result = await port.update({
-                        world,
-                        id: request.request.id,
-                        options: updateTaskOptions(request.request.input, facts.signal),
-                    });
-                    break;
-                case "task.start":
-                case "task.stop":
-                case "task.hold":
-                case "task.resume":
-                case "task.done":
-                case "task.drop": {
-                    const verb = action.slice("task.".length);
-                    const note = "note" in request.request ? request.request.note : undefined;
-                    result =
-                        "ids" in request.request
-                            ? await port.batch({
-                                world,
-                                verb,
-                                ids: request.request.ids,
-                                ...(note === undefined ? {} : { note }),
-                                signal: facts.signal,
-                            })
-                            : await port.lifecycle({
-                                world,
-                                verb,
-                                id: request.request.id,
-                                ...(note === undefined ? {} : { note }),
-                                signal: facts.signal,
-                            });
-                    break;
-                }
-            }
-            return { kind: "served", result, service: { action } };
-        },
-    };
-}
-export function taskMutationRequestCommands(port) {
-    return Object.fromEntries(TASK_MUTATION_ACTIONS.map((action) => [action, eraseRequestCommand(taskMutationRequestCommand(action, port))]));
-}
-export async function requestForwardedTask(input) {
-    const response = await requestBodyCommand({
-        directory: input.directory,
-        ...(input.id === undefined ? {} : { id: input.id }),
-        command: taskMutationRequestProtocol(input.request.action, "ids" in input.request),
-        value: { world: input.world, request: input.request },
-        ...(input.signal === undefined ? {} : { signal: input.signal }),
-    });
-    if (response.kind === "reference")
-        return response.reference;
-    return response.result;
-}
-/** Absent optional fields are omitted, never republished as an explicit undefined. */
-function definedFields(fields, additions = {}) {
-    const selected = {};
-    for (const [key, value] of Object.entries({ ...fields, ...additions })) {
-        if (value !== undefined)
-            selected[key] = value;
-    }
-    return selected;
-}
-function addTaskOptions(input, actor, signal) {
-    return definedFields(input, { actor, signal });
-}
-function updateTaskOptions(input, signal) {
-    return definedFields(input, { signal });
-}

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

@@ -1,71 +0,0 @@
-import type { TaskPriority, TaskState } from "./document.js";
-import type { TaskId } from "./identity.js";
-import type { TaskCleanupFailure, TaskRefusal, TaskRetry, TaskView } from "./mutation-result.js";
-export type { TaskView, TaskCleanupFailure, TaskCompositionDiagnostic, TaskRefusal, TaskRetry, TaskMutationResult, TaskUpdateResult, TaskBatchResult, } from "./mutation-result.js";
-export type TaskOutcome<A> = Readonly<{
-    kind: "accepted";
-    value: A;
-    cleanup?: TaskCleanupFailure;
-}> | Readonly<{
-    kind: "refused";
-    refusal: TaskRefusal;
-}> | Readonly<{
-    kind: "retry";
-    reason: TaskRetry;
-}>;
-export type TaskLifecycleVerb = Extract<TaskRefusal, {
-    kind: "invalid-lifecycle-transition";
-}>["verb"];
-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/operations.d.ts

@@ -1,28 +0,0 @@
-import { type BlockedTaskRow, type TaskBoardObservation, type TaskDetailFacts, type TaskRow } from "./board.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 { advanceTaskTimestamp, taskView } from "./view.js";
-export type { AddTaskDocumentInput, AddTaskInput, TaskCleanupFailure, SettledTaskResult, TaskBatchResult, TaskCompositionDiagnostic, TaskMutationResult, TaskOutcome, TaskRefusal, TaskRetry, TaskUpdateResult, TaskView, UpdateTaskInput, } from "./operation-types.js";
-import type { AddTaskDocumentInput, AddTaskInput, TaskMutationResult, TaskOutcome, TaskUpdateResult, UpdateTaskInput } from "./operation-types.js";
-export declare function nukeTask(world: WorldRoot, options?: Readonly<{
-    timeoutMs?: number;
-    onRemoved?(count: number): void;
-}>): Promise<number>;
-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 { 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 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>>>;
-export declare function observeTaskBoard(world: WorldRoot): Promise<TaskBoardObservation>;

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

@@ -1,76 +0,0 @@
-import type { TaskPriority, TaskState } from "./document.js";
-import { type TaskId } from "./identity.js";
-import type { TaskBoard, TaskRef, TaskRelationProjection, TaskRow } from "./board.js";
-import { type BoundedList } from "../bounded-list.js";
-export declare const TASK_RELATION_PREDICATE_FIELDS: readonly ["under", "needs", "blocks"];
-export type TaskRelationPredicateField = (typeof TASK_RELATION_PREDICATE_FIELDS)[number];
-export type TaskQueryPredicate = Readonly<{
-    field: "state";
-    operator: "=" | "!=";
-    value: TaskState;
-}> | Readonly<{
-    field: "priority";
-    operator: "=" | "!=" | "<" | "<=" | ">" | ">=";
-    value: TaskPriority;
-}> | Readonly<{
-    field: "title" | "id";
-    operator: "=" | "!=" | "~";
-    value: string;
-}> | Readonly<{
-    field: "parent";
-    operator: "=" | "!=";
-    value: TaskId | null;
-}> | Readonly<{
-    field: "under" | "needs" | "blocks";
-    operator: "=" | "!=";
-    value: TaskId;
-}> | Readonly<{
-    field: "ready" | "blocked";
-    operator: "=" | "!=";
-    value: boolean;
-}> | Readonly<{
-    field: "created" | "updated";
-    operator: "=" | "!=" | "<" | "<=" | ">" | ">=";
-    value: string;
-}>;
-export type TaskQueryExpression = Readonly<{
-    kind: "and" | "or";
-    terms: readonly TaskQueryExpression[];
-}> | Readonly<{
-    kind: "not";
-    term: TaskQueryExpression;
-}> | Readonly<{
-    kind: "predicate";
-    predicate: TaskQueryPredicate;
-}>;
-export type TaskQuerySort = "priority" | "created" | "updated" | "id";
-export type TaskQueryRow = TaskRow & Readonly<{
-    parent: TaskId | null;
-    needs: readonly TaskRef[];
-    blocks: readonly TaskRef[];
-    createdAt: string;
-    updatedAt: string;
-}>;
-export type TaskPage<Row> = BoundedList<Row>;
-/** Semantic refusals identify the caller input part; textual offsets belong to the CLI. */
-export declare class TaskQueryPredicateError extends TypeError {
-    readonly part: "field" | "operator" | "value";
-    constructor(message: string, part: "field" | "operator" | "value");
-}
-export declare function normalizeTaskQueryPredicate(value: unknown): TaskQueryPredicate;
-export declare function normalizeTaskQuery(value: unknown): TaskQueryExpression;
-/** CLI selection and native default share Task-owned terminal-state semantics. */
-export declare function taskQuerySelection(selection?: "active" | "closed" | "all", where?: TaskQueryExpression): TaskQueryExpression;
-export declare function projectQueryRows(board: TaskBoard, relations: TaskRelationProjection, input: Readonly<{
-    scope: readonly string[] | null;
-    expression: TaskQueryExpression;
-    sort?: TaskQuerySort;
-}>): readonly TaskQueryRow[];
-export declare function projectQuery(board: TaskBoard, relations: TaskRelationProjection, input: Readonly<{
-    scope: readonly string[] | null;
-    expression: TaskQueryExpression;
-    sort?: TaskQuerySort;
-    limit: number;
-}>): TaskPage<TaskQueryRow>;
-export declare function underExpression(parent: TaskId): TaskQueryExpression;
-export declare function queryUnderTargets(expression: TaskQueryExpression): readonly TaskId[];

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

@@ -1,4 +0,0 @@
-import type { TaskDocument } from "./document.js";
-import type { TaskView } from "./operation-types.js";
-export declare function taskView(document: TaskDocument): TaskView;
-export declare function advanceTaskTimestamp(previous: string, candidate: string): string;

package/build/src/task/view.js

@@ -1,7 +0,0 @@
-import { parseTaskId } from "./identity.js";
-export function taskView(document) {
-    return { ...document, namespace: parseTaskId(document.id).namespace };
-}
-export function advanceTaskTimestamp(previous, candidate) {
-    return candidate > previous ? candidate : new Date(Date.parse(previous) + 1).toISOString();
-}

package/skills/keiyaku-task/SKILL.md

@@ -1,104 +0,0 @@
----
-name: keiyaku-task
-description: >-
-  Must read when using Tasks for durable work planning, decomposition, or
-  dependencies.
----
-
-# Keiyaku Task
-
-A Task is durable planning memory. It records work, decomposition, and
-relationships that must remain after the current conversation. Task is an
-independent product; it is not a Contract, Arc, Akuma, permission, acceptance
-boundary, or fulfillment lifecycle.
-
-## 1. When To Use A Task
-
-Use a Task when the plan or dependency must outlive the current conversation.
-Skip it when the work is small and no durable planning memory is needed.
-
-- Use a `kei` for one independently acceptable outcome.
-- Use an Arc for a chapter inside one `kei`.
-- Use a Task for decomposition or dependency memory.
-- Do not create a Task just to mirror a `kei`.
-
-A Task may exist without a Contract. Associating a Task with a `kei` does not
-transfer the Contract's holder, acceptance, or lifecycle to the Task.
-
-## 2. Relationships And Parallel Work
-
-Independent Tasks may start and progress in parallel when their dependencies
-allow it.
-
-Use the relationships for their actual meanings:
-
-- `needs` means this Task must wait for another Task to become terminal.
-- `parent` groups decomposition; it does not create a dependency.
-- `supersedes` points to work replaced by this Task.
-- `relates` records a connection without affecting readiness.
-
-Only `needs` orders work. Do not add it because Tasks touch the same Region or
-because one Task is related to another. A terminal Task releases its dependents.
-An `on_hold` Task is deliberately paused; it is neither ready nor blocked.
-
-## 3. Task Commands
-
-Create and inspect Tasks:
-
-```bash
-keiyaku task add "<title>"
-keiyaku task add "<title>" --priority 1 --needs <task-id>
-keiyaku task show <task-id>
-keiyaku task ls
-keiyaku task ready
-keiyaku task blocked
-keiyaku task tree <task-id>
-keiyaku task doctor
-```
-
-Use complete Task IDs for targeted commands. `ls`, `ready`, and `blocked` use
-the current namespace; use `--world` to inspect the complete Task world.
-
-Change lifecycle state:
-
-```bash
-keiyaku task start <task-id>...
-keiyaku task stop <task-id>
-keiyaku task hold <task-id>...
-keiyaku task resume <task-id>
-keiyaku task done <task-id>...
-keiyaku task drop <task-id>... --note "<reason>"
-```
-
-Use `done` when the Task is complete. Use `drop` when it will not be done.
-Both terminal states release dependent Tasks. Use `hold` for a deliberate pause,
-not for an unresolved dependency; unresolved `needs` appear in `blocked`.
-
-Update a Task without changing its lifecycle:
-
-```bash
-keiyaku task update <task-id> --title "<title>"
-keiyaku task update <task-id> --body "<body>"
-keiyaku task update <task-id> --needs <task-id>
-```
-
-Use `task compose -` when several Tasks and their relationships should be
-planned or admitted together. Use `--plan` to inspect the composition without
-writing it.
-
-## 4. After Creating A Task
-
-Read the returned Task identity. Then:
-
-1. Start ready work.
-2. Run independent Tasks in parallel.
-3. Add or remove relationships when the plan changes.
-4. Hold work that is deliberately paused.
-5. Mark completed work `done`, or mark abandoned work `drop` with a reason.
-6. Use `ready`, `blocked`, `tree`, or `doctor` to rebuild the current view.
-
-Task records planning memory. It does not perform the work, claim acceptance,
-assign a holder, or decide what a Contract may accept.
-
-Read `keiyaku-bind` for Contract authoring and `keiyaku-workflow` for Contract
-lifecycle.