muonroi-cli 1.3.4 → 1.4.1

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

@@ -0,0 +1,12 @@
+/**
+ * src/ui/slash/status.ts
+ *
+ * /status slash command — renders a ProgressSnapshot markdown card.
+ *
+ * Reads backlog.json + sprint-plan.json + interaction_logs for the current
+ * runId and productSlug. Falls back gracefully when no active run exists.
+ *
+ * Self-registers on module import.
+ */
+import type { SlashHandler } from "./registry.js";
+export declare const handleStatusSlash: SlashHandler;

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

@@ -0,0 +1,32 @@
+/**
+ * src/ui/slash/status.ts
+ *
+ * /status slash command — renders a ProgressSnapshot markdown card.
+ *
+ * Reads backlog.json + sprint-plan.json + interaction_logs for the current
+ * runId and productSlug. Falls back gracefully when no active run exists.
+ *
+ * Self-registers on module import.
+ */
+import { computeProgressSnapshot, renderSnapshotMarkdown } from "../../product-loop/progress-snapshot.js";
+import { registerSlash } from "./registry.js";
+export const handleStatusSlash = async (_args, ctx) => {
+    // Resolve flowDir from cwd — the planning directory convention.
+    const flowDir = `${ctx.cwd}/.planning`;
+    const runId = ctx.sessionId ?? "";
+    // productSlug: try to read from sessionId or fall back to cwd basename.
+    const productSlug = ctx.cwd ? (ctx.cwd.split(/[/\\]/).filter(Boolean).pop() ?? "unknown") : "unknown";
+    if (!runId) {
+        return "No active run. Start `/ideal` first.";
+    }
+    try {
+        const snapshot = await computeProgressSnapshot({ flowDir, runId, productSlug });
+        return renderSnapshotMarkdown(snapshot);
+    }
+    catch (err) {
+        return `Error computing status: ${err.message}`;
+    }
+};
+// Self-register on module import
+registerSlash("status", handleStatusSlash);
+//# sourceMappingURL=status.js.map

package/dist/src/ui/state/active-run.d.ts

@@ -0,0 +1,26 @@
+/**
+ * src/ui/state/active-run.ts
+ *
+ * Singleton store tracking the currently-active /ideal run.
+ * Used by StatusBar (B1) and the reporter auto-fire observer (B2).
+ *
+ * Lifecycle:
+ *  - setActiveRunId() called when sprint-plan-committed fires
+ *  - clearActiveRunId() called when the run ends (shipped / halted)
+ *  - Subscribers receive the new runId (or null) on every change
+ */
+export interface ActiveRunState {
+    runId: string | null;
+    flowDir: string | null;
+    productSlug: string | null;
+}
+type Listener = (state: ActiveRunState) => void;
+export declare const activeRunStore: {
+    getState: () => ActiveRunState;
+    setActiveRun: (runId: string, flowDir: string, productSlug: string) => void;
+    clearActiveRun: () => void;
+    subscribe: (fn: Listener) => (() => void);
+};
+/** Test helper: reset to initial state. */
+export declare function __resetActiveRunStoreForTests(): void;
+export {};

package/dist/src/ui/state/active-run.js

@@ -0,0 +1,44 @@
+/**
+ * src/ui/state/active-run.ts
+ *
+ * Singleton store tracking the currently-active /ideal run.
+ * Used by StatusBar (B1) and the reporter auto-fire observer (B2).
+ *
+ * Lifecycle:
+ *  - setActiveRunId() called when sprint-plan-committed fires
+ *  - clearActiveRunId() called when the run ends (shipped / halted)
+ *  - Subscribers receive the new runId (or null) on every change
+ */
+function makeActiveRunStore() {
+    let state = {
+        runId: null,
+        flowDir: null,
+        productSlug: null,
+    };
+    const listeners = new Set();
+    return {
+        getState: () => state,
+        setActiveRun: (runId, flowDir, productSlug) => {
+            state = { runId, flowDir, productSlug };
+            for (const l of listeners)
+                l(state);
+        },
+        clearActiveRun: () => {
+            state = { runId: null, flowDir: null, productSlug: null };
+            for (const l of listeners)
+                l(state);
+        },
+        subscribe: (fn) => {
+            listeners.add(fn);
+            return () => {
+                listeners.delete(fn);
+            };
+        },
+    };
+}
+export const activeRunStore = makeActiveRunStore();
+/** Test helper: reset to initial state. */
+export function __resetActiveRunStoreForTests() {
+    activeRunStore.clearActiveRun();
+}
+//# sourceMappingURL=active-run.js.map

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

