@astrosheep/keiyaku 4.5.29 → 4.6.2

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

@@ -1,5 +1,12 @@
-import type { AcceptedResult, RetryResult } from "../result.js";
+import type { AbandonOutcome, AmendOutcome, ArcOutcome, AuditOutcome, BindOutcome, DeliverOutcome, ReviewOutcome } from "../../index.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 type ContractOutcome = BindOutcome | AmendOutcome | DeliverOutcome | ReviewOutcome | AuditOutcome | ArcOutcome | AbandonOutcome;
+export type AcceptedContractOutcome = Extract<ContractOutcome, {
+    kind: "accepted";
+}>;
+type RetryContractOutcome = Extract<ContractOutcome, {
+    kind: "retry";
+}>;
+export declare function renderAccepted(result: AcceptedContractOutcome, context?: TextRenderContext): string;
+export declare function renderRetry(result: RetryContractOutcome, context?: TextRenderContext): string;
 export { renderContractHistory } from "./contract-history.js";

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

@@ -1,16 +1,43 @@
+import { effectCleanup, effectExecutionStops, effectLags, effectRecoverySnapshot, effectRetainedCheckouts, effectRetainedWorktrees, effectRetiredWorktrees, effectSettlementLags, } from "./effects.js";
 import { renderAcceptedAudit } from "./audit.js";
-import { appendHookPayload, executionCleanupLines, executionStopLines, hookFailureSummary, outcomeLines, receiptPayload, receiptRow, reuseLines, stopLines, titleLines, } from "./receipt.js";
+import { appendHookPayload, executionCleanupLines, executionStopLines, gatesAwaitLines, hookFailureSummary, outcomeLines, receiptPayload, receiptRow, reuseLines, stopLines, titleLines, } from "./receipt.js";
+import { abbreviateGitIds, displayGitId, lifecycleWord } from "./contract-observation.js";
+import { renderDiffstat } from "./akuma-tool.js";
 import { DEFAULT_CLI_COLUMNS, renderOpaqueBlock, safeText, tone } from "./terminal.js";
 const HANG = "  ";
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
+function attestationVerdict(facts) {
+    const attestation = facts.findLast((fact) => fact.kind === "attestation" && fact.data.gate === "reviewed");
+    if (attestation === undefined)
+        throw new Error("accepted review is missing its reviewed attestation");
+    return attestation.data.verdict;
+}
+function bindTarget(facts) {
+    return facts.findLast((fact) => fact.kind === "bind")?.data.coordinates.target ?? null;
+}
+function arcChapter(facts) {
+    const arc = facts.findLast((fact) => fact.kind === "arc");
+    if (arc === undefined)
+        throw new Error("accepted arc is missing its arc fact");
+    return { seq: arc.data.seq, title: arc.data.title };
+}
+function abandonedNote(facts) {
+    return facts.findLast((fact) => fact.kind === "abandoned")?.data.note;
 }
 function retryLines(detail, indent, columns) {
     if (detail.kind === "publication-failed") {
-        return [...renderOpaqueBlock("publication-failed", indent, columns), ...["diagnostic", "", detail.diagnostic, ""]];
+        return [...renderOpaqueBlock("publication-failed", indent, columns), ...["reason", "", detail.diagnostic, ""]];
     }
     return renderOpaqueBlock(detail.kind, indent, columns);
 }
