@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/src/cli/parse.js

@@ -0,0 +1,348 @@
+import { isTaskAction, parseTaskCommand, renderTaskUsage, } from "./commands/task.js";
+import { isAkumaAction, parseAkumaCatalogPath, parseAkumaCommand, 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, usageLine } from "./usage.js";
+export { CliUsageError } from "./usage.js";
+const ROOT_USAGE = "usage: keiyaku [-C <path>] [--repo <path>] <command> [<contract>|@<contract>] [--flag ...] [-]";
+export function renderRootHelp() {
+    return [
+        ROOT_USAGE,
+        "",
+        "global options:",
+        "  -C, --cwd <path>  Set the invocation working directory.",
+        "  --repo <path>     Select the Git repository coordinate.",
+        "",
+        "commands:",
+        ...Object.values(CONTRACT_COMMAND_SPECS).flatMap((spec) => [`  ${spec.usage}`, `    ${spec.purpose}`]),
+        `  ${INSTALL_USAGE}`,
+        "    Install the Keiyaku skills into an agent harness.",
+        "  task ...",
+        "    Task coordination; see `keiyaku task --help`.",
+        ...renderAkumaRootRows(),
+    ].join("\n");
+}
+export function renderContractHelp(command) {
+    const spec = CONTRACT_COMMAND_SPECS[command];
+    return `${spec.purpose}\n\n${usageLine(spec.usage)}`;
+}
+function contractUsage(command) {
+    return usageLine(CONTRACT_COMMAND_SPECS[command].usage);
+}
+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);
+}
+function optionalFlag(flags, name) {
+    const value = flags[name];
+    return typeof value === "string" ? value : undefined;
+}
+function refuse(command, message) {
+    throw new CliUsageError(message, contractUsage(command));
+}
+function scanStdin(command, state, index, length) {
+    if (state.stdin)
+        refuse(command, "stdin marker '-' may appear only once");
+    if (index !== length - 1)
+        refuse(command, "stdin marker '-' must be the final argument");
+    if (CONTRACT_COMMAND_SPECS[command].stdin === "none")
+        refuse(command, `${command} reads no stdin`);
+    state.stdin = true;
+}
+function scanOption(command, argv, state, index) {
+    const token = argv[index];
+    const name = token.slice(2);
+    const spec = CONTRACT_COMMAND_SPECS[command];
+    const kind = spec.flags[name];
+    if (kind === undefined)
+        refuse(command, `option ${token} is not valid for ${command}`);
+    if (state.flags[name] !== undefined && kind !== "repeat-value")
+        refuse(command, `duplicate option: ${token}`);
+    if (kind === "boolean") {
+        state.flags[name] = true;
+        return index;
+    }
+    const value = argv[index + 1];
+    if (value === undefined || value === "-" || value.startsWith("--"))
+        refuse(command, `${token} requires a value`);
+    if (kind === "repeat-value") {
+        const values = state.flags[name];
+        state.flags[name] = [...(Array.isArray(values) ? values : values === undefined ? [] : [values]), value];
+    }
+    else {
+        state.flags[name] = value;
+    }
+    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 ?? ""}`, renderRootHelp());
+    }
+    const command = candidate;
+    const spec = CONTRACT_COMMAND_SPECS[command];
+    const state = { flags: {}, positionals: [], stdin: false };
+    for (let index = 1; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === "-") {
+            scanStdin(command, state, index, argv.length);
+            continue;
+        }
+        if (token.startsWith("--")) {
+            index = scanOption(command, argv, state, index);
+            continue;
+        }
+        state.positionals.push(token);
+    }
+    if (spec.positional === "none" && state.positionals.length > 0) {
+        refuse(command, `${command} accepts no contract`);
+    }
+    if (spec.positional === "optional" && state.positionals.length > 1) {
+        refuse(command, `${command} accepts at most one contract`);
+    }
+    if (spec.stdin === "required" && !state.stdin) {
+        refuse(command, `${command} requires stdin`);
+    }
+    const output = state.flags.json === true ? "json" : "text";
+    const actor = optionalFlag(state.flags, "actor");
+    return { command, ...state, output, ...(actor === undefined ? {} : { actor }) };
+}
+function parseBind(parts) {
+    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 = optionalFlag(parts.flags, "gates");
+    return {
+        command: "bind",
+        ...(task === undefined ? {} : { task }),
+        ...(target === undefined ? {} : { target }),
+        ...(parts.flags.here === true ? { workspace: "here" } : {}),
+        ...(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 = optionalFlag(parts.flags, "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 }),
+        output: parts.output,
+    };
+}
+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,
+        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 stdin '-' and --summary are mutually exclusive");
+    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 parseArc(parts) {
+    const contract = parts.positionals[0];
+    return {
+        command: "arc",
+        ...(contract === undefined ? {} : { contract }),
+        ...(parts.actor === undefined ? {} : { actor: parts.actor }),
+        output: parts.output,
+    };
+}
+function parseAbandon(parts) {
+    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,
+    };
+}
+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 parseShow(parts) {
+    const contract = parts.positionals[0];
+    return { command: "show", ...(contract === undefined ? {} : { contract }), output: parts.output };
+}
+function parseLs(parts) {
+    const path = parts.positionals[0];
+    if (path === "task/")
+        return { command: "ls", query: { kind: "tasks" }, output: parts.output };
+    if (path === "kei/")
+        return { command: "ls", query: { kind: "contracts" }, output: parts.output };
+    try {
+        const query = parseAkumaCatalogPath(path);
+        if (query === null)
+            refuse("ls", "ls requires an identity directory with a trailing slash");
+        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;
+    let stdinSeen = false;
+    const commandArgv = [];
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token !== "-C" && token !== "--cwd" && token !== "--repo") {
+            commandArgv.push(token);
+            if (token === "-")
+                stdinSeen = true;
+            continue;
+        }
+        if (stdinSeen)
+            throw new CliUsageError("stdin marker '-' must be the final argument", renderRootHelp());
+        if (token === "--repo" && repo !== undefined) {
+            throw new CliUsageError("--repo may appear only once", renderRootHelp());
+        }
+        if (token !== "--repo" && cwd !== undefined) {
+            throw new CliUsageError("-C/--cwd may appear only once", renderRootHelp());
+        }
+        const value = argv[index + 1];
+        if (value === undefined || value === "-" || value.startsWith("-")) {
+            throw new CliUsageError(`${token} requires a path`, renderRootHelp());
+        }
+        if (token === "--repo")
+            repo = value;
+        else
+            cwd = value;
+        index += 1;
+    }
+    return {
+        ...(cwd === undefined ? {} : { cwd }),
+        ...(repo === undefined ? {} : { repo }),
+        commandArgv,
+    };
+}
+function helpCoordinate(argv) {
+    const help = argv.indexOf("--help");
+    if (help < 0)
+        return null;
+    const words = argv.slice(0, help);
+    const root = words[0];
+    if (root === "task") {
+        const action = isTaskAction(words[1]) ? words[1] : undefined;
+        return { kind: "task", ...(action === undefined ? {} : { action }) };
+    }
+    if (root === "install")
+        return { kind: "install" };
+    if (isAkumaAction(root))
+        return { kind: "akuma", action: root };
+    if (root !== undefined && Object.hasOwn(CONTRACT_COMMAND_SPECS, root)) {
+        return { kind: "contract", command: root };
+    }
+    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": return parseArc(parts);
+        case "abandon": return parseAbandon(parts);
+        case "status": return parseStatus(parts);
+        case "show": return parseShow(parts);
+        case "ls": return parseLs(parts);
+        case "audit": {
+            const contract = parts.positionals[0];
+            return {
+                command: "audit",
+                ...(contract === undefined ? {} : { contract }),
+                showDiffBody: parts.flags["show-diff-body"] === 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 "settings": return { command: "settings", output: parts.output };
+    }
+}
+export function parseArgv(argv) {
+    const invocation = invocationOptions(argv);
+    const help = helpCoordinate(invocation.commandArgv);
+    if (help !== null)
+        return { help };
+    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;
+    return {
+        ...(invocation.cwd === undefined ? {} : { cwd: invocation.cwd }),
+        ...(invocation.repo === undefined ? {} : { repo: invocation.repo }),
+        command: task ?? akuma ?? install ?? parseCommand(scanArgv(invocation.commandArgv)),
+    };
+}

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

@@ -0,0 +1,13 @@
+import type { ActivityRow } from "../../akuma/index.js";
+type ToolRow = Extract<ActivityRow, {
+    kind: "tool";
+}>;
+export type ToolRepr = Readonly<{
+    label: string;
+    text: string;
+    overflow?: "middle-ellipsis";
+    suffix?: string;
+}>;
+/** Pure provider-neutral tool presentation; it performs no activity selection. */
+export declare function toolRepr(row: ToolRow): ToolRepr;
+export {};

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

@@ -0,0 +1,72 @@
+function oneLine(value) {
+    return value.replace(/\s+/gu, " ").trim();
+}
+function duration(milliseconds) {
+    if (milliseconds < 1_000)
+        return `${milliseconds}ms`;
+    const seconds = Math.round(milliseconds / 1_000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    const remainder = seconds % 60;
+    return remainder === 0 ? `${minutes}m` : `${minutes}m ${remainder}s`;
+}
+function result(row) {
+    if (row.state === "running")
+        return undefined;
+    const disposition = row.state.exitCode !== undefined
+        ? row.state.exitCode === 0 ? "ok" : `exit ${row.state.exitCode}`
+        : row.state.status;
+    const parts = [
+        ...(row.call.kind === "run" && row.durationMs !== undefined ? [duration(row.durationMs)] : []),
+        ...(row.call.kind === "fileChange" && disposition === "ok" ? [] : [disposition]),
+        ...(row.state.message === undefined ? [] : [oneLine(row.state.message)]),
+    ];
+    return parts.length === 0 ? undefined : parts.join(" · ");
+}
+function fileChange(call) {
+    const first = call.changes[0];
+    if (first === undefined)
+        return { label: "edit", text: "files" };
+    const label = call.changes.length === 1
+        ? first.op === "add" ? "write" : first.op === "delete" ? "delete" : "edit"
+        : "edit";
+    const subject = call.changes.length === 1
+        ? oneLine(first.path)
+        : `${call.changes.length} files · ${oneLine(first.path)} ...`;
+    const complete = call.changes.every((change) => change.diffstat !== undefined);
+    if (!complete)
+        return { label, text: subject };
+    const totals = call.changes.reduce((sum, change) => ({
+        added: sum.added + change.diffstat.added,
+        removed: sum.removed + change.diffstat.removed,
+    }), { added: 0, removed: 0 });
+    return { label, text: `${subject} — +${totals.added} -${totals.removed}` };
+}
+/** Pure provider-neutral tool presentation; it performs no activity selection. */
+export function toolRepr(row) {
+    let core;
+    switch (row.call.kind) {
+        case "run":
+            core = { label: "run", text: `$ ${oneLine(row.call.command)}`, overflow: "middle-ellipsis" };
+            break;
+        case "read":
+            core = { label: "read", text: oneLine(row.call.path) };
+            break;
+        case "search":
+            core = { label: "search", text: oneLine(row.call.query) };
+            break;
+        case "fileChange":
+            core = fileChange(row.call);
+            break;
+        case "other":
+            core = { label: "use", text: oneLine(row.call.display || row.name) };
+            break;
+    }
+    const suffix = result(row);
+    if (suffix === undefined)
+        return core;
+    return core.overflow === "middle-ellipsis"
+        ? { ...core, suffix: ` — ${suffix}` }
+        : { ...core, text: `${core.text} — ${suffix}` };
+}

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

@@ -0,0 +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 renderAkumaText(command: ParsedCommand, result: AkumaInvocationResult, context?: TextRenderContext): string;
+export declare function akumaExitCode(result: AkumaInvocationResult): number;
+export declare function akumaJsonValue(command: ParsedCommand, result: AkumaInvocationResult): unknown;
+export declare function renderAkumaJson(command: ParsedCommand, result: AkumaInvocationResult): string;

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

@@ -0,0 +1,194 @@
+import { toolRepr } from "./akuma-tool.js";
+import { displayColumns, renderBoundedTextBlock, renderVoiceRuler, safeText, truncateMiddleDisplayText } from "./terminal.js";
+const GUTTER_MS = 60_000;
+const LABEL_WIDTH = 6;
+const DEFAULT_CONTEXT = { columns: 80, color: false };
+function identity(id, alias) { return `${id}${alias === undefined ? "" : ` (${alias})`}`; }
+function ruler(left, columns, scope = "") {
+    if (scope !== "")
+        return renderVoiceRuler(left, scope, columns).trimEnd();
+    const width = Math.max(20, Math.min(80, columns));
+    return `${left} ${"─".repeat(Math.max(1, width - displayColumns(left) - 1))}`;
+}
+function clock(at) {
+    if (at === undefined)
+        return "";
+    const date = new Date(at);
+    return Number.isFinite(date.getTime()) ? `${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}` : "";
+}
+function label(value) { return `${value}${" ".repeat(Math.max(0, LABEL_WIDTH - displayColumns(value)))}`; }
+function renderSpineRow(item, context, profile, lastAt) {
+    const stamp = item.at === undefined ? undefined : Date.parse(item.at);
+    const printTime = stamp !== undefined && Number.isFinite(stamp) && (lastAt === undefined || stamp - lastAt >= GUTTER_MS);
+    const nextLastAt = printTime ? stamp : lastAt;
+    const gutter = `${printTime ? clock(item.at) : ""}`.padStart(5, " ");
+    const spine = item.spine === "turn" ? "┌│" : item.spine === "frontier" ? "┌⧖" : item.spine === "pending" ? " ⧗" : item.spine === "ok" ? " ✓" : item.spine === "error" ? " !" : " │";
+    const quote = item.quoted === true ? "“" : "";
+    const first = `${gutter}${spine} ${label(item.label)} ${quote}`;
+    if (item.indivisible === true)
+        return { lines: [`${first}${safeText(item.text)}`.trimEnd()], lastAt: nextLastAt };
+    if (item.overflow === "middle-ellipsis") {
+        const suffix = item.suffix ?? "";
+        const budget = Math.max(1, context.columns - displayColumns(first) - displayColumns(suffix));
+        return { lines: [`${first}${truncateMiddleDisplayText(item.text, budget)}${suffix}`.trimEnd()], lastAt: nextLastAt };
+    }
+    const continuation = `${"".padStart(gutter.length)}  │ ${"".padEnd(LABEL_WIDTH + 1, " ")}`;
+    const lines = renderBoundedTextBlock(item.text, { first, continuation, columns: context.columns, lines: profile === "history" ? Number.MAX_SAFE_INTEGER : (item.snapshotLines ?? 2), ...(item.truncated === true ? { truncated: true } : {}) });
+    return { lines: item.quoted === true ? lines.map((line, index) => index === lines.length - 1 ? `${line}”` : line) : lines, lastAt: nextLastAt };
+}
+function renderSpine(items, context, profile = "snapshot") {
+    let lastAt;
+    const lines = [];
+    for (const item of items) {
+        if (item.kind === "gap") {
+            if (item.count > 1)
+                lines.push(`     ⋮ +${item.count}`);
+            continue;
+        }
+        const rendered = renderSpineRow(item, context, profile, lastAt);
+        lastAt = rendered.lastAt;
+        lines.push(...rendered.lines);
+    }
+    return lines;
+}
+function activityLabel(row) {
+    if (row.kind === "said")
+        return "say";
+    if (row.kind === "thought")
+        return "think";
+    if (row.kind === "note")
+        return "note";
+    if (row.kind === "call" || row.kind === "turn")
+        return "call";
+    if (row.kind === "tell")
+        return "tell";
+    if (row.kind === "outcome")
+        return row.outcome.kind === "answered" ? "say" : "error";
+    return toolRepr(row).label;
+}
+function rowSpine(row, firstTurn, frontier) {
+    if (row.kind === "outcome")
+        return row.outcome.kind === "answered" ? "ok" : "error";
+    if (row.kind === "tell" && row.state === "pending")
+        return "pending";
+    if (frontier || (row.kind === "tool" && row.state === "running"))
+        return "frontier";
+    return firstTurn ? "turn" : "normal";
+}
+function rowText(row) {
+    if (row.kind === "said" || row.kind === "thought")
+        return { text: row.text, quoted: true, snapshotLines: row.kind === "said" ? 3 : 2 };
+    if (row.kind === "note")
+        return { text: row.text, snapshotLines: 2 };
+    if (row.kind === "call")
+        return { text: row.text, quoted: true, snapshotLines: 1 };
+    if (row.kind === "turn")
+        return { text: "", snapshotLines: 1 };
+    if (row.kind === "tell")
+        return { text: row.text, quoted: true, snapshotLines: 1 };
+    if (row.kind === "outcome")
+        return row.outcome.kind === "answered"
+            ? { text: row.outcome.answer, quoted: true, snapshotLines: 3 }
+            : { text: row.outcome.diagnostic, snapshotLines: 2 };
+    const repr = toolRepr(row);
+    return { text: repr.text, ...(repr.overflow === undefined ? {} : { overflow: repr.overflow }), ...(repr.suffix === undefined ? {} : { suffix: repr.suffix }), snapshotLines: 2 };
+}
+function rowItem(row, firstTurn, frontier) {
+    const truncated = "truncated" in row && row.truncated === true ? { truncated: true } : {};
+    return { kind: "row", at: row.at, label: activityLabel(row), spine: rowSpine(row, firstTurn, frontier), ...rowText(row), ...truncated };
+}
+function snapshotItems(entries) {
+    const seen = new Set();
+    return entries.flatMap((entry) => {
+        if (entry.kind === "gap")
+            return [entry];
+        const row = entry.row;
+        if (row.kind === "turn")
+            return [];
+        const first = "turnSequence" in row && !seen.has(row.turnSequence);
+        if ("turnSequence" in row)
+            seen.add(row.turnSequence);
+        return [rowItem(row, first, false)];
+    });
+}
+function snapshotText(view, context, options = {}) {
+    const status = view.status;
+    const items = [...snapshotItems(status.timeline.entries), ...(options.tail ?? [])];
+    return [ruler(identity(status.id, options.alias), context.columns, options.contractId ?? view.contractId), ...(options.facts ?? []), ...renderSpine(items, context)].filter(Boolean).join("\n");
+}
+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");
+    const history = result.history;
+    const rows = history.rows.map((row) => rowItem(row, false, false));
+    const contractId = result.historyResult.contractId;
+    const scope = contractId === undefined ? "history" : `history · ${contractId}`;
+    return [ruler(identity(result.akuma, result.alias), context.columns, scope), ...renderSpine(rows, context, "history")].join("\n");
+}
+function tellText(result, context) {
+    const facts = typeof result.result.tell.wake === "string" ? [] : [`! error ${safeText(result.result.tell.wake.diagnostic)}`];
+    return snapshotText(result.result.observation, context, { ...(result.alias === undefined ? {} : { alias: result.alias }), facts });
+}
+function dispatchLines(stage) {
+    if (stage.kind === "none")
+        return [];
+    if (stage.kind === "dispatched")
+        return [];
+    if (stage.failure.kind === "conflict")
+        return [`dispatch failed conflict ${stage.failure.current.contractId}`];
+    if (stage.failure.kind === "contention")
+        return ["dispatch failed contention"];
+    return [`dispatch failed ${stage.failure.kind} ${safeText(stage.failure.diagnostic)}`];
+}
+function callText(result, context) {
+    const alias = result.result.alias.kind === "aliased" ? result.result.alias.alias.alias : undefined;
+    const facts = [...dispatchLines(result.result.dispatch)];
+    const contractId = result.result.dispatch.kind === "dispatched" ? result.result.dispatch.dispatch.contractId : undefined;
+    const head = contractId === undefined ? identity(result.result.akuma, alias) : ruler(identity(result.result.akuma, alias), context.columns, contractId);
+    if (result.result.alias.kind === "failed")
+        facts.push(`alias failed ${result.result.alias.failure.kind} ${safeText(result.result.alias.failure.diagnostic)}`);
+    if (result.result.observation.kind === "detached")
+        return [head, ...facts].join("\n");
+    if (result.result.observation.kind === "failed")
+        return [head, ...facts, `! error ${safeText(result.result.observation.failure.diagnostic)}`].join("\n");
+    return snapshotText({ status: result.result.observation.status, ...(contractId === undefined ? {} : { contractId }) }, context, { ...(alias === undefined ? {} : { alias }), facts });
+}
+export function renderAkumaText(command, result, context = DEFAULT_CONTEXT) {
+    switch (result.action) {
+        case "call": return callText(result, context);
+        case "status": return snapshotText(result.status, context, { ...(result.alias === undefined ? {} : { alias: result.alias }) });
+        case "wait": return result.result.statuses.map((status) => snapshotText(status, context, { ...(result.alias === undefined ? {} : { alias: result.alias }) })).join("\n\n");
+        case "tell": return result.mode === "ordinary" ? tellText(result, context) : snapshotText(result.result.observation, context, { ...(result.alias === undefined ? {} : { alias: result.alias }) });
+        case "history": return historyText(command, result, context);
+        case "fork": {
+            if (result.receipt.kind !== "forked")
+                return result.receipt.kind === "unknown-history" ? `${result.receipt.at} has no matching retained answered turn` : result.receipt.kind === "provider-cannot-fork" ? `${result.receipt.provider} cannot fork` : result.receipt.kind === "fork-failed" ? result.receipt.diagnostic : result.receipt.diagnostic;
+            const contractId = result.receipt.dispatch.kind === "dispatched" ? result.receipt.dispatch.dispatch.contractId : undefined;
+            return contractId === undefined ? result.receipt.child : ruler(result.receipt.child, context.columns, contractId);
+        }
+        case "kill": return result.result.results.map((member) => snapshotText(member.observation, context, { facts: [`kill ${member.evidence}`], ...(result.alias === undefined ? {} : { alias: result.alias }) })).join("\n\n");
+    }
+}
+export function akumaExitCode(result) {
+    if (result.action === "call" && (result.result.dispatch.kind === "failed" || result.result.alias.kind === "failed" || result.result.observation.kind === "failed"))
+        return 2;
+    if (result.action === "kill" && result.result.results.some((member) => member.evidence === "unavailable" || member.evidence === "alive-after-sigkill"))
+        return 1;
+    if (result.action === "tell" && result.mode === "ordinary" && typeof result.result.tell.wake !== "string")
+        return 2;
+    if (result.action === "tell" && result.mode === "interrupt" && result.result.receipt.kind !== "interrupted")
+        return 1;
+    if (result.action === "fork" && result.receipt.kind !== "forked")
+        return result.receipt.kind === "upstream-forked" ? 2 : 1;
+    return 0;
+}
+export function akumaJsonValue(command, result) {
+    if (result.action === "call" || result.action === "fork" || result.action === "status" || result.action === "wait" || result.action === "tell" || result.action === "kill")
+        return result.action === "status" ? result.status : result.action === "wait" ? result.result : result.action === "tell" ? result.result : result.action === "kill" ? result.result : result.action === "call" ? result.result : result.receipt;
+    if (command.command !== "history")
+        throw new Error("history result requires the history command");
+    return result.historyResult;
+}
+export function renderAkumaJson(command, result) { return JSON.stringify(akumaJsonValue(command, result)); }

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

@@ -0,0 +1,2 @@
+import type { ObservationResult } from "../result.js";
+export declare function renderObservation(result: ObservationResult): string;

package/build/src/cli/render/board.js

@@ -0,0 +1,4 @@
+export function renderObservation(result) {
+    const { kind: _kind, command, ...observation } = result;
+    return [`observation ${command}`, JSON.stringify(observation, null, 2)].join("\n");
+}

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

@@ -0,0 +1,2 @@
+import type { Catalog } from "../../index.js";
+export declare function renderCatalogText(catalog: Catalog): string;

package/build/src/cli/render/catalog.js

@@ -0,0 +1,16 @@
+import { safeText } from "./terminal.js";
+export function renderCatalogText(catalog) {
+    if (catalog.kind === "tasks") {
+        return catalog.rows.map((row) => `${safeText(row.id)} - P${row.priority} - ${row.disposition} - ${safeText(row.title)}`).join("\n");
+    }
+    if (catalog.kind === "contracts") {
+        return catalog.rows.map((row) => `${safeText(row.id)} - ${row.phase}`).join("\n");
+    }
+    if (catalog.kind === "archetypes") {
+        return catalog.rows.flatMap((row) => [
+            `${safeText(row.name)}${row.model === undefined ? "" : ` - ${safeText(row.model)}`}`,
+            ...(row.description === undefined ? [] : [`  ${safeText(row.description)}`]),
+        ]).join("\n");
+    }
+    return catalog.rows.map((row) => `${safeText(row.id)} - ${row.life}`).join("\n");
+}