muonroi-cli 1.8.4 → 1.8.5

package/dist/src/tools/research.js

@@ -0,0 +1,233 @@
+/**
+ * src/tools/research.ts
+ *
+ * Native research tools for the inner agent.
+ *
+ * These replace the previous external MCP servers (fetch, tavily, and eventually
+ * context7 / muonroi-docs) so that web/docs lookup and search are:
+ * - Always available without spawn / warmup / "Connection closed"
+ * - Subject to the same permission, capping, redaction and cost rules as other builtins
+ * - Fast and reliable on first turn
+ *
+ * memory and playwright were removed from defaults (see auto-setup.ts).
+ * Full browser automation (playwright) can still be added manually if needed.
+ */
+import { dynamicTool, jsonSchema } from "ai";
+import TurndownService from "turndown";
+import { getMcpKey } from "../mcp/mcp-keychain.js";
+const turndown = new TurndownService({
+    headingStyle: "atx",
+    codeBlockStyle: "fenced",
+    bulletListMarker: "-",
+});
+// Basic cleanup for HTML before turndown (remove scripts, styles, etc.)
+function sanitizeForMarkdown(html) {
+    return html
+        .replace(/<script[\s\S]*?<\/script>/gi, "")
+        .replace(/<style[\s\S]*?<\/style>/gi, "")
+        .replace(/<noscript[\s\S]*?<\/noscript>/gi, "")
+        .replace(/<!--[\s\S]*?-->/g, "");
+}
+function extractTitle(html) {
+    const m = html.match(/<title[^>]*>([^<]+)<\/title>/i);
+    return m ? m[1].trim() : undefined;
+}
+export async function fetchUrl(url, opts = {}) {
+    const { format = "markdown", maxChars = 12000 } = opts;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 15000);
+    try {
+        const res = await fetch(url, {
+            signal: controller.signal,
+            headers: {
+                "User-Agent": "muonroi-cli/1.0 (+https://github.com/muonroi/muonroi-cli)",
+                Accept: "text/html,application/xhtml+xml,application/json,text/plain,*/*",
+            },
+            redirect: "follow",
+        });
+        if (!res.ok) {
+            return `ERROR fetch_failed: HTTP ${res.status} ${res.statusText} for ${url}`;
+        }
+        const contentType = res.headers.get("content-type") || "";
+        let body = await res.text();
+        if (format === "html") {
+            return body.length > maxChars ? body.slice(0, maxChars) + "\n... [truncated]" : body;
+        }
+        if (contentType.includes("application/json")) {
+            try {
+                const obj = JSON.parse(body);
+                body = JSON.stringify(obj, null, 2);
+            }
+            catch { }
+            return body.length > maxChars ? body.slice(0, maxChars) + "\n... [truncated]" : body;
+        }
+        // Treat as HTML or plain text
+        const isHtml = /<\/?[a-z][\s\S]*>/i.test(body) || contentType.includes("html");
+        if (format === "text") {
+            // Very lightweight text extraction
+            const text = isHtml
+                ? body
+                    .replace(/<[^>]+>/g, " ")
+                    .replace(/\s+/g, " ")
+                    .trim()
+                : body;
+            return text.length > maxChars ? text.slice(0, maxChars) + "\n... [truncated]" : text;
+        }
+        // markdown (default)
+        if (isHtml) {
+            const cleaned = sanitizeForMarkdown(body);
+            const title = extractTitle(body);
+            let md = turndown.turndown(cleaned);
+            if (title && !md.startsWith("# ")) {
+                md = `# ${title}\n\n${md}`;
+            }
+            if (md.length > maxChars) {
+                md = md.slice(0, maxChars) + "\n\n... [truncated — use more specific URL or smaller scope]";
+            }
+            // Add source
+            return `${md}\n\n_Source: ${url}_`;
+        }
+        // Plain text → code block or just return
+        const out = body.length > maxChars ? body.slice(0, maxChars) + "\n... [truncated]" : body;
+        return `\`\`\`\n${out}\n\`\`\`\n\n_Source: ${url}_`;
+    }
+    catch (err) {
+        if (err?.name === "AbortError") {
+            return `ERROR fetch_timeout: timed out after 15s fetching ${url}`;
+        }
+        return `ERROR fetch_error: ${err instanceof Error ? err.message : String(err)}`;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+export async function webSearch(query, opts = {}) {
+    const maxResults = Math.max(1, Math.min(opts.maxResults ?? 8, 20));
+    let key = opts.apiKey;
+    if (!key) {
+        key = (await getMcpKey("tavily")) || process.env.TAVILY_API_KEY || "";
+    }
+    if (!key || key.length < 10) {
+        return ("ERROR no_tavily_key: Tavily API key is required for web_search. " +
+            "Run `muonroi-cli mcp setup-research` or set TAVILY_API_KEY. " +
+            "You can also use `fetch_url` for direct URLs.");
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 12000);
+    try {
+        const res = await fetch("https://api.tavily.com/search", {
+            method: "POST",
+            signal: controller.signal,
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                api_key: key,
+                query,
+                max_results: maxResults,
+                include_answer: true,
+                include_raw_content: false,
+                search_depth: "basic",
+            }),
+        });
+        if (!res.ok) {
+            const text = await res.text().catch(() => "");
+            return `ERROR tavily_http_${res.status}: ${text.slice(0, 300)}`;
+        }
+        const data = await res.json();
+        const lines = [];
+        if (data.answer) {
+            lines.push("**Answer summary:**");
+            lines.push(data.answer);
+            lines.push("");
+        }
+        const results = Array.isArray(data.results) ? data.results : [];
+        if (results.length === 0) {
+            return "No web results found.";
+        }
+        lines.push(`**Web results** (top ${Math.min(results.length, maxResults)}):\n`);
+        for (const r of results.slice(0, maxResults)) {
+            const title = r.title || r.url;
+            const url = r.url;
+            const content = (r.content || r.raw_content || "").trim().slice(0, 600);
+            lines.push(`- **${title}**`);
+            lines.push(`  ${url}`);
+            if (content)
+                lines.push(`  ${content.replace(/\s+/g, " ")}`);
+            lines.push("");
+        }
+        if (data.query) {
+            lines.push(`_Query: ${data.query}_`);
+        }
+        return lines.join("\n");
+    }
+    catch (err) {
+        if (err?.name === "AbortError") {
+            return "ERROR web_search_timeout: Tavily request timed out.";
+        }
+        return `ERROR web_search_failed: ${err instanceof Error ? err.message : String(err)}`;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+/** Register the native research tools into the provided ToolSet. */
+export function registerNativeResearchTools(tools) {
+    tools.fetch_url = dynamicTool({
+        description: "Fetch a URL and return clean, readable content as markdown (default), plain text, or raw HTML. " +
+            "Ideal for documentation, articles, GitHub, blog posts, raw files, and any public web page. " +
+            "Use this for most 'read this URL' needs instead of external MCP fetch.",
+        inputSchema: jsonSchema({
+            type: "object",
+            properties: {
+                url: { type: "string", description: "The full http(s) URL to fetch" },
+                format: {
+                    type: "string",
+                    enum: ["markdown", "text", "html"],
+                    description: "Output format. Default: markdown (best for agents)",
+                },
+                maxChars: {
+                    type: "number",
+                    description: "Maximum characters to return (500-30000). Default ~12000.",
+                },
+            },
+            required: ["url"],
+            additionalProperties: false,
+        }),
+        execute: async (input) => {
+            const url = String(input?.url || "").trim();
+            if (!url || !/^https?:\/\//i.test(url)) {
+                return "ERROR invalid_url: fetch_url requires a full http(s):// URL";
+            }
+            const format = (["markdown", "text", "html"].includes(input?.format) ? input.format : "markdown");
+            const maxChars = typeof input?.maxChars === "number" ? input.maxChars : undefined;
+            return fetchUrl(url, { format, maxChars });
+        },
+    });
+    tools.web_search = dynamicTool({
+        description: "Search the live web using Tavily (LLM-optimized search with summaries). " +
+            "Returns titles, URLs, and content snippets. Requires a Tavily API key (free tier available). " +
+            "Use together with fetch_url when you need deeper content from specific results.",
+        inputSchema: jsonSchema({
+            type: "object",
+            properties: {
+                query: { type: "string", description: "Search query (natural language is fine)" },
+                maxResults: {
+                    type: "number",
+                    description: "How many results to return (1-20). Default 8.",
+                },
+            },
+            required: ["query"],
+            additionalProperties: false,
+        }),
+        execute: async (input) => {
+            const query = String(input?.query || "").trim();
+            if (!query)
+                return "ERROR invalid_query: web_search requires a non-empty query";
+            const maxResults = typeof input?.maxResults === "number" ? input.maxResults : undefined;
+            return webSearch(query, { maxResults });
+        },
+    });
+    return tools;
+}
+//# sourceMappingURL=research.js.map

package/dist/src/types/index.d.ts

@@ -34,6 +34,8 @@ export interface TaskRequest {
     description: string;
     prompt: string;
     maxToolRounds?: number;
+    /** When set, bypasses parent-tier cap and uses this model for the sub-agent. */
+    modelId?: string;
 }
 export interface TaskRun {
     agent: string;
@@ -246,7 +248,7 @@ export interface CouncilQuestionData {
     options?: CouncilQuestionOption[];
     defaultIndex?: number;
 }
-export type CouncilStatusPhase = "clarify" | "plan_debate" | "research" | "opening" | "exchange" | "evaluate" | "synthesis" | "summary";
+export type CouncilStatusPhase = "clarify" | "panel_select" | "plan_debate" | "research" | "opening" | "exchange" | "evaluate" | "synthesis" | "summary";
 export type CouncilStatusState = "start" | "tick" | "done" | "error";
 export interface CouncilStatusData {
     statusId: string;
@@ -256,12 +258,14 @@ export interface CouncilStatusData {
     detail?: string;
     role?: string;
     elapsedMs?: number;
+    /** Client-side first-seen stamp (upsertStatus), back-dated by the emitted elapsedMs. Drives live-ticking elapsed. */
+    startedAt?: number;
     tokensIn?: number;
     tokensOut?: number;
     errorMessage?: string;
 }
 /** High-level lifecycle event for a council phase. Drives the phase timeline UI. */
-export type CouncilPhaseKind = "clarification" | "clarification_round" | "preflight" | "debate_plan" | "research" | "opening" | "round" | "evaluation" | "mid_research" | "summary" | "synthesis" | "action_plan"
+export type CouncilPhaseKind = "clarification" | "clarification_round" | "preflight" | "debate_plan" | "research" | "opening" | "round" | "evaluation" | "mid_research" | "grounding_verify" | "summary" | "synthesis" | "action_plan"
 /**
  * Sprint stage emitted by sprint-runner — one of planning/implementation/
  * verification/judgment. label distinguishes the stage. Used so the user
@@ -333,6 +337,84 @@ export interface CouncilInfoCard {
     title: string;
     sections: CouncilInfoCardSection[];
 }
+/**
+ * Incremental council metadata for the context rail (P3). Emitted as one or more
+ * `council_meta` chunks — the leader/panel/researchMode/costAware fields come
+ * from the council entrypoint, the round budget/ceiling from inside runDebate
+ * (locals invisible to the entrypoint). The UI upsert-merges each patch into a
+ * single `councilMeta` object, so any subset of fields may be present.
+ */
+/**
+ * One debate round's lifecycle record for the round-grouped transcript (P5/P6).
+ * Emitted as `council_round` chunks: a `running` record at round start, then a
+ * `done` record (guaranteed on every loop exit) carrying the outcome. The UI
+ * upsert-merges by `round` (running → done overwrite).
+ */
+export interface CouncilRoundRecord {
+    round: number;
+    state: "running" | "done";
+    /** This round's focus, carried from the prior round's `nextRoundFocus`. */
+    topic?: string;
+    /** Role labels of the participants active this round. */
+    participants: string[];
+    /** Number of debate pairs exchanged this round. */
+    pairCount: number;
+    /** True when this round is beyond the leader's original planned budget. */
+    emergent: boolean;
+    /** Leader-evaluated criteria met / total (absent until the round is done). */
+    criteriaMet?: number;
+    criteriaTotal?: number;
+    /** Leader's one-sentence decision reason. */
+    leaderReason?: string;
+    /** What the leader / engine decided at the end of this round. */
+    leaderDecision?: "continue" | "stop" | "extend" | "aborted" | "circuit-break" | "eval-unavailable";
+    /** Topic the leader set for the NEXT round (drives the overview). */
+    nextRoundFocus?: string;
+    /**
+     * B5 — the leader's pre-round DIRECTIVE for this round (goal + criteria still
+     * unmet going in). Captured on the round record so it survives into the
+     * post-debate conclusion card, not only the ephemeral live directive bubble —
+     * otherwise a user who looks away during the debate never sees the leader
+     * conduct the round. Present only when the conductor is on + criteria pinned.
+     */
+    directive?: string;
+}
+/**
+ * Incremental council metadata for the context rail (P3). Emitted as one or more
+ * `council_meta` chunks — the leader/panel/researchMode/costAware fields come
+ * from the council entrypoint, the round budget/ceiling from inside runDebate
+ * (locals invisible to the entrypoint). The UI upsert-merges each patch into a
+ * single `councilMeta` object, so any subset of fields may be present.
+ */
+export interface CouncilMetaPatch {
+    /** The debate topic / question under discussion (shown at the top of the rail). */
+    topic?: string;
+    /** Leader model id driving the debate. */
+    leader?: string;
+    /** Panel member role labels. */
+    panel?: string[];
+    /** Planned round budget resolved for this debate. */
+    roundBudget?: number;
+    /** Hard ceiling rounds may extend to (emergent rounds). */
+    roundCeiling?: number;
+    /** Research mode enabled for this debate. */
+    researchMode?: boolean;
+    /** Cost-aware budgeting active. */
+    costAware?: boolean;
+    /**
+     * The pinned outcome criteria the debate is graded against (the user-owned
+     * `ClarifiedSpec.successCriteria`). Emitted once after clarify so the rail can
+     * show the OUTCOME the debate is chasing — fixes "criteria met là gì tôi không
+     * biết". Stable for the whole debate.
+     */
+    successCriteria?: string[];
+    /**
+     * Per-criterion met status, index-aligned to `successCriteria`. Upsert-merged
+     * and refreshed after each round's leader evaluation so the rail shows live
+     * ✓/○ against the pinned criteria. Length matches `successCriteria`.
+     */
+    criteriaMet?: boolean[];
+}
 export interface CouncilMessage {
     kind: CouncilMessageKind;
     speaker: {
@@ -343,6 +425,7 @@ export interface CouncilMessage {
         role: string;
     };
     round?: number;
+    phase?: "directive" | "verdict";
     text: string;
     toolCalls?: {
         name: string;
@@ -352,7 +435,7 @@ export interface CouncilMessage {
     runId?: string;
 }
 export interface StreamChunk {
-    type: "content" | "tool_calls" | "tool_result" | "tool_approval_request" | "council_question" | "council_preflight" | "council_status" | "council_phase" | "council_message" | "council_info_card" | "done" | "error" | "reasoning" | "structured_response" | "product_status_card" | "experience_warning" | "experience_injected" | "push_notification" | "halt" | "task_list_update";
+    type: "content" | "tool_calls" | "tool_result" | "tool_approval_request" | "council_question" | "council_preflight" | "council_status" | "council_phase" | "council_message" | "council_info_card" | "council_meta" | "council_round" | "done" | "error" | "reasoning" | "structured_response" | "product_status_card" | "experience_warning" | "experience_injected" | "push_notification" | "halt" | "toast" | "task_list_update";
     content?: string;
     toolCalls?: ToolCall[];
     toolCall?: ToolCall;
@@ -367,12 +450,21 @@ export interface StreamChunk {
     councilPhase?: CouncilPhaseEvent;
     councilMessage?: CouncilMessage;
     councilInfoCard?: CouncilInfoCard;
+    councilMeta?: CouncilMetaPatch;
+    councilRound?: CouncilRoundRecord;
     productStatusCard?: import("../product-loop/types.js").ProductStatusCardData;
     /** Populated when type === "halt". Contains structured recovery options. */
     haltChunk?: import("../product-loop/types.js").HaltChunk;
     experienceWarning?: ExperienceWarningData;
     experienceInjected?: ExperienceInjectedData;
     taskListSnapshot?: TaskListSnapshot;
+    /**
+     * Populated when type === "toast". A transient, ephemeral notice (e.g.
+     * "initializing sub-session…") that the UI shows briefly then auto-dismisses
+     * — it is NOT appended to the persisted assistant message. `content` holds
+     * the text; `toastLevel` selects the style (defaults to "info").
+     */
+    toastLevel?: "info" | "warn" | "error";
 }
 export type TaskListItemStatus = "pending" | "in_progress" | "completed";
 export interface TaskListItem {
@@ -413,13 +505,28 @@ export interface ModelInfo {
     multiAgent?: boolean;
     supportsClientTools?: boolean;
     supportsMaxOutputTokens?: boolean;
+    /**
+     * When set, the provider rejects any temperature other than this exact value
+     * (e.g. Moonshot/Kimi: "only 1 is allowed for this model"). Callers must send
+     * this value verbatim rather than their preferred temperature — see
+     * `resolveTemperature` in src/providers/capabilities.ts.
+     */
+    fixedTemperature?: number;
     defaultReasoningEffort?: ReasoningEffort;
     supportsReasoningEffort?: boolean;
     thinkingType?: "enabled" | "adaptive";
     supportsVision?: boolean;
+    /** When false, excluded from getModelByTier / automatic compaction routing. Default: routable. */
+    tierRouting?: boolean;
+    /** Extra tiers this model may satisfy in getModelByTier (primary tier remains `tier`). */
+    routingTiers?: ModelTier[];
+    roles?: string[];
+    /** Part E — model has native online web research (its own web_search/browsing). */
+    nativeWebResearch?: boolean;
 }
 export type AgentMode = "agent" | "plan" | "ask";
 export type SessionStatus = "active" | "completed" | "archived" | "abandoned";
+export type SessionKind = "conversation" | "rotation" | "subagent";
 export type UsageSource = "message" | "title" | "task" | "delegation" | "council" | "other";
 export interface WorkspaceInfo {
     id: string;
@@ -441,6 +548,14 @@ export interface SessionInfo {
     createdAt: Date;
     updatedAt: Date;
 }
+/**
+ * One row in the `/sessions` resume picker: a whole conversation tree collapsed
+ * to a single entry. `id`/`title`/`createdAt` describe the tree root; `resumeId`
+ * is the latest leaf to relaunch; `model`/`updatedAt`/`status` describe that leaf.
+ */
+export interface ResumeEntry extends SessionInfo {
+    resumeId: string;
+}
 export interface UsageEvent {
     id: number;
     sessionId: string;

package/dist/src/ui/cards/product-status-card.js

@@ -49,7 +49,7 @@ export function ProductStatusCard({ data, theme: t }) {
     const costSpark = data.costHistory?.length
         ? sparkline(data.costHistory.map((h) => (data.costCap > 0 ? h.cumulativeUsd / data.costCap : 0)))
         : "";
-    return (_jsx(Semantic, { id: "ideal-status", role: "region", name: "Ideal status", children: _jsxs("box", { flexDirection: "column", paddingLeft: 2, paddingTop: 0, flexShrink: 0, children: [_jsx("box", { children: _jsx("text", { fg: t.accent, children: `▶ Product Loop · ${data.currentStage}` }) }), _jsx(Semantic, { id: `ideal-phase-sprint`, role: "listitem", name: "Sprint", children: _jsxs("box", { children: [_jsx("text", { fg: t.textMuted, children: "Sprint:   " }), _jsx("text", { fg: t.text, children: `${data.sprintN}/${data.totalSprints} ` }), _jsx("text", { fg: t.accent, children: bar(sprintPct) }), _jsx("text", { fg: t.textDim, children: ` ${sprintPct.toFixed(0)}%` })] }) }), _jsx(Semantic, { id: `ideal-phase-cost`, role: "listitem", name: "Cost", children: _jsxs("box", { children: [_jsx("text", { fg: t.textMuted, children: "Cost:     " }), _jsx("text", { fg: t.text, children: `$${data.costSpent.toFixed(2)}/$${data.costCap.toFixed(2)} ` }), _jsx("text", { fg: costColor, children: bar(costPct) }), _jsx("text", { fg: t.textDim, children: ` ${costPct.toFixed(0)}%` })] }) }), costSpark && (_jsxs("box", { children: [_jsx("text", { fg: t.textMuted, children: "Burn:     " }), _jsx("text", { fg: costColor, children: costSpark }), _jsx("text", { fg: t.textDim, children: ` (per-sprint)` })] })), _jsx(Semantic, { id: `ideal-phase-criteria`, role: "listitem", name: "Criteria", children: _jsxs("box", { children: [_jsx("text", { fg: t.textMuted, children: "Criteria: " }), _jsx("text", { fg: t.planOptionCheck, children: `✓ ${data.criteriaMet}` }), _jsx("text", { fg: t.text, children: "  " }), _jsx("text", { fg: t.accent, children: `◐ ${data.criteriaPartial}` }), _jsx("text", { fg: t.text, children: "  " }), _jsx("text", { fg: t.diffRemovedFg, children: `✗ ${data.criteriaUnmet}` }), _jsx("text", { fg: t.textDim, children: `  (of ${totalCriteria})` })] }) }), criteriaSpark && (_jsxs("box", { children: [_jsx("text", { fg: t.textMuted, children: "Trend:    " }), _jsx("text", { fg: t.planOptionCheck, children: criteriaSpark }), _jsx("text", { fg: t.textDim, children: ` met-ratio per sprint` })] }))] }) }));
+    return (_jsx(Semantic, { id: "ideal-status", role: "region", name: "Ideal status", children: _jsxs("box", { flexDirection: "column", paddingLeft: 2, paddingTop: 0, flexShrink: 0, children: [_jsx("box", { children: _jsx("text", { fg: t.accent, children: `▶ Product Loop · ${data.currentStage}` }) }), _jsx(Semantic, { id: `ideal-phase-sprint`, role: "listitem", name: "Sprint", children: _jsxs("box", { children: [_jsx("text", { fg: t.textMuted, children: "Sprint:   " }), _jsx("text", { fg: t.text, children: `${data.sprintN}/${data.totalSprints} ` }), _jsx("text", { fg: t.accent, children: bar(sprintPct) }), _jsx("text", { fg: t.textDim, children: ` ${sprintPct.toFixed(0)}%` })] }) }), _jsx(Semantic, { id: `ideal-phase-cost`, role: "listitem", name: "Cost", children: _jsxs("box", { children: [_jsx("text", { fg: t.textMuted, children: "Cost:     " }), _jsx("text", { fg: t.text, children: `$${data.costSpent.toFixed(2)}/$${data.costCap.toFixed(2)} ` }), _jsx("text", { fg: costColor, children: bar(costPct) }), _jsx("text", { fg: t.textDim, children: ` ${costPct.toFixed(0)}%` })] }) }), costSpark && (_jsxs("box", { children: [_jsx("text", { fg: t.textMuted, children: "Burn:     " }), _jsx("text", { fg: costColor, children: costSpark }), _jsx("text", { fg: t.textDim, children: ` spend per sprint` })] })), _jsx(Semantic, { id: `ideal-phase-criteria`, role: "listitem", name: "Criteria", children: _jsxs("box", { children: [_jsx("text", { fg: t.textMuted, children: "Criteria: " }), _jsx("text", { fg: t.planOptionCheck, children: `✓ ${data.criteriaMet}` }), _jsx("text", { fg: t.text, children: "  " }), _jsx("text", { fg: t.accent, children: `◐ ${data.criteriaPartial}` }), _jsx("text", { fg: t.text, children: "  " }), _jsx("text", { fg: t.diffRemovedFg, children: `✗ ${data.criteriaUnmet}` }), _jsx("text", { fg: t.textDim, children: `  (of ${totalCriteria})` })] }) }), criteriaSpark && (_jsxs("box", { children: [_jsx("text", { fg: t.textMuted, children: "Trend:    " }), _jsx("text", { fg: t.planOptionCheck, children: criteriaSpark }), _jsx("text", { fg: t.textDim, children: ` criteria met per sprint` })] }))] }) }));
 }
 export default ProductStatusCard;
 //# sourceMappingURL=product-status-card.js.map

package/dist/src/ui/components/bubble-body-guard.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 declare const MAX_BUBBLE_BODY_CHARS = 12000;
+export declare function capBubbleBody(text: string, terminalCols: number, maxChars?: number): string;

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/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