agentic-qe 3.9.25 → 3.9.26

package/dist/cli/commands/hooks-handlers/hooks-dream-learning.js

@@ -45,6 +45,37 @@ export async function checkAndTriggerDream(memoryBackend) {
         }
         const reason = timeTriggered ? 'time-interval' : 'experience-threshold';
         console.log(chalk.dim(`[hooks] Dream trigger: ${reason} (${dreamState.experienceCount} experiences, ${Math.round(timeSinceLastDream / 60000)}min since last dream)`));
+        // Issue #461: concurrent hook subprocesses all see the same stale
+        // dreamState.lastDreamTime, race past the time/experience triggers, and
+        // start ~10s dream cycles in parallel. They then all hit the WAL writer
+        // at roughly the same time and 35% of cycles fail with
+        // `database is locked` (duration_ms ≈ 10050ms — the full cycle ran, only
+        // the write-back failed). `busy_timeout` doesn't help: it serializes
+        // sequential contention, not simultaneous writers.
+        //
+        // Peek at dream_cycles before we open the engine — if another process
+        // has started a cycle in the last 60s, bail out with reason='already-
+        // running'. Fail-open: any error in the guard lets the dream proceed,
+        // so this can never make things worse than they were before.
+        try {
+            const { getUnifiedMemory } = await import('../../../kernel/unified-memory.js');
+            const um = getUnifiedMemory();
+            if (um.isInitialized()) {
+                const db = um.getDatabase();
+                const running = db
+                    .prepare(`SELECT COUNT(*) AS n FROM dream_cycles
+             WHERE status = 'running'
+               AND start_time > datetime('now', '-60 seconds')`)
+                    .get();
+                if (running && running.n > 0) {
+                    return { triggered: false, reason: 'already-running' };
+                }
+            }
+        }
+        catch {
+            // fail-open — if dream_cycles table is missing or unified memory not
+            // ready, we'd rather risk the rare lock than block dreaming entirely.
+        }
         // Run a quick dream cycle
         const { createDreamEngine } = await import('../../../learning/dream/index.js');
         const { createQEReasoningBank: createRB } = await import('../../../learning/qe-reasoning-bank.js');
@@ -76,6 +107,27 @@ export async function checkAndTriggerDream(memoryBackend) {
             await engine.loadPatternsAsConcepts(importPatterns);
         }
         const result = await engine.dream(10000);
+        // Issue #456: apply actionable insights inline so the hook path doesn't
+        // leave the backlog growing forever. DreamScheduler.autoApplyInsights()
+        // wires this in the daemon path, but checkAndTriggerDream is the
+        // hook-driven path and has no scheduler — without this block, every
+        // hook-fired dream cycle writes insights with applied=0 and they
+        // accumulate indefinitely (#456 evidence: 378 unapplied / 9 applied).
+        // Threshold matches DreamSchedulerConfig.insightConfidenceThreshold
+        // default (0.5) and InsightGenerator's `actionable` gate.
+        let insightsApplied = 0;
+        try {
+            for (const insight of result.insights) {
+                if (insight.actionable && insight.confidenceScore >= 0.5) {
+                    const applyResult = await engine.applyInsight(insight.id);
+                    if (applyResult.success)
+                        insightsApplied++;
+                }
+            }
+        }
+        catch (applyErr) {
+            console.error(chalk.dim(`[hooks] Dream apply: ${applyErr instanceof Error ? applyErr.message : 'unknown'}`));
+        }
         // Update state
         dreamState.lastDreamTime = new Date().toISOString();
         dreamState.experienceCount = 0;
