agentic-qe 3.9.24 → 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) {
@@ -475,12 +569,19 @@ export async function updateRoutingOutcomeQuality(opts) {
             db.pragma('busy_timeout = 60000');
         }
         catch { /* hook-side patient timeout (ADR-001 / patch 260) */ }
+        // #451: explicit discriminator — only close PRE-TASK sentinels here.
+        // The route hook (UserPromptSubmit) writes sentinels with no taskId field
+        // in task_json. pre-task writes them with `"taskId"` in task_json. Without
+        // this filter, post-task could accidentally grab a stale route sentinel
+        // sitting from earlier in the session. Symmetric counterpart in
+        // routing-hooks.ts's `post-route` command, which has the inverse filter.
         db.prepare(`
       UPDATE routing_outcomes
       SET success = ?, quality_score = ?, duration_ms = ?
       WHERE id IN (
         SELECT id FROM routing_outcomes
         WHERE quality_score = -1
+          AND task_json LIKE '%"taskId"%'
           AND created_at > datetime('now', '-30 minutes')
         ORDER BY (CASE WHEN used_agent = ? THEN 0 ELSE 1 END), created_at DESC
         LIMIT 1
@@ -523,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,
@@ -538,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

@@ -7,42 +7,8 @@
 import { randomUUID } from 'crypto';
 import chalk from 'chalk';
 import path from 'node:path';
-import { findProjectRoot } 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 { findProjectRoot, getUnifiedMemory } from '../../../kernel/unified-memory.js';
+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
@@ -189,5 +155,106 @@ export function registerRoutingHooks(hooks) {
             throw error;
         }
     });
+    // -------------------------------------------------------------------------
+    // post-route: Close routing_outcomes sentinel from Stop hook (#451)
+    //
+    // The `route` hook fires on UserPromptSubmit and writes a sentinel row with
+    // quality_score=-1. That sentinel is only closed by post-task's
+    // updateRoutingOutcomeQuality, which fires on PostToolUse ^(Task|Agent)$ —
+    // so in any direct-work session (Bash/Edit/Read without spawning sub-agents)
+    // route sentinels accumulate forever and Stream D never converges.
+    //
+    // This subcommand is wired into the Stop hook (one invocation per turn) and
+    // closes the most-recent route sentinel 1:1. Discriminator
+    // `task_json NOT LIKE '%"taskId"%'` isolates route sentinels from the
+    // pre-task sentinels that carry taskId in their task_json.
+    // -------------------------------------------------------------------------
+    hooks
+        .command('post-route')
+        .description('Close the most-recent route sentinel from a Stop hook (#451)')
+        .option('--success <bool>', 'Whether the turn completed successfully', 'true')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        try {
+            const success = options.success === 'true' || options.success === true;
+            // 6-dim outcome quality, durationTier defaulted to favorable (1.0):
+            //   qualityScore = 0.25*success + 0.325 + 0.10*durationTier
+            // Stop hook doesn't measure turn duration, so we pick the most
+            // favorable bucket — same shape as the post-task formula but with the
+            // duration term collapsed to a constant.
+            const qualityScore = 0.325 + (success ? 0.25 : 0) + 0.10;
+            const um = getUnifiedMemory();
+            if (!um.isInitialized()) {
+                await um.initialize();
+            }
+            const db = um.getDatabase();
+            applyHookBusyTimeout(db);
+            const result = db.prepare(`
+          UPDATE routing_outcomes
+          SET success = ?, quality_score = ?, duration_ms = 0, error = NULL
+          WHERE id = (
+            SELECT id FROM routing_outcomes
+            WHERE quality_score = -1
+              AND task_json NOT LIKE '%"taskId"%'
+            ORDER BY created_at DESC
+            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) {
+            // Best-effort: Stop hooks must never crash the host. Swallow + log.
+            if (options.json) {
+                printJson({
+                    success: false,
+                    error: error instanceof Error ? error.message : 'unknown',
+                });
+            }
+            else {
+                console.error(chalk.dim(`[hooks] post-route: ${error instanceof Error ? error.message : 'unknown'}`));
+            }
+            return;
+        }
+    });
 }
 //# sourceMappingURL=routing-hooks.js.map

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/cli/commands/hooks.js

@@ -34,6 +34,7 @@ Examples:
   aqe hooks route --task "Generate tests for UserService"
   aqe hooks pre-task --description "Generate tests" --json
   aqe hooks post-task --task-id "task-123" --success true
+  aqe hooks post-route --success true --json   # Stop hook (#451)
 
   # Bash command hooks
   aqe hooks pre-command --command "npm test" --json

package/dist/init/init-wizard-hooks.js

@@ -165,6 +165,19 @@ export async function configureHooks(projectRoot, config) {
                     },
                 ],
             },
+            {
+                hooks: [
+                    {
+                        // #451: close the route sentinel from this turn. Stop fires
+                        // 1:1 with UserPromptSubmit/route — without this, route
+                        // sentinels accumulate at quality_score=-1 indefinitely.
+                        type: 'command',
+                        command: 'npx agentic-qe hooks post-route --success true --json',
+                        timeout: 5000,
+                        continueOnError: true,
+                    },
+                ],
+            },
         ],
     };
     // Smart merge: replace old AQE hooks, keep user hooks, add new AQE hooks

package/dist/init/phases/07-hooks.js

@@ -533,6 +533,20 @@ if (process.argv.includes('--json')) process.stdout.write(JSON.stringify(result)
                         },
                     ],
                 },
+                {
+                    hooks: [
+                        {
+                            // #451: close the route sentinel that UserPromptSubmit wrote
+                            // at the start of this turn. Stop fires 1:1 with UserPromptSubmit
+                            // — without this, `routing_outcomes` accumulates quality_score=-1
+                            // rows forever in direct-work sessions (no Task/Agent spawned).
+                            type: 'command',
+                            command: 'npx agentic-qe hooks post-route --success true --json',
+                            timeout: 5000,
+                            continueOnError: true,
+                        },
+                    ],
+                },
                 {
                     hooks: [
                         {

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>>;