beijingwahw/dsh-proactive

Proactive Intelligence scheduling plugin — a multi-model collaborative scheduling system for the DeepSeek Harness (DSH) ecosystem: it perceives, decides, and evolves on its own, with a built-in Scientist / Theorist dual mind, a cognitive energy symbiosis economy, and ninety-eight phase-change kernels (evidence → geometry-topology / genesis / prophet / equilibrium / awakening / flux / fabric / singularity / mind / game / emergence / proof / perception / judgment / execution / evolution / consciousness layers: anytime-valid / conformal / optimal transport / information geometry / sheaf consensus / Gittins / robust statistics / differential privacy / capacity planning / Gaussian process / Kalman filtering / extreme value theory / Monte-Carlo tree search / submodular optimization / adversarial no-regret learning / Hungarian global assignment / random matrix / CVaR distributional robustness / LQR feedback control / persistent homology / information bottleneck / nonlinear dynamics / PageRank spectral ranking / first passage / Jackson queueing networks / FFT spectral periodicity / max-flow / max-min fairness / OCBA budget allocation / quorum intersection / CRDT convergence / Shamir secret sharing / Haar wavelets / low-rank matrix completion / speculative decoding / test-time compute / Whittle index / Lyapunov backpressure / Hawkes self-excitation / belief propagation / variational inference / Langevin sampling / curriculum learning / rate distortion / stable matching / mechanism design / nucleolus / correlated equilibrium / dynamic pricing / simulated annealing / NSGA-II Pareto / compression distance / Mapper graph / partial information decomposition / A search / sparse recovery / best-arm identification / mirror descent / online calibration / novelty detection / causal discovery / canonical correlation / manifold learning / streaming sketches / argumentation / crowd aggregation / world-model learning / POMDP planning / symbolic solving / options framework / safety barrier / off-policy evaluation / safe policy improvement / preference learning / novelty search / self-play / Hyperband autoML / simulation calibration / interruptible autonomy / global workspace / metacognitive confidence / experience replay / attention economy / self-boundary)*.

English | 中文

What is Proactive Intelligence?

Traditional schedulers are reactive: they respond only when a signal arrives and idle otherwise. On top of the "perceive → decide → execute → reflect → consolidate" loop, this plugin adds an autonomy layer so the system:

• When idle, actively observes its own runtime state, discovers bottlenecks, and generates improvement goals
• Facing unknown territory, actively launches explorations, turning "unknown" into "experienced"
• Anticipating future load, actively predicts signal arrival trends and reserves capacity ahead of time
• On anomalies, actively trips circuit breakers, rate-limits, and degrades — instead of waiting to crash

Architecture Overview

The system has three tiers: the kernel stack (a substrate of minds sharing one statistical language), three-loop autonomy (operational loop / evolution loop / meta-cognition outer loop), and the symbiosis economy layer (a cognitive energy market).

┌─ Symbiosis Economy (symbiosis/) ─────────────────────────────┐
│  Energy Ledger (double-entry · chained audit)                │
│  Knowledge Market (continuous double auction · royalties)    │
│  Belief Market (LMSR · market as mind)                       │
│  Agents (reputation · legislation/enforcement split)         │
│  Symbiosis Runtime (survive→propose→veto→match→execute)      │
├─ Three-Loop Autonomy ────────────────────────────────────────┤
│  Operational: signal→decide→execute→reflect 10-step pipeline │
│  Evolution: policy evolver + sandbox + canary (policy/)      │
│  Meta outer: self-model → conservative tune → rollback (meta/)│
├─ Kernel Stack (core/) — ninety-eight kernels, 3.0 → 100.0 (century cap) ┤
│  Evidence 3.0  Resilience 4.0  Causal 5.0  Free-Energy 6.0   │
│  Deliberation 7.0  Metareasoning 8.0  Abstraction 9.0        │
│  Scientist 10.0  Theorist 11.0                               │
│  Anytime Evidence 12.0  Conformal 13.0  Quality-Diversity 14.0│
│  Runtime Verification 15.0  Shapley Attribution 16.0          │
│  Optimal Transport 17.0  Info-Geometry 18.0                  │
│  Optimal Stopping 19.0  Sheaf Consensus 20.0                  │
│  Gittins 21.0  Budget Knapsack 22.0   (genesis layer)         │
│  Robust Stats 23.0  Diff-Privacy 24.0  Capacity 25.0          │
│  Gaussian Process 26.0  Kalman 27.0  Extreme Value 28.0       │
│  MCTS 29.0  Submodular 30.0            (prophet layer)        │
│  No-Regret 31.0  Assignment 32.0  Random Matrix 33.0          │
│  CVaR Robustness 34.0  LQR Feedback 35.0 (equilibrium layer)  │
│  Persistence 36.0  Info-Bottleneck 37.0  Dynamics 38.0        │
│  Spectral Ranking 39.0  First Passage 40.0 (awakening layer)  │
│  Queueing 41.0  Spectral 42.0  Max-Flow 43.0 (flux layer)     │
│  Fair Division 44.0  OCBA 45.0 (flux layer)                   │
│  Quorum 46.0  CRDT 47.0  Shamir 48.0 (fabric layer)           │
│  Haar Wavelet 49.0  Matrix Completion 50.0 (fabric)            │
│  Speculative Decoding 51.0  Test-Time Compute 52.0            │
│  Whittle Index 53.0  Lyapunov Backpressure 54.0               │
│  Hawkes Self-Excitation 55.0   (singularity layer)            │
│  Belief Propagation 56.0  Variational Inference 57.0          │
│  Langevin Sampling 58.0  Curriculum 59.0  Rate Distortion 60.0│
│                                          (mind layer)         │
│  Stable Matching 61.0  Mechanism Design 62.0  Nucleolus 63.0  │
│  Correlated Equilibrium 64.0  Dynamic Pricing 65.0 (game)     │
│  Simulated Annealing 66.0  NSGA-II Pareto 67.0                │
│  Compression Distance 68.0  Mapper Graph 69.0  PID 70.0       │
│                                          (emergence layer)    │
│  A* Search 71.0  Sparse Recovery 72.0  Best-Arm ID 73.0       │
│  Mirror Descent 74.0  Online Calibration 75.0  (proof layer)  │
│  Novelty Detection 76.0  Causal Discovery 77.0  CCA 78.0      │
│  Diffusion Maps 79.0  Streaming Sketches 80.0  (perception)   │
│  Argumentation 81.0  Crowd Aggregation 82.0                   │
│  World-Model Learning 83.0  POMDP 84.0  Symbolic 85.0 (judgment)│
│  Options 86.0  Safety Barrier 87.0  OPE 88.0                  │
│  Safe Improvement 89.0  Preference Learning 90.0 (execution)  │
│  Novelty Search 91.0  Self-Play 92.0  Hyperband 93.0          │
│  Sim Calibration 94.0  Interruptible Autonomy 95.0 (evolution)│
│  Global Workspace 96.0  Metacognitive Confidence 97.0         │
│  Experience Replay 98.0  Attention Economy 99.0               │
│  Self-Boundary 100.0 (consciousness layer, century cap)       │
└──────────────────────────────────────────────────────────────┘

