muonroi-cli 1.8.4 → 1.8.5

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;

package/dist/src/ui/components/council-conclusion-card.js

@@ -0,0 +1,420 @@
+import { jsx as _jsx, jsxs as _jsxs } from "@opentui/react/jsx-runtime";
+function asStringArray(v) {
+    if (!Array.isArray(v))
+        return [];
+    return v.filter((x) => typeof x === "string" && x.trim().length > 0).map((x) => x.trim());
+}
+function firstString(obj, keys) {
+    for (const k of keys) {
+        const val = obj[k];
+        if (typeof val === "string" && val.trim().length > 0)
+            return val.trim();
+    }
+    return undefined;
+}
+function firstArray(obj, keys) {
+    for (const k of keys) {
+        const arr = asStringArray(obj[k]);
+        if (arr.length > 0)
+            return arr;
+    }
+    return [];
+}
+function coverageRows(obj) {
+    for (const k of ["coverage_matrix", "coverage", "criteria", "coverageMatrix"]) {
+        const raw = obj[k];
+        if (!Array.isArray(raw))
+            continue;
+        const rows = [];
+        for (const item of raw) {
+            if (item && typeof item === "object") {
+                const cells = Object.values(item)
+                    .filter((c) => typeof c === "string" && c.trim().length > 0)
+                    .map((c) => c.trim());
+                if (cells.length > 0)
+                    rows.push(cells);
+            }
+            else if (typeof item === "string" && item.trim().length > 0) {
+                rows.push([item.trim()]);
+            }
+        }
+        if (rows.length > 0)
+            return rows;
+    }
+    return [];
+}
+function parseDimensionScores(obj) {
+    const raw = obj.dimension_scores ?? obj.dimensionScores ?? obj.scores;
+    if (!Array.isArray(raw))
+        return [];
+    const out = [];
+    for (const item of raw) {
+        if (!item || typeof item !== "object")
+            continue;
+        const row = item;
+        const dimension = String(row.dimension ?? row.name ?? row.criteria ?? "").trim();
+        const scoreRaw = row.score ?? row.rating ?? row.value;
+        const score = typeof scoreRaw === "number" ? scoreRaw : Number.parseInt(String(scoreRaw), 10);
+        const justification = String(row.justification ?? row.reason ?? row.note ?? "").trim();
+        if (dimension && Number.isFinite(score)) {
+            out.push({ dimension, score, justification: justification || "(no justification)" });
+        }
+    }
+    return out;
+}
+function parseOperationalRisks(obj) {
+    const raw = obj.operational_risks ?? obj.operationalRisks ?? obj.risks;
+    if (!Array.isArray(raw))
+        return [];
+    const out = [];
+    for (const item of raw) {
+        if (!item || typeof item !== "object")
+            continue;
+        const row = item;
+        const risk = String(row.risk ?? row.name ?? row.title ?? "").trim();
+        const severity = String(row.severity ?? row.level ?? row.impact ?? "").trim();
+        const trigger = String(row.trigger ?? row.when ?? row.condition ?? "").trim();
+        if (risk) {
+            out.push({ risk, severity: severity || "Unknown", trigger: trigger || "(not specified)" });
+        }
+    }
+    return out;
+}
+function parsePriorityFixes(obj) {
+    const raw = obj.priority_fixes ?? obj.priorityFixes ?? obj.fixes ?? obj.action_items;
+    if (Array.isArray(raw)) {
+        const strings = asStringArray(raw);
+        if (strings.length > 0)
+            return strings;
+        const flat = [];
+        for (const item of raw) {
+            if (item && typeof item === "object") {
+                const cells = Object.entries(item)
+                    .filter(([, cv]) => cv !== null && cv !== undefined && typeof cv !== "object")
+                    .map(([ck, cv]) => `${ck}: ${String(cv)}`);
+                if (cells.length > 0)
+                    flat.push(cells.join(" · "));
+            }
+        }
+        if (flat.length > 0)
+            return flat;
+    }
+    return [];
+}
+function parseNextActions(obj) {
+    const raw = obj.nextActions ?? obj.next_actions ?? obj.actions;
+    if (!Array.isArray(raw))
+        return [];
+    const out = [];
+    for (const item of raw) {
+        if (!item || typeof item !== "object")
+            continue;
+        const row = item;
+        const action = String(row.action ?? row.id ?? row.key ?? "").trim();
+        const label = String(row.label ?? row.title ?? row.summary ?? action).trim();
+        const reason = String(row.reason ?? row.why ?? row.explanation ?? "").trim();
+        if (label) {
+            out.push({ action: action || label, label, reason: reason || undefined });
+        }
+    }
+    return out;
+}
+/**
+ * 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 function salvageJson(body) {
+    try {
+        const direct = JSON.parse(body);
+        return direct && typeof direct === "object" && !Array.isArray(direct) ? direct : null;
+    }
+    catch {
+        // fall through to salvage — expected branch for truncated output
+    }
+    const stack = [];
+    let inString = false;
+    let escaped = false;
+    let lastSafe = -1;
+    let stackAtSafe = [];
+    let prevSafe = -1;
+    let stackAtPrevSafe = [];
+    let lastStringEnd = -1; // safe point created by the most recent string close
+    const markSafe = (endExclusive) => {
+        if (endExclusive === lastSafe)
+            return;
+        prevSafe = lastSafe;
+        stackAtPrevSafe = stackAtSafe;
+        lastSafe = endExclusive;
+        stackAtSafe = stack.slice();
+    };
+    for (let i = 0; i < body.length; i++) {
+        const ch = body[i];
+        if (inString) {
+            if (escaped)
+                escaped = false;
+            else if (ch === "\\")
+                escaped = true;
+            else if (ch === '"') {
+                inString = false;
+                markSafe(i + 1);
+                lastStringEnd = i + 1;
+            }
+            continue;
+        }
+        if (ch === '"')
+            inString = true;
+        else if (ch === "{" || ch === "[")
+            stack.push(ch === "{" ? "}" : "]");
+        else if (ch === "}" || ch === "]") {
+            stack.pop();
+            markSafe(i + 1);
+        }
+        else if (ch === ":") {
+            // The string that just closed was a key, not a value — retract it.
+            if (lastSafe === lastStringEnd && prevSafe !== -1) {
+                lastSafe = prevSafe;
+                stackAtSafe = stackAtPrevSafe;
+            }
+        }
+        else if (/[0-9el]/.test(ch)) {
+            // Number / true / false / null terminal characters (outside strings,
+            // JSON only allows literals here) — cheap approximation of a value end.
+            markSafe(i + 1);
+        }
+    }
+    if (lastSafe <= 0)
+        return null;
+    const prefix = body.slice(0, lastSafe).replace(/,\s*$/, "") + stackAtSafe.reverse().join("");
+    try {
+        const parsed = JSON.parse(prefix);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        // salvage failed — caller renders plain text; expected for hopeless input
+        return null;
+    }
+}
+/** "agreed_architecture" → "Agreed Architecture"; "actionItems" → "Action Items". */
+function titleCase(key) {
+    return key
+        .replace(/([a-z])([A-Z])/g, "$1 $2")
+        .replace(/[_-]+/g, " ")
+        .trim()
+        .replace(/\b\w/g, (c) => c.toUpperCase());
+}
+/** Keys never worth a generic section: routing/meta fields. */
+const NOISE_KEYS = new Set([
+    "type",
+    "nextActions",
+    "next_actions",
+    "sections",
+    "kind",
+    "dimension_scores",
+    "dimensionScores",
+    "dimensions",
+    "operational_risks",
+    "operationalRisks",
+    "risk_matrix",
+    "priority_fixes",
+    "priorityFixes",
+    "fixes",
+    "action_items",
+]);
+/** Color a numeric score (1-5) by quality tier. */
+function scoreColor(score, theme) {
+    if (score <= 2)
+        return theme.diffRemovedFg;
+    if (score === 3)
+        return theme.mdItalic;
+    return theme.diffAddedFg;
+}
+function severityColor(severity, theme) {
+    const s = severity.toLowerCase();
+    if (s.includes("critical") || s.includes("high"))
+        return theme.diffRemovedFg;
+    if (s.includes("medium") || s.includes("moderate"))
+        return theme.mdItalic;
+    return theme.diffAddedFg;
+}
+/** Compact ASCII bar for a 1-5 score: e.g. "[###  ]". */
+function scoreBar(score) {
+    const clamped = Math.max(1, Math.min(5, Math.round(score)));
+    const filled = "#".repeat(clamped);
+    const empty = " ".repeat(5 - clamped);
+    return `[${filled}${empty}]`;
+}
+/** Flatten one unknown top-level value into displayable bullet items. */
+function flattenValue(v) {
+    if (typeof v === "string")
+        return v.trim().length > 0 ? [v.trim()] : [];
+    if (Array.isArray(v)) {
+        const items = [];
+        for (const el of v) {
+            if (typeof el === "string" && el.trim().length > 0)
+                items.push(el.trim());
+            else if (el && typeof el === "object") {
+                const cells = Object.entries(el)
+                    .filter(([, cv]) => cv !== null && cv !== undefined && typeof cv !== "object")
+                    .map(([ck, cv]) => `${ck}: ${String(cv)}`);
+                if (cells.length > 0)
+                    items.push(cells.join(" · "));
+            }
+        }
+        return items;
+    }
+    return [];
+}
+/**
+ * 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 function parseConclusion(text) {
+    const trimmed = text.trim();
+    // A `---READABLE---` prose tail means the synthesizer already produced human
+    // copy; don't try to structure it — let the plain-text path render the prose.
+    if (trimmed.includes("---READABLE---"))
+        return null;
+    // Strip a leading ```json … ``` fence if present, then isolate the object.
+    const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/);
+    const body = (fenced ? fenced[1] : trimmed).trim();
+    const start = body.indexOf("{");
+    if (start === -1)
+        return null;
+    const end = body.lastIndexOf("}");
+    // Truncated output may have NO balanced end — hand the raw tail to salvage.
+    const candidate = end > start ? body.slice(start, end + 1) : body.slice(start);
+    const parsed = salvageJson(candidate) ?? (end > start ? salvageJson(body.slice(start)) : null);
+    if (!parsed)
+        return null;
+    const summary = firstString(parsed, ["summary", "conclusion"]);
+    const recommendation = firstString(parsed, ["recommendation", "decision", "verdict"]);
+    const strengths = firstArray(parsed, ["strengths", "pros", "agreed"]);
+    const weaknesses = firstArray(parsed, ["weaknesses", "cons", "gaps"]);
+    const risks = firstArray(parsed, ["risks", "concerns"]);
+    const tradeoffs = firstArray(parsed, ["tradeoffs", "trade_offs", "trade-offs"]);
+    const coverage = coverageRows(parsed);
+    const dimensionScores = parseDimensionScores(parsed);
+    const operationalRisks = parseOperationalRisks(parsed);
+    const priorityFixes = parsePriorityFixes(parsed);
+    const nextActions = parseNextActions(parsed);
+    // Track which keys the named extractions actually consumed (a key only
+    // counts as consumed when it produced content — object-shaped `risks`
+    // yield [] above and must still reach the generic pass below).
+    const consumed = new Set();
+    if (summary)
+        for (const k of ["summary", "conclusion"])
+            if (firstString(parsed, [k]))
+                consumed.add(k);
+    if (recommendation)
+        for (const k of ["recommendation", "decision", "verdict"])
+            if (firstString(parsed, [k]))
+                consumed.add(k);
+    const arrayKeyGroups = [
+        [["strengths", "pros", "agreed"], strengths],
+        [["weaknesses", "cons", "gaps"], weaknesses],
+        [["risks", "concerns"], risks],
+        [["tradeoffs", "trade_offs", "trade-offs"], tradeoffs],
+    ];
+    for (const [keys, extracted] of arrayKeyGroups) {
+        if (extracted.length > 0)
+            for (const k of keys)
+                if (asStringArray(parsed[k]).length > 0)
+                    consumed.add(k);
+    }
+    if (coverage.length > 0)
+        for (const k of ["coverage_matrix", "coverage", "criteria", "coverageMatrix"])
+            if (Array.isArray(parsed[k]))
+                consumed.add(k);
+    if (dimensionScores.length > 0)
+        for (const k of ["dimension_scores", "dimensionScores", "dimensions", "scores"])
+            if (Array.isArray(parsed[k]))
+                consumed.add(k);
+    if (operationalRisks.length > 0)
+        for (const k of ["operational_risks", "operationalRisks", "risk_matrix"])
+            if (Array.isArray(parsed[k]))
+                consumed.add(k);
+    if (priorityFixes.length > 0)
+        for (const k of ["priority_fixes", "priorityFixes", "fixes", "action_items"])
+            if (Array.isArray(parsed[k]))
+                consumed.add(k);
+    if (nextActions.length > 0)
+        for (const k of ["nextActions", "next_actions"])
+            if (Array.isArray(parsed[k]))
+                consumed.add(k);
+    const sections = [];
+    for (const [key, value] of Object.entries(parsed)) {
+        if (consumed.has(key) || NOISE_KEYS.has(key))
+            continue;
+        const items = flattenValue(value);
+        if (items.length > 0)
+            sections.push({ title: titleCase(key), items });
+    }
+    const hasContent = !!summary ||
+        !!recommendation ||
+        strengths.length > 0 ||
+        weaknesses.length > 0 ||
+        risks.length > 0 ||
+        tradeoffs.length > 0 ||
+        coverage.length > 0 ||
+        dimensionScores.length > 0 ||
+        operationalRisks.length > 0 ||
+        priorityFixes.length > 0 ||
+        nextActions.length > 0 ||
+        sections.length > 0;
+    if (!hasContent)
+        return null;
+    return {
+        summary,
+        recommendation,
+        strengths,
+        weaknesses,
+        risks,
+        tradeoffs,
+        coverage,
+        dimensionScores,
+        operationalRisks,
+        priorityFixes,
+        nextActions,
+        sections,
+    };
+}
+function BulletSection({ title, items, color, theme: t, marker = "•" }) {
+    if (items.length === 0)
+        return null;
+    return (_jsxs("box", { flexDirection: "column", marginTop: 1, children: [_jsx("text", { fg: color, attributes: 1, children: title }), items.map((it, i) => (_jsxs("box", { flexDirection: "row", children: [_jsx("text", { fg: t.textMuted, children: `  ${marker} ` }), _jsx("text", { fg: t.text, children: it })] }, `${title}-${i}`)))] }));
+}
+function DimensionScoreTable({ scores, theme: t }) {
+    if (scores.length === 0)
+        return null;
+    return (_jsxs("box", { flexDirection: "column", marginTop: 1, children: [_jsx("text", { fg: t.accent, attributes: 1, children: "Dimension Scores" }), scores.map((s, i) => (_jsxs("box", { flexDirection: "column", marginTop: 1, children: [_jsxs("box", { flexDirection: "row", children: [_jsx("text", { fg: t.text, children: s.dimension }), _jsx("box", { flexGrow: 1 }), _jsx("text", { fg: scoreColor(s.score, t), attributes: 1, children: `${s.score}/5 ${scoreBar(s.score)}` })] }), _jsx("text", { fg: t.textMuted, children: `    ${s.justification}` })] }, `dim-${i}`)))] }));
+}
+function RiskTable({ risks, theme: t }) {
+    if (risks.length === 0)
+        return null;
+    return (_jsxs("box", { flexDirection: "column", marginTop: 1, children: [_jsx("text", { fg: t.diffRemovedFg, attributes: 1, children: "Operational Risks" }), risks.map((r, i) => (_jsxs("box", { flexDirection: "column", marginTop: 1, children: [_jsxs("box", { flexDirection: "row", children: [_jsx("text", { fg: t.text, attributes: 1, children: r.risk }), _jsx("box", { flexGrow: 1 }), _jsx("text", { fg: severityColor(r.severity, t), children: r.severity })] }), _jsx("text", { fg: t.textMuted, children: `    Trigger: ${r.trigger}` })] }, `risk-${i}`)))] }));
+}
+function PriorityFixList({ fixes, theme: t }) {
+    if (fixes.length === 0)
+        return null;
+    return (_jsxs("box", { flexDirection: "column", marginTop: 1, children: [_jsx("text", { fg: t.mdItalic, attributes: 1, children: "Priority Fixes" }), fixes.map((fix, i) => (_jsxs("box", { flexDirection: "row", children: [_jsx("text", { fg: t.textMuted, children: `  ${i + 1}. ` }), _jsx("text", { fg: t.text, children: fix })] }, `fix-${i}`)))] }));
+}
+function NextActionList({ actions, theme: t }) {
+    if (actions.length === 0)
+        return null;
+    return (_jsxs("box", { flexDirection: "column", marginTop: 1, children: [_jsx("text", { fg: t.planStepNum, attributes: 1, children: "Next Actions" }), actions.map((a, i) => (_jsxs("box", { flexDirection: "column", marginTop: 1, children: [_jsxs("box", { flexDirection: "row", children: [_jsx("text", { fg: t.textMuted, children: `  ${i + 1}. ` }), _jsx("text", { fg: t.text, attributes: 1, children: a.label })] }), a.reason && _jsx("text", { fg: t.textMuted, children: `     ${a.reason}` })] }, `act-${i}`)))] }));
+}
+export function CouncilConclusionCard({ conclusion, round, theme: t }) {
+    const title = round === undefined ? "Final Conclusion" : `Round ${round} Conclusion`;
+    return (_jsxs("box", { flexDirection: "column", marginBottom: 1, border: ["left"], borderColor: t.councilSynthesisBorder, paddingLeft: 2, children: [_jsx("text", { fg: t.councilSynthesisBorder, attributes: 1, children: title }), conclusion.summary && (_jsx("box", { marginTop: 1, children: _jsx("text", { fg: t.text, children: conclusion.summary }) })), conclusion.recommendation && (_jsxs("box", { flexDirection: "column", marginTop: 1, children: [_jsx("text", { fg: t.accent, attributes: 1, children: "Recommendation" }), _jsx("text", { fg: t.text, children: conclusion.recommendation })] })), _jsx(DimensionScoreTable, { scores: conclusion.dimensionScores, theme: t }), _jsx(BulletSection, { title: "Strengths", items: conclusion.strengths, color: t.diffAddedFg, theme: t }), _jsx(BulletSection, { title: "Weaknesses", items: conclusion.weaknesses, color: t.diffRemovedFg, theme: t }), _jsx(RiskTable, { risks: conclusion.operationalRisks, theme: t }), _jsx(BulletSection, { title: "Risks", items: conclusion.risks, color: t.diffRemovedFg, theme: t }), _jsx(BulletSection, { title: "Trade-offs", items: conclusion.tradeoffs, color: t.mdItalic, theme: t }), _jsx(PriorityFixList, { fixes: conclusion.priorityFixes, theme: t }), _jsx(NextActionList, { actions: conclusion.nextActions, theme: t }), conclusion.coverage.length > 0 && (_jsxs("box", { flexDirection: "column", marginTop: 1, children: [_jsx("text", { fg: t.textMuted, attributes: 1, children: "Coverage" }), conclusion.coverage.map((row, i) => (_jsxs("box", { flexDirection: "row", children: [_jsx("text", { fg: t.textMuted, children: "  – " }), _jsx("text", { fg: t.text, children: row.join(" · ") })] }, `cov-${i}`)))] })), conclusion.sections.map((sec) => (_jsx(BulletSection, { title: sec.title, items: sec.items, color: t.accent, theme: t }, sec.title)))] }));
+}
+//# sourceMappingURL=council-conclusion-card.js.map

package/dist/src/ui/components/council-debate-pill.d.ts

@@ -0,0 +1,36 @@
+import type { ReactNode } from "react";
+import type { Theme } from "../theme.js";
+export interface CouncilDebatePillProps {
+    /** Number of debate turns folded into the pill (leader + debate + research). */
+    count: number;
+    /** Debate still running — show a spinner + live tail; false → done summary. */
+    active: boolean;
+    /** Expanded → render full transcript (children); collapsed → header + tail only. */
+    expanded: boolean;
+    /**
+     * Last few non-empty lines of the most recent debate turn, joined with " · ".
+     * Only shown while active + collapsed to mimic the "thinking" pill. Empty
+     * string = nothing to show yet.
+     */
+    tailText: string;
+    theme: Theme;
+    /** Full debate bubbles, rendered only when `expanded` is true. */
+    children?: ReactNode;
+}
+/**
+ * Collapsible debate transcript, styled after the reasoning ("[Thought]") pill.
+ *
+ * The council debate can emit dozens of tall bubbles. Rendering them all inline
+ * buries the synthesis/deliverable and floods the scrollback. This pill folds
+ * the back-and-forth into a single line:
+ *   - active + collapsed  → spinner + "Debating… (N turns)" + a live tail of the
+ *     latest turn (like the reasoning pill's last-3-lines preview).
+ *   - done   + collapsed  → "Debated N turns" summary; detail is hidden.
+ *   - expanded            → full transcript in a left-bordered box.
+ * Toggle via Ctrl+O (wired in use-app-logic handleKey). Synthesis is rendered
+ * OUTSIDE this pill by the caller so the deliverable is always visible.
+ *
+ * ASCII-only strings on purpose: this file's siblings mangle non-ASCII glyphs
+ * to mojibake under the repo's encoding, so we mirror the "[Thought]" pill idiom.
+ */
+export declare function CouncilDebatePill({ count, active, expanded, tailText, theme: t, children }: CouncilDebatePillProps): ReactNode;

