muonroi-cli 1.5.0 → 1.6.1

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

@@ -0,0 +1,112 @@
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { surfaceCompactionArtifacts } from "../layer3-ee-injection.js";
+// Issue #4 — targeted complement to layer3's checkpoint arm on meta turns.
+// layer3 (now run on meta after issue #2) surfaces checkpoints via a FIXED
+// recency query; this arm searches by the meta question (ctx.raw) to surface the
+// elided tool-artifacts relevant to it, and DEFERS when layer3 already injected a
+// checkpoint block. Mock the EE search + the audit log so the test stays offline.
+vi.mock("../../ee/bridge.js", () => ({
+    searchByText: vi.fn().mockResolvedValue([]),
+}));
+vi.mock("../../storage/interaction-log.js", () => ({
+    logInteraction: vi.fn(),
+}));
+import { searchByText } from "../../ee/bridge.js";
+function makeCtx(overrides = {}) {
+    return {
+        raw: "compaction cần cải thiện gì trong CLI",
+        enriched: "compaction cần cải thiện gì trong CLI",
+        taskType: "general",
+        domain: null,
+        confidence: 0.85,
+        outputStyle: "balanced",
+        tokenBudget: 2000,
+        metrics: null,
+        layers: [],
+        sessionId: "sess-meta-1",
+        ...overrides,
+    };
+}
+const artifactPoint = {
+    id: "art1",
+    score: 0.9,
+    payload: {
+        text: "tool-artifact id=call_7 toolName=read_file elided 4200 chars: src/orchestrator/compaction.ts createCompactionSummaryMessage ...",
+    },
+    collection: "experience-behavioral",
+};
+const checkpointPoint = {
+    id: "cp1",
+    score: 0.8,
+    payload: { text: "Context checkpoint summary ✔ DONE: extended IMPORTANT_TOOL_NAMES; tests 16/16" },
+    collection: "experience-behavioral",
+};
+const genericPoint = {
+    id: "gen1",
+    score: 0.97,
+    payload: { text: "Always run the full test suite before pushing" },
+    collection: "experience-behavioral",
+};
+describe("surfaceCompactionArtifacts (issue #4 — meta-turn auto-surface)", () => {
+    beforeEach(() => {
+        vi.mocked(searchByText).mockReset();
+        vi.mocked(searchByText).mockResolvedValue([]);
+    });
+    test("auto-surfaces [artifact] + checkpoint refs (and the rehydrate instruction) into enriched", async () => {
+        // biome-ignore lint/suspicious/noExplicitAny: test fixture shape mirrors EEPoint
+        vi.mocked(searchByText).mockResolvedValue([artifactPoint, checkpointPoint]);
+        const ctx = makeCtx();
+        const out = await surfaceCompactionArtifacts(ctx);
+        expect(out.enriched).toContain("[artifact]"); // artifact-typed line
+        expect(out.enriched).toContain("ee.query tool"); // how to rehydrate the full output
+        expect(out.enriched).toContain("call_7"); // the concrete tool-artifact id the agent can fetch
+        const layer = out.layers.find((l) => l.name === "ee-meta-artifacts");
+        expect(layer?.applied).toBe(true);
+        expect(layer?.delta).toContain("artifacts=2");
+        // Searches only the behavioral collection (where tool-artifacts are persisted).
+        expect(vi.mocked(searchByText)).toHaveBeenCalledWith(expect.stringContaining("tool-artifact"), ["experience-behavioral"], expect.any(Number), expect.any(Object));
+    });
+    test("no sessionId → unchanged, no EE call (no prior compaction to rehydrate)", async () => {
+        const ctx = makeCtx({ sessionId: undefined });
+        const out = await surfaceCompactionArtifacts(ctx);
+        expect(out.enriched).toBe(ctx.enriched);
+        expect(out.layers.find((l) => l.name === "ee-meta-artifacts")?.delta).toBe("no-session");
+        expect(vi.mocked(searchByText)).not.toHaveBeenCalled();
+    });
+    test("search failure is fail-open + recorded (delta=error=…, enriched unchanged)", async () => {
+        vi.mocked(searchByText).mockRejectedValue(new Error("EE down"));
+        const ctx = makeCtx();
+        const out = await surfaceCompactionArtifacts(ctx);
+        expect(out.enriched).toBe(ctx.enriched);
+        expect(out.layers.find((l) => l.name === "ee-meta-artifacts")?.delta).toMatch(/^error=/);
+    });
+    test("generic behavioral hits are filtered out (not mislabelled as artifacts)", async () => {
+        // biome-ignore lint/suspicious/noExplicitAny: test fixture shape mirrors EEPoint
+        vi.mocked(searchByText).mockResolvedValue([genericPoint]);
+        const ctx = makeCtx();
+        const out = await surfaceCompactionArtifacts(ctx);
+        expect(out.enriched).toBe(ctx.enriched);
+        expect(out.layers.find((l) => l.name === "ee-meta-artifacts")?.delta).toBe("no-artifacts");
+    });
+    test("defers to layer3 — skips with NO EE call when a checkpoint block is already present", async () => {
+        // layer3 ran first this turn and injected a checkpoint block (its marker is
+        // in enriched). The complement must not duplicate it or pay a 2nd round-trip.
+        const enriched = `${makeCtx().raw}\n[task checkpoints …]\n<!-- ee-checkpoint-injected:0123456789abcdef -->`;
+        const out = await surfaceCompactionArtifacts(makeCtx({ enriched }));
+        expect(out.layers.find((l) => l.name === "ee-meta-artifacts")?.delta).toBe("already-surfaced");
+        expect(out.enriched).toBe(enriched); // unchanged
+        expect(vi.mocked(searchByText)).not.toHaveBeenCalled();
+    });
+    test("idempotent — a second pass on its own output defers (marker it wrote is seen)", async () => {
+        // biome-ignore lint/suspicious/noExplicitAny: test fixture shape mirrors EEPoint
+        vi.mocked(searchByText).mockResolvedValue([artifactPoint]);
+        const first = await surfaceCompactionArtifacts(makeCtx());
+        expect(first.enriched).toContain("[artifact]");
+        expect(vi.mocked(searchByText)).toHaveBeenCalledTimes(1);
+        const second = await surfaceCompactionArtifacts(makeCtx({ enriched: first.enriched }));
+        expect(second.layers.find((l) => l.name === "ee-meta-artifacts")?.delta).toBe("already-surfaced");
+        expect(second.enriched).toBe(first.enriched); // not grown a second time
+        expect(vi.mocked(searchByText)).toHaveBeenCalledTimes(1); // no second round-trip
+    });
+});
+//# sourceMappingURL=surface-compaction-artifacts.test.js.map

