agentic-qe 3.6.7 → 3.6.8

package/v3/dist/mcp/bundle.js

@@ -6115,6 +6115,10 @@ var init_unified_memory = __esm({
       constructor(config) {
         const resolvedDefaults = getResolvedDefaultConfig();
         this.config = { ...resolvedDefaults, ...config };
+        if (!path.isAbsolute(this.config.dbPath)) {
+          const projectRoot = findProjectRoot();
+          this.config.dbPath = path.join(projectRoot, this.config.dbPath);
+        }
       }
       /**
        * Get or create the singleton instance (synchronous).
@@ -7080,6 +7084,211 @@ var init_real_embeddings = __esm({
   }
 });
 
+// src/kernel/unified-persistence.ts
+function getUnifiedPersistence(config) {
+  return UnifiedPersistenceManager.getInstance(config);
+}
+async function initializeUnifiedPersistence(config) {
+  const manager = getUnifiedPersistence(config);
+  await manager.initialize();
+  return manager;
+}
+function registerExitHandlers2() {
+  if (exitHandlersRegistered2) return;
+  exitHandlersRegistered2 = true;
+  const cleanup = () => {
+    try {
+      const instance3 = UnifiedPersistenceManager["instance"];
+      if (instance3) {
+        instance3.close();
+      }
+    } catch (error) {
+      console.debug("[UnifiedPersistence] Cleanup error:", error instanceof Error ? error.message : error);
+    }
+  };
+  process.on("beforeExit", cleanup);
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    cleanup();
+    process.exit(0);
+  });
+}
+var DEFAULT_UNIFIED_CONFIG, UnifiedPersistenceManager, exitHandlersRegistered2;
+var init_unified_persistence = __esm({
+  "src/kernel/unified-persistence.ts"() {
+    "use strict";
+    init_unified_memory();
+    DEFAULT_UNIFIED_CONFIG = {
+      dbPath: DEFAULT_UNIFIED_MEMORY_CONFIG.dbPath,
+      // '.agentic-qe/memory.db'
+      walMode: true,
+      mmapSize: 64 * 1024 * 1024,
+      // 64MB
+      cacheSize: -32e3,
+      // 32MB
+      busyTimeout: 5e3
+    };
+    UnifiedPersistenceManager = class _UnifiedPersistenceManager {
+      static instance = null;
+      static instancePromise = null;
+      unifiedMemory = null;
+      config;
+      initialized = false;
+      initPromise = null;
+      constructor(config) {
+        this.config = { ...DEFAULT_UNIFIED_CONFIG, ...config };
+      }
+      /**
+       * Get or create the singleton instance (synchronous).
+       * Thread-safe: JS is single-threaded for synchronous code.
+       */
+      static getInstance(config) {
+        if (_UnifiedPersistenceManager.instance) {
+          return _UnifiedPersistenceManager.instance;
+        }
+        _UnifiedPersistenceManager.instance = new _UnifiedPersistenceManager(config);
+        return _UnifiedPersistenceManager.instance;
+      }
+      /**
+       * Get or create the singleton instance with async initialization.
+       * Thread-safe: Uses Promise lock to prevent concurrent initialization races.
+       */
+      static async getInstanceAsync(config) {
+        if (_UnifiedPersistenceManager.instance?.initialized) {
+          return _UnifiedPersistenceManager.instance;
+        }
+        if (!_UnifiedPersistenceManager.instancePromise) {
+          _UnifiedPersistenceManager.instancePromise = (async () => {
+            const instance3 = _UnifiedPersistenceManager.getInstance(config);
+            await instance3.initialize();
+            return instance3;
+          })();
+        }
+        return _UnifiedPersistenceManager.instancePromise;
+      }
+      /**
+       * Reset the singleton (for testing)
+       */
+      static resetInstance() {
+        if (_UnifiedPersistenceManager.instance) {
+          _UnifiedPersistenceManager.instance.close();
+          _UnifiedPersistenceManager.instance = null;
+        }
+        _UnifiedPersistenceManager.instancePromise = null;
+        resetUnifiedMemory();
+      }
+      /**
+       * Initialize the database and create all schemas.
+       * Thread-safe: Uses Promise lock to prevent concurrent initialization races.
+       */
+      async initialize() {
+        if (this.initialized) return;
+        if (!this.initPromise) {
+          this.initPromise = this._doInitialize();
+        }
+        return this.initPromise;
+      }
+      /**
+       * Internal initialization implementation
+       */
+      async _doInitialize() {
+        if (this.initialized) return;
+        try {
+          const memoryConfig = {
+            dbPath: this.config.dbPath,
+            walMode: this.config.walMode,
+            busyTimeout: this.config.busyTimeout,
+            mmapSize: this.config.mmapSize,
+            cacheSize: this.config.cacheSize
+          };
+          this.unifiedMemory = getUnifiedMemory(memoryConfig);
+          await this.unifiedMemory.initialize();
+          this.initialized = true;
+          console.log(`[UnifiedPersistence] Initialized via UnifiedMemoryManager: ${this.config.dbPath}`);
+        } catch (error) {
+          this.initPromise = null;
+          throw new Error(
+            `Failed to initialize UnifiedPersistenceManager: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      /**
+       * Get the raw database connection for advanced operations
+       */
+      getDatabase() {
+        if (!this.unifiedMemory || !this.initialized) {
+          throw new Error("UnifiedPersistenceManager not initialized");
+        }
+        return this.unifiedMemory.getDatabase();
+      }
+      /**
+       * Check if initialized
+       */
+      isInitialized() {
+        return this.initialized;
+      }
+      /**
+       * Get the database path
+       */
+      getDbPath() {
+        return this.config.dbPath;
+      }
+      /**
+       * Prepare and cache a statement
+       */
+      prepare(name, sql) {
+        if (!this.unifiedMemory) throw new Error("Database not initialized");
+        return this.unifiedMemory.prepare(name, sql);
+      }
+      /**
+       * Execute a transaction
+       */
+      transaction(fn) {
+        if (!this.unifiedMemory) throw new Error("Database not initialized");
+        return this.unifiedMemory.transaction(fn);
+      }
+      /**
+       * Get database statistics
+       */
+      getStats() {
+        if (!this.unifiedMemory) throw new Error("Database not initialized");
+        const memStats = this.unifiedMemory.getStats();
+        return {
+          tables: memStats.tables,
+          fileSize: memStats.fileSize,
+          walSize: memStats.walSize
+        };
+      }
+      /**
+       * Vacuum the database to reclaim space
+       */
+      vacuum() {
+        const db = this.getDatabase();
+        db.exec("VACUUM");
+      }
+      /**
+       * Checkpoint WAL to main database
+       */
+      checkpoint() {
+        const db = this.getDatabase();
+        db.pragma("wal_checkpoint(TRUNCATE)");
+      }
+      /**
+       * Close the database connection
+       */
+      close() {
+        this.initialized = false;
+        console.log("[UnifiedPersistence] Facade closed");
+      }
+    };
+    exitHandlersRegistered2 = false;
+    registerExitHandlers2();
+  }
+});
+
 // src/coordination/consensus/model-provider.ts
 function buildVerificationPrompt(finding, options = {}) {
   const {
@@ -9508,206 +9717,6 @@ var init_sona_wrapper = __esm({
   }
 });
 
-// src/kernel/unified-persistence.ts
-function getUnifiedPersistence(config) {
-  return UnifiedPersistenceManager.getInstance(config);
-}
-function registerExitHandlers2() {
-  if (exitHandlersRegistered2) return;
-  exitHandlersRegistered2 = true;
-  const cleanup = () => {
-    try {
-      const instance3 = UnifiedPersistenceManager["instance"];
-      if (instance3) {
-        instance3.close();
-      }
-    } catch (error) {
-      console.debug("[UnifiedPersistence] Cleanup error:", error instanceof Error ? error.message : error);
-    }
-  };
-  process.on("beforeExit", cleanup);
-  process.on("SIGINT", () => {
-    cleanup();
-    process.exit(0);
-  });
-  process.on("SIGTERM", () => {
-    cleanup();
-    process.exit(0);
-  });
-}
-var DEFAULT_UNIFIED_CONFIG, UnifiedPersistenceManager, exitHandlersRegistered2;
-var init_unified_persistence = __esm({
-  "src/kernel/unified-persistence.ts"() {
-    "use strict";
-    init_unified_memory();
-    DEFAULT_UNIFIED_CONFIG = {
-      dbPath: DEFAULT_UNIFIED_MEMORY_CONFIG.dbPath,
-      // '.agentic-qe/memory.db'
-      walMode: true,
-      mmapSize: 64 * 1024 * 1024,
-      // 64MB
-      cacheSize: -32e3,
-      // 32MB
-      busyTimeout: 5e3
-    };
-    UnifiedPersistenceManager = class _UnifiedPersistenceManager {
-      static instance = null;
-      static instancePromise = null;
-      unifiedMemory = null;
-      config;
-      initialized = false;
-      initPromise = null;
-      constructor(config) {
-        this.config = { ...DEFAULT_UNIFIED_CONFIG, ...config };
-      }
-      /**
-       * Get or create the singleton instance (synchronous).
-       * Thread-safe: JS is single-threaded for synchronous code.
-       */
-      static getInstance(config) {
-        if (_UnifiedPersistenceManager.instance) {
-          return _UnifiedPersistenceManager.instance;
-        }
-        _UnifiedPersistenceManager.instance = new _UnifiedPersistenceManager(config);
-        return _UnifiedPersistenceManager.instance;
-      }
-      /**
-       * Get or create the singleton instance with async initialization.
-       * Thread-safe: Uses Promise lock to prevent concurrent initialization races.
-       */
-      static async getInstanceAsync(config) {
-        if (_UnifiedPersistenceManager.instance?.initialized) {
-          return _UnifiedPersistenceManager.instance;
-        }
-        if (!_UnifiedPersistenceManager.instancePromise) {
-          _UnifiedPersistenceManager.instancePromise = (async () => {
-            const instance3 = _UnifiedPersistenceManager.getInstance(config);
-            await instance3.initialize();
-            return instance3;
-          })();
-        }
-        return _UnifiedPersistenceManager.instancePromise;
-      }
-      /**
-       * Reset the singleton (for testing)
-       */
-      static resetInstance() {
-        if (_UnifiedPersistenceManager.instance) {
-          _UnifiedPersistenceManager.instance.close();
-          _UnifiedPersistenceManager.instance = null;
-        }
-        _UnifiedPersistenceManager.instancePromise = null;
-        resetUnifiedMemory();
-      }
-      /**
-       * Initialize the database and create all schemas.
-       * Thread-safe: Uses Promise lock to prevent concurrent initialization races.
-       */
-      async initialize() {
-        if (this.initialized) return;
-        if (!this.initPromise) {
-          this.initPromise = this._doInitialize();
-        }
-        return this.initPromise;
-      }
-      /**
-       * Internal initialization implementation
-       */
-      async _doInitialize() {
-        if (this.initialized) return;
-        try {
-          const memoryConfig = {
-            dbPath: this.config.dbPath,
-            walMode: this.config.walMode,
-            busyTimeout: this.config.busyTimeout,
-            mmapSize: this.config.mmapSize,
-            cacheSize: this.config.cacheSize
-          };
-          this.unifiedMemory = getUnifiedMemory(memoryConfig);
-          await this.unifiedMemory.initialize();
-          this.initialized = true;
-          console.log(`[UnifiedPersistence] Initialized via UnifiedMemoryManager: ${this.config.dbPath}`);
-        } catch (error) {
-          this.initPromise = null;
-          throw new Error(
-            `Failed to initialize UnifiedPersistenceManager: ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
-      }
-      /**
-       * Get the raw database connection for advanced operations
-       */
-      getDatabase() {
-        if (!this.unifiedMemory || !this.initialized) {
-          throw new Error("UnifiedPersistenceManager not initialized");
-        }
-        return this.unifiedMemory.getDatabase();
-      }
-      /**
-       * Check if initialized
-       */
-      isInitialized() {
-        return this.initialized;
-      }
-      /**
-       * Get the database path
-       */
-      getDbPath() {
-        return this.config.dbPath;
-      }
-      /**
-       * Prepare and cache a statement
-       */
-      prepare(name, sql) {
-        if (!this.unifiedMemory) throw new Error("Database not initialized");
-        return this.unifiedMemory.prepare(name, sql);
-      }
-      /**
-       * Execute a transaction
-       */
-      transaction(fn) {
-        if (!this.unifiedMemory) throw new Error("Database not initialized");
-        return this.unifiedMemory.transaction(fn);
-      }
-      /**
-       * Get database statistics
-       */
-      getStats() {
-        if (!this.unifiedMemory) throw new Error("Database not initialized");
-        const memStats = this.unifiedMemory.getStats();
-        return {
-          tables: memStats.tables,
-          fileSize: memStats.fileSize,
-          walSize: memStats.walSize
-        };
-      }
-      /**
-       * Vacuum the database to reclaim space
-       */
-      vacuum() {
-        const db = this.getDatabase();
-        db.exec("VACUUM");
-      }
-      /**
-       * Checkpoint WAL to main database
-       */
-      checkpoint() {
-        const db = this.getDatabase();
-        db.pragma("wal_checkpoint(TRUNCATE)");
-      }
-      /**
-       * Close the database connection
-       */
-      close() {
-        this.initialized = false;
-        console.log("[UnifiedPersistence] Facade closed");
-      }
-    };
-    exitHandlersRegistered2 = false;
-    registerExitHandlers2();
-  }
-});
-
 // native-require:@ruvector/attention
 var attention_exports = {};
 __export(attention_exports, {
@@ -28026,13 +28035,13 @@ var PathTraversalValidator = class {
    */
   joinPathsAbsolute(...paths) {
     if (paths.length === 0) return "";
-    const isAbsolute5 = paths[0].startsWith("/");
+    const isAbsolute6 = paths[0].startsWith("/");
     const result = paths.map((p74) => {
       while (p74.startsWith("/")) p74 = p74.slice(1);
       while (p74.endsWith("/")) p74 = p74.slice(0, -1);
       return p74;
     }).filter(Boolean).join("/");
-    return isAbsolute5 ? `/${result}` : result;
+    return isAbsolute6 ? `/${result}` : result;
   }
   /**
    * Get file extension from path
@@ -31431,6 +31440,7 @@ var SemanticAntiDriftMiddleware = class {
 // src/kernel/kernel.ts
 init_constants();
 init_unified_memory();
+init_unified_persistence();
 import * as path12 from "path";
 import * as fs11 from "fs";
 
@@ -117958,6 +117968,13 @@ var QEKernelImpl = class {
     if (this._initialized) {
       return;
     }
+    if (this._config.memoryBackend === "memory") {
+      const tmpDbPath = path12.join(
+        __require("os").tmpdir(),
+        `aqe-test-${Date.now()}-${Math.random().toString(36).slice(2)}.db`
+      );
+      await initializeUnifiedPersistence({ dbPath: tmpDbPath });
+    }
     await this._memory.initialize();
     const antiDriftMiddleware = new SemanticAntiDriftMiddleware({
       agentId: "qe-kernel"
@@ -119989,7 +120006,10 @@ var QueenMinCutBridge = class {
     }
     this.eventSubscriptions = [];
     if (this.config.persistData) {
-      await this.saveSnapshot();
+      try {
+        await this.saveSnapshot();
+      } catch {
+      }
     }
     this.initialized = false;
   }
@@ -130425,34 +130445,55 @@ var ExperienceReplay = class {
     console.log("[ExperienceReplay] Initialized");
   }
   /**
-   * Ensure required schema exists
+   * Ensure required schema exists.
+   * Uses captured_experiences as the canonical table (written by experience-capture-middleware).
+   * Adds ExperienceReplay-specific columns if missing.
    */
   ensureSchema() {
     if (!this.db) throw new Error("Database not initialized");
     this.db.exec(`
-      CREATE TABLE IF NOT EXISTS experiences (
+      CREATE TABLE IF NOT EXISTS captured_experiences (
         id TEXT PRIMARY KEY,
-        trajectory_id TEXT NOT NULL,
         task TEXT NOT NULL,
-        domain TEXT NOT NULL,
-        strategy TEXT NOT NULL,
-        key_actions TEXT NOT NULL,
-        quality_score REAL NOT NULL DEFAULT 0.5,
+        agent TEXT NOT NULL,
+        domain TEXT NOT NULL DEFAULT '',
+        success INTEGER NOT NULL DEFAULT 0,
+        quality REAL NOT NULL DEFAULT 0.5,
+        duration_ms INTEGER NOT NULL DEFAULT 0,
+        model_tier INTEGER,
+        routing_json TEXT,
+        steps_json TEXT,
+        result_json TEXT,
+        error TEXT,
+        started_at TEXT NOT NULL DEFAULT (datetime('now')),
+        completed_at TEXT NOT NULL DEFAULT (datetime('now')),
+        source TEXT DEFAULT 'middleware',
         application_count INTEGER DEFAULT 0,
-        success_rate REAL DEFAULT 1.0,
         avg_token_savings REAL DEFAULT 0,
         embedding BLOB,
         embedding_dimension INTEGER,
-        original_metrics TEXT,
         tags TEXT,
-        created_at TEXT DEFAULT (datetime('now')),
-        last_applied_at TEXT,
-        FOREIGN KEY (trajectory_id) REFERENCES qe_trajectories(id) ON DELETE SET NULL
+        last_applied_at TEXT
       );
-      CREATE INDEX IF NOT EXISTS idx_experiences_domain ON experiences(domain);
-      CREATE INDEX IF NOT EXISTS idx_experiences_quality ON experiences(quality_score DESC);
-      CREATE INDEX IF NOT EXISTS idx_experiences_task ON experiences(task);
+      CREATE INDEX IF NOT EXISTS idx_captured_exp_domain ON captured_experiences(domain);
+      CREATE INDEX IF NOT EXISTS idx_captured_exp_quality ON captured_experiences(quality DESC);
+      CREATE INDEX IF NOT EXISTS idx_captured_exp_task ON captured_experiences(task);
     `);
+    const columns = this.db.prepare("PRAGMA table_info(captured_experiences)").all();
+    const colNames = new Set(columns.map((c70) => c70.name));
+    const additions = [
+      ["application_count", "INTEGER DEFAULT 0"],
+      ["avg_token_savings", "REAL DEFAULT 0"],
+      ["embedding", "BLOB"],
+      ["embedding_dimension", "INTEGER"],
+      ["tags", "TEXT"],
+      ["last_applied_at", "TEXT"]
+    ];
+    for (const [col, def] of additions) {
+      if (!colNames.has(col)) {
+        this.db.exec(`ALTER TABLE captured_experiences ADD COLUMN ${col} ${def}`);
+      }
+    }
     this.db.exec(`
       CREATE TABLE IF NOT EXISTS experience_applications (
         id TEXT PRIMARY KEY,
@@ -130462,38 +130503,37 @@ var ExperienceReplay = class {
         tokens_saved INTEGER DEFAULT 0,
         feedback TEXT,
         applied_at TEXT DEFAULT (datetime('now')),
-        FOREIGN KEY (experience_id) REFERENCES experiences(id) ON DELETE CASCADE
+        FOREIGN KEY (experience_id) REFERENCES captured_experiences(id) ON DELETE CASCADE
       );
       CREATE INDEX IF NOT EXISTS idx_exp_apps_experience ON experience_applications(experience_id);
     `);
   }
   /**
-   * Prepare commonly used statements
+   * Prepare commonly used statements against captured_experiences table
    */
   prepareStatements() {
     if (!this.db) throw new Error("Database not initialized");
     this.prepared.set("insertExperience", this.db.prepare(`
-      INSERT INTO experiences (
-        id, trajectory_id, task, domain, strategy, key_actions, quality_score,
-        embedding, embedding_dimension, original_metrics, tags
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      INSERT INTO captured_experiences (
+        id, task, agent, domain, success, quality, duration_ms,
+        steps_json, routing_json, embedding, embedding_dimension, tags, source
+      ) VALUES (?, ?, ?, ?, 1, ?, 0, ?, ?, ?, ?, ?, 'experience-replay')
     `));
     this.prepared.set("getExperience", this.db.prepare(`
-      SELECT * FROM experiences WHERE id = ?
+      SELECT * FROM captured_experiences WHERE id = ?
     `));
     this.prepared.set("getExperiencesByDomain", this.db.prepare(`
-      SELECT * FROM experiences WHERE domain = ? ORDER BY quality_score DESC LIMIT ?
+      SELECT * FROM captured_experiences WHERE domain = ? ORDER BY quality DESC LIMIT ?
     `));
     this.prepared.set("getAllExperiences", this.db.prepare(`
-      SELECT * FROM experiences ORDER BY quality_score DESC LIMIT ?
+      SELECT * FROM captured_experiences ORDER BY quality DESC LIMIT ?
     `));
     this.prepared.set("getAllEmbeddings", this.db.prepare(`
-      SELECT id, embedding, embedding_dimension FROM experiences WHERE embedding IS NOT NULL
+      SELECT id, embedding, embedding_dimension FROM captured_experiences WHERE embedding IS NOT NULL
     `));
     this.prepared.set("updateApplication", this.db.prepare(`
-      UPDATE experiences SET
+      UPDATE captured_experiences SET
         application_count = application_count + 1,
-        success_rate = (success_rate * application_count + ?) / (application_count + 1),
         avg_token_savings = (avg_token_savings * application_count + ?) / (application_count + 1),
         last_applied_at = datetime('now')
       WHERE id = ?
@@ -130503,13 +130543,13 @@ var ExperienceReplay = class {
       VALUES (?, ?, ?, ?, ?, ?)
     `));
     this.prepared.set("deleteExperience", this.db.prepare(`
-      DELETE FROM experiences WHERE id = ?
+      DELETE FROM captured_experiences WHERE id = ?
     `));
     this.prepared.set("getLowQualityExperiences", this.db.prepare(`
-      SELECT id FROM experiences WHERE quality_score < ? AND application_count < 3
+      SELECT id FROM captured_experiences WHERE quality < ? AND application_count < 3
     `));
     this.prepared.set("countByDomain", this.db.prepare(`
-      SELECT domain, COUNT(*) as count FROM experiences GROUP BY domain
+      SELECT domain, COUNT(*) as count FROM captured_experiences GROUP BY domain
     `));
   }
   /**
@@ -130585,15 +130625,17 @@ var ExperienceReplay = class {
       const embeddingBuffer = embedding ? this.floatArrayToBuffer(embedding) : null;
       insertStmt.run(
         id,
-        trajectory.id,
         trajectory.task,
-        domain,
         strategy,
-        JSON.stringify(keyActions),
+        // agent column stores strategy
+        domain,
         trajectory.metrics.efficiencyScore,
+        JSON.stringify(keyActions),
+        // steps_json stores key actions
+        JSON.stringify(trajectory.metrics),
+        // routing_json stores original metrics
         embeddingBuffer,
         embedding?.length ?? null,
-        JSON.stringify(trajectory.metrics),
         JSON.stringify(tags)
       );
     }
@@ -130725,7 +130767,7 @@ var ExperienceReplay = class {
     this.ensureInitialized();
     const updateStmt = this.prepared.get("updateApplication");
     if (updateStmt) {
-      updateStmt.run(success ? 1 : 0, tokensSaved, experienceId);
+      updateStmt.run(tokensSaved, experienceId);
     }
     const insertStmt = this.prepared.get("insertApplication");
     if (insertStmt) {
@@ -130832,19 +130874,21 @@ var ExperienceReplay = class {
     if (!row2) return null;
     return {
       id: row2.id,
-      trajectoryId: row2.trajectory_id,
+      trajectoryId: row2.id,
+      // captured_experiences doesn't have trajectory_id
       task: row2.task,
       domain: row2.domain,
-      strategy: row2.strategy,
-      keyActions: JSON.parse(row2.key_actions || "[]"),
-      qualityScore: row2.quality_score,
-      applicationCount: row2.application_count,
-      successRate: row2.success_rate,
-      avgTokenSavings: row2.avg_token_savings,
+      strategy: row2.agent,
+      // agent column stores strategy/agent name
+      keyActions: JSON.parse(row2.steps_json || "[]"),
+      qualityScore: row2.quality,
+      applicationCount: row2.application_count ?? 0,
+      successRate: row2.success ? 1 : 0,
+      avgTokenSavings: row2.avg_token_savings ?? 0,
       embedding: row2.embedding && row2.embedding_dimension ? this.bufferToFloatArray(row2.embedding, row2.embedding_dimension) : void 0,
-      createdAt: new Date(row2.created_at),
+      createdAt: new Date(row2.started_at),
       lastAppliedAt: row2.last_applied_at ? new Date(row2.last_applied_at) : void 0,
-      originalMetrics: JSON.parse(row2.original_metrics || "{}"),
+      originalMetrics: JSON.parse(row2.routing_json || "{}"),
       tags: JSON.parse(row2.tags || "[]")
     };
   }
@@ -161043,6 +161087,25 @@ async function main() {
       }
     } catch (infraError) {
       originalStderrWrite(`[MCP] WARNING: Infra-healing init failed: ${infraError}
+`);
+    }
+    originalStderrWrite("[MCP] Auto-initializing fleet...\n");
+    try {
+      const fleetResult = await handleFleetInit({
+        topology: "hierarchical",
+        maxAgents: 15,
+        memoryBackend: "hybrid",
+        lazyLoading: true
+      });
+      if (fleetResult.success) {
+        originalStderrWrite(`[MCP] Fleet ready: ${fleetResult.data?.fleetId}
+`);
+      } else {
+        originalStderrWrite(`[MCP] WARNING: Fleet auto-init failed: ${fleetResult.error}
+`);
+      }
+    } catch (fleetError) {
+      originalStderrWrite(`[MCP] WARNING: Fleet auto-init error: ${fleetError}
 `);
     }
     originalStderrWrite("[MCP] Starting server...\n");