@@ -86,6 +138,7 @@ export async function checkAndTriggerDream(memoryBackend) {
             triggered: true,
             reason,
             insightsGenerated: result.insights.length,
+            insightsApplied,
         };
     }
     catch (error) {
@@ -236,12 +289,19 @@ export async function persistTaskOutcome(opts) {
          model_tier, started_at, completed_at, source)
       VALUES (?, ?, ?, ?, ?, ?, ?, NULL, datetime('now'), datetime('now'), ?)
     `).run(experienceId, taskField.slice(0, 500), opts.agent, opts.domain ?? 'general', opts.success ? 1 : 0, qualityScore, durationMs, 'cli-hook-post-task');
-        // 2. Base experience_applications row
+        // 2. Base experience_applications row.
+        //
+        // Issue #463: tokens_saved was hardcoded to 0 on every row, so the
+        // learning-ROI column was permanently useless. qualityScore is already
+        // computed above and ranges 0.34 (failure+slow) to 0.68 (success+fast).
+        // Scale by 100 as a proxy until a real per-task token-delta calculation
+        // is wired in — gives a non-trivial 34-68 signal that downstream
+        // analytics can reason about.
         db.prepare(`
       INSERT INTO experience_applications
         (id, experience_id, task, success, tokens_saved, feedback, applied_at)
       VALUES (?, ?, ?, ?, ?, ?, datetime('now'))
-    `).run(`app-${Date.now()}-${randomUUID().slice(0, 8)}`, experienceId, taskField, opts.success ? 1 : 0, 0, `[Patch 060] post-task outcome: ${opts.success ? 'success' : 'failure'}`);
+    `).run(`app-${Date.now()}-${randomUUID().slice(0, 8)}`, experienceId, taskField, opts.success ? 1 : 0, Math.round(qualityScore * 100), `[Patch 060] post-task outcome: ${opts.success ? 'success' : 'failure'}`);
         // 3. Read bridge → fan out per-pattern application rows + delete bridge
         try {
             const bridgeRow = db.prepare(`
@@ -287,6 +347,27 @@ export async function persistTaskOutcome(opts) {
           WHERE id = ?
         `);
                 const getPatternConfidence = db.prepare(`SELECT confidence FROM qe_patterns WHERE id = ?`);
+                // Issue #455: recordOutcome() is called with a synthetic
+                // `task:agent:taskId` patternId that never matches qe_patterns.id, so
+                // checkPatternPromotionWithCoherence() is skipped for the real UUIDs
+                // updated here. Without an inline promotion check, short-term patterns
+                // that cross the thresholds (successful_uses ≥ 3, success_rate ≥ 0.7,
+                // confidence ≥ 0.6) stay short-term forever — qe_patterns.long-term
+                // count never grows past zero.
+                const promotionSelectStmt = db.prepare(`
+          SELECT tier, successful_uses, success_rate, confidence
+          FROM qe_patterns
+          WHERE id = ?
+        `);
+                const promotionUpdateStmt = db.prepare(`
+          UPDATE qe_patterns
+          SET tier = 'long-term', updated_at = datetime('now')
+          WHERE id = ?
+            AND tier = 'short-term'
+            AND successful_uses >= 3
+            AND success_rate >= 0.7
+            AND confidence >= 0.6
+        `);
                 for (const patternId of bridge.selectedPatternIds) {
                     insertApp.run(`app-${Date.now()}-${randomUUID().slice(0, 8)}`, experienceId, `${taskField}:pattern:${patternId}`, opts.success ? 1 : 0, perPatternTokens, `[Patch 160+300] task-bridge pattern_id=${patternId} ts=${perPatternTokens}`);
                     try {
@@ -297,6 +378,19 @@ export async function persistTaskOutcome(opts) {
                         }
                     }
                     catch { /* fail-soft per pattern */ }
+                    // Issue #455: re-read post-UPDATE state and promote if thresholds met.
+                    // Guarded WHERE clause makes the UPDATE idempotent and no-op for
+                    // already-long-term rows or rows below threshold.
+                    try {
+                        const pm = promotionSelectStmt.get(patternId);
+                        if (pm?.tier === 'short-term' &&
+                            pm.successful_uses >= 3 &&
+                            pm.success_rate >= 0.7 &&
+                            pm.confidence >= 0.6) {
+                            promotionUpdateStmt.run(patternId);
+                        }
+                    }
+                    catch { /* fail-soft per pattern */ }
                 }
                 // 4. Delete bridge entry (one-shot consumption)
                 if (bridgeRow) {
@@ -530,9 +624,16 @@ export async function consolidateExperiencesToPatterns() {
         }
     }
     // Aggregate unprocessed experiences by domain+agent with quality thresholds.
-    // Exclude 'cli-hook' agent — these are low-quality hook telemetry events
-    // (quality ~0.40, success_rate ~0.24) that flood the pipeline and block
-    // real pattern creation. See issue #348.
+    //
+    // Issue #464: dropped the `AND agent != 'cli-hook'` filter. The original
+    // exclusion (issue #348) was meant to keep low-quality Bash telemetry
+    // (quality ~0.40, success_rate ~0.24) from flooding the pipeline — but
+    // post-edit experiences also use agent='cli-hook' and have avg_quality
+    // ~0.75 / success_rate ~1.0, well above the HAVING thresholds. Excluding
+    // by agent name meant the dominant share of high-quality experiences was
+    // ineligible and consolidation never produced patterns. The HAVING clause
+    // below is the real quality gate; tighten it if #348's concern resurfaces
+    // rather than filtering by agent name.
     const aggregates = db.prepare(`
     SELECT
       domain,
@@ -545,7 +646,6 @@ export async function consolidateExperiencesToPatterns() {
       GROUP_CONCAT(DISTINCT source) as sources
     FROM captured_experiences
     WHERE application_count = 0
-      AND agent != 'cli-hook'
     GROUP BY domain, agent
     HAVING cnt >= 3 AND avg_quality >= 0.5 AND success_rate >= 0.6
     ORDER BY avg_quality DESC

package/dist/cli/commands/hooks-handlers/hooks-shared.d.ts

@@ -67,5 +67,25 @@ export declare function printJson(data: unknown): void;
 export declare function printSuccess(message: string): void;
 export declare function printError(message: string): void;
 export declare function printGuidance(guidance: string[]): void;
+/**
+ * Read piped stdin with a short timeout. Claude Code delivers
+ * UserPromptSubmit / PostToolUse / PreToolUse events as JSON on stdin —
+ * `$PROMPT`, `$TOOL_INPUT_file_path`, etc. are NOT exposed as env vars in
+ * every hook surface, so reading stdin is the only reliable fallback when
+ * the explicit CLI option resolves to an empty string.
+ *
+ * Returns '' when stdin is a TTY (interactive run) or no data arrives
+ * before the timeout. Never throws — a hook must never crash the host.
+ */
+export declare function readStdinJsonEvent(timeoutMs?: number): Promise<string>;
+/**
+ * Extract a file path from a Claude Code PostToolUse / PreToolUse hook event.
+ * Edit / Write / MultiEdit / NotebookEdit tools all put the target path in
+ * `tool_input.file_path` (snake_case from Claude Code) — older transports
+ * use `toolInput.file_path`. Returns '' when no recognized field is present.
+ *
+ * Exported for unit testing.
+ */
+export declare function extractFilePathFromEvent(raw: string): string;
 export { DREAM_STATE_KEY, DREAM_INTERVAL_MS, DREAM_EXPERIENCE_THRESHOLD, DREAM_MIN_GAP_MS, type DreamHookState, type TaskBridgePayload, type TaskOutcomeResult, checkAndTriggerDream, incrementDreamExperience, persistCommandExperience, persistTaskOutcome, updateHookRouterQValue, updateRoutingOutcomeQuality, consolidateExperiencesToPatterns, } from './hooks-dream-learning.js';
 //# sourceMappingURL=hooks-shared.d.ts.map

package/dist/cli/commands/hooks-handlers/hooks-shared.js

@@ -250,6 +250,78 @@ export function printGuidance(guidance) {
     });
 }
 // ============================================================================
+// Stdin Event Helpers
+// ============================================================================
+/**
+ * Read piped stdin with a short timeout. Claude Code delivers
+ * UserPromptSubmit / PostToolUse / PreToolUse events as JSON on stdin —
+ * `$PROMPT`, `$TOOL_INPUT_file_path`, etc. are NOT exposed as env vars in
+ * every hook surface, so reading stdin is the only reliable fallback when
+ * the explicit CLI option resolves to an empty string.
+ *
+ * Returns '' when stdin is a TTY (interactive run) or no data arrives
+ * before the timeout. Never throws — a hook must never crash the host.
+ */
+export async function readStdinJsonEvent(timeoutMs = 500) {
+    if (process.stdin.isTTY)
+        return '';
+    return new Promise((resolve) => {
+        let data = '';
+        const timer = setTimeout(() => {
+            process.stdin.removeAllListeners();
+            process.stdin.pause();
+            resolve(data);
+        }, timeoutMs);
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (chunk) => {
+            data += chunk;
+        });
+        process.stdin.on('end', () => {
+            clearTimeout(timer);
+            resolve(data);
+        });
+        process.stdin.on('error', () => {
+            clearTimeout(timer);
+            resolve(data);
+        });
+        process.stdin.resume();
+    });
+}
+/**
+ * Extract a file path from a Claude Code PostToolUse / PreToolUse hook event.
+ * Edit / Write / MultiEdit / NotebookEdit tools all put the target path in
+ * `tool_input.file_path` (snake_case from Claude Code) — older transports
+ * use `toolInput.file_path`. Returns '' when no recognized field is present.
+ *
+ * Exported for unit testing.
+ */
+export function extractFilePathFromEvent(raw) {
+    if (!raw.trim())
+        return '';
+    let event;
+    try {
+        event = JSON.parse(raw);
+    }
+    catch {
+        return '';
+    }
+    const toolInputSnake = event.tool_input;
+    const toolInputCamel = event.toolInput;
+    const candidates = [
+        toolInputSnake?.file_path,
+        toolInputSnake?.filePath,
+        toolInputCamel?.file_path,
+        toolInputCamel?.filePath,
+        event.file_path,
+        event.filePath,
+    ];
+    for (const c of candidates) {
+        if (typeof c === 'string' && c.trim())
+            return c;
+    }
+    return '';
+}
+// ============================================================================
 // Dream Scheduler & Learning — re-exported from hooks-dream-learning.ts
 // ============================================================================
 export { DREAM_STATE_KEY, DREAM_INTERVAL_MS, DREAM_EXPERIENCE_THRESHOLD, DREAM_MIN_GAP_MS, checkAndTriggerDream, incrementDreamExperience, persistCommandExperience, persistTaskOutcome, updateHookRouterQValue, updateRoutingOutcomeQuality, consolidateExperiencesToPatterns, } from './hooks-dream-learning.js';

package/dist/cli/commands/hooks-handlers/routing-hooks.js

@@ -8,41 +8,7 @@ import { randomUUID } from 'crypto';
 import chalk from 'chalk';
 import path from 'node:path';
 import { findProjectRoot, getUnifiedMemory } from '../../../kernel/unified-memory.js';
-import { applyHookBusyTimeout, getHooksSystem, createHybridBackendWithTimeout, incrementDreamExperience, printJson, printError, printGuidance, } from './hooks-shared.js';
-/**
- * Read piped stdin with a short timeout. Claude Code delivers
- * UserPromptSubmit / PostToolUse / etc. events as JSON on stdin —
- * `$PROMPT` is NOT exposed as an env var, so reading stdin is the
- * only reliable way to recover the prompt body for routing.
- *
- * Returns '' when stdin is a TTY (interactive run) or no data arrives
- * before the timeout. Never throws — a hook must never crash the host.
- */
-async function readStdinJsonEvent(timeoutMs = 500) {
-    if (process.stdin.isTTY)
-        return '';
-    return new Promise((resolve) => {
-        let data = '';
-        const timer = setTimeout(() => {
-            process.stdin.removeAllListeners();
-            process.stdin.pause();
-            resolve(data);
-        }, timeoutMs);
-        process.stdin.setEncoding('utf8');
-        process.stdin.on('data', (chunk) => {
-            data += chunk;
-        });
-        process.stdin.on('end', () => {
-            clearTimeout(timer);
-            resolve(data);
-        });
-        process.stdin.on('error', () => {
-            clearTimeout(timer);
-            resolve(data);
-        });
-        process.stdin.resume();
-    });
-}
+import { applyHookBusyTimeout, getHooksSystem, createHybridBackendWithTimeout, incrementDreamExperience, printJson, printError, printGuidance, readStdinJsonEvent, } from './hooks-shared.js';
 /**
  * Extract a routable task description from a Claude Code hook event JSON
  * payload. Different hook surfaces use different field names — try the
@@ -234,14 +200,46 @@ export function registerRoutingHooks(hooks) {
             LIMIT 1
           )
         `).run(success ? 1 : 0, qualityScore);
+            // Issue #465: orphan-sentinel sweep. Sessions that terminate without
+            // firing Stop (context compact, process kill, IDE crash) leave their
+            // sentinels at quality_score=-1 forever — every subsequent post-route
+            // call only closes the most-recent one (LIMIT 1) and newer rows keep
+            // pre-empting old ones in the ORDER BY DESC. Reporter saw 122/149
+            // rows stuck at -1, inverting AVG(quality_score) to -0.717.
+            //
+            // We use the conservative base score (0.325 = no success/duration
+            // bonus) rather than the current turn's qualityScore: those orphans
+            // belong to UNKNOWN historical turns and shouldn't inherit the
+            // current turn's outcome. Tag with error='stale-sentinel' so
+            // precision-sensitive queries can filter them out.
+            // Discriminator mirrors the LIMIT-1 close above and #451's symmetric
+            // design: route sentinels are owned by post-route, pre-task sentinels
+            // (task_json carries "taskId") are owned by post-task. Sweeping a
+            // pre-task sentinel here would race with updateRoutingOutcomeQuality
+            // and break the ownership split. If pre-task sentinels orphan, that
+            // belongs in a separate fix.
+            const staleResult = db.prepare(`
+          UPDATE routing_outcomes
+          SET success = 0,
+              quality_score = 0.325,
+              duration_ms = 0,
+              error = 'stale-sentinel'
+          WHERE quality_score = -1
+            AND task_json NOT LIKE '%"taskId"%'
+            AND created_at < datetime('now', '-300 seconds')
+        `).run();
             if (options.json) {
                 printJson({
                     success: true,
                     resolved: result.changes > 0,
+                    staleSwept: staleResult.changes,
                     qualityScore,
                     turnSuccess: success,
                 });
             }
+            else if (staleResult.changes > 0) {
+                console.log(chalk.dim(`[hooks] post-route: swept ${staleResult.changes} stale sentinel(s)`));
+            }
             return;
         }
         catch (error) {

package/dist/cli/commands/hooks-handlers/task-hooks.js

@@ -311,10 +311,19 @@ export function registerTaskHooks(hooks) {
                         durationMs,
                         success,
                     });