package/dist/src/pil/layer3-ee-injection.d.ts

@@ -15,4 +15,32 @@
  * 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.
+ *
+ * Since issue #2, Layer 3 now runs on the meta-analysis path too, so its
+ * checkpoint arm already surfaces recent checkpoints/artifacts for the agent.
+ * That arm uses a FIXED recency query, though — it isn't biased toward the
+ * current meta question. This arm fills that gap: it searches by `ctx.raw` so a
+ * self-evaluating agent sees the elided tool-artifacts RELEVANT to what it's
+ * analyzing, rendered via the same `formatTaskCheckpoints` so the `[artifact]
+ * … id=X` refs appear automatically instead of waiting on a manual `ee_query`.
+ *
+ * Defers to Layer 3: if a checkpoint block was already injected this turn (any
+ * `ee-checkpoint-injected` marker present) it skips entirely — no duplicate
+ * block and no second EE round-trip. Gated on `sessionId` (no session ⇒ no prior
+ * compaction to rehydrate). Strictly additive and fail-open: any error /
+ * no-session / no-match / already-surfaced returns ctx with the original
+ * `enriched` plus an `ee-meta-artifacts` layer marker for forensics.
+ */
+export declare function surfaceCompactionArtifacts(ctx: PipelineContext): Promise<PipelineContext>;

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.
@@ -119,7 +128,7 @@ async function queryEeBridge(raw) {
         const [principleRaw, behavioralRaw, checkpointRaw] = await Promise.all([
             searchByText(raw, ["experience-principles"], 3, signal),
             searchByText(raw, ["experience-behavioral"], 4, signal),
-            searchByText("Context checkpoint summary OR \"compaction checkpoint\" recent Progress DONE elided OR tool-artifact OR \"tool result id=\"", ["experience-behavioral"], 3, signal).catch(() => []),
+            searchByText('Context checkpoint summary OR "compaction checkpoint" recent Progress DONE elided OR tool-artifact OR "tool result id="', ["experience-behavioral"], 3, signal).catch(() => []),
         ]);
         const principlePoints = principleRaw.filter((p) => (p.score ?? 0) >= PIL_PRINCIPLES_FLOOR);
         const behavioralPoints = behavioralRaw.filter((p) => (p.score ?? 0) >= PIL_SCORE_FLOOR);
@@ -161,14 +170,16 @@ function formatExperienceHints(points) {
 function formatTaskCheckpoints(points) {
     if (points.length === 0)
         return "";
-    const lines = points.map((p) => {
+    const lines = points
+        .map((p) => {
         const t = extractPointText(p);
         // Idea 4: surface tool-artifact refs so agent sees "elided high-value, query for full"
         if (/tool-artifact|tool result id=|elided.*id=/.test(t.toLowerCase())) {
             return `- [artifact] ${t.slice(0, 160)} [id:${p.id}]`;
         }
         return `- ${t.slice(0, 180)} [id:${p.id}]`;
-    }).filter((l) => l !== "- ");
+    })
+        .filter((l) => l !== "- ");
     if (lines.length === 0)
         return "";
     return `[task checkpoints — prior compactions: use to answer "task finished?", "compacted yet?". Artifacts: use ee.query tool with "tool-artifact id=XXX" for full elided tool output.] \n${lines.join("\n")}`;
@@ -282,17 +293,27 @@ export async function layer3EeInjection(ctx) {
             const text = extractPointText(p);
             return text.length === 0 || !checkpointMarkerShas.has(payloadSha16(text));
         })
-        : (result.checkpointPoints || []);
+        : result.checkpointPoints || [];
     const allPoints = [...deduplicatedPrinciples, ...deduplicatedBehavioral, ...deduplicatedCheckpoints];
     // 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,
@@ -322,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) {
@@ -359,4 +390,94 @@ export async function layer3EeInjection(ctx) {
         ],
     };
 }
