@astrosheep/keiyaku 4.6.8 → 4.6.10

package/build/src/cli/commands/task-grammar.js

@@ -1,384 +0,0 @@
-import { CliUsageError, TASK_FAMILY_USAGE_GUIDE, unknownCommandGuide } from "../usage.js";
-import { scanArgs } from "../scan.js";
-import { parseTaskNamespaceSelector } from "../../task/catalog.js";
-import { parseTaskId } from "../../task/identity.js";
-import { parseTaskQueryExpression, validateTaskLimit, validateTaskParent, } from "./task-query.js";
-const COMMON = { json: "boolean" };
-const TASK_COMMAND_SPECS = {
-    add: {
-        arity: [0, 1],
-        stdin: "document",
-        flags: {
-            ...COMMON,
-            namespace: "value",
-            state: "value",
-            priority: "value",
-            needs: "repeat",
-            parent: "value",
-            supersedes: "repeat",
-            relates: "repeat",
-            body: "value",
-            note: "value",
-            actor: "value",
-        },
-        usage: `task add <TITLE> [--namespace <ns>] [--priority 0..3]
-  [--state open|in_progress|on_hold|done|drop]
-  [--note <text>] [--actor <actor>]
-  [--needs <TaskId>]... [--parent <TaskId>]
-  [--supersedes <TaskId>]... [--relates <TaskId>]...
-  [--body <text>]
-task add [--namespace <ns>] [--actor <actor>] -`,
-        purpose: "Create a Task from flags or a Task document on stdin.",
-        details: "The stdin document is YAML front matter (title, state, priority, needs, parent, supersedes, relates, note) followed by a Markdown body.",
-    },
-    show: {
-        arity: [1, Number.POSITIVE_INFINITY],
-        flags: COMMON,
-        usage: "task show <TaskId>...",
-        purpose: "Read one or more Tasks and their relationships.",
-    },
-    ls: {
-        arity: [0, 1],
-        flags: { ...COMMON, closed: "boolean", all: "boolean", world: "boolean", limit: "value" },
-        usage: "task ls [<namespace-selector>] [--closed | --all] [--world] [--limit <n>]",
-        purpose: "List Tasks in the selected namespace.",
-        details: [
-            "With no selector, lists the current directory Task context.",
-            "task/ selects the root namespace; --world lists every namespace in the current Task world.",
-        ].join("\n"),
-    },
-    ready: {
-        arity: [0, 0],
-        flags: { ...COMMON, world: "boolean", parent: "value", limit: "value" },
-        usage: "task ready [--world] [--parent <TaskId>] [--limit <n>]",
-        purpose: "List open Tasks whose every dependency is complete or dropped.",
-        details: "--world lists every namespace in the current Task world.",
-    },
-    blocked: {
-        arity: [0, 0],
-        flags: { ...COMMON, world: "boolean", parent: "value", limit: "value" },
-        usage: "task blocked [--world] [--parent <TaskId>] [--limit <n>]",
-        purpose: "List Tasks with unmet dependencies.",
-        details: "--world lists every namespace in the current Task world.",
-    },
-    query: {
-        arity: [0, 0],
-        flags: {
-            ...COMMON,
-            where: "value",
-            world: "boolean",
-            closed: "boolean",
-            all: "boolean",
-            sort: "value",
-            limit: "value",
-        },
-        usage: `task query [--where <expression>] [--closed | --all] [--world]
-  [--sort priority|created|updated|id] [--limit <n>]`,
-        purpose: "Filter and sort Tasks with a boolean expression.",
-        details: [
-            "fields: state priority title id parent under needs blocks ready blocked created updated",
-            "operators: = != < > <= >= ~ and or not ( )",
-            "sort: priority and created ascend; updated descends; id is lexical. Default: priority.",
-            "--world lists every namespace in the current Task world.",
-            "By default only active Tasks match; --closed selects terminal Tasks, --all includes both.",
-            "examples:",
-            "  keiyaku task query --where 'priority <= 1 and ready' --world",
-            "  keiyaku task query --where 'updated < 2026-08-06T00:00:00.000Z' --world",
-        ].join("\n"),
-    },
-    tree: {
-        arity: [1, 1],
-        flags: COMMON,
-        usage: "task tree <TaskId>",
-        purpose: "Show a Task and its parent/child breakdown.",
-    },
-    doctor: {
-        arity: [0, 0],
-        flags: COMMON,
-        usage: "task doctor",
-        purpose: "Check Tasks for inconsistencies without changing them.",
-    },
-    update: {
-        arity: [1, 1],
-        flags: {
-            ...COMMON,
-            title: "value",
-            body: "value",
-            append: "value",
-            note: "value",
-            priority: "value",
-            needs: "repeat",
-            "drop-needs": "repeat",
-            parent: "value",
-            "no-parent": "boolean",
-            supersedes: "repeat",
-            "drop-supersedes": "repeat",
-            relates: "repeat",
-            "drop-relates": "repeat",
-        },
-        usage: `task update <TaskId> [--title <text>] [--body <text>|- | --append <text>]
-  [--note <text>]
-  [--priority 0..3] [--needs <TaskId>]... [--drop-needs <TaskId>]...
-  [--parent <TaskId> | --no-parent]
-  [--supersedes <TaskId>]... [--drop-supersedes <TaskId>]...
-  [--relates <TaskId>]... [--drop-relates <TaskId>]...`,
-        purpose: "Change a Task's fields and relationships.",
-        details: [
-            "--body replaces the body; --append adds text after it, separated by a newline when needed.",
-            "--body - reads replacement body text from stdin.",
-        ].join("\n"),
-    },
-    start: {
-        arity: [1, Number.POSITIVE_INFINITY],
-        flags: COMMON,
-        usage: "task start <TaskId>...",
-        purpose: "Move one or more open Tasks into progress.",
-    },
-    stop: {
-        arity: [1, Number.POSITIVE_INFINITY],
-        flags: COMMON,
-        usage: "task stop <TaskId>...",
-        purpose: "Return one or more in-progress Tasks to open.",
-    },
-    hold: {
-        arity: [1, Number.POSITIVE_INFINITY],
-        flags: COMMON,
-        usage: "task hold <TaskId>...",
-        purpose: "Put one or more Tasks on hold.",
-    },
-    resume: {
-        arity: [1, Number.POSITIVE_INFINITY],
-        flags: COMMON,
-        usage: "task resume <TaskId>...",
-        purpose: "Return one or more held Tasks to open.",
-    },
-    done: {
-        arity: [1, Number.POSITIVE_INFINITY],
-        flags: { ...COMMON, note: "value" },
-        usage: "task done <TaskId>... [--note <text>]",
-        purpose: "Mark one or more Tasks done.",
-    },
-    drop: {
-        arity: [1, Number.POSITIVE_INFINITY],
-        flags: { ...COMMON, note: "value" },
-        usage: "task drop <TaskId>... [--note <text>]",
-        purpose: "Mark one or more Tasks as no longer needed.",
-    },
-    context: {
-        arity: [0, 1],
-        flags: COMMON,
-        usage: "task context [<namespace>]",
-        purpose: "Set or read the default Task namespace for this directory.",
-        details: "Omit <namespace> to read the current context; use / to reset it to the root namespace.",
-    },
-    compose: {
-        arity: [0, 0],
-        stdin: "compose",
-        flags: { ...COMMON, actor: "value", plan: "boolean" },
-        usage: "task compose [--actor <actor>] [--plan] -",
-        purpose: "Create or update several Tasks from one document, with an optional preview.",
-        details: [
-            "nodes: + <Title> creates; @task/<id> modifies a pre-existing Task",
-            "properties: as = <alias>; state = open|in_progress|on_hold|done|drop; pri = 0..3; parent = <ref>|empty",
-            "relations: needs|supersedes|relates with =, +=, or -=",
-            "references: @task/... is pre-existing; ^alias is new in this document",
-            "body: body = clears; body <<TOKEN reads exact content to TOKEN",
-            "TOKEN: [A-Z][A-Z0-9_]* with length 3..32",
-            "example:",
-            "  ns=feature",
-            "  + Parent",
-            "  as = parent",
-            "  pri = 1",
-            "  body <<BODY",
-            "  Exact body bytes.",
-            "  BODY",
-            "  + Child",
-            "  parent = ^parent",
-        ].join("\n"),
-    },
-};
-export function isTaskAction(value) {
-    return value !== undefined && Object.hasOwn(TASK_COMMAND_SPECS, value);
-}
-export function renderTaskHelp(action) {
-    if (action !== undefined) {
-        const spec = TASK_COMMAND_SPECS[action];
-        return `${spec.purpose}\n\n${renderTaskUsage(action)}${spec.details === undefined ? "" : `\n\n${spec.details}`}`;
-    }
-    const nameWidth = Math.max(...Object.keys(TASK_COMMAND_SPECS).map((name) => name.length));
-    return [
-        "usage  keiyaku task <command> ...",
-        "      keiyaku task <command> --help   shows that command's complete usage",
-        "",
-        ...Object.entries(TASK_COMMAND_SPECS).map(([name, spec]) => `  ${name.padEnd(nameWidth)}  ${spec.purpose}`),
-    ].join("\n");
-}
-function renderTaskUsage(action) {
-    return TASK_COMMAND_SPECS[action].usage
-        .split("\n")
-        .map((line, index) => {
-        if (index === 0 || line.trimStart().startsWith("task ")) {
-            const command = line.trimStart().startsWith("task ") ? `keiyaku ${line.trim()}` : `keiyaku ${line}`;
-            return `${index === 0 ? "usage  " : "      "}${command}`;
-        }
-        return `      ${line.trim()}`;
-    })
-        .join("\n");
-}
-function taskUsage(action) {
-    const lines = TASK_COMMAND_SPECS[action].usage.split("\n");
-    return lines
-        .map((line, index) => {
-        if (index === 0 || line.trimStart().startsWith("task "))
-            return `keiyaku ${line.trim()}`;
-        return `           ${line.trim()}`;
-    })
-        .join("\n");
-}
-export function taskUsageGuide(action) {
-    return {
-        scope: `keiyaku task ${action}`,
-        accepts: taskUsage(action),
-        help: `keiyaku task ${action} --help`,
-    };
-}
-/** One scan spec per Task action: `-` reads the document, or `--body -` replaces an update body. */
-function scanSpec(action, spec) {
-    return {
-        subject: `task ${action}`,
-        flags: spec.flags,
-        ...(spec.stdin === undefined ? {} : { stdin: spec.stdin }),
-        stdinRefusal: "stdin marker '-' is not valid here",
-        ...(action === "update" ? { stdinValue: "body" } : {}),
-    };
-}
-function validateUpdate(scanned, fail) {
-    const flags = scanned.flags;
-    if (flags.body !== undefined && flags.append !== undefined)
-        fail("--body and --append are mutually exclusive");
-    if (flags.parent !== undefined && flags["no-parent"] === true)
-        fail("--parent and --no-parent are mutually exclusive");
-    if (Object.keys(flags).every((name) => name === "json"))
-        fail("task update requires at least one patch option");
-}
-function validateTaskReadFlags(action, flags, fail) {
-    if ((action === "ls" || action === "query") && flags.closed === true && flags.all === true)
-        fail("--closed and --all are mutually exclusive");
-    if (action === "ls" && flags.world === true) {
-        // An explicit selector is checked below, after positional shape is known.
-    }
-    if (typeof flags.limit === "string") {
-        try {
-            validateTaskLimit(flags.limit);
-        }
-        catch (error) {
-            fail(error instanceof Error ? error.message : String(error));
-        }
-    }
-    if (typeof flags.sort === "string" &&
-        flags.sort !== "priority" &&
-        flags.sort !== "created" &&
-        flags.sort !== "updated" &&
-        flags.sort !== "id") {
-        fail("--sort must be priority, created, updated, or id");
-    }
-    if ((action === "ready" || action === "blocked") && typeof flags.parent === "string") {
-        try {
-            validateTaskParent(flags.parent);
-        }
-        catch (error) {
-            fail(error instanceof Error ? error.message : String(error));
-        }
-    }
-}
-/** Actions whose positionals are all addressed TaskIds validated by the native owner. */
-const TASK_ID_ACTIONS = new Set([
-    "show",
-    "tree",
-    "update",
-    "start",
-    "stop",
-    "hold",
-    "resume",
-    "done",
-    "drop",
-]);
-/** Validate every addressed TaskId positional through the native owner before any read or write. */
-function validateTaskIdPositionals(positionals, fail) {
-    for (const taskId of positionals) {
-        try {
-            parseTaskId(taskId);
-        }
-        catch (error) {
-            fail(error instanceof Error ? error.message : String(error));
-        }
-    }
-}
-/** Validate an explicit `task ls` namespace selector through the native owner. */
-function validateListSelector(selector, fail) {
-    if (selector !== "task/" && (!selector.startsWith("task/") || !selector.endsWith("/")))
-        fail(`invalid Task namespace selector: ${selector}`);
-    if (selector === "task/")
-        return;
-    try {
-        parseTaskNamespaceSelector(selector);
-    }
-    catch (error) {
-        fail(error instanceof Error ? error.message : String(error));
-    }
-}
-function validateTaskScan(action, scanned, fail) {
-    const spec = TASK_COMMAND_SPECS[action], { positionals, flags, stdin } = scanned;
-    if (positionals.length < spec.arity[0])
-        fail(spec.arity[1] === 1 ? `task ${action} requires a TaskId` : `task ${action} requires at least one TaskId`);
-    if (positionals.length > spec.arity[1])
-        fail(spec.arity[1] === 0
-            ? `task ${action} accepts no positional arguments`
-            : `task ${action} accepts at most ${spec.arity[1]} positional argument${spec.arity[1] === 1 ? "" : "s"}`);
-    if (action === "add" && (stdin === "document") === (positionals.length === 1))
-        fail("task add requires either TITLE or '-' input");
-    if (action === "add" &&
-        stdin === "document" &&
-        Object.keys(flags).some((name) => name !== "json" && name !== "namespace" && name !== "actor"))
-        fail("task add document input owns its creation fields");
-    if (action === "compose" && stdin !== "compose")
-        fail("task compose requires '-' input");
-    if (TASK_ID_ACTIONS.has(action))
-        validateTaskIdPositionals(positionals, fail);
-    if (action === "ls" && positionals.length === 1) {
-        validateListSelector(positionals[0], fail);
-        if (flags.world === true)
-            fail("--world cannot be combined with an explicit Task namespace selector");
-    }
-    validateTaskReadFlags(action, flags, fail);
-    if (action === "update")
-        validateUpdate(scanned, fail);
-}
-export function parseTaskCommand(argv) {
-    const candidate = argv[0];
-    if (!isTaskAction(candidate)) {
-        throw new CliUsageError(`unknown task command: ${candidate ?? ""}`, unknownCommandGuide(TASK_FAMILY_USAGE_GUIDE, candidate ?? ""));
-    }
-    const action = candidate;
-    const fail = (message) => {
-        throw new CliUsageError(message, taskUsageGuide(action));
-    };
-    const scanned = scanArgs(argv, scanSpec(action, TASK_COMMAND_SPECS[action]), fail);
-    validateTaskScan(action, scanned, fail);
-    let where;
-    if (action === "query" && typeof scanned.flags.where === "string") {
-        try {
-            where = parseTaskQueryExpression(scanned.flags.where);
-        }
-        catch (error) {
-            fail(error instanceof Error ? error.message : String(error));
-        }
-    }
-    return {
-        command: "task",
-        action,
-        output: scanned.flags.json === true ? "json" : "text",
-        ...scanned,
-        ...(where === undefined ? {} : { where }),
-    };
-}

