agentic-qe 3.9.18 → 3.9.19

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

@@ -4,11 +4,86 @@
  *
  * Handles file guardian and Bash command lifecycle hooks.
  */
+import { existsSync, readFileSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
 import chalk from 'chalk';
 import path from 'node:path';
 import { QE_HOOK_EVENTS } from '../../../learning/qe-hooks.js';
-import { findProjectRoot } from '../../../kernel/unified-memory.js';
-import { getHooksSystem, createHybridBackendWithTimeout, incrementDreamExperience, persistCommandExperience, printJson, printSuccess, printError, } from './hooks-shared.js';
+import { findProjectRoot, getUnifiedMemory } from '../../../kernel/unified-memory.js';
+import { applyHookBusyTimeout, getHooksSystem, createHybridBackendWithTimeout, incrementDreamExperience, persistCommandExperience, printJson, printSuccess, printError, } from './hooks-shared.js';
+/**
+ * Detect test framework from a Bash command. Returns null when no recognized
+ * framework is invoked.
+ */
+function detectTestFramework(command) {
+    if (/\bjest\b/i.test(command))
+        return 'jest';
+    if (/\bvitest\b/i.test(command))
+        return 'vitest';
+    if (/\bpytest\b/i.test(command))
+        return 'pytest';
+    if (/\bmocha\b/i.test(command))
+        return 'mocha';
+    return null;
+}
+/**
+ * Persist test_outcomes (patch 070) and coverage_sessions (patch 170) for a
+ * test-framework command. Best-effort — failures are logged at debug level.
+ */
+async function persistTestAndCoverage(opts) {
+    try {
+        const um = getUnifiedMemory();
+        if (!um.isInitialized()) {
+            await um.initialize();
+        }
+        const db = um.getDatabase();
+        applyHookBusyTimeout(db);
+        const language = opts.framework === 'pytest' ? 'python' : 'javascript';
+        const cmdSlug = opts.command.split(/\s+/).slice(0, 3).join('-').slice(0, 80);
+        db.prepare(`
+      INSERT INTO test_outcomes (
+        id, test_id, test_name, generated_by, framework, language, domain,
+        passed, execution_time_ms, maintainability_score, created_at
+      ) VALUES (?, ?, ?, 'cli-hook-post-command', ?, ?, 'test-execution',
+                ?, ?, 0.5, datetime('now'))
+    `).run(`to-${Date.now()}-${randomUUID().slice(0, 8)}`, `cmd:${cmdSlug}`, opts.command.slice(0, 200), opts.framework, language, opts.success ? 1 : 0, opts.durationMs);
+        // Patch 170: parse Istanbul coverage summary if it exists. Reuses the
+        // previous after_* values as before_* so coverage delta is calculable.
+        try {
+            const summaryPath = path.join(process.cwd(), 'coverage', 'coverage-summary.json');
+            if (existsSync(summaryPath)) {
+                const summary = JSON.parse(readFileSync(summaryPath, 'utf-8'));
+                const total = summary.total ?? {};
+                const afterLines = Number(total.lines?.pct ?? 0);
+                const afterBranches = Number(total.branches?.pct ?? 0);
+                const afterFunctions = Number(total.functions?.pct ?? 0);
+                const prev = db.prepare(`
+          SELECT after_lines, after_branches, after_functions
+          FROM coverage_sessions
+          WHERE target_path = ?
+          ORDER BY created_at DESC
+          LIMIT 1
+        `).get(process.cwd());
+                const nowIso = new Date().toISOString();
+                db.prepare(`
+          INSERT INTO coverage_sessions (
+            id, target_path, agent_id, technique,
+            before_lines, before_branches, before_functions,
+            after_lines, after_branches, after_functions,
+            tests_generated, tests_passed, duration_ms,
+            started_at, completed_at
+          ) VALUES (?, ?, 'cli-hook-post-command', ?, ?, ?, ?, ?, ?, ?, 0, ?, ?, ?, ?)
+        `).run(`cs-${Date.now()}-${randomUUID().slice(0, 8)}`, process.cwd(), opts.framework, prev?.after_lines ?? 0, prev?.after_branches ?? 0, prev?.after_functions ?? 0, afterLines, afterBranches, afterFunctions, opts.success ? 1 : 0, opts.durationMs, nowIso, nowIso);
+            }
+        }
+        catch (covErr) {
+            console.error(chalk.dim(`[hooks] coverage_sessions: ${covErr instanceof Error ? covErr.message : 'unknown'}`));
+        }
+    }
+    catch (error) {
+        console.error(chalk.dim(`[hooks] test_outcomes: ${error instanceof Error ? error.message : 'unknown'}`));
+    }
+}
 /**
  * Register guard, pre-command, and post-command subcommands on the hooks command.
  */
@@ -211,15 +286,33 @@ export function registerCommandHooks(hooks) {
                     feedback: `Command: ${command}, exit: ${exitCode}`,
                 });
                 patternsLearned = 1;
