@astrosheep/keiyaku 4.5.19 → 4.5.21

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

@@ -1,26 +1,37 @@
 import { parseAkumaStatus } from "../../akuma/akuma.js";
 import { toolRepr } from "./akuma-tool.js";
-import { displayColumns, renderBoundedTextBlock, safeText, truncateMiddleDisplayText, } from "./terminal.js";
+import { displayColumns, renderBoundedTextBlock, safeText, takeDisplayColumns, truncateMiddleDisplayText, } from "./terminal.js";
 export const DEFAULT_CONTEXT = { columns: 80, color: false };
-const SNAPSHOT_RULER = "────────────────";
 const TIME_WIDTH = 5;
 const VERB_WIDTH = 6;
+/**
+ * The one blessed ruler: a run of U+2500 exactly as wide as the frame head's
+ * widest line, marking the boundary between an observation frame and its content.
+ */
+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;
 function identity(id, alias) {
     return `${id}${alias === undefined ? "" : ` (${alias})`}`;
 }
 function associatedContractId(contract) {
     return contract.kind === "associated" ? contract.contractId : undefined;
 }
-export function associatedIdentity(id, alias, contract) {
-    const contractId = contract === undefined ? undefined : associatedContractId(contract);
-    return `${identity(id, alias)}${contractId === undefined ? "" : ` [${contractId}]`}`;
+export function associatedIdentity(id, alias, _contract) {
+    return identity(id, alias);
 }
 export function snapshotHeading(id, alias, contract) {
     const contractId = contract === undefined ? undefined : associatedContractId(contract);
-    return [identity(id, alias), contractId === undefined ? SNAPSHOT_RULER : `└─ ${contractId}`];
+    const head = [identity(id, alias), ...(contractId === undefined ? [] : [`└─ ${contractId}`])];
+    return [...head, frameRule(head)];
 }
 function answeredHeading(id, alias) {
-    return [`✓ came back ${identity(id, alias)}`, SNAPSHOT_RULER].join("\n");
+    const heading = `✓ came back ${identity(id, alias)}`;
+    return [heading, frameRule([heading])];
 }
 function contractFacts(contract) {
     return contract.kind === "failed" ? [`! contract failed ${safeText(contract.diagnostic)}`] : [];
@@ -30,12 +41,14 @@ function unobservedText(id, diagnostic) {
 }
 function lifeLabel(life) {
     if (life === "running")
-        return "● STILL RUNNING";
+        return "● running";
     if (life === "asleep")
         return "✓ came back";
     if (life === "killed")
-        return "✕ killed";
-    return `? ${life}`;
+        return "× killed";
+    if (life === "hung")
+        return "? hung";
+    return "! stranded";
 }
 function clock(at) {
     const date = new Date(at);
@@ -78,6 +91,18 @@ function mark(row) {
     }
     return "│";
 }
+/** Strip Markdown decoration from preview prose without rewriting the words. */
+function undecorated(text) {
+    return (text
+        .replace(/^ {0,3}#{1,6}[ \t]+/gmu, "")
+        .replace(/^ {0,3}(?:[-*+]|\d+\.)[ \t]+/gmu, "")
+        .replace(/\*\*([^*\n]+?)\*\*/gu, "$1")
+        // A single pair of asterisks is emphasis only when it does not sit inside a word, path, or glob.
+        .replace(/(?<![\w*/\\])\*([^\s*/\\](?:[^*/\\\n]*[^\s*/\\])?)\*(?![\w*/\\])/gu, "$1")
+        .replace(/`([^`\n]+?)`/gu, "$1")
+        .replace(/\s+/gu, " ")
+        .trim());
+}
 function rowText(row) {
     if (row.kind === "said" ||
         row.kind === "thought" ||
@@ -85,13 +110,13 @@ function rowText(row) {
         row.kind === "call" ||
         row.kind === "tell") {
         return {
-            text: row.text,
+            text: undecorated(row.text),
             lines: row.kind === "said" || row.kind === "thought" ? 2 : row.kind === "tell" || row.kind === "call" ? 1 : 2,
         };
     }
     if (row.kind === "outcome")
         return row.outcome.kind === "answered"
-            ? { text: row.outcome.answer, lines: 3 }
+            ? { text: undecorated(row.outcome.answer), lines: 3 }
             : { text: row.outcome.diagnostic, lines: 2 };
     if (row.kind === "turn")
         return { text: "", lines: 1 };
@@ -112,19 +137,41 @@ function eventPrefix(glyph, verb, time) {
 function continuationPrefix() {
     return eventPrefix("│", "");
 }
+/** 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 plainLayout() {
+    return {
+        head: (time, glyph, verb) => eventPrefix(glyph, verb, time),
+        continuation: continuationPrefix,
+        marker: (count) => `${" ".repeat(TIME_WIDTH)} ⋮ ${count} omitted`,
+    };
+}
+function sourceLayout(source, width) {
+    const gutter = () => `${" ".repeat(TIME_WIDTH)} ${padToDisplay(source, width())} `;
+    return {
+        head: (time, glyph, verb) => `${time === undefined ? " ".repeat(TIME_WIDTH) : time.padEnd(TIME_WIDTH)} ${padToDisplay(source, width())} ${glyph} ${verb.padEnd(VERB_WIDTH)} `,
+        // 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`,
+    };
+}
 function quotedBody(row) {
     return (row.kind === "said" ||
         row.kind === "thought" ||
         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 = prefix.length;
+    const prefixWidth = displayColumns(prefix);
     return lines.map((line) => {
-        const body = line.slice(prefixWidth);
+        const { text: head, rest: body } = takeDisplayColumns(line, prefixWidth);
         if (body.length === 0)
             return line;
-        return `${line.slice(0, prefixWidth)}“${body}”`;
+        return `${head}“${body}”`;
     });
 }
 function renderMiddleEllipsis(first, text, suffix, columns) {
@@ -136,7 +183,7 @@ function renderMiddleEllipsis(first, text, suffix, columns) {
     const showSuffix = suffix.length > 0 && withSuffix >= 6;
     return `${first}${truncateMiddleDisplayText(text, Math.max(0, showSuffix ? withSuffix : remaining))}${showSuffix ? suffix : ""}`;
 }
-function renderRow(row, context, history, first) {
+function renderRow(row, context, history, first, continuation) {
     const value = rowText(row);
     const quoted = quotedBody(row);
     const quoteWidth = quoted ? 2 : 0;
@@ -145,37 +192,419 @@ function renderRow(row, context, history, first) {
     }
     const lines = renderBoundedTextBlock(value.text, {
         first,
-        continuation: continuationPrefix(),
+        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 groupedEntries(entries, context, history = false) {
+function groupedEntries(entries, context, history = false, layout = plainLayout()) {
     const lines = [];
     let previousClock;
     for (const entry of entries) {
         if (entry.kind === "gap") {
-            lines.push(`${" ".repeat(TIME_WIDTH)} ⋮ ${entry.count} omitted`);
+            lines.push(layout.marker(entry.count));
             continue;
         }
         const row = entry.row;
         const at = clock(row.at);
         const changed = previousClock === undefined || at !== previousClock;
-        lines.push(...renderRow(row, context, history, eventPrefix(mark(row), label(row), changed ? at : undefined)));
+        lines.push(...renderRow(row, context, history, layout.head(changed ? at : undefined, mark(row), label(row)), layout.continuation()));
         previousClock = at;
     }
     return lines;
 }
-function groupedRows(rows, context, history = false) {
-    return groupedEntries(rows.filter((row) => row.kind !== "turn").map((row) => ({ kind: "row", row })), context, history);
+function groupedRows(rows, context, history = false, layout = plainLayout()) {
+    return groupedEntries(rows.filter((row) => row.kind !== "turn").map((row) => ({ kind: "row", row })), context, history, layout);
+}
+/** Ordered entry stream of one retained snapshot; an idle outcome keeps its sequence position. */
+function orderedSnapshotEntries(snapshot) {
+    if (snapshot.kind !== "idle" || snapshot.outcome === undefined)
+        return snapshot.entries;
+    const entries = [];
+    let outcomeInserted = false;
+    for (const entry of snapshot.entries) {
+        if (!outcomeInserted && entry.kind === "row" && entry.row.sequence > snapshot.outcome.sequence) {
+            entries.push({ kind: "row", row: snapshot.outcome });
+            outcomeInserted = true;
+        }
+        entries.push(entry);
+    }
+    if (!outcomeInserted)
+        entries.push({ kind: "row", row: snapshot.outcome });
+    return entries;
+}
+/**
+ * Focus one complete snapshot without making its provider-side gaps mean more
+ * than they do. Thought rows disappear; known tool rows use the same opening
+ * and recent budgets as live activity, while every other row keeps its place.
+ */
+function focusedSnapshotEntries(entries) {
+    const tools = entries.filter((entry) => entry.kind === "row" && entry.row.kind === "tool");
+    const focused = [];
+    let toolIndex = 0;
+    let omittedTools = 0;
+    const flushOmittedTools = () => {
+        if (omittedTools > 0)
+            focused.push({ kind: "gap", count: omittedTools });
+        omittedTools = 0;
+    };
+    for (const entry of entries) {
+        if (entry.kind === "row" && entry.row.kind === "thought")
+            continue;
+        if (entry.kind !== "row" || entry.row.kind !== "tool") {
+            flushOmittedTools();
+            focused.push(entry);
+            continue;
+        }
+        const keep = toolIndex < OPENING_TOOL_BUDGET || toolIndex >= tools.length - RECENT_TOOL_BUDGET;
+        toolIndex += 1;
+        if (keep)
+            flushOmittedTools();
+        else
+            omittedTools += 1;
+        if (keep)
+            focused.push(entry);
+    }
+    flushOmittedTools();
+    return focused;
+}
+/**
+ * Shared snapshot activity rendering. Full snapshots focus known tool evidence;
+ * `latest` preserves compact callers' established newest-entry selection.
+ */
+export function snapshotActivityLines(snapshot, context, selection = {}) {
+    const entries = orderedSnapshotEntries(snapshot);
+    if (selection.latest !== true)
+        return groupedEntries(focusedSnapshotEntries(entries), context);
+    const latest = entries.filter((entry) => entry.kind === "row").at(-1);
+    return latest === undefined ? [] : groupedEntries([latest], context);
+}
+/**
+ * One status' timeline without its conclusion: the newest open entry is still
+ * moving, and an idle outcome is the command's final result rather than a
+ * settled row.
+ */
+function settledTimeline(snapshot) {
+    switch (snapshot.kind) {
+        case "unborn":
+            return snapshot;
+        case "open":
+            return { ...snapshot, entries: snapshot.entries.slice(0, -1) };
+        case "idle": {
+            const { outcome: _outcome, ...rest } = snapshot;
+            return { ...rest, entries: snapshot.entries };
+        }
+    }
+}
+function settledRows(snapshot) {
+    return orderedSnapshotEntries(settledTimeline(snapshot)).flatMap((entry) => entry.kind === "row" ? [entry.row] : []);
+}
+function renderStreamRow(state, row, lines, context, layout) {
+    const at = clock(row.at);
+    const changed = state.previousClock === undefined || at !== state.previousClock;
+    lines.push(...renderRow(row, context, false, layout.head(changed ? at : undefined, mark(row), label(row)), layout.continuation()));
+    state.previousClock = at;
+}
+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" && entry.row.kind === "tool");
+    if (index === -1)
+        throw new Error("activity tail lost its pending tool");
+    state.deferred[index] = { kind: "gap", count: 1 };
+    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" && first.row.kind === "tool"))
+            return;
+        if (first.kind === "row") {
+            state.deferred.shift();
+            renderStreamRow(state, first.row, lines, context, layout);
+            continue;
+        }
+        const next = state.deferred[1];
+        if (next === undefined || (next.kind === "row" && next.row.kind === "tool"))
+            return;
+        state.deferred.shift();
+        lines.push(layout.marker(first.count));
+    }
+}
+function observeActivitySnapshot(state, snapshot, context, layout) {
+    const rows = settledRows(snapshot)
+        .filter((row) => state.newestSequence === undefined || row.sequence > state.newestSequence)
+        // Thoughts remain retained activity, but are ineligible for default live progress.
+        .filter((row) => row.kind !== "thought");
+    if (rows.length === 0)
+        return [];
+    state.newestSequence = rows.reduce((newest, row) => Math.max(newest, row.sequence), state.newestSequence ?? rows[0].sequence);
+    const lines = [];
+    for (const row of rows) {
+        if (row.kind === "tool" && state.openingTools < OPENING_TOOL_BUDGET) {
+            state.openingTools += 1;
+            renderStreamRow(state, row, lines, context, layout);
+            continue;
+        }
+        if (row.kind !== "tool" && state.deferred.length === 0) {
+            renderStreamRow(state, row, lines, context, layout);
+            continue;
+        }
+        state.deferred.push({ kind: "row", row });
+        if (row.kind === "tool") {
+            const pendingTools = state.deferred.filter((entry) => entry.kind === "row" && entry.row.kind === "tool").length;
+            if (pendingTools > RECENT_TOOL_BUDGET)
+                omitOldestDeferredTool(state);
+        }
+        flushSafeActivityPrefix(state, lines, context, layout);
+    }
+    return lines;
+}
+function flushActivityTail(state, context, layout) {
+    const lines = [];
+    for (const entry of state.deferred) {
+        if (entry.kind === "gap")
+            lines.push(layout.marker(entry.count));
+        else
+            renderStreamRow(state, entry.row, lines, context, layout);
+    }
+    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
+ * 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.
+ */
+export function activityStream(context, layout = plainLayout()) {
+    const state = {
+        newestSequence: undefined,
+        previousClock: undefined,
+        openingTools: 0,
+        deferred: [],
+    };
+    const seed = (snapshot) => {
+        const rows = settledRows(snapshot);
+        if (rows.length > 0)
+            state.newestSequence = rows.reduce((newest, row) => Math.max(newest, row.sequence), rows[0].sequence);
+    };
+    const observe = (snapshot) => observeActivitySnapshot(state, snapshot, context, layout);
+    const flush = () => flushActivityTail(state, context, layout);
+    return Object.assign(observe, { seed, flush });
+}
+function conclusionMarkVerb(status, answered) {
+    if (status.life === "running")
+        return { mark: "●", verb: "still running", waited: true };
+    if (answered)
+        return { mark: "✓", verb: "answered", waited: false };
+    if (status.life === "asleep")
+        return { mark: "!", verb: "failed", waited: false };
+    if (status.life === "killed")
+        return { mark: "×", verb: "killed", waited: false };
+    if (status.life === "hung")
+        return { mark: "?", verb: "hung", waited: false };
+    if (status.life === "untidy")
+        return { mark: "!", verb: "untidy", waited: false };
+    return { mark: "!", verb: "stranded", waited: false };
+}
+/**
+ * The durable moment an Akuma settled, read from the outcome row its own timeline
+ * retained. Absent for an ending that leaves no outcome row, so the caller falls
+ * back to the observation that noticed it.
+ */
+function settleMoment(status) {
+    const outcome = status.timeline.kind === "idle" ? status.timeline.outcome : undefined;
+    if (outcome === undefined)
+        return undefined;
+    const at = new Date(outcome.at).getTime();
+    return Number.isFinite(at) ? at : undefined;
+}
+function clockFromMs(at) {
+    return clock(new Date(at).toISOString());
+}
+function durationText(durationMs) {
+    const seconds = Math.max(0, Math.round(durationMs / 1000));
+    if (seconds < 60)
+        return `${seconds}s`;
+    return `${Math.floor(seconds / 60)}m${String(seconds % 60)}s`;
+}
+function createWaitObservationState() {
+    return {
+        streams: new Map(),
+        attributed: new Map(),
+        sources: new Map(),
+        settledAt: new Map(),
+        sourceWidth: 0,
+        opened: false,
+        observed: false,
+    };
+}
+function registerWaitSource(state, id, alias) {
+    if (state.sources.has(id))
+        return;
+    const label = alias ?? id;
+    state.sources.set(id, label);
+    state.sourceWidth = Math.max(state.sourceWidth, displayColumns(label));
+}
+function observeWaitRound(state, round, context, now) {
+    state.observed = true;
+    // Establish the whole round's sources before any row so widths stay aligned within it.
+    for (const member of round)
+        registerWaitSource(state, member.status.id, member.alias);
+    const lines = [];
+    for (const { status, alias, contract } of round) {
+        const known = state.streams.get(status.id);
+        if (known === undefined) {
+            if (state.opened)
+                lines.push("");
+            lines.push(...snapshotHeading(status.id, alias, contract));
+            state.opened = true;
+            state.attributed.set(status.id, alias);
+            // Only a plural wait attributes its rows; a single-target stream keeps the plain row grammar.
+            const stream = activityStream(context, state.sources.size > 1
+                ? sourceLayout(state.sources.get(status.id) ?? status.id, () => state.sourceWidth)
+                : plainLayout());
+            state.streams.set(status.id, stream);
+            // A wait starts at the current settled frontier: its backlog is neither evidence nor budget.
+            stream.seed(status.timeline);
+        }
+        else {
+            lines.push(...known(status.timeline));
+        }
+        if (!state.settledAt.has(status.id) && waitComplete(status))
+            state.settledAt.set(status.id, settleMoment(status) ?? now());
+    }
+    return lines;
+}
+function concludeWaitStream(state, result, startedAt, now) {
+    const tail = [];
+    // The returned observation can be newer than the final callback. Advance every known stream
+    // before flushing it, while still flushing members that became unobserved at the end.
+    for (const observation of result.observations) {
+        const stream = state.streams.get(observation.status.id);
+        if (stream !== undefined)
+            tail.push(...stream(observation.status.timeline));
+    }
+    for (const stream of state.streams.values())
+        tail.push(...stream.flush());
+    const end = now();
+    const total = result.observations.length + result.unobserved.length;
+    const multi = total > 1;
+    const conclusions = result.observations.map((observation) => {
+        const status = observation.status;
+        const answered = statusAnswer(observation) !== undefined;
+        const complete = waitComplete(status);
+        const at = complete ? (state.settledAt.get(status.id) ?? end) : end;
+        const durationMs = Math.max(0, at - startedAt);
+        const { mark, verb, waited } = conclusionMarkVerb(status, answered);
+        const target = multi ? ` ${padToDisplay(state.sources.get(status.id) ?? status.id, state.sourceWidth)}` : "";
+        return `${clockFromMs(at)}${target} ${mark} ${verb} — ${waited ? "waited " : ""}${durationText(durationMs)}`;
+    });
+    const unobservedLines = result.unobserved.map((member) => unobservedText(member.id, member.diagnostic));
+    const answeredSingle = !multi && result.observations.length === 1 && statusAnswer(result.observations[0]) !== undefined;
+    const blocks = [
+        ...(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.
+    return answeredSingle ? `${body}\n\n` : body;
+}
+/**
+ * Live view over a wait's successive observation rounds, one append-only
+ * stream per selected Akuma. Each Akuma's stream opens with its identity frame
+ * — the identity and Contract association the observed facts carry — before any
+ * row; an already settled Akuma prints that frame and never replays backlog
+ * rows. `conclude` renders the closing rows once the wait ends: one row per
+ * observed Akuma in `<clock> <mark> <verb> — <duration>` grammar, with a target
+ * named for a multi-target scoreboard and no activity replay.
+ */
+export function waitObservationStream(context, options = {}) {
+    const now = options.now ?? (() => Date.now());
+    const startedAt = now();
+    const state = createWaitObservationState();
+    const select = (selected) => {
+        for (const member of selected)
+            registerWaitSource(state, member.id, member.alias);
+    };
+    const observe = (round) => observeWaitRound(state, round, context, now);
+    const conclude = (result) => concludeWaitStream(state, result, startedAt, now);
+    return { select, observe, conclude, streamed: () => state.observed };
+}
+function failedOutcomeDiagnostic(status) {
+    const outcome = status.timeline.kind === "idle" ? status.timeline.outcome : undefined;
+    return outcome !== undefined && outcome.outcome.kind === "failed" ? outcome.outcome.diagnostic : undefined;
+}
+/**
+ * Live view over one observing call: its identity frame and birth diagnostics
+ * open the stream once, settled rows follow as they arrive, and the return
+ * appends one conclusion in single-target wait grammar. The stream never
+ * replays its own activity as a final snapshot, and it never carries the
+ * birth receipt's cwd row.
+ */
+export function callObservationStream(context, head, options = {}) {
+    const now = options.now ?? (() => Date.now());
+    const startedAt = now();
+    const stream = activityStream(context);
+    let opened = false;
+    const open = (lines) => {
+        if (opened)
+            return;
+        opened = true;
+        lines.push(...snapshotHeading(head.id, head.alias, head.contract), ...head.facts);
+    };
+    const observe = (status) => {
+        const lines = [];
+        open(lines);
+        lines.push(...stream(status.timeline));
+        return lines;
+    };
+    const conclude = (observation) => {
+        const lines = [];
+        open(lines);
+        if (observation.kind === "observed")
+            lines.push(...stream(observation.status.timeline));
+        lines.push(...stream.flush());
+        if (observation.kind === "failed") {
+            lines.push(`! error ${safeText(observation.failure.diagnostic)}`);
+            return lines.join("\n");
+        }
+        if (observation.kind !== "observed")
+            return lines.join("\n");
+        const end = now();
+        const status = observation.status;
+        const answered = statusAnswer({ status }) !== undefined;
+        const at = waitComplete(status) ? (settleMoment(status) ?? end) : end;
+        const durationMs = Math.max(0, at - startedAt);
+        const { mark, verb, waited } = conclusionMarkVerb(status, answered);
+        lines.push(`${clockFromMs(at)} ${mark} ${verb} — ${waited ? "waited " : ""}${durationText(durationMs)}`);
+        const failure = failedOutcomeDiagnostic(status);
+        if (failure !== undefined)
+            lines.push(`! error ${safeText(failure)}`);
+        return lines.join("\n");
+    };
+    return { observe, conclude, opened: () => opened };
 }
 function taskDispositionMark(disposition) {
     if (disposition === "done")
         return "✓";
     if (disposition === "drop")
-        return "✕";
+        return "×";
     if (disposition === "on_hold")
         return "⧗";
     if (disposition === "in_progress")
@@ -186,6 +615,8 @@ 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);
     return [
         `changes ${snapshot.reportedChanges.length + snapshot.reportedChangesOmitted}`,
@@ -211,6 +642,8 @@ function renderTaskContextLines(created, columns) {
         return [];
     if (created.kind === "failed")
         return [`! tasks failed ${safeText(created.diagnostic)}`];
+    if (created.rows.length === 0)
+        return [];
     return [`tasks ${created.rows.length}`, ...created.rows.flatMap((row) => renderTaskRow(row, columns))];
 }
 function answerContextLines(observation, columns) {
@@ -220,21 +653,17 @@ function answerContextLines(observation, columns) {
     ];
 }
 function answeredBlock(observation, answer, alias, columns) {
+    const frame = answeredHeading(observation.status.id, alias).join("\n");
     const context = answerContextLines(observation, columns).join("\n");
     if (context.length === 0)
-        return `${answeredHeading(observation.status.id, alias)}\n${answer}`;
+        return `${frame}\n${answer}`;
     const separator = answer.endsWith("\n") ? "\n" : "\n\n";
-    return `${answeredHeading(observation.status.id, alias)}\n${answer}${separator}${context}`;
+    return `${frame}\n${answer}${separator}${context}`;
 }
 function snapshotCore(view, context, options) {
-    const snapshot = view.status.timeline;
-    const activity = snapshot.kind === "idle" && snapshot.outcome !== undefined
-        ? groupedRows([
-            ...snapshot.entries.filter((entry) => entry.kind === "row").map((entry) => entry.row),
-            snapshot.outcome,
-        ].sort((left, right) => left.sequence - right.sequence), context)
-        : groupedEntries(snapshot.entries, context);
+    const activity = snapshotActivityLines(view.status.timeline, context);
     const facts = [
+        ...(options.showAllowed === true ? [`allowed  ${view.status.allowed.join(", ") || "none"}`] : []),
         ...(view.status.readonly?.enforcement === "none" ? [`! ${safeText(view.status.readonly.diagnostic)}`] : []),
         ...contractFacts(view.contract),
         ...(options.facts ?? []),
@@ -298,12 +727,26 @@ function answerCallFailed(result) {
 }
 export function akumaRawAnswer(result) {
     if (result.action === "call") {
+        if (result.streamed === true) {
+            // A streamed call's stdout is its answer or nothing; diagnostics belong to stderr.
+            if (answerCallFailed(result.result) || result.result.observation.kind !== "observed")
+                return "";
+            return statusAnswer({ status: parseAkumaStatus(result.result.observation.status) }) ?? "";
+        }
         if (answerCallFailed(result.result) || result.result.observation.kind !== "observed")
             return undefined;
         return statusAnswer({ status: parseAkumaStatus(result.result.observation.status) });
     }
-    if (result.action === "wait" && result.result.observations.length === 1)
-        return statusAnswer(result.result.observations[0]);
+    if (result.action === "wait") {
+        if (result.streamed === true) {
+            // Plural waits leave stdout empty so one answer can never be mistaken for the whole result.
+            const total = result.result.observations.length + result.result.unobserved.length;
+            const single = total === 1 ? result.result.observations[0] : undefined;
+            return single === undefined ? "" : (statusAnswer(single) ?? "");
+        }
+        if (result.result.observations.length === 1)
+            return statusAnswer(result.result.observations[0]);
+    }
     if (result.action === "history" && result.mode === "exact" && result.historyResult.kind === "exact") {
         return result.historyResult.outcome.outcome.kind === "answered"
             ? result.historyResult.outcome.outcome.answer
@@ -339,10 +782,11 @@ export function historyText(command, result, context) {
         return result.mode === "last" ? result.answer : "no answer retained";
     if (result.mode !== "page")
         throw new Error("history result lacks page");
-    return [
-        ...snapshotHeading(result.akuma, result.alias, result.historyResult.contract),
-        ...groupedRows(result.history.rows, context, true),
-    ].join("\n");
+    const rows = groupedRows(result.history.rows, context, true);
+    const paging = result.history.omitted > 0
+        ? [`  ⋮ ${result.history.omitted} earlier turns · showing last ${result.history.rows.length}`]
+        : [];
+    return [...snapshotHeading(result.akuma, result.alias, result.historyResult.contract), ...paging, ...rows].join("\n");
 }
 export function tellText(result, context) {
     const wake = result.result.tell.wake;
@@ -350,7 +794,8 @@ export function tellText(result, context) {
     const row = groupedRows([result.result.tell.row], context).join("\n");
     if (wake.kind === "failed") {
         const child = "child" in wake ? wake.child : undefined;
-        return `${target}\n${SNAPSHOT_RULER}\n${row}\n! tell delivery failed · ${safeText(wake.diagnostic)}${child === undefined ? "" : ` · log ${child.log.path} ${child.log.from}..${child.log.to}`}`;
+        const failure = `! tell delivery failed · ${safeText(wake.diagnostic)}${child === undefined ? "" : ` · log ${child.log.path} ${child.log.from}..${child.log.to}`}`;
+        return `${target}\n${row}\n${renderBoundedTextBlock(failure, { first: "", continuation: "  ", columns: context.columns, lines: Number.MAX_SAFE_INTEGER }).join("\n")}`;
     }
-    return `${target}\n${SNAPSHOT_RULER}\n${row}`;
+    return `${target}\n${row}`;
 }