@astrosheep/keiyaku 2.9.13 → 4.0.1

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

@@ -0,0 +1,262 @@
+import { CliUsageError, 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,
+        stdin: true,
+        flags: {
+            contract: "value",
+            alias: "value",
+            wait: "boolean",
+            timeout: "value",
+            detach: "boolean",
+            json: "boolean",
+        },
+        usage: "call <akuma> [--contract <kei/...>] [--alias @name] [--wait [--timeout <duration>] | -d | --detach] [--json] -",
+        purpose: "Call an Akuma from an Archetype and stdin body.",
+    },
+    wait: {
+        arity: "one-or-more",
+        stdin: false,
+        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: { interrupt: "boolean", json: "boolean" },
+        usage: "tell <aku/...> [--interrupt] [--json] -",
+        purpose: "Record and wake one Akuma, optionally putting down its current Body first.",
+    },
+    history: {
+        arity: 1,
+        stdin: false,
+        flags: { before: "value", since: "value", last: "boolean", json: "boolean" },
+        usage: "history <aku/...> [--before <index> | --since <index> | --last] [--json]",
+        purpose: "Read the persistent execution history or the last answer.",
+    },
+    fork: {
+        arity: 1,
+        stdin: false,
+        flags: { at: "value", json: "boolean" },
+        usage: "fork <aku/...> --at <historyId> [--json]",
+        purpose: "Fork one Akuma at a retained answered history point.",
+    },
+    kill: {
+        arity: "one-or-more",
+        stdin: false,
+        flags: { json: "boolean" },
+        usage: "kill <akuma-selector>... [--json]",
+        purpose: "Put down the current Body of an Akuma selector snapshot.",
+    },
+};
+export function isAkumaAction(value) {
+    return value !== undefined && Object.hasOwn(AKUMA_COMMAND_SPECS, value);
+}
+export function isParsedAkumaCommand(command) {
+    return isAkumaAction(command.command);
+}
+export function renderAkumaRootRows() {
+    return Object.values(AKUMA_COMMAND_SPECS).flatMap((spec) => [`  ${spec.usage}`, `    ${spec.purpose}`]);
+}
+export function renderAkumaHelp(action) {
+    const spec = AKUMA_COMMAND_SPECS[action];
+    return `${spec.purpose}\n\n${usageLine(spec.usage)}`;
+}
+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) {
+    if (typeof raw !== "string")
+        fail("--timeout requires an integer duration with unit ms, s, m, or h");
+    const duration = decodeDuration(raw);
+    if (duration.kind === "invalid")
+        fail("--timeout requires an integer duration with unit ms, s, m, or h");
+    if (duration.kind === "overflow")
+        fail("--timeout duration exceeds the safe millisecond range");
+    return duration.milliseconds;
+}
+function scanAkuma(action, argv, fail) {
+    const spec = AKUMA_COMMAND_SPECS[action];
+    const flags = {};
+    const positionals = [];
+    let stdin = false;
+    for (let index = 1; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === "-") {
+            if (stdin || index !== argv.length - 1 || !spec.stdin)
+                fail(`stdin marker '-' is not valid for ${action}`);
+            stdin = true;
+        }
+        else if (token === "-d") {
+            if (action !== "call")
+                fail(`option ${token} is not valid for ${action}`);
+            if (flags.detach !== undefined)
+                fail("duplicate option: --detach");
+            flags.detach = true;
+        }
+        else if (!token.startsWith("--"))
+            positionals.push(token);
+        else {
+            const name = token.slice(2);
+            const kind = spec.flags[name];
+            if (kind === undefined)
+                fail(`option ${token} is not valid for ${action}`);
+            if (flags[name] !== undefined)
+                fail(`duplicate option: ${token}`);
+            if (kind === "boolean")
+                flags[name] = true;
+            else {
+                const value = argv[index + 1];
+                if (value === undefined || value === "-" || value === "-d" || value.startsWith("--")) {
+                    fail(`${token} requires a value`);
+                }
+                flags[name] = value;
+                index += 1;
+            }
+        }
+    }
+    return { flags, positionals, stdin };
+}
+function positiveIndex(raw, option, fail) {
+    if (typeof raw !== "string" || !/^[1-9][0-9]*$/u.test(raw))
+        fail(`${option} requires a positive integer`);
+    const value = Number(raw);
+    if (!Number.isSafeInteger(value) || value <= 0)
+        fail(`${option} exceeds the safe integer range`);
+    return value;
+}
+function validateDirect(value, fail) {
+    try {
+        if (value.startsWith("@"))
+            parseAkumaAlias(value);
+        else
+            parseAkuId(value);
+    }
+    catch (error) {
+        fail(error instanceof Error ? error.message : "invalid Akuma selector");
+    }
+    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;
+    }
+    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");
+    }
+    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, 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)) {
+        fail("history --last cannot be combined with --before or --since");
+    }
+    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) }),
+        output,
+    };
+}
+function parseAddressed(action, rawSelectors, flags, output, fail) {
+    if (action === "kill")
+        return { command: action, akuma: rawSelectors.map((value) => validateSet(value, fail)), output };
+    if (action === "tell") {
+        return { command: action, akuma: validateDirect(rawSelectors[0], fail), interrupt: flags.interrupt === true, 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, akuma, at, output };
+}
+function parseCall(flags, positionals, output, fail) {
+    let alias;
+    if (flags.alias !== undefined) {
+        try {
+            alias = parseAkumaAlias(stringFlag(flags.alias, "--alias requires @name", fail));
+        }
+        catch (error) {
+            fail(error instanceof Error ? error.message : "invalid Akuma alias");
+        }
+    }
+    if (flags.detach === true && flags.wait === true)
+        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);
+    return {
+        command: "call",
+        archetype: positionals[0],
+        ...(typeof flags.contract === "string" ? { contract: flags.contract } : {}),
+        ...(alias === undefined ? {} : { alias }),
+        mode,
+        ...(timeoutMs === undefined ? {} : { timeoutMs }),
+        output,
+    };
+}
+export function parseAkumaCommand(argv) {
+    const candidate = argv[0];
+    if (!isAkumaAction(candidate))
+        throw new CliUsageError(`unknown command: ${candidate ?? ""}`);
+    const action = candidate;
+    const spec = AKUMA_COMMAND_SPECS[action];
+    const fail = (message) => { throw new CliUsageError(message, renderAkumaUsage(action)); };
+    const { flags, positionals, stdin } = scanAkuma(action, argv, fail);
+    if (spec.arity === "one-or-more" ? positionals.length === 0 : 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, flags, output, fail);
+}

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

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

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

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

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

