agentic-qe 3.9.30 → 3.9.32

package/dist/mcp/handlers/core-handlers.js

@@ -135,6 +135,27 @@ export async function handleFleetInit(params) {
                 domainPlugins.set(domain, plugin);
             }
         }
+        // Issue #491 Bug 1 + Bug 4b: the MCP-hosted daemon constructs its
+        // WorkerManager *before* the kernel exists (in src/mcp/entry.ts), so it
+        // starts with StubWorkerDomainAccess (getDomainAPI returns undefined for
+        // every domain) and a private InMemoryWorkerMemory the dashboard never
+        // reads from. Wire both now that kernel + plugins are ready. Without
+        // this, every domain-dependent worker tick fails with "<domain> not
+        // available" and `aqe learning loop-health` shows learningWorker as
+        // never-ran even when it executes every cycle.
+        try {
+            const { getDaemon } = await import('../../workers/daemon.js');
+            const workerManager = getDaemon().getWorkerManager();
+            workerManager.setKernel(state.kernel);
+            workerManager.setMemory(state.kernel.memory);
+        }
+        catch (err) {
+            // Daemon wiring is best-effort: a workless smoke install (e.g. some
+            // unit-test harnesses) may not even bundle the daemon module. Surface
+            // as a warning but don't fail fleet_init — the user still gets a
+            // working kernel + queen for MCP tool calls.
+            console.warn(`[fleet_init] Daemon worker manager wiring skipped: ${toErrorMessage(err)}`);
+        }
         // Create Queen Coordinator with domain plugins for direct task execution
         state.queen = createQueenCoordinator(state.kernel, state.router, protocolExecutor, undefined, // workflowExecutor
         domainPlugins // INTEGRATION FIX: Pass domain plugins

package/dist/routing/routing-feedback.js

@@ -12,6 +12,7 @@ import { safeJsonParse } from '../shared/safe-json.js';
 import { toErrorMessage } from '../shared/error-utils.js';
 import { EMACalibrator } from './calibration/index.js';
 import { AutoEscalationTracker } from './escalation/index.js';
+import { ensureRoutingOutcomesAdr095Columns } from './routing-outcomes-migration.js';
 import { EconomicRoutingModel, } from './economic-routing.js';
 import { getGlobalCostTracker } from '../shared/llm/cost-tracker.js';
 // ============================================================================
@@ -144,9 +145,9 @@ export class RoutingFeedbackCollector {
             return;
         try {
             const database = this.db.getDatabase();
-            // Ensure schema columns exist for databases created before ADR-092.
-            // Runs once per process via the flag; new databases have columns from
-            // unified-memory-schemas.ts CREATE TABLE.
+            // Ensure schema columns exist for databases created before ADR-092
+            // and ADR-095. Runs once per process via the flag; new databases have
+            // columns from unified-memory-schemas.ts CREATE TABLE.
             if (!RoutingFeedbackCollector.schemaMigrated) {
                 for (const col of [
                     'ALTER TABLE routing_outcomes ADD COLUMN model_tier TEXT',
@@ -157,6 +158,9 @@ export class RoutingFeedbackCollector {
                     }
                     catch { /* column already exists */ }
                 }
+                // ADR-095: routing exploration columns via shared helper so all
+                // writer paths agree on the column set.
+                ensureRoutingOutcomesAdr095Columns(database);
                 RoutingFeedbackCollector.schemaMigrated = true;
             }
             const modelTier = this.inferTier(outcome.usedAgent);

package/dist/routing/routing-outcomes-migration.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Routing Outcomes Schema Migration (ADR-095)
+ *
+ * Idempotently adds the ADR-095 columns (`exploration`, `criticality`,
+ * `q_weight`) to `routing_outcomes` for databases created before this
+ * release. New databases get the columns from `unified-memory-schemas.ts`
+ * at CREATE TABLE time; this helper handles upgrades.
+ *
+ * Pattern matches the existing ADR-092 migration in
+ * `src/routing/routing-feedback.ts:199-207` — try the ALTER, swallow the
+ * "duplicate column name" error if the column already exists.
+ *
+ * Callers run this before INSERTing rows that reference the new columns.
+ * A process-local flag prevents repeated migration attempts.
+ */
+import type { Database as DatabaseType } from 'better-sqlite3';
+/**
+ * Add the ADR-095 columns to routing_outcomes if they don't already exist.
+ * Safe to call multiple times — second and later calls are no-ops.
+ *
+ * Failure to migrate (e.g. table doesn't exist yet, permission error) is
+ * NOT fatal — callers that depend on the new columns should fall back to
+ * not writing them. The schema is forward-compatible: inserts that omit
+ * the new columns get the defaults.
+ */
+export declare function ensureRoutingOutcomesAdr095Columns(db: DatabaseType): void;
+/**
+ * Reset the process-local migration flag. Test-only.
+ */
+export declare function resetRoutingOutcomesMigrationState(): void;
+//# sourceMappingURL=routing-outcomes-migration.d.ts.map

package/dist/routing/routing-outcomes-migration.js

@@ -0,0 +1,60 @@
+/**
+ * Routing Outcomes Schema Migration (ADR-095)
+ *
+ * Idempotently adds the ADR-095 columns (`exploration`, `criticality`,
+ * `q_weight`) to `routing_outcomes` for databases created before this
+ * release. New databases get the columns from `unified-memory-schemas.ts`
+ * at CREATE TABLE time; this helper handles upgrades.
+ *
+ * Pattern matches the existing ADR-092 migration in
+ * `src/routing/routing-feedback.ts:199-207` — try the ALTER, swallow the
+ * "duplicate column name" error if the column already exists.
+ *
+ * Callers run this before INSERTing rows that reference the new columns.
+ * A process-local flag prevents repeated migration attempts.
+ */
+let migrated = false;
+/**
+ * Add the ADR-095 columns to routing_outcomes if they don't already exist.
+ * Safe to call multiple times — second and later calls are no-ops.
+ *
+ * Failure to migrate (e.g. table doesn't exist yet, permission error) is
+ * NOT fatal — callers that depend on the new columns should fall back to
+ * not writing them. The schema is forward-compatible: inserts that omit
+ * the new columns get the defaults.
+ */
+export function ensureRoutingOutcomesAdr095Columns(db) {
+    if (migrated)
+        return;
+    for (const stmt of [
+        'ALTER TABLE routing_outcomes ADD COLUMN exploration INTEGER NOT NULL DEFAULT 0',
+        'ALTER TABLE routing_outcomes ADD COLUMN criticality REAL',
+        'ALTER TABLE routing_outcomes ADD COLUMN q_weight REAL',
+    ]) {
+        try {
+            db.prepare(stmt).run();
+        }
+        catch {
+            // Column already exists, or table doesn't exist yet. Both are
+            // acceptable — ALTER is additive, and a missing table means the
+            // unified schema hasn't been applied yet (caller's INSERT will fail
+            // separately with a clearer error).
+        }
+    }
+    // Index on exploration for the bucket-comparison queries used by
+    // `aqe learning loop-health`. Idempotent via IF NOT EXISTS.
+    try {
+        db.prepare('CREATE INDEX IF NOT EXISTS idx_routing_outcomes_exploration ON routing_outcomes(exploration)').run();
+    }
+    catch {
+        // Table missing; index attempt is best-effort.
+    }
+    migrated = true;
+}
+/**
+ * Reset the process-local migration flag. Test-only.
+ */
+export function resetRoutingOutcomesMigrationState() {
+    migrated = false;
+}
+//# sourceMappingURL=routing-outcomes-migration.js.map

package/dist/workers/interfaces.d.ts

@@ -170,6 +170,20 @@ export interface WorkerDomainAccess {
         errors: string[];
     };
 }
+/**
+ * Structural shape of the kernel that worker-side code needs. Declared here
+ * (rather than imported from src/kernel) to avoid a circular dependency between
+ * the kernel and the workers package.
+ */
+export interface WorkerKernelReference {
+    getDomainAPI<T>(domain: DomainName): T | undefined;
+    getHealth(): {
+        domains: Record<string, {
+            status: string;
+            errors?: string[];
+        }>;
+    };
+}
 export interface WorkerHealth {
     /** Worker status */
     readonly status: WorkerStatus;
@@ -223,6 +237,18 @@ export interface WorkerManager {
      * Get manager health status
      */
     getHealth(): WorkerManagerHealth;
+    /**
+     * Bind the kernel late, after construction. Without this, workers fall
+     * through to a stub domain-access that returns undefined for every domain,
+     * causing every domain-dependent worker tick to fail (issue #491 Bug 1).
+     */
+    setKernel(kernel: WorkerKernelReference): void;
+    /**
+     * Bind the worker manager's memory to a shared instance (e.g. the kernel's
+     * HybridMemoryBackend) so workers and the dashboards that read worker output
+     * resolve to the same kv store (issue #491 Bug 4b).
+     */
+    setMemory(memory: WorkerMemory): void;
 }
 export interface WorkerManagerHealth {
     /** Total registered workers */

package/dist/workers/worker-manager.d.ts

@@ -5,20 +5,14 @@
  * Manages the lifecycle and scheduling of all background workers.
  * Provides centralized control for starting, stopping, and monitoring workers.
  */
-import { Worker, WorkerManager as IWorkerManager, WorkerManagerHealth, WorkerResult, WorkerEventBus, WorkerMemory, WorkerDomainAccess, WorkerEvent } from './interfaces';
-import { DomainName } from '../shared/types';
+import { Worker, WorkerManager as IWorkerManager, WorkerManagerHealth, WorkerResult, WorkerEventBus, WorkerMemory, WorkerDomainAccess, WorkerEvent, WorkerKernelReference } from './interfaces';
 /**
- * Reference interface for kernel (to avoid circular dependency)
+ * Local alias for the shared worker-kernel structural shape. The public type
+ * lives in interfaces.ts so the WorkerManager interface can refer to it
+ * without importing this file (which would re-introduce the circular
+ * dependency the original local declaration was avoiding).
  */
-interface KernelReference {
-    getDomainAPI<T>(domain: DomainName): T | undefined;
-    getHealth(): {
-        domains: Record<string, {
-            status: string;
-            errors?: string[];
-        }>;
-    };
-}
+type KernelReference = WorkerKernelReference;
 /**
  * Worker Manager implementation
  */
@@ -42,6 +36,15 @@ export declare class WorkerManagerImpl implements IWorkerManager {
      * Allows late binding of kernel after construction
      */
     setKernel(kernel: KernelReference): void;
+    /**
+     * Replace the worker manager's memory with a shared instance — typically the
+     * kernel's HybridMemoryBackend so dashboards reading worker-emitted keys
+     * (e.g. `learning:loop-health` in the `qe-kernel` namespace) actually see
+     * what workers write. Without this, workers write to the in-process
+     * InMemoryWorkerMemory and the dashboard reads a different kv (issue #491
+     * Bug 4b).
+     */
+    setMemory(memory: WorkerMemory): void;
     /**
      * Register a worker
      */

package/dist/workers/worker-manager.js

@@ -181,6 +181,17 @@ export class WorkerManagerImpl {
             this.domainAccess = new KernelWorkerDomainAccess(() => this.kernelRef);
         }
     }
+    /**
+     * Replace the worker manager's memory with a shared instance — typically the
+     * kernel's HybridMemoryBackend so dashboards reading worker-emitted keys
+     * (e.g. `learning:loop-health` in the `qe-kernel` namespace) actually see
+     * what workers write. Without this, workers write to the in-process
+     * InMemoryWorkerMemory and the dashboard reads a different kv (issue #491
+     * Bug 4b).
+     */
+    setMemory(memory) {
+        this.memory = memory;
+    }
     /**
      * Register a worker
      */

package/dist/workers/workers/learning-consolidation.d.ts

@@ -30,6 +30,34 @@ export declare class LearningConsolidationWorker extends BaseWorker {
      * Task Execution -> Experience Capture -> Pattern Extraction -> Pattern Promotion -> Pattern Utilization -> Improved Routing
      */
     private runContinuousLearningLoop;
+    /**
+     * #486 Gap A: mine experiences into `learning:pattern:*` kv per domain.
+     *
+     * The producer side of the learning-optimization domain pipeline:
+     *
+     *   captured_experiences (SQLite)
+     *     → bridge drain → learning.ExperienceCaptured event
+     *       → handleExperienceCaptured → recordExperience
+     *         → learning:experience:* kv (✓ working post-v3.9.29)
+     *           → mineExperiences (THIS STEP)
+     *             → extractPatternsFromExperiences → learnPattern → storePattern
+     *               → learning:pattern:* kv
+     *
+     * Without this step the chain ends at the experience kv, so `getPatternStats`
+     * reports zero patterns and the `LearningConsolidationWorker.collectPatterns`
+     * step a few lines above throws "No learning patterns to consolidate yet".
+     *
+     * Per-domain cursor avoids re-processing the same experiences (which would
+     * duplicate-write since `learnPattern` uses uuidv4 for pattern IDs). Cursor
+     * is stored in WorkerMemory under `learning:consolidation-cursor:{domain}`
+     * as an ISO timestamp. On first run, the cursor defaults to `now - 1 day`
+     * to match the lookback used elsewhere by `runLearningCycle`.
+     *
+     * Failures are isolated per domain — one bad domain doesn't block others.
+     * On failure or empty mining the cursor stays put so the next tick retries
+     * the same window with new experiences.
+     */
+    private mineExperiencesPerDomain;
     /**
      * Create patterns from pattern candidates
      */