muonroi-cli 1.5.0 → 1.6.1

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

@@ -16,6 +16,17 @@ const RETENTION_DAYS = (() => {
 // enough to keep the table bounded, cheap enough not to hurt hot path.
 const PRUNE_PROBABILITY = 1 / 200;
 let _pruneInflight = false;
+// These writes are fail-open (logging must never break a turn), but a swallowed
+// error still has to be diagnosable — a broken DB was previously invisible here.
+// Log the FIRST failure with context, then stay silent so a persistently-broken
+// DB can't spam the hot path (logInteraction fires ~3-5x/turn).
+let _dbFailureLogged = false;
+function logInteractionDbFailureOnce(op, err) {
+    if (_dbFailureLogged)
+        return;
+    _dbFailureLogged = true;
+    console.error(`[interaction-log] ${op} failed — interaction logging degraded (further errors suppressed this process): ${err?.message}`);
+}
 function maybePruneOld() {
     if (_pruneInflight)
         return;
@@ -26,8 +37,9 @@ function maybePruneOld() {
         const cutoff = new Date(Date.now() - RETENTION_DAYS * 86_400_000).toISOString();
         getDatabase().prepare(`DELETE FROM interaction_logs WHERE created_at < ?`).run(cutoff);
     }
-    catch {
-        // Fail-open
+    catch (err) {
+        // Fail-open: a prune failure must not break the write that triggered it.
+        logInteractionDbFailureOnce("prune", err);
     }
     finally {
         _pruneInflight = false;
@@ -66,8 +78,9 @@ export function logInteraction(sessionId, eventType, metadata) {
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(sessionId, eventType, metadata?.eventSubtype ?? null, metadata?.model ?? null, metadata?.durationMs ?? null, metadata?.inputTokens ?? null, metadata?.outputTokens ?? null, metadataJson, new Date().toISOString());
         maybePruneOld();
     }
-    catch {
-        // Fail-open: logging must never break the main flow
+    catch (err) {
+        // Fail-open: logging must never break the main flow.
+        logInteractionDbFailureOnce("insert", err);
     }
 }
 //# sourceMappingURL=interaction-log.js.map

package/dist/src/storage/session-experience-store.d.ts

@@ -0,0 +1,63 @@
+/**
+ * src/storage/session-experience-store.ts
+ *
+ * Persistence + cross-session aggregation for the session-experience counters
+ * (compactions / elisions / ee_query rehydrations / needed-but-unavailable).
+ *
+ * The in-process tracker (`src/orchestrator/session-experience.ts`) answers the
+ * LIVE "cảm nhận trong CLI" question. This module persists a per-session snapshot
+ * to `interaction_logs` (event_type='session_experience') at turn end so that
+ * `usage experience` can aggregate across many real sessions and answer the
+ * measure-before-re-architecting question: how often does compaction actually
+ * elide a tool output the agent then needs, and how often can it NOT recover it.
+ *
+ * One row per turn carrying the session's CUMULATIVE counts; readers take the
+ * latest row per session (counts are monotonic, so latest == session total).
+ * Fully fail-open: a DB error never breaks the turn. Counts are passed in by the
+ * caller (no orchestrator import here — storage stays a leaf).
+ */
+import type { SessionExperienceCounts } from "../orchestrator/session-experience.js";
+/**
+ * Persist the session's cumulative experience counts. No-ops on a missing
+ * sessionId or an all-zero snapshot (nothing happened → no signal to store).
+ */
+export declare function persistSessionExperience(sessionId: string | undefined | null, counts: SessionExperienceCounts): void;
+/** Latest persisted counts for one session (or null if none). Fail-open. */
+export declare function selectSessionExperience(sessionId: string): SessionExperienceCounts | null;
+export interface ExperiencePerSession {
+    sessionId: string;
+    createdAt: string;
+    counts: SessionExperienceCounts;
+}
+export interface ExperienceAggregate {
+    /** Sessions that recorded any experience signal (had ≥1 non-zero snapshot). */
+    sessionCount: number;
+    /** Of those, how many actually had compaction elide a tool output. */
+    sessionsWithElision: number;
+    /** Of those, how many hit a needed-but-unavailable rehydrate (the painful case). */
+    sessionsWithUnavailable: number;
+    totals: SessionExperienceCounts;
+    /**
+     * rehydrated / (rehydrated + unavailable) — how often, when the agent went
+     * back for an elided artifact, it actually recovered it. 1 = never lost; the
+     * lower this is, the more the manual-rehydrate friction actually bites.
+     */
+    rehydrateRecoveryRate: number;
+    perSession: ExperiencePerSession[];
+}
+export interface ExperienceRow {
+    session_id: string;
+    metadata_json: string | null;
+    created_at: string;
+}
+/**
+ * Pure aggregation: dedup to the latest row per session (rows MUST be ordered
+ * newest-first), parse, cap at `limit` sessions, sum, derive the recovery rate.
+ * Separated from the DB query so the logic is unit-testable without SQL.
+ */
+export declare function computeExperienceAggregate(rows: ExperienceRow[], limit?: number): ExperienceAggregate;
+/**
+ * Aggregate the latest snapshot per session across the most-recent `limit`
+ * sessions that recorded one. Fail-open: returns an empty aggregate on DB error.
+ */
+export declare function aggregateSessionExperience(limit?: number): ExperienceAggregate;

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

@@ -0,0 +1,164 @@
+/**
+ * src/storage/session-experience-store.ts
+ *
+ * Persistence + cross-session aggregation for the session-experience counters
+ * (compactions / elisions / ee_query rehydrations / needed-but-unavailable).
+ *
+ * The in-process tracker (`src/orchestrator/session-experience.ts`) answers the
+ * LIVE "cảm nhận trong CLI" question. This module persists a per-session snapshot
+ * to `interaction_logs` (event_type='session_experience') at turn end so that
+ * `usage experience` can aggregate across many real sessions and answer the
+ * measure-before-re-architecting question: how often does compaction actually
+ * elide a tool output the agent then needs, and how often can it NOT recover it.
+ *
+ * One row per turn carrying the session's CUMULATIVE counts; readers take the
+ * latest row per session (counts are monotonic, so latest == session total).
+ * Fully fail-open: a DB error never breaks the turn. Counts are passed in by the
+ * caller (no orchestrator import here — storage stays a leaf).
+ */
+import { getDatabase } from "./db.js";
+import { logInteraction } from "./interaction-log.js";
+const EVENT_TYPE = "session_experience";
+function countsTotal(c) {
+    return (c.compactions +
+        c.elided +
+        c.rehydratedCache +
+        c.rehydratedDisk +
+        c.rehydratedEe +
+        c.unavailable +
+        c.eeTimeouts +
+        c.eeErrors);
+}
+/**
+ * Persist the session's cumulative experience counts. No-ops on a missing
+ * sessionId or an all-zero snapshot (nothing happened → no signal to store).
+ */
+export function persistSessionExperience(sessionId, counts) {
+    if (!sessionId)
+        return;
+    if (countsTotal(counts) === 0)
+        return;
+    // logInteraction is itself fail-open.
+    logInteraction(sessionId, EVENT_TYPE, {
+        eventSubtype: "snapshot",
+        data: counts,
+    });
+}
+function parseCounts(json) {
+    if (!json)
+        return null;
+    try {
+        const o = JSON.parse(json);
+        return {
+            compactions: o.compactions ?? 0,
+            elided: o.elided ?? 0,
+            totalElidedChars: o.totalElidedChars ?? 0,
+            rehydratedCache: o.rehydratedCache ?? 0,
+            rehydratedDisk: o.rehydratedDisk ?? 0,
+            rehydratedEe: o.rehydratedEe ?? 0,
+            unavailable: o.unavailable ?? 0,
+            eeTimeouts: o.eeTimeouts ?? 0,
+            eeErrors: o.eeErrors ?? 0,
+        };
+    }
+    catch (err) {
+        console.error(`[session-experience-store] parse failed: ${err?.message}`);
+        return null;
+    }
+}
+/** Latest persisted counts for one session (or null if none). Fail-open. */
+export function selectSessionExperience(sessionId) {
+    try {
+        const row = getDatabase()
+            .prepare(`SELECT metadata_json FROM interaction_logs
+         WHERE session_id = ? AND event_type = ?
+         ORDER BY created_at DESC, id DESC LIMIT 1`)
+            .get(sessionId, EVENT_TYPE);
+        return parseCounts(row?.metadata_json ?? null);
+    }
+    catch (err) {
+        console.error(`[session-experience-store] select failed for ${sessionId}: ${err?.message}`);
+        return null;
+    }
+}
+function emptyCounts() {
+    return {
+        compactions: 0,
+        elided: 0,
+        totalElidedChars: 0,
+        rehydratedCache: 0,
+        rehydratedDisk: 0,
+        rehydratedEe: 0,
+        unavailable: 0,
+        eeTimeouts: 0,
+        eeErrors: 0,
+    };
+}
+/**
+ * Pure aggregation: dedup to the latest row per session (rows MUST be ordered
+ * newest-first), parse, cap at `limit` sessions, sum, derive the recovery rate.
+ * Separated from the DB query so the logic is unit-testable without SQL.
+ */
+export function computeExperienceAggregate(rows, limit = 100) {
+    const seen = new Set();
+    const perSession = [];
+    for (const r of rows) {
+        if (seen.has(r.session_id))
+            continue; // first row per session == latest
+        const counts = parseCounts(r.metadata_json);
+        if (!counts)
+            continue;
+        seen.add(r.session_id);
+        perSession.push({ sessionId: r.session_id, createdAt: r.created_at, counts });
+        if (perSession.length >= limit)
+            break;
+    }
+    const totals = emptyCounts();
+    let sessionsWithElision = 0;
+    let sessionsWithUnavailable = 0;
+    for (const { counts } of perSession) {
+        totals.compactions += counts.compactions;
+        totals.elided += counts.elided;
+        totals.totalElidedChars += counts.totalElidedChars;
+        totals.rehydratedCache += counts.rehydratedCache;
+        totals.rehydratedDisk += counts.rehydratedDisk;
+        totals.rehydratedEe += counts.rehydratedEe;
+        totals.unavailable += counts.unavailable;
+        totals.eeTimeouts += counts.eeTimeouts;
+        totals.eeErrors += counts.eeErrors;
+        if (counts.elided > 0)
+            sessionsWithElision += 1;
+        if (counts.unavailable > 0)
+            sessionsWithUnavailable += 1;
+    }
+    const rehydrated = totals.rehydratedCache + totals.rehydratedDisk + totals.rehydratedEe;
+    const attempts = rehydrated + totals.unavailable;
+    const rehydrateRecoveryRate = attempts > 0 ? rehydrated / attempts : 1;
+    return {
+        sessionCount: perSession.length,
+        sessionsWithElision,
+        sessionsWithUnavailable,
+        totals,
+        rehydrateRecoveryRate,
+        perSession,
+    };
+}
+/**
+ * Aggregate the latest snapshot per session across the most-recent `limit`
+ * sessions that recorded one. Fail-open: returns an empty aggregate on DB error.
+ */
+export function aggregateSessionExperience(limit = 100) {
+    try {
+        const rows = getDatabase()
+            .prepare(`SELECT session_id, metadata_json, created_at FROM interaction_logs
+         WHERE event_type = ?
+         ORDER BY created_at DESC, id DESC`)
+            .all(EVENT_TYPE);
+        return computeExperienceAggregate(rows, limit);
+    }
+    catch (err) {
+        console.error(`[session-experience-store] aggregate failed: ${err?.message}`);
+        return computeExperienceAggregate([], limit);
+    }
+}
+//# sourceMappingURL=session-experience-store.js.map

package/dist/src/storage/session-experience-store.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * session-experience-store — persist + cross-session aggregate of the anti-mù
+ * counters that decide whether compaction friction is real at a painful rate.
+ */
+export {};

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/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

@@ -9,7 +9,9 @@
  * (no network).
  */
 import os from "node:os";
-import { describe, expect, it } from "vitest";
+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", () => {
@@ -45,4 +47,25 @@ describe("isToolArtifactQuery — ee_query intent routing", () => {
         expect(isToolArtifactQuery("tool-artifact storage design")).toBe(false);
     });
 });
+describe("ee_query — anti-mù rehydrate (local-first, durable when EE is down)", () => {
+    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
+        // full content from the local cache rather than an [ee_unavailable] note.
+        recordArtifact("call_42", "read_file", "FULL ELIDED CONTENT — line A\nline B\nline C");
+        const tools = createBuiltinTools(new BashTool(os.tmpdir()), "agent");
+        const t = tools.ee_query;
+        const out = String(await t.execute?.({ query: "tool-artifact id=call_42" }));
+        expect(out).toContain("rehydrated from in-session cache");
+        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

@@ -466,15 +466,33 @@ export function createBuiltinTools(bash, mode, opts) {
                 }
                 try {
                     if (isToolArtifactQuery(query)) {
-                        // Artifact rehydration → raw /api/search (exact-collection lookup).
+                        // Local-first (anti-mù durability): the compactor records each elided
+                        // output in-process by toolCallId. For an exact "tool-artifact id=X"
+                        // 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.
                         const { searchEE } = await import("../ee/search.js");
                         const resp = await searchEE(query, {
                             ...(Array.isArray(input?.collections) ? { collections: input.collections } : {}),
                             ...(typeof input?.limit === "number" ? { limit: input.limit } : {}),
                         });
                         if (resp === null) {
-                            return "[ee_unavailable] Experience Engine returned no response (server down, timeout, circuit open, or unconfigured). Proceed without EE recall — re-read the source directly if you need the elided content.";
+                            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/package.json

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