package/build/src/cli/commands/task-query.d.ts

@@ -1,5 +0,0 @@
-import { type TaskQueryExpression } from "../../task/query.js";
-export type { TaskQueryExpression } from "../../task/query.js";
-export declare function parseTaskQueryExpression(source: string): TaskQueryExpression;
-export declare function validateTaskLimit(source: string): void;
-export declare function validateTaskParent(source: string): void;

package/build/src/cli/render/task.d.ts

@@ -1,39 +0,0 @@
-import type { BlockedTaskList, TaskBatchResult, TaskCompositionResult, TaskContextResult, TaskDecompositionTree, TaskDetail, TaskDoctorReport, TaskList, TaskMutationResult, TaskQueryResult, TaskUpdateResult } from "../../task/index.js";
-import { type TextRenderContext } from "./terminal.js";
-export { taskMark } from "./marks.js";
-type TaskListOutcome = TaskList | BlockedTaskList | TaskQueryResult;
-/** One addressed show selection: native details, or a refusal naming a missing addressed read. */
-export type TaskShowResult = TaskDetail | TaskDetail[] | Extract<TaskMutationResult, {
-    kind: "refused";
-}>;
-/** Presentation-only list scope the leaf acquired; never part of a product value. */
-export type TaskListScope = "world" | "current" | Readonly<{
-    namespace: string;
-}>;
-/** The union of native Task SDK answers one leaf renders directly; the CLI adds no result envelope. */
-type TaskNativeResult = TaskMutationResult | TaskUpdateResult | TaskBatchResult | TaskCompositionResult | TaskShowResult | TaskList | BlockedTaskList | TaskQueryResult | TaskDecompositionTree | TaskDoctorReport | TaskContextResult;
-type TaskFailure = Extract<TaskMutationResult, {
-    kind: "refused" | "retry";
-}> | Extract<TaskContextResult, {
-    kind: "refused" | "retry";
-}> | Extract<TaskCompositionResult, {
-    kind: "refused";
-}>;
-/** Task dispositions and relation states are snake_case facts; people read them as words. */
-export declare function dispositionText(word: string): string;
-export declare function taskFrameHead(view: string, scope: string): string;
-export declare function renderTaskList(action: "ls" | "ready" | "blocked" | "query", scope: TaskListScope, result: TaskListOutcome, context?: TextRenderContext): string;
-export declare function renderTaskShow(result: TaskShowResult, context?: TextRenderContext): string;
-export declare function renderDoctor(report: TaskDoctorReport): string;
-export declare function renderTaskUpdate(result: TaskUpdateResult, context?: TextRenderContext): string;
-export declare function renderTaskCompose(result: TaskCompositionResult, context?: TextRenderContext): string;
-export declare function renderTaskTree(result: TaskDecompositionTree, context?: TextRenderContext): string;
-export declare function renderTaskContext(result: TaskContextResult, context?: TextRenderContext): string;
-/** One single-Task mutation answer; `verb` is the literal action the leaf invoked. */
-export declare function renderTaskMutation(verb: string, result: TaskMutationResult, context?: TextRenderContext): string;
-/** One lifecycle answer: a single mutation or a plural batch, both native shapes. */
-export declare function renderTaskLifecycle(verb: string, result: TaskMutationResult | TaskBatchResult, context?: TextRenderContext): string;
-/** A native refusal the CLI edge raised for one action, through the shared refusal grammar. */
-export declare function renderTaskFailure(verb: string, result: TaskFailure, context?: TextRenderContext): string;
-export declare function renderTaskIncompleteDiagnostic(result: TaskCompositionResult): string;
-export declare function taskExitCode(result: TaskNativeResult): number;

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

