muonroi-cli 1.6.0 → 1.6.1

package/dist/src/pil/pipeline.js

@@ -27,6 +27,7 @@ import { layer4Gsd } from "./layer4-gsd.js";
 import { layer5Context } from "./layer5-context.js";
 import { isMetaAnalysisPrompt, layer6Output } from "./layer6-output.js";
 import { PipelineContextSchema } from "./schema.js";
+import { injectSessionExperience, isSelfExperiencePrompt } from "./session-experience-injection.js";
 import { bumpSessionTurn } from "./session-state.js";
 import { setPilLastResult } from "./store.js";
 import { resolveAfter } from "./timeout.js";
@@ -177,6 +178,16 @@ async function runLayers(ctx, options) {
             ],
         };
     }
+    // Felt-experience routing: a first-person "cảm nhận trong CLI / are you
+    // blind?" question gets the live session-experience snapshot so the agent
+    // answers from what actually happened to it this session — not by reading the
+    // compaction/PIL source. Runs REGARDLESS of taskType: such questions often
+    // classify to null (not a coding task), and gating it behind the taskType
+    // branch silently skipped it on exactly those prompts. Narrow (gated on
+    // isSelfExperiencePrompt) so non-experience turns add no layer.
+    if (isSelfExperiencePrompt(ctx.raw)) {
+        await timed("session-experience", async (c) => injectSessionExperience(c));
+    }
     await timed("layer6-output", layer6Output);
     const suffixCharsMatch = ctx.layers.find((l) => l.name === "output-optimization")?.delta?.match(/chars=(\d+)/);
     const suffixChars = suffixCharsMatch ? parseInt(suffixCharsMatch[1], 10) : 0;

package/dist/src/pil/session-experience-injection.d.ts

@@ -0,0 +1,34 @@
+/**
+ * src/pil/session-experience-injection.ts
+ *
+ * Felt-experience routing. When the user asks how the agent is *doing* inside
+ * this CLI session — "cảm nhận trong CLI", "bạn có bị mù context không",
+ * "how do you feel working in here", "did you struggle" — the agent should
+ * answer from what ACTUALLY happened to it this session, not by reading the
+ * compaction/PIL source and theorizing about mechanisms (the backwards behaviour
+ * in session ce816796a57d: no compaction fired, no ee_query call, no blindness —
+ * yet the agent answered by grepping the anti-mù code).
+ *
+ * This step injects the live session-experience snapshot into the enriched
+ * prompt and tells the agent to ground its answer in that data. It is narrow on
+ * purpose: a generic "đánh giá / cải thiện CLI" evaluation still goes the
+ * code-reading route — only first-person *experience* questions get the snapshot.
+ *
+ * Pure, synchronous, additive, fail-open: records a `session-experience` layer
+ * marker either way for forensics.
+ */
+import type { PipelineContext } from "./types.js";
+/**
+ * Narrow detector for "how do you (the agent) feel / are you blind / did you
+ * struggle in this session" questions. Deliberately keyed on introspective
+ * vocabulary (feeling / experience / blind / struggle) rather than the broad
+ * meta-analysis regex, so plain "evaluate the CLI" prompts are NOT captured.
+ */
+export declare const SELF_EXPERIENCE_RE: RegExp;
+export declare function isSelfExperiencePrompt(raw: string): boolean;
+/**
+ * Append the live session-experience snapshot when the prompt is a first-person
+ * experience question. No-op (but marker-recorded) otherwise, and idempotent if
+ * the snapshot is already present.
+ */
+export declare function injectSessionExperience(ctx: PipelineContext): PipelineContext;

package/dist/src/pil/session-experience-injection.js

