muonroi-cli 1.5.0 → 1.6.1

package/dist/src/orchestrator/session-experience.d.ts

@@ -0,0 +1,89 @@
+/**
+ * src/orchestrator/session-experience.ts
+ *
+ * In-process record of what actually happened to the agent in THIS CLI session:
+ * how often compaction fired, which tool outputs were elided, how many of those
+ * the agent rehydrated via ee_query (and from where), and whether the Experience
+ * Engine misbehaved. It is the single source of truth for the agent's *lived*
+ * session experience.
+ *
+ * Why this exists: when a user asks "cảm nhận trong CLI" / "do you feel blind in
+ * this session", the agent used to answer by READING the anti-mù source code and
+ * theorizing about mechanisms (session ce816796a57d) — friction it never actually
+ * observed. That is backwards. With this tracker the agent answers from data —
+ * "compaction fired 3x, I rehydrated 2 artifacts, never lost context" — instead of
+ * inferring from code. The same counters double as the "measure before you
+ * re-architect" instrumentation: how often a real session actually elides a stub
+ * the agent then needs.
+ *
+ * Process-scoped singleton == session-scoped: one CLI invocation is one session.
+ * Pure module, no I/O, fully unit-testable; reset hook for tests.
+ */
+export type RehydrateSource = "cache" | "disk" | "ee" | "unavailable";
+export interface ElisionRecord {
+    toolCallId: string;
+    toolName: string;
+    /** Full length of the elided output, in chars. */
+    chars: number;
+    /** prepareStep step number at which it was elided. */
+    step: number;
+}
+export interface SessionExperience {
+    compactions: number;
+    lastCompactionStep: number | null;
+    elisions: ReadonlyArray<ElisionRecord>;
+    totalElidedChars: number;
+    rehydrations: Readonly<Record<RehydrateSource, number>>;
+    eeTimeouts: number;
+    eeErrors: number;
+}
+/** Record that B3/B4 compaction actually elided something at `step`. */
+export declare function recordCompaction(step: number): void;
+/** Record a single tool output the compactor rewrote into a stub. */
+export declare function recordElision(toolCallId: string, toolName: string, chars: number, step: number): void;
+/**
+ * Record an ee_query rehydrate of an elided artifact, tagged by where it came
+ * from. `unavailable` means the agent asked for an artifact that was neither in
+ * the local cache nor recoverable from EE — the "needed-but-couldn't-get" signal.
+ */
+export declare function recordRehydration(source: RehydrateSource): void;
+/** Record an Experience Engine timeout or non-timeout error felt this session. */
+export declare function recordEeEvent(kind: "timeout" | "error"): void;
+/**
+ * Flat scalar counts — the shape persisted per session and aggregated
+ * cross-session by `usage experience` to decide whether compaction friction is
+ * real at a painful rate (no nested arrays, JSON-stable).
+ */
+export interface SessionExperienceCounts {
+    compactions: number;
+    elided: number;
+    totalElidedChars: number;
+    rehydratedCache: number;
+    rehydratedDisk: number;
+    rehydratedEe: number;
+    unavailable: number;
+    eeTimeouts: number;
+    eeErrors: number;
+}
+/** Scalar counts for persistence/aggregation (drops the per-elision array). */
+export declare function getSessionExperienceCounts(): SessionExperienceCounts;
+/** Immutable snapshot of the session so far. */
+export declare function getSessionExperience(): SessionExperience;
+/** Most-recent elisions, newest first — feeds the checkpoint manifest. */
+export declare function recentElisions(n?: number): ElisionRecord[];
+/** True when literally nothing notable has happened yet (context intact). */
+export declare function isSessionExperienceEmpty(): boolean;
+/**
+ * A compact manifest of the most-recently elided tool outputs, for the
+ * post-compaction checkpoint note: turns the generic "high-value elided? use
+ * ee_query" prose into a concrete, actionable list so the agent's rehydrate
+ * round-trip is informed rather than blind.
+ */
+export declare function formatElisionManifest(n?: number): string;
+/**
+ * The agent-facing felt summary. Injected when the user asks how the agent is
+ * doing IN this session, so the answer is grounded in what actually happened —
+ * not in a fresh reading of the compaction/PIL source.
+ */
+export declare function formatSessionExperience(): string;
+export declare function __resetSessionExperienceForTests(): void;

