2sagaco48 1.0.0

package/src/lib/gbse/engine.ts

@@ -0,0 +1,226 @@
+// BeliefSearch — TypeScript port of the Python orchestrator.
+// Log-odds evidence accumulation + Wald SPRT stopping + bounded coupling.
+
+import {
+  Verdict,
+  SPRTDecision,
+  type Evidence,
+  type Hypothesis,
+  type BeliefState,
+  type EngineConfig,
+  type EvidenceConfig,
+  type SPRTConfig,
+} from "./types";
+import { sprtUpper, sprtLower } from "./config";
+
+// --- pure helpers -----------------------------------------------------------
+
+function clamp(x: number, lo: number, hi: number): number {
+  return Math.max(lo, Math.min(hi, x));
+}
+
+function hashStr(s: string): string {
+  let h = 2166136261 >>> 0;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h.toString(16).padStart(8, "0");
+}
+
+export function llr(ev: Evidence, cfg: EvidenceConfig): number {
+  const mag = cfg.llrCap * ev.reliability * ev.strength;
+  if (ev.verdict === Verdict.SUPPORT) return +mag;
+  if (ev.verdict === Verdict.REFUTE) return -mag;
+  return 0;
+}
+
+export function sprtDecision(leaderLogw: number, runnerUpLogw: number, cfg: SPRTConfig): SPRTDecision {
+  const v = leaderLogw - runnerUpLogw;
+  if (v >= sprtUpper(cfg)) return SPRTDecision.ACCEPT;
+  if (v <= sprtLower(cfg)) return SPRTDecision.REJECT;
+  return SPRTDecision.CONTINUE;
+}
+
+export function posterior(st: BeliefState): Record<string, number> {
+  const live = Object.values(st.hyps).filter((h) => h.alive);
+  if (live.length === 0) return {};
+  const m = Math.max(...live.map((h) => h.logw));
+  const exps: Record<string, number> = {};
+  let z = 0;
+  for (const h of live) {
+    const e = Math.exp(h.logw - m);
+    exps[h.hid] = e;
+    z += e;
+  }
+  if (z === 0) return {};
+  const out: Record<string, number> = {};
+  for (const [k, v] of Object.entries(exps)) out[k] = v / z;
+  return out;
+}
+
+export function entropy(st: BeliefState): number {
+  const p = posterior(st);
+  const vals = Object.values(p);
+  if (vals.length <= 1) return 0;
+  let h = 0;
+  for (const v of vals) if (v > 0) h += -v * Math.log2(v);
+  return h / Math.log2(vals.length);
+}
+
+export function ranked(st: BeliefState): Array<[string, number]> {
+  return Object.entries(posterior(st)).sort((a, b) => b[1] - a[1]);
+}
+
+export function countSupportingSources(h: Hypothesis): number {
+  const s = new Set<string>();
+  for (const e of h.evidence) if (e.verdict === Verdict.SUPPORT) s.add(e.sourceId);
+  return s.size;
+}
+
+// --- state construction -----------------------------------------------------
+
+export function newState(texts: string[], priors: number[] | null, cfg: EngineConfig): BeliefState {
+  if (texts.length === 0) throw new Error("need at least one hypothesis");
+  const ps = priors ?? texts.map(() => 0.5);
+  if (ps.length !== texts.length) throw new Error("priors length must match texts length");
+  const cap = cfg.evidence.maxPriorLogOdds;
+  const sid = hashStr(texts.join("|")).slice(0, 16);
+  const hyps: Record<string, Hypothesis> = {};
+  texts.forEach((t, i) => {
+    const pr = clamp(ps[i], 1e-3, 1 - 1e-3);
+    const logw = clamp(Math.log(pr / (1 - pr)), -cap, cap);
+    const hid = `H${String(i).padStart(2, "0")}_${hashStr(t).slice(0, 6)}`;
+    hyps[hid] = {
+      hid,
+      text: t,
+      logw,
+      alive: true,
+      evidence: [],
+      coupled: {},
+      anchorVerdict: Verdict.SILENT,
+      anchorConfidence: 0,
+      spentTokens: 0,
+    };
+  });
+  return {
+    sid,
+    hyps,
+    committed: null,
+    commitReason: "",
+    spentTokens: 0,
+    createdAt: Date.now() / 1000,
+  };
+}
+
+export function couple(st: BeliefState, a: string, b: string, strength: number, cfg: EngineConfig): void {
+  if (!(a in st.hyps) || !(b in st.hyps)) throw new Error("both hypotheses must exist");
+  const s = clamp(strength, 0, cfg.evidence.couplingCap);
+  st.hyps[a].coupled[b] = s;
+  st.hyps[b].coupled[a] = s;
+}
+
+// --- evidence application ---------------------------------------------------
+
+export function applyEvidence(st: BeliefState, hid: string, ev: Evidence, cfg: EngineConfig): BeliefState {
+  if (st.committed) return st;
+  const h = st.hyps[hid];
+  if (!h || !h.alive) return st;
+
+  const delta = llr(ev, cfg.evidence);
+  h.logw += delta;
+  h.evidence.push(ev);
+  h.spentTokens += ev.tokenCost;
+  st.spentTokens += ev.tokenCost;
+
+  for (const [otherId, c] of Object.entries(h.coupled)) {
+    const o = st.hyps[otherId];
+    if (o && o.alive) o.logw += c * delta;
+  }
+
+  prune(st, cfg);
+  maybeCommit(st, cfg);
+  enforceBudget(st, cfg);
+  return st;
+}
+
+export function setAnchor(st: BeliefState, hid: string, verdict: Verdict, confidence: number, cfg: EngineConfig): void {
+  const h = st.hyps[hid];
+  if (!h) return;
+  h.anchorVerdict = verdict;
+  h.anchorConfidence = confidence;
+  if (verdict === Verdict.SUPPORT || verdict === Verdict.REFUTE) {
+    applyEvidence(
+      st,
+      hid,
+      {
+        sourceId: "anchor",
+        text: "verified-knowledge anchor",
+        verdict,
+        reliability: confidence,
+        strength: 0.6,
+        tokenCost: 0,
+        ts: Date.now(),
+      },
+      cfg,
+    );
+  }
+}
+
+function prune(st: BeliefState, cfg: EngineConfig): void {
+  const post = posterior(st);
+  const liveCount = () => Object.values(st.hyps).filter((h) => h.alive).length;
+  for (const [hid, p] of Object.entries(post)) {
+    if (p < cfg.pruneFloor && liveCount() > 1) {
+      st.hyps[hid].alive = false;
+    }
+  }
+}
+
+function maybeCommit(st: BeliefState, cfg: EngineConfig): void {
+  if (st.committed) return;
+  const r = ranked(st);
+  if (r.length < 1) return;
+  const [leaderHid] = r[0];
+  const leader = st.hyps[leaderHid];
+  const runnerLogw = r.length > 1 ? st.hyps[r[1][0]].logw : leader.logw - 1e9;
+  const decision = sprtDecision(leader.logw, runnerLogw, cfg.sprt);
+  const marginOk = (r[0][1] - (r[1]?.[1] ?? 0)) >= cfg.collapseMargin;
+  const sourcesOk = countSupportingSources(leader) >= cfg.sprt.minSupportingSources;
+
+  if (decision === SPRTDecision.ACCEPT && marginOk && sourcesOk) {
+    commit(st, leaderHid, "sprt_accept");
+  } else if (decision === SPRTDecision.REJECT) {
+    leader.alive = false;
+  }
+}
+
+function enforceBudget(st: BeliefState, cfg: EngineConfig): void {
+  if (st.committed) return;
+  if (st.spentTokens >= cfg.maxTokens) {
+    const r = ranked(st);
+    if (r.length > 0) commit(st, r[0][0], "budget_exhausted");
+  } else if (Date.now() / 1000 - st.createdAt >= cfg.maxSeconds) {
+    const r = ranked(st);
+    if (r.length > 0) commit(st, r[0][0], "time_exhausted");
+  }
+}
+
+function commit(st: BeliefState, hid: string, reason: string): void {
+  st.committed = hid;
+  st.commitReason = reason;
+  for (const k of Object.keys(st.hyps)) if (k !== hid) st.hyps[k].alive = false;
+}
+
+export function forceCommit(st: BeliefState): string | null {
+  if (!st.committed) {
+    const r = ranked(st);
+    if (r.length === 0) return null;
+    commit(st, r[0][0], "forced");
+  }
+  return st.committed;
+}
+
+export function isContested(st: BeliefState): boolean {
+  return ["budget_exhausted", "time_exhausted", "forced"].includes(st.commitReason);
+}