-                // Persist as captured experience
-                await persistCommandExperience({
-                    task: `bash: ${command}`,
-                    agent: 'cli-hook',
-                    domain,
-                    success,
-                    source: 'cli-hook-post-command',
-                });
-                experienceRecorded = true;
+                // Persist as captured experience — gated to test/build/lint commands
+                // so non-test Bash (git, ls, etc.) doesn't flood captured_experiences
+                // with low-success-rate noise that dilutes pattern signal.
+                // reasoningBank.recordOutcome above is the broader metric path and
+                // stays unconditional.
+                if (isTestCmd || isBuildCmd || isLintCmd) {
+                    await persistCommandExperience({
+                        task: `bash: ${command}`,
+                        agent: 'cli-hook',
+                        domain,
+                        success,
+                        source: 'cli-hook-post-command',
+                    });
+                    experienceRecorded = true;
+                }
+                // Patches 070 + 170: when a recognized test framework ran, write
+                // test_outcomes and (if Istanbul coverage summary is present) a
+                // coverage_sessions row. Best-effort.
+                const framework = detectTestFramework(command);
+                if (framework) {
+                    await persistTestAndCoverage({
+                        command,
+                        framework,
+                        success,
+                        durationMs: 0, // post-command does not currently track exec time
+                    });
+                }
                 // Increment dream experience counter
                 const projectRoot = findProjectRoot();
                 const dataDir = path.join(projectRoot, '.agentic-qe');

package/dist/cli/commands/hooks-handlers/hooks-dream-learning.d.ts

@@ -47,6 +47,104 @@ export declare function persistCommandExperience(opts: {
     durationMs?: number;
     source: string;
 }): Promise<void>;