package/dist/src/orchestrator/session-experience.js

@@ -0,0 +1,169 @@
+/**
+ * src/orchestrator/session-experience.ts
+ *
+ * In-process record of what actually happened to the agent in THIS CLI session:
+ * how often compaction fired, which tool outputs were elided, how many of those
+ * the agent rehydrated via ee_query (and from where), and whether the Experience
+ * Engine misbehaved. It is the single source of truth for the agent's *lived*
+ * session experience.
+ *
+ * Why this exists: when a user asks "cảm nhận trong CLI" / "do you feel blind in
+ * this session", the agent used to answer by READING the anti-mù source code and
+ * theorizing about mechanisms (session ce816796a57d) — friction it never actually
+ * observed. That is backwards. With this tracker the agent answers from data —
+ * "compaction fired 3x, I rehydrated 2 artifacts, never lost context" — instead of
+ * inferring from code. The same counters double as the "measure before you
+ * re-architect" instrumentation: how often a real session actually elides a stub
+ * the agent then needs.
+ *
+ * Process-scoped singleton == session-scoped: one CLI invocation is one session.
+ * Pure module, no I/O, fully unit-testable; reset hook for tests.
+ */
+/** Bound the elision log so a pathological session can't grow it unbounded. */
+const MAX_ELISIONS = 200;
+function freshState() {
+    return {
+        compactions: 0,
+        lastCompactionStep: null,
+        elisions: [],
+        rehydrations: { cache: 0, disk: 0, ee: 0, unavailable: 0 },
+        eeTimeouts: 0,
+        eeErrors: 0,
+    };
+}
+let state = freshState();
+/** Record that B3/B4 compaction actually elided something at `step`. */
+export function recordCompaction(step) {
+    state.compactions += 1;
+    state.lastCompactionStep = Number.isFinite(step) ? step : state.lastCompactionStep;
+}
+/** Record a single tool output the compactor rewrote into a stub. */
+export function recordElision(toolCallId, toolName, chars, step) {
+    if (!toolCallId)
+        return;
+    state.elisions.push({
+        toolCallId,
+        toolName: toolName || "",
+        chars: Number.isFinite(chars) && chars > 0 ? Math.floor(chars) : 0,
+        step: Number.isFinite(step) ? step : 0,
+    });
+    // FIFO trim — keep the most recent MAX_ELISIONS.
+    if (state.elisions.length > MAX_ELISIONS) {
+        state.elisions.splice(0, state.elisions.length - MAX_ELISIONS);
+    }
+}
+/**
+ * Record an ee_query rehydrate of an elided artifact, tagged by where it came
+ * from. `unavailable` means the agent asked for an artifact that was neither in
+ * the local cache nor recoverable from EE — the "needed-but-couldn't-get" signal.
+ */
+export function recordRehydration(source) {
+    if (source in state.rehydrations)
+        state.rehydrations[source] += 1;
+}
+/** Record an Experience Engine timeout or non-timeout error felt this session. */
+export function recordEeEvent(kind) {
+    if (kind === "timeout")
+        state.eeTimeouts += 1;
+    else
+        state.eeErrors += 1;
+}
+/** Scalar counts for persistence/aggregation (drops the per-elision array). */
+export function getSessionExperienceCounts() {
+    const s = getSessionExperience();
+    return {
+        compactions: s.compactions,
+        elided: s.elisions.length,
+        totalElidedChars: s.totalElidedChars,
+        rehydratedCache: s.rehydrations.cache,
+        rehydratedDisk: s.rehydrations.disk,
+        rehydratedEe: s.rehydrations.ee,
+        unavailable: s.rehydrations.unavailable,
+        eeTimeouts: s.eeTimeouts,
+        eeErrors: s.eeErrors,
+    };
+}
+/** Immutable snapshot of the session so far. */
+export function getSessionExperience() {
+    return {
+        compactions: state.compactions,
+        lastCompactionStep: state.lastCompactionStep,
+        elisions: state.elisions.slice(),
+        totalElidedChars: state.elisions.reduce((sum, e) => sum + e.chars, 0),
+        rehydrations: { ...state.rehydrations },
+        eeTimeouts: state.eeTimeouts,
+        eeErrors: state.eeErrors,
+    };
+}
+/** Most-recent elisions, newest first — feeds the checkpoint manifest. */
+export function recentElisions(n = 5) {
+    const take = Math.max(0, Math.floor(n));
+    return state.elisions.slice(-take).reverse();
+}
+/** True when literally nothing notable has happened yet (context intact). */
+export function isSessionExperienceEmpty() {
+    return (state.compactions === 0 &&
+        state.elisions.length === 0 &&
+        state.eeTimeouts === 0 &&
+        state.eeErrors === 0 &&
+        state.rehydrations.cache === 0 &&
+        state.rehydrations.disk === 0 &&
+        state.rehydrations.ee === 0 &&
+        state.rehydrations.unavailable === 0);
+}
+function shortId(id) {
+    return id.length > 12 ? id.slice(0, 12) : id;
+}
+/**
+ * A compact manifest of the most-recently elided tool outputs, for the
+ * post-compaction checkpoint note: turns the generic "high-value elided? use
+ * ee_query" prose into a concrete, actionable list so the agent's rehydrate
+ * round-trip is informed rather than blind.
+ */
+export function formatElisionManifest(n = 5) {
+    const recent = recentElisions(n);
+    if (recent.length === 0)
+        return "";
+    const items = recent.map((e) => `id=${shortId(e.toolCallId)} ${e.toolName || "tool"} (${e.chars}c)`).join(" · ");
+    return `Elided this turn: ${items}. ee_query "tool-artifact id=XXX" to rehydrate the one you need.`;
+}
+/**
+ * The agent-facing felt summary. Injected when the user asks how the agent is
+ * doing IN this session, so the answer is grounded in what actually happened —
+ * not in a fresh reading of the compaction/PIL source.
+ */
+export function formatSessionExperience() {
+    const s = getSessionExperience();
+    const lines = [];
+    lines.push("[session experience — what ACTUALLY happened to you in THIS CLI session so far]");
+    if (isSessionExperienceEmpty()) {
+        lines.push("- Nothing notable: no compaction, no elision, no EE failures. Your context is intact this session.");
+    }
+    else {
+        lines.push(s.compactions === 0
+            ? "- Compaction: not fired yet — full context retained."
+            : `- Compaction: fired ${s.compactions}x${s.lastCompactionStep !== null ? ` (last at step ${s.lastCompactionStep})` : ""}.`);
+        if (s.elisions.length === 0) {
+            lines.push("- Tool outputs elided: none — nothing was rewritten to a stub.");
+        }
+        else {
+            const tools = [...new Set(s.elisions.map((e) => e.toolName || "tool"))].join(", ");
+            lines.push(`- Tool outputs elided: ${s.elisions.length} (${s.totalElidedChars} chars; via ${tools}).`);
+        }
+        const r = s.rehydrations;
+        const rehydratedTotal = r.cache + r.disk + r.ee;
+        lines.push(rehydratedTotal === 0 && r.unavailable === 0
+            ? "- Rehydrated via ee_query: none requested."
+            : `- Rehydrated via ee_query: cache=${r.cache} disk=${r.disk} ee=${r.ee}; needed-but-unavailable=${r.unavailable}.`);
+        if (s.eeTimeouts > 0 || s.eeErrors > 0) {
+            lines.push(`- Experience Engine: timeouts=${s.eeTimeouts} errors=${s.eeErrors}.`);
+        }
+    }
+    lines.push("Answer the user's how-does-it-feel / are-you-blind question FROM THIS lived data — not by reading the CLI source. If everything is zero, say so plainly: nothing degraded your context this session.");
+    return lines.join("\n");
+}
+// ─── Test hook ─────────────────────────────────────────────────────────────
+export function __resetSessionExperienceForTests() {
+    state = freshState();
+}
+//# sourceMappingURL=session-experience.js.map