package/dist/src/ui/components/council-debate-pill.js

@@ -0,0 +1,34 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "@opentui/react/jsx-runtime";
+import { useEffect, useState } from "react";
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+function Spinner() {
+    const [frame, setFrame] = useState(0);
+    useEffect(() => {
+        const id = setInterval(() => setFrame((n) => (n + 1) % SPINNER_FRAMES.length), 100);
+        return () => clearInterval(id);
+    }, []);
+    return _jsx(_Fragment, { children: SPINNER_FRAMES[frame] });
+}
+/**
+ * Collapsible debate transcript, styled after the reasoning ("[Thought]") pill.
+ *
+ * The council debate can emit dozens of tall bubbles. Rendering them all inline
+ * buries the synthesis/deliverable and floods the scrollback. This pill folds
+ * the back-and-forth into a single line:
+ *   - active + collapsed  → spinner + "Debating… (N turns)" + a live tail of the
+ *     latest turn (like the reasoning pill's last-3-lines preview).
+ *   - done   + collapsed  → "Debated N turns" summary; detail is hidden.
+ *   - expanded            → full transcript in a left-bordered box.
+ * Toggle via Ctrl+O (wired in use-app-logic handleKey). Synthesis is rendered
+ * OUTSIDE this pill by the caller so the deliverable is always visible.
+ *
+ * ASCII-only strings on purpose: this file's siblings mangle non-ASCII glyphs
+ * to mojibake under the repo's encoding, so we mirror the "[Thought]" pill idiom.
+ */
+export function CouncilDebatePill({ count, active, expanded, tailText, theme: t, children }) {
+    const turnLabel = count === 1 ? "turn" : "turns";
+    const header = active ? `[Council] Debating... (${count} ${turnLabel})` : `[Council] Debated ${count} ${turnLabel}`;
+    const hint = expanded ? "Ctrl+O to collapse" : "Ctrl+O to expand";
+    return (_jsxs("box", { paddingLeft: 3, marginTop: 1, flexShrink: 0, flexDirection: "column", children: [_jsxs("box", { children: [active ? (_jsx("text", { fg: t.accent, children: _jsx(Spinner, {}) })) : null, _jsx("text", { fg: t.textMuted, children: `${active ? " " : ""}${header}  ·  ${hint}` })] }), expanded ? (_jsx("box", { border: ["left"], borderColor: t.textMuted, paddingLeft: 2, marginTop: 1, flexDirection: "column", children: children })) : active && tailText ? (_jsx("box", { border: ["left"], borderColor: t.textMuted, paddingLeft: 2, marginTop: 1, children: _jsx("text", { fg: t.textMuted, children: tailText }) })) : null] }));
+}
+//# sourceMappingURL=council-debate-pill.js.map

