muonroi-cli 1.8.4 → 1.9.0

package/dist/src/ui/components/bubble-body-guard.js

@@ -0,0 +1,50 @@
+/**
+ * Render-time guard for council message bodies.
+ *
+ * Root cause it defends against (live-diagnosed 2026-07-08, run mrbj8v6w81a3):
+ * a single round-1 debate turn whose body contained a very long whitespace-free
+ * run (an import graph / path list / blob a Flash-tier model dumped over a
+ * 1286-file repo). `CouncilMessageBubble` hands the raw body to a single
+ * OpenTUI `<text>` node with NO length or line-length bound. OpenTUI's word-wrap
+ * on such a mega-line pegs the main thread at 100% CPU — and because render and
+ * the product-loop share one JS thread, the entire `/ideal` run hard-freezes
+ * (render + input + debate logic all starve). Every muonroi-owned text function
+ * on the path (`truncateCodeBlocks`, `renderMarkdown`, `parseInline`,
+ * `tokenize`) was benchmarked fast on 80–130KB adversarial input, so the block
+ * lives in the terminal's layout of an unbounded body.
+ *
+ * This function bounds BOTH failure axes before the body reaches `<text>`:
+ *   1. total length  — cap at `maxChars`, append a muted pointer to /export.
+ *   2. line length   — hard-break any whitespace-free run longer than the
+ *      terminal width so the wrapper always has a break opportunity (turns a
+ *      pathological O(n²) single-line wrap into linear per-segment wrapping).
+ *
+ * Pure + side-effect free — safe to unit-test without a terminal.
+ */
+/** Default ceiling on a rendered bubble body. Well above any real prose turn
+ * (~2–4KB) but far below the 100KB+ blobs that trigger the layout hang. */
+export const MAX_BUBBLE_BODY_CHARS = 12_000;
+/** Lower bound on the wrap column, so a bogus `terminalCols` (0/undefined on a
+ * detached harness) never produces a degenerate 1-char break cadence. */
+const MIN_WRAP_COLS = 20;
+export function capBubbleBody(text, terminalCols, maxChars = MAX_BUBBLE_BODY_CHARS) {
+    // 1) Total-length cap first — bounds the work the hard-wrap below has to do.
+    let body = text;
+    let truncated = false;
+    if (body.length > maxChars) {
+        body = body.slice(0, maxChars);
+        truncated = true;
+    }
+    // 2) Hard-break whitespace-free runs longer than the wrap column. The lookahead
+    //    `(?=\S)` avoids inserting a break right before an existing whitespace/EOL,
+    //    so normal prose (which breaks on spaces) is left untouched. Linear: each
+    //    char is visited once by the non-overlapping global match.
+    const cols = Math.max(MIN_WRAP_COLS, Number.isFinite(terminalCols) && terminalCols > 0 ? terminalCols : 80);
+    const runBreaker = new RegExp(`(\\S{${cols}})(?=\\S)`, "g");
+    body = body.replace(runBreaker, "$1\n");
+    if (truncated) {
+        body += "\n… truncated — see /export for the full turn";
+    }
+    return body;
+}
+//# sourceMappingURL=bubble-body-guard.js.map

package/dist/src/ui/components/compact-progress-card.d.ts

@@ -0,0 +1,24 @@
+/**
+ * src/ui/components/compact-progress-card.tsx
+ *
+ * Live progress for a /compact run. Before this, `/compact` awaited two LLM
+ * passes with zero UI — a minute of a frozen screen that reads as a hang.
+ *
+ * The percentage comes from the compaction pipeline itself
+ * (flow/compaction/progress.ts), not from a timer: it advances on real stage
+ * boundaries, and the dominant compress pass streams so it moves continuously.
+ * The elapsed clock is what proves liveness while a stage is mid-flight.
+ */
+import type { CompactProgress } from "../../flow/compaction/progress.js";
+import type { Theme } from "../theme.js";
+/** Elapsed as the status line shows it: "42s", "1m 19s". */
+export declare function fmtCompactElapsed(ms: number): string;
+/** Filled/unfilled bar of exactly `width` cells for a 0..100 percent. */
+export declare function compactBar(percent: number, width?: number): string;
+export interface CompactProgressCardProps {
+    progress: CompactProgress;
+    /** Epoch ms the run started. */
+    startedAt: number;
+    t: Theme;
+}
+export declare function CompactProgressCard({ progress, startedAt, t }: CompactProgressCardProps): import("react").ReactNode;

package/dist/src/ui/components/compact-progress-card.js

