@astrosheep/keiyaku 4.6.7 → 4.6.9

package/build/plugins/opencode/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.

package/build/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.

package/build/src/cli/commands/amend.d.ts

@@ -1,12 +0,0 @@
-import { type ActorId, type Keiyaku, type Repo } from "../../index.js";
-import type { ParsedAmend } from "./contract-grammar.js";
-type AmendCommandInput = Readonly<{
-    command: ParsedAmend;
-    repo: Repo;
-    contract: Keiyaku;
-    markdown?: string;
-    gates?: readonly string[];
-    actor?: ActorId;
-}>;
-export declare function amendFromCommand({ command, repo, contract, markdown, gates, actor, }: AmendCommandInput): ReturnType<Keiyaku["amend"]>;
-export {};

package/build/src/cli/commands/amend.js

@@ -1,10 +0,0 @@
-import { contractFromInput } from "../selectors.js";
-export function amendFromCommand({ command, repo, contract, markdown, gates, actor, }) {
-    const after = command.clearAfter === true ? [] : command.after?.map((id) => contractFromInput(repo, id).id);
-    return contract.amend({
-        ...(markdown === undefined ? {} : { markdown }),
-        ...(actor === undefined ? {} : { actor }),
-        ...(after === undefined ? {} : { after }),
-        ...(gates === undefined ? {} : { gates }),
-    });
-}

package/build/src/cli/commands/bind.d.ts

@@ -1,11 +0,0 @@
-import { type ActorId, type BindResult, type KeiyakuLibrary, type Repo } from "../../index.js";
-import type { ParsedBind } from "./contract-grammar.js";
-type BindCommandInput = Readonly<{
-    command: ParsedBind;
-    repo: Repo;
-    library: KeiyakuLibrary;
-    markdown?: string;
-    actor?: ActorId;
-}>;
-export declare function bindFromCommand({ command, repo, library, markdown, actor, }: BindCommandInput): Promise<BindResult>;
-export {};

package/build/src/cli/commands/bind.js

@@ -1,23 +0,0 @@
-import { contractFromInput } from "../selectors.js";
-export async function bindFromCommand({ command, repo, library, markdown, actor, }) {
-    if (command.forkOf !== undefined) {
-        return library.bind({
-            repo,
-            forkOf: contractFromInput(repo, command.forkOf).id,
-            ...(command.target === undefined ? {} : { target: command.target }),
-            ...(actor === undefined ? {} : { actor }),
-        });
-    }
-    const after = command.after?.map((id) => contractFromInput(repo, id).id);
-    if (markdown === undefined)
-        throw new Error("Markdown bind command is missing stdin terms");
-    return library.bind({
-        repo,
-        markdown,
-        ...(command.task === undefined ? {} : { task: command.task }),
-        ...(command.target === undefined ? {} : { target: command.target }),
-        ...(actor === undefined ? {} : { actor }),
-        ...(after === undefined ? {} : { after }),
-        ...(command.gates === undefined ? {} : { gates: command.gates }),
-    });
-}

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

@@ -1,19 +0,0 @@
-import { type CliUsageGuide } from "../usage.js";
-import { type TaskQueryExpression } from "./task-query.js";
-export type TaskAction = "add" | "show" | "ls" | "ready" | "blocked" | "tree" | "doctor" | "update" | "query" | "start" | "stop" | "hold" | "resume" | "done" | "drop" | "context" | "compose";
-type TaskFlagValue = string | true | readonly string[];
-type TaskStdin = "document" | "body" | "append" | "note" | "compose";
-export type ParsedTaskCommand = Readonly<{
-    command: "task";
-    action: TaskAction;
-    output: "text" | "json";
-    positionals: readonly string[];
-    flags: Readonly<Record<string, TaskFlagValue>>;
-    stdin?: TaskStdin;
-    where?: TaskQueryExpression;
-}>;
-export declare function isTaskAction(value: string | undefined): value is TaskAction;
-export declare function renderTaskHelp(action?: TaskAction): string;
-export declare function taskUsageGuide(action: TaskAction): CliUsageGuide;
-export declare function parseTaskCommand(argv: readonly string[]): ParsedTaskCommand;
-export {};

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;