+                    // Issue #460: when --agent arrives empty (Claude Code does not
+                    // expose $TOOL_RESULT_agent_id in PostToolUse context), `agent`
+                    // resolves to 'unknown' and every Q-value lands in the same
+                    // bucket — the router can never learn per-agent differentiation.
+                    // The pre-task bridge already carries `agent: routing.recommendedAgent`
+                    // which is the correct action key, so prefer that over 'unknown'.
+                    const effectiveAgent = agent === 'unknown' && outcome.bridge?.agent
+                        ? outcome.bridge.agent
+                        : agent;
                     // Stream D (patch 150): apply 6-dim outcome quality to the
                     // routing_outcomes sentinel that pre-task wrote with quality=-1.
                     await updateRoutingOutcomeQuality({
-                        agent,
+                        agent: effectiveAgent,
                         success,
                         durationMs,
                         qualityScore: outcome.qualityScore,
@@ -327,7 +336,7 @@ export function registerTaskHooks(hooks) {
                             priority: outcome.bridge.priority,
                             domain: outcome.bridge.domain,
                             complexityBucket: outcome.bridge.complexityBucket,
-                            agent,
+                            agent: effectiveAgent,
                             success,
                         });
                     }
@@ -355,6 +364,7 @@ export function registerTaskHooks(hooks) {
                     dreamTriggered: dreamResult.triggered,
                     dreamReason: dreamResult.reason,
                     dreamInsights: dreamResult.insightsGenerated,
+                    dreamInsightsApplied: dreamResult.insightsApplied,
                 });
             }
             else {
@@ -364,7 +374,10 @@ export function registerTaskHooks(hooks) {
                     console.log(chalk.green(`  Patterns learned: ${patternsLearned}`));
                 }
                 if (dreamResult.triggered) {
-                    console.log(chalk.blue(`  🌙 Dream cycle triggered (${dreamResult.reason}): ${dreamResult.insightsGenerated} insights`));
+                    const appliedSuffix = typeof dreamResult.insightsApplied === 'number'
+                        ? `, ${dreamResult.insightsApplied} applied`
+                        : '';
+                    console.log(chalk.blue(`  🌙 Dream cycle triggered (${dreamResult.reason}): ${dreamResult.insightsGenerated} insights${appliedSuffix}`));
                 }
             }
             return;