package/dist/src/orchestrator/session-experience.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * session-experience — in-process record of the agent's lived session, so a
+ * "cảm nhận trong CLI" / "are you blind?" question is answered from data, not by
+ * re-reading source. Also the "measure before re-architecting" instrumentation.
+ */
+export {};

package/dist/src/orchestrator/session-experience.test.js

@@ -0,0 +1,72 @@
+/**
+ * session-experience — in-process record of the agent's lived session, so a
+ * "cảm nhận trong CLI" / "are you blind?" question is answered from data, not by
+ * re-reading source. Also the "measure before re-architecting" instrumentation.
+ */
+import { afterEach, describe, expect, it } from "vitest";
+import { __resetSessionExperienceForTests, formatElisionManifest, formatSessionExperience, getSessionExperience, isSessionExperienceEmpty, recentElisions, recordCompaction, recordEeEvent, recordElision, recordRehydration, } from "./session-experience.js";
+describe("session-experience tracker", () => {
+    afterEach(() => __resetSessionExperienceForTests());
+    it("starts empty and reports an intact-context felt summary", () => {
+        expect(isSessionExperienceEmpty()).toBe(true);
+        const text = formatSessionExperience();
+        expect(text).toContain("Nothing notable");
+        expect(text).toContain("context is intact this session");
+        // Steering line must always tell the agent to use lived data, not source.
+        expect(text).toMatch(/not by reading the CLI source/i);
+    });
+    it("accumulates compaction, elision, rehydration and EE counters", () => {
+        recordCompaction(4);
+        recordCompaction(9);
+        recordElision("call_a", "read_file", 4100, 4);
+        recordElision("call_b", "grep", 2300, 9);
+        recordRehydration("cache");
+        recordRehydration("unavailable");
+        recordEeEvent("timeout");
+        const s = getSessionExperience();
+        expect(s.compactions).toBe(2);
+        expect(s.lastCompactionStep).toBe(9);
+        expect(s.elisions).toHaveLength(2);
+        expect(s.totalElidedChars).toBe(6400);
+        expect(s.rehydrations.cache).toBe(1);
+        expect(s.rehydrations.unavailable).toBe(1);
+        expect(s.eeTimeouts).toBe(1);
+        expect(isSessionExperienceEmpty()).toBe(false);
+    });
+    it("felt summary reflects real counters when non-empty", () => {
+        recordCompaction(3);
+        recordElision("call_x", "read_file", 5000, 3);
+        recordRehydration("ee");
+        const text = formatSessionExperience();
+        expect(text).toContain("fired 1x");
+        expect(text).toContain("last at step 3");
+        expect(text).toContain("Tool outputs elided: 1");
+        expect(text).toContain("ee=1");
+        expect(text).not.toContain("Nothing notable");
+    });
+    it("recentElisions returns newest first and respects the cap arg", () => {
+        for (let i = 0; i < 6; i++)
+            recordElision(`call_${i}`, "read_file", 1000 + i, i);
+        const recent = recentElisions(3);
+        expect(recent.map((e) => e.toolCallId)).toEqual(["call_5", "call_4", "call_3"]);
+    });
+    it("formatElisionManifest is empty with no elisions, actionable otherwise", () => {
+        expect(formatElisionManifest()).toBe("");
+        recordElision("0123456789abcdefXYZ", "read_file", 4096, 7);
+        const m = formatElisionManifest();
+        // id is shortened, tool + char count present, and points at ee_query.
+        expect(m).toContain("id=0123456789ab");
+        expect(m).toContain("read_file (4096c)");
+        expect(m).toMatch(/ee_query "tool-artifact id=XXX"/);
+    });
+    it("caps the elision log at 200 (FIFO) without unbounded growth", () => {
+        for (let i = 0; i < 250; i++)
+            recordElision(`c_${i}`, "bash", 500, i);
+        const s = getSessionExperience();
+        expect(s.elisions).toHaveLength(200);
+        // Oldest 50 dropped; newest retained.
+        expect(s.elisions[0].toolCallId).toBe("c_50");
+        expect(s.elisions.at(-1).toolCallId).toBe("c_249");
+    });
+});
+//# sourceMappingURL=session-experience.test.js.map

