muonroi-cli 1.6.0 → 1.6.2

package/dist/src/storage/session-experience-store.test.js

@@ -0,0 +1,86 @@
+/**
+ * session-experience-store — persist + cross-session aggregate of the anti-mù
+ * counters that decide whether compaction friction is real at a painful rate.
+ */
+import { afterEach, describe, expect, it, vi } from "vitest";
+vi.mock("./db.js", () => ({ getDatabase: vi.fn(() => ({ prepare: () => ({ all: () => [] }) })) }));
+const logInteraction = vi.fn();
+vi.mock("./interaction-log.js", () => ({ logInteraction: (...a) => logInteraction(...a) }));
+import { computeExperienceAggregate, persistSessionExperience, } from "./session-experience-store.js";
+function counts(p = {}) {
+    return {
+        compactions: 0,
+        elided: 0,
+        totalElidedChars: 0,
+        rehydratedCache: 0,
+        rehydratedDisk: 0,
+        rehydratedEe: 0,
+        unavailable: 0,
+        eeTimeouts: 0,
+        eeErrors: 0,
+        ...p,
+    };
+}
+function row(sessionId, createdAt, c) {
+    return { session_id: sessionId, created_at: createdAt, metadata_json: JSON.stringify(counts(c)) };
+}
+describe("persistSessionExperience", () => {
+    afterEach(() => logInteraction.mockClear());
+    it("no-ops on a missing sessionId", () => {
+        persistSessionExperience(undefined, counts({ elided: 3 }));
+        persistSessionExperience("", counts({ elided: 3 }));
+        expect(logInteraction).not.toHaveBeenCalled();
+    });
+    it("no-ops on an all-zero snapshot (no signal to store)", () => {
+        persistSessionExperience("sess-1", counts());
+        expect(logInteraction).not.toHaveBeenCalled();
+    });
+    it("writes a session_experience snapshot when something happened", () => {
+        persistSessionExperience("sess-1", counts({ compactions: 2, elided: 5, rehydratedCache: 1 }));
+        expect(logInteraction).toHaveBeenCalledTimes(1);
+        const [sid, type, meta] = logInteraction.mock.calls[0];
+        expect(sid).toBe("sess-1");
+        expect(type).toBe("session_experience");
+        expect(meta.data.elided).toBe(5);
+    });
+});
+describe("computeExperienceAggregate", () => {
+    it("dedups to the latest row per session (rows newest-first) and sums totals", () => {
+        const rows = [
+            // sess-a newest first (cumulative) then an older row that must be ignored
+            row("sess-a", "2026-06-17T10:00:00Z", { compactions: 3, elided: 6, rehydratedCache: 4, unavailable: 1 }),
+            row("sess-a", "2026-06-17T09:00:00Z", { compactions: 1, elided: 2 }),
+            row("sess-b", "2026-06-17T08:00:00Z", { compactions: 1, elided: 2, rehydratedEe: 1, unavailable: 1 }),
+        ];
+        const agg = computeExperienceAggregate(rows);
+        expect(agg.sessionCount).toBe(2);
+        expect(agg.totals.elided).toBe(8); // 6 (latest a) + 2 (b), NOT the stale 2
+        expect(agg.totals.compactions).toBe(4); // 3 + 1
+        expect(agg.sessionsWithElision).toBe(2);
+        expect(agg.sessionsWithUnavailable).toBe(2);
+        // recovery = rehydrated(4+0+1) / (rehydrated 5 + unavailable 2) = 5/7
+        expect(agg.rehydrateRecoveryRate).toBeCloseTo(5 / 7, 5);
+    });
+    it("recovery rate is 1 when no rehydrate was ever attempted", () => {
+        const agg = computeExperienceAggregate([row("s", "2026-06-17T10:00:00Z", { compactions: 1, elided: 2 })]);
+        expect(agg.rehydrateRecoveryRate).toBe(1);
+        expect(agg.sessionsWithUnavailable).toBe(0);
+    });
+    it("caps at `limit` sessions and skips unparseable rows", () => {
+        const rows = [
+            row("s1", "2026-06-17T10:00:03Z", { elided: 1 }),
+            { session_id: "s2", created_at: "2026-06-17T10:00:02Z", metadata_json: "{bad json" },
+            row("s3", "2026-06-17T10:00:01Z", { elided: 1 }),
+        ];
+        const agg = computeExperienceAggregate(rows, 1);
+        expect(agg.sessionCount).toBe(1);
+        expect(agg.perSession[0].sessionId).toBe("s1");
+    });
+    it("empty input yields an empty aggregate with recovery rate 1", () => {
+        const agg = computeExperienceAggregate([]);
+        expect(agg.sessionCount).toBe(0);
+        expect(agg.totals.elided).toBe(0);
+        expect(agg.rehydrateRecoveryRate).toBe(1);
+    });
+});
+//# sourceMappingURL=session-experience-store.test.js.map

