@astrosheep/keiyaku 4.6.4 → 4.6.6

package/build/src/akuma/selection-observation.d.ts

@@ -125,8 +125,8 @@ declare const akumaObservationSchema: z.ZodObject<{
                         }>;
                         turnSequence: z.ZodNumber;
                         receipt: z.ZodOptional<z.ZodEnum<{
-                            required: "required";
                             unavailable: "unavailable";
+                            required: "required";
                         }>>;
                     }, z.core.$strict>, z.ZodTransform<Readonly<{
                         turnSequence: number;
@@ -137,7 +137,7 @@ declare const akumaObservationSchema: z.ZodObject<{
                         deliveredAt: string;
                         route: "live" | "launch";
                         turnSequence: number;
-                        receipt?: "required" | "unavailable" | undefined;
+                        receipt?: "unavailable" | "required" | undefined;
                     }>>>>;
                 }, z.core.$strict>]>, z.ZodObject<{
                     kind: z.ZodLiteral<"tool">;
@@ -332,8 +332,8 @@ declare const akumaObservationSchema: z.ZodObject<{
                         }>;
                         turnSequence: z.ZodNumber;
                         receipt: z.ZodOptional<z.ZodEnum<{
-                            required: "required";
                             unavailable: "unavailable";
+                            required: "required";
                         }>>;
                     }, z.core.$strict>, z.ZodTransform<Readonly<{
                         turnSequence: number;
@@ -344,7 +344,7 @@ declare const akumaObservationSchema: z.ZodObject<{
                         deliveredAt: string;
                         route: "live" | "launch";
                         turnSequence: number;
-                        receipt?: "required" | "unavailable" | undefined;
+                        receipt?: "unavailable" | "required" | undefined;
                     }>>>>;
                 }, z.core.$strict>]>, z.ZodObject<{
                     kind: z.ZodLiteral<"tool">;
@@ -589,8 +589,8 @@ declare const akumaWaitResultSchema: z.ZodObject<{
                             }>;
                             turnSequence: z.ZodNumber;
                             receipt: z.ZodOptional<z.ZodEnum<{
-                                required: "required";
                                 unavailable: "unavailable";
+                                required: "required";
                             }>>;
                         }, z.core.$strict>, z.ZodTransform<Readonly<{
                             turnSequence: number;
@@ -601,7 +601,7 @@ declare const akumaWaitResultSchema: z.ZodObject<{
                             deliveredAt: string;
                             route: "live" | "launch";
                             turnSequence: number;
-                            receipt?: "required" | "unavailable" | undefined;
+                            receipt?: "unavailable" | "required" | undefined;
                         }>>>>;
                     }, z.core.$strict>]>, z.ZodObject<{
                         kind: z.ZodLiteral<"tool">;
@@ -796,8 +796,8 @@ declare const akumaWaitResultSchema: z.ZodObject<{
                             }>;
                             turnSequence: z.ZodNumber;
                             receipt: z.ZodOptional<z.ZodEnum<{
-                                required: "required";
                                 unavailable: "unavailable";
+                                required: "required";
                             }>>;
                         }, z.core.$strict>, z.ZodTransform<Readonly<{
                             turnSequence: number;
@@ -808,7 +808,7 @@ declare const akumaWaitResultSchema: z.ZodObject<{
                             deliveredAt: string;
                             route: "live" | "launch";
                             turnSequence: number;
-                            receipt?: "required" | "unavailable" | undefined;
+                            receipt?: "unavailable" | "required" | undefined;
                         }>>>>;
                     }, z.core.$strict>]>, z.ZodObject<{
                         kind: z.ZodLiteral<"tool">;
@@ -958,8 +958,8 @@ declare const akumaTellResultSchema: z.ZodObject<{
                 }>;
                 turnSequence: z.ZodNumber;
                 receipt: z.ZodOptional<z.ZodEnum<{
-                    required: "required";
                     unavailable: "unavailable";
+                    required: "required";
                 }>>;
             }, z.core.$strict>, z.ZodTransform<Readonly<{
                 turnSequence: number;
@@ -970,7 +970,7 @@ declare const akumaTellResultSchema: z.ZodObject<{
                 deliveredAt: string;
                 route: "live" | "launch";
                 turnSequence: number;
-                receipt?: "required" | "unavailable" | undefined;
+                receipt?: "unavailable" | "required" | undefined;
             }>>>>;
         }, z.core.$strict>;
         wake: z.ZodUnion<readonly [z.ZodObject<{
@@ -1062,8 +1062,8 @@ declare const akumaAskResultSchema: z.ZodObject<{
                 }>;
                 turnSequence: z.ZodNumber;
                 receipt: z.ZodOptional<z.ZodEnum<{
-                    required: "required";
                     unavailable: "unavailable";
+                    required: "required";
                 }>>;
             }, z.core.$strict>, z.ZodTransform<Readonly<{
                 turnSequence: number;
@@ -1074,7 +1074,7 @@ declare const akumaAskResultSchema: z.ZodObject<{
                 deliveredAt: string;
                 route: "live" | "launch";
                 turnSequence: number;
-                receipt?: "required" | "unavailable" | undefined;
+                receipt?: "unavailable" | "required" | undefined;
             }>>>>;
         }, z.core.$strict>;
         wake: z.ZodUnion<readonly [z.ZodObject<{
@@ -1301,8 +1301,8 @@ export declare const selectionResultSchemas: {
                                 }>;
                                 turnSequence: z.ZodNumber;
                                 receipt: z.ZodOptional<z.ZodEnum<{
-                                    required: "required";
                                     unavailable: "unavailable";
+                                    required: "required";
                                 }>>;
                             }, z.core.$strict>, z.ZodTransform<Readonly<{
                                 turnSequence: number;
@@ -1313,7 +1313,7 @@ export declare const selectionResultSchemas: {
                                 deliveredAt: string;
                                 route: "live" | "launch";
                                 turnSequence: number;
-                                receipt?: "required" | "unavailable" | undefined;
+                                receipt?: "unavailable" | "required" | undefined;
                             }>>>>;
                         }, z.core.$strict>]>, z.ZodObject<{
                             kind: z.ZodLiteral<"tool">;
@@ -1508,8 +1508,8 @@ export declare const selectionResultSchemas: {
                                 }>;
                                 turnSequence: z.ZodNumber;
                                 receipt: z.ZodOptional<z.ZodEnum<{
-                                    required: "required";
                                     unavailable: "unavailable";
+                                    required: "required";
                                 }>>;
                             }, z.core.$strict>, z.ZodTransform<Readonly<{
                                 turnSequence: number;
@@ -1520,7 +1520,7 @@ export declare const selectionResultSchemas: {
                                 deliveredAt: string;
                                 route: "live" | "launch";
                                 turnSequence: number;
-                                receipt?: "required" | "unavailable" | undefined;
+                                receipt?: "unavailable" | "required" | undefined;
                             }>>>>;
                         }, z.core.$strict>]>, z.ZodObject<{
                             kind: z.ZodLiteral<"tool">;
@@ -1657,8 +1657,8 @@ export declare const selectionResultSchemas: {
                     }>;
                     turnSequence: z.ZodNumber;
                     receipt: z.ZodOptional<z.ZodEnum<{
-                        required: "required";
                         unavailable: "unavailable";
+                        required: "required";
                     }>>;
                 }, z.core.$strict>, z.ZodTransform<Readonly<{
                     turnSequence: number;
@@ -1669,7 +1669,7 @@ export declare const selectionResultSchemas: {
                     deliveredAt: string;
                     route: "live" | "launch";
                     turnSequence: number;
-                    receipt?: "required" | "unavailable" | undefined;
+                    receipt?: "unavailable" | "required" | undefined;
                 }>>>>;
             }, z.core.$strict>;
             wake: z.ZodUnion<readonly [z.ZodObject<{
@@ -1746,8 +1746,8 @@ export declare const selectionResultSchemas: {
                     }>;
                     turnSequence: z.ZodNumber;
                     receipt: z.ZodOptional<z.ZodEnum<{
-                        required: "required";
                         unavailable: "unavailable";
+                        required: "required";
                     }>>;
                 }, z.core.$strict>, z.ZodTransform<Readonly<{
                     turnSequence: number;
@@ -1758,7 +1758,7 @@ export declare const selectionResultSchemas: {
                     deliveredAt: string;
                     route: "live" | "launch";
                     turnSequence: number;
-                    receipt?: "required" | "unavailable" | undefined;
+                    receipt?: "unavailable" | "required" | undefined;
                 }>>>>;
             }, z.core.$strict>;
             wake: z.ZodUnion<readonly [z.ZodObject<{

package/build/src/akuma-body.js

@@ -62,6 +62,7 @@ function contractUpstream(processConfiguration) {
             return await contractChannel(repo, input.contractId, input.requester, configuration).review({
                 verdict: input.verdict,
                 ...(input.summary === undefined ? {} : { summary: input.summary }),
+                ...(input.actor === undefined ? {} : { actor: input.actor }),
                 signal: input.signal,
             }, input.observe === undefined ? undefined : { observe: input.observe });
         },

package/build/src/alias/index.d.ts

@@ -11,7 +11,6 @@ export type AliasMove = Readonly<{
 }>;
 export declare function nukeAliases(world: WorldRoot): Promise<void>;
 export declare function readAliases(world: WorldRoot): Promise<readonly AliasBinding[]>;
-export declare function resolveAlias(world: WorldRoot, value: AkumaAlias): Promise<AkuId | null>;
 export declare function moveAlias(input: Readonly<{
     world: WorldRoot;
     alias: AkumaAlias;

package/build/src/alias/index.js

@@ -113,10 +113,6 @@ export async function nukeAliases(world) {
 export async function readAliases(world) {
     return await read(paths(world).authority);
 }
-export async function resolveAlias(world, value) {
-    const alias = parseReadableAkumaAlias(value);
-    return (await readAliases(world)).find((binding) => binding.alias === alias)?.akuId ?? null;
-}
 export async function moveAlias(input) {
     const alias = parseAkumaAlias(input.alias);
     const akuId = parseAkuId(input.akuId).id;

package/build/src/body/amend.d.ts

@@ -1,8 +1,4 @@
 import type { DecodedContractDocument } from "./types.js";
-export declare function applyAmendDocument(source: string, current: DecodedContractDocument): Readonly<{
-    document: string;
-    changedSections: ReadonlySet<string>;
-}>;
 /** Caller syntax is decoded before any repository observation; current-dependent application stays pure. */
 export declare function prepareAmendDocument(source: string): (current: DecodedContractDocument) => Readonly<{
     document: string;

package/build/src/body/amend.js

@@ -239,9 +239,6 @@ function apply(document, operations, current) {
     }
     return { body: completeBody(body), changed };
 }
-export function applyAmendDocument(source, current) {
-    return prepareAmendDocument(source)(current);
-}
 /** Caller syntax is decoded before any repository observation; current-dependent application stays pure. */
 export function prepareAmendDocument(source) {
     const document = parseToAST(source);

package/build/src/body/region.d.ts

@@ -17,4 +17,3 @@ export declare function decodeRegionOrRefusal(document: DocumentNode, section: S
 export type RegionRelation = "same" | "mine-within-theirs" | "theirs-within-mine" | "intersect";
 export type RegionOverlapPair = readonly [mine: string, theirs: string, relation: RegionRelation];
 export declare function regionsOverlapWithRelation(mine: readonly string[], theirs: readonly string[]): readonly RegionOverlapPair[];
-export declare function regionsOverlap(mine: readonly string[], theirs: readonly string[]): readonly [string, string][];

package/build/src/body/region.js

@@ -254,6 +254,3 @@ export function regionsOverlapWithRelation(mine, theirs) {
     }
     return overlaps;
 }
-export function regionsOverlap(mine, theirs) {
-    return regionsOverlapWithRelation(mine, theirs).map(([minePattern, theirsPattern]) => [minePattern, theirsPattern]);
-}

package/build/src/body/verification.d.ts

@@ -1,6 +1,5 @@
 import type { DocumentNode, SectionNode } from "../markdown/types.js";
 import type { VerificationDeclaration } from "../verification/declaration.js";
-export type { VerificationDeclaration, VerificationExecutor } from "../verification/declaration.js";
 export declare class VerificationDocumentError extends Error {
     constructor(message: string);
 }

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

@@ -1,4 +1,5 @@
-import { CliUsageError, commandGuide, isBlankInput, usageLine } from "../usage.js";
+import { CliUsageError, commandGuide, usageLine } from "../usage.js";
+import { scanArgs } from "../scan.js";
 import { parseDuration as decodeDuration } from "../../duration.js";
 import { parseAkumaAlias, parseAkumaGlob } from "../../identity/selector.js";
 import { ALLOWED_ACTIONS, DEFAULT_ALLOWED_ACTIONS, decodeAllowedActions, } from "../../akuma/allowed.js";
@@ -12,7 +13,7 @@ const AKUMA_COMMAND_SPECS = {
             contract: "value",
             alias: "value",
             wait: "value",
-            allowed: "repeatable",
+            allowed: "repeat",
             json: "boolean",
             schema: "value",
         },
@@ -134,6 +135,23 @@ export function renderAkumaHelp(action) {
 export function akumaUsageGuide(action) {
     return commandGuide(action, AKUMA_COMMAND_SPECS[action].usage);
 }
+const TELL_ONLY_REFUSALS = {
+    "--wait": "tell --wait is not supported; use ask --wait",
+    "--schema": "tell --schema is not supported; use ask --schema",
+};
+/** The prompt is the only stdin reader; the ask-only options are refused tokens, as is `-d`. */
+function scanSpec(action, spec) {
+    return {
+        subject: action,
+        flags: spec.flags,
+        ...(spec.stdin ? { stdin: "prompt" } : {}),
+        stdinRefusal: `stdin marker '-' is not valid for ${action}`,
+        refused: {
+            "-d": `option -d is not valid for ${action}`,
+            ...(action === "tell" ? TELL_ONLY_REFUSALS : {}),
+        },
+    };
+}
 function stringFlag(value, diagnostic, fail) {
     if (typeof value !== "string")
         fail(diagnostic);
@@ -149,67 +167,6 @@ function parseDuration(raw, option, fail) {
         fail(`${option} duration exceeds the safe millisecond range`);
     return duration.milliseconds;
 }
-function scanNamedOption(input, flags, fail) {
-    const token = input.argv[input.index];
-    const name = token.slice(2);
-    const kind = input.spec.flags[name];
-    if (kind === undefined)
-        fail(`option ${token} is not valid for ${input.action}`);
-    if (kind !== "repeatable" && flags[name] !== undefined)
-        fail(`duplicate option: ${token}`);
-    if (kind === "boolean") {
-        flags[name] = true;
-        return input.index;
-    }
-    const value = input.argv[input.index + 1];
-    if (value === undefined || value === "-" || value === "-d" || value.startsWith("--")) {
-        fail(`${token} requires a value`);
-    }
-    if (isBlankInput(value))
-        fail(`${token} requires a nonblank value`);
-    flags[name] = kind === "repeatable" ? [...(Array.isArray(flags[name]) ? flags[name] : []), value] : value;
-    return input.index + 1;
-}
-function scanAkuma(action, argv, fail) {
-    const spec = AKUMA_COMMAND_SPECS[action];
-    const flags = {};
-    const positionals = [];
-    let stdin = false;
-    let positionalOnly = false;
-    for (let index = 1; index < argv.length; index += 1) {
-        const token = argv[index];
-        if (!positionalOnly && token === "--") {
-            positionalOnly = true;
-            continue;
-        }
-        if (positionalOnly) {
-            if (isBlankInput(token))
-                fail(`${action} requires a nonblank value`);
-            positionals.push(token);
-        }
-        else if (token === "-") {
-            if (!spec.stdin)
-                fail(`stdin marker '-' is not valid for ${action}`);
-            if (stdin)
-                fail("stdin marker '-' may appear only once");
-            stdin = true;
-        }
-        else if (token === "-d") {
-            fail(`option ${token} is not valid for ${action}`);
-        }
-        else if (!token.startsWith("--")) {
-            if (isBlankInput(token))
-                fail(`${action} requires a nonblank value`);
-            positionals.push(token);
-        }
-        else {
-            if (action === "tell" && (token === "--wait" || token === "--schema"))
-                fail(`tell ${token} is not supported; use ask ${token}`);
-            index = scanNamedOption({ action, spec, argv, index }, flags, fail);
-        }
-    }
-    return { flags, positionals, stdin };
-}
 function positiveIndex(raw, option, fail) {
     if (typeof raw !== "string" || !/^[1-9][0-9]*$/u.test(raw))
         fail(`${option} requires a positive integer`);
@@ -397,10 +354,10 @@ export function parseAkumaCommand(argv) {
     const fail = (message) => {
         throw new CliUsageError(message, akumaUsageGuide(action));
     };
-    const { flags, positionals, stdin } = scanAkuma(action, argv, fail);
+    const { flags, positionals, stdin } = scanArgs(argv, scanSpec(action, spec), fail);
     const output = flags.json === true ? "json" : "text";
     if (action === "call" || action === "tell" || action === "ask") {
-        const parsed = parsePrompted(action, positionals, stdin, fail);
+        const parsed = parsePrompted(action, positionals, stdin !== undefined, fail);
         return action === "call"
             ? parseCall(flags, parsed.subject, parsed.prompt, output, fail)
             : action === "tell"
@@ -417,7 +374,7 @@ export function parseAkumaCommand(argv) {
                 ? `${action} accepts one Akuma selector`
                 : `${action} accepts exactly ${spec.arity} Akuma selectors`);
     }
-    if (stdin)
+    if (stdin !== undefined)
         fail(`${action} reads no stdin`);
     return parseAddressed(action, positionals, flags, output, fail);
 }

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

@@ -12,10 +12,10 @@ import { akumasWithExecution } from "../../library/akumas.js";
 import { World } from "../../world.js";
 import { contractFromInput } from "../selectors.js";
 import { ActivityDriver } from "../activity.js";
-import { displayContext, resultContext, writeJson, writeStderr, writeStdout } from "../streams.js";
+import { displayContext, emit, resultContext, writeJson, writeStderr, writeStdout } from "../streams.js";
 import { callObservationStream, inputWaitStream, waitObservationStream, } from "../render/akuma-activity.js";
-import { askRawAnswer, callRawAnswer, historyRawAnswer, waitRawAnswer } from "../render/akuma-activity.js";
-import { askExitCode, askProgressStream, callExitCode, callObservationHead, forkExitCode, historyExitCode, killExitCode, renderCallText, renderForkText, renderHistoryText, renderKillText, renderTellText, renderWaitText, tellExitCode, waitedTellProgress, } from "../render/akuma.js";
+import { askRawAnswer, callRawAnswer, historyRawAnswer, historyText, tellText, waitRawAnswer, waitText, } from "../render/akuma-activity.js";
+import { askExitCode, askProgressStream, callExitCode, callObservationHead, forkExitCode, historyExitCode, killExitCode, renderCallText, renderForkText, renderKillText, tellExitCode, waitedTellProgress, } from "../render/akuma.js";
 export { isParsedAkumaCommand, renderAkumaHelp } from "./akuma-grammar.js";
 // ---------------------------------------------------------------------------
 // Leaf dispatch: acquisition, one public SDK invocation, direct rendering
@@ -86,7 +86,7 @@ async function inputInitiator(input) {
     }
     return { initiator };
 }
-function emitResult(body, exact) {
+function emitAnswer(body, exact) {
     if (exact)
         process.stdout.write(body);
     else
@@ -152,9 +152,9 @@ async function runCall(command, input) {
         }
         const raw = callRawAnswer(result, streamed);
         if (raw === undefined)
-            emitResult(renderCallText(result, streamed, displayContext()), false);
+            emitAnswer(renderCallText(result, streamed, displayContext()), false);
         else
-            emitResult(raw, true);
+            emitAnswer(raw, true);
         return callExitCode(result);
     }
     finally {
@@ -195,9 +195,9 @@ async function runWait(command, input) {
         }
         const raw = waitRawAnswer(result, streamed);
         if (raw === undefined)
-            emitResult(renderWaitText(result, presentation, displayContext()), false);
+            emitAnswer(waitText(result, presentation, displayContext()), false);
         else
-            emitResult(raw, true);
+            emitAnswer(raw, true);
         return 0;
     }
     finally {
@@ -214,12 +214,8 @@ async function runTell(command, input) {
         ...(input.repo === undefined ? {} : { repo: input.repo }),
         ...(input.signal === undefined ? {} : { signal: input.signal }),
     });
-    if (command.output === "json") {
-        writeJson(result);
-        return tellExitCode(result);
-    }
-    emitResult(renderTellText(result, inputAlias(command.akuma), displayContext()), false);
-    return tellExitCode(result);
+    const text = () => tellText(result, inputAlias(command.akuma), displayContext());
+    return emit(command.output, result, text, tellExitCode(result));
 }
 async function runAsk(command, input) {
     const body = await promptBody("ask", command, input);
@@ -261,7 +257,7 @@ async function runAsk(command, input) {
             writeJson(result);
             return askExitCode(result);
         }
-        emitResult(askRawAnswer(result, schema !== undefined) ?? "", true);
+        emitAnswer(askRawAnswer(result, schema !== undefined) ?? "", true);
         return askExitCode(result);
     }
     finally {
@@ -289,11 +285,11 @@ async function runHistory(command, input) {
         last: command.last,
     };
     if (raw !== undefined)
-        emitResult(raw, true);
+        emitAnswer(raw, true);
     else if (command.last && result.kind === "last")
-        emitResult(result.answer, true);
+        emitAnswer(result.answer, true);
     else
-        emitResult(renderHistoryText(result, presentation, displayContext()), false);
+        emitAnswer(historyText(result, presentation, displayContext()), false);
     return historyExitCode(result, command.id);
 }
 async function runFork(command, input) {
@@ -302,12 +298,7 @@ async function runFork(command, input) {
         at: command.at,
         ...(input.repo === undefined ? {} : { repo: input.repo }),
     });
-    if (command.output === "json") {
-        writeJson(receipt);
-        return forkExitCode(receipt);
-    }
-    emitResult(renderForkText(receipt), false);
-    return forkExitCode(receipt);
+    return emit(command.output, receipt, () => renderForkText(receipt), forkExitCode(receipt));
 }
 async function runKill(command, input) {
     const alias = command.akuma.length === 1 ? inputAlias(command.akuma[0]) : undefined;
@@ -316,12 +307,8 @@ async function runKill(command, input) {
         ...(input.repo === undefined ? {} : { repo: input.repo }),
         ...(input.signal === undefined ? {} : { signal: input.signal }),
     });
-    if (command.output === "json") {
-        writeJson(result);
-        return killExitCode(result);
-    }
-    emitResult(renderKillText(result, alias, displayContext()), false);
-    return killExitCode(result);
+    const text = () => renderKillText(result, alias, displayContext());
+    return emit(command.output, result, text, killExitCode(result));
 }
 async function akumaWorld(command, coordinates) {
     const world = command.command === "call"

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

@@ -44,7 +44,7 @@ export type ParsedDeliver = Output & Readonly<{
     materializeConflict: boolean;
     overwrite: boolean;
 }>;
-export type ParsedReview = Output & Readonly<{
+export type ParsedReview = Output & Actor & Readonly<{
     command: "review";
     contract?: string;
     verdict: "satisfied" | "unsatisfied";
@@ -66,11 +66,23 @@ export type ParsedStatus = Output & (Readonly<{
     selectors?: readonly string[];
     akuma?: never;
     guidance?: true;
+    category?: never;
+    limit?: never;
 }> | Readonly<{
     command: "status";
     contract: string;
     akuma: true;
     guidance?: never;
+    category?: never;
+    limit?: never;
+}> | Readonly<{
+    command: "status";
+    category: StatusCategory;
+    limit?: number;
+    contract?: never;
+    selectors?: never;
+    akuma?: never;
+    guidance?: never;
 }>);
 export type ParsedLs = Output & Readonly<{
     command: "ls";
@@ -108,5 +120,6 @@ export type ParsedContractParts = Readonly<{
     actor?: string;
 }>;
 export type ParsedContractCommand = ParsedBind | ParsedAmend | ParsedDeliver | ParsedReview | ParsedArc | ParsedAbandon | ParsedStatus | ParsedLs | ParsedAudit | ParsedReconcile | ParsedNuke | ParsedSettings | ParsedRegion;
+export type StatusCategory = "akuma" | "contract";
 export declare function parseContractCommand(parts: ParsedContractParts): ParsedContractCommand;
 export {};

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

@@ -123,32 +123,65 @@ function parseReview(parts) {
         verdict: parts.flags.satisfied === true ? "satisfied" : "unsatisfied",
         ...(summary === undefined ? {} : { summary }),
         ...(parts.stdin ? { summaryFromStdin: true } : {}),
+        ...(parts.actor === undefined ? {} : { actor: parts.actor }),
         output: parts.output,
     };
 }
-function parseStatus(parts) {
-    const guidance = parts.flags.guidance === true;
-    if (guidance) {
-        const selected = parts.positionals[0];
-        if (parts.positionals.length > 1)
-            refuse("status", "--guidance accepts at most one Contract selector");
-        if (selected?.startsWith("aku/") === true)
-            refuse("status", "--guidance cannot select an Akuma");
-        return {
-            command: "status",
-            ...(selected === undefined ? {} : { contract: selected }),
-            guidance: true,
-            output: parts.output,
-        };
+// Only these fixed category forms are status selectors.
+const STATUS_CATEGORY_SELECTORS = new Map([
+    ["aku", "akuma"],
+    ["aku/", "akuma"],
+    ["aku/*", "akuma"],
+    ["kei", "contract"],
+    ["kei/", "contract"],
+    ["kei/*", "contract"],
+]);
+function rejectStatusGlobs(positionals) {
+    for (const selector of positionals) {
+        if (!STATUS_CATEGORY_SELECTORS.has(selector) && !selector.startsWith("@") && /[*?\[\]]/u.test(selector))
+            refuse("status", `unsupported status glob: ${selector}`);
     }
+}
+function parseStatusGuidance(parts, limit) {
+    if (limit !== undefined)
+        refuse("status", "--limit is not valid with --guidance");
+    const selected = parts.positionals[0];
+    if (selected !== undefined && STATUS_CATEGORY_SELECTORS.has(selected))
+        refuse("status", "--guidance cannot select a category");
+    if (parts.positionals.length > 1)
+        refuse("status", "--guidance accepts at most one Contract selector");
+    if (selected?.startsWith("aku/") === true)
+        refuse("status", "--guidance cannot select an Akuma");
+    if (selected !== undefined && !selected.startsWith("@") && /[*?\[\]]/u.test(selected))
+        refuse("status", `unsupported status glob: ${selected}`);
+    return {
+        command: "status",
+        ...(selected === undefined ? {} : { contract: selected }),
+        guidance: true,
+        output: parts.output,
+    };
+}
+function parseStatus(parts) {
+    const limit = listLimit(parts, "status");
+    if (parts.flags.guidance === true)
+        return parseStatusGuidance(parts, limit);
+    rejectStatusGlobs(parts.positionals);
     if (parts.positionals.length > 1) {
+        if (limit !== undefined)
+            refuse("status", "--limit is valid only for one category selector");
+        if (parts.positionals.some((selector) => STATUS_CATEGORY_SELECTORS.has(selector)))
+            refuse("status", "a category selector cannot combine with other selectors");
         return { command: "status", selectors: parts.positionals, output: parts.output };
     }
-    const contract = parts.positionals[0];
-    if (contract?.startsWith("aku/") === true) {
-        return { command: "status", contract, akuma: true, output: parts.output };
-    }
-    return { command: "status", ...(contract === undefined ? {} : { contract }), output: parts.output };
+    const selected = parts.positionals[0];
+    const category = selected === undefined ? undefined : STATUS_CATEGORY_SELECTORS.get(selected);
+    if (category !== undefined)
+        return { command: "status", category, ...(limit === undefined ? {} : { limit }), output: parts.output };
+    if (limit !== undefined)
+        refuse("status", "--limit is valid only for a category selector");
+    if (selected?.startsWith("aku/") === true)
+        return { command: "status", contract: selected, akuma: true, output: parts.output };
+    return { command: "status", ...(selected === undefined ? {} : { contract: selected }), output: parts.output };
 }
 function parseRegion(parts) {
     const contract = parts.positionals[0];
@@ -172,10 +205,10 @@ function akumaCatalogQuery(query, parts) {
         ...(limit === undefined ? {} : { limit: Number(limit) }),
     };
 }
-function listLimit(parts) {
+function listLimit(parts, command = "ls") {
     const limit = optionalFlag(parts.flags, "limit");
     if (limit !== undefined && (!/^[1-9][0-9]*$/u.test(limit) || !Number.isSafeInteger(Number(limit))))
-        refuse("ls", "--limit requires a positive safe integer");
+        refuse(command, "--limit requires a positive safe integer");
     return limit === undefined ? undefined : Number(limit);
 }
 function taskCatalogQuery(path, limit) {