@@ -0,0 +1,42 @@
+import { jsx as _jsx, jsxs as _jsxs } from "@opentui/react/jsx-runtime";
+/**
+ * src/ui/components/compact-progress-card.tsx
+ *
+ * Live progress for a /compact run. Before this, `/compact` awaited two LLM
+ * passes with zero UI — a minute of a frozen screen that reads as a hang.
+ *
+ * The percentage comes from the compaction pipeline itself
+ * (flow/compaction/progress.ts), not from a timer: it advances on real stage
+ * boundaries, and the dominant compress pass streams so it moves continuously.
+ * The elapsed clock is what proves liveness while a stage is mid-flight.
+ */
+import { useEffect, useState } from "react";
+import { Region } from "../primitives/semantic-primitives.js";
+const BAR_WIDTH = 34;
+/** Elapsed as the status line shows it: "42s", "1m 19s". */
+export function fmtCompactElapsed(ms) {
+    const totalSec = Math.max(0, Math.floor(ms / 1000));
+    if (totalSec < 60)
+        return `${totalSec}s`;
+    return `${Math.floor(totalSec / 60)}m ${totalSec % 60}s`;
+}
+/** Filled/unfilled bar of exactly `width` cells for a 0..100 percent. */
+export function compactBar(percent, width = BAR_WIDTH) {
+    const clamped = Math.max(0, Math.min(100, Number.isFinite(percent) ? percent : 0));
+    const filled = Math.round((clamped / 100) * width);
+    return `${"█".repeat(filled)}${"░".repeat(Math.max(0, width - filled))}`;
+}
+export function CompactProgressCard({ progress, startedAt, t }) {
+    // The card owns its clock: a compaction can sit inside one LLM pass for a
+    // minute, and re-rendering the whole transcript once a second just to advance
+    // a timer is a cost the rest of the app should not pay.
+    const [now, setNow] = useState(() => Date.now());
+    useEffect(() => {
+        const id = setInterval(() => setNow(Date.now()), 1000);
+        return () => clearInterval(id);
+    }, []);
+    const elapsed = fmtCompactElapsed(now - startedAt);
+    const pct = Math.max(0, Math.min(100, Math.round(progress.percent)));
+    return (_jsx(Region, { id: "compact-progress", name: progress.label, value: `${pct}%`, state: progress.stage, props: { percent: pct, elapsedMs: now - startedAt }, children: _jsxs("box", { paddingLeft: 3, marginTop: 1, flexShrink: 0, flexDirection: "column", children: [_jsxs("text", { children: [_jsx("span", { style: { fg: t.accent }, children: "✦ " }), _jsx("span", { style: { fg: t.text }, children: progress.label }), _jsx("span", { style: { fg: t.textMuted }, children: `  (${elapsed})` })] }), _jsx("box", { paddingLeft: 2, children: _jsxs("text", { children: [_jsx("span", { style: { fg: t.accent }, children: compactBar(pct) }), _jsx("span", { style: { fg: t.textMuted }, children: `  ${pct}%` })] }) })] }) }));
+}
+//# sourceMappingURL=compact-progress-card.js.map

package/dist/src/ui/components/context-rail.d.ts

@@ -0,0 +1,26 @@
+import type { ReactNode } from "react";
+/** A single label/value row shown in the rail's metadata block. */
+export interface ContextRailRow {
+    label: string;
+    value: string;
+}
+export interface ContextRailProps {
+    /** Fixed column width of the rail (app.tsx decides based on terminal size). */
+    width: number;
+    /** Metadata rows (session id, mode, leader, panel, budget, …). */
+    rows: ContextRailRow[];
+    /**
+     * Rich content rendered below the metadata rows — info cards (Clarified Spec,
+     * Discussion Brief, Debate Plan), phase timeline, product-status. Wired by
+     * later phases; absent in the skeleton.
+     */
+    children?: ReactNode;
+}
+/**
+ * Right-hand context rail (MUONROI_CONTEXT_RAIL). Moves metadata-heavy chrome
+ * (session/leader/panel/budget + info cards) out of the scrolling transcript so
+ * the live debate stays on screen. Always renders the GLOBAL view — it never
+ * re-scopes to a selected round (that hides the overview and recreates the
+ * "empty rounds" problem). app.tsx gates visibility on width ≥ 100 and Ctrl+B.
+ */
+export declare function ContextRail({ width, rows, children }: ContextRailProps): ReactNode;