package/dist/src/ui/components/council-info-card.js

@@ -1,10 +1,10 @@
 import { jsx as _jsx, jsxs as _jsxs } from "@opentui/react/jsx-runtime";
-import { Semantic } from "@muonroi/agent-harness-opentui";
+import { ListItem } from "../primitives/index.js";
 const MAX_CARD_COLS = 100;
 const FALLBACK_THRESHOLD = 70;
 export function CouncilInfoCardView({ card, terminalCols, theme }) {
     const fallback = terminalCols < FALLBACK_THRESHOLD;
     const width = fallback ? terminalCols : Math.min(terminalCols - 2, MAX_CARD_COLS);
-    return (_jsx(Semantic, { id: "info-card", role: "listitem", name: card.title, children: _jsx("box", { flexDirection: "column", marginBottom: 1, children: _jsxs("box", { width: width, borderStyle: "single", borderColor: theme.councilInfoCardBorder, flexDirection: "column", paddingLeft: 1, paddingRight: 1, children: [_jsx("text", { fg: theme.councilInfoCardTitle, attributes: 1, children: card.title }), card.sections.map((section, i) => (_jsxs("box", { flexDirection: "column", marginTop: 1, children: [_jsx("text", { fg: theme.councilInfoCardHeading, attributes: 1, children: section.heading }), _jsx("text", { fg: theme.text, children: section.body })] }, `${section.heading}-${i}`)))] }) }) }));
+    return (_jsx(ListItem, { id: "info-card", name: card.title, children: _jsx("box", { flexDirection: "column", marginBottom: 1, children: _jsxs("box", { width: width, borderStyle: "single", borderColor: theme.councilInfoCardBorder, flexDirection: "column", paddingLeft: 1, paddingRight: 1, children: [_jsx("text", { fg: theme.councilInfoCardTitle, attributes: 1, children: card.title }), card.sections.map((section, i) => (_jsxs("box", { flexDirection: "column", marginTop: 1, children: [_jsx("text", { fg: theme.councilInfoCardHeading, attributes: 1, children: section.heading }), _jsx("text", { fg: theme.text, children: section.body })] }, `${section.heading}-${i}`)))] }) }) }));
 }
 //# sourceMappingURL=council-info-card.js.map

