muonroi-cli 1.6.1 → 1.6.2

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

@@ -1,2 +1,2 @@
-export declare const PACKAGE_VERSION = "1.6.1";
+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.1";
+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/orchestrator/subagent-compactor.d.ts

@@ -111,6 +111,16 @@ export declare const SUBAGENT_COMPACT_DEFAULT_KEEP_LAST = 3;
  * the native contract + native-capabilities tell the agent to rely on for "task finished?" and
  * rehydrate during long meta conversations about CLI/PIL/compaction/EE. */
 export declare const IMPORTANT_TOOL_NAMES: readonly ["read_file", "grep", "lsp", "bash", "ee_query", "usage_forensics", "selfverify_start", "selfverify_result", "selfverify_status"];
+/**
+ * MCP tool prefixes whose results are an AUTHORITATIVE source the agent is
+ * explicitly steered to fetch FIRST and ground on (the ECOSYSTEM_DOCS_NUDGE in
+ * src/gsd/directives.ts). Eliding them defeats the nudge — the agent calls the
+ * ecosystem docs, then compaction discards them and it goes blind on the very
+ * source it was told to trust (session 584ba476c07a: mcp_muonroi-docs__setup_guide
+ * + bb_recipe_list elided, ee_unavailable, 0 rehydrated → "partially blind").
+ * Keep their results verbatim so the agent stays grounded across the session.
+ */
+export declare const HIGH_VALUE_MCP_PREFIXES: readonly ["mcp_muonroi-docs__"];
 /**
  * Heuristic: keep full (no stub) for high-signal tool results.
  * Signals: allowlist tool + (error/todo/plan/keyfile/large output or explicit keep list).

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

@@ -73,6 +73,16 @@ export const IMPORTANT_TOOL_NAMES = [
     "selfverify_result",
     "selfverify_status",
 ];
+/**
+ * MCP tool prefixes whose results are an AUTHORITATIVE source the agent is
+ * explicitly steered to fetch FIRST and ground on (the ECOSYSTEM_DOCS_NUDGE in
+ * src/gsd/directives.ts). Eliding them defeats the nudge — the agent calls the
+ * ecosystem docs, then compaction discards them and it goes blind on the very
+ * source it was told to trust (session 584ba476c07a: mcp_muonroi-docs__setup_guide
+ * + bb_recipe_list elided, ee_unavailable, 0 rehydrated → "partially blind").
+ * Keep their results verbatim so the agent stays grounded across the session.
+ */
+export const HIGH_VALUE_MCP_PREFIXES = ["mcp_muonroi-docs__"];
 /**
  * Heuristic: keep full (no stub) for high-signal tool results.
  * Signals: allowlist tool + (error/todo/plan/keyfile/large output or explicit keep list).
@@ -86,6 +96,10 @@ export function isHighValueToolResult(toolName, preview, explicitKeepIds, toolCa
     // work/findings. Truncating it causes the agent to think it lost its answer.
     if (name.startsWith("respond_"))
         return true;
+    // Authoritative ecosystem-docs MCP results: the agent is nudged to fetch these
+    // FIRST, so eliding them strands it (session 584ba476c07a). Keep verbatim.
+    if (HIGH_VALUE_MCP_PREFIXES.some((p) => name.startsWith(p)))
+        return true;
     if (IMPORTANT_TOOL_NAMES.includes(name)) {
         const p = preview.toLowerCase();
         if (/error|fail|todo|plan|done|✔|blocked|critical/.test(p))

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

@@ -110,6 +110,60 @@ describe("subagent-compactor: compactSubAgentMessages", () => {
             expect(out[out.length - i]).toBe(msgs[msgs.length - i]);
         }
     });
+    it("keeps an OLDER authoritative muonroi-docs MCP result verbatim while eliding low-value peers (session 584ba476c07a)", () => {
+        // History: an early muonroi-docs setup_guide (older than keepLast=3) + many
+        // low-value tool turns. The ecosystem doc must survive compaction so the
+        // agent stays grounded on the source it was nudged to fetch first.
+        const docsValue = bigText("ECOSYSTEM_DOCS", 6); // ~6kb authoritative payload
+        const msgs = [
+            { role: "system", content: "You are the agent." },
+            { role: "user", content: "ecosystem question" },
+            {
+                role: "assistant",
+                content: [
+                    {
+                        type: "tool-call",
+                        toolCallId: "call_docs",
+                        toolName: "mcp_muonroi-docs__setup_guide",
+                        input: JSON.stringify({ component: "ecosystem" }),
+                    },
+                ],
+            },
+            {
+                role: "tool",
+                content: [
+                    {
+                        type: "tool-result",
+                        toolCallId: "call_docs",
+                        toolName: "mcp_muonroi-docs__setup_guide",
+                        output: { type: "text", value: docsValue },
+                    },
+                ],
+            },
+        ];
+        // Pile on low-value turns to push well past threshold and make the docs turn "old".
+        for (let i = 1; i <= 10; i++) {
+            const t = toolTurn(i, 10);
+            t[1].content[0].toolName = "mcp_filesystem__list_directory"; // low-value MCP
+            t[0].content[0].toolName = "mcp_filesystem__list_directory";
+            msgs.push(...t);
+        }
+        const out = compactSubAgentMessages(msgs);
+        expect(out).not.toBe(msgs); // compaction fired
+        // The muonroi-docs result is kept verbatim (full payload, no stub).
+        const docsMsg = out.find((m) => m.role === "tool" &&
+            Array.isArray(m.content) &&
+            m.content[0]?.toolName === "mcp_muonroi-docs__setup_guide");
+        const docsOut = (docsMsg?.content)[0].output.value;
+        expect(docsOut).toBe(docsValue);
+        expect(docsOut).not.toMatch(/elided by/);
+        // A low-value filesystem MCP peer from an OLD turn IS stubbed.
+        const stubbed = out.some((m) => m.role === "tool" &&
+            Array.isArray(m.content) &&
+            typeof m.content[0]?.output?.value === "string" &&
+            m.content[0].output.value.includes("elided by"));
+        expect(stubbed).toBe(true);
+    });
     it("rewrites older tool-result parts with elision stub", () => {
         const msgs = buildHistory(10, 10);
         // Neutralize tool so the basic elision test is not affected by high-value auto-keep (idea 1).

package/dist/src/storage/tool-results.js

@@ -31,6 +31,29 @@ export function extractToolResultFromOutput(output) {
             output: String(output.value),
         };
     }
+    // MCP tool results: `{ type: "content", value: [{ type: "text", text }, ...] }`
+    // (see cap-tool-result.ts). Before this branch, extraction returned null, so
+    // persisted output_json was the raw envelope with NO `success` field — on
+    // reload the renderer read `toolResult.success` as undefined and displayed
+    // "Error" for a SUCCESSFUL call (session 63f2d542b772: 50 muonroi-docs calls,
+    // 0 DB failures, all shown as "Error"). Flatten the text parts so it round-
+    // trips as a real ToolResult. A genuinely failed MCP call throws → the SDK
+    // records an `error-text` part, handled above, so content == success here.
+    if ("type" in output && output.type === "content" && "value" in output && Array.isArray(output.value)) {
+        const parts = output.value;
+        const text = parts
+            .filter((p) => !!p &&
+            typeof p === "object" &&
+            p.type === "text" &&
+            typeof p.text === "string")
+            .map((p) => p.text)
+            .join("\n");
+        const nonText = parts.length - parts.filter((p) => p?.type === "text").length;
+        return {
+            success: true,
+            output: text || (nonText > 0 ? `[${nonText} non-text MCP part(s)]` : "(empty MCP result)"),
+        };
+    }
     return null;
 }
 export function getOutputKind(output) {

package/dist/src/storage/tool-results.test.d.ts

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

package/dist/src/storage/tool-results.test.js

@@ -0,0 +1,48 @@
+import { describe, expect, it } from "vitest";
+import { extractToolResultFromOutput, isOutputSuccess } from "./tool-results.js";
+describe("extractToolResultFromOutput", () => {
+    it("passes through a native ToolResult shape", () => {
+        const r = extractToolResultFromOutput({ success: true, output: "hi" });
+        expect(r).toMatchObject({ success: true, output: "hi" });
+    });
+    it("treats error-text as a failure", () => {
+        const r = extractToolResultFromOutput({ type: "error-text", value: "boom" });
+        expect(r).toMatchObject({ success: false, error: "boom" });
+    });
+    it("flattens an MCP content envelope into a successful ToolResult (session 63f2d542b772)", () => {
+        // MCP tools return { type: "content", value: [{ type: "text", text }] }.
+        // Before the fix this returned null, so the persisted output_json had no
+        // `success` field and the renderer showed "Error" for a successful call.
+        const out = {
+            type: "content",
+            value: [
+                { type: "text", text: "package list" },
+                { type: "text", text: "more" },
+            ],
+        };
+        const r = extractToolResultFromOutput(out);
+        expect(r).toMatchObject({ success: true, output: "package list\nmore" });
+    });
+    it("round-trips through JSON so the renderer reads success=true (the actual bug)", () => {
+        // transcript.loadStoredToolResults does JSON.parse(output_json) and the
+        // renderer reads `.success`. Simulate persist→load and assert it is NOT
+        // misread as an error.
+        const mcpOutput = { type: "content", value: [{ type: "text", text: "## Muonroi.Core\nNuGet: Muonroi.Core" }] };
+        const persisted = JSON.stringify(extractToolResultFromOutput(mcpOutput));
+        const loaded = JSON.parse(persisted);
+        const rendered = loaded.success ? loaded.output || "Success" : loaded.error || "Error";
+        expect(rendered).toContain("Muonroi.Core");
+        expect(rendered).not.toBe("Error");
+    });
+    it("describes a non-text-only MCP content result instead of dropping to Error", () => {
+        const out = { type: "content", value: [{ type: "image", data: "..." }] };
+        const r = extractToolResultFromOutput(out);
+        expect(r?.success).toBe(true);
+        expect(r?.output).toMatch(/non-text MCP part/);
+    });
+    it("isOutputSuccess still treats content envelopes as success", () => {
+        expect(isOutputSuccess({ type: "content", value: [] })).toBe(true);
+        expect(isOutputSuccess({ type: "error-text", value: "x" })).toBe(false);
+    });
+});
+//# sourceMappingURL=tool-results.test.js.map

package/dist/src/ui/__tests__/markdown-render.test.js

@@ -39,6 +39,23 @@ describe("parseInline — marker concealment", () => {
         expect(text(parseInline("a **partial answer", t))).toBe("a **partial answer");
         expect(text(parseInline("trailing `code", t))).toBe("trailing `code");
     });
+    it("does NOT treat intra-word underscores as emphasis (identifiers stay intact)", () => {
+        // Session 584ba476c07a rendered `mcp_filesystem__list_directory` as
+        // "mcpfilesystemlistdirectory" — underscores eaten as italic/bold.
+        expect(text(parseInline("mcp_filesystem__list_directory", t))).toBe("mcp_filesystem__list_directory");
+        expect(text(parseInline("a snake_case name", t))).toBe("a snake_case name");
+        expect(text(parseInline("call mcp_muonroi-docs__setup_guide first", t))).toBe("call mcp_muonroi-docs__setup_guide first");
+        // None of these should be emphasized.
+        expect(parseInline("mcp_filesystem__list_directory", t).some((s) => s.italic || s.bold)).toBe(false);
+    });
+    it("still emphasizes underscores at word boundaries", () => {
+        expect(text(parseInline("an _italic_ word", t))).toBe("an italic word");
+        expect(parseInline("an _italic_ word", t).find((s) => s.text === "italic")?.italic).toBe(true);
+        expect(text(parseInline("a __bold__ word", t))).toBe("a bold word");
+        expect(parseInline("a __bold__ word", t).find((s) => s.text === "bold")?.bold).toBe(true);
+        // Underscore emphasis adjacent to punctuation still works.
+        expect(parseInline("(_em_)", t).find((s) => s.text === "em")?.italic).toBe(true);
+    });
     it("never leaves ** ` ### markers in styled segments", () => {
         const sample = "**A** and `b` and ***c*** and [d](http://e) and ~~f~~";
         const out = text(parseInline(sample, t));

package/dist/src/ui/markdown-render.js

@@ -77,6 +77,18 @@ export function parseInline(line, t, base = {}) {
             const inner = line.slice(i + m.open.length, close);
             if (inner.length === 0)
                 continue;
+            // CommonMark: underscore does NOT open/close emphasis intra-word, so
+            // identifiers like `mcp_filesystem__list_directory` or `snake_case` keep
+            // their underscores instead of being eaten as italic/bold (session
+            // 584ba476c07a rendered "mcpfilesystemlistdirectory"). Asterisk markers
+            // keep intraword behaviour. Reject when a word char hugs the marker on the
+            // word-internal side.
+            if (m.open[0] === "_") {
+                const before = i > 0 ? line[i - 1] : "";
+                const after = line[close + m.close.length] ?? "";
+                if (/[A-Za-z0-9]/.test(before) || /[A-Za-z0-9]/.test(after))
+                    continue;
+            }
             flushPlain(i);
             const isBold = "bold" in m && m.bold;
             const isItalic = "italic" in m && m.italic;

package/package.json

@@ -3,7 +3,7 @@
   "workspaces": [
     "packages/*"
   ],
-  "version": "1.6.1",
+  "version": "1.6.2",
   "description": "BYOK AI coding agent with multi-model council debate, role-based routing, and auto-compact.",
   "repository": {
     "type": "git",