@@ -0,0 +1,12 @@
+import { type ActorId, type BindResult, type Gate, type Repo, type WorktreeHooks } from "../../index.js";
+import type { ParsedBind } from "../parse.js";
+type BindCommandInput = Readonly<{
+    command: ParsedBind;
+    repo: Repo;
+    markdown: string;
+    gates: readonly Gate[];
+    actor?: ActorId;
+    hooks?: WorktreeHooks;
+}>;
+export declare function bindFromCommand({ command, repo, markdown, gates, actor, hooks }: BindCommandInput): Promise<BindResult>;
+export {};

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

@@ -0,0 +1,17 @@
+import { Keiyaku } from "../../index.js";
+import { contractFromInput } from "../selectors.js";
+export async function bindFromCommand({ command, repo, markdown, gates, actor, hooks }) {
+    const after = command.after?.map((id) => contractFromInput(repo, id).id);
+    const target = command.target ?? await repo.currentBranch();
+    return Keiyaku.bind({
+        repo,
+        markdown,
+        ...(command.task === undefined ? {} : { task: command.task }),
+        ...(target === null ? {} : { target }),
+        ...(command.workspace === undefined ? {} : { workspace: command.workspace }),
+        ...(actor === undefined ? {} : { actor }),
+        ...(hooks === undefined ? {} : { hooks }),
+        ...(after === undefined ? {} : { after }),
+        gates,
+    });
+}

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

