@astrosheep/keiyaku 4.5.28 → 4.6.1

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

@@ -1,20 +1,26 @@
-import type { ExecutionCleanup, ExecutionStop, ExecutionReceipt } from "../../index.js";
+import type { ExecutionCleanup, ExecutionStop, PartialOutcomeEnvelope, ReconciliationLag } from "../../index.js";
 import type { PlacementStop, VerificationReuse, VerificationStop } from "../../index.js";
-import type { Lag } from "../result.js";
 export type ReceiptSegment = Readonly<{
     text: string;
     opaque?: boolean;
 }>;
-type HookFailure = Extract<Lag, {
+type HookFailure = Extract<ReconciliationLag, {
     kind: "worktree-hook-failed";
 }>["failure"];
 export declare function receiptRow(lines: string[], mark: string, label: string, segments: readonly ReceiptSegment[], columns: number): void;
 export declare function receiptPayload(lines: string[], label: string, payload: string): void;
 export declare function outcomeLines(mark: "✓" | "×" | "!" | "?", verb: string, word: "accepted" | "refused" | "retry", contract: string | undefined, columns?: number): string[];
+export declare function refusalLines(verb: string, facts: readonly string[], columns?: number, trailingFacts?: readonly string[]): string[];
 export declare function titleLines(mark: string, title: string, contract: string, columns?: number): string[];
 export declare function hookFailureSummary(failure: HookFailure): string;
 export declare function appendHookPayload(lines: string[], failure: HookFailure): void;
 export declare function reuseLines(reuse: VerificationReuse | undefined, columns: number): readonly string[];
+/**
+ * The pending margin statement: the not-yet-happened requirements a refused placement awaits. A gate in stale
+ * state awaits the same event; when every unmet gate already holds a recorded verdict there is nothing pending and
+ * the line is omitted.
+ */
+export declare function gatesAwaitLines(placement: VerificationStop | PlacementStop | undefined): readonly string[];
 export declare function stopLines(stop: VerificationStop | PlacementStop, columns: number, addressed: string, dependent?: string): readonly string[];
 export declare function cleanupLines(cleanup: Extract<ExecutionCleanup, {
     kind: "verification-cleanup";
@@ -27,5 +33,5 @@ export declare function seatCloseLines(seatClose: readonly Extract<ExecutionClea
 }>["failure"][], columns: number): readonly string[];
 export declare function executionStopLines(stops: readonly ExecutionStop[], columns: number): readonly string[];
 export declare function executionCleanupLines(cleanup: readonly ExecutionCleanup[], columns: number, primary?: string): readonly string[];
-export declare function executionFailureLines(receipt: ExecutionReceipt, category: string, diagnostic: string, columns: number): readonly string[];
+export declare function executionFailureLines(receipt: PartialOutcomeEnvelope, category: string, diagnostic: string, columns: number): readonly string[];
 export {};

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

@@ -1,5 +1,5 @@
 import { renderRefusalFacts } from "./refusal.js";
-import { displayColumns, renderOpaqueBlock, safeText, quotedText } from "./terminal.js";
+import { DEFAULT_CLI_COLUMNS, displayColumns, orderRefusalFacts, renderOpaqueBlock, safeText, quotedText, } from "./terminal.js";
 export function receiptRow(lines, mark, label, segments, columns) {
     const prefix = mark.trim().length === 0 ? "  " : `${mark} `;
     let current = `${prefix}${label}`;
@@ -21,9 +21,9 @@ export function receiptRow(lines, mark, label, segments, columns) {
     lines.push(current);
 }
 export function receiptPayload(lines, label, payload) {
-    lines.push(label, ...renderOpaqueBlock(payload, "  ", 80), "");
+    lines.push(`  ${label.trim()}`, ...renderOpaqueBlock(payload, "  ", DEFAULT_CLI_COLUMNS), "");
 }
-export function outcomeLines(mark, verb, word, contract, columns = 80) {
+export function outcomeLines(mark, verb, word, contract, columns = DEFAULT_CLI_COLUMNS) {
     const base = `${mark} ${verb} ${word}`;
     if (contract === undefined)
         return [base];
@@ -32,7 +32,15 @@ export function outcomeLines(mark, verb, word, contract, columns = 80) {
         return [inline];
     return [`${base}`, `  contract  ${safeText(contract)}`];
 }
-export function titleLines(mark, title, contract, columns = 80) {
+export function refusalLines(verb, facts, columns = DEFAULT_CLI_COLUMNS, trailingFacts = []) {
+    const lines = [
+        ...outcomeLines("×", verb, "refused", undefined, columns),
+        ...orderRefusalFacts(facts).map((fact) => `  ${fact}`),
+        ...trailingFacts,
+    ];
+    return lines;
+}
+export function titleLines(mark, title, contract, columns = DEFAULT_CLI_COLUMNS) {
     const base = `${mark} ${title}`;
     const inline = `${base}  ${contract}`;
     if (displayColumns(inline) <= columns)
@@ -48,10 +56,10 @@ export function hookFailureSummary(failure) {
 }
 export function appendHookPayload(lines, failure) {
     if (failure.kind === "spawn-error")
-        receiptPayload(lines, "diagnostic", failure.diagnostic);
+        receiptPayload(lines, "reason", failure.diagnostic);
     if (!("stdout" in failure))
         return;
-    if (failure.stdout.length > 0)
+    if (failure.stdout !== undefined && failure.stdout.length > 0)
         receiptPayload(lines, "stdout", failure.stdout);
     if (failure.stderr !== undefined && failure.stderr.length > 0)
         receiptPayload(lines, "stderr", failure.stderr);
@@ -59,7 +67,7 @@ export function appendHookPayload(lines, failure) {
 export function reuseLines(reuse, columns) {
     if (reuse === undefined)
         return [];
-    return renderOpaqueBlock(`reuse  verified · ${reuse.verdict} · ${reuse.entry}`, "  ", columns);
+    return renderOpaqueBlock(`reuse  verified · ${reuse.verdict}`, "  ", columns);
 }
 function prerequisiteRows(stop, columns) {
     if (!("refusal" in stop) || stop.refusal?.kind !== "prerequisites-unsatisfied")
@@ -70,26 +78,44 @@ function prerequisiteRows(stop, columns) {
     }
     return lines;
 }
-function gateRows(stop, columns) {
+/** Requirement names speak as plain event nouns; the "gate" class word never prints on a receipt. */
+function eventNoun(gate) {
+    if (gate === "reviewed")
+        return "review";
+    if (gate === "verified")
+        return "verification";
+    return gate;
+}
+/** Only a recorded unsatisfied verdict alarms; missing and stale requirements fold into the await line. */
+function gateAlarmRows(stop, columns) {
     if (!("refusal" in stop) || stop.refusal?.kind !== "gates-unsatisfied")
         return [];
     const lines = [];
     for (const report of stop.refusal.unmet) {
         const { gate, current } = report;
-        if (current.kind === "attested") {
-            receiptRow(lines, " ", "gate", [{ text: gate, opaque: true }, { text: "·" }, { text: current.verdict }, { text: `· at ${current.at}` }], columns);
-            if (current.summary !== undefined)
-                receiptPayload(lines, `  summary ${gate}`, current.summary);
-        }
-        else if (current.kind === "stale") {
-            receiptRow(lines, " ", "gate", [{ text: gate, opaque: true }, { text: "· stale" }, { text: `· prior ${current.priorVerdict}` }], columns);
-        }
-        else {
-            receiptRow(lines, " ", "gate", [{ text: gate, opaque: true }, { text: "· missing" }], columns);
-        }
+        if (current.kind !== "attested")
+            continue;
+        receiptRow(lines, "!", eventNoun(gate), [{ text: `· ${current.verdict}` }, { text: `· at ${current.at}` }], columns);
+        if (current.summary !== undefined)
+            receiptPayload(lines, `  summary ${gate}`, current.summary);
     }
     return lines;
 }
+/**
+ * The pending margin statement: the not-yet-happened requirements a refused placement awaits. A gate in stale
+ * state awaits the same event; when every unmet gate already holds a recorded verdict there is nothing pending and
+ * the line is omitted.
+ */
+export function gatesAwaitLines(placement) {
+    if (placement === undefined || !("refusal" in placement) || placement.refusal?.kind !== "gates-unsatisfied")
+        return [];
+    const events = placement.refusal.unmet
+        .filter((report) => report.current.kind !== "attested")
+        .map((report) => eventNoun(report.gate));
+    if (events.length === 0)
+        return [];
+    return [`⧗ awaiting ${events.length > 3 ? `${events.length} gates` : events.join(", ")}`];
+}
 function targetMovedDetail(stop) {
     if ("integratedAt" in stop) {
         return [
@@ -106,16 +132,15 @@ function targetMovedDetail(stop) {
     ];
 }
 function directStopName(stop) {
-    if ("refusal" in stop && stop.refusal !== undefined)
+    if ("refusal" in stop)
         return stop.refusal.kind.replaceAll("-", " ");
-    if ("retry" in stop && stop.retry !== undefined)
+    if ("retry" in stop)
         return stop.retry.kind.replaceAll("-", " ");
     return stop.failure.replaceAll("-", " ");
 }
 function refusalEvidence(stop, columns) {
     const lines = [];
     lines.push(...prerequisiteRows(stop, columns));
-    lines.push(...gateRows(stop, columns));
     if (!("refusal" in stop) || stop.refusal === undefined)
         return lines;
     const refusal = stop.refusal;
@@ -142,15 +167,51 @@ function refusalEvidence(stop, columns) {
     }
     return lines;
 }
-export function stopLines(stop, columns, addressed, dependent) {
-    if ("refusal" in stop && stop.refusal?.kind === "checkout-not-followable") {
-        const checkout = renderRefusalFacts(stop.refusal, "", columns, addressed);
-        if (dependent === undefined)
-            return checkout;
-        const lines = [];
-        receiptRow(lines, "!", "continuation", [{ text: dependent, opaque: true }], columns);
-        return [...lines, ...checkout];
-    }
+function checkoutNotFollowableStopLines(stop, columns, addressed, dependent) {
+    if (!("refusal" in stop) || stop.refusal?.kind !== "checkout-not-followable")
+        return undefined;
+    const checkout = renderRefusalFacts(stop.refusal, "", columns, addressed);
+    if (dependent === undefined)
+        return checkout;
+    const lines = [];
+    receiptRow(lines, "!", "dependent", [{ text: dependent, opaque: true }], columns);
+    return [...lines, ...checkout];
+}
+function targetPlacementFailedStopLines(stop, columns, dependent) {
+    if (!("failure" in stop) || stop.failure !== "target-placement-failed")
+        return undefined;
+    const lines = [];
+    receiptRow(lines, "×", "not accepted", dependent === undefined ? [] : [{ text: dependent, opaque: true }], columns);
+    receiptPayload(lines, "reason", stop.diagnostic);
+    return lines;
+}
+function retryStopLines(stop, columns, dependent) {
+    if (!("retry" in stop) || stop.retry === undefined)
+        return undefined;
+    const lines = [];
+    const segments = [{ text: stop.retry.kind.replaceAll("-", " ") }];
+    if (dependent !== undefined)
+        segments.push({ text: "·" }, { text: dependent, opaque: true });
+    receiptRow(lines, "?", "retry", segments, columns);
+    if (stop.retry.kind === "publication-failed")
+        receiptPayload(lines, "reason", stop.retry.diagnostic);
+    return lines;
+}
+function gatesUnsatisfiedStopLines(stop, columns, dependent) {
+    if (!("refusal" in stop) || stop.refusal?.kind !== "gates-unsatisfied")
+        return undefined;
+    // The refused placement never prints its refusal kind: the per-gate alarms and the target's non-movement
+    // carry the story, and the caller closes the receipt with the awaiting margin line.
+    const lines = [];
+    const target = stop.refusal.target;
+    if (dependent !== undefined)
+        receiptRow(lines, "⧗", dependent, [{ text: "·" }, { text: "gates unmet" }], columns);
+    else if (target !== undefined)
+        receiptRow(lines, " ", "target", [{ text: target, opaque: true }, { text: "· unchanged" }], columns);
+    lines.push(...gateAlarmRows(stop, columns));
+    return lines;
+}
+function directStopLines(stop, columns, dependent) {
     const lines = [];
     const segments = dependent === undefined ? [] : [{ text: "·" }, { text: directStopName(stop) }];
     if ("failure" in stop && stop.failure === "target-moved")
@@ -163,14 +224,18 @@ export function stopLines(stop, columns, addressed, dependent) {
     if ("failure" in stop && stop.failure === "environment-failure" && "name" in stop) {
         appendHookPayload(lines, stop.detail);
     }
-    if ("retry" in stop && stop.retry?.kind === "publication-failed") {
-        receiptPayload(lines, "diagnostic", stop.retry.diagnostic);
-    }
-    else if ("failure" in stop && "diagnostic" in stop) {
-        receiptPayload(lines, "diagnostic", stop.diagnostic);
+    if ("failure" in stop && "diagnostic" in stop) {
+        receiptPayload(lines, "reason", stop.diagnostic);
     }
     return lines;
 }
+export function stopLines(stop, columns, addressed, dependent) {
+    return (checkoutNotFollowableStopLines(stop, columns, addressed, dependent) ??
+        targetPlacementFailedStopLines(stop, columns, dependent) ??
+        retryStopLines(stop, columns, dependent) ??
+        gatesUnsatisfiedStopLines(stop, columns, dependent) ??
+        directStopLines(stop, columns, dependent));
+}
 export function cleanupLines(cleanup, columns) {
     const lines = [];
     receiptRow(lines, "!", "cleanup", [
@@ -183,23 +248,23 @@ export function cleanupLines(cleanup, columns) {
 }
 export function leakLines(leak, columns) {
     const lines = [];
-    receiptRow(lines, "!", "leak", [{ text: "worktree" }, { text: leak.path, opaque: true }], columns);
-    receiptPayload(lines, "diagnostic", leak.diagnostic);
+    receiptRow(lines, " ", "verification scratch kept at", [{ text: leak.path, opaque: true }], columns);
+    receiptPayload(lines, "reason", leak.diagnostic);
     return lines;
 }
 export function seatCloseLines(seatClose, columns) {
     const lines = [];
     for (const lag of seatClose) {
         receiptRow(lines, "!", "lag", [{ text: lag.kind }], columns);
-        receiptPayload(lines, "diagnostic", lag.diagnostic);
+        receiptPayload(lines, "reason", lag.diagnostic);
     }
     return lines;
 }
 export function executionStopLines(stops, columns) {
     const lines = [];
     for (const stop of stops) {
-        receiptRow(lines, "!", stop.stage, [{ text: stop.reason }, { text: stop.contractId, opaque: true }], columns);
-        receiptPayload(lines, "diagnostic", stop.diagnostic);
+        receiptRow(lines, "!", "execution", [{ text: stop.reason }, { text: stop.contractId, opaque: true }], columns);
+        receiptPayload(lines, "reason", stop.diagnostic);
     }
     return lines;
 }
@@ -214,17 +279,32 @@ export function executionCleanupLines(cleanup, columns, primary) {
             lines.push(...cleanupLines(issue.failure, columns));
         else if (issue.kind === "worktree-leak")
             lines.push(...leakLines(issue.leak, columns));
+        else if (issue.kind === "decode-channel-retirement")
+            receiptPayload(lines, "cleanup", issue.diagnostic);
         else
             lines.push(...seatCloseLines([issue.failure], columns));
     }
     return lines;
 }
 export function executionFailureLines(receipt, category, diagnostic, columns) {
+    const contract = "contract" in receipt ? receipt.contract : undefined;
+    const stops = [];
+    const cleanup = [];
+    for (const effect of receipt.effects) {
+        if (effect.kind === "execution-stopped")
+            stops.push({
+                kind: "execution-stopped",
+                contractId: effect.contract,
+                stage: effect.stage,
+                reason: effect.reason,
+                diagnostic: effect.diagnostic,
+            });
+        else if (effect.kind === "cleanup")
+            cleanup.push(effect.issue);
+    }
     const lines = [];
-    receiptRow(lines, "!", "execution failed after admission", [{ text: category }, { text: receipt.contractId, opaque: true }], columns);
-    receiptPayload(lines, "diagnostic", diagnostic);
-    for (const fact of receipt.facts)
-        receiptRow(lines, " ", "journal", [{ text: fact.contract, opaque: true }, { text: fact.entry, opaque: true }, { text: fact.kind }], columns);
-    lines.push(...executionStopLines(receipt.executionStops, columns), ...executionCleanupLines(receipt.cleanup, columns, receipt.contractId));
+    receiptRow(lines, "!", "execution failed after admission", [{ text: category }, ...(contract === undefined ? [] : [{ text: contract, opaque: true }])], columns);
+    receiptPayload(lines, "reason", diagnostic);
+    lines.push(...executionStopLines(stops, columns), ...executionCleanupLines(cleanup, columns, contract));
     return lines;
 }

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

@@ -0,0 +1,5 @@
+import type { ReconcileReport } from "../../library/reconcile.js";
+import { type RepoReconcileReport } from "../../library/reconcile.js";
+import { type TextRenderContext } from "./terminal.js";
+export declare function reconcileHasFailure(report: ReconcileReport | RepoReconcileReport): boolean;
+export declare function renderReconcile(report: ReconcileReport | RepoReconcileReport, context?: TextRenderContext): string;

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

@@ -0,0 +1,152 @@
+import { reconcileLagIsFailure } from "../../library/reconcile.js";
+import { abbreviateGitIds, displayGitId } from "./contract-observation.js";
+import { receiptPayload, receiptRow } from "./receipt.js";
+import { DEFAULT_CLI_COLUMNS } from "./terminal.js";
+function effectText(effect) {
+    if (effect.action === "unchanged")
+        return null;
+    const ids = effect.kind === "ref"
+        ? [effect.before ?? "", effect.after ?? ""]
+        : effect.kind === "worktree" && effect.action === "followed"
+            ? [effect.before, effect.after]
+            : effect.kind === "recovery-snapshot"
+                ? [effect.snapshot]
+                : [];
+    const abbreviations = abbreviateGitIds(ids);
+    const state = effect.kind === "ref"
+        ? `${effect.action}${effect.before === null ? "" : ` · ${displayGitId(effect.before, abbreviations)}`}${effect.after === null ? "" : ` → ${displayGitId(effect.after, abbreviations)}`}`
+        : effect.kind === "worktree" && effect.action === "followed"
+            ? `followed · ${displayGitId(effect.before, abbreviations)} → ${displayGitId(effect.after, abbreviations)}`
+            : effect.action;
+    const path = effect.kind === "ref"
+        ? effect.name
+        : effect.kind === "recovery-snapshot"
+            ? displayGitId(effect.snapshot, abbreviations)
+            : effect.path;
+    return [effect.kind, state, path];
+}
+function worktreeHookLagRows(lines, lag, columns, contract) {
+    receiptRow(lines, "!", "reconcile", [
+        ...(contract === undefined ? [] : [{ text: contract, opaque: true }]),
+        { text: "hook", opaque: true },
+        { text: lag.phase, opaque: true },
+        { text: lag.path, opaque: true },
+        { text: lag.name, opaque: true },
+        { text: `command ${lag.command}`, opaque: true },
+        { text: lag.failure.kind === "exit" ? `exit ${lag.failure.code}` : lag.failure.kind, opaque: true },
+    ], columns);
+    const output = "stdout" in lag.failure ? lag.failure.stdout : undefined;
+    const error = "stderr" in lag.failure ? lag.failure.stderr : undefined;
+    if (lag.failure.kind === "spawn-error") {
+        receiptRow(lines, "!", "reason", [{ text: lag.failure.diagnostic, opaque: true }], columns);
+    }
+    if (output !== undefined && output.length > 0)
+        receiptPayload(lines, "stdout", output);
+    if (error !== undefined && error.length > 0)
+        receiptPayload(lines, "stderr", error);
+}
+function lagRow(lines, lag, columns, contract) {
+    switch (lag.kind) {
+        case "worktree-hook-failed":
+            worktreeHookLagRows(lines, lag, columns, contract);
+            break;
+        case "reconcile-failed":
+            receiptRow(lines, "!", "reconcile", [
+                ...(contract === undefined ? [] : [{ text: contract, opaque: true }]),
+                { text: lag.stage, opaque: true },
+                { text: lag.diagnostic, opaque: true },
+            ], columns);
+            break;
+        case "worktree-retained":
+            receiptRow(lines, " ", "worktree retained at", [{ text: lag.path, opaque: true }], columns);
+            if (lag.diagnostic !== undefined)
+                receiptRow(lines, " ", "reason", [{ text: lag.diagnostic, opaque: true }], columns);
+            break;
+        case "worktree-follow-retained":
+            receiptRow(lines, " ", "worktree follow kept at", [{ text: lag.path, opaque: true }, { text: `· ${lag.reason.replaceAll("-", " ")}` }], columns);
+            break;
+        case "unsealed-bytes":
+            receiptRow(lines, " ", "unsealed bytes kept at", [{ text: lag.path, opaque: true }], columns);
+            break;
+        case "target-checkout-retained":
+            receiptRow(lines, "!", "target checkout kept at", [
+                { text: lag.path, opaque: true },
+                { text: `· ${lag.target}`, opaque: true },
+            ], columns);
+            receiptRow(lines, " ", "reason", [{ text: lag.diagnostic, opaque: true }], columns);
+            break;
+        case "contract-file-failed":
+            receiptRow(lines, "!", "contract file unavailable", [
+                { text: lag.worktree, opaque: true },
+                { text: `· ${lag.path}`, opaque: true },
+            ], columns);
+            receiptRow(lines, " ", "reason", [{ text: lag.diagnostic, opaque: true }], columns);
+            break;
+        default: {
+            const exhaustive = lag;
+            return exhaustive;
+        }
+    }
+}
+function appendReport(lines, report, columns, seen, contract) {
+    for (const effect of report.effects) {
+        const parts = effectText(effect);
+        if (parts === null)
+            continue;
+        const key = JSON.stringify([contract, effect]);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        receiptRow(lines, " ", "effect", parts.map((text) => ({ text, opaque: true })), columns);
+    }
+    for (const lag of report.lag)
+        lagRow(lines, lag, columns, contract);
+    for (const action of report.settlement?.actions ?? []) {
+        receiptRow(lines, " ", "settlement", [{ text: action.kind, opaque: true }], columns);
+    }
+    for (const lag of report.settlement?.lags ?? []) {
+        receiptRow(lines, "!", "settlement", Object.entries(lag)
+            .filter(([key]) => key !== "kind")
+            .map(([key, value]) => ({ text: `${key} ${String(value)}`, opaque: true })), columns);
+    }
+    for (const failure of report.settlement?.seatClose ?? []) {
+        receiptRow(lines, "!", "settlement", [{ text: failure.kind, opaque: true }], columns);
+        receiptRow(lines, "!", "reason", [{ text: failure.diagnostic, opaque: true }], columns);
+    }
+}
+function isRepoReport(report) {
+    return "kind" in report && (report.kind === "completed" || report.kind === "world-observation-failed");
+}
+export function reconcileHasFailure(report) {
+    if (isRepoReport(report)) {
+        if (report.kind === "world-observation-failed")
+            return true;
+        const completed = report;
+        return completed.contracts.some((item) => {
+            return (item.report.lag.some((lag) => reconcileLagIsFailure(lag)) ||
+                item.report.settlement.lags.length > 0 ||
+                (item.report.settlement.seatClose?.length ?? 0) > 0);
+        });
+    }
+    return (report.lag.some((lag) => reconcileLagIsFailure(lag)) ||
+        (report.settlement?.lags.length ?? 0) > 0 ||
+        (report.settlement?.seatClose?.length ?? 0) > 0);
+}
+export function renderReconcile(report, context) {
+    const columns = context?.columns ?? DEFAULT_CLI_COLUMNS;
+    const lines = ["✓ reconcile"];
+    const seen = new Set();
+    if (isRepoReport(report)) {
+        if (report.kind === "world-observation-failed") {
+            receiptRow(lines, "!", "reconcile", [{ text: report.diagnostic, opaque: true }], columns);
+            return lines.join("\n");
+        }
+        for (const item of report.contracts)
+            appendReport(lines, item.report, columns, seen, item.contractId);
+    }
+    else
+        appendReport(lines, report, columns, seen);
+    if (lines.length === 1)
+        lines.push("  already consistent");
+    return lines.join("\n");
+}

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

@@ -1,5 +1,6 @@
-import type { BindDraftReceipt, RefusedResult } from "../result.js";
-import type { IntegrationConflictMaterialized, KeiyakuRefusal } from "../../index.js";
+import type { BindDraftReceipt } from "../draft.js";
+import { type CliUsageGuide } from "../usage.js";
+import type { ContractId, IntegrationConflictMaterialized, KeiyakuRefusal } from "../../index.js";
 import { type TextRenderContext } from "./terminal.js";
 type DirtyWithOption = Extract<KeiyakuRefusal, {
     kind: "dirty-workspace";
@@ -9,9 +10,25 @@ type DirtyWithOption = Extract<KeiyakuRefusal, {
         available: boolean;
     }>;
 };
-export type RenderableRefusal = KeiyakuRefusal | DirtyWithOption;
+/** Edge acquisition refusals the CLI owns; they never come from the SDK. */
+type CliEdgeRefusal = Readonly<{
+    kind: "invalid-document";
+    diagnostic: string;
+}>;
+export type RenderableRefusal = KeiyakuRefusal | DirtyWithOption | CliEdgeRefusal;
 export declare function renderRefusalFacts(refusal: RenderableRefusal, indent: string, columns: number, addressed?: string): readonly string[];
-export declare function renderRefusal(result: RefusedResult, context?: TextRenderContext): string;
+/**
+ * The one refusal receipt assembly: a denied-verdict title, a labeled reason, labeled facts, and the
+ * applicable acceptance grammar. Typed refusals and bare command refusals both render through here.
+ */
+export declare function renderStructuredRefusal(verb: string, reason: string, facts?: readonly string[], guide?: CliUsageGuide): string;
+/** One native refusal plus the CLI's own presentation identity; the draft belongs only to edge bind. */
+type RefusedInvocation = Readonly<{
+    operation: string;
+    contract?: ContractId;
+    refusal: RenderableRefusal;
+}>;
+export declare function renderRefusal(refused: RefusedInvocation, draft?: BindDraftReceipt, context?: TextRenderContext): string;
 export declare function renderConflictMaterialized(result: IntegrationConflictMaterialized, _context?: TextRenderContext): string;
 export declare function renderBindDraftReceipt(receipt: BindDraftReceipt): string;
 export {};