@astrosheep/keiyaku 4.5.29 → 4.6.2

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

@@ -1,14 +1,13 @@
-import type { ActivityRow, SnapshotRow } from "../../akuma/akuma.js";
+import type { ActivityRow, SnapshotRow } from "../../akuma/projection.js";
 import type { AkumaObservation } from "../../index.js";
-type FleetTimelineRow = Extract<AkumaObservation["status"]["timeline"]["entries"][number], {
+type StatusTimelineRow = Extract<AkumaObservation["status"]["timeline"]["entries"][number], {
     kind: "row";
 }>["row"];
-type ToolRow = Extract<ActivityRow | SnapshotRow | FleetTimelineRow, {
+type ToolRow = Extract<ActivityRow | SnapshotRow | StatusTimelineRow, {
     kind: "tool";
 }>;
 /** The bounded body of a generic tool row, including its terminal diagnostic. */
 export declare function toolContent(row: ToolRow, columns: number): string;
-export declare function toolLabel(row: ToolRow): string;
 /** The trailing failure, duration, or message clause one settled tool row carries, otherwise the empty string. */
 export declare function toolDiagnostic(row: ToolRow): string;
 export type ToolRepr = Readonly<{
@@ -23,6 +22,11 @@ export type ToolRepr = Readonly<{
         diagnostic?: string;
     }>;
 }>;
+/** The one diffstat renderer: unknown stays unknown, known renders compact additions and removals. */
+export declare function renderDiffstat(diffstat: Readonly<{
+    added: number;
+    removed: number;
+}> | undefined): 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

@@ -1,5 +1,5 @@
-import { displayColumns, truncateDisplayText } from "./terminal.js";
 import { normalizeToolCommand } from "./akuma-tool-command.js";
+import { displayColumns, truncateDisplayText } from "./terminal.js";
 /** The bounded body of a generic tool row, including its terminal diagnostic. */
 export function toolContent(row, columns) {
     const input = row.call.kind === "other" ? row.call.input : undefined;
@@ -24,9 +24,6 @@ export function toolContent(row, columns) {
     }
     return `${truncateDisplayText(text, width)}${diagnostic}`;
 }
-export function toolLabel(row) {
-    return toolCore(row).label;
-}
 /** The trailing failure, duration, or message clause one settled tool row carries, otherwise the empty string. */
 export function toolDiagnostic(row) {
     const suffix = result(row);
@@ -156,6 +153,10 @@ function commonOtherText(row) {
     }
     return undefined;
 }
+/** The one diffstat renderer: unknown stays unknown, known renders compact additions and removals. */
+export function renderDiffstat(diffstat) {
+    return diffstat === undefined ? "~" : `+${diffstat.added} -${diffstat.removed}`;
+}
 function fileChange(call, state) {
     const first = call.changes[0];
     if (first === undefined)
@@ -174,7 +175,7 @@ function fileChange(call, state) {
             removed: sum.removed + change.diffstat.removed,
         }), { added: 0, removed: 0 })
         : undefined;
-    const detail = `${call.changes.length === 1 ? "" : " ..."} — ${totals === undefined ? "+? -?" : `+${totals.added} -${totals.removed}`}`;
+    const detail = `${call.changes.length === 1 ? "" : " ..."} — ${renderDiffstat(totals)}`;
     return { label, text: `${before}${path}${detail}`, pathPreview: { before, path, detail } };
 }
 /** One provider-neutral core owns every tool-kind label and non-generic body. */

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

@@ -1,25 +1,45 @@
-import type { CallWaitHead } from "../../index.js";
-import type { AkumaInvocationResult } from "../commands/akuma-invoke.js";
-import type { ParsedCommand } from "../parse.js";
-import { type ObservedCallHead } from "./akuma-activity.js";
-import type { AkumaTellWaitResult } from "../../akuma/fleet-observation.js";
-import type { AkuId } from "../../akuma/identity.js";
 import type { LiveStatusObservation } from "../../akuma/akuma-observe.js";
-import type { TellResult } from "../../akuma/akuma.js";
+import type { TellResult } from "../../akuma/body.js";
+import type { AkuId } from "../../akuma/identity.js";
+import type { AkumaAskResult, AkumaKillResult, AkumaObservation, AkumaTellResult, AkumaWaitResult } from "../../akuma/selection-observation.js";
+import type { CallWaitHead, ForkResult } from "../../index.js";
+import type { CallResult } from "../../library/akuma-creation.js";
+import type { AkumaHistoryResult } from "../../library/selection.js";
+import { type ObservedCallHead } from "./akuma-activity.js";
 import { type TextRenderContext } from "./terminal.js";
