@astrosheep/keiyaku 4.5.19 → 4.5.21

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

@@ -1,6 +1,6 @@
 import { renderAcceptedAudit } from "./audit.js";
 import { appendHookPayload, executionCleanupLines, executionStopLines, hookFailureSummary, outcomeLines, receiptPayload, receiptRow, reuseLines, stopLines, titleLines, } from "./receipt.js";
-import { gitShortStat, renderOpaqueBlock } from "./terminal.js";
+import { renderOpaqueBlock, safeText, tone } from "./terminal.js";
 const HANG = "  ";
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -14,23 +14,19 @@ function retryLines(detail, indent, columns) {
 function lagRows(lag, columns) {
     const lines = [];
     if (lag.kind === "worktree-retained") {
-        receiptRow(lines, "!", "lag", [{ text: `worktree-retained ${lag.path}`, opaque: true }], columns);
+        receiptRow(lines, "!", "lag", [{ text: "worktree retained" }, { text: lag.path, opaque: true }], columns);
     }
     else if (lag.kind === "worktree-follow-retained") {
         receiptRow(lines, "!", "lag", [
-            {
-                text: `${lag.kind} reason ${lag.reason} tender ${lag.tender} head ${lag.head}${lag.paths === undefined || lag.paths.length === 0 ? "" : ` paths ${lag.paths.join(",")}`} path ${lag.path}`,
-                opaque: true,
-            },
+            { text: "worktree follow retained" },
+            { text: "·" },
+            { text: lag.reason.replaceAll("-", " ") },
+            { text: "·" },
+            { text: lag.path, opaque: true },
         ], columns);
     }
     else if (lag.kind === "unsealed-bytes") {
-        receiptRow(lines, "!", "lag", [
-            {
-                text: `unsealed-bytes ${lag.path}${lag.head === undefined ? "" : ` head ${lag.head}`}${lag.paths.length === 0 ? "" : ` paths ${lag.paths.join(",")}`}`,
-                opaque: true,
-            },
-        ], 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);
@@ -57,39 +53,43 @@ function lagRows(lag, columns) {
 }
 function settlementLagRows(lag, columns) {
     const lines = [];
-    receiptRow(lines, "!", "settlement", [
-        {
-            text: [
-                `surface ${lag.surface}`,
-                lag.taskId === undefined ? undefined : `task ${lag.taskId}`,
-                lag.path === undefined ? undefined : `path ${lag.path}`,
-            ]
-                .filter((part) => part !== undefined)
-                .join(" "),
-            opaque: true,
-        },
-    ], columns);
+    receiptRow(lines, "!", "settlement", [{ text: lag.surface.replaceAll("-", " ") }], columns);
+    if (lag.taskId !== undefined)
+        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);
     return lines;
 }
-function workspaceRows(workspace, columns) {
-    const lines = [];
-    receiptRow(lines, " ", "workspace", [{ text: gitShortStat(workspace.shortStat) }], columns);
-    for (const name of ["staged", "unstaged", "untracked"]) {
-        for (const path of workspace[name]) {
-            receiptRow(lines, " ", name, [{ text: path, opaque: true }], columns);
+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);
     }
-    return lines;
-}
-function overlapRows(overlaps, columns) {
-    const lines = [];
-    for (const overlap of overlaps) {
-        for (const pattern of overlap.patterns) {
-            receiptRow(lines, " ", "overlap", [
-                { text: overlap.contract, opaque: true },
-                { text: `${pattern.mine} ~ ${pattern.theirs}`, opaque: true },
-            ], columns);
+    if (groups.size === 0)
+        return [];
+    const lines = ["", `  ${tone("overlap", "dim", color)}`];
+    for (const [contract, patterns] of groups) {
+        if (lines.length > 2)
+            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;
         }
     }
     return lines;
@@ -101,19 +101,6 @@ function pushBlock(lines, block) {
 }
 function acceptedRecord(result, columns) {
     const record = [];
-    for (const fact of result.facts) {
-        const contract = fact.contract === result.contract ? [] : [{ text: fact.contract, opaque: true }];
-        receiptRow(record, " ", "journal", fact.kind === "reintegrated"
-            ? [
-                ...contract,
-                { text: fact.entry, opaque: true },
-                { text: "· reintegrated" },
-                { text: fact.data.predecessor, opaque: true },
-                { text: "->" },
-                { text: fact.data.snapshot, opaque: true },
-            ]
-            : [...contract, { text: fact.entry, opaque: true }, { text: `· ${fact.kind}` }], columns);
-    }
     if (result.recoverySnapshot !== undefined)
         receiptRow(record, " ", "recovery snapshot", [{ text: result.recoverySnapshot, opaque: true }], columns);
     if (result.verb === "deliver") {
@@ -134,25 +121,10 @@ function acceptedLagRows(result, columns) {
     pushBlock(obligations, executionStopLines(result.executionStops ?? [], columns));
     return obligations;
 }
-function indentRecord(lines) {
-    let payload = false;
-    return lines.map((line) => {
-        if (line.length === 0) {
-            payload = !payload;
-            return line;
-        }
-        return payload ? line : `  ${line}`;
-    });
-}
-function acceptedDeviations(result, columns) {
+function acceptedDeviations(result, columns, color) {
     const deviations = [];
-    if (result.verb === "review") {
-        if (result.workspace !== undefined)
-            pushBlock(deviations, workspaceRows(result.workspace, columns));
-        return deviations;
-    }
     if (result.overlaps !== undefined)
-        pushBlock(deviations, overlapRows(result.overlaps, columns));
+        pushBlock(deviations, overlapRows(result.overlaps, color));
     if (result.overlapFailure !== undefined) {
         receiptRow(deviations, "!", "overlap", [{ text: "unavailable" }], columns);
         receiptPayload(deviations, "diagnostic", result.overlapFailure);
@@ -161,29 +133,57 @@ function acceptedDeviations(result, columns) {
 }
 function recordBlock(result, columns) {
     const rows = [...acceptedRecord(result, columns), ...acceptedLagRows(result, columns)];
-    return ["  record", ...indentRecord(rows)];
+    return rows;
 }
-function completionLines(result, columns) {
+function nonGatingVerificationLines(result, columns) {
     const lines = [];
+    const verification = result.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);
+    }
+    return lines;
+}
+function shortGitId(value) {
+    return /^[0-9a-f]{40}$/iu.test(value) ? value.slice(0, 7) : value;
+}
+/**
+ * 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 commit the verdict ran against; placement made that
+ * commit the reference's new head, so the two 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.
+ */
+function completedPlacementLines(result, columns) {
     const completion = result.completion;
     if (completion === undefined)
-        return lines;
-    const verification = completion.verification;
-    receiptRow(lines, " ", "target", [
-        { text: "->" },
-        { text: completion.integration, opaque: true },
-        ...(verification !== undefined && "verdict" in verification && verification.verdict === "satisfied"
-            ? [{ text: `· verified (${verification.mode})` }]
-            : []),
-    ], columns);
-    if (verification !== undefined && "verdict" in verification && verification.verdict === "unsatisfied") {
-        receiptRow(lines, "!", "verification", [{ text: "unsatisfied" }, { text: `(${verification.mode})` }, { text: "· not required by Contract gates" }], columns);
-        if (result.verificationSummary !== undefined) {
-            receiptPayload(lines, "  summary", result.verificationSummary);
-        }
+        return [];
+    const lines = [];
+    if (completion.predecessor !== undefined && completion.target !== undefined) {
+        receiptRow(lines, " ", "target", [
+            { text: `${shortGitId(completion.predecessor)}..${shortGitId(completion.integration)}` },
+            { text: completion.target, opaque: true },
+        ], columns);
     }
+    if (completion.verification?.verdict === "satisfied") {
+        receiptRow(lines, " ", "verification", [{ text: "satisfied" }, { text: `· on ${shortGitId(completion.integration)}` }], 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);
     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);
+    rows.push(...acceptedLagRows(result, columns));
+    return rows;
+}
 function movementLines(result, columns) {
     const count = result.facts.filter((fact) => fact.kind === "reintegrated").length;
     if (count === 0)
@@ -213,7 +213,7 @@ function continuationLines(result, columns) {
     }
     return lines;
 }
-function renderAcceptedBind(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);
@@ -221,27 +221,34 @@ function renderAcceptedBind(result, columns) {
         receiptRow(lines, " ", "no target", [], columns);
     else
         receiptRow(lines, " ", "target", [{ text: result.target, opaque: true }], columns);
-    lines.push(...acceptedDeviations(result, columns), ...recordBlock(result, columns));
+    for (const warning of result.warnings ?? [])
+        receiptRow(lines, "!", "region warning", [{ text: warning }], columns);
+    lines.push(...acceptedDeviations(result, columns, color), ...recordBlock(result, columns));
     return lines.join("\n");
 }
-function renderAcceptedAmend(result, columns) {
-    const lines = titleLines("✓", "terms replaced", result.contract, columns);
-    receiptPayload(lines, "  terms diff", result.diff);
-    lines.push(...acceptedDeviations(result, columns), ...recordBlock(result, columns));
+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);
+    lines.push(...acceptedDeviations(result, columns, color), ...recordBlock(result, columns));
     return lines.join("\n");
 }
 function renderAcceptedDeliver(result, columns) {
     const complete = result.completion !== undefined;
-    const title = complete ? "delivered" : "deliver — not complete";
+    const title = complete ? "delivered" : "deliver incomplete";
     const lines = titleLines("✓", title, result.contract, columns);
     if (result.leading !== undefined) {
-        receiptRow(lines, " ", "leading", [{ text: result.leading.kind }, { text: result.leading.fact, opaque: true }], columns);
+        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);
-    lines.push(...movementLines(result, columns), ...completionLines(result, columns));
+    if (complete)
+        lines.push(...completedPlacementLines(result, columns));
+    else
+        lines.push(...movementLines(result, columns));
     if (result.verification !== undefined) {
         lines.push(...stopLines(result.verification, columns, result.contract));
     }
@@ -251,16 +258,12 @@ function renderAcceptedDeliver(result, columns) {
     if (!complete)
         receiptRow(lines, " ", "candidate", [{ text: "kept" }], columns);
     lines.push(...continuationLines(result, columns));
-    lines.push(...recordBlock(result, columns));
+    lines.push(...(complete ? obligationLines(result, columns) : recordBlock(result, columns)));
     return lines.join("\n");
 }
 function renderAcceptedReview(result, columns) {
-    const lines = titleLines("✓", `review ${result.verdict} recorded`, result.contract, columns);
-    lines.push(...movementLines(result, columns), ...completionLines(result, columns));
-    if (result.completion !== undefined) {
-        receiptRow(lines, " ", "placement", [{ text: "complete" }], columns);
-        receiptRow(lines, " ", "integration commit", [{ text: result.completion.integration, opaque: true }], columns);
-    }
+    const lines = titleLines("✓", `review ${result.verdict}`, result.contract, columns);
+    lines.push(...completedPlacementLines(result, columns));
     if (result.verification !== undefined) {
         lines.push(...stopLines(result.verification, columns, result.contract));
     }
@@ -268,11 +271,11 @@ function renderAcceptedReview(result, columns) {
         lines.push(...stopLines(result.placement, columns, result.contract));
     }
     lines.push(...continuationLines(result, columns));
-    lines.push(...acceptedDeviations(result, columns), ...recordBlock(result, columns));
+    lines.push(...obligationLines(result, columns));
     return lines.join("\n");
 }
 function renderAcceptedArc(result, columns) {
-    const lines = titleLines("✓", "chapter recorded", result.contract, 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);
     lines.push(...recordBlock(result, columns));
     return lines.join("\n");
@@ -290,9 +293,9 @@ export function renderAccepted(result, context) {
         case "audit":
             return renderAcceptedAudit(result, context);
         case "bind":
-            return renderAcceptedBind(result, columns);
+            return renderAcceptedBind(result, columns, context?.color === true);
         case "amend":
-            return renderAcceptedAmend(result, columns);
+            return renderAcceptedAmend(result, columns, context?.color === true);
         case "review":
             return renderAcceptedReview(result, columns);
         case "arc":

package/build/src/cli/render/execution-progress.d.ts

@@ -0,0 +1,26 @@
+import type { ExecutionEvent } from "../../library/execution.js";
+import { type TextRenderContext } from "./terminal.js";
+import { type StatusLineOptions, type StatusLineStream } from "./status-line.js";
+/** Sparse rendering for consumers that do not own a live stream. */
+export declare function executionProgressLines(event: ExecutionEvent, context: TextRenderContext): readonly string[];
+export type ExecutionProgressOptions = StatusLineOptions & Readonly<{
+    stream: StatusLineStream;
+    context: TextRenderContext;
+}>;
+/** Consumes witnessed events into either a live TTY line or sparse text. */
+export declare class ExecutionProgressRenderer {
+    private readonly input;
+    private readonly status;
+    private verificationStartedAt;
+    private declarations;
+    private declarationFailed;
+    private phaseFailed;
+    private phaseUnknown;
+    constructor(input: ExecutionProgressOptions);
+    consume(event: ExecutionEvent): Promise<void>;
+    finish(): void;
+    private consumeVerification;
+    private write;
+    private finalMark;
+}
+export declare function renderExecutionProgress(events: AsyncIterable<ExecutionEvent>, input: ExecutionProgressOptions): Promise<void>;

package/build/src/cli/render/execution-progress.js

@@ -0,0 +1,178 @@
+import { renderOpaqueBlock, safeText } from "./terminal.js";
+import { StatusLine } from "./status-line.js";
+const LIVE_OUTPUT_BYTES = 4 * 1024;
+function boundedUtf8Prefix(value) {
+    let bytes = 0;
+    let text = "";
+    for (const character of value) {
+        const size = Buffer.byteLength(character);
+        if (bytes + size > LIVE_OUTPUT_BYTES)
+            return { text, truncated: true };
+        bytes += size;
+        text += character;
+    }
+    return { text, truncated: false };
+}
+function elapsed(ms) {
+    const seconds = Math.max(0, Math.floor(ms / 1_000));
+    return seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m${seconds % 60}s`;
+}
+function phaseDetail(observation) {
+    if (observation.phase === "declaration")
+        return `declaration ${observation.index ?? "?"}/${observation.total ?? "?"}`;
+    return observation.name === undefined ? observation.phase : `${observation.phase} · ${safeText(observation.name)}`;
+}
+function phaseStartLine(observation) {
+    return `● ${[phaseDetail(observation), ...(observation.cwd === undefined ? [] : [safeText(observation.cwd)])].join(" · ")}`;
+}
+function phaseMark(outcome) {
+    if (outcome === undefined)
+        return "?";
+    return outcome === "ok" || outcome === "exit 0" ? "✓" : "×";
+}
+function phaseFinishLine(observation) {
+    const facts = [
+        phaseDetail(observation),
+        ...(observation.elapsedMs === undefined ? [] : [elapsed(observation.elapsedMs)]),
+    ];
+    if (observation.outcome !== undefined && observation.outcome !== "ok" && observation.outcome !== "exit 0")
+        facts.push(safeText(observation.outcome));
+    return `${phaseMark(observation.outcome)} ${facts.join(" · ")}`;
+}
+function outputLines(observation, context) {
+    const output = boundedUtf8Prefix(observation.text);
+    return [
+        observation.stream,
+        ...renderOpaqueBlock(output.text, "  ", context.columns),
+        ...(output.truncated ? ["  [live output truncated]"] : []),
+    ];
+}
+/** Sparse rendering for consumers that do not own a live stream. */
+export function executionProgressLines(event, context) {
+    switch (event.kind) {
+        case "admitted":
+            return [`✓ admitted ${event.fact.kind} · ${event.contractId}`];
+        case "verification":
+            return event.observation.kind === "output"
+                ? outputLines(event.observation, context)
+                : [
+                    event.observation.state === "started"
+                        ? phaseStartLine(event.observation)
+                        : phaseFinishLine(event.observation),
+                ];
+        case "stage":
+            return [`${event.state === "started" ? "●" : "✓"} ${event.stage}`];
+        case "progress-dropped":
+            return [`progress dropped ${event.count} event${event.count === 1 ? "" : "s"}`];
+    }
+}
+/** Consumes witnessed events into either a live TTY line or sparse text. */
+export class ExecutionProgressRenderer {
+    input;
+    status;
+    verificationStartedAt;
+    declarations;
+    declarationFailed = false;
+    phaseFailed = false;
+    phaseUnknown = false;
+    constructor(input) {
+        this.input = input;
+        this.status = new StatusLine(input.stream, input);
+    }
+    async consume(event) {
+        if (event.kind === "verification") {
+            await this.consumeVerification(event);
+            return;
+        }
+        await this.write(executionProgressLines(event, this.input.context));
+    }
+    finish() {
+        if (!this.status.isTTY || this.verificationStartedAt === undefined)
+            return;
+        const now = this.input.now ?? (() => performance.now());
+        const duration = elapsed(now() - this.verificationStartedAt);
+        if (this.declarations !== undefined) {
+            const { passed, total } = this.declarations;
+            this.status.finish(`verify  ${this.finalMark()} ${passed}/${total} · ${duration}`);
+            return;
+        }
+        this.status.finish(`verify  ${this.finalMark()} · ${duration}`);
+    }
+    async consumeVerification(event) {
+        const observation = event.observation;
+        if (observation.kind === "output") {
+            await this.write(outputLines(observation, this.input.context));
+            return;
+        }
+        if (observation.state === "started") {
+            this.verificationStartedAt ??= (this.input.now ?? (() => performance.now()))();
+            if (this.status.isTTY)
+                this.status.show((duration) => `verify  ● ${phaseDetail(observation)} · ${elapsed(duration)}`);
+            else
+                await this.write([phaseStartLine(observation)]);
+            return;
+        }
+        const mark = phaseMark(observation.outcome);
+        this.phaseFailed ||= mark === "×";
+        this.phaseUnknown ||= mark === "?";
+        if (observation.phase === "declaration") {
+            const total = observation.total ?? this.declarations?.total ?? 0;
+            const passed = (this.declarations?.passed ?? 0) + (mark === "✓" ? 1 : 0);
+            this.declarations = { passed, total };
+            this.declarationFailed ||= mark !== "✓";
+        }
+        if (this.status.isTTY)
+            this.status.show((duration) => `verify  ${mark} ${phaseDetail(observation)} · ${elapsed(duration)}`);
+        else
+            await this.write([phaseFinishLine(observation)]);
+    }
+    write(lines) {
+        if (this.status.isTTY) {
+            this.status.writeBlock(lines);
+            return Promise.resolve();
+        }
+        return writeChunk(this.input.stream, `${lines.join("\n")}\n`);
+    }
+    finalMark() {
+        return this.phaseFailed || this.declarationFailed ? "×" : this.phaseUnknown ? "?" : "✓";
+    }
+}
+export async function renderExecutionProgress(events, input) {
+    const renderer = new ExecutionProgressRenderer(input);
+    const destination = watchDestination(input.stream);
+    const iterator = events[Symbol.asyncIterator]();
+    try {
+        for (;;) {
+            const next = await Promise.race([iterator.next(), destination.promise]);
+            if (next.done === true)
+                break;
+            await renderer.consume(next.value);
+        }
+        renderer.finish();
+    }
+    finally {
+        destination.detach();
+    }
+}
+/** Reject when the destination dies while the producer is still owned. */
+function watchDestination(stream) {
+    let detach = () => undefined;
+    const promise = new Promise((_, reject) => {
+        const onError = (error) => reject(error);
+        const onClose = () => reject(Object.assign(new Error("write on prematurely closed destination"), { code: "ERR_STREAM_PREMATURE_CLOSE" }));
+        stream.once("error", onError);
+        stream.once("close", onClose);
+        detach = () => {
+            stream.off("error", onError);
+            stream.off("close", onClose);
+        };
+    });
+    promise.catch(() => undefined);
+    return { promise, detach };
+}
+/** Await one destination write: backpressure and error propagation in one callback. */
+function writeChunk(stream, text) {
+    return new Promise((resolve, reject) => {
+        stream.write(text, (error) => (error ? reject(error) : resolve()));
+    });
+}

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

@@ -1,5 +1,7 @@
-import { boundedActivity, elapsedMilliseconds, entityLines, identityLine, plumbFacts, RECENT_TONE_MS, renderSectionBlock, safeText, tone, } from "./terminal.js";
+import { snapshotActivityLines } from "./akuma-activity.js";
+import { elapsedMilliseconds, entityLines, identityLine, RECENT_TONE_MS, renderSectionBlock, safeText, tone, } from "./terminal.js";
 const NARROW_COLUMNS = 72;
+const ACTIVITY_INDENT = "  ";
 function mostRecentTimestamp(...values) {
     return values.reduce((latest, value) => {
         if (value === null || value === undefined)
@@ -24,40 +26,27 @@ function akumaStatusTone(row, observedAt) {
 function akumaMark(life) {
     return life === "running"
         ? "●"
-        : life === "stillborn"
-            ? "!"
-            : life === "asleep"
-                ? "○"
-                : life === "killed"
-                    ? "✕"
+        : life === "asleep"
+            ? "○"
+            : life === "killed"
+                ? "×"
+                : life === "stranded" || life === "stillborn" || life === "untidy"
+                    ? "!"
                     : "?";
 }
-function activitySnapshotLine(row) {
-    const snapshot = row.snapshot;
-    if (snapshot === undefined)
-        return undefined;
-    const latest = snapshot.entries.flatMap((entry) => (entry.kind === "row" ? [entry.row] : [])).at(-1);
-    if (latest === undefined) {
-        if (snapshot.kind !== "idle" || snapshot.outcome === undefined)
-            return undefined;
-        return snapshot.outcome.outcome.kind === "answered"
-            ? snapshot.outcome.outcome.answer
-            : snapshot.outcome.outcome.diagnostic;
-    }
-    if (latest.kind === "tool")
-        return latest.name;
-    return "text" in latest ? latest.text : "activity";
+/** Bounded latest semantic entry, rendered by the same activity renderer as a targeted snapshot. */
+function latestActivityLines(snapshot, context) {
+    const bounded = { ...context, columns: Math.max(1, context.columns - ACTIVITY_INDENT.length) };
+    return snapshotActivityLines(snapshot, bounded, { latest: true }).map((line) => `${ACTIVITY_INDENT}${line}`);
 }
 function akumaLabel(row) {
     const aliases = row.aliases ?? [];
     return aliases.length === 0 ? "" : `(${aliases.join(" ")})`;
 }
 function endpointFact(id, observed) {
-    return observed === "missing"
-        ? `-> ${id} (missing)`
-        : observed === "unavailable"
-            ? `-> ${id} (unavailable)`
-            : `-> ${id}`;
+    // A bounded or failed Contract read leaves the disposition unknown; a parenthetical that
+    // cannot name the reason is absent, while a complete read that established absence says so.
+    return observed === "missing" ? `${id} (missing)` : id;
 }
 function renderAkuma(report, context) {
     const section = report.akuma;
@@ -66,25 +55,26 @@ function renderAkuma(report, context) {
     if (section.kind === "failed")
         return ["AKUMA // unavailable", "", tone(`! ${safeText(section.failure.message)}`, "alert", context.color)];
     const rows = section.value.rows;
+    if (rows.length === 0)
+        return [];
     const rowLines = rows.map((row) => {
         const statusTone = akumaStatusTone(row, report.observedAt);
         const mark = statusTone === null ? akumaMark(row.life) : tone(akumaMark(row.life), statusTone, context.color);
         const lifeAt = "lifeAt" in row ? row.lifeAt : null;
-        const life = `${row.life} · ${formatAge(lifeAt, report.observedAt)}`;
-        const activity = "lastActivityAt" in row && row.lastActivityAt !== null
-            ? [`activity ${formatAge(row.lastActivityAt, report.observedAt)}`]
-            : [];
+        const lifeAge = formatAge(lifeAt, report.observedAt);
+        const life = `${row.life} · ${lifeAge}`;
+        const activityAge = "lastActivityAt" in row && row.lastActivityAt !== null ? formatAge(row.lastActivityAt, report.observedAt) : null;
+        const activity = activityAge === null || activityAge === lifeAge ? [] : [`activity ${activityAge}`];
         const key = row.life === "stranded" && "strandedReason" in row && row.strandedReason === "resume-unsupported"
             ? [life, ...activity, "resume unsupported"]
             : [life, ...activity];
-        const relation = row.contract === undefined ? ["unbound"] : [endpointFact(row.contract.id, row.contract.observed)];
-        const snapshot = activitySnapshotLine(row);
+        const relation = row.contract === undefined ? [] : [endpointFact(row.contract.id, row.contract.observed)];
+        const snapshot = row.snapshot;
+        const snapshotLines = snapshot === undefined ? [] : latestActivityLines(snapshot, context);
         const aliases = akumaLabel(row);
         if (context.columns > NARROW_COLUMNS) {
             const lines = [identityLine(mark, row.id, `${aliases} · ${[...key, ...relation].join(" · ")}`.trim())];
-            return snapshot === undefined
-                ? lines
-                : [...lines, ...plumbFacts([boundedActivity(snapshot, context.columns, "  ")], context.columns)];
+            return [...lines, ...snapshotLines];
         }
         const identity = aliases.length === 0 ? row.id : `${row.id} ${aliases}`;
         const lines = entityLines({
@@ -95,9 +85,7 @@ function renderAkuma(report, context) {
             facts: [...key.slice(1), ...relation],
             context,
         });
-        return snapshot === undefined
-            ? lines
-            : [...lines, ...plumbFacts([boundedActivity(snapshot, context.columns, "  ")], context.columns)];
+        return [...lines, ...snapshotLines];
     });
     const rendered = renderSectionBlock({
         name: "AKUMA",