@astrosheep/keiyaku 4.6.10 → 4.6.12

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

@@ -6,11 +6,13 @@ export const DEFAULT_CONTEXT = { columns: DEFAULT_CLI_COLUMNS, color: false };
 const TIME_WIDTH = 5;
 const VERB_WIDTH = 6;
 /**
- * The one blessed ruler: a run of U+2500 exactly as wide as the frame head's
- * widest line, marking the boundary between an observation frame and its content.
+ * The one blessed ruler: a run of U+2500 as wide as the frame head's widest line,
+ * never wider than the terminal, marking the boundary between an observation
+ * frame and its content.
  */
-export function frameRule(headLines) {
-    const width = headLines.reduce((widest, line) => Math.max(widest, displayColumns(line)), 0);
+export function frameRule(headLines, columns) {
+    const widest = headLines.reduce((widest, line) => Math.max(widest, displayColumns(line)), 0);
+    const width = columns === undefined ? widest : Math.min(widest, Math.max(0, columns));
     return "─".repeat(width);
 }
 /** Tool rows an activity view prints after each say or Tell checkpoint; the surplus folds in place. */
@@ -21,14 +23,35 @@ function identity(id, alias) {
 function associatedContractId(contract) {
     return contract.kind === "associated" ? contract.contractId : undefined;
 }
-export function associatedIdentity(id, alias, contract) {
-    const contractId = contract === undefined ? undefined : associatedContractId(contract);
-    return `${identity(id, alias)}${contractId === undefined ? "" : `\n└─ ${contractId}`}`;
+/** The one human-fact separator of this family. */
+const FACT_SEPARATOR = " · ";
+/** A supporting fact of an action receipt or an observation panel is one indent deep. */
+const SUBORDINATE_INDENT = "  ";
+/** Indent already-decided supporting lines one level, for every caller of this family. */
+export function subordinateLines(lines) {
+    return lines.map((line) => `${SUBORDINATE_INDENT}${line}`);
 }
-export function snapshotHeading(id, alias, contract) {
+/**
+ * The one observation identity line: complete Akuma identity, optional alias as a parenthetical
+ * supplement, and a known associated Contract inline behind the shared separator.
+ */
+function panelIdentity(id, alias, contract) {
     const contractId = contract === undefined ? undefined : associatedContractId(contract);
-    const head = [identity(id, alias), ...(contractId === undefined ? [] : [`└─ ${contractId}`])];
-    return [...head, frameRule(head)];
+    return `${identity(id, alias)}${contractId === undefined ? "" : `${FACT_SEPARATOR}${contractId}`}`;
+}
+/**
+ * Identity and its static coordinates. The execution directory and any already-exposed effective
+ * actions belong above the content boundary; an absent coordinate is an absent line.
+ */
+export function panelHead(id, alias, contract, context = []) {
+    return [panelIdentity(id, alias, contract), ...subordinateLines(context)];
+}
+/**
+ * One action receipt: the verdict and the complete subject on the first line, every supporting fact
+ * indented beneath it. Identity and evidence are never merged into one punctuation run.
+ */
+export function actionReceipt(input) {
+    return [`${input.mark} ${input.verb} ${identity(input.id, input.alias)}`, ...subordinateLines(input.evidence ?? [])];
 }
 function contractFacts(contract) {
     return contract.kind === "failed" ? [`! contract failed ${safeText(contract.diagnostic)}`] : [];
@@ -695,7 +718,9 @@ export function inputWaitStream(context, head, options) {
             throw new Error("input wait observed before admission");
         opened = true;
         const identity = head();
-        lines.push(...snapshotHeading(identity.id, identity.alias, identity.contract));
+        const headLines = panelHead(identity.id, identity.alias, identity.contract, identity.cwd === undefined ? [] : [safeText(identity.cwd)]);
+        // A streamed panel always states an observed conclusion before it closes, so its rule opens here.
+        lines.push(...headLines, frameRule(headLines, context.columns));
     };
     const observe = (observation) => {
         const lines = [];
@@ -714,6 +739,8 @@ export function inputWaitStream(context, head, options) {
     const conclude = (result) => {
         const lines = [];
         open(lines, result.kind === "failed");
+        if (result.kind === "failed" && result.evidence !== undefined)
+            lines.push(...result.evidence);
         lines.push(...activity.flush());
         if (result.kind === "failed")
             lines.push(`! error ${safeText(result.diagnostic)}`);
@@ -724,7 +751,7 @@ export function inputWaitStream(context, head, options) {
                 now: now(),
                 ...(lastStatus === undefined ? {} : { status: lastStatus }),
             }));
-        lines.push(...head().facts);
+        lines.push(...subordinateLines(head().facts));
         return `${lines.join("\n")}${options.answerSeparator === true ? "\n\n" : ""}`;
     };
     return { admitted: admit, observe, frame, flush, conclude, opened: () => opened };
@@ -736,11 +763,26 @@ export function callObservationStream(context, head, options = {}) {
         ...(options.now === undefined ? {} : { now: options.now }),
     });
     stream.admitted({ ...(options.admittedAt === undefined ? {} : { at: options.admittedAt }), rows: [] });
+    /** Tell rows already settled on the timeline, so a failed close never replays one. */
+    const settledTells = new Set();
     return {
         ...stream,
+        observe: (observation) => {
+            for (const row of observation.rows)
+                if (row.kind === "tell" && row.state === "told")
+                    settledTells.add(row.sequence);
+            return stream.observe(observation);
+        },
         conclude: (observation) => {
-            if (observation.kind === "failed")
-                return stream.conclude({ kind: "failed", diagnostic: observation.failure.diagnostic });
+            if (observation.kind === "failed") {
+                const tell = observation.tell;
+                const evidence = tell === undefined || settledTells.has(tell.row.sequence) ? [] : [tellAdmissionRow(tell, context)];
+                return stream.conclude({
+                    kind: "failed",
+                    diagnostic: observation.failure.diagnostic,
+                    ...(evidence.length === 0 ? {} : { evidence }),
+                });
+            }
             if (observation.kind !== "observed")
                 return "";
             return stream.conclude({
@@ -785,15 +827,15 @@ function renderDebtContextLines(created, columns) {
 }
 function snapshotCore(view, context, options) {
     const activity = snapshotActivityLines(view.status.timeline, context);
-    const facts = [
+    // Static coordinates belong above the content boundary; a dynamic diagnostic stays below it.
+    const contextFacts = [
         ...(options.showAllowed === true ? [`allowed  ${view.status.allowed.join(", ") || "none"}`] : []),
-        ...contractFacts(view.contract),
-        ...(options.facts ?? []),
-        ...(view.status.cwd === undefined ? [] : [`cwd  ${safeText(view.status.cwd)}`]),
+        ...(view.status.cwd === undefined ? [] : [safeText(view.status.cwd)]),
     ];
+    const facts = [...contractFacts(view.contract), ...(options.facts ?? [])];
     return {
         activity,
-        lines: [...snapshotHeading(view.status.id, options.alias, view.contract), ...activity],
+        head: panelHead(view.status.id, options.alias, view.contract, contextFacts),
         facts,
     };
 }
@@ -809,28 +851,36 @@ function snapshotConclusion(status) {
 }
 export function snapshotText(view, context, options = {}) {
     const core = snapshotCore(view, context, options);
-    const debtContext = renderDebtContextLines(view.createdDebts, context.columns);
     const conclusion = snapshotConclusion(view.status);
+    const content = [...core.activity, ...(conclusion.length === 0 ? [] : [conclusion])];
     return [
-        ...core.lines,
-        ...(conclusion.length === 0 ? [] : [conclusion]),
-        ...(debtContext.length > 0 ? ["", ...debtContext] : []),
-        ...(view.status.timeline.reportedChanges.length > 0 || view.status.timeline.reportedChangesOmitted > 0 ? [""] : []),
-        ...renderReportedChangeLines(view.status.timeline),
-        ...(core.facts.length > 0 ? ["", ...core.facts] : []),
+        ...core.head,
+        ...(content.length === 0 ? [] : [frameRule(core.head, context.columns), ...content]),
+        ...subordinateLines([
+            ...renderReportedChangeLines(view.status.timeline),
+            ...renderDebtContextLines(view.createdDebts, context.columns - SUBORDINATE_INDENT.length),
+            ...core.facts,
+        ]),
     ].join("\n");
 }
 function killResultLabel(evidence) {
     if (evidence === "killed")
-        return "✓ killed";
+        return { mark: "✓", verb: "killed", evidence: [] };
     if (evidence === "already-killed")
-        return "✓ already killed";
+        return { mark: "✓", verb: "already killed", evidence: [] };
     if (evidence === "already-stopped")
-        return "✓ already stopped";
-    return `! not killed · ${evidence}`;
+        return { mark: "✓", verb: "already stopped", evidence: [] };
+    return { mark: "!", verb: "not killed", evidence: [evidence] };
 }
 export function killResultText(id, evidence, alias) {
-    return [...snapshotHeading(id, alias, undefined), "", killResultLabel(evidence)].join("\n");
+    const label = killResultLabel(evidence);
+    return actionReceipt({
+        mark: label.mark,
+        verb: label.verb,
+        id,
+        ...(alias === undefined ? {} : { alias }),
+        evidence: label.evidence,
+    }).join("\n");
 }
 function answerBytes(answer, structured) {
     return !structured && typeof answer === "string" ? answer : JSON.stringify(answer);
@@ -884,32 +934,62 @@ export function historyText(result, presentation, context) {
                 : `${result.history.omitted} earlier events · showing last ${result.history.rows.length}`),
         ]
         : [];
-    return [...snapshotHeading(result.id, presentation.alias, result.contract), ...paging, ...rows].join("\n");
+    // History is an immutable timeline, so it takes the shared heading and content boundary and
+    // never gains a fabricated current-state conclusion or a live mark.
+    const content = [...paging, ...rows];
+    const head = panelHead(result.id, presentation.alias, result.contract);
+    return [...head, ...(content.length === 0 ? [] : [frameRule(head, context.columns), ...content])].join("\n");
+}
+/** One bounded preview of a submitted Tell, indented once beneath its verdict or evidence. */
+export function tellPayloadLines(text, context) {
+    return renderBoundedPayload({
+        text,
+        first: SUBORDINATE_INDENT,
+        continuation: `${SUBORDINATE_INDENT}│ `,
+        columns: context.columns,
+        maxLines: 1,
+        quote: '"',
+        openQuote: false,
+        truncated: false,
+    });
 }
-export function tellText(result, alias, context, options = {}) {
-    const wake = result.tell.wake;
-    const target = identity(result.akuma, alias);
+/** One admitted Tell as a timeline row inside a shared input panel; the panel owns the identity. */
+export function tellAdmissionRow(tell, context) {
+    const wake = tell.wake;
     const glyph = wake.kind === "failed" ? "!" : wake.kind === "held" ? "⧗" : "✓";
     const verb = wake.kind === "failed" || wake.kind === "held" ? "tell" : "told";
-    const row = groupedRows([result.tell.row], context, {
+    return groupedRows([tell.row], context, {
         ...plainLayout(),
         head: (time, _glyph, _verb, columns) => eventPrefix(glyph, verb, time, columns),
         singleLine: true,
     }).join("\n");
-    const heading = options.identity === false ? [] : snapshotHeading(target, undefined, undefined);
-    if (wake.kind === "failed") {
-        const child = "child" in wake ? wake.child : undefined;
-        const failure = `! tell delivery failed · ${safeText(wake.diagnostic)}${child === undefined ? "" : ` · log ${child.log.path} ${child.log.from}..${child.log.to}`}`;
-        return [
-            ...heading,
-            row,
-            ...renderBoundedTextBlock(failure, {
-                first: "",
-                continuation: "  ",
-                columns: context.columns,
-                lines: Number.MAX_SAFE_INTEGER,
-            }),
-        ].join("\n");
-    }
-    return [...heading, row].join("\n");
+}
+/**
+ * One Tell action receipt: the delivery verdict and complete subject, then the submitted payload
+ * once. A held Tell keeps neutral vocabulary; a failed delivery keeps its own concrete diagnosis.
+ */
+export function tellText(result, alias, context) {
+    const wake = result.tell.wake;
+    const mark = wake.kind === "failed" ? "!" : wake.kind === "held" ? "⧗" : "✓";
+    const verb = wake.kind === "failed" || wake.kind === "held" ? "tell" : "told";
+    const verdict = actionReceipt({
+        mark,
+        verb,
+        id: result.akuma,
+        ...(alias === undefined ? {} : { alias }),
+    });
+    if (wake.kind !== "failed")
+        return [...verdict, ...tellPayloadLines(result.tell.row.text, context)].join("\n");
+    const child = "child" in wake ? wake.child : undefined;
+    const failure = `! tell delivery failed · ${safeText(wake.diagnostic)}${child === undefined ? "" : ` · log ${child.log.path} ${child.log.from}..${child.log.to}`}`;
+    return [
+        ...verdict,
+        ...tellPayloadLines(result.tell.row.text, context),
+        ...subordinateLines(renderBoundedTextBlock(failure, {
+            first: "",
+            continuation: "",
+            columns: context.columns - SUBORDINATE_INDENT.length,
+            lines: Number.MAX_SAFE_INTEGER,
+        })),
+    ].join("\n");
 }

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

@@ -19,8 +19,14 @@ export declare function waitedTellProgress(result: AkumaAskResult, alias: string
 /** The shared identity frame for one admitted call input. */
 export declare function callObservationHead(input: Readonly<{
     akuma: string;
+    cwd?: string;
 }> & CallWaitHead): ObservedCallHead;
 export declare function renderCallText(result: CallResult, streamed: boolean, context: TextRenderContext): string;
+/**
+ * The failure panel for an observing call whose stream never opened. It opens the same shared head
+ * over the failure's own evidence, including a Tell the invocation had already admitted.
+ */
+export declare function renderFailedCallObservation(result: CallResult, 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;

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

@@ -1,4 +1,4 @@
-import { associatedIdentity, inputWaitStream, killResultText, snapshotHeading, tellText, } from "./akuma-activity.js";
+import { actionReceipt, callObservationStream, inputWaitStream, killResultText, subordinateLines, tellAdmissionRow, tellPayloadLines, } from "./akuma-activity.js";
 import { safeText } from "./terminal.js";
 export function askProgressStream(akuma, alias, context) {
     let target = akuma;
@@ -13,7 +13,7 @@ export function askProgressStream(akuma, alias, context) {
             return stream.admitted({
                 at: tell.row.at,
                 sequence: tell.row.sequence,
-                rows: [tellText({ akuma: target, tell }, alias, context, { identity: false })],
+                rows: [tellAdmissionRow(tell, context)],
             });
         },
         observe: (observation) => stream.observe(observation),
@@ -39,8 +39,8 @@ function dispatchLines(stage) {
         return (stage.seatClose ?? []).map((lag) => `dispatch lag ${lag.kind} ${safeText(lag.diagnostic)}`);
     }
     if (stage.failure.kind === "conflict")
-        return [`dispatch failed conflict ${stage.failure.current.contractId}`];
-    return [`dispatch failed ${stage.failure.kind} ${safeText(stage.failure.diagnostic)}`];
+        return [`! dispatch failed conflict ${stage.failure.current.contractId}`];
+    return [`! dispatch failed ${stage.failure.kind} ${safeText(stage.failure.diagnostic)}`];
 }
 /** The shared identity frame for one admitted call input. */
 export function callObservationHead(input) {
@@ -49,7 +49,7 @@ export function callObservationHead(input) {
     const facts = [
         ...dispatchLines(input.dispatch),
         ...(input.alias.kind === "failed"
-            ? [`alias failed ${input.alias.failure.kind} ${safeText(input.alias.failure.diagnostic)}`]
+            ? [`! alias failed ${input.alias.failure.kind} ${safeText(input.alias.failure.diagnostic)}`]
             : []),
     ];
     return {
@@ -57,8 +57,17 @@ export function callObservationHead(input) {
         ...(alias === undefined ? {} : { alias }),
         contract: contractId === undefined ? { kind: "none" } : { kind: "associated", contractId },
         facts,
+        ...(input.cwd === undefined ? {} : { cwd: input.cwd }),
     };
 }
+/** The admitted context a call action receipt can state without reading anything new. */
+function callEvidence(result, head) {
+    return [
+        ...(head.contract.kind === "associated" ? [safeText(head.contract.contractId)] : []),
+        safeText(result.execution.cwd),
+        ...head.facts,
+    ];
+}
 export function renderCallText(result, streamed, context) {
     if (streamed)
         return "";
@@ -66,23 +75,34 @@ export function renderCallText(result, streamed, context) {
         akuma: result.akuma,
         dispatch: result.dispatch,
         alias: result.alias,
+        cwd: result.execution.cwd,
     });
+    const receipt = (mark, extra = []) => actionReceipt({
+        mark,
+        verb: "called",
+        id: result.akuma,
+        ...(head.alias === undefined ? {} : { alias: head.alias }),
+        evidence: [...callEvidence(result, head), ...extra],
+    }).join("\n");
     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.akuma, head.alias),
-            ...branches.map((fact, index) => `${index === branches.length - 1 ? "└─" : "├─"} ${fact}`),
-            ...head.facts,
-        ].join("\n");
+        // Birth and integration are admitted facts; a failed Dispatch/Alias stage marks the receipt
+        // honestly instead of letting a successful action line stand over it.
+        return receipt(result.dispatch.kind === "failed" || result.alias.kind === "failed" ? "!" : "✓");
     }
     if (result.observation.kind === "failed") {
+        // The child, its admitted Tell input, and its context survive a failed stage; a detached failure
+        // stays an action receipt rather than becoming an observation panel.
+        const admittedTell = result.observation.tell;
         return [
-            ...snapshotHeading(head.id, head.alias, head.contract),
-            ...head.facts,
-            `! error ${safeText(result.observation.failure.diagnostic)}`,
+            ...actionReceipt({
+                mark: "!",
+                verb: "called",
+                id: result.akuma,
+                ...(head.alias === undefined ? {} : { alias: head.alias }),
+                evidence: callEvidence(result, head),
+            }),
+            ...(admittedTell === undefined ? [] : tellPayloadLines(admittedTell.row.text, context)),
+            ...subordinateLines([`! error ${safeText(result.observation.failure.diagnostic)}`]),
         ].join("\n");
     }
     const inputObservation = result.observation;
@@ -94,20 +114,43 @@ export function renderCallText(result, streamed, context) {
         ...(inputObservation.completedAt === undefined ? {} : { completedAt: inputObservation.completedAt }),
     });
 }
+/**
+ * The failure panel for an observing call whose stream never opened. It opens the same shared head
+ * over the failure's own evidence, including a Tell the invocation had already admitted.
+ */
+export function renderFailedCallObservation(result, context) {
+    const failure = callObservationStream(context, callObservationHead({
+        akuma: result.akuma,
+        dispatch: result.dispatch,
+        alias: result.alias,
+        cwd: result.execution.cwd,
+    }));
+    return failure.conclude(result.observation);
+}
 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 reason = receipt.kind === "unknown-history"
+            ? `${receipt.at} has no matching retained answered turn`
+            : receipt.kind === "provider-cannot-fork"
+                ? `${receipt.provider} cannot fork`
+                : receipt.diagnostic;
+        return actionReceipt({ mark: "!", verb: "fork", id: receipt.parent, evidence: [reason] }).join("\n");
     }
     const contractId = receipt.dispatch.kind === "dispatched" ? receipt.dispatch.dispatch.contractId : undefined;
-    return associatedIdentity(receipt.child, undefined, contractId === undefined ? { kind: "none" } : { kind: "associated", contractId });
+    return actionReceipt({
+        mark: receipt.dispatch.kind === "failed" ? "!" : "✓",
+        verb: "forked",
+        id: receipt.child,
+        evidence: [
+            `from ${receipt.parent}`,
+            ...(contractId === undefined ? [] : [safeText(contractId)]),
+            ...dispatchLines(receipt.dispatch),
+        ],
+    }).join("\n");
 }
 export function renderKillText(result, alias, context) {
     void context;
-    return result.results.map((member) => killResultText(member.id, member.evidence, alias)).join("\n\n");
+    return result.results.map((member) => killResultText(member.id, member.evidence, alias)).join("\n");
 }
 export function callExitCode(result) {
     if (result.dispatch.kind === "failed" || result.alias.kind === "failed" || result.observation.kind === "failed")

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

@@ -1,5 +1,17 @@
-import type { ContractAfterEdge, ContractGateReport, ContractRow, ContractWorkspaceObservation } from "../../index.js";
+import type { ContractAfterEdge, ContractRow, ContractWorkspaceObservation } from "../../index.js";
+type GateDisplayReport = Readonly<{
+    gate: string;
+    current: Readonly<{
+        kind: "missing";
+    } | {
+        kind: "stale";
+    } | {
+        kind: "attested";
+        verdict: "satisfied" | "unsatisfied";
+    }>;
+}>;
 export declare function shortGitId(value: string): string;
+export declare function contractOperationName(operation: string): string;
 export declare function gateDisplayName(gate: string): string;
 /**
  * The one display vocabulary for a Contract's lifecycle phase. The journal fact kind stays `claimed`; every
@@ -8,8 +20,8 @@ export declare function gateDisplayName(gate: string): string;
 export declare function lifecycleWord(phase: ContractRow["phase"]): string;
 /** The one readable projection of delivery and current-candidate gate progress. */
 export declare function progressStrip(row: Pick<ContractRow, "delivery" | "gates">): string;
-export declare function gateGlyph(report: ContractGateReport): string;
-export declare function gateFact(report: ContractGateReport): string;
+export declare function gateGlyph(report: GateDisplayReport): string;
+export declare function gateFact(report: GateDisplayReport): string;
 export declare function verificationFact(status: ContractRow["verification"]): string | undefined;
 export declare function afterWording(edge: ContractAfterEdge): string;
 export declare function mergeSummary(observation: ContractWorkspaceObservation): string | undefined;
@@ -18,3 +30,4 @@ export declare function gitIdsInRow(row: ContractRow): readonly string[];
 export declare function displayGitId(value: string, abbreviations: ReadonlyMap<string, string>): string;
 /** Render the pinned delivery target and the same-epoch observed target head. */
 export declare function targetMovementFacts(row: ContractRow, abbreviations: ReadonlyMap<string, string>): readonly string[];
+export {};

package/build/src/cli/render/contract-observation.js

@@ -2,6 +2,9 @@ const GIT_OBJECT_ID = /^[0-9a-f]{40}$/iu;
 export function shortGitId(value) {
     return GIT_OBJECT_ID.test(value) ? value.slice(0, 7) : value;
 }
+export function contractOperationName(operation) {
+    return operation === "deliver-preview" ? "deliver --dry-run" : operation;
+}
 export function gateDisplayName(gate) {
     if (gate === "reviewed")
         return "review";

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

@@ -1,6 +1,6 @@
-import type { AbandonOutcome, AmendOutcome, ArcOutcome, AuditOutcome, BindOutcome, DeliverOutcome, ReviewOutcome } from "../../index.js";
+import type { AbandonOutcome, AmendOutcome, ArcOutcome, DeliveryPreviewOutcome, BindOutcome, DeliverOutcome, ReviewOutcome } from "../../index.js";
 import { type TextRenderContext } from "./terminal.js";
-export type ContractOutcome = BindOutcome | AmendOutcome | DeliverOutcome | ReviewOutcome | AuditOutcome | ArcOutcome | AbandonOutcome;
+export type ContractOutcome = BindOutcome | AmendOutcome | DeliverOutcome | ReviewOutcome | DeliveryPreviewOutcome | ArcOutcome | AbandonOutcome;
 export type AcceptedContractOutcome = Extract<ContractOutcome, {
     kind: "accepted";
 }>;

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

@@ -1,5 +1,5 @@
 import { effectCleanup, effectExecutionStops, effectLags, effectRecoverySnapshot, effectRetainedCheckouts, effectRetainedWorktrees, effectRetiredWorktrees, effectSettlementLags, } from "./effects.js";
-import { renderAcceptedAudit } from "./audit.js";
+import { renderDeliveryPreview } from "./delivery-preview.js";
 import { appendHookPayload, executionCleanupLines, executionStopLines, gatesAwaitLines, hookFailureSummary, outcomeLines, receiptPayload, receiptRow, stopLines, titleLines, } from "./receipt.js";
 import { abbreviateGitIds, displayGitId, lifecycleWord } from "./contract-observation.js";
 import { renderDiffstat } from "./akuma-tool.js";
@@ -216,7 +216,7 @@ function landedChangesLines(scope, columns) {
  * identically: one git-shaped target movement row, naming the reference it advanced, then the final lifecycle
  * state. Satisfied Verification adds one fact row naming the integrated result; placement made that commit the
  * reference's new head, so the movement and integrated-result rows share one sha. The verdict names reuse in the
- * audit surface's vocabulary and carries no qualifier when this command executed declarations. A completion
+ * standing-evidence vocabulary and carries no qualifier when this command executed declarations. A completion
  * without an advanced reference states no movement. Journal ULIDs stay in JSON and `history`, never in ordinary
  * receipt text.
  */
@@ -403,8 +403,8 @@ function renderAcceptedAbandon(result, columns) {
 export function renderAccepted(result, context) {
     const columns = context?.columns ?? DEFAULT_CLI_COLUMNS;
     switch (result.operation) {
-        case "audit":
-            return renderAcceptedAudit(result, context);
+        case "deliver-preview":
+            return renderDeliveryPreview(result, context);
         case "bind":
             return renderAcceptedBind(result, columns, context?.color === true);
         case "amend":

package/build/src/cli/render/delivery-preview.d.ts

@@ -0,0 +1,7 @@
+import type { DeliveryPreviewOutcome } from "../../index.js";
+import { type TextRenderContext } from "./terminal.js";
+type AcceptedDeliveryPreview = Extract<DeliveryPreviewOutcome, {
+    kind: "accepted";
+}>;
+export declare function renderDeliveryPreview(result: AcceptedDeliveryPreview, context?: TextRenderContext): string;
+export {};

package/build/src/cli/render/{audit.js → delivery-preview.js}

@@ -1,7 +1,7 @@
 import { effectCleanup, effectExecutionStops } from "./effects.js";
-import { executionCleanupLines, executionStopLines, receiptPayload, receiptRow, stopLines, titleLines, } from "./receipt.js";
+import { executionCleanupLines, executionStopLines, receiptPayload, receiptRow, titleLines } from "./receipt.js";
 import { renderRefusalFacts } from "./refusal.js";
-import { abbreviateGitIds, displayGitId } from "./contract-observation.js";
+import { abbreviateGitIds, displayGitId, gateFact } from "./contract-observation.js";
 import { DEFAULT_CLI_COLUMNS, gitShortStat, renderTextBlock, safeText } from "./terminal.js";
 const CHILD = "  ";
 function workspaceEvidence(workspace) {
@@ -16,11 +16,16 @@ function candidateLines(report, columns, addressed, abbreviations) {
         return lines;
     }
     const identity = candidate.identity;
-    receiptRow(lines, " ", "candidate", [{ text: "ready" }, { text: displayGitId(identity.tenderSnapshot, abbreviations), opaque: true }], columns);
+    receiptRow(lines, " ", "candidate", [{ text: "prepared" }, { text: displayGitId(identity.tenderSnapshot, abbreviations), opaque: true }], columns);
     lines.push(`${CHILD}integration result  ${displayGitId(identity.integration.snapshot, abbreviations)}`);
     if (!/^0{40}$/u.test(identity.integration.changeId))
         lines.push(`${CHILD}content identity  ${displayGitId(identity.integration.changeId, abbreviations)}`);
     lines.push(...workspaceEvidence(candidate.workspace));
+    for (const report of candidate.requirements.gates)
+        lines.push(`${CHILD}${gateFact(report)}`);
+    for (const prerequisite of candidate.requirements.unmetPrerequisites) {
+        receiptRow(lines, "!", "prerequisite", [{ text: prerequisite.contractId }, { text: prerequisite.state }], columns);
+    }
     lines.push(...renderTextBlock(gitShortStat(candidate.scope), CHILD, columns));
     if (candidate.scope.paths !== undefined) {
         for (const path of candidate.scope.paths) {
@@ -31,32 +36,23 @@ function candidateLines(report, columns, addressed, abbreviations) {
         receiptPayload(lines, "diff", candidate.diff);
     return lines;
 }
-function verificationLines(verification, columns, addressed) {
+function verificationLines(verification, columns) {
     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);
-        return lines;
-    }
-    if (verification.kind === "stopped") {
-        return stopLines(verification.stop, columns, addressed);
-    }
-    if (verification.kind === "reused") {
-        receiptRow(lines, " ", "verification", [{ text: "reused" }, { text: verification.verdict }], columns);
-        if (verification.summary !== undefined)
-            receiptPayload(lines, "summary", auditSummary(verification.summary));
+    if (verification.kind !== "recorded") {
+        const text = verification.kind === "undeclared"
+            ? "none declared"
+            : verification.kind === "required"
+                ? "required · not run"
+                : "not run";
+        receiptRow(lines, " ", "verification", [{ text }], columns);
         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", auditSummary(verification.summary));
-    }
+    receiptRow(lines, verification.verdict === "unsatisfied" ? "!" : " ", "verification", [{ text: "recorded" }, { text: verification.verdict }], columns);
+    if (verification.summary !== undefined)
+        receiptPayload(lines, "summary", previewSummary(verification.summary));
     return lines;
 }
-function auditSummary(summary) {
+function previewSummary(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) {
@@ -86,6 +82,12 @@ function targetLines(report, columns, addressed, abbreviations) {
                 opaque: true,
             },
         ], columns);
+        for (const checkout of target.checkouts) {
+            if (checkout.kind === "followable")
+                continue;
+            receiptRow(lines, "!", "checkout cannot follow", [{ text: checkout.path, opaque: true }], columns);
+            receiptPayload(lines, "reason", checkout.diagnostic);
+        }
         return lines;
     }
     if (target.kind === "moved") {
@@ -114,7 +116,7 @@ function obligationLines(result, columns) {
         ...executionStopLines(effectExecutionStops(result.effects), columns),
     ];
 }
-export function renderAcceptedAudit(result, context) {
+export function renderDeliveryPreview(result, context) {
     const report = result.value;
     const columns = context?.columns ?? DEFAULT_CLI_COLUMNS;
     const ids = report.candidate.kind === "ready"
@@ -130,10 +132,10 @@ export function renderAcceptedAudit(result, context) {
         ids.push(report.target.expected, report.target.observed ?? "");
     const abbreviations = abbreviateGitIds(ids);
     return [
-        ...titleLines("✓", "audit", result.contract, columns),
+        ...titleLines("✓", "deliver --dry-run", result.contract, columns),
         ...candidateLines(report, columns, result.contract, abbreviations),
         ...admittedCandidateLines(report, columns),
-        ...verificationLines(report.verification, columns, result.contract),
+        ...verificationLines(report.verification, columns),
         ...targetLines(report, columns, result.contract, abbreviations),
         ...obligationLines(result, columns),
     ].join("\n");