In round 3 (v0.8.0), every module domain of the three-loop autonomy and symbiosis tiers (sentinel / decision / scheduling / executor / memory / reflection / autonomy / meta-cognition / evolution / world model / symbiosis / distributed / governance / client / benchmark & dashboard / contracts / main pipeline) received a world-class upgrade: 18 module domains × 4-6 upgrades each, all opt-in mounts (attach* methods / optional config; default = old behavior bit-for-bit), plus a new src/telemetry/ telemetry audit-bus module (exported from dist) — overview below, full announcement in UPGRADE-ALL-MODULES.md (Chinese).

Round 4 (v0.9.0, theme "Activation & Deepening") then did two things: 16 module domains each picked up 5 brand-new upgrade dimensions (~80 items total), and the round-3/4 module upgrades were wired into the main pipeline via 16 autonomy.modules.* flags (flag → attach differential verification, all-off zero drift), with the pipeline itself gaining a deepening trio and the telemetry bus completing phase 2 — overview in the section after next, full announcement in UPGRADE-ACTIVATION-DEEPENING.md (Chinese).

Round 5 (v1.0.0, theme "World-Class Evolution of All Kernels") closes the series: every one of the ninety-eight kernels itself advanced another notch along four axes — mathematics / performance / numerical robustness / randomized property testing (80 new APIs consolidated onto the root export) — taking the version straight to the 1.0.0 all-kernels-evolved milestone. Overview in the Round 5 section below; full announcement in UPGRADE-KERNEL-EVOLUTION.md (Chinese).

Round 3 · World-Class Upgrade of All Modules (v0.8.0 Overview)

With the ninety-eight mathematical kernels (3.0 → 100.0) in place, round 3 spreads the upgrade surface across every module domain — each engine on the main pipeline, every infrastructure piece, and the symbiosis economy picked up 4-6 quality upgrades. Every upgrade ships with a constructed "old vs new" comparison (not "it changed" but "it is provably better"), and everything is opt-in: attach* mounting or optional config; unenabled behavior stays bit-identical to before the upgrade (zero drift).

