@astrosheep/keiyaku 4.6.14 → 4.6.16

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

@@ -1,10 +1,21 @@
 import { defaultWaitComplete } from "../../akuma/akuma-observe.js";
 import { renderDiffstat, toolContent, toolRepr } from "./akuma-tool.js";
+import { dispositionText } from "./debt.js";
 import { debtDispositionMark } 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;
+/** The action family's fixed 3-cell state margin and minimum verb cell. */
+const ACTION_MARGIN = "   ";
+const ACTION_VERB_WIDTH = 6;
+/** Top-level rows: one mark plus its separator, and two spaces beneath it. */
+const TOP_SPEAK = "▎ ";
+const TOP_INPUT = "▸ ";
+const TOP_PENDING = "⧗ ";
+const TOP_ANSWER = "✓ ";
+const TOP_FAILURE = "! ";
+const TOP_CONTINUATION = "  ";
+/** The one row-omission glyph, in verb position. */
+const OMISSION = "···";
 /**
  * The one blessed ruler: a run of U+2500 as wide as the frame head's widest line,
  * never wider than the terminal, marking the boundary between an observation
@@ -56,47 +67,13 @@ export function actionReceipt(input) {
 function contractFacts(contract) {
     return contract.kind === "failed" ? [`! contract failed ${safeText(contract.diagnostic)}`] : [];
 }
-function unobservedText(id, diagnostic) {
-    return `× Akuma observation failed  ${safeText(id)} — ${safeText(diagnostic)}`;
-}
-function clock(at) {
-    const date = new Date(at);
-    return Number.isFinite(date.getTime())
-        ? `${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}`
-        : "unknown";
-}
-function label(row, tool) {
-    if (row.kind === "said")
-        return "";
-    if (row.kind === "thought")
-        return "think";
-    if (row.kind === "note")
-        return "note";
-    if (row.kind === "call")
-        return "call";
-    if (row.kind === "tell")
-        return row.state === "told" ? "told" : "tell";
-    if (row.kind === "outcome")
-        return row.outcome.kind === "answered" ? "answer" : "error";
-    if (row.kind === "turn")
-        return "call";
-    if (row.kind !== "tool")
-        return row.kind;
-    return tool.label;
-}
-function mark(row, live = false) {
-    if (row.kind === "outcome")
-        return row.outcome.kind === "answered" ? "✓" : "!";
-    if (row.kind === "tell" && row.state === "pending")
-        return "⧗";
-    if (row.kind === "tool") {
-        if (row.state === "active")
-            return live ? "●" : "?";
-        if (row.state === "unsettled")
-            return "?";
-        return row.state.status === "ok" ? "✓" : "!";
-    }
-    return "│";
+/** The action family's one mark cell: a settled success stays blank, and live is only a frame mark. */
+function toolMargin(row, live) {
+    if (row.state === "active")
+        return live ? "●  " : "?  ";
+    if (row.state === "unsettled")
+        return "?  ";
+    return row.state.status === "ok" ? ACTION_MARGIN : "!  ";
 }
 function rowText(row, tool) {
     if (row.kind === "said" ||
@@ -126,48 +103,30 @@ function rowText(row, tool) {
         ...(repr.suffix === undefined ? {} : { suffix: repr.suffix }),
     };
 }
-function eventPrefix(glyph, verb, time, columns) {
-    const gutter = time === undefined ? " ".repeat(TIME_WIDTH) : time.padEnd(TIME_WIDTH);
-    return actionCell(`${gutter} ${glyph}`, verb, columns);
-}
-/** The action column one row spends: six cells by default, or the name's own width when longer. */
-function verbColumn(verb) {
-    return Math.max(VERB_WIDTH, displayColumns(verb));
-}
 /**
- * Attach the action cell after one row prefix. A name wider than the row's
- * remaining columns truncates grapheme-safely, spending every column the row
- * leaves after the separator so an exact-fit name stays whole and args trim first.
+ * The action family's one prefix: a state margin, a verb cell at least six cells wide and as wide as a
+ * longer name, then one space. Continuation lines align with the actual content start.
  */
-function actionCell(head, verb, columns) {
-    const prefix = `${head} `;
-    if (verb === "")
-        return prefix;
-    const available = Math.max(0, columns - displayColumns(prefix) - 1);
-    const width = Math.min(verbColumn(verb), available);
-    return `${prefix}${padToDisplay(truncateDisplayText(verb, width), width)} `;
-}
-function continuationPrefix(verb) {
-    return " ".repeat(TIME_WIDTH) + " │ " + (verb === "" ? "" : " ".repeat(VERB_WIDTH + 1));
-}
-function timelineMarker(text) {
-    return `${" ".repeat(TIME_WIDTH)} ⋮ ${text}`;
-}
-function plainLayout() {
-    return {
-        head: (time, glyph, verb, columns) => eventPrefix(glyph, verb, time, columns),
-        continuation: continuationPrefix,
-        marker: (count) => timelineMarker(`${count} omitted`),
-    };
-}
-function compactLayout() {
-    return { ...plainLayout(), compactRun: true };
-}
-function historyLayout() {
-    return { ...compactLayout(), history: true };
-}
-function quotedBody(row) {
-    return row.kind === "thought" || row.kind === "tell" || (row.kind === "outcome" && row.outcome.kind === "answered");
+function actionPrefix(margin, verb, columns) {
+    const available = Math.max(0, columns - displayColumns(margin) - 1);
+    const width = Math.min(Math.max(ACTION_VERB_WIDTH, displayColumns(verb)), available);
+    const label = truncateDisplayText(verb, width);
+    return { first: `${margin}${padToDisplay(label, width)} `, continuation: `${margin}${" ".repeat(width + 1)}` };
+}
+function rowPrefix(row, tool, columns, view) {
+    if (row.kind === "tool")
+        return actionPrefix(toolMargin(row, view.live === true), tool.label, columns);
+    if (row.kind === "thought")
+        return actionPrefix(ACTION_MARGIN, "think", columns);
+    if (row.kind === "note")
+        return actionPrefix(ACTION_MARGIN, "note", columns);
+    if (row.kind === "outcome")
+        return { first: row.outcome.kind === "answered" ? TOP_ANSWER : TOP_FAILURE, continuation: TOP_CONTINUATION };
+    if (row.kind === "said")
+        return { first: TOP_SPEAK, continuation: TOP_SPEAK };
+    if (row.kind === "tell" && row.state === "pending")
+        return { first: TOP_PENDING, continuation: TOP_CONTINUATION };
+    return { first: TOP_INPUT, continuation: TOP_CONTINUATION };
 }
 function pathTail(path, maximum) {
     if (displayColumns(path) <= maximum)
@@ -230,6 +189,9 @@ function renderRunCommand(first, continuation, text, suffix, columns) {
     const tail = takeDisplayColumnsFromEnd(command, tailBudget).text;
     return [`${first}$ ${head}…`, `${continuation}…${tail}${keptSuffix}`];
 }
+function omissionMarker(text, columns) {
+    return `${actionPrefix(ACTION_MARGIN, OMISSION, columns).first}${text}`;
+}
 function rowBody(row, text, columns) {
     if (row.kind !== "tool" || row.call.kind !== "other")
         return text;
@@ -237,84 +199,60 @@ function rowBody(row, text, columns) {
 }
 function tailAnswerPreview(first, text, columns) {
     const readable = safeText(text).replace(/\s+/gu, " ").trim();
-    const budget = Math.max(0, columns - displayColumns(first + "“”"));
+    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}”`];
+    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);
+function renderCommandOverflow(first, continuation, value, columns, view) {
     const suffix = value.suffix ?? "";
+    if (view.compact !== true && view.history !== true)
+        return renderRunCommand(first, continuation, value.text, suffix, columns);
+    const remaining = columns - displayColumns(first);
     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 } = options;
+/** Every selected timeline row renders through here: one prefix family per row class. */
+function renderRow(row, context, view = {}) {
+    const tool = row.kind === "tool" ? toolRepr(row) : undefined;
     const value = rowText(row, tool);
-    const overflow = toolOverflowPreview(options, value, context.columns);
-    if (overflow !== undefined)
-        return overflow;
+    const { first, continuation } = rowPrefix(row, tool, context.columns, view);
+    const compact = view.compact === true;
+    if (tool?.overflow === "command")
+        return renderCommandOverflow(first, continuation, value, context.columns, view);
     if (tool?.pathPreview !== undefined)
         return [renderPathPreview(first, value.text, tool.pathPreview, context.columns)];
-    if (layout.tailAnswer === true && row.kind === "outcome" && row.outcome.kind === "answered")
+    if (view.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 ?? "");
+    const singleLine = compact || row.kind === "call" || row.kind === "tell" || row.kind === "turn";
     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 ? '"' : "“") : "",
+        maxLines: singleLine ? 1 : view.history === true ? Number.MAX_SAFE_INTEGER : value.lines,
+        quote: "",
         truncated: "truncated" in row && row.truncated === true,
+        ...(singleLine || row.kind === "tool" ? {} : { preserveLines: true }),
     });
 }
-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);
-    const verb = label(row, tool);
-    return renderRow(row, context, {
-        layout,
-        first: layout.head(time, glyph, verb, context.columns),
-        continuation: layout.continuation(verb),
-        tool,
-    });
-}
-function groupedEntries(entries, context, layout = plainLayout(), options = {}) {
+function groupedEntries(entries, context, view = {}) {
     const lines = [];
-    let previousClock;
     for (const entry of entries) {
         if (entry.kind === "gap") {
-            lines.push(layout.marker(entry.count));
+            lines.push(omissionMarker(`${entry.count} omitted`, context.columns));
             continue;
         }
-        const row = entry.row;
-        const at = clock(row.at);
-        const changed = previousClock === undefined || at !== previousClock;
-        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;
+        lines.push(...renderRow(entry.row, context, view));
     }
     return lines;
 }
-function groupedRows(rows, context, layout = plainLayout()) {
-    return groupedEntries(rows.filter((row) => row.kind !== "turn").map((row) => ({ kind: "row", row })), context, layout);
+function groupedRows(rows, context, view = {}) {
+    return groupedEntries(rows.filter((row) => row.kind !== "turn").map((row) => ({ kind: "row", row })), context, view);
 }
 /** Ordered entry stream of one retained snapshot; an idle outcome keeps its sequence position. */
 function orderedSnapshotEntries(snapshot) {
@@ -377,7 +315,7 @@ export function snapshotActivityLines(snapshot, context, selection = {}) {
     return latest === undefined
         ? []
         : groupedEntries([latest], context, {
-            ...compactLayout(),
+            compact: true,
             ...(selection.tailAnswer === true ? { tailAnswer: true } : {}),
         });
 }
@@ -412,16 +350,6 @@ function rememberPendingTells(state, activity) {
 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, unsettled = false } = options;
-    const at = clock(row.at);
-    const changed = state.previousClock === undefined || at !== state.previousClock;
-    lines.push(...renderTimelineRow(row, context, layout, changed ? at : undefined, {
-        inFlightSay,
-        unsettled,
-    }));
-    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.
@@ -511,37 +439,21 @@ function observeActivitySnapshot(state, activity) {
         }
         else if (row.kind === "said" || row.kind === "tell")
             state.checkpointTools = 0;
-        emitRow(state, emissions, { kind: "row", row, inFlightSay: inFlightSay(activity, row) });
+        emitRow(state, emissions, { kind: "row", row });
     }
     return emissions;
 }
-function renderEmissions(state, emissions, context, layout) {
-    const lines = [];
-    for (const emission of emissions) {
-        if (emission.kind === "gap")
-            lines.push(layout.marker(emission.count));
-        else
-            renderStreamRow(state, emission.row, lines, {
-                context,
-                layout,
-                ...(emission.inFlightSay === undefined ? {} : { inFlightSay: emission.inFlightSay }),
-                ...(emission.unsettled === undefined ? {} : { unsettled: emission.unsettled }),
-            });
-    }
-    return lines;
-}
 /**
  * Append-only live view over one command's successive settled snapshots.
  * After each say or Tell, the first three tools print as they settle; later
  * tools until the next checkpoint fold into one omission marker. Failed tools
  * always print.
  */
-export function activityStream(context, layout = plainLayout()) {
+export function activityStream(context) {
     const state = {
         newestSettledSequence: undefined,
         admissionSequence: undefined,
         pendingTellSequences: new Set(),
-        previousClock: undefined,
         renderedBoundaries: new Set(),
         admittedTellSequences: new Set(),
         checkpointTools: 0,
@@ -587,15 +499,15 @@ export function activityStream(context, layout = plainLayout()) {
         state.omitted = 0;
         for (const row of [...state.liveRows.values()].sort((left, right) => left.sequence - right.sequence)) {
             const unresolved = row.kind === "tool" && row.state === "active" ? { ...row, state: "unsettled" } : row;
-            emissions.push({ kind: "row", row: unresolved, unsettled: true });
+            emissions.push({ kind: "row", row: unresolved });
         }
         state.liveRows.clear();
         return emissions;
     };
-    const render = (emissions) => renderEmissions(state, emissions, context, layout);
+    const render = (emissions) => groupedEntries(emissions, context);
     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" });
+        .map((row) => ({ kind: "row", row })), context, { live: true });
     const observe = (activity) => render(observeActivitySnapshot(state, activity));
     return Object.assign(observe, {
         seed: (activity, alreadyRenderedSequence) => render(seed(activity, alreadyRenderedSequence)),
@@ -627,9 +539,6 @@ function conclusionMarkVerb(status, outcome) {
         return { mark: "!", verb: "untidy" };
     return { mark: "!", verb: "stranded" };
 }
-function clockFromMs(at) {
-    return clock(new Date(at).toISOString());
-}
 function durationText(durationMs) {
     const seconds = Math.max(0, Math.round(durationMs / 1000));
     if (seconds < 60)
@@ -637,20 +546,17 @@ function durationText(durationMs) {
     return `${Math.floor(seconds / 60)}m${String(seconds % 60)}s`;
 }
 /**
- * A conclusion clause asserts real waiting: a target that settled at or after
- * this wait began keeps its duration, a target already settled names no
- * duration, and an unfinished target carries the elapsed wait.
+ * One wait-style conclusion for every observer of an input-bound Tell. A target
+ * that settled at or after this wait began keeps its duration, a target already
+ * settled names no duration, and an unfinished target carries the elapsed wait.
  */
-function conclusionClause(at, startedAt, complete, end) {
-    if (!complete)
-        return ` — waited ${durationText(Math.max(0, end - startedAt))}`;
-    return at >= startedAt ? ` — ${durationText(Math.max(0, at - startedAt))}` : "";
-}
-/** One wait-style conclusion for every observer of an input-bound Tell. */
 function waitConclusionRow(input) {
-    const time = input.at === undefined ? "unknown" : clockFromMs(input.at);
-    const duration = input.at === undefined ? "" : conclusionClause(input.at, input.startedAt, input.complete, input.end);
-    return `${time}${input.target ?? ""} ${input.mark} ${input.verb}${duration}`;
+    const duration = input.complete
+        ? input.at !== undefined && input.at >= input.startedAt
+            ? ` — ${durationText(Math.max(0, input.at - input.startedAt))}`
+            : ""
+        : ` — waited ${durationText(Math.max(0, input.end - input.startedAt))}`;
+    return `${input.mark} ${input.verb}${duration}`;
 }
 export function inputWaitConclusion(observation, input) {
     const end = input.now ?? Date.now();
@@ -673,7 +579,7 @@ export function inputWaitConclusion(observation, input) {
             ...conclusion,
         }),
         ...(observation.reason === "failed" || observation.reason === "invalid-output"
-            ? [`! error ${safeText(observation.diagnostic)}`]
+            ? [`! ${safeText(observation.diagnostic)}`]
             : []),
     ];
 }
@@ -741,7 +647,7 @@ export function inputWaitStream(context, head, options) {
             lines.push(...result.evidence);
         lines.push(...activity.flush());
         if (result.kind === "failed")
-            lines.push(`! error ${safeText(result.diagnostic)}`);
+            lines.push(`! ${safeText(result.diagnostic)}`);
         else
             lines.push(...inputWaitConclusion(result.observation, {
                 startedAt,
@@ -798,12 +704,12 @@ function renderReportedChangeLines(snapshot) {
     return [
         `changes ${snapshot.reportedChanges.length + snapshot.reportedChangesOmitted}`,
         ...snapshot.reportedChanges.map((change) => `  ${renderDiffstat(change.diffstat).padEnd(width)}  ${safeText(change.path)}`),
-        ...(snapshot.reportedChangesOmitted > 0 ? [`  ⋮ ${snapshot.reportedChangesOmitted} more files`] : []),
+        ...(snapshot.reportedChangesOmitted > 0 ? [`  ${OMISSION} ${snapshot.reportedChangesOmitted} more files`] : []),
     ];
 }
 function renderDebtRow(row, columns) {
     const prefix = `  ${debtDispositionMark(row.disposition)} ${row.id} · `;
-    const body = `${safeText(row.title)} · ${row.disposition} · P${row.priority}`;
+    const body = `${safeText(row.title)} · ${dispositionText(row.disposition)} · P${row.priority}`;
     const inline = `${prefix}${body}`;
     if (displayColumns(inline) <= columns)
         return [inline];
@@ -839,13 +745,12 @@ function snapshotCore(view, context, options) {
 }
 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.
+    // The outcome row (`✓` / `!`) 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}`;
+    return `${mark} ${verb}`;
 }
 export function snapshotText(view, context, options = {}) {
     const core = snapshotCore(view, context, options);
@@ -900,17 +805,69 @@ export function historyRawAnswer(result, historyId) {
     const outcome = result.outcome.outcome;
     return outcome.kind === "answered" ? outcome.answer : outcome.diagnostic;
 }
+/** One compact wait result line: an observed life mark, the complete identity, a bounded summary. */
+const WAIT_SUMMARY_SEPARATOR = " — ";
+const WAIT_LIFE = {
+    running: { mark: "●", state: "running" },
+    killed: { mark: "×", state: "killed" },
+    hung: { mark: "?", state: "hung" },
+    untidy: { mark: "!", state: "untidy" },
+    stranded: { mark: "!", state: "stranded" },
+};
+function foldedSummary(value) {
+    return safeText(value).replace(/\s+/gu, " ").trim();
+}
+function preview(value, fallback) {
+    return foldedSummary(value) || fallback;
+}
+function waitLine(mark, subject, summary, columns) {
+    const head = `${mark} ${subject}`;
+    const room = columns - displayColumns(head) - displayColumns(WAIT_SUMMARY_SEPARATOR);
+    const folded = foldedSummary(summary);
+    return room < 1 || folded.length === 0
+        ? head
+        : `${head}${WAIT_SUMMARY_SEPARATOR}${truncateDisplayText(folded, room)}`;
+}
 /**
- * One wait's final text: each observed Akuma's own status snapshot, then one
- * failure fact per member the wait could not read. A wait observes to its
- * completion judgment and streams nothing, so an answer is visible only as the
- * snapshot's own outcome row.
+ * The final public snapshot as one wait summary. A stopped life stays explicit over any older
+ * outcome; pending input stays visible beside the life it belongs to; a sleeping member without
+ * pending input shows its current answered preview or failed diagnostic, else completion. The
+ * mark reports the observed life, never continuing liveness.
+ */
+function waitSummary(status) {
+    const pending = status.timeline.entries.some((entry) => entry.kind === "row" && entry.row.kind === "tell" && entry.row.state === "pending");
+    const outcome = status.timeline.kind === "idle" ? status.timeline.outcome?.outcome : undefined;
+    const observed = WAIT_LIFE[status.life] ??
+        (pending
+            ? { mark: "⧗", state: "pending tell" }
+            : outcome === undefined
+                ? { mark: "✓", state: "completed" }
+                : outcome.kind === "answered"
+                    ? { mark: "✓", state: preview(outcome.answer, "answered") }
+                    : { mark: "!", state: preview(outcome.diagnostic, "failed") });
+    return {
+        ...observed,
+        summary: [
+            observed.state,
+            ...(pending && status.life !== "asleep" ? ["pending tell"] : []),
+            ...(status.strandedReason === undefined ? [] : [status.strandedReason]),
+        ].join(FACT_SEPARATOR),
+    };
+}
+/**
+ * One wait's final text: one compact line per observed member, then one failure line per member
+ * the wait could not read. A wait opens no frame and extracts no separate answer, so an answer is
+ * visible only as the snapshot's own bounded summary.
  */
 export function waitText(result, presentation, context) {
     const alias = result.observations.length === 1 && result.unobserved.length === 0 ? presentation.alias : undefined;
-    const blocks = result.observations.map((observation) => snapshotText(observation, context, { ...(alias === undefined ? {} : { alias }) }));
-    const unobserved = result.unobserved.map((member) => unobservedText(member.id, member.diagnostic));
-    return [...blocks, ...(unobserved.length === 0 ? [] : [unobserved.join("\n")])].join("\n\n");
+    return [
+        ...result.observations.map((observation) => {
+            const { mark, summary } = waitSummary(observation.status);
+            return waitLine(mark, identity(observation.status.id, alias), summary, context.columns);
+        }),
+        ...result.unobserved.map((member) => waitLine("!", safeText(member.id), `observation failed${FACT_SEPARATOR}${member.diagnostic}`, context.columns)),
+    ].join("\n");
 }
 export function historyText(result, presentation, context) {
     if (presentation.id !== undefined) {
@@ -924,12 +881,12 @@ export function historyText(result, presentation, context) {
         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 rows = groupedRows(result.history.rows, context, { history: true });
     const paging = result.history.omitted > 0
         ? [
-            timelineMarker(result.history.hasLater
+            omissionMarker(result.history.hasLater
                 ? `${result.history.omitted} later events · showing first ${result.history.rows.length}`
-                : `${result.history.omitted} earlier events · showing last ${result.history.rows.length}`),
+                : `${result.history.omitted} earlier events · showing last ${result.history.rows.length}`, context.columns),
         ]
         : [];
     // History is an immutable timeline, so it takes the shared heading and content boundary and
@@ -938,7 +895,7 @@ export function historyText(result, presentation, context) {
     const head = panelHead(result.id, presentation.alias, result.contract);
     return [...head, ...(content.length === 0 ? [] : [frameRule(head, context.columns), ...content])].join("\n");
 }
-/** One bounded preview of a submitted Tell, indented once beneath its verdict or evidence. */
+/** One bounded, quoted preview of a Tell an outer receipt already admitted, indented beneath it. */
 export function tellPayloadLines(text, context) {
     return renderBoundedPayload({
         text,
@@ -950,38 +907,47 @@ export function tellPayloadLines(text, context) {
         truncated: false,
     });
 }
-/** One admitted Tell as a timeline row inside a shared input panel; the panel owns the identity. */
+/** One admitted Tell as a timeline input row inside a shared panel; the panel owns the identity. */
 export function tellAdmissionRow(tell, context) {
-    const wake = tell.wake;
-    const glyph = wake.kind === "failed" ? "!" : wake.kind === "held" ? "⧗" : "✓";
-    const verb = wake.kind === "failed" || wake.kind === "held" ? "tell" : "told";
-    return groupedRows([tell.row], context, {
-        ...plainLayout(),
-        head: (time, _glyph, _verb, columns) => eventPrefix(glyph, verb, time, columns),
-        singleLine: true,
-    }).join("\n");
+    const lead = tell.wake.kind === "failed" ? TOP_FAILURE : tell.wake.kind === "held" ? TOP_PENDING : TOP_INPUT;
+    return renderBoundedPayload({
+        text: tell.row.text,
+        first: lead,
+        continuation: TOP_CONTINUATION,
+        columns: context.columns,
+        maxLines: 1,
+        quote: "",
+        truncated: false,
+    })[0];
 }
 /**
- * One Tell action receipt: the delivery verdict and complete subject, then the submitted payload
- * once. A held Tell keeps neutral vocabulary; a failed delivery keeps its own concrete diagnosis.
+ * One Tell action receipt: the delivery verdict and complete subject stand whole on the first line
+ * with the submitted payload folded onto that same line, bounded so only its preview truncates. A
+ * held Tell keeps neutral vocabulary; a failed delivery keeps its concrete diagnosis and native log
+ * coordinates as separate supporting facts.
  */
 export function tellText(result, alias, context) {
     const wake = result.tell.wake;
     const mark = wake.kind === "failed" ? "!" : wake.kind === "held" ? "⧗" : "✓";
     const verb = wake.kind === "failed" || wake.kind === "held" ? "tell" : "told";
-    const verdict = actionReceipt({
+    const head = actionReceipt({
         mark,
         verb,
         id: result.akuma,
         ...(alias === undefined ? {} : { alias }),
-    });
+    })[0];
+    const preview = safeText(result.tell.row.text).replace(/\s+/gu, " ").trim();
+    const prefix = `${head} — `;
+    // The verdict and identity never truncate, so an over-wide identity still keeps one visible
+    // ellipsis for the input it could not show.
+    const room = Math.max(1, context.columns - displayColumns(prefix));
+    const verdict = preview.length === 0 ? head : `${prefix}${truncateDisplayText(preview, room)}`;
     if (wake.kind !== "failed")
-        return [...verdict, ...tellPayloadLines(result.tell.row.text, context)].join("\n");
+        return verdict;
     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 [
-        ...verdict,
-        ...tellPayloadLines(result.tell.row.text, context),
+        verdict,
         ...subordinateLines(renderBoundedTextBlock(failure, {
             first: "",
             continuation: "",

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

@@ -1,3 +1,4 @@
+import type { CliOutcome } from "../streams.js";
 import type { LiveStatusObservation } from "../../akuma/akuma-observe.js";
 import type { TellResult } from "../../akuma/body.js";
 import type { AkuId } from "../../akuma/identity.js";
@@ -29,10 +30,10 @@ export declare function renderCallText(result: CallResult, streamed: boolean, co
 export declare function renderFailedCallObservation(result: CallResult, context: TextRenderContext): string;
 export declare function renderForkText(receipt: ForkResult): string;
 export declare function renderKillText(result: AkumaKillResult, alias: string | undefined, context: TextRenderContext): string;
-export declare function callExitCode(result: CallResult): number;
-export declare function killExitCode(result: AkumaKillResult): number;
-export declare function tellExitCode(result: AkumaTellResult): number;
-export declare function askExitCode(result: AkumaAskResult): number;
-export declare function forkExitCode(receipt: ForkResult): number;
-export declare function historyExitCode(result: AkumaHistoryResult, id: string | undefined): number;
+export declare function callOutcome(result: CallResult): CliOutcome;
+export declare function killOutcome(result: AkumaKillResult): CliOutcome;
+export declare function tellOutcome(result: AkumaTellResult): CliOutcome;
+export declare function askOutcome(result: AkumaAskResult): CliOutcome;
+export declare function forkOutcome(receipt: ForkResult): CliOutcome;
+export declare function historyOutcome(result: AkumaHistoryResult, id: string | undefined): CliOutcome;
 export {};