@@ -0,0 +1,54 @@
+/**
+ * src/pil/session-experience-injection.ts
+ *
+ * Felt-experience routing. When the user asks how the agent is *doing* inside
+ * this CLI session — "cảm nhận trong CLI", "bạn có bị mù context không",
+ * "how do you feel working in here", "did you struggle" — the agent should
+ * answer from what ACTUALLY happened to it this session, not by reading the
+ * compaction/PIL source and theorizing about mechanisms (the backwards behaviour
+ * in session ce816796a57d: no compaction fired, no ee_query call, no blindness —
+ * yet the agent answered by grepping the anti-mù code).
+ *
+ * This step injects the live session-experience snapshot into the enriched
+ * prompt and tells the agent to ground its answer in that data. It is narrow on
+ * purpose: a generic "đánh giá / cải thiện CLI" evaluation still goes the
+ * code-reading route — only first-person *experience* questions get the snapshot.
+ *
+ * Pure, synchronous, additive, fail-open: records a `session-experience` layer
+ * marker either way for forensics.
+ */
+import { formatSessionExperience } from "../orchestrator/session-experience.js";
+/**
+ * Narrow detector for "how do you (the agent) feel / are you blind / did you
+ * struggle in this session" questions. Deliberately keyed on introspective
+ * vocabulary (feeling / experience / blind / struggle) rather than the broad
+ * meta-analysis regex, so plain "evaluate the CLI" prompts are NOT captured.
+ */
+export const SELF_EXPERIENCE_RE = /cảm nhận|cảm thấy|cảm giác|trải nghiệm|(bị\s*)?mù\s*context|bị\s*mù|how (do|does) (you|it) feel|how are you (doing|feeling)|your (own |felt )?experience|are you (feeling\s+)?blind|do you feel blind|did you (struggle|have (a |any )?(trouble|difficulty|hard time|problem))|có (gặp\s+)?khó khăn|gặp (vấn đề|khó khăn)/i;
+export function isSelfExperiencePrompt(raw) {
+    return typeof raw === "string" && SELF_EXPERIENCE_RE.test(raw);
+}
+const MARKER = "[session experience —";
+/**
+ * Append the live session-experience snapshot when the prompt is a first-person
+ * experience question. No-op (but marker-recorded) otherwise, and idempotent if
+ * the snapshot is already present.
+ */
+export function injectSessionExperience(ctx) {
+    const mark = (applied, delta) => ({
+        ...ctx,
+        layers: [...ctx.layers, { name: "session-experience", applied, delta }],
+    });
+    if (!isSelfExperiencePrompt(ctx.raw))
+        return mark(false, "not-self-experience");
+    if (ctx.enriched.includes(MARKER))
+        return mark(false, "already-injected");
+    const snapshot = formatSessionExperience();
+    const block = `\n${snapshot}`;
+    return {
+        ...ctx,
+        enriched: `${ctx.enriched}${block}`,
+        layers: [...ctx.layers, { name: "session-experience", applied: true, delta: `chars=${block.length}` }],
+    };
+}
+//# sourceMappingURL=session-experience-injection.js.map

package/dist/src/pil/session-experience-injection.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Felt-experience routing: a "cảm nhận trong CLI" / "are you blind?" question
+ * gets the live session-experience snapshot injected so the agent answers from
+ * lived data, while a plain "evaluate the CLI" prompt does NOT.
+ */
+export {};

package/dist/src/pil/session-experience-injection.test.js

