@astrosheep/keiyaku 4.5.29 → 4.6.2

package/build/src/cli/coordinates.d.ts

@@ -36,3 +36,13 @@ export declare const cliCoordinateDiscovery: {
     resolve(input: CliCoordinateInput): Promise<CliCoordinates>;
 };
 export declare function resolveCliCoordinates(input: CliCoordinateInput): Promise<CliCoordinates>;
+type InvocationCoordinatesInput = Readonly<{
+    processCwd?: string;
+    cwd?: string;
+    repo?: string;
+    workdir?: string;
+    command: ParsedCommand;
+}>;
+/** The one process-edge coordinate resolution: explicit filesystem inputs plus the command's Repo policy. */
+export declare function resolveInvocationCoordinates(invocation: InvocationCoordinatesInput, environment: NodeJS.ProcessEnv): Promise<CliCoordinates>;
+export {};

package/build/src/cli/coordinates.js

@@ -106,3 +106,23 @@ async function resolveWorld(cwd, repo) {
 export async function resolveCliCoordinates(input) {
     return cliCoordinateDiscovery.resolve(input);
 }
+/** One explicit Git executable override from the process edge; a blank value is usage, not absence. */
+function gitPathFromEdge(environment) {
+    const value = environment.KEIYAKU_GIT_PATH;
+    if (value === undefined)
+        return undefined;
+    if (value.trim().length === 0)
+        throw new CliUsageError("KEIYAKU_GIT_PATH requires a nonblank value");
+    return value;
+}
+/** The one process-edge coordinate resolution: explicit filesystem inputs plus the command's Repo policy. */
+export async function resolveInvocationCoordinates(invocation, environment) {
+    const gitPath = gitPathFromEdge(environment);
+    return resolveCliCoordinates({
+        ...(invocation.processCwd === undefined ? {} : { processCwd: invocation.processCwd }),
+        ...(invocation.cwd === undefined ? {} : { cwd: invocation.cwd }),
+        ...(invocation.repo === undefined ? {} : { repo: invocation.repo }),
+        ...(gitPath === undefined ? {} : { gitPath }),
+        command: invocation.command,
+    });
+}

package/build/src/cli/draft.d.ts

@@ -1,5 +1,11 @@
 import type { WorldRoot } from "../world.js";
-import type { BindDraftReceipt } from "./result.js";
+export type BindDraftReceipt = Readonly<{
+    path: string;
+    warning?: string;
+} | {
+    path?: never;
+    warning: string;
+}>;
 export declare class BindDraftError extends Error {
     readonly original: unknown;
     readonly draft: BindDraftReceipt;

package/build/src/cli/main.js

@@ -1,6 +1,15 @@
 import { CliUsageError, parseArgv, renderHelp } from "./parse.js";
 import { installedPackageVersion } from "./version.js";
+function handleBrokenPipe(stream) {
+    stream.on("error", (error) => {
+        if (error.code === "EPIPE")
+            process.exit(0);
+        throw error;
+    });
+}
 export async function main(argv = process.argv.slice(2)) {
+    handleBrokenPipe(process.stdout);
+    handleBrokenPipe(process.stderr);
     try {
         const parsed = parseArgv(argv);
         if ("help" in parsed) {
@@ -18,6 +27,6 @@ export async function main(argv = process.argv.slice(2)) {
     catch (error) {
         const diagnostic = error instanceof Error ? error.message : String(error);
         process.stderr.write(diagnostic.endsWith("\n") ? diagnostic : `${diagnostic}\n`);
-        return error instanceof CliUsageError ? 1 : 3;
+        return error instanceof CliUsageError ? 64 : 3;
     }
 }

package/build/src/cli/parse.d.ts

@@ -1,17 +1,17 @@
-import { type ParsedTaskCommand, type TaskAction } from "./commands/task.js";
-import { type AkumaAction, type ParsedAkumaCommand } from "./commands/akuma.js";
+import { type ParsedTaskCommand, type TaskAction } from "./commands/task-grammar.js";
+import { type AkumaAction, type ParsedAkumaCommand } from "./commands/akuma-grammar.js";
 import { type ParsedInstallCommand } from "./commands/install.js";
-import { type ContractCommand as Command, type ParsedAbandon, type ParsedAmend, type ParsedArc, type ParsedAudit, type ParsedBind, type ParsedDeliver, type ParsedLs, type ParsedNuke, type ParsedReconcile, type ParsedRegion, type ParsedReview, type ParsedSettings, type ParsedShow, type ParsedStatus } from "./commands/contract.js";
+import { type ParsedAbandon, type ParsedAmend, type ParsedArc, type ParsedAudit, type ParsedBind, type ParsedDeliver, type ParsedLs, type ParsedNuke, type ParsedReconcile, type ParsedRegion, type ParsedReview, type ParsedSettings, type ParsedStatus } from "./commands/contract-grammar.js";
+import { type ContractCommand as Command } from "./commands/contract-help.js";
 import { type CliUsageGuide } from "./usage.js";
 export { CliUsageError } from "./usage.js";
 export type { CliUsageGuide } from "./usage.js";
-export { renderContractHelp } from "./commands/contract.js";
+export { renderContractHelp } from "./commands/contract-help.js";
 export type { Command };
 export declare function renderRootHelp(columns?: number): string;
-export declare function renderCommandUsage(command: ParsedCommand): string;
 export declare function usageGuideForCommand(command: ParsedCommand): CliUsageGuide;
 export declare function renderHelp(coordinate: CliHelpCoordinate, columns?: number): string;
-export type ParsedCommand = ParsedBind | ParsedAmend | ParsedDeliver | ParsedReview | ParsedArc | ParsedAbandon | ParsedStatus | ParsedShow | ParsedLs | ParsedAudit | ParsedReconcile | ParsedNuke | ParsedSettings | ParsedRegion | ParsedInstallCommand | ParsedAkumaCommand | ParsedTaskCommand;
+export type ParsedCommand = ParsedBind | ParsedAmend | ParsedDeliver | ParsedReview | ParsedArc | ParsedAbandon | ParsedStatus | ParsedLs | ParsedAudit | ParsedReconcile | ParsedNuke | ParsedSettings | ParsedRegion | ParsedInstallCommand | ParsedAkumaCommand | ParsedTaskCommand;
 export type CliHelpCoordinate = Readonly<{
     kind: "root";
 }> | Readonly<{
@@ -26,13 +26,12 @@ export type CliHelpCoordinate = Readonly<{
     kind: "akuma";
     action: AkumaAction;
 }>;
-export type ParsedExecution = Readonly<{
+export type ParsedInvocation = Readonly<{
     cwd?: string;
     repo?: string;
     workdir?: string;
     command: ParsedCommand;
-}>;
-export type ParsedInvocation = ParsedExecution | Readonly<{
+}> | Readonly<{
     help: CliHelpCoordinate;
 }> | Readonly<{
     version: true;

package/build/src/cli/parse.js

@@ -1,11 +1,12 @@
-import { isTaskAction, parseTaskCommand, renderTaskHelp, renderTaskUsage, taskUsageGuide, } from "./commands/task.js";
-import { akumaUsageGuide, isAkumaAction, parseAkumaCommand, renderAkumaHelp, renderAkumaRootRows, renderAkumaUsage, } from "./commands/akuma.js";
+import { isTaskAction, parseTaskCommand, renderTaskHelp, taskUsageGuide, } from "./commands/task-grammar.js";
+import { akumaUsageGuide, isAkumaAction, parseAkumaCommand, renderAkumaHelp, renderAkumaRootRows, } from "./commands/akuma-grammar.js";
 import { INSTALL_ROOT_PURPOSE, INSTALL_USAGE, parseInstallCommand, renderInstallHelp, } from "./commands/install.js";
-import { CONTRACT_COMMAND_SPECS, parseContractCommand, renderContractHelp as renderContractHelpForOwner, renderContractUsage, } from "./commands/contract.js";
+import { parseContractCommand, } from "./commands/contract-grammar.js";
+import { CONTRACT_COMMAND_SPECS, renderContractHelp as renderContractHelpForOwner, } from "./commands/contract-help.js";
 import { renderOpaqueBlock, renderTextBlock } from "./render/terminal.js";
 import { CliUsageError, commandGuide, isBlankInput, ROOT_USAGE_GUIDE, unknownCommandGuide, } from "./usage.js";
 export { CliUsageError } from "./usage.js";
-export { renderContractHelp } from "./commands/contract.js";
+export { renderContractHelp } from "./commands/contract-help.js";
 const ROOT_USAGE = [
     "usage  keiyaku <command> [options]",
     "      keiyaku <command> --help   shows that command's complete usage",
@@ -25,22 +26,22 @@ export function renderRootHelp(columns) {
         "Task — plan memory",
         "  task       Task coordination; see `keiyaku task --help`.",
         "",
-        "Akuma — invoke capability",
+        "Akuma — contracted demons",
         ...renderAkumaRootRows(),
         "",
         "Workspace",
-        `  install   ${INSTALL_ROOT_PURPOSE}`,
-        `  settings  ${CONTRACT_COMMAND_SPECS.settings.purpose}`,
+        `  ${"install".padEnd(10)} ${INSTALL_ROOT_PURPOSE}`,
+        `  ${"settings".padEnd(10)} ${CONTRACT_COMMAND_SPECS.settings.purpose}`,
         "",
         "Package",
         "  --version  Print the running package version.",
         "",
         "Global options:",
-        "  -C, --cwd <path>  Set the invocation working directory.",
-        "  --repo <path>     Select the Git repository coordinate.",
+        "  -C, --cwd <path>    Set the invocation working directory.",
+        "  --repo <path>       Select the Git repository coordinate.",
+        "  --workdir <path>    Set the execution directory for call only.",
         "",
-        "Call option:",
-        "  --workdir <path>  Set the execution directory for call only.",
+        "Outcomes:  exit 0 accepted · 1 refused · 2 retry · 3 failed · 64 usage",
     ].join("\n"), columns);
 }
 function renderHelpText(help, columns) {
@@ -60,18 +61,6 @@ function renderHelpText(help, columns) {
     })
         .join("\n");
 }
-function contractUsage(command) {
-    return renderContractUsage(command);
-}
-export function renderCommandUsage(command) {
-    if (command.command === "install")
-        return renderInstallHelp();
-    if (command.command === "task")
-        return renderTaskUsage(command.action);
-    if (isAkumaAction(command.command))
-        return renderAkumaUsage(command.command);
-    return contractUsage(command.command);
-}
 export function usageGuideForCommand(command) {
     if (command.command === "install")
         return commandGuide("install", INSTALL_USAGE);
@@ -108,13 +97,13 @@ export function commandRepoPolicy(command) {
         case "abandon":
         case "audit":
         case "reconcile":
-        case "show":
         case "region":
             return { use: "required", acceptsExplicit: true };
         case "ls":
             return { use: command.query.kind === "contracts" ? "required" : "none", acceptsExplicit: false };
         case "status":
         case "tell":
+        case "ask":
             return { use: "optional", acceptsExplicit: false };
         case "history":
             return "contract" in command
@@ -172,9 +161,9 @@ function scanOption(command, argv, state, index) {
         return index;
     }
     const value = argv[index + 1];
-    if (value === undefined)
+    if (value === undefined || value.startsWith("--"))
         refuse(command, `${token} requires a value`);
-    if (kind !== "raw-value" && (value === "-" || value.startsWith("--"))) {
+    if (kind !== "raw-value" && value === "-") {
         refuse(command, `${token} requires a value`);
     }
     if (kind !== "raw-value" && isBlankInput(value))
@@ -188,21 +177,19 @@ function scanOption(command, argv, state, index) {
     }
     return index + 1;
 }
-function scanArgv(argv) {
-    const candidate = argv[0];
-    if (!candidate || !Object.prototype.hasOwnProperty.call(CONTRACT_COMMAND_SPECS, candidate)) {
-        throw new CliUsageError(`unknown command: ${candidate ?? ""}`, unknownCommandGuide(ROOT_USAGE_GUIDE, candidate ?? ""));
-    }
-    const command = candidate;
-    const spec = CONTRACT_COMMAND_SPECS[command];
-    const state = { flags: {}, positionals: [], stdin: false };
+function scanContractTokens(command, argv, state) {
+    let positionalOnly = false;
     for (let index = 1; index < argv.length; index += 1) {
         const token = argv[index];
-        if (token === "-") {
+        if (!positionalOnly && token === "--") {
+            positionalOnly = true;
+            continue;
+        }
+        if (!positionalOnly && token === "-") {
             scanStdin(command, state);
             continue;
         }
-        if (token.startsWith("--")) {
+        if (!positionalOnly && token.startsWith("--")) {
             index = scanOption(command, argv, state, index);
             continue;
         }
@@ -210,6 +197,16 @@ function scanArgv(argv) {
             refuse(command, `${command} requires a nonblank value`);
         state.positionals.push(token);
     }
+}
+function scanArgv(argv) {
+    const candidate = argv[0];
+    if (!candidate || !Object.prototype.hasOwnProperty.call(CONTRACT_COMMAND_SPECS, candidate)) {
+        throw new CliUsageError(`unknown command: ${candidate ?? ""}`, unknownCommandGuide(ROOT_USAGE_GUIDE, candidate ?? ""));
+    }
+    const command = candidate;
+    const spec = CONTRACT_COMMAND_SPECS[command];
+    const state = { flags: {}, positionals: [], stdin: false };
+    scanContractTokens(command, argv, state);
     if (spec.positional === "none" && state.positionals.length > 0) {
         refuse(command, `${command} accepts no contract`);
     }
@@ -228,32 +225,38 @@ function invocationOptions(argv) {
     let repo;
     let workdir;
     const commandArgv = [];
+    let positionalOnly = false;
     for (let index = 0; index < argv.length; index += 1) {
         const token = argv[index];
-        if (!INVOCATION_PATH_OPTIONS.has(token)) {
+        if (!positionalOnly && token === "--") {
+            positionalOnly = true;
             commandArgv.push(token);
             continue;
         }
-        if (token === "--repo" && repo !== undefined) {
-            throw new CliUsageError("--repo may appear only once", ROOT_USAGE_GUIDE);
-        }
-        if ((token === "-C" || token === "--cwd") && cwd !== undefined) {
-            throw new CliUsageError("-C/--cwd may appear only once", ROOT_USAGE_GUIDE);
-        }
-        if (token === "--workdir" && workdir !== undefined) {
-            throw new CliUsageError("--workdir may appear only once", ROOT_USAGE_GUIDE);
-        }
-        const value = argv[index + 1];
-        if (invalidInvocationPath(value)) {
-            throw new CliUsageError(`${token} requires a path`, ROOT_USAGE_GUIDE);
+        if (!positionalOnly && INVOCATION_PATH_OPTIONS.has(token)) {
+            if (token === "--repo" && repo !== undefined) {
+                throw new CliUsageError("--repo may appear only once", ROOT_USAGE_GUIDE);
+            }
+            if ((token === "-C" || token === "--cwd") && cwd !== undefined) {
+                throw new CliUsageError("-C/--cwd may appear only once", ROOT_USAGE_GUIDE);
+            }
+            if (token === "--workdir" && workdir !== undefined) {
+                throw new CliUsageError("--workdir may appear only once", ROOT_USAGE_GUIDE);
+            }
+            const value = argv[index + 1];
+            if (invalidInvocationPath(value)) {
+                throw new CliUsageError(`${token} requires a path`, ROOT_USAGE_GUIDE);
+            }
+            if (token === "--repo")
+                repo = value;
+            else if (token === "--workdir")
+                workdir = value;
+            else
+                cwd = value;
+            index += 1;
+            continue;
         }
-        if (token === "--repo")
-            repo = value;
-        else if (token === "--workdir")
-            workdir = value;
-        else
-            cwd = value;
-        index += 1;
+        commandArgv.push(token);
     }
     return {
         ...(cwd === undefined ? {} : { cwd }),
@@ -266,7 +269,9 @@ function invalidInvocationPath(value) {
     return value === undefined || value === "-" || value.startsWith("-") || isBlankInput(value);
 }
 function helpCoordinate(argv) {
-    const help = argv.indexOf("--help");
+    const endOptions = argv.indexOf("--");
+    const optionEnd = endOptions < 0 ? argv.length : endOptions;
+    const help = argv.slice(0, optionEnd).indexOf("--help");
     if (help < 0)
         return null;
     const words = argv.slice(0, help);
@@ -291,11 +296,6 @@ export function parseArgv(argv) {
         return { help };
     if (invocation.commandArgv.length === 1 && invocation.commandArgv[0] === "--version")
         return { version: true };
-    if (invocation.commandArgv[0] === "ls" &&
-        (invocation.commandArgv.length === 1 ||
-            (invocation.commandArgv.length === 2 && invocation.commandArgv[1] === "--json"))) {
-        return { help: { kind: "contract", command: "ls" } };
-    }
     const task = invocation.commandArgv[0] === "task" ? parseTaskCommand(invocation.commandArgv.slice(1)) : undefined;
     const install = invocation.commandArgv[0] === "install" ? parseInstallCommand(invocation.commandArgv.slice(1)) : undefined;
     const akuma = isAkumaAction(invocation.commandArgv[0]) ? parseAkumaCommand(invocation.commandArgv) : undefined;

package/build/src/cli/render/akuma-activity.d.ts

@@ -1,10 +1,11 @@
-import type { ActivityRow, AkumaStatus, KillEvidence } from "../../akuma/akuma.js";
-import type { CallObservation } from "../../library/akuma-creation.js";
-import type { AkumaObservation, AkumaObservationStage, CreatedTaskObservation, DispatchAssociation } from "../../index.js";
-import type { AkumaTellWaitObservation } from "../../akuma/fleet-observation.js";
-import type { AkumaInvocationResult } from "../commands/akuma-invoke.js";
-import type { WaitObservedAkuma } from "../../akuma/fleet-execution.js";
-import type { ParsedCommand } from "../parse.js";
+import type { AkumaStatus } from "../../akuma/akuma.js";
+import type { KillEvidence } from "../../akuma/heart/index.js";
+import type { ActivityRow } from "../../akuma/projection.js";
+import type { AkumaAskObservation, AkumaAskResult, AkumaTellResult, AkumaWaitResult } from "../../akuma/selection-observation.js";
+import type { AkumaObservation, CreatedTaskObservation, DispatchAssociation } from "../../index.js";
+import type { CallObservation, CallResult } from "../../library/akuma-creation.js";
+import type { WaitObservedAkuma } from "../../library/akumas.js";
+import type { AkumaHistoryResult } from "../../library/selection.js";
 import { type TextRenderContext } from "./terminal.js";
 export declare const DEFAULT_CONTEXT: TextRenderContext;
 /**
@@ -12,13 +13,13 @@ export declare const DEFAULT_CONTEXT: TextRenderContext;
  * widest line, marking the boundary between an observation frame and its content.
  */
 export declare function frameRule(headLines: readonly string[]): string;
-type FleetTimeline = AkumaObservation["status"]["timeline"];
-type RenderedSnapshot = FleetTimeline;
+type StatusTimeline = AkumaObservation["status"]["timeline"];
+type RenderedSnapshot = StatusTimeline;
 type RenderedActivity = Readonly<{
     snapshot: RenderedSnapshot;
     rows: readonly ActivityRow[];
 }>;
-export declare function associatedIdentity(id: string, alias?: string, _contract?: DispatchAssociation): string;
+export declare function associatedIdentity(id: string, alias?: string, contract?: DispatchAssociation): string;
 export declare function snapshotHeading(id: string, alias: string | undefined, contract: DispatchAssociation | undefined): readonly string[];
 /**
  * The one place row prefixes live: time, optional source, mark, verb, content.
@@ -31,8 +32,10 @@ type RowLayout = Readonly<{
     marker: (count: number) => string;
     history?: true;
     compactRun?: true;
-    /** Plural wait rows spend their full remaining width on one terminal line. */
+    /** Plural wait keeps ordinary rows on one line; speech can use its two-line budget. */
     singleLine?: true;
+    /** World-board answer previews keep the conclusion at the tail. */
+    tailAnswer?: true;
     /** A plural wait shares one minute clock across all of its attributed rows. */
     clock?: {
         previous?: string;
@@ -45,20 +48,23 @@ type RowLayout = Readonly<{
  */
 export declare function snapshotActivityLines(snapshot: RenderedSnapshot, context: TextRenderContext, selection?: Readonly<{
     latest?: boolean;
+    tailAnswer?: true;
 }>): readonly string[];
 /** One command's append-only activity view, with a baseline and a final tail flush. */
 export type ActivityStream = ((activity: RenderedActivity) => readonly string[]) & Readonly<{
     /** Establish a wait baseline without spending the command's live tool budget. */
     seed: (activity: RenderedActivity, alreadyRenderedSequence?: number) => readonly string[];
+    /** Current live rows for the redrawable frame; never part of append-only output. */
+    frame: () => readonly string[];
     /** Emit the deferred tail exactly once before the command's conclusion. */
     flush: () => readonly string[];
 }>;
 /**
  * Append-only live view over one command's successive settled snapshots. The
- * first three tools stream immediately; later tools wait in a two-row tail
- * until the command ends. As a newer tool displaces an older tail candidate,
- * its body becomes an in-place omission count. Narrative waits only while a
- * preceding tail tool still decides its position.
+ * first three tools stream immediately; later tools wait in a two-row tail.
+ * A say omits the earlier tail, so only the last two extra tools after the
+ * final say can print at closing. Newer tools displace older tail candidates
+ * in place. Other narrative rows wait behind undecided tail tools.
  */
 export declare function activityStream(context: TextRenderContext, layout?: RowLayout): ActivityStream;
 /** What a wait conclusion renders over: its observed and unobserved members. */
@@ -81,14 +87,19 @@ export type WaitObservationStream = Readonly<{
     select: (selected: readonly WaitSelectedIdentity[]) => void;
     /** One observation round; returns the head frames and newly settled rows to print. */
     observe: (observed: readonly WaitObservedAkuma[]) => readonly string[];
+    /** Current live rows from all selected streams; never part of append-only output. */
+    frame: () => readonly string[];
+    /** In-flight rows with their unresolved marks, emitted by a close that never concluded. */
+    flush: () => readonly string[];
     /** The wait's closing scoreboard, or the empty string when there is nothing to print. */
     conclude: (result: WaitConclusionResult) => string;
     streamed: () => boolean;
 }>;
-export declare function inputWaitConclusion(observation: AkumaTellWaitObservation, input: Readonly<{
+export declare function inputWaitConclusion(observation: AkumaAskObservation, input: Readonly<{
     startedAt: number;
     completedAt?: string | null;
     now?: number;
+    status?: AkumaStatus;
 }>): readonly string[];
 /**
  * Live view over a wait's successive observation rounds, one append-only
@@ -116,7 +127,7 @@ export type InputWaitConclusion = Readonly<{
     diagnostic: string;
 }> | Readonly<{
     kind: "observed";
-    observation: AkumaTellWaitObservation;
+    observation: AkumaAskObservation;
     completedAt?: string | null;
 }>;
 export type InputWaitStream = Readonly<{
@@ -129,13 +140,19 @@ export type InputWaitStream = Readonly<{
         status: AkumaStatus;
         rows: readonly ActivityRow[];
     }>) => readonly string[];
+    /** Current live rows for the redrawable frame; never part of append-only output. */
+    frame: () => readonly string[];
+    /** In-flight rows with their unresolved marks, emitted by a close that never concluded. */
+    flush: () => readonly string[];
     conclude: (result: InputWaitConclusion) => string;
     opened: () => boolean;
 }>;
-export type CallObservationStream = Readonly<{
-    observe: InputWaitStream["observe"];
+/**
+ * The call-observation projection of one input wait: the same admitted/observe/frame/flush/opened
+ * lifetime with the closing judgment translated from the native CallObservation.
+ */
+export type CallObservationStream = Readonly<Omit<InputWaitStream, "conclude"> & {
     conclude: (observation: CallObservation) => string;
-    opened: InputWaitStream["opened"];
 }>;
 /**
  * Live view over one observing input: its identity frame opens once, selected
@@ -162,26 +179,27 @@ type SnapshotCoreOptions = Readonly<{
 }>;
 export declare function snapshotText(view: SnapshotView, context: TextRenderContext, options?: SnapshotCoreOptions): string;
 export declare function killResultText(id: string, evidence: KillEvidence, alias?: string): string;
-export declare function mutationObservationStageText(id: string, observation: AkumaObservationStage, context: TextRenderContext, options?: SnapshotCoreOptions & Readonly<{
-    showLife?: boolean;
-}>): string;
 export declare function statusAnswer(view: Readonly<{
     status: AkumaObservation["status"];
 }>): string | undefined;
-export declare function akumaRawAnswer(result: AkumaInvocationResult): string | undefined;
-export declare function waitText(result: Extract<AkumaInvocationResult, {
-    action: "wait";
-}>, context: TextRenderContext): string;
-export declare function historyText(command: Extract<ParsedCommand, {
-    command: "history";
-    last: boolean;
-}>, result: Extract<AkumaInvocationResult, {
-    action: "history";
+/** Presentation-only state for one akuma invocation; it never reaches JSON. */
+type AkumaPresentation = Readonly<{
+    alias?: string;
+    streamed?: boolean;
+    structured?: boolean;
+    startedAt?: number;
+    selection?: readonly WaitSelectedIdentity[];
+}>;
+export declare function askRawAnswer(result: AkumaAskResult, structured: boolean | undefined): string | undefined;
+export declare function callRawAnswer(result: CallResult, streamed: boolean): string | undefined;
+export declare function waitRawAnswer(result: AkumaWaitResult, streamed: boolean): string | undefined;
+export declare function historyRawAnswer(result: AkumaHistoryResult, historyId: string | undefined): string | undefined;
+export declare function waitText(result: AkumaWaitResult, presentation: AkumaPresentation, context: TextRenderContext): string;
+export declare function historyText(result: AkumaHistoryResult, presentation: AkumaPresentation & Readonly<{
+    id?: string;
+    last?: boolean;
 }>, context: TextRenderContext): string;
-export declare function tellText(result: Extract<AkumaInvocationResult, {
-    action: "tell";
-    mode: "ordinary";
-}>, context: TextRenderContext, options?: Readonly<{
+export declare function tellText(result: AkumaTellResult, alias: string | undefined, context: TextRenderContext, options?: Readonly<{
     identity?: boolean;
 }>): string;
 export {};