Domain	Core upgrades	Key numbers
A1 Sentinel (sentinel.ts)	Adaptive aggregation window (3 states) / urgency half-life decay / per-source token-bucket backpressure / provenance-chain cycle guard / NCD near-duplicate / fingerprint stats	Storm residence latency 5× better
A2 Decision (decision-engine.ts)	Hysteresis state machine / counterfactual decision ledger (Wilson intervals) / ask-user value-of-information gate / per-context-bucket calibration / decision audit	Boundary flapping −60%; night-drift misses 18 → 0
A3 Scheduling (model-scheduler.ts)	Health-routing circuit breaker (EWMA + exponential backoff + half-open probe) / power-of-two-choices P2C load balancing / 3-tier cost profile / per-model retry budget / scheduling audit	Max load 31 < random 35 < single-point 120
A4 Executor (task-executor.ts)	EDF deadline scheduling / tail-latency hedging / plan-level retry budget / cancel propagation + checkpoint resume / execution audit / deterministic virtual clock	Deadline satisfaction 3/6 → 6/6; p99 300 → 87ms (cost +10%); storm retries 10 → 7; resume saves 40ms
A5 Memory (memory/)	Hot/warm/cold tiering / four-way fused retrieval / alias-cooccurrence disambiguation / entry checksum + atomic writes / migration dry-run diff / graph degree stats	Hot-tier hit rate 0.64 vs single-tier LRU 0.50; fixed a pre-existing link() key-concat bug
A6 Optimize/Reflect (optimizer/reflector/reflection-engine)	Experience-retrieval confidence routing / 3-dimension recommendation rationale / retry bandit / counterfactual OPE dataset / insight dedup decay / sedimentation value scoring	Retry bandit total cost −50%
A7 Autonomy (goal/curiosity/autonomy-loop)	Goal-DAG budget + stale demotion & merge / value × success-rate ranking / topological blind-spot targeted curiosity / 5-phase heartbeat machine / cadence adaptation / phase budget yield	Blind-spot hits 3/3 vs 0/3
A8 Meta-cognition (meta/)	Deadband + ramp + cooldown stabilizer loop / 89.0 adjustment certificate gate (fake improvements with LCB<0 rejected) / self-change log + snapshot rollback / self-assessment calibration / relative KPI band / inner-outer loop arbitration	Oscillation 6 adjusts 3 flips → 3 adjusts 0 flips; morning report 32 batches 0 false alarms
A9 Evolution (strategy-evolution/policy)	Certificate-gated evolution loop (sandbox → OPE → LCB → canary → rollback, persistent ledger) / adversarial adaptive difficulty + boundary mining / evolution lineage tree / softmax operator governance / stagnation-restart diversification / evolution budget	"High surface score, poor offline value" intercepted by the OPE gate
A10 World model (world-model/host)	Observation-belief fusion (source-reliability Beta learning + true-conflict marking) / time-travel snapshots + key-level diff / host-capability negotiation downgrade chain / host bridge 5 states + idempotency keys / world health	Noise-source key contamination 10 → 0
A11 Symbiosis (symbiosis/)	Order-book invariant engine I1-I5 / LMSR pricing consistency / ledger hash chain + tamper localization / reputation decay + Sybil resistance / argued vetoes / energy Sankey export	Same-window score farming 209.9 → 29.98; fixed the folded-root defect
A12 Distributed (consensus/sync/hot-reload)	Seeded Raft fault-injection bench / log-compaction snapshots / CRDT anti-entropy / hot-reload dependency-topology closure / atomic swap rollback	500 rounds 0 safety violations; anti-entropy traffic −87.5%; closure 2/5 touched
A13 Governance (tenant/security/safety-governor)	Max-min water-filling quotas / noisy-neighbor gradient suppression / key-rotation grace / Shamir 5-of-3 escrow / governor action ladder + cooldown / constant-time comparison	Fixed the Shamir non-ASCII mojibake bug
A14 Client (llm-client/progress-ws)	Decorrelated jitter backoff / token hard-budget breaker / streaming backpressure bounded buffer / progress coalescing with final-must-emit + gap detection / offset resume / call audit	Avalanche sync std 0 → 165ms+
A15 Benchmark & dashboard (benchmark/dashboard)	Sign test + bootstrap CI / e-process regression detection / BAI focus / structured reports / 98-kernel map + GWT bus + attention-market panels	Nominal coverage 0.947; regression power 0.95 with 0 false alarms; BAI 0.988 vs 0.960
A16 Contracts (types/contracts/errors)	13-code error taxonomy / runtime validator path-typed errors / 8 brand IDs / Result<T,E> monad laws / event envelope guard	classifyTaxonomy naming disambiguation
A17 Main pipeline (index.ts + adapters)	10-step audit trail ring buffer / 18-tool input validation + schemas / reverse-order resource release audit / introspect 3 new fields / 4 adapters made advisory	Flag overview exactly 50 entries
A18 Telemetry bus (src/telemetry/, new module)	Event bus (wildcard / ring / final-must-emit / gap detection) / metrics registry (quantiles / cardinality guardrails) / audit hash chain / trace spans	Four files exported from dist
A19 Integration regression	Cross-domain pure-data pipeline smoke (signal→decision→scheduling→execution→reflection→symbiosis settlement→ledger→memory→market) / telemetry × contract alignment / suite-wide --experimental-transform-types runner	verify-symbiosis determinism fix

The verification surface doubled accordingly: 19 new scripts (18 module-domain verify-mod-* + 1 cross-domain verify-mod-integration), bringing the offline verification total from 81 to 100 (full re-run: 100/100 green; round 4 later expanded it to 119, and round 5 to 138).

Round 4 · Activation & Deepening (v0.9.0 Overview)

Round 3 equipped every module domain with upgrades worth having; round 4 answers two questions: how much deeper can it go, and how does it actually run. 16 module domains each received 5 brand-new upgrade dimensions (~80 items; every one still a constructed "old vs new" comparison, opt-in, zero drift), while the scattered attach* upgrades were converged into 16 autonomy.modules.* flags wired into the main pipeline (flag on = mounted and effective, all off = bit-identical to pre-upgrade), the pipeline itself gained a deepening trio, and the telemetry bus completed phase 2.

