@astrosheep/keiyaku 4.0.2 → 4.0.4

package/build/src/cli/invoke.js

@@ -1,5 +1,5 @@
-import { AkumaWorldScopeError, gatesFrom, Keiyaku, requireBranchesToBeUpToDateFrom, settings, SettingsError, worktreeHooksFrom } from "../index.js";
-import { kanshi, selectKanshi, selectRegion } from "../kanshi/index.js";
+import { AkumaWorldScopeError, gatesFrom, Keiyaku, KeiyakuRefused, requireBranchesToBeUpToDateFrom, settings, SettingsError, worktreeHooksFrom, } from "../index.js";
+import { kanshi, observeKanshi, selectKanshi, selectRegion, } from "../kanshi/index.js";
 import { resolveActor } from "./actor.js";
 import { acceptedAbandon, acceptedAmend, acceptedArc, acceptedAudit, acceptedBind, acceptedDeliver, acceptedReview, resultFromMutationCall, } from "./accepted.js";
 import { amendFromCommand } from "./commands/amend.js";
@@ -10,7 +10,7 @@ import { installHarnesses } from "./commands/install.js";
 import { invokeTask } from "./commands/task-invoke.js";
 import { CliUsageError, renderCommandUsage } from "./parse.js";
 import { isBlankInput } from "./usage.js";
-import { contractFromInput, resolveContextualContract, resolveKanshiContract } from "./selectors.js";
+import { canonicalContractSelector, contractFromInput, resolveContextualContract, resolveKanshiContract, } from "./selectors.js";
 import { resolveNamedAddress } from "../library/address.js";
 import { assertExplicitRepoUse, resolveCliCoordinates } from "./coordinates.js";
 import { BindDraftError, preserveBindDraft } from "./draft.js";
