ruvnet
diff --git a/‎docs/dream-cycle/dream-gist-2026-08-17.md‎
Lines changed: 54 additions & 0 deletions b/‎docs/dream-cycle/dream-gist-2026-08-17.md‎
Lines changed: 54 additions & 0 deletions
diff --git a/‎v3/@claude-flow/cli/__tests__/router-bandit.test.ts‎
Lines changed: 116 additions & 1 deletion b/‎v3/@claude-flow/cli/__tests__/router-bandit.test.ts‎
Lines changed: 116 additions & 1 deletion
diff --git a/‎v3/@claude-flow/cli/benchmarks/results/prior-decay-receipt.json‎
Lines changed: 59 additions & 0 deletions b/‎v3/@claude-flow/cli/benchmarks/results/prior-decay-receipt.json‎
Lines changed: 59 additions & 0 deletions
@@ -0,0 +1,54 @@
+# Intelligence SOTA Report — 2026-08-17
+
+TL;DR: Tonight (2026-08-17, intelligence deep-dive) found that Ruflo's 3-tier model router (`model-router.ts`, ADR-026/143) accumulates its Beta-Bernoulli Thompson-sampling priors forever with zero temporal decay, while the codebase's *other* router (`q-learning-router.ts`) already solves the analogous problem via epsilon annealing — an internal-consistency gap, not a hypothetical one. Shipped an opt-in `priorDecay` config field (default disabled, zero behavior change) implementing discounted Thompson sampling. A 30-trial paired benchmark shows a real, statistically significant recovery-speed improvement in the low-complexity bucket after a simulated model-quality shift — but the effect does **not** generalize to the med-complexity bucket, a limitation an independent adversarial critic's feedback led directly to testing and disclosing.
+
+## What's New in 2026
+
+| Finding | Source | Confidence |
+|---|---|---|
+| Discounted Thompson Sampling remains an active, unsolved-by-default production problem | arXiv 2606.23933 (Jun 2026), arXiv 2305.10718 | A |
+| Confidence-Adaptive Routing (CARE) reallocates MoE expert budget via gate entropy | arXiv 2607.26052 (Jul 2026) | B |
+| Ghost Vectors: soft-deleted embeddings remain reconstructible in HNSW indexes | arXiv 2606.18497 (Jun 2026) | A (general finding); C (Ruflo-specific applicability, unmeasured) |
+| No orchestration framework (LangGraph/AutoGen/CrewAI/OpenAI Agents SDK) does learned/adaptive routing in its core loop — a deliberate, field-wide tradeoff, not an oversight | Live doc/repo review, 2026-08 | A |
+
+## Ruflo Current Capability
+
+`model-router.ts:recordOutcome()` does `bp[model].alpha += reward; bp[model].beta += 1-reward` with **zero decay anywhere in the 1490-line file** (confirmed by direct grep). Persisted forever to `.swarm/model-router-state.json`. Meanwhile `q-learning-router.ts` (a sibling, less-used router) already implements exponential epsilon annealing for its own exploration rate. Two more findings from tonight's architecture pass, not acted on tonight: the MoE gate (`moe-router.ts`) computes routing entropy every call but never uses it for expert-count control (dead signal); and `EWCConsolidator.pruneOldPatterns()` mutates its own pattern Map but never propagates deletions to `LocalReasoningBank` or the HNSW-backed store — three independent, unsynced "forgetting" mechanisms in one pipeline.
+
+## Competitor Comparison
+
+| Framework | Adaptive/learned routing | Forgetting mitigation | 2026 status |
+|---|---|---|---|
+| LangGraph | Developer-written conditionals / LLM-prompted routing only | RAG-style external memory; docs explicitly discourage weight-level fine-tuning | Active |
+| AutoGen / AG2 | LLM-prompted "manager" selection | `TeachableAgent` deprecated v0.12, removed v0.14 (Mar 2026 rewrite) | Maintenance-mode (upstream) |
+| CrewAI | Hierarchical/manager-based, not learned | Context/vector memory only | Active |
+| OpenAI Agents SDK | Developer-defined handoffs | External memory (no built-in continual learning) | Active |
+| Letta (MemGPT) | N/A | Self-editing 3-tier (Core/Recall/Archival) memory — explicit token-space alternative to weight-space continual learning | Active, sharpest comparator |
+
+None of the four major orchestration frameworks implement a real bandit/RL routing policy in their core loop — genuine adaptive routing exists only in standalone services (RouteLLM, MetaLLM) and academic work, never integrated. This is a deliberate cost/complexity tradeoff the field has made, not a gap nobody noticed — which makes Ruflo's own bandit (imperfect as tonight's finding shows) still ahead of the field's default posture. Letta's token-space memory is the sharpest available foil for EWC++'s weight/pattern-space approach, not a "competitors have nothing" claim.
+
+## Hypothesis
+
+Given the router's unbounded Beta-prior accumulation, when an exponential discount (`priorDecay < 1`) is applied to all bucket/model priors once per `recordOutcome()` call before that round's reward, then post-shift recovery speed after a simulated model-quality shift should improve relative to baseline, subject to: no material regression under a stationary (non-shifting) workload.
+
+## Benchmarks
+
+Bespoke deterministic simulation (`benchmarks/results/scripts/prior-decay-benchmark.mjs`) — no LLM calls, $0 cost, seeded PRNG (identical random stream fed to baseline and candidate per trial, isolating the decay math as the only variable). 1500 pre-shift rounds (simulating months of accumulated persisted history) + 300 post-shift rounds, n=30 paired trials, two complexity buckets. An independent adversarial-critic pass found and I fixed a real bug in the paired-t formula (population vs. sample stddev, inflating t by n/(n-1)) before finalizing these numbers.
+
+## Evaluation
+
+**evaluated: accepted, scoped.** Low bucket (haiku→sonnet shift): recovery 26.5→21.9 rounds (**-17.6%**, t=7.00), post-shift correct-routing rate +1.3pp (t=5.90), stationary invariant held (Δ=+0.02pp, t=0.70 — no regression). Med bucket (sonnet→opus shift): recovery essentially flat (Δ=-0.17 rounds, t=-0.74, not significant), stationary invariant held (Δ=-0.08pp; statistically distinguishable from zero at t=-3.01 but two orders of magnitude inside the pre-declared -1pp tolerance). **The mechanism's benefit is real but bucket-scoped** — it helps most where reward asymmetry is largest (haiku success reward=1.0 vs. opus=0.4 in `BANDIT_REWARDS`), which is exactly the case that produces the most entrenched stale posteriors. This was found only because an independent critic asked for med/high-bucket coverage; the first version of this benchmark tested only the low bucket and would have overclaimed generality. Shipped **disabled by default** (`priorDecay: 1`); this is an opt-in mechanism, not a default-behavior change.
+
+## Darwin Results
+
+**Skipped — scope mismatch**, same class of skip as 2026-08-16's security night. `@metaharness/darwin`'s discovered real interface (`evolve --bench <suite.json>`) evolves harness/prompt genomes against LLM-scored coding-task corpora; it has no analog for tuning a single continuous scalar (`priorDecay`) in a deterministic-math function. A γ-value sensitivity sweep (0.995/0.99/0.98) was run directly in the bespoke benchmark instead — 0.995 gave the cleanest signal-to-noise (t=7.00 vs. 6.76/3.71 for 0.99/0.98) and is the value used above.
+
+## SOTA Proof & Witness
+
+See the linked issue and PR for the full witness stamp (session commit, report hash, witness hash) and verifier procedure.
+
+## Recommended Next Steps
+
+1. **Merge tonight's opt-in `priorDecay` candidate** (draft PR) — zero-risk (disabled by default), reviewable single-file diff, evidence-backed for the low-complexity bucket, all findings from an independent adversarial critique addressed (paired-t formula fixed, NaN/negative-decay input validation added, med-bucket coverage added).
+2. **Follow-up candidate:** investigate why the med bucket shows no effect — likely `BANDIT_REWARDS`' smaller success-reward magnitudes for sonnet/opus change entrenchment dynamics; a bucket-scaled decay rate (stronger where reward asymmetry is largest) is the natural next hypothesis, explicitly flagged here rather than implemented tonight.
+3. **Follow-up candidate:** wire the MoE gate's already-computed routing entropy into its `topK` selection (Confidence-Adaptive Routing, arXiv 2607.26052) — currently dead signal, distinct from tonight's candidate, scored highly in tonight's 5-candidate ranking (2nd place).
@@ -18,7 +18,7 @@ import { describe, expect, it, beforeEach, afterEach } from 'vitest';
 import { rmSync, mkdtempSync, writeFileSync, mkdirSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { ModelRouter } from '../src/ruvector/model-router.js';
+import { ModelRouter, sampleBeta } from '../src/ruvector/model-router.js';
 
 let cwdRestore: string;
 let tmpDir: string;
@@ -188,3 +188,118 @@ describe('ModelRouter — Thompson sampling bandit (#1772, ADR-142 bucketed)', (
     expect(meanHaiku).toBeGreaterThan(meanOpus);
   }, 30_000);
 });