Domain	Core upgrades	Key numbers
R4-1 Sentinel	Common-cause burst detection (coincidence-pair lift) / periodic profile (visible period-miss) / cascading priority inheritance / source-quality feedback (autoDiscount ranking) / storm budget sharing	Common-cause lift 3.85 vs independent ≈1.0; silence misses 0 → injected per period; 40 generations self-reporting 0.99 flat → 0.6^k generational decay cap; valid-signal rank 4.0 → 2.0; storm admission 31 → 19
R4-2 Decision	Batch joint deciding (same-type merge sharing one strategist) / decision-fatigue metering / failure-mode clustering (Top-3 exact recovery) / decision-path explainer / undo protocol (3 states)	strategist 10 → 1 call, cost −58.5%; paid decisions 30 → 10; explainer field-by-field consistent
R4-3 Scheduling	Ensemble combination optimization (Condorcet) / predictive prewarming / 3-phase cold-start admission (shadow→canary→graduate) / cost-drift alert / specialty profiling	Condorcet ensemble 0.6576 > best single 0.62; prewarm 2010ms early; low-quality newcomer 10/10 → 0/10 admitted; specialty hits 50% → 100%
R4-4 Executor	Adaptive parallelism / failure-domain isolation / ETA quantile estimation / plan compression (semantically equivalent) / failure-injection drills	Converges to concurrency 3, duration −59%; innocent migrations 5 → 0; ETA error 885% → 8.2%; plan 6 → 4 nodes semantically equal
R4-5 Memory	Conflict arbitration (new evidence wins, old view archived) / aging temperature curve / causal-chain provenance / health audit / cross-task transfer mapping	Kept-warm 0.439 vs neglected 0.051; all 5 defect classes detected; transferable pairs Wilson lower bound 16× apart (0.596 vs 0.036)
R4-6 Optimize/Reflect	Cross-task experience transfer (similarity × quality triple gate) / reflection-depth grading (light→heavy escalation chain) / failure knowledge base / confidence propagation / plan-template abstraction	Depth grading saves 25% cost; second failure of the same pattern avoided (effectiveness = 1)
R4-7 Autonomy	Goal-resource conflict detection / adaptive exploration budget / 3-tier action safety (mutate without certificate fails closed) / milestone delays / time-window governance (across midnight)	Resource gaps 2 detected with 0 false positives; exploration direction 3 → 4 → 1 converges correctly
R4-8 Meta-cognition	Multi-scale monitoring (glitch = noise vs true degradation) / self-efficacy prediction / cognitive-load gate / adjustment-magnitude meta-learning / KPI correlation graph	Three-stage evolution separates glitches from degradation; efficacy separation error ≤ 0.03 with converging calibration; post-crash shrinkage escapes the old deadlock
R4-9 Evolution	Diversity dashboard (collapse early warning) / cross-task strategy transfer (useless transfers identified & dropped) / rate adaptation / A/B branch lineage (promote/retire) / freeze protocol	Warning precedes deepest collapse by 3 generations, diversity 8.2× after injection; transfer deploys in generation 1 (+0.22); deterministic 20% traffic split
R4-10 World model	Counterfactual shadow world (0-pollution three-way attribution) / uncertainty map (four quadrants) / multi-hypothesis arena (evidence flips ranking) / event causal-chain ledger / host bridge pool	Unknown-quadrant rate 0.3 visible; bad hosts 0 executions
R4-11 Symbiosis	Liquidity measurement / inflation governance (circulation target band) / contributor profiling + mutation detection / conditional-settlement contracts (3-way escrow conservation) / manipulation detection	Thin/thick book spread 1818 vs 168bps; 3 over-issuances settled back into band, dividends 40 → 20; wash-trading + circular volume detected
R4-12 Distributed	Byzantine detection & isolation / partition-healing report (truncations explicitly booked) / single-step membership change / cross-cluster federation (selective sync) / hot-reload canary	After isolation 5 → 4 nodes commit as usual; 3 → 5 → 4 with no dual leader; federation transfers 77.3%; bad version rolls back only its canary cells
R4-13 Governance	Quota forecasting (slope-extrapolated warning) / tiered keys (differentiated rotation) / event-forensics timeline (triple verification) / compliance export (SHA-256) / threat-score jumping	Warning 1000ms early with 0 false positives; wrong-tier usage alerted; high-risk direct in 1 hit vs old 4 hits with 3 cooldowns
R4-14 Client	Model-capability probing (failures never overstated) / priority queue (preemption + timeout) / streaming resume / snapshot + incremental seamless / cost reconciliation	Retransmission −60%, honest fallback when protocol lacks support; reconciliation discrepancies detected
R4-15 Benchmark & dashboard	Long-term trends (Mann-Kendall / Theil-Sen) / recommendation engine / comparison matrix (significance marking) / alarm panel / layout persistence	Flat stream 0/48 false alarms (old two-point diff cried 12/19); recommendations 12/12 vs random 2/12; significance matches pairwise tests
R4-16 Contracts	API semantic-version negotiation / schema-evolution chain (honest upgrade/downgrade audit) / declarative invariant library / type dependency graph (topo order + cycle detection + DOT) / error retry-strategy taxonomy	15-combination negotiation matrix fully covered
R4-17 Main pipeline (activation wiring)	16 autonomy.modules.* flags uniformly activating round-3/4 module upgrades (flag → attach differential verification, all-off zero drift) + deepening trio: cross-step cache / degradation ladder / step prefetch	Cache hits bit-identical to direct computation; degradation three rungs in order with consistent fallback; prefetch 62 → 50 units, zero staleness
R4-18 Telemetry phase 2	Sliding-window aggregation / deterministic sampling (Bresenham, errors always delivered) / Prometheus text export / dual-threshold retention (chain-anchored) / trace tail sampling	Sampler restored by estimator; retention chain verification passes
R4-19 Integration regression	Five-segment joint smoke (activation wiring / perceive→decide→execute / economy-governance-telemetry / dashboard / Prometheus + audit retention) + symbiosis wall-clock fix (injected frozen clock)	55 assertions all green

The verification surface grew accordingly: 19 new scripts (16 domain verify-r4-* + pipeline verify-r4-pipeline + telemetry verify-r4-telemetry + integration verify-r4-integration), bringing the offline verification total from 100 to 119 (full re-run: 119/119 green; round 5 later expanded it to 138).

Round 5 · Evolution of All Kernels (v1.0.0 Overview)

With both module layers saturated, round 5 returns to the kernel layer itself — no new kernels; instead each of the ninety-eight existing kernels (3.0 → 100.0) advances another notch along four axes:

• Mathematical evolution: new theorem-backed capabilities (closed forms / exact algorithms / tighter bounds) — closed-form Bayes factors, natural direct/indirect effects, k-choice prophet inequalities, closed-form hyperbolic Fisher distance, the LQG separation theorem...
• Performance evolution: complexity improvements + equivalence proofs (the new implementation matches the old one bit-for-bit or within analytic tolerance — "faster" is never allowed to mean "maybe wrong") + scale-vs-time comparisons — nucleolus 13937ms → 1ms, combinatorial-auction branch & bound ×6141, landmark diffusion 69×...
• Numerical robustness: hardening against ill-conditioned inputs and log-domain rewrites (bounded in under/overflow regimes, conservation laws preserved) — log-domain WIS (the naive path throws outright), ten-thousand-step e-process capital, Joseph-form covariance strictly symmetric over 2000 steps...
• Randomized property testing: every kernel faces ≥ 200 seeded inputs checking mathematical properties (unbiasedness / coverage frequencies / monotonicity / conservation laws / metric axioms / convexity), with fixed mulberry32 seeds and fully deterministic replay.

