@astrosheep/keiyaku 4.6.4 → 4.6.7

package/build/src/akuma/providers/pi/index.js

@@ -115,6 +115,37 @@ async function runPiPrompt(native, input, events, state, settle) {
             : { kind: "failed", diagnostic: diagnostic(error) });
     }
 }
+async function retirePiSession(native) {
+    let failure;
+    let unsubscribe;
+    try {
+        const runner = native.extensionRunner;
+        unsubscribe = runner?.onError((error) => {
+            if (error.event === "session_shutdown")
+                failure ??= new Error(error.error);
+        });
+        await runner?.emit({ type: "session_shutdown", reason: "quit" });
+    }
+    catch (error) {
+        failure ??= error;
+    }
+    finally {
+        try {
+            unsubscribe?.();
+        }
+        catch (error) {
+            failure ??= error;
+        }
+        try {
+            native.dispose();
+        }
+        catch (error) {
+            failure ??= error;
+        }
+    }
+    if (failure !== undefined)
+        throw failure;
+}
 async function drivePi(sdk, execution, input, signal, custody) {
     const created = await createPiSession(sdk, execution, input);
     const native = created.session;
@@ -144,33 +175,7 @@ async function drivePi(sdk, execution, input, signal, custody) {
     const agent = native.agent;
     let unsubscribeAgent;
     let unsubscribe;
-    try {
-        unsubscribeAgent = agent.subscribe((event) => {
-            if (event.type === "message_end") {
-                const waiter = pendingTells.get(event.message);
-                if (waiter !== undefined) {
-                    pendingTells.delete(event.message);
-                    waiter.resolve({ kind: "accepted", fence: `${native.sessionId}:${waiter.id}` });
-                }
-            }
-        });
-        unsubscribe = native.subscribe((event) => {
-            if (event.type === "agent_end" && !event.willRetry) {
-                state.terminalFailure = piTerminalFailure(event.messages);
-            }
-            for (const translated of translatePiEvent(event, eventState))
-                events.emit(translated);
-        });
-    }
-    catch (error) {
-        try {
-            unsubscribeAgent?.();
-        }
-        finally {
-            native.dispose();
-        }
-        throw error;
-    }
+    let binding;
     const settle = (result) => {
         if (state.settled)
             return closed;
@@ -178,7 +183,7 @@ async function drivePi(sdk, execution, input, signal, custody) {
         endPendingTells();
         let failure;
         try {
-            unsubscribe();
+            unsubscribe?.();
         }
         catch (error) {
             failure = error;
@@ -191,16 +196,19 @@ async function drivePi(sdk, execution, input, signal, custody) {
         }
         events.end();
         settleCompletion(result);
-        try {
-            native.dispose();
-        }
-        catch (error) {
-            failure ??= error;
-        }
-        if (failure === undefined)
-            settleRetired();
-        else
-            failRetired(failure);
+        void (async () => {
+            // Binding can create extension resources after cancellation. Shutdown must
+            // run after that work, while its contexts are still valid.
+            await binding?.catch(() => undefined);
+            try {
+                await retirePiSession(native);
+            }
+            catch (error) {
+                failure ??= error;
+            }
+            if (failure !== undefined)
+                throw failure;
+        })().then(settleRetired, failRetired);
         return closed;
     };
     const forceDispose = async () => {
@@ -209,6 +217,28 @@ async function drivePi(sdk, execution, input, signal, custody) {
         await settle({ kind: "failed", diagnostic: "Pi session force-disposed" });
     };
     custody?.own({ closed, abort: forceDispose, forceDispose });
+    try {
+        unsubscribeAgent = agent.subscribe((event) => {
+            if (event.type === "message_end") {
+                const waiter = pendingTells.get(event.message);
+                if (waiter !== undefined) {
+                    pendingTells.delete(event.message);
+                    waiter.resolve({ kind: "accepted", fence: `${native.sessionId}:${waiter.id}` });
+                }
+            }
+        });
+        unsubscribe = native.subscribe((event) => {
+            if (event.type === "agent_end" && !event.willRetry) {
+                state.terminalFailure = piTerminalFailure(event.messages);
+            }
+            for (const translated of translatePiEvent(event, eventState))
+                events.emit(translated);
+        });
+    }
+    catch (error) {
+        await settle({ kind: "failed", diagnostic: diagnostic(error) });
+        throw error;
+    }
     if (signal.aborted) {
         await settle({ kind: "failed", diagnostic: "Pi session aborted" });
         signal.throwIfAborted();
@@ -217,9 +247,12 @@ async function drivePi(sdk, execution, input, signal, custody) {
         await settle({ kind: "failed", diagnostic: "Pi session admitted without sessionFile" });
         throw new Error("Pi session admitted without sessionFile");
     }
+    binding = Promise.resolve().then(() => native.bindExtensions({}));
+    await abortable(binding, signal);
+    signal.throwIfAborted();
     events.emit({ type: "session", coordinate: { sessionFile: native.sessionFile, sessionId: native.sessionId } });
     void runPiPrompt(native, input, eventState, state, (result) => {
-        void settle(result);
+        void settle(result).catch(() => undefined);
     });
     return {
         admission: { fence: native.sessionId },

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/selection-owner-port.d.ts

@@ -9,4 +9,4 @@ import type { SelectionRequestPort } from "./selection-request.js";
  * unaddressable member never starts; the executor's own access to the target is
  * then the product act, never a second addressing probe.
  */
-export declare function selectionRequestPort(world: WorldRoot): SelectionRequestPort;
+export declare function selectionRequestPort(world: WorldRoot, reportDiagnostic: (message: string) => void): SelectionRequestPort;

package/build/src/akuma/selection-owner-port.js

@@ -1,3 +1,4 @@
+import { outcomePluginObserver } from "../plugin/akuma-signals.js";
 import { requireBornAkuma } from "./akuma-probe.js";
 import { executeAskAkuma, executeKillAkuma, executeTellAkuma } from "./akuma-selection-execution.js";
 import { executeWaitAkuma } from "./akuma-wait.js";
@@ -11,26 +12,36 @@ import { akumaObservationOf } from "./selection-observation.js";
  * unaddressable member never starts; the executor's own access to the target is
  * then the product act, never a second addressing probe.
  */
-export function selectionRequestPort(world) {
+export function selectionRequestPort(world, reportDiagnostic) {
     const prove = async (targets) => {
         for (const id of targets)
             await requireBornAkuma(world, id);
     };
     return {
-        wait: async ({ targets, ...request }) => {
+        wait: async ({ targets, observer, ...request }) => {
             await prove(targets);
             // The lower wait owner returns association-free native evidence; the
             // actual request crossing composes its canonical transport shape.
-            const native = await executeWaitAkuma({ path: world, ids: targets, ...request });
+            const native = await executeWaitAkuma({
+                path: world,
+                ids: targets,
+                ...request,
+                outcomeObserved: outcomePluginObserver({ world, reportDiagnostic }, observer),
+            });
             return { ...native, observations: native.observations.map(akumaObservationOf) };
         },
         tell: async ({ target, ...request }) => {
             await prove([target]);
             return await executeTellAkuma({ path: world, id: target, ...request });
         },
-        ask: async ({ target, ...request }) => {
+        ask: async ({ target, observer, ...request }) => {
             await prove([target]);
-            return await executeAskAkuma({ path: world, id: target, ...request });
+            return await executeAskAkuma({
+                path: world,
+                id: target,
+                ...request,
+                outcomeObserved: outcomePluginObserver({ world, reportDiagnostic }, observer),
+            });
         },
         kill: async ({ targets, ...request }) => {
             await prove(targets);

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

@@ -106,6 +106,7 @@ export type SelectionRequestPort = Readonly<{
         targets: readonly AkumaStatus["id"][];
         completion: "any" | "all";
         timeoutMs?: number;
+        observer: string;
         signal: AbortSignal;
     }>): Promise<AkumaWaitResult>;
     tell(input: Readonly<{
@@ -126,6 +127,7 @@ export type SelectionRequestPort = Readonly<{
         schemaJson?: string;
         initiator?: string;
         interrupt?: boolean;
+        observer: string;
         signal: AbortSignal;
     }>): Promise<AkumaAskResult>;
     kill(input: Readonly<{

package/build/src/akuma/selection-request.js

@@ -167,7 +167,7 @@ export function selectionRequestCommand(action, port) {
             if (request.action === "akuma.wait") {
                 return {
                     kind: "served",
-                    result: await port.wait({ ...request, signal: facts.signal }),
+                    result: await port.wait({ ...request, observer: facts.requester, signal: facts.signal }),
                     service: { action: request.action },
                 };
             }
@@ -196,6 +196,7 @@ export function selectionRequestCommand(action, port) {
                         body: request.body,
                         tellId: facts.id,
                         recordedAt: facts.admittedAt,
+                        observer: facts.requester,
                         ...(request.timeoutMs === undefined ? {} : { timeoutMs: request.timeoutMs }),
                         ...(request.schemaJson === undefined ? {} : { schemaJson: request.schemaJson }),
                         ...(request.initiator === undefined ? {} : { initiator: request.initiator }),

package/build/src/akuma-body.js

@@ -1,6 +1,6 @@
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { bodyLaunchSchema, LEASH_HELD_EXIT, runAkumaBody } from "./akuma/body.js";
+import { bodyLaunchSchema, LEASH_HELD_EXIT, runAkumaBody, recordPluginDiagnostic, } from "./akuma/body.js";
 import { worldRootForAkumaPaths } from "./akuma/identity.js";
 import { composeRequestCommands } from "./akuma/request-wire.js";
 import { localExecutionContext } from "./akuma/requests.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 });
         },
@@ -107,7 +108,9 @@ export async function externalRequestCommandsFor(launch, processConfiguration) {
     const world = await World.prove(worldRootForAkumaPaths(launch.paths));
     return {
         world,
-        commands: composeRequestCommands(selectionRequestCommands(selectionRequestPort(world)), contractRequestCommands(contractUpstream(processConfiguration)), taskMutationRequestCommands(taskMutationRequestPort())),
+        commands: composeRequestCommands(selectionRequestCommands(selectionRequestPort(world, (message) => {
+            void recordPluginDiagnostic(launch.paths, "outcome observation", message);
+        })), contractRequestCommands(contractUpstream(processConfiguration)), taskMutationRequestCommands(taskMutationRequestPort())),
     };
 }
 function bodyProcessConfiguration() {

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);
 }