@astrosheep/keiyaku 4.5.26 → 4.5.28

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

@@ -1,7 +1,7 @@
 import { parseAkumaStatus } from "../../akuma/akuma.js";
 import { defaultWaitComplete } from "../../akuma/akuma-observe.js";
-import { toolRepr } from "./akuma-tool.js";
-import { displayColumns, renderBoundedTextBlock, safeText, takeDisplayColumns, truncateMiddleDisplayText, } from "./terminal.js";
+import { toolContent, toolRepr } from "./akuma-tool.js";
+import { displayColumns, renderBoundedTextBlock, safeText, takeDisplayColumns, truncateDisplayText, truncateMiddleDisplayText, } from "./terminal.js";
 export const DEFAULT_CONTEXT = { columns: 80, color: false };
 const TIME_WIDTH = 5;
 const VERB_WIDTH = 6;
@@ -38,7 +38,7 @@ function contractFacts(contract) {
     return contract.kind === "failed" ? [`! contract failed ${safeText(contract.diagnostic)}`] : [];
 }
 function unobservedText(id, diagnostic) {
-    return `! ${id} unobserved: ${safeText(diagnostic)}`;
+    return `× Akuma observation failed  ${safeText(id)} — ${safeText(diagnostic)}`;
 }
 function lifeLabel(life) {
     if (life === "running")
@@ -57,7 +57,7 @@ function clock(at) {
         ? `${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}`
         : "unknown";
 }
-function label(row) {
+function label(row, tool) {
     if (row.kind === "said")
         return "say";
     if (row.kind === "thought")
@@ -74,7 +74,7 @@ function label(row) {
         return "call";
     if (row.kind !== "tool")
         return row.kind;
-    return toolRepr(row).label;
+    return tool.label;
 }
 function mark(row) {
     if (row.kind === "outcome")
@@ -92,7 +92,7 @@ function mark(row) {
     }
     return "│";
 }
-function rowText(row) {
+function rowText(row, tool) {
     if (row.kind === "said" ||
         row.kind === "thought" ||
         row.kind === "note" ||
@@ -111,40 +111,62 @@ function rowText(row) {
         return { text: "", lines: 1 };
     if (row.kind !== "tool")
         return { text: "", lines: 1 };
-    const repr = toolRepr(row);
+    if (row.call.kind === "other")
+        return { text: "", lines: 1 };
+    const repr = tool;
     return {
         text: repr.text,
-        lines: 2,
+        lines: 1,
         ...(repr.overflow === "middle-ellipsis" ? { middle: true } : {}),
         ...(repr.suffix === undefined ? {} : { suffix: repr.suffix }),
     };
 }
-function eventPrefix(glyph, verb, time) {
+function eventPrefix(glyph, verb, time, columns) {
     const gutter = time === undefined ? " ".repeat(TIME_WIDTH) : time.padEnd(TIME_WIDTH);
-    return `${gutter} ${glyph} ${verb.padEnd(VERB_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.
+ */
+function actionCell(head, verb, columns) {
+    const prefix = `${head} `;
+    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() {
-    return eventPrefix("│", "");
+    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}`;
+}
 function plainLayout() {
     return {
-        head: (time, glyph, verb) => eventPrefix(glyph, verb, time),
+        head: (time, glyph, verb, columns) => eventPrefix(glyph, verb, time, columns),
         continuation: continuationPrefix,
-        marker: (count) => `${" ".repeat(TIME_WIDTH)} ⋮ ${count} omitted`,
+        marker: (count) => timelineMarker(`${count} omitted`),
     };
 }
-function sourceLayout(source, width) {
+function sourceLayout(source, width, clock) {
     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)} `,
+        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,
+        singleLine: true,
     };
 }
 function quotedBody(row) {
@@ -172,14 +194,35 @@ 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, continuation) {
-    const value = rowText(row);
+function rowBody(row, text, columns) {
+    if (row.kind !== "tool" || row.call.kind !== "other")
+        return text;
+    return toolContent(row, columns);
+}
+function renderRow(row, context, options) {
+    const { history, first, continuation, tool, singleLine = false, inFlightSay = false } = options;
+    const value = rowText(row, tool);
     const quoted = quotedBody(row);
+    if (singleLine) {
+        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 ? "" : '"'}`];
+    }
     const quoteWidth = quoted ? 2 : 0;
     if (value.middle === true) {
         return [renderMiddleEllipsis(first, value.text, value.suffix ?? "", context.columns - quoteWidth)];
     }
-    const lines = renderBoundedTextBlock(value.text, {
+    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,
@@ -199,7 +242,14 @@ function groupedEntries(entries, context, history = false, layout = plainLayout(
         const row = entry.row;
         const at = clock(row.at);
         const changed = previousClock === undefined || at !== previousClock;
-        lines.push(...renderRow(row, context, history, layout.head(changed ? at : undefined, mark(row), label(row)), layout.continuation()));
+        const tool = row.kind === "tool" ? toolRepr(row) : undefined;
+        lines.push(...renderRow(row, context, {
+            history,
+            first: layout.head(changed ? at : undefined, mark(row), label(row, tool), context.columns),
+            continuation: layout.continuation(),
+            tool,
+            singleLine: layout.singleLine === true,
+        }));
         previousClock = at;
     }
     return lines;
@@ -307,11 +357,27 @@ function baselineOmissionCount(activity, boundary) {
     }
     return count;
 }
-function renderStreamRow(state, row, lines, context, layout) {
+function renderStreamRow(state, row, lines, options) {
+    const { context, layout, inFlightSay = false } = options;
     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;
+    const previousClock = layout.clock?.previous ?? state.previousClock;
+    const changed = previousClock === undefined || at !== previousClock;
+    const tool = row.kind === "tool" ? toolRepr(row) : undefined;
+    lines.push(...renderRow(row, context, {
+        history: false,
+        first: layout.head(changed ? at : undefined, inFlightSay ? "⧖" : mark(row), label(row, tool), context.columns),
+        continuation: layout.continuation(),
+        tool,
+        singleLine: layout.singleLine === true,
+        inFlightSay,
+    }));
+    if (layout.clock !== undefined)
+        layout.clock.previous = at;
+    else
+        state.previousClock = at;
+}
+function inFlightSay(activity, row) {
+    return activity.snapshot.kind === "open" && row.kind === "said";
 }
 function coalesceDeferredGaps(state) {
     state.deferred = state.deferred.reduce((entries, entry) => {
@@ -340,7 +406,7 @@ function flushSafeActivityPrefix(state, lines, context, layout) {
             return;
         if (first.kind === "row") {
             state.deferred.shift();
-            renderStreamRow(state, first.row, lines, context, layout);
+            renderStreamRow(state, first.row, lines, { context, layout, inFlightSay: first.inFlightSay });
             continue;
         }
         const next = state.deferred[1];
@@ -355,7 +421,7 @@ function renderCurrentTurnBoundary(state, activity, lines, context, layout) {
     if (boundary !== undefined && !state.renderedBoundaries.has(boundary.turnSequence)) {
         state.renderedBoundaries.add(boundary.turnSequence);
         if (boundary.row.kind !== "thought")
-            renderStreamRow(state, boundary.row, lines, context, layout);
+            renderStreamRow(state, boundary.row, lines, { context, layout });
     }
     return boundary;
 }
@@ -383,14 +449,14 @@ function observeActivitySnapshot(state, activity, context, layout) {
     for (const row of rows) {
         if (isBoundedStreamTool(row) && state.openingTools < OPENING_TOOL_BUDGET) {
             state.openingTools += 1;
-            renderStreamRow(state, row, lines, context, layout);
+            renderStreamRow(state, row, lines, { context, layout, inFlightSay: inFlightSay(activity, row) });
             continue;
         }
         if (!isBoundedStreamTool(row) && state.deferred.length === 0) {
-            renderStreamRow(state, row, lines, context, layout);
+            renderStreamRow(state, row, lines, { context, layout, inFlightSay: inFlightSay(activity, row) });
             continue;
         }
-        state.deferred.push({ kind: "row", row });
+        state.deferred.push({ kind: "row", row, inFlightSay: inFlightSay(activity, row) });
         if (isBoundedStreamTool(row)) {
             const pendingTools = state.deferred.filter((entry) => entry.kind === "row" && isBoundedStreamTool(entry.row)).length;
             if (pendingTools > RECENT_TOOL_BUDGET)
@@ -406,7 +472,7 @@ function flushActivityTail(state, context, layout) {
         if (entry.kind === "gap")
             lines.push(layout.marker(entry.count));
         else
-            renderStreamRow(state, entry.row, lines, context, layout);
+            renderStreamRow(state, entry.row, lines, { context, layout, inFlightSay: entry.inFlightSay });
     }
     state.deferred = [];
     return lines;
@@ -492,14 +558,50 @@ function createWaitObservationState() {
     return {
         streams: new Map(),
         sources: new Map(),
+        tags: new Map(),
         contracts: new Map(),
         settledAt: new Map(),
         sourceWidth: 0,
+        clock: {},
         plural: undefined,
         headerEmitted: false,
         observed: false,
     };
 }
+function shortestUniquePrefix(value, values) {
+    for (let length = 4; length <= value.length; length += 1) {
+        const tag = value.slice(0, length);
+        if (values.filter((candidate) => candidate.slice(0, length) === tag).length === 1)
+            return tag;
+    }
+    return undefined;
+}
+function shortestUniqueSegmentSuffix(id, ids) {
+    const segments = id.split("/");
+    for (let start = segments.length - 2; start >= 0; start -= 1) {
+        const tag = segments.slice(start).join("/");
+        if (ids.filter((candidate) => candidate.endsWith(`/${tag}`) || candidate === tag).length === 1)
+            return tag;
+    }
+    return undefined;
+}
+function waitIdentityTag(id, ids) {
+    const finals = ids.map((candidate) => candidate.slice(candidate.lastIndexOf("/") + 1));
+    const index = ids.indexOf(id);
+    const own = finals[index];
+    if (own === undefined)
+        return id;
+    return (shortestUniquePrefix(own, finals) ?? shortestUniqueSegmentSuffix(id, ids) ?? shortestUniquePrefix(id, ids) ?? id);
+}
+/** The selected set fixes identity tags before its first attributed row. */
+function freezeWaitTags(state) {
+    const ids = [...state.sources.keys()];
+    state.tags = new Map(ids.map((id) => [id, waitIdentityTag(id, ids)]));
+    state.sourceWidth = Math.max(0, ...Array.from(state.tags.values(), displayColumns));
+}
+function sourceTag(state, id) {
+    return state.tags.get(id) ?? waitIdentityTag(id, [...state.sources.keys()]);
+}
 /** Register one selected or newly observed source; the set freezes the column before the first row. */
 function registerWaitSource(state, id, alias, contract) {
     if (state.sources.has(id))
@@ -508,8 +610,6 @@ function registerWaitSource(state, id, alias, contract) {
     state.sources.set(id, label);
     if (contract !== undefined)
         state.contracts.set(id, contract);
-    if (!state.headerEmitted)
-        state.sourceWidth = Math.max(state.sourceWidth, displayColumns(label));
 }
 /**
  * The one aggregate head a plural wait prints before any activity row: the
@@ -520,7 +620,8 @@ function registerWaitSource(state, id, alias, contract) {
 function aggregateHeading(state) {
     const head = [...state.sources].map(([id, label]) => {
         const contractId = associatedContractId(state.contracts.get(id) ?? { kind: "none" });
-        return contractId === undefined ? label : `${label} · ${contractId}`;
+        const named = `${sourceTag(state, id)} ${label}`;
+        return contractId === undefined ? named : `${named} · ${contractId}`;
     });
     return [...head, frameRule(head)];
 }
@@ -529,6 +630,8 @@ function observeWaitRound(state, round, context, now) {
     // 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, member.contract);
+    if (!state.headerEmitted)
+        freezeWaitTags(state);
     const lines = [];
     // The observation subject opens once: an aggregate head for a plural set, the observed
     // identity frame for a single target. Every later round only appends attributed rows.
@@ -551,7 +654,7 @@ function observeWaitRound(state, round, context, now) {
         else {
             // Only a plural wait attributes its rows; a single-target stream keeps the plain row grammar.
             const stream = activityStream(context, state.plural === true
-                ? sourceLayout(state.sources.get(status.id) ?? status.id, () => state.sourceWidth)
+                ? sourceLayout(sourceTag(state, status.id), () => state.sourceWidth, state.clock)
                 : plainLayout());
             state.streams.set(status.id, stream);
             // Seed marks skipped retained evidence without spending this command's live tool budget.
@@ -595,15 +698,20 @@ function concludeWaitStream(state, result, startedAt, now) {
     for (const stream of state.streams.values())
         tail.push(...stream.flush());
     const end = now();
+    for (const observation of result.observations)
+        registerWaitSource(state, observation.status.id, undefined, observation.contract);
+    for (const member of result.unobserved)
+        registerWaitSource(state, member.id, undefined);
+    if (!state.headerEmitted)
+        freezeWaitTags(state);
     const order = orderedWaitIds(state, result);
     const multi = order.length > 1;
     const observationById = new Map(result.observations.map((observation) => [observation.status.id, observation]));
     const unobservedById = new Map(result.unobserved.map((member) => [member.id, member]));
-    // A multi-target scoreboard names the frozen source label; a single target keeps the bare diagnostic.
-    const label = (id) => (multi ? (state.sources.get(id) ?? id) : id);
+    // A failure fact keeps the complete identity even where the scoreboard attributes a target by its identity tag.
     const unobservedLines = order
         .filter((id) => unobservedById.has(id))
-        .map((id) => unobservedText(label(id), unobservedById.get(id).diagnostic));
+        .map((id) => unobservedText(id, unobservedById.get(id).diagnostic));
     const conclusions = order.flatMap((id) => {
         const observation = observationById.get(id);
         if (observation === undefined)
@@ -612,7 +720,7 @@ function concludeWaitStream(state, result, startedAt, now) {
         const complete = defaultWaitComplete(status);
         const at = complete ? (state.settledAt.get(id) ?? end) : end;
         const { mark, verb } = conclusionMarkVerb(status, statusAnswer(observation) !== undefined);
-        const target = multi ? ` ${padToDisplay(state.sources.get(id) ?? id, state.sourceWidth)}` : "";
+        const target = multi ? ` ${padToDisplay(sourceTag(state, id), state.sourceWidth)}` : "";
         return [`${clockFromMs(at)}${target} ${mark} ${verb}${conclusionClause(at, startedAt, complete, end)}`];
     });
     const answeredSingle = !multi && result.observations.length === 1 && statusAnswer(result.observations[0]) !== undefined;
@@ -643,6 +751,7 @@ export function waitObservationStream(context, options = {}) {
         for (const member of selected)
             registerWaitSource(state, member.id, member.alias, member.contract);
         state.plural ??= selected.length > 1;
+        freezeWaitTags(state);
     };
     const observe = (round) => observeWaitRound(state, round, context, now);
     const conclude = (result) => concludeWaitStream(state, result, startedAt, now);
@@ -763,6 +872,7 @@ 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"}`] : []),
         ...(view.status.readonly?.enforcement === "none" ? [`! ${safeText(view.status.readonly.diagnostic)}`] : []),
         ...contractFacts(view.contract),
@@ -871,23 +981,19 @@ export function waitText(result, context) {
     const end = Date.now();
     const startedAt = result.startedAt ?? end;
     const order = [];
-    const labels = new Map();
-    const remember = (id, frozenAlias) => {
-        if (labels.has(id))
-            return;
-        labels.set(id, frozenAlias ?? id);
-        order.push(id);
+    const remember = (id) => {
+        if (!order.includes(id))
+            order.push(id);
     };
     for (const member of result.selection ?? [])
-        remember(member.id, member.alias);
+        remember(member.id);
     for (const observation of observations)
         remember(observation.status.id);
     for (const member of unobserved)
         remember(member.id);
-    const label = (id) => labels.get(id) ?? id;
     const observationById = new Map(observations.map((observation) => [observation.status.id, observation]));
     const unobservedById = new Map(unobserved.map((member) => [member.id, member]));
-    const sourceWidth = order.reduce((width, id) => Math.max(width, displayColumns(label(id))), 0);
+    const sourceWidth = Math.max(0, ...order.map((id) => displayColumns(waitIdentityTag(id, order))));
     const blocks = [
         ...order.flatMap((id) => {
             const observation = observationById.get(id);
@@ -902,7 +1008,7 @@ export function waitText(result, context) {
             ? [
                 order
                     .filter((id) => unobservedById.has(id))
-                    .map((id) => unobservedText(label(id), unobservedById.get(id).diagnostic))
+                    .map((id) => unobservedText(id, unobservedById.get(id).diagnostic))
                     .join("\n"),
             ]
             : []),
@@ -916,7 +1022,7 @@ export function waitText(result, context) {
         const at = complete ? (settleMoment(status) ?? end) : end;
         const { mark, verb } = conclusionMarkVerb(status, statusAnswer(observation) !== undefined);
         return [
-            `${clockFromMs(at)} ${padToDisplay(label(id), sourceWidth)} ${mark} ${verb}${conclusionClause(at, startedAt, complete, end)}`,
+            `${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");
@@ -934,14 +1040,22 @@ export function historyText(command, result, context) {
         throw new Error("history result lacks page");
     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}`]
+        ? [
+            timelineMarker(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}`),
+        ]
         : [];
     return [...snapshotHeading(result.akuma, result.alias, result.historyResult.contract), ...paging, ...rows].join("\n");
 }
 export function tellText(result, context) {
     const wake = result.result.tell.wake;
     const target = identity(result.result.akuma, result.alias);
-    const row = groupedRows([result.result.tell.row], context).join("\n");
+    const row = groupedRows([result.result.tell.row], context, false, {
+        ...plainLayout(),
+        head: (time, _glyph, _verb, columns) => eventPrefix(wake.kind === "held" ? "⧗" : "⧖", "tell", time, columns),
+        singleLine: true,
+    }).join("\n");
     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}`}`;

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

@@ -6,6 +6,11 @@ type FleetTimelineRow = Extract<AkumaObservation["status"]["timeline"]["entries"
 type ToolRow = Extract<ActivityRow | SnapshotRow | FleetTimelineRow, {
     kind: "tool";
 }>;
+/** The bounded body of a generic tool row, including its terminal diagnostic. */
+export declare function toolContent(row: ToolRow, columns: number): string;
+export declare function toolLabel(row: ToolRow): string;
+/** The trailing failure, duration, or message clause one settled tool row carries, otherwise the empty string. */
+export declare function toolDiagnostic(row: ToolRow): string;
 export type ToolRepr = Readonly<{
     label: string;
     text: string;

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

@@ -1,4 +1,71 @@
+import { displayColumns, truncateDisplayText } from "./terminal.js";
 import { normalizeToolCommand } from "./akuma-tool-command.js";
+/** The bounded body of a generic tool row, including its terminal diagnostic. */
+export function toolContent(row, columns) {
+    const input = row.call.kind === "other" ? row.call.input : undefined;
+    const diagnostic = toolDiagnostic(row);
+    const width = Math.max(0, columns - displayColumns(diagnostic));
+    let text;
+    if (input === undefined) {
+        text = "";
+    }
+    else {
+        const common = commonOtherText(row);
+        if (common !== undefined)
+            text = common;
+        else if (input.json === "{}")
+            text = "";
+        else if (input.truncated)
+            text = `${input.json}…`;
+        else {
+            const value = jsonObject(input.json);
+            text = value === undefined ? input.json : objectFieldsText(value, width);
+        }
+    }
+    return `${truncateDisplayText(text, width)}${diagnostic}`;
+}
+export function toolLabel(row) {
+    return toolCore(row).label;
+}
+/** The trailing failure, duration, or message clause one settled tool row carries, otherwise the empty string. */
+export function toolDiagnostic(row) {
+    const suffix = result(row);
+    return suffix === undefined ? "" : ` — ${suffix}`;
+}
+function jsonObject(json) {
+    let value;
+    try {
+        value = JSON.parse(json);
+    }
+    catch {
+        return undefined;
+    }
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+/**
+ * Retain leading whole fields that fit and name the trailing omit count. When
+ * even that marker cannot fit, keep the first field or the object's own prefix
+ * with a visible ellipsis, never a silently complete-looking value.
+ */
+function objectFieldsText(value, columns) {
+    const fields = Object.entries(value).map(([key, field]) => `${JSON.stringify(key)}:${JSON.stringify(field)}`);
+    if (fields.length === 0)
+        return "";
+    const full = `{${fields.join(",")}}`;
+    if (displayColumns(full) <= columns)
+        return full;
+    for (let count = fields.length - 1; count >= 1; count -= 1) {
+        const candidate = `{${fields.slice(0, count).join(",")}} +${fields.length - count} fields`;
+        if (displayColumns(candidate) <= columns)
+            return candidate;
+    }
+    const first = fields[0];
+    if (fields.length > 1 && displayColumns(first) <= columns)
+        return `${first}…`;
+    return truncateDisplayText(full, columns);
+}
 function oneLine(value) {
     return value.replace(/\s+/gu, " ").trim();
 }
@@ -22,7 +89,7 @@ function result(row) {
         : row.state.status;
     const parts = [
         ...(row.call.kind === "run" && row.durationMs !== undefined ? [duration(row.durationMs)] : []),
-        ...(row.call.kind === "fileChange" && disposition === "ok" ? [] : [disposition]),
+        ...(disposition === "ok" ? [] : [disposition]),
         ...(row.state.message === undefined ? [] : [oneLine(row.state.message)]),
     ];
     return parts.length === 0 ? undefined : parts.join(" · ");
@@ -52,6 +119,43 @@ function searchText(call) {
         ...(call.glob === undefined ? [] : [oneLine(call.glob)]),
     ].join(" · ");
 }
+function inputObject(row) {
+    if (row.call.kind !== "other" || row.call.input?.truncated === true)
+        return undefined;
+    return jsonObject(row.call.input?.json ?? "");
+}
+function suppliedSlice(value) {
+    const offset = typeof value.offset_chars === "number" ? `from ${value.offset_chars}` : "";
+    const limit = typeof value.limit_chars === "number" ? `${value.limit_chars} chars` : "";
+    return [offset, limit].filter(Boolean).join(" · ");
+}
+function commonOtherText(row) {
+    const input = inputObject(row);
+    if (input === undefined)
+        return undefined;
+    if (row.name === "get_context_remaining")
+        return undefined;
+    if (row.name === "notes_read") {
+        const address = typeof input.address === "string" ? input.address : typeof input.path === "string" ? input.path : undefined;
+        return [address, suppliedSlice(input)]
+            .filter((value) => value !== undefined && value !== "")
+            .join(" · ");
+    }
+    if (row.name === "history_read") {
+        const item = typeof input.item_id === "string" ? input.item_id : undefined;
+        const window = typeof input.window_id === "string" ? input.window_id : undefined;
+        return [item, window, suppliedSlice(input)]
+            .filter((value) => value !== undefined && value !== "")
+            .join(" · ");
+    }
+    if (row.name === "history_list") {
+        const role = typeof input.role === "string" ? `role ${input.role}` : undefined;
+        const order = input.recent_first === true ? "newest first" : input.recent_first === false ? "oldest first" : undefined;
+        const limit = typeof input.limit === "number" ? `${input.limit} rows` : undefined;
+        return [role, order, limit].filter((value) => value !== undefined).join(" · ");
+    }
+    return undefined;
+}
 function fileChange(call, state) {
     const first = call.changes[0];
     if (first === undefined)
@@ -69,30 +173,30 @@ function fileChange(call, state) {
     }), { added: 0, removed: 0 });
     return { label, text: `${subject} — +${totals.added} -${totals.removed}` };
 }
-/** Pure provider-neutral tool presentation; it performs no activity selection. */
-export function toolRepr(row) {
-    let core;
+/** One provider-neutral core owns every tool-kind label and non-generic body. */
+function toolCore(row) {
     switch (row.call.kind) {
         case "run":
-            core = {
+            return {
                 label: "run",
                 text: `$ ${oneLine(normalizeToolCommand(row.call.command))}`,
                 overflow: "middle-ellipsis",
             };
-            break;
         case "read":
-            core = { label: "read", text: readText(row.call) };
-            break;
+            return { label: "read", text: readText(row.call) };
         case "search":
-            core = { label: searchLabel(row.call.scope), text: searchText(row.call) };
-            break;
+            return { label: searchLabel(row.call.scope), text: searchText(row.call) };
         case "fileChange":
-            core = fileChange(row.call, row.state);
-            break;
+            return fileChange(row.call, row.state);
         case "other":
-            core = { label: "use", text: oneLine(row.call.display || row.name) };
-            break;
+            return { label: row.name, text: "" };
     }
+}
+/** Pure provider-neutral tool presentation; it performs no activity selection. */
+export function toolRepr(row) {
+    const core = toolCore(row);
+    if (row.call.kind === "other")
+        return core;
     const suffix = result(row);
     if (suffix === undefined)
         return core;

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

@@ -1,8 +1,19 @@
 import type { AkumaInvocationResult } from "../commands/akuma-invoke.js";
 import type { ParsedCommand } from "../parse.js";
 import { type ObservedCallHead } from "./akuma-activity.js";
+import type { AkumaTellWaitResult } from "../../akuma/fleet-observation.js";
+import type { AkuId } from "../../akuma/identity.js";
+import type { LiveStatusObservation } from "../../akuma/akuma-observe.js";
+import type { TellResult } from "../../akuma/akuma.js";
 import { type TextRenderContext } from "./terminal.js";
-export { akumaRawAnswer } from "./akuma-activity.js";
+export type TellWaitProgress = Readonly<{
+    admitted: (tell: TellResult, id: AkuId) => readonly string[];
+    observe: (observation: LiveStatusObservation) => readonly string[];
+    conclude: (result: AkumaTellWaitResult) => readonly string[];
+}>;
+export declare function tellWaitProgressStream(akuma: AkuId | undefined, alias: string | undefined, context: TextRenderContext): TellWaitProgress;
+export declare function waitedTellProgress(result: AkumaTellWaitResult, alias: string | undefined, context: TextRenderContext): string;
+export declare function akumaRawAnswer(result: AkumaInvocationResult): string | undefined;
 /**
  * The head a streamed observing call opens with: the identity its birth already
  * established, its Contract association, and the birth's diagnostics. The