The 98 kernels are organized by mathematical affinity into 18 groups (statistics / causal / Bayesian computation / metacognition / information geometry / planning & search / decision computing / online learning / control & optimization / stochastic processes / spectral methods / topology & dynamics / fair division / consensus & verification / evolutionary learning / game & mechanisms / learning systems / resilient autonomy), each closed out by its own verify-r5-* script; 80 new kernel APIs are consolidated onto the root export (per-symbol runtime reachability asserted against dist/index.mjs). The verification surface gained 18 group scripts + 1 integration regression (1,471 assertions in total), bringing the offline verification total from 119 to 138.

Group (kernel numbers)	Signature evolutions (1-2 picks)	Key numbers
Statistics (3.0/12.0/13.0/23.0/24.0)	Closed-form Bayes factor + Kass–Raftery grading / mixture e-processes; Mondrian conditional conformal; Hodges–Lehmann estimation; exponential mechanism + optimal RDP order	Mixture e-process power 2.7×; imbalanced-group coverage 18.8% → 93.0%; HL breakdown point 29.3%; optimal order cheaper in 200/200
Causal science (5.0/10.0/11.0/77.0)	Natural direct/indirect effects (front-door adjustment); exact-DP GES; submodular-greedy batch EIG; MDL two-part code	total = NDE + NIE identity; GES globally optimal for d ≤ 12
Bayesian computation (6.0/26.0/27.0/57.0/58.0)	Canonical EFE decomposition; natural gradient; underdamped MALA; FITC sparse GP; UKF ≡ KF + Joseph form	Natural gradient 12 vs 2000 steps; ESS 424 vs 116; m = n degenerates to the exact GP
Metacognition (7.0/8.0/9.0/96.0/97.0)	Bayesian persuasion model; closed-form Poisson optimal stopping; rate-distortion optimal abstraction granularity; GWT temperature annealing; type-2 ROC parameter fitting	Abstraction granularity priced by the rate-distortion theorem; winner distribution controllable after annealing
Information geometry (17.0/18.0/37.0/68.0/70.0)	Exact 1-D Wasserstein (grid-free); debiased Sinkhorn divergence (Feydy); closed-form hyperbolic Fisher distance; deterministic IB; BROJA KKT certificates; LZ77 compression	Debiasing gives S(μ,μ)=0; NCD resolution 38–44×
Planning & search (19.0/29.0/71.0/84.0/85.0)	k-choice prophet inequality; PUCT + subtree reuse; weighted A* w-suboptimality; VSIDS + two-watched literals	Randomized threshold hits the bound 100%; Ĉ ≤ w·C* across all seeds; lazy h at ~39% of the vertex set
Decision computing (21.0/22.0/51.0/52.0/53.0/73.0)	Cost-aware Gittins; BwK LP dual certificates; exact Whittle policy iteration; LUCB tracking; exact-DP weighted majority; closed-form tree speculation	Cost Gittins 32.5×; dual certificate on an 8.4× monotone chain; exact Whittle 7×
Online learning (31.0/65.0/74.0/75.0/88.0/89.0)	AdaHedge (logarithmic regime); optimistic FTRL; online coverage tracking; scarcity pricing DP; switch-DR; multi-candidate FWER	Constant-stream regret O(1) (1/5 of classical OMD); switch-DR variance down ×10.6; scarcity revenue 1.23×
Control & optimization (32.0/34.0/35.0/43.0/54.0/87.0)	CVaR sample-complexity bound; LQG separation theorem; weighted backpressure (beats LQF in heavy traffic); multi-barrier conjunction; sparse assignment with Hall check; Dinic + min-cost flow dual certificates	CVaR saves 49× samples; weighted backpressure beats LQF under heavy traffic
Stochastic processes (25.0/28.0/40.0/41.0/42.0/55.0)	M/G/1 Pollaczek–Khinchine + cμ rule; square-root staffing; multivariate Hawkes; harmonic comb with exact Beta p; GPD return levels with delta-CI; closed-form drifted first passage	Hawkes matrix recovery ±0.017; Kleinrock conservation invariant across all K! orders
Spectral methods (33.0/39.0/49.0/50.0/78.0/79.0)	Personalized PageRank (dangling double-count fixed); MP density + Tracy–Widom numerics; Gavish–Donoho hard threshold; Daubechies D4 algebraic coefficients; kernel CCA; landmark diffusion	Rank recovery 100%; nonlinear dependence 0.806 vs 0.215; landmark diffusion 69×
Topology & dynamics (36.0/38.0/66.0/69.0/76.0/91.0)	H₁ representative cycles + clearing engine; quantile Mapper covers; Wolf Lyapunov; LOF; density-controlled archive pruning; parallel tempering + Luby restarts	Wolf λ₁ ≈ ln2 exactly; parallel tempering 40/40 ≥ single chain
Fair division (16.0/44.0/45.0/60.0/63.0/99.0)	Weighted Shapley (partial-permutation DFS); EF1 decision + envy-cycle elimination; nucleolusFast; order-preserving OCBA rounding; weighted Hamming RD; decaying attention	Nucleolus 13937ms → 1ms; EF1 elimination carries a theorem guarantee
Consensus & verification (15.0/20.0/46.0/47.0/48.0/56.0)	R+W>n analyzer + grid quorums; delta-CRDT; Feldman VSS; LTLf past operators + DFA minimization; sheaf H⁰ dimension + global sections; Bethe free energy + GDL prefix products	Communication −44%; tampering rejected 100%; online monitoring ×17431
Evolutionary learning (14.0/59.0/67.0/92.0/93.0/98.0)	CVT-MAP-Elites; ε-dominance archive; weakness profiling + α-rank; optimal-curriculum-ordering theorem; three-factor replay; η-sweep theory + async brackets	CVT coverage = 1 > grid; curriculum ordering theorem-backed
Game & mechanisms (61.0/62.0/64.0/81.0/82.0/90.0)	Many-to-one capacitated DA (Rural Hospital theorem); combinatorial-auction branch & bound; coarse CE; Bayesian aggregation with known confusion; value-based argumentation VAF; Plackett–Luce	Branch & bound ×6141; fully adversarial crowd aggregated to 1.0 by Bayes
Learning systems (30.0/72.0/80.0/83.0/86.0/94.0)	Graph-cut SFMin (globally optimal); SAFE strong-rule screening; prioritized sweeping; automatic bottleneck-skill discovery (Brandes + Tarjan); CountSketch (negative-count cancellation); truncated IW + weighted bootstrap	SFMin = 2ⁿ brute force on 260 seeds; SAFE screening with 0 violations
Resilient autonomy (4.0/95.0/100.0)	Full closed-form Weibull + k-of-n Poisson-binomial; multi-source interruption composition invariance + vectorized sweep; multi-step causal chains + other-agent models	k-of-n closed form 1867×; vectorized sweep 6.5×; intention direction ±0.80

