@astrosheep/keiyaku 4.5.29 → 4.6.2

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

@@ -1,6 +1,7 @@
 import { defaultWaitComplete } from "../../akuma/akuma-observe.js";
-import { toolContent, toolRepr } from "./akuma-tool.js";
-import { DEFAULT_CLI_COLUMNS, displayColumns, renderBoundedTextBlock, safeText, takeDisplayColumns, takeDisplayColumnsFromEnd, truncateDisplayText, truncateMiddleDisplayText, } from "./terminal.js";
+import { renderDiffstat, toolContent, toolRepr } from "./akuma-tool.js";
+import { taskDispositionMark } from "./marks.js";
+import { DEFAULT_CLI_COLUMNS, displayColumns, padToDisplay, renderBoundedPayload, renderBoundedTextBlock, safeText, takeDisplayColumns, takeDisplayColumnsFromEnd, truncateDisplayText, truncateMiddleDisplayText, } from "./terminal.js";
 export const DEFAULT_CONTEXT = { columns: DEFAULT_CLI_COLUMNS, color: false };
 const TIME_WIDTH = 5;
 const VERB_WIDTH = 6;
@@ -21,8 +22,9 @@ function identity(id, alias) {
 function associatedContractId(contract) {
     return contract.kind === "associated" ? contract.contractId : undefined;
 }
-export function associatedIdentity(id, alias, _contract) {
-    return identity(id, alias);
+export function associatedIdentity(id, alias, contract) {
+    const contractId = contract === undefined ? undefined : associatedContractId(contract);
+    return `${identity(id, alias)}${contractId === undefined ? "" : `\n└─ ${contractId}`}`;
 }
 export function snapshotHeading(id, alias, contract) {
     const contractId = contract === undefined ? undefined : associatedContractId(contract);
@@ -39,17 +41,6 @@ function contractFacts(contract) {
 function unobservedText(id, diagnostic) {
     return `× Akuma observation failed  ${safeText(id)} — ${safeText(diagnostic)}`;
 }
-function lifeLabel(life) {
-    if (life === "running")
-        return "● running";
-    if (life === "asleep")
-        return "✓ came back";
-    if (life === "killed")
-        return "× killed";
-    if (life === "hung")
-        return "? hung";
-    return "! stranded";
-}
 function clock(at) {
     const date = new Date(at);
     return Number.isFinite(date.getTime())
@@ -75,16 +66,14 @@ function label(row, tool) {
         return row.kind;
     return tool.label;
 }
-function mark(row) {
+function mark(row, live = false) {
     if (row.kind === "outcome")
         return row.outcome.kind === "answered" ? "✓" : "!";
-    if (row.kind === "tell" && row.state === "told")
-        return "✓";
     if (row.kind === "tell" && row.state === "pending")
         return "⧗";
     if (row.kind === "tool") {
         if (row.state === "active")
-            return "⧖";
+            return live ? "●" : "?";
         if (row.state === "unsettled")
             return "?";
         return row.state.status === "ok" ? "✓" : "!";
@@ -141,11 +130,6 @@ function actionCell(head, verb, columns) {
 function continuationPrefix() {
     return " ".repeat(TIME_WIDTH) + " │ " + " ".repeat(VERB_WIDTH) + " ";
 }
-/** Pad to a terminal-column width; raw string length is never the measuring stick. */
-function padToDisplay(text, width) {
-    const remaining = width - displayColumns(text);
-    return remaining > 0 ? `${text}${" ".repeat(remaining)}` : text;
-}
 function timelineMarker(text) {
     return `${" ".repeat(TIME_WIDTH)} ⋮ ${text}`;
 }
@@ -166,7 +150,6 @@ function sourceLayout(source, width, clock) {
     const gutter = () => `${" ".repeat(TIME_WIDTH)} ${padToDisplay(source, width())} `;
     return {
         head: (time, glyph, verb, columns) => actionCell(`${time === undefined ? " ".repeat(TIME_WIDTH) : time.padEnd(TIME_WIDTH)} ${padToDisplay(source, width())} ${glyph}`, verb, columns),
-        // Continuations blank the time and source columns and align under the mark.
         continuation: () => `${" ".repeat(TIME_WIDTH)} ${" ".repeat(width())} │ ${" ".repeat(VERB_WIDTH)} `,
         marker: (count) => `${gutter()}⋮ ${count} omitted`,
         clock,
@@ -179,16 +162,6 @@ function quotedBody(row) {
         row.kind === "tell" ||
         (row.kind === "outcome" && row.outcome.kind === "answered"));
 }
-/** Quote every rendered body line, slicing each line's prefix by its display width. */
-function quoteLines(lines, prefix) {
-    const prefixWidth = displayColumns(prefix);
-    return lines.map((line) => {
-        const { text: head, rest: body } = takeDisplayColumns(line, prefixWidth);
-        if (body.length === 0)
-            return line;
-        return `${head}“${body}”`;
-    });
-}
 function pathTail(path, maximum) {
     if (displayColumns(path) <= maximum)
         return path;
@@ -231,28 +204,16 @@ function renderPathPreview(first, text, pathPreview, columns) {
     const renderedDiagnostic = remainder > 0 ? truncateDisplayText(diagnostic, remainder) : "";
     return `${first}${base}${renderedDiagnostic}`;
 }
-function takeWordPrefix(value, maximum) {
-    const taken = takeDisplayColumns(value, maximum);
-    if (taken.rest.length === 0)
-        return { head: taken.text, rest: "" };
-    const split = taken.text.lastIndexOf(" ");
-    if (split <= 0)
-        return { head: taken.text, rest: taken.rest };
-    return {
-        head: taken.text.slice(0, split).trimEnd(),
-        rest: `${taken.text.slice(split)}${taken.rest}`.trimStart(),
-    };
-}
 function renderRunCommand(first, continuation, text, suffix, columns) {
     const firstBudget = Math.max(0, columns - displayColumns(first));
     const secondBudget = Math.max(0, columns - displayColumns(continuation));
     if (displayColumns(`${text}${suffix}`) <= firstBudget)
         return [`${first}${text}${suffix}`];
     const command = text.startsWith("$ ") ? text.slice(2) : text;
-    const firstPart = takeWordPrefix(command, Math.max(0, firstBudget - 3));
+    const firstPart = takeDisplayColumns(command, Math.max(0, firstBudget - 2));
     const restWidth = displayColumns(firstPart.rest) + displayColumns(suffix);
     if (restWidth <= secondBudget) {
-        return [`${first}$ ${firstPart.head}`, `${continuation}${firstPart.rest}${suffix}`];
+        return [`${first}$ ${firstPart.text}`, `${continuation}${firstPart.rest}${suffix}`];
     }
     const suffixBudget = Math.min(displayColumns(suffix), Math.max(0, secondBudget - 8));
     const keptSuffix = suffixBudget > 0 ? truncateDisplayText(suffix, suffixBudget) : "";
@@ -267,67 +228,66 @@ function rowBody(row, text, columns) {
         return text;
     return toolContent(row, columns);
 }
-function renderSingleLineRow(input) {
-    const { row, first, value, context, quoted, inFlightSay } = input;
-    const openQuote = row.kind === "said" && inFlightSay;
-    const quoteWidth = quoted ? (openQuote ? 1 : 2) : 0;
-    const remaining = context.columns - displayColumns(first) - quoteWidth;
-    const bodyText = rowBody(row, value.text, remaining);
-    const text = truncateDisplayText(bodyText, Math.max(0, remaining));
-    if (!quoted)
-        return [text.length === 0 ? first.trimEnd() : `${first}${text}`];
-    return [`${first}"${text}${openQuote ? "" : '"'}`];
-}
-function renderMultilineRow(input) {
-    const { row, first, continuation, value, context, history, quoted } = input;
-    const quoteWidth = quoted ? 2 : 0;
-    const remaining = context.columns - quoteWidth - displayColumns(first);
-    // A name that already fills its row spends the width whole; its arguments trim away entirely.
-    if (remaining <= 0)
-        return [first.trimEnd()];
-    const bodyText = rowBody(row, value.text, remaining - displayColumns(value.suffix ?? ""));
-    const lines = renderBoundedTextBlock(bodyText, {
-        first,
-        continuation,
-        columns: context.columns - quoteWidth,
-        lines: history ? Number.MAX_SAFE_INTEGER : value.lines,
-        ...("truncated" in row && row.truncated === true ? { truncated: true } : {}),
-    });
-    return quoted ? quoteLines(lines, first) : lines;
+function tailAnswerPreview(first, text, columns) {
+    const readable = safeText(text).replace(/\s+/gu, " ").trim();
+    const budget = Math.max(0, columns - displayColumns(first + "“”"));
+    const tail = takeDisplayColumnsFromEnd(readable, budget).text;
+    const preview = tail.length === readable.length ? tail : `…${takeDisplayColumnsFromEnd(readable, Math.max(0, budget - 1)).text}`;
+    return [`${first}“${preview}”`];
+}
+function toolOverflowPreview(options, value, columns) {
+    const { tool, layout, first, continuation } = options;
+    if (tool?.overflow !== "command")
+        return undefined;
+    if (layout.compactRun !== true)
+        return renderRunCommand(first, continuation, value.text, value.suffix ?? "", columns);
+    const remaining = columns - displayColumns(first);
+    const suffix = value.suffix ?? "";
+    const withSuffix = remaining - displayColumns(suffix);
+    const showSuffix = suffix.length > 0 && withSuffix >= 6;
+    return [
+        `${first}${truncateMiddleDisplayText(value.text, Math.max(0, showSuffix ? withSuffix : remaining))}${showSuffix ? suffix : ""}`,
+    ];
 }
 function renderRow(row, context, options) {
     const { layout, first, continuation, tool, inFlightSay = false } = options;
     const value = rowText(row, tool);
-    if (tool?.overflow === "command") {
-        if (layout.compactRun !== true)
-            return renderRunCommand(first, continuation, value.text, value.suffix ?? "", context.columns);
-        const remaining = context.columns - displayColumns(first);
-        const suffix = value.suffix ?? "";
-        const withSuffix = remaining - displayColumns(suffix);
-        const showSuffix = suffix.length > 0 && withSuffix >= 6;
-        return [
-            `${first}${truncateMiddleDisplayText(value.text, Math.max(0, showSuffix ? withSuffix : remaining))}${showSuffix ? suffix : ""}`,
-        ];
-    }
+    const overflow = toolOverflowPreview(options, value, context.columns);
+    if (overflow !== undefined)
+        return overflow;
     if (tool?.pathPreview !== undefined)
         return [renderPathPreview(first, value.text, tool.pathPreview, context.columns)];
-    const quoted = quotedBody(row);
-    return layout.singleLine === true
-        ? renderSingleLineRow({ row, first, value, context, quoted, inFlightSay })
-        : renderMultilineRow({ row, first, continuation, value, context, history: layout.history === true, quoted });
+    if (layout.tailAnswer === true && row.kind === "outcome" && row.outcome.kind === "answered")
+        return tailAnswerPreview(first, value.text, context.columns);
+    const available = context.columns - displayColumns(first) - displayColumns(value.suffix ?? "");
+    return renderBoundedPayload({
+        text: rowBody(row, value.text, available),
+        first,
+        continuation,
+        columns: context.columns,
+        maxLines: layout.singleLine === true && row.kind !== "said"
+            ? 1
+            : layout.history === true
+                ? Number.MAX_SAFE_INTEGER
+                : value.lines,
+        quote: quotedBody(row) ? (layout.singleLine === true && row.kind !== "said" ? '"' : "“") : "",
+        openQuote: row.kind === "said" && inFlightSay,
+        truncated: "truncated" in row && row.truncated === true,
+    });
 }
-/** Snapshot and live streams select different rows, but render each selected row identically. */
-function renderTimelineRow(row, context, layout, time, inFlightSay = false) {
+function renderTimelineRow(row, context, layout, time, options = {}) {
+    const { inFlightSay = false, live = false, unsettled = false } = options;
     const tool = row.kind === "tool" ? toolRepr(row) : undefined;
+    const glyph = inFlightSay ? (live ? "●" : "?") : unsettled ? "?" : mark(row, live);
     return renderRow(row, context, {
         layout,
-        first: layout.head(time, inFlightSay ? "⧖" : mark(row), label(row, tool), context.columns),
+        first: layout.head(time, glyph, label(row, tool), context.columns),
         continuation: layout.continuation(),
         tool,
         inFlightSay,
     });
 }
-function groupedEntries(entries, context, layout = plainLayout()) {
+function groupedEntries(entries, context, layout = plainLayout(), options = {}) {
     const lines = [];
     let previousClock;
     for (const entry of entries) {
@@ -338,7 +298,11 @@ function groupedEntries(entries, context, layout = plainLayout()) {
         const row = entry.row;
         const at = clock(row.at);
         const changed = previousClock === undefined || at !== previousClock;
-        lines.push(...renderTimelineRow(row, context, layout, changed ? at : undefined));
+        lines.push(...renderTimelineRow(row, context, layout, changed ? at : undefined, {
+            inFlightSay: options.inFlightSay?.(row) ?? false,
+            live: options.live === true,
+            unsettled: options.unsettled?.(row) ?? false,
+        }));
         previousClock = at;
     }
     return lines;
@@ -404,7 +368,12 @@ export function snapshotActivityLines(snapshot, context, selection = {}) {
         return groupedEntries(coalesceAdjacentGaps(full), context);
     }
     const latest = entries.filter((entry) => entry.kind === "row").at(-1);
-    return latest === undefined ? [] : groupedEntries([latest], context, compactLayout());
+    return latest === undefined
+        ? []
+        : groupedEntries([latest], context, {
+            ...compactLayout(),
+            ...(selection.tailAnswer === true ? { tailAnswer: true } : {}),
+        });
 }
 function isSettledStreamRow(row) {
     if (row.kind === "turn" || row.kind === "outcome")
@@ -413,49 +382,57 @@ function isSettledStreamRow(row) {
         return row.state === "told";
     return row.kind !== "tool" || (row.state !== "active" && row.state !== "unsettled");
 }
-/** A pending Tell or active tool retains its sequence when it later becomes eligible. */
-function isMutableStreamRow(row) {
-    return (row.kind === "tell" && row.state === "pending") || (row.kind === "tool" && row.state === "active");
+function sameTool(left, right) {
+    return (left.kind === "tool" &&
+        right.kind === "tool" &&
+        left.turnSequence === right.turnSequence &&
+        left.name === right.name &&
+        JSON.stringify(left.call) === JSON.stringify(right.call));
 }
 function settledRows(activity) {
-    return activity.rows.filter(isSettledStreamRow);
+    return activity.rows.filter((row) => isSettledStreamRow(row) && !inFlightSay(activity, row));
 }
 function isBoundedStreamTool(row) {
     return row.kind === "tool";
 }
-function rememberMutableRows(state, activity) {
+function rememberPendingTells(state, activity) {
     for (const row of activity.rows)
-        if (isMutableStreamRow(row))
-            state.mutableSequences.add(row.sequence);
+        if (row.kind === "tell" &&
+            row.state === "pending" &&
+            (state.admissionSequence === undefined || row.sequence >= state.admissionSequence))
+            state.pendingTellSequences.add(row.sequence);
 }
-/** A seeded wait counts its skipped settled companion evidence after its typed opening. */
-function baselineOmissionCount(activity, boundary) {
-    let afterBoundary = false;
-    let count = 0;
-    for (const row of activity.rows) {
-        if (!afterBoundary) {
-            if (row.sequence === boundary.row.sequence)
-                afterBoundary = true;
-            continue;
-        }
-        if (isSettledStreamRow(row))
-            count += 1;
-    }
-    return count;
+/** Count skipped settled rows within the eligible part of a seeded baseline. */
+function baselineOmissionCount(activity, after, before) {
+    return activity.rows.filter((row) => row.sequence > after && (before === undefined || row.sequence < before) && isSettledStreamRow(row)).length;
 }
 function renderStreamRow(state, row, lines, options) {
-    const { context, layout, inFlightSay = false } = options;
+    const { context, layout, inFlightSay = false, unsettled = false } = options;
     const at = clock(row.at);
     const previousClock = layout.clock?.previous ?? state.previousClock;
     const changed = previousClock === undefined || at !== previousClock;
-    lines.push(...renderTimelineRow(row, context, layout, changed ? at : undefined, inFlightSay));
+    lines.push(...renderTimelineRow(row, context, layout, changed ? at : undefined, {
+        inFlightSay,
+        unsettled,
+    }));
     if (layout.clock !== undefined)
         layout.clock.previous = at;
     else
         state.previousClock = at;
 }
+/**
+ * A say is in-flight only while it is the newest row of the open turn: it may still be streaming, so it
+ * stays in the redrawable frame. A say with any successor row is settled evidence and renders on the rail.
+ */
 function inFlightSay(activity, row) {
-    return activity.snapshot.kind === "open" && row.kind === "said";
+    if (activity.snapshot.kind !== "open" || row.kind !== "said")
+        return false;
+    let newest;
+    for (const candidate of activity.rows) {
+        if (newest === undefined || candidate.sequence > newest.sequence)
+            newest = candidate;
+    }
+    return newest !== undefined && newest.sequence === row.sequence;
 }
 function coalesceDeferredGaps(state) {
     state.deferred = state.deferred.reduce((entries, entry) => {
@@ -476,6 +453,11 @@ function omitOldestDeferredTool(state) {
     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 (;;) {
@@ -503,33 +485,53 @@ function renderCurrentTurnBoundary(state, activity, lines, context, layout) {
     }
     return boundary;
 }
+function rememberLiveRows(state, activity) {
+    for (const row of activity.rows) {
+        if (row.kind === "tool" && row.state === "active")
+            state.liveRows.set(row.sequence, row);
+        else if (row.kind === "said" && inFlightSay(activity, row))
+            state.liveRows.set(row.sequence, row);
+        else if (row.kind === "tool" && isSettledStreamRow(row)) {
+            for (const [sequence, live] of state.liveRows) {
+                if (sameTool(live, row)) {
+                    state.liveRows.delete(sequence);
+                    break;
+                }
+            }
+        }
+        else if (isSettledStreamRow(row))
+            state.liveRows.delete(row.sequence);
+    }
+}
 function observeActivitySnapshot(state, activity, context, layout) {
     const lines = [];
     const boundary = currentTurnBoundary(activity);
-    rememberMutableRows(state, activity);
+    rememberPendingTells(state, activity);
     // A row newly selected as this Turn's typed opening must still respect the
-    // settled cursor, even if its earlier pending form was remembered as mutable.
+    // settled cursor, even if its earlier pending form was remembered.
     if (boundary !== undefined)
-        state.mutableSequences.delete(boundary.row.sequence);
+        state.pendingTellSequences.delete(boundary.row.sequence);
     const observedRows = settledRows(activity)
+        .filter((row) => state.admissionSequence === undefined || row.sequence >= state.admissionSequence)
         .filter((row) => !state.admittedTellSequences.has(row.sequence))
         .filter((row) => boundary === undefined ||
         !state.renderedBoundaries.has(boundary.turnSequence) ||
         row.sequence !== boundary.row.sequence)
-        .filter((row) => state.mutableSequences.has(row.sequence) ||
+        .filter((row) => state.pendingTellSequences.has(row.sequence) ||
         state.newestSettledSequence === undefined ||
         row.sequence > state.newestSettledSequence);
+    rememberLiveRows(state, activity);
     if (observedRows.length === 0)
         return lines;
     for (const row of observedRows)
-        state.mutableSequences.delete(row.sequence);
+        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) });
-            state.openingTools = 0;
             continue;
         }
         if (isBoundedStreamTool(row) && state.openingTools < OPENING_TOOL_BUDGET) {
@@ -564,53 +566,87 @@ function flushActivityTail(state, context, layout) {
 }
 /**
  * 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
- * until the command ends. As a newer tool displaces an older tail candidate,
- * its body becomes an in-place omission count. Narrative waits only while a
- * preceding tail tool still decides its position.
+ * 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.
  */
 export function activityStream(context, layout = plainLayout()) {
     const state = {
         newestSettledSequence: undefined,
-        mutableSequences: new Set(),
+        admissionSequence: undefined,
+        pendingTellSequences: new Set(),
         previousClock: undefined,
         renderedBoundaries: new Set(),
         admittedTellSequences: new Set(),
         openingTools: 0,
         deferred: [],
+        liveRows: new Map(),
     };
     const seed = (activity, alreadyRenderedSequence) => {
         const lines = [];
-        if (alreadyRenderedSequence !== undefined)
+        if (alreadyRenderedSequence !== undefined) {
+            state.admissionSequence = alreadyRenderedSequence;
             state.admittedTellSequences.add(alreadyRenderedSequence);
+        }
         const boundary = currentTurnBoundary(activity);
         const unseenBoundary = boundary !== undefined && !state.renderedBoundaries.has(boundary.turnSequence);
         if (unseenBoundary) {
-            if (boundary.row.sequence === alreadyRenderedSequence)
+            if (alreadyRenderedSequence !== undefined && boundary.row.sequence > alreadyRenderedSequence) {
+                const beforeBoundary = baselineOmissionCount(activity, alreadyRenderedSequence, boundary.row.sequence);
+                if (beforeBoundary > 0)
+                    lines.push(layout.marker(beforeBoundary));
+            }
+            if (alreadyRenderedSequence !== undefined && boundary.row.sequence <= alreadyRenderedSequence)
                 state.renderedBoundaries.add(boundary.turnSequence);
             else
                 renderCurrentTurnBoundary(state, activity, lines, context, layout);
-            const omitted = baselineOmissionCount(activity, boundary);
+            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));
         }
-        rememberMutableRows(state, activity);
+        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;
     };
     const observe = (activity) => observeActivitySnapshot(state, activity, context, layout);
-    const flush = () => flushActivityTail(state, context, layout);
-    return Object.assign(observe, { seed, flush });
+    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)];
+        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,
+            });
+        }
+        state.liveRows.clear();
+        return lines;
+    };
+    return Object.assign(observe, { seed, frame, flush });
 }
-function conclusionMarkVerb(status, answered) {
-    if (failedOutcomeDiagnostic(status) !== undefined)
+function conclusionMarkVerb(status, outcome) {
+    if (outcome === "failed" || (status !== undefined && failedOutcomeDiagnostic(status) !== undefined))
         return { mark: "!", verb: "failed" };
-    if (answered)
+    if (outcome === "answered")
         return { mark: "✓", verb: "answered" };
+    if (outcome === "unanswered")
+        return { mark: "○", verb: "unanswered" };
+    if (status === undefined)
+        return { mark: "⧗", verb: "pending tell" };
     if (status.life === "running")
-        return { mark: "●", verb: "still running" };
+        return { mark: "●", verb: "running" };
     if (!defaultWaitComplete(status)) {
         return { mark: "⧗", verb: "pending tell" };
     }
@@ -777,13 +813,13 @@ export function inputWaitConclusion(observation, input) {
     const complete = observation.reason !== "deadline";
     const pinned = input.completedAt == null ? Number.NaN : Date.parse(input.completedAt);
     const at = complete ? (Number.isFinite(pinned) ? pinned : undefined) : end;
-    const conclusion = observation.reason === "answered"
-        ? { mark: "✓", verb: "answered" }
+    const conclusion = conclusionMarkVerb(input.status, observation.reason === "answered"
+        ? "answered"
         : observation.reason === "failed" || observation.reason === "invalid-output"
-            ? { mark: "!", verb: "failed" }
+            ? "failed"
             : observation.reason === "unanswered"
-                ? { mark: "○", verb: "unanswered" }
-                : { mark: "⧖", verb: "deadline" };
+                ? "unanswered"
+                : "life");
     return [
         waitConclusionRow({
             ...(at === undefined ? {} : { at }),
@@ -841,14 +877,14 @@ function concludeWaitStream(state, result, startedAt, now) {
         const status = observation.status;
         const complete = defaultWaitComplete(status);
         const at = complete ? (state.settledAt.get(id) ?? end) : end;
-        const { mark, verb } = conclusionMarkVerb(status, statusAnswer(observation) !== undefined);
+        const { mark, verb } = conclusionMarkVerb(status, statusAnswer(observation) !== undefined ? "answered" : "life");
         const target = multi ? ` ${padToDisplay(sourceTag(state, id), state.sourceWidth)}` : "";
         return [waitConclusionRow({ at, startedAt, complete, end, mark, verb, target })];
     });
     const answeredSingle = !multi && result.observations.length === 1 && statusAnswer(result.observations[0]) !== undefined;
     const blocks = [
+        ...(conclusions.length > 0 ? [conclusions.join("\n")] : []),
         ...(unobservedLines.length > 0 ? [unobservedLines.join("\n")] : []),
-        ...(conclusions.length > 0 ? [(multi ? [""] : []).concat(conclusions).join("\n")] : []),
     ];
     const body = [...tail, ...blocks].join("\n");
     // One blank line keeps the bare stdout answer visually separate from the stream.
@@ -876,8 +912,10 @@ export function waitObservationStream(context, options = {}) {
         freezeWaitTags(state);
     };
     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 conclude = (result) => concludeWaitStream(state, result, startedAt, now);
-    return { select, observe, conclude, streamed: () => state.observed };
+    return { select, observe, frame, flush, conclude, streamed: () => state.observed };
 }
 function failedOutcomeDiagnostic(status) {
     const outcome = status.timeline.kind === "idle" ? status.timeline.outcome : undefined;
@@ -895,6 +933,8 @@ export function inputWaitStream(context, head, options) {
     let admittedSequence;
     let opened = false;
     let cursorSeeded = false;
+    /** The last observed life, so a caller deadline concludes on the target's status rather than naming the deadline. */
+    let lastStatus;
     const admit = (input) => {
         if (admitted)
             throw new Error("input wait admitted more than once");
@@ -916,10 +956,11 @@ export function inputWaitStream(context, head, options) {
             throw new Error("input wait observed before admission");
         opened = true;
         const identity = head();
-        lines.push(...snapshotHeading(identity.id, identity.alias, identity.contract), ...identity.facts);
+        lines.push(...snapshotHeading(identity.id, identity.alias, identity.contract));
     };
     const observe = (observation) => {
         const lines = [];
+        lastStatus = observation.status;
         open(lines);
         const activityInput = { snapshot: observation.status.timeline, rows: observation.rows };
         if (!cursorSeeded && options.cursor === "admission")
@@ -929,6 +970,8 @@ export function inputWaitStream(context, head, options) {
         cursorSeeded = true;
         return lines;
     };
+    const frame = () => activity.frame();
+    const flush = () => activity.flush();
     const conclude = (result) => {
         const lines = [];
         open(lines, result.kind === "failed");
@@ -940,10 +983,12 @@ export function inputWaitStream(context, head, options) {
                 startedAt,
                 ...(result.completedAt === undefined ? {} : { completedAt: result.completedAt }),
                 now: now(),
+                ...(lastStatus === undefined ? {} : { status: lastStatus }),
             }));
+        lines.push(...head().facts);
         return `${lines.join("\n")}${options.answerSeparator === true ? "\n\n" : ""}`;
     };
-    return { admitted: admit, observe, conclude, opened: () => opened };
+    return { admitted: admit, observe, frame, flush, conclude, opened: () => opened };
 }
 export function callObservationStream(context, head, options = {}) {
     const stream = inputWaitStream(context, () => head, {
@@ -953,7 +998,7 @@ export function callObservationStream(context, head, options = {}) {
     });
     stream.admitted({ ...(options.admittedAt === undefined ? {} : { at: options.admittedAt }), rows: [] });
     return {
-        observe: stream.observe,
+        ...stream,
         conclude: (observation) => {
             if (observation.kind === "failed")
                 return stream.conclude({ kind: "failed", diagnostic: observation.failure.diagnostic });
@@ -965,30 +1010,15 @@ export function callObservationStream(context, head, options = {}) {
                 ...(observation.completedAt === undefined ? {} : { completedAt: observation.completedAt }),
             });
         },
-        opened: stream.opened,
     };
 }
-function taskDispositionMark(disposition) {
-    if (disposition === "done")
-        return "✓";
-    if (disposition === "drop")
-        return "×";
-    if (disposition === "on_hold")
-        return "⧗";
-    if (disposition === "in_progress")
-        return "●";
-    return disposition === "blocked" ? "‖" : "○";
-}
-function changeStat(change) {
-    return change.diffstat === undefined ? "+? -?" : `+${change.diffstat.added} -${change.diffstat.removed}`;
-}
 function renderReportedChangeLines(snapshot) {
     if (snapshot.reportedChanges.length === 0 && snapshot.reportedChangesOmitted === 0)
         return [];
-    const width = snapshot.reportedChanges.reduce((max, change) => Math.max(max, changeStat(change).length), 0);
+    const width = snapshot.reportedChanges.reduce((max, change) => Math.max(max, renderDiffstat(change.diffstat).length), 0);
     return [
         `changes ${snapshot.reportedChanges.length + snapshot.reportedChangesOmitted}`,
-        ...snapshot.reportedChanges.map((change) => `  ${changeStat(change).padEnd(width)}  ${safeText(change.path)}`),
+        ...snapshot.reportedChanges.map((change) => `  ${renderDiffstat(change.diffstat).padEnd(width)}  ${safeText(change.path)}`),
         ...(snapshot.reportedChangesOmitted > 0 ? [`  ⋮ ${snapshot.reportedChangesOmitted} more files`] : []),
     ];
 }
@@ -1031,32 +1061,40 @@ function answeredBlock(observation, answer, alias, columns) {
 function snapshotCore(view, context, options) {
     const activity = snapshotActivityLines(view.status.timeline, context);
     const facts = [
-        ...(view.status.cwd === undefined ? [] : [`cwd  ${safeText(view.status.cwd)}`]),
         ...(options.showAllowed === true ? [`allowed  ${view.status.allowed.join(", ") || "none"}`] : []),
         ...contractFacts(view.contract),
         ...(options.facts ?? []),
+        ...(view.status.cwd === undefined ? [] : [`cwd  ${safeText(view.status.cwd)}`]),
     ];
     return {
         activity,
-        lines: [...snapshotHeading(view.status.id, options.alias, view.contract), ...facts, ...activity],
+        lines: [...snapshotHeading(view.status.id, options.alias, view.contract), ...activity],
+        facts,
     };
 }
+function snapshotConclusion(status) {
+    const timeline = status.timeline;
+    // The outcome row (`✓ answer` / `! error`) is already the ending; a closer would be a second mark
+    // carrying no new information, so it is absent exactly then.
+    if (timeline.kind === "idle" && timeline.outcome !== undefined)
+        return "";
+    const last = [...timeline.entries].reverse().find((entry) => entry.kind === "row")?.row;
+    const { mark, verb } = conclusionMarkVerb(status, "life");
+    return `${last === undefined ? "unknown" : clock(last.at)} ${mark} ${verb}`;
+}
 export function snapshotText(view, context, options = {}) {
     const core = snapshotCore(view, context, options);
     const taskContext = renderTaskContextLines(view.createdTasks, context.columns);
+    const conclusion = snapshotConclusion(view.status);
     return [
         ...core.lines,
-        ...(core.activity.length > 0 && taskContext.length > 0 ? [""] : []),
-        ...taskContext,
+        ...(conclusion.length === 0 ? [] : [conclusion]),
+        ...(taskContext.length > 0 ? ["", ...taskContext] : []),
+        ...(view.status.timeline.reportedChanges.length > 0 || view.status.timeline.reportedChangesOmitted > 0 ? [""] : []),
         ...renderReportedChangeLines(view.status.timeline),
-        "",
-        lifeLabel(view.status.life),
+        ...(core.facts.length > 0 ? ["", ...core.facts] : []),
     ].join("\n");
 }
-function mutationSnapshotText(view, context, options = {}) {
-    const core = snapshotCore(view, context, options);
-    return [...core.lines, ...(options.showLife === false ? [] : ["", lifeLabel(view.status.life)])].join("\n");
-}
 function killResultLabel(evidence) {
     if (evidence === "killed")
         return "✓ killed";
@@ -1069,11 +1107,6 @@ function killResultLabel(evidence) {
 export function killResultText(id, evidence, alias) {
     return [...snapshotHeading(id, alias, undefined), "", killResultLabel(evidence)].join("\n");
 }
-export function mutationObservationStageText(id, observation, context, options = {}) {
-    if (observation.kind === "unobserved")
-        return unobservedText(id, observation.diagnostic);
-    return mutationSnapshotText(observation, context, options);
-}
 export function statusAnswer(view) {
     if (!defaultWaitComplete(view.status))
         return undefined;
@@ -1087,56 +1120,40 @@ export function statusAnswer(view) {
 function answerBytes(answer, structured) {
     return !structured && typeof answer === "string" ? answer : JSON.stringify(answer);
 }
-function tellAnswer(result) {
-    if (result.mode !== "wait")
-        return undefined;
-    if (result.result.observation.reason !== "answered")
+export function askRawAnswer(result, structured) {
+    if (result.observation.reason !== "answered")
         return "";
-    return answerBytes(result.result.observation.answer, result.structured === true);
+    return answerBytes(result.observation.answer, structured === true);
 }
-function callAnswer(result) {
-    const observation = result.result.observation;
+export function callRawAnswer(result, streamed) {
+    const observation = result.observation;
     if (observation.kind !== "observed" || observation.observation.reason !== "answered")
-        return result.streamed === true ? "" : undefined;
-    return answerBytes(observation.observation.answer, result.result.structured === true);
+        return streamed ? "" : undefined;
+    return answerBytes(observation.observation.answer, result.structured === true);
 }
-function waitAnswer(result) {
-    const total = result.result.observations.length + result.result.unobserved.length;
-    if (result.streamed === true) {
+export function waitRawAnswer(result, streamed) {
+    const total = result.observations.length + result.unobserved.length;
+    if (streamed) {
         // Plural waits leave stdout empty so one answer can never be mistaken for the whole result.
         if (total !== 1)
             return "";
-        const single = result.result.observations[0];
+        const single = result.observations[0];
         return single === undefined ? "" : (statusAnswer(single) ?? "");
     }
     if (total !== 1)
         return undefined;
-    return statusAnswer(result.result.observations[0]);
+    return statusAnswer(result.observations[0]);
 }
-function historyAnswer(result) {
-    if (result.mode !== "exact" || result.historyResult.kind !== "exact")
+export function historyRawAnswer(result, historyId) {
+    if (historyId === undefined || result.kind !== "exact")
         return undefined;
-    const outcome = result.historyResult.outcome.outcome;
+    const outcome = result.outcome.outcome;
     return outcome.kind === "answered" ? outcome.answer : outcome.diagnostic;
 }
-export function akumaRawAnswer(result) {
-    switch (result.action) {
-        case "tell":
-            return tellAnswer(result);
-        case "call":
-            return callAnswer(result);
-        case "wait":
-            return waitAnswer(result);
-        case "history":
-            return historyAnswer(result);
-        default:
-            return undefined;
-    }
-}
-export function waitText(result, context) {
-    const alias = result.alias;
-    const observations = result.result.observations;
-    const unobserved = result.result.unobserved;
+export function waitText(result, presentation, context) {
+    const alias = presentation.alias;
+    const observations = result.observations;
+    const unobserved = result.unobserved;
     const total = observations.length + unobserved.length;
     if (total <= 1) {
         const single = [
@@ -1151,13 +1168,13 @@ export function waitText(result, context) {
         return single.join("\n\n");
     }
     const end = Date.now();
-    const startedAt = result.startedAt ?? end;
+    const startedAt = presentation.startedAt ?? end;
     const order = [];
     const remember = (id) => {
         if (!order.includes(id))
             order.push(id);
     };
-    for (const member of result.selection ?? [])
+    for (const member of presentation.selection ?? [])
         remember(member.id);
     for (const observation of observations)
         remember(observation.status.id);
@@ -1192,23 +1209,24 @@ export function waitText(result, context) {
         const status = observation.status;
         const complete = defaultWaitComplete(status);
         const at = complete ? (settleMoment(status) ?? end) : end;
-        const { mark, verb } = conclusionMarkVerb(status, statusAnswer(observation) !== undefined);
+        const { mark, verb } = conclusionMarkVerb(status, statusAnswer(observation) !== undefined ? "answered" : "life");
         return [
             `${clockFromMs(at)} ${padToDisplay(waitIdentityTag(id, order), sourceWidth)} ${mark} ${verb}${conclusionClause(at, startedAt, complete, end)}`,
         ];
     });
     return rows.length > 0 ? [...blocks, rows.join("\n")].join("\n\n") : blocks.join("\n\n");
 }
-export function historyText(command, result, context) {
-    if (result.mode === "exact") {
-        const exact = result.historyResult;
-        if (exact.kind !== "exact")
-            return `${exact.kind === "unknown-history" ? exact.historyId : "unknown"} has no matching retained outcome`;
-        return exact.outcome.outcome.kind === "answered" ? exact.outcome.outcome.answer : exact.outcome.outcome.diagnostic;
+export function historyText(result, presentation, context) {
+    if (presentation.id !== undefined) {
+        if (result.kind !== "exact")
+            return `${result.kind === "unknown-history" ? result.historyId : "unknown"} has no matching retained outcome`;
+        return result.outcome.outcome.kind === "answered"
+            ? result.outcome.outcome.answer
+            : result.outcome.outcome.diagnostic;
     }
-    if (command.last)
-        return result.mode === "last" ? result.answer : "no answer retained";
-    if (result.mode !== "page")
+    if (presentation.last === true)
+        return result.kind === "last" ? result.answer : "no answer retained";
+    if (result.kind !== "history")
         throw new Error("history result lacks page");
     const rows = groupedRows(result.history.rows, context, historyLayout());
     const paging = result.history.omitted > 0
@@ -1218,22 +1236,24 @@ export function historyText(command, result, context) {
                 : `${result.history.omitted} earlier events · showing last ${result.history.rows.length}`),
         ]
         : [];
-    return [...snapshotHeading(result.akuma, result.alias, result.historyResult.contract), ...paging, ...rows].join("\n");
-}
-export function tellText(result, context, options = {}) {
-    const wake = result.result.tell.wake;
-    const target = identity(result.result.akuma, result.alias);
-    const row = groupedRows([result.result.tell.row], context, {
+    return [...snapshotHeading(result.id, presentation.alias, result.contract), ...paging, ...rows].join("\n");
+}
+export function tellText(result, alias, context, options = {}) {
+    const wake = result.tell.wake;
+    const target = identity(result.akuma, alias);
+    const glyph = wake.kind === "failed" ? "!" : wake.kind === "held" ? "⧗" : "✓";
+    const verb = wake.kind === "failed" || wake.kind === "held" ? "tell" : "told";
+    const row = groupedRows([result.tell.row], context, {
         ...plainLayout(),
-        head: (time, _glyph, _verb, columns) => eventPrefix(wake.kind === "held" ? "⧗" : "⧖", "tell", time, columns),
+        head: (time, _glyph, _verb, columns) => eventPrefix(glyph, verb, time, columns),
         singleLine: true,
     }).join("\n");
-    const identityLine = options.identity === false ? [] : [target];
+    const heading = options.identity === false ? [] : snapshotHeading(target, undefined, undefined);
     if (wake.kind === "failed") {
         const child = "child" in wake ? wake.child : undefined;
         const failure = `! tell delivery failed · ${safeText(wake.diagnostic)}${child === undefined ? "" : ` · log ${child.log.path} ${child.log.from}..${child.log.to}`}`;
         return [
-            ...identityLine,
+            ...heading,
             row,
             ...renderBoundedTextBlock(failure, {
                 first: "",
@@ -1243,5 +1263,5 @@ export function tellText(result, context, options = {}) {
             }),
         ].join("\n");
     }
-    return [...identityLine, row].join("\n");
+    return [...heading, row].join("\n");
 }