@astrosheep/keiyaku 4.6.3 → 4.6.6

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-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"