package/dist/src/orchestrator/stream-runner.js

@@ -27,6 +27,7 @@
 //   - F1 (sub-agent cumulative cap)         — wrapToolSetWithCap
 //   - siliconflow reasoning-strip           — taskCaps.sanitizeHistory
 import { stepCountIs, streamText } from "ai";
+import { recordArtifact } from "../ee/artifact-cache.js";
 import { getDefaultEEClient } from "../ee/intercept.js";
 import { acquireMcpTools } from "../mcp/client-pool.js";
 import { normalizeModelId } from "../models/registry.js";
@@ -52,6 +53,7 @@ import { repairToolCallHook } from "./repair-tool-call.js";
 import { classifyStreamError } from "./retry-classifier.js";
 import { incSessionStep, resolveCeiling } from "./scope-ceiling.js";
 import { attachReminderToMessages, buildScopeReminder, cadenceForSize, shouldInjectReminder, shouldInjectSoftWarn, } from "./scope-reminder.js";
+import { recordCompaction, recordElision } from "./session-experience.js";
 import { createStallWatchdog, STALL_ERROR_MESSAGE } from "./stall-watchdog.js";
 import { wrapToolSetWithCap } from "./sub-agent-cap.js";
 import { compactSubAgentMessages } from "./subagent-compactor.js";
