@astrosheep/keiyaku 2.8.4 → 2.9.0

package/build/cli/index.js

@@ -1,358 +1,67 @@
 import * as path from "node:path";
-import * as fs from "node:fs/promises";
 import { FlowError, asMessage } from "../flow-error.js";
 import { writeDraftArtifact } from "./draft-artifact.js";
-import { amendKeiyaku } from "../core/amend.js";
-import { arcKeiyaku, buildArcInput } from "../core/arc.js";
-import { bindContract } from "../core/bind.js";
-import { buildAmendInput, defaultActorClock } from "../core/command-io.js";
-import { AddressResolutionError, buildArtifactResolutionAttempt, buildResolutionAttempt, resolveContractAddress, withResolvedAddress, } from "../core/addressing.js";
-import { forfeitContractCommand } from "../core/forfeit.js";
-import { readContractLog } from "../core/log.js";
-import { buildPetitionClaimInput } from "../core/petition.js";
-import { petitionKeiyaku } from "../core/petition-run.js";
-import { renewKeiyaku } from "../core/renew.js";
-import { normalizeTargetRef, readKanshiBoard } from "../core/status.js";
-import { runCallAndPersist } from "../core/call-persist.js";
-import { isResponseArtifactId } from "../core/response-artifact-id.js";
-import { locateResponseArtifact } from "../core/transcripts.js";
-import { renderEnvExample } from "../config/env-keys.js";
-import { assertSettingsKnobUsable, loadKeiyakuSettings } from "../config/settings.js";
+import { compileBindDraftFlags } from "../core/draft.js";
 import { handleCliError } from "./render/errors.js";
-import { renderStatusBoard } from "./render/status.js";
-import { VERSION } from "../generated/version.js";
 import { FLAG_SPECS } from "./flags.js";
-import { renderAkumaList, renderAkumaShow } from "./commands/akuma.js";
-import { loadAkumaCatalogV2 } from "../config/akuma-loader_v2.js";
-import { renderCompletionCandidates, renderCompletionScript } from "./completion.js";
-import { CLI_COMMAND_METADATA, buildKeiyakuGuide, missingSubcommandError, renderCliCommandHelp as renderCliCommandHelpText, renderCliHelp as renderCliHelpText, } from "./help.js";
-import { commandUsesPromptInput, isCallCommand, parseCliArgs } from "./parse.js";
-import { buildAmendResponse, buildArcResponse, buildRenewResponse } from "./render/arc.js";
-import { buildLogResponse } from "./render/misc.js";
-import { buildPetitionClaimResponse } from "./render/petition.js";
+import { renderCliCommandHelp as renderCliCommandHelpText, renderCliHelp as renderCliHelpText, } from "./help.js";
+import { commandUsesPromptInput, isCallCommand, isPetitionDryRunInvocation, parseCliArgs } from "./parse.js";
+import { getCommandMetadata, loadCommandHandler } from "./commands/registry.js";
+import { repositoryCoordinateFromAddress } from "./commands/shared.js";
 import { shellQuote } from "./render/format.js";
