agentic-qe 3.9.2 → 3.9.4

package/dist/cli/handlers/init-handler.js

@@ -29,6 +29,7 @@ export class InitHandler {
             .option('-u, --upgrade', 'Upgrade existing installation (overwrite skills, agents, validation)')
             .option('--minimal', 'Minimal configuration (skip optional features)')
             .option('--skip-patterns', 'Skip loading pre-trained patterns')
+            .option('--skip-code-index', 'Skip code intelligence pre-scan (run `aqe code index` later)')
             .option('--with-n8n', 'Install n8n workflow testing agents and skills')
             .option('--with-opencode', 'Include OpenCode agent/skill provisioning')
             .option('--with-kiro', 'Include AWS Kiro IDE integration (agents, skills, hooks, steering)')
@@ -97,6 +98,7 @@ export class InitHandler {
             upgrade: options.upgrade,
             minimal: options.minimal,
             skipPatterns: options.skipPatterns,
+            skipCodeIndex: options.skipCodeIndex,
             withN8n: options.withN8n,
             withOpenCode: options.withOpencode,
             withKiro: options.withKiro,

package/dist/init/governance-installer.js

@@ -13,28 +13,60 @@ import { existsSync, mkdirSync, readdirSync, copyFileSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { toErrorMessage } from '../shared/error-utils.js';
+import { findPackageRoot } from './find-package-root.js';
 // ============================================================================
 // Constants
 // ============================================================================
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 /**
- * Path to bundled governance assets
+ * Path to bundled governance assets.
+ *
+ * fix/init-v3-9-4: In v3.9.1 this function was missed when skills-installer,
+ * agents-installer, opencode-installer, and n8n-installer were migrated to
+ * findPackageRoot(). The old fixed-depth `__dirname + '../../'` traversals
+ * work when the file is compiled as a standalone ESM module at
+ * `dist/init/governance-installer.js`, but they silently break when esbuild
+ * code-splitting bundles this module into a chunk under
+ * `dist/cli/chunks/chunk-XXX.js` — at which point `__dirname` points to
+ * the chunks directory and both candidate traversals land outside the
+ * package. That made the governance phase throw "Governance assets not
+ * found. Package may be corrupted." during phase 13 of `aqe init`, which
+ * the orchestrator caught and reported as `x Install governance
+ * configuration (1ms)` on cf-devpod.
+ *
+ * Resolution order (each path is checked with existsSync):
+ *   1. Dev tree fixed paths — work when running from src/ or the
+ *      standalone-compiled dist/init/.
+ *   2. findPackageRoot() walk-up — finds the nearest package.json with
+ *      name=agentic-qe regardless of bundle depth. This is the correct
+ *      path for all production installs.
+ *   3. Consumer's node_modules — covers edge cases where the package is a
+ *      transitive dep.
+ *   4. process.cwd() fallback — dev tree when running from project root.
  */
 function getGovernanceAssetsPath() {
-    // In development: src/init -> assets/governance
-    // In production: dist/init -> dist/assets/governance (copied during build)
-    const devPath = join(__dirname, '../../assets/governance');
-    const prodPath = join(__dirname, '../assets/governance');
-    if (existsSync(devPath))
-        return devPath;
-    if (existsSync(prodPath))
-        return prodPath;
-    // Fallback to assets (when running from project root)
-    const fallbackPath = join(process.cwd(), 'assets/governance');
-    if (existsSync(fallbackPath))
-        return fallbackPath;
-    throw new Error('Governance assets not found. Package may be corrupted.');
+    // 1. Dev tree fixed paths (src/init/ and standalone dist/init/)
+    const candidates = [
+        join(__dirname, '../../assets/governance'),
+        join(__dirname, '../assets/governance'),
+    ];
+    // 2. Walk up to the package root (works for chunk-split bundles)
+    const packageRoot = findPackageRoot(import.meta.url);
+    if (packageRoot) {
+        candidates.push(join(packageRoot, 'assets/governance'));
+        candidates.push(join(packageRoot, 'dist/assets/governance'));
+    }
+    // 3. Consumer's node_modules
+    candidates.push(join(process.cwd(), 'node_modules/agentic-qe/assets/governance'));
+    // 4. Fallback to cwd (dev tree running from project root)
+    candidates.push(join(process.cwd(), 'assets/governance'));
+    for (const c of candidates) {
+        if (existsSync(c))
+            return c;
+    }
+    throw new Error('Governance assets not found. Package may be corrupted. ' +
+        `Searched: ${candidates.join(', ')}`);
 }
 // ============================================================================
 // Installer

package/dist/init/kiro-installer.js

@@ -9,6 +9,7 @@ import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, } from
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { toErrorMessage } from '../shared/error-utils.js';
+import { findPackageRoot } from './find-package-root.js';
 // ESM compatibility
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -35,12 +36,24 @@ export class KiroInstaller {
     // Source Directory Detection
     // ==========================================================================
     findOpenCodeDir() {
+        // fix/init-v3-9-4: same chunk-split bundle regression as
+        // governance-installer. Walk up to the agentic-qe package root
+        // via findPackageRoot() instead of using fragile __dirname + '../..'
+        // traversals that break when this module is bundled into a chunk
+        // under dist/cli/chunks/.
         const possiblePaths = [
-            // Development: src/init/ or dist/init/ -> project root
+            // Dev tree fixed paths (src/init/ and standalone dist/init/)
             join(__dirname, '../../.opencode'),
-            // NPM package location
             join(__dirname, '../../assets/opencode'),
         ];
+        // Walk up to the package root (works for chunk-split bundles)
+        const packageRoot = findPackageRoot(import.meta.url);
+        if (packageRoot) {
+            possiblePaths.push(join(packageRoot, '.opencode'));
+            possiblePaths.push(join(packageRoot, 'assets/opencode'));
+        }
+        // Consumer's node_modules
+        possiblePaths.push(join(process.cwd(), 'node_modules/agentic-qe/assets/opencode'), join(process.cwd(), 'node_modules/agentic-qe/.opencode'));
         for (const p of possiblePaths) {
             if (existsSync(p) && (existsSync(join(p, 'agents')) || existsSync(join(p, 'skills')))) {
                 return p;

package/dist/init/orchestrator.js

@@ -31,6 +31,7 @@ export class ModularInitOrchestrator {
                 autoMode: options.autoMode,
                 upgrade: options.upgrade,
                 skipPatterns: options.skipPatterns,
+                skipCodeIndex: options.skipCodeIndex,
                 minimal: options.minimal,
                 withN8n: options.withN8n,
                 withOpenCode: options.withOpenCode,

package/dist/init/phases/06-code-intelligence.d.ts

@@ -8,8 +8,10 @@
  */
 import { BasePhase, type InitContext } from './phase-interface.js';
 export interface CodeIntelligenceResult {
-    status: 'indexed' | 'existing' | 'skipped' | 'error';
+    status: 'indexed' | 'existing' | 'skipped' | 'error' | 'timeout';
     entries: number;
+    /** Last file the indexer touched before a timeout, if any. Used for diagnostics. */
+    timeoutFile?: string;
 }
 /**
  * Code Intelligence phase - builds knowledge graph
@@ -20,6 +22,19 @@ export declare class CodeIntelligencePhase extends BasePhase<CodeIntelligenceRes
     readonly order = 60;
     readonly critical = false;
     readonly requiresPhases: readonly ["database"];
+    /**
+     * Opt-out gate: v3.9.4 escape hatch for users whose code intelligence
+     * pre-scan stalls on native calls that the phase-level watchdog can't
+     * interrupt (because Node's event loop is blocked inside synchronous
+     * NAPI code). Setting `AQE_SKIP_CODE_INDEX=1` or passing
+     * `--skip-code-index` to `aqe init` bypasses this phase entirely.
+     * Lazy on-demand indexing still works when the user runs
+     * `aqe code index` or `aqe memory search` afterwards.
+     *
+     * See https://github.com/proffesor-for-testing/agentic-qe/issues/XXX
+     * for the tracking issue on the proper killable-worker fix.
+     */
+    shouldRun(context: InitContext): Promise<boolean>;
     protected run(context: InitContext): Promise<CodeIntelligenceResult>;
     /**
      * Check if code intelligence index exists (uses provided db connection)
@@ -38,8 +53,38 @@ export declare class CodeIntelligencePhase extends BasePhase<CodeIntelligenceRes
      * - Dependency analysis (impact of changes)
      * - Test target discovery (what tests cover what code)
      * - Token reduction (search KG instead of reading entire files)
+     *
+     * fix/init-v3-9-3 Fix 5: The whole scan is wrapped in a phase-level
+     * watchdog. Inside, each file is indexed via `indexOneFile()` with a
+     * per-file timeout so a single pathological file or a native-layer
+     * stall (e.g. @ruvector/rvf-node fsync on an overlay filesystem) can
+     * never block the init command indefinitely. Progress is logged every
+     * PROGRESS_LOG_INTERVAL files so operators can see exactly where the
+     * indexer is — and, if a timeout fires, which file was responsible.
      */
     private runCodeIntelligenceScan;
+    /**
+     * Drive file-by-file indexing with per-file and phase-level timeouts.
+     *
+     * fix/init-v3-9-3 Fix 5. This method is the reason v3.9.3 can survive
+     * pathological files and native-layer stalls that hung v3.9.1/v3.9.2.
+     *
+     * Invariants:
+     *   - A single file cannot block longer than PER_FILE_TIMEOUT_MS.
+     *   - The whole loop cannot block longer than PHASE_TIMEOUT_MS.
+     *   - Progress is observable via structured log lines.
+     *   - Partial results are kept — on timeout we return the entries
+     *     indexed so far, not zero.
+     */
+    private runBoundedScan;
+    /**
+     * Race a promise against a timer. On timeout, rejects with a tagged
+     * error so the caller can distinguish timeouts from real failures.
+     *
+     * The tagged error prefix 'AQE_PER_FILE_TIMEOUT' is matched in
+     * runBoundedScan to differentiate per-file timeouts from other errors.
+     */
+    private withTimeout;
     /**
      * Build hypergraph from indexed files.
      * Uses shared extractor to populate hypergraph_nodes/hypergraph_edges in memory.db.

package/dist/init/phases/06-code-intelligence.js

@@ -12,6 +12,20 @@ import { safeJsonParse } from '../../shared/safe-json.js';
 import { openDatabase } from '../../shared/safe-db.js';
 import { BasePhase, } from './phase-interface.js';
 import { createMemoryBackend } from '../../kernel/memory-factory.js';
+// ============================================================================
+// Watchdog configuration (fix/init-v3-9-3 Fix 5)
+//
+// These are deliberately generous. Normal codebases of 10k+ entities index
+// in under 3 seconds on a laptop. The caps exist so that a pathological file
+// or a native-layer stall (e.g. on an overlay filesystem) can't hang the
+// entire init command indefinitely. When a cap fires the phase returns
+// gracefully with status='timeout', the warning names the last file, and the
+// user can open an issue with that exact filename.
+// ============================================================================
+/** Per-file timeout. A single file must not take longer than this to index. */
+const PER_FILE_TIMEOUT_MS = 30_000;
+/** Whole-phase timeout. The full KG build must not take longer than this. */
+const PHASE_TIMEOUT_MS = 180_000;
 /** Patterns to exclude from code intelligence scanning */
 const SCAN_IGNORE_PATTERNS = [
     '**/node_modules/**',
@@ -52,6 +66,32 @@ export class CodeIntelligencePhase extends BasePhase {
     order = 60;
     critical = false;
     requiresPhases = ['database'];
+    /**
+     * Opt-out gate: v3.9.4 escape hatch for users whose code intelligence
+     * pre-scan stalls on native calls that the phase-level watchdog can't
+     * interrupt (because Node's event loop is blocked inside synchronous
+     * NAPI code). Setting `AQE_SKIP_CODE_INDEX=1` or passing
+     * `--skip-code-index` to `aqe init` bypasses this phase entirely.
+     * Lazy on-demand indexing still works when the user runs
+     * `aqe code index` or `aqe memory search` afterwards.
+     *
+     * See https://github.com/proffesor-for-testing/agentic-qe/issues/XXX
+     * for the tracking issue on the proper killable-worker fix.
+     */
+    async shouldRun(context) {
+        const envSkip = process.env.AQE_SKIP_CODE_INDEX;
+        if (envSkip === '1' || envSkip === 'true') {
+            context.services.log('  Code intelligence skipped (AQE_SKIP_CODE_INDEX=1)');
+            context.services.log('  Run `aqe code index` later to build the KG on demand.');
+            return false;
+        }
+        if (context.options.skipCodeIndex) {
+            context.services.log('  Code intelligence skipped (--skip-code-index)');
+            context.services.log('  Run `aqe code index` later to build the KG on demand.');
+            return false;
+        }
+        return true;
+    }
     async run(context) {
         const { projectRoot } = context;
         const dbPath = join(projectRoot, '.agentic-qe', 'memory.db');
@@ -133,6 +173,14 @@ export class CodeIntelligencePhase extends BasePhase {
      * - Dependency analysis (impact of changes)
      * - Test target discovery (what tests cover what code)
      * - Token reduction (search KG instead of reading entire files)
+     *
+     * fix/init-v3-9-3 Fix 5: The whole scan is wrapped in a phase-level
+     * watchdog. Inside, each file is indexed via `indexOneFile()` with a
+     * per-file timeout so a single pathological file or a native-layer
+     * stall (e.g. @ruvector/rvf-node fsync on an overlay filesystem) can
+     * never block the init command indefinitely. Progress is logged every
+     * PROGRESS_LOG_INTERVAL files so operators can see exactly where the
+     * indexer is — and, if a timeout fires, which file was responsible.
      */
     async runCodeIntelligenceScan(projectRoot, context, incremental, changedFiles) {
         try {
@@ -164,29 +212,135 @@ export class CodeIntelligencePhase extends BasePhase {
                 });
                 filesToIndex = files.map(f => join(projectRoot, f));
             }
-            const result = await kgService.index({
-                paths: filesToIndex,
-                incremental,
-                includeTests: true,
-            });
+            context.services.log(`  Scanning ${filesToIndex.length} source files...`);
+            // Race the whole scan against a phase-level watchdog. If the cap
+            // fires, we stop eating files and report how far we got.
+            const scanResult = await this.runBoundedScan(kgService, filesToIndex, incremental, context);
             kgService.destroy();
             await memory.dispose();
-            if (result.success) {
-                const entries = result.value.nodesCreated + result.value.edgesCreated;
+            if (scanResult.status === 'timeout') {
+                context.services.warn(`  ⚠ Code intelligence pre-scan exceeded ${PHASE_TIMEOUT_MS / 1000}s phase cap. ` +
+                    `Indexed ${scanResult.entries} entries before timeout. ` +
+                    `Last file: ${scanResult.timeoutFile ?? '(unknown)'}. ` +
+                    `Init is continuing — re-run 'aqe code index' later, or report this file to ` +
+                    `https://github.com/proffesor-for-testing/agentic-qe/issues.`);
+                return scanResult;
+            }
+            if (scanResult.status === 'indexed') {
                 const label = incremental ? 'Delta indexed' : 'Indexed';
-                context.services.log(`  ${label} ${entries} entries to ${dbPath}`);
+                context.services.log(`  ${label} ${scanResult.entries} entries to ${dbPath}`);
                 // Also populate the hypergraph tables (hypergraph_nodes/hypergraph_edges)
                 // so CLI/MCP hypergraph queries work immediately after init
                 await this.buildHypergraph(dbPath, filesToIndex, context);
-                return { status: 'indexed', entries };
             }
-            return { status: 'error', entries: 0 };
+            return scanResult;
         }
         catch (error) {
             context.services.warn(`Code intelligence scan warning: ${error}`);
             return { status: 'skipped', entries: 0 };
         }
     }
+    /**
+     * Drive file-by-file indexing with per-file and phase-level timeouts.
+     *
+     * fix/init-v3-9-3 Fix 5. This method is the reason v3.9.3 can survive
+     * pathological files and native-layer stalls that hung v3.9.1/v3.9.2.
+     *
+     * Invariants:
+     *   - A single file cannot block longer than PER_FILE_TIMEOUT_MS.
+     *   - The whole loop cannot block longer than PHASE_TIMEOUT_MS.
+     *   - Progress is observable via structured log lines.
+     *   - Partial results are kept — on timeout we return the entries
+     *     indexed so far, not zero.
+     */
+    async runBoundedScan(kgService, filesToIndex, incremental, context) {
+        // Use the public index() with a one-file array per call so we can
+        // attach a per-file timeout and log progress.
+        let totalNodes = 0;
+        let totalEdges = 0;
+        let processed = 0;
+        let lastFile = '';
+        const startedAt = Date.now();
+        let timedOut = false;
+        // Clear once up-front if this is a full rebuild. The per-file calls
+        // below must not clear between files.
+        if (!incremental) {
+            await kgService.clear();
+        }
+        // Project-relative path helper for shorter per-file log lines.
+        const projectRoot = context.projectRoot;
+        const rel = (p) => p.startsWith(projectRoot) ? p.slice(projectRoot.length + 1) : p;
+        for (const file of filesToIndex) {
+            // Phase-level cap. Checked between files so in-flight work can
+            // still complete bounded by its own per-file cap.
+            //
+            // IMPORTANT: This check only fires BETWEEN file iterations. If a
+            // single call to kgService.index() blocks the Node event loop
+            // inside synchronous native code (e.g. an @ruvector/router
+            // native insert stalls on a specific vector shape), this check
+            // never runs and the phase appears to hang past PHASE_TIMEOUT_MS.
+            // That's the v3.9.3 failure mode observed on ruview. See
+            // shouldRun() for the v3.9.4 AQE_SKIP_CODE_INDEX escape hatch
+            // and the tracking issue for the killable-worker proper fix.
+            if (Date.now() - startedAt > PHASE_TIMEOUT_MS) {
+                timedOut = true;
+                break;
+            }
+            lastFile = file;
+            // fix/init-v3-9-4 Fix B: log EVERY file *before* we start
+            // processing it, not at 100-file intervals. This is the single
+            // most important diagnostic — when the next hang happens, the
+            // last log line will name the exact file that stalls, which is
+            // the data we need to fix the underlying native cause.
+            context.services.log(`  [${processed + 1}/${filesToIndex.length}] ${rel(file)}`);
+            try {
+                const indexResult = await this.withTimeout(kgService.index({
+                    paths: [file],
+                    incremental: true, // don't clear — we already cleared above
+                    includeTests: true,
+                }), PER_FILE_TIMEOUT_MS, file);
+                if (indexResult.success) {
+                    totalNodes += indexResult.value.nodesCreated;
+                    totalEdges += indexResult.value.edgesCreated;
+                }
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                if (message.startsWith('AQE_PER_FILE_TIMEOUT')) {
+                    // Skip the pathological file, log, and keep going.
+                    context.services.warn(`  ⚠ Skipped ${rel(file)} — indexing exceeded ${PER_FILE_TIMEOUT_MS / 1000}s`);
+                }
+                else {
+                    context.services.warn(`  ⚠ Failed to index ${rel(file)}: ${message}`);
+                }
+            }
+            processed++;
+        }
+        const entries = totalNodes + totalEdges;
+        if (timedOut) {
+            return { status: 'timeout', entries, timeoutFile: lastFile };
+        }
+        return { status: 'indexed', entries };
+    }
+    /**
+     * Race a promise against a timer. On timeout, rejects with a tagged
+     * error so the caller can distinguish timeouts from real failures.
+     *
+     * The tagged error prefix 'AQE_PER_FILE_TIMEOUT' is matched in
+     * runBoundedScan to differentiate per-file timeouts from other errors.
+     */
+    withTimeout(promise, timeoutMs, fileLabel) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                reject(new Error(`AQE_PER_FILE_TIMEOUT: ${fileLabel}`));
+            }, timeoutMs);
+            // unref so the timer doesn't keep the event loop alive if the
+            // promise resolves via the fast path.
+            if (typeof timer.unref === 'function')
+                timer.unref();
+            promise.then((v) => { clearTimeout(timer); resolve(v); }, (e) => { clearTimeout(timer); reject(e); });
+        });
+    }
     /**
      * Build hypergraph from indexed files.
      * Uses shared extractor to populate hypergraph_nodes/hypergraph_edges in memory.db.

package/dist/init/phases/10-workers.d.ts

@@ -22,19 +22,5 @@ export declare class WorkersPhase extends BasePhase<WorkersResult> {
     readonly requiresPhases: readonly ["configuration"];
     shouldRun(context: InitContext): Promise<boolean>;
     protected run(context: InitContext): Promise<WorkersResult>;
-    /**
-     * Start the MCP daemon in the background
-     */
-    private startDaemon;
-    /**
-     * Find the aqe-mcp command
-     *
-     * Search order:
-     * 1. Local aqe-mcp binary (node_modules/.bin/)
-     * 2. Local bundled MCP server (node_modules/agentic-qe/dist/)
-     * 3. Local aqe CLI binary with mcp subcommand
-     * 4. npx fallback (uses aqe mcp subcommand)
-     */
-    private findMcpCommand;
 }
 //# sourceMappingURL=10-workers.d.ts.map

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

@@ -2,9 +2,8 @@
  * Phase 10: Workers
  * Configures background workers for continuous monitoring
  */
-import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
 import { join } from 'path';
-import { spawn } from 'child_process';
 import { BasePhase, } from './phase-interface.js';
 /**
  * Workers phase - configures background workers
@@ -183,174 +182,30 @@ try {
         writeFileSync(stopScriptPath, stopScript);
         context.services.log(`  Workers dir: ${workersDir}`);
         context.services.log(`  Workers: ${config.workers.enabled.join(', ')}`);
-        // Auto-start the MCP daemon if configured
-        let daemonStarted = false;
-        let daemonPid = null;
-        let daemonError;
-        if (config.workers.daemonAutoStart) {
-            try {
-                const result = await this.startDaemon(workersDir, projectRoot, context);
-                daemonStarted = result.started;
-                daemonPid = result.pid;
-                daemonError = result.error;
-                if (daemonStarted) {
-                    context.services.log(`  MCP daemon started (PID: ${daemonPid})`);
-                }
-                else if (daemonError) {
-                    // Non-blocking: MCP will be started by Claude Code via .mcp.json
-                    context.services.log(`  MCP daemon: skipped (will start via Claude Code)`);
-                    context.services.log(`    Note: ${daemonError}`);
-                }
-            }
-            catch (error) {
-                // Non-blocking error - MCP works fine when Claude Code starts it
-                daemonError = error instanceof Error ? error.message : 'Unknown error';
-                context.services.log(`  MCP daemon: skipped (Claude Code will start it)`);
-            }
-        }
+        context.services.log(`  Registry: ${registryPath}`);
+        // MCP daemon startup is Claude Code's job, not init's.
+        //
+        // fix/init-v3-9-3 Fix 3: Previously this phase spawned `aqe mcp` as
+        // a detached child to pre-warm the MCP server. That spawn raced the
+        // init process for the same RVF / native HNSW file locks, producing
+        // the cascade of errors seen in v3.9.1 and v3.9.2:
+        //   • RVF error 0x0303: FsyncFailed (child couldn't open patterns.rvf)
+        //   • VectorDb creation failed: Database already open
+        //   • Error: Could not find MCP server entry point
+        //
+        // The canonical path is .mcp.json (written by phase 08). Claude Code
+        // reads it and starts `aqe mcp` on demand when a user actually opens
+        // the project. Users who want to run the daemon manually can use the
+        // generated `.agentic-qe/workers/start-daemon.cjs` helper script or
+        // the `aqe daemon` subcommand.
         return {
             workersDir,
             workersConfigured: config.workers.enabled.length,
             registryPath,
-            daemonStarted,
-            daemonPid,
-            daemonError,
+            daemonStarted: false,
+            daemonPid: null,
         };
     }
-    /**
-     * Start the MCP daemon in the background
-     */
-    async startDaemon(workersDir, projectRoot, context) {
-        const pidFile = join(workersDir, 'daemon.pid');
-        const logFile = join(workersDir, 'daemon.log');
-        // Check if already running
-        if (existsSync(pidFile)) {
-            try {
-                const existingPid = parseInt(readFileSync(pidFile, 'utf-8').trim(), 10);
-                // Check if process is running
-                process.kill(existingPid, 0);
-                return { started: true, pid: existingPid, error: 'Already running' };
-            }
-            catch {
-                // PID file exists but process not running, continue
-            }
-        }
-        // Try to find aqe-mcp command
-        const mcpCommand = await this.findMcpCommand(projectRoot);
-        if (!mcpCommand) {
-            return {
-                started: false,
-                pid: null,
-                error: 'aqe-mcp not found. Install globally with: npm install -g agentic-qe',
-            };
-        }
-        return new Promise((resolve) => {
-            try {
-                // Set up environment
-                const env = {
-                    ...process.env,
-                    AQE_STORAGE_PATH: '.agentic-qe',
-                    AQE_LEARNING_ENABLED: 'true',
-                    AQE_WORKERS_ENABLED: 'true',
-                    AQE_HTTP_PORT: '0',
-                };
-                // Spawn the MCP server as a detached process
-                const child = spawn(mcpCommand.command, mcpCommand.args, {
-                    cwd: projectRoot,
-                    env,
-                    detached: true,
-                    stdio: ['ignore', 'pipe', 'pipe'],
-                });
-                // Give the process a moment to start
-                let started = false;
-                let errorOutput = '';
-                child.stderr?.on('data', (data) => {
-                    errorOutput += data.toString();
-                });
-                child.on('error', (error) => {
-                    resolve({
-                        started: false,
-                        pid: null,
-                        error: error.message,
-                    });
-                });
-                // Wait a short time to see if the process starts successfully
-                setTimeout(() => {
-                    // Check if process is still alive
-                    try {
-                        if (child.pid) {
-                            process.kill(child.pid, 0); // Check if alive (throws if not)
-                            // Write PID file
-                            writeFileSync(pidFile, child.pid.toString(), 'utf-8');
-                            // Log startup
-                            const logEntry = `[${new Date().toISOString()}] MCP daemon started with PID: ${child.pid}\n`;
-                            writeFileSync(logFile, logEntry, { flag: 'a' });
-                            // Unref so the parent can exit
-                            child.unref();
-                            resolve({
-                                started: true,
-                                pid: child.pid,
-                            });
-                        }
-                        else {
-                            resolve({
-                                started: false,
-                                pid: null,
-                                error: errorOutput || 'No PID assigned',
-                            });
-                        }
-                    }
-                    catch {
-                        // Process died - check error output
-                        const errMsg = errorOutput.includes('ERR_MODULE_NOT_FOUND')
-                            ? 'Missing dependencies. Run: npm install agentic-qe'
-                            : errorOutput || 'Process exited immediately';
-                        resolve({
-                            started: false,
-                            pid: null,
-                            error: errMsg,
-                        });
-                    }
-                }, 1500);
-            }
-            catch (error) {
-                resolve({
-                    started: false,
-                    pid: null,
-                    error: error instanceof Error ? error.message : 'Spawn failed',
-                });
-            }
-        });
-    }
-    /**
-     * Find the aqe-mcp command
-     *
-     * Search order:
-     * 1. Local aqe-mcp binary (node_modules/.bin/)
-     * 2. Local bundled MCP server (node_modules/agentic-qe/dist/)
-     * 3. Local aqe CLI binary with mcp subcommand
-     * 4. npx fallback (uses aqe mcp subcommand)
-     */
-    async findMcpCommand(projectRoot) {
-        // Try local node_modules aqe-mcp binary first
-        const localMcpBin = join(projectRoot, 'node_modules', '.bin', 'aqe-mcp');
-        if (existsSync(localMcpBin)) {
-            return { command: localMcpBin, args: [] };
-        }
-        // Try local node_modules bundle (alternative path)
-        const localBundle = join(projectRoot, 'node_modules', 'agentic-qe', 'dist', 'mcp', 'bundle.js');
-        if (existsSync(localBundle)) {
-            return { command: 'node', args: [localBundle] };
-        }
-        // Try local aqe CLI binary with mcp subcommand
-        const localAqeBin = join(projectRoot, 'node_modules', '.bin', 'aqe');
-        if (existsSync(localAqeBin)) {
-            return { command: localAqeBin, args: ['mcp'] };
-        }
-        // Fallback to npx with aqe mcp subcommand
-        // The CLI now has an 'mcp' command that starts the MCP server
-        return { command: 'npx', args: ['--yes', 'agentic-qe', 'mcp'] };
-    }
 }
 // Instance exported from index.ts
 //# sourceMappingURL=10-workers.js.map