alphacouncil-agent 1.0.1 → 1.0.3

package/mcp/lib/personas-v3/grounding-adapter.mjs

@@ -571,6 +571,143 @@ function fundamentalFacts(grounding, context) {
  * across the newest ownership document per reporting owner, and the coverage limits of Section
  * 16 are real. Labelling it reported would claim a document that does not exist.
  */
+/**
+ * What else a basket is a bet on, as typed facts.
+ *
+ * Correlation to the broad market decides how much diversification a position actually buys,
+ * which is the input Dalio's authored policy already asks for and could never get. Correlation
+ * to Korea is the semiconductor cycle read from outside the United States. Sector dispersion is
+ * whether one factor or many are repricing the market.
+ */
+/**
+ * News as counts, never as content.
+ *
+ * A headline cannot reach a seat's arithmetic: the same symbol would answer differently
+ * depending on what was published that morning, and a frozen deterministic stance would stop
+ * being reproducible. What IS a fact is how much of the basket generated dated news in a stated
+ * window, and how many constituents filed an 8-K in it. Both are counts with a date, and both
+ * are the kind of thing an event-driven method legitimately asks for.
+ *
+ * The headlines themselves stay in the grounding for the report and for the voice worker that
+ * explains a stance the seat already reached.
+ */
+function basketNewsFacts(grounding, context) {
+  const news = grounding?.basket_news;
+  if (!news?.available) return;
+  const publicAt = timestampAtOrBefore(grounding?.gathered_at || context.asOf, context.cutoff);
+  if (!publicAt) return;
+  const sourceIdValue = sourceId("news", "basket_window", news.window_days, publicAt.slice(0, 10));
+  if (!registerSource(context, {
+    source_id: sourceIdValue,
+    source_kind: "news_aggregate",
+    title: `dated items for the basket's largest holdings over ${news.window_days} days`,
+    url: "https://news.google.com/rss",
+    public_at: publicAt,
+    retrieved_at: grounding.gathered_at || publicAt,
+    locator: { window_days: news.window_days, constituents_read: news.constituents_read, industry: news.industry?.id || null },
+  })) return;
+  const shared = {
+    asOf: context.asOf,
+    publicAt,
+    sources: [sourceIdValue],
+    confidence: 0.6,
+    derivation: "rederived",
+  };
+  addUnique(context.facts, context.diagnostics, baseFact({
+    ...shared,
+    factId: "news.covered_weight",
+    valueKind: "ratio",
+    value: news.coverage_weight,
+    unit: "decimal",
+    ratioDenominator: `weight_of_${news.constituents_read}_largest_holdings`,
+    derivationToolId: `${ADAPTER_ID}:news:covered_weight`,
+    derivationInput: { window_days: news.window_days },
+  }));
+  addUnique(context.facts, context.diagnostics, baseFact({
+    ...shared,
+    factId: "news.filing_event_weight",
+    valueKind: "ratio",
+    value: news.filing_event_weight,
+    unit: "decimal",
+    ratioDenominator: `weight_of_${news.constituents_read}_largest_holdings`,
+    derivationToolId: `${ADAPTER_ID}:news:filing_event_weight`,
+    derivationInput: { window_days: news.window_days, filers: news.filing_event_count },
+  }));
+}
+
+function crossMarketFacts(grounding, context) {
+  const rows = grounding?.cross_market;
+  const stamp = grounding?.gathered_at || context.asOf;
+  const publicAt = timestampAtOrBefore(stamp, context.cutoff);
+  if (Array.isArray(rows) && publicAt) {
+    for (const row of rows) {
+      if (!finite(row?.correlation)) continue;
+      const factId = CROSS_MARKET_FACTS[row.reference];
+      if (!factId) continue;
+      const sourceIdValue = sourceId("market", "cross_correlation", row.reference, row.to);
+      if (!registerSource(context, {
+        source_id: sourceIdValue,
+        source_kind: "market_snapshot",
+        title: `daily closes for ${row.label}`,
+        url: `https://query1.finance.yahoo.com/v8/finance/chart/${encodeURIComponent(row.reference)}?range=1y&interval=1d`,
+        public_at: publicAt,
+        retrieved_at: stamp,
+        locator: { reference: row.reference, from: row.from, to: row.to, sessions: row.sessions },
+      })) continue;
+      addUnique(context.facts, context.diagnostics, baseFact({
+        factId,
+        valueKind: "ratio",
+        value: row.correlation,
+        unit: "decimal",
+        ratioDenominator: `pearson_over_${row.sessions}_paired_sessions`,
+        asOf: context.asOf,
+        publicAt,
+        sources: [sourceIdValue],
+        confidence: 0.8,
+        derivation: "rederived",
+        derivationToolId: `${ADAPTER_ID}:cross_market:${row.reference}`,
+        derivationInput: { reference: row.reference, from: row.from, to: row.to, relative_return: row.relative_return },
+      }));
+    }
+  }
+  const dispersion = grounding?.sector_dispersion;
+  if (dispersion?.available && finite(dispersion.dispersion) && publicAt) {
+    const sourceIdValue = sourceId("market", "sector_dispersion", dispersion.to);
+    if (registerSource(context, {
+      source_id: sourceIdValue,
+      source_kind: "market_snapshot",
+      title: "Select Sector SPDR daily closes",
+      url: "https://query1.finance.yahoo.com/v8/finance/chart/XLK?range=1y&interval=1d",
+      public_at: publicAt,
+      retrieved_at: stamp,
+      locator: { sectors: dispersion.measured, from: dispersion.from, to: dispersion.to },
+    })) {
+      addUnique(context.facts, context.diagnostics, baseFact({
+        factId: "market.sector_dispersion",
+        valueKind: "ratio",
+        value: dispersion.dispersion,
+        unit: "decimal",
+        ratioDenominator: `stdev_of_${dispersion.measured}_sector_total_returns`,
+        asOf: context.asOf,
+        publicAt,
+        sources: [sourceIdValue],
+        confidence: 0.8,
+        derivation: "rederived",
+        derivationToolId: `${ADAPTER_ID}:sector_dispersion`,
+        derivationInput: { leader: dispersion.leader?.symbol, laggard: dispersion.laggard?.symbol, from: dispersion.from, to: dispersion.to },
+      }));
+    }
+  }
+}
+
+/** Reference market -> the fact id its correlation is published under. */
+const CROSS_MARKET_FACTS = Object.freeze({
+  "^GSPC": "market.correlation_to_broad_market",
+  "^KS11": "market.correlation_to_kospi",
+  "^KQ11": "market.correlation_to_kosdaq",
+  "^SOX": "market.correlation_to_semiconductors",
+});
+
 function insiderOwnershipFacts(grounding, context) {
   const owned = grounding?.insider_ownership;
   if (!owned || !finite(owned.value)) return;
@@ -668,7 +805,13 @@ export function adaptGroundingToTypedFacts(grounding, { asOf, knowledgeAsOf = as
   macroSeriesFacts(grounding, context);
   fundamentalFacts(grounding, context);
   instrumentAggregateFacts(grounding, context);
+  // The same converter, over the market-level block a company run now carries. Reusing it
+  // rather than writing a second one keeps one set of lineage and unit rules for facts that
+  // are the same facts, whoever the subject is.
+  instrumentAggregateFacts({ instrument_aggregate: grounding?.market_valuation, gathered_at: grounding?.gathered_at }, context);
   insiderOwnershipFacts(grounding, context);
+  crossMarketFacts(grounding, context);
+  basketNewsFacts(grounding, context);
   for (const family of ["screen", "macro", "market"]) {
     if (grounding?.[family] && !grounding[family].public_at) {
       if (family === "screen" && context.diagnostics.some((item) => String(item.source || "").startsWith("screen."))) continue;

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

@@ -528,10 +528,17 @@ export function assertFrozenDecisionIntegrity(frozenDecision) {
   return true;
 }
 
-/** Dispatch only an eligible anonymous decision. Missing required facts never call the layer. */
+/**
+ * Dispatch a decision the seat can still reach.
+ *
+ * `out_of_scope` -- none of the required facts present -- never calls the layer, because there
+ * is no method left to run. `insufficient_grounding` does: the policy's own vetoes and
+ * `on_missing` rules are how a method states what an absent input means, and refusing to
+ * execute them reported the runtime's own gate instead of the method's answer.
+ */
 export async function runAnonymousDecisionLayer(preDecision, decisionLayer) {
   verifyAnonymousPreDecision(preDecision);
-  if (preDecision.eligibility.status !== "ready") {
+  if (preDecision.eligibility.status === "out_of_scope") {
     return deepFreeze({
       decision_layer_called: false,
       frozen_decision: freezeAnonymousDecision(preDecision),

package/mcp/lib/screen.mjs

@@ -69,10 +69,36 @@ function ruleProvenance(series) {
  * Each returns { id, passed, value, threshold, reason } or { skipped } when the inputs
  * are not available -- a missing input is never silently treated as a pass.
  */
+/**
+ * Gross profit, direct where the filer tagged it and revenue less cost of revenue where not.
+ *
+ * The subtraction is the filer's own arithmetic on the filer's own figures, matched by period
+ * end so a year is never differenced against a different year. Years the filer did tag keep the
+ * tagged value: a direct number always beats a reconstructed one.
+ */
+export function derivedGrossProfit(direct, revenue, cost) {
+  if (direct?.length) return direct;
+  if (!revenue?.length || !cost?.length) return direct || [];
+  const costByEnd = new Map(cost.map((row) => [row.end, row]));
+  const derived = [];
+  for (const row of revenue) {
+    const paired = costByEnd.get(row.end);
+    if (!paired || !Number.isFinite(paired.val)) continue;
+    derived.push({
+      ...row,
+      val: row.val - paired.val,
+      tag: `${row.tag} - ${paired.tag}`,
+      derived_from: [row.tag, paired.tag],
+    });
+  }
+  return derived;
+}
+
 export function evaluateRules(facts, { asOf = null } = {}) {
   const revenue = values(facts, "revenue", asOf);
   const netIncome = values(facts, "netIncome", asOf);
-  const grossProfit = values(facts, "grossProfit", asOf);
+  // Derived where the filer did not tag it directly, from two figures it did publish.
+  const grossProfit = derivedGrossProfit(values(facts, "grossProfit", asOf), values(facts, "revenue", asOf), values(facts, "costOfRevenue", asOf));
   const operatingIncome = values(facts, "operatingIncome", asOf);
   const ocf = values(facts, "operatingCashFlow", asOf);
   const capex = values(facts, "capex", asOf);

package/mcp/lib/sec.mjs

@@ -31,21 +31,54 @@ async function throttle() {
   lastCall = Date.now();
 }
 
-async function secJson(url, timeoutMs = LIMITS.QUOTE_FETCH_MS * 2, upstreamSignal) {
-  await throttle();
-  const abort = linkedAbort(timeoutMs, upstreamSignal);
-  try {
-    const res = await fetch(url, {
-      signal: abort.signal,
-      headers: { "User-Agent": UA, Accept: "application/json" },
-    });
-    if (!res.ok) throw new Error(`HTTP ${res.status} for ${url}`);
-    const text = await res.text();
-    if (text.trimStart().startsWith("<")) throw new Error(`SEC returned HTML rather than JSON for ${url} (rate limited or blocked)`);
-    return JSON.parse(text);
-  } finally {
-    abort.cleanup();
+/**
+ * SEC answers 429 when a client outruns its guidance, and the throttle above only paces a
+ * single process -- a second one, or a burst of look-through fetches, still crosses the line.
+ * Without a backoff the whole evidence chain for a run collapses on one rate-limited response,
+ * which is indistinguishable in the report from the data not existing.
+ *
+ * Deliberately short and bounded: three attempts over about a second and a half. A caller that
+ * is genuinely over budget should fail fast and be told, not stall a research run.
+ */
+const RATE_LIMIT_ATTEMPTS = 3;
+const RATE_LIMIT_BACKOFF_MS = 400;
+
+function isRateLimited(status) {
+  return status === 429 || status === 503;
+}
+
+async function withRateLimitRetry(attempt) {
+  let lastError = null;
+  for (let tries = 0; tries < RATE_LIMIT_ATTEMPTS; tries += 1) {
+    if (tries > 0) await new Promise((resolve) => setTimeout(resolve, RATE_LIMIT_BACKOFF_MS * (2 ** (tries - 1))));
+    const outcome = await attempt();
+    if (!outcome.rateLimited) return outcome;
+    lastError = outcome.error;
   }
+  throw lastError;
+}
+
+async function secJson(url, timeoutMs = LIMITS.QUOTE_FETCH_MS * 2, upstreamSignal) {
+  const outcome = await withRateLimitRetry(async () => {
+    await throttle();
+    const abort = linkedAbort(timeoutMs, upstreamSignal);
+    try {
+      const res = await fetch(url, {
+        signal: abort.signal,
+        headers: { "User-Agent": UA, Accept: "application/json" },
+      });
+      if (isRateLimited(res.status)) {
+        return { rateLimited: true, error: new Error(`HTTP ${res.status} for ${url}`) };
+      }
+      if (!res.ok) throw new Error(`HTTP ${res.status} for ${url}`);
+      const text = await res.text();
+      if (text.trimStart().startsWith("<")) throw new Error(`SEC returned HTML rather than JSON for ${url} (rate limited or blocked)`);
+      return { rateLimited: false, value: JSON.parse(text) };
+    } finally {
+      abort.cleanup();
+    }
+  });
+  return outcome.value;
 }
 
 /** Raw filing index for one registrant. Callers that need form types read this, not `fetchSubmissions`. */
@@ -188,12 +221,42 @@ export const CONCEPTS = {
   ],
   netIncome: ["NetIncomeLoss", "ProfitLoss"],
   grossProfit: ["GrossProfit"],
-  operatingIncome: ["OperatingIncomeLoss"],
+  // Most filers never tag GrossProfit -- ten of fifteen large caps tested do not -- and report
+  // revenue and cost of revenue separately instead. The margin is derived from those when the
+  // direct tag is absent, which is arithmetic the filer already published rather than an
+  // estimate. Without this, a gross-margin rule was unavailable for two thirds of the market
+  // and every seat that reads it fell silent.
+  costOfRevenue: [
+    "CostOfGoodsAndServicesSold",
+    "CostOfRevenue",
+    "CostOfGoodsSold",
+    "CostOfServices",
+    "CostOfGoodsAndServicesSoldExcludingDepreciationDepletionAndAmortization",
+  ],
+  operatingIncome: ["OperatingIncomeLoss", "OperatingIncomeLossIncludingEquityMethodInvestments"],
   operatingCashFlow: ["NetCashProvidedByUsedInOperatingActivities", "NetCashProvidedByUsedInOperatingActivitiesContinuingOperations"],
-  capex: ["PaymentsToAcquirePropertyPlantAndEquipment", "PaymentsToAcquireProductiveAssets"],
+  // Capital expenditure has no single tag in practice. Corning files PaymentsForCapitalImprovements
+  // and nothing this list previously contained, which alone removed owner earnings -- and with
+  // it Buffett and Ackman -- for every issuer that tags it that way.
+  capex: [
+    "PaymentsToAcquirePropertyPlantAndEquipment",
+    "PaymentsToAcquireProductiveAssets",
+    "PaymentsForCapitalImprovements",
+    "PaymentsForProceedsFromProductiveAssets",
+    "PaymentsToAcquireOtherPropertyPlantAndEquipment",
+    "PaymentsToAcquireMachineryAndEquipment",
+  ],
   equity: ["StockholdersEquity", "StockholdersEquityIncludingPortionAttributableToNoncontrollingInterest"],
   assets: ["Assets"],
-  interestExpense: ["InterestExpense", "InterestIncomeExpenseNet", "InterestExpenseDebt"],
+  interestExpense: [
+    "InterestExpense",
+    "InterestIncomeExpenseNet",
+    "InterestExpenseDebt",
+    "InterestExpenseNonoperating",
+    "InterestAndDebtExpense",
+    "InterestIncomeExpenseNonoperatingNet",
+    "InterestExpenseBorrowings",
+  ],
   sharesOutstanding: ["CommonStockSharesOutstanding", "WeightedAverageNumberOfDilutedSharesOutstanding"],
 };
 

package/mcp/lib/voice-from-decision.mjs

@@ -0,0 +1,211 @@
+/**
+ * The five-field voice, composed from the frozen decision rather than written about it.
+ *
+ * A seat that computed a real verdict from real facts was reporting it in one sentence, and a
+ * reader could not see what it had looked at. The five fields existed and nothing filled them.
+ *
+ * The deterministic record already holds everything they need: which facts were read and what
+ * they were, which tools ran and what they produced, which scoring rules hit and missed, which
+ * vetoes fired, the band the score landed in, and the conditions that would move it. Composing
+ * the fields FROM that record has a property that asking a model to restate a sentence does
+ * not: the explanation cannot drift from the verdict, because it is derived from it. If the
+ * text says a rule missed, the rule missed.
+ *
+ * Nothing here is a claim about a named person. It is a rendering of arithmetic the seat's own
+ * policy performed, in the report's language.
+ */
+
+import { localized } from "./lang.mjs";
+import { defaultIntentForStance } from "./voice.mjs";
+
+const MAX_ITEMS = 4;
+
+function finite(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+/** Numbers a reader can scan: decimals stay short, big money keeps its magnitude. */
+export function readableValue(fact) {
+  const value = fact?.value;
+  if (!finite(value)) return String(value ?? "—");
+  if (fact.unit === "decimal" && Math.abs(value) < 10) return `${(value * 100).toFixed(1)}%`;
+  if (Math.abs(value) >= 1e9) return `${(value / 1e9).toFixed(2)}B`;
+  if (Math.abs(value) >= 1e6) return `${(value / 1e6).toFixed(1)}M`;
+  return Number(value.toFixed(4)).toString();
+}
+
+/** Every fact id a condition reads, in the order it reads them. */
+export function factsInCondition(node, into = []) {
+  if (!node || typeof node !== "object") return into;
+  if (typeof node.fact_id === "string") into.push(node.fact_id);
+  for (const value of Object.values(node)) {
+    if (Array.isArray(value)) value.forEach((entry) => factsInCondition(entry, into));
+    else if (value && typeof value === "object") factsInCondition(value, into);
+  }
+  return into;
+}
+
+function copyFor(language) {
+  return localized(language, {
+    en: {
+      readFacts: (list) => `Facts this method read: ${list}.`,
+      noFacts: "The point-in-time record supplied none of the facts this method reads.",
+      computed: (list) => `It computed ${list}.`,
+      hits: (n, total, list) => `${n} of ${total} scoring conditions held: ${list}.`,
+      misses: (list) => `Conditions that did not hold: ${list}.`,
+      noRules: "No scoring condition could be evaluated on what was available.",
+      veto: (list) => `A hard veto decided this before scoring: ${list}.`,
+      band: (stance, ratio) => `The score of ${ratio} places it in the ${stance} band.`,
+      intent: (label) => `On this evidence the method's position is: ${label}.`,
+      changes: (list) => `This changes if: ${list}.`,
+      noChanges: "No stated condition would move this within the method's own rules.",
+      disagree: "This is a single method run on frozen facts. It is not a forecast, and where it differs from the analyst sections the difference is the method's scope, not a correction of them.",
+      declineWhat: (list) => `This method requires ${list}, and the point-in-time record did not carry ${list === "" ? "them" : "all of it"}.`,
+      declineWhy: "It abstains rather than substituting a proxy, because a number the method did not compute is not the method's answer.",
+    },
+    zh: {
+      readFacts: (list) => `本方法读取的事实：${list}。`,
+      noFacts: "时点一致的记录没有提供本方法需要的任何事实。",
+      computed: (list) => `据此计算得到：${list}。`,
+      hits: (n, total, list) => `${total} 条评分条件中有 ${n} 条成立：${list}。`,
+      misses: (list) => `未成立的条件：${list}。`,
+      noRules: "在可得资料上没有任何评分条件能够求值。",
+      veto: (list) => `在评分之前已由硬否决决定：${list}。`,
+      band: (stance, ratio) => `得分 ${ratio}，落在「${stance}」档。`,
+      intent: (label) => `基于这些证据，本方法的立场是：${label}。`,
+      changes: (list) => `以下情况会改变这一判断：${list}。`,
+      noChanges: "在本方法自身的规则内，没有任何已陈述的条件会改变它。",
+      disagree: "这是一次在冻结事实上运行的单一方法，不是预测。与分析师各席的差异来自方法的适用范围，不构成对他们的更正。",
+      declineWhat: (list) => `本方法需要 ${list}，而时点一致的记录没有全部提供。`,
+      declineWhy: "它选择弃权而不是用替代值补位，因为方法没有计算出来的数字不是方法的答案。",
+    },
+    ja: {
+      readFacts: (list) => `この手法が読んだ事実：${list}。`,
+      noFacts: "時点整合した記録に、この手法が読む事実はありませんでした。",
+      computed: (list) => `そこから算出：${list}。`,
+      hits: (n, total, list) => `${total} 件の採点条件のうち ${n} 件が成立：${list}。`,
+      misses: (list) => `成立しなかった条件：${list}。`,
+      noRules: "利用可能な資料では採点条件を評価できませんでした。",
+      veto: (list) => `採点の前にハード拒否で決着：${list}。`,
+      band: (stance, ratio) => `スコア ${ratio}、「${stance}」の帯に入ります。`,
+      intent: (label) => `この証拠に基づく手法の立場：${label}。`,
+      changes: (list) => `次の場合に判断は変わります：${list}。`,
+      noChanges: "手法自身の規則の範囲では、判断を動かす条件は示されていません。",
+      disagree: "凍結された事実に対する単一手法の実行であり、予測ではありません。アナリスト各席との差異は手法の適用範囲によるもので、訂正ではありません。",
+      declineWhat: (list) => `この手法は ${list} を必要としますが、時点整合した記録が揃いませんでした。`,
+      declineWhy: "代替値で埋めず棄権します。手法が計算していない数値は手法の答えではないからです。",
+    },
+    ko: {
+      readFacts: (list) => `이 방법이 읽은 사실: ${list}.`,
+      noFacts: "시점이 일치하는 기록에 이 방법이 읽는 사실이 없었습니다.",
+      computed: (list) => `이로부터 산출: ${list}.`,
+      hits: (n, total, list) => `채점 조건 ${total}개 중 ${n}개 성립: ${list}.`,
+      misses: (list) => `성립하지 않은 조건: ${list}.`,
+      noRules: "확보된 자료로는 어떤 채점 조건도 평가할 수 없었습니다.",
+      veto: (list) => `채점 전에 하드 비토로 결정됨: ${list}.`,
+      band: (stance, ratio) => `점수 ${ratio}, "${stance}" 구간에 해당합니다.`,
+      intent: (label) => `이 증거에서 이 방법의 입장: ${label}.`,
+      changes: (list) => `다음의 경우 판단이 바뀝니다: ${list}.`,
+      noChanges: "방법 자체의 규칙 안에서 판단을 움직일 조건은 제시되지 않았습니다.",
+      disagree: "동결된 사실에 대한 단일 방법 실행이며 예측이 아닙니다. 애널리스트 좌석과의 차이는 방법의 적용 범위 차이이지 정정이 아닙니다.",
+      declineWhat: (list) => `이 방법은 ${list}이 필요하지만 시점 일치 기록이 이를 모두 담고 있지 않았습니다.`,
+      declineWhy: "대체값으로 메우지 않고 기권합니다. 방법이 계산하지 않은 숫자는 방법의 답이 아니기 때문입니다.",
+    },
+  });
+}
+
+/**
+ * Compose the five fields for a seat that reached a stance.
+ *
+ * `result` is the frozen `structured_decision.result`; `policy` is the seat's decision policy,
+ * which supplies the human-readable condition ids the result refers to by index.
+ */
+export function voiceFromDecision({ result, policy, factPack, language = "English" } = {}) {
+  const copy = copyFor(language);
+  const facts = new Map((factPack?.facts || []).map((fact) => [fact.fact_id, fact]));
+  const stance = result?.common_projection?.stance || "out_of_scope";
+
+  const readIds = [...new Set([
+    ...(policy?.scoring?.rules || []).flatMap((rule) => factsInCondition(rule.condition)),
+    ...(policy?.hard_vetoes || []).flatMap((veto) => factsInCondition(veto.condition)),
+    ...(policy?.eligibility?.all || []).flatMap((check) => factsInCondition(check.condition)),
+  ])].filter((id) => facts.has(id));
+  const readList = readIds.slice(0, MAX_ITEMS)
+    .map((id) => `${id} = ${readableValue(facts.get(id))}`).join("; ");
+
+  const computed = (result?.computations?.trace || [])
+    .filter((step) => step.status === "computed" && finite(step.value))
+    .slice(0, MAX_ITEMS)
+    .map((step) => `${step.output_id} = ${Number(step.value.toFixed(4))}`)
+    .join("; ");
+
+  // The executor publishes the rules it evaluated already split into hits, misses and the ones
+  // it could not compute. Reading its own split rather than re-deriving one is what keeps this
+  // text unable to disagree with the verdict it describes.
+  const scoring = result?.score || {};
+  const hits = scoring.hits || [];
+  const misses = scoring.misses || [];
+  const uncomputable = scoring.uncomputable || [];
+  const evaluated = [...hits, ...misses, ...uncomputable];
+  // The runtime anonymises rule ids so the decision layer cannot recognise the seat. A reader
+  // is not the decision layer: map each anonymous id back to the readable name in the seat's
+  // own policy, which lists its rules in the same order the executor evaluated them.
+  const readableRuleIds = new Map((policy?.scoring?.rules || [])
+    .map((rule, index) => [index, rule.rule_id])
+    .filter(([, id]) => typeof id === "string"));
+  const anonOrder = new Map(evaluated
+    .map((rule) => rule.rule_id)
+    .filter(Boolean)
+    .map((id, index) => [id, index]));
+  const ruleName = (rule) => {
+    const anon = rule.rule_id || rule.id;
+    const readable = readableRuleIds.get(anonOrder.get(anon));
+    return readable || anon || "rule";
+  };
+
+  const vetoes = (result?.vetoes_triggered || []).map((veto) => veto.veto_id).filter(Boolean);
+
+  const whatISee = [
+    readList ? copy.readFacts(readList) : copy.noFacts,
+    computed ? copy.computed(computed) : "",
+  ].filter(Boolean).join(" ");
+
+  const howItReads = [
+    vetoes.length ? copy.veto(vetoes.join("; ")) : "",
+    evaluated.length
+      ? copy.hits(hits.length, evaluated.length, hits.map(ruleName).join("; ") || "—")
+      : copy.noRules,
+    misses.length ? copy.misses(misses.map(ruleName).join("; ")) : "",
+    finite(result?.common_projection?.score_ratio)
+      ? copy.band(stance, Number(result.common_projection.score_ratio.toFixed(3)))
+      : "",
+  ].filter(Boolean).join(" ");
+
+  const changes = [
+    ...misses.map(ruleName),
+    ...uncomputable.map(ruleName),
+    ...vetoes,
+  ].slice(0, MAX_ITEMS);
+
+  return {
+    what_i_see: whatISee,
+    how_my_method_reads_it: howItReads,
+    would_i_act: copy.intent(defaultIntentForStance(stance)),
+    what_changes_my_mind: changes.length ? copy.changes(changes.join("; ")) : copy.noChanges,
+    where_i_disagree: copy.disagree,
+  };
+}
+
+/** The same five fields for a seat that could not run, so an abstention is also readable. */
+export function voiceFromDecline({ eligibility, language = "English" } = {}) {
+  const copy = copyFor(language);
+  const missing = (eligibility?.missing_required_fact_types || []).slice(0, MAX_ITEMS).join("; ");
+  const present = (eligibility?.present_required_fact_types || []).slice(0, MAX_ITEMS).join("; ");
+  return {
+    what_i_see: present ? copy.readFacts(present) : copy.noFacts,
+    how_my_method_reads_it: copy.declineWhat(missing),
+    would_i_act: copy.intent(defaultIntentForStance("out_of_scope")),
+    what_changes_my_mind: missing ? copy.changes(missing) : copy.noChanges,
+    where_i_disagree: copy.declineWhy,
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alphacouncil-agent",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Multi-agent company, ETF and market-index research workflow for Codex & Claude Code: sourced evidence, method seats, bull/bear debate and portfolio-manager synthesis.",
   "type": "module",
   "license": "MIT",

package/scripts/lib/persona-v3-solo-formula-pipeline.mjs

@@ -126,6 +126,17 @@ export const CANONICAL_SOLO_TEST_FACT_CONTRACTS = Object.freeze({
   "fund.aum": Object.freeze({ value_kind: "monetary", unit: "currency_units", period: INSTANT_AS_OF }),
   "fund.expense_ratio": Object.freeze({ value_kind: "ratio", unit: "decimal", period: INSTANT_AS_OF }),
   // Creations minus redemptions, priced. A crowding signal, never a valuation one.
+  // What else the holding is a bet on. Correlation decides what a position actually
+  // diversifies; dispersion says whether one factor or many are repricing the market.
+  "market.correlation_to_broad_market": Object.freeze({ value_kind: "ratio", unit: "decimal", period: INSTANT_AS_OF }),
+  "market.correlation_to_kospi": Object.freeze({ value_kind: "ratio", unit: "decimal", period: INSTANT_AS_OF }),
+  "market.correlation_to_kosdaq": Object.freeze({ value_kind: "ratio", unit: "decimal", period: INSTANT_AS_OF }),
+  "market.correlation_to_semiconductors": Object.freeze({ value_kind: "ratio", unit: "decimal", period: INSTANT_AS_OF }),
+  // News as counts. The headlines never enter a computation; how much of the basket is in the
+  // news, and how much of it filed, are dated quantities an event-driven method may read.
+  "news.covered_weight": Object.freeze({ value_kind: "ratio", unit: "decimal", period: INSTANT_AS_OF }),
+  "news.filing_event_weight": Object.freeze({ value_kind: "ratio", unit: "decimal", period: INSTANT_AS_OF }),
+  "market.sector_dispersion": Object.freeze({ value_kind: "ratio", unit: "decimal", period: INSTANT_AS_OF }),
   "fund.net_flow": Object.freeze({ value_kind: "monetary", unit: "currency_units", period: INSTANT_AS_OF }),
   "fund.net_flow_ratio": Object.freeze({ value_kind: "ratio", unit: "decimal", period: INSTANT_AS_OF }),