-import { buildBindDraftResponse, buildBindResponse, buildForfeitResponse, formatCallNextAction, renderCoreResult, textResponse } from "./render/shared.js";
-import { buildCallResponse, renderAdoptedLaunchReceipt } from "./render/call.js";
-import { projectionDir, writeInboxTell } from "../core/projection-core.js";
-import { assertTellEffortSupported, tellProjection } from "../core/projection-wake.js";
-import { killProjectionGeneration } from "../core/projection-kill.js";
-import { resolveProjectionAddress } from "./projection-address.js";
-import { waitForProjection } from "../core/projection-wait.js";
-import { buildWaitResponse } from "./render/wait.js";
-import { prependAddressReceipt, renderResolvedAddressReceipt } from "./render/address.js";
-import { installOfficialSkills } from "./skills-install.js";
-import { isGitRepo } from "../git/branches.js";
-import { stableRepoRoot } from "../core/worktree-path.js";
-import { assertProjectionAlias } from "../core/projection-alias.js";
-const CALL_INPUT_HINTS = [
-    "Call input can be a prompt argument, `-` to read stdin, or omitted to read stdin.",
-    "Use `keiyaku call NAME \"prompt\"`, `keiyaku call NAME - < prompt.md`, or `keiyaku revive ARTIFACT_ID`.",
-];
-function titleFromCallPrompt(prompt) {
-    const firstLine = prompt
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .find((line) => line.length > 0);
-    if (!firstLine)
-        return "Call";
-    return firstLine.replace(/^#+\s*/, "").slice(0, 80) || "Call";
-}
-function repositoryCoordinateFromAddress(address) {
-    return address?.repo.kind === "repository" ? address.repo.stableRoot : undefined;
-}
-function buildCallInput(content, flags, mode = "call") {
-    const cwd = flags.cwd ?? process.cwd();
-    const task = content.trim();
-    if (!task) {
-        throw new FlowError("EMPTY_PARAM", "call requires a prompt argument, `-` with stdin, or prompt text on stdin.", {
-            hints: CALL_INPUT_HINTS,
-        });
-    }
-    return {
-        cwd,
-        repo: flags.repo,
-        mode,
-        contractId: flags.contractId,
-        contractAddressSource: flags.contractAddressSource,
-        title: titleFromCallPrompt(task),
-        task,
-        agent: flags.akuma,
-        model: flags.model,
-        effort: flags.effort,
-        incognito: flags.incognito,
-        bare: flags.bare,
-        detach: flags.detach,
-        ...(mode === "call" && flags.alias !== undefined ? { alias: assertProjectionAlias(flags.alias) } : {}),
-    };
+import { formatCallNextAction } from "./render/shared.js";
+import { renderResolvedAddressReceipt } from "./render/address.js";
+function commandRequiresStdin(command) {
+    return getCommandMetadata(command).stdin === "required";
 }
-function revivePrompt(stdin) {
-    return stdin.trim() ? stdin : "Continue from the previous response.";
+function commandAcceptsOptionalStdin(command) {
+    return getCommandMetadata(command).stdin === "optional";
 }
-function commandSpec(command, run) {
-    return { ...CLI_COMMAND_METADATA[command], run };
+function commandSavesFailedStdin(command) {
+    return (commandRequiresStdin(command) || commandAcceptsOptionalStdin(command)) && command !== "call";
 }
-function effectiveDirectory(flags) {
-    return flags.cwd ?? process.cwd();
+function hasBindDomainFlags(flags) {
+    return (flags.bindPlace !== undefined
+        || flags.bindObjective !== undefined
+        || flags.bindScope !== undefined
+        || flags.bindChecks !== undefined);
 }
-async function repositoryDirectory(flags) {
-    const candidate = flags.repo ?? effectiveDirectory(flags);
-    if (!(await isGitRepo(candidate))) {
-        if (flags.contractId) {
-            const asTyped = flags.contractAddressSource === "at-address"
-                ? `@${flags.contractId}`
-                : `--contract ${flags.contractId}`;
-            throw new AddressResolutionError("EMPTY_PARAM", `${asTyped} is a commission address, but ${candidate} has no repository ledger; contract addressing requires a ledger`, buildResolutionAttempt({
-                repo: { kind: "user" },
-                workdir: effectiveDirectory(flags),
-                spelling: {
-                    asTyped,
-                    source: flags.contractAddressSource ?? "explicit-flag",
-                },
-            }));
-        }
-        throw new FlowError("NOT_GIT_REPO", `${candidate} is not a git repository`);
+function prepareBindInput(stdin, flags) {
+    const nonblankStdin = stdin.trim().length > 0;
+    const domainFlags = hasBindDomainFlags(flags);
+    if (flags.dryRun && flags.draftOnly) {
+        throw new FlowError("EMPTY_PARAM", "--dry-run cannot be combined with --draft-only");
     }
-    return flags.repo ? await stableRepoRoot(candidate) : candidate;
-}
-async function projectDirectory(flags) {
-    if (flags.repo)
-        return await repositoryDirectory(flags);
-    return effectiveDirectory(flags);
-}
-const CLI_COMMAND_SPECS = {
-    bind: commandSpec("bind", async (stdin, flags) => {
-        const cwd = await repositoryDirectory(flags);
-        if (flags.draftOnly) {
-            return buildBindDraftResponse(await writeDraftArtifact({ cwd, title: "bind-draft", content: stdin }));
-        }
-        const result = await bindContract({
-            cwd, draft: stdin, ...defaultActorClock(), workspace: "worktree",
-            after: flags.after ?? [], exclusive: flags.exclusive,
-            onProgress: (line) => {
-                process.stdout.write(`${line}\n`);
-            },
-        });
-        return buildBindResponse(result, cwd);
-    }),
-    arc: commandSpec("arc", async (stdin, flags) => {
-        const parsed = buildArcInput(stdin, effectiveDirectory(flags), flags.waivePaths, flags.contractId, flags.contractAddressSource);
-        const cwd = await repositoryDirectory(flags);
-        return renderCoreResult(arcKeiyaku({ ...parsed, cwd }), buildArcResponse);
-    }),
-    call: commandSpec("call", async (stdin, flags, signal) => {
-        const outcome = await runCallAndPersist({
-            ...buildCallInput(stdin, flags, "call"),
-            signal,
-            ...(!flags.detach
-                ? {
-                    onLaunch: ({ address, projection }) => {
-                        process.stdout.write(`${renderAdoptedLaunchReceipt(address, projection.id, projection.alias, projection.previousAliasTarget)}\n`);
-                    },
-                }
-                : {}),
-        });
-        if (outcome.result.foregroundWait && outcome.result.projection) {
-            return buildWaitResponse(outcome.result.projection.id, outcome.result.foregroundWait, { alias: outcome.result.projection.alias });
-        }
-        return buildCallResponse(outcome.result, {
-            responsePath: outcome.responsePath,
-            artifactId: outcome.artifactId,
-            addressPlacement: flags.detach ? "stdout" : "none",
-        });
-    }),
-    revive: commandSpec("revive", async (stdin, flags, signal, positional) => {
-        const cwd = effectiveDirectory(flags);
-        const artifactCwd = await projectDirectory(flags);
-        const artifactId = positional[0];
-        const isRepo = await isGitRepo(artifactCwd);
-        const responseStoreCwd = isRepo ? await stableRepoRoot(artifactCwd) : await fs.realpath(artifactCwd);
-        const artifact = await locateResponseArtifact({
-            cwd: responseStoreCwd,
-            artifactId,
-            attempt: buildArtifactResolutionAttempt({
-                repo: isRepo
-                    ? { kind: "repository", stableRoot: responseStoreCwd }
-                    : { kind: "user" },
-                workdir: cwd,
-                supplied: artifactId,
-                inference: ["response artifact identity lookup"],
-            }),
-        });
-        let executionCwd;
-        let repo;
-        if (artifact.provenance.authority.kind === "repository") {
-            executionCwd = responseStoreCwd;
-            repo = responseStoreCwd;
-        }
-        else {
-            if (!("workdir" in artifact.provenance.evidence)) {
-                throw new FlowError("INVALID_RESPONSE_PATH", `Invalid response artifact '${artifactId}': field 'provenance.evidence.workdir' is missing.`);
-            }
-            executionCwd = artifact.provenance.evidence.workdir;
-            repo = undefined;
-        }
-        const outcome = await runCallAndPersist({
-            ...buildCallInput(revivePrompt(stdin), { ...flags, cwd: executionCwd, repo }, "revive"),
-            reviveArtifact: artifact,
-            signal,
-        });
-        return buildCallResponse(outcome.result, { responsePath: outcome.responsePath, artifactId: outcome.artifactId, addressPlacement: "footer" });
-    }),
-    wait: commandSpec("wait", async (_stdin, flags, signal, positional) => {
-        const cwd = flags.contractId ? await repositoryDirectory(flags) : await projectDirectory(flags);
-        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();
-    }),
-    tell: commandSpec("tell", async (_stdin, flags, _signal, positional) => {
-        const cwd = flags.contractId ? await repositoryDirectory(flags) : await projectDirectory(flags);
-        const [projectionAddress, message] = positional;
-        if (!projectionAddress || !message)
-            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, message, Date.now(), { effort: flags.effort });
-            await tellProjection(directory, flags.effort);
-            return textResponse("");
-        };
-        return address ? await withResolvedAddress(address, operation) : await operation();
-    }),
-    kill: commandSpec("kill", async (_stdin, flags, _signal, positional) => {
-        const cwd = flags.contractId ? await repositoryDirectory(flags) : await projectDirectory(flags);
-        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 result = killProjectionGeneration(projectionDir(cwd, projection.id));
-            const line = result.status === "killed"
-                ? `× killed ${projection.id}`
-                : `· already resting ${projection.id}`;
-            return textResponse(line);
-        };
-        return address ? await withResolvedAddress(address, operation) : await operation();
-    }),
-    log: commandSpec("log", async (_stdin, flags) => {
-        const cwd = await repositoryDirectory(flags);
-        const address = await resolveContractAddress(cwd, flags.contractId, flags.contractAddressSource);
-        return await withResolvedAddress(address, async () => {
-            const result = await readContractLog({ cwd, contractId: address.binding.commissionId });
-            return buildLogResponse({ ...result, address });
-        });
-    }),
-    akuma: commandSpec("akuma", async () => { throw missingSubcommandError("akuma", CLI_COMMAND_METADATA.akuma.subcommands ?? []); }),
-    "akuma list": commandSpec("akuma list", async (_stdin, flags) => {
-        const cwd = await projectDirectory(flags);
-        const loaded = await loadKeiyakuSettings(cwd);
-        // Role markers need settings pointers; catalog consumers keep legacy agents disease actionable.
-        assertSettingsKnobUsable(loaded, "agents");
-        assertSettingsKnobUsable(loaded, "default");
-        assertSettingsKnobUsable(loaded, "reviewer");
-        return textResponse(renderAkumaList(await loadAkumaCatalogV2(cwd), loaded.providerInstances, loaded.knobs));
-    }),
-    "akuma ls": commandSpec("akuma ls", async (_stdin, flags, signal, positional) => CLI_COMMAND_SPECS["akuma list"].run(_stdin, flags, signal, positional)),
-    "akuma show": commandSpec("akuma show", async (_stdin, flags, _signal, positional) => {
-        const [name] = positional;
-        if (!name) {
-            throw new FlowError("EMPTY_PARAM", "akuma show requires an Akuma name");
-        }
-        if (isResponseArtifactId(name)) {
-            throw new FlowError("EMPTY_PARAM", `artifact ${name} is a response artifact; akuma show expects an Akuma profile name`);
+    if (nonblankStdin && domainFlags) {
+        throw new FlowError("EMPTY_PARAM", "bind accepts either stdin Markdown or the four domain flags, not both");
+    }
+    if (domainFlags) {
+        const missing = [];
+        if (flags.bindPlace === undefined)
+            missing.push("--place");
+        if (flags.bindObjective === undefined)
+            missing.push("--objective");
+        if (flags.bindScope === undefined)
+            missing.push("--scope");
+        if (flags.bindChecks === undefined)
+            missing.push("--checks");
+        if (missing.length > 0) {
+            throw new FlowError("EMPTY_PARAM", `bind flag mode requires --place, --objective, --scope, and --checks; missing ${missing.join(", ")}`);
         }
-        const cwd = await projectDirectory(flags);
-        const loaded = await loadKeiyakuSettings(cwd);
-        // Role markers need settings pointers; catalog consumers keep legacy agents disease actionable.
-        assertSettingsKnobUsable(loaded, "agents");
-        assertSettingsKnobUsable(loaded, "default");
-        assertSettingsKnobUsable(loaded, "reviewer");
-        return textResponse(renderAkumaShow(await loadAkumaCatalogV2(cwd), loaded.providerInstances, loaded.knobs, name));
-    }),
-    skills: commandSpec("skills", async () => { throw missingSubcommandError("skills", CLI_COMMAND_METADATA.skills.subcommands ?? []); }),
-    "skills install": commandSpec("skills install", 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"));
-    }),
-    amend: commandSpec("amend", async (stdin, flags) => {
-        const parsed = buildAmendInput(stdin, effectiveDirectory(flags), flags.contractId, flags.contractAddressSource);
-        const cwd = await repositoryDirectory(flags);
-        return renderCoreResult(amendKeiyaku({ ...parsed, cwd }), buildAmendResponse);
-    }),
-    renew: commandSpec("renew", async (_stdin, flags) => {
-        const cwd = await repositoryDirectory(flags);
-        const address = await resolveContractAddress(cwd, flags.contractId, flags.contractAddressSource);
-        return renderCoreResult(renewKeiyaku({ cwd, address, waivePaths: flags.waivePaths }), buildRenewResponse);
-    }),
-    petition: commandSpec("petition", async (stdin, flags, signal) => {
-        const cwd = await repositoryDirectory(flags);
-        const address = await resolveContractAddress(cwd, flags.contractId, flags.contractAddressSource);
-        return await withResolvedAddress(address, async () => {
-            const input = buildPetitionClaimInput({ cwd, contractId: address.binding.commissionId, stdin, signal, waivePaths: flags.waivePaths });
-            return buildPetitionClaimResponse({ ...await petitionKeiyaku(input), address }, input);
+        return compileBindDraftFlags({
+            place: flags.bindPlace,
+            objective: flags.bindObjective,
+            scope: flags.bindScope,
+            checks: flags.bindChecks,
         });
-    }),
-    forfeit: commandSpec("forfeit", async (_stdin, flags) => {
-        const cwd = await repositoryDirectory(flags);
-        const address = await resolveContractAddress(cwd, flags.contractId, flags.contractAddressSource);
-        return await withResolvedAddress(address, async () => buildForfeitResponse({
-            ...await forfeitContractCommand({ cwd, contractId: address.binding.commissionId, ...defaultActorClock(), note: flags.reason }),
-            address,
-        }));
-    }),
-    guide: commandSpec("guide", async () => textResponse(buildKeiyakuGuide(VERSION))),
-    completion: commandSpec("completion", async (_stdin, flags) => {
-        const cwd = await projectDirectory(flags);
-        if (flags.complete) {
-            return textResponse(await renderCompletionCandidates({ cwd, word: flags.word, previous: flags.previous }));
-        }
-        return textResponse(renderCompletionScript(flags.shell));
-    }),
-    status: commandSpec("status", async (_stdin, flags) => {
-        // Status is read-only and must open outside Git. projectDirectory still
-        // honors --repo as a repository coordinate when the operator names one.
-        const cwd = await projectDirectory(flags);
-        const target = flags.target === undefined ? undefined : normalizeTargetRef(flags.target);
-        return textResponse(renderStatusBoard(await readKanshiBoard(cwd, Date.now(), {
-            ...(target === undefined ? {} : { target }),
-            showAllProjections: flags.all === true,
-        })));
-    }),
-    "dump-env": commandSpec("dump-env", async () => textResponse(renderEnvExample())),
-};
-function getCliCommandSpec(command) {
-    return CLI_COMMAND_SPECS[command];
-}
-function commandRequiresStdin(command) {
-    return getCliCommandSpec(command).stdin === "required";
-}
-function commandSavesFailedStdin(command) {
-    return commandRequiresStdin(command) && command !== "call";
+    }
+    if (flags.dryRun) {
+        throw new FlowError("EMPTY_PARAM", "--dry-run requires --place, --objective, --scope, and --checks");
+    }
+    if (!nonblankStdin) {
+        throw new FlowError("EMPTY_PARAM", `No Markdown input received on stdin.\n\nExample:\n  ${usageExample("bind")}`);
+    }
+    return stdin;
 }
 async function readStdin() {
     if (process.stdin.isTTY)
@@ -421,10 +130,15 @@ function conversationalFooter(response) {
     }
     return lines.join("\n");
 }
-function writeSuccessResponse(command, response) {
-    // Successful tell is always silent: zero stdout bytes, even if text regresses.
-    if (command === "tell")
+function writeSuccessResponse(command, flags, response) {
+    // Plain tell is always silent; tell --wait owns the ordinary wait response.
+    if (command === "tell" && flags.timeoutMs === undefined)
+        return;
+    if (command === "bind" && flags.dryRun) {
+        // Canonical Markdown already ends with exactly one newline.
+        process.stdout.write(responseText(response));
         return;
+    }
     if (command !== "revive") {
         process.stdout.write(`${responseText(response)}\n`);
         return;
@@ -471,7 +185,7 @@ async function handleFailureAfterStdin(input) {
     else {
         await printFailure(input.error ?? new Error("Unknown CLI failure"), input.cwd);
     }
-    if (!commandSavesFailedStdin(input.command)) {
+    if (input.saveStdin === false || !commandSavesFailedStdin(input.command)) {
         return 1;
     }
     try {
@@ -491,36 +205,45 @@ async function handleFailureAfterStdin(input) {
 }
 async function runResponse(command, flags, stdin, positional) {
     const signal = makeAbortSignal();
-    return await getCliCommandSpec(command).run(stdin, flags, signal, positional);
+    const handler = await loadCommandHandler(command);
+    return await handler(stdin, flags, signal, positional);
 }
-function positionalPrompt(command, positional) {
+function bodyToken(command, positional) {
     if (isCallCommand(command))
         return positional[0];
+    if (command === "tell")
+        return positional[1];
     if (command === "revive")
         return positional[1];
     return undefined;
 }
-async function readPromptInput(command, positional, cwd) {
+async function readBodyInput(command, positional, cwd) {
     if (!commandUsesPromptInput(command))
         return undefined;
-    const prompt = positionalPrompt(command, positional);
-    if (prompt !== undefined && prompt !== "-")
-        return prompt;
-    const stdin = await readStdin();
-    if (!stdin.trim()) {
-        if (command === "revive") {
+    const token = bodyToken(command, positional);
+    if (token === undefined) {
+        if (command === "revive")
             return "";
+        await printFailure(new FlowError("EMPTY_PARAM", `${command} body cannot be empty`), cwd);
+        return undefined;
+    }
+    if (token !== "-") {
+        if (!token.trim()) {
+            await printFailure(new FlowError("EMPTY_PARAM", `${command} body cannot be empty`), cwd);
+            return undefined;
         }
-        await printFailure(new FlowError("EMPTY_PARAM", `${command} requires a prompt argument, \`-\` with stdin, or prompt text on stdin.`, {
-            hints: CALL_INPUT_HINTS,
-        }), cwd);
+        return token;
+    }
+    const stdin = await readStdin();
+    if (!stdin.trim()) {
+        await printFailure(new FlowError("EMPTY_PARAM", `${command} body cannot be empty`), cwd);
         return undefined;
     }
     return stdin;
 }
 function usageExample(command) {
-    const spec = getCliCommandSpec(command);
-    return spec.examples?.[0] ?? spec.usage[0] ?? `keiyaku ${command}`;
+    const meta = getCommandMetadata(command);
+    return meta.examples?.[0] ?? meta.usage[0] ?? `keiyaku ${command}`;
 }
 export async function runCliCommand(tokens) {
     let parsed;
@@ -529,7 +252,7 @@ export async function runCliCommand(tokens) {
     }
     catch (error) {
         await printFailure(error, process.cwd());
-        return 1;
+        return isPetitionDryRunInvocation(tokens) ? 2 : 1;
     }
     if (parsed.helpRequested) {
         process.stdout.write(`${renderCliCommandHelp(resolveCliHelpCommand(parsed.command))}\n`);
@@ -537,65 +260,89 @@ export async function runCliCommand(tokens) {
     }
     const cwd = parsed.flags.cwd ?? process.cwd();
     let stdin = "";
-    if (commandRequiresStdin(parsed.command)) {
+    if (parsed.command === "task add") {
+        if (parsed.positional[0] === "-")
+            stdin = await readStdin();
+        if (!(parsed.positional[0] === "-" ? stdin : parsed.positional[0]).trim()) {
+            await printFailure(new FlowError("EMPTY_PARAM", "task add input cannot be blank"), cwd);
+            return 1;
+        }
+    }
+    else if (parsed.command === "task update" && parsed.flags.taskBody === "-") {
+        stdin = await readStdin();
+    }
+    else if (commandRequiresStdin(parsed.command)) {
         stdin = await readStdin();
         if (!stdin.trim()) {
             await printFailure(new FlowError("EMPTY_PARAM", `No Markdown input received on stdin.\n\nExample:\n  ${usageExample(parsed.command)}`), cwd);
             return 1;
         }
     }
-    else if (parsed.command === "petition") {
-        // Optional stdin: empty must reach the oath gate as OATH_MISSING, not EMPTY_PARAM.
+    else if (commandAcceptsOptionalStdin(parsed.command)) {
+        // Optional stdin: bind prepares domain flags or blank-stdin errors itself;
+        // petition lets an empty body reach the oath gate as OATH_MISSING.
         stdin = await readStdin();
     }
     else {
-        const prompt = await readPromptInput(parsed.command, parsed.positional, cwd);
-        if (prompt === undefined && commandUsesPromptInput(parsed.command)) {
+        const body = await readBodyInput(parsed.command, parsed.positional, cwd);
+        if (body === undefined && commandUsesPromptInput(parsed.command)) {
+            return 1;
+        }
+        stdin = body ?? "";
+    }
+    // Bind dry-run must compile and return before repository/cwd resolution or filesystem effects.
+    if (parsed.command === "bind") {
+        try {
+            stdin = prepareBindInput(stdin, parsed.flags);
+        }
+        catch (error) {
+            await printFailure(error, cwd);
             return 1;
         }
-        stdin = prompt ?? "";
     }
     let response;
     try {
         response = await runResponse(parsed.command, parsed.flags, stdin, parsed.positional);
     }
     catch (error) {
-        if (commandRequiresStdin(parsed.command)) {
+        if (commandRequiresStdin(parsed.command) || (parsed.command === "bind" && !parsed.flags.dryRun)) {
             return await handleFailureAfterStdin({
                 error,
                 cwd,
                 cwdFlag: parsed.flags.cwd,
                 command: parsed.command,
                 stdin,
+                saveStdin: !(parsed.command === "bind" && hasBindDomainFlags(parsed.flags)),
             });
         }
         await printFailure(error, cwd);
+        if (parsed.command === "petition" && parsed.flags.dryRun)
+            return 2;
         return failureExitCode(error);
     }
     const success = !response.payload || !("error" in response.payload);
     if (success) {
-        writeSuccessResponse(parsed.command, response);
+        writeSuccessResponse(parsed.command, parsed.flags, response);
         return response.exitCode ?? 0;
     }
-    if (commandRequiresStdin(parsed.command)) {
+    if (commandRequiresStdin(parsed.command) || (parsed.command === "bind" && !parsed.flags.dryRun)) {
         return await handleFailureAfterStdin({
             response,
             cwd,
             cwdFlag: parsed.flags.cwd,
             command: parsed.command,
             stdin,
+            saveStdin: !(parsed.command === "bind" && hasBindDomainFlags(parsed.flags)),
         });
     }
     process.stderr.write(`${responseText(response)}\n`);
     return 1;
 }
 export function renderCliCommandHelp(command) {
-    const spec = getCliCommandSpec(command);
-    return renderCliCommandHelpText(command, spec, FLAG_SPECS);
+    const meta = getCommandMetadata(command);
+    return renderCliCommandHelpText(command, meta, FLAG_SPECS);
 }
 function resolveCliHelpCommand(command) {
-    if (command === "akuma ls")
-        return "akuma list";
     return command;
 }
 export function renderCliHelp(version) {

package/build/cli/output-stream-error-policy.js

@@ -0,0 +1,17 @@
+/**
+ * Install a process-level broken-pipe policy on each supplied stream.
+ * EPIPE is silent; every other emitted value is rethrown unchanged.
+ */
+export function installCliOutputStreamErrorPolicy(...streams) {
+    for (const stream of streams) {
+        stream.on("error", (error) => {
+            if (typeof error === "object" &&
+                error !== null &&
+                "code" in error &&
+                error.code === "EPIPE") {
+                return;
+            }
+            throw error;
+        });
+    }
+}