package/dist/src/storage/tool-results.js

@@ -31,6 +31,29 @@ export function extractToolResultFromOutput(output) {
             output: String(output.value),
         };
     }
+    // MCP tool results: `{ type: "content", value: [{ type: "text", text }, ...] }`
+    // (see cap-tool-result.ts). Before this branch, extraction returned null, so
+    // persisted output_json was the raw envelope with NO `success` field — on
+    // reload the renderer read `toolResult.success` as undefined and displayed
+    // "Error" for a SUCCESSFUL call (session 63f2d542b772: 50 muonroi-docs calls,
+    // 0 DB failures, all shown as "Error"). Flatten the text parts so it round-
+    // trips as a real ToolResult. A genuinely failed MCP call throws → the SDK
+    // records an `error-text` part, handled above, so content == success here.
+    if ("type" in output && output.type === "content" && "value" in output && Array.isArray(output.value)) {
+        const parts = output.value;
+        const text = parts
+            .filter((p) => !!p &&
+            typeof p === "object" &&
+            p.type === "text" &&
+            typeof p.text === "string")
+            .map((p) => p.text)
+            .join("\n");
+        const nonText = parts.length - parts.filter((p) => p?.type === "text").length;
+        return {
+            success: true,
+            output: text || (nonText > 0 ? `[${nonText} non-text MCP part(s)]` : "(empty MCP result)"),
+        };
+    }
     return null;
 }
 export function getOutputKind(output) {

package/dist/src/storage/tool-results.test.d.ts

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

package/dist/src/storage/tool-results.test.js

@@ -0,0 +1,48 @@
+import { describe, expect, it } from "vitest";
+import { extractToolResultFromOutput, isOutputSuccess } from "./tool-results.js";
+describe("extractToolResultFromOutput", () => {
+    it("passes through a native ToolResult shape", () => {
+        const r = extractToolResultFromOutput({ success: true, output: "hi" });
+        expect(r).toMatchObject({ success: true, output: "hi" });
+    });
+    it("treats error-text as a failure", () => {
+        const r = extractToolResultFromOutput({ type: "error-text", value: "boom" });
+        expect(r).toMatchObject({ success: false, error: "boom" });
+    });
+    it("flattens an MCP content envelope into a successful ToolResult (session 63f2d542b772)", () => {
+        // MCP tools return { type: "content", value: [{ type: "text", text }] }.
+        // Before the fix this returned null, so the persisted output_json had no
+        // `success` field and the renderer showed "Error" for a successful call.
+        const out = {
+            type: "content",
+            value: [
+                { type: "text", text: "package list" },
+                { type: "text", text: "more" },
+            ],
+        };
+        const r = extractToolResultFromOutput(out);
+        expect(r).toMatchObject({ success: true, output: "package list\nmore" });
+    });
+    it("round-trips through JSON so the renderer reads success=true (the actual bug)", () => {
+        // transcript.loadStoredToolResults does JSON.parse(output_json) and the
+        // renderer reads `.success`. Simulate persist→load and assert it is NOT
+        // misread as an error.
+        const mcpOutput = { type: "content", value: [{ type: "text", text: "## Muonroi.Core\nNuGet: Muonroi.Core" }] };
+        const persisted = JSON.stringify(extractToolResultFromOutput(mcpOutput));
+        const loaded = JSON.parse(persisted);
+        const rendered = loaded.success ? loaded.output || "Success" : loaded.error || "Error";
+        expect(rendered).toContain("Muonroi.Core");
+        expect(rendered).not.toBe("Error");
+    });
+    it("describes a non-text-only MCP content result instead of dropping to Error", () => {
+        const out = { type: "content", value: [{ type: "image", data: "..." }] };
+        const r = extractToolResultFromOutput(out);
+        expect(r?.success).toBe(true);
+        expect(r?.output).toMatch(/non-text MCP part/);
+    });
+    it("isOutputSuccess still treats content envelopes as success", () => {
+        expect(isOutputSuccess({ type: "content", value: [] })).toBe(true);
+        expect(isOutputSuccess({ type: "error-text", value: "x" })).toBe(false);
+    });
+});
+//# sourceMappingURL=tool-results.test.js.map

package/dist/src/storage/ui-interaction-log.js

@@ -27,8 +27,10 @@ export function logUIInteraction(sessionId, payload) {
             data: payload.data,
         });
     }
