@astrosheep/keiyaku 2.9.3 → 2.9.5

package/build/cli/index.js

@@ -5,17 +5,19 @@ import { compileBindDraftFlags } from "../core/draft.js";
 import { handleCliError } from "./render/errors.js";
 import { FLAG_SPECS } from "./flags.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 { isPetitionDryRunInvocation, parseCliArgs } from "./parse.js";
+import { getCommandMetadata } from "./commands/metadata.js";
+import { loadCommandHandler } from "./commands/registry.js";
 import { shellQuote } from "./render/format.js";
-import { formatCallNextAction } from "./render/shared.js";
-import { renderResolvedAddressReceipt } from "./render/address.js";
+import { writeSuccessResponse } from "./render/success-response.js";
+import { writeCliOutput } from "./output-stream-error-policy.js";
 function commandRequiresStdin(command) {
-    return getCommandMetadata(command).stdin === "required";
+    const stdin = getCommandMetadata(command).stdin;
+    return stdin.mode === "document" && stdin.selector.required;
 }
 function commandAcceptsOptionalStdin(command) {
-    return getCommandMetadata(command).stdin === "optional";
+    const stdin = getCommandMetadata(command).stdin;
+    return stdin.mode === "document" && !stdin.selector.required;
 }
 function commandSavesFailedStdin(command) {
     return (commandRequiresStdin(command) || commandAcceptsOptionalStdin(command)) && command !== "call";
@@ -59,13 +61,15 @@ function prepareBindInput(stdin, flags) {
         throw new FlowError("EMPTY_PARAM", "--dry-run requires --place, --objective, --scope, and --checks");
     }
     if (!nonblankStdin) {
+        // --task may supply name/objective defaults; core merges and reports missing sections.
+        if (flags.bindTaskIds !== undefined && flags.bindTaskIds.length > 0) {
+            return "";
+        }
         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)
-        return "";
     let data = "";
     process.stdin.setEncoding("utf-8");
     for await (const chunk of process.stdin)
@@ -80,77 +84,6 @@ function makeAbortSignal() {
 function responseText(response) {
     return response.text;
 }
-function responseData(response) {
-    const payload = response.payload;
-    if (!payload || typeof payload !== "object" || Array.isArray(payload) || "error" in payload)
-        return {};
-    return payload;
-}
-function isCallProjectionFacts(value) {
-    if (value === null || typeof value !== "object" || Array.isArray(value))
-        return false;
-    const facts = value;
-    return typeof facts.id === "string"
-        && (facts.phase === "active" || facts.phase === "done" || facts.phase === "failed"
-            || facts.phase === "dismissed" || facts.phase === "lost" || facts.phase === "quiescent");
-}
-function conversationalFooter(response) {
-    const data = responseData(response);
-    const lines = [];
-    if (response.address) {
-        const projection = data.projection;
-        const projectionFacts = isCallProjectionFacts(projection) ? projection : undefined;
-        const receiptArtifactId = typeof data.revivedArtifactId === "string"
-            ? data.revivedArtifactId
-            : typeof data.artifactId === "string" ? data.artifactId : undefined;
-        lines.push(renderResolvedAddressReceipt(response.address, { artifactId: receiptArtifactId, projectionId: projectionFacts?.id }));
-    }
-    const responsePath = typeof data.responsePath === "string" ? data.responsePath : undefined;
-    const agent = typeof data.agent === "string" ? data.agent : undefined;
-    const meta = data.meta && typeof data.meta === "object" && !Array.isArray(data.meta) ? data.meta : undefined;
-    const warnings = Array.isArray(meta?.warnings) ? meta.warnings.filter((warning) => typeof warning === "string") : [];
-    if (responsePath) {
-        lines.push(`Saved to ${responsePath}.`);
-    }
-    if (agent) {
-        lines.push(`Akuma: ${agent}`);
-    }
-    if (warnings.length > 0) {
-        lines.push("Warnings:", ...warnings.map((warning) => `- ${warning}`));
-    }
-    if (typeof data.summary === "string") {
-        const projection = data.projection;
-        const projectionFacts = isCallProjectionFacts(projection) ? projection : undefined;
-        const artifactId = typeof data.artifactId === "string" ? data.artifactId : undefined;
-        lines.push(formatCallNextAction({
-            projection: projectionFacts,
-            artifactId,
-            repositoryCoordinate: repositoryCoordinateFromAddress(response.address),
-        }));
-    }
-    return lines.join("\n");
-}
-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;
-    }
-    const data = responseData(response);
-    const answer = typeof data.summary === "string" ? data.summary.trim() : responseText(response).trim();
-    const footer = conversationalFooter(response);
-    process.stdout.write(`${answer}\n`);
-    if (footer) {
-        process.stderr.write(`${footer}\n`);
-    }
-}
 async function saveFailedStdin(input) {
     if (!input.content.trim())
         return undefined;
@@ -160,12 +93,49 @@ async function saveFailedStdin(input) {
         content: input.content,
     });
 }
