alphacouncil-agent 0.9.4 → 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,7 @@ 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,
@@ -161,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");
@@ -193,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 };
 }
 
@@ -296,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);
@@ -373,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,
@@ -525,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)");
@@ -687,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");
@@ -128,7 +129,7 @@ export async function runPackageSmoke() {
         host: "package-smoke",
         prompt: locale.prompt,
       }));
-      assert.equal(catalog.masters.length, 26, `${locale.language} installed catalog must contain exactly 26 seats`);
+      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}`);

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 = {};

package/scripts/review-persona-v3-solo-formulas.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-/** Build or verify the isolated 52-tool AI-assisted formula cross-review tree. */
+/** Build or verify the isolated AI-assisted formula cross-review tree. */
 
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -11,6 +11,10 @@ import {
   writeAIFormulaCrossReviews,
 } from "./lib/persona-v3-ai-formula-review.mjs";
 import { DEFAULT_SOLO_TEST_FORMULA_ROOT } from "./lib/persona-v3-solo-formula-pipeline.mjs";
+import { PLANNED_TOOL_COUNT } from "../data/persona-v3-build-specs.v1.mjs";
+
+/** The review profile gives every tool three independent machine roles. */
+const INDEPENDENT_ROLES_PER_REVIEW = 3;
 
 export function parseArgs(argv) {
   const args = {
@@ -57,13 +61,13 @@ function compact(result) {
   return [
     "persona-v3-ai-formula-review:",
     `mode=${result.mode || "plan_ai_formula_cross_reviews"}`,
-    `reviews=${result.review_count}/52`,
-    `roles=${result.role_count}/156`,
+    `reviews=${result.review_count}/${PLANNED_TOOL_COUNT}`,
+    `roles=${result.role_count}/${PLANNED_TOOL_COUNT * INDEPENDENT_ROLES_PER_REVIEW}`,
     `vectors=${result.test_vector_count}`,
     `invariants=${result.invariant_count}`,
-    `mechanical_pass=${result.mechanical_pass_count}/52`,
+    `mechanical_pass=${result.mechanical_pass_count}/${PLANNED_TOOL_COUNT}`,
     `disagreements=${result.disagreement_count}`,
-    `semantic_unknown=${result.semantic_unknown_count}/52`,
+    `semantic_unknown=${result.semantic_unknown_count}/${PLANNED_TOOL_COUNT}`,
     `human_reviewers=${result.human_reviewer_count}`,
     `approvals=${result.approval_count}`,
     `production_eligible=${result.production_eligible}`,
@@ -88,11 +92,11 @@ export function main(argv = process.argv.slice(2)) {
   }
   if (args.json) process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
   else process.stdout.write(compact(result));
-  const okay = result.review_count === 52
+  const okay = result.review_count === PLANNED_TOOL_COUNT
     && result.role_count === 156
-    && result.mechanical_pass_count === 52
+    && result.mechanical_pass_count === PLANNED_TOOL_COUNT
     && result.disagreement_count === 0
-    && result.semantic_unknown_count === 52
+    && result.semantic_unknown_count === PLANNED_TOOL_COUNT
     && result.human_reviewer_count === 0
     && result.approval_count === 0
     && result.production_eligible === false;

package/scripts/scaffold-persona-v3-staging.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-/** Create only missing PersonaPack v3 staging artifacts, then validate the full 26-seat tree. */
+/** Create only missing PersonaPack v3 staging artifacts, then validate the full staging tree. */
 
 import { fileURLToPath } from "node:url";
 import { resolve } from "node:path";

package/skills/agent-skills-governance/SKILL.md

@@ -37,7 +37,9 @@ Before giving a final investment answer, all gates below must be satisfied:
    when at least two completed and every failed role has a recorded diagnostic/data gap.
 5. Source gate: every material claim maps to scoped source IDs like `<task>:S1`; never cite bare `S1`.
 6. Master gate: every master named in the confirmed receipt has either reported or produced
-   a deterministic `out_of_scope` result. An unexecuted selected seat keeps the run incomplete.
+   a deterministic `out_of_scope` result, every result has a readable final statement, and
+   every stable ID appears in the published Master Bench. An unexecuted or hidden selected
+   seat keeps the run incomplete or `needs_revision`.
 7. Debate gate: full requires all three bull/bear rounds, exact round-3 Q&A and PM. Quick
    requires one parallel statement round and PM; one degraded side is allowed only if the
    other side and PM completed, while two degraded sides or PM failure is incomplete.
@@ -53,7 +55,9 @@ Before giving a final investment answer, all gates below must be satisfied:
     winner, confidence, valuation/position, material gaps and saved file locations. Full
     also carries forward setup and invalidations. Quick names all four analyst statuses,
     selected method IDs/stances, dated recent company/industry news, every degraded item,
-    and that it is not equivalent to full council.
+    and that it is not equivalent to full council. Full handoff ends with the exact selected
+    seat count and every per-seat method statement; use returned `user_response_markdown`
+    rather than an ACK-only recap.
 12. Deadline gate: plugin-managed quick uses headless `analyze_symbol`; `plan_visible_run`
     quick is rejected. Never extend its end-to-end deadline above 600000 ms or silently
     omit work to appear complete.
@@ -73,6 +77,8 @@ Before giving a final investment answer, all gates below must be satisfied:
 | "Quick report quality passed, so full passed." | Keep `full_council_equivalent=false`; only `quick_v1` passed. |
 | "The ten-minute clock expired, so skip a seat quietly." | Return the exact degraded/incomplete ledger; never extend the ceiling or invent evidence. |
 | "The master said this." | Call it a recorded method-seat result, never a quote from the named person. |
+| "The PM ACK says complete, so I can summarize it." | Deliver the returned `user_response_markdown`; the final per-seat section is part of the contract. |
+| "QQQ has an SEC CIK, so the company screen applies." | Classify first. ETF/fund/index company financial routes are not applicable; require look-through or aggregate evidence. |
 
 ## Exit Criteria