@@ -0,0 +1,79 @@
+/**
+ * Felt-experience routing: a "cảm nhận trong CLI" / "are you blind?" question
+ * gets the live session-experience snapshot injected so the agent answers from
+ * lived data, while a plain "evaluate the CLI" prompt does NOT.
+ */
+import { afterEach, describe, expect, it } from "vitest";
+import { __resetSessionExperienceForTests, recordCompaction, recordElision, } from "../orchestrator/session-experience.js";
+import { injectSessionExperience, isSelfExperiencePrompt } from "./session-experience-injection.js";
+function baseCtx(raw) {
+    return {
+        raw,
+        enriched: raw,
+        taskType: "analyze",
+        domain: null,
+        confidence: 1,
+        outputStyle: null,
+        tokenBudget: 8000,
+        metrics: null,
+        layers: [],
+    };
+}
+describe("isSelfExperiencePrompt", () => {
+    it("matches first-person experience / blindness / struggle questions (VI + EN)", () => {
+        for (const p of [
+            "cảm nhận trong cli thế nào",
+            "bạn có bị mù context hay cảm thấy có vấn đề gì khi làm việc trong các turn này không",
+            "how do you feel working in this session",
+            "did you struggle with anything this session",
+            "are you blind to earlier context?",
+            "bạn có gặp khó khăn gì không",
+        ]) {
+            expect(isSelfExperiencePrompt(p)).toBe(true);
+        }
+    });
+    it("does NOT match plain evaluate/improve-the-CLI prompts", () => {
+        for (const p of [
+            "đánh giá agent bên trong cli và đề xuất cải thiện",
+            "phân tích pipeline PIL",
+            "improve the compaction subsystem",
+            "review the council code",
+        ]) {
+            expect(isSelfExperiencePrompt(p)).toBe(false);
+        }
+    });
+});
+describe("injectSessionExperience", () => {
+    afterEach(() => __resetSessionExperienceForTests());
+    it("injects an intact-context snapshot on a fresh session and steers away from source-reading", () => {
+        const out = injectSessionExperience(baseCtx("bạn có bị mù context không trong session này"));
+        expect(out.enriched).toContain("[session experience —");
+        expect(out.enriched).toContain("context is intact this session");
+        expect(out.enriched).toMatch(/not by reading the CLI source/i);
+        expect(out.layers.at(-1)).toMatchObject({ name: "session-experience", applied: true });
+    });
+    it("reflects real counters when the session actually compacted/elided", () => {
+        recordCompaction(5);
+        recordElision("call_z", "read_file", 7000, 5);
+        const out = injectSessionExperience(baseCtx("cảm nhận của bạn trong cli ra sao"));
+        expect(out.enriched).toContain("fired 1x");
+        expect(out.enriched).toContain("Tool outputs elided: 1");
+    });
+    it("is a marker-recorded no-op for non-experience prompts", () => {
+        const out = injectSessionExperience(baseCtx("đánh giá tổng thể CLI và cải thiện"));
+        expect(out.enriched).not.toContain("[session experience —");
+        expect(out.layers.at(-1)).toMatchObject({
+            name: "session-experience",
+            applied: false,
+            delta: "not-self-experience",
+        });
+    });
+    it("is idempotent — does not double-inject", () => {
+        const once = injectSessionExperience(baseCtx("cảm nhận trong cli"));
+        const twice = injectSessionExperience(once);
+        const occurrences = twice.enriched.split("[session experience —").length - 1;
+        expect(occurrences).toBe(1);
+        expect(twice.layers.at(-1)).toMatchObject({ applied: false, delta: "already-injected" });
+    });
+});
+//# sourceMappingURL=session-experience-injection.test.js.map

package/dist/src/storage/interaction-log.d.ts

@@ -4,7 +4,7 @@
  * Fire-and-forget interaction logging for detailed user-agent event tracking.
  * All calls are fail-open — logging never breaks the main flow.
  */
-export type InteractionEventType = "user_message" | "agent_response" | "tool_call" | "tool_result" | "compaction" | "routing" | "pil" | "error" | "model_switch" | "council" | "ee_intercept" | "ee_judge" | "ee_injection" | "ui_interaction" | "stream_retry" | "f6_synthesis" | "grounding_flag" | "stall_rescue" | "stream_start" | "text_tool_resteer";
+export type InteractionEventType = "user_message" | "agent_response" | "tool_call" | "tool_result" | "compaction" | "routing" | "pil" | "error" | "model_switch" | "council" | "ee_intercept" | "ee_judge" | "ee_injection" | "ui_interaction" | "stream_retry" | "f6_synthesis" | "grounding_flag" | "stall_rescue" | "stream_start" | "text_tool_resteer" | "session_experience";
 export interface EEInjectionRow {
     session_id: string;
     event_subtype: string | null;

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

@@ -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;