muonroi-cli 1.6.1 → 1.6.3

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.3";
 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.3";
 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/mcp/__tests__/client-pool.spec.js

@@ -109,6 +109,27 @@ describe("acquireMcpTools — cross-turn client pool", () => {
         expect(results.every((r) => r === "pong")).toBe(true);
         expect(connectOneServer).toHaveBeenCalledTimes(2); // 14 failures → exactly ONE shared reconnect
     });
+    it("waits for a criticalServerId past the normal deadline so it lands THIS turn (session 584ba476c07a)", async () => {
+        // Normal deadline is 500ms (mock). docs connects at ~700ms — past the normal
+        // deadline but within the critical window → must be included when critical.
+        connectOneServer.mockImplementation((s) => new Promise((res) => {
+            if (s.id === "docs")
+                setTimeout(() => res(connected(s.id)), 700);
+            else
+                res(connected(s.id));
+        }));
+        const b = await acquireMcpTools([srv("docs")], { criticalServerIds: ["docs"], criticalDeadlineMs: 3000 });
+        expect(Object.keys(b.tools)).toContain("mcp_docs__ping");
+        expect(b.errors).toHaveLength(0);
+    });
+    it("without criticalServerIds, a slow server is reported still-connecting (available next turn)", async () => {
+        connectOneServer.mockImplementation((s) => new Promise((res) => {
+            setTimeout(() => res(connected(s.id)), 700);
+        }));
+        const b = await acquireMcpTools([srv("docs")]);
+        expect(Object.keys(b.tools)).not.toContain("mcp_docs__ping");
+        expect(b.errors.some((e) => /still connecting/.test(e))).toBe(true);
+    });
     it("keys by cwd/config — a different command reconnects rather than reusing", async () => {
         connectOneServer.mockImplementation(async (s) => connected(s.id));
         await acquireMcpTools([

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

@@ -179,6 +179,28 @@ export async function acquireMcpTools(servers, opts) {
     await Promise.race([Promise.allSettled(attempts), deadline]);
     if (deadlineTimer)
         clearTimeout(deadlineTimer);
+    // Critical-server extended wait: a turn that MUST have a specific server (e.g.
+    // muonroi-docs on an ecosystem question) waits for just that server's connect
+    // beyond the normal deadline, so a cold first-connect is included THIS turn
+    // rather than reported "still connecting → next turn". Only the named servers
+    // are awaited; everything already settled is untouched (no added latency for
+    // normal turns, which pass no criticalServerIds).
+    const critical = new Set((opts?.criticalServerIds ?? []).filter(Boolean));
+    if (critical.size > 0) {
+        const pendingIdx = enabled.map((s, i) => ({ s, i })).filter(({ s, i }) => critical.has(s.id) && !slots[i].done);
+        if (pendingIdx.length > 0) {
+            const criticalDeadlineMs = Math.max(deadlineMs, opts?.criticalDeadlineMs ?? 8000);
+            const extraMs = Math.max(0, criticalDeadlineMs - deadlineMs);
+            let extraTimer;
+            const extraDeadline = new Promise((resolve) => {
+                extraTimer = setTimeout(resolve, extraMs);
+                extraTimer.unref?.();
+            });
+            await Promise.race([Promise.allSettled(pendingIdx.map(({ i }) => attempts[i])), extraDeadline]);
+            if (extraTimer)
+                clearTimeout(extraTimer);
+        }
+    }
     for (let i = 0; i < slots.length; i++) {
         const slot = slots[i];
         if (slot.done) {

package/dist/src/mcp/runtime.d.ts

@@ -8,6 +8,17 @@ export interface McpToolBundle {
 }
 export interface McpBuildOptions {
     onOAuthRequired?: (serverId: string, url: URL) => void;
+    /**
+     * Server ids the CURRENT turn critically needs (e.g. muonroi-docs on an
+     * ecosystem question). acquireMcpTools waits for these specifically beyond the
+     * normal build deadline — up to `criticalDeadlineMs` — so a cold first-connect
+     * is included THIS turn instead of "ready next turn" (session 584ba476c07a:
+     * first ecosystem question missed muonroi-docs while it was still warming).
+     * Other servers are unaffected — only the named ones get the extended wait.
+     */
+    criticalServerIds?: string[];
+    /** Extended ceiling (ms) for criticalServerIds. Default 8000. */
+    criticalDeadlineMs?: number;
 }
 /**
  * Total wall-clock budget for building the MCP tool set. Servers connect in

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

@@ -60,6 +60,7 @@ import * as phaseTracker from "../ee/phase-tracker.js";
 import { buildScope as buildScopeForVeto } from "../ee/scope.js";
 import { fireTrajectoryEvent } from "../ee/session-trajectory.js";
 import { getTenantId as getTenantIdForVeto } from "../ee/tenant.js";
+import { mentionsEcosystemScope } from "../gsd/directives.js";
 import { acquireMcpTools } from "../mcp/client-pool.js";
 import { dropRedundantFsMcpTools, filterMcpServersByMessage } from "../mcp/smart-filter.js";
 import { getModelInfo } from "../models/registry.js";
@@ -1022,6 +1023,16 @@ export class MessageProcessor {
                         const filteredServers = filterMcpServersByMessage(loadMcpServers(), userMessage, {
                             disabled: process.env.MUONROI_DISABLE_SMART_MCP === "1",
                         });
+                        // Ecosystem question → muonroi-docs is the authoritative source the
+                        // agent is nudged to consult FIRST. Wait for it specifically beyond the
+                        // normal deadline so a cold first-connect lands THIS turn instead of
+                        // "ready next turn" (session 584ba476c07a: first ecosystem question
+                        // missed docs while warming → agent guessed from local files).
+                        const criticalServerIds = mentionsEcosystemScope(userMessage)
+                            ? filteredServers
+                                .filter((s) => /(^|[-_])docs([-_]|$)/.test(s.id) && /muonroi/i.test(s.id))
+                                .map((s) => s.id)
+                            : undefined;
                         // MCP non-blocking: acquireMcpTools self-bounds — it connects servers
                         // in parallel and returns PARTIAL results at its internal deadline
                         // (fast/cached servers included; slow first-connects reported in
@@ -1038,6 +1049,7 @@ export class MessageProcessor {
                                     // command-injection vector the old exec() opener had.
                                     openUrl(url);
                                 },
+                                ...(criticalServerIds && criticalServerIds.length > 0 ? { criticalServerIds } : {}),
                             });
                         }
                         catch (err) {

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/pil/__tests__/layer4-gsd.test.js

@@ -104,6 +104,16 @@ describe("layer4Gsd (gsd-native)", () => {
         const result = await layer4Gsd(makeCtx({ raw, enriched: raw, taskType: "analyze", intentKind: "task", deliverableKind: "answer" }));
         expect(result.enriched).toContain("QUESTION / explanatory");
     });
+    it("deliverableKind='report' is informational (no council/discuss scaffold) — session 666630479c1a", async () => {
+        // "Đọc và tóm tắt kiến trúc…" classifies as deliverableKind 'report'. A
+        // report is human-facing with NO code change, so it must route to the
+        // QUESTION directive, not the heavy implement/discuss/council scaffold that
+        // over-asked with askcards on a read/summarize task.
+        const raw = "đọc và tóm tắt kiến trúc src/orchestrator, src/pil, src/mcp kèm file:line";
+        const result = await layer4Gsd(makeCtx({ raw, enriched: raw, taskType: "analyze", intentKind: "task", deliverableKind: "report" }));
+        expect(result.enriched).toContain("QUESTION / explanatory");
+        expect(result.enriched).not.toContain("MANDATORY");
+    });
     it("Phase 2b: deliverableKind='code' is NOT informational even for a question-shaped prompt", async () => {
         // The raw text reads as a question — the legacy regex would mark it
         // informational. The model's deliverableKind='code' must override that so

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

@@ -84,15 +84,20 @@ export async function layer4Gsd(ctx) {
     // into the human-facing reply as a "2-3 line plan" + process narration
     // (session 829a83888dd2). Route them to the human-facing question directive.
     //
-    // Phase 2b: when the model classified the deliverable, CONSUME it — an
-    // "answer" deliverable IS informational. Only when the model didn't emit one
-    // (deliverableKind null → legacy cascade, or the model omitted the word) do
-    // we fall back to the legacy regex predicates:
+    // Phase 2b: when the model classified the deliverable, CONSUME it. Both an
+    // "answer" AND a "report" deliverable are HUMAN-FACING with no code change, so
+    // both are informational — only "code" routes through the implement/verify (and
+    // heavy discuss/council) scaffold. Treating "report" as non-informational sent
+    // read/summarize/architecture tasks (deliverableKind "report") down the heavy
+    // council + AskUserQuestion path, over-asking on a task that just wanted a
+    // written summary (session 666630479c1a: "Đọc và tóm tắt kiến trúc…" raised 2
+    // askcards + a council loop). Only when the model emitted no deliverable
+    // (deliverableKind null → legacy cascade) do we fall back to regex predicates:
     //   1. isMetaAnalysisPrompt — self/CLI evaluation, prior-turn reflection.
     //   2. taskType "general" classified as a real task by L1.
     //   3. question-shaped prompt that is NOT an implementation request.
     const informational = ctx.deliverableKind
-        ? ctx.deliverableKind === "answer"
+        ? ctx.deliverableKind !== "code"
         : isMetaAnalysisPrompt(ctx.raw) ||
             (ctx.taskType === "general" && ctx.intentKind === "task") ||
             (isQuestionLike(ctx.raw) && !isImplementationIntent(ctx.raw));

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/app.js

@@ -2525,7 +2525,7 @@ export function App({ agent, startupConfig, initialMessage, onExit }) {
                         applyLocalAssistantDelta(`\n⚠ [Experience] ${eeChunk.experienceWarning?.message ?? eeChunk.content ?? ""}\nWhy: ${eeChunk.experienceWarning?.why ?? ""}\n`);
                     }
                     else if (eeChunk.type === "experience_injected") {
-                        applyLocalAssistantDelta(`\n💡 [Experience Injected] ${eeChunk.experienceInjected?.pointCount ?? 0} point(s) loaded (score ≥ ${eeChunk.experienceInjected?.scoreFloor ?? 0})\n`);
+                        applyLocalAssistantDelta(formatExperienceInjectedBlock(eeChunk.experienceInjected ?? {}));
                     }
                 });
                 for await (const chunk of agent.processMessage(text.trim(), undefined, images)) {
@@ -3472,10 +3472,7 @@ export function App({ agent, startupConfig, initialMessage, onExit }) {
                                             },
                                         ];
                                     }
-                                    return [
-                                        ...prev,
-                                        buildAssistantEntry(`💡 [Experience Injected] ${chunk.experienceInjected.pointCount} point(s)`),
-                                    ];
+                                    return [...prev, buildAssistantEntry(formatExperienceInjectedBlock(chunk.experienceInjected))];
                                 });
                             }
                             if (chunk.type === "halt" && chunk.haltChunk) {
@@ -3694,10 +3691,7 @@ export function App({ agent, startupConfig, initialMessage, onExit }) {
                                             },
                                         ];
                                     }
-                                    return [
-                                        ...prev,
-                                        buildAssistantEntry(`💡 [Experience Injected] ${chunk.experienceInjected.pointCount} point(s)`),
-                                    ];
+                                    return [...prev, buildAssistantEntry(formatExperienceInjectedBlock(chunk.experienceInjected))];
                                 });
                             }
                             if (chunk.type === "done")

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.3",
   "description": "BYOK AI coding agent with multi-model council debate, role-based routing, and auto-compact.",
   "repository": {
     "type": "git",