alphacouncil-agent 0.9.2 → 0.9.4

package/mcp/lib/packets.mjs

@@ -1,7 +1,7 @@
 import { join } from "node:path";
 import { LIMITS, MASTER_STANCES, RATINGS } from "./constants.mjs";
 import { internalError } from "./errors.mjs";
-import { isChineseLanguage } from "./lang.mjs";
+import { isChineseLanguage, languageKey, localized } from "./lang.mjs";
 import { cleanLog, clip } from "./text.mjs";
 import { scopedSourceId } from "./gates.mjs";
 import { runPath } from "./run-store.mjs";
@@ -85,6 +85,7 @@ export function normalizeDebate(packet, role, run, raw = "") {
     questions_answered: Array.isArray(packet?.questions_answered) ? packet.questions_answered : [],
     debate_rounds: Array.isArray(packet?.debate_rounds) ? packet.debate_rounds : [],
     report_markdown: typeof packet?.report_markdown === "string" ? packet.report_markdown : "",
+    failure_kind: typeof packet?.failure_kind === "string" ? packet.failure_kind : undefined,
     thread_id: typeof packet?.thread_id === "string" ? packet.thread_id : undefined,
     thread_title: typeof packet?.thread_title === "string" ? packet.thread_title : undefined,
     execution_mode: typeof packet?.execution_mode === "string" ? packet.execution_mode : undefined,
@@ -92,6 +93,57 @@ export function normalizeDebate(packet, role, run, raw = "") {
   };
 }
 