package/dist/src/ui/components/council-leader-bubble.d.ts

@@ -1,10 +1,17 @@
 import type { CouncilMessage } from "../../types/index.js";
+import type { Theme } from "../theme.js";
 export interface CouncilLeaderBubbleProps {
     msg: CouncilMessage;
     terminalCols: number;
+    theme: Theme;
 }
-export declare function buildLeaderHeader(round: number | undefined): string;
+export declare function buildLeaderHeader(round: number | undefined, phase?: CouncilMessage["phase"]): string;
 /**
- * Centered, narrow (40% width), gray-bordered bubble for leader evaluations.
+ * Leader evaluation, rendered as a linear group-chat row (matching the debate
+ * speakers) instead of a centered narrow bubble — a muted gray left bar marks
+ * it as the moderator's turn while keeping the single downward reading flow.
+ *
+ * B5: a pre-round `directive` steers the debate and is rendered with the accent
+ * color so the leader visibly LEADS each round; `verdict`/`eval` stay muted.
  */
-export declare function CouncilLeaderBubble({ msg, terminalCols }: CouncilLeaderBubbleProps): import("react").ReactNode;
+export declare function CouncilLeaderBubble({ msg, terminalCols, theme: t }: CouncilLeaderBubbleProps): import("react").ReactNode;