package/src/lib/gbse/graph.ts

@@ -0,0 +1,118 @@
+// Signed Personalized PageRank relevance pre-ranker.
+// O(N^2) per iteration; converges for restart_prob > 0.
+import type { GraphConfig } from "./types";
+
+export interface GraphNode {
+  nid: string;
+  label: string;
+  confidence: number;
+}
+export interface GraphEdge {
+  src: string;
+  dst: string;
+  signedWeight: number;
+}
+
+export class RelevanceGraph {
+  cfg: GraphConfig;
+  nodes: Map<string, GraphNode> = new Map();
+  edges: GraphEdge[] = [];
+  private idx: Map<string, number> = new Map();
+  private dirty = true;
+
+  constructor(cfg: GraphConfig) {
+    this.cfg = cfg;
+  }
+
+  addNode(nid: string, label: string, confidence = 0.5): void {
+    if (!this.nodes.has(nid)) {
+      if (this.nodes.size >= this.cfg.maxNodes) throw new Error("node budget exceeded");
+      this.nodes.set(nid, { nid, label, confidence });
+      this.dirty = true;
+    } else {
+      const n = this.nodes.get(nid)!;
+      n.confidence = Math.max(n.confidence, confidence);
+    }
+  }
+
+  addEdge(src: string, dst: string, signedWeight: number): void {
+    if (this.nodes.has(src) && this.nodes.has(dst) && src !== dst) {
+      this.edges.push({ src, dst, signedWeight });
+      this.dirty = true;
+    }
+  }
+
+  clear(): void {
+    this.nodes.clear();
+    this.edges = [];
+    this.idx.clear();
+    this.dirty = true;
+  }
+
+  private reindex(): void {
+    if (!this.dirty) return;
+    this.idx = new Map();
+    let i = 0;
+    for (const nid of this.nodes.keys()) this.idx.set(nid, i++);
+    this.dirty = false;
+  }
+
+  /** Returns flat NxN matrix in row-major order: m[j*N + i] = mass src(i) -> dst(j). */
+  private transitionMatrix(): { m: Float64Array; n: number } {
+    this.reindex();
+    const n = this.nodes.size;
+    const m = new Float64Array(n * n);
+    for (const e of this.edges) {
+      const i = this.idx.get(e.src)!;
+      const j = this.idx.get(e.dst)!;
+      m[j * n + i] += e.signedWeight;
+    }
+    // Column-normalize by absolute sum to keep operator bounded.
+    const colAbs = new Float64Array(n);
+    for (let j = 0; j < n; j++) {
+      for (let i = 0; i < n; i++) colAbs[i] += Math.abs(m[j * n + i]);
+    }
+    for (let i = 0; i < n; i++) if (colAbs[i] === 0) colAbs[i] = 1;
+    for (let j = 0; j < n; j++) {
+      for (let i = 0; i < n; i++) m[j * n + i] /= colAbs[i];
+    }
+    return { m, n };
+  }
+
+  /** Returns [{nid,label,score}] sorted desc. Score is a relevance ranking in [0,1] */
+  personalizedPageRank(queryNid: string): Array<{ nid: string; label: string; score: number }> {
+    this.reindex();
+    if (!this.idx.has(queryNid) || this.nodes.size === 0) return [];
+    const { m, n } = this.transitionMatrix();
+    const restart = new Float64Array(n);
+    restart[this.idx.get(queryNid)!] = 1.0;
+    let r = new Float64Array(restart);
+    const a = this.cfg.restartProb;
+    for (let it = 0; it < this.cfg.maxIters; it++) {
+      const next = new Float64Array(n);
+      // next = (1-a) * (m @ r) + a * restart
+      for (let j = 0; j < n; j++) {
+        let s = 0;
+        for (let i = 0; i < n; i++) s += m[j * n + i] * r[i];
+        next[j] = (1 - a) * s + a * restart[j];
+      }
+      // L1 diff
+      let d = 0;
+      for (let i = 0; i < n; i++) d += Math.abs(next[i] - r[i]);
+      r = next;
+      if (d < this.cfg.tolerance) break;
+    }
+    let maxAbs = 0;
+    for (let i = 0; i < n; i++) if (Math.abs(r[i]) > maxAbs) maxAbs = Math.abs(r[i]);
+    if (maxAbs === 0) maxAbs = 1;
+    const inv: string[] = new Array(n);
+    for (const [nid, i] of this.idx.entries()) inv[i] = nid;
+    const out = inv.map((nid, i) => ({
+      nid,
+      label: this.nodes.get(nid)!.label,
+      score: Math.abs(r[i]) / maxAbs,
+    }));
+    out.sort((a, b) => b.score - a.score);
+    return out;
+  }
+}

