zouroboros-memory 3.0.0

package/dist/embeddings.js

@@ -0,0 +1,233 @@
+/**
+ * Vector embeddings for semantic search
+ *
+ * ECC-010: Memory Explosion Throttling
+ *   - Rate limiting: max MAX_EMBEDDINGS_PER_MINUTE per conversation (sliding window)
+ *   - Dedup: same content hash within DEDUP_COOLDOWN_MS returns cached embedding
+ *   - Tail sampling: when rate limited, return last cached embedding for the conversation
+ *   - Metrics: throttleCount / dedupCount exported for observability
+ */
+import { createHash } from 'node:crypto';
+// ─── ECC-010 Constants ────────────────────────────────────────────────────────
+const MAX_EMBEDDINGS_PER_MINUTE = 20;
+const DEDUP_COOLDOWN_MS = 300_000; // 5 minutes
+const TAIL_SAMPLE_K = 10; // keep last K embeddings per conversation when limited
+/** Per-conversation sliding rate window. Key: conversationId. */
+const _rateWindows = new Map();
+/** Per-content dedup cache. Key: SHA-256 hex of text. */
+const _dedupCache = new Map();
+/** Exported metrics counters — reset only on process restart. */
+export const throttleMetrics = {
+    throttleCount: 0,
+    dedupCount: 0,
+};
+function contentHash(text) {
+    return createHash('sha256').update(text).digest('hex');
+}
+/**
+ * ECC-010: Check rate limit for a conversation window.
+ * Returns the tail-sampled embedding if over limit, or null if under limit.
+ */
+function checkRateLimit(conversationId) {
+    const now = Date.now();
+    let window = _rateWindows.get(conversationId);
+    if (!window || now - window.windowStart > 60_000) {
+        window = { count: 0, windowStart: now, tail: [] };
+        _rateWindows.set(conversationId, window);
+    }
+    if (window.count >= MAX_EMBEDDINGS_PER_MINUTE) {
+        // Return tail sample (last produced in this window) or empty fallback
+        const sample = window.tail[window.tail.length - 1] ?? [];
+        throttleMetrics.throttleCount++;
+        return sample;
+    }
+    return null;
+}
+/** ECC-010: Record a produced embedding in the rate window tail buffer. */
+function recordInWindow(conversationId, embedding) {
+    const window = _rateWindows.get(conversationId);
+    if (!window)
+        return;
+    window.count++;
+    window.tail.push(embedding);
+    if (window.tail.length > TAIL_SAMPLE_K) {
+        window.tail.shift();
+    }
+}
+/** ECC-010: Reset throttle state (for testing). */
+export function resetThrottleState() {
+    _rateWindows.clear();
+    _dedupCache.clear();
+    throttleMetrics.throttleCount = 0;
+    throttleMetrics.dedupCount = 0;
+}
+// ─── Internal Ollama call ─────────────────────────────────────────────────────
+async function _generateEmbeddingFromOllama(text, config) {
+    const response = await fetch(`${config.ollamaUrl}/api/embeddings`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ model: config.ollamaModel, prompt: text }),
+    });
+    if (!response.ok) {
+        throw new Error(`Ollama error: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data.embedding;
+}
+/**
+ * Generate embeddings for text using Ollama.
+ *
+ * ECC-010: Throttling applied when conversationId is provided:
+ *   1. Dedup check — returns cached embedding if same content seen within 5 min
+ *   2. Rate limit check — returns tail-sampled embedding if > 20/min per conversation
+ *   3. Ollama call — only reached if dedup and rate limit both pass
+ *
+ * @param conversationId  Optional. When provided, enables per-conversation throttling.
+ */
+export async function generateEmbedding(text, config, conversationId) {
+    if (!config.vectorEnabled) {
+        throw new Error('Vector search is disabled in configuration');
+    }
+    if (conversationId) {
+        // Layer 1: Dedup check
+        const hash = contentHash(text);
+        const cached = _dedupCache.get(hash);
+        if (cached && Date.now() < cached.expiresAt) {
+            throttleMetrics.dedupCount++;
+            return cached.embedding;
+        }
+        // Layer 2: Rate limit check (tail sampling on overflow)
+        const sampled = checkRateLimit(conversationId);
+        if (sampled !== null) {
+            return sampled;
+        }
+        // Layer 3: Produce embedding and cache it
+        const embedding = await _generateEmbeddingFromOllama(text, config);
+        _dedupCache.set(hash, { embedding, expiresAt: Date.now() + DEDUP_COOLDOWN_MS });
+        recordInWindow(conversationId, embedding);
+        return embedding;
+    }
+    // No conversationId: bypass throttling (internal/system calls)
+    return _generateEmbeddingFromOllama(text, config);
+}
+/**
+ * Generate a hypothetical answer using Ollama's generate endpoint.
+ * Used by HyDE to create an ideal document for embedding.
+ */
+export async function generateHypotheticalAnswer(query, config, options = {}) {
+    const model = options.model ?? 'llama3';
+    const prompt = `Answer the following question concisely in 2-3 sentences as if you had perfect knowledge. Do not hedge or say "I don't know".\n\nQuestion: ${query}\n\nAnswer:`;
+    const response = await fetch(`${config.ollamaUrl}/api/generate`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            model,
+            prompt,
+            stream: false,
+            options: { num_predict: options.maxTokens ?? 150 },
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`Ollama generate error: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data.response.trim();
+}
+/**
+ * Generate HyDE (Hypothetical Document Expansion) embeddings.
+ *
+ * 1. Embeds the original query.
+ * 2. Uses an LLM to generate a hypothetical ideal answer.
+ * 3. Embeds the hypothetical answer.
+ * 4. Returns both embeddings so the caller can blend them.
+ *
+ * Falls back to duplicating the original embedding if generation fails.
+ */
+export async function generateHyDEExpansion(query, config, options = {}) {
+    const original = await generateEmbedding(query, config);
+    let hypothetical;
+    try {
+        hypothetical = await generateHypotheticalAnswer(query, config, {
+            model: options.generationModel,
+            maxTokens: options.maxTokens,
+        });
+    }
+    catch {
+        return { original, expanded: original, hypothetical: query };
+    }
+    const expanded = await generateEmbedding(hypothetical, config);
+    return { original, expanded, hypothetical };
+}
+/**
+ * Blend two embeddings by weighted average.
+ * Default: 40% original query, 60% hypothetical answer (HyDE sweet spot).
+ */
+export function blendEmbeddings(a, b, weightA = 0.4) {
+    if (a.length !== b.length) {
+        throw new Error('Embeddings must have the same dimension');
+    }
+    const weightB = 1 - weightA;
+    return a.map((val, i) => val * weightA + b[i] * weightB);
+}
+/**
+ * Calculate cosine similarity between two vectors
+ */
+export function cosineSimilarity(a, b) {
+    if (a.length !== b.length) {
+        throw new Error('Vectors must have the same length');
+    }
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        dotProduct += a[i] * b[i];
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+/**
+ * Serialize embedding for SQLite storage
+ */
+export function serializeEmbedding(embedding) {
+    // Convert to Float32Array and then to Buffer
+    const floatArray = new Float32Array(embedding);
+    return Buffer.from(floatArray.buffer);
+}
+/**
+ * Deserialize embedding from SQLite storage
+ */
+export function deserializeEmbedding(buffer) {
+    const floatArray = new Float32Array(buffer.buffer, buffer.byteOffset, buffer.length / 4);
+    return Array.from(floatArray);
+}
+/**
+ * Check if Ollama is available
+ */
+export async function checkOllamaHealth(config) {
+    try {
+        const response = await fetch(`${config.ollamaUrl}/api/tags`, {
+            method: 'GET',
+            signal: AbortSignal.timeout(5000),
+        });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * List available models from Ollama
+ */
+export async function listAvailableModels(config) {
+    try {
+        const response = await fetch(`${config.ollamaUrl}/api/tags`);
+        if (!response.ok)
+            return [];
+        const data = await response.json();
+        return data.models?.map(m => m.name) || [];
+    }
+    catch {
+        return [];
+    }
+}

package/dist/episode-summarizer.d.ts

@@ -0,0 +1,51 @@
+#!/usr/bin/env bun
+/**
+ * episode-summarizer.ts — Recursive Episode Summarization for Long Conversations
+ * MEM-002: Recursive Episode Summarization
+ *
+ * When episode count exceeds threshold, oldest messages are summarized into
+ * compressed episode records — preserving gist without token explosion.
+ *
+ * Usage:
+ *   bun episode-summarizer.ts summarize --episodeIds <id1,id2,...> --outputTokens 800
+ *   bun episode-summarizer.ts should-summarize --epCount 25 --threshold 20
+ *   bun episode-summarizer.ts list-summaries
+ */
+import { Database } from "bun:sqlite";
+export interface CompressedEpisode {
+    id: string;
+    summary: string;
+    compressedFrom: string[];
+    compressionRatio: number;
+    originalTokenEstimate: number;
+    compressedTokenEstimate: number;
+    keyDecisions: string[];
+    keyOutcomes: string[];
+    createdAt: number;
+}
+export interface SummarizationResult {
+    compressedEpisode: CompressedEpisode;
+    originalCount: number;
+    originalTokens: number;
+    compressedTokens: number;
+    compressionRatio: number;
+}
+export interface EpisodeForCompression {
+    id: string;
+    summary: string;
+    outcome: string;
+    happenedAt: number;
+    durationMs?: number;
+    entities: string[];
+    metadata?: Record<string, unknown>;
+}
+export declare function compressEpisodes(episodeIds: string[], db?: Database): Promise<SummarizationResult>;
+export declare function getCompressedEpisode(compressedId: string, db?: Database): CompressedEpisode | null;
+export declare function listCompressedEpisodes(limit?: number, db?: Database): CompressedEpisode[];
+export interface ShouldSummarizeResult {
+    shouldCompress: boolean;
+    reason: string;
+    oldestEpisodes?: string[];
+    oldestTimestamp?: number;
+}
+export declare function shouldSummarize(count: number, threshold?: number, db?: Database): ShouldSummarizeResult;

package/dist/episode-summarizer.js

@@ -0,0 +1,285 @@
+#!/usr/bin/env bun
+/**
+ * episode-summarizer.ts — Recursive Episode Summarization for Long Conversations
+ * MEM-002: Recursive Episode Summarization
+ *
+ * When episode count exceeds threshold, oldest messages are summarized into
+ * compressed episode records — preserving gist without token explosion.
+ *
+ * Usage:
+ *   bun episode-summarizer.ts summarize --episodeIds <id1,id2,...> --outputTokens 800
+ *   bun episode-summarizer.ts should-summarize --epCount 25 --threshold 20
+ *   bun episode-summarizer.ts list-summaries
+ */
+import { Database } from "bun:sqlite";
+import { randomUUID } from "crypto";
+const DB_PATH = process.env.ZO_MEMORY_DB || "/home/workspace/.zo/memory/shared-facts.db";
+const OLLAMA_URL = process.env.OLLAMA_URL || "http://localhost:11434";
+const SUMMARIZE_MODEL = process.env.ZO_SUMMARIZE_MODEL || "qwen2.5:7b";
+const EPISODE_WINDOW = 14 * 24 * 3600; // 14 days in seconds
+// ─── Database ─────────────────────────────────────────────────────────────────
+function getDb() {
+    const db = new Database(DB_PATH);
+    db.exec("PRAGMA journal_mode = WAL");
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS compressed_episodes (
+      id TEXT PRIMARY KEY,
+      summary TEXT NOT NULL,
+      compressed_from TEXT NOT NULL,
+      key_decisions TEXT NOT NULL DEFAULT '[]',
+      key_outcomes TEXT NOT NULL DEFAULT '[]',
+      original_token_estimate INTEGER NOT NULL DEFAULT 0,
+      compressed_token_estimate INTEGER NOT NULL DEFAULT 0,
+      compression_ratio REAL NOT NULL DEFAULT 0,
+      created_at INTEGER DEFAULT (strftime('%s','now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_compressed_episodes_created ON compressed_episodes(created_at);
+  `);
+    return db;
+}
+// ─── Ollama summarization ─────────────────────────────────────────────────────
+async function generateSummary(episodes) {
+    const prompt = `You are compressing a sequence of conversation episodes into a single summary.
+
+EPISODES TO COMPRESS (oldest first):
+${episodes.map((e, i) => `[${i + 1}] (${e.outcome}) ${e.summary}`).join("\n")}
+
+Generate a concise summary that preserves:
+1. The overall arc and flow
+2. Key decisions made and their rationale
+3. Final outcomes
+4. Any unresolved threads
+
+Respond ONLY with valid JSON (no markdown, no explanation):
+{
+  "summary": "2-3 sentence narrative of the full sequence",
+  "keyDecisions": ["decision 1", "decision 2"],
+  "keyOutcomes": ["outcome 1", "outcome 2"]
+}`;
+    const resp = await fetch(`${OLLAMA_URL}/api/generate`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            model: SUMMARIZE_MODEL,
+            prompt,
+            stream: false,
+            keep_alive: "1h",
+            options: { temperature: 0.3, num_predict: 400 },
+        }),
+    });
+    if (!resp.ok)
+        throw new Error(`Ollama error: ${resp.status}`);
+    const data = await resp.json();
+    const raw = data.response.trim();
+    const jsonMatch = raw.match(/\{[\s\S]*\}/);
+    if (!jsonMatch)
+        throw new Error(`Failed to parse summary JSON: ${raw.slice(0, 200)}`);
+    return JSON.parse(jsonMatch[0]);
+}
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+// ─── Core summarization logic ─────────────────────────────────────────────────
+export async function compressEpisodes(episodeIds, db) {
+    const _db = db || getDb();
+    // Load episodes
+    const episodes = [];
+    for (const id of episodeIds) {
+        const row = _db.prepare("SELECT * FROM episodes WHERE id = ?").get(id);
+        if (!row)
+            continue;
+        const entities = _db.prepare("SELECT entity FROM episode_entities WHERE episode_id = ?").all(id).map(e => e.entity);
+        episodes.push({
+            id: row.id,
+            summary: row.summary,
+            outcome: row.outcome,
+            happenedAt: row.happened_at,
+            durationMs: row.duration_ms,
+            entities,
+            metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
+        });
+    }
+    if (episodes.length === 0)
+        throw new Error("No valid episodes found for compression");
+    // Sort oldest first
+    episodes.sort((a, b) => a.happenedAt - b.happenedAt);
+    // Generate compressed summary via Ollama
+    const { summary, keyDecisions, keyOutcomes } = await generateSummary(episodes);
+    // Compute compression stats
+    const originalTokens = episodes.reduce((sum, e) => sum + estimateTokens(e.summary), 0);
+    const compressedTokens = estimateTokens(summary);
+    const compressionRatio = originalTokens > 0 ? Math.max(0, 1 - (compressedTokens / originalTokens)) : 0;
+    // Store compressed episode
+    const compressedId = `cmpe-${randomUUID().slice(0, 8)}`;
+    const nowSec = Math.floor(Date.now() / 1000);
+    _db.prepare(`
+    INSERT INTO compressed_episodes
+      (id, summary, compressed_from, key_decisions, key_outcomes, original_token_estimate, compressed_token_estimate, compression_ratio, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(compressedId, summary, JSON.stringify(episodeIds), JSON.stringify(keyDecisions), JSON.stringify(keyOutcomes), originalTokens, compressedTokens, compressionRatio, nowSec);
+    const compressedEpisode = {
+        id: compressedId,
+        summary,
+        compressedFrom: episodeIds,
+        compressionRatio,
+        originalTokenEstimate: originalTokens,
+        compressedTokenEstimate: compressedTokens,
+        keyDecisions,
+        keyOutcomes,
+        createdAt: nowSec,
+    };
+    return {
+        compressedEpisode,
+        originalCount: episodes.length,
+        originalTokens,
+        compressedTokens,
+        compressionRatio,
+    };
+}
+export function getCompressedEpisode(compressedId, db) {
+    const _db = db || getDb();
+    const row = _db.prepare("SELECT * FROM compressed_episodes WHERE id = ?").get(compressedId);
+    if (!row)
+        return null;
+    return {
+        id: row.id,
+        summary: row.summary,
+        compressedFrom: JSON.parse(row.compressed_from),
+        compressionRatio: row.compression_ratio,
+        originalTokenEstimate: row.original_token_estimate,
+        compressedTokenEstimate: row.compressed_token_estimate,
+        keyDecisions: JSON.parse(row.key_decisions),
+        keyOutcomes: JSON.parse(row.key_outcomes),
+        createdAt: row.created_at,
+    };
+}
+export function listCompressedEpisodes(limit = 20, db) {
+    const _db = db || getDb();
+    const rows = _db.prepare("SELECT * FROM compressed_episodes ORDER BY created_at DESC LIMIT ?").all(limit);
+    return rows.map(row => ({
+        id: row.id,
+        summary: row.summary,
+        compressedFrom: JSON.parse(row.compressed_from),
+        compressionRatio: row.compression_ratio,
+        originalTokenEstimate: row.original_token_estimate,
+        compressedTokenEstimate: row.compressed_token_estimate,
+        keyDecisions: JSON.parse(row.key_decisions),
+        keyOutcomes: JSON.parse(row.key_outcomes),
+        createdAt: row.created_at,
+    }));
+}
+export function shouldSummarize(count, threshold = 20, db) {
+    if (count <= threshold) {
+        return { shouldCompress: false, reason: `Episode count ${count} is below threshold ${threshold}` };
+    }
+    const _db = db || getDb();
+    const cutoff = Math.floor(Date.now() / 1000) - EPISODE_WINDOW;
+    const oldEps = _db.prepare("SELECT id, happened_at FROM episodes WHERE happened_at < ? ORDER BY happened_at ASC LIMIT ?").all(cutoff, Math.min(count - threshold + 1, 50));
+    if (oldEps.length === 0) {
+        return { shouldCompress: false, reason: "No episodes older than 14 days to compress" };
+    }
+    return {
+        shouldCompress: true,
+        reason: `${oldEps.length} episodes exceed window threshold`,
+        oldestEpisodes: oldEps.map(e => e.id),
+        oldestTimestamp: oldEps[0]?.happened_at,
+    };
+}
+// ─── CLI ─────────────────────────────────────────────────────────────────────
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.length === 0) {
+        console.log(`Episode Summarizer CLI - v1.0
+
+Commands:
+  should-summarize --count <n> --threshold <n>
+  summarize --episodeIds <id1,id2,...> --outputTokens <n>
+  list-summaries
+  show-summary <compressedId>
+`);
+        process.exit(0);
+    }
+    const command = args[0];
+    switch (command) {
+        case "should-summarize": {
+            let count = 0, threshold = 20;
+            for (let i = 1; i < args.length; i++) {
+                if (args[i] === "--count" || args[i] === "-c")
+                    count = parseInt(args[i + 1] || "0");
+                if (args[i] === "--threshold" || args[i] === "-t")
+                    threshold = parseInt(args[i + 1] || "20");
+            }
+            const result = shouldSummarize(count, threshold);
+            console.log(`Should compress: ${result.shouldCompress}`);
+            console.log(`Reason: ${result.reason}`);
+            if (result.oldestEpisodes?.length)
+                console.log(`Episode candidates: ${result.oldestEpisodes.length}`);
+            break;
+        }
+        case "summarize": {
+            let episodeIds = [];
+            for (let i = 1; i < args.length; i++) {
+                if (args[i] === "--episodeIds" || args[i] === "-e") {
+                    episodeIds = (args[i + 1] || "").split(",").map(s => s.trim()).filter(Boolean);
+                }
+            }
+            if (episodeIds.length === 0) {
+                console.error("No episode IDs provided");
+                process.exit(1);
+            }
+            console.log(`Compressing ${episodeIds.length} episodes...`);
+            const result = await compressEpisodes(episodeIds);
+            console.log(`\nCompressed Episode: ${result.compressedEpisode.id}`);
+            console.log(`Summary: ${result.compressedEpisode.summary}`);
+            console.log(`Decisions: ${result.compressedEpisode.keyDecisions.join(", ") || "(none)"}`);
+            console.log(`Outcomes: ${result.compressedEpisode.keyOutcomes.join(", ") || "(none)"}`);
+            console.log(`Compression: ${result.originalTokens}t -> ${result.compressedTokens}t (${Math.round(result.compressionRatio * 100)}% saved)`);
+            break;
+        }
+        case "list-summaries": {
+            const summaries = listCompressedEpisodes();
+            if (summaries.length === 0) {
+                console.log("No compressed episodes.");
+                break;
+            }
+            console.log(`Compressed Episodes (${summaries.length})\n`);
+            for (const s of summaries) {
+                console.log(`[${s.id}] ${s.compressionRatio.toFixed(1)}% saved | ${s.compressedFrom.length} -> 1 episodes`);
+                console.log(`  ${s.summary.slice(0, 120)}${s.summary.length > 120 ? "..." : ""}`);
+                if (s.keyDecisions.length > 0)
+                    console.log(`  Decisions: ${s.keyDecisions.slice(0, 3).join(" | ")}`);
+                if (s.keyOutcomes.length > 0)
+                    console.log(`  Outcomes: ${s.keyOutcomes.slice(0, 3).join(" | ")}`);
+                console.log();
+            }
+            break;
+        }
+        case "show-summary": {
+            const id = args[1];
+            if (!id) {
+                console.error("Provide a compressed episode ID");
+                process.exit(1);
+            }
+            const s = getCompressedEpisode(id);
+            if (!s) {
+                console.error(`Compressed episode not found: ${id}`);
+                process.exit(1);
+            }
+            console.log(`Compressed Episode: ${s.id}`);
+            console.log(`Created: ${new Date(s.createdAt * 1000).toISOString()}`);
+            console.log(`Compression: ${s.originalTokenEstimate}t -> ${s.compressedTokenEstimate}t (${Math.round(s.compressionRatio * 100)}% saved)`);
+            console.log(`\nSummary:\n${s.summary}`);
+            if (s.keyDecisions.length > 0)
+                console.log(`\nKey Decisions: ${s.keyDecisions.join(", ")}`);
+            if (s.keyOutcomes.length > 0)
+                console.log(`Key Outcomes: ${s.keyOutcomes.join(", ")}`);
+            console.log(`\nCompressed from ${s.compressedFrom.length} episodes: ${s.compressedFrom.join(", ")}`);
+            break;
+        }
+        default:
+            console.error(`Unknown command: ${command}`);
+            process.exit(1);
+    }
+}
+if (import.meta.main)
+    main();

package/dist/episodes.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Episodic memory for event-based storage
+ */
+import type { EpisodicMemory, TemporalQuery } from 'zouroboros-core';
+type Outcome = 'success' | 'failure' | 'resolved' | 'ongoing';
+interface CreateEpisodeInput {
+    summary: string;
+    outcome: Outcome;
+    entities: string[];
+    happenedAt?: Date;
+    durationMs?: number;
+    procedureId?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Create a new episode
+ */
+export declare function createEpisode(input: CreateEpisodeInput): EpisodicMemory;
+/**
+ * Search episodes with temporal filters
+ */
+export declare function searchEpisodes(query: TemporalQuery): EpisodicMemory[];
+/**
+ * Get episodes for a specific entity
+ */
+export declare function getEntityEpisodes(entity: string, options?: {
+    limit?: number;
+    outcome?: Outcome;
+}): EpisodicMemory[];
+/**
+ * Update episode outcome
+ */
+export declare function updateEpisodeOutcome(id: string, outcome: Outcome): boolean;
+/**
+ * Get episode statistics
+ */
+export declare function getEpisodeStats(): {
+    total: number;
+    byOutcome: Record<Outcome, number>;
+};
+export {};