-    catch {
-        // Fail-open
+    catch (err) {
+        // Fail-open (logInteraction is itself guarded; this is defensive). Surface
+        // the subtype so a serialization fault here is at least diagnosable.
+        console.error(`[ui-interaction-log] persist failed for subtype=${payload.subtype}: ${err?.message}`);
     }
 }
 //# sourceMappingURL=ui-interaction-log.js.map

package/dist/src/tools/registry-ee-query.test.js

@@ -11,6 +11,7 @@
 import os from "node:os";
 import { afterEach, describe, expect, it } from "vitest";
 import { __resetArtifactCacheForTests, recordArtifact } from "../ee/artifact-cache.js";
+import { __resetSessionExperienceForTests, getSessionExperience } from "../orchestrator/session-experience.js";
 import { BashTool } from "./bash.js";
 import { createBuiltinTools, isToolArtifactQuery } from "./registry.js";
 describe("ee_query builtin tool", () => {
@@ -47,7 +48,10 @@ describe("isToolArtifactQuery — ee_query intent routing", () => {
     });
 });
 describe("ee_query — anti-mù rehydrate (local-first, durable when EE is down)", () => {
-    afterEach(() => __resetArtifactCacheForTests());
+    afterEach(() => {
+        __resetArtifactCacheForTests();
+        __resetSessionExperienceForTests();
+    });
     it("rehydrates a tool-artifact from the in-session cache with NO EE/network call", async () => {
         // Simulates: the compactor elided this output earlier (recordArtifact), EE is
         // now down. The agent's ee_query("tool-artifact id=X") must still return the
@@ -60,6 +64,8 @@ describe("ee_query — anti-mù rehydrate (local-first, durable when EE is down)
         expect(out).toContain("tool=read_file");
         expect(out).toContain("FULL ELIDED CONTENT");
         expect(out).not.toMatch(/ee_unavailable/);
+        // Lived-experience telemetry recorded the cache-sourced rehydrate.
+        expect(getSessionExperience().rehydrations.cache).toBe(1);
     });
 });
 //# sourceMappingURL=registry-ee-query.test.js.map

package/dist/src/tools/registry.js

@@ -471,10 +471,15 @@ export function createBuiltinTools(bash, mode, opts) {
                         // lookup this is the authoritative full content for THIS session and
                         // works even when EE is down — the failure window long sessions hit.
                         const { findArtifactByQuery, findArtifactOnDisk } = await import("../ee/artifact-cache.js");
+                        // Lived-experience telemetry: record where the rehydrate came from so
+                        // a "cảm nhận trong CLI" question (and the measure-first instrumentation)
+                        // sees cache vs disk vs ee vs needed-but-unavailable.
+                        const { recordRehydration } = await import("../orchestrator/session-experience.js");
                         const mem = findArtifactByQuery(query);
                         const local = mem ?? (await findArtifactOnDisk(query));
                         if (local) {
                             const src = mem ? "in-session cache" : "local disk cache";
+                            recordRehydration(mem ? "cache" : "disk");
                             return truncateOutput(`[tool-artifact id=${local.toolCallId} tool=${local.toolName} — rehydrated from ${src}]\n${local.content}`);
                         }
                         // EE fallback (cross-session / post-restart) → raw /api/search exact lookup.
@@ -484,8 +489,10 @@ export function createBuiltinTools(bash, mode, opts) {
                             ...(typeof input?.limit === "number" ? { limit: input.limit } : {}),
                         });
                         if (resp === null) {
+                            recordRehydration("unavailable");
                             return "[ee_unavailable] Experience Engine returned no response (server down, timeout, circuit open, or unconfigured) and the artifact is not in this session's local cache. Proceed without EE recall — re-read the source directly if you need the elided content.";
                         }
+                        recordRehydration("ee");
                         return truncateOutput(JSON.stringify(resp));
                     }
                     // General recall → /api/recall (recallMode, [id col] index + surface).

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