package/src/lib/gbse/graph.worker.ts

@@ -0,0 +1,21 @@
+import * as Comlink from "comlink";
+import { RelevanceGraph } from "./graph";
+import { type GraphConfig } from "./types";
+
+// Worker-side implementation of the Graph relevance calculation.
+// Keeps the UI thread responsive during O(N^2) PageRank iterations.
+const workerApi = {
+  calculateRelevance(
+    nodes: Array<{ nid: string; label: string; confidence: number }>,
+    edges: Array<{ src: string; dst: string; signedWeight: number }>,
+    cfg: GraphConfig,
+    queryNid: string
+  ) {
+    const g = new RelevanceGraph(cfg);
+    for (const n of nodes) g.addNode(n.nid, n.label, n.confidence);
+    for (const e of edges) g.addEdge(e.src, e.dst, e.signedWeight);
+    return g.personalizedPageRank(queryNid);
+  },
+};
+
+Comlink.expose(workerApi);

package/src/lib/gbse/tests.ts

@@ -0,0 +1,117 @@
+// Lightweight in-browser correctness suite. Returns pass/fail per test so the UI
+// can render a green/red panel proving the math properties live.
+
+import { Verdict, type EngineConfig, type Evidence } from "./types";
+import { defaultConfig } from "./config";
+import {
+  applyEvidence,
+  countSupportingSources,
+  newState,
+  posterior,
+  sprtDecision,
+} from "./engine";
+import { RelevanceGraph } from "./graph";
+
+export interface TestResult { name: string; pass: boolean; detail?: string; }
+
+function ev(src: string, v: Verdict, rel = 0.8, strength = 0.7, cost = 100): Evidence {
+  return { sourceId: src, text: "e", verdict: v, reliability: rel, strength, tokenCost: cost, ts: Date.now() };
+}
+
+export function runTests(): TestResult[] {
+  const results: TestResult[] = [];
+  const cfg: EngineConfig = defaultConfig();
+
+  // 1) log-odds additivity is order-independent
+  try {
+    const a = newState(["X", "Y"], null, cfg);
+    const b = newState(["X", "Y"], null, cfg);
+    const ha = Object.keys(a.hyps)[0], hb = Object.keys(b.hyps)[0];
+    const e1 = ev("s1", Verdict.SUPPORT);
+    const e2 = ev("s2", Verdict.SUPPORT, 0.6);
+    applyEvidence(a, ha, e1, cfg); applyEvidence(a, ha, e2, cfg);
+    applyEvidence(b, hb, e2, cfg); applyEvidence(b, hb, e1, cfg);
+    const ok = Math.abs(a.hyps[ha].logw - b.hyps[hb].logw) < 1e-12;
+    results.push({ name: "log-odds additivity is order-independent", pass: ok, detail: `Δlogw=${(a.hyps[ha].logw - b.hyps[hb].logw).toExponential(2)}` });
+  } catch (e) { results.push({ name: "log-odds additivity", pass: false, detail: String(e) }); }
+
+  // 2) silent evidence moves nothing
+  try {
+    const st = newState(["X", "Y"], null, cfg);
+    const h = Object.keys(st.hyps)[0];
+    const before = st.hyps[h].logw;
+    applyEvidence(st, h, ev("s", Verdict.SILENT), cfg);
+    results.push({ name: "SILENT evidence does not move logw", pass: st.hyps[h].logw === before });
+  } catch (e) { results.push({ name: "SILENT evidence", pass: false, detail: String(e) }); }
+
+  // 3) posterior normalized
+  try {
+    const st = newState(["A", "B", "C"], null, cfg);
+    const s = Object.values(posterior(st)).reduce((a, b) => a + b, 0);
+    results.push({ name: "posterior sums to 1", pass: Math.abs(s - 1) < 1e-12, detail: `sum=${s}` });
+  } catch (e) { results.push({ name: "posterior sum", pass: false, detail: String(e) }); }
+
+  // 4) SPRT requires min sources
+  try {
+    const cfg2 = defaultConfig({ sprt: { alpha: 0.05, beta: 0.1, minSupportingSources: 2 } });
+    const st = newState(["A", "B"], null, cfg2);
+    const h = Object.keys(st.hyps)[0];
+    for (let i = 0; i < 10; i++) applyEvidence(st, h, ev("only_one", Verdict.SUPPORT, 1.0, 1.0), cfg2);
+    results.push({ name: "single source cannot commit (min_sources guard)", pass: st.committed === null });
+  } catch (e) { results.push({ name: "min sources", pass: false, detail: String(e) }); }
+
+  // 5) SPRT commits with enough independent support
+  try {
+    const st = newState(["A", "B", "C"], null, cfg);
+    const h = Object.keys(st.hyps)[0];
+    applyEvidence(st, h, ev("s1", Verdict.SUPPORT, 0.9, 0.9), cfg);
+    applyEvidence(st, h, ev("s2", Verdict.SUPPORT, 0.9, 0.9), cfg);
+    applyEvidence(st, h, ev("s3", Verdict.SUPPORT, 0.9, 0.9), cfg);
+    results.push({
+      name: "SPRT commits with ≥min independent support",
+      pass: st.committed === h && st.commitReason === "sprt_accept",
+      detail: `committed=${st.committed} reason=${st.commitReason}`,
+    });
+  } catch (e) { results.push({ name: "SPRT accept", pass: false, detail: String(e) }); }
+
+  // 6) signed PPR: contradiction cancels
+  try {
+    const g = new RelevanceGraph(cfg.graph);
+    for (const n of ["q", "support_only", "contested", "neg"]) g.addNode(n, n);
+    g.addEdge("q", "support_only", +1);
+    g.addEdge("q", "contested", +1);
+    g.addEdge("neg", "contested", -1);
+    g.addEdge("q", "neg", +1);
+    const ranked = g.personalizedPageRank("q");
+    const s = (id: string) => ranked.find((r) => r.nid === id)?.score ?? 0;
+    results.push({
+      name: "signed PPR: support-only ranks ≥ contested",
+      pass: s("support_only") >= s("contested"),
+      detail: `support=${s("support_only").toFixed(3)} contested=${s("contested").toFixed(3)}`,
+    });
+  } catch (e) { results.push({ name: "PPR contradiction", pass: false, detail: String(e) }); }
+
+  // 7) SPRT boundary semantics
+  try {
+    const d1 = sprtDecision(5, 0, cfg.sprt);
+    const d2 = sprtDecision(0, 5, cfg.sprt);
+    const d3 = sprtDecision(0.1, 0, cfg.sprt);
+    results.push({
+      name: "SPRT boundaries: ACCEPT/REJECT/CONTINUE",
+      pass: d1 === "accept" && d2 === "reject" && d3 === "continue",
+      detail: `${d1}/${d2}/${d3}`,
+    });
+  } catch (e) { results.push({ name: "SPRT boundaries", pass: false, detail: String(e) }); }
+
+  // 8) supporting source counting
+  try {
+    const st = newState(["A"], null, cfg);
+    const h = Object.keys(st.hyps)[0];
+    applyEvidence(st, h, ev("s1", Verdict.SUPPORT), cfg);
+    applyEvidence(st, h, ev("s1", Verdict.SUPPORT), cfg); // duplicate source
+    applyEvidence(st, h, ev("s2", Verdict.SUPPORT), cfg);
+    results.push({ name: "supporting-source counter dedups", pass: countSupportingSources(st.hyps[h]) === 2 });
+  } catch (e) { results.push({ name: "source dedup", pass: false, detail: String(e) }); }
+
+  return results;
+}

