2sagaco48 1.0.0

package/src/lib/memory-stress-tests.ts

@@ -0,0 +1,248 @@
+/**
+ * Memory Stress Tests — deterministic in-browser workloads that mimic the
+ * heaviest research configurations (SLOOP + N-Deep + Cluster) and verify
+ * the memory governor keeps the heap within budget.
+ *
+ * No network calls. Pure in-browser allocation simulations that mirror the
+ * actual peak memory patterns of each pipeline phase, using the governor's
+ * own safe-cap helpers and draft caps to predict whether the user's chosen
+ * configuration will OOM on their device BEFORE they launch a heavy query.
+ */
+
+import {
+  readMemoryReport,
+  safeClusterWidth,
+  safeNDeepPasses,
+  safeSloopPages,
+  safeDraftCharCap,
+  settleHeap,
+  type MemoryReport,
+} from "./memory-governor";
+
+// ─── Legacy minimal API (back-compat with existing MemoryStressPanel) ─────────
+export interface StressResult {
+  passed: boolean;
+  peakMB: number;
+  durationMs: number;
+  notes: string[];
+}
+
+// ─── New advanced API (R2 patch integration) ─────────────────────────────────
+export interface StressTestStep {
+  name: string;
+  ok: boolean;
+  details: string;
+  pressureBefore: number;
+  pressureAfter: number;
+  ms: number;
+}
+
+export interface StressTestReport {
+  config: {
+    sloopPages: number;
+    sloopSections: number;
+    clusterWidth: number;
+    nDeepPasses: number;
+    draftCharsPerSection: number;
+  };
+  steps: StressTestStep[];
+  startReport: MemoryReport;
+  endReport: MemoryReport;
+  passed: boolean;
+  peakMB: number;
+  durationMs: number;
+  recommendedConfig?: {
+    sloopPages: number;
+    clusterWidth: number;
+    nDeepPasses: number;
+  };
+}
+
+function repeat(s: string, n: number): string {
+  // Array.join is O(n) — avoids quadratic string concatenation.
+  return new Array(n + 1).join(s);
+}
+
+async function timed<T>(fn: () => Promise<T> | T): Promise<{ value: T; ms: number }> {
+  const t0 = performance.now();
+  const value = await fn();
+  return { value, ms: performance.now() - t0 };
+}
+
+function pressure(): number {
+  return readMemoryReport().pressure;
+}
+
+/** Synthetic workload that mimics SLOOP section generation. */
+function sloopSectionAlloc(chars: number): { digest: string; alloc: number } {
+  const block = repeat("LOREM IPSUM DOLOR SIT AMET CONSECTETUR ", Math.max(1, Math.ceil(chars / 40)));
+  const text = block.slice(0, chars);
+  const digest = text.slice(0, 240);
+  return { digest, alloc: text.length };
+}
+
+/** Synthetic workload that mimics N-Deep redraft memory pattern. */
+function nDeepRedraftAlloc(chars: number): string {
+  const a = repeat("X", chars);
+  const b = repeat("Y", chars);
+  const c = repeat("Z", Math.min(safeDraftCharCap(), Math.round(chars * 1.05)));
+  void a.length; void b.length;
+  return c;
+}
+
+/** Synthetic workload that mimics a cluster wave: N parallel payloads. */
+async function clusterWaveAlloc(width: number, payloadChars: number): Promise<number> {
+  const promises = new Array(width).fill(0).map((_v, i) =>
+    Promise.resolve(repeat(String.fromCharCode(65 + (i % 26)), payloadChars))
+  );
+  const arr = await Promise.all(promises);
+  const total = arr.reduce((sum, s) => sum + s.length, 0);
+  return total;
+}
+
+/**
+ * Advanced stress test — separates SLOOP, Cluster, and N-Deep phases with
+ * per-step pressure tracking and recommends a safe configuration on failure.
+ */
+export async function runStressTestAdvanced(opts: {
+  sloopPages: number;
+  clusterWidth: number;
+  nDeepPasses: number;
+  draftCharsPerSection?: number;
+}): Promise<StressTestReport> {
+  const startReport = readMemoryReport();
+  const start = Date.now();
+  const sloopSections = Math.max(4, opts.sloopPages * 2);
+  const draftCharsPerSection = Math.min(
+    opts.draftCharsPerSection ?? 18_000,
+    safeDraftCharCap(),
+  );
+  const steps: StressTestStep[] = [];
+  let peakMB = startReport.usedMB;
+
+  // Step 1 — SLOOP synthetic section pass
+  {
+    const before = pressure();
+    const t = await timed(async () => {
+      let totalAlloc = 0;
+      const digests: string[] = [];
+      for (let i = 0; i < sloopSections; i++) {
+        const { digest, alloc } = sloopSectionAlloc(draftCharsPerSection);
+        digests.push(digest);
+        totalAlloc += alloc;
+        const r = readMemoryReport();
+        if (r.usedMB > peakMB) peakMB = r.usedMB;
+        await new Promise(r => setTimeout(r, 0));
+      }
+      return { digests, totalAlloc };
+    });
+    const after = pressure();
+    steps.push({
+      name: `SLOOP synthetic ${sloopSections} sections @ ${Math.round(draftCharsPerSection / 1024)}KB`,
+      ok: after < 0.92,
+      details: `Allocated ${(t.value.totalAlloc / 1048576).toFixed(1)} MB total; held ${t.value.digests.length} digests`,
+      pressureBefore: before,
+      pressureAfter: after,
+      ms: t.ms,
+    });
+  }
+  await settleHeap(20);
+
+  // Step 2 — Cluster wave parallelism
+  {
+    const before = pressure();
+    const safeWidth = safeClusterWidth(opts.clusterWidth, readMemoryReport());
+    const t = await timed(() => clusterWaveAlloc(safeWidth, 12_000));
+    const after = pressure();
+    const r = readMemoryReport();
+    if (r.usedMB > peakMB) peakMB = r.usedMB;
+    steps.push({
+      name: `Cluster wave width=${opts.clusterWidth} (governor capped to ${safeWidth})`,
+      ok: after < 0.92,
+      details: `Total parallel payload ${(t.value / 1048576).toFixed(1)} MB`,
+      pressureBefore: before,
+      pressureAfter: after,
+      ms: t.ms,
+    });
+  }
+  await settleHeap(20);
+
+  // Step 3 — N-Deep redraft loop
+  {
+    const before = pressure();
+    const safePasses = safeNDeepPasses(opts.nDeepPasses, draftCharsPerSection * sloopSections, readMemoryReport());
+    const t = await timed(async () => {
+      let current = repeat("S", Math.min(safeDraftCharCap(), draftCharsPerSection * 2));
+      for (let p = 0; p < safePasses; p++) {
+        current = nDeepRedraftAlloc(current.length);
+        const r = readMemoryReport();
+        if (r.usedMB > peakMB) peakMB = r.usedMB;
+        await new Promise(r => setTimeout(r, 0));
+      }
+      return current.length;
+    });
+    const after = pressure();
+    steps.push({
+      name: `N-Deep redraft passes requested=${opts.nDeepPasses} (governor capped to ${safePasses})`,
+      ok: after < 0.95,
+      details: `Final working draft chars ${t.value}`,
+      pressureBefore: before,
+      pressureAfter: after,
+      ms: t.ms,
+    });
+  }
+
+  const endReport = readMemoryReport();
+  const passed = steps.every(s => s.ok) && endReport.pressure < 0.92;
+  const durationMs = Date.now() - start;
+
+  let recommendedConfig: StressTestReport["recommendedConfig"] | undefined;
+  if (!passed) {
+    recommendedConfig = {
+      sloopPages: safeSloopPages(opts.sloopPages, endReport),
+      clusterWidth: safeClusterWidth(opts.clusterWidth, endReport),
+      nDeepPasses: safeNDeepPasses(opts.nDeepPasses, draftCharsPerSection * sloopSections, endReport),
+    };
+  }
+
+  return {
+    config: {
+      sloopPages: opts.sloopPages,
+      sloopSections,
+      clusterWidth: opts.clusterWidth,
+      nDeepPasses: opts.nDeepPasses,
+      draftCharsPerSection,
+    },
+    steps,
+    startReport,
+    endReport,
+    passed,
+    peakMB,
+    durationMs,
+    recommendedConfig,
+  };
+}
+
+/** Legacy entry point — returns minimal StressResult shape for existing callers. */
+export async function runMemoryStressTest(opts: {
+  pages: number;
+  passes: number;
+  cluster: number;
+  onProgress?: (msg: string) => void;
+}): Promise<StressResult> {
+  opts.onProgress?.(`start: pages=${opts.pages} passes=${opts.passes} cluster=${opts.cluster}`);
+  const report = await runStressTestAdvanced({
+    sloopPages: opts.pages,
+    clusterWidth: opts.cluster,
+    nDeepPasses: opts.passes,
+  });
+  for (const s of report.steps) {
+    opts.onProgress?.(`${s.name}: ${s.ok ? "OK" : "FAIL"} (${s.pressureBefore.toFixed(2)} → ${s.pressureAfter.toFixed(2)})`);
+  }
+  return {
+    passed: report.passed,
+    peakMB: report.peakMB,
+    durationMs: report.durationMs,
+    notes: report.steps.map(s => `${s.name}: ${s.ok ? "ok" : "warn"}`),
+  };
+}