package/dist/learning/qe-reasoning-bank.js

@@ -466,17 +466,48 @@ export class QEReasoningBank {
         for (const domain of QE_DOMAIN_LIST) {
             byDomain[domain] = patternStoreStats.byDomain[domain] || 0;
         }
+        // DB fallback (#454): in-memory `this.stats` is reset on every process
+        // start, but every hook invocation spawns a fresh node. Without a DB
+        // fallback, `aqe hooks stats` always reports zeros even when historical
+        // routing_outcomes / qe_pattern_usage rows exist. We use the in-memory
+        // counters when they're non-zero (live, current-process data), otherwise
+        // fall back to aggregated DB totals.
+        let routingRequests = this.stats.routingRequests;
+        let avgRoutingConfidence = this.stats.routingRequests > 0
+            ? this.stats.totalRoutingConfidence / this.stats.routingRequests
+            : 0;
+        let learningOutcomes = this.stats.learningOutcomes;
+        let patternSuccessRate = this.stats.learningOutcomes > 0
+            ? this.stats.successfulOutcomes / this.stats.learningOutcomes
+            : 0;
+        if (routingRequests === 0 || learningOutcomes === 0) {
+            try {
+                const agg = this.getSqliteStore().getAggregateOutcomeStats();
+                if (routingRequests === 0 && agg.routingRequests > 0) {
+                    routingRequests = agg.routingRequests;
+                    avgRoutingConfidence = agg.avgRoutingConfidence;
+                }
+                if (learningOutcomes === 0 && agg.learningOutcomes > 0) {
+                    learningOutcomes = agg.learningOutcomes;
+                    // Prefer per-usage success rate (closer to recordOutcome semantics);
+                    // fall back to qe_patterns.success_rate aggregate when no usage rows.
+                    patternSuccessRate =
+                        agg.learningOutcomes > 0
+                            ? agg.successfulOutcomes / agg.learningOutcomes
+                            : agg.avgPatternSuccessRate;
+                }
+            }
+            catch {
+                // best-effort — never let stats reporting crash the host
+            }
+        }
         return {
             totalPatterns: patternStoreStats.totalPatterns,
             byDomain,
-            routingRequests: this.stats.routingRequests,
-            avgRoutingConfidence: this.stats.routingRequests > 0
-                ? this.stats.totalRoutingConfidence / this.stats.routingRequests
-                : 0,
-            learningOutcomes: this.stats.learningOutcomes,
-            patternSuccessRate: this.stats.learningOutcomes > 0
-                ? this.stats.successfulOutcomes / this.stats.learningOutcomes
-                : 0,
+            routingRequests,
+            avgRoutingConfidence,
+            learningOutcomes,
+            patternSuccessRate,
             patternStoreStats,
         };
     }

