alphacouncil-agent 0.9.4 → 1.0.1

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

@@ -80,6 +80,15 @@ function secCompanyFactsIdentity(id) {
   };
 }
 
+/**
+ * Keep an interval only when the value genuinely covers a span. A single-ended interval is not
+ * a shorter interval -- it is an observation date wearing the wrong field.
+ */
+function pointInTimeOrInterval(periodStart, periodEnd) {
+  if (!periodStart) return { period_start: null, period_end: null };
+  return { period_start: periodStart, period_end: periodEnd };
+}
+
 function baseFact({
   factId,
   valueKind,
@@ -108,8 +117,12 @@ function baseFact({
     currency,
     scale,
     ...(ratioDenominator ? { ratio_denominator: ratioDenominator } : {}),
-    period_start: periodStart,
-    period_end: periodEnd,
+    // `period_start`/`period_end` describe the span a value COVERS, not when it was observed --
+    // that is what `as_of` and `public_at` are for. A point-in-time observation with only an end
+    // date satisfies neither contract basis: the executor rejects it as an instant because the
+    // interval is non-null, and as a duration because a window needs both ends. Facts in that
+    // shape were unusable by any tool, which is most of what kept live seats silent.
+    ...pointInTimeOrInterval(periodStart, periodEnd),
     fiscal_year: fiscalYear,
     as_of: asOf,
     public_at: publicAt,
@@ -350,6 +363,293 @@ function optionsFacts(grounding, context) {
   }
 }
 
+/**
+ * FRED observations carry their own publication date, so unlike the market snapshot they can
+ * be converted without stamping the run time onto them. That is the whole reason the macro
+ * block could not be converted before: it had readings but no lineage.
+ */
+function macroSeriesFacts(grounding, context) {
+  const macro = grounding?.macro_series;
+  if (!macro?.series) return;
+  for (const [id, series] of Object.entries(macro.series)) {
+    if (!series?.fact || !finite(series.latest)) continue;
+    const publicAt = timestampAtOrBefore(series.public_at, context.cutoff);
+    if (!publicAt) {
+      context.diagnostics.push({ code: "missing_public_at", source: `fred.${id}`, action: "not_converted" });
+      continue;
+    }
+    const sourceIdValue = sourceId("fred", id, series.observation_date);
+    if (!registerSource(context, {
+      source_id: sourceIdValue,
+      source_kind: "official_statistic",
+      title: `FRED ${id}: ${series.label}`,
+      url: series.source_url,
+      public_at: publicAt,
+      retrieved_at: grounding.gathered_at || publicAt,
+      locator: { series_id: id, observation_date: series.observation_date },
+    })) continue;
+    // Every FRED series mapped here is quoted in percent; the typed-fact contract is decimal.
+    addUnique(context.facts, context.diagnostics, baseFact({
+      factId: series.fact,
+      valueKind: "ratio",
+      value: series.latest / 100,
+      unit: "decimal",
+      ratioDenominator: "annualized_rate",
+      periodEnd: series.observation_date,
+      asOf: context.asOf,
+      publicAt,
+      sources: [sourceIdValue],
+      confidence: 0.95,
+    }));
+  }
+
+  const impulse = macro.liquidity_impulse;
+  const liquidity = macro.net_liquidity;
+  if (impulse && finite(impulse.value) && liquidity) {
+    const publicAt = timestampAtOrBefore(liquidity.public_at, context.cutoff);
+    const inputIds = (liquidity.derived_from || []).map((id) => sourceId("fred", id, macro.series?.[id]?.observation_date));
+    const registered = publicAt && (liquidity.derived_from || []).every((id) => {
+      const series = macro.series?.[id];
+      return series && registerSource(context, {
+        source_id: sourceId("fred", id, series.observation_date),
+        source_kind: "official_statistic",
+        title: `FRED ${id}: ${series.label}`,
+        url: series.source_url,
+        public_at: series.public_at,
+        retrieved_at: grounding.gathered_at || series.public_at,
+        locator: { series_id: id, observation_date: series.observation_date },
+      });
+    });
+    if (registered) {
+      addUnique(context.facts, context.diagnostics, baseFact({
+        factId: "macro.liquidity_impulse",
+        valueKind: "ratio",
+        value: impulse.value,
+        unit: "decimal",
+        ratioDenominator: `net_liquidity_change_over_${impulse.window_days}_days`,
+        periodStart: impulse.from_date,
+        periodEnd: impulse.to_date,
+        asOf: context.asOf,
+        publicAt,
+        sources: inputIds,
+        confidence: 0.8,
+        derivation: "rederived",
+        derivationToolId: `${ADAPTER_ID}:macro:net_liquidity_impulse`,
+        derivationInput: {
+          window_days: impulse.window_days,
+          from: { date: impulse.from_date, value: impulse.from_value },
+          to: { date: impulse.to_date, value: impulse.to_value },
+          construction: "WALCL - RRPONTSYD*1000 - WTREGEN, in usd_millions",
+        },
+      }));
+    } else {
+      context.diagnostics.push({ code: "missing_source_lineage", source: "fred.net_liquidity", action: "not_converted" });
+    }
+  }
+
+  const regime = macro.regime;
+  if (regime?.state) {
+    const slope = macro.series?.T10Y3M;
+    const breakeven = macro.series?.T5YIE;
+    const publicAt = slope && breakeven
+      ? timestampAtOrBefore([slope.public_at, breakeven.public_at].sort()[0], context.cutoff)
+      : null;
+    const sources = [slope, breakeven].filter(Boolean).map((series) => sourceId("fred", series.id, series.observation_date));
+    if (publicAt && sources.length === 2) {
+      addUnique(context.facts, context.diagnostics, baseFact({
+        factId: "macro.growth_regime",
+        valueKind: "text",
+        value: regime.state,
+        unit: null,
+        periodEnd: slope.observation_date,
+        asOf: context.asOf,
+        publicAt,
+        sources,
+        confidence: 0.7,
+        derivation: "rederived",
+        derivationToolId: `${ADAPTER_ID}:macro:growth_inflation_quadrant`,
+        derivationInput: {
+          window_days: regime.window_days,
+          growth_axis: regime.growth_axis,
+          inflation_axis: regime.inflation_axis,
+        },
+      }));
+    } else {
+      context.diagnostics.push({ code: "missing_source_lineage", source: "fred.regime", action: "not_converted" });
+    }
+  }
+}
+
+/**
+ * Company fundamentals derived from XBRL, already shaped as typed-fact candidates.
+ *
+ * `deriveFundamentals` computes the period, the filing date and the source records, so this
+ * function's only job is registration and unit passthrough. It deliberately does not repair
+ * anything: a metric that arrives null arrived null for a reason the deriver already named.
+ */
+function fundamentalFacts(grounding, context) {
+  const metrics = grounding?.fundamentals?.metrics;
+  if (!metrics || typeof metrics !== "object") return;
+  const cik = grounding.fundamentals.cik || grounding.screen?.cik;
+  const digits = String(cik || "").replace(/\D/gu, "");
+  const companyFactsUrl = digits
+    ? `https://data.sec.gov/api/xbrl/companyfacts/CIK${digits.padStart(10, "0")}.json`
+    : null;
+  for (const [factId, metric] of Object.entries(metrics)) {
+    if (!metric || !finite(metric.value)) continue;
+    const publicAt = timestampAtOrBefore(metric.public_at, context.cutoff);
+    const sources = Array.isArray(metric.source_ids) ? metric.source_ids.filter(Boolean) : [];
+    if (!publicAt || !sources.length) {
+      context.diagnostics.push({ code: "missing_source_lineage", source: `fundamentals.${factId}`, action: "not_converted" });
+      continue;
+    }
+    // Register each filing record from ITS OWN filing date, not from the date of whichever
+    // metric happens to consume it. Several metrics legitimately share one XBRL record, and
+    // stamping the consumer's period onto the shared source made the second registration
+    // collide with the first -- which silently dropped the fact rather than the duplicate.
+    // Match on the identity the id already encodes rather than rebuilding the id, so a change
+    // in CIK zero-padding cannot quietly break the lookup and reintroduce the collision.
+    const recordFor = (id) => {
+      const [, , , tag, accession, periodEnd] = String(id).split(":");
+      return (metric.source_records || []).find((record) => (
+        record?.tag === tag && record?.accession === accession && record?.period_end === periodEnd
+      ));
+    };
+    const registered = sources.every((id) => {
+      // The mechanical screen reads the same filings and may already have registered this
+      // record. First registration wins: both paths describe the same SEC document, and
+      // re-asserting it under a second consumer's period is what produced the collision that
+      // silently dropped every fundamentals fact sharing a record with the screen.
+      if (context.sourceRecords.has(id)) return true;
+      const identity = secCompanyFactsIdentity(id);
+      const record = recordFor(id);
+      const filedAt = record?.filed ? `${record.filed}T00:00:00.000Z` : publicAt;
+      return registerSource(context, {
+        source_id: id,
+        source_kind: "regulatory_filing_data",
+        title: identity.title,
+        url: companyFactsUrl,
+        public_at: filedAt,
+        retrieved_at: grounding.gathered_at || context.asOf,
+        locator: identity.locator,
+      });
+    });
+    if (!registered) continue;
+    addUnique(context.facts, context.diagnostics, baseFact({
+      factId,
+      valueKind: metric.value_kind,
+      value: metric.value,
+      unit: metric.unit,
+      currency: metric.currency ?? null,
+      scale: metric.scale ?? null,
+      ratioDenominator: metric.ratio_denominator,
+      periodStart: metric.period_start || null,
+      periodEnd: metric.period_end || null,
+      fiscalYear: Number.isInteger(metric.fiscal_year) ? metric.fiscal_year : null,
+      asOf: context.asOf,
+      publicAt,
+      sources,
+      confidence: finite(metric.confidence) ? metric.confidence : 0.85,
+      derivation: metric.derivation || "rederived",
+      derivationToolId: `${ADAPTER_ID}:fundamentals:${factId}`,
+      // The maintenance-capex split is an assumption, so it travels with the fact rather
+      // than living only in a comment nobody reads at decision time.
+      derivationInput: metric.assumptions?.length ? { assumptions: metric.assumptions } : null,
+    }));
+  }
+}
+
+/**
+ * Fund and index aggregates, including the look-through metrics that let an operating-company
+ * method run against a basket. Coverage weight is carried on every look-through fact: a
+ * portfolio number computed over 8% of the weights is not the same claim as one over 95%.
+ */
+/**
+ * Section 16 insider ownership as one typed fact.
+ *
+ * The value is `estimated` rather than `reported`: no filing states this number: it is summed
+ * 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.
+ */
+function insiderOwnershipFacts(grounding, context) {
+  const owned = grounding?.insider_ownership;
+  if (!owned || !finite(owned.value)) return;
+  const publicAt = timestampAtOrBefore(owned.public_at, context.cutoff);
+  if (!publicAt || !owned.source_url || !owned.source_ids?.length) {
+    context.diagnostics.push({ code: "missing_source_lineage", source: "insider_ownership", action: "not_converted" });
+    return;
+  }
+  const sourceIdValue = sourceId("sec", "section16_ownership", owned.as_of || publicAt);
+  if (!registerSource(context, {
+    source_id: sourceIdValue,
+    source_kind: "regulatory_filing_data",
+    title: "Section 16 ownership filings (Forms 3, 4 and 5)",
+    url: owned.source_url,
+    public_at: publicAt,
+    retrieved_at: grounding.gathered_at || publicAt,
+    locator: { filing_count: owned.source_ids.length, reporting_owners: owned.owner_count },
+  })) return;
+  addUnique(context.facts, context.diagnostics, baseFact({
+    factId: "governance.insider_ownership",
+    valueKind: "ratio",
+    value: owned.value,
+    unit: "decimal",
+    ratioDenominator: "shares_outstanding",
+    asOf: context.asOf,
+    publicAt,
+    sources: [sourceIdValue],
+    confidence: 0.7,
+    derivation: "estimated",
+    derivationToolId: `${ADAPTER_ID}:section16:insider_ownership`,
+    derivationInput: { method: owned.method, reporting_owners: owned.owner_count },
+  }));
+}
+
+function instrumentAggregateFacts(grounding, context) {
+  const aggregates = grounding?.instrument_aggregate?.facts;
+  if (!Array.isArray(aggregates)) return;
+  for (const entry of aggregates) {
+    if (!entry?.fact_id || !finite(entry.value)) continue;
+    const publicAt = timestampAtOrBefore(entry.public_at, context.cutoff);
+    if (!publicAt || !/^https?:\/\//u.test(entry.source_url || "")) {
+      context.diagnostics.push({ code: "missing_source_lineage", source: `instrument.${entry.fact_id}`, action: "not_converted" });
+      continue;
+    }
+    const sourceIdValue = sourceId(entry.source_kind || "instrument", entry.fact_id, entry.observation_date || publicAt.slice(0, 10));
+    if (!registerSource(context, {
+      source_id: sourceIdValue,
+      source_kind: entry.source_kind || "market_snapshot",
+      title: entry.title || `instrument aggregate ${entry.fact_id}`,
+      url: entry.source_url,
+      public_at: publicAt,
+      retrieved_at: grounding.gathered_at || publicAt,
+      locator: entry.locator || { fact_id: entry.fact_id },
+    })) continue;
+    addUnique(context.facts, context.diagnostics, baseFact({
+      factId: entry.fact_id,
+      valueKind: entry.value_kind || "ratio",
+      value: entry.value,
+      unit: entry.unit || "decimal",
+      // A monetary fact carries a currency and a scale; forwarding only the ratio fields
+      // rejected the whole pack the moment a basket published its size in dollars.
+      currency: entry.currency ?? null,
+      scale: entry.scale ?? null,
+      ratioDenominator: entry.ratio_denominator,
+      periodStart: entry.period_start || null,
+      periodEnd: entry.period_end || entry.observation_date || null,
+      asOf: context.asOf,
+      publicAt,
+      sources: [sourceIdValue],
+      confidence: finite(entry.confidence) ? entry.confidence : 0.75,
+      derivation: entry.derivation || "rederived",
+      derivationToolId: `${ADAPTER_ID}:instrument:${entry.fact_id}`,
+      derivationInput: entry.method
+        ? { method: entry.method, coverage_weight: entry.coverage_weight ?? null, basis: entry.basis ?? null }
+        : null,
+    }));
+  }
+}
+
 /** Return both the immutable pack and an explicit list of fields skipped for missing lineage. */
 export function adaptGroundingToTypedFacts(grounding, { asOf, knowledgeAsOf = asOf } = {}) {
   const resolvedAsOf = asOf || grounding?.as_of || grounding?.gathered_at;
@@ -365,9 +665,16 @@ export function adaptGroundingToTypedFacts(grounding, { asOf, knowledgeAsOf = as
   quoteFacts(grounding, context);
   optionsFacts(grounding, context);
   screenFacts(grounding, context);
+  macroSeriesFacts(grounding, context);
+  fundamentalFacts(grounding, context);
+  instrumentAggregateFacts(grounding, context);
+  insiderOwnershipFacts(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;
+      // The market-priced macro block still has no lineage of its own, but the dated FRED
+      // series now cover the same ground; reporting both would read as a gap that is filled.
+      if (family === "macro" && grounding.macro_series?.series) continue;
       context.diagnostics.push({ code: "missing_source_lineage", source: family, action: "not_converted" });
     }
   }

package/mcp/lib/personas-v3/production-root.mjs

@@ -1,3 +1,4 @@
+import { CANONICAL_MASTER_COUNT } from "./staging.mjs";
 import {
   existsSync,
   lstatSync,
@@ -188,11 +189,11 @@ function validateReleaseManifest(manifest, pointer) {
   }
   if (manifest.release_id !== pointer.release_id) fail("active release manifest id does not match the pointer");
   if (manifest.release_status !== "assembled_immutable") fail("active release is not immutable");
-  if (manifest.canonical_master_count !== 26
+  if (manifest.canonical_master_count !== CANONICAL_MASTER_COUNT
     || !Array.isArray(manifest.canonical_master_ids)
-    || manifest.canonical_master_ids.length !== 26
-    || new Set(manifest.canonical_master_ids).size !== 26) {
-    fail("active release manifest does not contain exactly 26 canonical seats");
+    || manifest.canonical_master_ids.length !== CANONICAL_MASTER_COUNT
+    || new Set(manifest.canonical_master_ids).size !== CANONICAL_MASTER_COUNT) {
+    fail(`active release manifest does not contain exactly ${CANONICAL_MASTER_COUNT} canonical seats`);
   }
   if (manifest.masters_directory !== "masters") fail("active release masters directory is invalid");
   if (!isObject(manifest.source_review_evidence)

package/mcp/lib/personas-v3/release-formula-evidence.mjs

@@ -1,5 +1,12 @@
-/** Self-contained, immutable release evidence for all 52 deterministic formula tools. */
+/** Self-contained, immutable release evidence for every deterministic formula tool. */
 
+import { PLANNED_TOOL_COUNT } from "../../../data/persona-v3-build-specs.v1.mjs";
+import { CANONICAL_MASTER_COUNT } from "./staging.mjs";
+
+// Two planned tools per canonical seat; the seat count is the single source of truth.
+// Evaluated lazily: this module participates in an import cycle with the staging roster, so a
+// module-level constant reads the binding before it is initialised.
+const plannedToolCount = () => PLANNED_TOOL_COUNT;
 import { existsSync, lstatSync, readFileSync, realpathSync } from "node:fs";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
 
@@ -76,7 +83,7 @@ function expectedToolMap() {
     seat.planned_dedicated_tools.map((tool) => tool.tool_id),
   ]));
   const count = [...byPersona.values()].reduce((total, ids) => total + ids.length, 0);
-  if (count !== 52) fail(`release formula inventory must contain exactly 52 planned tools, found ${count}`);
+  if (count !== plannedToolCount()) fail(`release formula inventory must contain exactly ${plannedToolCount()} planned tools, found ${count}`);
   return byPersona;
 }
 
@@ -147,8 +154,8 @@ function bindingsFromPacks({ packsRoot, trustedKeys, verifiedAt }) {
       bindings.push(verifyToolBinding({ tool, bundle, personaId, trustedKeys, now: verifiedAt }));
     }
   }
-  if (bindings.length !== 52 || new Set(bindings.map((binding) => binding.tool_id)).size !== 52) {
-    fail("release formula evidence must contain exactly 52 unique bindings");
+  if (bindings.length !== plannedToolCount() || new Set(bindings.map((binding) => binding.tool_id)).size !== plannedToolCount()) {
+    fail(`release formula evidence must contain exactly ${plannedToolCount()} unique bindings`);
   }
   return canonicalValue(bindings);
 }
@@ -169,7 +176,7 @@ function buildDocument({ packsRoot, trustedFormulaReviewerKeys, verifiedAt }) {
     artifact_kind: "persona_v3_release_formula_review_evidence",
     verified_at: verifiedDate.toISOString(),
     canonical_master_count: CANONICAL_MASTER_IDS.length,
-    planned_tool_count: 52,
+    planned_tool_count: plannedToolCount(),
     trusted_formula_reviewer_keys: publicKeys,
     trusted_key_registry_hash: sha256(publicKeys),
     formula_binding_inventory_hash: sha256(bindings),
@@ -220,7 +227,7 @@ export function verifyReleaseFormulaReviewEvidence({
   const expected = [...EVIDENCE_FIELDS].sort();
   if (canonicalJson(actual) !== canonicalJson(expected)) fail("formula-review evidence bundle fields are invalid", { actual, expected });
   if (evidence.schema_version !== 1 || evidence.artifact_kind !== "persona_v3_release_formula_review_evidence") fail("formula-review evidence bundle header is invalid");
-  if (evidence.canonical_master_count !== 26 || evidence.planned_tool_count !== 52) fail("formula-review evidence coverage is not exact");
+  if (evidence.canonical_master_count !== CANONICAL_MASTER_COUNT || evidence.planned_tool_count !== plannedToolCount()) fail("formula-review evidence coverage is not exact");
   for (const field of ["trusted_key_registry_hash", "formula_binding_inventory_hash"]) {
     if (!HASH.test(evidence[field] || "")) fail(`formula-review evidence ${field} is invalid`);
   }
@@ -237,7 +244,7 @@ export function verifyReleaseFormulaReviewEvidence({
     trustedFormulaReviewerKeys: externallyTrustedSnapshot,
     verifiedAt: evidence.verified_at,
   });
-  if (canonicalJson(rebuilt) !== canonicalJson(evidence)) fail("formula-review evidence no longer matches the 52 physical tool bindings");
+  if (canonicalJson(rebuilt) !== canonicalJson(evidence)) fail("formula-review evidence no longer matches the physical tool bindings");
   return Object.freeze(rebuilt);
 }
 

package/mcp/lib/personas-v3/release-source-evidence.mjs

@@ -7,6 +7,7 @@
  * self-contained bundle is copied into the release and hash-bound by release-manifest.json.
  */
 
+import { CANONICAL_MASTER_COUNT } from "./staging.mjs";
 import {
   existsSync,
   lstatSync,
@@ -164,7 +165,7 @@ function normalizePackSources(packSourcesByPersona) {
   const actualIds = [...byPersona.keys()].sort();
   const expectedIds = [...CANONICAL_MASTER_IDS].sort();
   if (canonicalJson(actualIds) !== canonicalJson(expectedIds)) {
-    fail("source-review evidence requires source collections for exactly 26 canonical masters", {
+    fail(`source-review evidence requires source collections for exactly ${CANONICAL_MASTER_COUNT} canonical masters`, {
       actual_ids: actualIds,
       expected_ids: expectedIds,
     });

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

@@ -2,12 +2,13 @@
  * PersonaPack v3 immutable release assembly and current-pointer lifecycle.
  *
  * Release assembly is deliberately separate from the production loader root. A caller
- * supplies one complete 26-seat source tree; this module validates it, copies it into a
+ * supplies one complete source tree for the canonical roster; this module validates it, copies it into a
  * same-filesystem transaction, fsyncs it, and publishes one immutable release directory by
  * atomic rename. Cutover changes only a versioned JSON pointer. Existing releases are never
  * modified or deleted by this API.
  */
 
+import { PLANNED_TOOL_COUNT } from "../../../data/persona-v3-build-specs.v1.mjs";
 import { randomUUID } from "node:crypto";
 import {
   closeSync,
@@ -727,7 +728,7 @@ function validateReleaseManifestDocument(manifest, releaseId) {
   if (manifest.release_id !== releaseId) errors.push("release manifest.release_id does not match its directory");
   if (manifest.release_status !== "assembled_immutable") errors.push("release manifest.release_status is invalid");
   if (!Number.isFinite(Date.parse(manifest.assembled_at))) errors.push("release manifest.assembled_at is invalid");
-  if (manifest.canonical_master_count !== CANONICAL_MASTER_COUNT) errors.push("release manifest count is not 26");
+  if (manifest.canonical_master_count !== CANONICAL_MASTER_COUNT) errors.push(`release manifest count is not ${CANONICAL_MASTER_COUNT}`);
   try { validateCanonicalReleaseEntries(manifest.canonical_master_ids); } catch (error) { errors.push(error.message); }
   if (!SHA256.test(manifest.canonical_catalog_hash || "") || !SHA256.test(manifest.source_inventory_hash || "")) errors.push("release manifest inventory hashes are invalid");
   if (!isObject(manifest.source_review_evidence)) errors.push("release manifest source_review_evidence is required");
@@ -763,8 +764,8 @@ function validateReleaseManifestDocument(manifest, releaseId) {
         errors.push(`release manifest formula_review_evidence.${field} is invalid`);
       }
     }
-    if (manifest.formula_review_evidence.planned_tool_count !== 52) {
-      errors.push("release manifest formula-review evidence must bind exactly 52 tools");
+    if (manifest.formula_review_evidence.planned_tool_count !== PLANNED_TOOL_COUNT) {
+      errors.push(`release manifest formula-review evidence must bind exactly ${PLANNED_TOOL_COUNT} tools`);
     }
   }
   if (manifest.masters_directory !== PERSONA_RELEASE_RULES.masters_directory) errors.push("release manifest masters directory is invalid");

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

@@ -1,5 +1,6 @@
 /** Fail-closed, dependency-light verification for an activated PersonaPack v3 release. */
 
+import { CANONICAL_MASTER_COUNT } from "./staging.mjs";
 import {
   existsSync,
   lstatSync,
@@ -285,7 +286,7 @@ function verifySourceEvidence({ manifest, evidence, packSources, trustedReviewer
   if (evidence.schema_version !== 1 || evidence.artifact_kind !== "persona_v3_release_source_review_evidence") {
     fail("source-review evidence bundle header is invalid");
   }
-  if (evidence.canonical_master_count !== 26 || !Array.isArray(evidence.ledgers) || evidence.ledgers.length !== 26) {
+  if (evidence.canonical_master_count !== CANONICAL_MASTER_COUNT || !Array.isArray(evidence.ledgers) || evidence.ledgers.length !== CANONICAL_MASTER_COUNT) {
     fail("source-review evidence bundle does not cover 26 masters");
   }
   if (!Array.isArray(evidence.trusted_reviewer_keys)
@@ -349,13 +350,13 @@ export function verifyRuntimePersonaRelease({
   trustedFormulaReviewerKeys,
 } = {}) {
   const physicalRelease = plainDirectory(resolve(releaseDir), "active release directory");
-  if (!Array.isArray(manifest?.canonical_master_ids) || manifest.canonical_master_ids.length !== 26
-    || new Set(manifest.canonical_master_ids).size !== 26
-    || !Array.isArray(manifest.packs) || manifest.packs.length !== 26) {
+  if (!Array.isArray(manifest?.canonical_master_ids) || manifest.canonical_master_ids.length !== CANONICAL_MASTER_COUNT
+    || new Set(manifest.canonical_master_ids).size !== CANONICAL_MASTER_COUNT
+    || !Array.isArray(manifest.packs) || manifest.packs.length !== CANONICAL_MASTER_COUNT) {
     fail("active release manifest must contain 26 unique physical packs");
   }
   const packEntries = new Map(manifest.packs.map((entry) => [entry?.persona_id, entry]));
-  if (packEntries.size !== 26
+  if (packEntries.size !== CANONICAL_MASTER_COUNT
     || canonicalJson([...packEntries.keys()].sort()) !== canonicalJson([...manifest.canonical_master_ids].sort())) {
     fail("active release pack inventory does not match its canonical master ids");
   }

package/mcp/lib/personas-v3/semantic-source-adjudication.mjs

@@ -1,5 +1,6 @@
 /** Round-3, machine-only adjudication of extractor and skeptic semantic source reviews. */
 
+import { CANONICAL_MASTER_COUNT } from "./staging.mjs";
 import {
   existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync,
 } from "node:fs";
@@ -403,7 +404,7 @@ function buildIndex(entries) {
     human_reviewed_count: 0,
     method_attribution_approved_count: 0,
     production_effect: "none",
-    canonical_master_count: 26,
+    canonical_master_count: CANONICAL_MASTER_COUNT,
     seats_with_candidates: new Set(entries.map((entry) => entry.record.persona_id)).size,
     candidate_count: entries.length,
     proposition_adjudication_count: reviews.length,

package/mcp/lib/personas-v3/semantic-source-extraction.mjs

@@ -1,5 +1,6 @@
 /** Round-1, machine-labelled semantic extraction from archived source bytes. */
 
+import { CANONICAL_MASTER_COUNT } from "./staging.mjs";
 import { spawnSync } from "node:child_process";
 import {
   existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync,
@@ -277,7 +278,7 @@ function buildIndex(entries) {
     human_reviewed_count: 0,
     method_attribution_approved_count: 0,
     production_effect: "none",
-    canonical_master_count: 26,
+    canonical_master_count: CANONICAL_MASTER_COUNT,
     seats_with_candidates: new Set(entries.map((entry) => entry.record.persona_id)).size,
     candidate_count: entries.length,
     readability_counts: Object.fromEntries(["readable", "partial", "unreadable"].map((status) => [status, entries.filter((entry) => entry.artifact.readability.status === status).length])),

package/mcp/lib/personas-v3/semantic-source-skeptic-review.mjs

@@ -1,5 +1,6 @@
 /** Round-2, machine-only skeptic review of round-1 semantic source extractions. */
 
+import { CANONICAL_MASTER_COUNT } from "./staging.mjs";
 import {
   existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync,
 } from "node:fs";
@@ -366,7 +367,7 @@ function buildIndex(entries) {
     human_reviewed_count: 0,
     method_attribution_approved_count: 0,
     production_effect: "none",
-    canonical_master_count: 26,
+    canonical_master_count: CANONICAL_MASTER_COUNT,
     seats_with_candidates: new Set(entries.map((entry) => entry.record.persona_id)).size,
     candidate_count: entries.length,
     proposition_review_count: reviews.length,

package/mcp/lib/personas-v3/source-review-operations.mjs

@@ -1,5 +1,6 @@
 /** Read-only operational views for PersonaPack v3 human source review. */
 
+import { CANONICAL_MASTER_COUNT } from "./staging.mjs";
 import { canonicalValue, sha256 } from "./canonical.mjs";
 import { defaultKnowledgeDir } from "./admission.mjs";
 import { inspectSourceAcquisitions } from "./source-acquisition.mjs";
@@ -226,11 +227,11 @@ export function buildSourceReviewBatch({
       prepared_source_count: prepared.length,
       trusted_quorum_source_count: prepared.filter((item) => item.trusted_quorum.satisfied).length,
       invalid_seat_count: personas.filter((seat) => seat.errors.length).length,
-      all_26_seats_acquired: personas.length === 26 && personas.every((seat) => seat.candidate_count > 0),
+      all_seats_acquired: personas.length === CANONICAL_MASTER_COUNT && personas.every((seat) => seat.candidate_count > 0),
       all_candidates_prepared: candidates.length > 0 && prepared.length === candidates.length,
       all_prepared_sources_have_two_distinct_trusted_principals: prepared.length > 0
         && prepared.every((item) => item.trusted_quorum.satisfied),
-      all_26_seats_have_a_two_principal_quorum_source: personas.length === 26
+      all_seats_have_a_two_principal_quorum_source: personas.length === CANONICAL_MASTER_COUNT
         && personas.every((seat) => seat.candidates.some((item) => item.trusted_quorum.satisfied)),
       production_write_count: 0,
     },

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

@@ -25,7 +25,6 @@ import { canonicalJson, canonicalValue, sha256 } from "./canonical.mjs";
 import { canDefineMethodRule, validateSourceAnchor } from "./source-anchor.mjs";
 import { defaultKnowledgeDir } from "./admission.mjs";
 
-export const CANONICAL_MASTER_COUNT = 26;
 export const CANONICAL_MASTER_IDS = Object.freeze([
   "master_aschenbrenner",
   "master_buffett",
@@ -53,8 +52,12 @@ export const CANONICAL_MASTER_IDS = Object.freeze([
   "master_taleb",
   "master_natenberg",
   "master_sinclair",
+  "master_bogle",
 ]);
 
+/** Derived, never written twice: the roster above is the only place a seat is added. */
+export const CANONICAL_MASTER_COUNT = CANONICAL_MASTER_IDS.length;
+
 export const STAGING_COMPONENTS = Object.freeze([
   "sources",
   "doctrine",
@@ -316,6 +319,22 @@ function writeNew(file, content, created, existing) {
   created.push(file);
 }
 
+/**
+ * The seat index is derived from the canonical roster, not authored, so refusing to overwrite
+ * it -- which is the right rule for every other file here -- would leave a seat addition
+ * permanently unrepresentable without a manual delete.
+ */
+function writeDerived(file, content, created, existing) {
+  mkdirSync(dirname(file), { recursive: true });
+  const present = existsSync(file);
+  if (present && readFileSync(file, "utf8") === content) {
+    existing.push(file);
+    return;
+  }
+  writeFileSync(file, content, "utf8");
+  (present ? existing : created).push(file);
+}
+
 function prettyJson(value) {
   return `${JSON.stringify(value, null, 2)}\n`;
 }
@@ -329,7 +348,7 @@ export function scaffoldPersonaV3Staging({
   const blueprints = canonicalMasterBlueprints({ personaDir });
   const created = [];
   const existing = [];
-  writeNew(join(stagingRoot, INDEX_FILE), prettyJson(createStagingIndex(blueprints)), created, existing);
+  writeDerived(join(stagingRoot, INDEX_FILE), prettyJson(createStagingIndex(blueprints)), created, existing);
   writeNew(join(stagingRoot, TEMPLATE_DIR, "source-adjudication-record.template.json"), prettyJson(sourceRecordTemplate()), created, existing);
   writeNew(join(stagingRoot, TEMPLATE_DIR, "human-review-checklist.md"), reviewChecklist(), created, existing);
   for (const blueprint of blueprints) {
@@ -520,7 +539,7 @@ export function inspectPersonaV3Staging({
   else {
     const actualIndex = parseJson(indexFile, INDEX_FILE);
     const expectedIndex = createStagingIndex(blueprints);
-    if (canonicalJson(actualIndex) !== canonicalJson(expectedIndex)) globalErrors.push(`${INDEX_FILE} does not match the canonical 26-seat registry`);
+    if (canonicalJson(actualIndex) !== canonicalJson(expectedIndex)) globalErrors.push(`${INDEX_FILE} does not match the canonical seat registry`);
   }
 
   const expectedIds = new Set(CANONICAL_MASTER_IDS);