@astrosheep/keiyaku 4.6.2 → 4.6.3

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

@@ -13,9 +13,8 @@ export function frameRule(headLines) {
     const width = headLines.reduce((widest, line) => Math.max(widest, displayColumns(line)), 0);
     return "─".repeat(width);
 }
-/** Tool rows one focused activity view keeps at its opening and final end; the surplus folds in place. */
-const OPENING_TOOL_BUDGET = 3;
-const RECENT_TOOL_BUDGET = 2;
+/** Tool rows an activity view prints after each say or Tell checkpoint; the surplus folds in place. */
+const TOOL_BUDGET = 3;
 function identity(id, alias) {
     return `${id}${alias === undefined ? "" : ` (${alias})`}`;
 }
@@ -434,57 +433,6 @@ function inFlightSay(activity, row) {
     }
     return newest !== undefined && newest.sequence === row.sequence;
 }
-function coalesceDeferredGaps(state) {
-    state.deferred = state.deferred.reduce((entries, entry) => {
-        const previous = entries.at(-1);
-        if (entry.kind === "gap" && previous?.kind === "gap") {
-            entries[entries.length - 1] = { kind: "gap", count: previous.count + entry.count };
-        }
-        else {
-            entries.push(entry);
-        }
-        return entries;
-    }, []);
-}
-function omitOldestDeferredTool(state) {
-    const index = state.deferred.findIndex((entry) => entry.kind === "row" && isBoundedStreamTool(entry.row));
-    if (index === -1)
-        throw new Error("activity tail lost its pending tool");
-    state.deferred[index] = { kind: "gap", count: 1 };
-    coalesceDeferredGaps(state);
-}
-/** A say is a checkpoint: only tools after the last say may occupy the recent tail. */
-function omitPreSayTools(state) {
-    state.deferred = state.deferred.map((entry) => entry.kind === "row" && isBoundedStreamTool(entry.row) ? { kind: "gap", count: 1 } : entry);
-    coalesceDeferredGaps(state);
-}
-/** Emit only a prefix whose omission runs can no longer join an unresolved tail tool. */
-function flushSafeActivityPrefix(state, lines, context, layout) {
-    for (;;) {
-        const first = state.deferred[0];
-        if (first === undefined || (first.kind === "row" && isBoundedStreamTool(first.row)))
-            return;
-        if (first.kind === "row") {
-            state.deferred.shift();
-            renderStreamRow(state, first.row, lines, { context, layout, inFlightSay: first.inFlightSay });
-            continue;
-        }
-        const next = state.deferred[1];
-        if (next === undefined || (next.kind === "row" && isBoundedStreamTool(next.row)))
-            return;
-        state.deferred.shift();
-        lines.push(layout.marker(first.count));
-    }
-}
-function renderCurrentTurnBoundary(state, activity, lines, context, layout) {
-    const boundary = currentTurnBoundary(activity);
-    if (boundary !== undefined && !state.renderedBoundaries.has(boundary.turnSequence)) {
-        state.renderedBoundaries.add(boundary.turnSequence);
-        if (boundary.row.kind !== "thought")
-            renderStreamRow(state, boundary.row, lines, { context, layout });
-    }
-    return boundary;
-}
 function rememberLiveRows(state, activity) {
     for (const row of activity.rows) {
         if (row.kind === "tool" && row.state === "active")
@@ -503,8 +451,28 @@ function rememberLiveRows(state, activity) {
             state.liveRows.delete(row.sequence);
     }
 }
-function observeActivitySnapshot(state, activity, context, layout) {
-    const lines = [];
+/** A visible row first releases the untimed omission count accumulated before it. */
+function emitRow(state, emissions, emission) {
+    if (state.omitted > 0)
+        emissions.push({ kind: "gap", count: state.omitted });
+    state.omitted = 0;
+    emissions.push(emission);
+}
+function emitCurrentTurnBoundary(state, activity, emissions) {
+    const boundary = currentTurnBoundary(activity);
+    if (boundary !== undefined && !state.renderedBoundaries.has(boundary.turnSequence)) {
+        state.renderedBoundaries.add(boundary.turnSequence);
+        if (boundary.row.kind !== "thought")
+            emitRow(state, emissions, { kind: "row", row: boundary.row });
+    }
+}
+/**
+ * Decide each newly settled row once, when first observed: it prints now or
+ * becomes part of an untimed omission count. No timestamped row is held for a
+ * later observation, so concurrent streams merge without moving backward.
+ */
+function observeActivitySnapshot(state, activity) {
+    const emissions = [];
     const boundary = currentTurnBoundary(activity);
     rememberPendingTells(state, activity);
     // A row newly selected as this Turn's typed opening must still respect the
@@ -522,54 +490,48 @@ function observeActivitySnapshot(state, activity, context, layout) {
         row.sequence > state.newestSettledSequence);
     rememberLiveRows(state, activity);
     if (observedRows.length === 0)
-        return lines;
+        return emissions;
     for (const row of observedRows)
         state.pendingTellSequences.delete(row.sequence);
     state.newestSettledSequence = observedRows.reduce((newest, row) => Math.max(newest, row.sequence), state.newestSettledSequence ?? observedRows[0].sequence);
-    const rows = observedRows.filter((row) => row.kind !== "thought");
-    for (const row of rows) {
-        if (row.kind === "said") {
-            omitPreSayTools(state);
-            lines.push(...flushActivityTail(state, context, layout));
-            renderStreamRow(state, row, lines, { context, layout, inFlightSay: inFlightSay(activity, row) });
-            continue;
-        }
-        if (isBoundedStreamTool(row) && state.openingTools < OPENING_TOOL_BUDGET) {
-            state.openingTools += 1;
-            renderStreamRow(state, row, lines, { context, layout, inFlightSay: inFlightSay(activity, row) });
+    for (const row of observedRows) {
+        if (row.kind === "thought")
             continue;
+        // A failed tool is evidence, not routine progress, so it always prints and spends no budget.
+        const failed = row.kind === "tool" && typeof row.state === "object" && row.state.status === "error";
+        if (isBoundedStreamTool(row) && !failed) {
+            if (state.checkpointTools >= TOOL_BUDGET) {
+                state.omitted += 1;
+                continue;
+            }
+            state.checkpointTools += 1;
         }
-        if (!isBoundedStreamTool(row) && state.deferred.length === 0) {
-            renderStreamRow(state, row, lines, { context, layout, inFlightSay: inFlightSay(activity, row) });
-            continue;
-        }
-        state.deferred.push({ kind: "row", row, inFlightSay: inFlightSay(activity, row) });
-        if (isBoundedStreamTool(row)) {
-            const pendingTools = state.deferred.filter((entry) => entry.kind === "row" && isBoundedStreamTool(entry.row)).length;
-            if (pendingTools > RECENT_TOOL_BUDGET)
-                omitOldestDeferredTool(state);
-        }
-        flushSafeActivityPrefix(state, lines, context, layout);
+        else if (row.kind === "said" || row.kind === "tell")
+            state.checkpointTools = 0;
+        emitRow(state, emissions, { kind: "row", row, inFlightSay: inFlightSay(activity, row) });
     }
-    return lines;
+    return emissions;
 }
-function flushActivityTail(state, context, layout) {
+function renderEmissions(state, emissions, context, layout) {
     const lines = [];
-    for (const entry of state.deferred) {
-        if (entry.kind === "gap")
-            lines.push(layout.marker(entry.count));
+    for (const emission of emissions) {
+        if (emission.kind === "gap")
+            lines.push(layout.marker(emission.count));
         else
-            renderStreamRow(state, entry.row, lines, { context, layout, inFlightSay: entry.inFlightSay });
+            renderStreamRow(state, emission.row, lines, {
+                context,
+                layout,
+                ...(emission.inFlightSay === undefined ? {} : { inFlightSay: emission.inFlightSay }),
+                ...(emission.unsettled === undefined ? {} : { unsettled: emission.unsettled }),
+            });
     }
-    state.deferred = [];
     return lines;
 }
 /**
- * Append-only live view over one command's successive settled snapshots. The
- * first three tools stream immediately; later tools wait in a two-row tail.
- * A say omits the earlier tail, so only the last two extra tools after the
- * final say can print at closing. Newer tools displace older tail candidates
- * in place. Other narrative rows wait behind undecided tail tools.
+ * Append-only live view over one command's successive settled snapshots.
+ * After each say or Tell, the first three tools print as they settle; later
+ * tools until the next checkpoint fold into one omission marker. Failed tools
+ * always print.
  */
 export function activityStream(context, layout = plainLayout()) {
     const state = {
@@ -579,12 +541,12 @@ export function activityStream(context, layout = plainLayout()) {
         previousClock: undefined,
         renderedBoundaries: new Set(),
         admittedTellSequences: new Set(),
-        openingTools: 0,
-        deferred: [],
+        checkpointTools: 0,
+        omitted: 0,
         liveRows: new Map(),
     };
     const seed = (activity, alreadyRenderedSequence) => {
-        const lines = [];
+        const emissions = [];
         if (alreadyRenderedSequence !== undefined) {
             state.admissionSequence = alreadyRenderedSequence;
             state.admittedTellSequences.add(alreadyRenderedSequence);
@@ -595,46 +557,54 @@ export function activityStream(context, layout = plainLayout()) {
             if (alreadyRenderedSequence !== undefined && boundary.row.sequence > alreadyRenderedSequence) {
                 const beforeBoundary = baselineOmissionCount(activity, alreadyRenderedSequence, boundary.row.sequence);
                 if (beforeBoundary > 0)
-                    lines.push(layout.marker(beforeBoundary));
+                    emissions.push({ kind: "gap", count: beforeBoundary });
             }
             if (alreadyRenderedSequence !== undefined && boundary.row.sequence <= alreadyRenderedSequence)
                 state.renderedBoundaries.add(boundary.turnSequence);
             else
-                renderCurrentTurnBoundary(state, activity, lines, context, layout);
+                emitCurrentTurnBoundary(state, activity, emissions);
             rememberLiveRows(state, activity);
             const omitted = baselineOmissionCount(activity, alreadyRenderedSequence === undefined
                 ? boundary.row.sequence
                 : Math.max(boundary.row.sequence, alreadyRenderedSequence));
             if (omitted > 0)
-                lines.push(layout.marker(omitted));
+                emissions.push({ kind: "gap", count: omitted });
         }
         rememberPendingTells(state, activity);
         rememberLiveRows(state, activity);
         const rows = settledRows(activity);
         if (rows.length > 0)
             state.newestSettledSequence = rows.reduce((newest, row) => Math.max(newest, row.sequence), rows[0].sequence);
-        return lines;
+        return emissions;
     };
-    const observe = (activity) => observeActivitySnapshot(state, activity, context, layout);
-    const frame = () => groupedEntries([...state.liveRows.values()]
-        .sort((left, right) => left.sequence - right.sequence)
-        .map((row) => ({ kind: "row", row })), context, layout, { live: true, inFlightSay: (row) => row.kind === "said" });
     const flush = () => {
-        if ([...state.liveRows.values()].some((row) => row.kind === "said"))
-            omitPreSayTools(state);
-        const lines = [...flushActivityTail(state, context, layout)];
+        const emissions = [];
+        if (state.omitted > 0)
+            emissions.push({ kind: "gap", count: state.omitted });
+        state.omitted = 0;
         for (const row of [...state.liveRows.values()].sort((left, right) => left.sequence - right.sequence)) {
             const unresolved = row.kind === "tool" && row.state === "active" ? { ...row, state: "unsettled" } : row;
-            renderStreamRow(state, unresolved, lines, {
-                context,
-                layout,
-                unsettled: true,
-            });
+            emissions.push({ kind: "row", row: unresolved, unsettled: true });
         }
         state.liveRows.clear();
-        return lines;
+        return emissions;
     };
-    return Object.assign(observe, { seed, frame, flush });
+    const render = (emissions) => renderEmissions(state, emissions, context, layout);
+    const frame = () => groupedEntries([...state.liveRows.values()]
+        .sort((left, right) => left.sequence - right.sequence)
+        .map((row) => ({ kind: "row", row })), context, layout, { live: true, inFlightSay: (row) => row.kind === "said" });
+    const observe = (activity) => render(observeActivitySnapshot(state, activity));
+    return Object.assign(observe, {
+        seed: (activity, alreadyRenderedSequence) => render(seed(activity, alreadyRenderedSequence)),
+        frame,
+        flush: () => render(flush()),
+        emissions: {
+            observe: (activity) => observeActivitySnapshot(state, activity),
+            seed,
+            flush,
+        },
+        render,
+    });
 }
 function conclusionMarkVerb(status, outcome) {
     if (outcome === "failed" || (status !== undefined && failedOutcomeDiagnostic(status) !== undefined))
@@ -773,10 +743,11 @@ function observeWaitRound(state, round, context, now) {
             lines.push(...snapshotHeading(sole.status.id, sole.alias, sole.contract));
         }
     }
+    const parts = [];
     for (const { status, rows } of round) {
         const known = state.streams.get(status.id);
         if (known !== undefined) {
-            lines.push(...known({ snapshot: status.timeline, rows }));
+            parts.push({ stream: known, emissions: known.emissions.observe({ snapshot: status.timeline, rows }) });
         }
         else {
             // Only a plural wait attributes its rows; a single-target stream keeps the plain row grammar.
@@ -785,13 +756,51 @@ function observeWaitRound(state, round, context, now) {
                 : plainLayout());
             state.streams.set(status.id, stream);
             // Seed marks skipped retained evidence without spending this command's live tool budget.
-            lines.push(...stream.seed({ snapshot: status.timeline, rows }));
+            parts.push({ stream, emissions: stream.emissions.seed({ snapshot: status.timeline, rows }) });
         }
         if (!state.settledAt.has(status.id) && defaultWaitComplete(status))
             state.settledAt.set(status.id, settleMoment(status) ?? now());
     }
+    lines.push(...mergeStreamEmissions(parts));
     return lines;
 }
+/**
+ * Merge one observation's decided output across sources by row time. Each
+ * source keeps its own order; an omission count travels with the row after it,
+ * or with the row before it when it trails. Ties keep selection order.
+ */
+function mergeStreamEmissions(parts) {
+    const queues = parts.map(({ stream, emissions }) => {
+        const units = [];
+        let pending = [];
+        for (const emission of emissions) {
+            pending.push(emission);
+            if (emission.kind !== "row")
+                continue;
+            const at = Date.parse(emission.row.at);
+            units.push({ at: Number.isFinite(at) ? at : (units.at(-1)?.at ?? Number.NEGATIVE_INFINITY), emissions: pending });
+            pending = [];
+        }
+        if (pending.length > 0) {
+            const last = units.at(-1);
+            if (last === undefined)
+                units.push({ at: Number.NEGATIVE_INFINITY, emissions: pending });
+            else
+                last.emissions.push(...pending);
+        }
+        return { stream, units };
+    });
+    const lines = [];
+    for (;;) {
+        let next;
+        for (const queue of queues)
+            if (queue.units.length > 0 && (next === undefined || queue.units[0].at < next.units[0].at))
+                next = queue;
+        if (next === undefined)
+            return lines;
+        lines.push(...next.stream.render(next.units.shift().emissions));
+    }
+}
 /**
  * A conclusion clause asserts real waiting: a target that settled at or after
  * this wait began keeps its duration, a target already settled names no
@@ -851,10 +860,11 @@ function orderedWaitIds(state, result) {
     }
     return ids;
 }
+function flushWaitStreams(state) {
+    return mergeStreamEmissions([...state.streams.values()].map((stream) => ({ stream, emissions: stream.emissions.flush() })));
+}
 function concludeWaitStream(state, result, startedAt, now) {
-    const tail = [];
-    for (const stream of state.streams.values())
-        tail.push(...stream.flush());
+    const tail = flushWaitStreams(state);
     const end = now();
     for (const observation of result.observations)
         registerWaitSource(state, observation.status.id, undefined, observation.contract);
@@ -913,7 +923,7 @@ export function waitObservationStream(context, options = {}) {
     };
     const observe = (round) => observeWaitRound(state, round, context, now);
     const frame = () => [...state.streams.values()].flatMap((stream) => stream.frame());
-    const flush = () => [...state.streams.values()].flatMap((stream) => stream.flush());
+    const flush = () => flushWaitStreams(state);
     const conclude = (result) => concludeWaitStream(state, result, startedAt, now);
     return { select, observe, frame, flush, conclude, streamed: () => state.observed };
 }

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

@@ -98,7 +98,7 @@ function readText(call) {
         : call.offset !== undefined
             ? ` · from L${call.offset}`
             : call.limit !== undefined
-                ? ` · ${call.limit} lines`
+                ? ` · ${call.limit} ${call.limit === 1 ? "line" : "lines"}`
                 : "";
     return { label: "read", text: `${path}${detail}`, pathPreview: { before: "", path, detail } };
 }

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

@@ -1,5 +1,5 @@
 import { effectCleanup, effectExecutionStops } from "./effects.js";
-import { executionCleanupLines, executionStopLines, receiptPayload, receiptRow, reuseLines, stopLines, titleLines, } from "./receipt.js";
+import { executionCleanupLines, executionStopLines, receiptPayload, receiptRow, stopLines, titleLines, } from "./receipt.js";
 import { renderRefusalFacts } from "./refusal.js";
 import { abbreviateGitIds, displayGitId } from "./contract-observation.js";
 import { DEFAULT_CLI_COLUMNS, gitShortStat, renderTextBlock, safeText } from "./terminal.js";
@@ -16,11 +16,10 @@ function candidateLines(report, columns, addressed, abbreviations) {
         return lines;
     }
     const identity = candidate.identity;
-    receiptRow(lines, " ", "candidate", [{ text: "ready" }], columns);
-    lines.push(`${CHILD}candidate  ${displayGitId(identity.tenderSnapshot, abbreviations)}`);
+    receiptRow(lines, " ", "candidate", [{ text: "ready" }, { 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 (not commit)  ${displayGitId(identity.integration.changeId, abbreviations)}`);
+        lines.push(`${CHILD}content identity  ${displayGitId(identity.integration.changeId, abbreviations)}`);
     lines.push(...workspaceEvidence(candidate.workspace));
     lines.push(...renderTextBlock(gitShortStat(candidate.scope), CHILD, columns));
     if (candidate.scope.paths !== undefined) {
@@ -47,7 +46,6 @@ function verificationLines(verification, columns, addressed) {
     }
     if (verification.kind === "reused") {
         receiptRow(lines, " ", "verification", [{ text: "reused" }, { text: verification.verdict }], columns);
-        lines.push(...reuseLines(verification, columns));
         if (verification.summary !== undefined)
             receiptPayload(lines, "summary", auditSummary(verification.summary));
         return lines;
@@ -77,7 +75,7 @@ function targetLines(report, columns, addressed, abbreviations) {
     const target = report.target;
     const lines = [];
     if (target.kind === "not-observed") {
-        receiptRow(lines, " ", "target", [{ text: "not-observed" }], columns);
+        receiptRow(lines, " ", "target", [{ text: "none" }], columns);
         return lines;
     }
     if (target.kind === "placeable") {

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

@@ -81,10 +81,13 @@ export function renderArchetypeCatalogue(list) {
             ? []
             : [
                 "",
-                ...list.rows.flatMap((row) => [
-                    `${safeText(row.name)}${row.model === undefined ? "" : `  ${safeText(row.model)}`}`,
-                    ...(row.description === undefined ? [] : [`  ${safeText(row.description)}`]),
-                ]),
+                ...list.rows.flatMap((row) => {
+                    const facts = [
+                        ...(row.model === undefined ? [] : [safeText(row.model)]),
+                        ...(row.description === undefined ? [] : [safeText(row.description)]),
+                    ];
+                    return [safeText(row.name), ...(facts.length === 0 ? [] : [`  ${facts.join(" — ")}`])];
+                }),
                 ...(list.hasMore ? ["…"] : []),
             ]),
     ].join("\n");

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

@@ -47,15 +47,13 @@ function journalBody(fact, workspace) {
         }
         case "amend":
             return [...listFact("gates", fact.data.gates), ...listFact("after", fact.data.after)];
-        case "bound":
-            return [];
         case "deliver": {
             const { tenderSnapshot, integration, method, policy } = fact.data;
             return [
                 `  candidate  ${shortGitId(tenderSnapshot)}`,
                 `  predecessor commit  ${shortGitId(integration.predecessor)}`,
                 `  integration result  ${shortGitId(integration.snapshot)}`,
-                `  content identity (not commit)  ${integration.changeId}`,
+                `  content identity  ${integration.changeId}`,
                 `  method  ${method}`,
                 `  require branches up to date  ${String(policy.requireBranchesToBeUpToDate)}`,
             ];
@@ -160,6 +158,7 @@ function latestVerification(beat) {
     }
     return latest;
 }
+const lineCount = (count) => `${count} line${count === 1 ? "" : "s"}`;
 function skeletonBeatLines(beat, history) {
     const first = beat.events[0];
     if (first === undefined)
@@ -167,9 +166,9 @@ function skeletonBeatLines(beat, history) {
     const full = beat.events.flatMap((event) => fullEventLines(event, history.workspace));
     const evidenceSuffix = () => {
         const count = foldedPayloadLines(full);
-        return count > 0 ? ` · ${count} lines` : "";
+        return count > 0 ? ` · ${lineCount(count)}` : "";
     };
-    const payloadSuffix = (rendered) => rendered.length > 0 ? ` · ${rendered.length} lines` : "";
+    const payloadSuffix = (rendered) => rendered.length > 0 ? ` · ${lineCount(rendered.length)}` : "";
     if (first.source === "dispatch")
         return [`${clock(first)} dispatch · ${first.dispatch.akuId}`];
     const fact = first.fact;
@@ -178,8 +177,6 @@ function skeletonBeatLines(beat, history) {
             const dispatch = beat.events.find((event) => event.source === "dispatch");
             return [`${clock(first)} ${bindLine(fact, dispatch)}`];
         }
-        case "bound":
-            return [`${clock(first)} bound`];
         case "deliver": {
             const verdict = latestVerification(beat)?.data.verdict;
             return [
@@ -213,7 +210,7 @@ function skeletonBeatLines(beat, history) {
             ];
         default: {
             const folded = foldedPayloadLines(full);
-            return [`${clock(first)} ${eventKind(first)}${folded > 0 ? ` · ${folded} lines` : ""}`];
+            return [`${clock(first)} ${eventKind(first)}${folded > 0 ? ` · ${lineCount(folded)}` : ""}`];
         }
     }
 }
@@ -227,8 +224,6 @@ function skeletonState(history) {
         return lifecycleWord("claimed");
     if (journal.some((event) => event.fact.kind === "abandoned"))
         return "abandoned";
-    if (journal.some((event) => event.fact.kind === "deliver" || event.fact.kind === "reintegrated"))
-        return "delivered";
     return "bound";
 }
 function skeletonBeats(history) {
@@ -244,15 +239,10 @@ function skeletonBeats(history) {
         if (event.source === "journal" && event.fact.kind === "bind") {
             for (let next = index + 1; next < events.length; next += 1) {
                 const candidate = events[next];
-                if (candidate.source === "journal" && candidate.fact.kind === "bound") {
-                    grouped.push(candidate);
-                    consumed.add(next);
+                if (candidate.source !== "dispatch")
                     break;
-                }
-                if (candidate.source === "dispatch") {
-                    grouped.push(candidate);
-                    consumed.add(next);
-                }
+                grouped.push(candidate);
+                consumed.add(next);
             }
         }
         if (event.source === "journal" && (event.fact.kind === "deliver" || event.fact.kind === "reintegrated")) {

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

@@ -1,6 +1,6 @@
 import { effectCleanup, effectExecutionStops, effectLags, effectRecoverySnapshot, effectRetainedCheckouts, effectRetainedWorktrees, effectRetiredWorktrees, effectSettlementLags, } from "./effects.js";
 import { renderAcceptedAudit } from "./audit.js";
-import { appendHookPayload, executionCleanupLines, executionStopLines, gatesAwaitLines, hookFailureSummary, outcomeLines, receiptPayload, receiptRow, reuseLines, stopLines, titleLines, } from "./receipt.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";
 import { DEFAULT_CLI_COLUMNS, renderOpaqueBlock, safeText, tone } from "./terminal.js";
@@ -163,9 +163,6 @@ function acceptedRecord(result, 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) {
@@ -367,14 +364,14 @@ function renderAcceptedAmend(result, columns, color) {
     lines.push(...acceptedDeviations(result, columns, color), ...recordBlock(result, columns));
     return lines.join("\n");
 }
-function deliverIdentityLines(result, abbreviations, columns) {
+function deliverIdentityLines(result, abbreviations, columns, kept) {
     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);
+        receiptRow(lines, " ", "candidate", [{ text: `${displayGitId(result.value.tenderSnapshot, abbreviations)}${kept ? " · kept" : ""}`, 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);
+        receiptRow(lines, " ", "content identity", [{ text: displayGitId(result.value.integration.changeId, abbreviations), opaque: true }], columns);
     return lines;
 }
 function renderAcceptedDeliver(result, columns) {
@@ -387,7 +384,7 @@ function renderAcceptedDeliver(result, columns) {
         result.value.completion?.predecessor ?? "",
         result.value.completion?.integration ?? "",
     ]);
-    lines.push(...deliverIdentityLines(result, abbreviations, columns));
+    lines.push(...deliverIdentityLines(result, abbreviations, columns, !complete));
     if (complete)
         lines.push(...completedPlacementLines(result, columns));
     else {
@@ -404,8 +401,6 @@ function renderAcceptedDeliver(result, columns) {
         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), ...(complete ? obligationLines(result, columns) : recordBlock(result, columns)), ...worktreeRetirementLines(result, columns), ...gatesAwaitLines(result.value.placement));
     return lines.join("\n");
 }

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

@@ -41,7 +41,7 @@ function endpointFact(id, observed) {
 function renderAkuma(report, context) {
     const section = report.akuma;
     if (section.kind === "absent")
-        return ["AKUMA // absent", "", "  akuma absent"];
+        return ["AKUMA // absent"];
     if (section.kind === "failed")
         return ["AKUMA // unavailable", "", tone(`! ${safeText(section.failure.message)}`, "alert", context.color)];
     const rows = section.value.rows;