alphacouncil-agent 0.9.2 → 1.0.0

package/scripts/doctor.mjs

@@ -18,6 +18,8 @@ import {
 } from "../mcp/lib/personas-v3/registry.mjs";
 import { scanPersonaCorpusGaps } from "./report-persona-corpus-gaps.mjs";
 import { auditHostAdapterFreshness, validateHostCapabilities } from "./lib/host-capabilities.mjs";
+import { CANONICAL_MASTER_COUNT } from "../mcp/lib/personas-v3/staging.mjs";
+import { PLANNED_TOOL_COUNT } from "../data/persona-v3-build-specs.v1.mjs";
 
 const ROOT = fileURLToPath(new URL("..", import.meta.url));
 const problems = [];
@@ -95,20 +97,20 @@ try {
     const registry = loadCompiledPersonaPacks({ buildProfile });
     const operatorCount = registry.packs.filter((pack) => pack.admission.level === "operator_lens").length;
     const toolCount = registry.packs.reduce((sum, pack) => sum + pack.components.tools.length, 0);
-    const validSoloCut = registry.packs.length === 26
-      && operatorCount === 26
-      && toolCount === 52
+    const validSoloCut = registry.packs.length === CANONICAL_MASTER_COUNT
+      && operatorCount === CANONICAL_MASTER_COUNT
+      && toolCount === PLANNED_TOOL_COUNT
       && registry.packs.every((pack) => pack.build_profile === "solo_test");
     if (validSoloCut) {
-      ok("solo-test runtime", "26 physical provisional operator_lens; 52 derived-proxy tools; 0 method_model");
+      ok("solo-test runtime", `${CANONICAL_MASTER_COUNT} physical provisional operator_lens; ${PLANNED_TOOL_COUNT} derived-proxy tools; 0 method_model`);
       notes.push("Formal PersonaPack v3 production GA is not passed; human source/formula review, signed experiments, and live four-host E2E remain absent");
     } else {
-      warn("solo-test runtime incomplete", `${registry.packs.length}/26 packs, ${operatorCount}/26 operator_lens, ${toolCount}/52 tools`);
+      warn("solo-test runtime incomplete", `${registry.packs.length}/${CANONICAL_MASTER_COUNT} packs, ${operatorCount}/${CANONICAL_MASTER_COUNT} operator_lens, ${toolCount}/${PLANNED_TOOL_COUNT} tools`);
     }
-  } else if (/^0\.9\./.test(VERSION) && report.summary.operational_or_higher !== 26) {
-    warn("0.9 v3 cutover incomplete", `${report.summary.operational_or_higher}/26 seats operational or higher`);
-  } else if (report.summary.operational_or_higher !== 26) {
-    notes.push(`PersonaPack v3 migration remains in development: ${report.summary.operational_or_higher}/26 operational or higher`);
+  } else if (/^0\.9\./.test(VERSION) && report.summary.operational_or_higher !== CANONICAL_MASTER_COUNT) {
+    warn("0.9 v3 cutover incomplete", `${report.summary.operational_or_higher}/${CANONICAL_MASTER_COUNT} seats operational or higher`);
+  } else if (report.summary.operational_or_higher !== CANONICAL_MASTER_COUNT) {
+    notes.push(`PersonaPack v3 migration remains in development: ${report.summary.operational_or_higher}/${CANONICAL_MASTER_COUNT} operational or higher`);
   }
 } catch (error) {
   warn("PersonaPack v3 corpus inventory failed", error.message.split("\n")[0]);

package/scripts/export-persona-source-review-batch.mjs

@@ -82,7 +82,7 @@ function helpText() {
     "  node scripts/export-persona-source-review-batch.mjs --output FILE --write [--trusted-reviewer-keys FILE] [--json]",
     "",
     "Default/check mode is read-only. --write creates one new audit batch and never overwrites it.",
-    "The batch includes all 26 seats, raw acquisition bindings, human-only proposal templates, hashes, locator gaps, and strict trusted-principal quorum progress.",
+    "The batch includes every canonical seat, raw acquisition bindings, human-only proposal templates, hashes, locator gaps, and strict trusted-principal quorum progress.",
     "It never prepares, reviews, approves, promotes, or writes production knowledge.",
     "",
   ].join("\n");

package/scripts/generate-persona-v3-drafts.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-/** Generate or verify all 26 non-production PersonaPack v3 editorial draft slices. */
+/** Generate or verify every non-production PersonaPack v3 editorial draft slices. */
 
 import { fileURLToPath } from "node:url";
 import { resolve } from "node:path";
@@ -55,7 +55,7 @@ export function main(argv = process.argv.slice(2)) {
       "Usage: node scripts/generate-persona-v3-drafts.mjs [--check|--write] [--json|--markdown]",
       "",
       "  --check            verify only (default; never writes)",
-      "  --write            deterministically write all 26 editorial draft slices, then verify",
+      "  --write            deterministically write every editorial draft slice, then verify",
       "  --json             emit the machine-readable inventory",
       "  --markdown         emit the full Markdown inventory report",
       "  --root PATH        override the staging root",

package/scripts/lib/build-profile.mjs

@@ -0,0 +1,24 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+export function loadBuildProfile(repoRoot) {
+  const file = resolve(repoRoot, "data/build-profile.v1.json");
+  const profile = JSON.parse(readFileSync(file, "utf8"));
+  if (profile?.schema_version !== 1) throw new Error(`unsupported build profile at ${file}`);
+  return Object.freeze(profile);
+}
+
+/**
+ * Runtime releases and PersonaPack revisions are independent version axes.
+ *
+ * Falling back to package_version keeps older packaged trees readable, while current trees
+ * pin persona_pack_version so a routing-only release cannot invalidate pack review evidence.
+ */
+export function resolvePersonaPackVersion(repoRoot) {
+  const profile = loadBuildProfile(repoRoot);
+  const version = profile.persona_pack_version || profile.package_version;
+  if (typeof version !== "string" || !version.trim()) {
+    throw new Error("build profile must declare persona_pack_version or package_version");
+  }
+  return version;
+}

package/scripts/lib/council-evaluation-protocol.mjs

@@ -1,3 +1,4 @@
+import { CANONICAL_MASTER_COUNT } from "../../mcp/lib/personas-v3/staging.mjs";
 import { readFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -122,7 +123,7 @@ function liveSnapshot() {
     reg,
     default_analyst_ids: [...DEFAULT_TASKS],
     verifier_ids: verifiers,
-    canonical_26_master_ids: masters,
+    canonical_master_ids: masters,
   };
 }
 
@@ -232,7 +233,7 @@ function validateMetrics(protocol, errors) {
 
 function expectedArm(id, live) {
   const defaultAnalysts = live.default_analyst_ids;
-  const masters = live.canonical_26_master_ids;
+  const masters = live.canonical_master_ids;
   const common = { verifier_ids: [], bounded_repair: null, human_reference: null };
   if (id === "A") return { execution_mode: "single_agent_baseline", analyst_ids: [], master_ids: [], base_arm_ids: [], master_execution_mode: "none", ...common };
   if (id === "B") return { execution_mode: "machine_council", analyst_ids: defaultAnalysts, master_ids: [], base_arm_ids: [], master_execution_mode: "none", ...common };
@@ -298,12 +299,12 @@ export function validateCouncilEvaluationProtocol(protocol = loadCouncilEvaluati
   exactValue(protocol.canonical_arm_order, CANONICAL_ARM_IDS, "canonical_arm_order", errors);
 
   const live = liveSnapshot();
-  exactFields(protocol.registry_snapshot, ["default_analyst_ids", "verifier_ids", "priority_13_master_ids", "canonical_26_master_ids"], "registry_snapshot", errors);
+  exactFields(protocol.registry_snapshot, ["default_analyst_ids", "verifier_ids", "priority_13_master_ids", "canonical_master_ids"], "registry_snapshot", errors);
   exactValue(protocol.registry_snapshot?.default_analyst_ids, live.default_analyst_ids, "registry_snapshot.default_analyst_ids vs live DEFAULT_TASKS", errors);
   exactValue(protocol.registry_snapshot?.verifier_ids, live.verifier_ids, "registry_snapshot.verifier_ids vs live verify roster", errors);
   exactValue(protocol.registry_snapshot?.priority_13_master_ids, PRIORITY_13_MASTER_IDS, "registry_snapshot.priority_13_master_ids", errors);
-  exactValue(protocol.registry_snapshot?.canonical_26_master_ids, live.canonical_26_master_ids, "registry_snapshot.canonical_26_master_ids vs live master registry", errors);
-  if (live.canonical_26_master_ids.length !== 26) errors.push(`live master registry must contain exactly 26 enabled seats, got ${live.canonical_26_master_ids.length}`);
+  exactValue(protocol.registry_snapshot?.canonical_master_ids, live.canonical_master_ids, "registry_snapshot.canonical_master_ids vs live master registry", errors);
+  if (live.canonical_master_ids.length !== CANONICAL_MASTER_COUNT) errors.push(`live master registry must contain exactly ${CANONICAL_MASTER_COUNT} enabled seats, got ${live.canonical_master_ids.length}`);
   if (live.verifier_ids.length !== 3) errors.push(`live verify roster must contain exactly 3 verifiers, got ${live.verifier_ids.length}`);
   for (const id of live.default_analyst_ids) {
     const persona = live.reg.get(id);
@@ -327,7 +328,7 @@ export function validateCouncilEvaluationProtocol(protocol = loadCouncilEvaluati
     live: {
       default_analyst_ids: live.default_analyst_ids,
       verifier_ids: live.verifier_ids,
-      canonical_26_master_ids: live.canonical_26_master_ids,
+      canonical_master_ids: live.canonical_master_ids,
     },
   };
 }

package/scripts/lib/host-capabilities.mjs

@@ -1,3 +1,4 @@
+import { CANONICAL_MASTER_COUNT } from "../../mcp/lib/personas-v3/staging.mjs";
 import { createHash } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
 import os from "node:os";
@@ -216,7 +217,7 @@ export function validateHostCapabilities(contract = loadHostCapabilities(), { ro
   }
 
   const catalog = catalogSnapshot("English");
-  if (catalog.count !== 26 || !arraysEqual(catalog.all_master_ids, registry().ids("master"))) errors.push("runtime selector catalog is not the canonical 26-seat registry order");
+  if (catalog.count !== CANONICAL_MASTER_COUNT || !arraysEqual(catalog.all_master_ids, registry().ids("master"))) errors.push(`runtime selector catalog is not the canonical ${CANONICAL_MASTER_COUNT}-seat registry order`);
   if (!/^[a-f0-9]{64}$/.test(catalog.catalog_hash)) errors.push("runtime catalog hash is not sha256 hex");
   for (const [index, seat] of catalog.masters.entries()) {
     if (seat.index !== index + 1 || seat.id !== catalog.all_master_ids[index]) errors.push(`runtime selector index/id drift at ${index + 1}`);

package/scripts/lib/packaged-host-parity.mjs

@@ -6,6 +6,7 @@
  * PersonaPack v3 decision comparison while the production package contains zero v3 packs.
  */
 
+import { CANONICAL_MASTER_COUNT } from "../../mcp/lib/personas-v3/staging.mjs";
 import { createHash } from "node:crypto";
 import { once } from "node:events";
 import {
@@ -29,7 +30,12 @@ import { isDeepStrictEqual } from "node:util";
 const HERE = dirname(fileURLToPath(import.meta.url));
 export const PACKAGED_PARITY_REPO_ROOT = resolve(HERE, "../..");
 export const PACKAGED_HOST_IDS = Object.freeze(["claude_code", "codex", "opencode", "grok"]);
-export const PACKAGED_SELECTION_INPUT = "2,23-24,26";
+export const PACKAGED_SELECTION_INPUT = Object.freeze([
+  "master_buffett",
+  "master_damodaran",
+  "master_taleb",
+  "master_sinclair",
+]);
 
 const TEMP_PREFIX = "alphacouncil-packaged-parity-";
 const SYMBOL = "NOK";
@@ -39,6 +45,13 @@ const PROMPT = "packaged adapter parity fixture";
 const TASKS = Object.freeze(["market_data"]);
 const REQUEST_TIMEOUT_MS = 30_000;
 const PROCESS_TIMEOUT_MS = 120_000;
+const EXPECTED_TOOL_COUNT = 31;
+const INSTALLED_LOCALE_CASES = Object.freeze([
+  Object.freeze({ language: "en-US", prompt: "installed package locale smoke", key: "en", script: /[A-Za-z]/u }),
+  Object.freeze({ language: "zh-CN", prompt: "安装包语言烟雾测试", key: "zh", script: /\p{Script=Han}/u }),
+  Object.freeze({ language: "ja-JP", prompt: "インストール済みパッケージの言語スモークテスト", key: "ja", script: /[\p{Script=Hiragana}\p{Script=Katakana}]/u }),
+  Object.freeze({ language: "ko-KR", prompt: "설치 패키지 언어 스모크 테스트", key: "ko", script: /\p{Script=Hangul}/u }),
+]);
 const REQUIRED_PACKAGE_FILES = Object.freeze([
   "mcp/server.mjs",
   "data/host-capabilities.v1.json",
@@ -310,8 +323,13 @@ function validatePackagedSurfaces(pack) {
   }
   const reviewPrefix = "knowledge/ai-assisted-solo/reviews/";
   const packagedReviews = pack.tarFiles.filter((path) => path.startsWith(reviewPrefix) && path.endsWith(".json"));
-  if (packagedReviews.length !== 185) {
-    fail(`installed AI-assisted review capsule must contain exactly 185 JSON files; got ${packagedReviews.length}`);
+  // The capsule is complete when the package carries every review the repository holds. Pinning
+  // a number instead would only restate the roster size, and would have to be edited on the
+  // day a seat is added -- which is exactly when the check should still be meaningful.
+  const repoReviews = walkFiles(resolve(PACKAGED_PARITY_REPO_ROOT, reviewPrefix))
+    .filter((entry) => entry.path.endsWith(".json"));
+  if (packagedReviews.length !== repoReviews.length) {
+    fail(`installed AI-assisted review capsule must contain every one of the ${repoReviews.length} repository review files; got ${packagedReviews.length}`);
   }
   if (pack.tarFiles.some((path) => path.startsWith("knowledge/ai-assisted-solo/host-e2e/"))) {
     fail("local external-host failure evidence must not ship in the npm package");
@@ -570,21 +588,33 @@ function errorReason(response, label) {
 }
 
 function assertCompleteCatalog(opened, text, hostId) {
-  if (opened.maximum !== 26 || opened.masters?.length !== 26) fail(`${hostId}: packaged selector is not 26 seats`);
+  if (opened.maximum !== CANONICAL_MASTER_COUNT || opened.masters?.length !== CANONICAL_MASTER_COUNT) fail(`${hostId}: packaged selector is not ${CANONICAL_MASTER_COUNT} seats`);
   const seen = new Set();
   for (const [offset, master] of opened.masters.entries()) {
     if (master.index !== offset + 1 || seen.has(master.id)) fail(`${hostId}: catalog order or IDs are invalid`);
     seen.add(master.id);
-    for (const field of ["identity", "method", "best_for", "maturity", "pack_hash"]) {
+    for (const field of ["identity", "method", "best_for", "maturity", "maturity_label", "pack_hash"]) {
       if (typeof master[field] !== "string" || !master[field]) fail(`${hostId}: catalog seat ${master.id} lacks ${field}`);
     }
     if (!/^sha256:[a-f0-9]{64}$/u.test(master.pack_hash)) fail(`${hostId}: ${master.id} pack hash is invalid`);
-    for (const visible of [`${master.index}. `, `[${master.id}]`, master.identity, master.method, master.best_for, master.maturity]) {
+    for (const visible of [`${master.index}. `, `[${master.id}]`, master.identity, master.method, master.best_for, master.maturity, master.maturity_label]) {
       if (!text.includes(visible)) fail(`${hostId}: returned text did not display ${master.id} field ${visible}`);
     }
   }
 }
 
+function assertLocalizedCatalog(opened, text, locale) {
+  assertCompleteCatalog(opened, text, `installed-${locale.key}`);
+  for (const master of opened.masters) {
+    for (const field of ["identity", "method", "best_for", "maturity_label"]) {
+      if (!locale.script.test(master[field])) fail(`installed-${locale.key}: ${master.id}.${field} lacks requested-locale prose`);
+      if (locale.key !== "en" && /\b[a-z]+(?:_[a-z0-9]+)+\b/u.test(master[field])) {
+        fail(`installed-${locale.key}: ${master.id}.${field} leaked a machine domain id into reader-facing prose`);
+      }
+    }
+  }
+}
+
 function normalizedReceiptBinding(record) {
   return {
     symbol: record.symbol,
@@ -624,7 +654,27 @@ async function executePackagedAdapters({ pack, surfaces, tempRoot }) {
         networkSentinel,
       });
       await server.request("initialize", {});
-      sessions.push({ hostId, dataDir, server });
+      const listed = await server.request("tools/list", {});
+      const tools = listed.result?.tools || [];
+      if (tools.length !== EXPECTED_TOOL_COUNT) fail(`${hostId}: installed server exposed ${tools.length} tools, expected ${EXPECTED_TOOL_COUNT}`);
+      sessions.push({ hostId, dataDir, server, toolCount: tools.length });
+    }
+
+    const localeCases = process.env.ALPHACOUNCIL_PERSONA_BUILD_PROFILE === "production"
+      ? INSTALLED_LOCALE_CASES.slice(0, 1)
+      : INSTALLED_LOCALE_CASES;
+    const localeCatalogHashes = {};
+    for (const locale of localeCases) {
+      const response = await sessions[0].server.callTool("begin_council_selection", {
+        symbol: SYMBOL,
+        as_of: AS_OF,
+        language: locale.language,
+        prompt: locale.prompt,
+        host: "installed-package-locale-smoke",
+      });
+      const opened = structured(response, `installed ${locale.language} begin_council_selection`);
+      assertLocalizedCatalog(opened, response.result.content?.[0]?.text || "", locale);
+      localeCatalogHashes[locale.key] = opened.catalog_hash;
     }
 
     for (const session of sessions) {
@@ -642,7 +692,7 @@ async function executePackagedAdapters({ pack, surfaces, tempRoot }) {
         selection_id: opened.selection_id,
         catalog_hash: opened.catalog_hash,
         display_ack: true,
-        selection: PACKAGED_SELECTION_INPUT,
+        selected_master_ids: PACKAGED_SELECTION_INPUT,
       }), `${session.hostId} confirm_master_selection`);
       session.opened = opened;
       session.confirmed = confirmed;
@@ -744,11 +794,15 @@ async function executePackagedAdapters({ pack, surfaces, tempRoot }) {
       evidence_scope: "installed_npm_tarball_mcp_stdio_adapters_only",
       host_order: PACKAGED_HOST_IDS,
       host_count: sessions.length,
+      tool_count: EXPECTED_TOOL_COUNT,
+      locale_count: localeCases.length,
+      locale_catalog_hashes: localeCatalogHashes,
       catalog_count: baseline.catalog.length,
       catalog_hash: baseline.catalog_hash,
       catalog_order_hash: sha256(baseline.catalog),
       maturity_counts: maturityCounts,
       selection_input: PACKAGED_SELECTION_INPUT,
+      selection_input_type: "stable_ids",
       selected_master_ids: baseline.selected_master_ids,
       selected_master_pack_hashes: baseline.selected_master_pack_hashes,
       receipt_binding_hash: sha256(baseline.receipt_binding),
@@ -774,6 +828,7 @@ async function executePackagedAdapters({ pack, surfaces, tempRoot }) {
         host_id: session.hostId,
         server_entry: "mcp/server.mjs",
         adapter_status: "passed",
+        tool_count: session.toolCount,
         catalog_count: session.catalog.length,
         catalog_hash: session.opened.catalog_hash,
         selected_master_ids: session.confirmed.selected_master_ids,

package/scripts/lib/persona-v3-ai-assisted-solo-status.mjs

@@ -7,6 +7,8 @@
  * approval, production admission, method_model, or formal-GA claim.
  */
 
+import { PLANNED_TOOL_COUNT } from "../../data/persona-v3-build-specs.v1.mjs";
+import { CANONICAL_MASTER_COUNT } from "../../mcp/lib/personas-v3/staging.mjs";
 import { createHash } from "node:crypto";
 import {
   closeSync,
@@ -28,6 +30,7 @@ import {
 } from "../../mcp/lib/personas-v3/ai-source-pre-review.mjs";
 import { assessErrorNeff } from "../../mcp/lib/personas-v3/n-eff.mjs";
 import { inspectPersonaV3SoloTestPacks } from "./persona-v3-solo-test-packs.mjs";
+import { resolvePersonaPackVersion } from "./build-profile.mjs";
 import {
   AI_MACHINE_SIMULATION_RUN_IDS,
   verifyAIMachineSimulationTree,
@@ -748,12 +751,12 @@ export function loadAiAssistedSoloProfile(file = DEFAULT_AI_ASSISTED_SOLO_PROFIL
     if (profile[field] !== expected) errors.push(`${field} must be ${JSON.stringify(expected)}`);
   }
   const expectedRequirements = {
-    physical_solo_packs: 26,
+    physical_solo_packs: CANONICAL_MASTER_COUNT,
     ai_source_prereviews: 32,
     ai_semantic_extractions: 32,
     ai_semantic_skeptic_reviews: 32,
     ai_semantic_adjudications: 32,
-    ai_formula_cross_reviews: 52,
+    ai_formula_cross_reviews: PLANNED_TOOL_COUNT,
     independent_roles_per_review: 3,
     automated_experiment_runs: 8,
     live_hosts: 4,
@@ -775,12 +778,11 @@ export function inspectAiAssistedSoloStatus(options = {}) {
 
   let packReport = null;
   try {
-    const packageVersion = physicalJson(resolve(repoRoot, "package.json"), "package metadata").value.version;
     const packOptions = Object.fromEntries(Object.entries({
       root: options.packRoot || paths.solo_pack_root,
       formulaRoot: options.formulaRoot,
       personaDir: options.personaDir,
-      packVersion: options.packVersion || packageVersion,
+      packVersion: options.packVersion || resolvePersonaPackVersion(repoRoot),
     }).filter(([, value]) => value !== undefined));
     packReport = inspectPersonaV3SoloTestPacks(packOptions);
   } catch (error) { integrityErrors.push(`solo packs: ${error.message}`); }

package/scripts/lib/persona-v3-ai-formula-review.mjs

@@ -1,11 +1,12 @@
 /**
- * Isolated AI-assisted cross-review lane for the 52 solo-test derived proxies.
+ * Isolated AI-assisted cross-review lane for the solo-test derived proxies.
  *
  * This lane reviews mechanical reproducibility only. Its three reviewers are explicitly
  * machine principals. It cannot emit a human approval, make a tool production eligible,
  * or satisfy the formal formula-review compiler/GA path.
  */
 
+import { PLANNED_TOOL_COUNT } from "../../data/persona-v3-build-specs.v1.mjs";
 import {
   existsSync,
   lstatSync,
@@ -217,7 +218,7 @@ function physicalFormulaRecords(formulaRoot) {
   const plan = planSoloTestFormulaCompilation({ outputRoot: formulaRoot });
   const manifest = readPlainJson(root, "compilation-manifest.json", "solo formula manifest");
   if (manifest.compilation_hash !== plan.compilation_hash) {
-    fail("physical solo formula manifest is not bound to the current 52-tool compilation", {
+    fail("physical solo formula manifest is not bound to the current compilation", {
       expected: plan.compilation_hash,
       actual: manifest.compilation_hash,
     });
@@ -567,14 +568,14 @@ export function validateAIFormulaReviewArtifact(artifact, { reviewSchemaHash = s
   return errors;
 }
 
-/** Plan all 52 records without mutating the physical review tree. */
+/** Plan every record without mutating the physical review tree. */
 export function planAIFormulaCrossReviews({ formulaRoot = DEFAULT_SOLO_TEST_FORMULA_ROOT } = {}) {
   const schema = parsedReviewSchema();
   const reviewSchemaHash = sha256(schema);
   const input = physicalFormulaRecords(formulaRoot);
   const reviews = input.records.map((record) => reviewOne(record, input.compilationHash, reviewSchemaHash));
-  if (reviews.length !== 52 || new Set(reviews.map((review) => review.tool_id)).size !== 52) {
-    fail("AI formula cross-review must cover exactly 52 unique tools");
+  if (reviews.length !== PLANNED_TOOL_COUNT || new Set(reviews.map((review) => review.tool_id)).size !== PLANNED_TOOL_COUNT) {
+    fail(`AI formula cross-review must cover exactly ${PLANNED_TOOL_COUNT} unique tools`);
   }
   const invalid = reviews.flatMap((review) => validateAIFormulaReviewArtifact(review, { reviewSchemaHash })
     .map((message) => `${review.tool_id}: ${message}`));

package/scripts/lib/persona-v3-ai-machine-simulations.mjs

@@ -19,7 +19,7 @@ import { executeDeterministicPersonaPolicy } from "../../mcp/lib/personas-v3/det
 import { loadCompiledPersonaPacks } from "../../mcp/lib/personas-v3/registry.mjs";
 import { buildAnonymousPreDecision } from "../../mcp/lib/personas-v3/runtime.mjs";
 import { buildFactPack } from "../../mcp/lib/personas-v3/typed-facts.mjs";
-import { CANONICAL_MASTER_IDS } from "../../mcp/lib/personas-v3/staging.mjs";
+import { CANONICAL_MASTER_COUNT, CANONICAL_MASTER_IDS } from "../../mcp/lib/personas-v3/staging.mjs";
 import { PRIORITY_13_MASTER_IDS } from "./council-evaluation-protocol.mjs";
 
 export const AI_MACHINE_SIMULATION_RUN_IDS = Object.freeze([
@@ -105,6 +105,16 @@ function factPackFor(pack) {
       }
     });
   }
+  // Everything the seat declares it reads, not only what its tools consume. An authored
+  // policy gates eligibility on a fact outside its tool inputs on purpose, so a fixture built
+  // from tool inputs alone leaves every such seat correctly -- and uselessly -- out of scope,
+  // and the simulation would then demonstrate nothing.
+  for (const factId of [
+    ...(pack.manifest.capability.required_fact_types || []),
+    ...(pack.manifest.capability.optional_fact_types || []),
+  ]) {
+    if (!byFact.has(factId)) byFact.set(factId, { value_kind: "ratio", unit: "decimal" });
+  }
   const facts = [...byFact].map(([factId, contract]) => canonicalValue({
     schema_version: 1,
     fact_id: factId,
@@ -114,8 +124,10 @@ function factPackFor(pack) {
     currency: contract.value_kind === "monetary" ? "USD" : null,
     scale: contract.value_kind === "monetary" ? 1 : null,
     ...(contract.value_kind === "ratio" ? { ratio_denominator: "synthetic_denominator" } : {}),
-    period_start: null,
-    period_end: null,
+    // A fixture whose facts are all instants cannot exercise a method that reads a reporting
+    // interval -- the contract check rejects the fact before any arithmetic runs. The synthetic
+    // fact therefore carries whatever span its own contract asks for.
+    ...syntheticInterval(contract.period),
     fiscal_year: null,
     as_of: AS_OF,
     public_at: AS_OF,
@@ -128,6 +140,22 @@ function factPackFor(pack) {
   return buildFactPack(facts, { asOf: AS_OF });
 }
 
+/** Build an interval that satisfies the contract's declared window, or none for an instant. */
+function syntheticInterval(period) {
+  if (period?.basis !== "duration" && period?.basis !== "forecast_horizon") {
+    return { period_start: null, period_end: null };
+  }
+  const end = Date.parse(`${AS_OF}T00:00:00.000Z`);
+  const match = /^P([1-9]\d*)([DMY])$/u.exec(period.window || "");
+  const days = period.window === "ANY" ? 365
+    : match ? Number(match[1]) * ({ D: 1, M: 30, Y: 365 })[match[2]]
+      : 365;
+  return {
+    period_start: new Date(end - days * 86_400_000).toISOString().slice(0, 10),
+    period_end: AS_OF,
+  };
+}
+
 function buildInput(registry) {
   const protocol = boundFile("data/council-evaluation-protocol.v1.json");
   const protocolValue = readJson(resolve(REPO_ROOT, protocol.path));
@@ -224,7 +252,7 @@ function configs() {
     { run_id: "B", formal_arm_id: "B", ids: [], scope: "frozen-input control digest only; eight LLM analyst outputs are not simulated", checks: false },
     { run_id: "C", formal_arm_id: "C", ids: [], scope: "prompt-catalog binding only; prompt-only LLM outputs are not simulated", checks: false },
     { run_id: "D13", formal_arm_id: "D13", ids: [...PRIORITY_13_MASTER_IDS], scope: "13 physical provisional deterministic seats on frozen synthetic typed facts", checks: false },
-    { run_id: "D26", formal_arm_id: "D26", ids: [...CANONICAL_MASTER_IDS], scope: "26 physical provisional deterministic seats on frozen synthetic typed facts", checks: false },
+    { run_id: "D26", formal_arm_id: "D26", ids: [...CANONICAL_MASTER_IDS], scope: `${CANONICAL_MASTER_COUNT} physical provisional deterministic seats on frozen synthetic typed facts`, checks: false },
     { run_id: "E:D13", formal_arm_id: "E", ids: [...PRIORITY_13_MASTER_IDS], scope: "D13 deterministic seats plus machine-only hash, rederivation and fail-closed checks", checks: true },
     { run_id: "E:D26", formal_arm_id: "E", ids: [...CANONICAL_MASTER_IDS], scope: "D26 deterministic seats plus machine-only hash, rederivation and fail-closed checks", checks: true },
     { run_id: "H_ai_reference", formal_arm_id: "H", ids: [...CANONICAL_MASTER_IDS], scope: "AI deterministic reference digest only; no human analysts or blinded human adjudicator", checks: true },

package/scripts/lib/persona-v3-build-specs.mjs

@@ -1,3 +1,4 @@
+import { CANONICAL_MASTER_COUNT } from "../../mcp/lib/personas-v3/staging.mjs";
 import { existsSync, readFileSync, realpathSync } from "node:fs";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -234,7 +235,7 @@ export function validatePersonaV3BuildSpecs(inventory = personaV3BuildSpecs) {
   if (inventory.inventory_id !== "personapack-v3-build-specs") add(errors, null, "inventory_id is invalid");
   if (inventory.inventory_status !== "non_production_planning_only") add(errors, null, "inventory must remain non-production");
   if (inventory.canonical_catalog_source !== "mcp/lib/personas/registry.mjs") add(errors, null, "canonical catalog source changed");
-  if (inventory.seat_count !== 26) add(errors, null, "seat_count must be 26");
+  if (inventory.seat_count !== CANONICAL_MASTER_COUNT) add(errors, null, `seat_count must be ${CANONICAL_MASTER_COUNT}`);
 
   const policy = inventory.adjudication_policy || {};
   exactKeys(policy, ["method_attribution", "source_grading", "case_labels", "veto_thresholds", "reviewer_approvals", "experiments", "promotion_effect"], "adjudication_policy", null, errors);
@@ -247,7 +248,7 @@ export function validatePersonaV3BuildSpecs(inventory = personaV3BuildSpecs) {
 
   const catalogIds = registry().ids("master");
   const selectorIds = knownSelectorCardIds();
-  if (catalogIds.length !== 26) add(errors, null, `canonical registry has ${catalogIds.length} masters, expected 26`);
+  if (catalogIds.length !== CANONICAL_MASTER_COUNT) add(errors, null, `canonical registry has ${catalogIds.length} masters, expected ${CANONICAL_MASTER_COUNT}`);
   const missingCards = catalogIds.filter((id) => !selectorIds.includes(id));
   const extraCards = selectorIds.filter((id) => !catalogIds.includes(id));
   if (missingCards.length || extraCards.length) add(errors, null, `selector cards differ from registry; missing=${missingCards.join(",") || "none"}; extra=${extraCards.join(",") || "none"}`);

package/scripts/lib/persona-v3-draft-packs.mjs

@@ -1,7 +1,7 @@
 /**
  * Deterministic PersonaPack v3 editorial-prototype factory.
  *
- * These artifacts make every one of the 26 planned seats physically inspectable without
+ * These artifacts make every planned seat physically inspectable without
  * pretending that source adjudication, case labeling, experiments, or production promotion
  * happened. The production loader does not read this tree and a draft never contains a
  * `manifest.json`.
@@ -472,7 +472,7 @@ function generationContext(options = {}) {
   const byBlueprint = new Map(blueprints.map((blueprint) => [blueprint.persona_id, blueprint]));
   const bySource = new Map(acquisition.personas.map((persona) => [persona.persona_id, persona]));
   const bySpec = new Map(inventory.seats.map((seat) => [seat.persona_id, seat]));
-  if (bySpec.size !== CANONICAL_MASTER_COUNT) fail("canonical build-spec inventory is not exactly 26 unique seats");
+  if (bySpec.size !== CANONICAL_MASTER_COUNT) fail("canonical build-spec inventory does not cover the canonical roster exactly once");
   return { root, productionRoot, personaDir, staging, acquisition, byBlueprint, bySource, bySpec };
 }
 

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

@@ -2,11 +2,12 @@
  * Fail-closed PersonaPack v3 formula authoring and DSL 1.1 compilation pipeline.
  *
  * Inventory construction and compilation are pure functions. Filesystem helpers only read
- * the 26 canonical staging prototypes or, after an explicit caller action, write isolated
+ * the canonical staging prototypes or, after an explicit caller action, write isolated
  * non-production formula-candidate artifacts. Nothing here writes knowledge/masters,
  * manifests, release evidence, or production registrations.
  */
 
+import { PLANNED_TOOL_COUNT } from "../../data/persona-v3-build-specs.v1.mjs";
 import {
   existsSync,
   lstatSync,
@@ -316,7 +317,7 @@ function pendingFormulaSpec(prototype, prototypePath) {
   });
 }
 
-/** Build the 52-entry authoring queue from already-read prototype documents. */
+/** Build the authoring queue from already-read prototype documents. */
 export function buildFormulaAuthoringInventory(prototypeArtifacts) {
   if (!Array.isArray(prototypeArtifacts)) fail("prototypeArtifacts must be an array");
   const byPersona = new Map(prototypeArtifacts.map((artifact) => [artifact?.document?.persona_id, artifact]));
@@ -523,7 +524,7 @@ function collectJsonFiles(root, dir, prefix = "") {
   return result;
 }
 
-/** Read and verify all 52 human-authored specs and dual-signed bundles without writing. */
+/** Read and verify every human-authored spec and dual-signed bundles without writing. */
 export function planApprovedFormulaCompilation({
   candidateRoot = DEFAULT_FORMULA_CANDIDATE_ROOT,
   root = defaultStagingRoot(),
@@ -556,10 +557,10 @@ export function planApprovedFormulaCompilation({
   const actualSpecFiles = collectJsonFiles(candidate, resolve(candidate, "specs"));
   const actualApprovalFiles = collectJsonFiles(candidate, resolve(candidate, "approvals"));
   if (JSON.stringify(actualSpecFiles) !== JSON.stringify(expectedSpecFiles.sort())) {
-    fail("approved formula compilation requires exactly the 52 planned spec files", { expected: expectedSpecFiles.sort(), actual: actualSpecFiles });
+    fail("approved formula compilation requires exactly the planned spec files, one per tool", { expected: expectedSpecFiles.sort(), actual: actualSpecFiles });
   }
   if (JSON.stringify(actualApprovalFiles) !== JSON.stringify(expectedApprovalFiles.sort())) {
-    fail("approved formula compilation requires exactly the 52 planned approval bundles", { expected: expectedApprovalFiles.sort(), actual: actualApprovalFiles });
+    fail("approved formula compilation requires exactly the planned approval bundles, one per tool", { expected: expectedApprovalFiles.sort(), actual: actualApprovalFiles });
   }
   const prototypeDocuments = Object.fromEntries(readFormulaPrototypeArtifacts({ root })
     .map((artifact) => [artifact.relative_path, artifact.document]));
@@ -571,9 +572,9 @@ export function planApprovedFormulaCompilation({
   });
   const expectedIds = authoring.inventory.entries.map((entry) => entry.tool_id);
   const actualIds = tools.map((tool) => tool.id);
-  if (actualIds.length !== 52 || new Set(actualIds).size !== 52
+  if (actualIds.length !== PLANNED_TOOL_COUNT || new Set(actualIds).size !== PLANNED_TOOL_COUNT
     || JSON.stringify([...actualIds].sort()) !== JSON.stringify([...expectedIds].sort())) {
-    fail("approved compilation must produce exactly the 52 planned unique tool ids", { expected_ids: expectedIds, actual_ids: actualIds });
+    fail("approved compilation must produce exactly the planned unique tool ids, one per tool", { expected_ids: expectedIds, actual_ids: actualIds });
   }
   const bindings = tools.map((tool) => canonicalValue({
     persona_id: tool.id.split(".")[0],
@@ -591,7 +592,7 @@ export function planApprovedFormulaCompilation({
     mode: "check_only",
     production_effect: "none",
     canonical_seat_count: CANONICAL_MASTER_COUNT,
-    planned_tool_count: 52,
+    planned_tool_count: PLANNED_TOOL_COUNT,
     compiled_tool_count: tools.length,
     formula_approval_binding_count: bindings.length,
     tool_ids: actualIds,
@@ -669,7 +670,7 @@ export function planPersonaV3FormulaPipeline(options = {}) {
   const expected = buildInventory.seats.reduce((total, seat) => total + seat.planned_dedicated_tools.length, 0);
   const errors = [...inventory.global_errors];
   if (inventory.canonical_seat_count !== buildInventory.seat_count) errors.push("canonical seat count drifted");
-  if (inventory.prototype_count !== expected || expected !== 52) errors.push(`prototype inventory must be exactly 52, got ${inventory.prototype_count}/${expected}`);
+  if (inventory.prototype_count !== expected || expected !== PLANNED_TOOL_COUNT) errors.push(`prototype inventory must be exactly ${PLANNED_TOOL_COUNT}, got ${inventory.prototype_count}/${expected}`);
   if (inventory.entries.some((entry) => entry.validation_errors.length)) errors.push("one or more generated formula specs are invalid");
   if (inventory.executable_candidate_count !== 0 || inventory.dedicated_tool_count !== 0) errors.push("unreviewed prototypes must not become executable or dedicated tools");
   return Object.freeze(canonicalValue({ mode: "check_plan", errors, inventory }));
@@ -732,7 +733,7 @@ export function renderFormulaAuthoringPlan(plan) {
     "# PersonaPack v3 formula authoring queue",
     "",
     `Seats: ${plan.inventory.canonical_seat_count}`,
-    `Prototypes: ${plan.inventory.prototype_count}/52`,
+    `Prototypes: ${plan.inventory.prototype_count}/${PLANNED_TOOL_COUNT}`,
     `Needs formula authorship: ${plan.inventory.needs_formula_authorship_count}`,
     `Executable staging candidates: ${plan.inventory.executable_candidate_count}`,
     `Dedicated production tools: ${plan.inventory.dedicated_tool_count}`,

package/scripts/lib/persona-v3-production-candidates.mjs

@@ -3,11 +3,12 @@
  *
  * This layer deliberately does not manufacture manifests or promote editorial drafts. A
  * candidate exists only after a real schema-v3 directory has been authored on disk. The
- * inspector then proves loader/compiler validity, computed admission and coverage of the 52
+ * inspector then proves loader/compiler validity, computed admission and coverage of every
  * planned seat-specific tools. Immutable release assembly remains a later, separately signed
  * operation.
  */
 
+import { PLANNED_TOOL_COUNT } from "../../data/persona-v3-build-specs.v1.mjs";
 import {
   existsSync,
   lstatSync,
@@ -401,7 +402,7 @@ export function inspectPersonaV3ProductionCandidates({
   const inventoryErrors = [];
   if (buildInventory.seat_count !== CANONICAL_MASTER_COUNT) inventoryErrors.push("build-spec seat count is not 26");
   const expectedToolCount = [...expectedByPersona.values()].reduce((total, ids) => total + ids.length, 0);
-  if (expectedToolCount !== 52) inventoryErrors.push(`build-spec tool count is not 52: ${expectedToolCount}`);
+  if (expectedToolCount !== PLANNED_TOOL_COUNT) inventoryErrors.push(`build-spec tool count is not ${PLANNED_TOOL_COUNT}: ${expectedToolCount}`);
 
   const actualEntries = candidateRoot.exists
     ? readdirSync(candidateRoot.root, { withFileTypes: true })
@@ -474,13 +475,13 @@ export function renderPersonaV3ProductionCandidateReadiness(report) {
     "",
     "> Read-only staging report. Physical presence is not source approval, experiment passage, release assembly or production promotion.",
     "",
-    `Physical candidates: ${report.summary.physical_candidate_count}/26`,
-    `Loader-valid candidates: ${report.summary.loader_valid_count}/26`,
-    `Operational candidates: ${report.summary.operational_candidate_count}/26`,
-    `Candidate admissions: ${report.summary.candidate_admission_count}/26`,
-    `Method models: ${report.summary.method_model_count}/26`,
-    `Planned tool coverage: ${report.summary.planned_tool_coverage_count}/52`,
-    `Verified formula approvals: ${report.summary.formula_approval_evidence_count}/52`,
+    `Physical candidates: ${report.summary.physical_candidate_count}/${CANONICAL_MASTER_COUNT}`,
+    `Loader-valid candidates: ${report.summary.loader_valid_count}/${CANONICAL_MASTER_COUNT}`,
+    `Operational candidates: ${report.summary.operational_candidate_count}/${CANONICAL_MASTER_COUNT}`,
+    `Candidate admissions: ${report.summary.candidate_admission_count}/${CANONICAL_MASTER_COUNT}`,
+    `Method models: ${report.summary.method_model_count}/${CANONICAL_MASTER_COUNT}`,
+    `Planned tool coverage: ${report.summary.planned_tool_coverage_count}/${PLANNED_TOOL_COUNT}`,
+    `Verified formula approvals: ${report.summary.formula_approval_evidence_count}/${PLANNED_TOOL_COUNT}`,
     `Required admission: ${report.required_admission}`,
     `Gate clear: ${report.summary.gate_clear}`,
     `Readiness hash: \`${report.readiness_hash}\``,