@@ -0,0 +1,142 @@
+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 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/<archetype>/ [--json]\n       keiyaku ls aku/*/* [--json]";
+        readonly purpose: "List one identity directory.";
+    };
+    readonly audit: {
+        readonly positional: "optional";
+        readonly stdin: "none";
+        readonly flags: {
+            readonly "show-diff-body": "boolean";
+            readonly actor: "value";
+            readonly json: "boolean";
+        };
+        readonly usage: "audit [<contract>|@<contract>] [--show-diff-body] [--actor <actor>] [--json]";
+        readonly purpose: "Audit one Contract without mutation.";
+    };
+    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.";
+    };
+};
+export type ContractCommand = keyof typeof CONTRACT_COMMAND_SPECS;

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

@@ -0,0 +1,14 @@
+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/<archetype>/ [--json]\n       keiyaku ls aku/*/* [--json]", purpose: "List one identity directory." },
+    audit: { positional: "optional", stdin: "none", flags: { "show-diff-body": "boolean", actor: "value", json: "boolean" }, usage: "audit [<contract>|@<contract>] [--show-diff-body] [--actor <actor>] [--json]", purpose: "Audit one Contract without mutation." },
+    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." },
+};

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

@@ -0,0 +1,25 @@
+import { type ProcessInput, type ProcessOutcome } from "../../runtime/proc/run.js";
+export declare const HARNESS_NAMES: readonly ["codex", "claude", "opencode", "pi"];
+export type HarnessName = typeof HARNESS_NAMES[number];
+export type ParsedInstallCommand = Readonly<{
+    command: "install";
+    harnesses: readonly HarnessName[];
+    output: "text" | "json";
+}>;
+export type HarnessInstallResult = Readonly<{
+    harness: HarnessName;
+    status: "installed" | "failed";
+    diagnostic?: string;
+}>;
+export type InstallInvocationResult = Readonly<{
+    kind: "install";
+    results: readonly HarnessInstallResult[];
+}>;
+export type InstallRunner = (input: ProcessInput) => Promise<ProcessOutcome>;
+export declare const INSTALL_USAGE = "install <codex|claude|opencode|pi> [--json]\n       install --all [--json]";
+export declare function parseInstallCommand(argv: readonly string[]): ParsedInstallCommand;
+export declare function renderInstallHelp(): string;
+export declare function installAssetsRoot(): string;
+export declare function installHarnesses(harnesses: readonly HarnessName[], environment: NodeJS.ProcessEnv, runner?: InstallRunner): Promise<InstallInvocationResult>;
+export declare function renderInstallText(result: InstallInvocationResult): string;
+export declare function installExitCode(result: InstallInvocationResult): number;

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