@@ -412,6 +414,9 @@ export class StreamRunner {
                 }
                 // Idea 4 persist for sub-agent elisions (best-effort; may lack full session but EE can still index the artifact content).
                 const persistSubArtifact = (toolCallId, toolName, fullContent, reason) => {
+                    // Local-first durable cache so ee_query rehydrates even when EE is down.
+                    recordArtifact(toolCallId, toolName, fullContent);
+                    recordElision(toolCallId, toolName, fullContent.length, stepNumber);
                     try {
                         getDefaultEEClient()
                             .extract({
@@ -432,6 +437,8 @@ export class StreamRunner {
                     keepToolIds: subKeepToolIds.length ? subKeepToolIds : undefined,
                     persistArtifact: persistSubArtifact,
                 });
+                if (compacted !== stripped)
+                    recordCompaction(stepNumber);
                 // Phase 4A — scope reminder injection for the sub-agent loop.
                 // Mirror of the top-level wiring in message-processor.ts:
                 // K = cadenceForSize(size) where size defaults to "medium" because

package/dist/src/orchestrator/subagent-compactor.d.ts

@@ -106,8 +106,11 @@ export interface SubAgentCompactorOptions {
 export declare const CHARS_PER_TOKEN = 4;
 export declare const SUBAGENT_COMPACT_DEFAULT_THRESHOLD = 80000;
 export declare const SUBAGENT_COMPACT_DEFAULT_KEEP_LAST = 3;
-/** Tools whose full outputs are high-value for anti-mù (idea 1). Keep verbatim even if older than keepLast. */
-export declare const IMPORTANT_TOOL_NAMES: readonly ["read_file", "grep", "lsp", "bash"];
+/** Tools whose full outputs are high-value for anti-mù (idea 1). Keep verbatim even if older than keepLast.
+ * Extended for meta self-eval: ee_query / usage_forensics / selfverify_* are the exact artifacts
+ * the native contract + native-capabilities tell the agent to rely on for "task finished?" and
+ * rehydrate during long meta conversations about CLI/PIL/compaction/EE. */
+export declare const IMPORTANT_TOOL_NAMES: readonly ["read_file", "grep", "lsp", "bash", "ee_query", "usage_forensics", "selfverify_start", "selfverify_result", "selfverify_status"];
 /**
  * Heuristic: keep full (no stub) for high-signal tool results.
  * Signals: allowlist tool + (error/todo/plan/keyfile/large output or explicit keep list).
@@ -116,8 +119,14 @@ export declare const IMPORTANT_TOOL_NAMES: readonly ["read_file", "grep", "lsp",
 export declare function isHighValueToolResult(toolName: string, preview: string, explicitKeepIds?: Set<string>, toolCallId?: string): boolean;
 export declare function cumulativeMessageChars(messages: ReadonlyArray<ModelMessage>): number;
 /**
- * Compact a sub-agent message array in place-like fashion. Returns a NEW
- * array; the input is not mutated. Below the threshold the original array
- * reference is returned for cheap identity comparison in tests.
+ * Compact a sub-agent message array in place-like fashion. The input is never
+ * mutated. When compaction actually elides something a NEW array is returned.
+ * On a no-op (below threshold, or too few tool turns to skip) the ORIGINAL input
+ * array is returned BY REFERENCE so callers can detect "did not compact this
+ * step" via identity (`compacted === input`). The B4 wiring in
+ * message-processor.ts (pre-compaction warning + compaction note gating) and the
+ * sub-agent wiring in stream-runner.ts both rely on this contract — returning a
+ * fresh slice on a no-op silently made the warning dead and the note fire every
+ * step.
  */
 export declare function compactSubAgentMessages(messages: ReadonlyArray<ModelMessage>, opts?: SubAgentCompactorOptions): ModelMessage[];

package/dist/src/orchestrator/subagent-compactor.js

@@ -58,8 +58,21 @@ export const SUBAGENT_COMPACT_DEFAULT_THRESHOLD = 80_000;
 export const SUBAGENT_COMPACT_DEFAULT_KEEP_LAST = 3;
 const DEFAULT_OUTPUT_PREVIEW_CHARS = 200;
 const DEFAULT_LABEL = "sub-agent";
-/** Tools whose full outputs are high-value for anti-mù (idea 1). Keep verbatim even if older than keepLast. */
-export const IMPORTANT_TOOL_NAMES = ["read_file", "grep", "lsp", "bash"];
+/** Tools whose full outputs are high-value for anti-mù (idea 1). Keep verbatim even if older than keepLast.
+ * Extended for meta self-eval: ee_query / usage_forensics / selfverify_* are the exact artifacts
+ * the native contract + native-capabilities tell the agent to rely on for "task finished?" and
+ * rehydrate during long meta conversations about CLI/PIL/compaction/EE. */
+export const IMPORTANT_TOOL_NAMES = [
+    "read_file",
+    "grep",
+    "lsp",
+    "bash",
+    "ee_query",
+    "usage_forensics",
+    "selfverify_start",
+    "selfverify_result",
+    "selfverify_status",
+];
 /**
  * Heuristic: keep full (no stub) for high-signal tool results.
  * Signals: allowlist tool + (error/todo/plan/keyfile/large output or explicit keep list).
@@ -268,7 +281,9 @@ function rewriteOlderToolMessage(msg, previewChars, label, keepToolIds, persistA
             try {
                 persistArtifact(toolCallId, tr.toolName, rawPreview, "elided-by-compactor");
             }
-            catch { /* fail-open */ }
+            catch {
+                /* fail-open */
+            }
         }
         return {
             type: "tool-result",
@@ -282,9 +297,15 @@ function rewriteOlderToolMessage(msg, previewChars, label, keepToolIds, persistA
     return { ...msg, content: rewritten };
 }
 /**
- * Compact a sub-agent message array in place-like fashion. Returns a NEW
- * array; the input is not mutated. Below the threshold the original array
- * reference is returned for cheap identity comparison in tests.
+ * Compact a sub-agent message array in place-like fashion. The input is never
+ * mutated. When compaction actually elides something a NEW array is returned.
+ * On a no-op (below threshold, or too few tool turns to skip) the ORIGINAL input
+ * array is returned BY REFERENCE so callers can detect "did not compact this
+ * step" via identity (`compacted === input`). The B4 wiring in
+ * message-processor.ts (pre-compaction warning + compaction note gating) and the
+ * sub-agent wiring in stream-runner.ts both rely on this contract — returning a
+ * fresh slice on a no-op silently made the warning dead and the note fire every
+ * step.
  */
 export function compactSubAgentMessages(messages, opts = {}) {
     const resolved = resolveOpts(opts);
@@ -299,11 +320,12 @@ export function compactSubAgentMessages(messages, opts = {}) {
     // window utilization. Falls back to static char threshold + keepLast
     // when no contextWindowTokens supplied (preserves old behaviour).
     const { effectiveThresholdChars, effectiveKeepLastTurns } = computeDynamicParams(total, resolved);
+    // No-op: return the input BY REFERENCE (contract above) so `compacted === input`.
     if (total < effectiveThresholdChars)
-        return messages.slice();
+        return messages;
     const keepFrom = findKeepFromIndex(messages, effectiveKeepLastTurns);
     if (keepFrom <= 0)
-        return messages.slice();
+        return messages;
     // Walk older messages; rewrite fresh tool results into stubs, super-shrink
     // already-stubbed results (F1), and strip args off older assistant
     // tool-call shells (F1). The 1:1 assistant↔tool pairing required by the AI

package/dist/src/orchestrator/subagent-compactor.spec.js

@@ -64,6 +64,24 @@ describe("subagent-compactor: compactSubAgentMessages", () => {
         // No tool-result rewrite happened — output object identity per part preserved.
         expect(out[3]).toBe(msgs[3]);
     });
+    it("returns the SAME array reference on a no-op below threshold (compacted===input contract)", () => {
+        // Callers (message-processor B4 prepareStep:1840/1908/1914) detect "did NOT
+        // compact this step" via `compacted === stripped`. The docstring promises the
+        // original ref on a no-op; returning a fresh slice silently broke that —
+        // making the pre-compaction warning dead and the compaction note fire every
+        // step. Lock the identity contract.
+        const msgs = buildHistory(2, 5); // below threshold
+        expect(compactSubAgentMessages(msgs)).toBe(msgs);
+    });
+    it("returns a NEW array when compaction actually elides (compacted!==input)", () => {
+        const msgs = buildHistory(10, 10); // ~100kb > threshold
+        for (const m of msgs) {
+            if (m.role === "tool" && Array.isArray(m.content)) {
+                m.content[0].toolName = "other_tool"; // force low-value so it elides
+            }
+        }
+        expect(compactSubAgentMessages(msgs)).not.toBe(msgs);
+    });
     it("compacts when cumulative chars exceed threshold", () => {
         const msgs = buildHistory(10, 10); // ~100kb of tool output
         // Neutralize to test pure size-based elision (high-value keep would reduce savings).

package/dist/src/pil/__tests__/layer3-ee-injection.test.js

@@ -1,5 +1,5 @@
 import { beforeEach, describe, expect, test, vi } from "vitest";
-import { layer3EeInjection } from "../layer3-ee-injection.js";
+import { layer3EeInjection, RECALL_FEEDBACK_NUDGE } from "../layer3-ee-injection.js";
 vi.mock("../../ee/bridge.js", () => ({
     searchByText: vi.fn().mockResolvedValue([]),
 }));
@@ -93,8 +93,10 @@ describe("layer3EeInjection (bridge-based)", () => {
                 const chars = parseInt(charsMatch[1], 10);
                 // Two parallel collections, each at 15% of budget: 15% of 100 tokens * 4 chars/token
                 // = 60 chars per block + 3 for "..." suffix, joined with newline. Allow generous
-                // ceiling for header text + 2 blocks.
-                expect(chars).toBeLessThanOrEqual(260);
+                // ceiling for header text + 2 blocks, PLUS the fixed ee_feedback nudge appended
+                // when rateable experience is present. The 2000-char input means a truncation
+                // regression would blow well past this bound regardless.
+                expect(chars).toBeLessThanOrEqual(260 + RECALL_FEEDBACK_NUDGE.length + 1);
             }
         }
     });

package/dist/src/pil/__tests__/layer3-injected-chunk.test.js

@@ -75,6 +75,37 @@ describe("layer3 experience_injected chunk emission (CQ-16b)", () => {
         expect(chunk?.experienceInjected?.scoreFloor).toBeDefined();
         expect(typeof chunk?.experienceInjected?.scoreFloor).toBe("number");
     });
+    it("experience_injected chunk carries per-point {id, title, tier} so the TUI can show WHAT was injected", async () => {
+        mockSearchByText.mockResolvedValue([
+            {
+                id: "point-1",
+                score: 0.9,
+                payload: { text: "Use dependency injection for testability" },
+                collection: "experience-behavioral",
+            },
+        ]);
+        await layer3EeInjection(BASE_CTX);
+        const chunk = capturedSinkCalls.find((c) => typeof c !== "string" && c.type === "experience_injected");
+        const points = chunk?.experienceInjected?.points;
+        expect(Array.isArray(points)).toBe(true);
+        expect(points.length).toBeGreaterThan(0);
+        const p = points[0];
+        expect(p.id).toBe("point-1");
+        expect(p.title).toContain("dependency injection");
+        expect(["principle", "behavioral", "checkpoint"]).toContain(p.tier);
+    });
+    it("appends an ee_feedback nudge to the injected text when rateable experience is present", async () => {
+        mockSearchByText.mockResolvedValue([
+            {
+                id: "p1",
+                score: 0.9,
+                payload: { text: "Prefer composition over inheritance" },
+                collection: "experience-behavioral",
+            },
+        ]);
+        const result = await layer3EeInjection(BASE_CTX);
+        expect(result.enriched).toContain("ee_feedback(id, followed|ignored|noise)");
+    });
     it("does NOT emit experience_injected when searchByText returns empty array", async () => {
         mockSearchByText.mockResolvedValue([]);
         await layer3EeInjection(BASE_CTX);

package/dist/src/pil/__tests__/layer6-output.test.js

@@ -222,6 +222,15 @@ describe("getResponseToolSet — Phase 2b deliverableKind consume (model overrid
         // …and an explicit report request keeps it.
         expect(Object.keys(getResponseToolSet({ ...makeCtx("analyze", null), raw: "list all cost leaks" }))).toContain("respond_analyze");
     });
+    it("DROPS respond_* on an implement turn even when mis-classified as report (session 2b7a10219499)", () => {
+        // "lên plan rồi improvement … cải thiện X" is an implement turn the model
+        // tagged deliverable=report; the report-exception used to KEEP respond_plan,
+        // so the model stated a plan and ended the turn with edits done but
+        // uncommitted/unreported. Implementation intent must suppress the terminal
+        // tool BEFORE the deliverable branch is consulted.
+        expect(getResponseToolSet(ctxD("lên plan rồi improvement nhé, focus cải thiện Compaction", "plan", "report"))).toEqual({});
+        expect(getResponseToolSet(ctxD("improve the compactor and implement the fix", "plan", "report"))).toEqual({});
+    });
 });
 describe("applyPilSuffix — outputStyle variants", () => {
     const styles = ["concise", "detailed", "balanced"];
@@ -413,4 +422,16 @@ describe("isQuestionLike — Vietnamese yes/no question frames (regression: sess
         expect(isQuestionLike("explain the pipeline")).toBe(true);
     });
 });
+describe("isImplementationIntent — improve / cải thiện (regression: session 2b7a10219499)", () => {
+    it("recognises improve/improvement + VI cải thiện as implement turns", () => {
+        expect(isImplementationIntent("improve the compactor")).toBe(true);
+        expect(isImplementationIntent("lên plan rồi improvement nhé")).toBe(true);
+        expect(isImplementationIntent("focus cải thiện Compaction")).toBe(true);
+        expect(isImplementationIntent("cai thien phan compaction")).toBe(true);
+    });
+    it("does not over-match analysis questions that merely describe behaviour", () => {
+        expect(isImplementationIntent("what does the enrichment layer do?")).toBe(false);
+        expect(isImplementationIntent("why does the suite fail — break it down")).toBe(false);
+    });
+});
 //# sourceMappingURL=layer6-output.test.js.map

package/dist/src/pil/__tests__/pipeline.test.js

@@ -65,6 +65,23 @@ describe("runPipeline()", () => {
             expect(ctx.layers[i].delta).not.toBe("skipped:null-taskType");
         }
     });
+    it("felt-experience prompt injects the session snapshot even when taskType is null", async () => {
+        // Regression: the felt-experience injection was first placed INSIDE the
+        // `taskType !== null` branch, so a "cảm nhận trong CLI" question that
+        // classifies to null (not a coding task) silently skipped it. It must run
+        // regardless of taskType.
+        mockClassify.mockReturnValue({ tier: "abstain", confidence: 0.2, reason: "low-confidence" });
+        const ctx = await runPipeline("bạn có bị mù context không trong session này, cảm nhận thế nào");
+        expect(ctx.taskType).toBeNull();
+        expect(ctx.layers.find((l) => l.name === "session-experience")?.applied).toBe(true);
+        expect(ctx.enriched).toContain("[session experience —");
+        expect(ctx.enriched).toMatch(/not by reading the CLI source/i);
+    });
+    it("plain evaluate-the-CLI prompt does NOT inject the session snapshot", async () => {
+        const ctx = await runPipeline("đánh giá agent bên trong cli và đề xuất cải thiện");
+        expect(ctx.layers.find((l) => l.name === "session-experience")).toBeUndefined();
+        expect(ctx.enriched).not.toContain("[session experience —");
+    });
     it("metrics.totalMs is a non-negative number", async () => {
         const ctx = await runPipeline("refactor this");
         expect(ctx.metrics).not.toBeNull();

package/dist/src/pil/__tests__/surface-compaction-artifacts.test.d.ts

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