alphacouncil-agent 1.0.1 → 1.0.3

package/knowledge/ai-assisted-solo/experiments/simulation-input.json

@@ -18,7 +18,7 @@
   "formal_ga_effect": "none",
   "formal_h_satisfied": false,
   "human_reference": false,
-  "input_hash": "sha256:12ed14b1580ffc858af45f5dc4109d4fe3bcb7d89d20017f5103f3c770d9c213",
+  "input_hash": "sha256:cc4ffaa54c9477000383adc82ba43800c3725c331638f2f8f63cad15582a128f",
   "network_allowed": false,
   "production_effect": "none",
   "protocol_binding": {
@@ -31,14 +31,14 @@
   "reviewer_kind": "ai",
   "runtime_bindings": [
     {
-      "byte_length": 27327,
+      "byte_length": 27650,
       "path": "mcp/lib/personas-v3/runtime.mjs",
-      "physical_file_hash": "sha256:ad06e3d004cdb072909fc2fb9cf643dace28ff542a4c7092309fdd53f5623b63"
+      "physical_file_hash": "sha256:aa32cf59eaec9eeb9583e44b76b31fac8fb8661e49b0b19da6de0f9b4ca5f568"
     },
     {
-      "byte_length": 49532,
+      "byte_length": 51789,
       "path": "mcp/lib/personas-v3/deterministic-executor.mjs",
-      "physical_file_hash": "sha256:1222b8c56e5535ec1f446f55aee0a3c1b948f80403e53085de932398ae90f7ef"
+      "physical_file_hash": "sha256:ee45aed55448644c194e576b9f8611a9afd163e53b36f744ee687ae25ca99bdb"
     },
     {
       "byte_length": 8032,
@@ -1008,7 +1008,7 @@
         "schema_version": 1
       },
       "fact_pack_hash": "sha256:f69c424fb4ab9bb147ca933702857366ea492f8e988bfb2aeeb4e64df2c32706",
-      "pack_hash": "sha256:de88d2c0e811ac58876e7fd70c63d4dd75340e0f60164b960f21dad0db581aa7",
+      "pack_hash": "sha256:f960a6c7061ae791935590e8d045478a65ea451335aceaed5c275894a9b8c9d7",
       "pack_manifest_binding": {
         "byte_length": 5436,
         "path": "knowledge/solo-test/masters/master_graham/manifest.json",
@@ -6322,7 +6322,7 @@
         "schema_version": 1
       },
       "fact_pack_hash": "sha256:0b481c9b13e34ec6465e5007d364473d71c462e3940726744fa6f91b9646f4d3",
-      "pack_hash": "sha256:c71dc3fb2042965075386177ee6dad16ff88abb056b8599146117437e0b19f15",
+      "pack_hash": "sha256:a09fec122e5d4f43d8885a5b00e354d259768c7f4648c9f0eebb358cf0461134",
       "pack_manifest_binding": {
         "byte_length": 5399,
         "path": "knowledge/solo-test/masters/master_klarman/manifest.json",
@@ -6634,7 +6634,7 @@
         "schema_version": 1
       },
       "fact_pack_hash": "sha256:6735e9705be48f6b9c19db94360b13ad6727db15e288c4e1225664ddd1d1a5a1",
-      "pack_hash": "sha256:f48324d38fbe0f5b2f68a1c391298c618962f11bec362b83c46d462f5235953f",
+      "pack_hash": "sha256:8ee9e13deaadaeef3065feb7bb5b39382181338cf1055b769b153cad4c308ce4",
       "pack_manifest_binding": {
         "byte_length": 5594,
         "path": "knowledge/solo-test/masters/master_pabrai/manifest.json",
@@ -8278,7 +8278,7 @@
         "schema_version": 1
       },
       "fact_pack_hash": "sha256:d035c7f7cbace9a80cce787b1ea3204f7b85437e4552dec34681765f0ab3af26",
-      "pack_hash": "sha256:73e829f5d2e3b1124689635cb70bbef8f764559603689a5eae9920716eaf5d1c",
+      "pack_hash": "sha256:cbc29f36bcf214b24045d582bf954d06cda6cec3aab06c41f650f7410df510f0",
       "pack_manifest_binding": {
         "byte_length": 5640,
         "path": "knowledge/solo-test/masters/master_bogle/manifest.json",

package/knowledge/ai-assisted-solo/experiments/simulation-manifest.json

@@ -6,11 +6,11 @@
   "formal_h_satisfied": false,
   "human_reference": false,
   "input_binding": {
-    "content_hash": "sha256:c05cc5d09dbb4bac71c6f1cee891bc7d8ab6674a59ca8f828794f9a3a1d6eb5e",
-    "input_hash": "sha256:12ed14b1580ffc858af45f5dc4109d4fe3bcb7d89d20017f5103f3c770d9c213",
+    "content_hash": "sha256:6340496a97245ce4bef30d91fdd7007e1128d7324ab28f55f8ff884a221a1363",
+    "input_hash": "sha256:cc4ffaa54c9477000383adc82ba43800c3725c331638f2f8f63cad15582a128f",
     "path": "simulation-input.json"
   },
-  "manifest_hash": "sha256:ec018a1666edb9c7b69c5a6d21b5df60c592d99a35cfb6c50ad6fc3afff23cc2",
+  "manifest_hash": "sha256:bb7437c3661c054886c048ed258739064cd132b86fb286265e7f0b43e22cd2f3",
   "n_eff_disclosure_binding": {
     "artifact_hash": "sha256:42ddb52fb8c5cc6335a0c90bbb4989fcfcc0a626ea1a32c87697ba4335ec94ab",
     "content_hash": "sha256:18f4efc086ffa86322eeb9b442960b291f41811d92b7fc3f59db72dfb5cbc305",
@@ -32,66 +32,66 @@
   "run_bindings": [
     {
       "blocked_fail_closed_count": 0,
-      "content_hash": "sha256:c1cbaee09b8df627681a3fcb4463708223490cd0a06815749a8c9ec8fe45ebb1",
+      "content_hash": "sha256:6370e7f572f4ebcdec74b2424cd4a8b7f2867bd788902d38319b09d7c966ce52",
       "executed_count": 1,
       "path": "runs/a.json",
-      "run_artifact_hash": "sha256:e6667b6317419d31e8bcc403132977837c7e6403328aad9358748372bf87103a",
+      "run_artifact_hash": "sha256:699e79ff212ba32d287d8847828b46e6bd46076519c6dc8dca5e9ac09f6d769f",
       "run_id": "A"
     },
     {
       "blocked_fail_closed_count": 0,
-      "content_hash": "sha256:1f735b8038f2e16f8acc7eabd9950eadffe43d75b6a3a012b12197582ab8769f",
+      "content_hash": "sha256:82ad061ab98755a8f62ac2007ef245f28c711f71bbb9e99d27d02c8a61a52451",
       "executed_count": 0,
       "path": "runs/b.json",
-      "run_artifact_hash": "sha256:6c983e5bae0666b24981f9325b7381dd687402a7a229ffa57e2f8b775b28c49d",
+      "run_artifact_hash": "sha256:423ac48286f88cd5e95942dce855507559d54fe7fd3a5481327424c4e6966f85",
       "run_id": "B"
     },
     {
       "blocked_fail_closed_count": 0,
-      "content_hash": "sha256:64922c53001578fc10cf70f356b4e2399a31178f4baa4df73856267d05610f9f",
+      "content_hash": "sha256:900dc8d6b6514e06080c207d67e98564dccb9bb04170bf3e1dc19bbe8db90c1e",
       "executed_count": 0,
       "path": "runs/c.json",
-      "run_artifact_hash": "sha256:b670cc60a8d3d3b6d7c1a0f5736eb56dd77396dccd2dfec6078722643ef0abbb",
+      "run_artifact_hash": "sha256:9a10ff578582c9476676ac454577d40e71aeb83dea128275e76d1d7e1d566f6c",
       "run_id": "C"
     },
     {
       "blocked_fail_closed_count": 0,
-      "content_hash": "sha256:f5743ff07deb17efed1ef9c90e44f184723e99a1418b7dd3994995f2bb2f9cfb",
+      "content_hash": "sha256:acfe2440cd09928f73f542b39561bb5b66c77fc78cc37d56ec35b413daef32a5",
       "executed_count": 13,
       "path": "runs/d13.json",
-      "run_artifact_hash": "sha256:daa75132d89580f45d0baf9d64eff7d697d8124de38ea1efbba25c40ea1fe69c",
+      "run_artifact_hash": "sha256:4ea0207eb1f9090b7a841585a268d8bef366a61d23b22bdeee0295bb52d47610",
       "run_id": "D13"
     },
     {
       "blocked_fail_closed_count": 1,
-      "content_hash": "sha256:d7cade7c5f12edced2bf4d61835bce13dbd6c2f99fdf04d8cc0180eebde7b554",
+      "content_hash": "sha256:ccf02804dd2e4e41d8d79f81d4226227c6796ba5b753d0ab9724c1617839f476",
       "executed_count": 26,
       "path": "runs/d26.json",
-      "run_artifact_hash": "sha256:fe4d1876876fe19890e7bf79bdbaff4f175abc3c60866acf77b3137c46ff1114",
+      "run_artifact_hash": "sha256:eb5d0df7917c119e07f82f7d7b84b4d4e84c6423753462ca7a26f9be16ebfef8",
       "run_id": "D26"
     },
     {
       "blocked_fail_closed_count": 0,
-      "content_hash": "sha256:4baf3ed4448324cf00a8bd73e5399be833987fcfd268a4b30a5a4fe6fa7e0ece",
+      "content_hash": "sha256:443b278936de20e6f1645dc9eda2b1e3743c0ed58933c00794177549b256be67",
       "executed_count": 13,
       "path": "runs/e-d13.json",
-      "run_artifact_hash": "sha256:6264276ff9749efea70ad70db981dfbbd9b7773b2565a4f7ae3701f7fc6592d3",
+      "run_artifact_hash": "sha256:3817bcac7b4ce7d1d0ddf06381b31b463b05790461f38de6b17e26ae2250f297",
       "run_id": "E:D13"
     },
     {
       "blocked_fail_closed_count": 1,
-      "content_hash": "sha256:23ae4a59c10552c44705d662e5463b953c04488564e89c66b62da76a85239a02",
+      "content_hash": "sha256:9d5712d5baff1efe560691bc8208b25a5c90843b4ada21d1a339376a2b7395c7",
       "executed_count": 26,
       "path": "runs/e-d26.json",
-      "run_artifact_hash": "sha256:ee892f51113cc5eed8106348998174e734e0a1bf9500078aa3d5acfb61da4293",
+      "run_artifact_hash": "sha256:be206b4a629bcb349da681e6eaed9f695b0c880d84963092466285c19f830ce4",
       "run_id": "E:D26"
     },
     {
       "blocked_fail_closed_count": 1,
-      "content_hash": "sha256:377fab6c442cd6a44d5c2f2889d9399d88702e6ab0f971494dee1a1ced8a8258",
+      "content_hash": "sha256:805833bcc92aebb115c42de08e25c94ad4b8a98032d3375ed4301722521be02d",
       "executed_count": 26,
       "path": "runs/h_ai_reference.json",
-      "run_artifact_hash": "sha256:f5def24331e45e8260ec19dc1731b4a0856a36be84e04b70608963b67b62ca9d",
+      "run_artifact_hash": "sha256:790838e3d208ed1c9c3da3210ced26871f02b7fc8b01de920804bfbdefb4c000",
       "run_id": "H_ai_reference"
     }
   ],

package/knowledge/solo-test/masters/master_bogle/decision_policy.json

@@ -10,14 +10,14 @@
             "fact_id": "fund.top_ten_weight"
           }
         },
-        "condition_id": "master_bogle.holdings_breadth_visible",
+        "condition_id": "master_bogle.subject_is_a_basket",
         "on_false": {
           "common_stance": "out_of_scope",
-          "native_state": "provisional_insufficient_return_inputs"
+          "native_state": "provisional_not_a_basket"
         },
         "on_uncomputable": {
           "common_stance": "out_of_scope",
-          "native_state": "provisional_insufficient_return_inputs"
+          "native_state": "provisional_not_a_basket"
         },
         "source_ids": [
           "proxy:1b982d2dc6b935fc0"
@@ -77,6 +77,7 @@
     }
   ],
   "native_states": [
+    "provisional_not_a_basket",
     "provisional_insufficient_return_inputs",
     "provisional_overpriced_market",
     "provisional_fair_expected_return",

package/knowledge/solo-test/masters/master_bogle/provisional-index.json

@@ -6,9 +6,11 @@
     "provisional_fair_expected_return": "cautious",
     "provisional_insufficient_return_inputs": "out_of_scope",
     "provisional_low_cost_index_candidate": "cautious",
+    "provisional_not_a_basket": "cautious",
     "provisional_overpriced_market": "opposed"
   },
   "declared_state_hypotheses": [
+    "not_a_basket",
     "insufficient_return_inputs",
     "overpriced_market",
     "fair_expected_return",
@@ -19,6 +21,7 @@
   "formula_compilation_manifest_hash": "sha256:9eb750e5aec2e4b6ef7a7033aba119927d5a6540220d608cbe6fd90eaf255b05",
   "method_model_eligible": false,
   "native_states": [
+    "provisional_not_a_basket",
     "provisional_insufficient_return_inputs",
     "provisional_overpriced_market",
     "provisional_fair_expected_return",

package/knowledge/solo-test/masters/master_bogle/sources.jsonl

@@ -1 +1 @@
-{"adjudication":{"notes":"No human review, no named-method attribution, no production effect.","reviewer_ids":[],"status":"pending"},"author":"AlphaCouncil project build specification","content_hash":"sha256:f0a1c271c11a09700d1fd65dc1b772a8d68433473478fc9d962e2078877ac494","grade":"E","known_at":"2026-07-27","locator":{"section":"master_bogle"},"public_at":"2026-07-27","published_at":"2026-07-27","retrieved_at":"2026-07-27","schema_version":1,"source_id":"proxy:1b982d2dc6b935fc0","source_kind":"derived_proxy","summary":"Project-authored provisional proxy used only to exercise the deterministic solo-test build; it is not source approval or method attribution.","supports":["solo_test_structure","deterministic_execution_only"],"title":"Provisional project-derived method hypothesis for master_bogle","url":"https://github.com/Zhao73/alphacouncil-agent/blob/main/data/persona-v3-build-specs.v1.mjs"}
+{"adjudication":{"notes":"No human review, no named-method attribution, no production effect.","reviewer_ids":[],"status":"pending"},"author":"AlphaCouncil project build specification","content_hash":"sha256:21670e88406249cc764918c4137c9782bcd28419ef8f2e96077ccb5f18df121c","grade":"E","known_at":"2026-07-27","locator":{"section":"master_bogle"},"public_at":"2026-07-27","published_at":"2026-07-27","retrieved_at":"2026-07-27","schema_version":1,"source_id":"proxy:1b982d2dc6b935fc0","source_kind":"derived_proxy","summary":"Project-authored provisional proxy used only to exercise the deterministic solo-test build; it is not source approval or method attribution.","supports":["solo_test_structure","deterministic_execution_only"],"title":"Provisional project-derived method hypothesis for master_bogle","url":"https://github.com/Zhao73/alphacouncil-agent/blob/main/data/persona-v3-build-specs.v1.mjs"}

package/knowledge/solo-test/masters/master_graham/decision_policy.json

@@ -43,7 +43,7 @@
         }
       },
       "on_trigger": {
-        "common_stance": "out_of_scope",
+        "common_stance": "opposed",
         "native_state": "provisional_insufficient_floor"
       },
       "on_uncomputable": {

package/knowledge/solo-test/masters/master_klarman/decision_policy.json

@@ -43,7 +43,7 @@
         }
       },
       "on_trigger": {
-        "common_stance": "out_of_scope",
+        "common_stance": "opposed",
         "native_state": "provisional_downside_unknown"
       },
       "on_uncomputable": {

package/knowledge/solo-test/masters/master_pabrai/decision_policy.json

@@ -63,7 +63,7 @@
         }
       },
       "on_trigger": {
-        "common_stance": "out_of_scope",
+        "common_stance": "opposed",
         "native_state": "provisional_no_floor"
       },
       "on_uncomputable": {

package/mcp/lib/basket-news.mjs

@@ -0,0 +1,181 @@
+/**
+ * News for something that is not a company.
+ *
+ * `SOX` has no press office, files nothing, and returns nothing from a ticker news feed. Asked
+ * for "recent semiconductor news" the pipeline had no way to turn the symbol into that subject,
+ * so a basket run carried market-wide headlines and no industry at all.
+ *
+ * A basket's news identity comes from what it holds, not from a table someone maintains:
+ *
+ *   - **The industry** is the modal SIC group of its largest holdings. SOXX resolves to
+ *     semiconductors because its holdings are semiconductor registrants, and XLE resolves to
+ *     energy for the same reason. A hand-written map would drift the first time an index
+ *     rebalanced; this cannot.
+ *   - **The constituents** supply their own dated company news and their own 8-K filings,
+ *     weighted by how much of the basket each one is. A headline about 8% of the fund is worth
+ *     more than one about 0.3% of it, and the weight travels with the item so a reader can see
+ *     which it was.
+ *
+ * What this deliberately does NOT do is let a headline reach a seat's arithmetic. A frozen
+ * deterministic stance stays frozen; news informs what a seat SAYS about a stance it already
+ * reached, and supplies counts that are themselves dated facts. Anything else would make the
+ * same symbol answer differently depending on what was published that morning, which is the
+ * property this whole runtime exists to avoid.
+ */
+
+import { applyRecencyGate, fetchFeed, filingsFeed, queryNewsFeed, tickerNewsFeed } from "./feeds.mjs";
+import { sicGroupFor } from "./industry.mjs";
+import { fetchSubmissions, fetchUniverse } from "./sec.mjs";
+
+/** How many of the largest holdings are read for news. Weight decays; attention should too. */
+export const NEWS_CONSTITUENT_LIMIT = 10;
+
+/** Recency gate for a basket, in days. Wider than a single company's because a sector moves slower. */
+export const BASKET_NEWS_DAYS = 14;
+
+const finite = (value) => typeof value === "number" && Number.isFinite(value);
+
+/**
+ * The industry a basket is, derived from the registrants it holds.
+ *
+ * Weighted rather than counted: an index with forty small biotech names and two enormous
+ * semiconductor ones is a semiconductor bet, and a headcount would say otherwise.
+ */
+export function dominantIndustry(sicByTicker, holdings) {
+  return industryMix(sicByTicker, holdings)[0] || null;
+}
+
+/**
+ * The industries a basket actually is, largest first, until they account for most of it.
+ *
+ * A single label is right for SOXX, where semiconductors are half the fund, and wrong for a
+ * broad industrial basket whose largest group is eleven percent of it -- calling that one
+ * "electronics" would query the wrong news and state it with more confidence than the holdings
+ * support. Taking groups until they cover half the read weight gives an industrial fund its
+ * aerospace, machinery and transport news instead of one misleading query.
+ */
+export function industryMix(sicByTicker, holdings, { cover = 0.5, max = 3 } = {}) {
+  const weightByGroup = new Map();
+  for (const holding of holdings || []) {
+    const ticker = String(holding?.ticker || "").toUpperCase();
+    const sic = sicByTicker?.get?.(ticker);
+    const group = sic ? sicGroupFor(sic) : null;
+    if (!group || !finite(holding?.weight)) continue;
+    const current = weightByGroup.get(group.id) || { group, weight: 0, members: 0 };
+    weightByGroup.set(group.id, { group, weight: current.weight + holding.weight, members: current.members + 1 });
+  }
+  if (!weightByGroup.size) return [];
+  const ranked = [...weightByGroup.values()].sort((left, right) => right.weight - left.weight);
+  const chosen = [];
+  let cumulative = 0;
+  for (const entry of ranked) {
+    if (chosen.length >= max || (chosen.length && cumulative >= cover)) break;
+    chosen.push({
+      id: entry.group.id,
+      title: entry.group.title,
+      weight: Number(entry.weight.toFixed(6)),
+      members: entry.members,
+      // A basket whose largest industry is a third of it is not "a semiconductor fund", and
+      // the share is reported so a reader can judge rather than being told a single label.
+      is_concentrated: entry.weight >= 0.5,
+    });
+    cumulative += entry.weight;
+  }
+  return chosen;
+}
+
+/**
+ * Industry and constituent news for a basket, every item carrying its own publication date.
+ *
+ * `asOf` is honoured by the recency gate, so a historical run cannot pick up items published
+ * after the date it claims to be reasoning at.
+ */
+export async function fetchBasketNews(holdings, { asOf = null, days = BASKET_NEWS_DAYS, signal, limit = NEWS_CONSTITUENT_LIMIT } = {}) {
+  const unavailable = [];
+  const ranked = [...(holdings || [])]
+    .filter((holding) => holding?.ticker && finite(holding?.weight))
+    .sort((left, right) => right.weight - left.weight)
+    .slice(0, limit);
+  if (!ranked.length) return { available: false, unavailable: ["basket news: the basket published no weighted holdings"] };
+
+  let universe = null;
+  try {
+    universe = new Map((await fetchUniverse({ signal })).map((row) => [String(row.ticker).toUpperCase(), row.cik]));
+  } catch (error) {
+    unavailable.push(`basket news: SEC ticker universe unavailable (${String(error?.message || error)})`);
+  }
+
+  // One submissions call per constituent buys its SIC, which is what the industry is derived
+  // from and what a filings feed needs anyway.
+  const sicByTicker = new Map();
+  const cikByTicker = new Map();
+  for (const holding of ranked) {
+    const ticker = String(holding.ticker).toUpperCase();
+    const cik = universe?.get(ticker);
+    if (!cik) { unavailable.push(`basket news ${ticker}: no SEC registrant`); continue; }
+    cikByTicker.set(ticker, cik);
+    try {
+      const profile = await fetchSubmissions(cik, { signal });
+      if (profile?.sic) sicByTicker.set(ticker, profile.sic);
+    } catch (error) {
+      unavailable.push(`basket news ${ticker}: ${String(error?.message || error)}`);
+    }
+  }
+
+  const industries = industryMix(sicByTicker, ranked);
+  const industry = industries[0] || null;
+  const specs = [];
+  if (industries.length) {
+    // Each industry's own name is a query. Deriving them from holdings rather than from a map
+    // is what makes this survive a rebalance.
+    for (const group of industries) {
+      specs.push({ ...queryNewsFeed(`${group.title.en} industry`), kind: "industry", scope: "industry", industry: group.id });
+    }
+  } else {
+    unavailable.push("basket news: no holding resolved to a SIC group, so no industry could be named");
+  }
+  for (const holding of ranked) {
+    const ticker = String(holding.ticker).toUpperCase();
+    specs.push({ ...tickerNewsFeed(ticker), kind: "company", scope: "constituent", ticker, weight: holding.weight });
+    const cik = cikByTicker.get(ticker);
+    if (cik) specs.push({ ...filingsFeed(cik, "8-K"), kind: "filing", scope: "constituent", ticker, weight: holding.weight });
+  }
+
+  // Fetched per spec rather than through `fetchFeeds`, which returns a merged item list. The
+  // whole point here is that an item keeps which constituent it belongs to and how much of the
+  // basket that constituent is; a merged list has already thrown that away.
+  const fetched = await Promise.all(specs.map((spec) => fetchFeed(spec.url, { source: spec.source })));
+  const items = [];
+  fetched.forEach((feed, index) => {
+    const spec = specs[index];
+    if (!feed?.ok) { unavailable.push(`basket news ${spec.source}: ${feed?.reason || "unreachable"}`); return; }
+    for (const item of feed.items || []) {
+      items.push({ ...item, source: feed.source, kind: spec.kind, scope: spec.scope, ticker: spec.ticker || null, weight: spec.weight ?? null, industry: spec.industry || null });
+    }
+  });
+  const { included: dated } = applyRecencyGate(items, { days, asOf });
+
+  // How much of the basket actually generated dated news, and how many filed. Both are counts
+  // with a window, which is what makes them usable as facts rather than as impressions.
+  const covered = new Set(dated.filter((item) => item.ticker).map((item) => item.ticker));
+  const coverageWeight = ranked
+    .filter((holding) => covered.has(String(holding.ticker).toUpperCase()))
+    .reduce((sum, holding) => sum + holding.weight, 0);
+  const filers = new Set(dated.filter((item) => item.kind === "filing" && item.ticker).map((item) => item.ticker));
+
+  return {
+    available: dated.length > 0,
+    industry,
+    industries,
+    items: dated,
+    window_days: days,
+    constituents_read: ranked.length,
+    coverage_weight: Number(coverageWeight.toFixed(6)),
+    filing_event_count: filers.size,
+    filing_event_weight: Number(ranked
+      .filter((holding) => filers.has(String(holding.ticker).toUpperCase()))
+      .reduce((sum, holding) => sum + holding.weight, 0)
+      .toFixed(6)),
+    unavailable,
+  };
+}

package/mcp/lib/breadth.mjs

@@ -40,6 +40,30 @@ export function parseDailyCloses(json) {
   return clean.length ? clean : null;
 }
 
+/**
+ * Closes paired with the session they belong to.
+ *
+ * `parseDailyCloses` drops the timestamps, which is fine for a moving average over one series
+ * and wrong the moment two series are compared: Korea and the United States keep different
+ * holidays, so aligning by array position compares a Tuesday with a Wednesday and produces a
+ * correlation that is confidently wrong rather than visibly broken.
+ */
+export function parseDatedCloses(json) {
+  const result = json?.chart?.result?.[0];
+  const closes = result?.indicators?.quote?.[0]?.close;
+  const stamps = result?.timestamp;
+  if (!Array.isArray(closes) || !Array.isArray(stamps) || closes.length !== stamps.length) return null;
+  const rows = [];
+  for (let index = 0; index < closes.length; index += 1) {
+    const close = closes[index];
+    const stamp = stamps[index];
+    if (typeof close !== "number" || !Number.isFinite(close) || close <= 0) continue;
+    if (typeof stamp !== "number" || !Number.isFinite(stamp)) continue;
+    rows.push({ date: new Date(stamp * 1000).toISOString().slice(0, 10), close });
+  }
+  return rows.length ? rows : null;
+}
+
 /** Simple moving average of the last `window` closes, or null when there is not enough history. */
 export function movingAverage(closes, window = BREADTH_WINDOW_DAYS) {
   if (!Array.isArray(closes) || closes.length < window) return null;

package/mcp/lib/constants.mjs

@@ -183,6 +183,9 @@ export const LIMITS = Object.freeze({
   )),
   /** Deterministic grounding is useful, but it may not hold the whole run hostage. */
   FULL_GROUNDING_MS: 30 * 1000,
+  // Grounding settles at its own budget and returns a partial result. This is only the
+  // backstop for a call that never returns at all, so it sits just beyond the budget.
+  GROUNDING_SETTLE_HEADROOM_MS: 5 * 1000,
   /** All eight full evidence seats launch in one wave under this per-seat cap. */
   FULL_EVIDENCE_MS: Math.max(1_000, Math.min(
     Number(process.env.ALPHACOUNCIL_FULL_EVIDENCE_MS) || 6 * 60 * 1000,

package/mcp/lib/cross-market.mjs

@@ -0,0 +1,180 @@
+/**
+ * How a basket moves against other markets, and how its own sectors are moving apart.
+ *
+ * Every seat that reasons about crowding, reflexivity or position size needs to know what else
+ * a holding is a bet on. Dalio's own authored policy limits size by correlation; Soros needs a
+ * loop that runs between markets; Marks reads dispersion as where the cycle stands. None of
+ * them could ask, because nothing here compared one market with another.
+ *
+ * The inputs are daily closes, from the same keyless endpoint the breadth pass already uses,
+ * so a correlation costs one fetch per reference series and nothing per constituent.
+ *
+ * Two disciplines are enforced rather than assumed:
+ *
+ *   1. **Sessions are aligned by date, not by position.** Korea and the United States do not
+ *      share a holiday calendar, and zipping two arrays by index silently compares a Tuesday
+ *      with a Wednesday — which produces a correlation that is confidently wrong rather than
+ *      obviously broken.
+ *   2. **A short overlap produces nothing.** A correlation over twenty paired sessions is
+ *      noise with a decimal point on it.
+ */
+
+import { LIMITS } from "./constants.mjs";
+import { chartUrl, parseDatedCloses } from "./breadth.mjs";
+import { fetchText } from "./quotes.mjs";
+
+/** Windows the facts are published over. Both are stated on the fact, never implied. */
+export const CORRELATION_WINDOW_DAYS = 60;
+
+/** Below this many paired sessions a correlation is not reported at all. */
+export const MIN_PAIRED_SESSIONS = 40;
+
+/**
+ * Reference markets a US basket is worth being correlated against.
+ *
+ * Korea is here because it is the clearest listed read on the semiconductor and export cycle
+ * outside the United States: KOSPI's index weight is dominated by memory and display, so a
+ * semiconductor basket that has decoupled from it has decoupled from its own end demand.
+ */
+export const REFERENCE_MARKETS = Object.freeze({
+  "^GSPC": { label: "S&P 500", why: "the broad US market a US basket is measured against" },
+  "^KS11": { label: "KOSPI", why: "Korea's main board, weighted toward memory and export manufacturing" },
+  "^KQ11": { label: "KOSDAQ", why: "Korea's growth board, a read on domestic risk appetite rather than exporters" },
+  "^SOX": { label: "PHLX Semiconductor", why: "the semiconductor cycle as a listed series" },
+});
+
+/** The eleven Select Sector SPDRs, which between them partition the S&P 500. */
+export const SECTOR_SPDRS = Object.freeze(["XLK","XLF","XLE","XLV","XLI","XLY","XLP","XLU","XLB","XLRE","XLC"]);
+
+const finite = (value) => typeof value === "number" && Number.isFinite(value);
+
+/** Pearson correlation of two equal-length return series. */
+export function correlation(left, right) {
+  if (!Array.isArray(left) || left.length !== right?.length || left.length < 2) return null;
+  const n = left.length;
+  const meanLeft = left.reduce((sum, value) => sum + value, 0) / n;
+  const meanRight = right.reduce((sum, value) => sum + value, 0) / n;
+  let covariance = 0;
+  let varianceLeft = 0;
+  let varianceRight = 0;
+  for (let index = 0; index < n; index += 1) {
+    const dl = left[index] - meanLeft;
+    const dr = right[index] - meanRight;
+    covariance += dl * dr;
+    varianceLeft += dl * dl;
+    varianceRight += dr * dr;
+  }
+  if (varianceLeft <= 0 || varianceRight <= 0) return null;
+  return covariance / Math.sqrt(varianceLeft * varianceRight);
+}
+
+/**
+ * Daily returns for the sessions two series actually share.
+ *
+ * Aligning on the date is the whole point. Two markets with different holidays produce arrays
+ * of different lengths whose positions do not correspond, and comparing them by position is
+ * the standard way a cross-market correlation ends up measuring nothing.
+ */
+export function alignedReturns(left, right, windowDays = CORRELATION_WINDOW_DAYS) {
+  const rightByDate = new Map((right || []).map((row) => [row.date, row.close]));
+  const paired = [];
+  for (const row of left || []) {
+    const other = rightByDate.get(row.date);
+    if (finite(row.close) && finite(other)) paired.push({ date: row.date, left: row.close, right: other });
+  }
+  const window = paired.slice(-(windowDays + 1));
+  if (window.length < MIN_PAIRED_SESSIONS) return null;
+  const returns = { left: [], right: [], sessions: window.length - 1, from: window[0].date, to: window.at(-1).date };
+  for (let index = 1; index < window.length; index += 1) {
+    returns.left.push(window[index].left / window[index - 1].left - 1);
+    returns.right.push(window[index].right / window[index - 1].right - 1);
+  }
+  return returns;
+}
+
+async function datedCloses(symbol, signal) {
+  try {
+    return parseDatedCloses(JSON.parse(await fetchText(chartUrl(symbol), LIMITS.QUOTE_FETCH_MS, signal)));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Correlation and relative strength of one symbol against each reference market.
+ *
+ * Relative strength travels with the correlation on purpose. A correlation of 0.9 says two
+ * markets move together and says nothing about which one is winning; a reader given only the
+ * first will supply the second from imagination.
+ */
+export async function fetchCrossMarket(symbol, { signal, references = REFERENCE_MARKETS } = {}) {
+  const facts = [];
+  const unavailable = [];
+  const subject = await datedCloses(symbol, signal);
+  if (!subject?.length) {
+    return { facts, unavailable: [`cross-market: no daily closes for ${symbol}`] };
+  }
+  for (const [reference, meta] of Object.entries(references)) {
+    if (String(reference).toUpperCase() === String(symbol).toUpperCase()) continue;
+    const other = await datedCloses(reference, signal);
+    if (!other?.length) { unavailable.push(`cross-market ${reference}: no daily closes`); continue; }
+    const returns = alignedReturns(subject, other);
+    if (!returns) {
+      unavailable.push(
+        `cross-market ${reference}: fewer than ${MIN_PAIRED_SESSIONS} sessions shared with ${symbol};`
+        + " the two calendars do not overlap enough to compare",
+      );
+      continue;
+    }
+    const rho = correlation(returns.left, returns.right);
+    if (!finite(rho)) { unavailable.push(`cross-market ${reference}: a series did not move over the window`); continue; }
+    const total = (series) => series.reduce((compound, value) => compound * (1 + value), 1) - 1;
+    facts.push({
+      reference,
+      label: meta.label,
+      why: meta.why,
+      correlation: Number(rho.toFixed(4)),
+      relative_return: Number((total(returns.left) - total(returns.right)).toFixed(6)),
+      sessions: returns.sessions,
+      from: returns.from,
+      to: returns.to,
+    });
+  }
+  return { facts, unavailable };
+}
+
+/**
+ * How far apart a set of sector baskets has travelled over the window.
+ *
+ * One number, and it is a real one: the standard deviation of sector total returns. A market
+ * whose sectors all return the same thing is being repriced by one factor; a market whose
+ * sectors have separated is being repriced by many, and those are different regimes to own.
+ */
+export async function fetchSectorDispersion(symbols, { signal } = {}) {
+  const returns = [];
+  const unavailable = [];
+  let window = null;
+  for (const symbol of symbols || []) {
+    const closes = await datedCloses(symbol, signal);
+    const tail = (closes || []).slice(-(CORRELATION_WINDOW_DAYS + 1));
+    if (tail.length < MIN_PAIRED_SESSIONS) { unavailable.push(`sector dispersion ${symbol}: too few sessions`); continue; }
+    returns.push({ symbol, value: tail.at(-1).close / tail[0].close - 1 });
+    window = { from: tail[0].date, to: tail.at(-1).date, sessions: tail.length - 1 };
+  }
+  if (returns.length < 3) {
+    return { available: false, unavailable: [...unavailable, "sector dispersion: fewer than three sectors priced"] };
+  }
+  const mean = returns.reduce((sum, row) => sum + row.value, 0) / returns.length;
+  const variance = returns.reduce((sum, row) => sum + (row.value - mean) ** 2, 0) / returns.length;
+  const sorted = [...returns].sort((left, right) => right.value - left.value);
+  return {
+    available: true,
+    dispersion: Number(Math.sqrt(variance).toFixed(6)),
+    mean_return: Number(mean.toFixed(6)),
+    leader: sorted[0],
+    laggard: sorted.at(-1),
+    measured: returns.length,
+    ...window,
+    unavailable,
+  };
+}