package/dist/src/ui/components/council-leader-bubble.js

@@ -1,17 +1,27 @@
 import { jsx as _jsx, jsxs as _jsxs } from "@opentui/react/jsx-runtime";
-import { dark } from "../theme.js";
-import { computeBubbleLayout } from "./bubble-layout.js";
-export function buildLeaderHeader(round) {
-    return round !== undefined ? `Leader · round ${round} eval` : "Leader";
+import { capBubbleBody } from "./bubble-body-guard.js";
+export function buildLeaderHeader(round, phase) {
+    // B5: distinguish the leader's pre-round steering from its post-round grading
+    // so the conductor role reads clearly in the transcript (not a faint "eval").
+    const suffix = phase === "directive" ? "directive" : phase === "verdict" ? "verdict" : "eval";
+    const label = phase === "directive" ? "▶ Leader" : "Leader";
+    return round !== undefined ? `${label} · round ${round} ${suffix}` : label;
 }
 /**
- * Centered, narrow (40% width), gray-bordered bubble for leader evaluations.
+ * Leader evaluation, rendered as a linear group-chat row (matching the debate
+ * speakers) instead of a centered narrow bubble — a muted gray left bar marks
+ * it as the moderator's turn while keeping the single downward reading flow.
+ *
+ * B5: a pre-round `directive` steers the debate and is rendered with the accent
+ * color so the leader visibly LEADS each round; `verdict`/`eval` stay muted.
  */
-export function CouncilLeaderBubble({ msg, terminalCols }) {
-    const layout = computeBubbleLayout(terminalCols);
-    const width = layout.leaderCols;
-    const centerIndent = Math.max(0, Math.floor((terminalCols - width) / 2));
-    const header = buildLeaderHeader(msg.round);
-    return (_jsx("box", { flexDirection: "column", marginBottom: 1, marginLeft: centerIndent, children: _jsxs("box", { width: width, borderStyle: "single", borderColor: dark.councilLeaderBorder, flexDirection: "column", paddingLeft: 1, paddingRight: 1, children: [_jsx("text", { fg: dark.textMuted, attributes: 1, children: header }), _jsx("text", { fg: dark.textMuted, children: msg.text.trim() })] }) }));
+export function CouncilLeaderBubble({ msg, terminalCols, theme: t }) {
+    const header = buildLeaderHeader(msg.round, msg.phase);
+    const isDirective = msg.phase === "directive";
+    const headerColor = isDirective ? t.accent : t.textMuted;
+    const borderColor = isDirective ? t.accent : t.councilLeaderBorder;
+    // Same unbounded-<text> guard as the speaker bubble (see bubble-body-guard.ts).
+    const bodyText = capBubbleBody(msg.text.trim(), terminalCols);
+    return (_jsxs("box", { flexDirection: "column", marginBottom: 1, border: ["left"], borderColor: borderColor, paddingLeft: 2, children: [_jsx("text", { fg: headerColor, attributes: 1, children: header }), _jsx("text", { fg: t.textMuted, children: bodyText })] }));
 }
 //# sourceMappingURL=council-leader-bubble.js.map