package/dist/learning/rvf-pattern-store.d.ts

@@ -49,6 +49,15 @@ export declare class RvfPatternStore implements IPatternStore {
     /** Get the underlying RVF adapter (for COW branching, migration, etc.) */
     getAdapter(): RvfNativeAdapter | null;
     initialize(): Promise<void>;
+    /**
+     * Compare the RVF vector count with the SQLite pattern count; if RVF has
+     * more rows, read the idmap.json and delete any vector IDs that no longer
+     * have a matching qe_patterns row.
+     *
+     * Fail-open: any error in the purge path is swallowed so a stale or
+     * corrupted idmap can't keep the store from initializing (#462).
+     */
+    private purgeOrphanedVectors;
     dispose(): Promise<void>;
     store(pattern: QEPattern): Promise<Result<string>>;
     create(options: CreateQEPatternOptions): Promise<Result<QEPattern>>;

package/dist/learning/rvf-pattern-store.js

@@ -89,6 +89,48 @@ export class RvfPatternStore {
                 // SQLite auto-attach is best-effort
             }
         }
+        // Issue #462: purge orphan vectors that survived in patterns.rvf when an
+        // upgrade workflow rewrote qe_patterns via INSERT OR REPLACE without
+        // calling RvfPatternStore.delete() on the old IDs. Ghost vectors win
+        // cosine-similarity matches, route to non-existent pattern IDs, and
+        // every learning write fails silently. Run once on init.
+        await this.purgeOrphanedVectors();
+    }
+    /**
+     * Compare the RVF vector count with the SQLite pattern count; if RVF has
+     * more rows, read the idmap.json and delete any vector IDs that no longer
+     * have a matching qe_patterns row.
+     *
+     * Fail-open: any error in the purge path is swallowed so a stale or
+     * corrupted idmap can't keep the store from initializing (#462).
+     */
+    async purgeOrphanedVectors() {
+        if (!this.adapter || !this.sqliteStore)
+            return;
+        try {
+            const rvfCount = this.adapter.status()?.totalVectors ?? 0;
+            const dbCount = this.sqliteStore.getStats()?.totalPatterns ?? 0;
+            if (rvfCount <= dbCount)
+                return;
+            const { readFileSync, existsSync } = await import('node:fs');
+            const idmapPath = `${this.rvfPath}.idmap.json`;
+            if (!existsSync(idmapPath))
+                return;
+            const idmap = JSON.parse(readFileSync(idmapPath, 'utf-8'));
+            const rvfIds = new Set((idmap.entries ?? [])
+                .map((e) => (Array.isArray(e) ? e[0] : undefined))
+                .filter((id) => typeof id === 'string'));
+            const dbIds = new Set(this.sqliteStore.getPatterns({ limit: 10_000 }).map((p) => p.id));
+            const orphans = [...rvfIds].filter((id) => !dbIds.has(id));
+            if (orphans.length === 0)
+                return;
+            this.adapter.delete(orphans);
+            console.log(`[RvfPatternStore] Removed ${orphans.length} ghost vectors (index ${rvfCount} > DB ${dbCount})`);
+        }
+        catch (error) {
+            // fail-open: a stale idmap or read error must not block initialization
+            console.warn(`[RvfPatternStore] orphan purge skipped: ${toErrorMessage(error)}`);
+        }
     }
     async dispose() {
         if (this.adapter && !this.skipCloseOnDispose) {

package/dist/learning/sqlite-persistence.d.ts

@@ -134,6 +134,24 @@ export declare class SQLitePatternStore {
         byDomain: Record<string, number>;
         byTier: Record<string, number>;
     };
+    /**
+     * Aggregate outcome counters used by QEReasoningBank.getStats() as a fallback
+     * when the in-memory `this.stats` object is zero — every hook subprocess
+     * starts with a fresh counter, so without this fallback observability is
+     * always blank (#454).
+     *
+     * routing_outcomes and qe_pattern_usage live in the same unified memory.db
+     * as qe_patterns. avgConfidence/avgSuccessRate return 0 when the source
+     * tables are empty rather than NaN.
+     */
+    getAggregateOutcomeStats(): {
+        routingRequests: number;
+        avgRoutingConfidence: number;
+        successfulRoutings: number;
+        learningOutcomes: number;
+        successfulOutcomes: number;
+        avgPatternSuccessRate: number;
+    };
     /**
      * Check if there's any historical data (embeddings, usage, trajectories)
      * even if qe_patterns is empty. Used to detect data loss vs fresh database.

package/dist/learning/sqlite-persistence.js

@@ -596,6 +596,65 @@ export class SQLitePatternStore {
         }
         return { totalPatterns: total, byDomain, byTier };
     }
+    /**
+     * Aggregate outcome counters used by QEReasoningBank.getStats() as a fallback
+     * when the in-memory `this.stats` object is zero — every hook subprocess
+     * starts with a fresh counter, so without this fallback observability is
+     * always blank (#454).
+     *
+     * routing_outcomes and qe_pattern_usage live in the same unified memory.db
+     * as qe_patterns. avgConfidence/avgSuccessRate return 0 when the source
+     * tables are empty rather than NaN.
+     */
+    getAggregateOutcomeStats() {
+        const empty = {
+            routingRequests: 0,
+            avgRoutingConfidence: 0,
+            successfulRoutings: 0,
+            learningOutcomes: 0,
+            successfulOutcomes: 0,
+            avgPatternSuccessRate: 0,
+        };
+        if (!this.db)
+            return empty;
+        const safeGet = (sql) => {
+            try {
+                return this.db.prepare(sql).get();
+            }
+            catch {
+                return undefined;
+            }
+        };
+        // routing_outcomes carries (success, quality_score) per closed turn.
+        // Sentinels still have quality_score = -1, so filter to closed rows.
+        const routing = safeGet(`
+      SELECT
+        COUNT(*) AS total,
+        COUNT(CASE WHEN quality_score >= 0 THEN 1 END) AS closed,
+        AVG(CASE WHEN quality_score >= 0 THEN quality_score END) AS avg_q,
+        COALESCE(SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END), 0) AS succ
+      FROM routing_outcomes
+    `);
+        const usage = safeGet(`
+      SELECT
+        COUNT(*) AS total,
+        COALESCE(SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END), 0) AS succ
+      FROM qe_pattern_usage
+    `);
+        const patternAvg = safeGet(`
+      SELECT AVG(success_rate) AS avg_sr
+      FROM qe_patterns
+      WHERE usage_count > 0
+    `);
+        return {
+            routingRequests: routing?.total ?? 0,
+            avgRoutingConfidence: routing?.avg_q ?? 0,
+            successfulRoutings: routing?.succ ?? 0,
+            learningOutcomes: usage?.total ?? 0,
+            successfulOutcomes: usage?.succ ?? 0,
+            avgPatternSuccessRate: patternAvg?.avg_sr ?? 0,
+        };
+    }
     /**
      * Check if there's any historical data (embeddings, usage, trajectories)
      * even if qe_patterns is empty. Used to detect data loss vs fresh database.