package/src/lib/gbse/tiers.ts

@@ -0,0 +1,65 @@
+import type { TierSpec } from "./types";
+
+export const TIERS: Record<number, TierSpec> = {
+  0: { tier: 0, name: "T0 REFLEX",     hypothesisCount: 0,  evidenceProbes: 0,  maxTokens: 2_000,    maxSeconds: 15,   forecastCoverage: 0.30 },
+  1: { tier: 1, name: "T1 SCOUT",      hypothesisCount: 4,  evidenceProbes: 3,  maxTokens: 20_000,   maxSeconds: 180,  forecastCoverage: 0.55 },
+  2: { tier: 2, name: "T2 SURVEY",     hypothesisCount: 6,  evidenceProbes: 8,  maxTokens: 80_000,   maxSeconds: 480,  forecastCoverage: 0.70 },
+  3: { tier: 3, name: "T3 DEEP_DIVE",  hypothesisCount: 8,  evidenceProbes: 14, maxTokens: 300_000,  maxSeconds: 1200, forecastCoverage: 0.82 },
+  4: { tier: 4, name: "T4 EXHAUSTIVE", hypothesisCount: 10, evidenceProbes: 24, maxTokens: 1_200_000, maxSeconds: 2700, forecastCoverage: 0.91 },
+  5: { tier: 5, name: "T5 SATURATION", hypothesisCount: 12, evidenceProbes: 40, maxTokens: 3_000_000, maxSeconds: 5400, forecastCoverage: 0.96 },
+};
+
+const HIGH_STAKES = new Set(["medical", "clinical", "legal", "financial", "safety", "security", "dosage", "diagnosis"]);
+const VOLATILE = new Set(["current", "today", "price", "ceo", "president", "latest", "recent", "now", "2025", "2026"]);
+
+export function pickTier(query: string, anchorCoverage = 0.0): { tier: number; reason: string } {
+  const ql = query.toLowerCase();
+  const stakes = [...HIGH_STAKES].some((k) => ql.includes(k));
+  const volatile = [...VOLATILE].some((k) => ql.includes(k));
+  const entities = query.split(/\s+/).filter((w) => /^[A-Z]/.test(w)).length;
+  const complexity = Math.min(1.0, query.split(/\s+/).length / 40 + 0.05 * entities);
+  const score = complexity + (volatile ? 0.3 : 0) + (stakes ? 0.3 : 0);
+
+  if (anchorCoverage >= 0.75 && !stakes && !volatile) {
+    return { tier: 0, reason: "anchor covers query; low stakes" };
+  }
+  let tier: number;
+  if (score < 0.25) tier = 1;
+  else if (score < 0.45) tier = 2;
+  else if (score < 0.70) tier = 3;
+  else if (score < 0.90) tier = 4;
+  else tier = 5;
+  if (stakes) tier = Math.max(tier, 3);
+  return {
+    tier,
+    reason: `complexity=${score.toFixed(2)} stakes=${stakes} volatile=${volatile}`,
+  };
+}
+
+export interface TokenReport {
+  measuredSpent: number;
+  counterfactualBaseline: number;
+  estimatedSaved: number;
+  baselineAssumption: string;
+  nHypotheses: number;
+  nPruned: number;
+}
+
+export function tokenReport(
+  spentTokens: number,
+  nHypotheses: number,
+  nPruned: number,
+  synthesisCostPerHyp: number,
+): TokenReport {
+  const baseline = spentTokens + (nHypotheses - 1) * synthesisCostPerHyp;
+  const saved = Math.max(0, baseline - (spentTokens + synthesisCostPerHyp));
+  return {
+    measuredSpent: spentTokens,
+    counterfactualBaseline: baseline,
+    estimatedSaved: saved,
+    baselineAssumption:
+      "Baseline ASSUMES every hypothesis would be fully synthesized. Real savings depend on the host pipeline and are not measured here.",
+    nHypotheses,
+    nPruned,
+  };
+}

