muonroi-cli 1.6.0 → 1.6.1

package/dist/src/orchestrator/message-processor.js

@@ -66,6 +66,7 @@ import { getModelInfo } from "../models/registry.js";
 import { cheapModelShellLine, injectCheapModelPlaybook, injectCheapModelShellDirective, shouldInjectCheapModelPlaybook, } from "../pil/cheap-model-playbook.js";
 import { injectCheapModelWorkbook, shouldInjectCheapModelWorkbook } from "../pil/cheap-model-workbooks.js";
 import { applyPilSuffix, getResponseTaskType, getResponseToolSet, isResponseTool, runPipeline, shouldHaltOnResponseTool, } from "../pil/index.js";
+import { isMetaAnalysisPrompt } from "../pil/layer6-output.js";
 import { taskTypeToMaxTokens, taskTypeToReasoningEffort, taskTypeToTier } from "../pil/task-tier-map.js";
 import { getProviderCapabilities } from "../providers/capabilities.js";
 import { loadKeyForProvider } from "../providers/keychain.js";
@@ -78,6 +79,7 @@ import { reportRouteOutcome } from "../router/decide.js";
 import { decideStepRouting, getStepRouterConfig } from "../router/step-router.js";
 import { routerStore } from "../router/store.js";
 import { getNextMessageSequence, logInteraction, markMessageErrored, markToolCallErrored, persistMessageWriteAhead, persistToolCallWriteAhead, } from "../storage/index.js";
+import { persistSessionExperience } from "../storage/session-experience-store.js";
 import { createBuiltinTools } from "../tools/registry.js";
 import { snapshotFromTodoWriteArgs } from "../tools/todo-write-snapshot.js";
 import { visionToolsNeeded } from "../tools/vision-gate.js";
