@astrosheep/keiyaku 2.9.3 → 2.9.5

package/build/cli/commands/projection/call/handler.js

@@ -1,6 +1,6 @@
 import { runCallAndPersist } from "../../../../core/call-persist.js";
-import { projectionDir } from "../../../../core/projection-core.js";
-import { waitForProjection } from "../../../../core/projection-wait.js";
+import { projectionDir } from "../../../../core/projection/index.js";
+import { waitForProjection } from "../../../../core/projection/index.js";
 import { buildCallResponse, renderAdoptedLaunchReceipt } from "../../../render/call.js";
 import { buildWaitResponse } from "../../../render/wait.js";
 import { buildCallInput } from "../../shared.js";
@@ -12,8 +12,8 @@ export const handler = async (stdin, flags, signal) => {
         signal,
         ...(!flags.detach
             ? {
-                onLaunch: ({ address, projection }) => {
-                    process.stdout.write(`${renderAdoptedLaunchReceipt(address, projection.id, projection.alias, projection.previousAliasTarget)}\n`);
+                onLaunch: ({ address, projection, akumaName }) => {
+                    process.stdout.write(`${renderAdoptedLaunchReceipt(address, projection.id, projection.alias, projection.previousAliasTarget, akumaName)}\n`);
                 },
             }
             : {}),
@@ -25,8 +25,9 @@ export const handler = async (stdin, flags, signal) => {
         const projectionRoot = outcome.result.address.repo.kind === "repository"
             ? outcome.result.address.repo.stableRoot
             : flags.cwd ?? process.cwd();
+        const projectionDirectory = await projectionDir(projectionRoot, projection.id);
         return buildWaitResponse(projection.id, await waitForProjection({
-            projectionDirectory: projectionDir(projectionRoot, projection.id),
+            projectionDirectory,
             timeoutMs: flags.timeoutMs,
             signal,
         }), { alias: projection.alias });

package/build/cli/commands/projection/call/meta.js

@@ -2,7 +2,10 @@ export const meta = {
     command: "call",
     summary: "Start an Akuma helper session",
     usage: ["keiyaku call NAME [--wait DURATION] <BODY|->"],
-    stdin: "none",
+    stdin: {
+        mode: "argument",
+        selector: { kind: "positional", index: 0, required: true, rejectBlank: true },
+    },
     flags: ["cwd", "repo", "contract", "akuma", "model", "effort", "incognito", "bare", "detach", "alias", "wait"],
     purpose: "Run a scoped helper task.",
     completionRank: 2,

package/build/cli/commands/projection/kill/handler.js

@@ -1,37 +1,21 @@
 import { FlowError } from "../../../../flow-error.js";
-import { resolveContractAddress, withResolvedAddress, } from "../../../../core/addressing.js";
-import { projectionDir } from "../../../../core/projection-core.js";
-import { killProjectionGeneration } from "../../../../core/projection-kill.js";
-import { waitForProjection } from "../../../../core/projection-wait.js";
-import { resolveProjectionAddress } from "../../../projection-address.js";
-import { textResponse } from "../../../render/shared.js";
+import { killProjectionGeneration } from "../../../../core/projection/index.js";
+import { waitForProjection } from "../../../../core/projection/index.js";
+import { buildKillAcceptedResponse, buildKillAlreadyClosedResponse } from "../../../render/kill.js";
 import { buildWaitResponse } from "../../../render/wait.js";
-import { projectDirectory, repositoryDirectory } from "../../shared.js";
-export const handler = async (_stdin, flags, signal, positional) => {
-    const cwd = flags.contractId
-        ? await repositoryDirectory(flags, "kill contract addressing")
-        : await projectDirectory(flags, "kill");
+import { resolveProjectionCommandTarget, runProjectionCommand, } from "../shared.js";
+export const handler = async (_stdin, flags, signal, positional) => runProjectionCommand(flags, "kill", async (ctx) => {
     const [projectionAddress] = positional;
     if (!projectionAddress)
         throw new FlowError("EMPTY_PARAM", "kill requires a projection address");
-    const address = flags.contractId ? await resolveContractAddress(cwd, flags.contractId, flags.contractAddressSource) : undefined;
-    const operation = async () => {
-        const projection = await resolveProjectionAddress({
-            cwd,
-            address: projectionAddress,
-            scope: address,
-            verb: "kill",
-        });
-        const directory = projectionDir(cwd, projection.id);
-        const result = killProjectionGeneration(directory);
-        if (result.status === "already-closed") {
-            return textResponse(`· ${projection.id} already closed`);
-        }
-        if (flags.timeoutMs === undefined) {
-            return textResponse(`✓ kill ${projection.id}\n» keiyaku wait ${projection.id}`);
-        }
-        // Accepted with --wait: no acceptance receipt or address preamble.
-        return buildWaitResponse(projection.id, await waitForProjection({ projectionDirectory: directory, timeoutMs: flags.timeoutMs, signal }), { alias: projection.alias });
-    };
-    return address ? await withResolvedAddress(address, operation) : await operation();
-};
+    const projection = await resolveProjectionCommandTarget(ctx, projectionAddress, "kill");
+    const result = killProjectionGeneration(projection.directory);
+    if (result.status === "already-closed") {
+        return buildKillAlreadyClosedResponse(projection.id);
+    }
+    if (flags.timeoutMs === undefined) {
+        return buildKillAcceptedResponse(projection.id);
+    }
+    // Accepted with --wait: no acceptance receipt or address preamble.
+    return buildWaitResponse(projection.id, await waitForProjection({ projectionDirectory: projection.directory, timeoutMs: flags.timeoutMs, signal }), { alias: projection.alias });
+});

package/build/cli/commands/projection/kill/meta.js

@@ -5,7 +5,7 @@ export const meta = {
         "keiyaku kill <projection-address> [--wait DURATION]",
         "keiyaku @addr kill <projection-address> [--wait DURATION]",
     ],
-    stdin: "none",
+    stdin: { mode: "argument" },
     flags: ["cwd", "repo", "contract", "wait"],
     purpose: "Terminate the current generation while keeping the projection identity and tell ledger.",
 };

package/build/cli/commands/projection/revive/meta.js

@@ -2,7 +2,10 @@ export const meta = {
     command: "revive",
     summary: "Revive an Akuma helper session",
     usage: ["keiyaku revive ARTIFACT [BODY|-]"],
-    stdin: "none",
+    stdin: {
+        mode: "argument",
+        selector: { kind: "positional", index: 1, required: false, rejectBlank: true },
+    },
     flags: ["cwd", "repo", "model", "effort"],
     purpose: "Continue a persisted helper session.",
     completionRank: 4,

package/build/cli/commands/projection/shared.js

@@ -0,0 +1,28 @@
+import { resolveContractAddress, withResolvedAddress, } from "../../../core/addressing.js";
+import { projectionDir } from "../../../core/projection/index.js";
+import { resolveProjectionAddress, } from "../../projection-address.js";
+import { projectDirectory, repositoryDirectory } from "../shared.js";
+/** Resolve cwd + optional contract address, then run the verb under that carrier. */
+export async function runProjectionCommand(flags, verb, operation) {
+    const cwd = flags.contractId
+        ? await repositoryDirectory(flags, `${verb} contract addressing`)
+        : await projectDirectory(flags, verb);
+    const address = flags.contractId
+        ? await resolveContractAddress(cwd, flags.contractId, flags.contractAddressSource)
+        : undefined;
+    const run = () => operation({ cwd, address });
+    return address ? await withResolvedAddress(address, run) : await run();
+}
+export function resolveProjectionCommandAddress(ctx, projectionAddress, verb) {
+    return resolveProjectionAddress({
+        cwd: ctx.cwd,
+        address: projectionAddress,
+        scope: ctx.address,
+        verb,
+    });
+}
+export async function resolveProjectionCommandTarget(ctx, projectionAddress, verb) {
+    const projection = await resolveProjectionCommandAddress(ctx, projectionAddress, verb);
+    const directory = await projectionDir(ctx.cwd, projection.id);
+    return { ...projection, directory };
+}

package/build/cli/commands/projection/status/handler.js

@@ -1,6 +1,6 @@
 import { readKanshiBoard } from "../../../../core/status/board.js";
 import { normalizeTargetRef } from "../../../../core/target-ref.js";
-import { isProjectionId } from "../../../../core/projection-core.js";
+import { isProjectionId } from "../../../../core/projection/index.js";
 import { FlowError } from "../../../../flow-error.js";
 import { renderProjectionFilteredStatus, renderStatusBoard } from "../../../render/status.js";
 import { textResponse } from "../../../render/shared.js";

package/build/cli/commands/projection/status/meta.js

@@ -2,7 +2,7 @@ export const meta = {
     command: "status",
     summary: "Show the Kanshi board",
     usage: ["keiyaku status [PROJECTION] [-C|--cwd DIR] [--repo DIR] [--target REF] [--all]"],
-    stdin: "none",
+    stdin: { mode: "argument" },
     flags: ["cwd", "repo", "target", "all"],
     purpose: "Read the Kanshi board or filter it to one projection without mutation.",
     completionRank: 14,

package/build/cli/commands/projection/tell/handler.js

@@ -1,36 +1,20 @@
 import { FlowError } from "../../../../flow-error.js";
-import { resolveContractAddress, withResolvedAddress, } from "../../../../core/addressing.js";
-import { projectionDir, writeInboxTell } from "../../../../core/projection-core.js";
-import { assertTellEffortSupported, tellProjection } from "../../../../core/projection-wake.js";
-import { waitForProjection } from "../../../../core/projection-wait.js";
-import { resolveProjectionAddress } from "../../../projection-address.js";
+import { assertTellEffortSupported, tellProjection, writeInboxTell } from "../../../../core/projection/index.js";
+import { waitForProjection } from "../../../../core/projection/index.js";
 import { prependAddressReceipt } from "../../../render/address.js";
-import { textResponse } from "../../../render/shared.js";
+import { buildSilentTellResponse } from "../../../render/tell.js";
 import { buildWaitResponse } from "../../../render/wait.js";
-import { projectDirectory, repositoryDirectory } from "../../shared.js";
-export const handler = async (body, flags, signal, positional) => {
-    const cwd = flags.contractId
-        ? await repositoryDirectory(flags, "tell contract addressing")
-        : await projectDirectory(flags, "tell");
+import { resolveProjectionCommandTarget, runProjectionCommand, } from "../shared.js";
+export const handler = async (body, flags, signal, positional) => runProjectionCommand(flags, "tell", async (ctx) => {
     const projectionAddress = positional[0];
     if (!projectionAddress)
         throw new FlowError("EMPTY_PARAM", "tell requires a projection address and message");
-    const address = flags.contractId ? await resolveContractAddress(cwd, flags.contractId, flags.contractAddressSource) : undefined;
-    const operation = async () => {
-        const projection = await resolveProjectionAddress({
-            cwd,
-            address: projectionAddress,
-            scope: address,
-            verb: "tell",
-        });
-        const directory = projectionDir(cwd, projection.id);
-        assertTellEffortSupported(directory, flags.effort);
-        // Mailbox first: do not inspect phase before this immutable write.
-        writeInboxTell(directory, body, Date.now(), { effort: flags.effort });
-        await tellProjection(directory, flags.effort);
-        if (flags.timeoutMs === undefined)
-            return textResponse("");
-        return prependAddressReceipt(buildWaitResponse(projection.id, await waitForProjection({ projectionDirectory: directory, timeoutMs: flags.timeoutMs, signal }), { alias: projection.alias }), address, { projectionId: projection.id, projectionAlias: projection.alias });
-    };
-    return address ? await withResolvedAddress(address, operation) : await operation();
-};
+    const projection = await resolveProjectionCommandTarget(ctx, projectionAddress, "tell");
+    assertTellEffortSupported(projection.directory, flags.effort);
+    // Address admission and any effort validation precede the durable mailbox write.
+    writeInboxTell(projection.directory, body, Date.now(), { effort: flags.effort });
+    await tellProjection(projection.directory, projection.id, flags.effort);
+    if (flags.timeoutMs === undefined)
+        return buildSilentTellResponse();
+    return prependAddressReceipt(buildWaitResponse(projection.id, await waitForProjection({ projectionDirectory: projection.directory, timeoutMs: flags.timeoutMs, signal }), { alias: projection.alias }), ctx.address, { projectionId: projection.id, projectionAlias: projection.alias });
+});

package/build/cli/commands/projection/tell/meta.js

@@ -2,7 +2,10 @@ export const meta = {
     command: "tell",
     summary: "Send intent to a projection mailbox",
     usage: ["keiyaku tell PROJECTION [--wait DURATION] [--] <BODY|->"],
-    stdin: "none",
+    stdin: {
+        mode: "argument",
+        selector: { kind: "positional", index: 1, required: true, rejectBlank: true },
+    },
     flags: ["cwd", "repo", "contract", "effort", "wait"],
     purpose: "Write intent to the mailbox and wake only when eligible.",
     completionRank: 3,

package/build/cli/commands/projection/wait/handler.js

@@ -1,23 +1,46 @@
-import { resolveContractAddress, withResolvedAddress, } from "../../../../core/addressing.js";
-import { projectionDir } from "../../../../core/projection-core.js";
-import { waitForProjection } from "../../../../core/projection-wait.js";
-import { resolveProjectionAddress } from "../../../projection-address.js";
+import { projectionDir } from "../../../../core/projection/index.js";
+import { snapshotCommissionProjectionIds, waitForProjection, waitForProjectionSet } from "../../../../core/projection/index.js";
+import { FlowError } from "../../../../flow-error.js";
 import { prependAddressReceipt } from "../../../render/address.js";
-import { buildWaitResponse } from "../../../render/wait.js";
-import { projectDirectory, repositoryDirectory } from "../../shared.js";
-export const handler = async (_stdin, flags, signal, positional) => {
-    const cwd = flags.contractId
-        ? await repositoryDirectory(flags, "wait contract addressing")
-        : await projectDirectory(flags, "wait");
-    const address = flags.contractId ? await resolveContractAddress(cwd, flags.contractId, flags.contractAddressSource) : undefined;
-    const operation = async () => {
-        const projection = await resolveProjectionAddress({
-            cwd,
-            address: positional[0],
-            scope: address,
-            verb: "wait",
-        });
-        return prependAddressReceipt(buildWaitResponse(projection.id, await waitForProjection({ projectionDirectory: projectionDir(cwd, projection.id), timeoutMs: flags.timeoutMs, signal }), { alias: projection.alias }), address, { projectionId: projection.id, projectionAlias: projection.alias });
-    };
-    return address ? await withResolvedAddress(address, operation) : await operation();
-};
+import { buildProjectionWaitSetResponse, buildWaitResponse } from "../../../render/wait.js";
+import { resolveProjectionCommandAddress, resolveProjectionCommandTarget, runProjectionCommand, } from "../shared.js";
+import { WAIT_SET_SELECTION_ERROR } from "./meta.js";
+export const handler = async (_stdin, flags, signal, positional) => runProjectionCommand(flags, "wait", async (ctx) => {
+    // Selection modes only govern admitted sets with more than one explicit member.
+    if (positional.length === 1) {
+        const projection = await resolveProjectionCommandTarget(ctx, positional[0], "wait");
+        return prependAddressReceipt(buildWaitResponse(projection.id, await waitForProjection({
+            projectionDirectory: projection.directory,
+            timeoutMs: flags.timeoutMs,
+            signal,
+        }), { alias: projection.alias }), ctx.address, { projectionId: projection.id, projectionAlias: projection.alias });
+    }
+    const selected = [];
+    if (positional.length === 0) {
+        if (ctx.address?.binding.kind === "commission") {
+            selected.push(...await snapshotCommissionProjectionIds(ctx.cwd, ctx.address.binding.commissionId));
+        }
+    }
+    else {
+        // Resolve in argument order so multiple bad coordinates have one stable failure.
+        for (const projectionAddress of positional) {
+            selected.push((await resolveProjectionCommandAddress(ctx, projectionAddress, "wait")).id);
+        }
+    }
+    const ids = [...new Set(selected)].sort();
+    if (ids.length === 0) {
+        throw new FlowError("EMPTY_PARAM", "wait commission snapshot contains no projections");
+    }
+    if (!flags.any && !flags.all) {
+        throw new FlowError("EMPTY_PARAM", WAIT_SET_SELECTION_ERROR);
+    }
+    return prependAddressReceipt(buildProjectionWaitSetResponse(await waitForProjectionSet({
+        projections: await Promise.all(ids.map(async (id) => ({
+            id,
+            projectionDirectory: await projectionDir(ctx.cwd, id),
+        }))),
+        selection: flags.any ? "any" : "all",
+        timeoutMs: flags.timeoutMs,
+        signal,
+    })), ctx.address);
+});

package/build/cli/commands/projection/wait/meta.js

@@ -1,11 +1,16 @@
+export const WAIT_SET_SELECTION_ERROR = "wait requires exactly one of --any or --all when selecting multiple projections";
 export const meta = {
     command: "wait",
     summary: "Wait for an akuma projection",
     usage: [
         "keiyaku wait <projection-address> [--timeout DURATION]",
-        "keiyaku @addr wait <projection-address> [--timeout DURATION]",
+        "keiyaku wait <projection-address> <projection-address>... (--any|--all) [--timeout DURATION]",
+        "keiyaku @addr wait [<projection-address>...] (--any|--all) [--timeout DURATION]",
     ],
-    stdin: "none",
-    flags: ["cwd", "repo", "contract", "timeout"],
+    stdin: { mode: "argument" },
+    flags: ["cwd", "repo", "contract", "timeout", "any", "all"],
+    flagDescriptions: {
+        all: "For a projection set, return only after every admitted member reaches a terminal state.",
+    },
     purpose: "Read an akuma projection until its outcome is available, or show a timeout snapshot.",
 };

package/build/cli/commands/registry.js

@@ -5,40 +5,7 @@ import { akumaCatalog } from "./akuma/catalog.js";
 import { skillsCatalog } from "./skills/catalog.js";
 import { systemCatalog } from "./system/catalog.js";
 import { taskCatalog } from "./task/catalog.js";
-/** Stable metadata key order consumed by help and tests. */
-const METADATA_ORDER = [
-    "bind",
-    "arc",
-    "call",
-    "revive",
-    "wait",
-    "tell",
-    "kill",
-    "log",
-    "akuma",
-    "akuma ls",
-    "akuma view",
-    "skills",
-    "skills install",
-    "amend",
-    "renew",
-    "petition",
-    "forfeit",
-    "guide",
-    "completion",
-    "status",
-    "task",
-    "task add",
-    "task view",
-    "task ls",
-    "task start",
-    "task stop",
-    "task done",
-    "task drop",
-    "task update",
-    "task doctor",
-    "dump-env",
-];
+import { COMMAND_METADATA_ORDER } from "./metadata.js";
 function buildRegistry(catalogs) {
     const registrations = catalogs.flat();
     const byCommand = new Map();
@@ -50,7 +17,7 @@ function buildRegistry(catalogs) {
         byCommand.set(command, registration);
     }
     const registry = {};
-    for (const command of METADATA_ORDER) {
+    for (const command of COMMAND_METADATA_ORDER) {
         const registration = byCommand.get(command);
         if (!registration) {
             throw new FlowError("INTERNAL_STATE", `missing CLI command registration: ${command}`);
@@ -72,28 +39,9 @@ const REGISTRY = buildRegistry([
     systemCatalog,
     taskCatalog,
 ]);
-/** Longest multi-token match first; same token count keeps METADATA_ORDER. */
-function deriveParseOrder(order) {
-    return [...order].sort((a, b) => {
-        const tokenDelta = b.split(" ").length - a.split(" ").length;
-        if (tokenDelta !== 0)
-            return tokenDelta;
-        return order.indexOf(a) - order.indexOf(b);
-    });
-}
-const PARSE_ORDER = deriveParseOrder(METADATA_ORDER);
 export function getCommandRegistration(command) {
     return REGISTRY[command];
 }
-export function getCommandMetadata(command) {
-    return REGISTRY[command].meta;
-}
-export function allCommandMetadata() {
-    return METADATA_ORDER.map((command) => REGISTRY[command].meta);
-}
-export function commandParseOrder() {
-    return PARSE_ORDER;
-}
 export async function loadCommandHandler(command) {
     const module = await REGISTRY[command].load();
     return module.handler;

package/build/cli/commands/shared.js

@@ -1,8 +1,9 @@
 import { FlowError } from "../../flow-error.js";
 import { AddressResolutionError, buildResolutionAttempt, } from "../../core/addressing.js";
+import { normalizeFilesystemCoordinate } from "../../fs/path-coordinate.js";
 import { assertGitObservation, observeGitRepository } from "../../git/branches.js";
 import { stableRepoRoot } from "../../core/worktree-path.js";
-import { assertProjectionAlias } from "../../core/projection-alias.js";
+import { assertProjectionAlias } from "../../core/projection/index.js";
 export function titleFromCallPrompt(prompt) {
     const firstLine = prompt
         .split(/\r?\n/)
@@ -15,15 +16,15 @@ export function titleFromCallPrompt(prompt) {
 export function repositoryCoordinateFromAddress(address) {
     return address?.repo.kind === "repository" ? address.repo.stableRoot : undefined;
 }
-export function buildCallInput(content, flags, mode = "call") {
-    const cwd = flags.cwd ?? process.cwd();
+export function buildCallInput(content, flags, mode = "call", platform = process.platform) {
+    const cwd = effectiveDirectory(flags, platform);
     const task = content.trim();
     if (!task) {
         throw new FlowError("EMPTY_PARAM", `${mode} body cannot be empty`);
     }
     return {
         cwd,
-        repo: flags.repo,
+        repo: flags.repo === undefined ? undefined : normalizeFilesystemCoordinate(flags.repo, platform),
         mode,
         contractId: flags.contractId,
         contractAddressSource: flags.contractAddressSource,
@@ -41,11 +42,13 @@ export function buildCallInput(content, flags, mode = "call") {
 export function revivePrompt(stdin) {
     return stdin.trim() ? stdin : "Continue from the previous response.";
 }
-export function effectiveDirectory(flags) {
-    return flags.cwd ?? process.cwd();
+export function effectiveDirectory(flags, platform = process.platform) {
+    return normalizeFilesystemCoordinate(flags.cwd ?? process.cwd(), platform);
 }
 export async function repositoryDirectory(flags, operation) {
-    const candidate = flags.repo ?? effectiveDirectory(flags);
+    const candidate = flags.repo === undefined
+        ? effectiveDirectory(flags)
+        : normalizeFilesystemCoordinate(flags.repo);
     if (assertGitObservation(await observeGitRepository(candidate), operation) === "non-repository") {
         if (flags.contractId) {
             const asTyped = flags.contractAddressSource === "at-address"

package/build/cli/commands/skills/install/handler.js

@@ -1,10 +1,7 @@
 import { installOfficialSkills } from "../../../skills-install.js";
+import { renderSkillsInstallReceipt } from "../../../render/skills.js";
 import { textResponse } from "../../../render/shared.js";
 export const handler = async (_stdin, flags) => {
     const result = await installOfficialSkills(flags.force);
-    return textResponse([
-        "Installed official Keiyaku skills:",
-        ...result.targets.map((target) => `- ${target.path} -> ${target.source} (${target.status})`),
-        ...(result.warnings.length > 0 ? ["", "## Warning", ...result.warnings.map((warning) => `- ${warning}`)] : []),
-    ].join("\n"));
+    return textResponse(renderSkillsInstallReceipt(result));
 };

package/build/cli/commands/skills/install/meta.js

@@ -2,7 +2,7 @@ export const meta = {
     command: "skills install",
     summary: "Install the official Keiyaku skills",
     usage: ["keiyaku skills install [-f|--force]"],
-    stdin: "none",
+    stdin: { mode: "argument" },
     flags: ["force"],
     purpose: "Install the bundled official Keiyaku skills into supported agent skill directories.",
     notes: ["Force permits replacement of foreign collisions."],

package/build/cli/commands/skills/skills/handler.js

@@ -1,4 +1,4 @@
-import { missingSubcommandError } from "../../../help.js";
+import { missingSubcommandError } from "../../../missing-subcommand.js";
 export const handler = async () => {
     throw missingSubcommandError("skills", ["install"]);
 };

package/build/cli/commands/skills/skills/meta.js

@@ -2,7 +2,7 @@ export const meta = {
     command: "skills",
     summary: "Install official skills",
     usage: ["keiyaku skills install"],
-    stdin: "none",
+    stdin: { mode: "argument" },
     flags: [],
     purpose: "Install bundled official Keiyaku skills into supported agent skill directories.",
     subcommands: ["install"],

package/build/cli/commands/system/completion/meta.js

@@ -2,7 +2,7 @@ export const meta = {
     command: "completion",
     summary: "Print shell completion",
     usage: ["keiyaku completion [--shell bash|zsh]"],
-    stdin: "none",
+    stdin: { mode: "argument" },
     flags: ["cwd", "repo", "shell", "word", "previous", "complete"],
     purpose: "Print command and address candidates.",
     completionRank: 13,

package/build/cli/commands/system/dump-env/meta.js

@@ -2,7 +2,7 @@ export const meta = {
     command: "dump-env",
     summary: "Print the environment template",
     usage: ["keiyaku dump-env"],
-    stdin: "none",
+    stdin: { mode: "argument" },
     flags: [],
     purpose: "Print supported environment keys.",
     notes: ["Keiyaku loads <KEIYAKU_HOME>/.env, then .keiyaku/.env; process environment values win."],

package/build/cli/commands/system/guide/meta.js

@@ -2,7 +2,7 @@ export const meta = {
     command: "guide",
     summary: "Print the Keiyaku guide",
     usage: ["keiyaku guide"],
-    stdin: "none",
+    stdin: { mode: "argument" },
     flags: [],
     purpose: "Print workflow guidance.",
     completionRank: 12,

package/build/cli/commands/task/add/handler.js

@@ -1,21 +1,13 @@
-import { randomBytes } from "node:crypto";
-import { resolveTaskCreator } from "../../../../core/task-git-actor.js";
-import { openTaskCommandRepository } from "../../../../core/task-git-runtime.js";
-import { createTask } from "../../../../core/task.js";
-import { renderTaskMutationRow } from "../../../render/task.js";
-import { textResponse } from "../../../render/shared.js";
-import { effectiveDirectory } from "../../shared.js";
-import { parseTaskAddInput } from "../shared.js";
-export const handler = async (stdin, flags, _signal, positional) => {
-    const cwd = effectiveDirectory(flags);
-    const input = parseTaskAddInput(positional[0] === "-" ? stdin : positional[0]);
-    const task = await createTask(await openTaskCommandRepository(cwd), {
+import { createTask, resolveTaskCreator, } from "../../../../core/task/index.js";
+import { parseTaskAddInput, runTaskMutationCommand } from "../shared.js";
+export const handler = async (stdin, flags) => {
+    const input = parseTaskAddInput(stdin);
+    return runTaskMutationCommand(flags, async (repository, cwd) => createTask(repository, {
         ...input,
-        creator: resolveTaskCreator(cwd),
+        creator: await resolveTaskCreator(cwd),
         ...(flags.taskPri === undefined ? {} : { pri: flags.taskPri }),
         needs: flags.taskNeeds ?? [],
         parent: flags.taskParent ?? null,
         from: flags.taskFrom ?? [],
-    }, { randomBytes, now: () => new Date() });
-    return textResponse(renderTaskMutationRow(task));
+    }, { now: () => new Date() }));
 };

package/build/cli/commands/task/add/meta.js

@@ -2,7 +2,10 @@ export const meta = {
     command: "task add",
     summary: "Add a task",
     usage: ["keiyaku task add [-C|--cwd DIR] [--needs ID] [--parent ID] [--from ID] [--pri 0-3] <BODY|->"],
-    stdin: "none",
+    stdin: {
+        mode: "argument",
+        selector: { kind: "positional", index: 0, required: true, rejectBlank: true },
+    },
     flags: ["cwd", "needs", "parent", "from", "pri"],
     purpose: "Create a lightweight task from a title and optional body.",
 };

package/build/cli/commands/task/catalog.js

@@ -1,6 +1,6 @@
 import { meta as taskMeta } from "./task/meta.js";
 import { meta as addMeta } from "./add/meta.js";
-import { meta as viewMeta } from "./view/meta.js";
+import { meta as showMeta } from "./show/meta.js";
 import { meta as lsMeta } from "./ls/meta.js";
 import { meta as startMeta } from "./start/meta.js";
 import { meta as stopMeta } from "./stop/meta.js";
@@ -11,7 +11,7 @@ import { meta as doctorMeta } from "./doctor/meta.js";
 export const taskCatalog = [
     { meta: taskMeta, load: () => import("./task/handler.js") },
     { meta: addMeta, load: () => import("./add/handler.js") },
-    { meta: viewMeta, load: () => import("./view/handler.js") },
+    { meta: showMeta, load: () => import("./show/handler.js") },
     { meta: lsMeta, load: () => import("./ls/handler.js") },
     { meta: startMeta, load: () => import("./start/handler.js") },
     { meta: stopMeta, load: () => import("./stop/handler.js") },

package/build/cli/commands/task/doctor/meta.js

@@ -2,7 +2,7 @@ export const meta = {
     command: "task doctor",
     summary: "Diagnose the task board",
     usage: ["keiyaku task doctor [-C|--cwd DIR]"],
-    stdin: "none",
+    stdin: { mode: "argument" },
     flags: ["cwd"],
     purpose: "Report task state counts, supported board diseases, and lock state without repair.",
 };

package/build/cli/commands/task/done/handler.js

@@ -1,15 +1,11 @@
-import { openTaskCommandRepository } from "../../../../core/task-git-runtime.js";
-import { doneTask } from "../../../../core/task.js";
-import { renderTaskMutationRow } from "../../../render/task.js";
-import { textResponse } from "../../../render/shared.js";
+import { doneTask } from "../../../../core/task/index.js";
 import { effectiveDirectory } from "../../shared.js";
-import { mutationSelectionMessage, rejectBareContractTaskState } from "../shared.js";
+import { mutationSelectionMessage, rejectBareContractTaskState, runTaskMutationCommand } from "../shared.js";
 export const handler = async (_stdin, flags, _signal, positional) => {
     try {
-        const cwd = effectiveDirectory(flags);
         if (positional[0] === undefined)
-            await rejectBareContractTaskState(cwd, "done");
-        return textResponse(renderTaskMutationRow(await doneTask(await openTaskCommandRepository(cwd), positional[0])));
+            await rejectBareContractTaskState(effectiveDirectory(flags), "done");
+        return await runTaskMutationCommand(flags, (repository) => doneTask(repository, positional[0]));
     }
     catch (error) {
         return mutationSelectionMessage(error);