+/**
+ * Bridge payload written by pre-task into kv_store namespace='task-bridge'.
+ * Read by persistTaskOutcome to fan out per-pattern apps + derive q-learning state.
+ */
+export interface TaskBridgePayload {
+    selectedPatternIds: string[];
+    agent: string | null;
+    description: string;
+    taskType: string;
+    priority: string;
+    domain: string;
+    complexityBucket: number;
+    estimatedTokenSavings: number;
+    ts: number;
+}
+/**
+ * Result of persistTaskOutcome — surfaces fields the q-learning post-task
+ * integration needs (patch 280 / Stream F).
+ */
+export interface TaskOutcomeResult {
+    /** captured_experiences row id (FK target for experience_applications) */
+    experienceId: string;
+    /** Outcome quality computed via the 6-dim formula */
+    qualityScore: number;
+    /** Bridge payload that was consumed (null if no bridge entry found) */
+    bridge: TaskBridgePayload | null;
+    /** Number of multi-step siblings stitched into the trajectory (0 if single-step) */
+    stitchedSiblings: number;
+    /** Number of dream_insights rows whose applied counter was incremented */
+    insightsApplied: number;
+}
+/**
+ * Persist a Task() outcome through the full experience pipeline.
+ *
+ * Pipeline rolled into one helper that:
+ *
+ *   1. Writes captured_experiences (source='cli-hook-post-task')
+ *   2. Reads kv_store task-bridge (selectedPatternIds + estimatedTokenSavings)
+ *   3. Writes experience_applications: 1 base row + 1 per pattern_id (160/300)
+ *   4. Deletes the bridge entry to prevent double-consumption
+ *   5. Writes a single-step qe_trajectories row (120)
+ *   6. Looks for sibling captured_experiences with task LIKE '%:taskId' in the
+ *      last hour; if ≥2, creates a multi-step traj-multi-... row and marks
+ *      siblings consolidated_into = traj-multi-id (180)
+ *   7. Increments dream_insights.applied for top-3 most-recent actionable rows
+ *      when the task succeeded (110)
+ *
+ * All steps run inside a single transaction so partial failures don't leave
+ * inconsistent state. Returns the experience_id and derived fields for the
+ * q-learning post-task integration (Stream F / patch 280).
+ */
+export declare function persistTaskOutcome(opts: {
+    taskId: string;
+    agent: string;
+    domain?: string;
+    success: boolean;
+    durationMs?: number;
+}): Promise<TaskOutcomeResult>;
+/**
+ * Q-learning Bellman update for the hook-router state-action pair.
+ *
+ * Aligned to ADR-061/087:
+ *   - algorithm='q-learning' (not 'asymmetric-hebbian'; that label is for
+ *     ReasoningBank confidence updates, not Q-learning)
+ *   - agent_id='aqe-hook-router' (per-instance partition; persistent-q-router
+ *     convention so we don't collide with canonical RuVector q-router writes
+ *     at agent_id='q-router')
+ *   - state_key='${taskType}|${priority}|${domain}|${complexityBucket}'
+ *     (structural; see q-learning-router.ts:591)
+ *   - action_key=agent name chosen
+ *   - id='q-learning:aqe-hook-router:${stateKey}:${actionKey}'
+ *
+ * Update: Q ← Q + α(r + γ·max_a' Q(s',a') − Q) with α=0.1, γ=0.9.
+ * Reward: success +0.1, failure −1.0 (asymmetric per ADR-061).
+ *
+ * Best-effort — failures swallowed to keep post-task hook responsive.
+ */
+export declare function updateHookRouterQValue(opts: {
+    taskType: string;
+    priority: string;
+    domain: string;
+    complexityBucket: number;
+    agent: string;
+    success: boolean;
+}): Promise<void>;
+/**
+ * Update the routing_outcomes sentinel row that pre-task wrote with
+ * quality=-1, success=0. Patch 150: applies the 6-dim outcome quality and
+ * success bit to the most-recent pending sentinel matching the agent.
+ *
+ * Best-effort — no-op when no sentinel found.
+ */
+export declare function updateRoutingOutcomeQuality(opts: {
+    agent: string;
+    success: boolean;
+    durationMs: number;
+    qualityScore: number;
+}): Promise<void>;
 /**
  * Lightweight experience-to-pattern consolidation.
  * Aggregates captured_experiences by domain+agent, and for clusters that meet

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

@@ -128,6 +128,10 @@ export async function persistCommandExperience(opts) {
             await um.initialize();
         }
         const db = um.getDatabase();
+        try {
+            db.pragma('busy_timeout = 60000');
+        }
+        catch { /* hook-side patient timeout (ADR-001 / patch 260) */ }
         const id = `cli-${Date.now()}-${randomUUID().slice(0, 8)}`;
         // Compute quality based on context rather than binary success/fail.
         // Duration-aware: fast successful ops get higher quality.
@@ -157,6 +161,276 @@ export async function persistCommandExperience(opts) {
         console.error(chalk.dim(`[hooks] persistCommandExperience: ${error instanceof Error ? error.message : 'unknown'}`));
     }
 }
