muonroi-cli 1.8.4 → 1.9.0

package/dist/src/council/panel-select.js

@@ -0,0 +1,82 @@
+/**
+ * src/council/panel-select.ts
+ *
+ * U3 — task-aware debate panel selection. Instead of a fixed capability roster
+ * (resolveParticipants picks by tier, blind to the prompt), the leader reads the
+ * task and CHOOSES which reachable models should debate it. Fail-open: any parse
+ * / provider failure returns null and the caller keeps the default roster. The
+ * internal implement/verify/research routing slots are assigned here purely for
+ * downstream compatibility — they are never surfaced to the user (the UI shows
+ * the task-adaptive persona / model, per U1.1).
+ */
+import { tracedGenerate } from "./llm.js";
+const ALL_ROLES = ["implement", "verify", "research"];
+const SELECT_SYSTEM = "You are the council leader assembling a debate panel for a specific task. From the AVAILABLE MODELS, " +
+    "pick the 2-4 that will produce the most rigorous, diverse debate for THIS task — prefer provider and " +
+    "tier diversity, and match model strengths to what the task actually needs (e.g. a decision/analysis task " +
+    "wants strong reasoners; a build task wants a coding-capable model plus a critical reviewer). " +
+    'Return ONLY JSON: {"members":[{"model":"<exact id from the list>","why":"<short reason>"}]}. ' +
+    "Use exact model ids from the list; never invent an id.";
+/**
+ * Ask the leader to select a task-appropriate debate panel from `pool`.
+ * Returns a roster (models mapped onto internal routing roles) or null when the
+ * leader is unavailable / returns an unusable selection — the caller then keeps
+ * its default roster.
+ */
+export async function* selectTaskAwarePanel(opts) {
+    const { topic, pool, leaderModelId, llm } = opts;
+    if (pool.length < 2)
+        return null;
+    const poolList = pool
+        .map((c) => `- ${c.model}${c.tier ? ` [${c.tier}]` : ""}${c.provider ? ` (${c.provider})` : ""}: ${c.description.slice(0, 120)}`)
+        .join("\n");
+    const prompt = `## Task\n${topic}\n\n## Available models\n${poolList}\n\nSelect the 2-4 models best suited to debate this task.`;
+    let raw;
+    try {
+        raw = yield* tracedGenerate(llm, {
+            phase: "panel_select",
+            label: "Leader selecting debate panel",
+            modelId: leaderModelId,
+            system: SELECT_SYSTEM,
+            prompt,
+            maxTokens: 512,
+        });
+    }
+    catch (err) {
+        // Fail-open: caller keeps its default roster. Log so a provider outage on
+        // the leader model is diagnosable instead of silently degrading panel
+        // selection to the prompt-blind roster. (No-Silent-Catch.)
+        console.error(`[council/panel-select] leader panel selection call failed, keeping default roster: ${err instanceof Error ? err.message : String(err)}`, { leaderModelId, poolSize: pool.length });
+        return null;
+    }
+    const match = raw.match(/\{[\s\S]*\}/);
+    if (!match) {
+        console.error("[council/panel-select] leader returned no JSON object, keeping default roster", {
+            leaderModelId,
+            rawHead: raw.slice(0, 200),
+        });
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(match[0]);
+    }
+    catch (err) {
+        console.error(`[council/panel-select] leader selection JSON parse failed, keeping default roster: ${err instanceof Error ? err.message : String(err)}`, { leaderModelId, rawHead: match[0].slice(0, 200) });
+        return null;
+    }
+    const valid = new Set(pool.map((c) => c.model));
+    const picked = [];
+    for (const m of parsed.members ?? []) {
+        const id = typeof m?.model === "string" ? m.model.trim() : "";
+        if (id && valid.has(id) && !picked.includes(id))
+            picked.push(id);
+        if (picked.length >= 4)
+            break;
+    }
+    if (picked.length < 2)
+        return null;
+    // Roles are internal cost-tier routing slots (hidden from UI); assign cyclically.
+    return picked.map((model, i) => ({ role: ALL_ROLES[i % ALL_ROLES.length], model }));
+}
+//# sourceMappingURL=panel-select.js.map