+/**
+ * The one word for a checkout git could not carry to the landed head: `behind` is git's own name for
+ * that state, and the raw result kind never prints on a receipt.
+ */
+function checkoutBehindRows(path, target, columns) {
+    const lines = [];
+    receiptRow(lines, "!", "lag", [{ text: "checkout behind" }, { text: path, opaque: true }, { text: `· ${target}`, opaque: true }], columns);
+    return lines;
+}
 function lagRows(lag, columns) {
     const lines = [];
     if (lag.kind === "worktree-retained") {
@@ -29,8 +56,8 @@ function lagRows(lag, columns) {
         receiptRow(lines, "!", "lag", [{ text: "unsealed bytes" }, { text: lag.path, opaque: true }], columns);
     }
     else if (lag.kind === "target-checkout-retained") {
-        receiptRow(lines, "!", "lag", [{ text: `target-checkout-retained ${lag.target} ${lag.path}`, opaque: true }], columns);
-        receiptPayload(lines, "diagnostic", lag.diagnostic);
+        pushBlock(lines, checkoutBehindRows(lag.path, lag.target, columns));
+        receiptPayload(lines, "reason", lag.diagnostic);
     }
     else if (lag.kind === "worktree-hook-failed") {
         receiptRow(lines, "!", "lag", [
@@ -43,11 +70,11 @@ function lagRows(lag, columns) {
     }
     else if (lag.kind === "contract-file-failed") {
         receiptRow(lines, "!", "lag", [{ text: `contract-file-failed ${lag.worktree} ${lag.path}`, opaque: true }], columns);
-        receiptPayload(lines, "diagnostic", lag.diagnostic);
+        receiptPayload(lines, "reason", lag.diagnostic);
     }
     else {
         receiptRow(lines, "!", "lag", [{ text: `reconcile-failed ${lag.stage}`, opaque: true }], columns);
-        receiptPayload(lines, "diagnostic", lag.diagnostic);
+        receiptPayload(lines, "reason", lag.diagnostic);
     }
     return lines;
 }
@@ -58,39 +85,71 @@ function settlementLagRows(lag, columns) {
         receiptRow(lines, " ", "task", [{ text: lag.taskId, opaque: true }], columns);
     if (lag.path !== undefined)
         receiptRow(lines, " ", "path", [{ text: lag.path, opaque: true }], columns);
-    receiptPayload(lines, "diagnostic", lag.diagnostic);
+    receiptPayload(lines, "reason", lag.diagnostic);
     return lines;
 }
+function overlapGroup(patterns) {
+    const identical = [];
+    const identicalSeen = new Set();
+    const contained = new Map();
+    const intersections = [];
+    const intersectionSeen = new Set();
+    for (const pattern of patterns) {
+        if (pattern.relation === "same" || (pattern.relation === undefined && pattern.mine === pattern.theirs)) {
+            if (!identicalSeen.has(pattern.mine)) {
+                identicalSeen.add(pattern.mine);
+                identical.push(pattern.mine);
+            }
+            continue;
+        }
+        if (pattern.relation === "mine-within-theirs" || pattern.relation === "theirs-within-mine") {
+            const container = pattern.relation === "mine-within-theirs" ? pattern.theirs : pattern.mine;
+            const leaf = pattern.relation === "mine-within-theirs" ? pattern.mine : pattern.theirs;
+            const entry = contained.get(container) ?? { container, leaves: [] };
+            if (!entry.leaves.includes(leaf))
+                entry.leaves.push(leaf);
+            contained.set(container, entry);
+            continue;
+        }
+        const key = `${pattern.mine}\u0000${pattern.theirs}`;
+        if (!intersectionSeen.has(key)) {
+            intersectionSeen.add(key);
+            intersections.push({ mine: pattern.mine, theirs: pattern.theirs });
+        }
+    }
+    return { identical, contained: [...contained.values()], intersections };
+}
 function overlapRows(overlaps, color) {
     const groups = new Map();
     for (const overlap of overlaps) {
-        let patterns = groups.get(overlap.contract);
-        if (patterns === undefined) {
-            patterns = new Map();
-            groups.set(overlap.contract, patterns);
-        }
-        for (const pattern of overlap.patterns)
-            patterns.set(JSON.stringify([pattern.mine, pattern.theirs]), pattern);
+        const patterns = groups.get(overlap.contract) ?? [];
+        patterns.push(...overlap.patterns);
+        groups.set(overlap.contract, patterns);
     }
     if (groups.size === 0)
         return [];
-    const lines = ["", `  ${tone("overlap", "dim", color)}`];
+    const lines = [""];
+    let groupIndex = 0;
     for (const [contract, patterns] of groups) {
-        if (lines.length > 2)
+        if (groupIndex++ > 0)
             lines.push("");
         const identity = safeText(contract);
-        lines.push(`  ${tone("└─", "dim", color)} ${color ? `\u001b[1m${identity}\u001b[0m` : identity}`);
-        let first = true;
-        for (const { mine, theirs } of patterns.values()) {
-            if (mine === theirs)
-                lines.push(`       ${safeText(mine)}`);
-            else {
-                if (!first)
-                    lines.push("");
-                lines.push(`       this   ${safeText(mine)}`, `       other  ${safeText(theirs)}`);
-            }
-            first = false;
+        lines.push(`  overlap  ${color ? `\u001b[1m${identity}\u001b[0m` : identity}`);
+        const group = overlapGroup(patterns);
+        const relation = (symbol) => tone(symbol, "dim", color);
+        const bounded = group.identical.slice(0, 6);
+        for (const pattern of bounded)
+            lines.push(`    ${relation("≡")}  ${safeText(pattern)}`);
+        if (group.identical.length > 6)
+            lines.push(`    ${relation("≡")}  … (${group.identical.length - 6} more)`);
+        for (const { container, leaves } of group.contained) {
+            for (const leaf of leaves.slice(0, 6))
+                lines.push(`    ${safeText(leaf)}  ${relation("⊂")}  ${safeText(container)}`);
+            if (leaves.length > 6)
+                lines.push(`    … (${leaves.length - 6} more)  ${relation("⊂")}  ${safeText(container)}`);
         }
+        for (const { mine, theirs } of group.intersections)
+            lines.push(`    ${relation("∩")}  ${safeText(mine)} · ${safeText(theirs)}`);
     }
     return lines;
 }
@@ -101,33 +160,47 @@ function pushBlock(lines, block) {
 }
 function acceptedRecord(result, columns) {
     const record = [];
-    if (result.recoverySnapshot !== undefined)
-        receiptRow(record, " ", "recovery snapshot", [{ text: result.recoverySnapshot, opaque: true }], columns);
-    if (result.verb === "deliver") {
-        pushBlock(record, reuseLines(result.verificationReuse, columns));
+    const recoverySnapshot = effectRecoverySnapshot(result.effects);
+    if (recoverySnapshot !== undefined)
+        receiptRow(record, " ", "recovery snapshot", [{ text: recoverySnapshot, opaque: true }], columns);
+    if (result.operation === "deliver") {
+        pushBlock(record, reuseLines(result.value.verificationReuse, columns));
     }
     return record;
 }
 function acceptedLagRows(result, columns) {
     const obligations = [];
-    if (result.lag !== undefined) {
-        for (const lag of result.lag)
-            pushBlock(obligations, lagRows(lag, columns));
+    // A checkout this invocation's own follow could not carry is loud; the same arm's reconciliation lag
+    // is pre-existing residue and stays in the typed result only.
+    for (const checkout of effectRetainedCheckouts(result.effects) ?? []) {
+        pushBlock(obligations, checkoutBehindRows(checkout.path, checkout.target, columns));
     }
-    for (const lag of result.settlementLags) {
+    for (const { contract, lag } of effectLags(result.effects)) {
+        if (lag.kind === "worktree-retained" ||
+            lag.kind === "worktree-follow-retained" ||
+            lag.kind === "unsealed-bytes" ||
+            lag.kind === "target-checkout-retained")
+            continue;
+        if (contract !== result.contract)
+            receiptRow(obligations, "!", "lag owner", [{ text: contract, opaque: true }], columns);
+        pushBlock(obligations, lagRows(lag, columns));
+    }
+    for (const { contract, lag } of effectSettlementLags(result.effects)) {
+        if (contract !== result.contract)
+            receiptRow(obligations, "!", "settlement owner", [{ text: contract, opaque: true }], columns);
         pushBlock(obligations, settlementLagRows(lag, columns));
     }
-    pushBlock(obligations, executionCleanupLines(result.cleanup ?? [], columns, result.contract));
-    pushBlock(obligations, executionStopLines(result.executionStops ?? [], columns));
+    pushBlock(obligations, executionCleanupLines(effectCleanup(result.effects).filter((issue) => issue.kind !== "worktree-leak"), columns, result.contract));
+    pushBlock(obligations, executionStopLines(effectExecutionStops(result.effects), columns));
     return obligations;
 }
 function acceptedDeviations(result, columns, color) {
     const deviations = [];
-    if (result.overlaps !== undefined)
-        pushBlock(deviations, overlapRows(result.overlaps, color));
-    if (result.overlapFailure !== undefined) {
+    if (result.value.overlaps !== undefined)
+        pushBlock(deviations, overlapRows(result.value.overlaps, color));
+    if (result.value.overlapFailure !== undefined) {
         receiptRow(deviations, "!", "overlap", [{ text: "unavailable" }], columns);
-        receiptPayload(deviations, "diagnostic", result.overlapFailure);
+        receiptPayload(deviations, "reason", result.value.overlapFailure);
     }
     return deviations;
 }
@@ -137,50 +210,99 @@ function recordBlock(result, columns) {
 }
 function nonGatingVerificationLines(result, columns) {
     const lines = [];
-    const verification = result.completion?.verification;
+    const verification = result.value.completion?.verification;
     if (verification === undefined || verification.verdict !== "unsatisfied")
         return lines;
-    receiptRow(lines, "!", "verification", [{ text: "unsatisfied" }, { text: `(${verification.mode})` }, { text: "· not required by Contract gates" }], columns);
-    if (result.verificationSummary !== undefined) {
-        receiptPayload(lines, "  summary", result.verificationSummary);
+    receiptRow(lines, "!", "verification", [
+        ...(verification.mode === "reused" ? [{ text: "reused" }] : []),
+        { text: "unsatisfied" },
+        { text: "· not required by Contract gates" },
+    ], columns);
+    if (result.value.verificationSummary !== undefined) {
+        receiptPayload(lines, "  summary", result.value.verificationSummary);
     }
     return lines;
 }
-function shortGitId(value) {
-    return /^[0-9a-f]{40}$/iu.test(value) ? value.slice(0, 7) : value;
+/** A terminal command names the worktree it retired, or the retained worktree it failed to remove. */
+function worktreeRetirementLines(result, columns) {
+    const lines = [];
+    for (const { contract, name } of effectRetiredWorktrees(result.effects)) {
+        if (contract === result.contract)
+            receiptRow(lines, " ", "worktree", [{ text: `${name} retired` }], columns);
+        else
+            receiptRow(lines, "!", "worktree owner", [
+                { text: contract, opaque: true },
+                { text: `${name} retired`, opaque: true },
+            ], columns);
+    }
+    for (const { contract, path } of effectRetainedWorktrees(result.effects)) {
+        if (contract === result.contract)
+            receiptRow(lines, "!", "lag", [{ text: "worktree retained" }, { text: path, opaque: true }], columns);
+        else
+            receiptRow(lines, "!", "worktree owner", [
+                { text: contract, opaque: true },
+                { text: `retained ${path}`, opaque: true },
+            ], columns);
+    }
+    return lines;
+}
+/** The landed diff's shape, rendered by the one diffstat rule the akuma surfaces already own. */
+function landedChangesLines(scope, columns) {
+    if (scope === undefined)
+        return [];
+    const files = `${scope.filesChanged} ${scope.filesChanged === 1 ? "file" : "files"}`;
+    const lines = [];
+    receiptRow(lines, " ", "changes", [{ text: `${files} · ${renderDiffstat({ added: scope.insertions, removed: scope.deletions })}` }], columns);
+    return lines;
 }
 /**
  * Shared presentation of a completed placement, so a deliver and a review that placed the same candidate read
  * 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. Verification mode words stay in
- * JSON and `history`, never in ordinary receipt text. A completion without an advanced reference states no movement.
- * Journal ULIDs stay in JSON and `history`, never in ordinary receipt text.
+ * 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
+ * without an advanced reference states no movement. Journal ULIDs stay in JSON and `history`, never in ordinary
+ * receipt text.
  */
 function completedPlacementLines(result, columns) {
-    const completion = result.completion;
+    const completion = result.value.completion;
     if (completion === undefined)
         return [];
+    const abbreviations = abbreviateGitIds([
+        completion.predecessor ?? "",
+        completion.integration,
+        ...(result.operation === "deliver"
+            ? [result.value.tenderSnapshot ?? "", result.value.integration?.changeId ?? ""]
+            : []),
+    ]);
     const lines = [];
     if (completion.predecessor !== undefined && completion.target !== undefined) {
         receiptRow(lines, " ", "target", [
-            { text: `${shortGitId(completion.predecessor)}..${shortGitId(completion.integration)}` },
+            {
+                text: `${displayGitId(completion.predecessor, abbreviations)}..${displayGitId(completion.integration, abbreviations)}`,
+            },
             { text: completion.target, opaque: true },
         ], columns);
     }
     if (completion.verification?.verdict === "satisfied") {
-        receiptRow(lines, " ", "integration result", [{ text: `${shortGitId(completion.integration)} · verification satisfied` }], columns);
+        receiptRow(lines, " ", "integration result", [
+            {
+                text: `${displayGitId(completion.integration, abbreviations)} · verification ${completion.verification.mode === "reused" ? "reused " : ""}satisfied`,
+            },
+        ], columns);
     }
+    lines.push(...landedChangesLines(completion.scope, columns));
     lines.push(...nonGatingVerificationLines(result, columns));
-    // Placement admission always admits the claim entry beside the movement, so a completed placement is claimed.
-    receiptRow(lines, "●", "claimed", [], columns);
+    // Placement admission always admits the claim entry beside the movement, so a completed placement is accepted.
+    receiptRow(lines, "✓", lifecycleWord("claimed"), [], columns);
     return lines;
 }
 /** Evidence handles stay in JSON and history; ordinary receipt text carries only outstanding obligations. */
 function obligationLines(result, columns) {
     const rows = [];
-    if (result.recoverySnapshot !== undefined)
-        receiptRow(rows, " ", "recovery snapshot", [{ text: result.recoverySnapshot, opaque: true }], columns);
+    const recoverySnapshot = effectRecoverySnapshot(result.effects);
+    if (recoverySnapshot !== undefined)
+        receiptRow(rows, " ", "recovery snapshot", [{ text: recoverySnapshot, opaque: true }], columns);
     rows.push(...acceptedLagRows(result, columns));
     return rows;
 }
@@ -193,12 +315,12 @@ function movementLines(result, columns) {
     return lines;
 }
 function continuationLines(result, columns) {
-    const report = result.continuation;
+    const report = result.value.continuation;
     if (report === undefined)
         return [];
     const lines = [];
     for (const contractId of report.claimed) {
-        receiptRow(lines, "✓", "continuation", [{ text: "complete" }, { text: contractId, opaque: true }], columns);
+        receiptRow(lines, "✓", "dependent", [{ text: "complete" }, { text: contractId, opaque: true }], columns);
     }
     for (const { contractId, stop } of report.stopped) {
         if ("kind" in stop && stop.kind === "already-terminal")
@@ -206,7 +328,7 @@ function continuationLines(result, columns) {
         else if ("kind" in stop && stop.kind === "execution-stopped")
             lines.push(...executionStopLines([stop], columns));
         else if ("kind" in stop && stop.kind === "physical-lag") {
-            receiptRow(lines, "!", "continuation", [{ text: contractId, opaque: true }, { text: "physical follow stopped" }], columns);
+            receiptRow(lines, "!", "dependent", [{ text: contractId, opaque: true }, { text: "physical follow stopped" }], columns);
         }
         else
             lines.push(...stopLines(stop, columns, contractId, contractId));
@@ -215,81 +337,110 @@ function continuationLines(result, columns) {
 }
 function renderAcceptedBind(result, columns, color) {
     const lines = titleLines("✓", "bound", result.contract, columns);
-    if (result.workspace !== undefined)
-        receiptRow(lines, " ", "workspace", [{ text: "worktree" }, { text: result.workspace.path, opaque: true }], columns);
-    if (result.target === null)
+    if (result.value.workspace !== undefined)
+        receiptRow(lines, " ", "worktree", [{ text: result.value.workspace.path, opaque: true }], columns);
+    const target = bindTarget(result.facts);
+    if (target === null)
         receiptRow(lines, " ", "no target", [], columns);
     else
-        receiptRow(lines, " ", "target", [{ text: result.target, opaque: true }], columns);
-    for (const warning of result.warnings ?? [])
+        receiptRow(lines, " ", "target", [{ text: target, opaque: true }], columns);
+    for (const warning of result.value.warnings ?? [])
         receiptRow(lines, "!", "region warning", [{ text: warning }], columns);
     lines.push(...acceptedDeviations(result, columns, color), ...recordBlock(result, columns));
     return lines.join("\n");
 }
+function termsDiffText(diff) {
+    return diff.replace(/^={3,}\r?\n/u, "").replace(/^((?:---|\+\+\+) [^\r\n]*)[ \t]+$/gmu, "$1");
+}
 function renderAcceptedAmend(result, columns, color) {
-    const changed = result.diff.length > 0;
-    const lines = titleLines("✓", changed ? "terms replaced" : "terms unchanged", result.contract, columns);
-    if (changed)
-        receiptPayload(lines, "  terms diff", result.diff);
+    const documentChanged = result.value.documentDiff.length > 0;
+    const changed = documentChanged || result.value.changes.gates !== undefined || result.value.changes.after !== undefined;
+    const lines = titleLines("✓", "amended", result.contract, columns);
+    if (!changed)
+        receiptRow(lines, " ", "terms", [{ text: "unchanged" }], columns);
+    if (result.value.changes.gates !== undefined)
+        receiptRow(lines, " ", "gates", [{ text: result.value.changes.gates.join(" · ") || "none" }], columns);
+    if (result.value.changes.after !== undefined)
+        receiptRow(lines, " ", "after", [{ text: result.value.changes.after.join(" · ") || "none" }], columns);
+    if (documentChanged)
+        receiptPayload(lines, "terms diff", termsDiffText(result.value.documentDiff));
     lines.push(...acceptedDeviations(result, columns, color), ...recordBlock(result, columns));
     return lines.join("\n");
 }
+function deliverIdentityLines(result, abbreviations, columns) {
+    const lines = [];
+    if (result.value.leading !== undefined && result.value.leading.kind === "already-admitted")
+        receiptRow(lines, " ", "leading", [{ text: result.value.leading.kind.replaceAll("-", " ") }], columns);
+    if (result.value.tenderSnapshot !== undefined)
+        receiptRow(lines, " ", "candidate", [{ text: displayGitId(result.value.tenderSnapshot, abbreviations), opaque: true }], columns);
+    if (result.value.integration !== undefined && !/^0{40}$/u.test(result.value.integration.changeId))
+        receiptRow(lines, " ", "content identity (not commit)", [{ text: displayGitId(result.value.integration.changeId, abbreviations), opaque: true }], columns);
+    return lines;
+}
 function renderAcceptedDeliver(result, columns) {
-    const complete = result.completion !== undefined;
-    const title = complete ? "delivered" : "deliver incomplete";
-    const lines = titleLines("✓", title, result.contract, columns);
-    if (result.leading !== undefined) {
-        receiptRow(lines, " ", "leading", [{ text: result.leading.kind.replaceAll("-", " ") }], columns);
-    }
-    if (result.tenderSnapshot !== undefined)
-        receiptRow(lines, " ", "tender commit", [{ text: result.tenderSnapshot, opaque: true }], columns);
-    if (result.integration !== undefined)
-        receiptRow(lines, " ", "content identity (not commit)", [{ text: result.integration.changeId, opaque: true }], columns);
+    const complete = result.value.completion !== undefined;
+    const lines = titleLines("✓", "delivered", result.contract, columns);
+    const abbreviations = abbreviateGitIds([
+        result.value.tenderSnapshot ?? "",
+        result.value.integration?.changeId ?? "",
+        result.value.verificationSubject?.snapshot ?? "",
+        result.value.completion?.predecessor ?? "",
+        result.value.completion?.integration ?? "",
+    ]);
+    lines.push(...deliverIdentityLines(result, abbreviations, columns));
     if (complete)
         lines.push(...completedPlacementLines(result, columns));
-    else
+    else {
+        const subject = result.value.verificationSubject;
+        if (subject !== undefined)
+            receiptRow(lines, " ", "integration result", [
+                {
+                    text: `${displayGitId(subject.snapshot, abbreviations)} · verification ${subject.mode === "reused" ? "reused " : ""}${subject.verdict}`,
+                },
+            ], columns);
         lines.push(...movementLines(result, columns));
-    if (result.verification !== undefined) {
-        lines.push(...stopLines(result.verification, columns, result.contract));
-    }
-    if (!complete && result.placement !== undefined) {
-        lines.push(...stopLines(result.placement, columns, result.contract));
     }
+    if (result.value.verification !== undefined)
+        lines.push(...stopLines(result.value.verification, columns, result.contract));
+    if (!complete && result.value.placement !== undefined)
+        lines.push(...stopLines(result.value.placement, columns, result.contract));
     if (!complete)
         receiptRow(lines, " ", "candidate", [{ text: "kept" }], columns);
-    lines.push(...continuationLines(result, columns));
-    lines.push(...(complete ? obligationLines(result, columns) : recordBlock(result, columns)));
+    lines.push(...continuationLines(result, columns), ...(complete ? obligationLines(result, columns) : recordBlock(result, columns)), ...worktreeRetirementLines(result, columns), ...gatesAwaitLines(result.value.placement));
     return lines.join("\n");
 }
 function renderAcceptedReview(result, columns) {
-    const lines = titleLines("✓", `review ${result.verdict}`, result.contract, columns);
+    const lines = titleLines("✓", `review ${attestationVerdict(result.facts)}`, result.contract, columns);
     lines.push(...completedPlacementLines(result, columns));
-    if (result.verification !== undefined) {
-        lines.push(...stopLines(result.verification, columns, result.contract));
+    if (result.value.verification !== undefined) {
+        lines.push(...stopLines(result.value.verification, columns, result.contract));
     }
-    if (result.placement !== undefined) {
-        lines.push(...stopLines(result.placement, columns, result.contract));
+    if (result.value.placement !== undefined) {
+        lines.push(...stopLines(result.value.placement, columns, result.contract));
     }
     lines.push(...continuationLines(result, columns));
     lines.push(...obligationLines(result, columns));
+    lines.push(...worktreeRetirementLines(result, columns));
+    lines.push(...gatesAwaitLines(result.value.placement));
     return lines.join("\n");
 }
 function renderAcceptedArc(result, columns) {
-    const lines = titleLines("✓", `entered chapter ${result.chapter.seq}`, result.contract, columns);
-    receiptRow(lines, " ", "chapter", [{ text: String(result.chapter.seq) }, { text: "·" }, { text: result.chapter.title }], columns);
+    const lines = titleLines("✓", `chapter ${arcChapter(result.facts).seq} opened · ${arcChapter(result.facts).title}`, result.contract, columns);
     lines.push(...recordBlock(result, columns));
     return lines.join("\n");
 }
 function renderAcceptedAbandon(result, columns) {
     const lines = titleLines("✓", "abandoned", result.contract, columns);
-    if (result.note !== undefined)
-        receiptRow(lines, " ", "note", [{ text: result.note }], columns);
+    const note = abandonedNote(result.facts);
+    if (note !== undefined)
+        receiptRow(lines, " ", "note", [{ text: note }], columns);
     lines.push(...recordBlock(result, columns));
+    lines.push(...worktreeRetirementLines(result, columns));
     return lines.join("\n");
 }
 export function renderAccepted(result, context) {
     const columns = context?.columns ?? DEFAULT_CLI_COLUMNS;
-    switch (result.verb) {
+    switch (result.operation) {
         case "audit":
             return renderAcceptedAudit(result, context);
         case "bind":
@@ -308,9 +459,7 @@ export function renderAccepted(result, context) {
 }
 export function renderRetry(result, context) {
     const columns = context?.columns ?? DEFAULT_CLI_COLUMNS;
-    const detail = isRecord(result.detail) && typeof result.detail.kind === "string"
-        ? retryLines(result.detail, HANG, columns)
-        : [];
-    return [...outcomeLines("?", result.verb, "retry", result.contract, columns), ...detail].join("\n");
+    const detail = retryLines(result.reason, HANG, columns);
+    return [...outcomeLines("?", result.operation, "retry", result.contract, columns), ...detail].join("\n");
 }
 export { renderContractHistory } from "./contract-history.js";

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

@@ -0,0 +1,26 @@
+import type { ContractId, ExecutionCleanup, ExecutionStop, InvocationEffect, ReconciliationLag, SettlementLag, SnapshotId } from "../../index.js";
+/** Presentation reads of the one native effect carrier; it never recomputes owner finality. */
+export declare function effectLags(effects: readonly InvocationEffect[]): readonly Readonly<{
+    contract: ContractId;
+    lag: ReconciliationLag;
+}>[];
+export declare function effectSettlementLags(effects: readonly InvocationEffect[]): readonly Readonly<{
+    contract: ContractId;
+    lag: SettlementLag;
+}>[];
+export declare function effectCleanup(effects: readonly InvocationEffect[]): readonly ExecutionCleanup[];
+export declare function effectExecutionStops(effects: readonly InvocationEffect[]): readonly ExecutionStop[];
+export declare function effectRetainedCheckouts(effects: readonly InvocationEffect[]): readonly Readonly<{
+    path: string;
+    target: string;
+    diagnostic: string;
+}>[];
+export declare function effectRetiredWorktrees(effects: readonly InvocationEffect[]): readonly Readonly<{
+    contract: ContractId;
+    name: string;
+}>[];
+export declare function effectRetainedWorktrees(effects: readonly InvocationEffect[]): readonly Readonly<{
+    contract: ContractId;
+    path: string;
+}>[];
+export declare function effectRecoverySnapshot(effects: readonly InvocationEffect[]): SnapshotId | undefined;

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

@@ -0,0 +1,41 @@
+/** Presentation reads of the one native effect carrier; it never recomputes owner finality. */
+export function effectLags(effects) {
+    return effects.flatMap((effect) => effect.kind === "reconciliation-lag" ? [{ contract: effect.contract, lag: effect.lag }] : []);
+}
+export function effectSettlementLags(effects) {
+    return effects.flatMap((effect) => effect.kind === "settlement-lag" ? [{ contract: effect.contract, lag: effect.lag }] : []);
+}
+export function effectCleanup(effects) {
+    return effects.flatMap((effect) => (effect.kind === "cleanup" ? [effect.issue] : []));
+}
+export function effectExecutionStops(effects) {
+    return effects.flatMap((effect) => effect.kind === "execution-stopped"
+        ? [
+            {
+                kind: "execution-stopped",
+                contractId: effect.contract,
+                stage: effect.stage,
+                reason: effect.reason,
+                diagnostic: effect.diagnostic,
+            },
+        ]
+        : []);
+}
+export function effectRetainedCheckouts(effects) {
+    return effects.flatMap((effect) => effect.kind === "checkout-retained"
+        ? [{ path: effect.path, target: effect.target, diagnostic: effect.diagnostic }]
+        : []);
+}
+export function effectRetiredWorktrees(effects) {
+    return effects.flatMap((effect) => effect.kind === "worktree-retired" ? [{ contract: effect.contract, name: effect.name }] : []);
+}
+export function effectRetainedWorktrees(effects) {
+    return effects.flatMap((effect) => effect.kind === "worktree-retained" ? [{ contract: effect.contract, path: effect.path }] : []);
+}
+export function effectRecoverySnapshot(effects) {
+    for (const effect of effects) {
+        if (effect.kind === "reconciliation-effect" && effect.effect.kind === "recovery-snapshot")
+            return effect.effect.snapshot;
+    }
+    return undefined;
+}