+/**
+ * Persist a Task() outcome through the full experience pipeline.
+ *
+ * Pipeline rolled into one helper that:
+ *
+ *   1. Writes captured_experiences (source='cli-hook-post-task')
+ *   2. Reads kv_store task-bridge (selectedPatternIds + estimatedTokenSavings)
+ *   3. Writes experience_applications: 1 base row + 1 per pattern_id (160/300)
+ *   4. Deletes the bridge entry to prevent double-consumption
+ *   5. Writes a single-step qe_trajectories row (120)
+ *   6. Looks for sibling captured_experiences with task LIKE '%:taskId' in the
+ *      last hour; if ≥2, creates a multi-step traj-multi-... row and marks
+ *      siblings consolidated_into = traj-multi-id (180)
+ *   7. Increments dream_insights.applied for top-3 most-recent actionable rows
+ *      when the task succeeded (110)
+ *
+ * All steps run inside a single transaction so partial failures don't leave
+ * inconsistent state. Returns the experience_id and derived fields for the
+ * q-learning post-task integration (Stream F / patch 280).
+ */
+export async function persistTaskOutcome(opts) {
+    const { getUnifiedMemory } = await import('../../../kernel/unified-memory.js');
+    const um = getUnifiedMemory();
+    if (!um.isInitialized()) {
+        await um.initialize();
+    }
+    const db = um.getDatabase();
+    try {
+        db.pragma('busy_timeout = 60000');
+    }
+    catch { /* hook-side patient timeout (ADR-001 / patch 260) */ }
+    const experienceId = `exp-${Date.now()}-${randomUUID().slice(0, 8)}`;
+    const taskField = `${opts.agent}:${opts.taskId}`;
+    const durationMs = opts.durationMs ?? 0;
+    // 6-dim outcome quality (patch 080/150 canonical formula)
+    // 0.25 * effectiveness + 0.325 baseline + 0.10 * duration_tier
+    // Other 4 dims default-0.5 weighted contribute via the 0.325 baseline term.
+    const successScore = opts.success ? 1 : 0;
+    const durationTier = durationMs < 100 ? 1.0 :
+        durationMs < 500 ? 0.8 :
+            durationMs < 2000 ? 0.6 :
+                durationMs < 5000 ? 0.4 :
+                    durationMs < 10000 ? 0.2 : 0.1;
+    const qualityScore = 0.25 * successScore + 0.325 + 0.10 * durationTier;
+    let bridge = null;
+    let stitchedSiblings = 0;
+    let insightsApplied = 0;
+    const txn = db.transaction(() => {
+        // 1. captured_experiences row
+        db.prepare(`
+      INSERT INTO captured_experiences
+        (id, task, agent, domain, success, quality, duration_ms,
+         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
+        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'}`);
+        // 3. Read bridge → fan out per-pattern application rows + delete bridge
+        try {
+            const bridgeRow = db.prepare(`
+        SELECT key, value FROM kv_store
+        WHERE namespace = 'task-bridge'
+          AND (expires_at IS NULL OR expires_at > strftime('%s','now') * 1000)
+        ORDER BY created_at DESC
+        LIMIT 1
+      `).get();
+            if (bridgeRow?.value) {
+                try {
+                    bridge = JSON.parse(bridgeRow.value);
+                }
+                catch {
+                    bridge = null;
+                }
+            }
+            if (bridge && Array.isArray(bridge.selectedPatternIds) && bridge.selectedPatternIds.length > 0) {
+                const perPatternTokens = bridge.estimatedTokenSavings && bridge.selectedPatternIds.length
+                    ? Math.round(bridge.estimatedTokenSavings / bridge.selectedPatternIds.length)
+                    : 0;
+                const insertApp = db.prepare(`
+          INSERT INTO experience_applications
+            (id, experience_id, task, success, tokens_saved, feedback, applied_at)
+          VALUES (?, ?, ?, ?, ?, ?, datetime('now'))
+        `);
+                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}`);
+                }
+                // 4. Delete bridge entry (one-shot consumption)
+                if (bridgeRow) {
+                    db.prepare(`DELETE FROM kv_store WHERE namespace='task-bridge' AND key = ?`).run(bridgeRow.key);
+                }
+            }
+        }
+        catch (bridgeErr) {
+            console.error(chalk.dim(`[hooks] post-task bridge: ${bridgeErr instanceof Error ? bridgeErr.message : 'unknown'}`));
+        }
+        // 5. Single-step qe_trajectories row
+        const trajId = `traj-${Date.now()}-${randomUUID().slice(0, 8)}`;
+        db.prepare(`
+      INSERT INTO qe_trajectories (id, task, agent, domain, started_at, ended_at, success, steps_json)
+      VALUES (?, ?, ?, ?, datetime('now'), datetime('now'), ?, ?)
+    `).run(trajId, taskField, opts.agent, opts.domain ?? 'general', opts.success ? 1 : 0, JSON.stringify([{ step: 1, task: opts.taskId, success: opts.success }]));
+        // 6. Multi-step stitch — siblings sharing the same suffix taskId in the
+        // last hour. Only fires when ≥2 unconsolidated siblings exist.
+        try {
+            const siblings = db.prepare(`
+        SELECT id, task, agent, success, started_at, completed_at
+        FROM captured_experiences
+        WHERE consolidated_into IS NULL
+          AND task LIKE ?
+          AND started_at > datetime('now', '-1 hour')
+        ORDER BY started_at ASC
+      `).all(`%:${opts.taskId}`);
+            if (siblings.length >= 2) {
+                const multiTrajId = `traj-multi-${Date.now()}-${randomUUID().slice(0, 8)}`;
+                const stepsJson = JSON.stringify(siblings.map((s, i) => ({
+                    step: i + 1,
+                    task: s.task,
+                    agent: s.agent,
+                    success: !!s.success,
+                    started_at: s.started_at,
+                    completed_at: s.completed_at,
+                })));
+                const allSuccess = siblings.every((s) => !!s.success);
+                db.prepare(`
+          INSERT INTO qe_trajectories (id, task, agent, domain, started_at, ended_at, success, steps_json)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(multiTrajId, `multi:${opts.taskId}`, opts.agent, opts.domain ?? 'general', siblings[0].started_at, siblings[siblings.length - 1].completed_at, allSuccess ? 1 : 0, stepsJson);
+                const placeholders = siblings.map(() => '?').join(',');
+                db.prepare(`UPDATE captured_experiences SET consolidated_into = ? WHERE id IN (${placeholders})`).run(multiTrajId, ...siblings.map((s) => s.id));
+                stitchedSiblings = siblings.length;
+            }
+        }
+        catch (stitchErr) {
+            console.error(chalk.dim(`[hooks] post-task stitch: ${stitchErr instanceof Error ? stitchErr.message : 'unknown'}`));
+        }
+        // 7. dream_insights.applied counter — only on success
+        if (opts.success) {
+            try {
+                const result = db.prepare(`
+          UPDATE dream_insights
+          SET applied = COALESCE(applied, 0) + 1
+          WHERE id IN (
+            SELECT id FROM dream_insights
+            WHERE actionable = 1
+            ORDER BY created_at DESC
+            LIMIT 3
+          )
+        `).run();
+                insightsApplied = result.changes ?? 0;
+            }
+            catch {
+                // dream_insights may not exist on minimal schemas
+            }
+        }
+    });
+    try {
+        txn();
+    }
+    catch (error) {
+        console.error(chalk.dim(`[hooks] persistTaskOutcome txn: ${error instanceof Error ? error.message : 'unknown'}`));
+    }
+    return {
+        experienceId,
+        qualityScore,
+        bridge,
+        stitchedSiblings,
+        insightsApplied,
+    };
+}
+/**
+ * Q-learning Bellman update for the hook-router state-action pair.
+ *
+ * Aligned to ADR-061/087:
+ *   - algorithm='q-learning' (not 'asymmetric-hebbian'; that label is for
+ *     ReasoningBank confidence updates, not Q-learning)
+ *   - agent_id='aqe-hook-router' (per-instance partition; persistent-q-router
+ *     convention so we don't collide with canonical RuVector q-router writes
+ *     at agent_id='q-router')
+ *   - state_key='${taskType}|${priority}|${domain}|${complexityBucket}'
+ *     (structural; see q-learning-router.ts:591)
+ *   - action_key=agent name chosen
+ *   - id='q-learning:aqe-hook-router:${stateKey}:${actionKey}'
+ *
+ * Update: Q ← Q + α(r + γ·max_a' Q(s',a') − Q) with α=0.1, γ=0.9.
+ * Reward: success +0.1, failure −1.0 (asymmetric per ADR-061).
+ *
+ * Best-effort — failures swallowed to keep post-task hook responsive.
+ */
+export async function updateHookRouterQValue(opts) {
+    try {
+        const { getUnifiedMemory } = await import('../../../kernel/unified-memory.js');
+        const um = getUnifiedMemory();
+        if (!um.isInitialized()) {
+            await um.initialize();
+        }
+        const db = um.getDatabase();
+        try {
+            db.pragma('busy_timeout = 60000');
+        }
+        catch { /* hook-side patient timeout (ADR-001 / patch 260) */ }
+        const stateKey = `${opts.taskType}|${opts.priority}|${opts.domain || 'any'}|${opts.complexityBucket}`;
+        const actionKey = opts.agent;
+        const id = `q-learning:aqe-hook-router:${stateKey}:${actionKey}`;
+        const reward = opts.success ? 0.1 : -1.0;
+        const alpha = 0.1;
+        const gamma = 0.9;
+        const existing = db.prepare(`
+      SELECT q_value FROM rl_q_values WHERE id = ?
+    `).get(id);
+        const oldQ = (existing && typeof existing.q_value === 'number') ? existing.q_value : 0;
+        const futureRow = db.prepare(`
+      SELECT MAX(q_value) AS m FROM rl_q_values WHERE state_key = ?
+    `).get(stateKey);
+        const futureMaxQ = (futureRow && typeof futureRow.m === 'number') ? futureRow.m : 0;
+        // Bellman update
+        const newQ = oldQ + alpha * (reward + gamma * futureMaxQ - oldQ);
+        db.prepare(`
+      INSERT INTO rl_q_values
+        (id, algorithm, agent_id, state_key, action_key, q_value, visits, last_reward, domain, created_at, updated_at)
+      VALUES (?, 'q-learning', 'aqe-hook-router', ?, ?, ?, 1, ?, ?, datetime('now'), datetime('now'))
+      ON CONFLICT(algorithm, agent_id, state_key, action_key) DO UPDATE SET
+        q_value = excluded.q_value,
+        visits = visits + 1,
+        last_reward = excluded.last_reward,
+        updated_at = datetime('now')
+    `).run(id, stateKey, actionKey, newQ, reward, opts.domain || 'any');
+    }
+    catch (error) {
+        console.error(chalk.dim(`[hooks] q-learning update: ${error instanceof Error ? error.message : 'unknown'}`));
+    }
+}
+/**
+ * Update the routing_outcomes sentinel row that pre-task wrote with
+ * quality=-1, success=0. Patch 150: applies the 6-dim outcome quality and
+ * success bit to the most-recent pending sentinel matching the agent.
+ *
+ * Best-effort — no-op when no sentinel found.
+ */
+export async function updateRoutingOutcomeQuality(opts) {
+    try {
+        const { getUnifiedMemory } = await import('../../../kernel/unified-memory.js');
+        const um = getUnifiedMemory();
+        if (!um.isInitialized()) {
+            await um.initialize();
+        }
+        const db = um.getDatabase();
+        try {
+            db.pragma('busy_timeout = 60000');
+        }
+        catch { /* hook-side patient timeout (ADR-001 / patch 260) */ }
+        db.prepare(`
+      UPDATE routing_outcomes
+      SET success = ?, quality_score = ?, duration_ms = ?
+      WHERE id IN (
+        SELECT id FROM routing_outcomes
+        WHERE quality_score = -1
+          AND created_at > datetime('now', '-30 minutes')
+        ORDER BY (CASE WHEN used_agent = ? THEN 0 ELSE 1 END), created_at DESC
+        LIMIT 1
+      )
+    `).run(opts.success ? 1 : 0, opts.qualityScore, opts.durationMs, opts.agent);
+    }
+    catch (error) {
+        console.error(chalk.dim(`[hooks] routing UPDATE: ${error instanceof Error ? error.message : 'unknown'}`));
+    }
+}
 /**
  * Lightweight experience-to-pattern consolidation.
  * Aggregates captured_experiences by domain+agent, and for clusters that meet
@@ -170,6 +444,10 @@ export async function consolidateExperiencesToPatterns() {
         await um.initialize();
     }
     const db = um.getDatabase();
+    try {
+        db.pragma('busy_timeout = 60000');
+    }
+    catch { /* hook-side patient timeout (ADR-001 / patch 260) */ }
     // Ensure consolidation columns exist (may be missing on older DBs)
     const existingCols = new Set(db.prepare('PRAGMA table_info(captured_experiences)').all().map(c => c.name));
     const migrations = [
@@ -238,13 +516,19 @@ export async function consolidateExperiencesToPatterns() {
                 const patternId = uuidv4();
                 const confidence = Math.min(0.95, agg.avg_quality * 0.8 + agg.success_rate * 0.2);
                 const qualityScore = confidence * 0.3 + (Math.min(agg.cnt, 100) / 100) * 0.2 + agg.success_rate * 0.5;
+                const description = `Auto-consolidated from ${agg.cnt} experiences. Agent: ${agg.agent}, success rate: ${(agg.success_rate * 100).toFixed(0)}%`;
+                const tags = (agg.sources || '').split(',').filter(Boolean);
                 db.prepare(`
           INSERT INTO qe_patterns (
             id, pattern_type, qe_domain, domain, name, description,
             confidence, usage_count, success_rate, quality_score, tier,
             template_json, context_json, created_at, successful_uses
           ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'), ?)
-        `).run(patternId, 'workflow', agg.domain, agg.domain, patternName, `Auto-consolidated from ${agg.cnt} experiences. Agent: ${agg.agent}, success rate: ${(agg.success_rate * 100).toFixed(0)}%`, confidence, agg.cnt, agg.success_rate, qualityScore, 'short-term', JSON.stringify({ type: 'workflow', content: `${agg.agent} pattern for ${agg.domain}`, variables: [] }), JSON.stringify({ tags: (agg.sources || '').split(','), sourceType: 'session-consolidation', extractedAt: new Date().toISOString() }), agg.successes);
+        `).run(patternId, 'workflow', agg.domain, agg.domain, patternName, description, confidence, agg.cnt, agg.success_rate, qualityScore, 'short-term', JSON.stringify({ type: 'workflow', content: `${agg.agent} pattern for ${agg.domain}`, variables: [] }), JSON.stringify({ tags, sourceType: 'session-consolidation', extractedAt: new Date().toISOString() }), agg.successes);
+                // Pair the qe_patterns row with an embedding so HNSW pattern recall
+                // doesn't see this as a "ghost" (ADR-058 embedding-locality). Fail-soft.
+                const { ensurePatternEmbedding } = await import('../../../learning/embed-and-insert-pattern.js');
+                await ensurePatternEmbedding(db, patternId, patternName, description, tags);
                 created++;
             }
             // Mark experiences as processed

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

@@ -33,6 +33,25 @@ export declare function getHooksSystem(): Promise<{
  * Initialize the hooks system
  */
 export declare function initializeHooksSystem(): Promise<void>;
+/**
+ * Hook-side busy_timeout (ADR-001 Option C / patch 260).
+ *
+ * Hooks fire from short-lived `npx aqe hooks ...` subprocesses. They open the
+ * shared memory.db while MCP-daemon workers may be holding the WAL write-lock
+ * for several seconds during dream-cycle / pattern-promotion. With the default
+ * 5s busy_timeout, hooks fail under contention. With 60s, they wait patiently
+ * — the hook subprocess exits as soon as it's done, so the longer timeout has
+ * no broader cost.
+ *
+ * Workers in MCP still use the platform default (5s) so they fail fast and
+ * retry on the next tick — they yield the lock to hooks under contention.
+ *
+ * This is per-connection: setting the pragma in a hook subprocess only affects
+ * that subprocess's connection, not the MCP daemon's.
+ */
+export declare function applyHookBusyTimeout(db: {
+    pragma: (s: string) => void;
+}): void;
 /**
  * Create hybrid backend with timeout protection
  *
@@ -48,5 +67,5 @@ 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;
-export { DREAM_STATE_KEY, DREAM_INTERVAL_MS, DREAM_EXPERIENCE_THRESHOLD, DREAM_MIN_GAP_MS, type DreamHookState, checkAndTriggerDream, incrementDreamExperience, persistCommandExperience, consolidateExperiencesToPatterns, } from './hooks-dream-learning.js';
+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

@@ -117,6 +117,30 @@ export async function initializeHooksSystem() {
         state.initialized = true;
     }
 }
+/**
+ * Hook-side busy_timeout (ADR-001 Option C / patch 260).
+ *
+ * Hooks fire from short-lived `npx aqe hooks ...` subprocesses. They open the
+ * shared memory.db while MCP-daemon workers may be holding the WAL write-lock
+ * for several seconds during dream-cycle / pattern-promotion. With the default
+ * 5s busy_timeout, hooks fail under contention. With 60s, they wait patiently
+ * — the hook subprocess exits as soon as it's done, so the longer timeout has
+ * no broader cost.
+ *
+ * Workers in MCP still use the platform default (5s) so they fail fast and
+ * retry on the next tick — they yield the lock to hooks under contention.
+ *
+ * This is per-connection: setting the pragma in a hook subprocess only affects
+ * that subprocess's connection, not the MCP daemon's.
+ */
+export function applyHookBusyTimeout(db) {
+    try {
+        db.pragma('busy_timeout = 60000');
+    }
+    catch {
+        // No-op if pragma fails (mocked DBs in tests, etc.)
+    }
+}
 /**
  * Create hybrid backend with timeout protection
  *
@@ -126,13 +150,21 @@ export async function initializeHooksSystem() {
 export async function createHybridBackendWithTimeout(dataDir) {
     const timeoutMs = 5000;
     // ADR-046: Use unified memory.db path - same as all other components
-    // HybridMemoryBackend is a facade over UnifiedMemoryManager
+    // HybridMemoryBackend is a facade over UnifiedMemoryManager.
+    //
+    // ADR-001 Option C / patch 260: hooks open with a 60s busy_timeout so they
+    // wait patiently through worker bursts (dream-cycle / pattern-promotion
+    // can hold the WAL write-lock for several seconds). Hooks fire from a
+    // short-lived `npx aqe hooks ...` process — our 60s timeout here only
+    // affects the hook process; the MCP daemon's worker connections inherit
+    // the platform default (5s) so they fail fast and retry next tick,
+    // yielding the lock to hooks under contention.
     const backend = new HybridMemoryBackend({
         sqlite: {
             path: path.join(dataDir, 'memory.db'), // ADR-046: Unified storage
             walMode: true,
             poolSize: 3,
-            busyTimeout: 5000,
+            busyTimeout: 60000,
         },
         // agentdb.path is ignored - vectors stored in unified memory.db
         enableFallback: true,
@@ -220,5 +252,5 @@ export function printGuidance(guidance) {
 // ============================================================================
 // 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, consolidateExperiencesToPatterns, } from './hooks-dream-learning.js';
+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';
 //# sourceMappingURL=hooks-shared.js.map