@@ -1,168 +0,0 @@
-import { type TaskDocument, type TaskPriority, type TaskState } from "./document.js";
-import { type TaskId } from "./identity.js";
-import { z } from "zod";
-import { type BoundedList } from "../bounded-list.js";
-export type TaskRef = Readonly<{
-    id: TaskId;
-    title: string | null;
-    state: TaskState | "missing";
-}>;
-export declare const taskRowSchema: z.ZodObject<{
-    id: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
-    title: z.ZodString;
-    state: z.ZodEnum<{
-        open: "open";
-        in_progress: "in_progress";
-        on_hold: "on_hold";
-        done: "done";
-        drop: "drop";
-    }>;
-    priority: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
-    disposition: z.ZodEnum<{
-        in_progress: "in_progress";
-        on_hold: "on_hold";
-        done: "done";
-        drop: "drop";
-        ready: "ready";
-        blocked: "blocked";
-    }>;
-    updatedAt: z.ZodString;
-    bodyPresent: z.ZodBoolean;
-    children: z.ZodOptional<z.ZodObject<{
-        live: z.ZodNumber;
-        total: z.ZodNumber;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export declare const taskRowsSchema: z.ZodReadonly<z.ZodArray<z.ZodObject<{
-    id: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
-    title: z.ZodString;
-    state: z.ZodEnum<{
-        open: "open";
-        in_progress: "in_progress";
-        on_hold: "on_hold";
-        done: "done";
-        drop: "drop";
-    }>;
-    priority: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
-    disposition: z.ZodEnum<{
-        in_progress: "in_progress";
-        on_hold: "on_hold";
-        done: "done";
-        drop: "drop";
-        ready: "ready";
-        blocked: "blocked";
-    }>;
-    updatedAt: z.ZodString;
-    bodyPresent: z.ZodBoolean;
-    children: z.ZodOptional<z.ZodObject<{
-        live: z.ZodNumber;
-        total: z.ZodNumber;
-    }, z.core.$strict>>;
-}, z.core.$strict>>>;
-export type TaskDisposition = z.infer<typeof taskRowSchema>["disposition"];
-export type TaskRow = z.infer<typeof taskRowSchema>;
-export type BlockedTaskRow = TaskRow & Readonly<{
-    blockers: readonly TaskRef[];
-}>;
-export type TaskDetailFacts = Readonly<{
-    task: TaskDocument;
-    needs: readonly (TaskRef & Readonly<{
-        released: boolean;
-    }>)[];
-    blockers: readonly TaskRef[];
-    blocks: readonly TaskRef[];
-    parent: TaskRef | null;
-    children: readonly TaskRef[];
-    supersedes: readonly TaskRef[];
-    supersededBy: readonly TaskRef[];
-    related: readonly TaskRef[];
-}>;
-export type TaskTreeNode = Readonly<{
-    task: TaskRef & Readonly<{
-        priority: TaskPriority | null;
-    }>;
-    cycle?: true;
-    children: readonly TaskTreeNode[];
-}>;
-export type TaskBoard = Readonly<{
-    tasks: ReadonlyMap<TaskId, TaskDocument>;
-}>;
-/** The local ids occupied across one namespace of the current board. */
-export declare function occupiedLocalIds(board: TaskBoard, namespace: readonly string[]): Set<string>;
-type TaskRelation = "needs" | "parent" | "supersedes" | "relates";
-export type TaskDoctorIssue = Readonly<{
-    kind: "missing-target";
-    taskId: TaskId;
-    relation: TaskRelation;
-    target: TaskId;
-}> | Readonly<{
-    kind: "self-relation";
-    taskId: TaskId;
-    relation: TaskRelation;
-}> | Readonly<{
-    kind: "cycle";
-    relation: "needs" | "parent" | "supersedes";
-    tasks: readonly TaskId[];
-}>;
-export declare function taskRef(board: TaskBoard, id: TaskId): TaskRef;
-export type TaskRelationProjection = Readonly<{
-    children(id: TaskId): readonly TaskRef[];
-    blocks(id: TaskId): readonly TaskRef[];
-    supersededBy(id: TaskId): readonly TaskRef[];
-    related(id: TaskId): readonly TaskRef[];
-}>;
-export declare function createTaskRelations(board: TaskBoard): TaskRelationProjection;
-export declare function taskDisposition(board: TaskBoard, task: TaskDocument): TaskDisposition;
-export declare function taskBlocked(board: TaskBoard, task: TaskDocument): boolean;
-export declare function projectOwnedDetailFacts(board: TaskBoard, id: TaskId): TaskDetailFacts | null;
-export declare function projectDetailFacts(board: TaskBoard, id: TaskId, relations: TaskRelationProjection): TaskDetailFacts | null;
-export declare function projectTaskRow(board: TaskBoard, relations: TaskRelationProjection, task: TaskDocument): TaskRow;
-export declare function projectRows(board: TaskBoard, relations: TaskRelationProjection, scope: readonly string[] | null, selection: "active" | "closed" | "all"): readonly TaskRow[];
-/**
- * Rows for the identities that created work, grouped by creator. Only documents a
- * requested identity created reach row projection, and each group keeps the
- * established row order.
- */
-export declare function projectCreatedByRows(board: TaskBoard, relations: TaskRelationProjection, createdByIds: readonly string[]): ReadonlyMap<string, readonly TaskRow[]>;
-export declare function projectBlocked(board: TaskBoard, scope: readonly string[] | null, relations: TaskRelationProjection): readonly BlockedTaskRow[];
-export declare function projectStatusRows(board: TaskBoard, relations: TaskRelationProjection, scope: readonly string[] | null): ({
-    id: `task/${string}`;
-    title: string;
-    state: "open" | "in_progress" | "on_hold" | "done" | "drop";
-    priority: 0 | 1 | 2 | 3;
-    disposition: "in_progress" | "on_hold" | "done" | "drop" | "ready" | "blocked";
-    updatedAt: string;
-    bodyPresent: boolean;
-    children?: {
-        live: number;
-        total: number;
-    } | undefined;
-} | {
-    blockers: readonly Readonly<{
-        id: TaskId;
-        title: string | null;
-        state: TaskState | "missing";
-    }>[];
-    id: `task/${string}`;
-    title: string;
-    state: "open" | "in_progress" | "on_hold" | "done" | "drop";
-    priority: 0 | 1 | 2 | 3;
-    disposition: "in_progress" | "on_hold" | "done" | "drop" | "ready" | "blocked";
-    updatedAt: string;
-    bodyPresent: boolean;
-    children?: {
-        live: number;
-        total: number;
-    } | undefined;
-})[];
-export type TaskBoardObservation = Readonly<{
-    statusRows: ReturnType<typeof projectStatusRows>;
-    selectRecentStatus(limit?: number): BoundedList<ReturnType<typeof projectStatusRows>[number]>;
-    selectNamespace(namespace: readonly string[]): readonly TaskRow[];
-    selectCreatedBy(createdBy: string): readonly TaskRow[];
-}>;
-export declare function projectTaskBoardObservation(board: TaskBoard): TaskBoardObservation;
-export declare function relationProblem(board: TaskBoard, before: TaskDocument | null, after: TaskDocument): string | null;
-export declare function diagnoseBoard(board: TaskBoard): readonly TaskDoctorIssue[];
-export declare function buildTree(board: TaskBoard, root: TaskId, relations: TaskRelationProjection): TaskTreeNode | null;
-export {};

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

@@ -1,11 +0,0 @@
-import type { BoundedList } from "../bounded-list.js";
-import type { TaskRef, TaskRow } from "./board.js";
-import type { WorldRoot } from "../world.js";
-export declare function parseTaskNamespaceSelector(value: string): readonly string[];
-export type RecentTaskStatusRow = TaskRow & Readonly<{
-    blockers?: readonly TaskRef[];
-}>;
-export declare function observeRecentTaskStatus(world: WorldRoot, input?: Readonly<{
-    namespace?: readonly string[];
-    limit?: number;
-}>): Promise<BoundedList<RecentTaskStatusRow>>;

package/build/src/task/catalog.js

@@ -1,59 +0,0 @@
-import { isTaskSegment, parseTaskId } from "./identity.js";
-import { readRecentTaskDocuments, readTaskDocument } from "./store.js";
-export function parseTaskNamespaceSelector(value) {
-    if (value === "task/")
-        return [];
-    if (!value.startsWith("task/") || !value.endsWith("/")) {
-        throw new TypeError(`invalid Task namespace selector: ${value}`);
-    }
-    const body = value.slice("task/".length, -1);
-    const segments = body.split("/");
-    if (body.length === 0 || !segments.every(isTaskSegment)) {
-        throw new TypeError(`invalid Task namespace selector: ${value}`);
-    }
-    return parseTaskId(`task/${body}/placeholder`).namespace;
-}
-function terminal(task) {
-    return task?.state === "done" || task?.state === "drop";
-}
-async function catalogRow(world, task, documents) {
-    const needs = await Promise.all(task.needs.map(async (id) => documents.get(id) ?? (await readTaskDocument(world, id))));
-    const blockers = [];
-    if (task.state === "open" || task.state === "in_progress") {
-        for (const [index, need] of needs.entries()) {
-            if (terminal(need))
-                continue;
-            blockers.push({ id: task.needs[index], title: need?.title ?? null, state: need?.state ?? "missing" });
-        }
-    }
-    return {
-        id: task.id,
-        title: task.title,
-        state: task.state,
-        priority: task.priority,
-        disposition: task.state === "open" && needs.some((need) => !terminal(need))
-            ? "blocked"
-            : task.state === "open"
-                ? "ready"
-                : task.state,
-        updatedAt: task.updatedAt,
-        bodyPresent: task.body.length > 0,
-        ...(blockers.length === 0 ? {} : { blockers }),
-    };
-}
-export async function observeRecentTaskStatus(world, input = {}) {
-    const { namespace } = input;
-    if (namespace !== undefined && !namespace.every(isTaskSegment)) {
-        throw new TypeError("namespace must contain canonical segments");
-    }
-    const documents = await readRecentTaskDocuments(world, {
-        ...(namespace === undefined ? {} : { namespace }),
-        selection: "active",
-        ...(input.limit === undefined ? {} : { limit: input.limit }),
-    });
-    const known = new Map(documents.rows.map((document) => [document.id, document]));
-    return {
-        rows: await Promise.all(documents.rows.map((document) => catalogRow(world, document, known))),
-        hasMore: documents.hasMore,
-    };
-}