alphacouncil-agent 0.9.2 → 1.0.0

package/mcp/lib/orchestrator.mjs

@@ -1,17 +1,17 @@
-import { existsSync, mkdirSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { COUNCIL_MODES, DEBATE_ROLES, DEFAULT_TASKS, LIMITS, OUTPUT_MODES, QUICK_TASKS } from "./constants.mjs";
 import { invalidParams } from "./errors.mjs";
 import { readJson, writeJson } from "./fsutil.mjs";
 import { registry } from "./personas/registry.mjs";
-import { isChineseLanguage, resolveLanguage } from "./lang.mjs";
+import { assertReaderLanguage, isChineseLanguage, localized, resolveLanguage } from "./lang.mjs";
 import { cleanLog } from "./text.mjs";
-import { completenessStatus, verificationStatus } from "./gates.mjs";
+import { completenessStatus, masterSeatIncomplete, verificationStatus } from "./gates.mjs";
 import { agentState, appendEvent, artifactPaths, existingDebate, runPath, runId, safeSymbol, saveRun, taskState, today, updateAgent, updateTask, writeSourceManifest, writeStatus } from "./run-store.mjs";
 import { writeAllAgentsMarkdown, writeAnalystMarkdownFiles, writeArtifactIndex, writeFinalArtifacts } from "./markdown.mjs";
-import { debateFromCodex, debateQnaGate, dryDebate, dryPacket, extractJson, firstFailedDebateResult, managerFallback, mergeDebateRounds, normalizeDebate, normalizeMasterOpinion, normalizePacket, rawRecordText } from "./packets.mjs";
+import { debateFailurePacket, debateFromCodex, debateQnaGate, dryDebate, dryPacket, extractJson, firstFailedDebateResult, managerFallback, mergeDebateRounds, normalizeDebate, normalizeMasterOpinion, normalizeMasterVoice, normalizePacket, rawRecordText } from "./packets.mjs";
 import { mapLimit, runCodex } from "./codex.mjs";
-import { debatePrompt, masterPrompt, selectedMasters, taskPrompt } from "./prompts.mjs";
+import { debatePrompt, masterPrompt, masterVoicePrompt, selectedMasters, taskPrompt } from "./prompts.mjs";
 import { resolveSeatWeights } from "./weights.mjs";
 import { completedMasterOpinion, declinedMasterOpinion, planMasterSeats, reconcileMasterOpinion } from "./personas/engine.mjs";
 import { gatherGrounding } from "./grounding.mjs";
@@ -28,40 +28,67 @@ function plannedTasks(args = {}) {
   return DEFAULT_TASKS;
 }
 
-function quickTiming(args, startedAt) {
-  if (councilMode(args) !== "quick") {
-    return { council_mode: "full", debate_format: "three_round_cross_exam", time_budget_ms: null, deadline_at: null };
-  }
+function councilTiming(args, startedAt) {
+  const mode = councilMode(args);
   const requested = Number(args.total_timeout_ms);
+  const hardMaximum = mode === "quick" ? LIMITS.QUICK_HARD_MAX_MS : LIMITS.FULL_HARD_MAX_MS;
+  const defaultBudget = mode === "quick" ? LIMITS.QUICK_TOTAL_MS : LIMITS.FULL_TOTAL_MS;
   const timeBudgetMs = Number.isFinite(requested) && requested > 0
-    ? Math.min(requested, LIMITS.QUICK_HARD_MAX_MS)
-    : LIMITS.QUICK_TOTAL_MS;
+    ? Math.min(requested, hardMaximum)
+    : defaultBudget;
   const deadlineAt = args.queued_run?.deadline_at
     || new Date(Date.parse(startedAt) + timeBudgetMs).toISOString();
   return {
-    council_mode: "quick",
-    debate_format: "single_round_parallel",
+    council_mode: mode,
+    debate_format: mode === "quick" ? "single_round_parallel" : "three_round_cross_exam_parallel_per_round",
     time_budget_ms: timeBudgetMs,
     deadline_at: deadlineAt,
+    deadline_enforced: true,
+  };
+}
+
+function visibleCouncilTiming(args) {
+  const mode = councilMode(args);
+  return {
+    council_mode: mode,
+    debate_format: mode === "quick" ? "single_round_parallel" : "host_managed_visible_debate",
+    time_budget_ms: null,
+    deadline_at: null,
+    deadline_enforced: false,
   };
 }
 
-function remainingQuickBudget(run, capMs) {
-  if (run.council_mode !== "quick" || !run.deadline_at) return capMs;
+function remainingCouncilBudget(run, capMs) {
+  if (!run.deadline_at) return capMs;
+  const configuredReserve = run.council_mode === "quick"
+    ? LIMITS.QUICK_FINALIZE_RESERVE_MS
+    : LIMITS.FULL_FINALIZE_RESERVE_MS;
   const reserve = Math.min(
-    LIMITS.QUICK_FINALIZE_RESERVE_MS,
-    Math.max(100, Math.floor(Number(run.time_budget_ms || LIMITS.QUICK_TOTAL_MS) * 0.1)),
+    configuredReserve,
+    Math.max(100, Math.floor(Number(run.time_budget_ms || LIMITS.FULL_TOTAL_MS) * 0.1)),
   );
-  const usable = Date.parse(run.deadline_at) - Date.now() - reserve;
+  const killGrace = councilKillGrace(run);
+  // runCodex may need one SIGKILL grace after its timeout. Budget that grace before
+  // launching a child so the queue-to-persistence deadline remains the outer boundary.
+  const usable = Date.parse(run.deadline_at) - Date.now() - reserve - killGrace;
   return Math.max(0, Math.min(capMs, usable));
 }
 
-function deadlineResult() {
+function councilKillGrace(run) {
+  const total = Math.max(1_000, Number(run?.time_budget_ms || LIMITS.FULL_TOTAL_MS));
+  // A fixed five-second grace would consume tiny operator-supplied budgets before the
+  // first worker. Production budgets retain the full grace; small budgets scale it down.
+  // The exact same value is passed to runCodex, so forced settlement remains inside the
+  // queue-to-persistence deadline rather than becoming an unaccounted overrun.
+  return Math.min(LIMITS.SIGKILL_GRACE_MS, Math.max(50, Math.floor(total * 0.02)));
+}
+
+function deadlineResult(run) {
   return {
     ok: false,
     code: null,
     text: "",
-    stderr: "quick council global deadline exhausted",
+    stderr: `${run?.council_mode || "council"} global deadline exhausted`,
     stdout: "",
     timedOut: true,
     deadline_exhausted: true,
@@ -169,7 +196,10 @@ export function visibleRun(args) {
   const dir = runPath(id);
   mkdirSync(dir, { recursive: true });
   const startedAt = new Date().toISOString();
-  const timing = quickTiming(args, startedAt);
+  // External host threads are outside this MCP process, so the plugin cannot stop them or
+  // make a truthful queue-to-persistence SLA claim. Only analyze_symbol gets the enforced
+  // thirty-minute full-council deadline.
+  const timing = visibleCouncilTiming(args);
   const run = {
     run_id: id,
     symbol,
@@ -188,6 +218,18 @@ export function visibleRun(args) {
     tasks,
     task_status: Object.fromEntries(tasks.map((task) => [task, { task, status: "pending" }])),
     agent_status: Object.fromEntries(DEBATE_ROLES.map((role) => [role, { role, status: "pending" }])),
+    // Visible hosts call record_visible_decision once per role and round. Keep those
+    // packets separate: overwriting bull_researcher.json three times destroys the audit
+    // chain and makes a one-round shortcut indistinguishable from a full cross-exam.
+    visible_debate: {
+      contract: "role_round_audit_v1",
+      rounds_expected: councilMode(args) === "quick" ? 1 : 3,
+      rounds: { bull_researcher: {}, bear_researcher: {} },
+      qna_gate: {
+        status: councilMode(args) === "quick" ? "not_run" : "pending",
+        errors: [],
+      },
+    },
     packets: [],
     // The receipt resolves the user's exact choice once. This frozen list, not a dynamic
     // roster lookup, is the run truth and every seat is part of the completeness gate.
@@ -220,9 +262,19 @@ export function visibleRun(args) {
 export function visibleAgentSpecs(run, userPrompt = "") {
   const evidence_agents = run.tasks.map((task) => ({
     role: task,
-    title: isChineseLanguage(run.language) ? `AlphaCouncil Agent ${run.symbol} ${task} 证据子代理` : `AlphaCouncil Agent ${run.symbol} ${task} evidence subagent`,
+    title: localized(run.language, {
+      en: `AlphaCouncil Agent ${run.symbol} ${task} evidence subagent`,
+      zh: `AlphaCouncil Agent ${run.symbol} ${task} 证据子代理`,
+      ja: `AlphaCouncil Agent ${run.symbol} ${task} 証拠サブエージェント`,
+      ko: `AlphaCouncil Agent ${run.symbol} ${task} 증거 하위 에이전트`,
+    }),
     prompt: taskPrompt(task, run.symbol, run.as_of, userPrompt, run.language, run.grounding),
-    output_contract: isChineseLanguage(run.language) ? "只返回一个 JSON evidence packet。" : `Return one JSON evidence packet with reader-facing fields in ${run.language}.`,
+    output_contract: localized(run.language, {
+      en: `Return one JSON evidence packet with reader-facing fields in ${run.language}.`,
+      zh: "只返回一个 JSON evidence packet。",
+      ja: "読者向けフィールドを日本語にした JSON evidence packet を1つだけ返してください。",
+      ko: "독자용 필드를 한국어로 작성한 JSON evidence packet 하나만 반환하십시오.",
+    }),
   }));
   const debate_agents = DEBATE_ROLES.map((role) => ({
     role,
@@ -230,15 +282,17 @@ export function visibleAgentSpecs(run, userPrompt = "") {
     prompt_template: [
       debatePrompt(role, run),
       "",
-      isChineseLanguage(run.language) ? "主线程必须先粘贴已完成的 Evidence JSON，再运行这个可见代理。" : "The main thread must paste the completed Evidence JSON before running this visible agent.",
-      role === "bear_researcher" ? (isChineseLanguage(run.language) ? "主线程还必须粘贴 Bull argument JSON。" : "The main thread must also paste Bull argument JSON.") : "",
-      role === "portfolio_manager" ? (isChineseLanguage(run.language) ? "主线程还必须粘贴 Bull 和 Bear argument JSON。" : "The main thread must also paste Bull and Bear argument JSON.") : "",
+      localized(run.language, {
+        en: "The main thread must paste the completed Evidence JSON before running this visible agent.", zh: "主线程必须先粘贴已完成的 Evidence JSON，再运行这个可见代理。", ja: "メインスレッドは、この可視エージェントを実行する前に完成済みの Evidence JSON を貼り付ける必要があります。", ko: "메인 스레드는 이 표시형 에이전트를 실행하기 전에 완료된 Evidence JSON을 붙여 넣어야 합니다.",
+      }),
+      role === "bear_researcher" ? localized(run.language, { en: "The main thread must also paste Bull argument JSON.", zh: "主线程还必须粘贴 Bull argument JSON。", ja: "メインスレッドは Bull argument JSON も貼り付ける必要があります。", ko: "메인 스레드는 Bull argument JSON도 붙여 넣어야 합니다." }) : "",
+      role === "portfolio_manager" ? localized(run.language, { en: "The main thread must also paste Bull and Bear argument JSON.", zh: "主线程还必须粘贴 Bull 和 Bear argument JSON。", ja: "メインスレッドは Bull と Bear の argument JSON も貼り付ける必要があります。", ko: "메인 스레드는 Bull 및 Bear argument JSON도 붙여 넣어야 합니다." }) : "",
     ].filter(Boolean).join("\n"),
-    output_contract: isChineseLanguage(run.language) ? "只返回一个 JSON debate packet。" : `Return one JSON debate packet with reader-facing fields in ${run.language}.`,
+    output_contract: localized(run.language, { en: `Return one JSON debate packet with reader-facing fields in ${run.language}.`, zh: "只返回一个 JSON debate packet。", ja: "読者向けフィールドを日本語にした JSON debate packet を1つだけ返してください。", ko: "독자용 필드를 한국어로 작성한 JSON debate packet 하나만 반환하십시오." }),
   }));
-  // The deterministic pass runs first and settles, for free, every seat whose method cannot
-  // reach this security. Spawning an agent for a lens that has already declined is how the
-  // previous design produced ten confident essays over a screen that computed nothing.
+  // The deterministic pass freezes every physical v3 stance before language generation.
+  // Visible v3 workers below may explain that frozen result after evidence completes, but
+  // cannot turn an out_of_scope method into a directional vote.
   const plan = planMasterSeats(run, selectedMasters(run));
   run.master_decisions = plan.decisions;
   run.fact_pack_hash = plan.shared_fact_pack_hash;
@@ -253,35 +307,58 @@ export function visibleAgentSpecs(run, userPrompt = "") {
       "",
       decision ? deterministicVerdictBlock(decision, zh) : "",
       "",
-      zh
-        ? "主线程必须先粘贴已完成的 Evidence JSON，再运行这个大师议席；大师在证据之后、辩论之前运行。"
-        : "The main thread must paste the completed Evidence JSON first. Masters run after the evidence stage and before the debate.",
+      localized(run.language, {
+        en: "The main thread must paste the completed Evidence JSON first. Masters run after the evidence stage and before the debate.",
+        zh: "主线程必须先粘贴已完成的 Evidence JSON，再运行这个大师议席；大师在证据之后、辩论之前运行。",
+        ja: "メインスレッドは先に完成済みの Evidence JSON を貼り付ける必要があります。メソッド席は証拠段階の後、討論の前に実行します。",
+        ko: "메인 스레드는 먼저 완료된 Evidence JSON을 붙여 넣어야 합니다. 방법론 좌석은 증거 단계 이후, 토론 이전에 실행합니다.",
+      }),
     ].filter(Boolean).join("\n"),
-    output_contract: zh
-      ? "只返回一个 JSON master opinion。"
-      : `Return one JSON master opinion with reader-facing fields in ${run.language}.`,
+    output_contract: localized(run.language, {
+      en: `Return one JSON master opinion with reader-facing fields in ${run.language}.`,
+      zh: "只返回一个 JSON master opinion。",
+      ja: "読者向けフィールドを日本語にした JSON master opinion を1つだけ返してください。",
+      ko: "독자용 필드를 한국어로 작성한 JSON master opinion 하나만 반환하십시오.",
+    }),
   }));
-  // A declined seat is settled here rather than skipped: it is written straight into the
-  // run as an out_of_scope opinion, so the completeness gate is satisfied and no agent is
-  // ever spawned for a method that cannot look.
+  // Persist the deterministic fallback before the visible worker runs. It remains auditable
+  // if the host fails, but a full visible PM now waits for the returned explanation worker.
   if (plan.declined.length) {
     const byId = new Map((run.master_opinions || []).map((o) => [o.master, o]));
     for (const item of plan.declined) {
       if (!byId.has(item.id)) {
+        const fallback = declinedMasterOpinion(run, item);
         byId.set(item.id, attachMasterRuntimeProvenance(
           run,
           item.id,
-          declinedMasterOpinion(run, item),
+          {
+            ...fallback,
+            voice_statement: fallback.voice_statement || fallback.summary || fallback.verdict,
+            voice_status: fallback.voice_status || "deterministic_fallback",
+            statement_origin: fallback.statement_origin || "deterministic_scope_fallback",
+          },
           item.engine,
         ));
       }
+      // A declined seat already carries a readable deterministic scope statement and a frozen
+      // out_of_scope stance no worker may change, so the explanation worker could not alter
+      // the record -- it only cost one sequential model turn per seat on a host with no
+      // fan-out. On a full bench that was 26 extra turns, which roughly doubled visible
+      // wall-clock. Seats that actually reached a decision still get their worker below.
+      const requiresVisibleVoice = false;
+      const alreadyVoiced = run.master_status?.[item.id]?.status === "completed"
+        && byId.get(item.id)?.voice_status === "completed";
+      const completed = alreadyVoiced || !requiresVisibleVoice;
       run.master_status[item.id] = {
         ...(run.master_status[item.id] || {}),
         master: item.id,
-        status: "completed",
+        status: completed ? "completed" : "waiting",
         engine: item.engine || "v2_method_model",
         deterministic_decline: true,
-        completed_at: new Date().toISOString(),
+        voice_required: requiresVisibleVoice,
+        completed_at: completed
+          ? (run.master_status[item.id]?.completed_at || new Date().toISOString())
+          : null,
       };
     }
     run.master_opinions = selectedMasters(run).map((id) => byId.get(id)).filter(Boolean);
@@ -297,13 +374,16 @@ export function visibleAgentSpecs(run, userPrompt = "") {
           item.engine,
         ));
       }
+      const alreadyVoiced = run.master_status?.[item.id]?.status === "completed"
+        && byId.get(item.id)?.voice_status === "completed";
       run.master_status[item.id] = {
         ...(run.master_status[item.id] || {}),
         master: item.id,
-        status: "completed",
+        status: alreadyVoiced ? "completed" : "waiting",
         engine: item.engine,
         deterministic_execution: true,
-        completed_at: new Date().toISOString(),
+        voice_required: true,
+        completed_at: alreadyVoiced ? run.master_status[item.id].completed_at : null,
       };
     }
     run.master_opinions = selectedMasters(run).map((id) => byId.get(id)).filter(Boolean);
@@ -318,10 +398,43 @@ export function visibleAgentSpecs(run, userPrompt = "") {
       updated_at: new Date().toISOString(),
     };
   }
+  const frozenById = new Map((run.master_opinions || []).map((opinion) => [opinion.master, opinion]));
+  const v3VoiceAgents = plan.completed
+    .filter((item) => item.engine === "v3_method_runtime")
+    .filter((item) => run.master_status?.[item.id]?.status !== "completed")
+    .map((item) => {
+      const frozenOpinion = frozenById.get(item.id);
+      return {
+        role: item.id,
+        engine: "v3_method_runtime",
+        worker_kind: "visible_method_voice",
+        frozen_stance: frozenOpinion?.stance || "out_of_scope",
+        title: `AlphaCouncil Agent ${run.symbol} ${item.id} method-seat explanation`,
+        prompt_template: [
+          masterVoicePrompt(item.id, run, frozenOpinion),
+          localized(run.language, {
+            en: "The main thread MUST append the completed Evidence JSON before launching this visible worker. Use it only to explain or challenge analyst interpretation; never change the frozen stance or add a fact.",
+            zh: "主线程必须在启动这个可见方法席前附上已完成的 Evidence JSON。它只能用于解释或质疑分析师解读；不得改变冻结立场，也不得新增事实。",
+            ja: "メインスレッドは、この可視メソッド席を起動する前に完成済み Evidence JSON を追加してください。分析担当の解釈を説明・検討する目的だけに使い、凍結済みスタンスの変更や事実追加は禁止です。",
+            ko: "메인 스레드는 이 표시형 방법론 좌석을 시작하기 전에 완료된 Evidence JSON을 추가해야 합니다. 분석가 해석을 설명·검토하는 데만 사용하고 동결된 입장을 바꾸거나 사실을 추가하지 마십시오.",
+          }),
+        ].join("\n\n"),
+        output_contract: localized(run.language, {
+          en: "Return one JSON method voice: master, acknowledged_stance, statement, key_findings, disagreements, what_would_change_my_mind, source_ids, confidence. acknowledged_stance must equal frozen_stance.",
+          zh: "只返回一个 JSON 方法席陈词：master、acknowledged_stance、statement、key_findings、disagreements、what_would_change_my_mind、source_ids、confidence；acknowledged_stance 必须等于冻结立场。",
+          ja: "master、acknowledged_stance、statement、key_findings、disagreements、what_would_change_my_mind、source_ids、confidence を持つ JSON を1つだけ返し、acknowledged_stance は凍結済みスタンスと一致させてください。",
+          ko: "master, acknowledged_stance, statement, key_findings, disagreements, what_would_change_my_mind, source_ids, confidence를 가진 JSON 하나만 반환하고 acknowledged_stance는 동결된 입장과 같아야 합니다.",
+        }),
+      };
+    });
+  master_agents.push(...v3VoiceAgents);
+  const orderedMasterAgents = selectedMasters(run)
+    .map((id) => master_agents.find((agent) => agent.role === id))
+    .filter(Boolean);
   saveRun(run);
   return {
     evidence_agents,
-    master_agents,
+    master_agents: orderedMasterAgents,
     debate_agents,
     // Recorded, not hidden: a reader must be able to tell a method that judged from a method
     // that could not look, and neither from a seat that was never offered.
@@ -395,18 +508,90 @@ export function recordMasterOpinion(args) {
   if (!allowed.includes(args.master)) {
     throw invalidParams(`master ${args.master} was not selected for this run. Selected: ${allowed.join(", ") || "none"}`);
   }
+  const missingEvidence = (run.tasks || []).filter((task) => taskState(run, task).status !== "completed");
+  if (missingEvidence.length) {
+    throw invalidParams("record_master_opinion rejected: every planned evidence packet must complete first.", {
+      reason: "VISIBLE_MASTER_EVIDENCE_INCOMPLETE",
+      run_id: run.run_id,
+      missing_evidence: missingEvidence,
+    });
+  }
   const dir = runPath(run.run_id);
-  const normalized = normalizeMasterOpinion(
-    { ...(args.packet || {}), thread_id: args.thread_id },
-    args.master,
-    run,
-    rawRecordText(args.packet),
-  );
-  // A narrated stance that disagrees with the arithmetic does not get to win quietly. The
-  // deterministic verdict stands and the disagreement is preserved on the record.
-  const reconciled = reconcileMasterOpinion(run, args.master, normalized);
-  const opinion = attachMasterRuntimeProvenance(run, args.master, reconciled.opinion, reconciled.engine);
-  const { overridden } = reconciled;
+  const frozenOpinion = (run.master_opinions || []).find((item) => item.master === args.master);
+  const v3Voice = frozenOpinion?.engine === "v3_method_runtime"
+    || run.master_runtime_provenance?.[args.master]?.engine === "v3_method_runtime";
+  let opinion;
+  let overridden = false;
+  if (v3Voice) {
+    if (!frozenOpinion) throw invalidParams(`v3 master ${args.master} has no frozen deterministic opinion.`);
+    if (args.packet?.master !== args.master || args.packet?.acknowledged_stance !== frozenOpinion.stance) {
+      throw invalidParams("visible v3 method voice must acknowledge the exact frozen master and stance.", {
+        reason: "VISIBLE_MASTER_FROZEN_STANCE_MISMATCH",
+        run_id: run.run_id,
+        master: args.master,
+        expected_stance: frozenOpinion.stance,
+        supplied_master: args.packet?.master || null,
+        supplied_stance: args.packet?.acknowledged_stance || null,
+      });
+    }
+    const voice = normalizeMasterVoice(
+      args.packet,
+      args.master,
+      run,
+      frozenOpinion,
+      rawRecordText(args.packet),
+    );
+    assertVisibleReaderLanguage([
+      voice.statement,
+      ...(voice.key_findings || []),
+      ...(voice.disagreements || []),
+      ...(voice.what_would_change_my_mind || []),
+    ].filter(Boolean).join("\n"), run, `visible master voice ${args.master}`);
+    opinion = attachMasterRuntimeProvenance(run, args.master, {
+      ...frozenOpinion,
+      deterministic_summary: frozenOpinion.deterministic_summary || frozenOpinion.summary,
+      summary: voice.statement,
+      voice_statement: voice.statement,
+      voice_status: "completed",
+      voice_language: run.language,
+      statement_origin: "visible_method_voice_worker",
+      key_findings: voice.key_findings.length ? voice.key_findings : frozenOpinion.key_findings,
+      disagreements: voice.disagreements,
+      what_would_change_my_mind: voice.what_would_change_my_mind.length
+        ? voice.what_would_change_my_mind
+        : frozenOpinion.what_would_change_my_mind,
+      source_ids: [...new Set([...(frozenOpinion.source_ids || []), ...voice.source_ids])],
+      confidence: voice.confidence,
+      thread_id: args.thread_id,
+      dedicated_worker: {
+        status: "completed",
+        language: run.language,
+        execution_mode: "visible_host_thread",
+        thread_id: args.thread_id,
+      },
+    }, "v3_method_runtime");
+  } else {
+    const normalized = normalizeMasterOpinion(
+      { ...(args.packet || {}), thread_id: args.thread_id },
+      args.master,
+      run,
+      rawRecordText(args.packet),
+    );
+    assertVisibleReaderLanguage(masterReaderText(normalized), run, `visible master ${args.master}`);
+    // A narrated stance that disagrees with the arithmetic does not get to win quietly. The
+    // deterministic verdict stands and the disagreement is preserved on the record.
+    const reconciled = reconcileMasterOpinion(run, args.master, normalized);
+    opinion = attachMasterRuntimeProvenance(run, args.master, {
+      ...reconciled.opinion,
+      voice_statement: reconciled.opinion.voice_statement
+        || reconciled.opinion.summary
+        || reconciled.opinion.verdict,
+      voice_status: "completed",
+      voice_language: run.language,
+      statement_origin: "visible_legacy_method_worker",
+    }, reconciled.engine);
+    overridden = reconciled.overridden;
+  }
   const byId = new Map((run.master_opinions || []).map((item) => [item.master, item]));
   byId.set(args.master, opinion);
   run.master_opinions = allowed.map((id) => byId.get(id)).filter(Boolean);
@@ -453,6 +638,7 @@ export function recordVisiblePacket(args) {
     thread_title: args.thread_title,
     execution_mode: "visible_host_threads",
   }, task, run.symbol, run.as_of, rawRecordText(args.packet));
+  assertVisibleReaderLanguage(visibleEvidenceReaderText(packet), run, `visible evidence ${task}`);
   const byTask = new Map(run.packets.map((item) => [item.task, item]));
   byTask.set(task, packet);
   run.packets = run.tasks.map((item) => byTask.get(item)).filter(Boolean);
@@ -472,70 +658,380 @@ export function recordVisiblePacket(args) {
   return run;
 }
 
-export function recordVisibleDecision(args) {
-  const run = readJson(join(runPath(args.run_id), "evidence.json"));
-  if (run.execution_mode !== "visible_host_threads") {
-    throw invalidParams("record_visible_decision requires a run created by plan_visible_run.");
+function visibleDebateState(run) {
+  const expected = run.council_mode === "quick" ? 1 : 3;
+  run.visible_debate = run.visible_debate && typeof run.visible_debate === "object"
+    ? run.visible_debate
+    : {};
+  run.visible_debate.contract = "role_round_audit_v1";
+  run.visible_debate.rounds_expected = expected;
+  run.visible_debate.rounds = run.visible_debate.rounds && typeof run.visible_debate.rounds === "object"
+    ? run.visible_debate.rounds
+    : {};
+  for (const role of ["bull_researcher", "bear_researcher"]) {
+    run.visible_debate.rounds[role] = run.visible_debate.rounds[role]
+      && typeof run.visible_debate.rounds[role] === "object"
+      ? run.visible_debate.rounds[role]
+      : {};
+  }
+  run.visible_debate.qna_gate = run.visible_debate.qna_gate && typeof run.visible_debate.qna_gate === "object"
+    ? run.visible_debate.qna_gate
+    : { status: expected === 1 ? "not_run" : "pending", errors: [] };
+  return run.visible_debate;
+}
+
+function visibleRoundEntry(state, role, round) {
+  return state?.rounds?.[role]?.[String(round)] || null;
+}
+
+function visibleRoundPacket(state, role, round) {
+  return visibleRoundEntry(state, role, round)?.packet || null;
+}
+
+function visibleRoundNumbers(state, role) {
+  return Object.keys(state?.rounds?.[role] || {})
+    .map(Number)
+    .filter(Number.isInteger)
+    .sort((a, b) => a - b);
+}
+
+function visibleDecisionContentHash(packet) {
+  const content = JSON.parse(JSON.stringify(packet || {}));
+  delete content.raw_text;
+  delete content.thread_id;
+  delete content.thread_title;
+  delete content.execution_mode;
+  return sha256(content);
+}
+
+function roundGateArgs(state, role, round, candidate) {
+  const get = (candidateRole, candidateRound) => (
+    candidateRole === role && candidateRound === round
+      ? candidate
+      : visibleRoundPacket(state, candidateRole, candidateRound)
+  );
+  return {
+    bullR2: get("bull_researcher", 2),
+    bearR2: get("bear_researcher", 2),
+    bullR3: get("bull_researcher", 3),
+    bearR3: get("bear_researcher", 3),
+  };
+}
+
+function rejectVisibleDecision(run, reason, message, data = {}) {
+  throw invalidParams(message, { reason, run_id: run.run_id, ...data });
+}
+
+function assertVisibleRoundOrder(run, state, role, round) {
+  if (round === 1) return;
+  const previous = round - 1;
+  const missing = ["bull_researcher", "bear_researcher"]
+    .filter((side) => !visibleRoundEntry(state, side, previous))
+    .map((side) => `${side}:${previous}`);
+  if (missing.length) {
+    rejectVisibleDecision(
+      run,
+      "VISIBLE_DEBATE_ROUND_OUT_OF_ORDER",
+      `Cannot record ${role} round ${round} before both round ${previous} packets are recorded.`,
+      { role, round, missing_prerequisite_rounds: missing },
+    );
+  }
+}
+
+function assertVisibleRoundQna(run, state, role, round, packet) {
+  if (run.council_mode === "quick" || round === 1) return;
+  const gate = debateQnaGate(roundGateArgs(state, role, round, packet));
+  const ownErrors = gate.errors.filter((error) => error.startsWith(`${role} round ${round}`));
+  if (ownErrors.length) {
+    rejectVisibleDecision(
+      run,
+      "VISIBLE_DEBATE_QNA_INVALID",
+      `Rejected ${role} round ${round}: ${ownErrors.join("; ")}`,
+      { role, round, qna_gate: { status: "failed", errors: ownErrors } },
+    );
+  }
+  const other = role === "bull_researcher" ? "bear_researcher" : "bull_researcher";
+  if (round === 3 && visibleRoundEntry(state, other, 3) && gate.status !== "passed") {
+    rejectVisibleDecision(
+      run,
+      "VISIBLE_DEBATE_QNA_INVALID",
+      `Rejected ${role} round 3 because the completed cross-exam failed the exact Q&A gate.`,
+      { role, round, qna_gate: gate },
+    );
   }
+}
+
+function visibleRoundAgentPatch(run, state, role) {
+  const dir = runPath(run.run_id);
+  const rounds = visibleRoundNumbers(state, role);
+  const latest = rounds.length ? visibleRoundEntry(state, role, rounds.at(-1)) : null;
+  return {
+    rounds_completed: rounds,
+    last_completed_round: rounds.at(-1) || null,
+    round_status: rounds.length ? "completed" : "pending",
+    qna_gate: state.qna_gate.status,
+    thread_id: latest?.thread_id,
+    thread_title: latest?.thread_title,
+    output: join(dir, `${role}.json`),
+  };
+}
+
+function recordVisibleDebateRound(run, args) {
   const role = args.role;
-  if (!DEBATE_ROLES.includes(role)) throw invalidParams(`Unknown decision role: ${role}`);
+  const missingEvidence = (run.tasks || []).filter((task) => taskState(run, task).status !== "completed");
+  const missingMasters = selectedMasters(run).filter((master) => masterSeatIncomplete(run, master));
+  if (missingEvidence.length || missingMasters.length) {
+    rejectVisibleDecision(
+      run,
+      "VISIBLE_DEBATE_PREREQUISITES_INCOMPLETE",
+      "Bull/Bear debate rejected: complete every evidence packet and returned method-seat worker first.",
+      { missing_evidence: missingEvidence, missing_masters: missingMasters },
+    );
+  }
+  const expected = run.council_mode === "quick" ? [1] : [1, 2, 3];
+  if (!Number.isInteger(args.round) || !expected.includes(args.round)) {
+    rejectVisibleDecision(
+      run,
+      "VISIBLE_DEBATE_ROUND_REQUIRED",
+      `${role} requires an explicit round=${expected.join("|")}.`,
+      { role, supplied_round: args.round ?? null, allowed_rounds: expected },
+    );
+  }
+  const round = args.round;
+  const dir = runPath(run.run_id);
+  const state = visibleDebateState(run);
+  const packet = {
+    ...normalizeDebate({
+      ...(args.packet || {}),
+      thread_id: args.thread_id,
+      thread_title: args.thread_title,
+      execution_mode: "visible_host_threads",
+    }, role, run, rawRecordText(args.packet)),
+    round,
+    // A caller records exactly one round. Nested supplied rounds would create a second,
+    // unaudited history inside the packet and are therefore discarded.
+    debate_rounds: [],
+  };
+  assertVisibleReaderLanguage(debateReaderText(packet), run, `visible debate ${role} round ${round}`);
+  const contentHash = visibleDecisionContentHash(packet);
+  const existing = visibleRoundEntry(state, role, round);
+  if (existing) {
+    if (existing.content_hash !== contentHash) {
+      rejectVisibleDecision(
+        run,
+        "VISIBLE_DEBATE_ROUND_CONFLICT",
+        `Conflicting replay for ${role} round ${round}.`,
+        { role, round, existing_content_hash: existing.content_hash, submitted_content_hash: contentHash },
+      );
+    }
+    return { run, decision: existing.packet, idempotent_replay: true };
+  }
+
+  assertVisibleRoundOrder(run, state, role, round);
+  assertVisibleRoundQna(run, state, role, round, packet);
+
+  const completedAt = new Date().toISOString();
+  const roundFile = join(dir, `${role}.round-${round}.json`);
+  state.rounds[role][String(round)] = {
+    round,
+    role,
+    content_hash: contentHash,
+    packet,
+    thread_id: args.thread_id,
+    thread_title: args.thread_title,
+    output: roundFile,
+    completed_at: completedAt,
+  };
+  writeJson(roundFile, packet);
+  const merged = mergeDebateRounds(visibleRoundNumbers(state, role)
+    .map((item) => visibleRoundPacket(state, role, item)));
+  writeJson(join(dir, `${role}.json`), merged);
+
+  const quick = run.council_mode === "quick";
+  const hasBothFinalRounds = ["bull_researcher", "bear_researcher"]
+    .every((side) => visibleRoundEntry(state, side, quick ? 1 : 3));
+  if (quick) {
+    state.qna_gate = { status: "not_run", errors: [], checked_at: completedAt };
+    updateAgent(run, role, "completed", {
+      ...visibleRoundAgentPatch(run, state, role),
+      completed_at: completedAt,
+    });
+  } else if (hasBothFinalRounds) {
+    const qnaGate = debateQnaGate(roundGateArgs(state, role, round, packet));
+    // The candidate was validated before persistence. This guard protects future state
+    // migrations or a manually corrupted run file from manufacturing a passed audit.
+    if (qnaGate.status !== "passed") {
+      delete state.rounds[role][String(round)];
+      rejectVisibleDecision(
+        run,
+        "VISIBLE_DEBATE_QNA_INVALID",
+        "The completed visible cross-exam failed the exact Q&A gate.",
+        { role, round, qna_gate: qnaGate },
+      );
+    }
+    state.qna_gate = { ...qnaGate, checked_at: completedAt };
+    for (const side of ["bull_researcher", "bear_researcher"]) {
+      updateAgent(run, side, "completed", {
+        ...visibleRoundAgentPatch(run, state, side),
+        completed_at: completedAt,
+      });
+    }
+    appendEvent(run, "debate_qna_gate", state.qna_gate);
+  } else {
+    updateAgent(run, role, "waiting", visibleRoundAgentPatch(run, state, role));
+  }
+
+  run.status = "running";
+  run.phase = "visible_debate";
+  run.completed_at = null;
+  saveRun(run);
+  appendEvent(run, "visible_debate_round_recorded", {
+    role,
+    round,
+    content_hash: contentHash,
+    output: roundFile,
+    qna_gate: state.qna_gate.status,
+  });
+  writeAnalystMarkdownFiles(run, existingDebate(dir));
+  writeArtifactIndex(run, existingDebate(dir));
+  writeAllAgentsMarkdown(run, existingDebate(dir));
+  return { run, decision: packet, idempotent_replay: false };
+}
+
+function visiblePmPrerequisites(run, state) {
+  const missingEvidence = (run.tasks || [])
+    .filter((task) => taskState(run, task).status !== "completed");
+  const missingMasters = selectedMasters(run).filter((master) => masterSeatIncomplete(run, master));
+  const expected = run.council_mode === "quick" ? [1] : [1, 2, 3];
+  const missingRounds = ["bull_researcher", "bear_researcher"].flatMap((role) => (
+    expected.filter((round) => !visibleRoundEntry(state, role, round)).map((round) => `${role}:${round}`)
+  ));
+  const missingSides = ["bull_researcher", "bear_researcher"]
+    .filter((role) => agentState(run, role).status !== "completed");
+  const qnaRequired = run.council_mode !== "quick";
+  return {
+    missing_evidence: missingEvidence,
+    missing_masters: missingMasters,
+    missing_debate_rounds: missingRounds,
+    missing_debate_sides: missingSides,
+    qna_gate: state.qna_gate,
+    passed: missingEvidence.length === 0
+      && missingMasters.length === 0
+      && missingRounds.length === 0
+      && missingSides.length === 0
+      && (!qnaRequired || state.qna_gate.status === "passed"),
+  };
+}
+
+function recordVisiblePortfolioManager(run, args) {
+  if (args.round !== undefined && args.round !== null) {
+    rejectVisibleDecision(
+      run,
+      "VISIBLE_PM_ROUND_FORBIDDEN",
+      "portfolio_manager is the final decision and does not accept a debate round.",
+      { supplied_round: args.round },
+    );
+  }
   const dir = runPath(run.run_id);
+  const state = visibleDebateState(run);
   const packet = normalizeDebate({
     ...(args.packet || {}),
     thread_id: args.thread_id,
     thread_title: args.thread_title,
     execution_mode: "visible_host_threads",
-  }, role, run, rawRecordText(args.packet));
-  const file = role === "portfolio_manager" ? "manager_synthesis.json" : `${role}.json`;
-  writeJson(join(dir, file), packet);
-  // Mark the agent completed BEFORE evaluating the gates. The completeness gate now
-  // counts portfolio_manager, so reading it first would report every finished run as
-  // incomplete -- the PM would never be recorded by the time it was checked.
-  updateAgent(run, role, "completed", {
-    completed_at: new Date().toISOString(),
+  }, "portfolio_manager", run, rawRecordText(args.packet));
+  assertVisibleReaderLanguage(debateReaderText(packet), run, "visible portfolio_manager decision");
+  const contentHash = visibleDecisionContentHash(packet);
+  if (state.portfolio_manager) {
+    if (state.portfolio_manager.content_hash !== contentHash) {
+      rejectVisibleDecision(run, "VISIBLE_PM_CONFLICT", "Conflicting portfolio_manager replay.", {
+        existing_content_hash: state.portfolio_manager.content_hash,
+        submitted_content_hash: contentHash,
+      });
+    }
+    const handoffPath = join(dir, "user_response.md");
+    const reportPath = join(dir, "final_report.md");
+    const qualityPath = join(dir, "report_quality.json");
+    return {
+      run,
+      decision: state.portfolio_manager.packet,
+      idempotent_replay: true,
+      user_response_markdown: existsSync(handoffPath) ? readFileSync(handoffPath, "utf8") : "",
+      final_report_markdown: existsSync(reportPath) ? readFileSync(reportPath, "utf8") : "",
+      report_quality: existsSync(qualityPath) ? readJson(qualityPath) : null,
+      artifacts: artifactPaths(run),
+    };
+  }
+
+  const prerequisites = visiblePmPrerequisites(run, state);
+  if (!prerequisites.passed) {
+    rejectVisibleDecision(
+      run,
+      "VISIBLE_PM_PREREQUISITES_INCOMPLETE",
+      "portfolio_manager rejected: complete evidence, every selected master, all required bull/bear rounds, and the exact Q&A gate are mandatory first.",
+      prerequisites,
+    );
+  }
+
+  const completedAt = new Date().toISOString();
+  const file = join(dir, "manager_synthesis.json");
+  state.portfolio_manager = {
+    content_hash: contentHash,
+    packet,
     thread_id: args.thread_id,
     thread_title: args.thread_title,
-    output: join(dir, file),
+    output: file,
+    completed_at: completedAt,
+  };
+  writeJson(file, packet);
+  writeJson(join(dir, "decision.json"), packet);
+  updateAgent(run, "portfolio_manager", "completed", {
+    completed_at: completedAt,
+    thread_id: args.thread_id,
+    thread_title: args.thread_title,
+    output: file,
+    debate_qna_gate: state.qna_gate.status,
   });
-  let finalArtifacts = {};
-  if (role === "portfolio_manager") {
-    const gate = verificationStatus(run);
-    const completeness = completenessStatus(run);
-    writeJson(join(dir, "decision.json"), packet);
-    if (completeness.completeness === "incomplete") {
-      run.status = "incomplete";
-      run.phase = "incomplete";
-      appendEvent(run, "incomplete", {
-        missing_evidence: completeness.missing_evidence,
-        missing_debate: completeness.missing_debate,
-        missing_masters: completeness.missing_masters,
-      });
-    } else if (gate.verification === "needs_verification") {
-      run.status = "needs_verification";
-      run.phase = "needs_verification";
-      appendEvent(run, "needs_verification", { missing: gate.missing_claim_source_ids.length });
-    } else {
-      run.status = "complete";
-      run.phase = "complete";
-    }
-    run.completed_at = new Date().toISOString();
-  } else {
-    run.status = "running";
-    run.phase = "visible_debate";
+
+  const gate = verificationStatus(run);
+  const completeness = completenessStatus(run);
+  if (completeness.completeness === "incomplete") {
+    // Defensive only: visiblePmPrerequisites rejects all known incomplete states before
+    // this point. Never create a final report if a future completeness field disagrees.
+    rejectVisibleDecision(run, "VISIBLE_PM_PREREQUISITES_INCOMPLETE", "portfolio_manager completeness gate failed.", {
+      missing_evidence: completeness.missing_evidence,
+      missing_debate: completeness.missing_debate,
+      missing_masters: completeness.missing_masters,
+    });
   }
-  saveRun(run);
-  writeJson(join(dir, "evidence.json"), run);
-  if (role === "portfolio_manager") {
-    finalArtifacts = writeFinalArtifacts(run, existingDebate(dir));
-    writeJson(join(dir, "evidence.json"), run);
-    if (run.status === "complete") appendEvent(run, "run_complete", { decision: packet.rating, winner: packet.winner });
+  if (gate.verification === "needs_verification") {
+    run.status = "needs_verification";
+    run.phase = "needs_verification";
+    appendEvent(run, "needs_verification", { missing: gate.missing_claim_source_ids.length });
   } else {
-    writeAnalystMarkdownFiles(run, existingDebate(dir));
-    writeArtifactIndex(run, existingDebate(dir));
+    run.status = "complete";
+    run.phase = "complete";
   }
+  run.completed_at = completedAt;
+  saveRun(run);
+  const finalArtifacts = writeFinalArtifacts(run, existingDebate(dir));
+  saveRun(run);
+  if (run.status === "complete") appendEvent(run, "run_complete", { decision: packet.rating, winner: packet.winner });
   writeStatus(run);
   writeAllAgentsMarkdown(run, existingDebate(dir));
-  return { run, decision: packet, ...finalArtifacts };
+  return { run, decision: packet, idempotent_replay: false, ...finalArtifacts };
+}
+
+export function recordVisibleDecision(args) {
+  const run = readJson(join(runPath(args.run_id), "evidence.json"));
+  if (run.execution_mode !== "visible_host_threads") {
+    throw invalidParams("record_visible_decision requires a run created by plan_visible_run.");
+  }
+  const role = args.role;
+  if (!DEBATE_ROLES.includes(role)) throw invalidParams(`Unknown decision role: ${role}`);
+  return role === "portfolio_manager"
+    ? recordVisiblePortfolioManager(run, args)
+    : recordVisibleDebateRound(run, args);
 }
 
 export function isDryRun(args = {}) {
@@ -550,30 +1046,51 @@ export function isDryRun(args = {}) {
  * but is not a sourced claim and must never enter evidence.json or downstream debate.
  */
 export function workerFailureArtifacts({ task, symbol, asOfDate, language, timeoutMs, result, failureKind, parseError }) {
-  const chinese = isChineseLanguage(language);
+  const copy = localized(language, {
+    en: {
+      parse: `Evidence worker ${task} returned output that violated the JSON contract; it produced no evidence usable for an investment decision.`,
+      language: `Evidence worker ${task} returned reader-facing content in the wrong language; it produced no evidence usable for an investment decision.`,
+      failed: `Evidence worker ${task} timed out or failed; it produced no evidence usable for an investment decision.`,
+      inspect: `Inspect the separate ${task} failure diagnostic and retry; do not use its partial transcript as evidence.`,
+    },
+    zh: {
+      parse: `证据席位 ${task} 的输出不符合 JSON 契约；未生成可用于投资判断的证据。`,
+      language: `证据席位 ${task} 返回了错误语言的读者内容；未生成可用于投资判断的证据。`,
+      failed: `证据席位 ${task} 执行超时或失败；未生成可用于投资判断的证据。`,
+      inspect: `检查 ${task} 的独立失败诊断并重试；不得用该席位的部分对话补齐证据。`,
+    },
+    ja: {
+      parse: `証拠席 ${task} の出力は JSON 契約に違反しており、投資判断に使用できる証拠は生成されませんでした。`,
+      language: `証拠席 ${task} は指定と異なる言語の読者向け内容を返したため、投資判断に使用できる証拠は生成されませんでした。`,
+      failed: `証拠席 ${task} はタイムアウトまたは失敗し、投資判断に使用できる証拠は生成されませんでした。`,
+      inspect: `${task} の分離された失敗診断を確認して再実行してください。部分的な対話を証拠として使用してはいけません。`,
+    },
+    ko: {
+      parse: `증거 좌석 ${task}의 출력이 JSON 계약을 위반해 투자 판단에 사용할 수 있는 증거를 생성하지 못했습니다.`,
+      language: `증거 좌석 ${task}가 지정과 다른 언어의 독자용 내용을 반환해 투자 판단에 사용할 수 있는 증거를 생성하지 못했습니다.`,
+      failed: `증거 좌석 ${task}가 시간 초과 또는 실패로 투자 판단에 사용할 수 있는 증거를 생성하지 못했습니다.`,
+      inspect: `${task}의 분리된 실패 진단을 확인한 뒤 다시 실행하십시오. 부분 대화를 증거로 사용해서는 안 됩니다.`,
+    },
+  });
   const timedOut = result?.timedOut === true;
   const parseFailed = failureKind === "parse_failed";
-  const status = parseFailed ? "parse_failed" : (timedOut ? "timed_out" : "failed");
+  const languageMismatch = failureKind === "reader_language_mismatch";
+  const outputContractFailed = parseFailed || languageMismatch;
+  const status = outputContractFailed ? failureKind : (timedOut ? "timed_out" : "failed");
   const exitLabel = Number.isInteger(result?.code) ? `exit code ${result.code}` : "worker error";
   const parseMessage = cleanLog(parseError?.message || parseError || "subagent did not return valid JSON", 1_000);
-  const reason = parseFailed ? parseMessage : (timedOut ? `timeout after ${timeoutMs}ms` : exitLabel);
+  const reason = outputContractFailed ? parseMessage : (timedOut ? `timeout after ${timeoutMs}ms` : exitLabel);
   const rawOutput = String(result?.text || "");
-  const positionMatch = parseFailed ? /\bposition\s+(\d+)\b/i.exec(parseMessage) : null;
+  const positionMatch = outputContractFailed ? /\bposition\s+(\d+)\b/i.exec(parseMessage) : null;
   const parsePosition = positionMatch ? Number(positionMatch[1]) : null;
   const contextStart = Number.isInteger(parsePosition) ? Math.max(0, parsePosition - 500) : 0;
   const contextEnd = Number.isInteger(parsePosition) ? Math.min(rawOutput.length, parsePosition + 500) : 0;
   const packet = normalizePacket({
     summary: parseFailed
-      ? (chinese
-        ? `证据席位 ${task} 的输出不符合 JSON 契约；未生成可用于投资判断的证据。`
-        : `Evidence worker ${task} returned output that violated the JSON contract; it produced no evidence usable for an investment decision.`)
-      : (chinese
-        ? `证据席位 ${task} 执行超时或失败；未生成可用于投资判断的证据。`
-        : `Evidence worker ${task} timed out or failed; it produced no evidence usable for an investment decision.`),
+      ? copy.parse
+      : languageMismatch ? copy.language : copy.failed,
     claims: [],
-    open_questions: [chinese
-      ? `检查 ${task} 的独立失败诊断并重试；不得用该席位的部分对话补齐证据。`
-      : `Inspect the separate ${task} failure diagnostic and retry; do not use its partial transcript as evidence.`],
+    open_questions: [copy.inspect],
     confidence: "low",
   }, task, symbol, asOfDate, "");
   const diagnostic = {
@@ -586,11 +1103,11 @@ export function workerFailureArtifacts({ task, symbol, asOfDate, language, timeo
     timeout_ms: timeoutMs,
     exit_code: Number.isInteger(result?.code) ? result.code : null,
     reason,
-    diagnostic_excerpt: cleanLog(parseFailed
+    diagnostic_excerpt: cleanLog(outputContractFailed
       ? (rawOutput || result?.stderr || result?.stdout || reason)
       : (result?.stderr || result?.stdout || rawOutput || reason)),
-    ...(parseFailed ? {
-      parse_error: parseMessage,
+    ...(outputContractFailed ? {
+      ...(parseFailed ? { parse_error: parseMessage } : { reader_language_error: parseMessage }),
       parse_position: Number.isInteger(parsePosition) ? parsePosition : null,
       parse_context: Number.isInteger(parsePosition)
         ? cleanLog(rawOutput.slice(contextStart, contextEnd), 1_000)
@@ -603,6 +1120,68 @@ export function workerFailureArtifacts({ task, symbol, asOfDate, language, timeo
   return { packet, diagnostic };
 }
 
+function evidenceReaderText(packet) {
+  return [
+    packet?.summary,
+    ...(packet?.claims || []).flatMap((claim) => [claim?.claim, claim?.evidence]),
+    ...(packet?.open_questions || []),
+  ].filter(Boolean).join("\n");
+}
+
+function readerStrings(value, skipKeys = new Set()) {
+  if (typeof value === "string") return value.trim() ? [value] : [];
+  if (Array.isArray(value)) return value.flatMap((item) => readerStrings(item, skipKeys));
+  if (!value || typeof value !== "object") return [];
+  return Object.entries(value).flatMap(([key, item]) => (
+    skipKeys.has(key) ? [] : readerStrings(item, skipKeys)
+  ));
+}
+
+function visibleEvidenceReaderText(packet) {
+  const machine = new Set([
+    "task", "symbol", "as_of", "source_ids", "id", "url", "published_at", "retrieved_at",
+    "confidence", "information_richness", "thread_id", "execution_mode", "raw_text",
+  ]);
+  return [
+    ...readerStrings(packet, machine),
+  ].filter(Boolean).join("\n");
+}
+
+function masterReaderText(opinion) {
+  const machine = new Set([
+    "master", "symbol", "as_of", "stance", "source_ids", "confidence", "thread_id", "raw_text",
+    "engine", "voice_status", "voice_language", "dedicated_worker", "runtime_provenance",
+  ]);
+  return readerStrings(opinion, machine).join("\n");
+}
+
+function debateReaderText(packet) {
+  const machine = new Set([
+    "role", "symbol", "as_of", "decision_available", "rating", "winner", "source_ids", "confidence",
+    "thread_id", "execution_mode", "raw_text", "round", "debate_rounds",
+  ]);
+  return readerStrings(packet, machine).join("\n");
+}
+
+function assertVisibleReaderLanguage(text, run, label) {
+  try {
+    return assertReaderLanguage(text, run.language, label);
+  } catch (error) {
+    if (error?.code !== "READER_LANGUAGE_MISMATCH") throw error;
+    throw invalidParams(error.message, {
+      reason: "READER_LANGUAGE_MISMATCH",
+      label,
+      ...error.data,
+    });
+  }
+}
+
+function outputFailureKind(error) {
+  return error?.code === "READER_LANGUAGE_MISMATCH"
+    ? "reader_language_mismatch"
+    : "parse_failed";
+}
+
 /**
  * A production headless run must not silently become a prompt-only council because its
  * caller omitted `grounding`. Visible runs already collect it in rpc.mjs; this gives the
@@ -669,7 +1248,7 @@ export function queueHeadlessRun(args) {
   const dir = runPath(id);
   mkdirSync(dir, { recursive: true });
   const startedAt = new Date().toISOString();
-  const timing = quickTiming(args, startedAt);
+  const timing = councilTiming(args, startedAt);
   const run = {
     run_id: id,
     symbol,
@@ -723,21 +1302,32 @@ export async function collectEvidence(args) {
   const language = resolveLanguage(args);
   const frozen = frozenMasterSelection(args);
   const startedAt = args.queued_run?.started_at || new Date().toISOString();
-  const timing = quickTiming(args, startedAt);
+  const timing = councilTiming(args, startedAt);
   const requestedTimeoutMs = Number.isFinite(args.timeout_ms) ? args.timeout_ms : LIMITS.CODEX_TIMEOUT_MS;
   const timeoutMs = timing.council_mode === "quick"
     ? Math.min(requestedTimeoutMs, LIMITS.QUICK_EVIDENCE_MS)
-    : requestedTimeoutMs;
-  const defaultConcurrency = timing.council_mode === "quick" ? QUICK_TASKS.length : LIMITS.CONCURRENCY_DEFAULT;
-  const maxConcurrency = Math.max(LIMITS.CONCURRENCY_MIN, Math.min(LIMITS.CONCURRENCY_MAX, Number(args.max_concurrency || defaultConcurrency)));
+    : Math.min(requestedTimeoutMs, LIMITS.FULL_EVIDENCE_MS);
+  const defaultConcurrency = timing.council_mode === "quick"
+    ? QUICK_TASKS.length
+    : Math.min(tasks.length, LIMITS.FULL_EVIDENCE_CONCURRENCY);
+  // The evidence topology is contractual: every planned evidence seat starts in the same
+  // wave. A legacy low max_concurrency override may not silently turn the full fan-out back
+  // into the old three-wave, ~30-minute evidence stage. Higher values have no effect once
+  // every task can launch.
+  const requestedConcurrency = Number(args.max_concurrency || defaultConcurrency);
+  const maxConcurrency = Math.max(
+    defaultConcurrency,
+    Math.min(LIMITS.CONCURRENCY_MAX, Number.isFinite(requestedConcurrency) ? requestedConcurrency : defaultConcurrency),
+  );
   const grounding = await groundingForHeadlessRun({
     symbol,
     asOf: asOfDate,
     grounding: args.grounding,
     dryRun,
-    timeoutMs: timing.council_mode === "quick"
-      ? remainingQuickBudget(timing, LIMITS.QUICK_GROUNDING_MS)
-      : undefined,
+    timeoutMs: remainingCouncilBudget(
+      timing,
+      timing.council_mode === "quick" ? LIMITS.QUICK_GROUNDING_MS : LIMITS.FULL_GROUNDING_MS,
+    ),
   });
   const dir = runPath(id);
   mkdirSync(dir, { recursive: true });
@@ -847,15 +1437,15 @@ export async function collectEvidence(args) {
       return packet;
     }
     const workerStartedAt = Date.now();
-    const runAttempt = async (workerPrompt, budgetMs, attempt) => {
-      const allowedMs = remainingQuickBudget(run, budgetMs);
-      if (allowedMs <= 0) return { ...deadlineResult(), budget_ms: 0 };
+    const runAttempt = async (workerPrompt, budgetMs, attempt, { search = true } = {}) => {
+      const allowedMs = remainingCouncilBudget(run, budgetMs);
+      if (allowedMs <= 0) return { ...deadlineResult(run), budget_ms: 0 };
       const result = await runCodex(workerPrompt, allowedMs, ({ pid, output }) => {
         updateTask(run, task, "running", { pid, output, attempts: attempt });
       }, ({ pid, output, elapsed_ms }) => {
         updateTask(run, task, "running", { pid, output, attempts: attempt });
         appendEvent(run, "task_heartbeat", { task, pid, output, elapsed_ms, attempt });
-      });
+      }, { search, sigkillGraceMs: councilKillGrace(run) });
       return { ...result, budget_ms: allowedMs };
     };
     const commitFailure = ({ failedResult, budgetMs, attempts, failureKind, parseError, retryDiagnostic }) => {
@@ -882,8 +1472,8 @@ export async function collectEvidence(args) {
         ...(retryDiagnostic ? { retry_diagnostic: retryDiagnostic } : {}),
         attempts,
         deadline_exhausted: failedResult.deadline_exhausted === true,
-        error: failureKind === "parse_failed"
-          ? "parse_failed"
+        error: ["parse_failed", "reader_language_mismatch"].includes(failureKind)
+          ? failureKind
           : (failedResult.deadline_exhausted ? "global_deadline" : failedResult.timedOut ? "timeout" : `exit code ${failedResult.code}`),
       });
       return failure.packet;
@@ -896,10 +1486,12 @@ export async function collectEvidence(args) {
     let packet;
     try {
       packet = normalizePacket(extractJson(result.text), task, symbol, asOfDate, result.text);
+      assertReaderLanguage(evidenceReaderText(packet), language, `evidence worker ${task}`);
       commitPacket(packet);
       updateTask(run, task, "completed", { completed_at: new Date().toISOString(), output: join(dir, `${task}.json`), attempts: 1 });
       return packet;
     } catch (firstParseError) {
+      const firstFailureKind = outputFailureKind(firstParseError);
       const firstFailure = workerFailureArtifacts({
         task,
         symbol,
@@ -907,19 +1499,23 @@ export async function collectEvidence(args) {
         language,
         timeoutMs,
         result,
-        failureKind: "parse_failed",
+        failureKind: firstFailureKind,
         parseError: firstParseError,
       });
       const retryDiagnostic = join(dir, `${task}.attempt-1.failure.json`);
       writeJson(retryDiagnostic, firstFailure.diagnostic, { mode: 0o600 });
       const elapsedMs = Date.now() - workerStartedAt;
-      const retryTimeoutMs = Math.min(timeoutMs - elapsedMs, remainingQuickBudget(run, timeoutMs));
+      const retryTimeoutMs = Math.min(
+        LIMITS.PARSE_REPAIR_MS,
+        timeoutMs - elapsedMs,
+        remainingCouncilBudget(run, LIMITS.PARSE_REPAIR_MS),
+      );
       if (retryTimeoutMs <= 0) {
         return commitFailure({
           failedResult: result,
           budgetMs: result.budget_ms ?? timeoutMs,
           attempts: 1,
-          failureKind: "parse_failed",
+          failureKind: firstFailureKind,
           parseError: firstParseError,
           retryDiagnostic,
         });
@@ -929,13 +1525,22 @@ export async function collectEvidence(args) {
         task,
         attempt: 2,
         max_attempts: 2,
-        reason: "parse_failed",
+        reason: firstFailureKind,
         retry_diagnostic: retryDiagnostic,
         remaining_ms: retryTimeoutMs,
       });
       updateTask(run, task, "running", { attempts: 2, retry_diagnostic: retryDiagnostic });
-      const retryPrompt = `${prompt}\n\nTRANSPORT RETRY ONLY: Your previous final response violated the required JSON transport contract. Return exactly one JSON object matching the schema above, with no prose, Markdown fence, second object, or trailing text. Do not infer or repair facts from the prior malformed response; perform the same source-bounded task again.`;
-      result = await runAttempt(retryPrompt, retryTimeoutMs, 2);
+      const malformed = String(result.text || "").slice(0, LIMITS.PARSE_REPAIR_INPUT_CHARS);
+      const retryPrompt = [
+        "PARSE-ONLY TRANSPORT REPAIR. Do not search, browse, fetch, add facts, or redo the research.",
+        `Target task: ${task}; symbol: ${symbol}; as_of: ${asOfDate}; reader language: ${language}.`,
+        firstFailureKind === "reader_language_mismatch"
+          ? "Translate only the reader-facing strings in the supplied valid JSON into the requested language. Preserve the evidence packet schema, claims, numbers, source IDs, URLs, dates, explicit gaps and uncertainty. Return exactly one JSON object and nothing else."
+          : "Convert only the supplied malformed worker output into exactly one valid JSON object matching the evidence packet schema. Preserve claims, numbers, source IDs, URLs, dates, explicit gaps and uncertainty. If a field cannot be recovered, use an empty value and record the loss in open_questions. Return JSON only.",
+        `Write every reader-facing value in ${language}. Translation is permitted only to repair the language mismatch; do not alter facts, numbers, dates, source IDs or uncertainty.`,
+        `Malformed worker output:\n${malformed}`,
+      ].join("\n\n");
+      result = await runAttempt(retryPrompt, retryTimeoutMs, 2, { search: false });
       if (!result.ok) {
         return commitFailure({
           failedResult: result,
@@ -946,6 +1551,7 @@ export async function collectEvidence(args) {
       }
       try {
         packet = normalizePacket(extractJson(result.text), task, symbol, asOfDate, result.text);
+        assertReaderLanguage(evidenceReaderText(packet), language, `evidence worker ${task} repair`);
         commitPacket(packet);
         updateTask(run, task, "completed", {
           completed_at: new Date().toISOString(),
@@ -955,11 +1561,12 @@ export async function collectEvidence(args) {
         });
         return packet;
       } catch (secondParseError) {
+        const secondFailureKind = outputFailureKind(secondParseError);
         return commitFailure({
           failedResult: result,
           budgetMs: result.budget_ms ?? retryTimeoutMs,
           attempts: 2,
-          failureKind: "parse_failed",
+          failureKind: secondFailureKind,
           parseError: secondParseError,
           retryDiagnostic,
         });
@@ -1022,11 +1629,14 @@ export async function runHeadlessMasters(run, args = {}) {
   const requestedTimeoutMs = Number.isFinite(args.timeout_ms) ? args.timeout_ms : LIMITS.CODEX_TIMEOUT_MS;
   const timeoutMs = run.council_mode === "quick"
     ? Math.min(requestedTimeoutMs, LIMITS.QUICK_MASTER_MS)
-    : requestedTimeoutMs;
-  const defaultConcurrency = run.council_mode === "quick" ? 4 : LIMITS.CONCURRENCY_DEFAULT;
+    : Math.min(requestedTimeoutMs, LIMITS.FULL_MASTER_MS);
+  const defaultConcurrency = run.council_mode === "quick"
+    ? 4
+    : Math.min(selected.length, LIMITS.FULL_MASTER_CONCURRENCY);
+  const requestedConcurrency = Number(args.max_concurrency || defaultConcurrency);
   const maxConcurrency = Math.max(
-    LIMITS.CONCURRENCY_MIN,
-    Math.min(LIMITS.CONCURRENCY_MAX, Number(args.max_concurrency || defaultConcurrency)),
+    defaultConcurrency,
+    Math.min(LIMITS.CONCURRENCY_MAX, Number.isFinite(requestedConcurrency) ? requestedConcurrency : defaultConcurrency),
   );
   const plan = planMasterSeats(run, selected);
   const byId = new Map((run.master_opinions || []).map((opinion) => [opinion.master, opinion]));
@@ -1045,40 +1655,6 @@ export async function runHeadlessMasters(run, args = {}) {
     blocked: plan.blocked.length,
   });
 
-  for (const item of plan.declined) {
-    const opinion = attachMasterRuntimeProvenance(
-      run,
-      item.id,
-      declinedMasterOpinion(run, item),
-      item.engine,
-    );
-    byId.set(item.id, opinion);
-    writeJson(join(dir, `${item.id}.json`), opinion);
-    updateMasterStatus(run, item.id, "completed", {
-      engine: item.engine || opinion.engine,
-      deterministic_decline: true,
-      completed_at: new Date().toISOString(),
-    });
-  }
-
-  for (const item of plan.completed) {
-    const opinion = attachMasterRuntimeProvenance(
-      run,
-      item.id,
-      completedMasterOpinion(run, item),
-      item.engine,
-    );
-    byId.set(item.id, opinion);
-    writeJson(join(dir, `${item.id}.json`), opinion);
-    updateMasterStatus(run, item.id, "completed", {
-      engine: item.engine,
-      deterministic_execution: true,
-      policy_execution_hash: opinion.policy_execution_hash,
-      frozen_decision_hash: opinion.frozen_decision_hash,
-      completed_at: new Date().toISOString(),
-    });
-  }
-
   for (const item of plan.blocked) {
     updateMasterStatus(run, item.id, "failed", {
       engine: item.engine,
@@ -1087,48 +1663,155 @@ export async function runHeadlessMasters(run, args = {}) {
     });
   }
 
-  const outcomes = await mapLimit(plan.to_run, maxConcurrency, async ({ id, decision, engine }) => {
-    const prompt = [
-      masterPrompt(id, run),
-      decision ? deterministicVerdictBlock(decision, isChineseLanguage(run.language)) : "",
-    ].filter(Boolean).join("\n\n");
-    updateMasterStatus(run, id, "running", { started_at: new Date().toISOString() });
+  const workerItems = [
+    ...plan.declined.map((item) => ({
+      ...item,
+      frozenOpinion: attachMasterRuntimeProvenance(run, item.id, declinedMasterOpinion(run, item), item.engine),
+      deterministic_decline: true,
+    })),
+    ...plan.completed.map((item) => ({
+      ...item,
+      frozenOpinion: attachMasterRuntimeProvenance(run, item.id, completedMasterOpinion(run, item), item.engine),
+      deterministic_execution: true,
+    })),
+    ...plan.to_run,
+  ];
+  for (const item of workerItems) {
+    if (!item.frozenOpinion) continue;
+    writeJson(join(dir, `${item.id}.deterministic.json`), item.frozenOpinion);
+  }
+
+  const outcomes = await mapLimit(workerItems, maxConcurrency, async ({ id, decision, engine, frozenOpinion, deterministic_decline, deterministic_execution }) => {
+    const prompt = frozenOpinion
+      ? masterVoicePrompt(id, run, frozenOpinion)
+      : [
+        masterPrompt(id, run),
+        decision ? deterministicVerdictBlock(decision, isChineseLanguage(run.language)) : "",
+      ].filter(Boolean).join("\n\n");
+    updateMasterStatus(run, id, "running", {
+      started_at: new Date().toISOString(),
+      worker_kind: frozenOpinion ? "dedicated_method_voice" : "dedicated_method_judgment",
+      deterministic_decline: deterministic_decline || undefined,
+      deterministic_execution: deterministic_execution || undefined,
+    });
 
     if (run.dry_run) {
+      if (frozenOpinion) {
+        return {
+          id,
+          engine,
+          opinion: {
+            ...frozenOpinion,
+            deterministic_summary: frozenOpinion.summary,
+            voice_statement: frozenOpinion.summary,
+            voice_status: "dry_run",
+            dedicated_worker: { status: "dry_run", language: run.language, execution_mode: "dry_run" },
+          },
+        };
+      }
       const normalized = normalizeMasterOpinion({
         verdict: "DRY_RUN",
         stance: "out_of_scope",
-        summary: "Dry run: the master prompt was planned but no model judgment was executed.",
+        summary: "Dry run: the dedicated method worker was planned but no model judgment was executed.",
         what_would_change_my_mind: ["Run without dry_run to obtain a method judgment."],
         confidence: "low",
       }, id, run, prompt);
       const reconciled = reconcileMasterOpinion(run, id, normalized);
       const resolvedEngine = engine || reconciled.engine || (decision ? "v2_method_model" : "v1_prompt");
-      return { id, opinion: attachMasterRuntimeProvenance(run, id, reconciled.opinion, resolvedEngine), engine: resolvedEngine };
-    }
-
-    const allowedMs = remainingQuickBudget(run, timeoutMs);
-    const result = allowedMs <= 0
-      ? deadlineResult()
-      : await runCodex(prompt, allowedMs, ({ pid, output }) => {
-        updateMasterStatus(run, id, "running", { pid, output });
-      }, ({ pid, output, elapsed_ms }) => {
-        updateMasterStatus(run, id, "running", { pid, output, elapsed_ms });
-      });
-    if (!result.ok) {
       return {
         id,
-        error: result.timedOut ? "timeout" : `exit code ${result.code}`,
-        raw: cleanLog(result.stderr || result.stdout || result.text || "master execution failed"),
+        opinion: attachMasterRuntimeProvenance(run, id, {
+          ...reconciled.opinion,
+          voice_status: "dry_run",
+          dedicated_worker: { status: "dry_run", language: run.language, execution_mode: "dry_run" },
+        }, resolvedEngine),
+        engine: resolvedEngine,
       };
     }
-    try {
+
+    let pid = null;
+    const execute = async (workerPrompt, budgetMs, attempt) => {
+      const allowedMs = remainingCouncilBudget(run, budgetMs);
+      if (allowedMs <= 0) return { ...deadlineResult(run), budget_ms: 0 };
+      const result = await runCodex(workerPrompt, allowedMs, ({ pid: workerPid, output }) => {
+        pid = workerPid;
+        updateMasterStatus(run, id, "running", { pid: workerPid, output, attempts: attempt });
+      }, ({ pid: workerPid, output, elapsed_ms }) => {
+        updateMasterStatus(run, id, "running", { pid: workerPid, output, elapsed_ms, attempts: attempt });
+      }, { search: false, sigkillGraceMs: councilKillGrace(run) });
+      return { ...result, budget_ms: allowedMs };
+    };
+    const parse = (result) => {
+      if (frozenOpinion) {
+        const voice = normalizeMasterVoice(extractJson(result.text), id, run, frozenOpinion, result.text);
+        assertReaderLanguage([
+          voice.statement,
+          ...(voice.key_findings || []),
+          ...(voice.disagreements || []),
+          ...(voice.what_would_change_my_mind || []),
+        ].filter(Boolean).join("\n"), run.language, `master voice ${id}`);
+        return attachMasterRuntimeProvenance(run, id, {
+          ...frozenOpinion,
+          deterministic_summary: frozenOpinion.summary,
+          summary: voice.statement,
+          voice_statement: voice.statement,
+          voice_status: "completed",
+          voice_language: run.language,
+          key_findings: voice.key_findings.length ? voice.key_findings : frozenOpinion.key_findings,
+          disagreements: voice.disagreements,
+          what_would_change_my_mind: voice.what_would_change_my_mind.length
+            ? voice.what_would_change_my_mind
+            : frozenOpinion.what_would_change_my_mind,
+          source_ids: [...new Set([...(frozenOpinion.source_ids || []), ...voice.source_ids])],
+          confidence: voice.confidence,
+          dedicated_worker: { status: "completed", pid, language: run.language, execution_mode: "codex_exec" },
+        }, engine);
+      }
       const normalized = normalizeMasterOpinion(extractJson(result.text), id, run, result.text);
+      assertReaderLanguage([
+        normalized.summary,
+        normalized.verdict,
+        ...(normalized.key_findings || []),
+        ...(normalized.disagreements || []),
+        ...(normalized.what_would_change_my_mind || []),
+      ].filter(Boolean).join("\n"), run.language, `legacy master voice ${id}`);
       const reconciled = reconcileMasterOpinion(run, id, normalized);
       const resolvedEngine = engine || reconciled.engine || (decision ? "v2_method_model" : "v1_prompt");
-      return { id, opinion: attachMasterRuntimeProvenance(run, id, reconciled.opinion, resolvedEngine), engine: resolvedEngine };
-    } catch (error) {
-      return { id, error: "parse_failed", raw: cleanLog(result.text || String(error?.message || error)) };
+      return attachMasterRuntimeProvenance(run, id, {
+        ...reconciled.opinion,
+        voice_statement: reconciled.opinion.summary || reconciled.opinion.verdict,
+        voice_status: "completed",
+        voice_language: run.language,
+        dedicated_worker: { status: "completed", pid, language: run.language, execution_mode: "codex_exec" },
+      }, resolvedEngine);
+    };
+
+    let result = await execute(prompt, timeoutMs, 1);
+    if (!result.ok) {
+      return { id, error: result.deadline_exhausted ? "global_deadline" : result.timedOut ? "timeout" : `exit code ${result.code}`, raw: cleanLog(result.stderr || result.stdout || "method worker failed") };
+    }
+    try {
+      return { id, opinion: parse(result), engine };
+    } catch (firstParseError) {
+      const firstFailureKind = outputFailureKind(firstParseError);
+      const repairBudget = Math.min(LIMITS.PARSE_REPAIR_MS, remainingCouncilBudget(run, LIMITS.PARSE_REPAIR_MS));
+      if (repairBudget <= 0) return { id, error: firstFailureKind, raw: cleanLog(firstParseError?.message || result.text) };
+      const repairPrompt = [
+        "PARSE-ONLY TRANSPORT REPAIR. Do not browse, search, add facts or change the frozen method stance.",
+        `Master ID: ${id}; required acknowledged stance: ${frozenOpinion?.stance || "use the original stance"}; output language: ${run.language}.`,
+        frozenOpinion
+          ? "Return one JSON object with master, acknowledged_stance, statement, key_findings, disagreements, what_would_change_my_mind, source_ids and confidence."
+          : "Return one JSON object matching the master_opinion schema from the original prompt.",
+        `Write every reader-facing value in ${run.language}. Translation is allowed only to repair language; preserve the frozen stance, facts, numbers and source IDs.`,
+        `Malformed output:\n${String(result.text || "").slice(0, LIMITS.PARSE_REPAIR_INPUT_CHARS)}`,
+      ].join("\n\n");
+      result = await execute(repairPrompt, repairBudget, 2);
+      if (!result.ok) return { id, error: result.deadline_exhausted ? "global_deadline" : result.timedOut ? "timeout" : `exit code ${result.code}`, raw: cleanLog(result.stderr || "method repair failed") };
+      try {
+        return { id, opinion: parse(result), engine };
+      } catch (secondParseError) {
+        return { id, error: outputFailureKind(secondParseError), raw: cleanLog(secondParseError?.message || result.text) };
+      }
     }
   }, (error, { id }) => ({
     id,
@@ -1138,13 +1821,37 @@ export async function runHeadlessMasters(run, args = {}) {
 
   for (const outcome of outcomes) {
     if (!outcome.opinion) {
-      updateMasterStatus(run, outcome.id, "failed", { error: outcome.error, output: outcome.raw });
+      const diagnosticPath = join(dir, `${outcome.id}.failure.json`);
+      writeJson(diagnosticPath, {
+        master: outcome.id,
+        failure_kind: outcome.error,
+        diagnostic: outcome.raw,
+        public_summary: outcome.error === "reader_language_mismatch"
+          ? localized(run.language, {
+            en: "The dedicated method worker returned reader-facing content in the wrong language; no method-seat statement is available.",
+            zh: "专属方法席 worker 返回了错误语言的读者内容；没有可用的方法席发言。",
+            ja: "専用メソッド席ワーカーは指定と異なる言語の読者向け内容を返したため、利用可能なメソッド席の発言はありません。",
+            ko: "전용 방법론 좌석 워커가 지정과 다른 언어의 독자용 내용을 반환해 사용할 수 있는 방법론 좌석 발언이 없습니다.",
+          })
+          : localized(run.language, {
+            en: "The dedicated method worker did not complete; no method-seat statement is available.",
+            zh: "专属方法席 worker 未完成；没有可用的方法席发言。",
+            ja: "専用メソッド席ワーカーが完了せず、利用可能なメソッド席の発言はありません。",
+            ko: "전용 방법론 좌석 워커가 완료되지 않아 사용할 수 있는 방법론 좌석 발언이 없습니다.",
+          }),
+      }, { mode: 0o600 });
+      updateMasterStatus(run, outcome.id, "failed", { error: outcome.error, diagnostic: diagnosticPath });
       continue;
     }
     byId.set(outcome.id, outcome.opinion);
     writeJson(join(dir, `${outcome.id}.json`), outcome.opinion);
     updateMasterStatus(run, outcome.id, "completed", {
       engine: outcome.opinion.engine || outcome.engine,
+      worker_kind: outcome.opinion.dedicated_worker?.execution_mode === "dry_run"
+        ? "dedicated_method_voice_dry_run"
+        : "dedicated_method_worker",
+      worker_pid: outcome.opinion.dedicated_worker?.pid || null,
+      voice_status: outcome.opinion.voice_status || "completed",
       completed_at: new Date().toISOString(),
       output: join(dir, `${outcome.id}.json`),
     });
@@ -1162,50 +1869,112 @@ export async function runHeadlessMasters(run, args = {}) {
 export async function runDebateRole(run, role, context, timeoutMs) {
   const prompt = debatePrompt(role, run, context);
   updateAgent(run, role, "running", { started_at: new Date().toISOString(), round: context.round });
-  const result = timeoutMs <= 0
-    ? deadlineResult()
+  let result = timeoutMs <= 0
+    ? deadlineResult(run)
     : await runCodex(prompt, timeoutMs, ({ pid, output }) => {
       updateAgent(run, role, "running", { pid, output, round: context.round });
     }, ({ pid, output, elapsed_ms }) => {
       updateAgent(run, role, "running", { pid, output, round: context.round });
       appendEvent(run, "agent_heartbeat", { role, round: context.round, pid, output, elapsed_ms });
-    });
-  const packet = debateFromCodex(result, role, run, prompt);
+    }, { search: false, sigkillGraceMs: councilKillGrace(run) });
+  const enforceLanguage = (candidate) => {
+    if (candidate?.failure_kind) return candidate;
+    try {
+      assertReaderLanguage([
+        candidate?.summary,
+        ...(candidate?.long_thesis || []),
+        ...(candidate?.short_thesis || []),
+        ...(candidate?.catalysts || []),
+        ...(candidate?.risks || []),
+        candidate?.position,
+        ...(candidate?.invalidation || []),
+        ...(candidate?.questions || []),
+        ...(candidate?.questions_answered || []).flatMap((item) => [item?.question, item?.answer]),
+        candidate?.report_markdown,
+      ].filter(Boolean).join("\n"), run.language, `${role} debate output`);
+      return candidate;
+    } catch (error) {
+      return debateFailurePacket(role, run, "reader_language_mismatch");
+    }
+  };
+  let packet = enforceLanguage(debateFromCodex(result, role, run, prompt));
+  if (result.ok && ["parse_failed", "reader_language_mismatch"].includes(packet.failure_kind)) {
+    const repairBudget = Math.min(LIMITS.PARSE_REPAIR_MS, remainingCouncilBudget(run, LIMITS.PARSE_REPAIR_MS));
+    if (repairBudget > 0) {
+      const repairReason = packet.failure_kind;
+      appendEvent(run, "agent_parse_repair", { role, round: context.round, budget_ms: repairBudget, reason: repairReason });
+      const repairPrompt = [
+        "PARSE-ONLY TRANSPORT REPAIR. Do not search, browse, add facts or redo the analysis.",
+        `Role: ${role}; symbol: ${run.symbol}; as_of: ${run.as_of}; reader language: ${run.language}; round: ${context.round || "final"}.`,
+        repairReason === "reader_language_mismatch"
+          ? "Translate only the reader-facing strings in the supplied valid debate-packet JSON. Preserve exact round-2 questions, exact round-3 question bindings, facts, numbers, source IDs and uncertainty. Return one JSON object only."
+          : "Convert only the supplied malformed output into one valid debate-packet JSON object. Preserve exact round-2 questions and exact round-3 question bindings when present. Return JSON only.",
+        `Write every reader-facing value in ${run.language}. Translation is allowed only to repair language; preserve facts, numbers, source IDs and exact Q&A bindings.`,
+        `Malformed output:\n${String(result.text || "").slice(0, LIMITS.PARSE_REPAIR_INPUT_CHARS)}`,
+      ].join("\n\n");
+      result = await runCodex(repairPrompt, repairBudget, ({ pid, output }) => {
+        updateAgent(run, role, "running", { pid, output, round: context.round, attempts: 2 });
+      }, () => {}, { search: false, sigkillGraceMs: councilKillGrace(run) });
+      packet = enforceLanguage(debateFromCodex(result, role, run, repairPrompt));
+    }
+  }
   const roundCompletedAt = new Date().toISOString();
-  // A role can run three times. Leaving it marked `running` after one awaited invocation
-  // returned made sequential rounds look concurrent in status.json. Record the dependency
-  // boundary explicitly while reserving `completed` for the merged three-round artifact.
-  updateAgent(run, role, "waiting", {
-    round: context.round,
-    round_status: "completed",
-    last_completed_round: context.round,
-    round_completed_at: roundCompletedAt,
-    pid: null,
-    output: null,
-  });
-  appendEvent(run, "agent_round_completed", {
-    role,
-    round: context.round,
-    ok: result.ok,
-    timed_out: result.timedOut === true,
-    verdict: packet.verdict,
-    question_count: packet.questions.length,
-    answered_count: packet.questions_answered.length,
-  });
+  if (Number.isInteger(context.round)) {
+    // A role can run three times. Leaving it marked `running` after one awaited invocation
+    // returned made sequential rounds look concurrent in status.json. Record the dependency
+    // boundary explicitly while reserving `completed` for the merged three-round artifact.
+    updateAgent(run, role, "waiting", {
+      round: context.round,
+      round_status: "completed",
+      last_completed_round: context.round,
+      round_completed_at: roundCompletedAt,
+      pid: null,
+      output: null,
+    });
+    appendEvent(run, "agent_round_completed", {
+      role,
+      round: context.round,
+      ok: result.ok,
+      timed_out: result.timedOut === true,
+      verdict: packet.verdict,
+      failure_kind: packet.failure_kind,
+      question_count: packet.questions.length,
+      answered_count: packet.questions_answered.length,
+    });
+  } else {
+    updateAgent(run, role, "waiting", {
+      synthesis_status: "completed",
+      synthesis_completed_at: roundCompletedAt,
+      pid: null,
+      output: null,
+    });
+    appendEvent(run, "agent_role_completed", {
+      role,
+      ok: result.ok,
+      timed_out: result.timedOut === true,
+      verdict: packet.verdict,
+      failure_kind: packet.failure_kind,
+    });
+  }
   return { packet, result };
 }
 
 function debateFailure(step) {
-  if (step.result.ok && step.packet.verdict !== "PARSE_FAILED") return undefined;
+  if (!step.result.ok) {
+    if (step.result.deadline_exhausted) return "global_deadline";
+    if (step.result.timedOut) return "timeout";
+    if (Number.isInteger(step.result.code)) return `exit code ${step.result.code}`;
+    return "unexpected_error";
+  }
+  if (step.packet.failure_kind) return step.packet.failure_kind;
   if (step.packet.verdict === "PARSE_FAILED") return "parse_failed";
-  if (step.result.deadline_exhausted) return "global_deadline";
-  return step.result.timedOut ? "timeout" : `exit code ${step.result.code ?? "unknown"}`;
+  return undefined;
 }
 
 async function synthesizeQuickDecision(run, args, timeoutMs, outputMode) {
   const dir = runPath(run.run_id);
   appendEvent(run, "debate_round", { round: 1, format: "single_round_parallel" });
-  const sideBudget = remainingQuickBudget(run, timeoutMs);
+  const sideBudget = remainingCouncilBudget(run, timeoutMs);
   const [bullOutcome, bearOutcome] = await Promise.allSettled([
     runDebateRole(run, "bull_researcher", { round: 1, brief: "quick long case" }, sideBudget),
     runDebateRole(run, "bear_researcher", { round: 1, brief: "quick short case" }, sideBudget),
@@ -1249,21 +2018,11 @@ async function synthesizeQuickDecision(run, args, timeoutMs, outputMode) {
   });
   writeAllAgentsMarkdown(run, { bull, bear });
 
-  const managerPrompt = debatePrompt("portfolio_manager", run, { bull, bear, outputMode });
-  updateAgent(run, "portfolio_manager", "running", { started_at: new Date().toISOString() });
-  const managerBudget = remainingQuickBudget(run, timeoutMs);
-  const managerResult = managerBudget <= 0
-    ? deadlineResult()
-    : await runCodex(managerPrompt, managerBudget, ({ pid, output }) => {
-      updateAgent(run, "portfolio_manager", "running", { pid, output });
-    }, ({ pid, output, elapsed_ms }) => {
-      updateAgent(run, "portfolio_manager", "running", { pid, output });
-      appendEvent(run, "agent_heartbeat", { role: "portfolio_manager", pid, output, elapsed_ms });
-    });
-  const manager = managerResult.ok
-    ? debateFromCodex(managerResult, "portfolio_manager", run, managerPrompt)
-    : managerFallback(run, args.prompt || "");
-  const managerOk = managerResult.ok && manager.verdict !== "PARSE_FAILED";
+  const managerBudget = remainingCouncilBudget(run, timeoutMs);
+  const managerStep = await runDebateRole(run, "portfolio_manager", { bull, bear, outputMode }, managerBudget);
+  const managerError = debateFailure(managerStep);
+  const managerOk = !managerError;
+  const manager = managerOk ? managerStep.packet : managerFallback(run, args.prompt || "");
   writeJson(join(dir, "manager_synthesis.json"), manager);
   writeJson(join(dir, "decision.json"), manager);
   updateAgent(run, "portfolio_manager", managerOk ? "completed" : "failed", {
@@ -1271,9 +2030,7 @@ async function synthesizeQuickDecision(run, args, timeoutMs, outputMode) {
     output: join(dir, "manager_synthesis.json"),
     error: managerOk
       ? undefined
-      : manager.verdict === "PARSE_FAILED"
-        ? "parse_failed"
-        : managerResult.deadline_exhausted ? "global_deadline" : managerResult.timedOut ? "timeout" : `exit code ${managerResult.code ?? "unknown"}`,
+      : managerError,
   });
 
   const gate = verificationStatus(run);
@@ -1340,6 +2097,47 @@ function finalizeBeforeDebate(run, args, reason) {
   return { bull: null, bear: null, manager, ...finalArtifacts };
 }
 
+function finalizeAfterDebateFailure(run, args, reason, bullRounds = [], bearRounds = []) {
+  const dir = runPath(run.run_id);
+  const bull = mergeDebateRounds(bullRounds.map((step) => step?.packet).filter(Boolean));
+  const bear = mergeDebateRounds(bearRounds.map((step) => step?.packet).filter(Boolean));
+  if (bull) writeJson(join(dir, "bull_researcher.json"), bull);
+  if (bear) writeJson(join(dir, "bear_researcher.json"), bear);
+  updateAgent(run, "bull_researcher", "failed", {
+    error: reason,
+    completed_at: new Date().toISOString(),
+    output: bull ? join(dir, "bull_researcher.json") : undefined,
+  });
+  updateAgent(run, "bear_researcher", "failed", {
+    error: reason,
+    completed_at: new Date().toISOString(),
+    output: bear ? join(dir, "bear_researcher.json") : undefined,
+  });
+  updateAgent(run, "portfolio_manager", "skipped", {
+    error: reason,
+    completed_at: new Date().toISOString(),
+  });
+  const manager = managerFallback(run, args.prompt || "");
+  writeJson(join(dir, "manager_synthesis.json"), manager);
+  writeJson(join(dir, "decision.json"), manager);
+  run.phase = "incomplete";
+  run.status = "incomplete";
+  run.completed_at = new Date().toISOString();
+  const completeness = completenessStatus(run);
+  appendEvent(run, "incomplete", {
+    reason,
+    downstream_model_calls_skipped: true,
+    missing_evidence: completeness.missing_evidence,
+    missing_debate: completeness.missing_debate,
+    missing_masters: completeness.missing_masters,
+  });
+  const finalArtifacts = writeFinalArtifacts(run, { bull, bear, manager });
+  writeJson(join(dir, "evidence.json"), run);
+  writeStatus(run);
+  writeAllAgentsMarkdown(run, { bull, bear, manager });
+  return { bull, bear, manager, ...finalArtifacts };
+}
+
 export async function synthesizeDecision(run, args) {
   const dir = runPath(run.run_id);
   const requestedSynthesisMs = Number.isFinite(args.synthesis_timeout_ms)
@@ -1347,7 +2145,7 @@ export async function synthesizeDecision(run, args) {
     : Number(args.timeout_ms || LIMITS.CODEX_TIMEOUT_MS);
   const timeoutMs = run.council_mode === "quick"
     ? Math.min(requestedSynthesisMs, LIMITS.QUICK_SYNTHESIS_MS)
-    : requestedSynthesisMs;
+    : Math.min(requestedSynthesisMs, LIMITS.FULL_DEBATE_MS);
   const outputMode = OUTPUT_MODES.includes(args.output_mode) ? args.output_mode : "public_equity";
   run.phase = "debate";
   run.status = "running";
@@ -1403,28 +2201,66 @@ export async function synthesizeDecision(run, args) {
     return synthesizeQuickDecision(run, args, timeoutMs, outputMode);
   }
 
-  // Three-round debate: R1 cases, R2 cross-rebuttal, R3 Q&A.
-  appendEvent(run, "debate_round", { round: 1 });
-  const bullR1 = await runDebateRole(run, "bull_researcher", { round: 1, brief: "long" }, timeoutMs);
-  const bearR1 = await runDebateRole(run, "bear_researcher", { round: 1, brief: "short", bull: bullR1.packet }, timeoutMs);
-
-  appendEvent(run, "debate_round", { round: 2 });
-  const bullR2 = await runDebateRole(run, "bull_researcher", { round: 2, otherCaseR1: bearR1.packet }, timeoutMs);
-  const bearR2 = await runDebateRole(run, "bear_researcher", { round: 2, otherCaseR1: bullR1.packet }, timeoutMs);
-
-  appendEvent(run, "debate_round", { round: 3 });
-  const bullR3 = await runDebateRole(run, "bull_researcher", {
-    round: 3,
-    otherCaseR1: bearR2.packet,
-    questionsYouAsked: bullR2.packet.questions,
-    questionsForYou: bearR2.packet.questions,
-  }, timeoutMs);
-  const bearR3 = await runDebateRole(run, "bear_researcher", {
-    round: 3,
-    otherCaseR1: bullR2.packet,
-    questionsYouAsked: bearR2.packet.questions,
-    questionsForYou: bullR2.packet.questions,
-  }, timeoutMs);
+  const rejectedStep = (reason, role) => {
+    const result = {
+      ok: false, code: null, text: "", stderr: cleanLog(reason?.message || reason), stdout: "",
+      timedOut: false, unexpected_error: true,
+    };
+    return { result, packet: debateFromCodex(result, role, run, "unexpected debate failure") };
+  };
+  const parallelRound = async (round, bullContext, bearContext) => {
+    const budget = remainingCouncilBudget(run, timeoutMs);
+    appendEvent(run, "debate_round", { round, format: "parallel_per_round", budget_ms: budget });
+    const [bullOutcome, bearOutcome] = await Promise.allSettled([
+      runDebateRole(run, "bull_researcher", { round, ...bullContext }, budget),
+      runDebateRole(run, "bear_researcher", { round, ...bearContext }, budget),
+    ]);
+    return {
+      bull: bullOutcome.status === "fulfilled" ? bullOutcome.value : rejectedStep(bullOutcome.reason, "bull_researcher"),
+      bear: bearOutcome.status === "fulfilled" ? bearOutcome.value : rejectedStep(bearOutcome.reason, "bear_researcher"),
+    };
+  };
+  const failedRound = (round) => [debateFailure(round.bull), debateFailure(round.bear)].filter(Boolean);
+
+  // Three-round debate with a strict inter-round barrier and parallel sides per round.
+  const r1 = await parallelRound(1, { brief: "long" }, { brief: "short" });
+  if (failedRound(r1).length) {
+    return finalizeAfterDebateFailure(run, args, `debate_round_1_failed:${failedRound(r1).join(",")}`, [r1.bull], [r1.bear]);
+  }
+
+  const r2 = await parallelRound(2,
+    { otherCaseR1: r1.bear.packet },
+    { otherCaseR1: r1.bull.packet });
+  if (failedRound(r2).length) {
+    return finalizeAfterDebateFailure(run, args, `debate_round_2_failed:${failedRound(r2).join(",")}`, [r1.bull, r2.bull], [r1.bear, r2.bear]);
+  }
+  const exactlyThreeQuestions = (packet) => Array.isArray(packet?.questions)
+    && packet.questions.length === 3
+    && packet.questions.every((question) => typeof question === "string" && question.trim());
+  if (!exactlyThreeQuestions(r2.bull.packet) || !exactlyThreeQuestions(r2.bear.packet)) {
+    appendEvent(run, "debate_qna_gate", { status: "failed", errors: ["round 2 did not produce exactly three questions per side"] });
+    return finalizeAfterDebateFailure(run, args, "debate_round_2_questions_incomplete", [r1.bull, r2.bull], [r1.bear, r2.bear]);
+  }
+
+  const r3 = await parallelRound(3, {
+    otherCaseR1: r2.bear.packet,
+    questionsYouAsked: r2.bull.packet.questions,
+    questionsForYou: r2.bear.packet.questions,
+  }, {
+    otherCaseR1: r2.bull.packet,
+    questionsYouAsked: r2.bear.packet.questions,
+    questionsForYou: r2.bull.packet.questions,
+  });
+  if (failedRound(r3).length) {
+    return finalizeAfterDebateFailure(run, args, `debate_round_3_failed:${failedRound(r3).join(",")}`, [r1.bull, r2.bull, r3.bull], [r1.bear, r2.bear, r3.bear]);
+  }
+
+  const bullR1 = r1.bull;
+  const bearR1 = r1.bear;
+  const bullR2 = r2.bull;
+  const bearR2 = r2.bear;
+  const bullR3 = r3.bull;
+  const bearR3 = r3.bear;
 
   const bull = mergeDebateRounds([bullR1.packet, bullR2.packet, bullR3.packet]);
   const bear = mergeDebateRounds([bearR1.packet, bearR2.packet, bearR3.packet]);
@@ -1435,6 +2271,9 @@ export async function synthesizeDecision(run, args) {
     bearR3: bearR3.packet,
   });
   appendEvent(run, "debate_qna_gate", qnaGate);
+  if (qnaGate.status !== "passed") {
+    return finalizeAfterDebateFailure(run, args, "debate_round_3_qna_incomplete", [bullR1, bullR2, bullR3], [bearR1, bearR2, bearR3]);
+  }
   const bullQnaErrors = qnaGate.errors.filter((error) => error.startsWith("bull_researcher"));
   const bearQnaErrors = qnaGate.errors.filter((error) => error.startsWith("bear_researcher"));
   const bullTransportOk = [bullR1, bullR2, bullR3].every((step) => step.result.ok);
@@ -1472,24 +2311,17 @@ export async function synthesizeDecision(run, args) {
   });
   writeAllAgentsMarkdown(run, { bull, bear });
 
-  const managerPrompt = debatePrompt("portfolio_manager", run, { bull, bear, outputMode });
-  updateAgent(run, "portfolio_manager", "running", { started_at: new Date().toISOString() });
-  const managerResult = await runCodex(managerPrompt, timeoutMs, ({ pid, output }) => {
-    updateAgent(run, "portfolio_manager", "running", { pid, output });
-  }, ({ pid, output, elapsed_ms }) => {
-    updateAgent(run, "portfolio_manager", "running", { pid, output });
-    appendEvent(run, "agent_heartbeat", { role: "portfolio_manager", pid, output, elapsed_ms });
-  });
-  const manager = managerResult.ok
-    ? debateFromCodex(managerResult, "portfolio_manager", run, managerPrompt)
-    : managerFallback(run, args.prompt || "");
+  const pmBudget = remainingCouncilBudget(run, Math.min(requestedSynthesisMs, LIMITS.FULL_PM_MS));
+  const managerStep = await runDebateRole(run, "portfolio_manager", { bull, bear, outputMode }, pmBudget);
+  const managerOk = !debateFailure(managerStep);
+  const manager = managerOk ? managerStep.packet : managerFallback(run, args.prompt || "");
   const gate = verificationStatus(run);
   writeJson(join(dir, "manager_synthesis.json"), manager);
   writeJson(join(dir, "decision.json"), manager);
-  updateAgent(run, "portfolio_manager", managerResult.ok && manager.verdict !== "PARSE_FAILED" ? "completed" : "failed", {
+  updateAgent(run, "portfolio_manager", managerOk ? "completed" : "failed", {
     completed_at: new Date().toISOString(),
     output: join(dir, "manager_synthesis.json"),
-    error: managerResult.ok ? undefined : (managerResult.timedOut ? "timeout" : `exit code ${managerResult.code}`),
+    error: managerOk ? undefined : debateFailure(managerStep),
   });
   const completeness = completenessStatus(run);
   run.completed_at = new Date().toISOString();
@@ -1532,7 +2364,7 @@ export async function analyzeSymbol(args) {
       artifacts: debate.artifacts || artifactPaths(run),
     };
   }
-  if (run.council_mode === "quick" && remainingQuickBudget(run, 1) <= 0) {
+  if (remainingCouncilBudget(run, 1) <= 0) {
     const debate = finalizeBeforeDebate(run, args, "global_deadline_before_masters");
     return {
       run,
@@ -1546,8 +2378,7 @@ export async function analyzeSymbol(args) {
   }
   await runHeadlessMasters(run, args);
   gate = completenessStatus(run);
-  if (gate.missing_masters.length > 0
-    || (run.council_mode === "quick" && remainingQuickBudget(run, 1) <= 0)) {
+  if (gate.missing_masters.length > 0 || remainingCouncilBudget(run, 1) <= 0) {
     const debate = finalizeBeforeDebate(run, args,
       gate.missing_masters.length ? "master_gate_failed" : "global_deadline_before_debate");
     return {