@astrosheep/keiyaku 2.9.11 → 2.9.13

package/build/cli/parse-flags.js

@@ -11,7 +11,7 @@ export function parseFlagName(raw) {
 }
 export function assertAllowedFlag(command, name) {
     if (!allowedFlagsForParse(command).includes(name)) {
-        throw new FlowError("EMPTY_PARAM", `option --${name} is not valid for ${command}`);
+        throw new FlowError("UNKNOWN_OPTION", `option --${name} is not valid for ${command}`);
     }
 }
 export function assignFlag(flags, name, value) {
@@ -65,43 +65,40 @@ export function assignFlag(flags, name, value) {
             return;
         case "place":
             if (flags.bindPlace !== undefined) {
-                throw new FlowError("EMPTY_PARAM", "option --place may only be specified once");
+                throw new FlowError("INVALID_USAGE", "option --place may only be specified once");
             }
             flags.bindPlace = String(value);
             return;
         case "objective":
             if (flags.bindObjective !== undefined) {
-                throw new FlowError("EMPTY_PARAM", "option --objective may only be specified once");
+                throw new FlowError("INVALID_USAGE", "option --objective may only be specified once");
             }
             flags.bindObjective = String(value);
             return;
         case "context":
             if (flags.bindContext !== undefined) {
-                throw new FlowError("EMPTY_PARAM", "option --context may only be specified once");
+                throw new FlowError("INVALID_USAGE", "option --context may only be specified once");
             }
             flags.bindContext = String(value);
             return;
         case "design":
             if (flags.bindDesign !== undefined) {
-                throw new FlowError("EMPTY_PARAM", "option --design may only be specified once");
+                throw new FlowError("INVALID_USAGE", "option --design may only be specified once");
             }
             flags.bindDesign = String(value);
             return;
         case "scope":
-            if (flags.bindScope !== undefined) {
-                throw new FlowError("EMPTY_PARAM", "option --scope may only be specified once");
-            }
-            flags.bindScope = String(value);
+            flags.bindScope = [...(flags.bindScope ?? []), String(value)];
             return;
         case "criteria":
             if (flags.bindCriteria !== undefined) {
-                throw new FlowError("EMPTY_PARAM", "option --criteria may only be specified once");
+                throw new FlowError("INVALID_USAGE", "option --criteria may only be specified once");
             }
             flags.bindCriteria = String(value);
             return;
         case "verification":
             if (flags.bindVerification !== undefined) {
-                throw new FlowError("EMPTY_PARAM", "option --verification may only be specified once");
+                throw new FlowError("INVALID_USAGE", "option --verification may only be specified once");
             }
             flags.bindVerification = String(value);
             return;
@@ -120,12 +117,18 @@ export function assignFlag(flags, name, value) {
         case "dry-run":
             flags.dryRun = Boolean(value);
             return;
+        case "check":
+            flags.check = Boolean(value);
+            return;
         case "append-scope":
             flags.appendScope = [...(flags.appendScope ?? []), String(value)];
             return;
         case "renew":
             flags.renewBeforePetition = Boolean(value);
             return;
+        case "audit":
+            flags.renewAudit = Boolean(value);
+            return;
         case "continue":
             flags.renewContinue = Boolean(value);
             return;
@@ -152,7 +155,7 @@ export function assignFlag(flags, name, value) {
             return;
         case "target":
             if (flags.target !== undefined) {
-                throw new FlowError("EMPTY_PARAM", "option --target may only be specified once");
+                throw new FlowError("INVALID_USAGE", "option --target may only be specified once");
             }
             flags.target = String(value);
             return;
@@ -162,11 +165,14 @@ export function assignFlag(flags, name, value) {
         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");
+                throw new FlowError("INVALID_USAGE", "option --diff-budget requires a non-negative safe integer byte count");
             }
             flags.auditDiffBudgetBytes = parsed;
             return;
         }
+        case "skip-diff-body":
+            flags.auditSkipDiffBody = Boolean(value);
+            return;
         case "done":
             flags.done = Boolean(value);
             return;
@@ -175,17 +181,44 @@ export function assignFlag(flags, name, value) {
             return;
         case "sort":
             if (flags.taskSort !== undefined) {
-                throw new FlowError("EMPTY_PARAM", "option --sort may only be specified once");
+                throw new FlowError("INVALID_USAGE", "option --sort may only be specified once");
             }
             flags.taskSort = String(value);
             return;
+        case "limit": {
+            const parsed = Number(String(value));
+            if (!Number.isSafeInteger(parsed) || parsed < 1) {
+                throw new FlowError("INVALID_USAGE", "option --limit requires a positive safe integer entry count");
+            }
+            flags.historyLimit = parsed;
+            return;
+        }
+        case "offset": {
+            const parsed = Number(String(value));
+            if (!Number.isSafeInteger(parsed) || parsed < 0) {
+                throw new FlowError("INVALID_USAGE", "option --offset requires a non-negative safe integer entry count");
+            }
+            flags.historyOffset = parsed;
+            return;
+        }
+        case "entry": {
+            const parsed = Number(String(value));
+            if (!Number.isSafeInteger(parsed) || parsed < 0) {
+                throw new FlowError("INVALID_USAGE", "option --entry requires a non-negative safe integer retained entry index");
+            }
+            flags.historyEntry = parsed;
+            return;
+        }
+        case "raw":
+            flags.historyRaw = Boolean(value);
+            return;
         case "pri": {
             const raw = String(value);
             if (!/^[0-3]$/.test(raw)) {
-                throw new FlowError("EMPTY_PARAM", "task priority must be an integer from 0 through 3");
+                throw new FlowError("INVALID_USAGE", "task priority must be an integer from 0 through 3");
             }
             if (flags.taskPri !== undefined) {
-                throw new FlowError("EMPTY_PARAM", "option --pri may only be specified once");
+                throw new FlowError("INVALID_USAGE", "option --pri may only be specified once");
             }
             flags.taskPri = Number(raw);
             return;
@@ -213,7 +246,7 @@ export function assignFlag(flags, name, value) {
             return;
         case "parent":
             if (flags.taskParent !== undefined) {
-                throw new FlowError("EMPTY_PARAM", "option --parent may only be specified once");
+                throw new FlowError("INVALID_USAGE", "option --parent may only be specified once");
             }
             flags.taskParent = String(value);
             return;
@@ -222,24 +255,30 @@ export function assignFlag(flags, name, value) {
             return;
         case "title":
             if (flags.taskTitle !== undefined) {
-                throw new FlowError("EMPTY_PARAM", "option --title may only be specified once");
+                throw new FlowError("INVALID_USAGE", "option --title may only be specified once");
             }
             flags.taskTitle = String(value);
             return;
         case "body":
             if (flags.taskBody !== undefined) {
-                throw new FlowError("EMPTY_PARAM", "option --body may only be specified once");
+                throw new FlowError("INVALID_USAGE", "option --body may only be specified once");
             }
             flags.taskBody = String(value);
             return;
         case "append":
             if (flags.taskAppend !== undefined) {
-                throw new FlowError("EMPTY_PARAM", "option --append may only be specified once");
+                throw new FlowError("INVALID_USAGE", "option --append may only be specified once");
             }
             flags.taskAppend = String(value);
             return;
+        case "note":
+            if (flags.taskNote !== undefined) {
+                throw new FlowError("INVALID_USAGE", "option --note may only be specified once");
+            }
+            flags.taskNote = String(value);
+            return;
         default:
-            throw new FlowError("EMPTY_PARAM", `unknown option: --${name}`);
+            throw new FlowError("UNKNOWN_OPTION", `unknown option: --${name}`);
     }
 }
 export function readValueFlag(name, token, eq, tokens, index) {

package/build/cli/parse-metadata.js

@@ -45,13 +45,13 @@ export function isPetitionDryRunInvocation(tokens) {
 export function parseWaitTimeout(value) {
     const matched = /^(?<amount>[1-9][0-9]*)(?<unit>[smh])$/.exec(value);
     if (!matched?.groups) {
-        throw new FlowError("EMPTY_PARAM", "wait timeout must use <positive integer><s|m|h>, for example 45s, 5m, or 2h (maximum 24h)");
+        throw new FlowError("INVALID_USAGE", "wait timeout must use <positive integer><s|m|h>, for example 45s, 5m, or 2h (maximum 24h)");
     }
     const amount = Number(matched.groups.amount);
     const multiplier = matched.groups.unit === "s" ? 1_000 : matched.groups.unit === "m" ? 60_000 : 3_600_000;
     const timeoutMs = amount * multiplier;
     if (!Number.isSafeInteger(timeoutMs) || timeoutMs > 24 * 3_600_000) {
-        throw new FlowError("EMPTY_PARAM", "wait timeout must use <positive integer><s|m|h>, for example 45s, 5m, or 2h (maximum 24h)");
+        throw new FlowError("INVALID_USAGE", "wait timeout must use <positive integer><s|m|h>, for example 45s, 5m, or 2h (maximum 24h)");
     }
     return timeoutMs;
 }
@@ -68,7 +68,7 @@ export function commandPositionalRange(command) {
     if (command === "tell") {
         return { min: 2, max: 2, label: "<PROJECTION> <BODY|->" };
     }
-    if (command === "revive") {
+    if (command === "fork") {
         return { min: 1, max: 2, label: "<ARTIFACT> [BODY|-]" };
     }
     if (command === "wait") {
@@ -84,11 +84,17 @@ export function commandPositionalRange(command) {
         return { min: 0, max: 1, label: "[projection|alias|rsp]" };
     }
     if (command === "task add") {
-        return { min: 1, max: 1, label: "<BODY|->" };
+        return { min: 1, max: 1, label: "<TITLE|->" };
+    }
+    if (command === "task compose") {
+        return { min: 0, max: 0 };
     }
     if (command === "task show" || command === "task log" || command === "task start" || command === "task hold" || command === "task resume" || command === "task drop") {
         return { min: 1, max: 1, label: "<ID>" };
     }
+    if (command === "task note") {
+        return { min: 2, max: 2, label: "<ID> <TEXT|->" };
+    }
     if (command === "task update") {
         return { min: 1, max: 1, label: "<ID>" };
     }

package/build/cli/parse-selectors.js

@@ -14,6 +14,21 @@ const COMMISSION_SELECTOR_COMMANDS = new Set([
     "petition",
     "forfeit",
     "audit",
+    "status",
+    "task add",
+    "task compose",
+    "task show",
+    "task ls",
+    "task log",
+    "task start",
+    "task stop",
+    "task hold",
+    "task resume",
+    "task done",
+    "task note",
+    "task drop",
+    "task update",
+    "task doctor",
 ]);
 function formatSelectorList(items) {
     if (items.length <= 1) {
@@ -26,13 +41,13 @@ function formatSelectorList(items) {
 }
 export function applyCommissionSelector(command, flags, atTokens, contractFlagRaws) {
     if (atTokens.length > 0 && contractFlagRaws.length > 0) {
-        throw new FlowError("EMPTY_PARAM", `commission address supplied twice: ${atTokens[0]} and --contract ${contractFlagRaws[0]}; use exactly one form`);
+        throw new FlowError("INVALID_USAGE", `commission address supplied twice: ${atTokens[0]} and --contract ${contractFlagRaws[0]}; use exactly one form`);
     }
     if (atTokens.length > 1) {
-        throw new FlowError("EMPTY_PARAM", `${command} accepts one commission address; got ${formatSelectorList(atTokens)}`);
+        throw new FlowError("INVALID_USAGE", `${command} accepts one commission address; got ${formatSelectorList(atTokens)}`);
     }
     if (contractFlagRaws.length > 1) {
-        throw new FlowError("EMPTY_PARAM", `${command} accepts one commission address; got ${formatSelectorList(contractFlagRaws.map((raw) => `--contract ${raw}`))}`);
+        throw new FlowError("INVALID_USAGE", `${command} accepts one commission address; got ${formatSelectorList(contractFlagRaws.map((raw) => `--contract ${raw}`))}`);
     }
     if (atTokens.length === 1) {
         flags.contractId = normalizeContractAddress(atTokens[0]);
@@ -46,9 +61,12 @@ export function assertCommissionSelectorAllowed(command, flags) {
     if (flags.contractId === undefined || COMMISSION_SELECTOR_COMMANDS.has(command)) {
         return;
     }
-    throw new FlowError("EMPTY_PARAM", `contract address @${flags.contractId} is not valid for ${command}`);
+    throw new FlowError("INVALID_USAGE", `contract address @${flags.contractId} is not valid for ${command}`);
 }
 export function assertProjectionSelectorPresent(command, flags, atTokens, contractFlagRaws, restLength, payloadLength) {
+    if (command === "status" && flags.contractId !== undefined && restLength + payloadLength > 0) {
+        throw new FlowError("INVALID_USAGE", `status accepts either one projection id or one commission selector; ${flags.contractAddressSource === "at-address" ? atTokens[0] ?? `@${flags.contractId}` : `--contract ${contractFlagRaws[0] ?? flags.contractId}`} cannot be combined with a projection id`);
+    }
     if ((command !== "wait" && command !== "tell") || flags.contractId === undefined) {
         return;
     }

package/build/cli/parse.js

@@ -4,10 +4,13 @@ import { isResponseArtifactId } from "../core/response-artifact-id.js";
 import { isCommissionId } from "../core/ids.js";
 import { HELP_FLAGS } from "./flags.js";
 import { getCommandMetadata } from "./commands/metadata.js";
+import { AKUMA_SUBCOMMANDS } from "./types.js";
 import { assertAllowedFlag, assignFlag, BOOLEAN_FLAGS, CONTROL_FLAGS, parseFlagName, readValueFlag, SHORT_FLAG_ALIASES, VALUE_FLAGS, } from "./parse-flags.js";
 import { commandPositionalRange, isCallCommand, resolveCommand, splitAtLiteralBoundary, TASK_SUBCOMMANDS, } from "./parse-metadata.js";
 import { applyCommissionSelector, assertCommissionSelectorAllowed, assertProjectionSelectorPresent, } from "./parse-selectors.js";
 import { WAIT_SET_SELECTION_ERROR } from "./commands/projection/wait/meta.js";
+import { TASK_ADD_INPUT_SHAPE_ERROR } from "./commands/task/add/meta.js";
+import { TASK_UPDATE_EXPLICIT_CHANGE_ERROR } from "./commands/task/update/meta.js";
 export { commandPositionalRange, isCallCommand, isPetitionDryRunInvocation, normalizeContractAddress, parseWaitTimeout, } from "./parse-metadata.js";
 export function parseCliArgs(tokens) {
     const { head, payload } = splitAtLiteralBoundary(tokens);
@@ -31,7 +34,7 @@ export function parseCliArgs(tokens) {
             const short = token.slice(1);
             const name = SHORT_FLAG_ALIASES[short];
             if (!name) {
-                throw new FlowError("EMPTY_PARAM", `unknown option: ${token}`);
+                throw new FlowError("UNKNOWN_OPTION", `unknown option: ${token}`);
             }
             seenFlagNames.add(name);
             if (VALUE_FLAGS.has(name)) {
@@ -52,7 +55,7 @@ export function parseCliArgs(tokens) {
                 assignFlag(flags, name, true);
                 continue;
             }
-            throw new FlowError("EMPTY_PARAM", `unknown option: ${token}`);
+            throw new FlowError("UNKNOWN_OPTION", `unknown option: ${token}`);
         }
         if (!token.startsWith("--")) {
             free.push(token);
@@ -61,9 +64,17 @@ export function parseCliArgs(tokens) {
         const eq = token.indexOf("=");
         const name = parseFlagName(eq === -1 ? token : token.slice(0, eq));
         if (!CONTROL_FLAGS.has(name)) {
-            throw new FlowError("EMPTY_PARAM", `unknown option: --${name}`);
+            throw new FlowError("UNKNOWN_OPTION", `unknown option: --${name}`);
         }
         seenFlagNames.add(name);
+        // `--akuma` is a status-only collection selector. Elsewhere it remains
+        // the existing value-taking launch option.
+        if (name === "akuma" && head.includes("status")) {
+            if (eq !== -1)
+                throw new FlowError("INVALID_USAGE", "option --akuma does not accept a value for status");
+            flags.akumaRoster = true;
+            continue;
+        }
         if (VALUE_FLAGS.has(name)) {
             const { value, nextIndex } = readValueFlag(name, token, eq, head, index);
             index = nextIndex;
@@ -77,7 +88,7 @@ export function parseCliArgs(tokens) {
         }
         if (BOOLEAN_FLAGS.has(name)) {
             if (eq !== -1) {
-                throw new FlowError("EMPTY_PARAM", `option --${name} does not accept a value`);
+                throw new FlowError("INVALID_USAGE", `option --${name} does not accept a value`);
             }
             assignFlag(flags, name, true);
         }
@@ -103,7 +114,7 @@ export function parseCliArgs(tokens) {
         };
     }
     if (command === "akuma") {
-        throw new FlowError("EMPTY_PARAM", "akuma requires subcommand: ls or show");
+        throw new FlowError("EMPTY_PARAM", `akuma requires subcommand: ${AKUMA_SUBCOMMANDS.slice(0, -1).join(", ")} or ${AKUMA_SUBCOMMANDS.at(-1)}`);
     }
     if (command === "skills") {
         throw new FlowError("EMPTY_PARAM", "skills requires subcommand: install");
@@ -113,9 +124,9 @@ export function parseCliArgs(tokens) {
     }
     if (seenFlagNames.has("place")) {
         if (command === "bind") {
-            throw new FlowError("EMPTY_PARAM", "bind no longer accepts --place; use --title <text>");
+            throw new FlowError("UNKNOWN_OPTION", "bind no longer accepts --place; use --title <text>");
         }
-        throw new FlowError("EMPTY_PARAM", "unknown option --place; use @addr or --contract <addr>");
+        throw new FlowError("UNKNOWN_OPTION", "unknown option --place; use @addr or --contract <addr>");
     }
     for (const name of seenFlagNames) {
         assertAllowedFlag(command, name);
@@ -125,48 +136,48 @@ export function parseCliArgs(tokens) {
         delete flags.taskTitle;
     }
     if (command === "call" && flags.detach && flags.timeoutMs !== undefined) {
-        throw new FlowError("EMPTY_PARAM", "call cannot combine --detach and --wait");
+        throw new FlowError("INVALID_USAGE", "call cannot combine --detach and --wait");
     }
     if (command === "task ls" && flags.all && flags.done) {
-        throw new FlowError("EMPTY_PARAM", "task ls cannot combine --all and --done");
+        throw new FlowError("INVALID_USAGE", "task ls cannot combine --all and --done");
     }
     if (command === "wait" && flags.any && flags.all) {
-        throw new FlowError("EMPTY_PARAM", WAIT_SET_SELECTION_ERROR);
+        throw new FlowError("INVALID_USAGE", 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");
+        throw new FlowError("INVALID_USAGE", "task update cannot combine --parent and --no-parent");
     }
     if (command === "task update" && flags.taskBody !== undefined && flags.taskAppend !== undefined) {
-        throw new FlowError("EMPTY_PARAM", "task update cannot combine --body and --append");
+        throw new FlowError("INVALID_USAGE", "task update cannot combine --body and --append");
     }
     if (command === "task update" && flags.taskTitle === undefined && flags.taskBody === undefined && flags.taskAppend === undefined
         && flags.taskPri === undefined && flags.taskNeeds === undefined && flags.taskDropNeeds === undefined
         && flags.taskParent === undefined && !flags.taskNoParent && flags.taskFrom === undefined
         && flags.taskSupersedes === undefined && flags.taskDropSupersedes === undefined
         && flags.taskRelatesTo === undefined && flags.taskDropRelatesTo === undefined) {
-        throw new FlowError("EMPTY_PARAM", "task update requires at least one change");
+        throw new FlowError("INVALID_USAGE", TASK_UPDATE_EXPLICIT_CHANGE_ERROR);
     }
     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");
+        throw new FlowError("INVALID_USAGE", "petition --json requires --dry-run");
     }
     if (command === "renew") {
         const recoveryModes = [flags.renewContinue, flags.renewAbort].filter(Boolean).length;
         if (recoveryModes > 1) {
-            throw new FlowError("EMPTY_PARAM", "renew accepts only one of --continue or --abort");
+            throw new FlowError("INVALID_USAGE", "renew accepts only one of --continue or --abort");
         }
         if (flags.renewAbort && (flags.appendScope?.length ?? 0) > 0) {
-            throw new FlowError("EMPTY_PARAM", "renew --abort does not accept --append-scope");
+            throw new FlowError("INVALID_USAGE", "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 === "amend" && flags.appendScope && positional.length > 0 && positional[0] !== "-") {
+        throw new FlowError("INVALID_USAGE", "amend accepts Markdown only through literal '-' and --append-scope never reads unselected stdin");
+    }
     if (command === "bind" && flags.contractId !== undefined) {
         if (!isCommissionId(flags.contractId)) {
-            throw new FlowError("EMPTY_PARAM", `bind replay requires a full canonical contract id; got ${flags.contractId}`);
+            throw new FlowError("UNKNOWN_ADDRESS", `bind replay requires a full canonical contract id; got ${flags.contractId}`);
         }
         const hasReplayInput = positional.length > 0
             || flags.bindTaskIds !== undefined
@@ -182,7 +193,7 @@ export function parseCliArgs(tokens) {
             || flags.bindCriteria !== undefined
             || flags.bindVerification !== undefined;
         if (hasReplayInput) {
-            throw new FlowError("EMPTY_PARAM", "addressed bind is replay-only and accepts no draft or creation input");
+            throw new FlowError("INVALID_USAGE", "addressed bind is replay-only and accepts no draft or creation input");
         }
     }
     if (command === "wait") {
@@ -190,13 +201,13 @@ export function parseCliArgs(tokens) {
             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);
+            throw new FlowError("INVALID_USAGE", WAIT_SET_SELECTION_ERROR);
         }
     }
     if (isCallCommand(command)) {
         if (flags.akuma) {
             if (positional.length > 1) {
-                throw new FlowError("EMPTY_PARAM", `${command} accepts at most one <BODY|-> when --akuma is used`);
+                throw new FlowError("INVALID_USAGE", `${command} accepts at most one <BODY|-> when --akuma is used`);
             }
         }
         else {
@@ -205,16 +216,16 @@ export function parseCliArgs(tokens) {
                 throw new FlowError("EMPTY_PARAM", `${command} requires an agent name; use \`keiyaku ${command} NAME <BODY|->\``);
             }
             if (isResponseArtifactId(name)) {
-                throw new FlowError("EMPTY_PARAM", `artifact ${name} is a response artifact; call expects an Akuma profile name`);
+                throw new FlowError("UNKNOWN_ADDRESS", `artifact ${name} is a response artifact; call expects an Akuma profile name`);
             }
             const parsedName = agentNameSchema.safeParse(name);
             if (!parsedName.success) {
-                throw new FlowError("EMPTY_PARAM", `${command} requires a valid agent name before <BODY|->`);
+                throw new FlowError("UNKNOWN_ADDRESS", `${command} requires a valid agent name before <BODY|->`);
             }
             flags.akuma = parsedName.data;
             positional.shift();
             if (positional.length > 1) {
-                throw new FlowError("EMPTY_PARAM", `${command} accepts at most one <BODY|-> after the agent name`);
+                throw new FlowError("INVALID_USAGE", `${command} accepts at most one <BODY|-> after the agent name`);
             }
         }
     }
@@ -228,10 +239,12 @@ export function parseCliArgs(tokens) {
         && 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);
+        const message = command === "task add"
+            ? TASK_ADD_INPUT_SHAPE_ERROR
+            : stdin.mode === "document"
+                ? `${command} reads Markdown only through literal '-'; file path arguments are not supported`
+                : `${command} does not accept positional arguments`;
+        throw new FlowError("INVALID_USAGE", message);
     }
     return { command, flags, positional };
 }

package/build/cli/projection-address.js

@@ -56,7 +56,7 @@ export async function resolveProjectionAddress(input) {
         });
     }
     if (isResponseArtifactId(input.address)) {
-        throw new AddressResolutionError("EMPTY_PARAM", `artifact ${input.address} is a response artifact; ${input.verb} expects a projection id or alias`, { ...attempt, actual: "artifact" });
+        throw new AddressResolutionError("UNKNOWN_ADDRESS", `artifact ${input.address} is a response artifact; ${input.verb} expects a projection id or alias`, { ...attempt, actual: "artifact" });
     }
     const suffix = input.scope
         ? `within ${input.scope.spelling.asTyped}`
@@ -65,22 +65,22 @@ export async function resolveProjectionAddress(input) {
     let alias;
     if (input.address.includes("/")) {
         if (!isProjectionId(input.address))
-            throw new AddressResolutionError("EMPTY_PARAM", `projection ${input.address} has no match ${suffix}`, attempt);
+            throw new AddressResolutionError("UNKNOWN_ADDRESS", `projection ${input.address} has no match ${suffix}`, attempt);
         id = input.address;
     }
     else {
         if (!isProjectionAlias(input.address))
-            throw new AddressResolutionError("EMPTY_PARAM", `projection alias ${input.address} has no match ${suffix}`, attempt);
+            throw new AddressResolutionError("UNKNOWN_ADDRESS", `projection alias ${input.address} has no match ${suffix}`, attempt);
         const target = await readProjectionAliasAtRoot(projectionAliasRootAtCoordinate(coordinate), input.address);
         if (!target)
-            throw new AddressResolutionError("EMPTY_PARAM", `projection alias ${input.address} has no match ${suffix}`, attempt);
+            throw new AddressResolutionError("UNKNOWN_ADDRESS", `projection alias ${input.address} has no match ${suffix}`, attempt);
         id = target;
         alias = input.address;
     }
     const directory = projectionDirAtCoordinate(coordinate, id);
     if (!isRealDirectory(directory)) {
         const subject = alias ? `projection alias ${alias} points to missing projection ${id}` : `projection ${id}`;
-        throw new AddressResolutionError("EMPTY_PARAM", `${subject} has no match ${suffix}`, attempt);
+        throw new AddressResolutionError("UNKNOWN_ADDRESS", `${subject} has no match ${suffix}`, attempt);
     }
     // Historical projection storage has no current identity to resolve. Tell
     // still reaches its typed no-mutation refusal instead of exposing storage
@@ -94,12 +94,12 @@ export async function resolveProjectionAddress(input) {
     catch (error) {
         if (error instanceof Error && /ENOENT|no such file/i.test(error.message)) {
             const subject = alias ? `projection alias ${alias} points to missing projection ${id}` : `projection ${id}`;
-            throw new AddressResolutionError("EMPTY_PARAM", `${subject} has no match ${suffix}`, attempt);
+            throw new AddressResolutionError("UNKNOWN_ADDRESS", `${subject} has no match ${suffix}`, attempt);
         }
         throw error;
     }
     if (input.scope && (identity.binding.kind !== "commission" || identity.binding.commissionId !== input.scope.binding.commissionId)) {
-        throw new AddressResolutionError("EMPTY_PARAM", `projection ${id} has no match ${suffix}`, attempt);
+        throw new AddressResolutionError("UNKNOWN_ADDRESS", `projection ${id} has no match ${suffix}`, attempt);
     }
     return { id, directory, ...(alias ? { alias } : {}) };
 }

package/build/cli/render/arc.js

@@ -15,12 +15,19 @@ function sealLines(result) {
         `fence ${result.sealed.oldFence.slice(0, 7)}▸${result.sealed.newFence.slice(0, 7)}`,
     ];
 }
+function scopeWarnings(sealed) {
+    const violations = sealed?.scopeAudit.violations ?? [];
+    return violations.length === 0 ? [] : [`Scope warning: ${violations.join(", ")}`];
+}
 export function buildArcResponse(result) {
     const { status: _status, address: _address, ...resultData } = result;
     const diff = renderSealDiffSection(result.sealed, "working tree untouched");
     const payload = { ...resultData, diff };
     const summarySection = buildSection(CONTENT_SECTION_TITLE, sealLines(result));
-    const warningSection = buildSection(WARNING_SECTION_TITLE, formatWarnings(result.meta?.warnings ?? []));
+    const warningSection = buildSection(WARNING_SECTION_TITLE, [
+        ...scopeWarnings(result.sealed),
+        ...formatWarnings(result.meta?.warnings ?? []),
+    ]);
     const hintsSection = buildSection(HINTS_SECTION_TITLE, formatHints(result.meta?.hints ?? [], { maxItems: HINTS_LIST_MAX_ITEMS }));
     const infoSection = buildSection(INFO_SECTION_TITLE, [
         ...formatMaybe("Title", result.title),
@@ -46,7 +53,10 @@ export function buildRenewResponse(result) {
         ...formatMaybe("Ledger Head", result.ledgerHead, INFO_COMMIT_MAX_CHARS),
         ...formatList("Seal", sealLines(result)),
     ]);
-    const warningSection = buildSection(WARNING_SECTION_TITLE, formatWarnings(result.meta?.warnings ?? []));
+    const warningSection = buildSection(WARNING_SECTION_TITLE, [
+        ...scopeWarnings(result.sealed),
+        ...formatWarnings(result.meta?.warnings ?? []),
+    ]);
     return prependAddressReceipt({
         text: assembleResponse(`${RESPONSE_MARKERS.arc} Renewed`, appendPersistenceSummary(result.summary, result.responsePath), [buildSection(CONTENT_SECTION_TITLE, diff), infoSection, warningSection].filter((section) => section !== null)),
         payload: buildPayload(payload, result.responsePath),
@@ -55,7 +65,6 @@ export function buildRenewResponse(result) {
 export function buildRenewAbortResponse(result) {
     const payload = {
         contractId: result.contractId,
-        oldHead: result.oldHead,
         scratchName: result.scratchName,
         summary: result.summary,
     };

package/build/cli/render/audit.js

@@ -120,7 +120,7 @@ function renderChanges(report) {
         `${report.diff.stat.filesChanged} files · +${report.diff.stat.insertions} -${report.diff.stat.deletions}`,
     ];
     if (outside.length > 0) {
-        lines.push("", "Outside declared write set", "");
+        lines.push("", "Scope warning · Outside declared write set", "");
         for (const file of outside) {
             lines.push(...renderFileBlock(file, report), "");
         }
@@ -231,7 +231,7 @@ function renderVerificationResults(report) {
     }
     const labels = report.verification.results.map((result) => result.label);
     const width = Math.max(8, ...labels.map((label) => label.length));
-    const lines = [];
+    const lines = [`  run ${report.verification.runId}`];
     const groups = ["contract", "repository-gate"];
     for (const source of groups) {
         const results = report.verification.results.filter((result) => result.source === source);

package/build/cli/render/call.js

@@ -9,9 +9,9 @@ export function renderAdoptedLaunchReceipt(address, projectionId, alias, previou
             ...(alias ? { projectionAlias: alias } : {}),
             ...(akumaName ? { akumaName } : {}),
         }),
-        ...(alias ? [`alias ${alias} → ${projectionId}`] : []),
+        `${projectionId}${alias ? ` (${alias})` : ""} launched.`,
         ...(alias && previousAliasTarget ? [`(moved from ${previousAliasTarget}, still running)`] : []),
-        ...projectionRejoinHintLines(alias ?? projectionId),
+        ...projectionRejoinHintLines(projectionId),
     ].join("\n");
 }
 export function buildCallResponse(result, input) {
@@ -24,8 +24,8 @@ export function buildCallResponse(result, input) {
             text: input.addressPlacement === "stdout"
                 ? renderAdoptedLaunchReceipt(result.address, result.projection.id, result.projection.alias, result.projection.previousAliasTarget, result.agent ?? input.agent)
                 : [
-                    ...(result.projection.alias ? [`alias ${result.projection.alias} → ${result.projection.id}`] : []),
-                    ...projectionRejoinHintLines(result.projection.alias ?? result.projection.id),
+                    `${result.projection.id}${result.projection.alias ? ` (${result.projection.alias})` : ""} launched.`,
+                    ...projectionRejoinHintLines(result.projection.id),
                 ].join("\n"),
             payload: buildPayload(payload),
         };