1.0.0: The Five-Round Milestone

• 0.5.0 baseline: 48 phase-change kernels (3.0 → 50.0, seven layers) + three-loop autonomy + the symbiosis-economy substrate;
• 0.6.0 round 1 (genesis): +25 kernels (51.0 → 75.0) laying down "what math can be called", 13 engines wired;
• 0.7.0 round 2 (autonomous essence): +25 kernels (76.0 → 100.0, century cap) covering perception/judgment/execution/evolution/consciousness, 14 engines wired;
• 0.8.0 round 3 (world-class upgrade of all modules): 18 module domains × 4-6 quality upgrades + the new telemetry bus module;
• 0.9.0 round 4 (activation & deepening): 16 domains × 5 brand-new dimensions + 16 modules.* flags wired into the main pipeline + the deepening trio;
• 1.0.0 round 5 (world-class evolution of all kernels): 98 kernels × four axes + 80 new APIs consolidated on the root export, 138 verification scripts all green — the all-kernels-evolved milestone.

Core Features

Proactive Perception & Autonomous Decision-Making

• Sentinel multi-source signal ingestion (webhook / filesystem watch / polling / manual injection), aggregation-window dedup and urgency ranking
• Strategic decision engine: execute / defer / dismiss / ask-user, continuously calibrated by statistical learning (time decay + Wilson lower bound + UCB cold start)
• Experience retrieval + DAG plan generation + multi-model parallel execution, a 10-step unidirectional pipeline

Scientist / Theorist Dual Mind

• Scientist kernel (core/scientist.ts): Bayesian optimal experiment design — pricing "knowledge acquisition itself". True EIG (nats) to value an experiment's information, confounding bonus (experiment-exclusive value), budget arbitration (netValue = EIG − cost), information-ledger calibration, knowledge-frontier contraction
• Theorist kernel (core/theorist.ts): hierarchical Bayes + MDL (understanding as compression) — compressing data into laws. Same-family edges converge into laws (borrowing-strength shrinkage), compression pricing (log Bayes factor), zero-shot prediction, anomaly detection, paradigm shifts (Kuhn leap)

Anytime Evidence / Conformal / Diversity / Formal Safety / Fair Attribution (12.0 → 16.0)

• Anytime-evidence kernel (core/anytime-evidence.ts): confidence sequences + e-processes — peeking is legal at any moment. Time-uniform confidence intervals (stitched CS) are valid whenever read; e-process capital adjudicates hypotheses via Ville's inequality, and genome eliminations go through the e-BH process with an FDR cap (a mathematical bound on wrongful eliminations); once mounted on the meta-cognition KPI guarantee layer, degradation/recovery verdicts upgrade to an episodic regime state machine (evidence accumulates separately on each side of the watermark, resetting on crossing — peeking-immune, recovery-detectable)
• Conformal kernel (core/conformal.ts): distribution-free exact coverage — prediction intervals with zero distributional assumptions. Split conformal intervals give finite-sample exact guarantees (P(actual ∈ interval) ≥ 1−α); a coverage-drift monitor detects miscalibration via a predictable-λ betting e-process; threshold self-calibration upgrades to risk-controlled selection (empirical Bernstein upper bounds + Bonferroni, P(future retry rate ≤ target) ≥ confidence)
• Quality-diversity kernel (core/quality-diversity.ts): MAP-Elites behavioral archive — diversity collapse is structurally blocked. Strategy genomes fall into niche grids by behavioral descriptors (daring / frugal / vigilant), every school gets an equal trial budget (uniform frontier sampling); the QD-score measures quality and coverage together, so evolution no longer converges to a single solution
• Runtime-verification kernel (core/runtime-verification.ts): LTLf specification monitoring — safety specs made formal, verdicts carry proofs. The default spec set (no failure storms / commands must be answered / periodic heartbeat / authorize-before-execute) compiles into four monitor atoms; violation reports carry full evidence traces and counterexample witnesses; severity-based escalation (critical → Kill Switch, warn → circuit breaker, info → audit)
• Shapley kernel (core/shapley.ts): axiomatic fair attribution — value split backed by a mathematical theorem. Efficiency / symmetry / dummy / additivity axioms all hold exactly; permutation sampling with anytime-valid confidence intervals (bounds while you sample, guaranteed whether you stop or not); synergy detection automatically flags 1+1>2 positive synergies and free-riding negative ones

Optimal Transport / Information Geometry / Optimal Stopping / Sheaf Consensus (17.0 → 20.0)

