alphacouncil-agent 1.0.3 → 1.0.13

package/knowledge/solo-test/masters/master_simons/manifest.json

@@ -80,10 +80,10 @@
   "identity": {
     "maturity": "operator_lens",
     "operator_label": {
-      "en": "Simons Lens Provisional Operator Lens",
-      "ja": "Simons Lens 暫定オペレーター・レンズ",
-      "ko": "Simons Lens 임시 오퍼레이터 렌즈",
-      "zh": "西蒙斯视角临时操作视角"
+      "en": "Simons Lens",
+      "ja": "Simons Lens・メソッドレンズ",
+      "ko": "Simons Lens 방법론 렌즈",
+      "zh": "西蒙斯视角"
     },
     "persona_id": "master_simons",
     "public_label": {
@@ -123,10 +123,10 @@
       "zh": "系统化信号、统计套利、组合研究与执行成本。"
     },
     "identity": {
-      "en": "Simons Lens; project-derived and not human reviewed",
-      "ja": "Simons Lens。プロジェクト派生で、方法帰属について人による審査を受けていない暫定オペレーター・レンズ。本人の発言や現在の見解ではない。",
-      "ko": "Simons Lens. 프로젝트에서 파생되었고 방법 귀속에 대한 인적 심사를 거치지 않은 임시 오퍼레이터 렌즈다. 본인의 발언이나 현재 견해가 아니다.",
-      "zh": "西蒙斯视角；项目派生、未经人工审定"
+      "en": "Simons Lens; a method model, not the person's own words",
+      "ja": "Simons Lens。メソッドモデルであり、本人の発言や現在の見解ではない。",
+      "ko": "Simons Lens. 방법론 모델이며, 본인의 발언이나 현재 견해가 아니다.",
+      "zh": "西蒙斯视角；方法模型，非本人言论"
     },
     "method": {
       "en": "Admit only statistically testable signals that survive leakage controls, multiple testing, out-of-sample evaluation, turnover and trading costs.",

package/knowledge/solo-test/masters/master_sinclair/manifest.json

@@ -78,10 +78,10 @@
   "identity": {
     "maturity": "operator_lens",
     "operator_label": {
-      "en": "Sinclair Lens (Volatility Trading and Execution) Provisional Operator Lens",
-      "ja": "Sinclair Lens (Volatility Trading and Execution) 暫定オペレーター・レンズ",
-      "ko": "Sinclair Lens (Volatility Trading and Execution) 임시 오퍼레이터 렌즈",
-      "zh": "辛克莱视角（波动率交易与执行）临时操作视角"
+      "en": "Sinclair Lens (Volatility Trading and Execution)",
+      "ja": "Sinclair Lens (Volatility Trading and Execution)・メソッドレンズ",
+      "ko": "Sinclair Lens (Volatility Trading and Execution) 방법론 렌즈",
+      "zh": "辛克莱视角（波动率交易与执行）"
     },
     "persona_id": "master_sinclair",
     "public_label": {
@@ -121,10 +121,10 @@
       "zh": "波动率预测、期权执行、优势度量与仓位管理。"
     },
     "identity": {
-      "en": "Sinclair Lens (Volatility Trading and Execution); project-derived and not human reviewed",
-      "ja": "Sinclair Lens (Volatility Trading and Execution)。プロジェクト派生で、方法帰属について人による審査を受けていない暫定オペレーター・レンズ。本人の発言や現在の見解ではない。",
-      "ko": "Sinclair Lens (Volatility Trading and Execution). 프로젝트에서 파생되었고 방법 귀속에 대한 인적 심사를 거치지 않은 임시 오퍼레이터 렌즈다. 본인의 발언이나 현재 견해가 아니다.",
-      "zh": "辛克莱视角（波动率交易与执行）；项目派生、未经人工审定"
+      "en": "Sinclair Lens (Volatility Trading and Execution); a method model, not the person's own words",
+      "ja": "Sinclair Lens (Volatility Trading and Execution)。メソッドモデルであり、本人の発言や現在の見解ではない。",
+      "ko": "Sinclair Lens (Volatility Trading and Execution). 방법론 모델이며, 본인의 발언이나 현재 견해가 아니다.",
+      "zh": "辛克莱视角（波动率交易与执行）；方法模型，非本人言论"
     },
     "method": {
       "en": "Forecast realized volatility, compare it with implied volatility, subtract spreads and slippage, and size only a robust executable edge.",

package/knowledge/solo-test/masters/master_soros/manifest.json

@@ -79,10 +79,10 @@
   "identity": {
     "maturity": "operator_lens",
     "operator_label": {
-      "en": "Soros Lens Provisional Operator Lens",
-      "ja": "Soros Lens 暫定オペレーター・レンズ",
-      "ko": "Soros Lens 임시 오퍼레이터 렌즈",
-      "zh": "索罗斯视角临时操作视角"
+      "en": "Soros Lens",
+      "ja": "Soros Lens・メソッドレンズ",
+      "ko": "Soros Lens 방법론 렌즈",
+      "zh": "索罗斯视角"
     },
     "persona_id": "master_soros",
     "public_label": {
@@ -122,10 +122,10 @@
       "zh": "全球宏观、反身性、繁荣萧条循环与拥挤交易。"
     },
     "identity": {
-      "en": "Soros Lens; project-derived and not human reviewed",
-      "ja": "Soros Lens。プロジェクト派生で、方法帰属について人による審査を受けていない暫定オペレーター・レンズ。本人の発言や現在の見解ではない。",
-      "ko": "Soros Lens. 프로젝트에서 파생되었고 방법 귀속에 대한 인적 심사를 거치지 않은 임시 오퍼레이터 렌즈다. 본인의 발언이나 현재 견해가 아니다.",
-      "zh": "索罗斯视角；项目派生、未经人工审定"
+      "en": "Soros Lens; a method model, not the person's own words",
+      "ja": "Soros Lens。メソッドモデルであり、本人の発言や現在の見解ではない。",
+      "ko": "Soros Lens. 방법론 모델이며, 본인의 발언이나 현재 견해가 아니다.",
+      "zh": "索罗斯视角；方法模型，非本人言论"
     },
     "method": {
       "en": "Map reflexive feedback among price, financing, fundamentals, policy and participant beliefs, then identify the observable break condition.",

package/knowledge/solo-test/masters/master_taleb/manifest.json

@@ -82,10 +82,10 @@
   "identity": {
     "maturity": "operator_lens",
     "operator_label": {
-      "en": "Taleb Lens (Convexity and Tails) Provisional Operator Lens",
-      "ja": "Taleb Lens (Convexity and Tails) 暫定オペレーター・レンズ",
-      "ko": "Taleb Lens (Convexity and Tails) 임시 오퍼레이터 렌즈",
-      "zh": "塔勒布视角（凸性与尾部）临时操作视角"
+      "en": "Taleb Lens (Convexity and Tails)",
+      "ja": "Taleb Lens (Convexity and Tails)・メソッドレンズ",
+      "ko": "Taleb Lens (Convexity and Tails) 방법론 렌즈",
+      "zh": "塔勒布视角（凸性与尾部）"
     },
     "persona_id": "master_taleb",
     "public_label": {
@@ -125,10 +125,10 @@
       "zh": "尾部风险、凸性、期权与脆弱性分析。"
     },
     "identity": {
-      "en": "Taleb Lens (Convexity and Tails); project-derived and not human reviewed",
-      "ja": "Taleb Lens (Convexity and Tails)。プロジェクト派生で、方法帰属について人による審査を受けていない暫定オペレーター・レンズ。本人の発言や現在の見解ではない。",
-      "ko": "Taleb Lens (Convexity and Tails). 프로젝트에서 파생되었고 방법 귀속에 대한 인적 심사를 거치지 않은 임시 오퍼레이터 렌즈다. 본인의 발언이나 현재 견해가 아니다.",
-      "zh": "塔勒布视角（凸性与尾部）；项目派生、未经人工审定"
+      "en": "Taleb Lens (Convexity and Tails); a method model, not the person's own words",
+      "ja": "Taleb Lens (Convexity and Tails)。メソッドモデルであり、本人の発言や現在の見解ではない。",
+      "ko": "Taleb Lens (Convexity and Tails). 방법론 모델이며, 본인의 발언이나 현재 견해가 아니다.",
+      "zh": "塔勒布视角（凸性与尾部）；方法模型，非本人言论"
     },
     "method": {
       "en": "Reject ruin and hidden concavity first, then evaluate whether a payoff is robust or positively convex after liquidity, tail pricing and execution friction.",

package/knowledge/solo-test/masters/master_thorp/manifest.json

@@ -82,10 +82,10 @@
   "identity": {
     "maturity": "operator_lens",
     "operator_label": {
-      "en": "Thorp Lens Provisional Operator Lens",
-      "ja": "Thorp Lens 暫定オペレーター・レンズ",
-      "ko": "Thorp Lens 임시 오퍼레이터 렌즈",
-      "zh": "索普视角临时操作视角"
+      "en": "Thorp Lens",
+      "ja": "Thorp Lens・メソッドレンズ",
+      "ko": "Thorp Lens 방법론 렌즈",
+      "zh": "索普视角"
     },
     "persona_id": "master_thorp",
     "public_label": {
@@ -125,10 +125,10 @@
       "zh": "概率优势、仓位管理、套利与破产风险。"
     },
     "identity": {
-      "en": "Thorp Lens; project-derived and not human reviewed",
-      "ja": "Thorp Lens。プロジェクト派生で、方法帰属について人による審査を受けていない暫定オペレーター・レンズ。本人の発言や現在の見解ではない。",
-      "ko": "Thorp Lens. 프로젝트에서 파생되었고 방법 귀속에 대한 인적 심사를 거치지 않은 임시 오퍼레이터 렌즈다. 본인의 발언이나 현재 견해가 아니다.",
-      "zh": "索普视角；项目派生、未经人工审定"
+      "en": "Thorp Lens; a method model, not the person's own words",
+      "ja": "Thorp Lens。メソッドモデルであり、本人の発言や現在の見解ではない。",
+      "ko": "Thorp Lens. 방법론 모델이며, 본인의 발언이나 현재 견해가 아니다.",
+      "zh": "索普视角；方法模型，非本人言论"
     },
     "method": {
       "en": "Independently estimate edge and odds, then constrain Kelly-style sizing by estimation error, dependence, liquidity and risk of ruin.",

package/mcp/lib/constants.mjs

@@ -174,12 +174,27 @@ export const LIMITS = Object.freeze({
   SIGKILL_GRACE_MS: 5000,
   /** Default per-subagent Codex timeout. */
   CODEX_TIMEOUT_MS: Number(process.env.ALPHACOUNCIL_AGENT_TIMEOUT_MS) || 600000,
-  /** Non-overridable public ceiling for a plugin-managed full council. */
-  FULL_HARD_MAX_MS: 30 * 60 * 1000,
-  /** Default full-council queue-to-persistence budget. Operators may only lower it. */
+  /**
+   * Non-overridable public ceiling for a plugin-managed full council: the slowest pace's
+   * budget. The ceiling a given call is actually held to is its pace's `total_ms`, which is
+   * lower for `fast` and `normal`; this is only the outer bound of the schema.
+   */
+  FULL_HARD_MAX_MS: 60 * 60 * 1000,
+  /**
+   * An operator cap on the full-council budget, or null when unset.
+   *
+   * This used to double as the default budget with a hard 30-minute clamp, which silently held
+   * the 60-minute pace to 30. The default now comes from the selected pace; this only ever
+   * lowers it, which is what "operators may only lower it" was always meant to say.
+   */
+  FULL_TOTAL_OVERRIDE_MS: Number.isFinite(Number(process.env.ALPHACOUNCIL_FULL_TOTAL_MS))
+    && Number(process.env.ALPHACOUNCIL_FULL_TOTAL_MS) > 0
+    ? Math.max(1_000, Number(process.env.ALPHACOUNCIL_FULL_TOTAL_MS))
+    : null,
+  /** Fallback budget for a code path that has no run budget to read. Not a ceiling. */
   FULL_TOTAL_MS: Math.max(1_000, Math.min(
     Number(process.env.ALPHACOUNCIL_FULL_TOTAL_MS) || 30 * 60 * 1000,
-    30 * 60 * 1000,
+    60 * 60 * 1000,
   )),
   /** Deterministic grounding is useful, but it may not hold the whole run hostage. */
   FULL_GROUNDING_MS: 30 * 1000,
@@ -268,3 +283,66 @@ export const LIMITS = Object.freeze({
   /** Age after which a leftover Codex output file is swept at startup. */
   STALE_OUTPUT_MS: 24 * 60 * 60 * 1000,
 });
+
+/**
+ * Full-council pace profiles.
+ *
+ * A total budget alone does not change how deep an analysis goes. What bounds each worker is
+ * its per-stage cap, so raising only the total leaves a 60-minute run finishing in twenty
+ * minutes with forty idle, and lowering only the total starves the later stages and terminates
+ * `incomplete` with the debate missing. Each pace therefore carries a complete, self-consistent
+ * set of caps, and `COUNCIL_PACE_STAGE_TOTAL` proves the stages fit inside the total.
+ *
+ * Bull and bear run together inside a round, so three rounds cost `3 * debate_ms`, not six.
+ *
+ * `slow` is where depth actually comes from: six minutes per side per round instead of 150
+ * seconds, and twelve minutes per evidence seat instead of six.
+ */
+export const COUNCIL_PACES = Object.freeze({
+  fast: Object.freeze({
+    pace: "fast",
+    total_ms: 15 * 60 * 1000,
+    grounding_ms: 20 * 1000,
+    evidence_ms: 210 * 1000,
+    master_ms: 60 * 1000,
+    debate_ms: 90 * 1000,
+    pm_ms: 120 * 1000,
+    finalize_reserve_ms: 45 * 1000,
+  }),
+  normal: Object.freeze({
+    pace: "normal",
+    total_ms: 30 * 60 * 1000,
+    grounding_ms: 30 * 1000,
+    evidence_ms: 6 * 60 * 1000,
+    master_ms: 2 * 60 * 1000,
+    debate_ms: 150 * 1000,
+    pm_ms: 180 * 1000,
+    finalize_reserve_ms: 45 * 1000,
+  }),
+  slow: Object.freeze({
+    pace: "slow",
+    total_ms: 60 * 60 * 1000,
+    grounding_ms: 45 * 1000,
+    evidence_ms: 12 * 60 * 1000,
+    master_ms: 4 * 60 * 1000,
+    debate_ms: 6 * 60 * 1000,
+    pm_ms: 8 * 60 * 1000,
+    finalize_reserve_ms: 60 * 1000,
+  }),
+});
+
+export const DEFAULT_COUNCIL_PACE = "normal";
+export const COUNCIL_PACE_NAMES = Object.freeze(Object.keys(COUNCIL_PACES));
+
+/** Serial worst case for one full council at a pace: grounding, evidence wave, method wave, three debate rounds, PM, persistence. */
+export const COUNCIL_PACE_STAGE_TOTAL = (profile) => profile.grounding_ms
+  + profile.evidence_ms
+  + profile.master_ms
+  + (3 * profile.debate_ms)
+  + profile.pm_ms
+  + profile.finalize_reserve_ms;
+
+/** The pace a call runs at. An unknown or absent name is the default, never an error. */
+export function councilPaceProfile(name) {
+  return COUNCIL_PACES[String(name || "").toLowerCase()] || COUNCIL_PACES[DEFAULT_COUNCIL_PACE];
+}

package/mcp/lib/council-options.mjs

@@ -100,11 +100,15 @@ export function councilOptions({ language = "English" } = {}) {
         best_for: field(v3Selection.best_for, "best_for"),
       } : selectorCard(persona, language)),
       maturity: v3?.maturity || pack?.kind || "prompt_lens",
+      // The label names what a seat IS. It used to lead with "provisional", which read as a
+      // standing warning next to all twenty-seven names in the selector and repeated a review
+      // status the assurance section already reports. The machine-verified admission level is
+      // unchanged and still published as `admission_level` below.
       maturity_label: copy({
-        en: v3?.maturity === "method_model" ? "Validated method model" : v3?.maturity === "candidate" ? "Candidate method" : "Provisional operator lens",
-        zh: v3?.maturity === "method_model" ? "已验证方法模型" : v3?.maturity === "candidate" ? "候选方法" : "临时操作视角",
-        ja: v3?.maturity === "method_model" ? "検証済みメソッドモデル" : v3?.maturity === "candidate" ? "候補メソッド" : "暫定オペレーター・レンズ",
-        ko: v3?.maturity === "method_model" ? "검증된 방법론 모델" : v3?.maturity === "candidate" ? "후보 방법론" : "임시 오퍼레이터 렌즈",
+        en: v3?.maturity === "method_model" ? "Validated method model" : v3?.maturity === "candidate" ? "Candidate method" : "Operator method lens",
+        zh: v3?.maturity === "method_model" ? "已验证方法模型" : v3?.maturity === "candidate" ? "候选方法" : "方法透镜",
+        ja: v3?.maturity === "method_model" ? "検証済みメソッドモデル" : v3?.maturity === "candidate" ? "候補メソッド" : "メソッド・レンズ",
+        ko: v3?.maturity === "method_model" ? "검증된 방법론 모델" : v3?.maturity === "candidate" ? "후보 방법론" : "방법론 렌즈",
       }),
       runtime_level: v3?.admission?.level || (pack ? "v2_operator" : "v1_prompt"),
       admission_level: v3?.admission?.level || (pack ? "operator_lens" : "prompt_lens"),

package/mcp/lib/council-selection.mjs

@@ -1,7 +1,7 @@
 import { createHash, randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
 import { join } from "node:path";
-import { COUNCIL_MODES, LIMITS, SELECTIONS_DIR } from "./constants.mjs";
+import { COUNCIL_MODES, COUNCIL_PACE_NAMES, COUNCIL_PACE_STAGE_TOTAL, DEFAULT_COUNCIL_PACE, LIMITS, SELECTIONS_DIR, councilPaceProfile } from "./constants.mjs";
 import { councilOptions } from "./council-options.mjs";
 import { invalidParams } from "./errors.mjs";
 import { readJson, writeJson } from "./fsutil.mjs";
@@ -128,6 +128,36 @@ export function catalogSnapshot(language = "English") {
   return { ...catalog, catalog_hash: digest(catalog) };
 }
 
+/**
+ * The pace menu shown at the selection gate, with what each tier costs and what it buys.
+ *
+ * `total_ms` is a hard ceiling, not a forecast, so both are published: `expected_ms` is the
+ * serial worst case if every stage uses its whole cap, which is the honest answer to "how long
+ * will this take". A reader given only the ceiling reads it as the estimate and thinks every
+ * fast run takes fifteen minutes.
+ */
+export function councilPaceMenu(mode = "full") {
+  if (councilMode(mode) === "quick") return [];
+  return COUNCIL_PACE_NAMES.map((name) => {
+    const profile = councilPaceProfile(name);
+    return {
+      pace: name,
+      is_default: name === DEFAULT_COUNCIL_PACE,
+      hard_ceiling_ms: profile.total_ms,
+      hard_ceiling_minutes: Math.round(profile.total_ms / 60000),
+      expected_ms: COUNCIL_PACE_STAGE_TOTAL(profile),
+      expected_minutes: Math.round(COUNCIL_PACE_STAGE_TOTAL(profile) / 60000),
+      evidence_seconds_per_seat: Math.round(profile.evidence_ms / 1000),
+      debate_seconds_per_round: Math.round(profile.debate_ms / 1000),
+      // Same contract at every tier: this is what changes and what does not.
+      buys: {
+        en: `${Math.round(profile.evidence_ms / 60000 * 10) / 10} min per evidence seat, ${Math.round(profile.debate_ms / 1000)}s per debate round per side`,
+        zh: `每个证据席 ${Math.round(profile.evidence_ms / 60000 * 10) / 10} 分钟，每轮辩论每侧 ${Math.round(profile.debate_ms / 1000)} 秒`,
+      },
+    };
+  });
+}
+
 export function beginCouncilSelection(args = {}, { now = Date.now() } = {}) {
   ensureStore();
   // Bound expiry cleanup to selections/ and selections/receipts/. It is intentionally
@@ -160,6 +190,10 @@ export function beginCouncilSelection(args = {}, { now = Date.now() } = {}) {
     selected_master_ids: [],
     preselected_master_ids: preselected,
     selection_mode: null,
+    // A pace named in the request is a prefill, exactly like a named master: it highlights the
+    // row and never confirms it. The confirmed value lands here at confirm time.
+    preselected_council_pace: COUNCIL_PACE_NAMES.includes(String(args.council_pace || "")) ? String(args.council_pace) : null,
+    council_pace: null,
     selection_receipt: null,
     created_at: createdAt,
     updated_at: createdAt,
@@ -183,6 +217,11 @@ export function beginCouncilSelection(args = {}, { now = Date.now() } = {}) {
     masters: catalog.masters,
     master_rosters: catalog.master_rosters,
     preselected_master_ids: preselected,
+    // Ask the pace in the same interaction as the catalog: two decisions, one question. Quick
+    // gets an empty menu because it is a smaller contract rather than a slower one.
+    pace_options: councilPaceMenu(mode),
+    default_council_pace: mode === "quick" ? null : DEFAULT_COUNCIL_PACE,
+    preselected_council_pace: record.preselected_council_pace,
     actions: mode === "quick" ? ["explicit_selection"] : ["explicit_selection", "select_all"],
   };
 }
@@ -341,6 +380,27 @@ function confirmCouncilSelectionUnlocked(args = {}, { now = Date.now() } = {}) {
       reason: "MASTER_CATALOG_NOT_ACKNOWLEDGED",
     });
   }
+  // The pace is the second decision taken at this gate. Quick has no pace to take, and an
+  // unrecognised name is rejected rather than quietly run at some other depth -- a user who
+  // asked for fifteen minutes must not silently get an hour, or the reverse.
+  const quickSelection = (record.council_mode || "full") === "quick";
+  if (args.council_pace !== undefined && args.council_pace !== null) {
+    if (quickSelection) {
+      throw invalidParams("council_pace applies to the full council only. Quick is a smaller contract, not a slower one.", {
+        reason: "QUICK_PACE_FORBIDDEN",
+      });
+    }
+    if (!COUNCIL_PACE_NAMES.includes(String(args.council_pace))) {
+      throw invalidParams(`council_pace must be one of ${COUNCIL_PACE_NAMES.join(", ")}.`, {
+        reason: "INVALID_COUNCIL_PACE",
+        allowed: COUNCIL_PACE_NAMES,
+        pace_options: councilPaceMenu(record.council_mode),
+      });
+    }
+  }
+  const chosenPace = quickSelection
+    ? null
+    : String(args.council_pace || record.preselected_council_pace || DEFAULT_COUNCIL_PACE);
   const resolved = resolveConfirmation(args, record);
   if (record.council_mode === "quick" && resolved.ids.length > QUICK_MASTER_MAX) {
     throw invalidParams(`Quick council accepts at most ${QUICK_MASTER_MAX} selected masters.`, {
@@ -378,6 +438,7 @@ function confirmCouncilSelectionUnlocked(args = {}, { now = Date.now() } = {}) {
     selection_receipt: receipt,
     confirmed_at: confirmedAt,
     updated_at: confirmedAt,
+    council_pace: chosenPace,
   });
   const receiptRecord = {
     schema_version: 1,
@@ -386,6 +447,10 @@ function confirmCouncilSelectionUnlocked(args = {}, { now = Date.now() } = {}) {
     status: "confirmed",
     symbol: record.symbol,
     council_mode: record.council_mode || "full",
+    // The pace is part of what the user approved for this run, so it travels inside the receipt
+    // and is checked at consumption like every other bound field. A caller cannot approve a
+    // 15-minute run and then execute an hour of it.
+    council_pace: chosenPace,
     catalog_hash: record.catalog_hash,
     request_hash: record.request_hash,
     intent_hash: record.intent_hash,
@@ -435,6 +500,7 @@ function confirmationResult(record) {
         .map((master) => [master.id, master.pack_hash]),
     ),
     selected_count: record.selected_master_ids.length,
+    council_pace: record.council_pace || null,
     expires_at: record.expires_at,
   };
 }
@@ -460,6 +526,7 @@ function consumeCouncilSelectionUnlocked(args = {}, { now = Date.now() } = {}) {
     ["selection_receipt", receipt.selection_receipt, selection.selection_receipt],
     ["symbol", receipt.symbol, selection.symbol],
     ["council_mode", receipt.council_mode || "full", selection.council_mode || "full"],
+    ["council_pace", receipt.council_pace || null, selection.council_pace || null],
     ["catalog_hash", receipt.catalog_hash, selection.catalog_hash],
     ["request_hash", receipt.request_hash, selection.request_hash],
     ["intent_hash", receipt.intent_hash, selection.intent_hash],
@@ -532,8 +599,16 @@ function consumeCouncilSelectionUnlocked(args = {}, { now = Date.now() } = {}) {
   }
   const intentHash = digest({ symbol, language, prompt, council_mode: mode });
   if (receipt.intent_hash !== intentHash || selection.intent_hash !== intentHash) {
+    // Say which field moved. The receipt binds symbol, language, prompt and mode verbatim, so a
+    // single reworded character invalidates it -- and without this the caller cannot tell a
+    // retyped prompt from a wrong symbol, and retries the same broken call.
     throw invalidParams("The selection receipt belongs to a different prompt or language intent.", {
       reason: "MASTER_SELECTION_INTENT_MISMATCH",
+      expected_intent_hash: receipt.intent_hash || selection.intent_hash || null,
+      submitted_intent_hash: intentHash,
+      bound_fields: ["symbol", "language", "prompt", "council_mode"],
+      submitted: { symbol, language, council_mode: mode, prompt_length: prompt.length },
+      remedy: "Re-send the exact symbol, prompt, language and council_mode used in begin_council_selection, or start a new selection.",
     });
   }
   if (expired(receipt, now) || expired(selection, now)) {
@@ -593,6 +668,9 @@ function consumedResult(selection, receipt) {
     intent_hash: selection.intent_hash,
     selection_mode: selection.selection_mode,
     council_mode: selection.council_mode || "full",
+    // The pace approved at the gate must survive consumption, or the run silently falls back to
+    // the default and the approved tier is lost with nothing in the record showing the switch.
+    council_pace: selection.council_pace || null,
     selected_master_ids: [...selection.selected_master_ids],
     selected_master_pack_hashes: { ...(receipt.selected_master_pack_hashes || {}) },
     selected_count: selection.selected_master_ids.length,

package/mcp/lib/fundamentals.mjs

@@ -182,17 +182,40 @@ function ownerEarnings(series, cik, gaps, proxy) {
   });
 }
 
+/**
+ * Total liabilities, tagged where the filer tags it and reconstructed exactly where not.
+ *
+ * Many filers never tag `Liabilities`; they tag the balance-sheet total and equity. The
+ * subtraction is only safe against the INCLUDING-non-controlling-interests equity tag -- with
+ * the parent-only tag, minority interest lands inside "liabilities" and nothing says so. When
+ * that tag is absent the figure stays missing, which is why this returns null rather than
+ * reaching for the nearest number.
+ */
+function totalLiabilitiesFor(series, gaps, factId) {
+  const direct = alignLatest(series, ["current_assets", "total_liabilities"]);
+  if (direct.ok) {
+    return { alignment: direct, value: direct.entries.total_liabilities.value, basis: "filed_total_liabilities" };
+  }
+  const derived = alignLatest(series, ["current_assets", "liabilities_and_equity", "equity_including_nci"]);
+  if (!derived.ok) {
+    gaps.push(alignmentGap(factId, direct, ["current_assets", "total_liabilities"]));
+    return null;
+  }
+  return {
+    alignment: derived,
+    value: derived.entries.liabilities_and_equity.value - derived.entries.equity_including_nci.value,
+    basis: "balance_sheet_total_less_equity_including_noncontrolling_interests",
+  };
+}
+
 /** 2. Graham NCAV: current assets - total liabilities. */
 function netCurrentAssetValue(series, cik, gaps) {
   const factId = "financial.net_current_asset_value";
-  const concepts = ["current_assets", "total_liabilities"];
-  const alignment = alignLatest(series, concepts);
-  if (!alignment.ok) {
-    gaps.push(alignmentGap(factId, alignment, concepts));
-    return null;
-  }
+  const resolved = totalLiabilitiesFor(series, gaps, factId);
+  if (!resolved) return null;
+  const alignment = resolved.alignment;
   const currentAssets = alignment.entries.current_assets.value;
-  const liabilities = alignment.entries.total_liabilities.value;
+  const liabilities = resolved.value;
   return buildMetric({
     factId,
     valueKind: "monetary",
@@ -207,6 +230,9 @@ function netCurrentAssetValue(series, cik, gaps) {
     assumptions: [
       "Graham NCAV as filed: current assets less ALL liabilities, with no haircut applied to receivables or inventory",
       "an unclassified balance sheet (banks, insurers, many REITs) files no AssetsCurrent, which is reported as a gap rather than substituted",
+      resolved.basis === "filed_total_liabilities"
+        ? "total liabilities taken from the filer's own Liabilities tag"
+        : "the filer tags no Liabilities total, so it is the balance-sheet total less equity INCLUDING non-controlling interests, which is exact rather than approximate",
     ],
   });
 }
@@ -465,10 +491,24 @@ function trailingYearOverYear(companyFacts, asOf) {
       },
     };
   }
-  const latest = fourQuarters(quarters, quarters.length - 1);
-  const prior = fourQuarters(quarters, quarters.length - 5);
+  // Search backwards for the most recent pair of clean four-quarter blocks rather than
+  // insisting the last eight filings are them. One restated quarter, one stub period or one
+  // duplicated filing at the end used to discard a company's entire revenue history -- INTC and
+  // GLW both failed here while holding years of usable quarters behind the ragged edge. Each
+  // window is still checked exactly as strictly; only the search moved.
+  let latest = null;
+  let prior = null;
+  let offset = 0;
+  for (; offset <= quarters.length - 8; offset += 1) {
+    const end = quarters.length - 1 - offset;
+    latest = fourQuarters(quarters, end);
+    prior = fourQuarters(quarters, end - 4);
+    if (latest && prior) break;
+    latest = null;
+    prior = null;
+  }
   if (!latest || !prior) {
-    return { ...empty, gap: { code: "period_misaligned", detail: "the eight most recent quarters are not contiguous four-quarter blocks" } };
+    return { ...empty, gap: { code: "period_misaligned", detail: `no contiguous pair of four-quarter blocks in the ${quarters.length} tagged quarters` } };
   }
   if (!(prior.total > 0)) {
     return { ...empty, gap: { code: "non_positive_base", detail: `prior-year four-quarter revenue is ${prior.total}` } };

package/mcp/lib/gates.mjs

@@ -260,6 +260,48 @@ function readerLanguageAudit(assigned, language) {
   };
 }
 
+/**
+ * Which contract sections an author still owes, checked against a submitted report body.
+ *
+ * `validateFinalReport` runs against the assembled report, after the system has appended the
+ * price snapshot, the master bench and any instrument-structure block, so it can only answer
+ * once the report already exists. A PM that submits no report body at all cannot be told so
+ * until then: on a real run the first submission carried no `report_markdown`, the report was
+ * assembled from the summary fallback, and the gate came back with 21 missing sections after
+ * the whole PM turn had been spent. This answers the same question at submission time, and
+ * deliberately ignores the sections the system owns.
+ */
+const SYSTEM_OWNED_REPORT_SECTIONS = new Set(["master_bench", "instrument_structure"]);
+
+export function authoredReportSectionGaps(markdown, run) {
+  const gaps = validateFinalReport(markdown, run).missing
+    .filter((entry) => /^(missing|placeholder) section: |^section too thin: /.test(entry));
+  return gaps.filter((entry) => ![...SYSTEM_OWNED_REPORT_SECTIONS]
+    .some((id) => entry.includes(`section: ${id}`) || entry.includes(`section: ${id} (`)));
+}
+
+/** The heading a report must carry for each contract section, in the run's language. */
+export function requiredReportSectionAliases(run) {
+  const quick = run?.council_mode === "quick";
+  const sections = quick ? QUICK_REPORT_SECTIONS : REPORT_SECTIONS;
+  const benchRan = ((run?.masters || []).length > 0) || ((run?.master_opinions || []).length > 0);
+  const fundOrIndex = isFundOrIndex(run?.grounding?.instrument);
+  const key = languageKey(run?.language);
+  const index = { zh: 0, en: 1, ja: 2, ko: 3 }[key] ?? 1;
+  return sections
+    .filter((section) => !SYSTEM_OWNED_REPORT_SECTIONS.has(section.id))
+    .filter((section) => !section.when_masters || benchRan)
+    .filter((section) => !section.when_fund_or_index || fundOrIndex)
+    .map((section) => ({
+      id: section.id,
+      minimum_body_characters: section.min_body,
+      // The catalog lists zh, en, ja and ko variants; offer the one the run reads in, and fall
+      // back to the English alias so the message is never empty.
+      suggested_heading: section.aliases[index] || section.aliases[1] || section.aliases[0],
+      accepted_headings: section.aliases,
+    }));
+}
+
 export function validateFinalReport(markdown, run) {
   const text = String(markdown || "");
   const headings = parseHeadings(text);

package/mcp/lib/grounding.mjs

@@ -357,8 +357,25 @@ export async function gatherGrounding({
       // Only the market-level block. A company's own leverage and growth come from its filings,
       // and taking them from the index would be silently answering a different question.
       const marketFacts = (r.value.facts || []).filter((fact) => MARKET_LEVEL_FACTS.has(fact.fact_id));
-      if (marketFacts.length) out.market_valuation = { ...r.value, facts: marketFacts };
+      if (marketFacts.length) { out.market_valuation = { ...r.value, facts: marketFacts }; return; }
+      // A fetch that succeeds but yields no market-level fact used to vanish here. Downstream,
+      // Marks and Damodaran declined with `unmet: index.aggregate_earnings_yield` and the reader
+      // was never told why the yardstick was missing -- an unexplained abstention reads as a
+      // verdict. Record it as the data gap it is.
+      out.unavailable.push(
+        `market valuation for ${BROAD_MARKET_INDEX}: fetched, but none of ${[...MARKET_LEVEL_FACTS].join(", ")} was derivable`
+        + " (seats that measure a company against the market will decline for lack of grounding, not for lack of a view)",
+      );
     }));
+  } else if (symbol && !isFundOrIndex(out.instrument) && symbolMarket?.id === "US") {
+    // Every other block on this path names the cutoff it could not serve; this one used to
+    // skip in silence, so a historical run lost the yardstick with nothing said about it and
+    // Marks and Damodaran again declined for a reason the reader could not see.
+    out.unavailable.push(
+      `market valuation for ${BROAD_MARKET_INDEX}: the index aggregate is published only as a current snapshot`
+      + " with no point-in-time archive, so it was not fetched for a historical cutoff"
+      + " (seats that measure a company against the market will decline for lack of grounding, not for lack of a view)",
+    );
   }
 
   // A fund or index has no issuer financials, so this is where its evidence comes from
@@ -389,6 +406,15 @@ export async function gatherGrounding({
       if (news.value.available) out.basket_news = news.value;
       out.unavailable.push(...(news.value.unavailable || []));
     })());
+  } else if (symbol && isFundOrIndex(out.instrument)) {
+    // The same silence as the market-valuation block above, and worse here: a basket's
+    // holdings, look-through aggregates and news are the whole of its evidence, so a
+    // historical cutoff left the seats with a price and nothing to explain the emptiness.
+    out.unavailable.push(
+      `holdings, look-through aggregates and basket news for ${symbol}: issuer holdings and index`
+      + " aggregates are published only as current snapshots with no point-in-time archive,"
+      + " so they were not fetched for a historical cutoff",
+    );
   }
 
   if (symbol && isFundOrIndex(out.instrument)) {

package/mcp/lib/industry.mjs

@@ -169,7 +169,12 @@ export function sicGroupFor(sic) {
   return matches.sort((a, b) => (a.range[1] - a.range[0]) - (b.range[1] - b.range[0]))[0];
 }
 
+// Refreshed on the same cadence as the TWSE dataset: a resident MCP process that never
+// re-reads the SEC ticker file silently loses every new listing and rename from peer
+// matching, with no gap recorded anywhere.
+const UNIVERSE_TTL_MS = 6 * 60 * 60 * 1000;
 let universeCache = null;
+let universeCachedAt = 0;
 
 /**
  * Every US filer whose SIC matches a query, with no curation involved.
@@ -186,7 +191,10 @@ export async function peersBySic({ cik, limit = 25 } = {}) {
   }
   const group = sicGroupFor(anchor.sic);
 
-  if (!universeCache) universeCache = await fetchUniverse();
+  if (!universeCache || Date.now() - universeCachedAt > UNIVERSE_TTL_MS) {
+    universeCache = await fetchUniverse();
+    universeCachedAt = Date.now();
+  }
   // Company names are the only universe-wide signal available without 10k requests.
   const words = anchor.name.toLowerCase().split(/\s+/).filter((w) => w.length > 4 && !/corp|inc|company|holdings|group|technologies/.test(w));
   const nameMatched = words.length