package/dist/src/ui/components/context-rail.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx, jsxs as _jsxs } from "@opentui/react/jsx-runtime";
+import { Semantic } from "@muonroi/agent-harness-opentui";
+import { dark } from "../theme.js";
+/**
+ * Right-hand context rail (MUONROI_CONTEXT_RAIL). Moves metadata-heavy chrome
+ * (session/leader/panel/budget + info cards) out of the scrolling transcript so
+ * the live debate stays on screen. Always renders the GLOBAL view — it never
+ * re-scopes to a selected round (that hides the overview and recreates the
+ * "empty rounds" problem). app.tsx gates visibility on width ≥ 100 and Ctrl+B.
+ */
+export function ContextRail({ width, rows, children }) {
+    return (_jsx(Semantic, { id: "context-rail", role: "region", name: "Context", 
+        // labels/values exposed for harness assertions (rail rows are plain <text>,
+        // not semantic nodes, so they don't otherwise show in the snapshot tree).
+        props: {
+            rowCount: rows.length,
+            labels: rows.map((r) => r.label).join(","),
+            values: rows.map((r) => r.value).join(" | "),
+        }, children: _jsxs("box", { flexShrink: 0, width: width, flexDirection: "column", border: ["left"], borderColor: dark.councilLeaderBorder, paddingLeft: 2, paddingRight: 1, gap: 1, children: [_jsx("text", { fg: dark.textMuted, attributes: 1, children: "Context" }), rows.length > 0 && (_jsx("box", { flexDirection: "column", flexShrink: 0, children: rows.map((r, idx) => (
+                    // Index key: list-style rows (e.g. per-criterion outcome lines) may
+                    // share an empty or duplicate label, which would collide on a
+                    // label-keyed map. An empty label renders value-only (no "· : ").
+                    //
+                    // Label + value MUST live in one <text> node (via an inline <span>),
+                    // not two sibling <text> in a flex-row: when a long value wraps, the
+                    // terminal trims the trailing separator of the preceding text node,
+                    // so "Topic: rest…" rendered as "Topicrest…" and "Progress: Round…"
+                    // lost its space. A single text flow keeps the "Label: " prefix.
+                    _jsx("box", { flexDirection: "column", children: _jsxs("text", { children: [r.label ? _jsx("span", { style: { fg: dark.textMuted }, children: `${r.label}: ` }) : null, r.value] }) }, idx))) })), children ? (
+                // biome-ignore lint/suspicious/noExplicitAny: OpenTUI stickyStart typing
+                _jsx("scrollbox", { flexGrow: 1, stickyScroll: false, stickyStart: "top", children: children })) : null] }) }));
+}
+//# sourceMappingURL=context-rail.js.map

package/dist/src/ui/components/council-conclusion-card.d.ts

@@ -0,0 +1,73 @@
+import type { Theme } from "../theme.js";
+/**
+ * Structured post-debate conclusion, parsed from the leader synthesis JSON.
+ *
+ * When a debate's deliverable is an evaluation/decision, the synthesizer emits a
+ * JSON object (summary + strengths/weaknesses/recommendation/coverage_matrix …).
+ * Rendered verbatim (the old CouncilSynthesisBanner path) it reads as an unbroken
+ * wall of JSON — "freetext khó nhìn". This card lifts the known sections into a
+ * scannable layout. When the text is NOT parseable structured JSON (e.g. the
+ * synthesizer emitted a `---READABLE---` prose tail), `parseConclusion` returns
+ * null and the caller falls back to plain-text rendering.
+ */
+export interface DimensionScore {
+    dimension: string;
+    score: number;
+    justification: string;
+}
+export interface OperationalRisk {
+    risk: string;
+    severity: string;
+    trigger: string;
+}
+export interface NextAction {
+    action: string;
+    label: string;
+    reason?: string;
+}
+export interface ParsedConclusion {
+    summary?: string;
+    recommendation?: string;
+    strengths: string[];
+    weaknesses: string[];
+    risks: string[];
+    tradeoffs: string[];
+    dimensionScores: DimensionScore[];
+    operationalRisks: OperationalRisk[];
+    priorityFixes: string[];
+    nextActions: NextAction[];
+    /** Generic rows: each row is a list of its string cell values, best-effort. */
+    coverage: string[][];
+    /** Leftover top-level keys (implementation_plan etc.) as generic titled sections. */
+    sections: Array<{
+        title: string;
+        items: string[];
+    }>;
+}
+/**
+ * Best-effort parse of possibly-truncated JSON. Providers cut synthesis output
+ * at maxTokens mid-array (live-verified 2026-07-06: `"nextActions":[…"action":"ask`),
+ * which made the whole conclusion fall back to a raw-JSON text wall.
+ *
+ * Single scan tracking string/escape state and the open-bracket stack. A "safe
+ * point" is the index AFTER a complete VALUE (string close, bracket close, or a
+ * number/true/false/null character). A closed string is only tentatively safe:
+ * if the next structural char is `:` it was a KEY, so we roll back to the
+ * previous safe point (otherwise the cut would produce a dangling `{"key"` —
+ * invalid JSON). The bracket stack is snapshotted at each safe point so the
+ * appended closers match the cut position, not the ragged end.
+ */
+export declare function salvageJson(body: string): Record<string, unknown> | null;
+/**
+ * Best-effort parse of a synthesis body into a structured conclusion. Returns
+ * null when the text is not a JSON object with at least one recognizable section
+ * — the caller then renders it as plain text.
+ */
+export declare function parseConclusion(text: string): ParsedConclusion | null;
+export interface CouncilConclusionCardProps {
+    conclusion: ParsedConclusion;
+    /** Round number for a per-round synthesis; undefined = final synthesis. */
+    round?: number;
+    theme: Theme;
+}
+export declare function CouncilConclusionCard({ conclusion, round, theme: t }: CouncilConclusionCardProps): import("react").ReactNode;