+
+describe('ModelRouter — priorDecay (discounted Thompson sampling, arXiv 2305.10718)', () => {
+  beforeEach(setupTempCwd);
+  afterEach(cleanupTempCwd);
+
+  it('defaults priorDecay to 1 (no-op) — identical behavior to a router with no decay config', () => {
+    const withDefault = new ModelRouter();
+    const task = 'simple task';
+    for (let i = 0; i < 5; i++) withDefault.recordOutcome(task, 'haiku', 'success');
+    for (let i = 0; i < 3; i++) withDefault.recordOutcome(task, 'sonnet', 'failure');
+    const p = withDefault.getBanditPriors(bucketOf(withDefault, task));
+    // Same math as the pre-priorDecay assertions above: reward accumulates
+    // with no decay applied anywhere in the call chain.
+    expect(p.haiku.alpha).toBeCloseTo(6.0, 5); // 1 + 5*1.0
+    expect(p.haiku.beta).toBeCloseTo(1.0, 5);
+    expect(p.sonnet.beta).toBeCloseTo(4.0, 5); // 1 + 3*1.0 (failure reward=0)
+  });
+
+  it('decays ALL bucket/model priors once per recordOutcome call, before adding the new reward', () => {
+    const router = new ModelRouter({ priorDecay: 0.5 });
+    const task = 'simple task';
+    const bucket = bucketOf(router, task);
+    // Round 1: decay Beta(1,1)→Beta(1,1) (no-op at the uniform prior), then
+    // haiku success (reward 1.0) → alpha 1*0.5 + 1.0 = 1.5, beta 1*0.5 = 0.5.
+    router.recordOutcome(task, 'haiku', 'success');
+    let p = router.getBanditPriors(bucket);
+    expect(p.haiku.alpha).toBeCloseTo(1.5, 5);
+    expect(p.haiku.beta).toBeCloseTo(0.5, 5);
+    // Round 2: decay is applied to EVERY bucket/model first (this is the
+    // "every routing decision is one time-step for every arm" semantics) —
+    // so sonnet, though untouched in round 1's outcome, already decayed
+    // from Beta(1,1) to Beta(0.5,0.5) as a side effect of round 1's call.
+    // Now: haiku decays 1.5*0.5=0.75, 0.5*0.5=0.25 (no reward added, it
+    // wasn't this round's outcome). sonnet decays 0.5*0.5=0.25, 0.5*0.5=0.25,
+    // then gets this round's failure (reward 0) → alpha stays 0.25, beta
+    // becomes 0.25 + (1 - 0) = 1.25.
+    router.recordOutcome(task, 'sonnet', 'failure');
+    p = router.getBanditPriors(bucket);
+    expect(p.haiku.alpha).toBeCloseTo(0.75, 5);
+    expect(p.haiku.beta).toBeCloseTo(0.25, 5);
+    expect(p.sonnet.alpha).toBeCloseTo(0.25, 5);
+    expect(p.sonnet.beta).toBeCloseTo(1.25, 5);
+  });
+
+  it('floors decayed alpha/beta at PRIOR_DECAY_FLOOR (0.05) instead of collapsing to 0', () => {
+    const router = new ModelRouter({ priorDecay: 0.1 }); // aggressive decay
+    const task = 'simple task';
+    // One bucket/model (opus, in the 'low' bucket) never receives an outcome
+    // directly — but every recordOutcome call for ANY model in this bucket
+    // still decays it. Hammer haiku with outcomes many times; opus's
+    // untouched Beta(1,1) should decay toward the floor, never below it,
+    // and never go non-positive (which would break sampleBeta's Gamma draws).
+    for (let i = 0; i < 50; i++) router.recordOutcome(task, 'haiku', 'failure');
+    const p = router.getBanditPriors(bucketOf(router, task));
+    expect(p.opus.alpha).toBeCloseTo(0.05, 5);
+    expect(p.opus.beta).toBeCloseTo(0.05, 5);
+    expect(p.opus.alpha).toBeGreaterThan(0);
+    expect(p.opus.beta).toBeGreaterThan(0);
+    expect(sampleBeta(p.opus.alpha, p.opus.beta)).not.toBeNaN();
+  });
+
+  it('rejects an out-of-range priorDecay (NaN/negative/>1) by falling back to disabled (1)', () => {
+    // Caught by an independent adversarial-critic pass: Math.max's NaN-
+    // poisoning bypasses sampleBeta's own alpha<=0||beta<=0 fallback, and a
+    // negative decay pins every prior at PRIOR_DECAY_FLOOR on the first
+    // call — either would silently corrupt persisted router state forever.
+    for (const [i, bad] of [NaN, -1, 0, 1.5, Infinity, -Infinity].entries()) {
+      const router = new ModelRouter({
+        priorDecay: bad,
+        statePath: join(tmpDir, `.swarm/state-${i}.json`),
+      });
+      router.recordOutcome('t', 'haiku', 'success');
+      const p = router.getBanditPriors(bucketOf(router, 't'));
+      // Falls through to priorDecay=1 (disabled): plain accumulation, no decay.
+      expect(p.haiku.alpha).toBeCloseTo(2.0, 5);
+      expect(p.haiku.beta).toBeCloseTo(1.0, 5);
+    }
+  });
+
+  it('regression: candidate must not degrade routing under a stationary workload', async () => {
+    // Pre-declared invariant (STEP 3.3 hypothesis, checked in the receipt at
+    // benchmarks/results/prior-decay-receipt.json with n=30 paired trials):
+    // decay must not reduce accuracy when the correct model never changes.
+    // This is the fast in-suite version of that same check.
+    async function runStationary(priorDecay: number): Promise<number> {
+      const router = new ModelRouter({ priorDecay });
+      let seed = 0x2468ace;
+      const rng = () => {
+        seed |= 0;
+        seed = (seed + 0x6D2B79F5) | 0;
+        let t = Math.imul(seed ^ (seed >>> 15), 1 | seed);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+      };
+      const origRandom = Math.random;
+      Math.random = rng;
+      let correct = 0;
+      const N = 150;
+      try {
+        for (let i = 0; i < N; i++) {
+          const r = await router.route('fix a typo in the readme file');
+          const outcome = r.model === 'haiku' ? 'success' : 'failure';
+          router.recordOutcome('fix a typo in the readme file', r.model, outcome);
+          if (r.model === 'haiku') correct++;
+        }
+      } finally {
+        Math.random = origRandom;
+      }
+      return correct / N;
+    }
+    const baseline = await runStationary(1);
+    const candidate = await runStationary(0.995);
+    expect(candidate).toBeGreaterThanOrEqual(baseline - 0.05); // no material regression
+  }, 30_000);
+});
@@ -0,0 +1,59 @@
+{
+  "config": {
+    "TRIALS": 30,
+    "SHIFT_AT": 1500,
+    "POST_ROUNDS": 300,
+    "TOTAL_ROUNDS": 1800,
+    "STATIONARY_ROUNDS": 400,
+    "CANDIDATE_DECAY": 0.995,
+    "RECOVERY_WINDOW": 20,
+    "RECOVERY_THRESHOLD": 14
+  },
+  "scenarios": [
+    {
+      "bucket": "low",
+      "task": "fix a typo in the readme file",
+      "shift": "haiku -> sonnet",
+      "nonStationary": {
+        "baselineMeanRecoveryRound": 26.533333333333335,
+        "candidateMeanRecoveryRound": 21.866666666666667,
+        "recoveryRoundDeltaMean": 4.666666666666667,
+        "recoveryRoundDeltaT": 7,
+        "baselineMeanPostShiftCorrectRate": 0.9582222222222222,
+        "candidateMeanPostShiftCorrectRate": 0.9712222222222221,
+        "postShiftRateDeltaMean": 0.013000000000000012,
+        "postShiftRateDeltaT": 5.8956649538645785
+      },
+      "stationary": {
+        "baselineMeanCorrectRate": 0.9976666666666668,
+        "candidateMeanCorrectRate": 0.9978333333333335,
+        "deltaMean": 0.00016666666666666682,
+        "deltaT": 0.7010887416930878,
+        "invariantHeld": true
+      }
+    },
+    {
+      "bucket": "med",
+      "task": "refactor the payment processing module to support multiple currencies and add integration tests",
+      "shift": "sonnet -> opus",
+      "nonStationary": {
+        "baselineMeanRecoveryRound": 20.4,
+        "candidateMeanRecoveryRound": 20.566666666666666,
+        "recoveryRoundDeltaMean": -0.16666666666666666,
+        "recoveryRoundDeltaT": -0.7397092748646286,
+        "baselineMeanPostShiftCorrectRate": 0.9802222222222222,
+        "candidateMeanPostShiftCorrectRate": 0.9798888888888888,
+        "postShiftRateDeltaMean": -0.000333333333333341,
+        "postShiftRateDeltaT": -0.3324851555379874
+      },
+      "stationary": {
+        "baselineMeanCorrectRate": 0.9955,
+        "candidateMeanCorrectRate": 0.9946666666666669,
+        "deltaMean": -0.0008333333333333452,
+        "deltaT": -3.010398644698114,
+        "invariantHeld": true
+      }
+    }
+  ],
+  "generatedAt": "2026-08-17T06:29:03.189Z"
+}