package/dist/src/council/planner.js

@@ -1,5 +1,7 @@
+import { getCouncilLanguage } from "../utils/settings.js";
 import { tracedGenerate } from "./llm.js";
 import { phaseDone, phaseError, phaseStart } from "./phase-events.js";
+import { emitPreflightHarnessEvent } from "./preflight.js";
 import { buildSynthesisPrompt } from "./prompts.js";
 export async function* runPlanning(debateState, spec, participants, leaderModelId, respondToPreflight, llm, debatePlan, 
 // CQ-18: PIL outputStyle from runCouncil
@@ -33,6 +35,9 @@ planEmphasis) {
             outputStyle: outputStyle ?? undefined,
             refineContext,
             planEmphasis,
+            // Feature B — synthesis output language follows the resolved council
+            // debate language (auto → detect from the brief; pinned → that locale).
+            language: getCouncilLanguage(),
         };
         const first = buildSynthesisPrompt(baseArgs);
         synthesisText = yield* tracedGenerate(llm, {
@@ -141,6 +146,15 @@ planEmphasis) {
             yield { type: "content", content: `- [${step.priority}] ${step.description}\n` };
         }
         const preflightId = crypto.randomUUID();
+        emitPreflightHarnessEvent({
+            t: "event",
+            kind: "askcard-open",
+            questionId: preflightId,
+            question: `Approve action plan for: ${spec.problemStatement}`,
+            phase: "plan-confirm",
+            optionCount: 2,
+            defaultIndex: 0,
+        });
         yield {
             type: "council_preflight",
             content: "Review the action plan above. Approve to proceed with execution, or reject.",
@@ -155,6 +169,13 @@ planEmphasis) {
             },
         };
         const approved = await respondToPreflight(preflightId);