@@ -7,7 +7,12 @@
  * Subscribes to statusBarStore for live updates (no polling).
  */
 import * as React from "react";
-import { type StatusBarState } from "./store.js";
+import { type SprintProgressSegment, type StatusBarState } from "./store.js";
+/**
+ * Format a SprintProgressSegment into the StatusBar display string.
+ * Format: Sprint N/M · X/Y stories · Z%
+ */
+export declare function renderSprintSegment(s: SprintProgressSegment): string;
 /** Pure render function -- testable without React hooks context. */
 export declare function renderStatusBar(s: StatusBarState): React.ReactElement;
 /** React component with hook-based subscription -- used in app.tsx layout. */

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

@@ -37,17 +37,32 @@ function fmtCost(usd) {
         return `$${usd.toFixed(3)}`;
     return `$${usd.toFixed(4)}`;
 }
+/**
+ * Format a SprintProgressSegment into the StatusBar display string.
+ * Format: Sprint N/M · X/Y stories · Z%
+ */
+export function renderSprintSegment(s) {
+    return `Sprint ${s.activeSprintNumber}/${s.totalSprints} · ${s.completedStories}/${s.totalStories} stories · ${s.overallPct}%`;
+}
 /** Pure render function -- testable without React hooks context. */
 export function renderStatusBar(s) {
     const modelLabel = s.routed_from && s.routed_from !== s.model
         ? `${s.provider || "-"}/${s.routed_from}→${s.model}`
         : `${s.provider || "-"}/${s.model || "-"}`;
-    const tokenStr = `↑${fmtTokens(s.in_tokens)} ↓${fmtTokens(s.out_tokens)}${s.cache_read_tokens ? ` ⊚${fmtTokens(s.cache_read_tokens)}` : ""}`;
+    // F5 — show context fill % (latest call vs model window) so the user can
+    // see how close they are to hitting the model's context limit, not just
+    // the cumulative billed input.
+    const ctxFill = s.ctx_pct !== undefined
+        ? ` ctx${s.ctx_pct}%`
+        : 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 ee = EE_DOT[s.ee_status] ?? EE_DOT.unknown;
     const slots = [
         React.createElement("text", { key: "pm", fg: "#5c9cf5", "data-testid": "slot-provider-model" }, modelLabel),
         React.createElement(TierBadge, { key: "tier", tier: s.tier }),
-        React.createElement("text", { key: "tok", fg: "cyan", "data-testid": "slot-tokens" }, `${tokenStr}${s.ctx_tokens !== undefined ? ` [ctx: ${fmtTokens(s.ctx_tokens)}]` : ""}${s.compaction_summary ? ` [${s.compaction_summary}]` : ""} ${fmtCost(s.session_usd)}`),
+        React.createElement("text", { key: "tok", fg: "cyan", "data-testid": "slot-tokens" }, `${tokenStr}${s.compaction_summary ? ` [${s.compaction_summary}]` : ""} ${fmtCost(s.session_usd)}`),
         React.createElement(UsdMeter, {
             key: "usd",
             session_usd: s.session_usd,
@@ -56,6 +71,10 @@ export function renderStatusBar(s) {
         }),
         React.createElement("text", { key: "ee", fg: ee.color, "data-testid": "slot-ee" }, ee.symbol),
     ];
+    // Sprint progress segment (B1) — only shown when an /ideal run is active.
+    if (s.sprint) {
+        slots.push(React.createElement("text", { key: "sprint", fg: "#a0e0a0", "data-testid": "slot-sprint" }, renderSprintSegment(s.sprint)));
+    }
     if (s.degraded) {
         slots.push(React.createElement("text", { key: "deg", fg: "yellow", blink: true, "data-testid": "slot-degraded" }, "DEGRADED"));
     }

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

@@ -17,7 +17,14 @@ vi.mock("../../usage/thresholds.js", () => ({
 vi.mock("../../usage/downgrade.js", () => ({
     subscribeDowngrade: () => () => { },
 }));
-import { renderStatusBar } from "./index.js";
+vi.mock("../state/active-run.js", () => ({
+    activeRunStore: {
+        getState: () => ({ runId: null, flowDir: null, productSlug: null }),
+        subscribe: () => () => { },
+        clearActiveRun: () => { },
+    },
+}));
+import { renderSprintSegment, renderStatusBar } from "./index.js";
 function makeState(overrides = {}) {
     return {
         provider: "",
@@ -76,5 +83,57 @@ describe("StatusBar (renderStatusBar)", () => {
         // Should have ' | ' separators
         expect(json).toContain(" | ");
     });
+    // B1: sprint progress segment tests
+    it("hides sprint segment when sprint is undefined", () => {
+        const el = renderStatusBar(makeState({ sprint: undefined }));
+        expect(JSON.stringify(el)).not.toContain("slot-sprint");
+    });
+    it("shows sprint segment with correct text when sprint is present", () => {
+        const sprint = {
+            activeSprintNumber: 2,
+            totalSprints: 5,
+            completedStories: 3,
+            totalStories: 8,
+            overallPct: 37.5,
+        };
+        const el = renderStatusBar(makeState({ sprint }));
+        const json = JSON.stringify(el);
+        expect(json).toContain("slot-sprint");
+        expect(json).toContain("Sprint 2/5");
+        expect(json).toContain("3/8 stories");
+        expect(json).toContain("37.5%");
+    });
+});
+describe("renderSprintSegment", () => {
+    it("formats the segment correctly", () => {
+        const seg = {
+            activeSprintNumber: 1,
+            totalSprints: 3,
+            completedStories: 0,
+            totalStories: 4,
+            overallPct: 0,
+        };
+        expect(renderSprintSegment(seg)).toBe("Sprint 1/3 · 0/4 stories · 0%");
+    });
+    it("formats with non-zero values", () => {
+        const seg = {
+            activeSprintNumber: 3,
+            totalSprints: 3,
+            completedStories: 4,
+            totalStories: 4,
+            overallPct: 100,
+        };
+        expect(renderSprintSegment(seg)).toBe("Sprint 3/3 · 4/4 stories · 100%");
+    });
+    it("handles decimal overallPct", () => {
+        const seg = {
+            activeSprintNumber: 2,
+            totalSprints: 4,
+            completedStories: 2,
+            totalStories: 5,
+            overallPct: 33.3,
+        };
+        expect(renderSprintSegment(seg)).toBe("Sprint 2/4 · 2/5 stories · 33.3%");
+    });
 });
 //# sourceMappingURL=index.test.js.map

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

@@ -5,6 +5,18 @@
  * wireStatusBar() connects to routerStore (Plan 03), subscribeThresholds (Plan 04),
  * and subscribeDowngrade (Plan 05).
  */
+export interface SprintProgressSegment {
+    /** Active sprint index (1-based). */
+    activeSprintNumber: number;
+    /** Total number of sprints in the plan. */
+    totalSprints: number;
+    /** Completed stories in the active sprint. */
+    completedStories: number;
+    /** Total stories in the active sprint. */
+    totalStories: number;
+    /** Overall completion % across ALL sprints (0-100, 1 decimal). */
+    overallPct: number;
+}
 export interface StatusBarState {
     provider: string;
     model: string;
@@ -21,7 +33,11 @@ export interface StatusBarState {
     routed_from: string | null;
     ee_status: "ok" | "warn" | "down" | "unknown";
     ctx_tokens?: number;
+    /** F5 — percent of model contextWindow filled by the latest call. */
+    ctx_pct?: number;
     compaction_summary?: string;
+    /** Sprint progress segment — present only while an /ideal run is active. */
+    sprint?: SprintProgressSegment;
 }
 type Listener = (s: StatusBarState) => void;
 export declare const statusBarStore: {

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

@@ -9,6 +9,7 @@ import { getCircuitState } from "../../ee/client.js";
 import { routerStore } from "../../router/store.js";
 import { subscribeDowngrade } from "../../usage/downgrade.js";
 import { subscribeThresholds } from "../../usage/thresholds.js";
+import { activeRunStore } from "../state/active-run.js";
 function makeStore() {
     let state = {
         provider: "",
@@ -105,7 +106,7 @@ export function wireStatusBar() {
             const timeout = setTimeout(() => controller.abort(), 5000);
             const headers = {};
             if (eeAuthToken)
-                headers["Authorization"] = `Bearer ${eeAuthToken}`;
+                headers.Authorization = `Bearer ${eeAuthToken}`;
             const res = await fetch(`${eeBaseUrl}/health`, { signal: controller.signal, headers });
             clearTimeout(timeout);
             if (res.ok) {
@@ -128,12 +129,129 @@ export function wireStatusBar() {
     }
     checkEEHealth();
     eeTimer = setInterval(checkEEHealth, 30_000);
+    // ── Sprint progress polling (B1) ───────────────────────────────────────────
+    // Cache the last-read snapshot so we don't hit disk on every 5s tick when
+    // nothing has changed. Invalidated by active-run subscription on sprint_stage.
+    let sprintSnapshotDirty = false;
+    let sprintPollTimer = null;
+    async function refreshSprintProgress() {
+        const run = activeRunStore.getState();
+        if (!run.runId || !run.flowDir) {
+            statusBarStore.setState({ sprint: undefined });
+            return;
+        }
+        try {
+            // Lazy import to avoid circular dependency at module load time.
+            const { readBacklog } = await import("../../product-loop/backlog-store.js");
+            const { readSprintPlan } = await import("../../product-loop/sprint-store.js");
+            const [backlog, sprintPlan] = await Promise.all([
+                readBacklog(run.flowDir, run.runId).catch(() => null),
+                readSprintPlan(run.flowDir, run.runId).catch(() => null),
+            ]);
+            if (!sprintPlan || sprintPlan.sprints.length === 0) {
+                statusBarStore.setState({ sprint: undefined });
+                return;
+            }
+            const activeSprint = sprintPlan.activeSprintId
+                ? (sprintPlan.sprints.find((s) => s.id === sprintPlan.activeSprintId) ?? null)
+                : null;
+            // Overall completion: all done items across all sprints / all items in all sprints
+            const allItemIds = sprintPlan.sprints.flatMap((s) => s.itemIds);
+            const allItems = backlog
+                ? allItemIds
+                    .map((id) => backlog.items.find((i) => i.id === id))
+                    .filter((i) => i !== undefined)
+                : [];
+            const totalAllItems = allItems.length;
+            const doneAllItems = allItems.filter((i) => i.status === "done").length;
+            const overallPct = totalAllItems > 0 ? Math.round((doneAllItems / totalAllItems) * 1000) / 10 : 0;
+            if (!activeSprint) {
+                // No active sprint but plan exists — show total/overall only.
+                statusBarStore.setState({
+                    sprint: {
+                        activeSprintNumber: sprintPlan.sprints.length,
+                        totalSprints: sprintPlan.sprints.length,
+                        completedStories: doneAllItems,
+                        totalStories: totalAllItems,
+                        overallPct,
+                    },
+                });
+                return;
+            }
+            const activeItems = backlog
+                ? activeSprint.itemIds
+                    .map((id) => backlog.items.find((i) => i.id === id))
+                    .filter((i) => i !== undefined)
+                : [];
+            const completedStories = activeItems.filter((i) => i.status === "done").length;
+            statusBarStore.setState({
+                sprint: {
+                    activeSprintNumber: activeSprint.number,
+                    totalSprints: sprintPlan.sprints.length,
+                    completedStories,
+                    totalStories: activeItems.length,
+                    overallPct,
+                },
+            });
+        }
+        catch {
+            // Non-fatal — hide the segment rather than crash
+            statusBarStore.setState({ sprint: undefined });
+        }
+    }
+    // Subscribe to active-run changes: immediately refresh on run start/end.
+    const offActiveRun = activeRunStore.subscribe(() => {
+        sprintSnapshotDirty = true;
+        void refreshSprintProgress();
+    });
+    // Also subscribe to global sprint_stage events to invalidate cache.
+    // We tap the same globalThis.__muonroiAgentRuntime emitEvent that the harness uses,
+    // but since we're in a module-level function we register a listener via a
+    // lightweight per-process event bus instead.
+    const sprintStageHandler = (e) => {
+        if (!e || typeof e !== "object")
+            return;
+        const ev = e;
+        if (ev.t === "event" && (ev.kind === "sprint-stage" || ev.kind === "sprint_stage")) {
+            sprintSnapshotDirty = true;
+            void refreshSprintProgress();
+        }
+    };
+    // Register on the global event bus if available.
+    const globals = globalThis;
+    const existingRuntime = globals.__muonroiAgentRuntime;
+    let patchedEmit = null;
+    let originalEmit = null;
+    if (existingRuntime && typeof existingRuntime.emitEvent === "function") {
+        originalEmit = existingRuntime.emitEvent.bind(existingRuntime);
+        patchedEmit = (e) => {
+            sprintStageHandler(e);
+            originalEmit(e);
+        };
+        existingRuntime.emitEvent = patchedEmit;
+    }
+    // Fallback 5s poll for environments without the harness event bus.
+    sprintPollTimer = setInterval(() => {
+        if (sprintSnapshotDirty || activeRunStore.getState().runId) {
+            sprintSnapshotDirty = false;
+            void refreshSprintProgress();
+        }
+    }, 5_000);
+    // Initial load.
+    void refreshSprintProgress();
     return () => {
         offRouter();
         offThresholds();
         offDowngrade();
+        offActiveRun();
         if (eeTimer)
             clearInterval(eeTimer);
+        if (sprintPollTimer)
+            clearInterval(sprintPollTimer);
+        // Restore original emitEvent if we patched it.
+        if (patchedEmit && originalEmit && existingRuntime && existingRuntime.emitEvent === patchedEmit) {
+            existingRuntime.emitEvent = originalEmit;
+        }
         wired = false;
     };
 }
@@ -155,6 +273,7 @@ export function __resetStatusBarStoreForTests() {
         routed_from: null,
         ee_status: "unknown",
         ctx_tokens: undefined,
+        sprint: undefined,
     });
     wired = false;
 }

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,50 @@
+import { describe, expect, it } from "vitest";
+import { buildToolGroupEntry, formatAnswerForLog } from "../format.js";
+describe("formatAnswerForLog", () => {
+    it("freetext: returns text verbatim (or '(empty)' for blank)", () => {
+        expect(formatAnswerForLog({ kind: "freetext", text: "hello" })).toBe("hello");
+        expect(formatAnswerForLog({ kind: "freetext", text: "" })).toBe("(empty)");
+    });
+    it("chat: returns placeholder", () => {
+        expect(formatAnswerForLog({ kind: "chat", text: "anything" })).toBe("[Chat about this]");
+    });
+    it("choice without context: bare verb (legacy behaviour)", () => {
+        expect(formatAnswerForLog({ kind: "choice", text: "accept" })).toBe("accept");
+        expect(formatAnswerForLog({ kind: "choice", text: "skip" })).toBe("skip");
+    });
+    it("choice with selectedOptionLabel: appends value", () => {
+        expect(formatAnswerForLog({ kind: "choice", text: "accept" }, { selectedOptionLabel: '"internal-tool"' })).toBe('accept · "internal-tool"');
+    });
+    it("choice with selectedOptionLabel + questionId: includes field name", () => {
+        expect(formatAnswerForLog({ kind: "choice", text: "accept" }, { selectedOptionLabel: '"internal-tool"', questionId: "productType" })).toBe('accept · productType="internal-tool"');
+    });
+    it("choice: strips rationale tail (everything after em-dash)", () => {
+        expect(formatAnswerForLog({ kind: "choice", text: "override" }, {
+            selectedOptionLabel: '"consumer-app" — Could be packaged as a standalone desktop app',
+            questionId: "productType",
+        })).toBe('override · productType="consumer-app"');
+    });
+    it("choice: when label === verb, no decoration (avoid 'accept · accept')", () => {
+        expect(formatAnswerForLog({ kind: "choice", text: "accept" }, { selectedOptionLabel: "accept" })).toBe("accept");
+    });
+    it("choice: empty/whitespace label is treated as missing", () => {
+        expect(formatAnswerForLog({ kind: "choice", text: "accept" }, { selectedOptionLabel: "   " })).toBe("accept");
+    });
+});
+describe("buildToolGroupEntry", () => {
+    it("creates an active group with a unique id and empty items list", () => {
+        const e1 = buildToolGroupEntry();
+        const e2 = buildToolGroupEntry();
+        expect(e1.type).toBe("tool_group");
+        expect(e1.toolGroup?.state).toBe("active");
+        expect(e1.toolGroup?.items).toEqual([]);
+        expect(e1.toolGroup?.id).not.toBe(e2.toolGroup?.id);
+        expect(typeof e1.toolGroup?.startedAt).toBe("number");
+    });
+    it("propagates partial ChatEntry overrides to the entry", () => {
+        const e = buildToolGroupEntry({ modeColor: "#ff0000", sourceLabel: "test-source" });
+        expect(e.modeColor).toBe("#ff0000");
+        expect(e.sourceLabel).toBe("test-source");
+    });
+});
+//# sourceMappingURL=format.test.js.map

package/dist/src/ui/utils/__tests__/tools.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/ui/utils/__tests__/tools.test.js

@@ -0,0 +1,48 @@
+import { describe, expect, it } from "vitest";
+import { dominantVerb, verbForTool } from "../tools.js";
+describe("verbForTool", () => {
+    it("maps the common read tools to 'Reading'", () => {
+        expect(verbForTool("read_file")).toBe("Reading");
+        expect(verbForTool("read_multiple_files")).toBe("Reading");
+        expect(verbForTool("mcp_filesystem__read_text_file")).toBe("Reading");
+        expect(verbForTool("mcp__filesystem__read_file")).toBe("Reading");
+    });
+    it("maps shell to 'Running'", () => {
+        expect(verbForTool("bash")).toBe("Running");
+    });
+    it("maps grep / web search / file search to 'Searching'", () => {
+        expect(verbForTool("grep")).toBe("Searching");
+        expect(verbForTool("search_web")).toBe("Searching");
+        expect(verbForTool("search_x")).toBe("Searching");
+        expect(verbForTool("search_files")).toBe("Searching");
+        expect(verbForTool("mcp_filesystem__search_files")).toBe("Searching");
+    });
+    it("maps edit/write to 'Editing'", () => {
+        expect(verbForTool("edit_file")).toBe("Editing");
+        expect(verbForTool("write_file")).toBe("Editing");
+        expect(verbForTool("mcp__filesystem__edit_file")).toBe("Editing");
+    });
+    it("maps task / delegate to 'Exploring'", () => {
+        expect(verbForTool("task")).toBe("Exploring");
+        expect(verbForTool("delegate")).toBe("Exploring");
+    });
+    it("falls back to 'Working' for unknown tools", () => {
+        expect(verbForTool("zzz_unknown")).toBe("Working");
+    });
+});
+describe("dominantVerb", () => {
+    it("returns 'Working' for empty input", () => {
+        expect(dominantVerb([])).toBe("Working");
+    });
+    it("returns the verb of a single tool", () => {
+        expect(dominantVerb(["read_file"])).toBe("Reading");
+    });
+    it("picks the most-frequent verb across mixed tool names", () => {
+        // 3 reads, 1 bash → Reading wins
+        expect(dominantVerb(["read_file", "read_file", "read_file", "bash"])).toBe("Reading");
+    });
+    it("survives unknown tools by falling back to 'Working'", () => {
+        expect(dominantVerb(["zzz", "zzz"])).toBe("Working");
+    });
+});
+//# sourceMappingURL=tools.test.js.map

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

@@ -3,12 +3,29 @@ import type { ScheduleDaemonStatus, StoredSchedule } from "../../tools/schedule.
 import type { ChatEntry, CouncilQuestionData, ToolCall, ToolResult } from "../../types/index.js";
 import type { CouncilCardKey } from "../components/council-question-card.js";
 export declare function formatScheduleDetails(schedule: StoredSchedule, daemonStatus: ScheduleDaemonStatus): string;
+/**
+ * Render the user's AskCard answer for inclusion in the chat log.
+ *
+ * For choice-kind answers we used to display the bare verb ("accept",
+ * "override", "skip") which makes the log meaningless when 6 cards in a row
+ * resolve as "accept / accept / accept …" — the user can't tell what they
+ * actually agreed to. Now we append the selected option's label when one is
+ * known, so the entry becomes e.g. `accept · productType="internal-tool"` or
+ * `override · "consumer-app"`.
+ *
+ * The `questionId` (when provided) is normalized to a short prefix so the
+ * entry remains scannable, e.g. `accept · targetPlatform=["cli"]`.
+ */
 export declare function formatAnswerForLog(ans: {
     kind: string;
     text: string;
+}, ctx?: {
+    selectedOptionLabel?: string;
+    questionId?: string;
 }): string;
 export declare function buildAssistantEntry(content: string, extra?: Partial<ChatEntry>): ChatEntry;
 export declare function buildToolResultEntry(toolCall: ToolCall, toolResult: ToolResult, extra?: Partial<ChatEntry>): ChatEntry;
+export declare function buildToolGroupEntry(extra?: Partial<ChatEntry>): ChatEntry;
 export declare function buildUserEntry(content: string, extra?: Partial<ChatEntry>): ChatEntry;
 export declare function buildPreflightQuestion(pf: {
     preflightId: string;

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

@@ -17,12 +17,34 @@ export function formatScheduleDetails(schedule, daemonStatus) {
         schedule.instruction,
     ].join("\n");
 }
-export function formatAnswerForLog(ans) {
+/**
+ * Render the user's AskCard answer for inclusion in the chat log.
+ *
+ * For choice-kind answers we used to display the bare verb ("accept",
+ * "override", "skip") which makes the log meaningless when 6 cards in a row
+ * resolve as "accept / accept / accept …" — the user can't tell what they
+ * actually agreed to. Now we append the selected option's label when one is
+ * known, so the entry becomes e.g. `accept · productType="internal-tool"` or
+ * `override · "consumer-app"`.
+ *
+ * The `questionId` (when provided) is normalized to a short prefix so the
+ * entry remains scannable, e.g. `accept · targetPlatform=["cli"]`.
+ */
+export function formatAnswerForLog(ans, ctx) {
     if (ans.kind === "freetext")
         return ans.text || "(empty)";
     if (ans.kind === "chat")
         return "[Chat about this]";
-    return ans.text;
+    const verb = ans.text;
+    const label = ctx?.selectedOptionLabel?.trim();
+    if (!label || label === verb)
+        return verb;
+    // Single line — labels carry value + rationale tail; keep echo to the value.
+    const valueOnly = label.split("—")[0].trim().replace(/\s+/g, " ");
+    if (ctx?.questionId) {
+        return `${verb} · ${ctx.questionId}=${valueOnly}`;
+    }
+    return `${verb} · ${valueOnly}`;
 }
 export function buildAssistantEntry(content, extra) {
     return { type: "assistant", content, timestamp: new Date(), ...extra };
@@ -38,6 +60,27 @@ export function buildToolResultEntry(toolCall, toolResult, extra) {
         ...extra,
     };
 }
+let toolGroupSeq = 0;
+// Create a fresh active tool-group entry. Caller is expected to append items
+// via setMessages mutation keyed on `toolGroup.id`, and close the group by
+// setting `state` to "done" / "failed" once the assistant emits text or the
+// stream ends.
+export function buildToolGroupEntry(extra) {
+    const now = Date.now();
+    const id = `tg-${now}-${++toolGroupSeq}`;
+    return {
+        type: "tool_group",
+        content: "",
+        timestamp: new Date(now),
+        toolGroup: {
+            id,
+            state: "active",
+            items: [],
+            startedAt: now,
+        },
+        ...extra,
+    };
+}
 export function buildUserEntry(content, extra) {
     return { type: "user", content, timestamp: new Date(), ...extra };
 }

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

@@ -6,7 +6,8 @@ export function formatTokenCount(tokens) {
     return String(tokens);
 }
 export function trunc(s, n) {
-    return s.length <= n ? s : `${s.slice(0, n)}…`;
+    const str = String(s ?? "");
+    return str.length <= n ? str : `${str.slice(0, n)}…`;
 }
 export function truncateLine(s, n) {
     return trunc(s.replace(/\s+/g, " ").trim(), n);

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

@@ -5,4 +5,6 @@ export declare function describeMcpFsTool(name: string): {
 } | null;
 export declare function toolArgs(tc?: ToolCall): string;
 export declare function tryParseArg(tc: ToolCall | undefined, key: string): string;
+export declare function verbForTool(name: string): string;
+export declare function dominantVerb(toolNames: readonly string[]): string;
 export declare function toolLabel(tc: ToolCall): string;