• Optimal-transport kernel (core/optimal-transport.ts): Wasserstein distance + Sinkhorn — drift detection sees the shape of the distribution. Exact 1-D W₁ (quantile coupling, O(n log n)), log-domain stabilized Sinkhorn (arbitrary cost matrices), Wasserstein barycenter (shape-preserving distribution fusion); once the shape-aware drift monitor (sliding window vs disjoint reference + adaptive quantile threshold) is mounted on meta-cognition — "the mean didn't move but the world changed" becomes visible for the first time (fills the blind spot of the 12.0 watermark detectors, tripwire for 13.0 conformal validity)
• Information-geometry kernel (core/information-geometry.ts): Fisher metric + KL trust region — evolution walks on the manifold. Strategy mutation upgrades from per-coordinate noise to joint correlated steps along the population-covariance principal axes (favorable gene combinations transfer whole); step size is priced in nats (Mahalanobis-capped KL trust region) and strictly invariant under affine reparameterization (numerically verified: identical to 6 decimals after 100×/0.01× coordinate rescaling); condition number / effective dimension make the search geometry itself observable
• Optimal-stopping kernel (core/optimal-stopping.ts): prophet inequality + backward induction — waiting has a mathematical price. Exact stopping-value recursion over the empirical distribution (V_k = E[max(X, V_{k+1})]), prophet benchmark (exact order-statistics E[max]), Samuel-Cahn single-threshold rule (≥ ½ of prophet for any distribution), secretary 1/e rule and Bruss' odds algorithm; once mounted on decision-engine Rule C, defer/execute for costly signals upgrades from the "urgency < 0.3" magic number to a continuation-value verdict (act iff current value ≥ V_{horizon} — mathematically optimal to grab the slot, otherwise waiting pays)
• Sheaf-consensus kernel (core/sheaf-consensus.ts): cellular-sheaf Laplacian + harmonic consensus — the shape of disagreement is visible. "Who must agree with whom, on which claims" becomes a first-class mathematical object (vertex stalks + edge restriction maps); weighted harmonic consensus (dual solve: soft mediation + best fit on the perfect-consensus manifold) reports the consensus assignment, per-source walk-back distances (outlier localization), and structural-obstruction detection — under circular hard constraints with contradictory observations (0.9/0.1/0.5) averaging says a happy 0.5, this kernel says "no solution exists, resolve the contradiction first"; the sheaf_consensus Tool lets the LLM call structured belief fusion at reasoning time

Genesis Layer (21.0 → 25.0)

• Index-scheduling kernel (core/index-scheduling.ts): exact Gittins index computation — model scheduling gets its first provably-optimal policy. Retired-MDP backward induction over the (α,β) triangle yields exact discounted-bandit optimal indices; the learning premium ν − p̂ self-terminates as evidence accumulates (no hand-tuned exploration budget)
• Budget-optimal routing kernel (core/bandit-knapsack.ts): Bandits with Knapsacks — shadow prices emerge endogenously from budget scarcity. Empirical-Bernstein optimism for quality, feasibility from remaining-budget-per-round, the shadow price λ solved live from a mixed-LP vertex of infeasible-high-quality arms vs selected arms
• Robust-statistics kernel (core/robust-statistics.ts): Catoni estimator + median-of-means — heavy-tailed latencies no longer kidnap the mean. Sub-Gaussian confidence under finite variance only (5% contamination at 1e6 magnitude drags the plain mean to 50000, Catoni holds it at 2.69 — four orders of magnitude of robustness); per-model latency streams adapt mean → MoM → Catoni with sample size
• Differential-privacy kernel (core/differential-privacy.ts): Laplace/Gaussian mechanisms + Rényi-DP accounting — telemetry never exposes individuals. Halving budget allocation never overspends (Σε ≤ ε), ids/timestamps auto-skipped, analytic RDP→(ε,δ) conversion
• Capacity-planning kernel (core/capacity-planning.ts): Erlang-C / Kingman inversion — concurrency limits are computed from queueing theory. Heartbeat phase 2.5 feeds the world-model predicted arrival rate × robust mean latency into the planner, inverting the minimum concurrency that holds the target wait; honestly returns infeasible when ρ ≥ 1

Prophet Layer (26.0 → 30.0)

• Gaussian-process kernel (core/gaussian-process.ts): RBF/Matérn Bayesian regression + expected improvement — prediction bias itself becomes a learnable curve. The world-model calibration history's actual/predicted ratio series feeds a GP regression that returns a multiplicative correction factor with uncertainty (the 1.25/0.75 trend magic numbers are taken over by learned corrections); the analytic-EI acquisition function (verified against Monte Carlo) powers discrete-candidate Bayesian optimization
• Kalman-filter kernel (core/kalman-filter.ts): local-linear-trend filtering + RTS smoothing + NIS gating — anomaly detection upgrades from heuristics to a hypothesis test. The full KPI history compresses into (level, slope) sufficient statistics; an alarm fires only when the normalized innovation squared exceeds the χ²(1) 99.7% quantile; slow drifts get early readings from the filtered slope; the random-walk steady state matches the closed form P∞=(√(q²+4qr)−q)/2 exactly
• Extreme-value-theory kernel (core/extreme-value.ts): POT/GPD + Hill estimation — p99.9 is no longer the luck of the sample maximum. Pickands–Balkema–de Haan guarantees threshold exceedances converge to a GPD; Grimshaw profile likelihood reduces the 2-D MLE to a 1-D search; tail quantiles are extrapolated with theorem backing (plus bootstrap CIs); heartbeat phase 2.7 assesses latency tail risk and emits tail-risk insights beyond target
• Monte-Carlo-tree-search kernel (core/mcts.ts): UCT + discounted returns — the allocation of search budget itself becomes a sequential decision. Transition edges sample Bernoulli outcomes from Beta posteriors, UCB1 balances exploit/explore, node-local returns backpropagate without depth bias, and any exhausted iteration/time budget reads out immediately (anytime property); the deliberation engine's searchMcts cross-checks beam search under one shared report format
• Submodular-optimization kernel (core/submodular.ts): weighted coverage + lazy greedy (CELF) — exploration-budget allocation gets its first approximation-ratio guarantee (≥ (1−1/e)·OPT, Nemhauser–Wolsey–Fisher). Knowledge items are themes of their own with similar items partially covering them: a redundant second pick's marginal decays to (1−c)·w, complementary blind spots get picked first; a curvature refinement tightens the guarantee to (1−e^−c)/c·OPT

