@phuetz/code-buddy 0.3.0 → 1.0.0-rc.8

package/dist/observability/run-store.js

@@ -13,8 +13,14 @@ import fs from 'fs';
 import path from 'path';
 import os from 'os';
 import { randomBytes } from 'crypto';
+import Database from 'better-sqlite3';
 import { logger } from '../utils/logger.js';
+import { executeHermesLifecycleHook } from '../hooks/hermes-lifecycle-hooks.js';
 const MAX_RUNS = 30;
+const MAX_ARTIFACT_SEARCH_BYTES = 200_000;
+const ARTIFACT_INDEX_DB = 'artifact-index.sqlite';
+/** Cap the detail row list in health reports; counts stay accurate. */
+const ARTIFACT_INDEX_HEALTH_DETAIL_CAP = 500;
 // ──────────────────────────────────────────────────────────────────
 // RunStore
 // ──────────────────────────────────────────────────────────────────
@@ -27,17 +33,27 @@ export class RunStore {
     runsDir;
     /** File handles for active run event streams */
     handles = new Map();
+    /** Immediate in-process view of events, avoiding read-after-write stream races. */
+    eventBuffers = new Map();
     /** In-memory event counts per run */
     eventCounts = new Map();
     /** In-memory summaries for fast listing */
     summaries = new Map();
     /** The currently active run ID (set by startRun, cleared by endRun) */
     _currentRunId = null;
+    /** Durable FTS5 index for text artifacts. Opened lazily. */
+    artifactIndexDb = null;
+    /** If SQLite/FTS is unavailable, keep run search on the file-scan fallback. */
+    artifactIndexUnavailable = false;
     constructor(runsDir) {
-        this.runsDir = runsDir || path.join(os.homedir(), '.codebuddy', 'runs');
+        this.runsDir =
+            runsDir || process.env.CODEBUDDY_RUNS_DIR || path.join(os.homedir(), '.codebuddy', 'runs');
         this.ensureDir(this.runsDir);
         this.loadSummaries();
     }
+    getRunsDir() {
+        return this.runsDir;
+    }
     static getInstance() {
         if (!RunStore._instance) {
             RunStore._instance = new RunStore();
@@ -53,6 +69,34 @@ export class RunStore {
             this.emit(this._currentRunId, { type, data });
         }
     }
+    /** The id of the run currently being recorded, or null when idle. */
+    getCurrentRunId() {
+        return this._currentRunId;
+    }
+    dispose() {
+        for (const ws of this.handles.values()) {
+            try {
+                ws.destroy();
+            }
+            catch {
+                // Ignore dispose-time stream errors.
+            }
+        }
+        this.handles.clear();
+        this.eventBuffers.clear();
+        if (this.artifactIndexDb) {
+            try {
+                this.artifactIndexDb.close();
+            }
+            catch {
+                // Ignore dispose-time SQLite errors.
+            }
+            this.artifactIndexDb = null;
+        }
+        if (_activeStore === this) {
+            setActiveRunStore(null);
+        }
+    }
     // ──────────────────────────────────────────────────────────────
     // Run lifecycle
     // ──────────────────────────────────────────────────────────────
@@ -75,10 +119,17 @@ export class RunStore {
         };
         this.summaries.set(runId, summary);
         this.eventCounts.set(runId, 0);
+        this.eventBuffers.set(runId, []);
         // Create events file synchronously, then open append stream
         const eventsPath = path.join(runDir, 'events.jsonl');
         fs.writeFileSync(eventsPath, '', { flag: 'a' }); // ensure file exists
         const ws = fs.createWriteStream(eventsPath, { flags: 'a', encoding: 'utf-8' });
+        ws.on('error', (err) => {
+            logger.debug('RunStore: event stream error', {
+                runId,
+                err: err instanceof Error ? err.message : String(err),
+            });
+        });
         this.handles.set(runId, ws);
         // Emit run_start event
         this.emit(runId, { type: 'run_start', data: { objective, metadata } });
@@ -143,6 +194,10 @@ export class RunStore {
             runId,
             ...event,
         };
+        const buffer = this.eventBuffers.get(runId);
+        if (buffer) {
+            buffer.push(fullEvent);
+        }
         try {
             ws.write(JSON.stringify(fullEvent) + '\n');
         }
@@ -180,17 +235,40 @@ export class RunStore {
         catch {
             // Ignore
         }
-        // Close write stream
+        const afterStreamClosed = () => {
+            executeHermesLifecycleHook(process.cwd(), 'after_run_complete', {
+                runId,
+                runStatus: status,
+                runObjective: summary?.objective,
+                runMetadata: summary?.metadata,
+                endedAt: summary?.endedAt,
+            }).catch((err) => logger.debug('RunStore: AfterRunComplete hook failed', {
+                runId,
+                error: err instanceof Error ? err.message : String(err),
+            }));
+            import('../agent/learning-agent.js')
+                .then(({ runLearningRetrospective }) => runLearningRetrospective(this, runId, {
+                workDir: process.cwd(),
+            }))
+                .catch((err) => logger.debug('RunStore: Learning Agent retrospective failed', {
+                runId,
+                error: err instanceof Error ? err.message : String(err),
+            }));
+            logger.debug(`RunStore: ended run ${runId} with status ${status}`);
+        };
+        // Close write stream before post-run analyzers read events.jsonl.
         const ws = this.handles.get(runId);
         if (ws) {
-            ws.end();
+            ws.end(afterStreamClosed);
             this.handles.delete(runId);
         }
+        else {
+            queueMicrotask(afterStreamClosed);
+        }
         if (this._currentRunId === runId) {
             this._currentRunId = null;
             setActiveRunStore(null);
         }
-        logger.debug(`RunStore: ended run ${runId} with status ${status}`);
     }
     // ──────────────────────────────────────────────────────────────
     // Artifacts
@@ -203,6 +281,7 @@ export class RunStore {
         this.ensureDir(artifactsDir);
         const filePath = path.join(artifactsDir, name);
         fs.writeFileSync(filePath, content, 'utf-8');
+        this.indexArtifactForSearch(runId, name, content);
         const summary = this.summaries.get(runId);
         if (summary) {
             summary.artifactCount = (summary.artifactCount || 0) + 1;
@@ -276,6 +355,10 @@ export class RunStore {
      * Read all events from a run's JSONL file.
      */
     getEvents(runId) {
+        const buffered = this.eventBuffers.get(runId);
+        if (buffered) {
+            return [...buffered];
+        }
         const eventsPath = path.join(this.runDir(runId), 'events.jsonl');
         if (!fs.existsSync(eventsPath))
             return [];
@@ -354,12 +437,492 @@ export class RunStore {
             return null;
         }
     }
+    /**
+     * Search recent run summaries, event payloads, and text artifacts.
+     *
+     * This keeps generated scripts, plans, summaries, and command logs
+     * discoverable from the CLI without loading chat history.
+     */
+    searchRuns(query, options = {}) {
+        const terms = normalizeSearchTerms(query);
+        if (terms.length === 0)
+            return [];
+        const limit = Math.min(Math.max(options.limit ?? 20, 1), 100);
+        const includeArtifacts = options.includeArtifacts !== false;
+        const includeEvents = options.includeEvents !== false;
+        const sources = normalizeSearchFilterValues(options.sources);
+        const results = [];
+        const indexedArtifacts = new Set();
+        if (includeArtifacts) {
+            const artifactHits = this.searchArtifactsWithIndex(terms, limit, sources);
+            for (const hit of artifactHits) {
+                if (hit.artifact) {
+                    indexedArtifacts.add(`${hit.runId}\u0000${hit.artifact}`);
+                }
+                results.push(hit);
+            }
+        }
+        for (const summary of this.listRuns(100)) {
+            if (!matchesRunSearchSources(summary, sources)) {
+                continue;
+            }
+            const source = inferRunSearchSource(summary, sources);
+            const summaryText = [
+                summary.runId,
+                summary.objective,
+                summary.status,
+                JSON.stringify(summary.metadata ?? {}),
+            ].join(' ');
+            const summaryScore = scoreSearchText(summaryText, terms);
+            if (summaryScore > 0) {
+                results.push({
+                    runId: summary.runId,
+                    objective: summary.objective,
+                    status: summary.status,
+                    startedAt: summary.startedAt,
+                    matched: 'summary',
+                    score: summaryScore + 20,
+                    snippet: buildSearchSnippet(summaryText, terms),
+                    source,
+                });
+            }
+            if (includeEvents) {
+                for (const event of this.getEvents(summary.runId)) {
+                    const eventText = `${event.type} ${safeStringify(event.data)}`;
+                    const eventScore = scoreSearchText(eventText, terms);
+                    if (eventScore > 0) {
+                        results.push({
+                            runId: summary.runId,
+                            objective: summary.objective,
+                            status: summary.status,
+                            startedAt: summary.startedAt,
+                            matched: 'event',
+                            eventType: event.type,
+                            score: eventScore + 10,
+                            snippet: buildSearchSnippet(eventText, terms),
+                            source,
+                        });
+                    }
+                }
+            }
+            if (includeArtifacts) {
+                const record = this.getRun(summary.runId);
+                for (const artifact of record?.artifacts ?? []) {
+                    if (indexedArtifacts.has(`${summary.runId}\u0000${artifact}`)) {
+                        continue;
+                    }
+                    const artifactText = this.readArtifactForSearch(summary.runId, artifact);
+                    const artifactScore = scoreSearchText(`${artifact} ${artifactText}`, terms);
+                    if (artifactScore > 0) {
+                        this.indexArtifactForSearch(summary.runId, artifact, artifactText);
+                        results.push({
+                            runId: summary.runId,
+                            objective: summary.objective,
+                            status: summary.status,
+                            startedAt: summary.startedAt,
+                            matched: 'artifact',
+                            artifact,
+                            score: artifactScore + 30,
+                            snippet: buildSearchSnippet(artifactText || artifact, terms),
+                            source,
+                        });
+                    }
+                }
+            }
+        }
+        return results
+            .sort((a, b) => b.score - a.score || b.startedAt - a.startedAt)
+            .slice(0, limit);
+    }
+    /**
+     * Populate the durable artifact FTS index for existing run folders.
+     *
+     * New artifacts are indexed when saved. This backfill is for historical run
+     * folders created before the index existed, or for repaired/copied stores.
+     */
+    backfillArtifactIndex(options = {}) {
+        const limit = Math.min(Math.max(options.limit ?? 100, 1), 1000);
+        const sources = normalizeSearchFilterValues(options.sources);
+        const db = this.getArtifactIndexDb();
+        const selectedRuns = this.listRuns(limit).filter((summary) => matchesRunSearchSources(summary, sources));
+        const result = {
+            artifactCount: 0,
+            failedCount: 0,
+            indexedCount: 0,
+            limit,
+            runCount: selectedRuns.length,
+            runIds: selectedRuns.map((summary) => summary.runId),
+            skippedCount: 0,
+            sources,
+            unavailable: db === null,
+        };
+        if (!db) {
+            result.skippedCount = selectedRuns.reduce((count, summary) => count + (this.getRun(summary.runId)?.artifacts.length ?? 0), 0);
+            return result;
+        }
+        for (const summary of selectedRuns) {
+            const record = this.getRun(summary.runId);
+            for (const artifact of record?.artifacts ?? []) {
+                result.artifactCount += 1;
+                const artifactText = this.readArtifactForSearch(summary.runId, artifact);
+                if (this.indexArtifactForSearch(summary.runId, artifact, artifactText)) {
+                    result.indexedCount += 1;
+                }
+                else {
+                    result.failedCount += 1;
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Inspect the durable artifact FTS index for rows that no longer map to live
+     * data on disk. Stale rows accumulate when run folders are pruned (MAX_RUNS)
+     * or moved, leaving search hits that point at nothing.
+     *
+     * Read-only: this never mutates the index. Pair it with repairArtifactIndex().
+     */
+    checkArtifactIndexHealth() {
+        const scan = this.scanArtifactIndex();
+        return this.toHealthReport(scan);
+    }
+    /**
+     * Remove stale artifact FTS rows (run folder gone). When includeOrphans is
+     * set, also remove rows whose run folder survived but whose artifact file was
+     * deleted. The FTS mirror stays in sync via the AFTER DELETE trigger.
+     */
+    repairArtifactIndex(options = {}) {
+        const includeOrphans = options.includeOrphans === true;
+        const scan = this.scanArtifactIndex();
+        const report = this.toHealthReport(scan);
+        const base = {
+            ...report,
+            repaired: false,
+            includedOrphans: includeOrphans,
+            removedRows: 0,
+        };
+        const db = this.getArtifactIndexDb();
+        if (!db || scan.unavailable) {
+            return base;
+        }
+        const targets = scan.rows.filter((row) => row.reason === 'missing_run' || (includeOrphans && row.reason === 'missing_artifact'));
+        if (targets.length === 0) {
+            return { ...base, repaired: true };
+        }
+        try {
+            const stmt = db.prepare('DELETE FROM artifact_index WHERE run_id = ? AND artifact = ?');
+            const removeAll = db.transaction((rows) => {
+                let removed = 0;
+                for (const row of rows) {
+                    removed += stmt.run(row.runId, row.artifact).changes;
+                }
+                return removed;
+            });
+            const removedRows = removeAll(targets);
+            return { ...base, repaired: true, removedRows };
+        }
+        catch (err) {
+            logger.debug('RunStore: artifact index repair failed', {
+                err: err instanceof Error ? err.message : String(err),
+            });
+            return base;
+        }
+    }
+    /**
+     * Reconstruct the fork family of a run: the ancestor chain above it (via
+     * `metadata.parentRolloutId`) and the descendant subtree below it. This is
+     * the data behind a "thread family tree" view — when a session is forked,
+     * compressed-and-rolled-back, or A/B varied, `forkRun` records the parent
+     * link, and this walks it both ways.
+     */
+    getRunLineage(runId) {
+        const root = this.summaries.get(runId);
+        if (!root) {
+            return { runId, found: false, ancestors: [], tree: null, familySize: 0 };
+        }
+        // Walk ancestors upward, guarding against cycles and runaway depth.
+        const ancestors = [];
+        const seenUp = new Set([runId]);
+        let cursor = root.metadata?.parentRolloutId;
+        while (cursor && !seenUp.has(cursor) && ancestors.length < 100) {
+            seenUp.add(cursor);
+            const parent = this.summaries.get(cursor);
+            if (!parent) {
+                // Parent was pruned; record the id so the chain isn't silently lost.
+                ancestors.unshift({ runId: cursor, objective: '(pruned)' });
+                break;
+            }
+            ancestors.unshift({
+                runId: parent.runId,
+                objective: parent.objective,
+                ...(parent.metadata?.forkReason ? { forkReason: parent.metadata.forkReason } : {}),
+            });
+            cursor = parent.metadata?.parentRolloutId;
+        }
+        // Index children by parent id for the descendant walk.
+        const childrenByParent = new Map();
+        for (const summary of this.summaries.values()) {
+            const parentId = summary.metadata?.parentRolloutId;
+            if (parentId) {
+                const list = childrenByParent.get(parentId) ?? [];
+                list.push(summary);
+                childrenByParent.set(parentId, list);
+            }
+        }
+        const seenDown = new Set();
+        const buildNode = (summary) => {
+            seenDown.add(summary.runId);
+            const childSummaries = (childrenByParent.get(summary.runId) ?? [])
+                .filter((child) => !seenDown.has(child.runId))
+                .sort((a, b) => a.startedAt - b.startedAt);
+            return {
+                runId: summary.runId,
+                objective: summary.objective,
+                status: summary.status,
+                startedAt: summary.startedAt,
+                ...(summary.metadata?.forkReason ? { forkReason: summary.metadata.forkReason } : {}),
+                children: childSummaries.map(buildNode),
+            };
+        };
+        const tree = buildNode(root);
+        const familySize = ancestors.length + seenDown.size;
+        return { runId, found: true, ancestors, tree, familySize };
+    }
     // ──────────────────────────────────────────────────────────────
     // Private helpers
     // ──────────────────────────────────────────────────────────────
+    /**
+     * Walk every artifact index row and classify it against the filesystem.
+     * Returns the full (uncapped) set of stale rows so repair can act on all of
+     * them; the public report caps the detail list separately.
+     */
+    scanArtifactIndex() {
+        const db = this.getArtifactIndexDb();
+        if (!db) {
+            return { rows: [], totalRows: 0, healthyRows: 0, unavailable: true };
+        }
+        let indexed = [];
+        try {
+            indexed = db
+                .prepare('SELECT run_id, artifact FROM artifact_index')
+                .all();
+        }
+        catch (err) {
+            logger.debug('RunStore: artifact index scan failed', {
+                err: err instanceof Error ? err.message : String(err),
+            });
+            return { rows: [], totalRows: 0, healthyRows: 0, unavailable: true };
+        }
+        const stale = [];
+        let healthy = 0;
+        for (const row of indexed) {
+            const runDir = this.runDir(row.run_id);
+            if (!fs.existsSync(runDir)) {
+                stale.push({ runId: row.run_id, artifact: row.artifact, reason: 'missing_run' });
+                continue;
+            }
+            const artifactPath = path.join(runDir, 'artifacts', row.artifact);
+            if (!fs.existsSync(artifactPath)) {
+                stale.push({ runId: row.run_id, artifact: row.artifact, reason: 'missing_artifact' });
+                continue;
+            }
+            healthy += 1;
+        }
+        return {
+            rows: stale,
+            totalRows: indexed.length,
+            healthyRows: healthy,
+            unavailable: false,
+        };
+    }
+    toHealthReport(scan) {
+        let staleRows = 0;
+        let orphanedRows = 0;
+        for (const row of scan.rows) {
+            if (row.reason === 'missing_run') {
+                staleRows += 1;
+            }
+            else {
+                orphanedRows += 1;
+            }
+        }
+        return {
+            unavailable: scan.unavailable,
+            totalRows: scan.totalRows,
+            healthyRows: scan.healthyRows,
+            staleRows,
+            orphanedRows,
+            rows: scan.rows.slice(0, ARTIFACT_INDEX_HEALTH_DETAIL_CAP),
+        };
+    }
     runDir(runId) {
         return path.join(this.runsDir, runId);
     }
+    getArtifactIndexDb() {
+        if (this.artifactIndexUnavailable) {
+            return null;
+        }
+        if (this.artifactIndexDb) {
+            return this.artifactIndexDb;
+        }
+        try {
+            const db = new Database(path.join(this.runsDir, ARTIFACT_INDEX_DB));
+            db.pragma('journal_mode = WAL');
+            // Check if table exists and does NOT have tokenize='trigram'
+            let needsRebuild = false;
+            try {
+                const tableInfo = db.prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name='artifact_index_fts'").get();
+                if (tableInfo && !tableInfo.sql.includes("tokenize='trigram'") && !tableInfo.sql.includes('tokenize="trigram"')) {
+                    needsRebuild = true;
+                }
+            }
+            catch {
+                // Table doesn't exist or tableInfo query failed
+            }
+            if (needsRebuild) {
+                db.exec(`
+          DROP TRIGGER IF EXISTS artifact_index_ai;
+          DROP TRIGGER IF EXISTS artifact_index_ad;
+          DROP TRIGGER IF EXISTS artifact_index_au;
+          DROP TABLE IF EXISTS artifact_index_fts;
+        `);
+            }
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS artifact_index (
+          run_id TEXT NOT NULL,
+          artifact TEXT NOT NULL,
+          content TEXT NOT NULL,
+          updated_at INTEGER NOT NULL,
+          PRIMARY KEY (run_id, artifact)
+        );
+        CREATE VIRTUAL TABLE IF NOT EXISTS artifact_index_fts USING fts5(
+          run_id UNINDEXED,
+          artifact UNINDEXED,
+          content,
+          content='artifact_index',
+          content_rowid='rowid',
+          tokenize='trigram'
+        );
+        CREATE TRIGGER IF NOT EXISTS artifact_index_ai AFTER INSERT ON artifact_index BEGIN
+          INSERT INTO artifact_index_fts(rowid, run_id, artifact, content)
+          VALUES (new.rowid, new.run_id, new.artifact, new.content);
+        END;
+        CREATE TRIGGER IF NOT EXISTS artifact_index_ad AFTER DELETE ON artifact_index BEGIN
+          INSERT INTO artifact_index_fts(artifact_index_fts, rowid, run_id, artifact, content)
+          VALUES ('delete', old.rowid, old.run_id, old.artifact, old.content);
+        END;
+        CREATE TRIGGER IF NOT EXISTS artifact_index_au AFTER UPDATE ON artifact_index BEGIN
+          INSERT INTO artifact_index_fts(artifact_index_fts, rowid, run_id, artifact, content)
+          VALUES ('delete', old.rowid, old.run_id, old.artifact, old.content);
+          INSERT INTO artifact_index_fts(rowid, run_id, artifact, content)
+          VALUES (new.rowid, new.run_id, new.artifact, new.content);
+        END;
+      `);
+            if (needsRebuild) {
+                db.exec("INSERT INTO artifact_index_fts(artifact_index_fts) VALUES('rebuild');");
+            }
+            this.artifactIndexDb = db;
+            return db;
+        }
+        catch (err) {
+            this.artifactIndexUnavailable = true;
+            logger.debug('RunStore: artifact FTS index unavailable, falling back to file scan', {
+                err: err instanceof Error ? err.message : String(err),
+            });
+            return null;
+        }
+    }
+    indexArtifactForSearch(runId, name, content) {
+        const db = this.getArtifactIndexDb();
+        if (!db)
+            return false;
+        const searchContent = `${name}\n${content}`.slice(0, MAX_ARTIFACT_SEARCH_BYTES);
+        try {
+            db.prepare(`
+        INSERT INTO artifact_index (run_id, artifact, content, updated_at)
+        VALUES (?, ?, ?, ?)
+        ON CONFLICT(run_id, artifact) DO UPDATE SET
+          content = excluded.content,
+          updated_at = excluded.updated_at
+      `).run(runId, name, searchContent, Date.now());
+            return true;
+        }
+        catch (err) {
+            logger.debug('RunStore: failed to index artifact for search', {
+                runId,
+                artifact: name,
+                err: err instanceof Error ? err.message : String(err),
+            });
+            return false;
+        }
+    }
+    searchArtifactsWithIndex(terms, limit, sources) {
+        const db = this.getArtifactIndexDb();
+        const query = buildFtsQuery(terms);
+        if (!db || !query)
+            return [];
+        try {
+            const rows = db.prepare(`
+        SELECT
+          run_id AS runId,
+          artifact,
+          content,
+          snippet(artifact_index_fts, 2, '<mark>', '</mark>', '...', 25) AS snippet,
+          bm25(artifact_index_fts) AS rank
+        FROM artifact_index_fts
+        WHERE artifact_index_fts MATCH ?
+        ORDER BY rank
+        LIMIT ?
+      `).all(query, Math.max(limit * 5, 25));
+            const hits = [];
+            for (const row of rows) {
+                const summary = this.summaries.get(row.runId);
+                if (!summary || !matchesRunSearchSources(summary, sources)) {
+                    continue;
+                }
+                const score = scoreSearchText(row.content, terms);
+                hits.push({
+                    runId: summary.runId,
+                    objective: summary.objective,
+                    status: summary.status,
+                    startedAt: summary.startedAt,
+                    matched: 'artifact',
+                    artifact: row.artifact,
+                    score: (score > 0 ? score : 1) + 35,
+                    snippet: buildSearchSnippet(row.content, terms),
+                    source: inferRunSearchSource(summary, sources),
+                });
+            }
+            return hits;
+        }
+        catch (err) {
+            logger.debug('RunStore: artifact FTS search failed, falling back to file scan', {
+                err: err instanceof Error ? err.message : String(err),
+            });
+            return [];
+        }
+    }
+    readArtifactForSearch(runId, name) {
+        const filePath = path.join(this.runDir(runId), 'artifacts', name);
+        try {
+            const stat = fs.statSync(filePath);
+            if (!stat.isFile())
+                return '';
+            const fd = fs.openSync(filePath, 'r');
+            try {
+                const length = Math.min(stat.size, MAX_ARTIFACT_SEARCH_BYTES);
+                const buffer = Buffer.alloc(length);
+                fs.readSync(fd, buffer, 0, length, 0);
+                return buffer.toString('utf-8');
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+        }
+        catch {
+            return '';
+        }
+    }
     ensureDir(dir) {
         if (!fs.existsSync(dir)) {
             fs.mkdirSync(dir, { recursive: true });
@@ -419,6 +982,7 @@ export class RunStore {
             const runDir = this.runDir(s.runId);
             this.summaries.delete(s.runId);
             this.eventCounts.delete(s.runId);
+            this.eventBuffers.delete(s.runId);
             // Destroy handle immediately (force close, no flush needed for pruned runs)
             const ws = this.handles.get(s.runId);
             if (ws) {
@@ -437,4 +1001,117 @@ export class RunStore {
         }
     }
 }
+function normalizeSearchTerms(query) {
+    return query
+        .trim()
+        .toLowerCase()
+        .split(/\s+/)
+        .filter(Boolean);
+}
+function buildFtsQuery(terms) {
+    return terms
+        .map((term) => term.replace(/"/g, '""').trim())
+        .filter((term) => {
+        const isCjk = /[\u4e00-\u9fa5\u3040-\u309f\u30a0-\u30ff\u3400-\u4dbf\u1100-\u11ff\u3130-\u318f\uac00-\ud7af]/u.test(term);
+        return term.length >= 2 || (isCjk && term.length >= 1);
+    })
+        .filter(Boolean)
+        .map((term) => `"${term}"`)
+        .join(' ');
+}
+function normalizeSearchFilterValues(values) {
+    if (!Array.isArray(values)) {
+        return [];
+    }
+    return [...new Set(values
+            .flatMap((value) => value.split(','))
+            .map((value) => value.trim().toLowerCase())
+            .filter(Boolean)
+            .flatMap((value) => expandRunSourceAliases(value)))];
+}
+function matchesRunSearchSources(summary, sources) {
+    if (sources.length === 0) {
+        return true;
+    }
+    const candidates = new Set(runSearchSourceCandidates(summary).flatMap((value) => expandRunSourceAliases(value)));
+    return sources.some((source) => candidates.has(source));
+}
+function inferRunSearchSource(summary, requestedSources) {
+    const candidates = runSearchSourceCandidates(summary);
+    if (candidates.length === 0) {
+        return undefined;
+    }
+    if (requestedSources.length === 0) {
+        return candidates[0];
+    }
+    return candidates.find((candidate) => expandRunSourceAliases(candidate).some((alias) => requestedSources.includes(alias))) ?? candidates[0];
+}
+function runSearchSourceCandidates(summary) {
+    const metadata = summary.metadata;
+    const candidates = [
+        metadata?.channel,
+        metadata?.source,
+        metadata?.platform,
+        metadata?.origin,
+        ...(Array.isArray(metadata?.tags) ? metadata.tags : []),
+    ];
+    return [...new Set(candidates
+            .filter((value) => typeof value === 'string')
+            .map((value) => value.trim().toLowerCase())
+            .filter(Boolean))];
+}
+function expandRunSourceAliases(value) {
+    switch (value) {
+        case 'cli':
+        case 'terminal':
+            return ['cli', 'terminal'];
+        case 'cowork':
+        case 'desktop':
+            return ['cowork', 'desktop'];
+        case 'scheduled':
+        case 'schedule':
+        case 'cron':
+            return ['scheduled', 'schedule', 'cron'];
+        case 'phone':
+        case 'mobile':
+            return ['mobile', 'phone'];
+        default:
+            return [value];
+    }
+}
+function scoreSearchText(text, terms) {
+    const lower = text.toLowerCase();
+    if (!terms.every((term) => lower.includes(term))) {
+        return 0;
+    }
+    return terms.reduce((score, term) => {
+        const index = lower.indexOf(term);
+        return score + 10 + Math.max(0, 20 - Math.floor(index / 20));
+    }, 0);
+}
+function buildSearchSnippet(text, terms, maxLength = 180) {
+    const compact = text.replace(/\s+/g, ' ').trim();
+    if (compact.length <= maxLength) {
+        return compact;
+    }
+    const lower = compact.toLowerCase();
+    const indexes = terms
+        .map((term) => lower.indexOf(term.toLowerCase()))
+        .filter((index) => index >= 0);
+    const first = indexes.length > 0 ? Math.min(...indexes) : 0;
+    const start = Math.max(0, first - 50);
+    const end = Math.min(compact.length, start + maxLength);
+    const snippet = compact.slice(start, end);
+    const prefix = start > 0 ? '...' : '';
+    const suffix = end < compact.length ? '...' : '';
+    return prefix + snippet + suffix;
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
 //# sourceMappingURL=run-store.js.map