alphacouncil-agent 0.9.2 → 1.0.0

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

@@ -7,12 +7,14 @@
  * signature, approval bundle, or method-model claim and cannot satisfy production admission.
  */
 
+import { PLANNED_TOOL_COUNT } from "../../data/persona-v3-build-specs.v1.mjs";
 import {
   existsSync,
   lstatSync,
   mkdirSync,
   readFileSync,
   readdirSync,
+  rmSync,
   realpathSync,
   statSync,
   writeFileSync,
@@ -21,6 +23,7 @@ import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path
 
 import { canonicalValue, sha256 } from "../../mcp/lib/personas-v3/canonical.mjs";
 import {
+  ANY_REPORTING_INTERVAL,
   PROVISIONAL_DERIVED_PROXY_ASSURANCE,
   deterministicToolSchemaHashes,
 } from "../../mcp/lib/personas-v3/deterministic-executor.mjs";
@@ -29,6 +32,7 @@ import {
   CANONICAL_MASTER_IDS,
   defaultStagingRoot,
 } from "../../mcp/lib/personas-v3/staging.mjs";
+import { authoredMethods } from "../../data/authored/index.mjs";
 import {
   DEFAULT_FORMULA_CANDIDATE_ROOT,
   FORMULA_AUTHORING_STATUS,
@@ -52,6 +56,16 @@ export const SOLO_TEST_PROXY_UNIT = "derived_proxy_scalar";
 
 const INSTANT_AS_OF = Object.freeze({ basis: "instant", window: null, alignment: "as_of" });
 
+/**
+ * Some facts genuinely cover a span rather than a moment: a five-year cash-flow total is not an
+ * observation taken on one day. Declaring those as instants made them unusable -- the executor
+ * rejects an instant contract against a fact that carries a reporting interval, so every seat
+ * whose method reads company fundamentals failed closed on live grounding.
+ */
+function duration(window) {
+  return Object.freeze({ basis: "duration", window, alignment: "as_of" });
+}
+
 /**
  * Typed-fact contracts currently emitted by grounding-adapter and safe to bind mechanically.
  * A fact whose physical period differs from this canonical instant snapshot still fails closed.
@@ -59,16 +73,59 @@ const INSTANT_AS_OF = Object.freeze({ basis: "instant", window: null, alignment:
 export const CANONICAL_SOLO_TEST_FACT_CONTRACTS = Object.freeze({
   "market.price": Object.freeze({ value_kind: "monetary", unit: "currency_units", period: INSTANT_AS_OF }),
   "market.change_pct": Object.freeze({ value_kind: "ratio", unit: "decimal", period: INSTANT_AS_OF }),
-  "financial.return_on_equity_10y": Object.freeze({ value_kind: "ratio", unit: "decimal", period: INSTANT_AS_OF }),
-  "financial.free_cash_flow_5y": Object.freeze({ value_kind: "monetary", unit: "currency_units", period: INSTANT_AS_OF }),
-  "financial.interest_coverage": Object.freeze({ value_kind: "ratio", unit: "multiple", period: INSTANT_AS_OF }),
-  "financial.gross_margin_5y": Object.freeze({ value_kind: "ratio", unit: "decimal", period: INSTANT_AS_OF }),
-  "financial.net_margin_5y": Object.freeze({ value_kind: "ratio", unit: "decimal", period: INSTANT_AS_OF }),
-  "accounting.cash_conversion": Object.freeze({ value_kind: "ratio", unit: "multiple", period: INSTANT_AS_OF }),
+  "financial.return_on_equity_10y": Object.freeze({ value_kind: "ratio", unit: "decimal", period: duration("P10Y") }),
+  "financial.free_cash_flow_5y": Object.freeze({ value_kind: "monetary", unit: "currency_units", period: duration("P5Y") }),
+  "financial.interest_coverage": Object.freeze({ value_kind: "ratio", unit: "multiple", period: duration(ANY_REPORTING_INTERVAL) }),
+  "financial.gross_margin_5y": Object.freeze({ value_kind: "ratio", unit: "decimal", period: duration("P5Y") }),
+  "financial.net_margin_5y": Object.freeze({ value_kind: "ratio", unit: "decimal", period: duration("P5Y") }),
+  "accounting.cash_conversion": Object.freeze({ value_kind: "ratio", unit: "multiple", period: duration("P5Y") }),
   "capital_allocation.share_count_change_5y": Object.freeze({ value_kind: "ratio", unit: "decimal", period: INSTANT_AS_OF }),
   "options.implied_volatility": Object.freeze({ value_kind: "ratio", unit: "decimal_annualized_volatility", period: INSTANT_AS_OF }),
   "options.skew_25d": Object.freeze({ value_kind: "ratio", unit: "decimal_volatility_difference", period: INSTANT_AS_OF }),
   "execution.bid_ask": Object.freeze({ value_kind: "ratio", unit: "decimal_of_mid", period: INSTANT_AS_OF }),
+
+  // Dated official series. These are what let a macro or cycle method have a direction at all,
+  // and their units are decimal fractions rather than the percent the sources publish.
+  "macro.long_bond_yield": Object.freeze({ value_kind: "ratio", unit: "decimal", period: INSTANT_AS_OF }),
+  "macro.short_bond_yield": Object.freeze({ value_kind: "ratio", unit: "decimal", period: INSTANT_AS_OF }),
+  "macro.term_structure_slope": Object.freeze({ value_kind: "ratio", unit: "decimal", period: INSTANT_AS_OF }),
+  "macro.real_rate": Object.freeze({ value_kind: "ratio", unit: "decimal", period: INSTANT_AS_OF }),
+  "macro.breakeven_inflation": Object.freeze({ value_kind: "ratio", unit: "decimal", period: INSTANT_AS_OF }),
+  "macro.aaa_corporate_yield": Object.freeze({ value_kind: "ratio", unit: "decimal", period: INSTANT_AS_OF }),
+  "macro.credit_spread": Object.freeze({ value_kind: "ratio", unit: "decimal", period: INSTANT_AS_OF }),
+  "macro.liquidity_impulse": Object.freeze({ value_kind: "ratio", unit: "decimal", period: duration("P3M") }),
+  // macro.growth_regime is deliberately absent. A tool contract accepts only monetary, ratio,
+  // count or scalar, so a text-valued fact cannot flow through the computation layer at all.
+  // It reaches a policy the other way: a condition compares it with `eq` against a state name.
+
+  // Company fundamentals derived from filings, beyond the seven the mechanical screen computes.
+  "financial.owner_earnings": Object.freeze({ value_kind: "monetary", unit: "currency_units", period: duration("P1Y") }),
+  "financial.net_current_asset_value": Object.freeze({ value_kind: "monetary", unit: "currency_units", period: INSTANT_AS_OF }),
+  "financial.incremental_return_on_capital": Object.freeze({ value_kind: "ratio", unit: "decimal", period: duration("P5Y") }),
+  "financial.leverage": Object.freeze({ value_kind: "ratio", unit: "decimal", period: INSTANT_AS_OF }),
+  "valuation.revenue_growth": Object.freeze({ value_kind: "ratio", unit: "decimal", period: duration(ANY_REPORTING_INTERVAL) }),
+  "valuation.downside_asset_value": Object.freeze({ value_kind: "monetary", unit: "currency_units", period: INSTANT_AS_OF }),
+  "valuation.downside_floor": Object.freeze({ value_kind: "monetary", unit: "currency_units", period: INSTANT_AS_OF }),
+  "capital_allocation.share_count": Object.freeze({ value_kind: "count", unit: "shares", period: duration("P1Y") }),
+
+  // Basket-level facts. Without these an index or fund method has nothing to reason about,
+  // which is why every seat abstained on an ETF regardless of how well it was written.
+  "index.aggregate_pe_ttm": Object.freeze({ value_kind: "ratio", unit: "multiple", period: INSTANT_AS_OF }),
+  "index.aggregate_pe_forward": Object.freeze({ value_kind: "ratio", unit: "multiple", period: INSTANT_AS_OF }),
+  "index.aggregate_earnings_yield": Object.freeze({ value_kind: "ratio", unit: "decimal", period: INSTANT_AS_OF }),
+  "index.dividend_yield": Object.freeze({ value_kind: "ratio", unit: "decimal", period: INSTANT_AS_OF }),
+  "fund.top_ten_weight": Object.freeze({ value_kind: "ratio", unit: "decimal", period: INSTANT_AS_OF }),
+  "fund.concentration_hhi": Object.freeze({ value_kind: "ratio", unit: "decimal", period: INSTANT_AS_OF }),
+  "valuation.implied_erp": Object.freeze({ value_kind: "ratio", unit: "decimal", period: INSTANT_AS_OF }),
+  "cycle.valuation_percentile": Object.freeze({ value_kind: "ratio", unit: "decimal", period: INSTANT_AS_OF }),
+  "index.breadth_above_200dma": Object.freeze({ value_kind: "ratio", unit: "decimal", period: INSTANT_AS_OF }),
+  "index.breadth_counted_above_200dma": Object.freeze({ value_kind: "ratio", unit: "decimal", period: INSTANT_AS_OF }),
+  "fund.aum": Object.freeze({ value_kind: "monetary", unit: "currency_units", period: INSTANT_AS_OF }),
+  "fund.expense_ratio": Object.freeze({ value_kind: "ratio", unit: "decimal", period: INSTANT_AS_OF }),
+
+  // The US has no promoter shareholding record. Section 16 ownership is the filed analogue,
+  // and it is what lets a governance-first method reach a number on this universe at all.
+  "governance.insider_ownership": Object.freeze({ value_kind: "ratio", unit: "decimal", period: INSTANT_AS_OF }),
 });
 
 const ID = /^[a-z][a-z0-9_.:-]{1,159}$/u;
@@ -153,6 +210,74 @@ function exactPendingCandidate(entry, candidateRoot) {
   return spec;
 }
 
+/**
+ * The formula a seat's method actually needs, when one has been authored for it.
+ *
+ * Everything else in this module derives an identity proxy, which is executable and
+ * deliberately meaningless: it exists so the pipeline can be exercised before any method has
+ * been written. An authored formula replaces that with the seat's real arithmetic, still
+ * unreviewed and still barred from production, but no longer a placeholder pretending to be a
+ * computation. Both paths are validated identically downstream.
+ */
+function authoredFormula(spec, authored) {
+  const tool = (authored?.tools || []).find((candidate) => candidate.tool_id === spec.tool_id);
+  if (!tool) return null;
+  // The per-tool candidate lists are a generated projection of the authored tools themselves,
+  // so checking one against the other proves nothing. What still has to hold is that every
+  // input names a real fact and the output is the one the spec was regenerated to expect --
+  // the meaningful contract check happens downstream, where the policy validator rejects any
+  // condition reading a fact the seat did not declare.
+  for (const operand of tool.inputs || []) {
+    if (operand?.fact_id && !ID.test(operand.fact_id)) {
+      fail(`${spec.tool_id}: authored input ${JSON.stringify(operand.fact_id)} is not a valid fact id`);
+    }
+  }
+  if (!ID.test(tool.output_id || "")) {
+    fail(`${spec.tool_id}: authored output ${JSON.stringify(tool.output_id)} is not a valid output id`);
+  }
+  const contractFor = (operand) => {
+    if (operand?.literal !== undefined) {
+      return { value_kind: "scalar", unit: SOLO_TEST_PROXY_UNIT, period: INSTANT_AS_OF };
+    }
+    if (operand?.fact_id) {
+      return CANONICAL_SOLO_TEST_FACT_CONTRACTS[operand.fact_id]
+        || { value_kind: "scalar", unit: SOLO_TEST_PROXY_UNIT, period: INSTANT_AS_OF };
+    }
+    // An output operand carries the PRODUCING tool's contract, not the consuming one's. The
+    // executor compares against what the producer declared, so reading the consumer's kind
+    // breaks every tool that divides a monetary numerator by a monetary denominator to make
+    // a ratio -- which is most of what a valuation method does.
+    if (operand?.output_id) {
+      const producer = (authored?.tools || []).find((candidate) => candidate.output_id === operand.output_id);
+      if (producer) return { value_kind: producer.value_kind, unit: producer.unit, period: INSTANT_AS_OF };
+      return { value_kind: "scalar", unit: SOLO_TEST_PROXY_UNIT, period: INSTANT_AS_OF };
+    }
+    return { value_kind: tool.value_kind, unit: tool.unit, period: INSTANT_AS_OF };
+  };
+  return canonicalValue({
+    version: "0.2.0",
+    kind: "recomputation",
+    operation: tool.operation,
+    on_missing: "fail",
+    inputs: (tool.inputs || []).map((operand) => {
+      const contract = contractFor(operand);
+      return {
+        operand,
+        value_kind: contract.value_kind,
+        unit: contract.unit,
+        period: contract.period,
+        on_missing: "fail",
+      };
+    }),
+    output: {
+      output_id: tool.output_id,
+      value_kind: tool.value_kind,
+      unit: tool.unit,
+      period: INSTANT_AS_OF,
+    },
+  });
+}
+
 function proxyFormula(spec) {
   const inputFactId = spec.authorship_request.candidate_input_fact_types[0];
   const outputId = spec.authorship_request.candidate_output_fact_types[0];
@@ -186,11 +311,12 @@ function proxyFormula(spec) {
 }
 
 /** Create one explicitly non-reviewed derived proxy and its immutable local-test evidence. */
-export function deriveSoloTestFormula(entry, physicalCandidate) {
+export function deriveSoloTestFormula(entry, physicalCandidate, authored = null) {
   if (physicalCandidate.formula_spec_id !== entry.formula_spec.formula_spec_id) {
     fail(`${entry.tool_id}: physical candidate identity does not match the current queue`);
   }
-  const formula = proxyFormula(physicalCandidate);
+  const written = authoredFormula(physicalCandidate, authored);
+  const formula = written || proxyFormula(physicalCandidate);
   const derivationSpec = canonicalValue({
     schema_version: 1,
     artifact_kind: "persona_v3_provisional_formula_derivation_spec",
@@ -201,7 +327,9 @@ export function deriveSoloTestFormula(entry, physicalCandidate) {
     prototype_id: entry.prototype_id,
     prototype_content_hash: entry.source_prototype.content_hash,
     authoring_candidate_hash: sha256(physicalCandidate),
-    derivation_policy: "first_declared_input_to_first_declared_output_identity_v1",
+    derivation_policy: written
+      ? "ai_authored_method_formula_v1"
+      : "first_declared_input_to_first_declared_output_identity_v1",
     input_contract_source: CANONICAL_SOLO_TEST_FACT_CONTRACTS[formula.inputs[0].operand.fact_id]
       ? "grounding_adapter_canonical_contract_v1"
       : "unknown_fact_fail_closed_proxy_scalar_v1",
@@ -222,8 +350,15 @@ export function deriveSoloTestFormula(entry, physicalCandidate) {
     derivation_spec: derivationSpec,
     derivation_spec_hash: derivationSpecHash,
     limitations: [
-      "mechanical_identity_proxy_not_the_named_investor_method",
-      "first_declared_input_and_output_are_test_contract_choices_not_human_adjudication",
+      ...(written
+        ? [
+          "ai_authored_candidate_formula_not_human_reviewed",
+          "thresholds_are_derived_from_published_method_writing_not_adjudicated",
+        ]
+        : [
+          "mechanical_identity_proxy_not_the_named_investor_method",
+          "first_declared_input_and_output_are_test_contract_choices_not_human_adjudication",
+        ]),
       ...(derivationSpec.input_contract_source === "unknown_fact_fail_closed_proxy_scalar_v1"
         ? ["unknown_fact_proxy_scalar_unit_requires_a_local_test_adapter"]
         : []),
@@ -280,7 +415,7 @@ export function planSoloTestFormulaCompilation({
   )).sort();
   const actualSpecFiles = collectFiles(resolve(candidate, "specs"));
   if (JSON.stringify(actualSpecFiles) !== JSON.stringify(expectedSpecFiles)) {
-    fail("solo formula compilation requires exactly the 52 planned pending spec files", {
+    fail("solo formula compilation requires exactly the planned pending spec files, one per tool", {
       expected: expectedSpecFiles,
       actual: actualSpecFiles,
     });
@@ -294,14 +429,21 @@ export function planSoloTestFormulaCompilation({
 
   const records = authoring.inventory.entries.map((entry) => {
     const spec = exactPendingCandidate(entry, candidate);
-    const derived = deriveSoloTestFormula(entry, spec);
+    const derived = deriveSoloTestFormula(entry, spec, authoredMethods[entry.persona_id] || null);
     return { entry, ...derived };
   });
   const tools = records.map((record) => record.tool);
   const ids = tools.map((tool) => tool.id);
   const outputs = tools.map((tool) => tool.output_id);
-  if (tools.length !== 52 || new Set(ids).size !== 52 || new Set(outputs).size !== 52) {
-    fail("solo formula compilation must produce 52 unique tools and outputs", {
+  // Derived from the authoring inventory rather than hardcoded, so a seat may declare a third
+  // tool without the guard reading it as drift. The property that matters is unchanged: one
+  // tool per planned entry, no id or output silently collapsing into another.
+  const expectedToolCount = authoring.inventory.entries.length;
+  if (tools.length !== expectedToolCount
+    || new Set(ids).size !== expectedToolCount
+    || new Set(outputs).size !== expectedToolCount) {
+    fail("solo formula compilation must produce one unique tool and output per planned entry", {
+      expected: expectedToolCount,
       tool_count: tools.length,
       unique_tool_count: new Set(ids).size,
       unique_output_count: new Set(outputs).size,
@@ -329,7 +471,7 @@ export function planSoloTestFormulaCompilation({
     production_eligible: false,
     method_model_eligible: false,
     canonical_seat_count: CANONICAL_MASTER_COUNT,
-    planned_tool_count: 52,
+    planned_tool_count: PLANNED_TOOL_COUNT,
     compiled_tool_count: tools.length,
     provisional_derivation_count: records.length,
     formula_approval_binding_count: 0,
@@ -361,6 +503,25 @@ function writeStable(file, content, result) {
   result.written.push(file);
 }
 
+/** Delete every regular file under `root` the compilation did not just account for. */
+function pruneToWritten(root, keep) {
+  const removed = [];
+  const walk = (dir) => {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const path = resolve(dir, entry.name);
+      if (entry.isSymbolicLink()) fail(`unsafe solo formula entry: ${path}`);
+      if (entry.isDirectory()) {
+        walk(path);
+        if (!readdirSync(path).length) { rmSync(path, { recursive: false }); removed.push(path); }
+        continue;
+      }
+      if (!keep.has(path)) { rmSync(path); removed.push(path); }
+    }
+  };
+  walk(root);
+  return removed;
+}
+
 function evidenceLeaf(personaId, toolId) {
   const prefix = `${personaId}.`;
   if (!toolId.startsWith(prefix)) fail(`tool id is not prefixed by ${personaId}`);
@@ -414,6 +575,11 @@ export function writeSoloTestFormulaCompilation({
     bindings: plan.bindings,
   });
   writeStable(resolve(root, "compilation-manifest.json"), `${JSON.stringify(manifest, null, 2)}\n`, result);
+  // A tool that is renamed leaves its old evidence file behind, and the downstream review binds
+  // the tree by exact file list -- so debris from a previous compilation reads as tampering
+  // rather than as staleness. The compilation owns this tree entirely; anything it did not just
+  // write does not belong in it.
+  result.removed = pruneToWritten(root, new Set([...result.written, ...result.unchanged]));
   return Object.freeze(canonicalValue({
     ...manifest,
     mode: "write_isolated_solo_test_compilation",

package/scripts/lib/persona-v3-solo-test-packs.mjs

@@ -1,5 +1,5 @@
 /**
- * Deterministic builder for the packaged 26-seat solo-test PersonaPack v3 tree.
+ * Deterministic builder for the packaged solo-test PersonaPack v3 tree.
  *
  * This is intentionally a separate assurance channel. It consumes only the isolated
  * provisional formula tree, writes manifests with build_profile=solo_test, uses pending
@@ -7,6 +7,7 @@
  * loader rejects every output. Normal admission therefore remains operator_lens.
  */
 
+import { PLANNED_TOOL_COUNT } from "../../data/persona-v3-build-specs.v1.mjs";
 import {
   existsSync,
   lstatSync,
@@ -21,6 +22,12 @@ import { fileURLToPath } from "node:url";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 
 import buildInventory from "../../data/persona-v3-build-specs.v1.mjs";
+import { authoredMethods } from "../../data/authored/index.mjs";
+import {
+  selectorBestForLocale,
+  selectorMethodLocale,
+} from "../../data/master-selector-method-locales.v1.mjs";
+import { selectorCard } from "../../mcp/lib/master-catalog.mjs";
 import { inspectPersonaAdmission } from "../../mcp/lib/personas-v3/admission.mjs";
 import {
   canonicalValue,
@@ -156,7 +163,7 @@ function loadFormulaTree(formulaRoot) {
   const errors = [];
   if (manifest.schema_version !== 1) errors.push("schema_version must be 1");
   if (manifest.artifact_kind !== "persona_v3_solo_test_formula_staging_tree") errors.push("artifact_kind is invalid");
-  if (manifest.canonical_seat_count !== 26 || manifest.compiled_tool_count !== 52) errors.push("manifest must bind exactly 26 seats and 52 tools");
+  if (manifest.canonical_seat_count !== CANONICAL_MASTER_COUNT || manifest.compiled_tool_count !== PLANNED_TOOL_COUNT) errors.push(`manifest must bind exactly ${CANONICAL_MASTER_COUNT} seats and ${PLANNED_TOOL_COUNT} tools`);
   if (manifest.assurance_class !== SOLO_TEST_ASSURANCE_CLASS) errors.push("assurance_class must be provisional_derived_proxy");
   if (manifest.review_status !== "not_human_reviewed") errors.push("review_status must be not_human_reviewed");
   if (manifest.production_eligible !== false || manifest.method_model_eligible !== false) errors.push("formula tree must be production/method-model ineligible");
@@ -188,7 +195,7 @@ function loadFormulaTree(formulaRoot) {
   if (JSON.stringify(actualSeatEntries) !== JSON.stringify([...CANONICAL_MASTER_IDS].sort())) {
     fail("formula tree contains missing or unexpected top-level entries", { actual: actualSeatEntries });
   }
-  if (total !== 52) fail(`formula tree compiled ${total} tools instead of 52`);
+  if (total !== PLANNED_TOOL_COUNT) fail(`formula tree compiled ${total} tools instead of ${PLANNED_TOOL_COUNT}`);
   return { root, manifest, byPersona };
 }
 
@@ -291,6 +298,103 @@ function bindProxySource(tools, sourceId) {
   });
 }
 
+/**
+ * A seat's real decision logic, when it has been authored.
+ *
+ * The generated fallback below scores every tool output against zero, which is executable and
+ * says nothing: it exists so the pipeline runs before a method is written. An authored policy
+ * replaces it with the seat's own judgement -- what it needs before it will speak at all
+ * (eligibility), what disqualifies a candidate outright (hard vetoes), and what it actually
+ * measures (scoring).
+ *
+ * The distinction between eligibility and scoring matters more than it looks. `min_coverage`
+ * is 1, so ONE uncomputable scoring rule collapses the whole seat to out_of_scope. That is
+ * precisely why twenty-five seats abstained on every symbol. A "can this method speak at all"
+ * test therefore belongs in eligibility, which has its own exit and its own explanation.
+ */
+function authoredDecisionPolicy(seat, tools, authored) {
+  if (!authored?.scoring?.length || !authored?.bands?.length) return null;
+  const declaredStates = new Set(seat.native_decision_contract.states.map(executableNativeState));
+  const state = (value) => {
+    const resolved = executableNativeState(value);
+    if (!declaredStates.has(resolved)) {
+      fail(`${seat.persona_id}: authored policy uses undeclared native state ${JSON.stringify(value)}`, {
+        declared: [...declaredStates],
+      });
+    }
+    return resolved;
+  };
+  const outOfScopeHypothesis = seat.native_decision_contract.states
+    .find((candidate) => stanceForState(candidate) === "out_of_scope") || seat.native_decision_contract.states[0];
+  const outOfScope = executableNativeState(outOfScopeHypothesis);
+  const maxScore = authored.scoring.reduce((sum, rule) => sum + (rule.points || 0), 0);
+  return canonicalValue({
+    schema_version: 1,
+    dsl_version: "1.1",
+    native_decision_schema: seat.native_decision_contract.schema_id,
+    native_states: seat.native_decision_contract.states.map(executableNativeState),
+    abstention_policy: "fail_closed",
+    fact_gate: { on_missing_critical: { native_state: outOfScope, common_stance: "out_of_scope" } },
+    // Authoring supplies the judgement; the build supplies identity. Source ids are minted
+    // here because the loader rejects a source id that is not in the pack, and native states
+    // are mapped here because the authored form uses the raw name a build spec declares.
+    eligibility: {
+      all: (authored.eligibility?.all || []).map((entry) => ({
+        condition_id: entry.condition_id,
+        condition: entry.condition,
+        on_false: {
+          native_state: state(entry.on_false.native_state),
+          common_stance: entry.on_false.common_stance,
+        },
+        on_uncomputable: {
+          native_state: state((entry.on_uncomputable || entry.on_false).native_state),
+          common_stance: (entry.on_uncomputable || entry.on_false).common_stance,
+        },
+        source_ids: [authored.source_id],
+      })),
+    },
+    hard_vetoes: (authored.hard_vetoes || []).map((veto) => ({
+      veto_id: veto.veto_id,
+      condition: veto.condition,
+      on_trigger: {
+        native_state: state(veto.on_trigger.native_state),
+        common_stance: veto.on_trigger.common_stance,
+      },
+      // A veto whose condition cannot be evaluated must not read as "not triggered". An
+      // unmeasurable disqualifier is a reason to abstain, not a reason to proceed.
+      on_uncomputable: {
+        action: "abstain",
+        decision: {
+          native_state: state(veto.on_uncomputable?.native_state || outOfScopeHypothesis),
+          common_stance: veto.on_uncomputable?.common_stance || "out_of_scope",
+        },
+      },
+      source_ids: [authored.source_id],
+    })),
+    scoring: {
+      max_score: maxScore,
+      min_coverage: 1,
+      on_insufficient_coverage: { native_state: outOfScope, common_stance: "out_of_scope" },
+      rules: authored.scoring.map((rule) => ({
+        rule_id: rule.rule_id,
+        condition: rule.condition,
+        points: rule.points,
+        coverage_weight: rule.coverage_weight ?? 1,
+        source_ids: [authored.source_id],
+      })),
+    },
+    score_bands: authored.bands.map((band) => ({
+      min_ratio: band.min_ratio,
+      decision: { native_state: state(band.native_state), common_stance: band.common_stance },
+    })),
+    native_output_fields: tools.map((tool, index) => ({
+      field: `metric_${index + 1}`,
+      value: { output_id: tool.output_id },
+      on_missing: "fail",
+    })),
+  });
+}
+
 function buildDecisionPolicy(seat, tools, sourceId) {
   const stateHypotheses = seat.native_decision_contract.states;
   const states = stateHypotheses.map(executableNativeState);
@@ -368,7 +472,9 @@ function buildDocuments({ seat, blueprint, rawTools, packVersion, formulaManifes
   const required = referencedFacts;
   const optional = seat.required_fact_types.filter((fact) => !required.includes(fact));
   if (!required.length) fail(`${seat.persona_id}: formula tools have no physical fact inputs`);
-  const policy = buildDecisionPolicy(seat, tools, source.source_id);
+  const authored = authoredMethods[seat.persona_id] || null;
+  const policy = authoredDecisionPolicy(seat, tools, authored ? { ...authored, source_id: source.source_id } : null)
+    || buildDecisionPolicy(seat, tools, source.source_id);
   const policyErrors = validateDeterministicPolicyArtifacts({
     policy,
     tools,
@@ -381,14 +487,26 @@ function buildDocuments({ seat, blueprint, rawTools, packVersion, formulaManifes
   if (policyErrors.length) fail(`${seat.persona_id}: generated deterministic policy is invalid`, { errors: policyErrors });
 
   const publicTitle = blueprint.canonical_title;
+  const selectorPersona = { id: seat.persona_id, title: publicTitle };
+  const chineseMethod = selectorCard(selectorPersona, "zh-CN").method;
   const manifest = canonicalValue({
     schema_version: 3,
     build_profile: "solo_test",
     pack_version: packVersion,
     identity: {
       persona_id: seat.persona_id,
-      public_label: { en: `${publicTitle.en} Solo Test`, zh: `${publicTitle.zh}单人测试` },
-      operator_label: { en: `${publicTitle.en} Provisional Operator Lens`, zh: `${publicTitle.zh}临时操作视角` },
+      public_label: {
+        en: `${publicTitle.en} Solo Test`,
+        zh: `${publicTitle.zh}单人测试`,
+        ja: `${publicTitle.en} 単独テスト`,
+        ko: `${publicTitle.en} 단독 테스트`,
+      },
+      operator_label: {
+        en: `${publicTitle.en} Provisional Operator Lens`,
+        zh: `${publicTitle.zh}临时操作视角`,
+        ja: `${publicTitle.en} 暫定オペレーター・レンズ`,
+        ko: `${publicTitle.en} 임시 오퍼레이터 렌즈`,
+      },
       maturity: "operator_lens",
       source_cutoff: SOURCE_DATE,
     },
@@ -396,11 +514,20 @@ function buildDocuments({ seat, blueprint, rawTools, packVersion, formulaManifes
       identity: {
         en: `${publicTitle.en}; project-derived and not human reviewed`,
         zh: `${publicTitle.zh}；项目派生、未经人工审定`,
+        ja: `${publicTitle.en}。プロジェクト派生で、方法帰属について人による審査を受けていない暫定オペレーター・レンズ。本人の発言や現在の見解ではない。`,
+        ko: `${publicTitle.en}. 프로젝트에서 파생되었고 방법 귀속에 대한 인적 심사를 거치지 않은 임시 오퍼레이터 렌즈다. 본인의 발언이나 현재 견해가 아니다.`,
+      },
+      method: {
+        en: seat.method_scope.planning_hypothesis,
+        zh: chineseMethod,
+        ja: selectorMethodLocale(seat.persona_id, "ja"),
+        ko: selectorMethodLocale(seat.persona_id, "ko"),
       },
-      method: { en: seat.method_scope.planning_hypothesis, zh: seat.method_scope.planning_hypothesis },
       best_for: {
-        en: `Testing deterministic behavior in ${seat.method_scope.applicable_domains.join(", ")}`,
-        zh: `用于测试确定性行为：${seat.method_scope.applicable_domains.join("、")}`,
+        en: selectorBestForLocale(seat.persona_id, "en"),
+        zh: selectorBestForLocale(seat.persona_id, "zh"),
+        ja: selectorBestForLocale(seat.persona_id, "ja"),
+        ko: selectorBestForLocale(seat.persona_id, "ko"),
       },
     },
     capability: {
@@ -499,7 +626,7 @@ function generationContext({ root = DEFAULT_SOLO_TEST_PACK_ROOT, formulaRoot = D
   const blueprints = canonicalMasterBlueprints({ personaDir });
   const byBlueprint = new Map(blueprints.map((blueprint) => [blueprint.persona_id, blueprint]));
   const bySeat = new Map(buildInventory.seats.map((seat) => [seat.persona_id, seat]));
-  if (bySeat.size !== 26 || byBlueprint.size !== 26) fail("canonical solo-test inventory must contain exactly 26 unique seats");
+  if (bySeat.size !== CANONICAL_MASTER_COUNT || byBlueprint.size !== CANONICAL_MASTER_COUNT) fail(`canonical solo-test inventory must contain exactly ${CANONICAL_MASTER_COUNT} unique seats`);
   const output = resolve(root);
   if (basename(output) !== "masters" || basename(dirname(output)) !== "solo-test") {
     fail("solo-test pack root must end in knowledge/solo-test/masters (or an equivalent isolated solo-test/masters path)");
@@ -661,12 +788,12 @@ export function renderPersonaV3SoloTestPackReport(report) {
     "",
     "> These are packaged provisional operator lenses. They are not approved method models and the production loader rejects them.",
     "",
-    `Physical packs: ${report.summary.physical_pack_count}/26`,
-    `Solo loader valid: ${report.summary.solo_loader_valid_count}/26`,
-    `Compiled: ${report.summary.compiler_valid_count}/26`,
-    `Provisional operator lenses: ${report.summary.provisional_operator_lens_count}/26`,
-    `Production loader rejected: ${report.summary.production_loader_rejection_count}/26`,
-    `Tools: ${report.summary.tool_count}/52`,
+    `Physical packs: ${report.summary.physical_pack_count}/${CANONICAL_MASTER_COUNT}`,
+    `Solo loader valid: ${report.summary.solo_loader_valid_count}/${CANONICAL_MASTER_COUNT}`,
+    `Compiled: ${report.summary.compiler_valid_count}/${CANONICAL_MASTER_COUNT}`,
+    `Provisional operator lenses: ${report.summary.provisional_operator_lens_count}/${CANONICAL_MASTER_COUNT}`,
+    `Production loader rejected: ${report.summary.production_loader_rejection_count}/${CANONICAL_MASTER_COUNT}`,
+    `Tools: ${report.summary.tool_count}/${PLANNED_TOOL_COUNT}`,
     `Operational/method_model: ${report.summary.operational_count}/0`,
     `Ready for solo testing: ${report.summary.ready_for_solo_testing}`,
     `Readiness hash: \`${report.readiness_hash}\``,

package/scripts/package-smoke.mjs

@@ -8,6 +8,7 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { CANONICAL_MASTER_COUNT } from "../mcp/lib/personas-v3/staging.mjs";
 
 const root = fileURLToPath(new URL("..", import.meta.url));
 const serverEntry = join(root, "mcp", "server.mjs");
@@ -107,19 +108,38 @@ export async function runPackageSmoke() {
 
     const listed = await server.request("tools/list", {});
     const tools = listed.result?.tools || [];
+    assert.equal(tools.length, 31, "installed server must expose exactly 31 MCP tools");
     const names = new Set(tools.map((tool) => tool.name));
     for (const required of ["begin_council_selection", "confirm_master_selection", "plan_visible_run", "analyze_symbol"]) {
       assert.ok(names.has(required), `installed server is missing ${required}`);
     }
 
-    const prompt = "bounded installed-package smoke";
-    const opened = structured(await server.callTool("begin_council_selection", {
-      symbol: "AAPL",
-      language: "English",
-      host: "package-smoke",
-      prompt,
-    }));
-    assert.equal(opened.masters.length, 26, "installed catalog must contain exactly 26 seats");
+    const localeCases = [
+      { language: "en-US", prompt: "bounded installed-package smoke", script: /[A-Za-z]/u },
+      { language: "zh-CN", prompt: "安装包有界烟雾测试", script: /\p{Script=Han}/u },
+      { language: "ja-JP", prompt: "インストール済みパッケージの有界スモークテスト", script: /[\p{Script=Hiragana}\p{Script=Katakana}]/u },
+      { language: "ko-KR", prompt: "설치 패키지의 제한된 스모크 테스트", script: /\p{Script=Hangul}/u },
+    ];
+    let opened;
+    let prompt;
+    for (const locale of localeCases) {
+      const catalog = structured(await server.callTool("begin_council_selection", {
+        symbol: "AAPL",
+        language: locale.language,
+        host: "package-smoke",
+        prompt: locale.prompt,
+      }));
+      assert.equal(catalog.masters.length, CANONICAL_MASTER_COUNT, `${locale.language} installed catalog must contain exactly ${CANONICAL_MASTER_COUNT} seats`);
+      for (const master of catalog.masters) {
+        for (const field of ["identity", "method", "best_for", "maturity_label"]) {
+          assert.match(master[field], locale.script, `${locale.language} ${master.id}.${field}`);
+        }
+      }
+      if (locale.language === "zh-CN") {
+        opened = catalog;
+        prompt = locale.prompt;
+      }
+    }
 
     const confirmed = structured(await server.callTool("confirm_master_selection", {
       selection_id: opened.selection_id,
@@ -132,7 +152,7 @@ export async function runPackageSmoke() {
     const runId = `PACKAGE-SMOKE-${process.pid}`;
     const planned = structured(await server.callTool("plan_visible_run", {
       symbol: "AAPL",
-      language: "English",
+      language: "zh-CN",
       prompt,
       run_id: runId,
       tasks: ["market_data"],
@@ -143,7 +163,7 @@ export async function runPackageSmoke() {
 
     const replay = await server.callTool("plan_visible_run", {
       symbol: "AAPL",
-      language: "English",
+      language: "zh-CN",
       prompt,
       run_id: `${runId}-REPLAY`,
       tasks: ["market_data"],
@@ -152,8 +172,8 @@ export async function runPackageSmoke() {
     });
     assert.equal(replay.error?.data?.reason, "MASTER_SELECTION_REPLAYED");
 
-    process.stdout.write(`package-smoke: passed tools=${tools.length} catalog=26 selected=1 replay_rejected=true\n`);
-    return { tools: tools.length, catalog: 26, selected: 1, replay_rejected: true };
+    process.stdout.write(`package-smoke: passed tools=${tools.length} catalog=26 locales=4 selected=1 replay_rejected=true\n`);
+    return { tools: tools.length, catalog: 26, locales: 4, selected: 1, replay_rejected: true };
   } finally {
     if (!server.child.killed) await server.close().catch(() => server.child.kill());
     rmSync(dataDir, { recursive: true, force: true });

package/scripts/report-persona-corpus-gaps.mjs

@@ -6,6 +6,7 @@
  * Gaps are expected and do not make the command fail; malformed physical artifacts do.
  */
 
+import { CANONICAL_MASTER_COUNT } from "../mcp/lib/personas-v3/staging.mjs";
 import { fileURLToPath } from "node:url";
 import { join, resolve } from "node:path";
 import { loadPersonas, defaultPersonaDir } from "../mcp/lib/personas/registry.mjs";
@@ -22,7 +23,9 @@ import {
   inspectPersonaAdmission,
 } from "../mcp/lib/personas-v3/admission.mjs";
 
-export const CANONICAL_MASTER_COUNT = 26;
+// Re-exported rather than redeclared: two independent copies of the seat count is how a
+// roster change passes one gate and fails another.
+export { CANONICAL_MASTER_COUNT } from "../mcp/lib/personas-v3/staging.mjs";
 
 function invalidResult(personaId, promptPresent, error) {
   const counts = {};