@@ -103,6 +105,7 @@ import { buildRepetitionReminder, recordAssistantBurst, shouldInjectRepetitionRe
 import { classifyStreamError } from "./retry-classifier.js";
 import { forcedFinalize, getSessionLastTask, incSessionStep, parseBudgetOverride, recordSessionLastTask, resetSessionStep, resolveCeiling, } from "./scope-ceiling.js";
 import { attachReminderToMessages, buildCheckpointReminder, buildScopeReminder, cadenceForSize, shouldInjectCeilingCrossing, shouldInjectReminder, shouldInjectSoftWarn, shouldPreWarnCompaction, } from "./scope-reminder.js";
+import { formatElisionManifest, getSessionExperienceCounts, recordCompaction, recordElision, } from "./session-experience.js";
 import { attemptStallRescue, pushStallToolResult } from "./stall-rescue.js";
 import { createStallWatchdog, STALL_ERROR_MESSAGE } from "./stall-watchdog.js";
 import { wrapToolSetWithCap } from "./sub-agent-cap.js";
@@ -1505,6 +1508,10 @@ export class MessageProcessor {
                                 // rehydrate it even if EE is down (the EE extract below caps at 8k
                                 // and needs the network; the cache keeps up to 200k, no network).
                                 recordArtifact(toolCallId, toolName, fullContent);
+                                // Lived-experience telemetry: count this elision so a later
+                                // "cảm nhận trong CLI" question answers from data, and so the
+                                // post-compaction note can list what it just stubbed.
+                                recordElision(toolCallId, toolName, fullContent.length, sn);
                                 try {
                                     getDefaultEEClient()
                                         .extract({
@@ -1527,13 +1534,20 @@ export class MessageProcessor {
                             };
                             const compacted = compactSubAgentMessages(stripped, {
                                 thresholdChars: topLevelCompactThreshold,
-                                keepLastTurns: topLevelCompactKeepLast,
+                                // Rec #1 (cheap part): on meta/self-eval turns keep a couple more
+                                // trailing tool turns verbatim — those carry the reasoning the
+                                // agent is being asked to reflect on, and over-eliding them is
+                                // exactly what starves a self-evaluation. One boolean, no new
+                                // detection logic (isMetaAnalysisPrompt already gates layer3/5).
+                                keepLastTurns: topLevelCompactKeepLast + (isMetaAnalysisPrompt(userMessage) ? 2 : 0),
                                 label: "top-level",
                                 envelopeChars,
                                 contextWindowTokens,
                                 keepToolIds: keepToolIds.length ? keepToolIds : undefined,
                                 persistArtifact,
                             });
+                            if (compacted !== stripped)
+                                recordCompaction(sn);
                             // Pre-compaction visibility: give the agent one step of notice
                             // before B4 actually rewrites history into stubs. This is the
                             // advance warning that was missing — agent can now decide to
@@ -1619,7 +1633,15 @@ export class MessageProcessor {
                             // "task finished?", "compacted yet?", "EE checkpoint" so agent can self-assess and avoid mù
                             // even when the top-level summary is not in its immediate focus (sub-agents, long loops).
                             const _compactNote = compacted !== stripped
-                                ? `[context compacted at step ${sn} — older or low-value tool results rewritten to stubs to fit budget. High-value evidence (file reads, bash, your previous responses) is kept verbatim. ${buildCheckpointReminder(sn, true)}]`
+                                ? (() => {
+                                    // Rec #2: turn the generic "high-value elided? use ee_query"
+                                    // prose into a concrete, actionable manifest of what was just
+                                    // stubbed (id/tool/size) — sourced from the elisions recorded
+                                    // by persistArtifact above — so the rehydrate round-trip is
+                                    // informed, not blind.
+                                    const _m = formatElisionManifest();
+                                    return `[context compacted at step ${sn} — older or low-value tool results rewritten to stubs to fit budget. High-value evidence (file reads, bash, your previous responses) is kept verbatim. ${buildCheckpointReminder(sn, true)}${_m ? ` ${_m}` : ""}]`;
+                                })()
                                 : null;
                             if (_compactNote) {
                                 return { messages: attachReminderToMessages(compacted, _compactNote) };
@@ -1680,6 +1702,16 @@ export class MessageProcessor {
                                 console.error("[Agent:onFinish] failed to emit llm-done", err);
                             }
                             deps.setCurrentCallId("");
+                            // Rec #1 persisted forensics: onFinish fires once per top-level turn,
+                            // so flush this session's cumulative experience counts here. Readers
+                            // take the latest row per session, so the last turn's row is the
+                            // session total. No-ops on missing id / all-zero. Fail-open.
+                            try {
+                                persistSessionExperience(deps.session?.id ?? null, getSessionExperienceCounts());
+                            }
+                            catch (err) {
+                                console.error("[Agent:onFinish] persistSessionExperience failed", err);
+                            }
                         },
                     });
                     let _topTokenIndex = 0;

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

@@ -53,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";
@@ -415,6 +416,7 @@ export class StreamRunner {
                 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({
@@ -435,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/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__/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/layer3-ee-injection.d.ts

@@ -15,6 +15,15 @@
  * and PIL Layer 3 are active on the same pipeline run.
  */
 import type { PipelineContext } from "./types.js";
+/**
+ * Inline reminder appended to the injected experience block (when rateable
+ * principles/behavioral are present) so passively-injected recalls carry a
+ * feedback prompt next to their [id:..] handles — the front-loaded
+ * native-capabilities instruction can be compacted away on long sessions, and
+ * unrated recalls degrade future recall (the recall arm of the EE loop is
+ * explicit-feedback-only by design).
+ */
+export declare const RECALL_FEEDBACK_NUDGE = "\u21B3 Acted on one of the above [id:..]? Rate it: ee_feedback(id, followed|ignored|noise). Unrated recalls degrade future recall.";
 export declare function layer3EeInjection(ctx: PipelineContext): Promise<PipelineContext>;
 /**
  * Issue #4 — meta-turn TARGETED complement to Layer 3's checkpoint arm.

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

@@ -45,6 +45,15 @@ const PIL_PRINCIPLES_FLOOR = Math.max(0, PIL_SCORE_FLOOR - 0.15);
 // hitCount threshold for promoting a behavioral point to T1 "proven" reflex.
 // Mirrors the EE evolution promotion rule (3 confirmed hits → T1).
 const T1_HIT_THRESHOLD = 3;
+/**
+ * Inline reminder appended to the injected experience block (when rateable
+ * principles/behavioral are present) so passively-injected recalls carry a
+ * feedback prompt next to their [id:..] handles — the front-loaded
+ * native-capabilities instruction can be compacted away on long sessions, and
+ * unrated recalls degrade future recall (the recall arm of the EE loop is
+ * explicit-feedback-only by design).
+ */
+export const RECALL_FEEDBACK_NUDGE = "↳ Acted on one of the above [id:..]? Rate it: ee_feedback(id, followed|ignored|noise). Unrated recalls degrade future recall.";
 /**
  * Extract all sha16 values from `<!-- bb-context-injected:<sha16> -->` markers
  * already present in the enriched context string.
@@ -289,12 +298,22 @@ export async function layer3EeInjection(ctx) {
     // STALE-01: Register injected point IDs for prompt-stale reconciliation.
     updateLastSurfacedState(allPoints.map((p) => String(p.id)));
     // CQ-16b: Emit experience_injected StreamChunk so TUI can show collapsible block.
+    // Carry per-point {id, title, tier} so the TUI can show WHAT was injected, not
+    // just how many (the data already exists here; previously only the count + ids
+    // reached the client and the title was never serialized).
+    const pointTitle = (p) => (extractPointText(p).split("\n")[0] ?? "").replace(/\s+/g, " ").trim().slice(0, 100);
+    const injectedPoints = [
+        ...deduplicatedPrinciples.map((p) => ({ id: String(p.id), title: pointTitle(p), tier: "principle" })),
+        ...deduplicatedBehavioral.map((p) => ({ id: String(p.id), title: pointTitle(p), tier: "behavioral" })),
+        ...deduplicatedCheckpoints.map((p) => ({ id: String(p.id), title: pointTitle(p), tier: "checkpoint" })),
+    ];
     try {
         const injectedChunk = {
             type: "experience_injected",
             experienceInjected: {
                 pointCount: totalPoints + deduplicatedCheckpoints.length,
                 pointIds: allPoints.map((p) => String(p.id)),
+                points: injectedPoints,
                 scoreFloor: PIL_SCORE_FLOOR,
                 taskType: ctx.taskType ?? undefined,
                 domain: ctx.domain ?? undefined,
@@ -324,6 +343,16 @@ export async function layer3EeInjection(ctx) {
         // Idea 5: raised from 0.08 to 0.12 for higher fidelity on critical progress + artifact refs.
         parts.push(truncateToBudget(cpText + "\n" + marker, Math.floor(ctx.tokenBudget * 0.12)));
     }
+    // Close the recall feedback loop at the injection site: passively-injected
+    // experience (the agent did not ee_query for it) otherwise carries no feedback
+    // prompt, so it goes unrated and EE cannot learn if the injection was gold or
+    // noise. The front-loaded native-capabilities instruction can be compacted away
+    // on long sessions; this nudge rides next to the [id:..] handles it refers to.
+    // Gated on rateable experience (principles/behavioral) — checkpoints are task
+    // artifacts, not recall verdicts.
+    if (deduplicatedPrinciples.length + deduplicatedBehavioral.length > 0) {
+        parts.push(RECALL_FEEDBACK_NUDGE);
+    }
     const injected = parts.join("\n");
     try {
         if (ctx.sessionId) {

package/dist/src/pil/layer4-gsd.js

@@ -18,7 +18,7 @@
  */
 import { routeTask } from "../ee/bridge.js";
 import { scoreComplexity } from "../gsd/complexity.js";
-import { buildDirective } from "../gsd/directives.js";
+import { buildDirective, mentionsEcosystemScope } from "../gsd/directives.js";
 import { detectGrayAreas } from "../gsd/gray-areas.js";
 import { detectGsdPhase } from "../gsd/types.js";
 import { classifyEeError, logEeFailure } from "../utils/ee-logger.js";
@@ -96,7 +96,8 @@ export async function layer4Gsd(ctx) {
         : isMetaAnalysisPrompt(ctx.raw) ||
             (ctx.taskType === "general" && ctx.intentKind === "task") ||
             (isQuestionLike(ctx.raw) && !isImplementationIntent(ctx.raw));
-    const directive = buildDirective({ complexity, phase, grayAreas, informational });
+    const ecosystem = mentionsEcosystemScope(ctx.raw);
+    const directive = buildDirective({ complexity, phase, grayAreas, informational, ecosystem });
     const budgetChars = Math.floor(ctx.tokenBudget * DIRECTIVE_BUDGET_FRACTION);
     const trimmed = truncateToBudget(directive.text, budgetChars);
     return {