+/**
+ * Records whose text actually reads like a compaction checkpoint or an elided
+ * tool-artifact. Used to keep generic behavioral hits from being mislabelled as
+ * `[artifact]`/checkpoint lines when we search by the meta question (ctx.raw)
+ * rather than the fixed checkpoint-arm query.
+ */
+const CHECKPOINT_LIKE_RE = /context checkpoint summary|compaction checkpoint|tool-artifact|tool result id=|elided|progress[^a-z]*done|✔/i;
+/**
+ * Issue #4 — meta-turn TARGETED complement to Layer 3's checkpoint arm.
+ *
+ * Since issue #2, Layer 3 now runs on the meta-analysis path too, so its
+ * checkpoint arm already surfaces recent checkpoints/artifacts for the agent.
+ * That arm uses a FIXED recency query, though — it isn't biased toward the
+ * current meta question. This arm fills that gap: it searches by `ctx.raw` so a
+ * self-evaluating agent sees the elided tool-artifacts RELEVANT to what it's
+ * analyzing, rendered via the same `formatTaskCheckpoints` so the `[artifact]
+ * … id=X` refs appear automatically instead of waiting on a manual `ee_query`.
+ *
+ * Defers to Layer 3: if a checkpoint block was already injected this turn (any
+ * `ee-checkpoint-injected` marker present) it skips entirely — no duplicate
+ * block and no second EE round-trip. Gated on `sessionId` (no session ⇒ no prior
+ * compaction to rehydrate). Strictly additive and fail-open: any error /
+ * no-session / no-match / already-surfaced returns ctx with the original
+ * `enriched` plus an `ee-meta-artifacts` layer marker for forensics.
+ */
+export async function surfaceCompactionArtifacts(ctx) {
+    const markLayer = (applied, delta) => ({
+        ...ctx,
+        layers: [...ctx.layers, { name: "ee-meta-artifacts", applied, delta }],
+    });
+    if (!ctx.sessionId)
+        return markLayer(false, "no-session");
+    // Defer to Layer 3: a checkpoint/artifact block is already present this turn,
+    // so don't duplicate it or pay a second EE round-trip. This arm only fills the
+    // gap when Layer 3's fixed-query checkpoint arm surfaced nothing.
+    if (extractCheckpointMarkerShas(ctx.enriched).size > 0)
+        return markLayer(false, "already-surfaced");
+    let points = [];
+    try {
+        const signal = AbortSignal.timeout(PIL_SEARCH_TIMEOUT_MS);
+        // Bias toward records relevant to THIS meta question (ctx.raw) while pulling
+        // in checkpoint/artifact vocabulary so the single cheap arm lands on the
+        // compaction records rather than generic behavioral patterns.
+        const query = `${ctx.raw}\nContext checkpoint summary tool-artifact "tool result id=" elided Progress DONE`;
+        const raw = await searchByText(query, ["experience-behavioral"], 5, signal);
+        points = raw
+            .filter((p) => (p.score ?? 0) >= PIL_SCORE_FLOOR * 0.7)
+            .filter((p) => CHECKPOINT_LIKE_RE.test(extractPointText(p)));
+    }
+    catch (err) {
+        logEeFailure("pil.meta.surfaceCompactionArtifacts", classifyEeError(err), err, { budgetMs: PIL_SEARCH_TIMEOUT_MS });
+        return markLayer(false, `error=${String(err)}`);
+    }
+    if (points.length === 0)
+        return markLayer(false, "no-artifacts");
+    const cpText = formatTaskCheckpoints(points);
+    if (!cpText)
+        return markLayer(false, "no-artifacts");
+    // Append the marker AFTER truncation so it always survives into `enriched`
+    // — that marker is what makes the defer-check above fire on any later pass.
+    const blockSha = payloadSha16(cpText);
+    const body = truncateToBudget(cpText, Math.floor(ctx.tokenBudget * 0.12));
+    const block = `${body}\n<!-- ee-checkpoint-injected:${blockSha} -->`;
+    try {
+        if (ctx.sessionId) {
+            logInteraction(ctx.sessionId, "ee_injection", {
+                eventSubtype: "injected",
+                data: {
+                    phase: "pil_meta_artifacts",
+                    role: "knowledge_retriever",
+                    checkpointCount: points.length,
+                    pointIds: points.map((p) => String(p.id)),
+                    injectedChars: block.length,
+                },
+            });
+        }
+    }
+    catch (err) {
+        // No silent catch: surfacing succeeded; only the audit write failed.
+        console.error(`[pil.meta.surfaceCompactionArtifacts] interaction log failed: ${err?.message}`);
+    }
+    return {
+        ...ctx,
+        enriched: `${ctx.enriched}\n${block}`,
+        layers: [
+            ...ctx.layers,
+            { name: "ee-meta-artifacts", applied: true, delta: `artifacts=${points.length} chars=${block.length}` },
+        ],
+    };
+}
 //# sourceMappingURL=layer3-ee-injection.js.map

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 {

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

@@ -258,12 +258,16 @@ export function applyPilSuffix(systemPrompt, ctx, responseToolsActive = false) {
  * OUTPUT RULES (graceful — exactly what code-heavy tasks already do), so a false
  * positive on an analysis turn only forgoes structured JSON, never breaks output.
  *
- * High-signal verbs only (implement/edit/wire/rewrite/rename/scaffold/refactor,
- * "make the change", "apply the fix/patch", VI equivalents). Bare "fix"/"replace"
- * are excluded — too common in analysis ("explain the fix") — so pure
- * analyze/plan/debug-investigation turns keep their structured output.
+ * High-signal verbs only (implement/edit/wire/rewrite/rename/scaffold/refactor/
+ * improve, "make the change", "apply the fix/patch", VI equivalents incl. "cải
+ * thiện"). Bare "fix"/"replace" are excluded — too common in analysis ("explain
+ * the fix") — so pure analyze/plan/debug-investigation turns keep their
+ * structured output. "improve(ment)" / "cải thiện" added after session
+ * 2b7a10219499: "lên plan rồi improvement … cải thiện Compaction" was an
+ * implement turn the model mis-classified as a `report`, so a terminal
+ * respond_plan ended it on a plan (edits done but uncommitted/unreported).
  */
-const IMPLEMENTATION_INTENT_RE = /\b(implement|edit|wire(?:\s+up)?|rewrite|rename|scaffold|refactor)\b|\bmake\s+(the\s+)?(change|edit|modification)s?\b|\bapply\s+(the\s+)?(fix|change|patch|edit|diff)\b|(?:^|\s)(triển\s*khai|trien\s*khai|chỉnh\s*sửa|chinh\s*sua|viết\s*lại|viet\s*lai|đổi\s*tên|doi\s*ten)\b/i;
+const IMPLEMENTATION_INTENT_RE = /\b(implement|edit|wire(?:\s+up)?|rewrite|rename|scaffold|refactor)\b|\bimprove(?:ment)?\b|\bmake\s+(the\s+)?(change|edit|modification)s?\b|\bapply\s+(the\s+)?(fix|change|patch|edit|diff)\b|(?:^|\s)(triển\s*khai|trien\s*khai|chỉnh\s*sửa|chinh\s*sua|viết\s*lại|viet\s*lai|đổi\s*tên|doi\s*ten|cải\s*thiện|cai\s*thien)\b/i;
 export function isImplementationIntent(raw) {
     return !!raw && IMPLEMENTATION_INTENT_RE.test(raw);
 }
@@ -340,6 +344,15 @@ export function getResponseToolSet(ctx, providerId) {
     //   - report → keep the structured tool (its value IS the structure).
     // Only when the model didn't emit a deliverable (null → legacy cascade / model
     // omitted the word) do we fall back to the legacy regex predicates.
+    // Implementation intent ALWAYS suppresses a terminal respond_* — checked
+    // BEFORE the deliverable branch so a mis-classified `report` can't bypass it
+    // (session 2b7a10219499: a "plan rồi improvement" implement turn got
+    // deliverable=report → the report-exception below kept respond_plan → the
+    // model stated a plan and ended the turn with edits done but uncommitted).
+    // A respond_* tool lets the model "answer" and stop before edits land, so any
+    // implement turn must fall through to the markdown OUTPUT RULES instead.
+    if (isImplementationIntent(ctx.raw))
+        return {};
     if (ctx.deliverableKind) {
         if (ctx.deliverableKind === "code")
             return {};
@@ -347,8 +360,6 @@ export function getResponseToolSet(ctx, providerId) {
             return {};
     }
     else {
-        if (isImplementationIntent(ctx.raw))
-            return {};
         if (ctx.taskType !== "general" && !prefersStructuredReport(ctx.raw))
             return {};
     }

package/dist/src/pil/pipeline.js

@@ -22,11 +22,12 @@ import { isDiscoveryEnabled } from "./config.js";
 import { scoreComplexitySize } from "./layer1_5-complexity-size.js";
 import { layer1Intent } from "./layer1-intent.js";
 import { layer2Personality } from "./layer2-personality.js";
-import { layer3EeInjection } from "./layer3-ee-injection.js";
+import { layer3EeInjection, surfaceCompactionArtifacts } from "./layer3-ee-injection.js";
 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";
@@ -144,15 +145,21 @@ async function runLayers(ctx, options) {
     }
     if (ctx.taskType !== null) {
         await timed("layer2-personality", layer2Personality);
+        // Issue #2: meta-analysis turns used to skip layer3 (EE recall) + layer5
+        // (context) to cut overhead — but that starved exactly the self-evaluation
+        // turns where behavioral/principle recall matters most. Run the full
+        // sequence for every taskType-bearing turn now. In the live (interactive)
+        // path there is no pipeline timeout (see runPipeline), and each EE layer is
+        // internally timeout-bounded, so meta turns just carry the same EE budget as
+        // a normal turn.
+        await timed("layer3-ee-injection", layer3EeInjection);
+        await timed("layer4-gsd-structuring", layer4Gsd);
+        await timed("layer5-context-enrichment", layer5Context);
         if (isMetaAnalysisPrompt(ctx.raw)) {
-            // FIX: skip heavy EE (layer3) + context (layer5) for meta-analysis turns
-            // to reduce PIL overhead on evaluation/improvement questions (as intended).
-            await timed("layer4-gsd-structuring", layer4Gsd);
-        }
-        else {
-            await timed("layer3-ee-injection", layer3EeInjection);
-            await timed("layer4-gsd-structuring", layer4Gsd);
-            await timed("layer5-context-enrichment", layer5Context);
+            // Issue #4 (targeted complement): surface the elided tool-artifacts
+            // RELEVANT to this meta question. Defers to layer3 — it only fires when
+            // layer3's fixed-query checkpoint arm surfaced no checkpoint block.
+            await timed("ee-meta-artifacts", surfaceCompactionArtifacts);
         }
     }
     else {
@@ -171,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;