muonroi-cli 1.4.1 → 1.6.0

package/dist/src/tools/registry.js

@@ -12,7 +12,9 @@ import { needsVisionProxy } from "../providers/vision-proxy.js";
 import { getBashRun, sliceBashOutput } from "./bash-output-cache.js";
 import { editFile, readFile, writeFile } from "./file.js";
 import { FileTracker } from "./file-tracker.js";
+import { analyzeGitCommand, checkPushGate, pushBlockedMessage, recordCommandOutcome, stagingWarning, } from "./git-safety.js";
 import { executeGrep } from "./grep.js";
+import { registerNativeMuonroiTools } from "./native-tools.js";
 import { VISION_TOOL_NAMES } from "./vision-gate.js";
 function getBashRepeatState() {
     if (!globalThis.__muonroiBashRepeatState) {
@@ -124,6 +126,15 @@ export function createBuiltinTools(bash, mode, opts) {
     // user turns / askcards no longer wipes it. See getBashRepeatState().
     const repeatState = getBashRepeatState();
     const repeatKey = resolveBashRepeatKey(opts?.sessionId);
+    // Git-safety state key. MUST be stable across createBuiltinTools() rebuilds
+    // within one process — otherwise a failed-test record made before a registry
+    // rebuild (askcard answer, sub-agent turn) would be invisible to the push
+    // gate after the rebuild. Unlike resolveBashRepeatKey's anon fallback (which
+    // intentionally generates a fresh key per instance to isolate repeat-reminder
+    // state), we want the gate to PERSIST: use the real sessionId when present,
+    // else a single process-stable key. Over-sharing here is the safe direction
+    // (it can only over-block a push, never wrongly allow one).
+    const gitSafetyKey = opts?.sessionId && opts.sessionId.length > 0 ? opts.sessionId : `__proc_default__:${process.pid}`;
     tools.bash = dynamicTool({
         description: "Execute a shell command. Output is automatically cached — every call returns a " +
             "run_id you can re-query via bash_output_get(run_id, mode=tail|head|grep|lines). " +
@@ -149,19 +160,36 @@ export function createBuiltinTools(bash, mode, opts) {
             if (typeof input.command !== "string" || input.command.trim() === "") {
                 return 'ERROR: the `bash` tool requires a non-empty "command" string, but the call had empty arguments. Provide the shell command to run, e.g. {"command":"ls -la"}.';
             }
+            const cmd = typeof input.command === "string" ? input.command : "";
+            // Git safety (pre-execution). Block `git push` while a verification
+            // command failed this session and was not re-run green; warn on broad
+            // `git add -A` / `git commit -a` when sensitive paths exist. Applied to
+            // BOTH foreground and background paths. See git-safety.ts for the audit
+            // motivation (session 18285908637a). gitSafetyKey is STABLE per process
+            // (or the real sessionId) — unlike repeatKey, whose anon fallback changes
+            // on every registry rebuild and would silently drop the gate across turns.
+            const gitShape = analyzeGitCommand(cmd);
+            const stageWarn = gitShape.isBroadStage ? stagingWarning(bash.getCwd()) : "";
+            if (gitShape.isPush) {
+                const gate = checkPushGate(gitSafetyKey);
+                if (gate.blocked) {
+                    return `${pushBlockedMessage(gate.failed)}${stageWarn}`;
+                }
+            }
             if (input.background) {
                 const result = await bash.startBackground(input.command);
-                return formatResult(result);
+                return `${formatResult(result)}${stageWarn}`;
             }
             // 3-3: compute canonical form BEFORE running so we can attach an
             // inline reminder if it matches the previous bash call.
-            const cmd = typeof input.command === "string" ? input.command : "";
             const canonical = cmd ? canonicalizeBashCommand(cmd) : "";
             const entry = repeatState.get(repeatKey) ?? { lastCanonical: null, lastRunId: null };
             const repeatedIntent = canonical !== "" && canonical === entry.lastCanonical && entry.lastRunId !== null;
             const prevRunId = entry.lastRunId;
             const result = await bash.execute(input.command, input.timeout ?? 30000);
             const formatted = formatResult(result);
+            // Record verification outcome so a later `git push` can be gated on it.
+            recordCommandOutcome(gitSafetyKey, canonical, result.success);
             // Update last-canonical state AFTER we compared, so the current call's
             // runId becomes the comparison target for the next one. Session-scoped
             // map persists across createBuiltinTools() rebuilds (Phase 4R).
@@ -185,9 +213,9 @@ export function createBuiltinTools(bash, mode, opts) {
                 const hint = chars >= 4_000
                     ? ` — ${chars} chars cached; use bash_output_get(run_id, mode=tail|head|grep|lines) to re-query`
                     : "";
-                return `${formatted}\n\n[bash_run_id: ${result.bashRunId}${hint}]${reminder}`;
+                return `${formatted}\n\n[bash_run_id: ${result.bashRunId}${hint}]${reminder}${stageWarn}`;
             }
-            return formatted;
+            return `${formatted}${stageWarn}`;
         },
     });
     // bash_output_get — re-query the cached full output of a previous bash run.
@@ -438,14 +466,25 @@ export function createBuiltinTools(bash, mode, opts) {
                 }
                 try {
                     if (isToolArtifactQuery(query)) {
-                        // Artifact rehydration → raw /api/search (exact-collection lookup).
+                        // Local-first (anti-mù durability): the compactor records each elided
+                        // output in-process by toolCallId. For an exact "tool-artifact id=X"
+                        // lookup this is the authoritative full content for THIS session and
+                        // works even when EE is down — the failure window long sessions hit.
+                        const { findArtifactByQuery, findArtifactOnDisk } = await import("../ee/artifact-cache.js");
+                        const mem = findArtifactByQuery(query);
+                        const local = mem ?? (await findArtifactOnDisk(query));
+                        if (local) {
+                            const src = mem ? "in-session cache" : "local disk cache";
+                            return truncateOutput(`[tool-artifact id=${local.toolCallId} tool=${local.toolName} — rehydrated from ${src}]\n${local.content}`);
+                        }
+                        // EE fallback (cross-session / post-restart) → raw /api/search exact lookup.
                         const { searchEE } = await import("../ee/search.js");
                         const resp = await searchEE(query, {
                             ...(Array.isArray(input?.collections) ? { collections: input.collections } : {}),
                             ...(typeof input?.limit === "number" ? { limit: input.limit } : {}),
                         });
                         if (resp === null) {
-                            return "[ee_unavailable] Experience Engine returned no response (server down, timeout, circuit open, or unconfigured). Proceed without EE recall — re-read the source directly if you need the elided content.";
+                            return "[ee_unavailable] Experience Engine returned no response (server down, timeout, circuit open, or unconfigured) and the artifact is not in this session's local cache. Proceed without EE recall — re-read the source directly if you need the elided content.";
                         }
                         return truncateOutput(JSON.stringify(resp));
                     }
@@ -473,6 +512,13 @@ export function createBuiltinTools(bash, mode, opts) {
                 }
             },
         });
+        // Native muonroi-tools builtins — ee_health, ee_feedback, usage_forensics,
+        // lsp_query, setup_guide, selfverify_*. These run IN-PROCESS; the CLI no
+        // longer self-spawns itself as an MCP server to expose them to its own inner
+        // agent (that self-spawn cold-started 2-3.5s and overran the build deadline,
+        // and a seed-time bug once persisted a crashing vitest-worker command). The
+        // muonroi-tools MCP server stays only for EXTERNAL agents. See native-tools.ts.
+        registerNativeMuonroiTools(tools, { cwd: bash.getCwd() });
     }
     // Vision proxy tools — only for text-only models (DeepSeek, etc.)
     if (opts?.modelId && needsVisionProxy(opts.modelId)) {

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

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

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;