package/src/lib/gbse/types.ts

@@ -0,0 +1,94 @@
+// GBSE — shared types
+// Classical Bayesian belief search; no quantum metaphors.
+
+export enum Verdict {
+  SUPPORT = "support",
+  REFUTE = "refute",
+  SILENT = "silent",
+  CONTESTED = "contested",
+}
+
+export interface Evidence {
+  sourceId: string;
+  text: string;
+  verdict: Verdict;
+  reliability: number; // [0,1]
+  strength: number; // [0,1]
+  tokenCost: number;
+  url?: string;
+  ts: number;
+}
+
+export interface Hypothesis {
+  hid: string;
+  text: string;
+  logw: number;
+  alive: boolean;
+  evidence: Evidence[];
+  coupled: Record<string, number>;
+  anchorVerdict: Verdict;
+  anchorConfidence: number;
+  spentTokens: number;
+}
+
+export interface BeliefState {
+  sid: string;
+  hyps: Record<string, Hypothesis>;
+  committed: string | null;
+  commitReason: string;
+  spentTokens: number;
+  createdAt: number;
+}
+
+export interface SPRTConfig {
+  alpha: number;
+  beta: number;
+  minSupportingSources: number;
+}
+
+export interface EvidenceConfig {
+  llrCap: number;
+  maxPriorLogOdds: number;
+  couplingCap: number;
+}
+
+export interface GraphConfig {
+  restartProb: number;
+  maxIters: number;
+  tolerance: number;
+  maxNodes: number;
+}
+
+export interface EngineConfig {
+  sprt: SPRTConfig;
+  evidence: EvidenceConfig;
+  graph: GraphConfig;
+  collapseMargin: number;
+  pruneFloor: number;
+  maxTokens: number;
+  maxSeconds: number;
+  seed: number;
+}
+
+export enum SPRTDecision {
+  ACCEPT = "accept",
+  CONTINUE = "continue",
+  REJECT = "reject",
+}
+
+export interface TierSpec {
+  tier: number;
+  name: string;
+  hypothesisCount: number;
+  evidenceProbes: number;
+  maxTokens: number;
+  maxSeconds: number;
+  forecastCoverage: number;
+}
+
+export interface TraceEvent {
+  ts: number;
+  phase: string;
+  message: string;
+  data?: unknown;
+}