muonroi-cli 1.5.0 → 1.6.1

package/dist/src/gsd/directives.js

@@ -15,6 +15,27 @@
  * user-facing prompts into the user's language at render time.
  */
 const HEADER = "[gsd-native]";
+/**
+ * High-precision predicate: is this turn about the Muonroi ECOSYSTEM (where the
+ * muonroi-docs MCP is the right source), as opposed to muonroi-cli internals?
+ * Deliberately TIGHTER than smart-filter's hasEcosystemSignal — that one keeps
+ * the server (over-keeping costs only tokens), but a behavioural "call docs
+ * FIRST" nudge must not fire on every "muonroi" mention or it misdirects
+ * CLI-internals questions toward .NET package docs. EN + VI.
+ */
+const ECOSYSTEM_SCOPE_RE = /\becosystem\b|hệ\s*sinh\s*thái|he\s*sinh\s*thai|building[-\s]?block|open[-\s]?core|rule\s*engine|decision\s*table|\bnuget\b/i;
+export function mentionsEcosystemScope(message) {
+    return ECOSYSTEM_SCOPE_RE.test(message);
+}
+/**
+ * Appended to any directive when the turn is ecosystem-scoped. Phrased
+ * conditionally ("if … available") so it is harmless when muonroi-docs is not
+ * configured — the model simply finds no such tool and falls back to local files.
+ */
+export const ECOSYSTEM_DOCS_NUDGE = [
+    `${HEADER} ECOSYSTEM SCOPE — this turn concerns the Muonroi ecosystem (platform overview, BB/.NET packages, building-block, open-core boundary, setup).`,
+    "If the muonroi-docs MCP is available, it is the AUTHORITATIVE source — call it FIRST (docs_search / setup_guide / bb_recipe_list / bb_package_describe), THEN ground with local files. Do NOT characterize the ecosystem from local repo files alone.",
+].join("\n");
 function renderGrayAreas(qs) {
     if (qs.length === 0)
         return "  (no gray areas detected — confirm the request is fully specified before proceeding)";
@@ -94,16 +115,19 @@ function buildQuick(input) {
 export function buildDirective(input) {
     // Informational/meta prompts answer a human — never apply the
     // implement/verify scaffold (it agent-ifies the reply), regardless of tier.
-    if (input.informational) {
-        return { text: buildQuestion(), tier: input.complexity.tier, blocking: false };
-    }
-    switch (input.complexity.tier) {
-        case "heavy":
-            return { text: buildHeavy(input), tier: "heavy", blocking: true };
-        case "standard":
-            return { text: buildStandard(input), tier: "standard", blocking: false };
-        default:
-            return { text: buildQuick(input), tier: "quick", blocking: false };
+    const base = input.informational
+        ? { text: buildQuestion(), tier: input.complexity.tier, blocking: false }
+        : input.complexity.tier === "heavy"
+            ? { text: buildHeavy(input), tier: "heavy", blocking: true }
+            : input.complexity.tier === "standard"
+                ? { text: buildStandard(input), tier: "standard", blocking: false }
+                : { text: buildQuick(input), tier: "quick", blocking: false };
+    // Ecosystem-scoped turns get a docs-first nudge regardless of tier (question
+    // OR task): muonroi-docs is the authoritative source and must not be skipped
+    // in favour of guessing from local files (session 41ccfeb2ceee turn 1).
+    if (input.ecosystem) {
+        return { ...base, text: `${base.text}\n${ECOSYSTEM_DOCS_NUDGE}` };
     }
+    return base;
 }
 //# sourceMappingURL=directives.js.map

package/dist/src/index.js

@@ -1319,6 +1319,15 @@ usage
     const { runCostForensics } = await import("./cli/cost-forensics.js");
     await runCostForensics({ prefix: sessionPrefix, json: opts.json });
 });
+usage
+    .command("experience")
+    .description("Cross-session anti-mù telemetry: how often compaction elides tool outputs and whether the agent recovers them (gates the deferred auto-protect re-architecture).")
+    .option("--limit <n>", "Number of most-recent sessions to aggregate", "100")
+    .option("--json", "Emit aggregate as JSON")
+    .action(async (opts) => {
+    const { runExperienceReport } = await import("./cli/experience-report.js");
+    await runExperienceReport({ limit: parseInt(opts.limit, 10) || 100, json: opts.json });
+});
 usage
     .command("security-audit")
     .description("Security posture: yolo/permission overrides, high-risk cmds, shuru audits + cost (from decision-log events)")

package/dist/src/mcp/__tests__/client-pool.spec.js

@@ -42,7 +42,7 @@ describe("acquireMcpTools — cross-turn client pool", () => {
         expect(Object.keys(b2.tools)).toContain("mcp_fs__ping");
         expect(connectOneServer).toHaveBeenCalledTimes(2); // retried after eviction
     });
-    it("self-heals: a tool hitting a connection error evicts the client so the next turn reconnects", async () => {
+    it("self-heals: a connection error reconnects ONCE in-turn; a permanently-dead server surfaces the error (no loop)", async () => {
         connectOneServer.mockImplementation(async (s) => ({
             tools: {
                 [`mcp_${s.id}__boom`]: {
@@ -55,9 +55,59 @@ describe("acquireMcpTools — cross-turn client pool", () => {
         }));
         const b1 = await acquireMcpTools([srv("fs")]);
         await expect(b1.tools["mcp_fs__boom"].execute({}, {})).rejects.toThrow(/transport closed/);
-        const b2 = await acquireMcpTools([srv("fs")]);
-        expect(b2).toBeDefined();
-        expect(connectOneServer).toHaveBeenCalledTimes(2); // reconnected after the connection error
+        // Initial connect + exactly ONE in-turn reconnect — the retry is not looped.
+        expect(connectOneServer).toHaveBeenCalledTimes(2);
+    });
+    it("in-turn reconnect: a mid-turn transport drop is reconnected and the call retried once — succeeds", async () => {
+        let gen = 0;
+        connectOneServer.mockImplementation(async (s) => {
+            gen += 1;
+            const dead = gen === 1; // first connect drops mid-call; the reconnect is healthy
+            return {
+                tools: {
+                    [`mcp_${s.id}__ping`]: {
+                        execute: async () => {
+                            if (dead)
+                                throw new Error("Attempted to send a request from a closed client");
+                            return "pong";
+                        },
+                    },
+                },
+                client: { close: async () => { } },
+            };
+        });
+        const b = await acquireMcpTools([srv("docs")]);
+        const result = await b.tools["mcp_docs__ping"].execute({}, {});
+        expect(result).toBe("pong"); // recovered within the SAME turn
+        expect(connectOneServer).toHaveBeenCalledTimes(2); // drop + one reconnect
+    });
+    it("a parallel burst on a dropped client shares ONE reconnect; every call retries and succeeds", async () => {
+        // Repro of session 41ccfeb2ceee: a 14-call burst at muonroi-docs dropped the
+        // HTTP socket after the first calls; previously the rest all threw
+        // "Attempted to send a request from a closed client". They must now share a
+        // single reconnect and all recover.
+        let gen = 0;
+        connectOneServer.mockImplementation(async (s) => {
+            gen += 1;
+            const dead = gen === 1;
+            return {
+                tools: {
+                    [`mcp_${s.id}__ping`]: {
+                        execute: async () => {
+                            if (dead)
+                                throw new Error("The socket connection was closed unexpectedly");
+                            return "pong";
+                        },
+                    },
+                },
+                client: { close: async () => { } },
+            };
+        });
+        const b = await acquireMcpTools([srv("docs")]);
+        const tool = b.tools["mcp_docs__ping"];
+        const results = await Promise.all(Array.from({ length: 14 }, () => tool.execute({}, {})));
+        expect(results.every((r) => r === "pong")).toBe(true);
+        expect(connectOneServer).toHaveBeenCalledTimes(2); // 14 failures → exactly ONE shared reconnect
     });
     it("keys by cwd/config — a different command reconnects rather than reusing", async () => {
         connectOneServer.mockImplementation(async (s) => connected(s.id));

package/dist/src/mcp/__tests__/forensics-tools.test.js

@@ -27,6 +27,7 @@ const fakeSummary = (id) => ({
     cacheHitRatio: 0,
     peakSingleCallInput: 100,
     events: [],
+    experience: null,
 });
 describe("forensics-tools", () => {
     it("usage_forensics returns the summary for a unique prefix", async () => {

package/dist/src/mcp/client-pool.d.ts

@@ -15,8 +15,15 @@
  *
  * Self-healing: a server that fails to connect is evicted (not cached as a
  * rejection), so a later turn retries. A live client whose child process dies
- * later is evicted when one of its tool calls hits a transport/connection error,
- * so the next turn reconnects fresh.
+ * later is evicted when one of its tool calls hits a transport/connection error.
+ *
+ * In-turn reconnect: a transport that drops MID-TURN (live: muonroi-docs HTTP
+ * socket closed after 2 of a 14-call parallel burst, session 41ccfeb2ceee —
+ * every remaining call then threw "Attempted to send a request from a closed
+ * client") is reconnected and the failing call is retried ONCE against the fresh
+ * client, instead of only reconnecting on the NEXT turn. Concurrent failures in
+ * the same burst share one reconnect (the pool dedupes by key); eviction is
+ * race-safe so a fresh reconnect is never torn down by a sibling's late failure.
  */
 import type { McpServerConfig } from "../utils/settings.js";
 import { type McpBuildOptions, type McpToolBundle } from "./runtime.js";

package/dist/src/mcp/client-pool.js

@@ -15,8 +15,15 @@
  *
  * Self-healing: a server that fails to connect is evicted (not cached as a
  * rejection), so a later turn retries. A live client whose child process dies
- * later is evicted when one of its tool calls hits a transport/connection error,
- * so the next turn reconnects fresh.
+ * later is evicted when one of its tool calls hits a transport/connection error.
+ *
+ * In-turn reconnect: a transport that drops MID-TURN (live: muonroi-docs HTTP
+ * socket closed after 2 of a 14-call parallel burst, session 41ccfeb2ceee —
+ * every remaining call then threw "Attempted to send a request from a closed
+ * client") is reconnected and the failing call is retried ONCE against the fresh
+ * client, instead of only reconnecting on the NEXT turn. Concurrent failures in
+ * the same burst share one reconnect (the pool dedupes by key); eviction is
+ * race-safe so a fresh reconnect is never torn down by a sibling's late failure.
  */
 import { connectOneServer, getMcpBuildDeadlineMs, } from "./runtime.js";
 import { validateMcpServerConfig } from "./validate.js";
@@ -38,16 +45,20 @@ function serverKey(s) {
         cwd: s.cwd ?? process.cwd(),
     });
 }
-/** Tear down one pooled entry (best-effort) and remove it. */
-function evict(key) {
+/**
+ * Tear down a pooled entry ONLY if it still holds `dead` (the specific server a
+ * failing tool call was bound to). Race-safe under a parallel burst: when 14
+ * sibling calls all fail on the same dropped client, the first evicts it and
+ * reconnects; the rest find `entry.connected !== dead` (a fresh client, or no
+ * entry) and leave the reconnect untouched. Best-effort cleanup of the dead one.
+ */
+function evictDeadServer(key, dead) {
     const entry = pool.get(key);
-    if (!entry)
+    if (!entry || entry.connected !== dead)
         return;
     pool.delete(key);
-    void entry.promise.then((cs) => {
-        cs.cleanup?.();
-        void cs.client.close().catch(() => { });
-    }, () => { });
+    dead.cleanup?.();
+    void dead.client.close().catch(() => { });
 }
 /** Heuristic: does this error mean the MCP transport/child is gone? */
 function isConnectionError(e) {
@@ -69,22 +80,35 @@ function getOrConnect(server, opts) {
     const promise = connectOneServer(server, opts);
     const entry = { key, promise };
     pool.set(key, entry);
+    promise.then(
+    // Record the resolved server so evictDeadServer can match by identity.
+    (cs) => {
+        entry.connected = cs;
+    }, 
     // Cache a rejection only transiently: evict so the next turn retries rather
     // than returning the same failed promise forever.
-    promise.catch(() => {
+    () => {
         if (pool.get(key) === entry)
             pool.delete(key);
     });
     return promise;
 }
 /**
- * Wrap each tool's execute so a transport/connection failure evicts the pooled
- * client (next turn reconnects). The MCP child may die after a successful
- * connect; without this the dead client would be reused on every later turn.
+ * Wrap each tool's execute so a transport/connection failure is recovered
+ * in-turn: evict the dead pooled client (race-safe), reconnect once, and retry
+ * the SAME call against the fresh client. Before this, a mid-turn drop only
+ * reconnected on the NEXT turn, so the rest of the current turn's batch all
+ * failed with "Attempted to send a request from a closed client". The MCP child
+ * may also die after a successful connect; the eviction keeps the pool clean for
+ * later turns either way.
+ *
+ * The retry is fired at most ONCE per call (no loop): if the fresh client also
+ * drops, or the reconnect itself fails, the original transport error propagates
+ * so the model sees a real failure rather than hanging.
  */
-function wrapForSelfHeal(tools, key) {
+function wrapForSelfHeal(cs, key, server, opts) {
     const out = {};
-    for (const [name, tool] of Object.entries(tools)) {
+    for (const [name, tool] of Object.entries(cs.tools)) {
         const base = tool.execute;
         if (typeof base !== "function") {
             out[name] = tool;
@@ -97,11 +121,25 @@ function wrapForSelfHeal(tools, key) {
                     return await base(args, options);
                 }
                 catch (e) {
-                    if (isConnectionError(e)) {
-                        console.error(`[mcp:pool] '${name}' hit a connection error — evicting cached client so the next turn reconnects`);
-                        evict(key);
+                    if (!isConnectionError(e))
+                        throw e;
+                    console.error(`[mcp:pool] '${name}' hit a connection error — reconnecting '${server.id}' in-turn and retrying once: ${e instanceof Error ? e.message : String(e)}`);
+                    // Evict THIS dead client (no-op if a sibling already reconnected), then
+                    // reconnect. getOrConnect dedupes by key, so a burst shares one reconnect.
+                    evictDeadServer(key, cs);
+                    let fresh;
+                    try {
+                        fresh = await getOrConnect(server, opts);
+                    }
+                    catch (reconnectErr) {
+                        console.error(`[mcp:pool] in-turn reconnect for '${server.id}' failed; surfacing original error: ${reconnectErr instanceof Error ? reconnectErr.message : String(reconnectErr)}`);
+                        throw e;
                     }
-                    throw e;
+                    const freshTools = fresh.tools;
+                    const freshExec = freshTools[name]?.execute;
+                    if (typeof freshExec !== "function")
+                        throw e;
+                    return await freshExec(args, options);
                 }
             },
         };
@@ -141,13 +179,14 @@ export async function acquireMcpTools(servers, opts) {
     await Promise.race([Promise.allSettled(attempts), deadline]);
     if (deadlineTimer)
         clearTimeout(deadlineTimer);
-    for (const slot of slots) {
+    for (let i = 0; i < slots.length; i++) {
+        const slot = slots[i];
         if (slot.done) {
             if (slot.error) {
                 errors.push(`${slot.label}: ${slot.error}`);
             }
             else if (slot.result) {
-                Object.assign(tools, wrapForSelfHeal(slot.result.tools, slot.key));
+                Object.assign(tools, wrapForSelfHeal(slot.result, slot.key, enabled[i], opts));
             }
         }
         else {

package/dist/src/orchestrator/compaction.d.ts

@@ -23,6 +23,8 @@ export declare const DEFAULT_RESERVE_TOKENS = 16384;
 export declare const DEFAULT_KEEP_RECENT_TOKENS = 20000;
 export declare const POST_TURN_MIN_TOKENS = 2000;
 export declare const COMPACTION_MAX_OUTPUT_TOKENS = 4096;
+export declare const COMPACTION_META_MAX_OUTPUT_TOKENS = 1536;
+export declare function metaCompactionMaxTokens(): number;
 export declare const TOOL_RESULT_MAX_CHARS_CONFIGURABLE = 8000;
 export declare const COMPACTION_SUMMARY_HEADER = "[Context checkpoint summary]";
 export declare function extractUserContent(content: unknown): string;

package/dist/src/orchestrator/compaction.js

@@ -10,6 +10,19 @@ export const DEFAULT_RESERVE_TOKENS = 16_384;
 export const DEFAULT_KEEP_RECENT_TOKENS = 20_000;
 export const POST_TURN_MIN_TOKENS = 2_000;
 export const COMPACTION_MAX_OUTPUT_TOKENS = 4_096;
+// Meta-analysis (agent/PIL self-eval) summaries are capped tighter than normal
+// to prevent runaway summaries (session df2dbb878984: 73k input → 14k-char
+// summary). Default 1536 (was a hard 1024) — modestly more fidelity now that
+// anti-mù recovery (layer3 surfacing + the in-process/disk artifact cache)
+// backstops detail loss, still ~2.3x below the 14k-char problem. Tune per machine
+// with MUONROI_META_COMPACT_MAX_TOKENS (clamped 512..COMPACTION_MAX_OUTPUT_TOKENS).
+export const COMPACTION_META_MAX_OUTPUT_TOKENS = 1_536;
+export function metaCompactionMaxTokens() {
+    const raw = Number(process.env.MUONROI_META_COMPACT_MAX_TOKENS);
+    if (Number.isFinite(raw) && raw >= 512 && raw <= COMPACTION_MAX_OUTPUT_TOKENS)
+        return Math.floor(raw);
+    return COMPACTION_META_MAX_OUTPUT_TOKENS;
+}
 export const TOOL_RESULT_MAX_CHARS_CONFIGURABLE = 8000;
 export const COMPACTION_SUMMARY_HEADER = "[Context checkpoint summary]";
 const SUMMARIZATION_SYSTEM_PROMPT = `You are a context summarization assistant.
@@ -450,7 +463,7 @@ async function summarizeConversation(provider, modelId, messages, reserveTokens,
     const userText = messages.map((m) => extractUserContent(m.content)).join("\n");
     const isMeta = isMetaAnalysisPrompt(userText);
     const effectiveMax = isMeta
-        ? Math.min(1024, Math.max(512, Math.floor(reserveTokens * 0.5)))
+        ? Math.min(metaCompactionMaxTokens(), Math.max(512, Math.floor(reserveTokens * 0.5)))
         : Math.min(COMPACTION_MAX_OUTPUT_TOKENS, Math.max(512, Math.floor(reserveTokens * 0.8)));
     if (previousSummary) {
         promptParts.push(`Existing summary:\n${previousSummary}`);

package/dist/src/orchestrator/compaction.test.js

@@ -1,6 +1,6 @@
 import { afterAll, beforeAll, describe, expect, it } from "vitest";
 import { buildEffectiveTranscript } from "../storage/transcript-view.js";
-import { COMPACTION_SUMMARY_HEADER, createCompactionSummaryMessage, findCutPoint, prepareCompaction, serializeConversation, shouldCompactContext, } from "./compaction.js";
+import { COMPACTION_META_MAX_OUTPUT_TOKENS, COMPACTION_SUMMARY_HEADER, createCompactionSummaryMessage, findCutPoint, metaCompactionMaxTokens, prepareCompaction, serializeConversation, shouldCompactContext, } from "./compaction.js";
 import { buildCheckpointReminder } from "./scope-reminder.js";
 import { __forceFallbackForTests } from "./token-counter.js";
 // Pin token counts to the chars/4 fallback so cut-point assertions remain stable.
@@ -160,4 +160,28 @@ describe("compaction helpers", () => {
         expect(r).toContain("tool-artifact");
     });
 });
+describe("metaCompactionMaxTokens — meta summary cap (tunable, session 2b7a10219499)", () => {
+    it("defaults to 1536 — looser than the old hard 1024, still well below the 14k-char problem", () => {
+        delete process.env.MUONROI_META_COMPACT_MAX_TOKENS;
+        expect(metaCompactionMaxTokens()).toBe(COMPACTION_META_MAX_OUTPUT_TOKENS);
+        expect(COMPACTION_META_MAX_OUTPUT_TOKENS).toBe(1536);
+        expect(COMPACTION_META_MAX_OUTPUT_TOKENS).toBeGreaterThan(1024);
+    });
+    it("honors a valid MUONROI_META_COMPACT_MAX_TOKENS override", () => {
+        process.env.MUONROI_META_COMPACT_MAX_TOKENS = "2048";
+        try {
+            expect(metaCompactionMaxTokens()).toBe(2048);
+        }
+        finally {
+            delete process.env.MUONROI_META_COMPACT_MAX_TOKENS;
+        }
+    });
+    it("clamps out-of-range / garbage overrides to the default", () => {
+        for (const bad of ["999999", "100", "-5", "abc", ""]) {
+            process.env.MUONROI_META_COMPACT_MAX_TOKENS = bad;
+            expect(metaCompactionMaxTokens(), bad).toBe(COMPACTION_META_MAX_OUTPUT_TOKENS);
+        }
+        delete process.env.MUONROI_META_COMPACT_MAX_TOKENS;
+    });
+});
 //# sourceMappingURL=compaction.test.js.map

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

@@ -50,6 +50,7 @@
 //   - O1 (providerOptions shape forensics)  — extractProviderOptionsShape
 //   - siliconflow reasoning-strip           — turnCaps.sanitizeHistory
 import { stepCountIs, streamText } from "ai";
+import { recordArtifact } from "../ee/artifact-cache.js";
 import { getCachedAuthToken, getCachedServerBaseUrl } from "../ee/auth.js";
 import { routeFeedback, routeModel } from "../ee/bridge.js";
 import { getDefaultEEClient } from "../ee/intercept.js";
@@ -65,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";
@@ -77,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";
@@ -101,11 +104,12 @@ import { repairToolCallHook } from "./repair-tool-call.js";
 import { buildRepetitionReminder, recordAssistantBurst, shouldInjectRepetitionReminder, } from "./repetition-detector.js";
 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, } from "./scope-reminder.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";
-import { compactSubAgentMessages } from "./subagent-compactor.js";
+import { compactSubAgentMessages, cumulativeMessageChars } from "./subagent-compactor.js";
 import { detectTextEmittedToolCall, parseDsmlToolCalls } from "./text-tool-call-detector.js";
 import { createToolLoopCapPredicate } from "./tool-loop-cap.js";
 import { buildToolRepetitionAbortMessage, recordToolError as recordToolRepetitionError, recordToolSuccess as recordToolRepetitionSuccess, } from "./tool-repetition-detector.js";
@@ -1500,6 +1504,14 @@ export class MessageProcessor {
                             const _cwd = process.cwd();
                             const _sess = undefined; // best-effort; EE artifact still indexable by content + meta.toolCallId
                             const persistArtifact = (toolCallId, toolName, fullContent, reason) => {
+                                // Local-first: record the FULL output in-process so ee_query can
+                                // 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({
@@ -1522,19 +1534,31 @@ 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
-                            // summarize, finish, or request preservation.
-                            const _preCompactWarnAt = Math.floor(topLevelCompactThreshold * 0.78);
-                            if (stripped.length > _preCompactWarnAt && compacted === stripped) {
+                            // summarize, finish, or request preservation. Fires when we did
+                            // NOT compact this step (compacted === stripped, restored by the
+                            // compactSubAgentMessages no-op ref contract) AND the prompt is
+                            // approaching the threshold. Must compare CHARS (messages +
+                            // envelope), not stripped.length (a message count that never
+                            // exceeds a char-scaled threshold) — session 2b7a10219499.
+                            const _preWarnChars = cumulativeMessageChars(stripped) + envelopeChars;
+                            if (compacted === stripped && shouldPreWarnCompaction(_preWarnChars, topLevelCompactThreshold)) {
                                 const _cp = buildCheckpointReminder(sn, true);
                                 const _pre = `[pre-compaction warning at step ${sn} — next step(s) will likely rewrite older tool results to stubs (threshold ${topLevelCompactThreshold}, keepLast=${topLevelCompactKeepLast}). ${_cp} Summarize or finish if possible.]`;
                                 return { messages: attachReminderToMessages(stripped, _pre) };
@@ -1609,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) };
@@ -1670,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/scope-reminder.d.ts

@@ -100,3 +100,15 @@ export declare function attachReminderToMessages<T>(messages: ReadonlyArray<T>,
  * Used by prepareStep / sub-agent paths after compaction.
  */
 export declare function buildCheckpointReminder(iteration: number, hasEECheckpoint: boolean): string;
+/**
+ * Pre-compaction "advance warning" gate. Fires when the prompt is approaching
+ * (default ≥78% of) the compaction threshold but compaction has NOT yet run this
+ * step — giving the agent one step to PRESERVE / finish before B3/B4 rewrites
+ * older tool results into stubs.
+ *
+ * `promptChars` MUST be the same quantity the compactor thresholds on (cumulative
+ * message chars + envelope chars), NOT the message COUNT. The original B4 wiring
+ * compared `stripped.length` (a message count, ~tens) against a char-scaled
+ * threshold (~156000), so the warning could never fire — session 2b7a10219499.
+ */
+export declare function shouldPreWarnCompaction(promptChars: number, thresholdChars: number, ratio?: number): boolean;

package/dist/src/orchestrator/scope-reminder.js

@@ -218,4 +218,20 @@ export function buildCheckpointReminder(iteration, hasEECheckpoint) {
         return base;
     return base.slice(0, 220);
 }
+/**
+ * Pre-compaction "advance warning" gate. Fires when the prompt is approaching
+ * (default ≥78% of) the compaction threshold but compaction has NOT yet run this
+ * step — giving the agent one step to PRESERVE / finish before B3/B4 rewrites
+ * older tool results into stubs.
+ *
+ * `promptChars` MUST be the same quantity the compactor thresholds on (cumulative
+ * message chars + envelope chars), NOT the message COUNT. The original B4 wiring
+ * compared `stripped.length` (a message count, ~tens) against a char-scaled
+ * threshold (~156000), so the warning could never fire — session 2b7a10219499.
+ */
+export function shouldPreWarnCompaction(promptChars, thresholdChars, ratio = 0.78) {
+    if (thresholdChars <= 0 || promptChars <= 0)
+        return false;
+    return promptChars >= Math.floor(thresholdChars * ratio);
+}
 //# sourceMappingURL=scope-reminder.js.map

package/dist/src/orchestrator/scope-reminder.test.js

@@ -13,7 +13,7 @@
  *   - Reminder lives in tool_result/system message — never in system prompt
  */
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { attachReminderToMessages, buildScopeReminder, cadenceForSize, shouldInjectCeilingCrossing, shouldInjectReminder, shouldInjectSoftWarn, } from "./scope-reminder.js";
+import { attachReminderToMessages, buildScopeReminder, cadenceForSize, shouldInjectCeilingCrossing, shouldInjectReminder, shouldInjectSoftWarn, shouldPreWarnCompaction, } from "./scope-reminder.js";
 describe("cadenceForSize", () => {
     it("locks 3/5/8 for small/medium/large with hard floor >= 3", () => {
         expect(cadenceForSize("small")).toBe(3);
@@ -201,4 +201,25 @@ describe("attachReminderToMessages", () => {
         expect(out).toEqual(messages);
     });
 });
+describe("shouldPreWarnCompaction (regression: session 2b7a10219499 dead pre-warning)", () => {
+    const THRESHOLD = 200_000; // MUONROI_TOP_LEVEL_COMPACT_THRESHOLD_CHARS default
+    it("fires when prompt chars reach >=78% of the threshold (approaching compaction)", () => {
+        expect(shouldPreWarnCompaction(Math.floor(THRESHOLD * 0.78), THRESHOLD)).toBe(true);
+        expect(shouldPreWarnCompaction(190_000, THRESHOLD)).toBe(true);
+    });
+    it("does NOT fire while comfortably below the threshold", () => {
+        expect(shouldPreWarnCompaction(100_000, THRESHOLD)).toBe(false);
+        expect(shouldPreWarnCompaction(0, THRESHOLD)).toBe(false);
+    });
+    it("guards against the original bug: a message COUNT can never trip a char threshold", () => {
+        // The dead wiring compared stripped.length (a message count, ~tens) to the
+        // char-scaled threshold. With chars it crosses; with a count it never does.
+        const messageCount = 60; // plausible long-session message count
+        expect(shouldPreWarnCompaction(messageCount, THRESHOLD)).toBe(false);
+        expect(shouldPreWarnCompaction(170_000, THRESHOLD)).toBe(true);
+    });
+    it("is inert for a zero/negative threshold (no compaction configured)", () => {
+        expect(shouldPreWarnCompaction(999_999, 0)).toBe(false);
+    });
+});
 //# sourceMappingURL=scope-reminder.test.js.map