package/src/lib/model-intelligence.ts

@@ -0,0 +1,48 @@
+/**
+ * Model intelligence ratings — Arena.ai / LMSys Arena-aligned Elo-style scores.
+ * Higher = stronger. Used for tie-breaking in N-Deep accept/reject judge:
+ * when the judge cannot confidently decide between the critic's revision and
+ * the original text, the text produced by the *stronger* author model wins.
+ *
+ * Scores are normalized to the 0..100 band and reflect Arena leaderboard
+ * rankings as of early 2026. They are deliberately approximate (±3 pts) and
+ * used only as a deterministic ordering signal — never as an absolute quality
+ * claim.
+ */
+import type { ModelId } from "./models";
+
+export const MODEL_INTELLIGENCE: Record<ModelId, number> = {
+  // Gemini frontier
+  "gemini-3.5-flash": 92,
+  "gemini-3-flash-preview": 90,
+  "gemini-2.5-pro": 94,
+  "gemini-2.5-flash": 88,
+  "gemini-3.1-flash-lite": 82,
+  "gemini-2.5-flash-lite": 78,
+  // Gemma open weights
+  "gemma-4-31b-it": 80,
+  "gemma-4-26b-it": 76,
+  "gemma-3-27b-it": 74,
+  // Claude
+  "claude-3-7-sonnet-latest": 93,
+  "claude-3-5-sonnet-latest": 89,
+  "claude-3-5-haiku-latest": 80,
+  // Grok
+  "grok-2-latest": 86,
+  // DeepSeek
+  "deepseek-reasoner": 91,
+  "deepseek-chat": 85,
+};
+
+export function intelligenceOf(model: ModelId | string): number {
+  return (MODEL_INTELLIGENCE as Record<string, number>)[model] ?? 70;
+}
+
+/** Compare two model IDs. Returns a (intelligence > b ? 1 : a === b ? 0 : -1). */
+export function compareIntelligence(a: ModelId | string, b: ModelId | string): number {
+  const ai = intelligenceOf(a);
+  const bi = intelligenceOf(b);
+  if (ai > bi) return 1;
+  if (ai < bi) return -1;
+  return 0;
+}

