alphacouncil-agent 0.9.4 → 1.0.0

package/mcp/lib/master-catalog.mjs

@@ -111,6 +111,10 @@ const CARDS = Object.freeze({
     zh: ["Mohnish Pabrai，Pabrai Funds 创始人和 Dhandho 价值投资人", "寻找低永久损失、高不确定性、离散催化剂和明显不对称赔率。", "特殊情形、资产保护、克隆后独立复算和集中机会"],
     en: ["Mohnish Pabrai, Pabrai Funds founder and Dhandho value investor", "Looks for low permanent-loss risk, high uncertainty, discrete catalysts and strongly asymmetric odds.", "Special situations, asset protection, independently rebuilt clones and concentration"],
   },
+  master_bogle: {
+    zh: ["约翰·博格，先锋集团创始人和低成本指数投资的倡导者", "把一篮子的长期预期回报拆成股息率、盈利增长和估值变化，再减去持有成本。", "指数基金、ETF、整体市场预期回报和持有成本"],
+    en: ["John C. Bogle, Vanguard's founder and the advocate of low-cost index investing", "Decomposes a basket's long-run expected return into dividend yield, earnings growth and the change in valuation, then subtracts the cost of holding it.", "Index funds, ETFs, market-wide expected return and cost of ownership"],
+  },
   master_jhunjhunwala: {
     zh: ["Rakesh Jhunjhunwala，以长期集中持仓闻名的印度投资人", "结合印度结构成长、promoter 治理、现金质量、规模扩张和流动性。", "印度上市公司、结构渗透、治理和集中成长机会"],
     en: ["Rakesh Jhunjhunwala, an Indian investor known for long-duration concentrated holdings", "Combines Indian structural growth, promoter governance, cash quality, scaling and liquidity.", "Indian equities, structural penetration, governance and concentrated growth"],

package/mcp/lib/orchestrator.mjs

@@ -1,4 +1,4 @@
-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";
@@ -6,7 +6,7 @@ import { readJson, writeJson } from "./fsutil.mjs";
 import { registry } from "./personas/registry.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 { debateFailurePacket, debateFromCodex, debateQnaGate, dryDebate, dryPacket, extractJson, firstFailedDebateResult, managerFallback, mergeDebateRounds, normalizeDebate, normalizeMasterOpinion, normalizeMasterVoice, normalizePacket, rawRecordText } from "./packets.mjs";
@@ -290,9 +290,9 @@ export function visibleAgentSpecs(run, userPrompt = "") {
     ].filter(Boolean).join("\n"),
     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;
@@ -321,27 +321,44 @@ export function visibleAgentSpecs(run, userPrompt = "") {
       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);
@@ -357,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);
@@ -378,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.
@@ -455,19 +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),
-  );
-  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);
-  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);
@@ -654,6 +778,16 @@ function visibleRoundAgentPatch(run, state, role) {
 
 function recordVisibleDebateRound(run, args) {
   const role = args.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(
@@ -767,8 +901,7 @@ function recordVisibleDebateRound(run, args) {
 function visiblePmPrerequisites(run, state) {
   const missingEvidence = (run.tasks || [])
     .filter((task) => taskState(run, task).status !== "completed");
-  const recordedMasters = new Set((run.master_opinions || []).map((opinion) => opinion.master));
-  const missingMasters = selectedMasters(run).filter((master) => !recordedMasters.has(master));
+  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}`)
@@ -816,7 +949,18 @@ function recordVisiblePortfolioManager(run, args) {
         submitted_content_hash: contentHash,
       });
     }
-    return { run, decision: state.portfolio_manager.packet, idempotent_replay: true };
+    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);

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";
+// 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";
@@ -571,19 +581,62 @@ export function normalizeMasterOpinion(packet, masterId, run, raw = "") {
  * 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 = "") {
-  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}`);
+  // 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 internalError(`dedicated method worker attempted to change frozen stance for ${masterId}`);
+    throw invalidParams(`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}`);
+  // 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),

package/mcp/lib/personas/engine.mjs

@@ -194,10 +194,10 @@ export function completedMasterOpinion(run, item) {
   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} 충족` },
+    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 || [];
@@ -214,13 +214,18 @@ export function completedMasterOpinion(run, item) {
     : result.score
       ? `${result.score.score}/${result.score.max_possible} (${Math.round((result.ratio || 0) * 100)}%)`
     : copy.unscored;
+  const deterministicStatement = copy.summary(scoreText);
   return {
     master: item.id,
     symbol: run.symbol,
     as_of: run.as_of,
     stance: result.stance,
     verdict: copy.verdict(result.stance, result.reason),
-    summary: copy.summary(scoreText),
+    summary: deterministicStatement,
+    voice_statement: deterministicStatement,
+    voice_status: "deterministic_fallback",
+    voice_language: run.language,
+    statement_origin: "deterministic_policy_fallback",
     key_findings: uniqueStrings([
       ...hitIds.map(copy.hit),
       ...missIds.map(copy.miss),
@@ -260,13 +265,17 @@ export function declinedMasterOpinion(run, item) {
   const locale = languageKey(run.language);
   const label = item.pack.admitted_label?.[locale]
     || item.pack.admitted_label?.en || item.id;
+  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.`, 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}을 시점 일치 출처에서 확보할 수 있게 됨` },
+    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,
@@ -274,7 +283,11 @@ export function declinedMasterOpinion(run, item) {
     stance: "out_of_scope",
     verdict: copy.verdict,
     summary: copy.summary(missing),
-    key_findings: [],
+    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(copy.available),

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,