muonroi-cli 1.4.1 → 1.5.0

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

@@ -0,0 +1,48 @@
+import { describe, expect, it } from "vitest";
+import { parseInline } from "../markdown-render.js";
+import { dark } from "../theme.js";
+const t = dark;
+const text = (segs) => segs.map((s) => s.text).join("");
+describe("parseInline — marker concealment", () => {
+    it("strips bold markers and styles the inner text", () => {
+        const segs = parseInline("a **bold** b", t);
+        expect(text(segs)).toBe("a bold b");
+        const bold = segs.find((s) => s.text === "bold");
+        expect(bold?.bold).toBe(true);
+        expect(bold?.fg).toBe(t.mdBold);
+    });
+    it("strips italic markers (* and _)", () => {
+        expect(text(parseInline("an *italic* word", t))).toBe("an italic word");
+        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);
+    });
+    it("handles bold+italic ***x***", () => {
+        const seg = parseInline("***wow***", t).find((s) => s.text === "wow");
+        expect(seg?.bold).toBe(true);
+        expect(seg?.italic).toBe(true);
+    });
+    it("strips inline code backticks and colors it", () => {
+        const segs = parseInline("call `.catch(next)` here", t);
+        expect(text(segs)).toBe("call .catch(next) here");
+        expect(segs.find((s) => s.text === ".catch(next)")?.fg).toBe(t.mdCode);
+    });
+    it("renders link label only, dropping the url", () => {
+        const segs = parseInline("see [the docs](https://x/y) now", t);
+        expect(text(segs)).toBe("see the docs now");
+        expect(text(segs)).not.toContain("https://x/y");
+        expect(segs.find((s) => s.text === "the docs")?.underline).toBe(true);
+    });
+    it("strips strikethrough ~~x~~", () => {
+        expect(text(parseInline("~~gone~~", t))).toBe("gone");
+    });
+    it("leaves unterminated markers as literal text (streaming-safe)", () => {
+        expect(text(parseInline("a **partial answer", t))).toBe("a **partial answer");
+        expect(text(parseInline("trailing `code", t))).toBe("trailing `code");
+    });
+    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));
+        expect(out).not.toMatch(/\*\*|`|~~|\]\(/);
+    });
+});
+//# sourceMappingURL=markdown-render.test.js.map

package/dist/src/ui/components/message-view.js

@@ -2,7 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "@opentui/reac
 import { memo } from "react";
 import { Markdown } from "../markdown.js";
 import { PlanView } from "../plan.js";
-import { trunc } from "../utils/text.js";
+import { stripStrayModelMacros, trunc } from "../utils/text.js";
 import { describeMcpFsTool, toolArgs, toolLabel, tryParseArg } from "../utils/tools.js";
 import { DiffView, ReadFilePreviewView } from "./diff-view.js";
 import { LspDiagnosticsView, LspResultView } from "./lsp-views.js";
@@ -29,6 +29,9 @@ const USER_MSG_COLLAPSED_LINES = 5;
 // cost. 8 fits comfortably on a short terminal and conveys the gist.
 const ASSISTANT_MSG_COLLAPSED_LINES = 8;
 export function AssistantMessageContent({ content, t, expanded, isFinal, }) {
+    // Strip stray model self-annotation macros (e.g. grok's trailing
+    // `\confidence{85}`) that leak into the answer — not instructed in the prompt.
+    content = stripStrayModelMacros(content);
     const lines = content.split("\n");
     const isLong = lines.length > ASSISTANT_MSG_COLLAPSED_LINES;
     // Phase 5 F7 — the FINAL assistant message in a turn IS the answer the

package/dist/src/ui/components/structured-response-view.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs } from "@opentui/react/jsx-runtime";
+import { renderMarkdown } from "../markdown-render.js";
 export function StructuredResponseView({ t, sr, modeColor }) {
     const d = sr.data;
     switch (sr.taskType) {
@@ -27,17 +28,20 @@ export function StructuredResponseView({ t, sr, modeColor }) {
         }
         case "documentation": {
             const r = d;
-            return (_jsxs("box", { flexDirection: "column", paddingLeft: 2, marginTop: 1, children: [_jsx("text", { children: r.content }), (r.examples ?? []).map((ex, i) => (_jsxs("box", { flexDirection: "column", marginTop: 1, children: [_jsx("text", { fg: t.textMuted, children: ex.description }), _jsx("text", { fg: t.mdCode, children: ex.code })] }, `de${i}`)))] }));
+            return (_jsxs("box", { flexDirection: "column", paddingLeft: 2, marginTop: 1, children: [r.content ? renderMarkdown(r.content, t) : null, (r.examples ?? []).map((ex, i) => (_jsxs("box", { flexDirection: "column", marginTop: 1, children: [_jsx("text", { fg: t.textMuted, children: ex.description }), _jsx("text", { fg: t.mdCode, children: ex.code })] }, `de${i}`)))] }));
         }
         case "generate": {
             const r = d;
             return (_jsxs("box", { flexDirection: "column", paddingLeft: 2, marginTop: 1, children: [r.explanation && _jsx("text", { fg: t.textMuted, children: r.explanation }), (r.files ?? []).map((f, i) => (_jsxs("box", { flexDirection: "column", marginTop: 1, children: [_jsxs("text", { children: [_jsx("span", { style: { fg: t.accent }, children: "── " }), _jsx("span", { style: { fg: t.accent }, children: f.path }), _jsx("span", { style: { fg: t.textMuted }, children: ` (${f.language})` }), _jsx("span", { style: { fg: t.accent }, children: " ──" })] }), _jsx("text", { fg: t.mdCodeBlockFg, children: f.content })] }, `gf${i}`)))] }));
         }
         case "general": {
+            // `reasoning` is the model's internal justification — deliberately NOT
+            // surfaced (it leaked as a "── reasoning:" tail and reads as process
+            // narration). The user-facing answer is `response`, rendered as markdown.
             const g = d;
             if (!g.response)
                 return _jsx("text", { fg: t.textMuted, children: JSON.stringify(d, null, 2) });
-            return (_jsxs("box", { flexDirection: "column", paddingLeft: 2, marginTop: 1, children: [_jsx("text", { fg: t.text, children: g.response }), g.reasoning ? (_jsxs("text", { fg: t.textMuted, children: ["  ── reasoning: ", g.reasoning] })) : null] }));
+            return (_jsx("box", { flexDirection: "column", paddingLeft: 2, marginTop: 1, children: renderMarkdown(g.response, t) }));
         }
         default: {
             // Graceful fallback for taskTypes without a dedicated renderer (e.g. a new
@@ -50,7 +54,7 @@ export function StructuredResponseView({ t, sr, modeColor }) {
                 (typeof obj.text === "string" && obj.text) ||
                 null;
             if (primary) {
-                return (_jsxs("box", { flexDirection: "column", paddingLeft: 2, marginTop: 1, children: [_jsx("text", { fg: t.text, children: primary }), _jsx("text", { fg: t.textMuted, children: `  ── (renderer missing for taskType: ${sr.taskType})` })] }));
+                return (_jsxs("box", { flexDirection: "column", paddingLeft: 2, marginTop: 1, children: [renderMarkdown(primary, t), _jsx("text", { fg: t.textMuted, children: `  ── (renderer missing for taskType: ${sr.taskType})` })] }));
             }
             return _jsx("text", { fg: t.text, children: JSON.stringify(d, null, 2) });
         }

package/dist/src/ui/components/tool-group.js

@@ -15,6 +15,11 @@ import { jsx as _jsx, jsxs as _jsxs } from "@opentui/react/jsx-runtime";
 import { Semantic } from "@muonroi/agent-harness-opentui";
 import { trunc } from "../utils/text.js";
 import { dominantVerb, toolLabel } from "../utils/tools.js";
+import { DiffView } from "./diff-view.js";
+// Tools whose result carries a FileDiff worth rendering inline under the item
+// line. Mirrors the per-tool branch in message-view.tsx so grouped edits show
+// the same +/- diff a non-grouped tool_result would.
+const DIFF_TOOLS = new Set(["write_file", "edit_file"]);
 // Max items rendered inline while a group is active. Anything beyond gets a
 // "+N more (ctrl+e expand)" affordance — matches Claude Code's overflow line.
 const ACTIVE_INLINE_LIMIT = 8;
@@ -79,7 +84,8 @@ export function ToolGroupView({ entry, t, expanded, modeColor }) {
     return (_jsx(Semantic, { id: `tool-group-${g.id}`, role: "region", name: headerVerb, state: g.state, children: _jsxs("box", { paddingLeft: 3, marginTop: 1, flexShrink: 0, flexDirection: "column", children: [_jsxs("text", { children: [_jsx("span", { style: { fg: headerColor }, children: "● " }), _jsx("span", { style: { fg: t.text }, children: headerVerb }), _jsx("span", { style: { fg: t.textMuted }, children: `  (${stats})` })] }), showItems && visibleItems.length > 0 && (_jsxs("box", { paddingLeft: 2, flexDirection: "column", children: [overflow > 0 && (_jsx("text", { fg: t.textMuted, children: `… +${overflow} earlier ${overflow > 1 ? "tools" : "tool"} (ctrl+e to expand)` })), visibleItems.map((it) => {
                             const label = trunc(toolLabel(it.toolCall), 90);
                             const errSuffix = it.failed && it.result?.error ? `  — ${trunc(it.result.error.replace(/\s+/g, " "), 60)}` : "";
-                            return (_jsxs("text", { children: [_jsx("span", { style: { fg: itemColor(it, t) }, children: `${itemGlyph(it)} ` }), _jsx("span", { style: { fg: t.textMuted }, children: label }), errSuffix && _jsx("span", { style: { fg: t.diffRemovedFg }, children: errSuffix })] }, it.toolCall.id));
+                            const diff = !it.failed && DIFF_TOOLS.has(it.toolCall.function.name) ? it.result?.diff : undefined;
+                            return (_jsxs("box", { flexDirection: "column", children: [_jsxs("text", { children: [_jsx("span", { style: { fg: itemColor(it, t) }, children: `${itemGlyph(it)} ` }), _jsx("span", { style: { fg: t.textMuted }, children: label }), errSuffix && _jsx("span", { style: { fg: t.diffRemovedFg }, children: errSuffix })] }), diff && _jsx(DiffView, { t: t, diff: diff })] }, it.toolCall.id));
                         })] })), g.state === "done" && !expanded && total > 0 && (_jsx("box", { paddingLeft: 2, children: _jsx("text", { fg: t.textDim, children: "ctrl+e to expand" }) }))] }) }));
 }
 //# sourceMappingURL=tool-group.js.map

package/dist/src/ui/markdown-render.d.ts

@@ -0,0 +1,41 @@
+/**
+ * src/ui/markdown-render.tsx
+ *
+ * Self-contained markdown → styled-text renderer for the TUI.
+ *
+ * Why this exists: the bundled `@opentui/core` MarkdownRenderable (v0.1.107)
+ * does NOT support concealing syntax markers — the `conceal` prop passed to
+ * `<markdown>` is silently ignored, so `**bold**`, `### heading`, `` `code` ``
+ * and `- bullet` all render with their literal markers visible (verified via
+ * @opentui/react testRender). On top of that the tree-sitter wasm used for
+ * highlight often fails to load, leaving raw unstyled text. The result reads
+ * like machine output rather than a rendered answer.
+ *
+ * This renderer parses the common markdown constructs an LLM answer uses and
+ * emits opentui `<text>`/`<span>` nodes with theme colors and the markers
+ * stripped. It is intentionally pragmatic (not CommonMark-complete): headings,
+ * bold, italic, bold+italic, inline code, strikethrough, links, ordered and
+ * unordered lists, blockquotes, fenced code blocks, and horizontal rules.
+ * Unterminated inline markers degrade to literal text (streaming-safe).
+ */
+import type { ReactNode } from "react";
+import type { Theme } from "./theme.js";
+export interface InlineSegment {
+    text: string;
+    fg?: string;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    strike?: boolean;
+}
+/**
+ * Parse a single line of inline markdown into styled segments, with markers
+ * removed. `base` carries the inherited style (used when recursing into the
+ * body of a bold/italic span so emphasis nests).
+ */
+export declare function parseInline(line: string, t: Theme, base?: Partial<InlineSegment>): InlineSegment[];
+/**
+ * Render markdown `content` into themed opentui nodes with all syntax markers
+ * concealed. Returns a column box; safe to embed inside any flex container.
+ */
+export declare function renderMarkdown(content: string, t: Theme): ReactNode;

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

@@ -0,0 +1,223 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "@opentui/react/jsx-runtime";
+import { detectLang, tokenize } from "./syntax-highlight.js";
+// Inline markers, longest-first so `***` wins over `**`/`*` and `~~` is whole.
+const INLINE = [
+    { open: "***", close: "***", bold: true, italic: true },
+    { open: "___", close: "___", bold: true, italic: true },
+    { open: "**", close: "**", bold: true },
+    { open: "__", close: "__", bold: true },
+    { open: "~~", close: "~~", strike: true },
+    { open: "*", close: "*", italic: true },
+    { open: "_", close: "_", italic: true },
+];
+function pushText(out, text, base) {
+    if (!text)
+        return;
+    const last = out[out.length - 1];
+    // Merge adjacent plain segments to keep the span count low.
+    if (last && !last.fg && !last.bold && !last.italic && !last.underline && !last.strike && isPlain(base)) {
+        last.text += text;
+        return;
+    }
+    out.push({ text, ...base });
+}
+function isPlain(b) {
+    return !b.fg && !b.bold && !b.italic && !b.underline && !b.strike;
+}
+/**
+ * Parse a single line of inline markdown into styled segments, with markers
+ * removed. `base` carries the inherited style (used when recursing into the
+ * body of a bold/italic span so emphasis nests).
+ */
+export function parseInline(line, t, base = {}) {
+    const out = [];
+    let i = 0;
+    let plainStart = 0;
+    const flushPlain = (end) => {
+        if (end > plainStart)
+            pushText(out, line.slice(plainStart, end), base);
+    };
+    while (i < line.length) {
+        const ch = line[i];
+        // Inline code: `code` — highest precedence, no nested formatting inside.
+        if (ch === "`") {
+            const end = line.indexOf("`", i + 1);
+            if (end > i) {
+                flushPlain(i);
+                out.push({ text: line.slice(i + 1, end), fg: t.mdCode });
+                i = end + 1;
+                plainStart = i;
+                continue;
+            }
+        }
+        // Link: [label](url) — show the label as an underlined link, drop the url.
+        if (ch === "[") {
+            const close = line.indexOf("]", i + 1);
+            if (close > i && line[close + 1] === "(") {
+                const urlEnd = line.indexOf(")", close + 2);
+                if (urlEnd > close) {
+                    flushPlain(i);
+                    const label = line.slice(i + 1, close);
+                    for (const seg of parseInline(label, t, { ...base, fg: t.mdLinkText, underline: true }))
+                        out.push(seg);
+                    i = urlEnd + 1;
+                    plainStart = i;
+                    continue;
+                }
+            }
+        }
+        // Emphasis markers.
+        let matched = false;
+        for (const m of INLINE) {
+            if (!line.startsWith(m.open, i))
+                continue;
+            const close = line.indexOf(m.close, i + m.open.length);
+            if (close < 0)
+                continue; // unterminated → treat as literal
+            const inner = line.slice(i + m.open.length, close);
+            if (inner.length === 0)
+                continue;
+            flushPlain(i);
+            const isBold = "bold" in m && m.bold;
+            const isItalic = "italic" in m && m.italic;
+            const isStrike = "strike" in m && m.strike;
+            const childBase = {
+                ...base,
+                bold: base.bold || isBold || undefined,
+                italic: base.italic || isItalic || undefined,
+                strike: base.strike || isStrike || undefined,
+                fg: base.fg ?? (isBold ? t.mdBold : isItalic ? t.mdItalic : isStrike ? t.textMuted : undefined),
+            };
+            for (const seg of parseInline(inner, t, childBase))
+                out.push(seg);
+            i = close + m.close.length;
+            plainStart = i;
+            matched = true;
+            break;
+        }
+        if (matched)
+            continue;
+        i++;
+    }
+    flushPlain(line.length);
+    return out;
+}
+const FENCE = /^\s*(`{3,}|~{3,})\s*([\w+-]*)\s*$/;
+const HEADING = /^(#{1,6})\s+(.*)$/;
+const HR = /^\s*([-*_])\1{2,}\s*$/;
+const BULLET = /^(\s*)[-*+]\s+(.*)$/;
+const ORDERED = /^(\s*)(\d+)[.)]\s+(.*)$/;
+const QUOTE = /^\s*>\s?(.*)$/;
+function parseBlocks(content, t) {
+    const lines = content.replace(/\r\n/g, "\n").split("\n");
+    const blocks = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        const fence = FENCE.exec(line);
+        if (fence) {
+            const marker = fence[1];
+            const lang = fence[2] ?? "";
+            const body = [];
+            i++;
+            while (i < lines.length && !new RegExp(`^\\s*${marker[0]}{${marker.length},}\\s*$`).test(lines[i])) {
+                body.push(lines[i]);
+                i++;
+            }
+            i++; // consume closing fence (or run off the end — streaming-safe)
+            blocks.push({ kind: "code", lang, lines: body });
+            continue;
+        }
+        if (line.trim() === "") {
+            blocks.push({ kind: "blank" });
+            i++;
+            continue;
+        }
+        if (HR.test(line)) {
+            blocks.push({ kind: "hr" });
+            i++;
+            continue;
+        }
+        const h = HEADING.exec(line);
+        if (h) {
+            blocks.push({ kind: "heading", level: h[1].length, segs: parseInline(h[2], t, { fg: t.mdHeading, bold: true }) });
+            i++;
+            continue;
+        }
+        const q = QUOTE.exec(line);
+        if (q) {
+            blocks.push({ kind: "quote", segs: parseInline(q[1], t, { fg: t.mdItalic, italic: true }) });
+            i++;
+            continue;
+        }
+        const b = BULLET.exec(line);
+        if (b) {
+            blocks.push({ kind: "bullet", indent: b[1].length, segs: parseInline(b[2], t) });
+            i++;
+            continue;
+        }
+        const o = ORDERED.exec(line);
+        if (o) {
+            blocks.push({ kind: "ordered", indent: o[1].length, marker: `${o[2]}.`, segs: parseInline(o[3], t) });
+            i++;
+            continue;
+        }
+        blocks.push({ kind: "para", segs: parseInline(line, t) });
+        i++;
+    }
+    return blocks;
+}
+function Spans({ segs }) {
+    // opentui sets bold/italic/underline via the <b>/<i>/<u> text-modifier
+    // elements, NOT via span style flags. Compose them around a colored <span>.
+    return (_jsx(_Fragment, { children: segs.map((s, i) => {
+            // biome-ignore lint/suspicious/noArrayIndexKey: segments are positional within a line
+            let node = (_jsx("span", { style: s.fg ? { fg: s.fg } : undefined, children: s.text }, `s${i}`));
+            if (s.underline)
+                node = _jsx("u", { children: node }, `u${i}`);
+            if (s.italic)
+                node = _jsx("i", { children: node }, `i${i}`);
+            if (s.bold)
+                node = _jsx("b", { children: node }, `b${i}`);
+            return node;
+        }) }));
+}
+/**
+ * Render markdown `content` into themed opentui nodes with all syntax markers
+ * concealed. Returns a column box; safe to embed inside any flex container.
+ */
+export function renderMarkdown(content, t) {
+    const blocks = parseBlocks(content, t);
+    return (_jsx("box", { flexDirection: "column", flexShrink: 0, children: blocks.map((blk, idx) => {
+            // biome-ignore lint/suspicious/noArrayIndexKey: blocks are positional and re-rendered wholesale
+            const key = `b${idx}`;
+            switch (blk.kind) {
+                case "blank":
+                    return _jsx("box", { height: 1 }, key);
+                case "hr":
+                    return (_jsx("text", { fg: t.mdHr, children: "─".repeat(40) }, key));
+                case "heading":
+                    return (_jsx("text", { marginTop: idx === 0 ? 0 : 1, children: _jsx(Spans, { segs: blk.segs }) }, key));
+                case "quote":
+                    return (_jsxs("text", { children: [_jsx("span", { style: { fg: t.mdHr }, children: "▏ " }), _jsx(Spans, { segs: blk.segs })] }, key));
+                case "bullet":
+                    return (_jsxs("text", { children: [_jsx("span", { style: { fg: t.text }, children: " ".repeat(blk.indent) }), _jsx("span", { style: { fg: t.mdListBullet }, children: "• " }), _jsx(Spans, { segs: blk.segs })] }, key));
+                case "ordered":
+                    return (_jsxs("text", { children: [_jsx("span", { style: { fg: t.text }, children: " ".repeat(blk.indent) }), _jsx("span", { style: { fg: t.mdListBullet }, children: `${blk.marker} ` }), _jsx(Spans, { segs: blk.segs })] }, key));
+                case "code": {
+                    const lang = detectLang(`x.${blk.lang || "txt"}`);
+                    return (_jsx("box", { backgroundColor: t.mdCodeBlockBg, paddingLeft: 1, paddingRight: 1, flexDirection: "column", children: blk.lines.map((ln, j) => {
+                            const toks = lang === "plain" ? [] : tokenize(ln, lang, t);
+                            return (
+                            // biome-ignore lint/suspicious/noArrayIndexKey: code lines are positional
+                            _jsx("text", { children: toks.length === 0 ? (_jsx("span", { style: { fg: t.mdCodeBlockFg }, children: ln || " " })) : (toks.map((tok, k) => (
+                                // biome-ignore lint/suspicious/noArrayIndexKey: token positions are stable per render
+                                _jsx("span", { style: { fg: tok.fg }, children: tok.text }, `t${k}`)))) }, `c${j}`));
+                        }) }, key));
+                }
+                default:
+                    return (_jsx("text", { children: _jsx(Spans, { segs: blk.segs }) }, key));
+            }
+        }) }));
+}
+//# sourceMappingURL=markdown-render.js.map

package/dist/src/ui/markdown.d.ts

@@ -1,4 +1,14 @@
 import type { Theme } from "./theme.js";
+/**
+ * Render markdown to themed TUI text.
+ *
+ * Historically this delegated to opentui's `<markdown>` renderable with
+ * `conceal`, but the bundled @opentui/core (0.1.107) ignores `conceal` and
+ * leaves `**`/`###`/`` ` `` markers visible (and frequently fails to load the
+ * tree-sitter wasm for highlighting). We now render markdown ourselves via
+ * `renderMarkdown`, which strips markers and applies theme colors. See
+ * markdown-render.tsx for the construct coverage.
+ */
 export declare function Markdown({ content, t }: {
     content: string;
     t: Theme;

package/dist/src/ui/markdown.js

@@ -1,38 +1,15 @@
-import { jsx as _jsx } from "@opentui/react/jsx-runtime";
-import { RGBA, SyntaxStyle } from "@opentui/core";
-import { useMemo } from "react";
-function buildSyntaxStyle(t) {
-    return SyntaxStyle.fromStyles({
-        default: { fg: RGBA.fromHex(t.text) },
-        "markup.heading": { fg: RGBA.fromHex(t.mdHeading), bold: true },
-        "markup.heading.1": { fg: RGBA.fromHex(t.mdHeading), bold: true },
-        "markup.heading.2": { fg: RGBA.fromHex(t.mdHeading), bold: true },
-        "markup.heading.3": { fg: RGBA.fromHex(t.mdHeading), bold: true },
-        "markup.bold": { fg: RGBA.fromHex(t.mdBold), bold: true },
-        "markup.italic": { fg: RGBA.fromHex(t.mdItalic), italic: true },
-        "markup.raw": { fg: RGBA.fromHex(t.mdCode) },
-        "markup.link": { fg: RGBA.fromHex(t.mdLink), underline: true },
-        "markup.link.label": { fg: RGBA.fromHex(t.mdLinkText) },
-        "markup.list": { fg: RGBA.fromHex(t.mdListBullet) },
-        "markup.quote": { fg: RGBA.fromHex(t.mdItalic), italic: true },
-        "markup.separator": { fg: RGBA.fromHex(t.mdHr) },
-        code: { fg: RGBA.fromHex(t.mdCodeBlockFg), bg: RGBA.fromHex(t.mdCodeBlockBg) },
-    });
-}
-const TABLE_OPTIONS = {
-    widthMode: "full",
-    columnFitter: "balanced",
-    wrapMode: "word",
-    cellPadding: 1,
-    borders: true,
-    outerBorder: true,
-    borderStyle: "rounded",
-    borderColor: "#333333",
-};
+import { renderMarkdown } from "./markdown-render.js";
+/**
+ * Render markdown to themed TUI text.
+ *
+ * Historically this delegated to opentui's `<markdown>` renderable with
+ * `conceal`, but the bundled @opentui/core (0.1.107) ignores `conceal` and
+ * leaves `**`/`###`/`` ` `` markers visible (and frequently fails to load the
+ * tree-sitter wasm for highlighting). We now render markdown ourselves via
+ * `renderMarkdown`, which strips markers and applies theme colors. See
+ * markdown-render.tsx for the construct coverage.
+ */
 export function Markdown({ content, t }) {
-    const syntaxStyle = useMemo(() => buildSyntaxStyle(t), [t]);
-    return (_jsx("markdown", { content: content, syntaxStyle: syntaxStyle, conceal: true, 
-        // @ts-expect-error MarkdownProps omits inherited Renderable.selectable; needed for TUI text selection
-        selectable: true, tableOptions: TABLE_OPTIONS, flexShrink: 0 }));
+    return renderMarkdown(content, t);
 }
 //# sourceMappingURL=markdown.js.map

package/dist/src/ui/slash/council-inspect.js

@@ -37,10 +37,10 @@ export const handleCouncilInspectSlash = async (args) => {
     }
     // Load all system messages for this session — parameterized query prevents SQL injection (T-17-04)
     const rows = db
-        .prepare(`SELECT role, message_json, seq, created_at
-       FROM messages
-       WHERE session_id = ?
-         AND role = 'system'
+        .prepare(`SELECT role, message_json, seq, created_at
+       FROM messages
+       WHERE session_id = ?
+         AND role = 'system'
        ORDER BY seq ASC`)
         .all(sessionId);
     if (rows.length === 0) {

package/dist/src/ui/slash/export.js

@@ -25,10 +25,10 @@ function selectInteractionTimeline(sessionId) {
     try {
         const db = getDatabase();
         return db
-            .prepare(`SELECT event_type, event_subtype, metadata_json, created_at
-         FROM interaction_logs
-         WHERE session_id = ?
-           AND event_type IN ('ui_interaction', 'routing', 'council', 'ee_injection')
+            .prepare(`SELECT event_type, event_subtype, metadata_json, created_at
+         FROM interaction_logs
+         WHERE session_id = ?
+           AND event_type IN ('ui_interaction', 'routing', 'council', 'ee_injection')
          ORDER BY created_at ASC, id ASC`)
             .all(sessionId);
     }

package/dist/src/ui/utils/text.d.ts

@@ -4,3 +4,11 @@ export declare function truncateLine(s: string, n: number): string;
 export declare function truncateBlock(text: string, maxLines: number): string;
 export declare function compactTaskLabel(label: string): string;
 export declare function sanitizeContent(raw: string): string;
+/**
+ * Strip stray model self-annotation macros that leak into the user-facing answer
+ * but are NOT instructed anywhere in the prompt. Currently: a trailing
+ * `\confidence{NN}` macro emitted intermittently by grok-build. Conservative —
+ * only the `\confidence{...}` form is removed, so legitimate LaTeX/code in an
+ * answer (e.g. `\frac{a}{b}`) is untouched. Fast-pathed: no work when absent.
+ */
+export declare function stripStrayModelMacros(text: string): string;

package/dist/src/ui/utils/text.js

@@ -29,4 +29,20 @@ export function sanitizeContent(raw) {
     s = s.replace(/\{"success"\s*:\s*(true|false)\s*,\s*"output"\s*:\s*"[\s\S]*$/m, "");
     return s.trim();
 }
+/**
+ * Strip stray model self-annotation macros that leak into the user-facing answer
+ * but are NOT instructed anywhere in the prompt. Currently: a trailing
+ * `\confidence{NN}` macro emitted intermittently by grok-build. Conservative —
+ * only the `\confidence{...}` form is removed, so legitimate LaTeX/code in an
+ * answer (e.g. `\frac{a}{b}`) is untouched. Fast-pathed: no work when absent.
+ */
+export function stripStrayModelMacros(text) {
+    if (!text || !text.includes("\\confidence"))
+        return text;
+    // Trailing form (most common) — also swallow the whitespace/newline before it.
+    let out = text.replace(/\s*\\confidence\s*\{[^}]*\}\s*$/i, "");
+    // Any remaining mid-text occurrences.
+    out = out.replace(/\\confidence\s*\{[^}]*\}/gi, "");
+    return out;
+}
 //# sourceMappingURL=text.js.map

package/dist/src/ui/utils/text.test.d.ts

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

package/dist/src/ui/utils/text.test.js

@@ -0,0 +1,23 @@
+import { describe, expect, it } from "vitest";
+import { stripStrayModelMacros } from "./text.js";
+describe("stripStrayModelMacros", () => {
+    it("strips a trailing \\confidence{NN} macro and the blank line before it", () => {
+        const input = "Root cause: parseInt radix.\n\nFix: use radix 10.\n\n\\confidence{85}";
+        expect(stripStrayModelMacros(input)).toBe("Root cause: parseInt radix.\n\nFix: use radix 10.");
+    });
+    it("strips a mid-text \\confidence macro too", () => {
+        expect(stripStrayModelMacros("answer \\confidence{90} continues")).toBe("answer  continues");
+    });
+    it("is a no-op when no macro is present (fast path)", () => {
+        const clean = "A normal answer with `\\frac{a}{b}` LaTeX that must survive.";
+        expect(stripStrayModelMacros(clean)).toBe(clean);
+    });
+    it("does not touch other backslash macros (conservative)", () => {
+        const latex = "Use \\frac{1}{2} and \\sum_{i}.";
+        expect(stripStrayModelMacros(latex)).toBe(latex);
+    });
+    it("handles empty / falsy input", () => {
+        expect(stripStrayModelMacros("")).toBe("");
+    });
+});
+//# sourceMappingURL=text.test.js.map

package/dist/src/usage/ledger.js

@@ -63,26 +63,59 @@ async function ensureUsageFile(filePath) {
         }
     }
 }
+/**
+ * In-process serialization per usage.json path.
+ *
+ * proper-lockfile guards CROSS-process access, but its FS-mtime staleness
+ * check can admit a second concurrent critical section under CPU starvation:
+ * a holder that is descheduled long enough fails to refresh the lock mtime,
+ * a competitor deems the lock stale and steals it, and two reserve() bodies
+ * run at once. Reproduced under 6-process contention — exactly one extra
+ * reservation slips past a $1.00 cap (6 × $0.18 = $1.08 > cap).
+ *
+ * A JS promise-chain mutex makes same-process reserve/commit/release bursts
+ * strictly serial. This is the dominant real case (10 parallel tool calls in
+ * one CLI process) and closes the in-process overshoot window entirely; the
+ * file lock still handles genuine multi-process access.
+ */
+const pathMutex = new Map();
+function withPathMutex(filePath, fn) {
+    const prev = pathMutex.get(filePath) ?? Promise.resolve();
+    // Run regardless of the prior caller's outcome (success or rejection).
+    const run = prev.then(fn, fn);
+    // Stored tail swallows rejection so one failed caller never rejects queued
+    // ones; prune the map entry when this tail is the last in the chain.
+    const tail = run.then(() => { }, () => { });
+    pathMutex.set(filePath, tail);
+    void tail.then(() => {
+        if (pathMutex.get(filePath) === tail)
+            pathMutex.delete(filePath);
+    });
+    return run;
+}
 /**
  * Execute a function under exclusive file lock on usage.json.
- * The lock prevents racing readers/writers across CLI processes.
+ * The lock prevents racing readers/writers across CLI processes; the
+ * in-process mutex serializes concurrent callers within this process.
  */
 async function withLock(filePath, fn) {
-    await ensureUsageFile(filePath);
-    const releaseLock = await lockfile.lock(filePath, {
-        retries: { retries: 10, minTimeout: 10, maxTimeout: 100 },
-        stale: 5_000,
-        realpath: false,
+    return withPathMutex(filePath, async () => {
+        await ensureUsageFile(filePath);
+        const releaseLock = await lockfile.lock(filePath, {
+            retries: { retries: 10, minTimeout: 10, maxTimeout: 100 },
+            stale: 5_000,
+            realpath: false,
+        });
+        try {
+            const state = (await atomicReadJSON(filePath)) ?? emptyState();
+            const { next, result } = await fn(state);
+            await atomicWriteJSON(filePath, next);
+            return result;
+        }
+        finally {
+            await releaseLock();
+        }
     });
-    try {
-        const state = (await atomicReadJSON(filePath)) ?? emptyState();
-        const { next, result } = await fn(state);
-        await atomicWriteJSON(filePath, next);
-        return result;
-    }
-    finally {
-        await releaseLock();
-    }
 }
 /**
  * Reserve projected token spend against the monthly cap.

package/dist/src/utils/__tests__/footprint-gitignore.test.d.ts

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