+export function debateFailurePacket(role, run, failureKind) {
+  const kind = ["global_deadline", "timeout", "exit", "parse_failed", "reader_language_mismatch", "unexpected_error"]
+    .includes(failureKind)
+    ? failureKind
+    : "unexpected_error";
+  const copy = localized(run.language, {
+    en: {
+      global_deadline: `${role} did not complete before the council's global deadline.`,
+      timeout: `${role} timed out and produced no usable debate statement.`,
+      exit: `${role} exited unsuccessfully and produced no usable debate statement.`,
+      parse_failed: `${role} returned output that violated the debate JSON contract.`,
+      reader_language_mismatch: `${role} returned reader-facing content in the wrong language.`,
+      unexpected_error: `${role} failed unexpectedly and produced no usable debate statement.`,
+    },
+    zh: {
+      global_deadline: `${role} 未能在委员会全局截止时间前完成。`,
+      timeout: `${role} 执行超时，未生成可用的辩论发言。`,
+      exit: `${role} 异常退出，未生成可用的辩论发言。`,
+      parse_failed: `${role} 的输出违反辩论 JSON 契约。`,
+      reader_language_mismatch: `${role} 返回了错误语言的读者内容。`,
+      unexpected_error: `${role} 意外失败，未生成可用的辩论发言。`,
+    },
+    ja: {
+      global_deadline: `${role} は委員会全体の期限までに完了しませんでした。`,
+      timeout: `${role} はタイムアウトし、利用可能な討論発言を生成しませんでした。`,
+      exit: `${role} は異常終了し、利用可能な討論発言を生成しませんでした。`,
+      parse_failed: `${role} の出力は討論 JSON 契約に違反しています。`,
+      reader_language_mismatch: `${role} は指定と異なる言語の読者向け内容を返しました。`,
+      unexpected_error: `${role} は予期せず失敗し、利用可能な討論発言を生成しませんでした。`,
+    },
+    ko: {
+      global_deadline: `${role}이 위원회 전체 마감 시간 전에 완료되지 않았습니다.`,
+      timeout: `${role}이 시간 초과되어 사용할 수 있는 토론 발언을 생성하지 못했습니다.`,
+      exit: `${role}이 비정상 종료되어 사용할 수 있는 토론 발언을 생성하지 못했습니다.`,
+      parse_failed: `${role}의 출력이 토론 JSON 계약을 위반했습니다.`,
+      reader_language_mismatch: `${role}이 지정과 다른 언어의 독자용 내용을 반환했습니다.`,
+      unexpected_error: `${role}이 예기치 않게 실패해 사용할 수 있는 토론 발언을 생성하지 못했습니다.`,
+    },
+  });
+  return normalizeDebate({
+    verdict: "FAILED",
+    decision_available: false,
+    rating: null,
+    winner: "unknown",
+    summary: copy[kind],
+    confidence: "low",
+    report_markdown: "",
+    failure_kind: kind,
+  }, role, run, "");
+}
+
 export function dryPacket(task, symbol, asOfDate, prompt, language = "English") {
   const chinese = isChineseLanguage(language);
   return normalizePacket({
@@ -124,15 +176,41 @@ export function compactEvidence(run) {
     run_id: run.run_id,
     symbol: run.symbol,
     as_of: run.as_of,
-    packets: run.packets.map((packet) => ({
-      task: packet.task,
-      summary: packet.summary,
-      claims: packet.claims,
-      metrics: packet.metrics,
-      sources: packet.sources,
-      open_questions: packet.open_questions,
-      confidence: packet.confidence,
-    })),
+    context_contract: "bounded_full_v1",
+    packets: (run.packets || []).map((packet) => {
+      const claims = (packet.claims || []).slice(0, 8);
+      const sourceById = new Map((packet.sources || []).map((source) => [source?.id, source]));
+      const referenced = [...new Set(claims.flatMap((claim) => claim?.source_ids || []))];
+      const selectedIds = referenced.filter((id) => sourceById.has(id)).slice(0, 12);
+      for (const source of packet.sources || []) {
+        if (selectedIds.length >= 12) break;
+        if (source?.id && !selectedIds.includes(source.id)) selectedIds.push(source.id);
+      }
+      const included = new Set(selectedIds);
+      return {
+        task: packet.task,
+        summary: clip(packet.summary || "", 1_800),
+        claims: claims.map((claim) => ({
+          claim: clip(claim?.claim || "", 700),
+          evidence: clip(claim?.evidence || "", 700),
+          confidence: claim?.confidence || "low",
+          source_ids: (claim?.source_ids || []).filter((id) => included.has(id)),
+        })),
+        metrics: compactValue(packet.metrics || {}),
+        sources: selectedIds.map((id) => sourceById.get(id)).filter(Boolean).map((source) => ({
+          id: source?.id,
+          title: clip(source?.title || "", 260),
+          url: source?.url || "",
+          published_at: source?.published_at || "unknown",
+          retrieved_at: source?.retrieved_at || run.as_of,
+        })),
+        omitted_claim_count: Math.max(0, (packet.claims || []).length - claims.length),
+        omitted_source_count: Math.max(0, (packet.sources || []).length - selectedIds.length),
+        open_questions: (packet.open_questions || []).slice(0, 8).map((item) => clip(item, 650)),
+        confidence: packet.confidence,
+        information_richness: packet.information_richness,
+      };
+    }),
   };
 }
 
@@ -239,21 +317,53 @@ export function compactDebateContext(packet) {
 }
 
 export function debateFromCodex(result, role, run, fallbackPrompt) {
-  if (!result.ok) return dryDebate(role, run, cleanLog(result.stderr || result.text || fallbackPrompt));
+  if (!result.ok) {
+    const failureKind = result.deadline_exhausted
+      ? "global_deadline"
+      : result.timedOut
+        ? "timeout"
+        : Number.isInteger(result.code)
+          ? "exit"
+          : "unexpected_error";
+    return debateFailurePacket(role, run, failureKind);
+  }
   try {
     return normalizeDebate(extractJson(result.text), role, run, result.text);
-  } catch {
-    return normalizeDebate({
-      verdict: "PARSE_FAILED",
-      rating: "Hold",
-      winner: "unknown",
-      summary: `${role} returned non-JSON output.`,
-      confidence: "low",
-      report_markdown: cleanLog(result.text),
-    }, role, run, cleanLog(result.text));
+  } catch (error) {
+    return debateFailurePacket(role, run, "parse_failed");
   }
 }
 
+function asianManagerFallback(run, summary) {
+  const key = languageKey(run.language);
+  if (!new Set(["ja", "ko"]).has(key)) return null;
+  const c = localized(run.language, {
+    ja: {
+      title: "投資委員会ドラフト", conclusion: "結論", analyst: "アナリスト作業記録", debate: "強気・弱気討論記録", masters: "メソッド席", long: "強気論点", short: "弱気論点", market: "市場期待と織り込み条件", rating: "アナリスト評価と目標株価の変更", call: "決算説明会の経営シグナル", quant: "定量・ファクター視点", news: "ニュースと企業・業界シグナル", borrow: "空売り・貸株・オプション情報", transaction: "戦略取引・銀行イベント", valuation: "企業価値評価レンジ", price: "価格条件", catalysts: "主要カタリスト", risks: "主要リスク", position: "ポジション提案", shortTerm: "短期1–4週間の見通し", mediumTerm: "中期3–6か月の見通し", longTerm: "長期12か月の見通し", gaps: "データ欠落・利用不可データ", invalidation: "無効化条件", confidence: "信頼度", sources: "出典表",
+      unavailable: "今回の実行では同じ言語で確認できる情報を取得できませんでした。", managerMissing: "portfolio_manager の統合が完了していないため、正式な投資判断はありません。", draftOnly: "この文書はドラフトであり、正式なポジションを示しません。", noPackets: "証拠パケットは生成されませんでした。", noMaster: "完了したメソッド席はありません。", keyFindings: "主要所見", dataGaps: "データ欠落", packetSummary: "要約", packetConfidence: "信頼度", sourceCount: "出典数",
+    },
+    ko: {
+      title: "투자위원회 초안", conclusion: "결론", analyst: "분석가 작업 기록", debate: "강세·약세 토론 기록", masters: "방법론 좌석", long: "강세 논거", short: "약세 논거", market: "시장 기대와 내재 조건", rating: "애널리스트 등급 및 목표가 변경", call: "실적 발표 콜 경영진 신호", quant: "정량·팩터 관점", news: "뉴스 및 기업·산업 신호", borrow: "공매도·대차·옵션 정보", transaction: "전략적 거래·금융 이벤트", valuation: "가치평가 범위", price: "가격 조건", catalysts: "핵심 촉매", risks: "주요 위험", position: "포지션 제안", shortTerm: "단기 1–4주 전망", mediumTerm: "중기 3–6개월 전망", longTerm: "장기 12개월 전망", gaps: "데이터 공백·사용 불가 데이터", invalidation: "무효화 조건", confidence: "신뢰도", sources: "출처 표",
+      unavailable: "이번 실행에서는 같은 언어로 확인 가능한 정보를 확보하지 못했습니다.", managerMissing: "portfolio_manager 종합이 완료되지 않아 공식 투자 판단을 제공할 수 없습니다.", draftOnly: "이 문서는 초안이며 공식 포지션을 제시하지 않습니다.", noPackets: "증거 패킷이 생성되지 않았습니다.", noMaster: "완료된 방법론 좌석이 없습니다.", keyFindings: "핵심 발견", dataGaps: "데이터 공백", packetSummary: "요약", packetConfidence: "신뢰도", sourceCount: "출처 수",
+    },
+  });
+  const analystLog = run.packets.length
+    ? run.packets.map((packet) => {
+      const claims = (packet.claims || []).slice(0, 5).map((claim) => `  - ${claim.claim}`).join("\n");
+      const gaps = (packet.open_questions || []).slice(0, 3).map((item) => `  - ${item}`).join("\n");
+      return `### ${packet.task}\n- ${c.packetConfidence}: ${packet.confidence || "unknown"}\n- ${c.packetSummary}: ${packet.summary || c.unavailable}\n${claims ? `- ${c.keyFindings}:\n${claims}\n` : ""}${gaps ? `- ${c.dataGaps}:\n${gaps}\n` : ""}`;
+    }).join("\n\n")
+    : c.noPackets;
+  const masterLog = (run.master_opinions || []).length
+    ? run.master_opinions.map((opinion) => `- ${opinion.master}: ${opinion.stance} - ${opinion.summary || opinion.verdict || c.unavailable}`).join("\n")
+    : `- ${c.noMaster}`;
+  const long = summary.thesis.filter((claim) => claim.confidence !== "low").slice(0, 6).map((claim) => `- ${claim.claim}`).join("\n") || `- ${c.unavailable}`;
+  const short = summary.open_questions.slice(0, 6).map((item) => `- ${item}`).join("\n") || `- ${c.unavailable}`;
+  const gaps = summary.open_questions.length ? summary.open_questions.map((item) => `- ${item}`).join("\n") : `- ${c.unavailable}`;
+  const report = `# ${run.symbol} ${c.title}\n\n## ${c.conclusion}\n${summary.final_decision} — ${c.managerMissing}\n\n## ${c.analyst}\n${analystLog}\n\n## ${c.debate}\n${c.managerMissing}\n\n## ${c.masters}\n${masterLog}\n\n## ${c.long}\n${long}\n\n## ${c.short}\n${short}\n\n## ${c.market}\n${c.unavailable}\n\n## ${c.rating}\n${c.unavailable}\n\n## ${c.call}\n${c.unavailable}\n\n## ${c.quant}\n${c.unavailable}\n\n## ${c.news}\n${c.unavailable}\n\n## ${c.borrow}\n${c.unavailable}\n\n## ${c.transaction}\n${c.unavailable}\n\n## ${c.valuation}\n${c.unavailable}\n\n## ${c.price}\n${c.managerMissing} ${c.unavailable}\n\n## ${c.catalysts}\n${c.managerMissing}\n\n## ${c.risks}\n${short}\n\n## ${c.position}\n${c.draftOnly}\n\n## ${c.shortTerm}\n${c.managerMissing}\n\n## ${c.mediumTerm}\n${c.managerMissing}\n\n## ${c.longTerm}\n${c.managerMissing}\n\n## ${c.gaps}\n${gaps}\n\n## ${c.invalidation}\n${c.managerMissing} ${c.draftOnly}\n\n## ${c.confidence}\n${summary.confidence}\n\n## ${c.sources}\n- ${c.sourceCount}: ${summary.source_count}\n`;
+  return { copy: c, analystLog, masterLog, report };
+}
+
 export function mergeDebateRounds(rounds) {
   const list = (rounds || []).filter(Boolean);
   if (list.length === 0) return null;
@@ -347,6 +457,20 @@ export function summarizeRun(run, userPrompt = "") {
 
 export function managerFallback(run, userPrompt = "") {
   const summary = summarizeRun(run, userPrompt);
+  const asian = asianManagerFallback(run, summary);
+  if (asian) {
+    return normalizeDebate({
+      verdict: summary.final_decision,
+      decision_available: false,
+      rating: null,
+      winner: "unknown",
+      summary: asian.copy.managerMissing,
+      long_thesis: summary.thesis.filter((claim) => claim.confidence !== "low").slice(0, 6).map((claim) => claim.claim),
+      short_thesis: summary.open_questions.slice(0, 6),
+      confidence: summary.confidence,
+      report_markdown: asian.report,
+    }, "portfolio_manager", run);
+  }
   const chinese = isChineseLanguage(run.language);
   const analystLog = run.packets.length
     ? run.packets.map((packet) => {
@@ -442,6 +566,35 @@ export function normalizeMasterOpinion(packet, masterId, run, raw = "") {
   };
 }
 
+/**
+ * A dedicated v3 method worker explains an already frozen decision; it never gets to
+ * choose or rewrite the stance. Keeping this packet separate from normalizeMasterOpinion
+ * makes a persuasive narrative incapable of overriding deterministic policy output.
+ */
+export function normalizeMasterVoice(packet, masterId, run, frozenOpinion, raw = "") {
+  const list = (value) => (Array.isArray(value) ? value.filter((x) => typeof x === "string" && x.trim()) : []);
+  if (packet?.master !== masterId) throw internalError(`dedicated method worker returned the wrong master id for ${masterId}`);
+  if (packet?.acknowledged_stance !== frozenOpinion?.stance) {
+    throw internalError(`dedicated method worker attempted to change frozen stance for ${masterId}`);
+  }
+  const statement = typeof packet?.statement === "string" ? packet.statement.trim() : "";
+  if (!statement) throw internalError(`dedicated method worker returned no statement for ${masterId}`);
+  return {
+    master: masterId,
+    symbol: run.symbol,
+    as_of: run.as_of,
+    acknowledged_stance: frozenOpinion.stance,
+    statement,
+    key_findings: list(packet?.key_findings),
+    disagreements: list(packet?.disagreements),
+    what_would_change_my_mind: list(packet?.what_would_change_my_mind),
+    source_ids: list(packet?.source_ids),
+    confidence: ["high", "medium", "low"].includes(packet?.confidence) ? packet.confidence : frozenOpinion.confidence || "low",
+    language: run.language,
+    raw_text: raw,
+  };
+}
+
 /** Compact master opinions for injection into the debate prompt. */
 export function compactMasterOpinions(run) {
   return (run.master_opinions || []).map((opinion) => ({

package/mcp/lib/personas/engine.mjs

@@ -12,7 +12,7 @@ import { buildFactPack } from "../personas-v3/typed-facts.mjs";
 import { typedFactPackFromGrounding } from "../personas-v3/grounding-adapter.mjs";
 import { buildAnonymousPreDecision, freezeAnonymousDecision } from "../personas-v3/runtime.mjs";
 import { executeDeterministicPersonaPolicy } from "../personas-v3/deterministic-executor.mjs";
-import { isChineseLanguage } from "../lang.mjs";
+import { languageKey, localized } from "../lang.mjs";
 import {
   declinedOpinion as v2DeclinedOpinion,
   planMasters as planLegacyMasters,
@@ -190,9 +190,15 @@ export function completedMasterOpinion(run, item) {
     throw new Error("completedMasterOpinion requires a completed v3 deterministic seat");
   }
   const result = item.frozenDecision.structured_decision.result;
-  const zh = isChineseLanguage(run.language);
-  const label = item.pack.admitted_label?.[zh ? "zh" : "en"]
+  const locale = languageKey(run.language);
+  const label = item.pack.admitted_label?.[locale]
     || item.pack.admitted_label?.en || item.id;
+  const copy = localized(run.language, {
+    en: { withheld: (pct) => `${pct}% coverage; score withheld`, unscored: "not scored", verdict: (stance, reason) => `${label} frozen decision: ${stance} (${reason})`, summary: (score) => `The PersonaPack v3 deterministic policy executed with score ${score}. Typed facts, hard vetoes, and score bands produced this stance; no language model selected it.`, hit: (id) => `score hit: ${id}`, miss: (id) => `score miss: ${id}`, eligibility: (id) => `eligibility condition ${id} becomes satisfied`, veto: (id) => `hard veto ${id} no longer triggers`, score: (id) => `score condition ${id} becomes satisfied` },
+    zh: { withheld: (pct) => `覆盖率 ${pct}%，分数被保留不发布`, unscored: "未评分", verdict: (stance, reason) => `${label}的冻结结论：${stance}（${reason}）`, summary: (score) => `PersonaPack v3 确定性政策已执行；得分 ${score}。该立场由结构化事实、硬否决和评分带产生，没有让语言模型选择立场。`, hit: (id) => `评分命中：${id}`, miss: (id) => `评分未命中：${id}`, eligibility: (id) => `资格条件 ${id} 变为满足`, veto: (id) => `硬否决 ${id} 不再触发`, score: (id) => `评分条件 ${id} 变为满足` },
+    ja: { withheld: (pct) => `カバレッジ ${pct}% のためスコアは非公開`, unscored: "未採点", verdict: (stance, reason) => `${label}の凍結済み判断：${stance}（${reason}）`, summary: (score) => `PersonaPack v3 の決定論的ポリシーを実行し、スコアは ${score}。構造化事実、ハード拒否条件、スコア帯がこの立場を生成しており、言語モデルは立場を選択していない。`, hit: (id) => `採点条件を満たす：${id}`, miss: (id) => `採点条件を満たさない：${id}`, eligibility: (id) => `適格条件 ${id} が満たされる`, veto: (id) => `ハード拒否条件 ${id} が解除される`, score: (id) => `採点条件 ${id} が満たされる` },
+    ko: { withheld: (pct) => `커버리지 ${pct}%로 점수를 공개하지 않음`, unscored: "미채점", verdict: (stance, reason) => `${label}의 동결된 판단: ${stance}(${reason})`, summary: (score) => `PersonaPack v3 결정론적 정책을 실행했으며 점수는 ${score}입니다. 구조화된 사실, 하드 거부 조건, 점수 구간이 이 입장을 만들었고 언어 모델은 입장을 선택하지 않았습니다.`, hit: (id) => `점수 조건 충족: ${id}`, miss: (id) => `점수 조건 미충족: ${id}`, eligibility: (id) => `적격 조건 ${id} 충족`, veto: (id) => `하드 거부 조건 ${id} 해제`, score: (id) => `점수 조건 ${id} 충족` },
+  });
   const vetoIds = (result.vetoes_triggered || []).map((veto) => veto.veto_id);
   const unmet = result.eligibility?.unmet_condition_ids || [];
   const hitIds = (result.score?.hits || []).map((rule) => rule.rule_id);
@@ -204,33 +210,27 @@ export function completedMasterOpinion(run, item) {
     ...(result.score?.misses || []).flatMap((rule) => rule.source_ids || []),
   ]);
   const scoreText = result.score?.status === "insufficient_coverage"
-    ? zh
-      ? `覆盖率 ${Math.round(result.score.coverage * 100)}%，分数被保留不发布`
-      : `${Math.round(result.score.coverage * 100)}% coverage; score withheld`
+    ? copy.withheld(Math.round(result.score.coverage * 100))
     : result.score
       ? `${result.score.score}/${result.score.max_possible} (${Math.round((result.ratio || 0) * 100)}%)`
-    : zh ? "未评分" : "not scored";
+    : copy.unscored;
   return {
     master: item.id,
     symbol: run.symbol,
     as_of: run.as_of,
     stance: result.stance,
-    verdict: zh
-      ? `${label}的冻结结论：${result.stance}（${result.reason}）`
-      : `${label} frozen decision: ${result.stance} (${result.reason})`,
-    summary: zh
-      ? `PersonaPack v3 确定性政策已执行；得分 ${scoreText}。该立场由结构化事实、硬否决和评分带产生，没有让语言模型选择立场。`
-      : `The PersonaPack v3 deterministic policy executed with score ${scoreText}. Typed facts, hard vetoes, and score bands produced this stance; no language model selected it.`,
+    verdict: copy.verdict(result.stance, result.reason),
+    summary: copy.summary(scoreText),
     key_findings: uniqueStrings([
-      ...hitIds.map((id) => zh ? `评分命中：${id}` : `score hit: ${id}`),
-      ...missIds.map((id) => zh ? `评分未命中：${id}` : `score miss: ${id}`),
+      ...hitIds.map(copy.hit),
+      ...missIds.map(copy.miss),
     ]),
     disagreements: [],
     disqualifiers_triggered: uniqueStrings([...unmet, ...vetoIds]),
     what_would_change_my_mind: uniqueStrings([
-      ...unmet.map((id) => zh ? `资格条件 ${id} 变为满足` : `eligibility condition ${id} becomes satisfied`),
-      ...vetoIds.map((id) => zh ? `硬否决 ${id} 不再触发` : `hard veto ${id} no longer triggers`),
-      ...missIds.map((id) => zh ? `评分条件 ${id} 变为满足` : `score condition ${id} becomes satisfied`),
+      ...unmet.map(copy.eligibility),
+      ...vetoIds.map(copy.veto),
+      ...missIds.map(copy.score),
     ]),
     source_ids: sourceIds,
     confidence: result.common_projection?.confidence || "low",
@@ -257,27 +257,27 @@ export function completedMasterOpinion(run, item) {
 export function declinedMasterOpinion(run, item) {
   if (item?.engine !== "v3_method_runtime") return v2DeclinedOpinion(run, item.id, item.decision);
   const eligibility = item.preDecision.eligibility;
-  const zh = isChineseLanguage(run.language);
-  const label = item.pack.admitted_label?.[zh ? "zh" : "en"]
+  const locale = languageKey(run.language);
+  const label = item.pack.admitted_label?.[locale]
     || item.pack.admitted_label?.en || item.id;
-  const missing = eligibility.missing_required_fact_types.join(", ") || (zh ? "无" : "none");
+  const copy = localized(run.language, {
+    en: { none: "none", verdict: `${label} cannot evaluate ${run.symbol}: ${eligibility.reason}`, summary: (missing) => `The v3 typed-fact gate returned ${eligibility.status}; missing: ${missing}. No legacy prompt or narrative decision layer was called.`, available: (id) => `${id} becomes available from a point-in-time source` },
+    zh: { none: "无", verdict: `${label}无法评估 ${run.symbol}：${eligibility.reason}`, summary: (missing) => `v3 typed-fact 闸门返回 ${eligibility.status}；缺失：${missing}。系统未调用旧提示词或叙述决策层。`, available: (id) => `${id} 可从时点一致的来源取得` },
+    ja: { none: "なし", verdict: `${label}は ${run.symbol} を評価できません：${eligibility.reason}`, summary: (missing) => `v3 typed-fact ゲートは ${eligibility.status} を返しました。欠落：${missing}。旧プロンプトや叙述型の判断層は呼び出していません。`, available: (id) => `${id} が時点整合した出典から利用可能になる` },
+    ko: { none: "없음", verdict: `${label}은 ${run.symbol}을 평가할 수 없습니다: ${eligibility.reason}`, summary: (missing) => `v3 typed-fact 게이트가 ${eligibility.status}을 반환했습니다. 누락: ${missing}. 기존 프롬프트나 서술형 판단 계층은 호출하지 않았습니다.`, available: (id) => `${id}을 시점 일치 출처에서 확보할 수 있게 됨` },
+  });
+  const missing = eligibility.missing_required_fact_types.join(", ") || copy.none;
   return {
     master: item.id,
     symbol: run.symbol,
     as_of: run.as_of,
     stance: "out_of_scope",
-    verdict: zh
-      ? `${label}无法评估 ${run.symbol}：${eligibility.reason}`
-      : `${label} cannot evaluate ${run.symbol}: ${eligibility.reason}`,
-    summary: zh
-      ? `v3 typed-fact 闸门返回 ${eligibility.status}；缺失：${missing}。系统未调用旧提示词或叙述决策层。`
-      : `The v3 typed-fact gate returned ${eligibility.status}; missing: ${missing}. No legacy prompt or narrative decision layer was called.`,
+    verdict: copy.verdict,
+    summary: copy.summary(missing),
     key_findings: [],
     disagreements: [],
     disqualifiers_triggered: eligibility.missing_required_fact_types,
-    what_would_change_my_mind: eligibility.missing_required_fact_types.map((id) => (
-      zh ? `${id} 可从时点一致的来源取得` : `${id} becomes available from a point-in-time source`
-    )),
+    what_would_change_my_mind: eligibility.missing_required_fact_types.map(copy.available),
     source_ids: [],
     // The refusal itself is deterministic, but the seat has insufficient evidence for an
     // investment judgment. Keep the reader-facing evidence confidence low so a mechanically

package/mcp/lib/personas-v3/compiler.mjs

@@ -18,6 +18,8 @@ function candidateLabel(label) {
   return {
     en: /candidate/i.test(label.en) ? label.en : `${label.en} candidate`,
     zh: /候选/.test(label.zh) ? label.zh : `${label.zh}候选`,
+    ...(label.ja ? { ja: /候補/.test(label.ja) ? label.ja : `${label.ja}候補` } : {}),
+    ...(label.ko ? { ko: /후보/.test(label.ko) ? label.ko : `${label.ko} 후보` } : {}),
   };
 }
 

package/mcp/lib/personas-v3/loader.mjs

@@ -113,8 +113,10 @@ function physicalComponent(packDir, relativePath, label) {
   return file;
 }
 
-function localized(value, label, errors) {
-  if (!isObject(value) || !value.en?.trim() || !value.zh?.trim()) errors.push(`${label} must contain non-empty en and zh strings`);
+function localized(value, label, errors, required = ["en", "zh"]) {
+  if (!isObject(value) || required.some((key) => !value[key]?.trim())) {
+    errors.push(`${label} must contain non-empty ${required.join(", ")} strings`);
+  }
 }
 
 function validateManifest(manifest, packDir) {
@@ -128,15 +130,16 @@ function validateManifest(manifest, packDir) {
     errors.push("pack_version must be a semantic version, optionally with a prerelease suffix");
   }
   const identity = manifest.identity;
+  const selectorLocales = manifest.build_profile === "solo_test" ? ["en", "zh", "ja", "ko"] : ["en", "zh"];
   if (!isObject(identity) || !ID.test(identity.persona_id || "")) errors.push("identity.persona_id is invalid");
   else if (basename(resolve(packDir)) !== identity.persona_id) errors.push(`pack directory must be named ${identity.persona_id}`);
-  localized(identity?.public_label, "identity.public_label", errors);
-  localized(identity?.operator_label, "identity.operator_label", errors);
+  localized(identity?.public_label, "identity.public_label", errors, selectorLocales);
+  localized(identity?.operator_label, "identity.operator_label", errors, selectorLocales);
   if (!MATURITIES.has(identity?.maturity)) errors.push("identity.maturity is invalid (and remains advisory even when valid)");
   if (!Number.isFinite(inclusiveCutoffTime(identity?.source_cutoff))) errors.push("identity.source_cutoff is invalid");
-  localized(manifest.selection?.identity, "selection.identity", errors);
-  localized(manifest.selection?.method, "selection.method", errors);
-  localized(manifest.selection?.best_for, "selection.best_for", errors);
+  localized(manifest.selection?.identity, "selection.identity", errors, selectorLocales);
+  localized(manifest.selection?.method, "selection.method", errors, selectorLocales);
+  localized(manifest.selection?.best_for, "selection.best_for", errors, selectorLocales);
   if (!Array.isArray(manifest.capability?.domains) || !manifest.capability.domains.length) errors.push("capability.domains is required");
   const requiredFacts = manifest.capability?.required_fact_types;
   const optionalFacts = manifest.capability?.optional_fact_types;

package/mcp/lib/personas-v3/source-acquisition.mjs

@@ -353,7 +353,13 @@ function headerValue(value) {
   return value === undefined ? null : String(value);
 }
 
-function requestOnce(url, { timeoutMs, maxBytes, requestImpl, destination }) {
+function requestOnce(url, {
+  timeoutMs,
+  configuredTimeoutMs = timeoutMs,
+  maxBytes,
+  requestImpl,
+  destination,
+}) {
   return new Promise((resolvePromise, rejectPromise) => {
     let settled = false;
     let timer = null;
@@ -367,8 +373,8 @@ function requestOnce(url, { timeoutMs, maxBytes, requestImpl, destination }) {
     const transport = requestImpl || (new URL(url).protocol === "https:" ? httpsRequest : httpRequest);
     let request;
     timer = setTimeout(() => {
-      request?.destroy(new Error(`source acquisition timed out after ${timeoutMs}ms`));
-      reject(new PersonaSourceAcquisitionError(`source acquisition timed out after ${timeoutMs}ms`));
+      request?.destroy(new Error(`source acquisition timed out after ${configuredTimeoutMs}ms`));
+      reject(new PersonaSourceAcquisitionError(`source acquisition timed out after ${configuredTimeoutMs}ms`));
     }, timeoutMs);
     try {
       request = transport(url, {
@@ -465,6 +471,7 @@ export async function retrieveExplicitHttpBytes(url, {
     networkTrace.push(destination);
     const result = await requestOnce(current, {
       timeoutMs: remaining,
+      configuredTimeoutMs: normalizedLimits.timeout_ms,
       maxBytes: normalizedLimits.max_bytes,
       requestImpl,
       destination,

package/mcp/lib/prompts.mjs

@@ -156,6 +156,39 @@ export function masterPrompt(masterId, run) {
   ].filter(Boolean).join("\n\n");
 }
 
+/**
+ * One isolated worker per selected physical v3 method, after its structured decision is
+ * frozen. The worker may explain and challenge the evidence, but it cannot vote again.
+ */
+export function masterVoicePrompt(masterId, run, frozenOpinion) {
+  const reg = registry();
+  const persona = reg.get(masterId);
+  if (!persona || persona.kind !== "master") throw new Error(`unknown master persona: ${masterId}`);
+  const language = run.language || "English";
+  const values = { symbol: run.symbol, as_of: run.as_of, language };
+  const evidence = JSON.stringify(run.council_mode === "quick" ? compactQuickEvidence(run) : compactEvidence(run));
+  return [
+    `You are the dedicated, isolated method-seat explanation worker for ${personaTitle(persona, language)} (${masterId}) in the ${run.symbol} council.`,
+    `Write every reader-facing field in ${language}. Keep stable IDs, tickers and source IDs unchanged.`,
+    "This is a project-derived provisional method lens, not the named person's current statement, endorsement, or quotation.",
+    "The structured method decision below is already frozen. You MUST NOT change, soften, strengthen or reinterpret its stance. Explain why that frozen result follows, identify the highest-information facts or missing facts, state any disagreement with analyst interpretation, and say what evidence would change the method result. Do not browse or add facts.",
+    `Frozen method result JSON: ${JSON.stringify({
+      master: masterId,
+      stance: frozenOpinion?.stance,
+      verdict: frozenOpinion?.verdict,
+      summary: frozenOpinion?.summary,
+      disqualifiers_triggered: frozenOpinion?.disqualifiers_triggered || [],
+      what_would_change_my_mind: frozenOpinion?.what_would_change_my_mind || [],
+      source_ids: frozenOpinion?.source_ids || [],
+      deterministic_core_hash: frozenOpinion?.deterministic_core_hash || null,
+      frozen_decision_hash: frozenOpinion?.frozen_decision_hash || null,
+    })}`,
+    `Method instructions (for explanation only):\n${render(personaPrompt(persona, language), values)}`,
+    "Return ONLY one valid JSON object, no Markdown fence. Schema: {\"master\":\"stable id\",\"acknowledged_stance\":\"constructive|cautious|opposed|out_of_scope\",\"statement\":\"reader-facing explanation\",\"key_findings\":[\"string\"],\"disagreements\":[\"string\"],\"what_would_change_my_mind\":[\"string\"],\"source_ids\":[\"task:S1\"],\"confidence\":\"high|medium|low\"}.",
+    `Bounded shared evidence JSON: ${evidence}`,
+  ].join("\n\n");
+}
+
 /** The master ids a run has selected, from an explicit list or a roster name. */
 export function selectedMasters(run) {
   const reg = registry();