muonroi-cli 1.6.0 → 1.6.2

package/dist/src/cli/cost-forensics.d.ts

@@ -8,6 +8,7 @@
  * confirm that sub-agent context no longer balloons past 80k input
  * after the cumulative cap kicks in.
  */
+import type { SessionExperienceCounts } from "../orchestrator/session-experience.js";
 export interface CostForensicsRow {
     id: number;
     source: string;
@@ -35,6 +36,8 @@ export interface CostForensicsSummary {
     cacheHitRatio: number;
     peakSingleCallInput: number;
     events: CostForensicsRow[];
+    /** Anti-mù counters for this session (null when none recorded). */
+    experience: SessionExperienceCounts | null;
 }
 /**
  * Return ALL session ids matching a prefix (newest first, capped at 5).

package/dist/src/cli/cost-forensics.js

@@ -11,6 +11,7 @@
 import { getProviderCapabilities } from "../providers/capabilities.js";
 import { detectProviderForModel } from "../providers/runtime.js";
 import { getDatabase } from "../storage/db.js";
+import { selectSessionExperience } from "../storage/session-experience-store.js";
 function resolveSessionId(prefix) {
     const rows = getDatabase()
         .prepare(`SELECT id FROM sessions WHERE id LIKE ? ORDER BY created_at DESC LIMIT 5`)
@@ -103,6 +104,7 @@ export function collectCostForensics(sessionId) {
         cacheHitRatio,
         peakSingleCallInput,
         events,
+        experience: selectSessionExperience(sessionId),
     };
 }
 export function computeCacheCadence(events) {
@@ -164,6 +166,15 @@ export function printCostForensics(summary, opts = {}) {
             `(~${formatNum(cadence.estReBilledTokens)} tok re-billed). ` +
             `Likely fast tool-loop latency — fewer/batched tool rounds recover this.`);
     }
+    // Anti-mù counters for this session (rec #1 persisted forensics).
+    if (summary.experience) {
+        const x = summary.experience;
+        const rehydrated = x.rehydratedCache + x.rehydratedDisk + x.rehydratedEe;
+        w(`Anti-mù:             ${x.compactions} compaction(s), ${x.elided} tool output(s) elided` +
+            `${x.elided > 0 ? ` (${formatNum(x.totalElidedChars)} chars)` : ""}, ` +
+            `${rehydrated} rehydrated (cache=${x.rehydratedCache} disk=${x.rehydratedDisk} ee=${x.rehydratedEe}), ` +
+            `${x.unavailable} needed-but-unavailable.`);
+    }
     w(``);
     w(`Per-event breakdown:`);
     w(`${"seq".padEnd(5)}${"src".padEnd(10)}${"input".padStart(9)}${"out".padStart(7)}${"cacheR".padStart(9)}${"cacheC".padStart(8)}  ts`);

package/dist/src/cli/cost-forensics.test.js

@@ -62,6 +62,7 @@ function summary(events) {
         cacheHitRatio: totalInput > 0 ? totalCacheRead / totalInput : 0,
         peakSingleCallInput: Math.max(0, ...events.map((e) => e.inputTokens)),
         events,
+        experience: null,
     };
 }
 function captureStdout(fn) {

package/dist/src/cli/experience-report.d.ts

@@ -0,0 +1,20 @@
+/**
+ * src/cli/experience-report.ts
+ *
+ * `muonroi-cli usage experience` — cross-session anti-mù telemetry. Aggregates
+ * the per-session session_experience snapshots to answer the measure-before-
+ * re-architecting question: how often does compaction actually elide a tool
+ * output, and when the agent goes back for one, can it recover it?
+ *
+ * This is the data gate for the deferred anti-mù re-architecture (auto-protect /
+ * auto-rehydrate). Low elision rate or high recovery rate ⇒ the friction is rare
+ * or cognitive, not data-loss ⇒ defer. High unavailable / low recovery ⇒ real
+ * loss ⇒ justified.
+ */
+import { type ExperienceAggregate } from "../storage/session-experience-store.js";
+/** Pure renderer — returns the report lines so it is unit-testable without a DB. */
+export declare function renderExperienceAggregate(agg: ExperienceAggregate, limit: number): string[];
+export declare function runExperienceReport(opts?: {
+    limit?: number;
+    json?: boolean;
+}): Promise<void>;

package/dist/src/cli/experience-report.js

@@ -0,0 +1,76 @@
+/**
+ * src/cli/experience-report.ts
+ *
+ * `muonroi-cli usage experience` — cross-session anti-mù telemetry. Aggregates
+ * the per-session session_experience snapshots to answer the measure-before-
+ * re-architecting question: how often does compaction actually elide a tool
+ * output, and when the agent goes back for one, can it recover it?
+ *
+ * This is the data gate for the deferred anti-mù re-architecture (auto-protect /
+ * auto-rehydrate). Low elision rate or high recovery rate ⇒ the friction is rare
+ * or cognitive, not data-loss ⇒ defer. High unavailable / low recovery ⇒ real
+ * loss ⇒ justified.
+ */
+import { aggregateSessionExperience } from "../storage/session-experience-store.js";
+function pct(n, d) {
+    return d > 0 ? `${((n / d) * 100).toFixed(0)}%` : "—";
+}
+function num(n) {
+    return n.toLocaleString("en-US");
+}
+/** Pure renderer — returns the report lines so it is unit-testable without a DB. */
+export function renderExperienceAggregate(agg, limit) {
+    const t = agg.totals;
+    const rehydrated = t.rehydratedCache + t.rehydratedDisk + t.rehydratedEe;
+    const out = [];
+    out.push("");
+    out.push(`Session-experience aggregate — latest ${agg.sessionCount} session(s) with a snapshot (cap ${limit})`);
+    out.push("─".repeat(72));
+    if (agg.sessionCount === 0) {
+        out.push("No session_experience snapshots recorded yet.");
+        out.push("Run some real (non-meta) sessions, then re-check — compaction only");
+        out.push("persists a snapshot once it actually elides / rehydrates something.");
+        return out;
+    }
+    out.push(`Sessions with compaction elision:   ${agg.sessionsWithElision} (${pct(agg.sessionsWithElision, agg.sessionCount)})`);
+    out.push(`Sessions hitting needed-but-unavail: ${agg.sessionsWithUnavailable} (${pct(agg.sessionsWithUnavailable, agg.sessionCount)})`);
+    out.push("");
+    out.push("Totals across those sessions:");
+    out.push(`  Compactions fired:       ${num(t.compactions)}`);
+    out.push(`  Tool outputs elided:     ${num(t.elided)} (${num(t.totalElidedChars)} chars)`);
+    out.push(`  Rehydrated via ee_query: ${num(rehydrated)} (cache=${t.rehydratedCache} disk=${t.rehydratedDisk} ee=${t.rehydratedEe})`);
+    out.push(`  Needed-but-unavailable:  ${num(t.unavailable)}`);
+    out.push(`  EE timeouts / errors:    ${num(t.eeTimeouts)} / ${num(t.eeErrors)}`);
+    out.push("");
+    out.push(`Rehydrate recovery rate: ${(agg.rehydrateRecoveryRate * 100).toFixed(0)}%  (rehydrated / (rehydrated + unavailable))`);
+    out.push("");
+    // Decision signal for the deferred re-architecture.
+    out.push("Re-architecture decision signal:");
+    if (t.elided === 0) {
+        out.push("  • Compaction has not elided anything — friction is not occurring. DEFER.");
+    }
+    else {
+        const elisionRate = agg.sessionsWithElision / agg.sessionCount;
+        if (elisionRate < 0.2) {
+            out.push(`  • Elision bites in only ${pct(agg.sessionsWithElision, agg.sessionCount)} of sessions — rare. Likely DEFER.`);
+        }
+        if (agg.rehydrateRecoveryRate >= 0.9 || t.unavailable === 0) {
+            out.push("  • Recovery rate high / no unavailable — manual rehydrate works; friction is cognitive, not data-loss. Manifest+keepLast likely enough.");
+        }
+        else {
+            out.push(`  • Recovery rate ${(agg.rehydrateRecoveryRate * 100).toFixed(0)}% with ${num(t.unavailable)} unrecoverable — real data loss. Auto-protect/auto-rehydrate JUSTIFIED.`);
+        }
+    }
+    return out;
+}
+export async function runExperienceReport(opts = {}) {
+    const limit = opts.limit && opts.limit > 0 ? opts.limit : 100;
+    const agg = aggregateSessionExperience(limit);
+    if (opts.json) {
+        process.stdout.write(`${JSON.stringify(agg, null, 2)}\n`);
+        return;
+    }
+    for (const line of renderExperienceAggregate(agg, limit))
+        process.stdout.write(`${line}\n`);
+}
+//# sourceMappingURL=experience-report.js.map

package/dist/src/cli/experience-report.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * experience-report renderer — the cross-session decision signal that gates the
+ * deferred anti-mù auto-protect/auto-rehydrate re-architecture.
+ */
+export {};

package/dist/src/cli/experience-report.test.js

@@ -0,0 +1,63 @@
+/**
+ * experience-report renderer — the cross-session decision signal that gates the
+ * deferred anti-mù auto-protect/auto-rehydrate re-architecture.
+ */
+import { describe, expect, it } from "vitest";
+import { renderExperienceAggregate } from "./experience-report.js";
+function counts(p = {}) {
+    return {
+        compactions: 0,
+        elided: 0,
+        totalElidedChars: 0,
+        rehydratedCache: 0,
+        rehydratedDisk: 0,
+        rehydratedEe: 0,
+        unavailable: 0,
+        eeTimeouts: 0,
+        eeErrors: 0,
+        ...p,
+    };
+}
+function agg(p = {}) {
+    return {
+        sessionCount: p.sessionCount ?? 1,
+        sessionsWithElision: p.sessionsWithElision ?? 0,
+        sessionsWithUnavailable: p.sessionsWithUnavailable ?? 0,
+        totals: counts(p.totals),
+        rehydrateRecoveryRate: p.rehydrateRecoveryRate ?? 1,
+        perSession: p.perSession ?? [],
+    };
+}
+describe("renderExperienceAggregate", () => {
+    it("reports the no-data case clearly", () => {
+        const text = renderExperienceAggregate(agg({ sessionCount: 0 }), 100).join("\n");
+        expect(text).toContain("No session_experience snapshots recorded yet");
+    });
+    it("signals DEFER when nothing was ever elided", () => {
+        const text = renderExperienceAggregate(agg({ sessionCount: 5, totals: { compactions: 3 } }), 100).join("\n");
+        expect(text).toContain("has not elided anything");
+        expect(text).toContain("DEFER");
+    });
+    it("signals cognitive-not-data-loss when recovery is high / no unavailable", () => {
+        const text = renderExperienceAggregate(agg({
+            sessionCount: 4,
+            sessionsWithElision: 3,
+            rehydrateRecoveryRate: 1,
+            totals: { compactions: 5, elided: 20, rehydratedCache: 8 },
+        }), 100).join("\n");
+        expect(text).toMatch(/cognitive, not data-loss/);
+        expect(text).not.toMatch(/JUSTIFIED/);
+    });
+    it("signals re-architecture JUSTIFIED when recovery is low with unrecoverable artifacts", () => {
+        const text = renderExperienceAggregate(agg({
+            sessionCount: 6,
+            sessionsWithElision: 5,
+            sessionsWithUnavailable: 4,
+            rehydrateRecoveryRate: 0.3,
+            totals: { compactions: 10, elided: 40, rehydratedEe: 3, unavailable: 7 },
+        }), 100).join("\n");
+        expect(text).toContain("real data loss");
+        expect(text).toContain("JUSTIFIED");
+    });
+});
+//# sourceMappingURL=experience-report.test.js.map

package/dist/src/generated/version.d.ts

@@ -1,2 +1,2 @@
-export declare const PACKAGE_VERSION = "1.6.0";
+export declare const PACKAGE_VERSION = "1.6.2";
 export declare const PACKAGE_DESCRIPTION = "BYOK AI coding agent with multi-model council debate, role-based routing, and auto-compact.";

package/dist/src/generated/version.js

@@ -1,5 +1,5 @@
 // AUTO-GENERATED by scripts/sync-version.cjs. DO NOT EDIT BY HAND.
 // Sourced from package.json at build time so it survives bun --compile bundling.
-export const PACKAGE_VERSION = "1.6.0";
+export const PACKAGE_VERSION = "1.6.2";
 export const PACKAGE_DESCRIPTION = "BYOK AI coding agent with multi-model council debate, role-based routing, and auto-compact.";
 //# sourceMappingURL=version.js.map

package/dist/src/gsd/__tests__/directives.test.js

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
 import { scoreComplexity } from "../complexity.js";
-import { buildDirective } from "../directives.js";
+import { buildDirective, mentionsEcosystemScope } from "../directives.js";
 import { detectGrayAreas } from "../gray-areas.js";
 describe("buildDirective", () => {
     it("emits a blocking heavy directive with mandatory steps", () => {
@@ -66,6 +66,29 @@ describe("buildDirective", () => {
         expect(out.blocking).toBe(false);
         expect(out.text.length).toBeLessThan(300);
     });
+    it("appends the muonroi-docs nudge for an ecosystem question (session 41ccfeb2ceee turn 1)", () => {
+        const complexity = scoreComplexity("bạn hiểu thế nào về ecosystem muonroi nói chung");
+        const out = buildDirective({ complexity, phase: null, grayAreas: [], informational: true, ecosystem: true });
+        expect(out.text).toMatch(/QUESTION \/ explanatory/); // still the human-facing question directive
+        expect(out.text).toMatch(/ECOSYSTEM SCOPE/);
+        expect(out.text).toMatch(/muonroi-docs MCP is the AUTHORITATIVE source|AUTHORITATIVE source/);
+        expect(out.text).toMatch(/call it FIRST/i);
+    });
+    it("does NOT append the ecosystem nudge for a plain question", () => {
+        const complexity = scoreComplexity("how does this CLI affect you?");
+        const out = buildDirective({ complexity, phase: null, grayAreas: [], informational: true });
+        expect(out.text).not.toMatch(/ECOSYSTEM SCOPE/);
+    });
+    it("mentionsEcosystemScope is tight: ecosystem/BB wording yes, bare CLI-internals no", () => {
+        // Fires on genuine ecosystem scope (the case muonroi-docs exists to serve)…
+        expect(mentionsEcosystemScope("ecosystem muonroi nói chung và muonroi-cli nói riêng")).toBe(true);
+        expect(mentionsEcosystemScope("hệ sinh thái muonroi gồm những gì")).toBe(true);
+        expect(mentionsEcosystemScope("how does the building-block rule engine work")).toBe(true);
+        // …but NOT on a muonroi-cli internals question that merely names the product,
+        // which would wrongly steer toward .NET package docs.
+        expect(mentionsEcosystemScope("how does muonroi-cli compaction work")).toBe(false);
+        expect(mentionsEcosystemScope("fix the off-by-one in the router")).toBe(false);
+    });
     it("renders the recommended option first in gray-area block", () => {
         const prompt = "redo everything from scratch";
         const complexity = scoreComplexity(prompt);

package/dist/src/gsd/directives.d.ts

@@ -31,6 +31,21 @@ export interface DirectiveInput {
      * buildDirective emits a human-facing question directive instead.
      */
     informational?: boolean;
+    /**
+     * True when the turn is about the Muonroi ECOSYSTEM (the whole platform, BB/
+     * .NET packages, building-block, open-core boundary, setup/install) rather than
+     * muonroi-cli's own TS internals. When set, buildDirective appends a nudge to
+     * consult the authoritative muonroi-docs MCP first. Computed by the caller via
+     * mentionsEcosystemScope so a CLI-internals question (which merely contains the
+     * word "muonroi") does NOT misfire toward .NET docs.
+     *
+     * Live miss (session 41ccfeb2ceee turn 1): "bạn hiểu thế nào về ecosystem
+     * muonroi…" — muonroi-docs WAS in the toolset (smart-filter kept it) but the
+     * question directive steered the agent to read/grep local files, so it answered
+     * "no comprehensive ecosystem description in the files read" instead of querying
+     * the shipped authoritative source.
+     */
+    ecosystem?: boolean;
 }
 export interface DirectiveOutput {
     text: string;
@@ -38,4 +53,11 @@ export interface DirectiveOutput {
     /** True when the directive forbids the agent from acting before clarifying. */
     blocking: boolean;
 }
+export declare function mentionsEcosystemScope(message: string): boolean;
+/**
+ * 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 declare const ECOSYSTEM_DOCS_NUDGE: string;
 export declare function buildDirective(input: DirectiveInput): DirectiveOutput;

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 {