muonroi-cli 1.8.4 → 1.9.0

package/dist/src/council/prompts.js

@@ -1,6 +1,14 @@
 import { buildStackLockSection } from "./decisions-lock.js";
 // ── Clarification prompts ────────────────────────────────────────────────────
-export function buildClarificationPrompt(topic, conversationContext, previousQA) {
+export function buildClarificationPrompt(topic, conversationContext, previousQA, 
+/**
+ * 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 = "auto") {
     const qaSection = previousQA?.length
         ? `\n\n## Already Clarified\n${previousQA.map((qa) => `Q: ${qa.question}\nA: ${qa.answer}`).join("\n\n")}`
         : "";
@@ -12,10 +20,28 @@ export function buildClarificationPrompt(topic, conversationContext, previousQA)
             `- SCOPE: what is in/out of scope for THIS change?\n` +
             `- CONSTRAINTS: hard technical/time/business constraints not already implied by the context.\n` +
             `- SUCCESS CRITERIA: how "done" is judged, when it isn't already obvious.\n\n` +
+            `## Ground your questions in the research (IMPORTANT)\n` +
+            `If a "## Scope Research" section is present, it is evidence gathered about THIS topic before you ` +
+            `were asked to clarify. Read it first, then use it to ask SHARPER, better-grounded questions — ` +
+            `research makes your questions more pointed, it does NOT reduce the need to ask. Treat the research's ` +
+            `own guesses/speculation as UNVERIFIED, never as the user's answer: if the research had to assume ` +
+            `what the user actually wants (their real goal, the concrete task, the system of record, the target ` +
+            `user), that assumption IS the gray area you must confirm with them — do not adopt it silently. ` +
+            `In particular, when the request is vague and the research could only speculate about the core goal, ` +
+            `asking the user to name that goal/pain concretely is the single highest-value question — ask it. ` +
+            `Only skip a question when the research (or the topic/context) settles it with real evidence, not a guess.\n\n` +
             `## How many questions\n` +
             `Ask the minimum that unblocks a focused discussion — typically 0-2. A well-scoped topic, or one ` +
             `whose context already answers the gaps, needs ZERO questions: return []. Do NOT pad to a quota, ` +
             `and never ask a question whose answer is already in the topic or the project context.\n\n` +
+            `## Ask ONLY when the answer forks the debate (ROI gate — critical)\n` +
+            `Before emitting ANY question, ask yourself: "If the user said 'you decide', would I be confident?" ` +
+            `If YES and picking wrong would be cheap to correct once the debate surfaces it, DO NOT ask — return [] ` +
+            `and let the debate proceed on your recommended reading. A card that merely asks the user to CONFIRM the ` +
+            `default you already recommend is pure noise: it cost a real user 60s for zero new information. Only ask ` +
+            `when the answer MATERIALLY changes what the experts debate — e.g. two incompatible scopes that produce ` +
+            `entirely different debates — AND you genuinely cannot pick for them. When in doubt, return [] and proceed ` +
+            `on your best reading; the debate itself will expose any wrong assumption far more cheaply than a gate.\n\n` +
             `## Existing-repo grounding (IMPORTANT)\n` +
             `If a "## Current Project" section is present you are working in an EXISTING repository — NOT a ` +
             `greenfield project. Ground every question and every option in what that snapshot actually shows ` +
@@ -28,17 +54,19 @@ export function buildClarificationPrompt(topic, conversationContext, previousQA)
             `the project IS the one described in the "## Current Project" section of the context. DO NOT ask which project.\n` +
             `- Only ask about project identity when the topic mentions multiple distinct projects or external products.\n` +
             `- Use the project's package.json name and description as implicit context for follow-up questions.\n\n` +
-            `## Language Rule (mandatory)\n` +
-            `Write the "question", "why", and every "suggestions"/"recommended" option in the SAME ` +
-            `language the user used in the Topic below — detect it; if the user wrote Vietnamese, write ` +
-            `Vietnamese; if English, English. The user reads and answers these on a card, so they must ` +
-            `NOT default to English. Keep code identifiers, file paths, tech/product names, and JSON keys in English.\n\n` +
+            buildLanguageRule(lang) +
+            `The user reads and answers these on a card, so the "question", "why", and every option ` +
+            `"label"/"description" MUST be in that language — never default to English for card text, and ` +
+            `do NOT mirror the language of any "## Scope Research"/context block; follow the user's language.\n\n` +
             `Output ONLY a JSON array (no markdown, no preamble):\n` +
-            `[{"question": "...", "why": "why this matters for a focused discussion", "suggestions": ["option A", "option B"], "recommended": "option A", "isRequired": true}]\n\n` +
-            `Rules for "recommended" (be decisive — the user should never face an unranked list):\n` +
-            `- ALWAYS include "recommended" — the single option you would choose if the user said "you decide", given the topic + project context.\n` +
-            `- Its value MUST be exactly equal to one of the entries in "suggestions".\n` +
-            `- Omit it ONLY in a genuine 50/50 tie where recommending either option would be misleading. A missing recommendation must be the rare exception, not the default.\n` +
+            `[{"question": "...", "why": "why this matters for a focused discussion", "options": [` +
+            `{"label": "option A", "description": "what picking this means and its trade-off — one line", "recommended": true}, ` +
+            `{"label": "option B", "description": "what picking this means and its trade-off — one line"}], "isRequired": true}]\n\n` +
+            `Rules for "options" (each option is a real, distinct fork the user picks between):\n` +
+            `- Every option MUST carry a "label" (the short button text) AND a "description" (one line explaining what choosing it means / its trade-off) so the user can decide without guessing. Never emit a bare label with no description.\n` +
+            `- Mark EXACTLY ONE option with "recommended": true — the option you would choose if the user said "you decide", given the topic + project context. Be decisive; the user should never face an unranked list.\n` +
+            `- Omit "recommended" on every option ONLY in a genuine 50/50 tie where recommending either would be misleading. A missing recommendation must be the rare exception, not the default.\n` +
+            `- Provide 2-4 options per question. Do NOT add "type your own" / "let's discuss" options yourself — those escape hatches are appended automatically.\n` +
             `Return [] if no clarification is needed.`,
         prompt: `## Topic\n${topic}\n\n` +
             (conversationContext ? `## Conversation Context\n${conversationContext}\n` : "") +
@@ -125,6 +153,79 @@ const ENGLISH_ONLY_RULE = `\n## Language Rule (mandatory)\n` +
     `Code identifiers, tool output, JSON keys, and citation tags must remain in English. ` +
     `The user-facing summary at the end of the council is the only place where ` +
     `the user's native language is used; the debate is engineering-internal.\n`;
+/**
+ * Feature B — the debate language rule, parameterized. The user's chosen
+ * language IS the debate language (no separate translate-back pass), so the
+ * prompts that used to hard-force English now select their rule from the
+ * resolved `councilLanguage` setting.
+ *
+ * Regardless of language, machine-readable tokens stay verbatim English so the
+ * original stability guarantee (citation tags, JSON, cross-turn citations) is
+ * preserved: `[CONFIRMED via …]` / `[REFUTED via …]` / `[UNVERIFIED: …]` tags,
+ * JSON keys and the `type` field, code identifiers, tool output, and STACK LOCK
+ * technology names.
+ *
+ * Modes (`lang` is already normalized by `normalizeCouncilLanguage`):
+ *   - undefined / "english" → the historical English-only rule, byte-identical
+ *     so existing prompt-string tests and machine-stability are unaffected.
+ *   - "auto" → write in the SAME language as the user's brief/topic (detected
+ *     from the brief that every debate prompt already embeds).
+ *   - any other value → write in that named language.
+ */
+const NON_ENGLISH_TOKENS_RULE = `Keep these verbatim in English no matter what: code identifiers, tool output, ` +
+    `JSON keys and the \`type\` field, citation tags (\`[CONFIRMED via …]\`, ` +
+    `\`[REFUTED via …]\`, \`[UNVERIFIED: …]\`), and any STACK LOCK technology names. ` +
+    `Only your prose/analysis text switches language.\n`;
+export function buildLanguageRule(lang) {
+    if (!lang || lang === "english")
+        return ENGLISH_ONLY_RULE;
+    if (lang === "auto") {
+        return (`\n## Language Rule (mandatory)\n` +
+            `Write your ENTIRE response in the SAME language the user used in the ` +
+            `Discussion Brief / topic below. If the brief is in Vietnamese, write in ` +
+            `Vietnamese; if Japanese, Japanese; if English, English. ` +
+            NON_ENGLISH_TOKENS_RULE);
+    }
+    return (`\n## Language Rule (mandatory)\n` +
+        `Write your ENTIRE response in ${lang}. Do not switch to English for the ` +
+        `prose even if the brief or your partner's message is in another language. ` +
+        NON_ENGLISH_TOKENS_RULE);
+}
+/**
+ * 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 function buildSynthesisLanguageRule(lang) {
+    const pinned = lang && lang !== "english" && lang !== "auto" ? lang : undefined;
+    const debatePreamble = !lang || lang === "english"
+        ? `The debate above is entirely in English (debate language is forced). `
+        : `The debate above was conducted in the same language as the Problem Statement. `;
+    const selectLine = pinned
+        ? `- Write ALL prose (JSON free-text values AND Part-2 markdown body) in ${pinned}. ` +
+            `Do not translate code, identifiers, or quoted citation tags ` +
+            `(\`[REFUTED via ...]\`, \`[CONFIRMED via ...]\`).\n\n`
+        : `- Detect the user's language from the Problem Statement. If it's Vietnamese, write in ` +
+            `Vietnamese. If Japanese, Japanese. If English, English. Do not translate code, identifiers, ` +
+            `or quoted citation tags (\`[REFUTED via ...]\`, \`[CONFIRMED via ...]\`).\n\n`;
+    return (`## Language Rule (mandatory)\n` +
+        `${debatePreamble}The user wrote the ` +
+        `Problem Statement above in their own native language. You must:\n` +
+        `- **Part 1 (JSON)**: keys, the \`type\` field, and citation/tag strings stay in ENGLISH. ` +
+        `Free-text values inside JSON fields (\`summary\`, list items, prose sections) MUST use ` +
+        `the SAME language the user used in the Problem Statement.\n` +
+        `- **Part 2 (Markdown)**: write entirely in the user's native language. Markdown headings ` +
+        `that we control (the ones listed below) stay in English as printed, but body text under ` +
+        `each heading is in the user's language.\n` +
+        selectLine);
+}
 /**
  * Evidence rule injected into stance prompts. Verification tools may be
  * absent (fast-tier participants skip them) — the rule covers both cases.
@@ -159,6 +260,20 @@ const EVIDENCE_RULE_FOLLOWUP = `\n## Evidence Rule\n` +
     `- Most follow-up turns will not need any tool call.\n` +
     `Tag verified results: \`[CONFIRMED via <tool>:<evidence>]\` or \`[REFUTED via <tool>:<evidence>]\`.\n` +
     `Uncited numbers you cannot verify: \`[UNVERIFIED: <claim>]\`.\n`;
+/**
+ * Scope discipline (F10). Debate turns are for DIRECTION — a stance, its
+ * reasoning, and a cross-question — not for delivering the work product. Left
+ * unconstrained, models "over-deliver": a researcher opening once emitted a full
+ * `docs/plans/…-implementation-plan.md` with file contents and a
+ * "REQUIRED SUB-SKILL: executing-plans / Which approach?" handoff — the
+ * synthesis stage's job, not a debate turn's. This keeps turns argumentative and
+ * leaves the plan/spec/code to the Leader's synthesis.
+ */
+const DEBATE_SCOPE_RULE = `\n## Scope\n` +
+    `This is a debate about DIRECTION, not an implementation handoff. In your turn do NOT:\n` +
+    `- write out file contents, code files, or a full step-by-step implementation/execution plan;\n` +
+    `- emit task lists, "Final file content:", plan-file templates, or "next steps / which approach?" handoffs.\n` +
+    `Argue your position and its trade-offs; the Leader's synthesis owns the plan and any artifacts.\n`;
 /**
  * Length discipline injected into every debate turn (F13 token-thrift). The
  * debate-turn ceilings are generous (4096-6144 maxTokens) and reasoning models
@@ -187,7 +302,33 @@ function personaOf(role, stance) {
             focus: stance.focus ?? "",
         };
     }
-    return { label: `${role} specialist`, lens: `your ${role} perspective`, focus: "" };
+    return {
+        label: `${role} specialist`,
+        lens: `the ${role} discipline — what a proposal costs, breaks, or unlocks in your domain, judged with a practitioner's scar tissue`,
+        focus: "",
+    };
+}
+/**
+ * Ongoing-task context block, threaded from `spec.parentContext`. Both the
+ * explicit `/council` path and auto-council attach the session/task context onto
+ * the spec (see council/index.ts), so EVERY debate stage — rebuttal, follow-up,
+ * leader evaluation, synthesis — stays anchored to the parent task and the
+ * decisions already made, instead of drifting off the isolated sub-task.
+ *
+ * `buildOpeningPrompt` already injects `conversationContext` directly, so it does
+ * NOT call this (avoids double-inclusion in the opening statement). Capped so a
+ * long session context cannot blow the per-turn debate prompt budget.
+ */
+function ongoingContextBlock(spec, cap = 4000) {
+    const ctx = spec.parentContext?.trim();
+    if (!ctx)
+        return "";
+    const body = ctx.length > cap ? `${ctx.slice(0, cap)}\n…(earlier context truncated)` : ctx;
+    return (`\n## Ongoing Task Context\n` +
+        `You are mid-way through a larger task — this debate continues that work; it does not restart it. ` +
+        `Treat every decision recorded below as settled input: build directly on it, and make your arguments advance the parent task from where it stands now. ` +
+        `Do not reopen settled decisions, do not propose starting over, and do not wander onto any problem other than the one this step serves.\n` +
+        `${body}\n\n---\n\n`);
 }
 export function buildOpeningPrompt(ctx) {
     const me = personaOf(ctx.speakerRole, ctx.speakerStance);
@@ -198,11 +339,14 @@ export function buildOpeningPrompt(ctx) {
     const focusLine = me.focus ? `\nYour specific focus: ${me.focus}\n` : "";
     const stackLock = buildStackLockSection(ctx.spec);
     return {
-        system: `You are the "${me.label}". Your lens: ${me.lens}.\n` +
-            `You are entering a discussion with the "${them.label}" (${them.lens}).\n` +
+        system: `You are the "${me.label}", and you own that chair. Your lens: ${me.lens}. ` +
+            `Speak like someone who has watched this exact class of problem fail before — not like a document.\n` +
+            `You are entering a discussion with the "${them.label}" (${them.lens}). ` +
+            `They are sharp and they will push back; a claim you cannot defend is a claim you should not open with.\n` +
             focusLine +
-            ENGLISH_ONLY_RULE +
+            buildLanguageRule(ctx.language) +
             EVIDENCE_RULE_OPENING +
+            DEBATE_SCOPE_RULE +
             concisenessRule(220) +
             (stackLock ? `\n${stackLock}\n` : "") +
             guardrails +
@@ -212,9 +356,10 @@ export function buildOpeningPrompt(ctx) {
             `Constraints: ${ctx.spec.constraints.join("; ")}\n` +
             `Success Criteria: ${ctx.spec.successCriteria.join("; ")}\n` +
             `Scope: ${ctx.spec.scope}\n\n` +
-            `Share your analysis from your stated lens. Focus on the success criteria — address each one. ` +
-            `End by asking the "${them.label}" for their perspective on your analysis.`,
-        prompt: `Analyze the problem through your stated lens. Be specific, evidence-based, and stay within your stance — do not drift into another role's perspective.`,
+            `Deliver your opening analysis in your own voice. Take the success criteria one by one: say plainly ` +
+            `which are easy, which are hard, and where — from your seat — the bodies are buried. ` +
+            `Close by putting one pointed question to the "${them.label}": the question you most need answered before you would sign off.`,
+        prompt: `Open the debate from your stated lens. Stake out a real position — a stance nobody could disagree with is not a stance. Be specific and evidence-based, and do not drift into another role's perspective; your value here is depth, not coverage.`,
     };
 }
 export function buildResponsePrompt(ctx) {
@@ -222,19 +367,22 @@ export function buildResponsePrompt(ctx) {
     const them = personaOf(ctx.partnerRole, ctx.partnerStance);
     const stackLock = buildStackLockSection(ctx.spec);
     return {
-        system: `You are the "${me.label}" (lens: ${me.lens}) responding to the "${them.label}" (lens: ${them.lens}).\n` +
-            ENGLISH_ONLY_RULE +
+        system: `You are the "${me.label}" (lens: ${me.lens}) responding to the "${them.label}" (lens: ${them.lens}). ` +
+            `This is a working session between peers — candid, specific, zero diplomacy theater.\n` +
+            buildLanguageRule(ctx.language) +
             EVIDENCE_RULE_RESPONSE +
+            DEBATE_SCOPE_RULE +
             concisenessRule(160) +
             (stackLock ? `\n${stackLock}\n` : "") +
             `\n## Discussion Brief\n` +
             `Problem: ${ctx.spec.problemStatement}\n` +
             `Success Criteria: ${ctx.spec.successCriteria.join("; ")}\n\n` +
-            `Give your honest take:\n` +
-            `- Where you agree, say so briefly and build on it\n` +
-            `- Where you disagree, explain why with your own reasoning\n` +
-            `- Share what they might be missing from your stated lens\n\n` +
-            `End with a question back to them.\n\n` +
+            ongoingContextBlock(ctx.spec) +
+            `React the way a good colleague does:\n` +
+            `- Where they are right, concede fast — one line — then build their point somewhere they did not take it\n` +
+            `- Where they are wrong, say so plainly and name the exact assumption that breaks\n` +
+            `- Name the blind spot: the thing your lens sees that theirs structurally cannot\n\n` +
+            `End by pressing them with one sharp question — aimed at the weakest joint in their argument.\n\n` +
             `Do NOT include round numbers (e.g. "Round N", "Round 2 Response", "Reply #3") ` +
             `or any numeric counter referring to the discussion round in your output. ` +
             `The orchestrator already prints round headers above your response.`,
@@ -247,28 +395,41 @@ export function buildFollowupPrompt(ctx) {
     const them = personaOf(ctx.partnerRole, ctx.partnerStance);
     const stackLock = buildStackLockSection(ctx.spec);
     return {
-        system: `You are the "${me.label}" (lens: ${me.lens}) continuing a discussion (round ${ctx.round}) with the "${them.label}" (lens: ${them.lens}).\n` +
-            ENGLISH_ONLY_RULE +
+        // Cache-prefix stability (see project_cache_prefix_stability): every clause
+        // here depends ONLY on (speaker, partner, stance, spec, language) — all
+        // stable across rounds — so this `system` string is byte-identical from
+        // round 2..N for the same speaker. The per-round-dynamic bits (round number,
+        // running summary) MUST live in the `prompt` tail below, never here: a
+        // provider prompt-cache keys on the exact prefix, and the round number used
+        // to sit in the FIRST sentence, busting the cached prefix every round.
+        system: `You are the "${me.label}" (lens: ${me.lens}) continuing a discussion with the "${them.label}" (lens: ${them.lens}). ` +
+            `The easy points are settled; what remains is the hard residue — spend your words only there.\n` +
+            buildLanguageRule(ctx.language) +
             EVIDENCE_RULE_FOLLOWUP +
             concisenessRule(140) +
             (stackLock ? `\n${stackLock}\n` : "") +
             `\n` +
-            (ctx.runningSummary
-                ? `## Discussion State So Far\n${ctx.runningSummary}\n\nFocus on UNRESOLVED points only. Do not repeat agreed positions.\n\n`
-                : "") +
+            ongoingContextBlock(ctx.spec) +
             `## Success Criteria (what we need to resolve)\n` +
             ctx.spec.successCriteria.map((c, i) => `${i + 1}. ${c}`).join("\n") +
             `\n\n` +
-            `Read their latest response. Then:\n` +
-            `- If they raised valid points, acknowledge them and update your thinking\n` +
-            `- If you still disagree, bring new evidence or a different angle\n` +
-            `- If you've changed your mind, say so explicitly\n\n` +
-            `Stay within your lens; do not drift into the other specialist's role. ` +
+            `Read their latest response like a peer, not a debater scoring points. Then:\n` +
+            `- If they landed a real hit, say so and update — changing your mind on evidence is strength, not defeat\n` +
+            `- If you still disagree, do not repeat yourself louder; bring NEW evidence or attack from an angle you have not used\n` +
+            `- If you have genuinely converged, declare it in one sentence and stop arguing\n\n` +
+            `Stay in your lane — your lens, not theirs. ` +
             `Be concise. End with: do you agree on where we've landed?\n\n` +
+            `When a "Discussion State So Far" summary is present in the message below, ` +
+            `focus on UNRESOLVED points only — restating agreed positions is dead weight.\n\n` +
             `Do NOT include round numbers (e.g. "Round N", "Response Round 2", "Round 4") ` +
             `or any numeric counter referring to the discussion round in your output. ` +
             `The orchestrator already prints round headers above your response.`,
-        prompt: (ctx.speakerLastPosition ? `Your previous position:\n${ctx.speakerLastPosition}\n\n` : "") +
+        // Per-round dynamic content lives here so the `system` prefix above stays
+        // cacheable. The first user message already changes every round (partner's
+        // latest response differs), so nothing cacheable is lost by placing the
+        // round number / running summary here.
+        prompt: (ctx.runningSummary ? `## Discussion State So Far\n${ctx.runningSummary}\n\n` : "") +
+            (ctx.speakerLastPosition ? `Your previous position:\n${ctx.speakerLastPosition}\n\n` : "") +
             `Their latest (${them.label}):\n${ctx.partnerPosition}`,
     };
 }
@@ -284,11 +445,12 @@ export function buildLeaderEvaluationPrompt(ctx) {
         : "";
     return {
         system: `You are the discussion moderator evaluating whether a multi-expert debate has produced sufficient results.\n` +
-            ENGLISH_ONLY_RULE +
+            buildLanguageRule(ctx.language) +
             (stackLock ? `\n${stackLock}\n` : "") +
             `\n## Success Criteria to Evaluate\n` +
             ctx.spec.successCriteria.map((c, i) => `${i + 1}. ${c}`).join("\n") +
             `\n\n` +
+            ongoingContextBlock(ctx.spec) +
             `For EACH criterion, determine:\n` +
             `- Is it adequately addressed by the debate? (met/not-met)\n` +
             `- What evidence from the debate supports this?\n\n` +
@@ -302,8 +464,9 @@ export function buildLeaderEvaluationPrompt(ctx) {
             outOfStackCheck +
             `Output ONLY a JSON object (no markdown):\n` +
             `{\n` +
+            `  "nextRoundFocus": "one short phrase naming the single most important point the NEXT round should resolve (empty string if you are stopping)",\n` +
             `  "allCriteriaMet": true/false,\n` +
-            `  "criteriaStatus": [{"criterion": "...", "met": true/false, "evidence": "..."}],\n` +
+            `  "criteriaStatus": [{"criterion": "...", "met": true/false, "evidence": "..."}],  // EXACTLY one entry per Success Criterion above, IN THE SAME ORDER. Do not merge, split, reorder, or invent criteria — the user pins these and watches each one.\n` +
             `  "unresolvedPoints": ["point 1"],\n` +
             `  "needsResearch": false,\n` +
             `  "researchQuery": null,\n` +
@@ -319,15 +482,17 @@ export function buildLeaderEvaluationPrompt(ctx) {
     };
 }
 // ── Round summary ────────────────────────────────────────────────────────────
-export function buildRoundSummaryPrompt(allExchanges, topic, round) {
+export function buildRoundSummaryPrompt(allExchanges, topic, round, 
+/** Feature B — resolved council debate language (undefined → English). */
+language) {
     return {
         system: `Summarize this discussion in 3-5 bullet points.` +
-            ENGLISH_ONLY_RULE +
-            `\nFocus on:\n` +
-            `1. Points where participants AGREE\n` +
-            `2. Points still in DISPUTE (with each side's core argument)\n` +
-            `3. New EVIDENCE or perspectives raised this round\n` +
-            `Be concise — one line per bullet. No preamble. ` +
+            buildLanguageRule(language) +
+            `\nYou are the debate's working memory — later turns see ONLY your bullets, so anything you drop is lost. Capture:\n` +
+            `1. AGREED — points both sides now share\n` +
+            `2. DISPUTED — live disagreements, with each side's strongest single argument (not their weakest)\n` +
+            `3. NEW — evidence, verified facts, or angles that first surfaced this round\n` +
+            `Be concise — one line per bullet. No preamble, no color commentary. ` +
             `Do NOT write "Round N" or any round-number counter in your bullets — this summary is fed into later turns, where round labels read as robotic noise. Refer to points by their content.`,
         prompt: `Round ${round} discussion on: ${topic}\n\n${allExchanges}`,
     };
@@ -431,7 +596,8 @@ export function buildDebatePlanPrompt(spec) {
         prompt: `## Topic\n${spec.problemStatement}\n\n` +
             `## Constraints\n${spec.constraints.map((c) => `- ${c}`).join("\n") || "- (none)"}\n\n` +
             `## Success Criteria\n${spec.successCriteria.map((c) => `- ${c}`).join("\n")}\n\n` +
-            `## Scope\n${spec.scope || "(unspecified)"}`,
+            `## Scope\n${spec.scope || "(unspecified)"}` +
+            ongoingContextBlock(spec),
     };
 }
 function shapeHint(s) {
@@ -505,33 +671,26 @@ export function buildSynthesisPrompt(ctx) {
     const decisiveness = finalShape.kind === "decision" || finalShape.kind === "implementation_plan"
         ? `\n## Decisiveness (recommendation/verdict)\n` +
             `Lead with the single choice you would make if the user said "you decide" — name it in the first sentence of the recommendation. ` +
-            `Do NOT hedge with "it depends", "both have merits", or an unranked list of options. ` +
+            `Do NOT hedge with "it depends", "both have merits", or an unranked list of options; the user hired a panel to get a call, not a menu. ` +
             `If the debate genuinely did not converge, say so in one sentence and STILL give your best single recommendation plus the one condition that would change it.\n`
         : "";
-    let system = `You are the team lead synthesizing a multi-specialist discussion.\n\n` +
+    let system = `You are the team lead synthesizing a multi-specialist discussion. The panel has argued; now you rule. ` +
+        `Work like an editor-in-chief: keep what survived scrutiny, cut what got refuted, credit the dissent worth keeping, ` +
+        `and hand the user something they can act on without re-reading the debate.\n\n` +
         `## Original Brief\n` +
         `Problem: ${ctx.spec.problemStatement}\n` +
         `Constraints: ${ctx.spec.constraints.join("; ")}\n` +
         `Success Criteria: ${ctx.spec.successCriteria.join("; ")}\n` +
+        ongoingContextBlock(ctx.spec) +
         intent +
         (stackLockForSynth ? `\n${stackLockForSynth}\n` : "") +
         guardrailBlock +
         decisiveness +
-        `\nProduce the answer the user requested — do NOT default to an implementation plan ` +
+        `\nProduce the answer the user actually asked for — do NOT default to an implementation plan ` +
         `unless the output shape explicitly asks for actionItems/plan. ` +
-        `Stay grounded in the discussion; do not invent facts; mark unverified claims explicitly.\n\n` +
-        `## Language Rule (mandatory)\n` +
-        `The debate above is entirely in English (debate language is forced). The user wrote the ` +
-        `Problem Statement above in their own native language. You must:\n` +
-        `- **Part 1 (JSON)**: keys, the \`type\` field, and citation/tag strings stay in ENGLISH. ` +
-        `Free-text values inside JSON fields (\`summary\`, list items, prose sections) MUST use ` +
-        `the SAME language the user used in the Problem Statement.\n` +
-        `- **Part 2 (Markdown)**: write entirely in the user's native language. Markdown headings ` +
-        `that we control (the ones listed below) stay in English as printed, but body text under ` +
-        `each heading is in the user's language.\n` +
-        `- Detect the user's language from the Problem Statement. If it's Vietnamese, write in ` +
-        `Vietnamese. If Japanese, Japanese. If English, English. Do not translate code, identifiers, ` +
-        `or quoted citation tags (\`[REFUTED via ...]\`, \`[CONFIRMED via ...]\`).\n\n` +
+        `Stay grounded in what was actually said in the debate: you may sharpen and arbitrate, but never invent facts ` +
+        `the specialists did not raise, and mark unverified claims explicitly.\n\n` +
+        buildSynthesisLanguageRule(ctx.language) +
         `Output TWO parts separated by the exact line \`---READABLE---\`:\n\n` +
         `**Part 1: JSON** — a single JSON object:\n` +
         `{\n` +
@@ -539,10 +698,36 @@ export function buildSynthesisPrompt(ctx) {
         `  "summary": "1-2 sentence executive summary in the user's native language",\n` +
         sectionLines +
         "\n" +
+        `  "nextActions": [ /* 2-4 items, see the Next Actions rule below */ ]\n` +
         `}\n\n` +
+        `## Next Actions (mandatory — YOU decide, do not default)\n` +
+        `After reading this outcome, what should the user be offered to do NEXT? This depends ` +
+        `entirely on WHY this debate happened — a bug investigation, an evaluation, a plan, and a ` +
+        `decision each warrant DIFFERENT follow-ups. A fixed "accept / research / apply" menu is wrong. ` +
+        `Choose 2-4 actions from this fixed vocabulary, ordered best-first (index 0 = your recommended ` +
+        `default), writing each label/reason in the user's native language:\n` +
+        `  - "implement" → the conclusion is ready to BUILD. Offer this whenever acting on the outcome ` +
+        `means changing code — INCLUDING a decision to refactor / remove / add. The conclusion itself is ` +
+        `the spec (no separate plan artifact needed); picking it loads that spec and carries it out ` +
+        `through the normal workflow (plan → change → verify). Make it the recommended default (index 0) ` +
+        `when the debate converged on a concrete, buildable decision. Label it with the ACTION (e.g. ` +
+        `"Triển khai …" / "Implement …"), never "continue".\n` +
+        `  - "continue_session" → return to the composer WITHOUT building. The user keeps DISCUSSING with ` +
+        `this debate as context (their next message inherits the conclusion automatically). The right ` +
+        `default for a pure evaluation / discussion whose deliverable is the analysis itself, or when the ` +
+        `user should weigh in before any code change. This ALSO covers "ask a follow-up" — do NOT emit a ` +
+        `separate follow-up action.\n` +
+        `  - "save_exit" → the analysis IS the deliverable; save it and stop here.\n` +
+        `Rules: choose from {"implement","continue_session","save_exit"}. Offer "implement" whenever the ` +
+        `outcome is actionable in code (a build decision, an implementation_plan, or a bug investigation ` +
+        `ready to fix) and make it index 0; otherwise lead with "continue_session". NEVER attach an ` +
+        `implementation-flavoured label ("triển khai", "build", "fix now") to "continue_session" — if you ` +
+        `mean build, the action MUST be "implement". Always include an escape ("save_exit" or ` +
+        `"continue_session"). Emit each as ` +
+        `{"action":"<id>","label":"<short button text>","reason":"<one line: why this fits THIS debate>"}.\n\n` +
         `**Part 2: Human-readable** — after \`---READABLE---\`, write in markdown with these headings (in this order):\n` +
         headingLines +
-        `\n\nBe decisive but evidence-grounded.`;
+        `\n\nBe decisive but evidence-grounded — a verdict without evidence is noise; evidence without a verdict is homework handed back to the user.`;
     if (styleDirective) {
         system = `${styleDirective}\n\n${system}`;
     }
@@ -582,16 +767,18 @@ ${ctx.allExchanges}${extraContext}`,
 /**
  * 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).
  */
 export function buildResearchSystemPrompt(hasUrl, internetFirst = false) {
     const urlInstruction = hasUrl
         ? `\n## URL Research Requirement\n` +
-            `This topic contains a URL. You MUST invoke a Playwright or Chrome-DevTools tool ` +
-            `to navigate to it before reporting Frontend Findings. Do not skip this step.\n`
+            `This topic contains a URL. You MUST use the native fetch_url tool (preferred for most pages) ` +
+            `or a browser tool (playwright/chrome-devtools when you need screenshots, rendered layout, or interaction) ` +
+            `before reporting Frontend Findings. Do not skip this step.\n`
         : "";
     const modeBlock = internetFirst
         ? `\n## Research Mode: INTERNET-FIRST\n` +
@@ -615,8 +802,8 @@ export function buildResearchSystemPrompt(hasUrl, internetFirst = false) {
         `If no internet search was performed, write: ` +
         `_No internet research performed (tavily/web-fetch unavailable or not needed)._\n\n` +
         `## Frontend Findings (live)\n` +
-        `Each finding must cite [snapshot:uid] from a Playwright screenshot or Chrome-DevTools inspection.\n` +
-        `If no URL was present or browser tool was not invoked, write: _No live frontend inspection performed._\n\n` +
+        `Each finding must cite [snapshot:uid] from a Playwright/Chrome-DevTools screenshot/inspection **if** a browser tool was used.\n` +
+        `For ordinary pages, cite the result of fetch_url. If no URL inspection happened, write: _No live frontend inspection performed._\n\n` +
         `Do NOT speculate. Only report what you verified with tools.`);
 }
 //# sourceMappingURL=prompts.js.map

package/dist/src/council/stance-recall.d.ts

@@ -0,0 +1,42 @@
+/**
+ * src/council/stance-recall.ts
+ *
+ * Sprint-2 item 3 — per-stance recall at debate opening. Builds the
+ * `CouncilConfig.stanceRecall` function from an EE client: given the panel's
+ * unique roles and a query, it fires ONE stance-weighted `/api/recall` per role
+ * (in parallel, bounded, failure-tolerant) and returns a `role → seed-text` map.
+ *
+ * The server weights the recall collections by the stance/role hint (researcher
+ * → principles, implementer → behavioral, verifier → self-QA), so each stance
+ * opens grounded in the slice of the brain its lens cares about — instead of the
+ * whole panel sharing one generic recall.
+ *
+ * Contract: never throws. A role whose recall fails/empties/ times out simply
+ * gets no entry in the map (that participant opens unchanged).
+ */
+import type { EERecallResponse } from "../ee/types.js";
+/** Minimal EE-client surface this helper needs (keeps it unit-testable). */
+export interface StanceRecallClient {
+    recall(query: string, opts?: {
+        stance?: string;
+        cwd?: string;
+        project?: string;
+        sourceSession?: string;
+        timeoutMs?: number;
+    }): Promise<EERecallResponse | null>;
+}
+export interface StanceRecallOptions {
+    cwd?: string;
+    project?: string;
+    sourceSession?: string;
+    /** Per-recall timeout. Kept modest so N parallel recalls don't stall openings. */
+    timeoutMs?: number;
+    /** Cap the seed text folded into each opening so it can't blow the prompt. */
+    maxSeedChars?: number;
+}
+/**
+ * Build a `stanceRecall(roles, query)` function bound to an EE client. Returns
+ * undefined when no client is available, so callers can spread it into
+ * CouncilConfig without a conditional (`stanceRecall: makeStanceRecall(...)`).
+ */
+export declare function makeStanceRecall(client: StanceRecallClient | null | undefined, opts?: StanceRecallOptions): ((roles: string[], query: string) => Promise<Map<string, string>>) | undefined;

package/dist/src/council/stance-recall.js

@@ -0,0 +1,57 @@
+/**
+ * src/council/stance-recall.ts
+ *
+ * Sprint-2 item 3 — per-stance recall at debate opening. Builds the
+ * `CouncilConfig.stanceRecall` function from an EE client: given the panel's
+ * unique roles and a query, it fires ONE stance-weighted `/api/recall` per role
+ * (in parallel, bounded, failure-tolerant) and returns a `role → seed-text` map.
+ *
+ * The server weights the recall collections by the stance/role hint (researcher
+ * → principles, implementer → behavioral, verifier → self-QA), so each stance
+ * opens grounded in the slice of the brain its lens cares about — instead of the
+ * whole panel sharing one generic recall.
+ *
+ * Contract: never throws. A role whose recall fails/empties/ times out simply
+ * gets no entry in the map (that participant opens unchanged).
+ */
+const DEFAULT_TIMEOUT_MS = 4000;
+const DEFAULT_MAX_SEED_CHARS = 1200;
+/**
+ * Build a `stanceRecall(roles, query)` function bound to an EE client. Returns
+ * undefined when no client is available, so callers can spread it into
+ * CouncilConfig without a conditional (`stanceRecall: makeStanceRecall(...)`).
+ */
+export function makeStanceRecall(client, opts = {}) {
+    if (!client)
+        return undefined;
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const maxSeedChars = opts.maxSeedChars ?? DEFAULT_MAX_SEED_CHARS;
+    return async (roles, query) => {
+        const seeds = new Map();
+        const q = (query ?? "").trim();
+        if (!q)
+            return seeds;
+        const unique = Array.from(new Set(roles.filter((r) => typeof r === "string" && r.trim())));
+        if (unique.length === 0)
+            return seeds;
+        await Promise.all(unique.map(async (role) => {
+            try {
+                const resp = await client.recall(q, {
+                    stance: role,
+                    cwd: opts.cwd,
+                    project: opts.project,
+                    sourceSession: opts.sourceSession,
+                    timeoutMs,
+                });
+                const text = resp?.text?.trim();
+                if (text)
+                    seeds.set(role, text.slice(0, maxSeedChars));
+            }
+            catch {
+                /* per-role failure is non-fatal — that stance just opens unseeded */
+            }
+        }));
+        return seeds;
+    };
+}
+//# sourceMappingURL=stance-recall.js.map

package/dist/src/council/strip-think.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Strip inline chain-of-thought markup from council LLM output.
+ *
+ * Some providers (kimi-k2.7 via opencode-go, GLM thinking variants) emit
+ * reasoning inline as `<think>…</think>` in `result.text` instead of the AI
+ * SDK's separated `reasoningText`. Rendered verbatim, the user sees hundreds
+ * of words of internal drafting above every debate turn (live-verified
+ * 2026-07-06). Applied at the council LLM boundary (src/council/llm.ts) so
+ * every consumer — debate turns, leader evals, synthesis — is covered.
+ *
+ * Handles three shapes:
+ *   - complete `<think>…</think>` blocks anywhere (global, case-insensitive)
+ *   - an unclosed trailing `<think>…` block (output truncated mid-reasoning)
+ *   - a stray leading `…</think>` (model omitted the opener; everything up to
+ *     and including the close tag is reasoning)
+ */
+export declare function stripThinkBlocks(text: string): string;