@astrosheep/keiyaku 4.1.1 → 4.1.2

package/build/src/cli/parse.js

@@ -1,9 +1,10 @@
 import { isTaskAction, parseTaskCommand, renderTaskHelp, renderTaskUsage, } from "./commands/task.js";
-import { isAkumaAction, parseAkumaCatalogPath, parseAkumaCommand, renderAkumaHelp, renderAkumaRootRows, renderAkumaUsage, } from "./commands/akuma.js";
+import { isAkumaAction, parseAkumaCommand, renderAkumaHelp, renderAkumaRootRows, renderAkumaUsage, } from "./commands/akuma.js";
 import { INSTALL_USAGE, parseInstallCommand, renderInstallHelp, } from "./commands/install.js";
-import { CONTRACT_COMMAND_SPECS, } from "./commands/contract.js";
-import { CliUsageError, isBlankInput, usageLine } from "./usage.js";
+import { CONTRACT_COMMAND_SPECS, parseContractCommand, renderContractHelp as renderContractHelpForOwner, renderContractUsage, } from "./commands/contract.js";
+import { CliUsageError, isBlankInput } from "./usage.js";
 export { CliUsageError } from "./usage.js";
+export { renderContractHelp } from "./commands/contract.js";
 const ROOT_USAGE = "usage: keiyaku [-C <path>] [--repo <path>] <command> [<contract>|@<contract>] [--flag ...] [-]";
 export function renderRootHelp() {
     return [
@@ -22,13 +23,8 @@ export function renderRootHelp() {
         ...renderAkumaRootRows(),
     ].join("\n");
 }
-export function renderContractHelp(command) {
-    const spec = CONTRACT_COMMAND_SPECS[command];
-    const help = `${spec.purpose}\n\n${usageLine(spec.usage)}`;
-    return spec.details === undefined ? help : `${help}\n\n${spec.details}`;
-}
 function contractUsage(command) {
-    return usageLine(CONTRACT_COMMAND_SPECS[command].usage);
+    return renderContractUsage(command);
 }
 export function renderCommandUsage(command) {
     if (command.command === "install")
@@ -44,7 +40,7 @@ export function renderHelp(coordinate) {
         case "root":
             return renderRootHelp();
         case "contract":
-            return renderContractHelp(coordinate.command);
+            return renderContractHelpForOwner(coordinate.command);
         case "task":
             return renderTaskHelp(coordinate.action);
         case "install":
@@ -103,10 +99,6 @@ export function assertExplicitRepoUse(command, repo) {
     if (repo !== undefined && !commandRepoPolicy(command).acceptsExplicit)
         refuseUnusedRepo(command);
 }
-function optionalFlag(flags, name) {
-    const value = flags[name];
-    return typeof value === "string" ? value : undefined;
-}
 function refuse(command, message) {
     throw new CliUsageError(message, contractUsage(command));
 }
@@ -179,147 +171,9 @@ function scanArgv(argv) {
         refuse(command, `${command} requires stdin`);
     }
     const output = state.flags.json === true ? "json" : "text";
-    const actor = optionalFlag(state.flags, "actor");
+    const actor = typeof state.flags.actor === "string" ? state.flags.actor : undefined;
     return { command, ...state, output, ...(actor === undefined ? {} : { actor }) };
 }
-function parseBind(parts) {
-    const forkOf = optionalFlag(parts.flags, "fork-of");
-    if (forkOf !== undefined) {
-        if (parts.stdin)
-            refuse("bind", "fork bind reads no stdin");
-        for (const option of ["task", "after", "gates"]) {
-            if (parts.flags[option] !== undefined)
-                refuse("bind", `--${option} is not valid with --fork-of`);
-        }
-        const target = optionalFlag(parts.flags, "target");
-        return {
-            command: "bind",
-            forkOf,
-            ...(target === undefined ? {} : { target }),
-            ...(parts.actor === undefined ? {} : { actor: parts.actor }),
-            output: parts.output,
-        };
-    }
-    if (!parts.stdin)
-        refuse("bind", "bind requires stdin");
-    const task = optionalFlag(parts.flags, "task");
-    const target = optionalFlag(parts.flags, "target");
-    const after = parts.flags.after === undefined ? [] : Array.isArray(parts.flags.after) ? parts.flags.after : [parts.flags.after];
-    const gates = parseGateBundleNames(parts, "bind");
-    return {
-        command: "bind",
-        ...(task === undefined ? {} : { task }),
-        ...(target === undefined ? {} : { target }),
-        ...(parts.flags.after === undefined ? {} : { after }),
-        ...(gates === undefined ? {} : { gates }),
-        ...(parts.actor === undefined ? {} : { actor: parts.actor }),
-        output: parts.output,
-    };
-}
-function parseAmend(parts) {
-    const contract = parts.positionals[0];
-    const after = parts.flags.after === undefined ? [] : Array.isArray(parts.flags.after) ? parts.flags.after : [parts.flags.after];
-    if (parts.flags["clear-after"] === true && after.length > 0)
-        refuse("amend", "--clear-after and --after are mutually exclusive");
-    const gates = parseGateBundleNames(parts, "amend");
-    if (!parts.stdin && parts.flags.after === undefined && parts.flags["clear-after"] !== true && gates === undefined) {
-        refuse("amend", "amend requires stdin or --after, --clear-after, or --gates");
-    }
-    return {
-        command: "amend",
-        ...(contract === undefined ? {} : { contract }),
-        ...(parts.flags.after === undefined ? {} : { after }),
-        ...(parts.flags["clear-after"] === true ? { clearAfter: true } : {}),
-        ...(gates === undefined ? {} : { gates }),
-        ...(parts.actor === undefined ? {} : { actor: parts.actor }),
-        ...(parts.stdin ? { stdin: true } : {}),
-        output: parts.output,
-    };
-}
-function parseGateBundleNames(parts, command) {
-    const value = optionalFlag(parts.flags, "gates");
-    if (value === undefined)
-        return undefined;
-    const names = value.split(",");
-    if (names.some((name) => name.length === 0)) {
-        refuse(command, "--gates requires nonempty comma-separated names");
-    }
-    return names;
-}
-function parseDeliver(parts) {
-    const contract = parts.positionals[0];
-    const message = optionalFlag(parts.flags, "message");
-    return {
-        command: "deliver",
-        ...(contract === undefined ? {} : { contract }),
-        ...(parts.actor === undefined ? {} : { actor: parts.actor }),
-        ...(message === undefined ? {} : { message }),
-        includeDirty: parts.flags["include-dirty"] === true,
-        materializeConflict: parts.flags["materialize-conflict"] === true,
-        output: parts.output,
-    };
-}
-function parseReview(parts) {
-    if (Number(parts.flags.satisfied === true) + Number(parts.flags.unsatisfied === true) !== 1) {
-        refuse("review", "review requires exactly one verdict flag");
-    }
-    const summary = optionalFlag(parts.flags, "summary");
-    if (parts.stdin === (summary !== undefined)) {
-        refuse("review", "review requires exactly one of --summary <text> or stdin '-'");
-    }
-    const contract = parts.positionals[0];
-    return {
-        command: "review",
-        ...(contract === undefined ? {} : { contract }),
-        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 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,
-    };
-}
-function parseRegion(parts) {
-    const contract = parts.positionals[0];
-    const pathFlag = parts.flags.path;
-    const paths = pathFlag === undefined ? undefined : Array.isArray(pathFlag) ? pathFlag : [pathFlag];
-    if (paths !== undefined && contract !== undefined)
-        refuse("region", "--path cannot combine with a contract");
-    return {
-        command: "region",
-        ...(contract === undefined ? {} : { contract }),
-        ...(paths === undefined ? {} : { paths: paths }),
-        output: parts.output,
-    };
-}
-function parseLs(parts) {
-    const path = parts.positionals[0];
-    if (path === "task" || path === "task/")
-        return { command: "ls", query: { kind: "tasks" }, output: parts.output };
-    if (path === "kei" || path === "kei/")
-        return { command: "ls", query: { kind: "contracts" }, output: parts.output };
-    try {
-        const query = parseAkumaCatalogPath(path);
-        if (query === null)
-            refuse("ls", "ls requires a supported identity directory selector");
-        return { command: "ls", query, output: parts.output };
-    }
-    catch (error) {
-        if (error instanceof CliUsageError)
-            throw error;
-        refuse("ls", error instanceof Error ? error.message : "invalid ls directory");
-    }
-}
 function invocationOptions(argv) {
     let cwd;
     let repo;
@@ -371,74 +225,6 @@ function helpCoordinate(argv) {
     }
     return { kind: "root" };
 }
-function parseCommand(parts) {
-    switch (parts.command) {
-        case "bind":
-            return parseBind(parts);
-        case "amend":
-            return parseAmend(parts);
-        case "deliver":
-            return parseDeliver(parts);
-        case "review":
-            return parseReview(parts);
-        case "arc": {
-            const contract = parts.positionals[0];
-            return {
-                command: "arc",
-                ...(contract === undefined ? {} : { contract }),
-                ...(parts.actor === undefined ? {} : { actor: parts.actor }),
-                output: parts.output,
-            };
-        }
-        case "abandon": {
-            const contract = parts.positionals[0];
-            const note = optionalFlag(parts.flags, "note");
-            return {
-                command: "abandon",
-                ...(contract === undefined ? {} : { contract }),
-                ...(note === undefined ? {} : { note }),
-                ...(parts.actor === undefined ? {} : { actor: parts.actor }),
-                output: parts.output,
-            };
-        }
-        case "status":
-            return parseStatus(parts);
-        case "show": {
-            const contract = parts.positionals[0];
-            return { command: "show", ...(contract === undefined ? {} : { contract }), output: parts.output };
-        }
-        case "ls":
-            return parseLs(parts);
-        case "audit": {
-            const contract = parts.positionals[0];
-            return {
-                command: "audit",
-                ...(contract === undefined ? {} : { contract }),
-                includeDirty: parts.flags["include-dirty"] === true,
-                showDiff: parts.flags.diff === true,
-                ...(parts.actor === undefined ? {} : { actor: parts.actor }),
-                output: parts.output,
-            };
-        }
-        case "reconcile": {
-            const contract = parts.positionals[0];
-            return {
-                command: "reconcile",
-                ...(contract === undefined ? {} : { contract }),
-                retryHooks: parts.flags["retry-hooks"] === true,
-                output: parts.output,
-            };
-        }
-        case "nuke": {
-            const confirm = optionalFlag(parts.flags, "confirm");
-            return { command: "nuke", ...(confirm === undefined ? {} : { confirm }), output: parts.output };
-        }
-        case "settings":
-            return { command: "settings", output: parts.output };
-        case "region":
-            return parseRegion(parts);
-    }
-}
 export function parseArgv(argv) {
     const invocation = invocationOptions(argv);
     const help = helpCoordinate(invocation.commandArgv);
@@ -455,6 +241,6 @@ export function parseArgv(argv) {
     return {
         ...(invocation.cwd === undefined ? {} : { cwd: invocation.cwd }),
         ...(invocation.repo === undefined ? {} : { repo: invocation.repo }),
-        command: task ?? akuma ?? install ?? parseCommand(scanArgv(invocation.commandArgv)),
+        command: task ?? akuma ?? install ?? parseContractCommand(scanArgv(invocation.commandArgv)),
     };
 }

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

@@ -0,0 +1,38 @@
+import type { AkumaObservation, AkumaObservationStage, CreatedTaskObservation, DispatchAssociation } from "../../index.js";
+import type { AkumaInvocationResult } from "../commands/akuma-invoke.js";
+import type { ParsedCommand } from "../parse.js";
+import { type TextRenderContext } from "./terminal.js";
+export declare const DEFAULT_CONTEXT: TextRenderContext;
+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[];
+type SnapshotView = Readonly<{
+    status: AkumaObservation["status"];
+    contract: DispatchAssociation;
+    createdTasks?: CreatedTaskObservation;
+}>;
+type SnapshotCoreOptions = Readonly<{
+    alias?: string;
+    facts?: readonly string[];
+}>;
+export declare function snapshotText(view: SnapshotView, context: TextRenderContext, options?: SnapshotCoreOptions): 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";
+}>, context: TextRenderContext): string;
+export declare function tellText(result: Extract<AkumaInvocationResult, {
+    action: "tell";
+    mode: "ordinary";
+}>, context: TextRenderContext): string;
+export {};

package/build/src/cli/render/akuma-activity.js

@@ -0,0 +1,362 @@
+import { defaultWaitComplete } from "../../akuma/index.js";
+import { toolRepr } from "./akuma-tool.js";
+import { displayColumns, renderBoundedTextBlock, safeText, truncateMiddleDisplayText, } from "./terminal.js";
+export const DEFAULT_CONTEXT = { columns: 80, color: false };
+const SNAPSHOT_RULER = "────────────";
+const TIME_WIDTH = 5;
+const VERB_WIDTH = 6;
+function identity(id, alias) {
+    return `${id}${alias === undefined ? "" : ` (${alias})`}`;
+}
+function associatedContractId(contract) {
+    return contract.kind === "associated" ? contract.contractId : undefined;
+}
+export function associatedIdentity(id, alias, contract) {
+    const contractId = contract === undefined ? undefined : associatedContractId(contract);
+    return `${identity(id, alias)}${contractId === undefined ? "" : ` [${contractId}]`}`;
+}
+export function snapshotHeading(id, alias, contract) {
+    const contractId = contract === undefined ? undefined : associatedContractId(contract);
+    return [identity(id, alias), SNAPSHOT_RULER, ...(contractId === undefined ? [] : [`└─ ${contractId}`])];
+}
+function answeredHeading(id, alias) {
+    return [`✓ came back ${identity(id, alias)}`, SNAPSHOT_RULER].join("\n");
+}
+function contractFacts(contract) {
+    return contract.kind === "failed" ? [`! contract failed ${safeText(contract.diagnostic)}`] : [];
+}
+function unobservedText(id, diagnostic) {
+    return `! ${id} unobserved: ${safeText(diagnostic)}`;
+}
+function lifeLabel(life) {
+    if (life === "running")
+        return "● STILL RUNNING";
+    if (life === "asleep")
+        return "✓ came back";
+    if (life === "killed")
+        return "× killed";
+    return `? ${life}`;
+}
+function pendingWithoutLiveBody(status) {
+    if (status.life === "running")
+        return 0;
+    return status.timeline.entries.reduce((count, entry) => count + (entry.kind === "row" && entry.row.kind === "tell" && entry.row.state === "pending" ? 1 : 0), 0);
+}
+function clock(at) {
+    const date = new Date(at);
+    return Number.isFinite(date.getTime())
+        ? `${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}`
+        : "unknown";
+}
+function label(row) {
+    if (row.kind === "said")
+        return "say";
+    if (row.kind === "thought")
+        return "think";
+    if (row.kind === "note")
+        return "note";
+    if (row.kind === "call")
+        return "call";
+    if (row.kind === "tell")
+        return "tell";
+    if (row.kind === "outcome")
+        return row.outcome.kind === "answered" ? "say" : "error";
+    if (row.kind === "turn")
+        return "call";
+    return toolRepr(row).label;
+}
+function mark(row) {
+    if (row.kind === "outcome")
+        return row.outcome.kind === "answered" ? "✓" : "!";
+    if (row.kind === "tell" && row.state === "pending")
+        return "⧗";
+    if (row.kind === "tool") {
+        if (row.state === "active")
+            return "⧖";
+        if (row.state === "unsettled")
+            return "?";
+        return row.state.status === "ok" ? "✓" : "!";
+    }
+    return "│";
+}
+function rowText(row) {
+    if (row.kind === "said" ||
+        row.kind === "thought" ||
+        row.kind === "note" ||
+        row.kind === "call" ||
+        row.kind === "tell") {
+        return {
+            text: row.text,
+            lines: row.kind === "said" || row.kind === "thought" ? 2 : row.kind === "tell" || row.kind === "call" ? 1 : 2,
+        };
+    }
+    if (row.kind === "outcome")
+        return row.outcome.kind === "answered"
+            ? { text: row.outcome.answer, lines: 3 }
+            : { text: row.outcome.diagnostic, lines: 2 };
+    if (row.kind === "turn")
+        return { text: "", lines: 1 };
+    const repr = toolRepr(row);
+    return {
+        text: repr.text,
+        lines: 2,
+        ...(repr.overflow === "middle-ellipsis" ? { middle: true } : {}),
+        ...(repr.suffix === undefined ? {} : { suffix: repr.suffix }),
+    };
+}
+function eventPrefix(glyph, verb, time) {
+    const gutter = time === undefined ? " ".repeat(TIME_WIDTH) : time.padEnd(TIME_WIDTH);
+    return `${gutter} ${glyph} ${verb.padEnd(VERB_WIDTH)} `;
+}
+function continuationPrefix() {
+    return eventPrefix("│", "");
+}
+function quotedBody(row) {
+    return (row.kind === "said" ||
+        row.kind === "thought" ||
+        row.kind === "tell" ||
+        (row.kind === "outcome" && row.outcome.kind === "answered"));
+}
+function quoteLines(lines, prefix) {
+    const prefixWidth = prefix.length;
+    return lines.map((line) => {
+        const body = line.slice(prefixWidth);
+        if (body.length === 0)
+            return line;
+        return `${line.slice(0, prefixWidth)}“${body}”`;
+    });
+}
+function renderMiddleEllipsis(first, text, suffix, columns) {
+    const prefixWidth = displayColumns(first);
+    const remaining = columns - prefixWidth;
+    const suffixWidth = displayColumns(suffix);
+    const withSuffix = remaining - suffixWidth;
+    // `$ ` + one head char + ellipsis + tail; cue and ellipsis alone are not a subject.
+    const showSuffix = suffix.length > 0 && withSuffix >= 6;
+    return `${first}${truncateMiddleDisplayText(text, Math.max(0, showSuffix ? withSuffix : remaining))}${showSuffix ? suffix : ""}`;
+}
+function renderRow(row, context, history, first) {
+    const value = rowText(row);
+    const quoted = quotedBody(row);
+    const quoteWidth = quoted ? 2 : 0;
+    if (value.middle === true) {
+        return [renderMiddleEllipsis(first, value.text, value.suffix ?? "", context.columns - quoteWidth)];
+    }
+    const lines = renderBoundedTextBlock(value.text, {
+        first,
+        continuation: continuationPrefix(),
+        columns: context.columns - quoteWidth,
+        lines: history ? Number.MAX_SAFE_INTEGER : value.lines,
+        ...("truncated" in row && row.truncated === true ? { truncated: true } : {}),
+    });
+    return quoted ? quoteLines(lines, first) : lines;
+}
+function groupedEntries(entries, context, history = false) {
+    const lines = [];
+    let previousClock;
+    for (const entry of entries) {
+        if (entry.kind === "gap") {
+            lines.push(`${" ".repeat(TIME_WIDTH)} ⋮ ${entry.count} omitted`);
+            continue;
+        }
+        const row = entry.row;
+        const at = clock(row.at);
+        const changed = previousClock === undefined || at !== previousClock;
+        lines.push(...renderRow(row, context, history, eventPrefix(mark(row), label(row), changed ? at : undefined)));
+        previousClock = at;
+    }
+    return lines;
+}
+function groupedRows(rows, context, history = false) {
+    return groupedEntries(rows.filter((row) => row.kind !== "turn").map((row) => ({ kind: "row", row })), context, history);
+}
+function taskDispositionMark(disposition) {
+    if (disposition === "done")
+        return "✓";
+    if (disposition === "drop")
+        return "×";
+    if (disposition === "on_hold")
+        return "⧗";
+    if (disposition === "in_progress")
+        return "●";
+    return disposition === "blocked" ? "‖" : "○";
+}
+function changeStat(group) {
+    let added = 0;
+    let removed = 0;
+    for (const change of group) {
+        if (change.diffstat === undefined)
+            return "+? -?";
+        added += change.diffstat.added;
+        removed += change.diffstat.removed;
+    }
+    return `+${added} -${removed}`;
+}
+function groupedChangeRows(changes) {
+    const groups = [];
+    const seen = new Map();
+    for (const change of changes) {
+        const index = seen.get(change.path);
+        if (index === undefined) {
+            seen.set(change.path, groups.length);
+            groups.push([change]);
+        }
+        else
+            groups[index].push(change);
+    }
+    return groups.map((group) => ({ path: group[0].path, stat: changeStat(group) }));
+}
+function renderReportedChangeLines(snapshot) {
+    const rows = groupedChangeRows(snapshot.reportedChanges);
+    const width = rows.reduce((max, row) => Math.max(max, row.stat.length), 0);
+    return [
+        `changes ${snapshot.reportedChanges.length + snapshot.reportedChangesOmitted}`,
+        ...rows.map((row) => `  ${row.stat.padEnd(width)}  ${safeText(row.path)}`),
+        ...(snapshot.reportedChangesOmitted > 0 ? [`  ⋮ ${snapshot.reportedChangesOmitted} earlier changes`] : []),
+    ];
+}
+function renderTaskRow(row, columns) {
+    const prefix = `  ${taskDispositionMark(row.disposition)} ${row.id} · `;
+    const body = `${safeText(row.title)} · ${row.disposition} · P${row.priority}`;
+    const inline = `${prefix}${body}`;
+    if (displayColumns(inline) <= columns)
+        return [inline];
+    return renderBoundedTextBlock(body, {
+        first: prefix,
+        continuation: "    ",
+        columns,
+        lines: Number.MAX_SAFE_INTEGER,
+    });
+}
+function renderTaskContextLines(created, columns) {
+    if (created === undefined)
+        return [];
+    if (created.kind === "failed")
+        return [`! tasks failed ${safeText(created.diagnostic)}`];
+    return [`tasks ${created.rows.length}`, ...created.rows.flatMap((row) => renderTaskRow(row, columns))];
+}
+function answerContextLines(observation, columns) {
+    return [
+        ...renderTaskContextLines(observation.createdTasks, columns),
+        ...renderReportedChangeLines(observation.status.timeline),
+    ];
+}
+function answeredBlock(observation, answer, alias, columns) {
+    const context = answerContextLines(observation, columns).join("\n");
+    if (context.length === 0)
+        return `${answeredHeading(observation.status.id, alias)}\n${answer}`;
+    const separator = answer.endsWith("\n") ? "\n" : "\n\n";
+    return `${answeredHeading(observation.status.id, alias)}\n${answer}${separator}${context}`;
+}
+function snapshotCore(view, context, options) {
+    const snapshot = view.status.timeline;
+    const activity = snapshot.kind === "idle" && snapshot.outcome !== undefined
+        ? groupedRows([
+            ...snapshot.entries.filter((entry) => entry.kind === "row").map((entry) => entry.row),
+            snapshot.outcome,
+        ].sort((left, right) => left.sequence - right.sequence), context)
+        : groupedEntries(snapshot.entries, context);
+    const facts = [
+        ...(view.status.readonly?.enforcement === "none" ? [`! ${safeText(view.status.readonly.diagnostic)}`] : []),
+        ...contractFacts(view.contract),
+        ...(options.facts ?? []),
+    ];
+    const pending = pendingWithoutLiveBody(view.status);
+    return {
+        activity,
+        lines: [
+            ...snapshotHeading(view.status.id, options.alias, view.contract),
+            ...facts,
+            ...activity,
+            ...(pending === 0 ? [] : [`pending ${pending} tells · no live body`]),
+        ],
+    };
+}
+export function snapshotText(view, context, options = {}) {
+    const core = snapshotCore(view, context, options);
+    const taskContext = renderTaskContextLines(view.createdTasks, context.columns);
+    return [
+        ...core.lines,
+        ...(core.activity.length > 0 && taskContext.length > 0 ? [""] : []),
+        ...taskContext,
+        ...renderReportedChangeLines(view.status.timeline),
+        "",
+        lifeLabel(view.status.life),
+    ].join("\n");
+}
+function mutationSnapshotText(view, context, options = {}) {
+    const core = snapshotCore(view, context, options);
+    return [...core.lines, ...(options.showLife === false ? [] : ["", lifeLabel(view.status.life)])].join("\n");
+}
+export function mutationObservationStageText(id, observation, context, options = {}) {
+    if (observation.kind === "unobserved")
+        return unobservedText(id, observation.diagnostic);
+    return mutationSnapshotText(observation, context, options);
+}
+export function statusAnswer(view) {
+    if (!defaultWaitComplete(view.status))
+        return undefined;
+    if (view.status.life !== "asleep")
+        return undefined;
+    if (view.status.readonly?.enforcement === "none")
+        return undefined;
+    const timeline = view.status.timeline;
+    if (timeline.kind !== "idle" || timeline.outcome?.outcome.kind !== "answered")
+        return undefined;
+    return timeline.outcome.outcome.answer;
+}
+function answerCallFailed(result) {
+    return result.dispatch.kind === "failed" || result.alias.kind === "failed" || result.readonly?.enforcement === "none";
+}
+export function akumaRawAnswer(result) {
+    if (result.action === "call") {
+        if (answerCallFailed(result.result) || result.result.observation.kind !== "observed")
+            return undefined;
+        return statusAnswer({ status: result.result.observation.status });
+    }
+    if (result.action === "wait" && result.result.observations.length === 1)
+        return statusAnswer(result.result.observations[0]);
+    return undefined;
+}
+export function waitText(result, context) {
+    const alias = result.alias;
+    const total = result.result.observations.length + result.result.unobserved.length;
+    const done = result.result.observations.filter((observation) => defaultWaitComplete(observation.status)).length;
+    const blocks = [
+        ...result.result.observations.map((observation) => {
+            const answer = statusAnswer(observation);
+            if (answer !== undefined)
+                return answeredBlock(observation, answer, alias, context.columns);
+            return snapshotText(observation, context, { ...(alias === undefined ? {} : { alias }) });
+        }),
+        ...result.result.unobserved.map((member) => unobservedText(member.id, member.diagnostic)),
+    ];
+    if (total <= 1)
+        return blocks.join("\n\n");
+    return [...blocks, `${done} of ${total} done`].join("\n\n");
+}
+export function historyText(command, result, context) {
+    if (command.last)
+        return result.mode === "last" ? result.answer : "no answer retained";
+    if (result.mode !== "page")
+        throw new Error("history result lacks page");
+    return [
+        ...snapshotHeading(result.akuma, result.alias, result.historyResult.contract),
+        ...groupedRows(result.history.rows, context, true),
+    ].join("\n");
+}
+export function tellText(result, context) {
+    const wake = result.result.tell.wake;
+    const facts = wake.kind === "failed"
+        ? [
+            `! wake failed · ${safeText(wake.diagnostic)}${wake.child === undefined ? "" : ` · log ${wake.child.log.path} ${wake.child.log.from}..${wake.child.log.to}`}`,
+        ]
+        : wake.kind === "pursuing"
+            ? []
+            : [`wake ${wake.kind}`];
+    return mutationObservationStageText(result.result.akuma, result.result.observation, context, {
+        ...(result.alias === undefined ? {} : { alias: result.alias }),
+        facts,
+        showLife: false,
+    });
+}

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

@@ -1,7 +1,7 @@
 import type { AkumaInvocationResult } from "../commands/akuma-invoke.js";
 import type { ParsedCommand } from "../parse.js";
 import { type TextRenderContext } from "./terminal.js";
-export declare function akumaRawAnswer(result: AkumaInvocationResult): string | undefined;
+export { akumaRawAnswer } from "./akuma-activity.js";
 export declare function renderAkumaText(command: ParsedCommand, result: AkumaInvocationResult, context?: TextRenderContext): string;
 export declare function akumaExitCode(result: AkumaInvocationResult): number;
 export declare function akumaJsonValue(result: AkumaInvocationResult): unknown;