+        emitPreflightHarnessEvent({
+            t: "event",
+            kind: "askcard-answered",
+            questionId: preflightId,
+            answerKind: "choice",
+            answerText: approved ? "approve" : "reject",
+        });
         yield phaseDone({
             phaseId: "phase:action-plan",
             kind: "action_plan",
@@ -233,10 +254,29 @@ function parseOutcome(synthesisText, debatePlan) {
                         sections[s.key] = parsed[s.key];
                 }
             }
+            // Model-first post-debate options. Keep only entries whose action is in
+            // the wired vocabulary; drop malformed items so a hallucinated action id
+            // can't reach the handler switch. Empty → index.ts uses its fallback set.
+            const VALID_ACTIONS = new Set(["ask_followup", "generate_plan", "implement", "save_exit", "continue_session"]);
+            const nextActions = Array.isArray(parsed.nextActions)
+                ? parsed.nextActions
+                    .filter((a) => !!a &&
+                    typeof a === "object" &&
+                    typeof a.action === "string" &&
+                    VALID_ACTIONS.has(a.action) &&
+                    typeof a.label === "string" &&
+                    a.label.trim().length > 0)
+                    .map((a) => ({
+                    action: a.action,
+                    label: a.label.trim(),
+                    reason: typeof a.reason === "string" ? a.reason.trim() : undefined,
+                }))
+                : undefined;
             return {
                 type,
                 summary,
                 sections: Object.keys(sections).length > 0 ? sections : undefined,
+                nextActions: nextActions && nextActions.length > 0 ? nextActions : undefined,
                 // Legacy fields — synthesizer may still emit them when shape calls for them.
                 agreed: Array.isArray(parsed.agreed) ? parsed.agreed : undefined,
                 tradeoffs: Array.isArray(parsed.tradeoffs) ? parsed.tradeoffs : undefined,

package/dist/src/council/preflight.d.ts

@@ -1,8 +1,25 @@
 import type { StreamChunk } from "../types/index.js";
 import type { ClarifiedSpec, PreflightResponder } from "./types.js";
+/**
+ * Emit a harness LiveEvent for a preflight/plan-confirm approval gate.
+ *
+ * These gates are surfaced as `council_preflight` StreamChunks (a UI render path),
+ * NOT as LiveEvents — so a monitor on MUONROI_HARNESS_EVENT_LOG is structurally
+ * blind to them, unlike the clarify gate which flows through askcard-open. Emitting
+ * askcard-open/answered here lets a wake-at-milestone monitor react to the
+ * human-approval pause. Observe-only: never throws, no-op when no agent runtime.
+ */
+export declare function emitPreflightHarnessEvent(event: Record<string, unknown>): void;
 export interface RunPreflightOptions {
     repoEmpty?: boolean;
     researchOverridable?: boolean;
+    /**
+     * ROI: when the clarifier judged the spec ready (high confidence, no gaps),
+     * the approve card is a rubber-stamp. Show the Discussion Brief for
+     * transparency but auto-approve without blocking on a gate. Default false —
+     * an unready/low-confidence spec still surfaces the approve card.
+     */
+    autoApprove?: boolean;
 }
 export declare function runPreflight(spec: ClarifiedSpec, participants: Array<{
     role: string;

package/dist/src/council/preflight.js

@@ -1,4 +1,24 @@
 import { phaseDone, phaseStart } from "./phase-events.js";
+/**
+ * Emit a harness LiveEvent for a preflight/plan-confirm approval gate.
+ *
+ * These gates are surfaced as `council_preflight` StreamChunks (a UI render path),
+ * NOT as LiveEvents — so a monitor on MUONROI_HARNESS_EVENT_LOG is structurally
+ * blind to them, unlike the clarify gate which flows through askcard-open. Emitting
+ * askcard-open/answered here lets a wake-at-milestone monitor react to the
+ * human-approval pause. Observe-only: never throws, no-op when no agent runtime.
+ */
+export function emitPreflightHarnessEvent(event) {
+    try {
+        const ar = globalThis.__muonroiAgentRuntime;
+        if (!ar || typeof ar.emitEvent !== "function")
+            return;
+        ar.emitEvent(event);
+    }
+    catch {
+        /* observe-only */
+    }
+}
 export async function* runPreflight(spec, participants, researchNeeded, respondToPreflight, options) {
     const preflightId = crypto.randomUUID();
     const startedAt = Date.now();
@@ -31,13 +51,34 @@ export async function* runPreflight(spec, participants, researchNeeded, respondT
                 },
                 { heading: "Scope", body: spec.scope || "Not specified" },
                 {
-                    heading: "Participants",
-                    body: participants.map((p) => `- ${p.role} → ${p.model}`).join("\n"),
+                    heading: "Panel",
+                    body: participants.map((p) => `- ${p.model}`).join("\n"),
                 },
                 { heading: "Research phase", body: `${researchMode}${researchNote}` },
             ],
         },
     };
+    // ROI: skip the approve gate when the spec is already judged ready — show the
+    // brief above for transparency but don't block on a rubber-stamp.
+    if (options?.autoApprove === true) {
+        yield phaseDone({
+            phaseId: "phase:preflight",
+            kind: "preflight",
+            label: "Pre-flight review",
+            startedAt,
+            detail: "auto-approved (spec ready)",
+        });
+        return true;
+    }
+    emitPreflightHarnessEvent({
+        t: "event",
+        kind: "askcard-open",
+        questionId: preflightId,
+        question: `Approve discussion plan for: ${spec.problemStatement}`,
+        phase: "preflight",
+        optionCount: 2,
+        defaultIndex: 0,
+    });
     yield {
         type: "council_preflight",
         content: "Review the discussion brief above. Approve to start debate, or reject to revise.",
@@ -54,6 +95,13 @@ export async function* runPreflight(spec, participants, researchNeeded, respondT
         },
     };
     const approved = await respondToPreflight(preflightId);
+    emitPreflightHarnessEvent({
+        t: "event",
+        kind: "askcard-answered",
+        questionId: preflightId,
+        answerKind: "choice",
+        answerText: approved ? "approve" : "reject",
+    });
     yield phaseDone({
         phaseId: "phase:preflight",
         kind: "preflight",

package/dist/src/council/prompts.d.ts

@@ -2,7 +2,15 @@ import type { ClarifiedSpec, DebatePlan, DebateStance, OutputShape } from "./typ
 export declare function buildClarificationPrompt(topic: string, conversationContext: string, previousQA?: Array<{
     question: string;
     answer: string;
-}>): {
+}>, 
+/**
+ * Interview language, already resolved by the caller (runClarification): a
+ * concrete language name ("vietnamese", "english", a pinned locale) or "auto".
+ * Feeds the shared `buildLanguageRule` so the cards follow the SAME language
+ * policy as the debate — the user's conversation language, not English-by-
+ * default. Defaults to "auto" so existing no-arg callers keep auto-detection.
+ */
+lang?: string): {
     system: string;
     prompt: string;
 };
@@ -37,6 +45,20 @@ export declare function buildReadinessJudgePrompt(topic: string, qa: Array<{
     system: string;
     prompt: string;
 };
+export declare function buildLanguageRule(lang?: string): string;
+/**
+ * Feature B — synthesis-specific language rule. The synthesis prompt already
+ * localizes its user-facing output to the user's language; this only adjusts (a)
+ * the now-possibly-inaccurate "debate above is entirely in English" preamble and
+ * (b) the language-selection instruction when the user PINNED a specific locale.
+ *
+ * undefined / "english" → the historical block, byte-identical (debate was
+ *   English-only, output detected from the Problem Statement).
+ * "auto" → same "detect from the Problem Statement" output behavior, but the
+ *   preamble no longer falsely claims the debate ran in English.
+ * pinned locale → force all prose into that language instead of detecting it.
+ */
+export declare function buildSynthesisLanguageRule(lang?: string): string;
 export declare function buildOpeningPrompt(ctx: {
     speakerRole: string;
     partnerRole: string;
@@ -45,6 +67,8 @@ export declare function buildOpeningPrompt(ctx: {
     spec: ClarifiedSpec;
     outputShape?: OutputShape;
     conversationContext?: string;
+    /** Feature B — resolved council debate language (undefined → English). */
+    language?: string;
 }): {
     system: string;
     prompt: string;
@@ -57,6 +81,8 @@ export declare function buildResponsePrompt(ctx: {
     speakerPosition: string;
     partnerPosition: string;
     spec: ClarifiedSpec;
+    /** Feature B — resolved council debate language (undefined → English). */
+    language?: string;
 }): {
     system: string;
     prompt: string;
@@ -72,6 +98,8 @@ export declare function buildFollowupPrompt(ctx: {
     round: number;
     runningSummary?: string;
     spec: ClarifiedSpec;
+    /** Feature B — resolved council debate language (undefined → English). */
+    language?: string;
 }): {
     system: string;
     prompt: string;
@@ -80,11 +108,15 @@ export declare function buildLeaderEvaluationPrompt(ctx: {
     spec: ClarifiedSpec;
     exchangeLogs: string;
     round: number;
+    /** Feature B — resolved council debate language (undefined → English). */
+    language?: string;
 }): {
     system: string;
     prompt: string;
 };
-export declare function buildRoundSummaryPrompt(allExchanges: string, topic: string, round: number): {
+export declare function buildRoundSummaryPrompt(allExchanges: string, topic: string, round: number, 
+/** Feature B — resolved council debate language (undefined → English). */
+language?: string): {
     system: string;
     prompt: string;
 };
@@ -106,6 +138,8 @@ export declare function buildSynthesisPrompt(ctx: {
     outputStyle?: string | null;
     refineContext?: string;
     planEmphasis?: boolean;
+    /** Feature B — resolved council debate language (undefined → English). */
+    language?: string;
 }): {
     system: string;
     prompt: string;
@@ -113,8 +147,9 @@ export declare function buildSynthesisPrompt(ctx: {
 /**
  * Builds the system prompt for the research role.
  *
- * When `hasUrl` is true, injects a mandatory instruction to invoke a Playwright
- * or Chrome-DevTools tool before reporting Frontend Findings (CQ-04).
+ * When `hasUrl` is true, injects a mandatory instruction to use fetch_url (preferred
+ * for content) or a browser tool (playwright/chrome when screenshots or heavy JS interaction
+ * are required) before reporting Frontend Findings (CQ-04).
  *
  * Output format enforces 3 labelled sections with citation requirements (CQ-05).
  */