@astrosheep/keiyaku 4.0.0 → 4.0.2

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

@@ -1,6 +1,7 @@
-import { CliUsageError, usageLine } from "../usage.js";
-import { parseAkumaAlias } from "../../identity/selector.js";
-import { parseAkuId } from "../../akuma/identity.js";
+import { CliUsageError, isBlankInput, usageLine } from "../usage.js";
+import { archetypeName, parseAkuId } from "../../akuma/identity.js";
+import { parseDuration as decodeDuration } from "../../duration.js";
+import { parseAkumaAlias, parseAkumaGlob } from "../../identity/selector.js";
 const AKUMA_COMMAND_SPECS = {
     call: {
         arity: 1,
@@ -8,41 +9,43 @@ const AKUMA_COMMAND_SPECS = {
         flags: {
             contract: "value",
             alias: "value",
-            workdir: "value",
-            wait: "boolean",
-            timeout: "value",
+            wait: "value",
             detach: "boolean",
             json: "boolean",
         },
-        usage: "call <akuma> [--contract <kei/...>] [--alias @name] [--workdir <path>] [--wait [--timeout <duration>] | -d | --detach] [--json] -",
-        purpose: "Call an Akuma from an Archetype and stdin body.",
+        usage: "call <akuma-name> [--contract <kei/...>] [--alias @name] [--wait <duration> | -d | --detach] [--json] (<prompt> | -)",
+        purpose: "Birth an Akuma from <akuma-name> with one prompt.",
+        details: [
+            "Give <prompt> as one argument, or use final - to read stdin.",
+            "Default: --wait 5m. An explicit --wait replaces that duration; -d and --detach return after birth.",
+            "--contract dispatches the born Akuma to that Contract.",
+            "--alias assigns the world-local @name selector to the born Akuma.",
+            "With --contract, Dispatch succeeds first. If @name exists, the alias then moves.",
+        ].join("\n"),
     },
     wait: {
-        arity: 1,
+        arity: "one-or-more",
         stdin: false,
-        flags: { timeout: "value", json: "boolean" },
-        usage: "wait <aku/...> [--timeout <duration>] [--json]",
-        purpose: "Wait for one Akuma or return its current snapshot at the timeout.",
+        flags: { any: "boolean", all: "boolean", timeout: "value", json: "boolean" },
+        usage: "wait <akuma-selector>... [--any | --all] [--timeout <duration>] [--json]",
+        purpose: "Wait for one Akuma or an explicitly selected Akuma set.",
     },
     tell: {
         arity: 1,
         stdin: true,
-        flags: { json: "boolean" },
-        usage: "tell <aku/...> [--json] -",
-        purpose: "Record and wake one Akuma with an stdin body.",
-    },
-    interrupt: {
-        arity: 1,
-        stdin: true,
-        flags: { json: "boolean" },
-        usage: "interrupt <aku/...> [--json] -",
-        purpose: "Put down the current body and deliver an stdin body.",
+        flags: { interrupt: "boolean", json: "boolean" },
+        usage: "tell <aku/...|@alias> [--interrupt] [--json] (<prompt> | -)",
+        purpose: "Send one prompt to an existing Akuma and wake it.",
+        details: [
+            "Give <prompt> as one argument, or use final - to read stdin.",
+            "--interrupt ends the current Body before recording the prompt and waking its successor.",
+        ].join("\n"),
     },
     history: {
         arity: 1,
         stdin: false,
-        flags: { before: "value", since: "value", last: "boolean", json: "boolean" },
-        usage: "history <aku/...> [--before <index> | --since <index> | --last] [--json]",
+        flags: { before: "value", since: "value", limit: "value", last: "boolean", json: "boolean" },
+        usage: "history <aku/...> [--before <index> | --since <index>] [--limit <count>] [--last] [--json]",
         purpose: "Read the persistent execution history or the last answer.",
     },
     fork: {
@@ -53,11 +56,11 @@ const AKUMA_COMMAND_SPECS = {
         purpose: "Fork one Akuma at a retained answered history point.",
     },
     kill: {
-        arity: 1,
+        arity: "one-or-more",
         stdin: false,
         flags: { json: "boolean" },
-        usage: "kill <aku/...> [--json]",
-        purpose: "Record death and put down one Akuma.",
+        usage: "kill <akuma-selector>... [--json]",
+        purpose: "Put down the current Body of an Akuma selector snapshot.",
     },
 };
 export function isAkumaAction(value) {
@@ -71,25 +74,35 @@ export function renderAkumaRootRows() {
 }
 export function renderAkumaHelp(action) {
     const spec = AKUMA_COMMAND_SPECS[action];
-    return `${spec.purpose}\n\n${usageLine(spec.usage)}`;
+    return `${spec.purpose}\n\n${usageLine(spec.usage)}${spec.details === undefined ? "" : `\n\n${spec.details}`}`;
 }
 export function renderAkumaUsage(action) {
     return usageLine(AKUMA_COMMAND_SPECS[action].usage);
 }
+export function parseAkumaCatalogPath(value) {
+    if (value === "aku/")
+        return { kind: "archetypes" };
+    if (value === "aku/*/*")
+        return { kind: "akuma" };
+    const match = /^aku\/(.+)\/$/u.exec(value);
+    if (match === null)
+        return null;
+    return { kind: "akuma", archetype: archetypeName(match[1]) };
+}
 function stringFlag(value, diagnostic, fail) {
     if (typeof value !== "string")
         fail(diagnostic);
     return value;
 }
-function parseDuration(raw, fail) {
-    const match = typeof raw === "string" ? /^(0|[1-9][0-9]*)(ms|s|m|h)$/u.exec(raw) : null;
-    if (match === null)
-        fail("--timeout requires an integer duration with unit ms, s, m, or h");
-    const multipliers = { ms: 1n, s: 1000n, m: 60000n, h: 3600000n };
-    const milliseconds = BigInt(match[1]) * multipliers[match[2]];
-    if (milliseconds > BigInt(Number.MAX_SAFE_INTEGER))
-        fail("--timeout duration exceeds the safe millisecond range");
-    return Number(milliseconds);
+function parseDuration(raw, option, fail) {
+    if (typeof raw !== "string")
+        fail(`${option} requires an integer duration with unit ms, s, m, or h`);
+    const duration = decodeDuration(raw);
+    if (duration.kind === "invalid")
+        fail(`${option} requires an integer duration with unit ms, s, m, or h`);
+    if (duration.kind === "overflow")
+        fail(`${option} duration exceeds the safe millisecond range`);
+    return duration.milliseconds;
 }
 function scanAkuma(action, argv, fail) {
     const spec = AKUMA_COMMAND_SPECS[action];
@@ -110,8 +123,11 @@ function scanAkuma(action, argv, fail) {
                 fail("duplicate option: --detach");
             flags.detach = true;
         }
-        else if (!token.startsWith("--"))
+        else if (!token.startsWith("--")) {
+            if (isBlankInput(token))
+                fail(`${action} requires a nonblank value`);
             positionals.push(token);
+        }
         else {
             const name = token.slice(2);
             const kind = spec.flags[name];
@@ -126,6 +142,8 @@ function scanAkuma(action, argv, fail) {
                 if (value === undefined || value === "-" || value === "-d" || value.startsWith("--")) {
                     fail(`${token} requires a value`);
                 }
+                if (isBlankInput(value))
+                    fail(`${token} requires a nonblank value`);
                 flags[name] = value;
                 index += 1;
             }
@@ -141,44 +159,94 @@ function positiveIndex(raw, option, fail) {
         fail(`${option} exceeds the safe integer range`);
     return value;
 }
-function parseAddressed(action, rawId, flags, output, fail) {
-    let id;
+function validateDirect(value, fail) {
     try {
-        id = parseAkuId(rawId).id;
+        if (value.startsWith("@"))
+            parseAkumaAlias(value);
+        else
+            parseAkuId(value);
     }
     catch (error) {
-        fail(error instanceof Error ? error.message : "invalid Akuma identity");
+        fail(error instanceof Error ? error.message : "invalid Akuma selector");
     }
-    if (action === "tell" || action === "interrupt" || action === "kill") {
-        return { command: action, id, output };
+    return value;
+}
+function validateSet(value, fail) {
+    if (value.startsWith("kei/"))
+        return value;
+    if (value.includes("*")) {
+        try {
+            parseAkumaGlob(value);
+        }
+        catch (error) {
+            fail(error instanceof Error ? error.message : `invalid Akuma glob: ${value}`);
+        }
+        return value;
     }
-    if (action === "wait") {
-        const raw = flags.timeout;
-        if (raw === undefined)
-            return { command: action, id, output };
-        return { command: action, id, timeoutMs: parseDuration(raw, fail), output };
+    return validateDirect(value, fail);
+}
+function parseWait(rawSelectors, flags, output, fail) {
+    if (flags.any === true && flags.all === true)
+        fail("wait --any and --all are mutually exclusive");
+    if (rawSelectors.length > 1 && flags.any !== true && flags.all !== true) {
+        fail("wait requires --any or --all when selecting multiple Akuma");
     }
-    if (action === "history") {
-        if (flags.before !== undefined && flags.since !== undefined)
-            fail("history --before and --since are mutually exclusive");
-        if (flags.last === true && (flags.before !== undefined || flags.since !== undefined)) {
-            fail("history --last cannot be combined with --before or --since");
-        }
-        return {
-            command: action,
-            id,
-            last: flags.last === true,
-            ...(flags.before === undefined ? {} : { before: positiveIndex(flags.before, "--before", fail) }),
-            ...(flags.since === undefined ? {} : { since: positiveIndex(flags.since, "--since", fail) }),
-            output,
-        };
+    const completion = flags.any === true ? "any" : flags.all === true ? "all" : undefined;
+    return {
+        command: "wait",
+        akuma: rawSelectors.map((value) => validateSet(value, fail)),
+        ...(completion === undefined ? {} : { completion }),
+        ...(flags.timeout === undefined ? {} : { timeoutMs: parseDuration(flags.timeout, "--timeout", fail) }),
+        output,
+    };
+}
+function parseHistory(akuma, flags, output, fail) {
+    if (flags.before !== undefined && flags.since !== undefined)
+        fail("history --before and --since are mutually exclusive");
+    if (flags.last === true && (flags.before !== undefined || flags.since !== undefined || flags.limit !== undefined)) {
+        fail("history --last cannot be combined with --before, --since, or --limit");
     }
+    const limit = flags.limit === undefined ? undefined : positiveIndex(flags.limit, "--limit", fail);
+    if (limit !== undefined && limit > 5_000)
+        fail("--limit must be no greater than 5000");
+    return {
+        command: "history",
+        akuma,
+        last: flags.last === true,
+        ...(flags.before === undefined ? {} : { before: positiveIndex(flags.before, "--before", fail) }),
+        ...(flags.since === undefined ? {} : { since: positiveIndex(flags.since, "--since", fail) }),
+        ...(limit === undefined ? {} : { limit }),
+        output,
+    };
+}
+function parseAddressed(action, rawSelectors, flags, output, fail) {
+    if (action === "kill")
+        return { command: action, akuma: rawSelectors.map((value) => validateSet(value, fail)), output };
+    if (action === "wait")
+        return parseWait(rawSelectors, flags, output, fail);
+    const akuma = validateDirect(rawSelectors[0], fail);
+    if (action === "history")
+        return parseHistory(akuma, flags, output, fail);
     const at = stringFlag(flags.at, "fork requires --at <historyId>", fail);
-    if (at.trim().length === 0)
-        fail("fork requires --at <historyId>");
-    return { command: action, id, at, output };
+    return { command: action, akuma, at, output };
 }
-function parseCall(flags, positionals, output, fail) {
+function parsePrompted(action, positionals, stdin, fail) {
+    if (positionals.length < 1 || positionals.length > 2)
+        fail(`${action} has invalid positional arguments`);
+    const argument = positionals[1];
+    if (stdin && argument !== undefined)
+        fail(`${action} accepts either a prompt argument or stdin, not both`);
+    if (!stdin && argument === undefined)
+        fail(`${action} requires a prompt argument or stdin`);
+    return {
+        subject: positionals[0],
+        prompt: stdin ? { kind: "stdin" } : { kind: "argument", value: argument },
+    };
+}
+function parseTell(flags, subject, prompt, output, fail) {
+    return { command: "tell", akuma: validateDirect(subject, fail), interrupt: flags.interrupt === true, prompt, output };
+}
+function parseCall(flags, archetype, prompt, output, fail) {
     let alias;
     if (flags.alias !== undefined) {
         try {
@@ -188,20 +256,18 @@ function parseCall(flags, positionals, output, fail) {
             fail(error instanceof Error ? error.message : "invalid Akuma alias");
         }
     }
-    if (flags.detach === true && flags.wait === true)
+    if (flags.detach === true && flags.wait !== undefined)
         fail("call --wait and --detach are mutually exclusive");
-    if (flags.detach === true && flags.timeout !== undefined)
-        fail("call --timeout and --detach are mutually exclusive");
     const mode = flags.detach === true ? "detach" : "wait";
-    const timeoutMs = flags.timeout === undefined ? undefined : parseDuration(flags.timeout, fail);
+    const timeoutMs = flags.wait === undefined ? undefined : parseDuration(flags.wait, "--wait", fail);
     return {
         command: "call",
-        archetype: positionals[0],
+        archetype,
         ...(typeof flags.contract === "string" ? { contract: flags.contract } : {}),
         ...(alias === undefined ? {} : { alias }),
-        ...(typeof flags.workdir === "string" ? { workdir: flags.workdir } : {}),
         mode,
         ...(timeoutMs === undefined ? {} : { timeoutMs }),
+        prompt,
         output,
     };
 }
@@ -213,12 +279,17 @@ export function parseAkumaCommand(argv) {
     const spec = AKUMA_COMMAND_SPECS[action];
     const fail = (message) => { throw new CliUsageError(message, renderAkumaUsage(action)); };
     const { flags, positionals, stdin } = scanAkuma(action, argv, fail);
-    if (positionals.length !== spec.arity)
-        fail(`${action} has invalid positional arguments`);
-    if (stdin !== spec.stdin)
-        fail(`${action} ${spec.stdin ? "requires" : "reads no"} stdin`);
     const output = flags.json === true ? "json" : "text";
-    if (action === "call")
-        return parseCall(flags, positionals, output, fail);
-    return parseAddressed(action, positionals[0], flags, output, fail);
+    if (action === "call" || action === "tell") {
+        const parsed = parsePrompted(action, positionals, stdin, fail);
+        return action === "call"
+            ? parseCall(flags, parsed.subject, parsed.prompt, output, fail)
+            : parseTell(flags, parsed.subject, parsed.prompt, output, fail);
+    }
+    if (spec.arity === "one-or-more" ? positionals.length === 0 : positionals.length !== spec.arity) {
+        fail(`${action} has invalid positional arguments`);
+    }
+    if (stdin)
+        fail(`${action} reads no stdin`);
+    return parseAddressed(action, positionals, flags, output, fail);
 }

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

@@ -0,0 +1,155 @@
+export type ContractFlagKind = "boolean" | "value" | "repeat-value";
+export type ContractCommandSpec = Readonly<{
+    positional: "none" | "optional";
+    stdin: "none" | "optional" | "required";
+    flags: Readonly<Record<string, ContractFlagKind>>;
+    usage: string;
+    purpose: string;
+}>;
+export declare const AMEND_MINIMAL_STDIN_HELP: string;
+export declare const CONTRACT_COMMAND_SPECS: {
+    readonly bind: {
+        readonly positional: "none";
+        readonly stdin: "required";
+        readonly flags: {
+            readonly actor: "value";
+            readonly task: "value";
+            readonly target: "value";
+            readonly here: "boolean";
+            readonly after: "repeat-value";
+            readonly gates: "value";
+            readonly json: "boolean";
+        };
+        readonly usage: "bind [--task <task/...>] [--target <ref>] [--here] [--after <kei/...> ...] [--gates <name>] [--actor <actor>] [--json] -";
+        readonly purpose: "Create one Contract from stdin Markdown.";
+    };
+    readonly amend: {
+        readonly positional: "optional";
+        readonly stdin: "required";
+        readonly flags: {
+            readonly actor: "value";
+            readonly after: "repeat-value";
+            readonly "clear-after": "boolean";
+            readonly gates: "value";
+            readonly json: "boolean";
+        };
+        readonly usage: "amend [<contract>|@<contract>] [--after <kei/...> ... | --clear-after] [--gates <name>] [--actor <actor>] [--json] -";
+        readonly purpose: "Apply stdin amendment operations to one Contract.";
+    };
+    readonly deliver: {
+        readonly positional: "optional";
+        readonly stdin: "none";
+        readonly flags: {
+            readonly actor: "value";
+            readonly message: "value";
+            readonly "include-dirty": "boolean";
+            readonly json: "boolean";
+        };
+        readonly usage: "deliver [<contract>|@<contract>] [--message <text>] [--include-dirty] [--actor <actor>] [--json]";
+        readonly purpose: "Deliver one Contract candidate.";
+    };
+    readonly review: {
+        readonly positional: "optional";
+        readonly stdin: "optional";
+        readonly flags: {
+            readonly actor: "value";
+            readonly satisfied: "boolean";
+            readonly unsatisfied: "boolean";
+            readonly summary: "value";
+            readonly json: "boolean";
+        };
+        readonly usage: "review [<contract>|@<contract>] (--satisfied | --unsatisfied) (--summary <text> | -) [--actor <actor>] [--json]";
+        readonly purpose: "Record one review verdict.";
+    };
+    readonly arc: {
+        readonly positional: "optional";
+        readonly stdin: "required";
+        readonly flags: {
+            readonly actor: "value";
+            readonly json: "boolean";
+        };
+        readonly usage: "arc [<contract>|@<contract>] [--actor <actor>] [--json] -";
+        readonly purpose: "Record stdin arc Markdown for one Contract.";
+    };
+    readonly abandon: {
+        readonly positional: "optional";
+        readonly stdin: "none";
+        readonly flags: {
+            readonly actor: "value";
+            readonly note: "value";
+            readonly json: "boolean";
+        };
+        readonly usage: "abandon [<contract>|@<contract>] [--note <text>] [--actor <actor>] [--json]";
+        readonly purpose: "Abandon one Contract with an optional note.";
+    };
+    readonly status: {
+        readonly positional: "optional";
+        readonly stdin: "none";
+        readonly flags: {
+            readonly json: "boolean";
+        };
+        readonly usage: "status [<contract>|@name|<aku/...>] [--json]";
+        readonly purpose: "Read the world status board or one Contract projection.";
+    };
+    readonly show: {
+        readonly positional: "optional";
+        readonly stdin: "none";
+        readonly flags: {
+            readonly json: "boolean";
+        };
+        readonly usage: "show [<contract>|@<contract>] [--json]";
+        readonly purpose: "Read one Contract guidance projection.";
+    };
+    readonly ls: {
+        readonly positional: "optional";
+        readonly stdin: "none";
+        readonly flags: {
+            readonly json: "boolean";
+        };
+        readonly usage: "ls task/ [--json]\n       keiyaku ls kei/ [--json]\n       keiyaku ls aku/ [--json]\n       keiyaku ls aku/<akuma>/ [--json]\n       keiyaku ls \"aku/*/*\" [--json]";
+        readonly purpose: "List one identity directory.";
+    };
+    readonly audit: {
+        readonly positional: "optional";
+        readonly stdin: "none";
+        readonly flags: {
+            readonly "include-dirty": "boolean";
+            readonly diff: "boolean";
+            readonly actor: "value";
+            readonly json: "boolean";
+        };
+        readonly usage: "audit [<contract>|@<contract>] [--include-dirty] [--diff] [--actor <actor>] [--json]";
+        readonly purpose: "Ask what candidate preparation, Verification, and target placement would do.";
+    };
+    readonly reconcile: {
+        readonly positional: "optional";
+        readonly stdin: "none";
+        readonly flags: {
+            readonly "retry-hooks": "boolean";
+            readonly json: "boolean";
+        };
+        readonly usage: "reconcile [<contract>|@<contract>] [--retry-hooks] [--json]";
+        readonly purpose: "Reconcile one Contract or the invocation world.";
+    };
+    readonly settings: {
+        readonly positional: "none";
+        readonly stdin: "none";
+        readonly flags: {
+            readonly json: "boolean";
+        };
+        readonly usage: "settings [--json]";
+        readonly purpose: "Read user and project Settings resources.";
+    };
+    readonly region: {
+        readonly positional: "optional";
+        readonly stdin: "none";
+        readonly flags: {
+            readonly overlap: "boolean";
+            readonly path: "value";
+            readonly json: "boolean";
+        };
+        readonly usage: "region [<contract>] [--overlap] [--json]\n       region --path <repo-relative-path> [--json]";
+        readonly purpose: "Read active declared Contract Regions.";
+    };
+};
+export type ContractCommand = keyof typeof CONTRACT_COMMAND_SPECS;

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

@@ -0,0 +1,20 @@
+export const AMEND_MINIMAL_STDIN_HELP = [
+    "minimal stdin:",
+    "  ## Replace: Design",
+    "  <complete replacement>",
+].join("\n");
+export const CONTRACT_COMMAND_SPECS = {
+    bind: { positional: "none", stdin: "required", flags: { actor: "value", task: "value", target: "value", here: "boolean", after: "repeat-value", gates: "value", json: "boolean" }, usage: "bind [--task <task/...>] [--target <ref>] [--here] [--after <kei/...> ...] [--gates <name>] [--actor <actor>] [--json] -", purpose: "Create one Contract from stdin Markdown." },
+    amend: { positional: "optional", stdin: "required", flags: { actor: "value", after: "repeat-value", "clear-after": "boolean", gates: "value", json: "boolean" }, usage: "amend [<contract>|@<contract>] [--after <kei/...> ... | --clear-after] [--gates <name>] [--actor <actor>] [--json] -", purpose: "Apply stdin amendment operations to one Contract." },
+    deliver: { positional: "optional", stdin: "none", flags: { actor: "value", message: "value", "include-dirty": "boolean", json: "boolean" }, usage: "deliver [<contract>|@<contract>] [--message <text>] [--include-dirty] [--actor <actor>] [--json]", purpose: "Deliver one Contract candidate." },
+    review: { positional: "optional", stdin: "optional", flags: { actor: "value", satisfied: "boolean", unsatisfied: "boolean", summary: "value", json: "boolean" }, usage: "review [<contract>|@<contract>] (--satisfied | --unsatisfied) (--summary <text> | -) [--actor <actor>] [--json]", purpose: "Record one review verdict." },
+    arc: { positional: "optional", stdin: "required", flags: { actor: "value", json: "boolean" }, usage: "arc [<contract>|@<contract>] [--actor <actor>] [--json] -", purpose: "Record stdin arc Markdown for one Contract." },
+    abandon: { positional: "optional", stdin: "none", flags: { actor: "value", note: "value", json: "boolean" }, usage: "abandon [<contract>|@<contract>] [--note <text>] [--actor <actor>] [--json]", purpose: "Abandon one Contract with an optional note." },
+    status: { positional: "optional", stdin: "none", flags: { json: "boolean" }, usage: "status [<contract>|@name|<aku/...>] [--json]", purpose: "Read the world status board or one Contract projection." },
+    show: { positional: "optional", stdin: "none", flags: { json: "boolean" }, usage: "show [<contract>|@<contract>] [--json]", purpose: "Read one Contract guidance projection." },
+    ls: { positional: "optional", stdin: "none", flags: { json: "boolean" }, usage: "ls task/ [--json]\n       keiyaku ls kei/ [--json]\n       keiyaku ls aku/ [--json]\n       keiyaku ls aku/<akuma>/ [--json]\n       keiyaku ls \"aku/*/*\" [--json]", purpose: "List one identity directory." },
+    audit: { positional: "optional", stdin: "none", flags: { "include-dirty": "boolean", diff: "boolean", actor: "value", json: "boolean" }, usage: "audit [<contract>|@<contract>] [--include-dirty] [--diff] [--actor <actor>] [--json]", purpose: "Ask what candidate preparation, Verification, and target placement would do." },
+    reconcile: { positional: "optional", stdin: "none", flags: { "retry-hooks": "boolean", json: "boolean" }, usage: "reconcile [<contract>|@<contract>] [--retry-hooks] [--json]", purpose: "Reconcile one Contract or the invocation world." },
+    settings: { positional: "none", stdin: "none", flags: { json: "boolean" }, usage: "settings [--json]", purpose: "Read user and project Settings resources." },
+    region: { positional: "optional", stdin: "none", flags: { overlap: "boolean", path: "value", json: "boolean" }, usage: "region [<contract>] [--overlap] [--json]\n       region --path <repo-relative-path> [--json]", purpose: "Read active declared Contract Regions." },
+};

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

@@ -70,6 +70,8 @@ function diagnostic(argv, outcome) {
         return `${argv[0]} timed out`;
     if (outcome.kind === "unknown-exit")
         return `${argv[0]} exited without a status`;
+    if (outcome.kind === "cancelled")
+        return `${argv[0]} cancelled`;
     if (outcome.code === 0)
         return "";
     const detail = outcome.stderr.trim() || outcome.stdout.trim();

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

@@ -1,9 +1,24 @@
-import { type BlockedTaskList, type TaskBatchResult, type TaskCompositionResult, type TaskDependencyTree, type TaskDetail, type TaskDoctorReport, type TaskList, type TaskMutationResult, type TaskNamespaceResult, type TaskUpdateResult } from "../../task/index.js";
+import { type BlockedTaskList, type TaskBatchResult, type TaskCompositionResult, type TaskDecompositionTree, type TaskDetail, type TaskDoctorReport, type TaskList, type TaskMutationResult, type TaskNamespaceResult, type TaskQueryResult, type TaskUpdateResult } from "../../task/index.js";
 import type { ParsedTaskCommand } from "./task.js";
-export type TaskInvocationResult = TaskMutationResult | TaskUpdateResult | TaskBatchResult | TaskCompositionResult | TaskDetail | TaskList | BlockedTaskList | TaskDependencyTree | TaskDoctorReport | TaskNamespaceResult;
+import type { WorldRoot } from "../../world.js";
+export type TaskInvocationResult = TaskMutationResult | TaskUpdateResult | TaskBatchResult | TaskCompositionResult | TaskDetail | TaskList | BlockedTaskList | TaskQueryResult | TaskDecompositionTree | TaskDoctorReport | TaskNamespaceResult | TaskWorldObservation;
+type TaskWorldRead = TaskList | BlockedTaskList | TaskQueryResult | TaskDoctorReport;
+export type TaskWorldObservation = Readonly<{
+    kind: "present";
+    value: TaskWorldRead;
+}> | Readonly<{
+    kind: "absent";
+}> | Readonly<{
+    kind: "failed";
+    failure: Readonly<{
+        message: string;
+    }>;
+}>;
 type TaskInput = Readonly<{
-    path?: string;
-    readStdin(): string;
+    world: WorldRoot | null;
+    establish(): Promise<WorldRoot>;
+    readStdin(): Promise<string>;
+    actor?: string;
 }>;
 export declare function invokeTask(command: ParsedTaskCommand, input: TaskInput): Promise<TaskInvocationResult>;
 export {};