muonroi-cli 1.8.4 → 1.9.0

package/dist/src/ui/slash/menu-items.d.ts

@@ -40,3 +40,10 @@ export interface SlashMenuItem {
 export declare const SLASH_MENU_ITEMS: SlashMenuItem[];
 /** Items shown in the splash autocomplete + /help listing. */
 export declare const VISIBLE_SLASH_MENU_ITEMS: SlashMenuItem[];
+/**
+ * Arrow-navigation order for the empty-query ("just /") dropdown: primary
+ * surface first, then the hidden commands. The dropdown renders a scrolling
+ * viewport, so listing the full set here makes every command reachable by
+ * arrow keys without cluttering the top of the list (primary stays on top).
+ */
+export declare const SLASH_MENU_ITEMS_ARROW_ORDER: SlashMenuItem[];

package/dist/src/ui/slash/menu-items.js

@@ -28,32 +28,36 @@
 export const SLASH_MENU_ITEMS = [
     // ── Primary surface ────────────────────────────────────────────────────
     { id: "exit", label: "exit", description: "Quit the CLI" },
-    { id: "providers", label: "providers", description: "Manage providers + API keys (enable/disable, set default)" },
+    {
+        id: "providers",
+        label: "providers",
+        description: "Providers, keys and sign-in (K adds a key, Enter signs in with OAuth)",
+    },
     { id: "compact", label: "compact", description: "Compact conversation context" },
     { id: "clear", label: "clear", description: "Clear conversation and start fresh" },
-    { id: "ideal", label: "ideal", description: "Product Ideal Loop — autonomous build from idea to ship" },
+    { id: "ideal", label: "ideal", description: "Product Ideal Loop — from idea to shipped product, autonomously" },
     { id: "council", label: "council", description: "Multi-model adversarial debate" },
     // ── Hidden (still functional when typed in full) ───────────────────────
     { id: "help", label: "help", description: "Show available commands", hidden: true },
-    { id: "config", label: "config", description: "Open provider and council configuration", hidden: true },
     { id: "remote-control", label: "remote-control", description: "Remote control", hidden: true },
-    { id: "agents", label: "agents", description: "Manage custom sub-agents", hidden: true },
-    { id: "schedule", label: "schedule", description: "View scheduled runs", hidden: true },
     { id: "mcp", label: "mcp", description: "Manage MCP servers", hidden: true },
     { id: "sandbox", label: "sandbox", description: "Select shell sandbox mode", hidden: true },
     { id: "wallet", label: "wallet", description: "Wallet and payment settings", hidden: true },
     { id: "models", label: "models", description: "Alias of /providers", hidden: true },
     { id: "new", label: "new session", description: "Start a new session", hidden: true },
-    { id: "sessions", label: "sessions", description: "List recent sessions to resume", hidden: true },
+    { id: "resume", label: "resume", description: "List recent sessions to resume" },
     { id: "commit-push", label: "commit & push", description: "Commit and push", hidden: true },
     { id: "commit-pr", label: "commit & pr", description: "Commit and open PR", hidden: true },
     { id: "review", label: "review", description: "Review recent changes", hidden: true },
     { id: "verify", label: "verify", description: "Run local verification", hidden: true },
-    { id: "skills", label: "skills", description: "Manage skills", hidden: true },
-    { id: "btw", label: "btw", description: "Ask a side question without interrupting", hidden: true },
     { id: "update", label: "update", description: "Update muonroi-cli to the latest version", hidden: true },
     { id: "cost", label: "cost", description: "Show session cost breakdown", hidden: true },
-    { id: "ee", label: "ee", description: "Experience Engine status and controls", hidden: true },
+    {
+        id: "ee",
+        label: "ee",
+        description: "Experience Engine — connect a brain (/ee config <url> [token]), stats, search",
+        hidden: true,
+    },
     { id: "route", label: "route", description: "Show current model routing info", hidden: true },
     { id: "plan", label: "plan", description: "Show active GSD plan", hidden: true },
     { id: "execute", label: "execute", description: "Execute active GSD plan", hidden: true },
@@ -74,21 +78,20 @@ export const SLASH_MENU_ITEMS = [
     { id: "pin", label: "pin", description: "Pin a user message so it survives compaction", hidden: true },
     { id: "unpin", label: "unpin", description: "Remove a pinned message by sequence number", hidden: true },
     { id: "pins", label: "pins", description: "List currently pinned message sequences", hidden: true },
-    { id: "ee-stats", label: "ee stats", description: "Knowledge base statistics", hidden: true },
-    { id: "ee-gates", label: "ee gates", description: "Quality gate checklist", hidden: true },
-    { id: "ee-evolve", label: "ee evolve", description: "Trigger EE evolution cycle", hidden: true },
-    { id: "ee-user", label: "ee user", description: "Current EE user identity", hidden: true },
-    { id: "ee-search", label: "ee search", description: "Semantic search across knowledge base", hidden: true },
-    { id: "ee-timeline", label: "ee timeline", description: "Principle evolution for a topic", hidden: true },
-    { id: "ee-graph", label: "ee graph", description: "Principle relationship graph", hidden: true },
-    { id: "ee-route", label: "ee route", description: "Route task to workflow", hidden: true },
-    { id: "ee-context-on", label: "ee-context on", description: "Enable BB-aware EE context injection", hidden: true },
-    { id: "ee-context-off", label: "ee-context off", description: "Disable BB-aware EE context injection", hidden: true },
-    { id: "ee-context-status", label: "ee-context status", description: "Show current BB-context setting", hidden: true },
     { id: "export", label: "export", description: "Export entire conversation to a .txt file", hidden: true },
     { id: "status", label: "status", description: "Show Agile sprint progress dashboard", hidden: true },
     { id: "ponytail", label: "ponytail", description: "Toggle Lazy Senior AI Mode (on/off/status)", hidden: false },
 ];
 /** Items shown in the splash autocomplete + /help listing. */
 export const VISIBLE_SLASH_MENU_ITEMS = SLASH_MENU_ITEMS.filter((m) => !m.hidden);
+/**
+ * Arrow-navigation order for the empty-query ("just /") dropdown: primary
+ * surface first, then the hidden commands. The dropdown renders a scrolling
+ * viewport, so listing the full set here makes every command reachable by
+ * arrow keys without cluttering the top of the list (primary stays on top).
+ */
+export const SLASH_MENU_ITEMS_ARROW_ORDER = [
+    ...VISIBLE_SLASH_MENU_ITEMS,
+    ...SLASH_MENU_ITEMS.filter((m) => m.hidden),
+];
 //# sourceMappingURL=menu-items.js.map

package/dist/src/ui/slash/registry.d.ts

@@ -23,6 +23,8 @@ export interface SlashContext {
 export type SlashHandler = (args: string[], ctx: SlashContext) => Promise<string> | string;
 /** Register a slash command handler. */
 export declare function registerSlash(name: string, handler: SlashHandler): void;
+/** Unregister a slash command handler (used for tests). */
+export declare function unregisterSlash(name: string): void;
 /**
  * Dispatch a slash command by name.
  * Returns null if command not registered (caller falls back to legacy switch).

package/dist/src/ui/slash/registry.js

@@ -9,6 +9,10 @@ const registry = new Map();
 export function registerSlash(name, handler) {
     registry.set(name, handler);
 }
+/** Unregister a slash command handler (used for tests). */
+export function unregisterSlash(name) {
+    registry.delete(name);
+}
 /**
  * Dispatch a slash command by name.
  * Returns null if command not registered (caller falls back to legacy switch).

package/dist/src/ui/status-bar/cache-hit.d.ts

@@ -0,0 +1,6 @@
+/** Cache-hit ratio = cache_read / total input (cumulative). `in_tokens` already
+ *  includes cache-read tokens (verified: usage_events cache_read ⊆ input_tokens). */
+export declare function computeCacheHitPct(s: {
+    in_tokens: number;
+    cache_read_tokens: number;
+}): number | null;

package/dist/src/ui/status-bar/cache-hit.js

@@ -0,0 +1,9 @@
+/** Cache-hit ratio = cache_read / total input (cumulative). `in_tokens` already
+ *  includes cache-read tokens (verified: usage_events cache_read ⊆ input_tokens). */
+export function computeCacheHitPct(s) {
+    if (s.in_tokens <= 0)
+        return null;
+    const pct = (s.cache_read_tokens / s.in_tokens) * 100;
+    return Math.max(0, Math.min(100, Math.round(pct)));
+}
+//# sourceMappingURL=cache-hit.js.map

package/dist/src/ui/status-bar/index.d.ts

@@ -7,7 +7,7 @@
  * Subscribes to statusBarStore for live updates (no polling).
  */
 import * as React from "react";
-import { type SprintProgressSegment, type StatusBarState } from "./store.js";
+import { type SprintProgressSegment, type StatusBarState } from "../../state/status-bar-store.js";
 /**
  * Format a SprintProgressSegment into the StatusBar display string.
  * Format: Sprint N/M · X/Y stories · Z%

package/dist/src/ui/status-bar/index.js

@@ -9,7 +9,8 @@ import { jsx as _jsx } from "@opentui/react/jsx-runtime";
  */
 import { Semantic } from "@muonroi/agent-harness-opentui";
 import * as React from "react";
-import { statusBarStore } from "./store.js";
+import { statusBarStore } from "../../state/status-bar-store.js";
+import { computeCacheHitPct } from "./cache-hit.js";
 import { TierBadge } from "./tier-badge.js";
 import { UsdMeter } from "./usd-meter.js";
 function useStatusBarState() {
@@ -57,7 +58,11 @@ export function renderStatusBar(s) {
         : s.ctx_tokens !== undefined
             ? ` [ctx: ${fmtTokens(s.ctx_tokens)}]`
             : "";
-    const tokenStr = `↑${fmtTokens(s.in_tokens)} ↓${fmtTokens(s.out_tokens)}${s.cache_read_tokens ? ` ⊚${fmtTokens(s.cache_read_tokens)}` : ""}${ctxFill}`;
+    const hitPct = computeCacheHitPct(s);
+    const cacheSeg = s.cache_read_tokens
+        ? ` ⊚${fmtTokens(s.cache_read_tokens)}${hitPct !== null ? ` ${hitPct}%` : ""}`
+        : "";
+    const tokenStr = `↑${fmtTokens(s.in_tokens)} ↓${fmtTokens(s.out_tokens)}${cacheSeg}${ctxFill}`;
     const ee = EE_DOT[s.ee_status] ?? EE_DOT.unknown;
     const slots = [
         React.createElement("text", { key: "pm", fg: "#5c9cf5", "data-testid": "slot-provider-model" }, modelLabel),
@@ -66,7 +71,6 @@ export function renderStatusBar(s) {
         React.createElement(UsdMeter, {
             key: "usd",
             session_usd: s.session_usd,
-            month_usd: s.month_usd,
             current_pct: s.current_pct,
         }),
         React.createElement("text", { key: "ee", fg: ee.color, "data-testid": "slot-ee" }, ee.symbol),

package/dist/src/ui/status-bar/usd-meter.d.ts

@@ -1,13 +1,14 @@
 /**
  * src/ui/status-bar/usd-meter.tsx
  *
- * USD meter sub-component: session + month with threshold color escalation.
- * white < 50%, cyan >= 50%, yellow >= 80%, red >= 100%.
+ * USD meter sub-component: session spend with threshold color escalation.
+ * white < 50%, cyan >= 50%, yellow >= 80%, red >= 100%. The month total is
+ * intentionally NOT shown here (redundant on the status bar); it remains in the
+ * store and is surfaced on demand via `/cost`.
  */
 import * as React from "react";
 export interface UsdMeterProps {
     session_usd: number;
-    month_usd: number;
     current_pct: number;
 }
-export declare function UsdMeter({ session_usd, month_usd, current_pct }: UsdMeterProps): React.ReactElement;
+export declare function UsdMeter({ session_usd, current_pct }: UsdMeterProps): React.ReactElement;

package/dist/src/ui/status-bar/usd-meter.js

@@ -1,13 +1,15 @@
 /**
  * src/ui/status-bar/usd-meter.tsx
  *
- * USD meter sub-component: session + month with threshold color escalation.
- * white < 50%, cyan >= 50%, yellow >= 80%, red >= 100%.
+ * USD meter sub-component: session spend with threshold color escalation.
+ * white < 50%, cyan >= 50%, yellow >= 80%, red >= 100%. The month total is
+ * intentionally NOT shown here (redundant on the status bar); it remains in the
+ * store and is surfaced on demand via `/cost`.
  */
 import * as React from "react";
-export function UsdMeter({ session_usd, month_usd, current_pct }) {
+export function UsdMeter({ session_usd, current_pct }) {
     const color = current_pct >= 100 ? "red" : current_pct >= 80 ? "yellow" : current_pct >= 50 ? "cyan" : "white";
-    const text = `session: $${session_usd.toFixed(2)} | month: $${month_usd.toFixed(2)}`;
+    const text = `session: $${session_usd.toFixed(2)}`;
     return React.createElement("text", { fg: color, "data-testid": "usd-meter", "data-pct": current_pct }, text);
 }
 //# sourceMappingURL=usd-meter.js.map

package/dist/src/ui/theme.d.ts

@@ -65,6 +65,7 @@ export declare const dark: {
     readonly syntaxRegex: "#d16969";
     readonly syntaxTag: "#569cd6";
     readonly syntaxAttr: "#9cdcfe";
+    readonly overlay: "#000000cc";
     readonly councilLeaderBorder: "#666666";
     readonly councilSynthesisBorder: "#5c9cf5";
     readonly councilInfoCardBorder: "#4a4a4a";

package/dist/src/ui/theme.js

@@ -65,6 +65,8 @@ export const dark = {
     syntaxRegex: "#d16969",
     syntaxTag: "#569cd6",
     syntaxAttr: "#9cdcfe",
+    // ── Overlay / modal backdrop ─────────────────────────────────────────────
+    overlay: "#000000cc",
     // ── Council bubble tokens ────────────────────────────────────────────────
     councilLeaderBorder: "#666666",
     councilSynthesisBorder: "#5c9cf5",

package/dist/src/ui/types.d.ts

@@ -63,6 +63,13 @@ export interface AppStartupConfig {
      * Never set this in production — only passed via --inject-halt CLI flag.
      */
     injectHalt?: boolean;
+    /**
+     * TEST SEAM (A): when true, dispatch a synthetic `sprint_failed` halt chunk
+     * (Resume / Retry / Skip verify / Abort) after first idle. Lets harness E2E
+     * specs verify the sprint-break recovery card without a real mid-run failure.
+     * Never set this in production — only passed via --inject-halt-sprint.
+     */
+    injectHaltSprint?: boolean;
 }
 export interface AppProps {
     agent: Agent;

package/dist/src/ui/utils/agent-activities.d.ts

@@ -0,0 +1,39 @@
+/**
+ * src/ui/utils/agent-activities.ts
+ *
+ * Collect every sub-agent / background job the main agent has spawned this
+ * session, for the rail's Agents block.
+ *
+ * Derived entirely from state the UI already holds — the transcript entries and
+ * the in-flight tool calls. Spawning goes through tools (`task`, `delegate`,
+ * `bash background:true`), so the tool stream IS the record; there is no need
+ * for a parallel registry in core, and nothing here can drift out of sync with
+ * what the transcript shows.
+ *
+ * Running entries come from activeToolCalls (no result yet), finished ones from
+ * tool_result / tool_group items. A call that is both (still streaming while an
+ * earlier identical call finished) is keyed by tool-call id, so it appears once.
+ */
+import type { ChatEntry, ToolCall } from "../../types/index.js";
+export type ActivityKind = "subagent" | "delegate" | "background";
+export type ActivityStatus = "running" | "done" | "failed";
+export interface AgentActivity {
+    /** Tool-call id — stable across the running → finished transition. */
+    id: string;
+    kind: ActivityKind;
+    /** Short line for the rail row, e.g. an explore agent's description. */
+    label: string;
+    /** Sub-agent type ("explore", "general", …). Empty for background shells. */
+    agent: string;
+    status: ActivityStatus;
+    /** Full text shown when the row is opened: the prompt/command, then output. */
+    detail: string;
+}
+/** The activity kind a tool call represents, or null if it spawns nothing. */
+export declare function activityKindFor(tc: ToolCall): ActivityKind | null;
+/**
+ * Every activity in the session, oldest first. Later state for the same
+ * tool-call id wins, so a call that finishes replaces its own running row
+ * instead of adding a second one.
+ */
+export declare function collectAgentActivities(messages: ChatEntry[], activeToolCalls?: ToolCall[]): AgentActivity[];

package/dist/src/ui/utils/agent-activities.js

@@ -0,0 +1,96 @@
+/**
+ * src/ui/utils/agent-activities.ts
+ *
+ * Collect every sub-agent / background job the main agent has spawned this
+ * session, for the rail's Agents block.
+ *
+ * Derived entirely from state the UI already holds — the transcript entries and
+ * the in-flight tool calls. Spawning goes through tools (`task`, `delegate`,
+ * `bash background:true`), so the tool stream IS the record; there is no need
+ * for a parallel registry in core, and nothing here can drift out of sync with
+ * what the transcript shows.
+ *
+ * Running entries come from activeToolCalls (no result yet), finished ones from
+ * tool_result / tool_group items. A call that is both (still streaming while an
+ * earlier identical call finished) is keyed by tool-call id, so it appears once.
+ */
+const KIND_BY_TOOL = {
+    task: "subagent",
+    delegate: "delegate",
+};
+function parseArgs(tc) {
+    try {
+        const parsed = JSON.parse(tc.function.arguments || "{}");
+        return parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch (err) {
+        // Arguments stream in as partial JSON while a call assembles — an
+        // unparseable value here is expected mid-flight, not an error.
+        return {};
+    }
+}
+function str(value) {
+    return typeof value === "string" ? value : "";
+}
+/** The activity kind a tool call represents, or null if it spawns nothing. */
+export function activityKindFor(tc) {
+    const name = tc.function.name;
+    const known = KIND_BY_TOOL[name];
+    if (known)
+        return known;
+    // A backgrounded shell is a spawned job too — but only when it actually
+    // backgrounds. A normal bash call is just a tool, not an activity.
+    if (name === "bash" && parseArgs(tc).background === true)
+        return "background";
+    return null;
+}
+function toActivity(tc, result) {
+    const kind = activityKindFor(tc);
+    if (!kind)
+        return null;
+    const args = parseArgs(tc);
+    const agent = kind === "background" ? "" : str(args.agent);
+    const command = str(args.command);
+    const label = (kind === "background" ? command : str(args.description) || str(args.prompt)) || tc.function.name;
+    const request = kind === "background" ? command : str(args.prompt);
+    let status = "running";
+    if (result)
+        status = result.success ? "done" : "failed";
+    const output = result ? (result.success ? result.output || "" : result.error || "") : "";
+    const detail = [request, output].filter((s) => s.trim().length > 0).join("\n\n");
+    return { id: tc.id, kind, label: label.replace(/\s+/g, " ").trim(), agent, status, detail };
+}
+/**
+ * Every activity in the session, oldest first. Later state for the same
+ * tool-call id wins, so a call that finishes replaces its own running row
+ * instead of adding a second one.
+ */
+export function collectAgentActivities(messages, activeToolCalls = []) {
+    const byId = new Map();
+    const add = (tc, result) => {
+        if (!tc)
+            return;
+        const activity = toActivity(tc, result);
+        if (activity)
+            byId.set(activity.id, activity);
+    };
+    for (const entry of messages) {
+        if (entry.type === "tool_result") {
+            add(entry.toolCall, entry.toolResult);
+            continue;
+        }
+        if (entry.type === "tool_group") {
+            for (const item of entry.toolGroup?.items ?? [])
+                add(item.toolCall, item.result);
+        }
+    }
+    // In-flight calls fill in only what the transcript does not already have.
+    // activeToolCalls is not always cleared the instant a result lands, so adding
+    // one unconditionally would flip a finished row back to "running".
+    for (const tc of activeToolCalls) {
+        if (!byId.has(tc.id))
+            add(tc, undefined);
+    }
+    return [...byId.values()];
+}
+//# sourceMappingURL=agent-activities.js.map

package/dist/src/ui/utils/format.d.ts

@@ -35,4 +35,18 @@ export declare function buildPreflightQuestion(pf: {
         model: string;
     }>;
 }): CouncilQuestionData;
+/**
+ * F5 — the council entrypoint (council/index.ts) emits `leader`+`panel`+`topic`
+ * together exactly once, at the START of each debate; every later `council_meta`
+ * patch is partial (a lone roundBudget / researchMode / successCriteria /
+ * criteriaMet). That combination is the strongest new-council signal — stronger
+ * than a topic change, which misses a re-run on the SAME topic (auto-council
+ * re-firing on a phase, or a fresh /council after an Esc that skipped
+ * clearLiveTurnUi) and leaks the prior council's pinned criteria into the rail as
+ * stale ○ rows. The rail resets its meta+rounds on this.
+ */
+export declare function isCouncilStartPatch(patch: {
+    leader?: string;
+    panel?: string[];
+}): boolean;
 export declare function mapCouncilCardKey(key: KeyEvent): CouncilCardKey | null;

package/dist/src/ui/utils/format.js

@@ -41,6 +41,13 @@ export function formatAnswerForLog(ans, ctx) {
         return verb;
     // Single line — labels carry value + rationale tail; keep echo to the value.
     const valueOnly = label.split("—")[0].trim().replace(/\s+/g, " ");
+    // Internal snake_case action ids (continue_session, save_exit, generate_plan,
+    // ask_followup…) are routing tokens the user should NEVER see. When the value
+    // is such an id, echo the human label alone instead of "continue_session · …".
+    // Short human verbs (accept, skip, override) have no underscore and keep the
+    // value-prefixed forensics form below.
+    if (/_/.test(verb))
+        return valueOnly || verb;
     if (ctx?.questionId) {
         return `${verb} · ${ctx.questionId}=${valueOnly}`;
     }
@@ -89,15 +96,28 @@ export function buildPreflightQuestion(pf) {
         questionId: pf.preflightId,
         phase: "preflight",
         question: `Approve discussion plan for: ${pf.problemStatement}`,
-        context: pf.participants.length > 0 ? `Participants: ${pf.participants.map((p) => p.role).join(", ")}` : undefined,
+        context: pf.participants.length > 0 ? `Panel: ${pf.participants.map((p) => p.model).join(", ")}` : undefined,
         options: [
-            { label: "Approve", value: "approve", kind: "choice", description: "Start the debate now" },
-            { label: "Reject", value: "reject", kind: "choice", description: "Cancel and rewrite the topic" },
+            { label: "Approve", value: "approve", kind: "choice", description: "Looks good — start the debate" },
+            { label: "Reject", value: "reject", kind: "choice", description: "Hold off — go back and rephrase the topic" },
         ],
         isRequired: true,
         defaultIndex: 0,
     };
 }
+/**
+ * F5 — the council entrypoint (council/index.ts) emits `leader`+`panel`+`topic`
+ * together exactly once, at the START of each debate; every later `council_meta`
+ * patch is partial (a lone roundBudget / researchMode / successCriteria /
+ * criteriaMet). That combination is the strongest new-council signal — stronger
+ * than a topic change, which misses a re-run on the SAME topic (auto-council
+ * re-firing on a phase, or a fresh /council after an Esc that skipped
+ * clearLiveTurnUi) and leaks the prior council's pinned criteria into the rail as
+ * stale ○ rows. The rail resets its meta+rounds on this.
+ */
+export function isCouncilStartPatch(patch) {
+    return !!patch.leader && !!patch.panel;
+}
 export function mapCouncilCardKey(key) {
     if (key.name === "up")
         return { kind: "up" };

package/dist/src/ui/utils/group-tool-entries.d.ts

@@ -0,0 +1,26 @@
+/**
+ * src/ui/utils/group-tool-entries.ts
+ *
+ * Rebuild the tool_group panels when a flat transcript is (re)loaded.
+ *
+ * WHY: the live turn renders tool calls inside a `tool_group` ChatEntry, but the
+ * persisted transcript stores one `tool_result` entry per call. Anything that
+ * replaces the message list with `agent.getChatEntries()` — the end-of-turn
+ * resync in finalizeActiveTurn, session load, resume — therefore DESTROYED the
+ * group and dropped the transcript back to one flat "→ <tool>" line per call.
+ * That is what a user sees after the answer lands, so the nice
+ * "Read 2 files, ran 1 shell command" recap only ever existed mid-turn.
+ *
+ * This folds consecutive tool_result entries back into a done/failed group.
+ */
+import type { ChatEntry } from "../../types/index.js";
+/**
+ * Fold runs of consecutive groupable tool_result entries into one tool_group
+ * entry each. Non-tool entries and rich results pass through untouched, so the
+ * transcript keeps its order. A run of one is still grouped: the recap line
+ * ("Read 1 file") is what stays visible once collapsed.
+ *
+ * `tool_call` entries are dropped inside a run — they are the pending twin of a
+ * result that is already represented by the item.
+ */
+export declare function groupToolEntries(entries: ChatEntry[]): ChatEntry[];

package/dist/src/ui/utils/group-tool-entries.js

@@ -0,0 +1,111 @@
+/**
+ * src/ui/utils/group-tool-entries.ts
+ *
+ * Rebuild the tool_group panels when a flat transcript is (re)loaded.
+ *
+ * WHY: the live turn renders tool calls inside a `tool_group` ChatEntry, but the
+ * persisted transcript stores one `tool_result` entry per call. Anything that
+ * replaces the message list with `agent.getChatEntries()` — the end-of-turn
+ * resync in finalizeActiveTurn, session load, resume — therefore DESTROYED the
+ * group and dropped the transcript back to one flat "→ <tool>" line per call.
+ * That is what a user sees after the answer lands, so the nice
+ * "Read 2 files, ran 1 shell command" recap only ever existed mid-turn.
+ *
+ * This folds consecutive tool_result entries back into a done/failed group.
+ */
+/**
+ * Tool results whose own renderer shows something a tool-group item line cannot
+ * (a plan, a sub-agent run, an image, streaming process logs). These stay as
+ * standalone entries and also break a run, so ordering is preserved.
+ */
+function rendersRichResult(entry) {
+    const name = entry.toolCall?.function.name ?? "";
+    const r = entry.toolResult;
+    if (!r)
+        return true;
+    if (r.plan || r.task || r.delegation || r.backgroundProcess || (r.media?.length ?? 0) > 0)
+        return true;
+    return (name === "generate_plan" ||
+        name === "task" ||
+        name === "delegate" ||
+        name === "delegation_list" ||
+        name === "delegation_read" ||
+        name === "lsp" ||
+        name === "process_logs" ||
+        name === "process_stop" ||
+        name === "process_list");
+}
+function groupable(entry) {
+    return entry.type === "tool_result" && !!entry.toolCall && !rendersRichResult(entry);
+}
+function toItem(entry) {
+    const at = entry.timestamp instanceof Date ? entry.timestamp.getTime() : Date.now();
+    const failed = entry.toolResult?.success === false;
+    return {
+        toolCall: entry.toolCall,
+        result: entry.toolResult,
+        startedAt: at,
+        finishedAt: at,
+        ...(failed ? { failed: true } : {}),
+    };
+}
+/**
+ * Fold runs of consecutive groupable tool_result entries into one tool_group
+ * entry each. Non-tool entries and rich results pass through untouched, so the
+ * transcript keeps its order. A run of one is still grouped: the recap line
+ * ("Read 1 file") is what stays visible once collapsed.
+ *
+ * `tool_call` entries are dropped inside a run — they are the pending twin of a
+ * result that is already represented by the item.
+ */
+export function groupToolEntries(entries) {
+    const out = [];
+    let run = [];
+    const flush = () => {
+        if (run.length === 0)
+            return;
+        const items = run.map(toItem);
+        const first = run[0];
+        const last = run[run.length - 1];
+        const startedAt = items[0].startedAt;
+        const finishedAt = items[items.length - 1].finishedAt ?? startedAt;
+        out.push({
+            type: "tool_group",
+            content: "",
+            timestamp: first.timestamp,
+            ...(first.modeColor ? { modeColor: first.modeColor } : {}),
+            ...(first.remoteKey ? { remoteKey: first.remoteKey } : {}),
+            ...(first.sourceLabel ? { sourceLabel: first.sourceLabel } : {}),
+            toolGroup: {
+                // Deterministic id: the same transcript must rebuild to the same ids, or
+                // React remounts every group on each resync and expansion state is lost.
+                id: `tg-restored-${startedAt}-${items.length}-${last.toolCall?.id ?? "x"}`,
+                state: items.some((i) => i.failed) ? "failed" : "done",
+                items,
+                startedAt,
+                finishedAt,
+                // The persisted entries carry a write-time timestamp, not the tool's real
+                // wall-clock span, so any duration derived here is fiction (a 10s turn
+                // rebuilt as "23ms"). Flag it and let the header omit the number rather
+                // than print a confident lie.
+                restored: true,
+            },
+        });
+        run = [];
+    };
+    for (const entry of entries) {
+        if (groupable(entry)) {
+            run.push(entry);
+            continue;
+        }
+        // A pending tool_call adjacent to a run is already covered by the run's
+        // items; dropping it prevents a duplicate line above the group.
+        if (entry.type === "tool_call" && run.length > 0)
+            continue;
+        flush();
+        out.push(entry);
+    }
+    flush();
+    return out;
+}
+//# sourceMappingURL=group-tool-entries.js.map

package/dist/src/ui/utils/tool-summary.d.ts

@@ -0,0 +1,21 @@
+/**
+ * src/ui/utils/tool-summary.ts
+ *
+ * Phrasing for the tool-group panel. Pure string helpers, no React, so the
+ * wording is unit-testable and the component stays presentational.
+ *
+ * Active:  "Reading 2 files…"          (header, present participle)
+ * Done:    "Read 2 files, ran 1 shell command"   (past-tense recap)
+ *
+ * Counting is per CATEGORY, not per tool name: read_file and
+ * mcp__filesystem__read_text_file are both "files" to a reader.
+ */
+export declare function categoryForTool(name: string): string;
+/**
+ * Header while the group runs: "Reading 2 files…".
+ * With a mixed batch the dominant category wins and the rest are summed into a
+ * trailing "+N more" so the header never claims work it isn't doing.
+ */
+export declare function activeToolGroupHeader(toolNames: readonly string[]): string;
+/** Past-tense recap once the group closes: "Read 2 files, ran 1 shell command". */
+export declare function doneToolGroupSummary(toolNames: readonly string[]): string;