-function retryHint(command, draftPath, cwd, cwdFlag) {
-    if (!cwdFlag) {
-        return `Retry: keiyaku ${command} < ${shellQuote(draftPath)}`;
+/**
+ * Rebuild bind flags for a failed-stdin retry in deterministic shell-safe order.
+ * Order follows bind usage/parse authority: cwd, repo, after, exclusive,
+ * draft-only, task. Domain-flag bind does not save stdin, so place/objective/
+ * scope/checks are not reconstructed. --dry-run never reaches this path.
+ */
+function bindRetryFlagTokens(flags) {
+    const tokens = [];
+    if (flags.cwd !== undefined) {
+        tokens.push("--cwd", shellQuote(flags.cwd));
+    }
+    if (flags.repo !== undefined) {
+        tokens.push("--repo", shellQuote(flags.repo));
+    }
+    for (const after of flags.after ?? []) {
+        tokens.push("--after", shellQuote(after));
+    }
+    if (flags.exclusive === true) {
+        tokens.push("--exclusive");
+    }
+    if (flags.draftOnly === true) {
+        tokens.push("--draft-only");
+    }
+    if (flags.bindTaskIds !== undefined) {
+        for (const taskId of flags.bindTaskIds) {
+            tokens.push("--task", shellQuote(taskId));
+        }
     }
-    const absoluteDraftPath = path.resolve(cwd, draftPath);
-    return `Retry: keiyaku ${command} --cwd ${shellQuote(cwdFlag)} < ${shellQuote(absoluteDraftPath)}`;
+    return tokens;
+}
+function retryHint(input) {
+    const draftArg = input.flags.cwd === undefined
+        ? shellQuote(input.draftPath)
+        : shellQuote(path.resolve(input.cwd, input.draftPath));
+    if (input.command === "bind") {
+        const flagTokens = bindRetryFlagTokens(input.flags);
+        const flagPart = flagTokens.length > 0 ? ` ${flagTokens.join(" ")}` : "";
+        return `Retry: keiyaku bind${flagPart} - < ${draftArg}`;
+    }
+    if (input.flags.cwd === undefined) {
+        return `Retry: keiyaku ${input.command} - < ${shellQuote(input.draftPath)}`;
+    }
+    return `Retry: keiyaku ${input.command} --cwd ${shellQuote(input.flags.cwd)} - < ${draftArg}`;
 }
 async function printFailure(error, cwd) {
     const response = await handleCliError({
@@ -173,14 +143,14 @@ async function printFailure(error, cwd) {
         cwd,
         logLabel: "cli",
     });
-    process.stderr.write(`${responseText(response)}\n`);
+    await writeCliOutput(process.stderr, `${responseText(response)}\n`);
 }
 function failureExitCode(error) {
     return error instanceof Error && error.name === "AbortError" ? 130 : 1;
 }
 async function handleFailureAfterStdin(input) {
     if (input.response) {
-        process.stderr.write(`${responseText(input.response)}\n`);
+        await writeCliOutput(process.stderr, `${responseText(input.response)}\n`);
     }
     else {
         await printFailure(input.error ?? new Error("Unknown CLI failure"), input.cwd);
@@ -195,11 +165,16 @@ async function handleFailureAfterStdin(input) {
             content: input.stdin,
         });
         if (draftPath) {
-            process.stderr.write(`\nSaved stdin input to ${draftPath}.\n${retryHint(input.command, draftPath, input.cwd, input.cwdFlag)}\n`);
+            await writeCliOutput(process.stderr, `\nSaved stdin input to ${draftPath}.\n${retryHint({
+                command: input.command,
+                draftPath,
+                cwd: input.cwd,
+                flags: input.flags,
+            })}\n`);
         }
     }
     catch (draftError) {
-        process.stderr.write(`\nFailed to save stdin input: ${asMessage(draftError)}\n`);
+        await writeCliOutput(process.stderr, `\nFailed to save stdin input: ${asMessage(draftError)}\n`);
     }
     return 1;
 }
@@ -208,38 +183,42 @@ async function runResponse(command, flags, stdin, positional) {
     const handler = await loadCommandHandler(command);
     return await handler(stdin, flags, signal, 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 readBodyInput(command, positional, cwd) {
-    if (!commandUsesPromptInput(command))
-        return undefined;
-    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;
-        }
-        return token;
-    }
-    const stdin = await readStdin();
-    if (!stdin.trim()) {
-        await printFailure(new FlowError("EMPTY_PARAM", `${command} body cannot be empty`), cwd);
+function selectedArgument(parsed) {
+    const stdin = getCommandMetadata(parsed.command).stdin;
+    if (stdin.selector === undefined)
         return undefined;
-    }
-    return stdin;
+    if (stdin.selector.kind === "positional") {
+        return { token: parsed.positional[stdin.selector.index], replace: () => parsed.flags };
+    }
+    const flagName = stdin.selector.name;
+    return {
+        token: parsed.flags[flagName],
+        replace: (value) => ({ ...parsed.flags, [flagName]: value }),
+    };
+}
+async function resolveCliInput(parsed) {
+    const stdinMeta = getCommandMetadata(parsed.command).stdin;
+    const selected = selectedArgument(parsed);
+    const token = selected?.token;
+    const selectsStdin = token === "-";
+    if (selectsStdin && process.stdin.isTTY) {
+        throw new FlowError("EMPTY_PARAM", `${parsed.command} literal '-' requires piped stdin`);
+    }
+    const piped = selectsStdin ? await readStdin() : "";
+    const input = selectsStdin ? piped : token ?? "";
+    if (stdinMeta.selector?.required && token === undefined) {
+        const message = stdinMeta.mode === "document"
+            ? `${parsed.command} requires literal '-' to read Markdown from stdin`
+            : `${parsed.command} body cannot be empty`;
+        throw new FlowError("EMPTY_PARAM", message);
+    }
+    if (token !== undefined && stdinMeta.selector?.rejectBlank && !input.trim()) {
+        const message = stdinMeta.mode === "document"
+            ? `No Markdown input received on stdin.\n\nExample:\n  ${usageExample(parsed.command)}`
+            : `${parsed.command} body cannot be empty`;
+        throw new FlowError("EMPTY_PARAM", message);
+    }
+    return { stdin: input, flags: selected?.replace(input) ?? parsed.flags };
 }
 function usageExample(command) {
     const meta = getCommandMetadata(command);
@@ -255,40 +234,19 @@ export async function runCliCommand(tokens) {
         return isPetitionDryRunInvocation(tokens) ? 2 : 1;
     }
     if (parsed.helpRequested) {
-        process.stdout.write(`${renderCliCommandHelp(resolveCliHelpCommand(parsed.command))}\n`);
+        await writeCliOutput(process.stdout, `${renderCliCommandHelp(resolveCliHelpCommand(parsed.command))}\n`);
         return 0;
     }
     const cwd = parsed.flags.cwd ?? process.cwd();
-    let stdin = "";
-    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 (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();
+    let stdin;
+    try {
+        const resolved = await resolveCliInput(parsed);
+        stdin = resolved.stdin;
+        parsed = { ...parsed, flags: resolved.flags };
     }
-    else {
-        const body = await readBodyInput(parsed.command, parsed.positional, cwd);
-        if (body === undefined && commandUsesPromptInput(parsed.command)) {
-            return 1;
-        }
-        stdin = body ?? "";
+    catch (error) {
+        await printFailure(error, cwd);
+        return 1;
     }
     // Bind dry-run must compile and return before repository/cwd resolution or filesystem effects.
     if (parsed.command === "bind") {
@@ -309,9 +267,9 @@ export async function runCliCommand(tokens) {
             return await handleFailureAfterStdin({
                 error,
                 cwd,
-                cwdFlag: parsed.flags.cwd,
                 command: parsed.command,
                 stdin,
+                flags: parsed.flags,
                 saveStdin: !(parsed.command === "bind" && hasBindDomainFlags(parsed.flags)),
             });
         }
@@ -322,20 +280,20 @@ export async function runCliCommand(tokens) {
     }
     const success = !response.payload || !("error" in response.payload);
     if (success) {
-        writeSuccessResponse(parsed.command, parsed.flags, response);
+        await writeSuccessResponse(parsed.command, parsed.flags, response);
         return response.exitCode ?? 0;
     }
     if (commandRequiresStdin(parsed.command) || (parsed.command === "bind" && !parsed.flags.dryRun)) {
         return await handleFailureAfterStdin({
             response,
             cwd,
-            cwdFlag: parsed.flags.cwd,
             command: parsed.command,
             stdin,
+            flags: parsed.flags,
             saveStdin: !(parsed.command === "bind" && hasBindDomainFlags(parsed.flags)),
         });
     }
-    process.stderr.write(`${responseText(response)}\n`);
+    await writeCliOutput(process.stderr, `${responseText(response)}\n`);
     return 1;
 }
 export function renderCliCommandHelp(command) {

package/build/cli/missing-subcommand.js

@@ -0,0 +1,7 @@
+import { FlowError } from "../flow-error.js";
+export function formatSubcommandList(subcommands) {
+    return subcommands.length < 2 ? (subcommands[0] ?? "") : `${subcommands.slice(0, -1).join(", ")} or ${subcommands.at(-1)}`;
+}
+export function missingSubcommandError(name, subcommands) {
+    return new FlowError("EMPTY_PARAM", `${name} requires subcommand: ${formatSubcommandList(subcommands)}`);
+}

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

@@ -1,3 +1,21 @@
+export function isBrokenPipeError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === "EPIPE");
+}
+/** Resolve only after Node reports that this chunk has been flushed. */
+export function writeCliOutput(stream, chunk) {
+    return new Promise((resolve, reject) => {
+        stream.write(chunk, (error) => {
+            if (error && !isBrokenPipeError(error)) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
+}
 /**
  * Install a process-level broken-pipe policy on each supplied stream.
  * EPIPE is silent; every other emitted value is rethrown unchanged.
@@ -5,12 +23,8 @@
 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") {
+            if (isBrokenPipeError(error))
                 return;
-            }
             throw error;
         });
     }

package/build/cli/parse-flags.js

@@ -1,5 +1,5 @@
 import { FlowError } from "../flow-error.js";
-import { getCommandMetadata } from "./commands/registry.js";
+import { getCommandMetadata } from "./commands/metadata.js";
 import { BOOLEAN_FLAGS, CONTROL_FLAGS, SHORT_FLAG_ALIASES, VALUE_FLAGS, } from "./flags.js";
 import { normalizeContractAddress, parseWaitTimeout } from "./parse-metadata.js";
 function allowedFlagsForParse(command) {
@@ -85,10 +85,7 @@ export function assignFlag(flags, name, value) {
             flags.bindChecks = String(value);
             return;
         case "task":
-            if (flags.bindTaskId !== undefined) {
-                throw new FlowError("EMPTY_PARAM", "option --task may only be specified once");
-            }
-            flags.bindTaskId = String(value);
+            flags.bindTaskIds = [...(flags.bindTaskIds ?? []), String(value)];
             return;
         case "after":
             flags.after = [...(flags.after ?? []), String(value)];
@@ -102,8 +99,17 @@ export function assignFlag(flags, name, value) {
         case "dry-run":
             flags.dryRun = Boolean(value);
             return;
-        case "waive":
-            flags.waivePaths = [...(flags.waivePaths ?? []), String(value)];
+        case "append-scope":
+            flags.appendScope = [...(flags.appendScope ?? []), String(value)];
+            return;
+        case "resolve":
+            flags.renewResolve = Boolean(value);
+            return;
+        case "continue":
+            flags.renewContinue = Boolean(value);
+            return;
+        case "abort":
+            flags.renewAbort = Boolean(value);
             return;
         case "shell":
             flags.shell = String(value);
@@ -120,6 +126,9 @@ export function assignFlag(flags, name, value) {
         case "all":
             flags.all = Boolean(value);
             return;
+        case "any":
+            flags.any = Boolean(value);
+            return;
         case "target":
             if (flags.target !== undefined) {
                 throw new FlowError("EMPTY_PARAM", "option --target may only be specified once");
@@ -129,9 +138,26 @@ export function assignFlag(flags, name, value) {
         case "json":
             flags.json = Boolean(value);
             return;
+        case "diff-budget": {
+            const parsed = Number(String(value));
+            if (!Number.isSafeInteger(parsed) || parsed < 0) {
+                throw new FlowError("EMPTY_PARAM", "option --diff-budget requires a non-negative safe integer byte count");
+            }
+            flags.auditDiffBudgetBytes = parsed;
+            return;
+        }
         case "done":
             flags.done = Boolean(value);
             return;
+        case "filter":
+            flags.taskFilters = [...(flags.taskFilters ?? []), String(value)];
+            return;
+        case "sort":
+            if (flags.taskSort !== undefined) {
+                throw new FlowError("EMPTY_PARAM", "option --sort may only be specified once");
+            }
+            flags.taskSort = String(value);
+            return;
         case "pri": {
             const raw = String(value);
             if (!/^[0-3]$/.test(raw)) {

package/build/cli/parse-metadata.js

@@ -1,6 +1,6 @@
 import { FlowError } from "../flow-error.js";
 import { HELP_FLAGS, SHORT_FLAG_ALIASES, VALUE_FLAGS } from "./flags.js";
-import { commandParseOrder, getCommandMetadata } from "./commands/registry.js";
+import { commandParseOrder } from "./commands/metadata.js";
 import { TASK_SUBCOMMANDS } from "./types.js";
 export function normalizeContractAddress(raw) {
     const value = raw.startsWith("@") ? raw.slice(1) : raw;
@@ -42,9 +42,6 @@ export function isPetitionDryRunInvocation(tokens) {
     }
     return false;
 }
-export function commandUsesPromptInput(command) {
-    return isCallCommand(command) || command === "tell" || command === "revive";
-}
 export function parseWaitTimeout(value) {
     const matched = /^(?<amount>[1-9][0-9]*)(?<unit>[smh])$/.exec(value);
     if (!matched?.groups) {
@@ -75,7 +72,7 @@ export function commandPositionalRange(command) {
         return { min: 1, max: 2, label: "<ARTIFACT> [BODY|-]" };
     }
     if (command === "wait") {
-        return { min: 1, max: 1, label: "<projection-address>" };
+        return { min: 0, max: Number.MAX_SAFE_INTEGER, label: "<projection-address>" };
     }
     if (command === "kill") {
         return { min: 1, max: 1, label: "<projection-address>" };
@@ -86,7 +83,7 @@ export function commandPositionalRange(command) {
     if (command === "task add") {
         return { min: 1, max: 1, label: "<BODY|->" };
     }
-    if (command === "task view" || command === "task start" || command === "task drop") {
+    if (command === "task show" || command === "task start" || command === "task drop") {
         return { min: 1, max: 1, label: "<ID>" };
     }
     if (command === "task update") {
@@ -97,9 +94,6 @@ export function commandPositionalRange(command) {
     }
     return { min: 0, max: 0 };
 }
-export function commandRequiresStdin(command) {
-    return getCommandMetadata(command).stdin === "required";
-}
 export function resolveCommand(tokens) {
     if (tokens[0] === "petition" && (tokens[1] === "claim" || tokens[1] === "forfeit")) {
         throw new FlowError("UNKNOWN_COMMAND", `unknown command: petition ${tokens[1]}`);

package/build/cli/parse-selectors.js

@@ -12,6 +12,7 @@ const COMMISSION_SELECTOR_COMMANDS = new Set([
     "renew",
     "petition",
     "forfeit",
+    "audit",
 ]);
 function formatSelectorList(items) {
     if (items.length <= 1) {
@@ -56,7 +57,7 @@ export function assertProjectionSelectorPresent(command, flags, atTokens, contra
         ? atTokens[0] ?? `@${flags.contractId}`
         : `--contract ${contractFlagRaws[0] ?? flags.contractId}`;
     const message = `${command} requires a projection id or alias; ${selectorSpelling} only limits projection lookup, so add the projection address`;
-    if (command === "wait" && restLength + payloadLength === 0) {
+    if (command === "wait" && restLength + payloadLength === 0 && !flags.any && !flags.all) {
         throw new FlowError("EMPTY_PARAM", message);
     }
     if (command === "tell" && restLength === 0) {

package/build/cli/parse.js

@@ -2,10 +2,12 @@ import { FlowError } from "../flow-error.js";
 import { agentNameSchema } from "../config/settings/schema.js";
 import { isResponseArtifactId } from "../core/response-artifact-id.js";
 import { HELP_FLAGS } from "./flags.js";
+import { getCommandMetadata } from "./commands/metadata.js";
 import { assertAllowedFlag, assignFlag, BOOLEAN_FLAGS, CONTROL_FLAGS, parseFlagName, readValueFlag, SHORT_FLAG_ALIASES, VALUE_FLAGS, } from "./parse-flags.js";
-import { commandPositionalRange, commandRequiresStdin, isCallCommand, resolveCommand, splitAtLiteralBoundary, TASK_SUBCOMMANDS, } from "./parse-metadata.js";
+import { commandPositionalRange, isCallCommand, resolveCommand, splitAtLiteralBoundary, TASK_SUBCOMMANDS, } from "./parse-metadata.js";
 import { applyCommissionSelector, assertCommissionSelectorAllowed, assertProjectionSelectorPresent, } from "./parse-selectors.js";
-export { commandPositionalRange, commandUsesPromptInput, isCallCommand, isPetitionDryRunInvocation, normalizeContractAddress, parseWaitTimeout, } from "./parse-metadata.js";
+import { WAIT_SET_SELECTION_ERROR } from "./commands/projection/wait/meta.js";
+export { commandPositionalRange, isCallCommand, isPetitionDryRunInvocation, normalizeContractAddress, parseWaitTimeout, } from "./parse-metadata.js";
 export function parseCliArgs(tokens) {
     const { head, payload } = splitAtLiteralBoundary(tokens);
     const flags = {};
@@ -120,6 +122,9 @@ export function parseCliArgs(tokens) {
     if (command === "task ls" && flags.all && flags.done) {
         throw new FlowError("EMPTY_PARAM", "task ls cannot combine --all and --done");
     }
+    if (command === "wait" && flags.any && flags.all) {
+        throw new FlowError("EMPTY_PARAM", WAIT_SET_SELECTION_ERROR);
+    }
     if (command === "task update" && flags.taskParent !== undefined && flags.taskNoParent) {
         throw new FlowError("EMPTY_PARAM", "task update cannot combine --parent and --no-parent");
     }
@@ -131,9 +136,29 @@ export function parseCliArgs(tokens) {
     if (command === "petition" && flags.json && !flags.dryRun) {
         throw new FlowError("EMPTY_PARAM", "petition --json requires --dry-run");
     }
+    if (command === "petition" && flags.dryRun && (flags.appendScope?.length ?? 0) > 0) {
+        throw new FlowError("EMPTY_PARAM", "petition --dry-run does not accept --append-scope");
+    }
+    if (command === "renew") {
+        const recoveryModes = [flags.renewResolve, flags.renewContinue, flags.renewAbort].filter(Boolean).length;
+        if (recoveryModes > 1) {
+            throw new FlowError("EMPTY_PARAM", "renew accepts only one of --resolve, --continue, or --abort");
+        }
+        if (flags.renewAbort && (flags.appendScope?.length ?? 0) > 0) {
+            throw new FlowError("EMPTY_PARAM", "renew --abort does not accept --append-scope");
+        }
+    }
     assertCommissionSelectorAllowed(command, flags);
     assertProjectionSelectorPresent(command, flags, atTokens, contractFlagRaws, rest.length, payload.length);
     const positional = [...rest, ...payload];
+    if (command === "wait") {
+        if (positional.length === 0 && !flags.contractId) {
+            throw new FlowError("EMPTY_PARAM", "wait requires <projection-address>");
+        }
+        if (positional.length > 1 && !flags.any && !flags.all) {
+            throw new FlowError("EMPTY_PARAM", WAIT_SET_SELECTION_ERROR);
+        }
+    }
     if (isCallCommand(command)) {
         if (flags.akuma) {
             if (positional.length > 1) {
@@ -163,9 +188,14 @@ export function parseCliArgs(tokens) {
     if (positional.length < positionalRange.min) {
         throw new FlowError("EMPTY_PARAM", `${command} requires ${positionalRange.label ?? "an argument"}`);
     }
-    if (positional.length > positionalRange.max) {
-        const message = commandRequiresStdin(command)
-            ? `${command} reads Markdown from stdin; file path arguments are not supported`
+    const stdin = getCommandMetadata(command).stdin;
+    const documentStdinSelector = stdin.mode === "document"
+        && stdin.selector.kind === "positional"
+        && positional.length === stdin.selector.index + 1
+        && positional[stdin.selector.index] === "-";
+    if (positional.length > positionalRange.max && !documentStdinSelector) {
+        const message = stdin.mode === "document"
+            ? `${command} reads Markdown only through literal '-'; file path arguments are not supported`
             : `${command} does not accept positional arguments`;
         throw new FlowError("EMPTY_PARAM", message);
     }