alphacouncil-agent 0.9.2 → 1.0.0

package/mcp/lib/packets.mjs

@@ -1,7 +1,17 @@
 import { join } from "node:path";
 import { LIMITS, MASTER_STANCES, RATINGS } from "./constants.mjs";
-import { internalError } from "./errors.mjs";
-import { isChineseLanguage } from "./lang.mjs";
+// A worker returning a malformed packet is a client contract violation, not a server bug:
+// these three checks used to raise -32603 while the equivalent checks in the orchestrator
+// correctly raised -32602.
+import { internalError, invalidParams } from "./errors.mjs";
+import { isChineseLanguage, languageKey, localized } from "./lang.mjs";
+import {
+  composeVoiceStatement,
+  defaultIntentForStance,
+  intentsForStance,
+  isIntentAllowed,
+  VOICE_FIELDS,
+} from "./voice.mjs";
 import { cleanLog, clip } from "./text.mjs";
 import { scopedSourceId } from "./gates.mjs";
 import { runPath } from "./run-store.mjs";
@@ -85,6 +95,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 +103,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 +186,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 +327,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 +467,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 +576,78 @@ 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.
+ */
+/**
+ * A worker statement is prose that gets interpolated into a system-owned report section.
+ * Left raw, a statement containing a line such as `## Conclusion` emits a real level-2
+ * heading inside that section; heading assignment keeps the richest body, so the injected
+ * block becomes the section the quality gate validates and the genuine PM conclusion drops
+ * out of the gate's view entirely. Escape structural markdown at the trust boundary rather
+ * than at each render site, so a new renderer cannot reintroduce the hole.
+ */
+export function sanitizeStatementMarkdown(value) {
+  return String(value ?? "")
+    .replace(/\r\n?/gu, "\n")
+    .split("\n")
+    .map((line) => line
+      .replace(/^(\s*)(#{1,6})(\s)/u, "$1\\$2$3")
+      .replace(/^(\s*)(={3,}|-{3,}|\*{3,}|_{3,})\s*$/u, "$1\\$2"))
+    .join("\n")
+    .replace(/\n{2,}/gu, "\n")
+    .trim();
+}
+
+export function normalizeMasterVoice(packet, masterId, run, frozenOpinion, raw = "") {
+  // Every one of these is rendered into the system-owned bench, so all of them are escaped.
+  const list = (value) => (Array.isArray(value)
+    ? value.map(sanitizeStatementMarkdown).filter(Boolean)
+    : []);
+  if (packet?.master !== masterId) throw invalidParams(`dedicated method worker returned the wrong master id for ${masterId}`);
+  if (packet?.acknowledged_stance !== frozenOpinion?.stance) {
+    throw invalidParams(`dedicated method worker attempted to change frozen stance for ${masterId}`);
+  }
+  // The five-field voice is the current contract; a flat `statement` remains accepted so a
+  // legacy worker, or one that answered before the contract moved, is not a hard failure.
+  const voice = Object.fromEntries(VOICE_FIELDS
+    .map((field) => [field, sanitizeStatementMarkdown(packet?.voice?.[field])])
+    .filter(([, text]) => text));
+  const statement = Object.keys(voice).length
+    ? composeVoiceStatement(voice, run.language)
+    : sanitizeStatementMarkdown(packet?.statement);
+  if (!statement) throw invalidParams(`dedicated method worker returned no statement for ${masterId}`);
+
+  // Intent narrows the frozen stance; it never reopens it. Rejected the same way a changed
+  // stance is, so a worker cannot turn `opposed` into `would_buy` by choosing a label.
+  const requested = packet?.position_intent;
+  if (requested !== undefined && !isIntentAllowed(requested, frozenOpinion.stance)) {
+    throw invalidParams(
+      `dedicated method worker returned an intent outside the frozen stance for ${masterId}: `
+      + `${JSON.stringify(requested)} is not one of ${intentsForStance(frozenOpinion.stance).join(", ")}`,
+    );
+  }
+
+  return {
+    master: masterId,
+    symbol: run.symbol,
+    as_of: run.as_of,
+    acknowledged_stance: frozenOpinion.stance,
+    position_intent: requested ?? defaultIntentForStance(frozenOpinion.stance),
+    voice: Object.keys(voice).length ? voice : null,
+    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) => `Using the ${label} method on ${run.symbol}, 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) => `按${label}方法审视 ${run.symbol}：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) => `${label}の方法で ${run.symbol} を評価し、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) => `${label} 방법으로 ${run.symbol}을 검토하여 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,32 @@ 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;
+  const deterministicStatement = copy.summary(scoreText);
   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: deterministicStatement,
+    voice_statement: deterministicStatement,
+    voice_status: "deterministic_fallback",
+    voice_language: run.language,
+    statement_origin: "deterministic_policy_fallback",
     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 +262,35 @@ 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 instrument = run?.grounding?.instrument;
+  const fundOrIndex = instrument?.fund_like === true || instrument?.index_like === true
+    || ["etf", "mutual_fund", "index"].includes(instrument?.asset_type);
+  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.`, fundContext: fundOrIndex ? `${run.symbol} is classified as ${instrument.asset_type}; this method must use dated holdings or aggregate index evidence rather than treating the instrument as an operating company. ` : "", statement: (missing, context) => `${context}Using the ${label} method, I do not issue a directional view on ${run.symbol} in this run because the point-in-time record lacks ${missing}. This is neither bearish nor a vote against the asset. I would reassess only after those method-critical facts are available.`, 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}。系统未调用旧提示词或叙述决策层。`, fundContext: fundOrIndex ? `${run.symbol} 已识别为 ${instrument.asset_type}；该方法必须通过带时点的持仓穿透或指数聚合证据使用，不能把它当成经营公司。` : "", statement: (missing, context) => `${context}按${label}方法审视 ${run.symbol}，本轮不作方向判断，因为时点一致的资料缺少：${missing}。这不是看空，也不是一张反对票；只有取得这些方法关键事实后，该席位才会重新评估。`, available: (id) => `${id} 可从时点一致的来源取得` },
+    ja: { none: "なし", verdict: `${label}は ${run.symbol} を評価できません：${eligibility.reason}`, summary: (missing) => `v3 typed-fact ゲートは ${eligibility.status} を返しました。欠落：${missing}。旧プロンプトや叙述型の判断層は呼び出していません。`, fundContext: fundOrIndex ? `${run.symbol} は ${instrument.asset_type} に分類されており、事業会社として扱わず、基準日付き保有銘柄のルックスルーまたは指数集計証拠を用いる必要があります。` : "", statement: (missing, context) => `${context}${label}の方法では、時点整合した資料に ${missing} が欠けているため、今回は ${run.symbol} の方向判断を出しません。弱気判断や反対票ではなく、これらの方法上重要な事実が揃った時点で再評価します。`, available: (id) => `${id} が時点整合した出典から利用可能になる` },
+    ko: { none: "없음", verdict: `${label}은 ${run.symbol}을 평가할 수 없습니다: ${eligibility.reason}`, summary: (missing) => `v3 typed-fact 게이트가 ${eligibility.status}을 반환했습니다. 누락: ${missing}. 기존 프롬프트나 서술형 판단 계층은 호출하지 않았습니다.`, fundContext: fundOrIndex ? `${run.symbol}은 ${instrument.asset_type}로 분류되므로 영업회사처럼 취급하지 않고 기준일이 있는 보유 종목 룩스루 또는 지수 집계 증거를 사용해야 합니다. ` : "", statement: (missing, context) => `${context}${label} 방법으로는 시점 일치 자료에 ${missing}이 없어 이번 실행에서 ${run.symbol}의 방향 판단을 내리지 않습니다. 이는 약세 판단이나 반대표가 아니며, 해당 핵심 사실이 확보된 뒤에만 재평가합니다.`, available: (id) => `${id}을 시점 일치 출처에서 확보할 수 있게 됨` },
+  });
+  const missing = eligibility.missing_required_fact_types.join(", ") || copy.none;
+  const deterministicStatement = copy.statement(missing, copy.fundContext);
   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.`,
-    key_findings: [],
+    verdict: copy.verdict,
+    summary: copy.summary(missing),
+    voice_statement: deterministicStatement,
+    voice_status: "deterministic_fallback",
+    voice_language: run.language,
+    statement_origin: "deterministic_scope_fallback",
+    key_findings: [deterministicStatement],
     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/deterministic-executor.mjs

@@ -227,7 +227,7 @@ function validatePeriodContract(period, path, errors) {
   if (!exactFields(period, path, fields, [...fields], errors)) return;
   if (!["instant", "duration", "forecast_horizon", "not_applicable"].includes(period.basis)) add(errors, `${path}.basis`, "is invalid");
   if (!["exact", "same_period", "as_of", "not_applicable"].includes(period.alignment)) add(errors, `${path}.alignment`, "is invalid");
-  if (period.window !== null && (typeof period.window !== "string" || !/^P[1-9]\d*[DMY]$/u.test(period.window))) add(errors, `${path}.window`, "must be null or P<n>D, P<n>M, or P<n>Y");
+  if (period.window !== null && (typeof period.window !== "string" || !/^(P[1-9]\d*[DMY]|ANY)$/u.test(period.window))) add(errors, `${path}.window`, "must be null, ANY, or P<n>D, P<n>M, or P<n>Y");
   if (["instant", "not_applicable"].includes(period.basis) && period.window !== null) add(errors, `${path}.window`, `must be null for ${period.basis}`);
   if (["duration", "forecast_horizon"].includes(period.basis) && period.window === null) add(errors, `${path}.window`, `is required for ${period.basis}`);
   if (period.basis === "not_applicable" && period.alignment !== "not_applicable") add(errors, `${path}.alignment`, "must be not_applicable");
@@ -532,18 +532,29 @@ function periodTuple(fact) {
   return [fact.period_start, fact.period_end, fact.fiscal_year];
 }
 
+/** Window token for a duration whose length is set by data availability, not by the method. */
+export const ANY_REPORTING_INTERVAL = "ANY";
+
 function periodWindowMatches(fact, window) {
   if (!fact.period_start || !fact.period_end) return false;
   const start = Date.parse(fact.period_start);
   const end = Date.parse(fact.period_end);
   if (!Number.isFinite(start) || !Number.isFinite(end) || end < start) return false;
+  // Some aggregates cover as many periods as the filings supplied rather than a fixed span --
+  // interest coverage is three years for one issuer and one for the next. Pinning a count there
+  // would reject the fact for being honest about its own coverage; what still has to hold is
+  // that it carries a real interval rather than a stray observation date.
+  if (window === ANY_REPORTING_INTERVAL) return true;
   const match = /^P([1-9]\d*)([DMY])$/u.exec(window || "");
   if (!match) return false;
   const count = Number(match[1]);
   const elapsedDays = (end - start) / 86_400_000;
   if (match[2] === "D") return elapsedDays === count;
   if (match[2] === "M") return elapsedDays >= count * 27 && elapsedDays <= count * 32;
-  return elapsedDays >= count * 365 - 1 && elapsedDays <= count * 366 + 1;
+  // A fiscal year is 52 or 53 weeks, not 365 days, and it is measured between two fiscal
+  // year-end dates -- so a real one-year filing span is routinely 363 or 364 days. Demanding
+  // 365 rejected every issuer whose year ends on a weekday.
+  return elapsedDays >= count * 364 - 2 && elapsedDays <= count * 366 + 1;
 }
 
 function assertFactInputContract(fact, contract, factPackAsOf, path) {

package/mcp/lib/personas-v3/ga-external-evidence.mjs

@@ -1,3 +1,4 @@
+import { CANONICAL_MASTER_COUNT } from "./staging.mjs";
 import { createHash } from "node:crypto";
 import {
   existsSync,
@@ -441,8 +442,8 @@ export function inspectGaExternalEvidence({
   const releaseIds = manifest.canonical_master_ids || [];
   const releasePackHashes = (manifest.packs || []).map((pack) => pack.pack_hash);
   const releaseVersions = (manifest.packs || []).map((pack) => pack.pack_version);
-  if (releaseVersions.length !== 26 || releaseVersions.some((version) => version !== expectedVersion)) {
-    errors.push(`all 26 immutable release pack versions must equal ${expectedVersion}`);
+  if (releaseVersions.length !== CANONICAL_MASTER_COUNT || releaseVersions.some((version) => version !== expectedVersion)) {
+    errors.push(`all ${CANONICAL_MASTER_COUNT} immutable release pack versions must equal ${expectedVersion}`);
   }
   if (packageEvidence?.artifact) {
     if (!same(packageEvidence.derived_catalog?.selected_master_ids, releaseIds)) errors.push("installed package selected master IDs/order differ from the release manifest");

package/mcp/lib/personas-v3/ga-gate.mjs

@@ -19,9 +19,10 @@ import { verifyPersonaRelease } from "./releases.mjs";
 import { inspectSourceAcquisitions } from "./source-acquisition.mjs";
 import { inspectSourceAdjudications } from "./source-adjudication.mjs";
 import { defaultStagingRoot, inspectPersonaV3Staging } from "./staging.mjs";
+import { CANONICAL_MASTER_COUNT } from "./staging.mjs";
 
 export const GA_REPORT_SCHEMA_VERSION = 1;
-export const GA_DEFAULT_COUNT = 26;
+export const GA_DEFAULT_COUNT = CANONICAL_MASTER_COUNT;
 export const GA_DEFAULT_MIN_ADMISSION = "operational";
 export const GA_TARGET_VERSION = "0.9.0";
 

package/mcp/lib/personas-v3/ga-package-evidence.mjs

@@ -1,3 +1,4 @@
+import { CANONICAL_MASTER_COUNT } from "./staging.mjs";
 import { createHash } from "node:crypto";
 import { spawnSync } from "node:child_process";
 import {
@@ -219,9 +220,9 @@ function safelyInstallAndDerive(tarball, { packageName, releaseId }) {
     const releaseFile = containedPhysicalFile(installedRoot, join("knowledge", "persona-releases", releaseId, "manifest.json"), "installed release manifest");
     const release = parseJson(releaseFile.bytes, "installed release manifest");
     if (release.artifact_kind !== "persona_v3_release_manifest" || release.release_id !== releaseId) throw new Error("installed release manifest identity differs from the package artifact");
-    if (release.canonical_master_count !== 26 || !Array.isArray(release.canonical_master_ids)
-      || release.canonical_master_ids.length !== 26 || new Set(release.canonical_master_ids).size !== 26
-      || !Array.isArray(release.packs) || release.packs.length !== 26) throw new Error("installed release manifest does not contain exactly 26 canonical packs");
+    if (release.canonical_master_count !== CANONICAL_MASTER_COUNT || !Array.isArray(release.canonical_master_ids)
+      || release.canonical_master_ids.length !== CANONICAL_MASTER_COUNT || new Set(release.canonical_master_ids).size !== CANONICAL_MASTER_COUNT
+      || !Array.isArray(release.packs) || release.packs.length !== CANONICAL_MASTER_COUNT) throw new Error(`installed release manifest does not contain exactly ${CANONICAL_MASTER_COUNT} canonical packs`);
     const selectedPackHashes = release.packs.map((pack, index) => {
       if (pack?.persona_id !== release.canonical_master_ids[index] || !HASH.test(pack?.pack_hash || "")) throw new Error(`installed release manifest pack ${index} does not bind canonical ID/order/hash`);
       return pack.pack_hash;
@@ -323,7 +324,7 @@ export function checkGaPackageArtifactFile(file, { packageJsonPath, expectedVers
       if (artifact.package?.[field] !== sourcePackage?.[field]) errors.push(`package artifact ${field} differs from repository package.json`);
       if (artifact.package?.[field] !== tarballPackage?.[field]) errors.push(`package artifact ${field} differs from tarball package.json`);
     }
-    if (artifact.catalog?.selected_master_ids?.length === 26) {
+    if (artifact.catalog?.selected_master_ids?.length === CANONICAL_MASTER_COUNT) {
       installedMetadata = safelyInstallAndDerive(tarballFile.absolute, {
         packageName: tarballPackage.name,
         releaseId: artifact.release_id,