@@ -23,9 +23,10 @@ async function readStdin() {
 function selectedStdinDiagnostic(command) {
     switch (command.command) {
         case "bind":
-        case "amend":
         case "arc":
             return `${command.command} requires a nonblank stdin document`;
+        case "amend":
+            return command.stdin === true ? "amend requires a nonblank stdin document" : undefined;
         case "review":
             return command.summaryFromStdin === true ? "review requires a nonblank summary" : undefined;
         case "call":
@@ -53,13 +54,12 @@ async function withAcquiredStdin(command, runtime) {
         throw new CliUsageError(diagnostic);
     return { ...runtime, readStdin: async () => bytes };
 }
-function settingsAt(root, environment) {
-    const home = environment.KEIYAKU_HOME?.trim();
-    return settings({ ...(root === undefined ? {} : { root }), ...(home === undefined || home.length === 0 ? {} : { home }) });
+function settingsAt(root, home) {
+    return settings({ ...(root === undefined ? {} : { root }), ...(home === undefined ? {} : { home }) });
 }
-function selectedGates(value, name) {
+function consumeSettings(run) {
     try {
-        return gatesFrom({ settings: value, ...(name === undefined ? {} : { name }) });
+        return run();
     }
     catch (error) {
         if (error instanceof SettingsError)
@@ -67,25 +67,11 @@ function selectedGates(value, name) {
         throw error;
     }
 }
-function selectedHooks(value) {
-    try {
-        return worktreeHooksFrom({ settings: value });
-    }
-    catch (error) {
-        if (error instanceof SettingsError)
-            throw new CliUsageError(error.message);
-        throw error;
-    }
+function selectedGates(value, name) {
+    return consumeSettings(() => gatesFrom({ settings: value, ...(name === undefined ? {} : { name }) }));
 }
 function selectedGitPolicy(value) {
-    try {
-        return requireBranchesToBeUpToDateFrom({ settings: value });
-    }
-    catch (error) {
-        if (error instanceof SettingsError)
-            throw new CliUsageError(error.message);
-        throw error;
-    }
+    return consumeSettings(() => requireBranchesToBeUpToDateFrom({ settings: value }));
 }
 function actorFromEdge(actor, environment) {
     let resolved;
@@ -127,7 +113,7 @@ async function invokeBind({ parsed, repo, edge, configuration, hooks, establishW
             const bound = accepted.facts.find((fact) => fact.kind === "bind");
             if (bound === undefined || bound.kind !== "bind")
                 throw new Error("accepted bind is missing its bind fact");
-            return acceptedBind(accepted, bound.data.coordinates.target ?? null);
+            return acceptedBind(accepted, bound.data.coordinates);
         });
         if (result.kind !== "refused")
             return result;
@@ -182,11 +168,19 @@ async function invokeExisting({ parsed, repo, edge, scope, configuration, hooks
     const seat = { contract, id, ...(actor === undefined ? {} : { actor }), hooks };
     switch (parsed.command) {
         case "amend": {
-            const markdown = await edge.readStdin();
+            const markdown = parsed.stdin === true ? await edge.readStdin() : undefined;
             const gates = parsed.gates === undefined
                 ? undefined
                 : selectedGates(configuration, parsed.gates);
-            return resultFromMutationCall("amend", () => amendFromCommand({ command: parsed, repo, contract, markdown, gates, ...(actor === undefined ? {} : { actor }), hooks }), (result) => acceptedAmend(result, id), { coordinate: id });
+            return resultFromMutationCall("amend", () => amendFromCommand({
+                command: parsed,
+                repo,
+                contract,
+                ...(markdown === undefined ? {} : { markdown }),
+                gates,
+                ...(actor === undefined ? {} : { actor }),
+                hooks,
+            }), (result) => acceptedAmend(result, id), { coordinate: id });
         }
         case "deliver":
             return invokeDeliver(parsed, seat, selectedGitPolicy(configuration));
@@ -212,32 +206,23 @@ async function invokeExisting({ parsed, repo, edge, scope, configuration, hooks
             return parsed;
     }
 }
-async function invokeAkumaCommand(parsed, input) {
-    const { path, executionCwd, repo, configuration, edge } = input;
-    if (parsed.command === "call" && parsed.contract !== undefined) {
-        if (repo === undefined)
+async function invokeAkumaFromEdge(parsed, input) {
+    try {
+        const { path, statedCwd, repo, home, configuration, edge } = input;
+        if (parsed.command === "call" && parsed.contract !== undefined && repo === undefined) {
             throw new Error("call with Contract requires a resolved Repo");
-        const selected = contractFromInput(repo, parsed.contract);
+        }
         return await invokeAkuma(parsed, {
             path,
-            ...(executionCwd === undefined ? {} : { executionCwd }),
-            settings: configuration,
-            contract: selected.contract,
+            ...(statedCwd === undefined ? {} : { statedCwd }),
+            ...(home === undefined ? {} : { home }),
+            ...(configuration === undefined ? {} : { settings: configuration }),
+            ...(parsed.command === "call" && parsed.contract !== undefined
+                ? { contract: contractFromInput(repo, parsed.contract).contract }
+                : repo === undefined ? {} : { repo }),
             readStdin: edge.readStdin,
         });
     }
-    return await invokeAkuma(parsed, {
-        path,
-        ...(executionCwd === undefined ? {} : { executionCwd }),
-        settings: configuration,
-        ...(repo === undefined ? {} : { repo }),
-        readStdin: edge.readStdin,
-    });
-}
-async function invokeAkumaFromEdge(parsed, input) {
-    try {
-        return await invokeAkumaCommand(parsed, input);
-    }
     catch (error) {
         if (error instanceof AkumaWorldScopeError)
             throw error;
@@ -252,7 +237,7 @@ async function akumaWorldFor(parsed, located, candidate, establish) {
         throw new CliUsageError("no Keiyaku world contains the invocation cwd");
     return world;
 }
-async function invokeCatalog(parsed, world, repo, edge) {
+async function invokeCatalog(parsed, world, repo, home) {
     try {
         if (parsed.query.kind === "contracts") {
             if (repo === undefined)
@@ -262,7 +247,7 @@ async function invokeCatalog(parsed, world, repo, edge) {
         if (parsed.query.kind === "archetypes") {
             return {
                 kind: "catalog",
-                catalog: await Keiyaku.ls({ query: parsed.query, settings: await settingsAt(undefined, edge.environment) }),
+                catalog: await Keiyaku.ls({ query: parsed.query, ...(home === undefined ? {} : { home }) }),
             };
         }
         if (world === null)
@@ -278,12 +263,11 @@ async function invokeCatalog(parsed, world, repo, edge) {
         throw error;
     }
 }
-async function invokeStatus(parsed, world, repo, edge) {
-    const configuration = await settingsAt(world ?? undefined, edge.environment);
+async function invokeStatus(parsed, world, repo) {
     if (parsed.akuma === true) {
         if (world === null)
             throw new CliUsageError("no Keiyaku world contains the invocation cwd");
-        return invokeAkumaStatus(world, parsed.contract, configuration, undefined, repo);
+        return invokeAkumaStatus(world, parsed.contract, undefined, repo);
     }
     if (parsed.contract === undefined) {
         const report = await kanshi({ world, ...(repo === undefined ? {} : { repo }) });
@@ -291,18 +275,18 @@ async function invokeStatus(parsed, world, repo, edge) {
     }
     if (parsed.contract.startsWith("@")) {
         try {
-            const address = await resolveNamedAddress({
-                path: world,
+            const observation = await observeKanshi({ world, ...(repo === undefined ? {} : { repo }) });
+            const address = resolveNamedAddress({
                 selector: parsed.contract,
-                contracts: repo === undefined ? [] : (await Keiyaku.list({ repo })).rows,
+                report: observation.report,
+                aliases: observation.aliases,
             });
             if (address.kind === "akuma") {
                 if (world === null)
                     throw new CliUsageError("no Keiyaku world contains the invocation cwd");
-                return invokeAkumaStatus(world, address.id, configuration, parsed.contract, repo);
+                return invokeAkumaStatus(world, address.id, parsed.contract, repo);
             }
-            const report = await kanshi({ world, ...(repo === undefined ? {} : { repo }) });
-            return { kind: "status", report: selectKanshi({ report, contract: address.id }), selection: "contract" };
+            return { kind: "status", report: selectKanshi({ report: observation.report, contract: address.id }), selection: "contract" };
         }
         catch (error) {
             if (error instanceof TypeError)
@@ -310,6 +294,16 @@ async function invokeStatus(parsed, world, repo, edge) {
             throw error;
         }
     }
+    if (parsed.contract.startsWith("kei/")) {
+        if (repo === undefined)
+            throw new CliUsageError("cannot select a contract while the Contract world is absent");
+        const contract = canonicalContractSelector(parsed.contract);
+        return {
+            kind: "status",
+            report: await kanshi({ world, repo, contract }),
+            selection: "contract",
+        };
+    }
     const report = await kanshi({ world, ...(repo === undefined ? {} : { repo }) });
     const contract = resolveKanshiContract(report, parsed.contract);
     return { kind: "status", report: selectKanshi({ report, contract }), selection: "contract" };
@@ -343,6 +337,22 @@ async function invokeRegion(parsed, world, repo) {
     const selection = parsed.overlap ? { kind: "overlap", contract } : { kind: "contract", contract };
     return { kind: "region", region: { kind: "present", value: selectRegion({ declarations: report.region.value.declarations, selection }) } };
 }
+async function invokeContractHistory(repo, contract) {
+    if (repo === undefined)
+        throw new Error("history kei/... requires a resolved Repo");
+    const selected = contractFromInput(repo, contract);
+    try {
+        return { kind: "contract-history", history: await selected.contract.history() };
+    }
+    catch (error) {
+        if (error instanceof TypeError)
+            throw new CliUsageError(error.message);
+        if (error instanceof KeiyakuRefused) {
+            return { kind: "refused", verb: "history", contract: selected.id, refusal: error.refusal };
+        }
+        throw error;
+    }
+}
 // eslint-disable-next-line complexity -- command dispatch keeps the CLI's existing boundary in one place.
 async function invokeParsed(invocation, runtime) {
     const coordinates = await resolveCliCoordinates({
@@ -351,14 +361,16 @@ async function invokeParsed(invocation, runtime) {
         ...(invocation.repo === undefined ? {} : { repo: invocation.repo }),
         command: invocation.command,
     });
-    const { cwd, repo, world, candidateWorld, establishWorld } = coordinates;
+    const { cwd, cwdSource, repo, world, candidateWorld, establishWorld } = coordinates;
     const edge = {
         environment: runtime.environment ?? process.env,
         readStdin: runtime.readStdin ?? readStdin,
     };
     const parsed = invocation.command;
+    const mapped = edge.environment.KEIYAKU_HOME?.trim();
+    const home = mapped === undefined || mapped.length === 0 ? undefined : mapped;
     if (parsed.command === "settings") {
-        return { kind: "settings", value: await settingsAt(world ?? undefined, edge.environment) };
+        return { kind: "settings", value: await settingsAt(world ?? undefined, home) };
     }
     if (parsed.command === "task") {
         try {
@@ -375,30 +387,31 @@ async function invokeParsed(invocation, runtime) {
             throw error;
         }
     }
+    if (parsed.command === "history" && "contract" in parsed)
+        return await invokeContractHistory(repo, parsed.contract);
     if (isParsedAkumaCommand(parsed)) {
         const akumaWorld = await akumaWorldFor(parsed, world, candidateWorld, coordinates.establishWorld);
-        const configuration = await settingsAt(akumaWorld, edge.environment);
+        const configuration = parsed.command === "call" ? await settingsAt(akumaWorld, home) : undefined;
         return await invokeAkumaFromEdge(parsed, {
             path: akumaWorld,
-            ...(parsed.command === "call" && parsed.contract !== undefined && invocation.cwd === undefined
-                ? {}
-                : { executionCwd: cwd }),
+            ...(cwdSource === "input" ? { statedCwd: cwd } : {}),
             ...(repo === undefined ? {} : { repo }),
-            configuration,
+            ...(parsed.command === "call" && home !== undefined ? { home } : {}),
+            ...(configuration === undefined ? {} : { configuration }),
             edge,
         });
     }
     if (parsed.command === "ls")
-        return await invokeCatalog(parsed, world, repo, edge);
+        return await invokeCatalog(parsed, world, repo, home);
     if (parsed.command === "status")
-        return await invokeStatus(parsed, world, repo, edge);
+        return await invokeStatus(parsed, world, repo);
     if (repo === undefined)
         throw new Error(`${parsed.command} requires a resolved Repo`);
     if (parsed.command === "region")
         return invokeRegion(parsed, world, repo);
     const scope = cwd;
-    const configuration = await settingsAt(world ?? undefined, edge.environment);
-    const hooks = selectedHooks(configuration);
+    const configuration = await settingsAt(world ?? undefined, home);
+    const hooks = consumeSettings(() => worktreeHooksFrom({ settings: configuration }));
     if (parsed.command === "show") {
         const selected = await selectContract(repo, parsed.contract, scope);
         return { kind: "guidance", contract: selected.id, guidance: await selected.contract.guidance() };
@@ -427,13 +440,17 @@ export async function invoke(invocation, runtime = {}) {
     try {
         const command = invocation.command;
         assertExplicitRepoUse(command, invocation.repo);
-        if (command.command === "install")
+        if (command.command === "install") {
+            runtime.onOperationStart?.();
             return installHarnesses(command.harnesses, runtime.environment ?? process.env);
+        }
+        const acquiredRuntime = await withAcquiredStdin(command, withResolvedTaskActor(command, runtime));
+        runtime.onOperationStart?.();
         return await invokeParsed({
             ...(invocation.cwd === undefined ? {} : { cwd: invocation.cwd }),
             ...(invocation.repo === undefined ? {} : { repo: invocation.repo }),
             command,
-        }, await withAcquiredStdin(command, withResolvedTaskActor(command, runtime)));
+        }, acquiredRuntime);
     }
     catch (error) {
         if (error instanceof CliUsageError && error.projection === undefined) {

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

@@ -1 +1,3 @@
+import { type ParsedCommand } from "./parse.js";
+export declare function invocationStart(command: ParsedCommand): string | undefined;
 export declare function main(argv?: readonly string[]): Promise<number>;

package/build/src/cli/main.js

@@ -28,7 +28,7 @@ function writeTask(command, result) {
     return taskExitCode(result);
 }
 function writeAkuma(command, result) {
-    const output = command.output === "json" ? renderAkumaJson(command, result) : renderAkumaText(command, result, {
+    const output = command.output === "json" ? renderAkumaJson(result) : renderAkumaText(command, result, {
         columns: process.stdout.isTTY === true && Number.isInteger(process.stdout.columns) ? process.stdout.columns : 80,
         color: process.stdout.isTTY === true && process.env.NO_COLOR === undefined,
     });
@@ -46,6 +46,18 @@ function renderHelp(coordinate) {
         case "akuma": return renderAkumaHelp(coordinate.action);
     }
 }
+export function invocationStart(command) {
+    if (command.output === "json")
+        return undefined;
+    switch (command.command) {
+        case "bind": return "⧖ preparing keiyaku";
+        case "deliver": return "⧖ delivering";
+        case "audit": return "⧖ auditing";
+        case "reconcile": return "⧖ reconciling";
+        case "install": return "⧖ installing skills";
+        default: return undefined;
+    }
+}
 function writeGuidance(command, result) {
     if (command.output === "json")
         process.stdout.write(`${JSON.stringify({ contract: result.contract, guidance: result.guidance })}\n`);
@@ -71,8 +83,17 @@ function writeResult(command, result) {
         process.stdout.write(`${command.output === "json" ? JSON.stringify(settingsJsonValue(value)) : renderSettingsText(value)}\n`);
         return 0;
     }
-    if (isParsedAkumaCommand(command)
-        || (typeof result === "object" && result !== null && "kind" in result && result.kind === "akuma")) {
+    if (typeof result === "object" && result !== null && "kind" in result && result.kind === "contract-history") {
+        const history = result.history;
+        const output = command.output === "json" ? JSON.stringify(history) : renderText(result);
+        process.stdout.write(`${output}\n`);
+        return 0;
+    }
+    const akumaResult = typeof result === "object" && result !== null && "kind" in result && result.kind === "akuma";
+    if (isParsedAkumaCommand(command)) {
+        return writeAkuma(command, result);
+    }
+    if (akumaResult && command.command === "status") {
         return writeAkuma(command, result);
     }
     const contractResult = result;
@@ -111,7 +132,11 @@ export async function main(argv = process.argv.slice(2)) {
         }
         output = parsed.command.output;
         const { invoke } = await import("./invoke.js");
-        const result = await invoke(parsed, { cwd: process.cwd() });
+        const start = invocationStart(parsed.command);
+        const result = await invoke(parsed, {
+            cwd: process.cwd(),
+            ...(start === undefined ? {} : { onOperationStart: () => { process.stderr.write(`${start}\n`); } }),
+        });
         return writeResult(parsed.command, result);
     }
     catch (error) {

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

@@ -28,6 +28,7 @@ export type ParsedAmend = Output & Actor & Readonly<{
     after?: readonly string[];
     clearAfter?: true;
     gates?: string;
+    stdin?: true;
 }>;
 export type ParsedDeliver = Output & Actor & Readonly<{
     command: "deliver";

package/build/src/cli/parse.js

@@ -2,11 +2,11 @@ import { isTaskAction, parseTaskCommand, renderTaskUsage, } from "./commands/tas
 import { isAkumaAction, parseAkumaCatalogPath, parseAkumaCommand, renderAkumaRootRows, renderAkumaUsage, } from "./commands/akuma.js";
 import { INSTALL_USAGE, parseInstallCommand, renderInstallHelp } from "./commands/install.js";
 import { AMEND_MINIMAL_STDIN_HELP, CONTRACT_COMMAND_SPECS } from "./commands/contract.js";
-import { CliUsageError, isBlankInput, usageLine } from "./usage.js";
+import { CliUsageError, isBlankInput, usageLine, withJsonAutomationHelp } 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 [
+    return withJsonAutomationHelp([
         ROOT_USAGE,
         "",
         "global options:",
@@ -20,12 +20,12 @@ export function renderRootHelp() {
         "  task ...",
         "    Task coordination; see `keiyaku task --help`.",
         ...renderAkumaRootRows(),
-    ].join("\n");
+    ].join("\n"));
 }
 export function renderContractHelp(command) {
     const spec = CONTRACT_COMMAND_SPECS[command];
     const help = `${spec.purpose}\n\n${usageLine(spec.usage)}`;
-    return command === "amend" ? `${help}\n\n${AMEND_MINIMAL_STDIN_HELP}` : help;
+    return withJsonAutomationHelp(command === "amend" ? `${help}\n\n${AMEND_MINIMAL_STDIN_HELP}` : help);
 }
 function contractUsage(command) {
     return usageLine(CONTRACT_COMMAND_SPECS[command].usage);
@@ -139,6 +139,9 @@ function parseAmend(parts) {
     if (parts.flags["clear-after"] === true && after.length > 0)
         refuse("amend", "--clear-after and --after are mutually exclusive");
     const gates = optionalFlag(parts.flags, "gates");
+    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 }),
@@ -146,6 +149,7 @@ function parseAmend(parts) {
         ...(parts.flags["clear-after"] === true ? { clearAfter: true } : {}),
         ...(gates === undefined ? {} : { gates }),
         ...(parts.actor === undefined ? {} : { actor: parts.actor }),
+        ...(parts.stdin ? { stdin: true } : {}),
         output: parts.output,
     };
 }

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

@@ -4,5 +4,5 @@ import { type TextRenderContext } from "./terminal.js";
 export declare function akumaRawAnswer(result: AkumaInvocationResult): string | undefined;
 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;
+export declare function akumaJsonValue(result: AkumaInvocationResult): unknown;
+export declare function renderAkumaJson(result: AkumaInvocationResult): string;

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

@@ -1,5 +1,5 @@
 import { toolRepr } from "./akuma-tool.js";
-import { displayColumns, renderBoundedTextBlock, safeText, truncateMiddleDisplayText } from "./terminal.js";
+import { displayColumns, renderBoundedTextBlock, renderTextBlock, safeText, truncateMiddleDisplayText, } from "./terminal.js";
 const DEFAULT_CONTEXT = { columns: 80, color: false };
 const OPENING_STROKE = "─────";
 const TIME_WIDTH = 5;
@@ -138,6 +138,59 @@ function groupedEntries(entries, context, history = false) {
 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 taskScanLine(row, indent = "") {
+    return `${indent}${taskDispositionMark(row.disposition)} ${row.id} · P${row.priority} ${row.disposition}`;
+}
+function changeOp(op) {
+    return op === "add" ? "write" : op === "delete" ? "delete" : "edit";
+}
+function renderReportedChangeLines(snapshot, columns) {
+    const lines = [`  changes ${snapshot.reportedChanges.length + snapshot.reportedChangesOmitted}`];
+    for (const change of snapshot.reportedChanges) {
+        const scan = `  ${changeOp(change.op)}`;
+        const path = safeText(change.path);
+        const stat = change.diffstat === undefined
+            ? ""
+            : ` — +${change.diffstat.added} -${change.diffstat.removed}`;
+        const inline = `${scan} ${path}${stat}`;
+        if (displayColumns(inline) <= columns)
+            lines.push(inline);
+        else
+            lines.push(`${scan}`, ...renderTextBlock(`${path}${stat}`, "    ", columns));
+    }
+    if (snapshot.reportedChangesOmitted > 0) {
+        lines.push(`  ⋮ ${snapshot.reportedChangesOmitted} earlier changes`);
+    }
+    return lines;
+}
+function renderTaskContextLines(created, columns) {
+    if (created === undefined)
+        return [];
+    if (created.kind === "failed")
+        return [`! tasks failed ${safeText(created.diagnostic)}`];
+    const lines = [`  tasks ${created.rows.length}`];
+    for (const row of created.rows) {
+        const scan = `  ${taskScanLine(row)}`;
+        const title = safeText(row.title);
+        const inline = `${scan} — ${title}`;
+        if (displayColumns(inline) <= columns)
+            lines.push(inline);
+        else
+            lines.push(`${scan} —`, ...renderTextBlock(title, "    ", columns));
+    }
+    return lines;
+}
 function snapshotText(view, context, options = {}) {
     const snapshot = view.status.timeline;
     const activity = snapshot.kind === "idle" && snapshot.outcome !== undefined
@@ -151,7 +204,14 @@ function snapshotText(view, context, options = {}) {
         ...(options.facts ?? []),
     ];
     const footer = options.showLife === false ? [] : [`  ${lifeLabel(view.status.life)}`];
-    return [...snapshotHeading(view.status.id, options.alias, view.contractId), ...facts, ...activity, ...footer].join("\n");
+    return [
+        ...snapshotHeading(view.status.id, options.alias, view.contractId),
+        ...facts,
+        ...activity,
+        ...footer,
+        ...renderReportedChangeLines(snapshot, context.columns),
+        ...renderTaskContextLines(view.createdTasks, context.columns),
+    ].join("\n");
 }
 function historyText(command, result, context) {
     if (command.last)
@@ -195,8 +255,9 @@ export function akumaRawAnswer(result) {
             return undefined;
         return statusAnswer({ status: result.result.observation.status });
     }
-    if (result.action === "wait" && result.result.statuses.length === 1)
-        return statusAnswer(result.result.statuses[0]);
+    if (result.action === "wait" && result.result.observations.length === 1) {
+        return statusAnswer(result.result.observations[0]);
+    }
     return undefined;
 }
 function executionCwdLine(result) {
@@ -237,9 +298,11 @@ 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 "wait":
+            return result.result.observations.map((observation) => snapshotText(observation, 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 }), showLife: false });
-        case "history": return historyText(command, result, context);
+        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.diagnostic;
@@ -277,13 +340,21 @@ export function akumaExitCode(result) {
         default: 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");
+export function akumaJsonValue(result) {
+    if (result.action === "call")
+        return result.result;
+    if (result.action === "fork")
+        return result.receipt;
+    if (result.action === "status")
+        return result.status;
+    if (result.action === "wait")
+        return result.result;
+    if (result.action === "tell")
+        return result.result;
+    if (result.action === "kill")
+        return result.result;
     return result.historyResult;
 }
-export function renderAkumaJson(command, result) {
-    return JSON.stringify(akumaJsonValue(command, result));
+export function renderAkumaJson(result) {
+    return JSON.stringify(akumaJsonValue(result));
 }

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

@@ -1,4 +1,4 @@
-import { cleanupLines, leakLines, outcomeLines, receiptPayload, receiptRow, stopLines, } from "./receipt.js";
+import { cleanupLines, leakLines, receiptPayload, receiptRow, stopLines, titleLines, } from "./receipt.js";
 import { renderRefusalFacts } from "./refusal.js";
 import { gitShortStat, renderBoundedTextBlock, renderOpaqueBlock, } from "./terminal.js";
 const CHILD = "  ";
@@ -91,14 +91,28 @@ function obligationLines(result, columns) {
         ...(result.leak === undefined ? [] : leakLines(result.leak, columns)),
     ];
 }
+function recordLines(result, columns) {
+    if (result.facts.length === 0)
+        return [];
+    const rows = [];
+    for (const fact of result.facts) {
+        receiptRow(rows, " ", "journal", [
+            { text: fact.entry, opaque: true },
+            { text: `· ${fact.kind}` },
+        ], columns);
+    }
+    receiptRow(rows, " ", "head", [{ text: result.head, opaque: true }], columns);
+    return ["  record", ...rows.map((line) => `  ${line}`)];
+}
 export function renderAcceptedAudit(result, context) {
     const report = result.report;
     const columns = context?.columns ?? 80;
     return [
-        ...outcomeLines("✓", result.verb, "accepted", result.contract, columns),
+        ...titleLines("✓", "audit", result.contract, columns),
         ...candidateLines(report, columns, result.contract),
         ...verificationLines(report.verification, columns, result.contract),
         ...targetLines(report.target, columns, result.contract),
         ...obligationLines(result, columns),
+        ...recordLines(result, columns),
     ].join("\n");
 }

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

@@ -1,4 +1,6 @@
+import type { ContractHistory } from "../../index.js";
 import type { AcceptedResult, RetryResult } from "../result.js";
 import { type TextRenderContext } from "./terminal.js";
 export declare function renderAccepted(result: AcceptedResult, context?: TextRenderContext): string;
 export declare function renderRetry(result: RetryResult, context?: TextRenderContext): string;
+export declare function renderContractHistory(history: ContractHistory): string;