muonroi-cli 1.8.4 → 1.9.0

package/dist/src/tools/research.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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 { type ToolSet } from "ai";
+export interface FetchUrlOptions {
+    format?: "markdown" | "text" | "html";
+    /** Max characters to return (soft cap) */
+    maxChars?: number;
+}
+export declare function fetchUrl(url: string, opts?: FetchUrlOptions): Promise<string>;
+export interface WebSearchOptions {
+    maxResults?: number;
+    /** Optional override; otherwise loaded from keychain or TAVILY_API_KEY */
+    apiKey?: string;
+}
+export declare function webSearch(query: string, opts?: WebSearchOptions): Promise<string>;
+/** Register the native research tools into the provided ToolSet. */
+export declare function registerNativeResearchTools(tools: ToolSet): ToolSet;

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;
@@ -192,6 +194,13 @@ export interface ToolGroup {
     items: ToolGroupItem[];
     startedAt: number;
     finishedAt?: number;
+    /**
+     * True when this group was rebuilt from a persisted transcript rather than
+     * observed live (see ui/utils/group-tool-entries.ts). Its timestamps come
+     * from entry write-time, so the elapsed span is NOT a real measurement and
+     * must not be displayed as one.
+     */
+    restored?: boolean;
     inputTokens?: number;
     outputTokens?: number;
 }
@@ -223,7 +232,7 @@ export interface StructuredResponse {
     taskType: string;
     data: Record<string, unknown>;
 }