-export type TellWaitProgress = Readonly<{
+export type AskProgress = Readonly<{
     admitted: (tell: TellResult, id: AkuId) => readonly string[];
     observe: (observation: LiveStatusObservation) => readonly string[];
-    conclude: (result: AkumaTellWaitResult) => readonly string[];
+    frame: () => readonly string[];
+    flush: () => readonly string[];
+    conclude: (result: AkumaAskResult) => readonly string[];
 }>;
-export declare function tellWaitProgressStream(akuma: AkuId | undefined, alias: string | undefined, context: TextRenderContext): TellWaitProgress;
-export declare function waitedTellProgress(result: AkumaTellWaitResult, alias: string | undefined, context: TextRenderContext): string;
-export declare function akumaRawAnswer(result: AkumaInvocationResult): string | undefined;
+export declare function askProgressStream(akuma: AkuId | undefined, alias: string | undefined, context: TextRenderContext): AskProgress;
+export declare function waitedTellProgress(result: AkumaAskResult, alias: string | undefined, context: TextRenderContext): string;
 /** The shared identity frame for one admitted call input. */
 export declare function callObservationHead(input: Readonly<{
     akuma: string;
 }> & CallWaitHead): ObservedCallHead;
-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;
-export declare function renderAkumaJson(result: AkumaInvocationResult): string;
+export declare function renderCallText(result: CallResult, streamed: boolean, context: TextRenderContext): string;
+export declare function renderWaitText(result: AkumaWaitResult, presentation: Readonly<{
+    alias?: string;
+    startedAt?: number;
+    selection?: readonly import("./akuma-activity.js").WaitSelectedIdentity[];
+}>, context?: TextRenderContext): string;
+export declare function renderStatusText(status: AkumaObservation, alias: string | undefined, context?: TextRenderContext): string;
+export declare function renderTellText(result: AkumaTellResult, alias: string | undefined, context?: TextRenderContext, options?: Readonly<{
+    identity?: boolean;
+}>): string;
+export declare function renderHistoryText(result: AkumaHistoryResult, presentation: Readonly<{
+    alias?: string;
+    id?: string;
+    last?: boolean;
+}>, context?: TextRenderContext): string;
+export declare function renderForkText(receipt: ForkResult): string;
+export declare function renderKillText(result: AkumaKillResult, alias: string | undefined, context: TextRenderContext): string;
+export declare function callExitCode(result: CallResult): number;
+export declare function killExitCode(result: AkumaKillResult): number;
+export declare function tellExitCode(result: AkumaTellResult): number;
+export declare function askExitCode(result: AkumaAskResult): number;
+export declare function forkExitCode(receipt: ForkResult): number;
+export declare function historyExitCode(result: AkumaHistoryResult, id: string | undefined): number;

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

@@ -1,6 +1,6 @@
-import { DEFAULT_CONTEXT, akumaRawAnswer as akumaActivityRawAnswer, associatedIdentity, historyText, inputWaitStream, killResultText, mutationObservationStageText, snapshotHeading, snapshotText, tellText, waitText, } from "./akuma-activity.js";
+import { DEFAULT_CONTEXT, associatedIdentity, historyText, inputWaitStream, killResultText, snapshotHeading, snapshotText, tellText, waitText, } from "./akuma-activity.js";
 import { safeText } from "./terminal.js";
-export function tellWaitProgressStream(akuma, alias, context) {
+export function askProgressStream(akuma, alias, context) {
     let target = akuma;
     const stream = inputWaitStream(context, () => {
         if (target === undefined)
@@ -13,19 +13,12 @@ export function tellWaitProgressStream(akuma, alias, context) {
             return stream.admitted({
                 at: tell.row.at,
                 sequence: tell.row.sequence,
-                rows: [
-                    tellText({
-                        kind: "akuma",
-                        action: "tell",
-                        mode: "ordinary",
-                        result: { akuma: target, tell },
-                        body: "",
-                        ...(alias === undefined ? {} : { alias }),
-                    }, context, { identity: false }),
-                ],
+                rows: [tellText({ akuma: target, tell }, alias, context, { identity: false })],
             });
         },
         observe: (observation) => stream.observe(observation),
+        frame: () => stream.frame(),
+        flush: () => stream.flush(),
         conclude: (result) => [
             stream.conclude({
                 kind: "observed",
@@ -36,12 +29,9 @@ export function tellWaitProgressStream(akuma, alias, context) {
     };
 }
 export function waitedTellProgress(result, alias, context) {
-    const stream = tellWaitProgressStream(result.akuma, alias, context);
+    const stream = askProgressStream(result.akuma, alias, context);
     return [...stream.admitted(result.tell, result.akuma), ...stream.conclude(result)].join("\n");
 }
-export function akumaRawAnswer(result) {
-    return akumaActivityRawAnswer(result);
-}
 function dispatchLines(stage) {
     if (stage.kind === "none")
         return [];
@@ -69,30 +59,33 @@ export function callObservationHead(input) {
         facts,
     };
 }
-function callText(result, context) {
-    if (result.streamed === true)
+export function renderCallText(result, streamed, context) {
+    if (streamed)
         return "";
     const head = callObservationHead({
-        akuma: result.result.akuma,
-        dispatch: result.result.dispatch,
-        alias: result.result.alias,
+        akuma: result.akuma,
+        dispatch: result.dispatch,
+        alias: result.alias,
     });
-    if (result.result.observation.kind === "detached") {
+    if (result.observation.kind === "detached" || result.observation.kind === "born") {
+        const branches = [
+            ...(head.contract.kind === "associated" ? [safeText(head.contract.contractId)] : []),
+            safeText(result.execution.cwd),
+        ];
         return [
-            associatedIdentity(result.result.akuma, head.alias),
-            ...(head.contract.kind === "associated" ? [`  -> ${safeText(head.contract.contractId)}`] : []),
-            `  cwd  ${safeText(result.result.execution.cwd)}`,
+            associatedIdentity(result.akuma, head.alias),
+            ...branches.map((fact, index) => `${index === branches.length - 1 ? "└─" : "├─"} ${fact}`),
             ...head.facts,
         ].join("\n");
     }
-    if (result.result.observation.kind === "failed") {
+    if (result.observation.kind === "failed") {
         return [
             ...snapshotHeading(head.id, head.alias, head.contract),
             ...head.facts,
-            `! error ${safeText(result.result.observation.failure.diagnostic)}`,
+            `! error ${safeText(result.observation.failure.diagnostic)}`,
         ].join("\n");
     }
-    const inputObservation = result.result.observation;
+    const inputObservation = result.observation;
     const stream = inputWaitStream(context, () => head, { cursor: "empty" });
     stream.admitted({ at: inputObservation.tell.row.at, rows: [] });
     return stream.conclude({
@@ -101,119 +94,59 @@ function callText(result, context) {
         ...(inputObservation.completedAt === undefined ? {} : { completedAt: inputObservation.completedAt }),
     });
 }
-export function renderAkumaText(command, result, context = DEFAULT_CONTEXT) {
-    const answer = akumaRawAnswer(result);
-    if (answer !== undefined)
-        return answer;
-    if (result.action === "tell" && result.mode === "schema")
-        return JSON.stringify(result.result);
-    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 waitText(result, context);
-        case "tell":
-            if (result.mode === "wait")
-                return "";
-            return result.mode === "ordinary"
-                ? tellText(result, context)
-                : mutationObservationStageText(result.result.id, result.result.observation, context, {
-                    ...(result.alias === undefined ? {} : { alias: result.alias }),
-                    showLife: false,
-                });
-        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;
-            const contractId = result.receipt.dispatch.kind === "dispatched" ? result.receipt.dispatch.dispatch.contractId : undefined;
-            return associatedIdentity(result.receipt.child, undefined, contractId === undefined ? { kind: "none" } : { kind: "associated", contractId });
-        }
-        case "kill":
-            return result.result.results
-                .map((member) => killResultText(member.id, member.evidence, result.alias))
-                .join("\n\n");
+export function renderWaitText(result, presentation, context = DEFAULT_CONTEXT) {
+    return waitText(result, presentation, context);
+}
+export function renderStatusText(status, alias, context = DEFAULT_CONTEXT) {
+    return snapshotText(status, context, ...(alias === undefined ? [{}] : [{ alias }]));
+}
+export function renderTellText(result, alias, context = DEFAULT_CONTEXT, options = {}) {
+    return tellText(result, alias, context, options);
+}
+export function renderHistoryText(result, presentation, context = DEFAULT_CONTEXT) {
+    return historyText(result, presentation, context);
+}
+export function renderForkText(receipt) {
+    if (receipt.kind !== "forked") {
+        if (receipt.kind === "unknown-history")
+            return `${receipt.at} has no matching retained answered turn`;
+        if (receipt.kind === "provider-cannot-fork")
+            return `${receipt.provider} cannot fork`;
+        return receipt.diagnostic;
     }
+    const contractId = receipt.dispatch.kind === "dispatched" ? receipt.dispatch.dispatch.contractId : undefined;
+    return associatedIdentity(receipt.child, undefined, contractId === undefined ? { kind: "none" } : { kind: "associated", contractId });
+}
+export function renderKillText(result, alias, context) {
+    void context;
+    return result.results.map((member) => killResultText(member.id, member.evidence, alias)).join("\n\n");
 }
-function callExitCode(result) {
-    if (result.result.dispatch.kind === "failed" ||
-        result.result.alias.kind === "failed" ||
-        result.result.observation.kind === "failed")
+export function callExitCode(result) {
+    if (result.dispatch.kind === "failed" || result.alias.kind === "failed" || result.observation.kind === "failed")
         return 2;
-    if (result.result.observation.kind !== "observed")
+    if (result.observation.kind !== "observed")
         return 0;
-    return result.result.observation.observation.reason === "failed" ||
-        result.result.observation.observation.reason === "invalid-output"
+    return result.observation.observation.reason === "failed" ||
+        result.observation.observation.reason === "invalid-output"
         ? 2
         : 0;
 }
-function killExitCode(result) {
-    return result.result.results.some((member) => member.evidence === "unavailable" || member.evidence === "hung" || member.evidence === "untidy")
+export function killExitCode(result) {
+    return result.results.some((member) => member.evidence === "unavailable" || member.evidence === "hung" || member.evidence === "untidy")
         ? 1
         : 0;
 }
-function tellExitCode(result) {
-    if (result.mode === "schema")
-        return 0;
-    if (result.mode === "wait")
-        return result.result.observation.reason === "failed" || result.result.observation.reason === "invalid-output"
-            ? 2
-            : 0;
-    return result.mode === "ordinary"
-        ? result.result.tell.wake.kind === "failed"
-            ? 2
-            : 0
-        : result.result.receipt.kind === "interrupted"
-            ? 0
-            : 1;
-}
-function forkExitCode(result) {
-    return result.receipt.kind === "forked" ? 0 : result.receipt.kind === "upstream-forked" ? 2 : 1;
-}
-function historyExitCode(result) {
-    if (result.mode !== "exact")
-        return 0;
-    return result.historyResult.kind === "exact" ? 0 : 1;
-}
-export function akumaExitCode(result) {
-    switch (result.action) {
-        case "call":
-            return callExitCode(result);
-        case "kill":
-            return killExitCode(result);
-        case "tell":
-            return tellExitCode(result);
-        case "fork":
-            return forkExitCode(result);
-        case "history":
-            return historyExitCode(result);
-        default:
-            return 0;
-    }
+export function tellExitCode(result) {
+    return result.tell.wake.kind === "failed" ? 2 : 0;
 }
-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.mode === "schema" ? result.result : result.result;
-    if (result.action === "kill")
-        return result.result;
-    return result.historyResult;
-}
-export function renderAkumaJson(result) {
-    return JSON.stringify(akumaJsonValue(result));
+export function askExitCode(result) {
+    return result.observation.reason === "failed" || result.observation.reason === "invalid-output" ? 2 : 0;
+}
+export function forkExitCode(receipt) {
+    return receipt.kind === "forked" ? 0 : receipt.kind === "upstream-forked" ? 2 : 1;
+}
+export function historyExitCode(result, id) {
+    if (id === undefined)
+        return 0;
+    return result.kind === "exact" ? 0 : 1;
 }

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

@@ -1,3 +1,7 @@
-import type { AcceptedAuditResult } from "../result.js";
+import type { AuditOutcome } from "../../index.js";
 import { type TextRenderContext } from "./terminal.js";
-export declare function renderAcceptedAudit(result: AcceptedAuditResult, context?: TextRenderContext): string;
+type AcceptedAudit = Extract<AuditOutcome, {
+    kind: "accepted";
+}>;
+export declare function renderAcceptedAudit(result: AcceptedAudit, context?: TextRenderContext): string;
+export {};

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

@@ -1,11 +1,13 @@
-import { executionCleanupLines, executionStopLines, receiptPayload, receiptRow, stopLines, titleLines, } from "./receipt.js";
+import { effectCleanup, effectExecutionStops } from "./effects.js";
+import { executionCleanupLines, executionStopLines, receiptPayload, receiptRow, reuseLines, stopLines, titleLines, } from "./receipt.js";
 import { renderRefusalFacts } from "./refusal.js";
+import { abbreviateGitIds, displayGitId } from "./contract-observation.js";
 import { DEFAULT_CLI_COLUMNS, gitShortStat, renderTextBlock, safeText } from "./terminal.js";
 const CHILD = "  ";
 function workspaceEvidence(workspace) {
-    return [`${CHILD}workspace  ${workspace.kind}`, `${CHILD}worktree  ${safeText(workspace.path)}`];
+    return [`${CHILD}worktree  ${safeText(workspace.path)}`];
 }
-function candidateLines(report, columns, addressed) {
+function candidateLines(report, columns, addressed, abbreviations) {
     const candidate = report.candidate;
     const lines = [];
     if (candidate.kind === "blocked") {
@@ -15,9 +17,10 @@ function candidateLines(report, columns, addressed) {
     }
     const identity = candidate.identity;
     receiptRow(lines, " ", "candidate", [{ text: "ready" }], columns);
-    lines.push(`${CHILD}tender commit  ${identity.tenderSnapshot}`);
-    lines.push(`${CHILD}integration commit  ${identity.integration.snapshot}`);
-    lines.push(`${CHILD}content identity (not commit)  ${identity.integration.changeId}`);
+    lines.push(`${CHILD}candidate  ${displayGitId(identity.tenderSnapshot, abbreviations)}`);
+    lines.push(`${CHILD}integration result  ${displayGitId(identity.integration.snapshot, abbreviations)}`);
+    if (!/^0{40}$/u.test(identity.integration.changeId))
+        lines.push(`${CHILD}content identity (not commit)  ${displayGitId(identity.integration.changeId, abbreviations)}`);
     lines.push(...workspaceEvidence(candidate.workspace));
     lines.push(...renderTextBlock(gitShortStat(candidate.scope), CHILD, columns));
     if (candidate.scope.paths !== undefined) {
@@ -31,50 +34,76 @@ function candidateLines(report, columns, addressed) {
 }
 function verificationLines(verification, columns, addressed) {
     const lines = [];
+    if (verification.kind === "undeclared") {
+        receiptRow(lines, " ", "verification", [{ text: "none declared" }], columns);
+        return lines;
+    }
     if (verification.kind === "not-run") {
-        receiptRow(lines, " ", "verification", [{ text: "not-run" }], columns);
+        receiptRow(lines, " ", "verification", [{ text: "not run" }], columns);
         return lines;
     }
     if (verification.kind === "stopped") {
         return stopLines(verification.stop, columns, addressed);
     }
-    receiptRow(lines, verification.kind === "satisfied" ? " " : "!", "verification", [{ text: verification.kind }, { text: `${verification.passed} of ${verification.total}` }], columns);
+    if (verification.kind === "reused") {
+        receiptRow(lines, " ", "verification", [{ text: "reused" }, { text: verification.verdict }], columns);
+        lines.push(...reuseLines(verification, columns));
+        if (verification.summary !== undefined)
+            receiptPayload(lines, "summary", auditSummary(verification.summary));
+        return lines;
+    }
+    receiptRow(lines, verification.kind === "satisfied" ? "✓" : "!", "verification", [{ text: verification.kind }, { text: `${verification.passed} of ${verification.total}` }], columns);
     if (verification.summary !== undefined) {
-        receiptPayload(lines, "summary", verification.summary);
+        receiptPayload(lines, "summary", auditSummary(verification.summary));
     }
     return lines;
 }
+function auditSummary(summary) {
+    return summary.replace(/\[(\d+) (bash|zsh|pwsh) exit (-?\d+)( output-truncated)?\]/gu, (_, number, executor, exit, truncated) => `declaration ${number} · ${executor} exit ${exit}${truncated ?? ""}`);
+}
 function admittedCandidateLines(report, columns) {
     const delivery = report.delivery;
     if (delivery === undefined)
         return [];
     const verification = delivery.verification;
+    if (verification.kind === "undeclared")
+        return [];
     const detail = verification.kind === "recorded" ? `${verification.kind} ${verification.verdict}` : verification.kind;
     const lines = [];
     receiptRow(lines, verification.kind === "unrecorded" ? "!" : " ", "admitted verification", [{ text: detail }], columns);
     return lines;
 }
-function targetLines(target, columns, addressed) {
+function targetLines(report, columns, addressed, abbreviations) {
+    const target = report.target;
     const lines = [];
     if (target.kind === "not-observed") {
         receiptRow(lines, " ", "target", [{ text: "not-observed" }], columns);
         return lines;
     }
     if (target.kind === "placeable") {
-        receiptRow(lines, " ", "target", [{ text: "placeable" }, { text: target.ref, opaque: true }, { text: target.head, opaque: true }], columns);
+        receiptRow(lines, " ", "target", [
+            { text: "placeable" },
+            {
+                text: `${target.ref.replace(/^refs\/heads\//u, "")} @ ${displayGitId(target.head, abbreviations)}${report.targetLag?.kind === "counted" && report.targetLag.behind > 0 ? ` · behind ${report.targetLag.behind}` : report.targetLag?.kind === "unknown" ? " · behind unknown" : ""}`,
+                opaque: true,
+            },
+        ], columns);
         return lines;
     }
     if (target.kind === "moved") {
         receiptRow(lines, "!", "target", [
             { text: "moved" },
             { text: target.ref, opaque: true },
-            { text: `${target.expected} -> ${target.observed}`, opaque: true },
+            {
+                text: `${displayGitId(target.expected, abbreviations)} -> ${target.observed === null ? "absent" : displayGitId(target.observed, abbreviations)}`,
+                opaque: true,
+            },
         ], columns);
         return lines;
     }
     if (target.kind === "failed") {
         receiptRow(lines, "!", "target", [{ text: "failed" }], columns);
-        receiptPayload(lines, "diagnostic", target.diagnostic);
+        receiptPayload(lines, "reason", target.diagnostic);
         return lines;
     }
     receiptRow(lines, "!", "target", [{ text: "refused" }], columns);
@@ -83,29 +112,31 @@ function targetLines(target, columns, addressed) {
 }
 function obligationLines(result, columns) {
     return [
-        ...executionCleanupLines(result.cleanup ?? [], columns, result.contract),
-        ...executionStopLines(result.executionStops ?? [], columns),
+        ...executionCleanupLines(effectCleanup(result.effects).filter((issue) => issue.kind !== "worktree-leak"), columns, result.contract),
+        ...executionStopLines(effectExecutionStops(result.effects), 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);
-    }
-    return rows;
-}
 export function renderAcceptedAudit(result, context) {
-    const report = result.report;
+    const report = result.value;
     const columns = context?.columns ?? DEFAULT_CLI_COLUMNS;
+    const ids = report.candidate.kind === "ready"
+        ? [
+            report.candidate.identity.tenderSnapshot,
+            report.candidate.identity.integration.snapshot,
+            report.candidate.identity.integration.changeId,
+        ]
+        : [];
+    if (report.target.kind === "placeable")
+        ids.push(report.target.head);
+    if (report.target.kind === "moved")
+        ids.push(report.target.expected, report.target.observed ?? "");
+    const abbreviations = abbreviateGitIds(ids);
     return [
         ...titleLines("✓", "audit", result.contract, columns),
-        ...candidateLines(report, columns, result.contract),
+        ...candidateLines(report, columns, result.contract, abbreviations),
         ...admittedCandidateLines(report, columns),
         ...verificationLines(report.verification, columns, result.contract),
-        ...targetLines(report.target, columns, result.contract),
+        ...targetLines(report, columns, result.contract, abbreviations),
         ...obligationLines(result, columns),
-        ...recordLines(result, columns),
     ].join("\n");
 }

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

@@ -1,2 +1,11 @@
-import type { Catalog } from "../catalog.js";
-export declare function renderCatalogText(catalog: Catalog): string;
+import type { AkumaList } from "../../akuma/akuma.js";
+import type { ArchetypeCatalogRow } from "../../akuma/archetype.js";
+import type { ContractList } from "../../library/contract-types.js";
+import type { TaskPage, TaskRow } from "../../task/index.js";
+export declare function renderAkumaCatalogue(list: AkumaList, archetype: string | null): string;
+export declare function renderContractCatalogue(list: ContractList): string;
+export declare function renderArchetypeCatalogue(list: Readonly<{
+    rows: readonly ArchetypeCatalogRow[];
+    hasMore: boolean;
+}>): string;
+export declare function renderTaskCatalogue(list: TaskPage<TaskRow>, namespace: readonly string[]): string;