package/src/lib/model-rotator.ts

@@ -0,0 +1,75 @@
+import { geminiGenerate, type GenerateResult } from "./v15-gemini";
+import { GEMINI_ELO_ROSTER, getModelEloInfo, type ModelEloRating } from "./elo-registry";
+import { tryAcquire, recordResult, snapshotUsage } from "./v15-rate-limiter";
+import { getAllowedModels } from "./v15-state";
+
+export const ROTATION_POOL = [...GEMINI_ELO_ROSTER];
+
+export function getActiveRotationPool(): string[] {
+  try {
+    const allowed = getAllowedModels();
+    const filtered = allowed?.length ? GEMINI_ELO_ROSTER.filter(m => allowed.includes(m)) : [];
+    return filtered.length ? filtered : ROTATION_POOL;
+  } catch { return ROTATION_POOL; }
+}
+
+export interface RotationAttempt { model: string; elo: number; tier?: string; ok: boolean; latencyMs: number; error?: string }
+export interface RotatedGenerateResult extends GenerateResult { modelUsed: string; eloInfo: ModelEloRating; attempts: RotationAttempt[] }
+
+const usedThisRound = new Set<string>();
+function shuffle<T>(xs: T[]): T[] { const out = [...xs]; for (let i = out.length - 1; i > 0; i--) { const j = Math.floor(Math.random() * (i + 1)); [out[i], out[j]] = [out[j], out[i]]; } return out; }
+
+function roundRobinOrder(pool: string[], preferred?: string) {
+  if (usedThisRound.size >= pool.length) usedThisRound.clear();
+  const unused = pool.filter(m => !usedThisRound.has(m));
+  const used = pool.filter(m => usedThisRound.has(m));
+  if (preferred && unused.includes(preferred)) return [preferred, ...shuffle(unused.filter(m => m !== preferred)), ...shuffle(used)];
+  return [...shuffle(unused), ...shuffle(used)];
+}
+
+export async function generateWithRotation(opts: { apiKey: string; prompt: string; systemInstruction?: string; preferredModel?: string; maxOutputTokens?: number; pool?: string[] }): Promise<RotatedGenerateResult> {
+  const pool = opts.pool ?? getActiveRotationPool();
+  const order = roundRobinOrder(pool, opts.preferredModel);
+  const attempts: RotationAttempt[] = [];
+  const webHint = "\n\nIf this model has native web-search/tool grounding available, use it to verify time-sensitive factual claims; otherwise rely only on provided evidence and state uncertainty.";
+  for (const model of order) {
+    const eloInfo = getModelEloInfo(model);
+    const acquired = await tryAcquire(model, true);
+    if (!acquired) {
+      const s = snapshotUsage(model);
+      attempts.push({ model, elo: eloInfo.elo, tier: eloInfo.tier, ok: false, latencyMs: 0, error: `rate-limit skip (RPM ${s.rpmUsed}/${s.rpmMax}, RPD ${s.rpdUsed}/${s.rpdMax})` });
+      continue;
+    }
+    const res = await geminiGenerate({ apiKey: opts.apiKey, model, prompt: opts.prompt + webHint, systemInstruction: opts.systemInstruction, maxOutputTokens: opts.maxOutputTokens });
+    recordResult(model, res.ok);
+    attempts.push({ model, elo: eloInfo.elo, tier: eloInfo.tier, ok: res.ok, latencyMs: res.latencyMs, error: res.error });
+    if (res.ok && res.text.trim()) { usedThisRound.add(model); return { ...res, modelUsed: model, eloInfo, attempts }; }
+    await new Promise(r => setTimeout(r, 150));
+  }
+  const fallback = order[0] ?? "gemini-3.5-flash";
+  return { text: "", ok: false, error: `All models failed (${attempts.map(a => `${a.model}: ${a.error}`).join("; ")})`, latencyMs: attempts.reduce((a, b) => a + b.latencyMs, 0), modelUsed: fallback, eloInfo: getModelEloInfo(fallback), attempts };
+}
+
+export interface JudgeResult { model: string; score: number; note?: string }
+export interface ParallelJudgeResult { judgments: JudgeResult[]; attempts: RotationAttempt[] }
+
+export async function parallelJudgeRotation(opts: { apiKey: string; question: string; answer: string; judgeModels?: string[] }): Promise<ParallelJudgeResult> {
+  const models = opts.judgeModels ?? getActiveRotationPool();
+  const attempts: RotationAttempt[] = [];
+  const judgments: JudgeResult[] = [];
+  await Promise.all(models.map(async model => {
+    const prompt = `Score the answer 0-10. Penalize truncation, prompt leakage, hallucinated citations, missing scope, and missing computations. Return JSON only: {"score": number, "note": "short rationale"}\n\nQUESTION:\n${opts.question}\n\nANSWER:\n${opts.answer.slice(0, 8000)}`;
+    const res = await generateWithRotation({ apiKey: opts.apiKey, prompt, preferredModel: model, pool: [model], maxOutputTokens: 350 });
+    attempts.push(...res.attempts);
+    if (!res.ok) return;
+    try {
+      const m = res.text.match(/\{[\s\S]*\}/);
+      const j = JSON.parse(m ? m[0] : res.text);
+      judgments.push({ model: res.modelUsed, score: Math.max(0, Math.min(10, Number(j.score) || 0)), note: String(j.note ?? "") });
+    } catch {
+      const truncated = /\b(to|the|of|is|and|a|an)\s*$/i.test(opts.answer.trim()) || opts.answer.trim().length < 160;
+      judgments.push({ model: res.modelUsed, score: truncated ? 1 : 7, note: "Deterministic judge fallback; model JSON was malformed." });
+    }
+  }));
+  return { judgments, attempts };
+}