-export type CouncilQuestionPhase = "clarify" | "preflight" | "plan-confirm" | "post-debate" | "pil-interview" | "pil-acceptance" | "tool-loop-cap" | "safety-override";
+export type CouncilQuestionPhase = "clarify" | "preflight" | "plan-confirm" | "post-debate" | "pil-interview" | "pil-acceptance" | "tool-loop-cap" | "safety-override" | "ask-user";
 export type CouncilOptionKind = "choice" | "freetext" | "chat";
 export interface CouncilQuestionOption {
     label: string;
@@ -246,7 +255,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 +265,25 @@ 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;
+    /**
+     * Push-based stream liveness (additive, optional). `elapsedMs` alone cannot
+     * prove a council call is alive: the tick generator only advances when the
+     * CONSUMER pulls, so a round awaiting its pairs via Promise.all freezes it.
+     * These two come from the token stream itself — `streamedChars` counts text +
+     * reasoning deltas since the phase began, and `lastDeltaAgeMs` is the age of
+     * the most recent delta. Growing chars / small age = SLOW BUT ALIVE; static
+     * chars + growing age = genuinely STUCK.
+     */
+    streamedChars?: number;
+    lastDeltaAgeMs?: 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 +355,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 +443,7 @@ export interface CouncilMessage {
         role: string;
     };
     round?: number;
+    phase?: "directive" | "verdict";
     text: string;
     toolCalls?: {
         name: string;
@@ -350,9 +451,19 @@ export interface CouncilMessage {
     attempts?: number;
     failureReason?: string;
     runId?: string;
+    /**
+     * Wall-clock of THIS speaker's LLM call, including retries.
+     *
+     * Without it the only timed council rows are `debate_complete` (the whole
+     * debate, measured at 87s..1128s) and `council_summary` — aggregates that
+     * cannot say WHICH model burned the time, so every latency diagnosis is
+     * guesswork. Persisted to `interaction_logs.duration_ms` alongside the
+     * `speakerModel` this row already carries, making the bottleneck queryable.
+     */
+    durationMs?: number;
 }
 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 +478,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 +533,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 +576,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/agent-rail-activities.d.ts

@@ -0,0 +1,26 @@
+/**
+ * src/ui/components/agent-rail-activities.tsx
+ *
+ * Rail block listing every sub-agent / background job this session spawned.
+ *
+ * Before this, a spawned agent was visible only as a transient line in the
+ * transcript: it scrolled away, and once done there was nowhere to see WHAT it
+ * was asked or what it returned. The rail keeps the roster on screen, and a row
+ * opens to show the prompt and the result.
+ *
+ * Selection is by click (OpenTUI onMouseDown per row, same as
+ * council-rail-rounds.tsx) — clicking the open row closes it again.
+ */
+import type { AgentActivity } from "../utils/agent-activities.js";
+import type { Theme } from "../theme.js";
+/** Row prefix naming what was spawned: the agent type, or "shell" for a job. */
+export declare function activityPrefix(a: AgentActivity): string;
+export interface AgentRailActivitiesProps {
+    activities: AgentActivity[];
+    /** Tool-call id of the open row, or null when all are collapsed. */
+    selected: string | null;
+    onSelect: (id: string | null) => void;
+    width: number;
+    t: Theme;
+}
+export declare function AgentRailActivities({ activities, selected, onSelect, width, t }: AgentRailActivitiesProps): import("react").ReactNode;

package/dist/src/ui/components/agent-rail-activities.js

@@ -0,0 +1,47 @@
+import { jsx as _jsx, jsxs as _jsxs } from "@opentui/react/jsx-runtime";
+/**
+ * src/ui/components/agent-rail-activities.tsx
+ *
+ * Rail block listing every sub-agent / background job this session spawned.
+ *
+ * Before this, a spawned agent was visible only as a transient line in the
+ * transcript: it scrolled away, and once done there was nowhere to see WHAT it
+ * was asked or what it returned. The rail keeps the roster on screen, and a row
+ * opens to show the prompt and the result.
+ *
+ * Selection is by click (OpenTUI onMouseDown per row, same as
+ * council-rail-rounds.tsx) — clicking the open row closes it again.
+ */
+import { ListItem, Region } from "../primitives/semantic-primitives.js";
+import { trunc } from "../utils/text.js";
+/** Characters of detail shown when a row is open. Keeps the rail scrollable. */
+const DETAIL_LIMIT = 600;
+const GLYPH = { running: "▸", done: "✓", failed: "✗" };
+function statusColor(status, t) {
+    if (status === "failed")
+        return t.diffRemovedFg;
+    if (status === "done")
+        return t.diffAddedFg;
+    return t.accent;
+}
+/** Row prefix naming what was spawned: the agent type, or "shell" for a job. */
+export function activityPrefix(a) {
+    if (a.kind === "background")
+        return "shell";
+    return a.agent || (a.kind === "delegate" ? "delegate" : "sub-agent");
+}
+export function AgentRailActivities({ activities, selected, onSelect, width, t }) {
+    if (activities.length === 0)
+        return null;
+    const running = activities.filter((a) => a.status === "running").length;
+    return (_jsx(Region, { id: "agent-rail-activities", name: "Agents", value: `${activities.length}`, props: {
+            count: activities.length,
+            running,
+            selected: selected ?? "",
+            ids: activities.map((a) => a.id).join(","),
+        }, children: _jsxs("box", { flexDirection: "column", flexShrink: 0, children: [_jsx("text", { fg: t.textMuted, attributes: 1, children: running > 0 ? `Agents (${running} running)` : "Agents" }), activities.map((a) => {
+                    const isOpen = selected === a.id;
+                    return (_jsx(ListItem, { id: `rail-agent-${a.id}`, name: `${activityPrefix(a)} ${a.label}`, state: a.status, selected: isOpen || undefined, children: _jsxs("box", { flexDirection: "column", flexShrink: 0, children: [_jsx("box", { flexDirection: "row", onMouseDown: () => onSelect(isOpen ? null : a.id), children: _jsxs("text", { children: [_jsx("span", { style: { fg: statusColor(a.status, t) }, children: `${GLYPH[a.status]} ` }), _jsx("span", { style: { fg: t.textMuted }, children: `${activityPrefix(a)}  ` }), _jsx("span", { style: { fg: t.text }, children: trunc(a.label, Math.max(8, width - 12)) })] }) }), isOpen && (_jsx("box", { paddingLeft: 2, flexDirection: "column", children: _jsx("text", { fg: t.textDim, children: a.detail.trim() ? trunc(a.detail, DETAIL_LIMIT) : "(no output yet)" }) }))] }) }, a.id));
+                })] }) }));
+}
+//# sourceMappingURL=agent-rail-activities.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;