@@ -0,0 +1,105 @@
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { runProcess } from "../../runtime/proc/run.js";
+import { CliUsageError, usageLine } from "../usage.js";
+export const HARNESS_NAMES = ["codex", "claude", "opencode", "pi"];
+export const INSTALL_USAGE = "install <codex|claude|opencode|pi> [--json]\n       install --all [--json]";
+function isHarness(value) {
+    return value !== undefined && HARNESS_NAMES.includes(value);
+}
+export function parseInstallCommand(argv) {
+    let all = false;
+    let json = false;
+    const positionals = [];
+    for (const token of argv) {
+        if (token === "--all") {
+            if (all)
+                throw new CliUsageError("duplicate option: --all", usageLine(INSTALL_USAGE));
+            all = true;
+        }
+        else if (token === "--json") {
+            if (json)
+                throw new CliUsageError("duplicate option: --json", usageLine(INSTALL_USAGE));
+            json = true;
+        }
+        else if (token.startsWith("--")) {
+            throw new CliUsageError(`option ${token} is not valid for install`, usageLine(INSTALL_USAGE));
+        }
+        else {
+            positionals.push(token);
+        }
+    }
+    if (positionals.length > 1)
+        throw new CliUsageError("install accepts at most one harness", usageLine(INSTALL_USAGE));
+    const harness = positionals[0];
+    if (all && harness !== undefined)
+        throw new CliUsageError("install accepts either a harness or --all", usageLine(INSTALL_USAGE));
+    if (!all && !isHarness(harness))
+        throw new CliUsageError("install requires a supported harness or --all", usageLine(INSTALL_USAGE));
+    return {
+        command: "install",
+        harnesses: all ? HARNESS_NAMES : [harness],
+        output: json ? "json" : "text",
+    };
+}
+export function renderInstallHelp() {
+    return `Install the Keiyaku skills into one or more agent harnesses.\n\n${usageLine(INSTALL_USAGE)}`;
+}
+const INSTALL_TIMEOUT_MS = 5 * 60 * 1000;
+const ASSET_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "../../../integrations/marketplace");
+const PLUGIN_ROOT = resolve(ASSET_ROOT, "plugins/keiyaku");
+function recipes(harness) {
+    switch (harness) {
+        case "codex": return [
+            ["codex", "plugin", "marketplace", "add", ASSET_ROOT, "--json"],
+            ["codex", "plugin", "add", "keiyaku", "--marketplace", "keiyaku", "--json"],
+        ];
+        case "claude": return [
+            ["claude", "plugin", "marketplace", "add", ASSET_ROOT],
+            ["claude", "plugin", "install", "keiyaku@keiyaku", "--scope", "user"],
+            ["claude", "plugin", "update", "keiyaku@keiyaku", "--scope", "user"],
+        ];
+        case "opencode": return [["opencode", "plugin", PLUGIN_ROOT, "--global", "--force"]];
+        case "pi": return [["pi", "install", PLUGIN_ROOT]];
+    }
+}
+function diagnostic(argv, outcome) {
+    if (outcome.kind === "spawn-error")
+        return `${argv[0]} unavailable: ${outcome.diagnostic}`;
+    if (outcome.kind === "timeout")
+        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();
+    return `${argv[0]} exited ${outcome.code}${detail.length === 0 ? "" : `: ${detail}`}`;
+}
+export function installAssetsRoot() {
+    return ASSET_ROOT;
+}
+export async function installHarnesses(harnesses, environment, runner = runProcess) {
+    const results = [];
+    for (const harness of harnesses) {
+        let failure;
+        for (const argv of recipes(harness)) {
+            const detail = diagnostic(argv, await runner({ argv, env: environment, timeoutMs: INSTALL_TIMEOUT_MS }));
+            if (detail.length > 0) {
+                failure = detail;
+                break;
+            }
+        }
+        results.push({ harness, status: failure === undefined ? "installed" : "failed", ...(failure === undefined ? {} : { diagnostic: failure }) });
+    }
+    return { kind: "install", results };
+}
+export function renderInstallText(result) {
+    return result.results.map((item) => item.status === "installed"
+        ? `${item.harness} installed`
+        : `${item.harness} failed: ${item.diagnostic}`).join("\n");
+}
+export function installExitCode(result) {
+    return result.results.some((item) => item.status === "failed") ? 1 : 0;
+}

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

@@ -0,0 +1,11 @@
+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 { ParsedTaskCommand } from "./task.js";
+import type { WorldRoot } from "../../world.js";
+export type TaskInvocationResult = TaskMutationResult | TaskUpdateResult | TaskBatchResult | TaskCompositionResult | TaskDetail | TaskList | BlockedTaskList | TaskDependencyTree | TaskDoctorReport | TaskNamespaceResult;
+type TaskInput = Readonly<{
+    world: WorldRoot | null;
+    establish(): WorldRoot;
+    readStdin(): string;
+}>;
+export declare function invokeTask(command: ParsedTaskCommand, input: TaskInput): Promise<TaskInvocationResult>;
+export {};