Equilibrium Layer (31.0 → 35.0)

The prophet layer predicts the world's future; the equilibrium layer admits the world fights back — adversaries, global constraints, noise, worst cases, and feedback instability. Five mathematical pillars lift scheduling from "predictive optimality" to "adversarial equilibrium".

• Online-learning kernel (core/online-learning.ts): Fixed-Share Hedge — no regret no matter how the adversary plays. Every statistical learner in the system (Wilson / UCB / Gittins) assumes a stationary distribution; this kernel layers an adversarial view on top: model scores gain a bounded Hedge multiplier ([0.25, 4]), regret against the best fixed model in hindsight is ≤ √(2T lnN) (Freund–Schapire, distribution-free); the α share keeps weights trackable when model capabilities flip (Herbster–Warmuth), and a model under attack loses weight at e^{−η} per failure — an order of magnitude faster than statistical decay
• Global-assignment kernel (core/optimal-assignment.ts): Hungarian algorithm (Jonker–Volgenant, O(n³)) — batch model selection goes from local greedy to global optimum. Dynamically-assigned nodes in one execution batch form a node × candidate profit matrix solved exactly as a linear sum assignment: the best model is no longer double-booked by same-batch nodes; a dual certificate (u_i + v_j ≤ c_ij + complementary slackness + zero gap) makes optimality checkable digit by digit rather than claimed (same proof-carrying philosophy as 15.0)
• Random-matrix kernel (core/random-matrix.ts): Marchenko–Pastur noise edge + eigenvalue cleansing — correlation upgrades from statistical illusion to falsifiable structural claim. Most of the spectral structure of an empirical model-failure correlation matrix is pure noise (the MP band); cyclic Jacobi eigendecomposition + Laloux/Bouchaud cleansing absorbs pseudo-correlation into the band (no false alarms), while a top eigenvalue far above the edge with sufficient explained share yields a systemic-risk insight: models sharing a vendor/upstream sink together, and "seemingly diversified" hot spares are an illusion
• Distributionally-robust kernel (core/robust-decisions.ts): CVaR + Wasserstein balls — the worst case gets a closed-form price. Per-model timeout = margin × CVaR_α(latency history) (exact Rockafellar–Uryasev form, backed by the four coherence axioms): heavy-tailed models automatically earn longer budgets, light-tailed ones are no longer clipped by one-size-fits-all; the Wasserstein-1 robust mean is an algebraic identity of Kantorovich–Rubinstein duality (sup = E + ε), and worst-case exceedance inside the ball has an exact finite-sample algorithm
• Feedback-control kernel (core/feedback-control.ts): discrete LQR + Lyapunov certificate — closed-loop steering of the concurrency ceiling. The 25.0 queueing inversion produces a static target; this kernel turns computeParallelism into a feedback controller tracking it: the gain comes from the DARE closed form (cross-checked digit-for-digit against fixed-point iteration), and every closed-loop step's stability is proven by a Lyapunov function (V(e_{k+1}) − V(e_k) = −(qe² + ru²) to machine precision); deadband anti-chatter and clamping anti-windup retire AIMD-style heuristic tuning

Awakening Layer (36.0 → 40.0)

The equilibrium layer plays against the world; the awakening layer sees its own shape — the topology of knowledge, the information price of distillation, the dynamical constitution of KPIs, influence emerging from structure, and the probabilistic price of recovery. Five mathematical pillars turn "self-awareness" from a reporting format into computable mathematics.

• Persistent-homology kernel (core/persistent-homology.ts): H₀ persistence diagram + bottleneck distance — the shape of knowledge across scales. Co-occurrence weights as similarity, threshold sweep reveals continents (stable knowledge clusters) and islands (memories co-occurring with nothing — the topological definition of a blind spot); the bottleneck distance carries the Cohen-Steiner–Edelsbrunner–Harer stability theorem (input perturbation δ ⟹ landscape drift ≤ δ). A new topology action on query_memory reads the knowledge landscape on demand
• Information-bottleneck kernel (core/information-bottleneck.ts): Blahut–Arimoto / Tishby — the information-theoretic price of distillation. With X = task signatures and Y = outcomes, the IB-optimal retention I(T;Y)/I(X;Y) prices "how much distillable new information this batch carries": homogeneous batches (retention below floor or I(X;Y) < 0.05 nat) are honestly skipped — any watermark only yields duplicate knowledge; the data-processing inequality bounds retention ≤ 1 (three deterministic restarts escape hard-assignment freezes)
• Nonlinear-dynamics kernel (core/nonlinear-dynamics.ts): Rosenstein Lyapunov + R/S Hurst — constitutional classification of KPIs. Chaotic (λ₁ > 0, with a nearest-neighbor predictability gate that rejects white-noise pseudo-chaos) → forecast horizon ~1/λ₁ steps; persistent (H > 0.5) → trend weighting; anti-persistent (H < 0.5) → breakout discounting; the logistic map's λ₁ = ln2 is the analytic anchor
• Spectral-ranking kernel (core/spectral-ranking.ts): PageRank power iteration — influence emerges from the structure of the knowledge graph. "Co-occurring with the important makes you important" as a fixed point, linear convergence with mass conservation checkable digit by digit; related() upgrades to edge-weight × neighbor-influence, topInfluential outputs the knowledge skeleton (the keep-the-bones basis for distillation); the exact uniformity of a ring graph is the verification anchor
• First-passage kernel (core/first-passage.ts): reflection principle + inverse Gaussian + gambler's ruin — the probabilistic price of circuit-breaker recovery. Drift/volatility of failure intervals feed a first-passage model that solves the minimal cooldown such that "confident recovery at target probability"; μ̂ ≤ 0 structural deterioration honestly reports unreachable; the Brownian reflection identity is cross-checked against 20,000 simulated paths

Flux Layer (41.0 → 45.0)

The prophet foresees, the equilibrium layer plays, the awak

…