@@ -308,6 +308,12 @@ export interface ExperienceWarningData {
 export interface ExperienceInjectedData {
     pointCount: number;
     pointIds: string[];
+    /** Per-point detail so the TUI can show WHAT was injected, not just the count. */
+    points?: Array<{
+        id: string;
+        title: string;
+        tier: "principle" | "behavioral" | "checkpoint";
+    }>;
     scoreFloor: number;
     taskType?: string;
     domain?: string;

package/dist/src/ui/__tests__/markdown-render.test.js

@@ -39,6 +39,23 @@ describe("parseInline — marker concealment", () => {
         expect(text(parseInline("a **partial answer", t))).toBe("a **partial answer");
         expect(text(parseInline("trailing `code", t))).toBe("trailing `code");
     });
+    it("does NOT treat intra-word underscores as emphasis (identifiers stay intact)", () => {
+        // Session 584ba476c07a rendered `mcp_filesystem__list_directory` as
+        // "mcpfilesystemlistdirectory" — underscores eaten as italic/bold.
+        expect(text(parseInline("mcp_filesystem__list_directory", t))).toBe("mcp_filesystem__list_directory");
+        expect(text(parseInline("a snake_case name", t))).toBe("a snake_case name");
+        expect(text(parseInline("call mcp_muonroi-docs__setup_guide first", t))).toBe("call mcp_muonroi-docs__setup_guide first");
+        // None of these should be emphasized.
+        expect(parseInline("mcp_filesystem__list_directory", t).some((s) => s.italic || s.bold)).toBe(false);
+    });
+    it("still emphasizes underscores at word boundaries", () => {
+        expect(text(parseInline("an _italic_ word", t))).toBe("an italic word");
+        expect(parseInline("an _italic_ word", t).find((s) => s.text === "italic")?.italic).toBe(true);
+        expect(text(parseInline("a __bold__ word", t))).toBe("a bold word");
+        expect(parseInline("a __bold__ word", t).find((s) => s.text === "bold")?.bold).toBe(true);
+        // Underscore emphasis adjacent to punctuation still works.
+        expect(parseInline("(_em_)", t).find((s) => s.text === "em")?.italic).toBe(true);
+    });
     it("never leaves ** ` ### markers in styled segments", () => {
         const sample = "**A** and `b` and ***c*** and [d](http://e) and ~~f~~";
         const out = text(parseInline(sample, t));

package/dist/src/ui/markdown-render.js

@@ -77,6 +77,18 @@ export function parseInline(line, t, base = {}) {
             const inner = line.slice(i + m.open.length, close);
             if (inner.length === 0)
                 continue;
+            // CommonMark: underscore does NOT open/close emphasis intra-word, so
+            // identifiers like `mcp_filesystem__list_directory` or `snake_case` keep
+            // their underscores instead of being eaten as italic/bold (session
+            // 584ba476c07a rendered "mcpfilesystemlistdirectory"). Asterisk markers
+            // keep intraword behaviour. Reject when a word char hugs the marker on the
+            // word-internal side.
+            if (m.open[0] === "_") {
+                const before = i > 0 ? line[i - 1] : "";
+                const after = line[close + m.close.length] ?? "";
+                if (/[A-Za-z0-9]/.test(before) || /[A-Za-z0-9]/.test(after))
+                    continue;
+            }
             flushPlain(i);
             const isBold = "bold" in m && m.bold;
             const isItalic = "italic" in m && m.italic;

package/package.json

@@ -3,7 +3,7 @@
   "workspaces": [
     "packages/*"
   ],
-  "version": "1.6.0",
+  "version": "1.6.2",
   "description": "BYOK AI coding agent with multi-model council debate, role-based routing, and auto-compact.",
   "repository": {
     "type": "git",