agentic-qe 3.9.29 → 3.9.31

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

@@ -6,6 +6,7 @@
  */
 import { randomUUID } from 'crypto';
 import chalk from 'chalk';
+import { recordPatternUsage } from '../../../learning/pattern-usage-recorder.js';
 // ============================================================================
 // Dream Scheduler State (persisted in kv_store between hook invocations)
 // ============================================================================
@@ -328,25 +329,6 @@ export async function persistTaskOutcome(opts) {
             (id, experience_id, task, success, tokens_saved, feedback, applied_at)
           VALUES (?, ?, ?, ?, ?, ?, datetime('now'))
         `);
-                // Mirror SQLitePatternStore.recordUsage() so the hook flow updates
-                // qe_patterns.{usage_count, successful_uses, success_rate, quality_score}.
-                // recordUsage() is otherwise only reachable via HandleTaskOutcomeRecord
-                // — never from this hook path — so 88/89 patterns stayed pinned at the
-                // bootstrap quality_score floor (~0.30) and never promoted to long-term.
-                // Quality formula: confidence*0.3 + min(usage_count/100,1)*0.2 + success_rate*0.5
-                const updatePatternUsage = db.prepare(`
-          UPDATE qe_patterns SET
-            usage_count = usage_count + 1,
-            successful_uses = successful_uses + ?,
-            success_rate = CAST(successful_uses + ? AS REAL) / CAST(usage_count + 1 AS REAL),
-            quality_score = ? * 0.3
-              + MIN(CAST(usage_count + 1 AS REAL) / 100.0, 1.0) * 0.2
-              + (CAST(successful_uses + ? AS REAL) / CAST(usage_count + 1 AS REAL)) * 0.5,
-            last_used_at = datetime('now'),
-            updated_at = datetime('now')
-          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
@@ -370,12 +352,22 @@ export async function persistTaskOutcome(opts) {
         `);
                 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}`);
+                    // #486 Gap B: single-writer for pattern usage. Replaces the legacy
+                    // inline UPDATE that bumped qe_patterns columns but skipped the
+                    // qe_pattern_usage INSERT, leaving the audit table empty even as
+                    // usage_count climbed. recordPatternUsage() does both writes in
+                    // one transaction, matching SQLitePatternStore.recordUsage().
                     try {
-                        const row = getPatternConfidence.get(patternId);
-                        if (row) {
-                            const successInc = opts.success ? 1 : 0;
-                            updatePatternUsage.run(successInc, successInc, row.confidence, successInc, patternId);
-                        }
+                        recordPatternUsage(db, {
+                            patternId,
+                            success: opts.success,
+                            metrics: {
+                                tokens_saved: perPatternTokens,
+                                source: 'cli-hook-post-task',
+                                experience_id: experienceId,
+                            },
+                            feedback: `[Patch 160+300] task-bridge pattern_id=${patternId} ts=${perPatternTokens}`,
+                        });
                     }
                     catch { /* fail-soft per pattern */ }
                     // Issue #455: re-read post-UPDATE state and promote if thresholds met.

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

@@ -87,5 +87,5 @@ export declare function readStdinJsonEvent(timeoutMs?: number): Promise<string>;
  * 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';
+export { DREAM_STATE_KEY, DREAM_INTERVAL_MS, DREAM_EXPERIENCE_THRESHOLD, DREAM_MIN_GAP_MS, type DreamHookState, type TaskBridgePayload, type TaskOutcomeResult, 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

@@ -357,5 +357,12 @@ export function extractFilePathFromEvent(raw) {
 // ============================================================================
 // 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';
+export { DREAM_STATE_KEY, DREAM_INTERVAL_MS, DREAM_EXPERIENCE_THRESHOLD, DREAM_MIN_GAP_MS, 
+// ADR-094: checkAndTriggerDream is intentionally NOT re-exported here.
+// Hook handlers must not trigger dreams from inside the subprocess; the
+// kernel-side DreamScheduler is the authoritative trigger. The function
+// remains exported from hooks-dream-learning.ts for direct test access
+// and for any future kernel-side caller that wants the encapsulated
+// single-cycle logic.
+incrementDreamExperience, persistCommandExperience, persistTaskOutcome, updateHookRouterQValue, updateRoutingOutcomeQuality, consolidateExperiencesToPatterns, } from './hooks-dream-learning.js';
 //# sourceMappingURL=hooks-shared.js.map

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

@@ -5,6 +5,7 @@
  * Handles task routing to optimal QE agent.
  */
 import { randomUUID } from 'crypto';
+import { ensureRoutingOutcomesAdr095Columns } from '../../../routing/routing-outcomes-migration.js';
 import chalk from 'chalk';
 import path from 'node:path';
 import { findProjectRoot, getUnifiedMemory } from '../../../kernel/unified-memory.js';
@@ -87,6 +88,10 @@ export function registerRoutingHooks(hooks) {
                     patternCount: routing.patterns.length,
                     guidance: routing.guidance,
                     reasoning: routing.reasoning,
+                    // ADR-095 telemetry passed through to operators / scripts
+                    exploration: routing.exploration ?? false,
+                    criticality: routing.criticality ?? null,
+                    qWeight: routing.qWeight ?? null,
                 });
             }
             else {
@@ -114,6 +119,8 @@ export function registerRoutingHooks(hooks) {
                 }
                 const db = um.getDatabase();
                 applyHookBusyTimeout(db);
+                // ADR-095: ensure new columns exist before INSERTing them. Idempotent.
+                ensureRoutingOutcomesAdr095Columns(db);
                 const outcomeId = `route-${Date.now()}-${randomUUID().slice(0, 8)}`;
                 // Split-write semantics: quality_score means "outcome quality after
                 // task ran" (6-dim formula), NOT routing confidence. Routing-
@@ -122,22 +129,27 @@ export function registerRoutingHooks(hooks) {
                 // quality. lowConfidence is surfaced via decision_json + the error
                 // column so it's visible in queries that don't parse JSON.
                 const lowConfidence = routing.confidence < 0.5;
+                const routingTelemetry = routing;
                 db.prepare(`
             INSERT OR REPLACE INTO routing_outcomes (
               id, task_json, decision_json, used_agent,
               followed_recommendation, success, quality_score,
-              duration_ms, error
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+              duration_ms, error,
+              exploration, criticality, q_weight
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
           `).run(outcomeId, JSON.stringify({ description: task, domain: options.domain }), JSON.stringify({
                     recommended: routing.recommendedAgent,
                     confidence: routing.confidence,
                     alternatives: routing.alternatives,
                     lowConfidence,
+                    exploration: routingTelemetry.exploration ?? false,
+                    criticality: routingTelemetry.criticality ?? null,
+                    qWeight: routingTelemetry.qWeight ?? null,
                 }), routing.recommendedAgent, 1, // followed_recommendation = true
                 0, // success = 0 (sentinel — post-task UPDATEs)
                 -1, // quality_score = -1 sentinel
                 0, // duration not yet tracked
-                lowConfidence ? 'low-confidence' : null);
+                lowConfidence ? 'low-confidence' : null, routingTelemetry.exploration ? 1 : 0, routingTelemetry.criticality ?? null, routingTelemetry.qWeight ?? null);
                 // Increment dream experience counter
                 const projectRoot = findProjectRoot();
                 const dataDir = path.join(projectRoot, '.agentic-qe');

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

@@ -9,7 +9,9 @@ import chalk from 'chalk';
 import path from 'node:path';
 import { QE_HOOK_EVENTS } from '../../../learning/qe-hooks.js';
 import { findProjectRoot, getUnifiedMemory } from '../../../kernel/unified-memory.js';
-import { applyHookBusyTimeout, getHooksSystem, createHybridBackendWithTimeout, incrementDreamExperience, checkAndTriggerDream, persistTaskOutcome, updateHookRouterQValue, updateRoutingOutcomeQuality, printJson, printSuccess, } from './hooks-shared.js';
+import { applyHookBusyTimeout, getHooksSystem, createHybridBackendWithTimeout, incrementDreamExperience, persistTaskOutcome, updateHookRouterQValue, updateRoutingOutcomeQuality, printJson, printSuccess, } from './hooks-shared.js';
+import { ensureRoutingOutcomesAdr095Columns } from '../../../routing/routing-outcomes-migration.js';
+import { deriveTaskType } from '../../../learning/agent-routing.js';
 // ============================================================================
 // Constants — task-bridge / routing-quality / q-learning
 // ============================================================================
@@ -22,30 +24,9 @@ const LOW_CONFIDENCE_THRESHOLD = 0.5;
 // ============================================================================
 // Helpers
 // ============================================================================
-/**
- * Derive a structural taskType from a free-form task description.
- * Mirrors the categories the q-learning router cares about (ADR-061/087).
- */
-function deriveTaskType(description) {
-    const d = description.toLowerCase();
-    if (/\bgenerate[- ]?test|\btest[- ]?gen|\bgenerate.+spec/.test(d))
-        return 'test-generation';
-    if (/\bcoverage|\banalyze.+cover/.test(d))
-        return 'coverage-analysis';
-    if (/\bquality|\bassess|\baudit/.test(d))
-        return 'quality-assessment';
-    if (/\bsecurity|\bvulnerab|\bcompliance/.test(d))
-        return 'security-compliance';
-    if (/\bdefect|\bbug|\bdiagnos/.test(d))
-        return 'defect-intelligence';
-    if (/\brequirement|\bspec\b/.test(d))
-        return 'requirements-validation';
-    if (/\brefactor|\brewrite|\boptim/.test(d))
-        return 'refactoring';
-    if (/\btest|\brun.+test/.test(d))
-        return 'test-execution';
-    return 'unknown';
-}
+// ADR-095: deriveTaskType moved to learning/agent-routing.ts so the routing
+// path (QEReasoningBank.routeTask) and the post-task Q-update path share
+// the same state_key derivation. Imported above.
 /** Hash a description to a stable short bridge key. */
 function hashDescription(description) {
     return createHash('sha256').update(description).digest('hex').slice(0, 16);
@@ -142,7 +123,14 @@ export function registerTaskHooks(hooks) {
                 // Patch 160 + 280-bridge: write the task-bridge entry that post-task
                 // will consume to fan out experience_applications per pattern_id and
                 // derive a structural q-learning state_key.
-                if (options.description && selectedPatternIds.length > 0) {
+                //
+                // The bridge MUST write even when selectedPatternIds is empty: the
+                // Q-learning Bellman update at task-hooks.ts post-task site uses a
+                // state_key derived from (taskType|priority|domain|complexityBucket)
+                // and an action_key from routing.recommendedAgent — neither requires
+                // non-empty patterns. Gating on patterns starves rl_q_values for
+                // low-confidence prompts. (#487)
+                if (options.description) {
                     try {
                         const description = String(options.description);
                         const taskType = deriveTaskType(description);
@@ -182,23 +170,33 @@ export function registerTaskHooks(hooks) {
                 // same `hook-${ts}` fallback as post-task.
                 if (routing?.recommendedAgent) {
                     try {
+                        // ADR-095: ensure routing_outcomes has the new columns before
+                        // INSERTing them. Idempotent (process-local flag).
+                        ensureRoutingOutcomesAdr095Columns(db);
                         const effectivePreTaskId = options.taskId || `hook-${Date.now()}`;
                         const outcomeId = `route-${Date.now()}-${randomUUID().slice(0, 8)}`;
                         const lowConfidence = routing.confidence < LOW_CONFIDENCE_THRESHOLD;
+                        const routingWithTelemetry = routing;
                         db.prepare(`
                 INSERT INTO routing_outcomes (
                   id, task_json, decision_json, used_agent,
                   followed_recommendation, success, quality_score,
-                  duration_ms, error
-                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+                  duration_ms, error,
+                  exploration, criticality, q_weight
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
               `).run(outcomeId, JSON.stringify({ description: options.description, taskId: effectivePreTaskId }), JSON.stringify({
                             recommended: routing.recommendedAgent,
                             confidence: routing.confidence,
                             alternatives: routing.alternatives,
                             lowConfidence,
+                            // Preserve telemetry in decision_json too for callers that
+                            // read just the JSON blob.
+                            exploration: routingWithTelemetry.exploration ?? false,
+                            criticality: routingWithTelemetry.criticality ?? null,
+                            qWeight: routingWithTelemetry.qWeight ?? null,
                         }), routing.recommendedAgent, 1, 0, // success = 0 (sentinel — post-task UPDATEs to actual)
                         -1, // quality_score = -1 sentinel
-                        0, lowConfidence ? 'low-confidence' : null);
+                        0, lowConfidence ? 'low-confidence' : null, routingWithTelemetry.exploration ? 1 : 0, routingWithTelemetry.criticality ?? null, routingWithTelemetry.qWeight ?? null);
                     }
                     catch (sentinelErr) {
                         console.error(chalk.dim(`[hooks] pre-task sentinel: ${sentinelErr instanceof Error ? sentinelErr.message : 'unknown'}`));
@@ -268,7 +266,6 @@ export function registerTaskHooks(hooks) {
             // Initialize hooks system and record learning outcome
             // BUG FIX: Must call getHooksSystem() FIRST to initialize, not check state.initialized
             let patternsLearned = 0;
-            let dreamResult = { triggered: false };
             try {
                 // Initialize system (creates ReasoningBank and HookRegistry)
                 const { hookRegistry, reasoningBank } = await getHooksSystem();
@@ -341,30 +338,30 @@ export function registerTaskHooks(hooks) {
                         });
                     }
                 }
-                // Record experience for dream scheduler and check if dream should trigger
+                // ADR-094: post-task bumps the experience counter but DOES NOT
+                // trigger dream cycles inline. Dream cycles run in the long-lived
+                // kernel's DreamScheduler so the 10-second SQLite write transaction
+                // doesn't block other writers from this short-lived hook subprocess.
                 const projectRoot = findProjectRoot();
                 const dataDir = path.join(projectRoot, '.agentic-qe');
                 const memoryBackend = await createHybridBackendWithTimeout(dataDir);
-                const expCount = await incrementDreamExperience(memoryBackend);
-                // Check if dream cycle should be triggered
-                // Always check — time-based triggers need every invocation, and the
-                // check itself is lightweight (just reads state + compares timestamps)
-                dreamResult = await checkAndTriggerDream(memoryBackend);
+                await incrementDreamExperience(memoryBackend);
             }
             catch (initError) {
                 // Log but don't fail - learning is best-effort
                 console.error(chalk.dim(`[hooks] Learning init: ${initError instanceof Error ? initError.message : 'unknown'}`));
             }
             if (options.json) {
+                // dreamTriggered/dreamReason retained for backwards-compat with
+                // operator scripts; the kernel-side scheduler is the authoritative
+                // trigger now (ADR-094).
                 printJson({
                     success: true,
                     taskId: options.taskId,
                     taskSuccess: success,
                     patternsLearned,
-                    dreamTriggered: dreamResult.triggered,
-                    dreamReason: dreamResult.reason,
-                    dreamInsights: dreamResult.insightsGenerated,
-                    dreamInsightsApplied: dreamResult.insightsApplied,
+                    dreamTriggered: false,
+                    dreamReason: 'deferred-to-kernel',
                 });
             }
             else {
@@ -373,12 +370,6 @@ export function registerTaskHooks(hooks) {
                 if (patternsLearned > 0) {
                     console.log(chalk.green(`  Patterns learned: ${patternsLearned}`));
                 }
-                if (dreamResult.triggered) {
-                    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/learning.js

@@ -65,6 +65,7 @@ Examples:
     registerDreamCommand(learning);
     registerRepairCommand(learning);
     registerHealthCommand(learning);
+    registerLoopHealthCommand(learning);
     return learning;
 }
 // ============================================================================
@@ -1414,6 +1415,199 @@ function registerHealthCommand(learning) {
     });
 }
 // ============================================================================
+// Subcommand: loop-health (#488 B.2)
+// ============================================================================
+/**
+ * Component staleness thresholds (ms). Each component has its own expected
+ * cadence — the bridge polls every 5s, the learning worker ticks every 30
+ * min, the dream scheduler is variable. Anything older than ~2x its cadence
+ * counts as stale and operators should investigate.
+ */
+const COMPONENT_STALE_THRESHOLDS = {
+    bridge: 30_000, // 5s poll → stale at 30s
+    learningWorker: 2 * 3600_000, // 30 min tick → stale at 2h
+    dreamScheduler: 2 * 3600_000, // similar cadence to worker
+};
+function registerLoopHealthCommand(learning) {
+    learning
+        .command('loop-health')
+        .description('Show pipeline component liveness for the self-learning loop')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        try {
+            const projectRoot = findProjectRoot();
+            const dbPath = path.join(projectRoot, '.agentic-qe', 'memory.db');
+            if (!existsSync(dbPath)) {
+                throw new Error('Database not found. Run "aqe init --auto" first.');
+            }
+            const db = openDatabase(dbPath, { readonly: true });
+            let raw;
+            try {
+                // Try the unified kv_store first (kernel-owned key).
+                const row = db
+                    .prepare(`SELECT value FROM kv_store WHERE key = 'learning:loop-health' LIMIT 1`)
+                    .get();
+                raw = row?.value;
+            }
+            catch {
+                // kv_store may not exist yet on a freshly-init'd shop.
+            }
+            // ADR-095: routing diversification stats (7-day rolling window)
+            let routingStats = null;
+            try {
+                const colCheck = db
+                    .prepare("PRAGMA table_info(routing_outcomes)")
+                    .all();
+                const hasExploration = colCheck.some((c) => c.name === 'exploration');
+                if (hasExploration) {
+                    const totals = db
+                        .prepare(`SELECT
+                   COUNT(*) AS total,
+                   SUM(CASE WHEN exploration = 1 THEN 1 ELSE 0 END) AS explore,
+                   AVG(criticality) AS avgCrit,
+                   AVG(q_weight) AS avgQ
+                 FROM routing_outcomes
+                 WHERE created_at >= datetime('now', '-7 days')`)
+                        .get();
+                    const total = totals.total ?? 0;
+                    const explore = totals.explore ?? 0;
+                    const exploit = total - explore;
+                    const exploitQ = db
+                        .prepare(`SELECT AVG(quality_score) AS avgQ FROM routing_outcomes
+                  WHERE exploration = 0 AND quality_score >= 0
+                    AND created_at >= datetime('now', '-7 days')`)
+                        .get();
+                    const exploreQ = db
+                        .prepare(`SELECT AVG(quality_score) AS avgQ FROM routing_outcomes
+                  WHERE exploration = 1 AND quality_score >= 0
+                    AND created_at >= datetime('now', '-7 days')`)
+                        .get();
+                    routingStats = {
+                        totalDecisions: total,
+                        explorationCount: explore,
+                        exploitCount: exploit,
+                        explorationRate: total > 0 ? explore / total : 0,
+                        avgQualityExploit: exploitQ.avgQ,
+                        avgQualityExplore: exploreQ.avgQ,
+                        avgCriticality: totals.avgCrit,
+                        avgQWeight: totals.avgQ,
+                    };
+                }
+            }
+            catch {
+                // routing_outcomes missing or pre-ADR-095 schema — skip silently.
+            }
+            db.close();
+            let health = null;
+            if (raw) {
+                try {
+                    health = safeJsonParse(raw);
+                }
+                catch {
+                    health = null;
+                }
+            }
+            const now = Date.now();
+            const verdict = (componentKey, c) => {
+                const threshold = COMPONENT_STALE_THRESHOLDS[componentKey] ?? 600_000;
+                if (!c || !c.lastSuccessAt)
+                    return 'never-ran';
+                const age = now - new Date(c.lastSuccessAt).getTime();
+                return age > threshold ? 'stale' : 'live';
+            };
+            if (options.json) {
+                if (!health) {
+                    printJson({
+                        overallLastSuccess: null,
+                        bootedAt: null,
+                        components: {},
+                        verdicts: {},
+                        routingDiversification: routingStats,
+                        note: 'No loop-health record yet. Workers must run at least once for this to populate.',
+                    });
+                    return;
+                }
+                const verdicts = {};
+                for (const key of Object.keys(health.components)) {
+                    verdicts[key] = verdict(key, health.components[key]);
+                }
+                printJson({ ...health, verdicts, routingDiversification: routingStats });
+                return;
+            }
+            console.log('');
+            console.log(chalk.bold('Self-Learning Loop Health'));
+            console.log('');
+            if (!health) {
+                console.log(chalk.dim('  No loop-health record yet.'));
+                console.log(chalk.dim('  Workers must run at least once to populate.'));
+                console.log(chalk.dim('  Start the daemon: aqe daemon start'));
+                // FALL THROUGH (no early return): routing-diversification stats may
+                // still be available even when loop-health components haven't ticked
+                // yet (e.g., routing happened via hook handlers but daemon-side
+                // workers never ran). Operators need both signals visible.
+            }
+            else {
+                console.log(`  Booted at:           ${chalk.dim(health.bootedAt)}`);
+                console.log(`  Last success (any):  ${health.overallLastSuccess || chalk.dim('(none yet)')}`);
+                console.log('');
+                console.log(chalk.bold('  Components:'));
+                const known = [
+                    ['bridge', 'CapturedExperienceBridge'],
+                    ['learningWorker', 'LearningConsolidationWorker'],
+                    ['dreamScheduler', 'DreamScheduler'],
+                ];
+                for (const [key, label] of known) {
+                    const c = health.components[key];
+                    const v = verdict(key, c);
+                    const colored = v === 'live'
+                        ? chalk.green('● live')
+                        : v === 'stale'
+                            ? chalk.yellow('● stale')
+                            : chalk.dim('○ never-ran');
+                    const lastSuccess = c?.lastSuccessAt || chalk.dim('(never)');
+                    const ticks = c
+                        ? `${c.successesSinceBoot}/${c.ticksSinceBoot} ticks ok`
+                        : chalk.dim('no ticks');
+                    console.log(`    ${label.padEnd(32)} ${colored.padEnd(20)} ${ticks}`);
+                    console.log(`      ${chalk.dim('last success:')} ${lastSuccess}`);
+                    if (c?.lastError) {
+                        console.log(`      ${chalk.red('last error:')} ${c.lastError.message} ${chalk.dim('(at ' + c.lastError.at + ')')}`);
+                    }
+                }
+                const stale = known.filter(([k, _]) => verdict(k, health.components[k]) === 'stale');
+                if (stale.length > 0) {
+                    console.log('');
+                    console.log(chalk.yellow(`  Warning: ${stale.length} component(s) stale — daemon may not be running or the loop is wedged.`));
+                }
+            }
+            // ADR-095: routing diversification dashboard
+            if (routingStats && routingStats.totalDecisions > 0) {
+                console.log('');
+                console.log(chalk.bold('  Routing diversification (last 7 days):'));
+                const ratePct = (routingStats.explorationRate * 100).toFixed(1);
+                console.log(`    Decisions:           ${routingStats.totalDecisions} (${routingStats.exploitCount} exploit, ${routingStats.explorationCount} explore = ${ratePct}%)`);
+                if (routingStats.avgQualityExploit !== null && routingStats.avgQualityExplore !== null) {
+                    const delta = routingStats.avgQualityExplore - routingStats.avgQualityExploit;
+                    const deltaStr = delta >= 0 ? chalk.green(`+${delta.toFixed(3)}`) : chalk.red(delta.toFixed(3));
+                    console.log(`    Avg quality:         exploit=${routingStats.avgQualityExploit.toFixed(3)}, explore=${routingStats.avgQualityExplore.toFixed(3)} (Δ ${deltaStr})`);
+                }
+                if (routingStats.avgCriticality !== null) {
+                    console.log(`    Avg mincut multiplier:  ${routingStats.avgCriticality.toFixed(2)} (1.0=full rate, 0.2=critical-topology dampening)`);
+                }
+                if (routingStats.avgQWeight !== null && routingStats.avgQWeight > 0) {
+                    console.log(`    Avg Q-weight:        ${routingStats.avgQWeight.toFixed(3)} (0=cold start, ${0.4} max)`);
+                }
+            }
+            console.log('');
+            return;
+        }
+        catch (error) {
+            printError(`loop-health failed: ${error instanceof Error ? error.message : 'unknown'}`);
+            throw error;
+        }
+    });
+}
+// ============================================================================
 // Exports
 // ============================================================================
 export { initializeLearningSystem } from './learning-helpers.js';

package/dist/cli/commands/sync.js

@@ -16,8 +16,11 @@ import ora from 'ora';
 import { createSyncAgent, syncToCloud, syncIncrementalToCloud, DEFAULT_SYNC_CONFIG, pullFromCloud, pullIncrementalFromCloud, } from '../../sync/index.js';
 import * as fs from 'fs';
 import * as path from 'path';
+import { fileURLToPath } from 'url';
 import { toErrorMessage } from '../../shared/error-utils.js';
 import { findPackageRoot } from '../../init/find-package-root.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 /**
  * Create sync commands
  */

package/dist/domains/requirements-validation/services/quality-criteria/quality-criteria-service.js

@@ -5,8 +5,11 @@
  * Part of the QCSD (Quality Conscious Software Delivery) framework.
  */
 import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
 import { HTSM_CATEGORIES, NEVER_OMIT_CATEGORIES } from './types.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
 // ============================================================================
 // Quality Criteria Service
 // ============================================================================

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

@@ -8,8 +8,11 @@
  * - Adds full env vars and v3 settings sections
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { join } from 'path';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
 import { safeJsonParse } from '../../shared/safe-json.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
 import { isAqeHookEntry, mergeHooksSmart, generateAqeEnvVars, generateV3SettingsSections, } from '../settings-merge.js';
 import { BasePhase, } from './phase-interface.js';
 /**

package/dist/init/phases/10-workers.js

@@ -3,8 +3,11 @@
  * Configures background workers for continuous monitoring
  */
 import { existsSync, mkdirSync, writeFileSync } from 'fs';
-import { join } from 'path';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
 import { BasePhase, } from './phase-interface.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
 /**
  * Workers phase - configures background workers
  */
@@ -118,12 +121,30 @@ if (existsSync(pidFile)) {
 const ts = new Date().toISOString();
 appendFileSync(logFile, '[' + ts + '] Starting AQE v3 Worker Daemon...\\n');
 
-// Find the best way to run aqe-mcp
+// Find the best way to run aqe-mcp.
+//
+// #488 B.1: candidate ordering matters for the pidfile contract. When we
+// spawn the real MCP binary directly, child.pid is the long-lived process
+// — \`process.kill(pid, 0)\` against the pidfile correctly reports liveness.
+// When we fall back to \`npx --yes agentic-qe mcp\`, child.pid is the npx
+// wrapper PID, which exits as soon as it has forked the real bundle. The
+// pidfile then points at a dead process and idempotency checks misbehave.
+//
+// We try in order: local .bin → local node_modules bundle → global install
+// via require.resolve → npx wrapper (last resort, with the caveat above).
 const candidates = [
   join(projectRoot, 'node_modules', '.bin', 'aqe-mcp'),
   join(projectRoot, 'node_modules', 'agentic-qe', 'dist', 'mcp', 'bundle.js'),
 ];
 
+// Probe globally-installed agentic-qe (npm install -g) via require.resolve.
+// This is the case the npx fallback used to silently cover with a bad PID.
+try {
+  candidates.push(require.resolve('agentic-qe/dist/mcp/bundle.js'));
+} catch {
+  // Not globally installed — fall through to npx fallback below.
+}
+
 let mcpCmd, mcpArgs;
 const binCandidate = candidates.find(c => existsSync(c));
 
@@ -136,6 +157,7 @@ if (binCandidate && binCandidate.endsWith('bundle.js')) {
 } else {
   mcpCmd = process.platform === 'win32' ? 'npx.cmd' : 'npx';
   mcpArgs = ['--yes', 'agentic-qe', 'mcp'];
+  appendFileSync(logFile, '[' + ts + '] WARNING: using npx fallback — daemon.pid will point at the npx wrapper, not the MCP server. \`aqe daemon status\` may misreport liveness after the wrapper exits.\\n');
 }
 
 appendFileSync(logFile, '[' + ts + '] Using: ' + mcpCmd + ' ' + mcpArgs.join(' ') + '\\n');