agentic-qe 3.15.1 → 3.15.3

package/dist/domains/code-intelligence/services/metric-collector/test-counter.js

@@ -274,10 +274,10 @@ function countCargoTests(projectPath, config) {
         // Count lines ending with ": test"
         const testLines = output.split('\n').filter(line => line.endsWith(': test'));
         const total = testLines.length;
-        // Classify by test path patterns
-        const unit = testLines.filter(t => !t.includes('integration') && !t.includes('e2e')).length;
-        const integration = testLines.filter(t => t.includes('integration')).length;
+        // Disjoint categories, e2e before integration: `tests::integration::e2e_x` counts once.
         const e2e = testLines.filter(t => t.includes('e2e')).length;
+        const integration = testLines.filter(t => !t.includes('e2e') && t.includes('integration')).length;
+        const unit = total - integration - e2e;
         return {
             total,
             unit,

package/dist/domains/coverage-analysis/services/gap-detector.js

@@ -9,6 +9,7 @@ import { ok, err } from '../../../shared/types/index.js';
 import { toError } from '../../../shared/error-utils.js';
 import { safeJsonParse } from '../../../shared/safe-json.js';
 import { getClaudeModelForTier } from '../../../shared/llm/model-registry.js';
+import { createSafeRecord } from '../../../shared/utils/safe-record.js';
 const DEFAULT_CONFIG = {
     minCoverage: 80,
     enableLLMAnalysis: true, // On by default - opt-out
@@ -212,7 +213,8 @@ Return JSON in this exact format:
      * Calculate effort breakdown by file
      */
     calculateEffortBreakdown(gaps) {
-        const breakdown = {};
+        // File paths are data, so the buckets must not inherit from Object.prototype (#914).
+        const breakdown = createSafeRecord();
         for (const gap of gaps) {
             const effort = Math.ceil(gap.lines.length / 15);
             breakdown[gap.file] = (breakdown[gap.file] || 0) + effort;

package/dist/domains/learning-optimization/services/learning-coordinator.js

@@ -9,6 +9,7 @@ import { rehydrateDates } from '../../../shared/utils/kv-date-rehydrate.js';
 import { toError } from '../../../shared/error-utils.js';
 import { createQEFlashAttention, } from '../../../integrations/ruvector/wrappers.js';
 import { getClaudeModelForTier } from '../../../shared/llm/model-registry.js';
+import { createSafeRecord } from '../../../shared/utils/safe-record.js';
 const DEFAULT_CONFIG = {
     minExperiencesForPattern: 5,
     patternConfidenceThreshold: 0.7,
@@ -943,8 +944,9 @@ Provide:
         return false;
     }
     calculateCentroid(experiences) {
-        const avgMetrics = {};
-        const metricCounts = {};
+        // Metric names come from stored experiences (#914).
+        const avgMetrics = createSafeRecord();
+        const metricCounts = createSafeRecord();
         for (const exp of experiences) {
             for (const [key, value] of Object.entries(exp.state.metrics)) {
                 avgMetrics[key] = (avgMetrics[key] || 0) + value;

package/dist/domains/test-execution/services/flaky-detector.js

@@ -13,6 +13,7 @@ import { toError } from '../../../shared/error-utils.js';
 import { safeJsonParse } from '../../../shared/safe-json.js';
 import { getTestRunnerExecutionError } from '../../../shared/test-runner-verdict.js';
 import { createVitestJsonReport, needsVitestJsonReportFile } from '../../../shared/vitest-json-report.js';
+import { isJestCommand, jestExactPathPattern, runnerFilePath } from '../../../shared/test-runner-args.js';
 import { secureRandom } from '../../../shared/utils/crypto-random.js';
 const DEFAULT_FLAKY_CONFIG = {
     simulateForTesting: false,
@@ -256,14 +257,19 @@ export class FlakyDetectorService {
         const runId = uuidv4();
         const startTime = Date.now();
         return new Promise((resolve, reject) => {
-            const baseArgs = [...this.config.testRunnerArgs, file];
+            const cwd = this.config.cwd ?? process.cwd();
+            // #909: pass an absolute path (never read as a flag); Jest reads it as a
+            // regex, so escape and anchor it to select exactly this file.
+            const fileArg = isJestCommand([this.config.testRunner, ...this.config.testRunnerArgs])
+                ? jestExactPathPattern(file, cwd)
+                : runnerFilePath(file, cwd);
+            const baseArgs = [...this.config.testRunnerArgs, fileArg];
             // Vitest 5 writes --reporter=json output to a file, not stdout. Detect
             // Vitest from the runner command too (testRunner: 'vitest', args: ['run', ...]).
             const report = needsVitestJsonReportFile([this.config.testRunner, ...baseArgs])
                 ? createVitestJsonReport()
                 : undefined;
             const args = report ? [...baseArgs, ...report.args] : baseArgs;
-            const cwd = this.config.cwd ?? process.cwd();
             const child = spawn(this.config.testRunner, args, {
                 cwd,
                 env: { ...process.env, ...this.config.env },

package/dist/domains/test-execution/services/retry-handler.js

@@ -5,6 +5,7 @@
 import { LoggerFactory } from '../../../logging/index.js';
 import { spawn } from 'node:child_process';
 import { createVitestJsonReport } from '../../../shared/vitest-json-report.js';
+import { jestExactPathPattern, nameFilterArg, runnerFilePath } from '../../../shared/test-runner-args.js';
 import { existsSync, readFileSync } from 'node:fs';
 import { ok, err } from '../../../shared/types/index.js';
 import { TEST_EXECUTION_CONSTANTS, RETRY_CONSTANTS } from '../../constants.js';
@@ -264,7 +265,7 @@ export class RetryHandlerService {
                 `or configure testRunner in RetryHandlerConfig. Cannot execute retry for: ${testFile}`);
         }
         // Build command based on runner
-        const { command, args, report } = this.buildTestCommand(runner, testFile, testName);
+        const { command, args, report } = this.buildTestCommand(runner, testFile, testName, cwd);
         // Execute the test
         return this.spawnTestProcess(command, args, cwd, report);
     }
@@ -334,40 +335,42 @@ export class RetryHandlerService {
     /**
      * Build the command and arguments for the test runner
      */
-    buildTestCommand(runner, testFile, testName) {
+    buildTestCommand(runner, testFile, testName, cwd = this.config.cwd ?? process.cwd()) {
         const npx = this.config.npxPath;
-        // These runners interpret name filters as regular expressions, but a
-        // FailedTest contains the literal assertion name from the previous run.
-        const namePattern = testName?.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') ?? '';
+        // A FailedTest holds the literal assertion name and path from the previous
+        // run. Name filters are regex-escaped and passed as --flag=value; file
+        // filters are absolute (Jest: escaped and anchored), so neither can be
+        // misread as a regex or as a flag when it starts with '-' (#886, #909).
+        const filterByName = Boolean(testName) && testName !== testFile;
         switch (runner) {
             case 'vitest':
-                // vitest run --reporter=json testFile -t "testName"
+                // vitest run --reporter=json <abs file> --testNamePattern=<name>
                 // --outputFile: Vitest 5 no longer prints the JSON report to stdout.
                 {
                     const report = createVitestJsonReport();
-                    const vitestArgs = ['vitest', 'run', '--reporter=json', testFile];
-                    if (testName && testName !== testFile) {
-                        vitestArgs.push('-t', namePattern);
-                    }
+                    const vitestArgs = ['vitest', 'run', '--reporter=json', runnerFilePath(testFile, cwd)];
+                    if (filterByName)
+                        vitestArgs.push(nameFilterArg('vitest', testName));
                     vitestArgs.push(...report.args);
                     return { command: npx, args: vitestArgs, report };
                 }
             case 'jest':
-                // jest --json testFile -t "testName"
+                // jest --json --testNamePattern=<name> ^<escaped abs file>$
+                // Positional TestPathPatterns work on Jest 29 and 30 (Jest 30 rejects
+                // the old --testPathPattern flag).
                 {
-                    const jestArgs = ['jest', '--json', '--testPathPattern', testFile];
-                    if (testName && testName !== testFile) {
-                        jestArgs.push('-t', namePattern);
-                    }
+                    const jestArgs = ['jest', '--json'];
+                    if (filterByName)
+                        jestArgs.push(nameFilterArg('jest', testName));
+                    jestArgs.push(jestExactPathPattern(testFile, cwd));
                     return { command: npx, args: jestArgs };
                 }
             case 'mocha':
-                // mocha --reporter json testFile --grep "testName"
+                // mocha --reporter json <abs file> --grep=<name>
                 {
-                    const mochaArgs = ['mocha', '--reporter', 'json', testFile];
-                    if (testName && testName !== testFile) {
-                        mochaArgs.push('--grep', namePattern);
-                    }
+                    const mochaArgs = ['mocha', '--reporter', 'json', runnerFilePath(testFile, cwd)];
+                    if (filterByName)
+                        mochaArgs.push(nameFilterArg('mocha', testName));
                     return { command: npx, args: mochaArgs };
                 }
             default:

package/dist/domains/test-execution/services/test-executor.js

@@ -16,6 +16,7 @@ import { secureRandom, secureRandomInt } from '../../../shared/utils/crypto-rand
 import { writeQualityEvidence } from '../../quality-assessment/quality-evidence.js';
 import { getTestRunnerExecutionError, TestRunnerExecutionError } from '../../../shared/test-runner-verdict.js';
 import { createVitestJsonReport } from '../../../shared/vitest-json-report.js';
+import { jestExactPathPattern, runnerFilePath } from '../../../shared/test-runner-args.js';
 import { getClaudeModelForTier } from '../../../shared/llm/model-registry.js';
 import { terminateTestRunner, trackTestRunnerExit } from '../../../shared/test-runner-process.js';
 const DEFAULT_CONFIG = {
@@ -481,7 +482,9 @@ Provide:
      * Build test command based on framework
      */
     buildTestCommand(fileOrFiles, framework) {
-        const files = Array.isArray(fileOrFiles) ? fileOrFiles : [fileOrFiles];
+        // #909: absolute paths never start with '-', so a file cannot be read as a
+        // flag; Jest's positional patterns are regexes, so escape and anchor them.
+        const files = (Array.isArray(fileOrFiles) ? fileOrFiles : [fileOrFiles]).map(file => runnerFilePath(file));
         const createCoverageDirectory = () => mkdtempSync(join(tmpdir(), 'aqe-test-coverage-'));
         switch (framework.toLowerCase()) {
             case 'vitest': {
@@ -507,7 +510,7 @@ Provide:
                 const coverageDirectory = createCoverageDirectory();
                 return {
                     command: 'npx',
-                    args: ['jest', ...files, '--json', '--no-colors', '--testLocationInResults', `--coverageDirectory=${coverageDirectory}`],
+                    args: ['jest', ...files.map(file => jestExactPathPattern(file)), '--json', '--no-colors', '--testLocationInResults', `--coverageDirectory=${coverageDirectory}`],
                     coverageDirectory,
                 };
             }

package/dist/domains/test-generation/services/test-generator.js

@@ -993,8 +993,11 @@ Return a JSON array of test suggestions, each with: { "name": "test name", "desc
         if (lang && lang !== 'typescript' && lang !== 'javascript') {
             return resolveTestFilePath(sourceFile, lang);
         }
-        const ext = sourceFile.split('.').pop() || 'ts';
-        const base = sourceFile.replace(`.${ext}`, '');
+        // #936 follow-up: strip only the trailing extension. A first-match
+        // replace turned /home/u/my.ts-app/src/a.ts into /home/u/my-app/src/a.ts,
+        // pointing the test file at a sibling directory outside the project.
+        const ext = fileExt ? fileExt.slice(1) : 'ts';
+        const base = fileExt ? sourceFile.slice(0, -fileExt.length) : sourceFile;
         if (framework === 'pytest') {
             return `test_${base.split('/').pop()}.py`;
         }

package/dist/governance/compliance-reporter.js

@@ -19,6 +19,7 @@ import { governanceFlags, } from './feature-flags.js';
 import { proofEnvelopeIntegration, } from './proof-envelope-integration.js';
 import { getUnifiedMemory } from '../kernel/unified-memory.js';
 import { toErrorMessage } from '../shared/error-utils.js';
+import { createSafeRecord } from '../shared/utils/safe-record.js';
 // ============================================================================
 // Default Configuration
 // ============================================================================
@@ -274,14 +275,14 @@ export class ComplianceReporter {
         });
         // Calculate overall score
         const overall = this.calculateOverallScore(violations);
-        // Calculate score by gate
-        const byGate = {};
+        // Calculate score by gate. Gate and agent names are data (#914).
+        const byGate = createSafeRecord();
         const gateViolations = this.groupBy(violations, 'gate');
         for (const [gate, gateViols] of Object.entries(gateViolations)) {
             byGate[gate] = this.calculateOverallScore(gateViols);
         }
         // Calculate score by agent
-        const byAgent = {};
+        const byAgent = createSafeRecord();
         const agentViolations = this.groupBy(violations, 'agentId');
         for (const [agentId, agentViols] of Object.entries(agentViolations)) {
             if (agentId !== 'undefined') {
@@ -572,13 +573,13 @@ export class ComplianceReporter {
         for (const v of allViolations) {
             bySeverity[v.severity]++;
         }
-        // Count by gate
-        const byGate = {};
+        // Count by gate. Gate and agent names are data (#914).
+        const byGate = createSafeRecord();
         for (const v of allViolations) {
             byGate[v.gate] = (byGate[v.gate] || 0) + 1;
         }
         // Count by agent
-        const byAgent = {};
+        const byAgent = createSafeRecord();
         for (const v of allViolations) {
             if (v.agentId) {
                 byAgent[v.agentId] = (byAgent[v.agentId] || 0) + 1;
@@ -984,7 +985,7 @@ export class ComplianceReporter {
      * Group violations by a field
      */
     groupBy(violations, field) {
-        const groups = {};
+        const groups = createSafeRecord();
         for (const v of violations) {
             const key = String(v[field]);
             if (!groups[key]) {

package/dist/governance/proof-envelope-integration.js

@@ -19,6 +19,7 @@ import { safeJsonParse } from '../shared/safe-json.js';
  */
 import { wasmKernelIntegration, } from './wasm-kernel-integration.js';
 import { governanceFlags, } from './feature-flags.js';
+import { createSafeRecord } from '../shared/utils/safe-record.js';
 /**
  * Genesis envelope hash constant
  */
@@ -514,7 +515,8 @@ export class ProofEnvelopeIntegration {
      * Get chain statistics
      */
     getProofStats() {
-        const actionCounts = {};
+        // Action names are data, so the buckets must not inherit from Object.prototype (#914).
+        const actionCounts = createSafeRecord();
         const agents = new Set();
         for (const envelope of this.chain) {
             agents.add(envelope.agentId);

package/dist/init/claude-plugin-detection.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Claude Code plugin detection (#922)
+ *
+ * The `agentic-qe-fleet` Claude Code plugin bundles its own `agentic-qe` MCP
+ * server (exposed as `mcp__plugin_agentic-qe-fleet_agentic-qe__*`). When that
+ * plugin is enabled, `aqe init` must not also register a project-level
+ * `agentic-qe` server in `.mcp.json`, or AQE ends up registered twice.
+ *
+ * Detection reads `enabledPlugins` from the three Claude Code settings scopes
+ * and merges them per key with Claude Code's precedence (local > project >
+ * user):
+ *   - user:    `$CLAUDE_CONFIG_DIR/settings.json` (default `~/.claude/settings.json`)
+ *   - project: `<project>/.claude/settings.json`
+ *   - local:   `<project>/.claude/settings.local.json`
+ *
+ * A key `agentic-qe-fleet@<marketplace>` whose merged value is `true` means
+ * the plugin is enabled. Missing, unreadable or invalid files count as "no
+ * opinion"; detection never throws.
+ */
+/** Plugin name as published in the `agentic-qe` marketplace. */
+export declare const AQE_FLEET_PLUGIN_NAME = "agentic-qe-fleet";
+export type ClaudeSettingsScope = 'user' | 'project' | 'local';
+export interface PluginDetectionOptions {
+    /** Environment to read CLAUDE_CONFIG_DIR from (defaults to process.env). */
+    env?: NodeJS.ProcessEnv;
+    /** Home directory used when CLAUDE_CONFIG_DIR is unset (defaults to os.homedir()). */
+    homeDir?: string;
+}
+export interface PluginDetectionResult {
+    /** True when at least one `agentic-qe-fleet@*` key resolves to `true`. */
+    enabled: boolean;
+    /** The enabled plugin key, e.g. `agentic-qe-fleet@agentic-qe`. */
+    pluginKey?: string;
+    /** Scope whose setting decided the enabled key. */
+    scope?: ClaudeSettingsScope;
+    /** Settings file that decided the enabled key. */
+    settingsPath?: string;
+}
+/**
+ * Settings files in ascending precedence order (later entries win).
+ */
+export declare function claudeSettingsPaths(projectRoot: string, options?: PluginDetectionOptions): Array<{
+    scope: ClaudeSettingsScope;
+    path: string;
+}>;
+/**
+ * Detect whether the `agentic-qe-fleet` Claude Code plugin is enabled for
+ * `projectRoot`. Never throws.
+ */
+export declare function detectAqeFleetPlugin(projectRoot: string, options?: PluginDetectionOptions): PluginDetectionResult;
+/** One-line notice printed when init skips the project MCP entry. */
+export declare const AQE_PLUGIN_MCP_SKIP_MESSAGE: string;
+/**
+ * One-line notice printed when the plugin is enabled but `.mcp.json` already
+ * has an `agentic-qe` entry (e.g. an upgrade from 3.15.1). Init never deletes
+ * user config, so the entry is kept and the user is told how to remove it.
+ */
+export declare const AQE_PLUGIN_MCP_EXISTING_ENTRY_MESSAGE: string;
+/** True when `<projectRoot>/.mcp.json` declares an `agentic-qe` server. Never throws. */
+export declare function hasProjectAqeMcpEntry(projectRoot: string): boolean;
+/** The notice to print when init skips the project entry because of the plugin. */
+export declare function aqePluginMcpSkipMessage(projectRoot: string): string;
+//# sourceMappingURL=claude-plugin-detection.d.ts.map

package/dist/init/claude-plugin-detection.js

@@ -0,0 +1,118 @@
+/**
+ * Claude Code plugin detection (#922)
+ *
+ * The `agentic-qe-fleet` Claude Code plugin bundles its own `agentic-qe` MCP
+ * server (exposed as `mcp__plugin_agentic-qe-fleet_agentic-qe__*`). When that
+ * plugin is enabled, `aqe init` must not also register a project-level
+ * `agentic-qe` server in `.mcp.json`, or AQE ends up registered twice.
+ *
+ * Detection reads `enabledPlugins` from the three Claude Code settings scopes
+ * and merges them per key with Claude Code's precedence (local > project >
+ * user):
+ *   - user:    `$CLAUDE_CONFIG_DIR/settings.json` (default `~/.claude/settings.json`)
+ *   - project: `<project>/.claude/settings.json`
+ *   - local:   `<project>/.claude/settings.local.json`
+ *
+ * A key `agentic-qe-fleet@<marketplace>` whose merged value is `true` means
+ * the plugin is enabled. Missing, unreadable or invalid files count as "no
+ * opinion"; detection never throws.
+ */
+import { readFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { safeJsonParse } from '../shared/safe-json.js';
+/** Plugin name as published in the `agentic-qe` marketplace. */
+export const AQE_FLEET_PLUGIN_NAME = 'agentic-qe-fleet';
+/**
+ * Settings files in ascending precedence order (later entries win).
+ */
+export function claudeSettingsPaths(projectRoot, options = {}) {
+    const env = options.env ?? process.env;
+    const configDir = env.CLAUDE_CONFIG_DIR?.trim()
+        ? env.CLAUDE_CONFIG_DIR.trim()
+        : join(options.homeDir ?? homedir(), '.claude');
+    return [
+        { scope: 'user', path: join(configDir, 'settings.json') },
+        { scope: 'project', path: join(projectRoot, '.claude', 'settings.json') },
+        { scope: 'local', path: join(projectRoot, '.claude', 'settings.local.json') },
+    ];
+}
+/** Read `enabledPlugins` from one settings file; null on any failure. */
+function readEnabledPlugins(path) {
+    try {
+        const parsed = safeJsonParse(readFileSync(path, 'utf-8'));
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            return null;
+        const plugins = parsed.enabledPlugins;
+        if (!plugins || typeof plugins !== 'object' || Array.isArray(plugins))
+            return null;
+        return plugins;
+    }
+    catch {
+        return null;
+    }
+}
+function isFleetPluginKey(key) {
+    const at = key.lastIndexOf('@');
+    const name = at === -1 ? key : key.slice(0, at);
+    return name === AQE_FLEET_PLUGIN_NAME && at > 0 && at < key.length - 1;
+}
+/**
+ * Detect whether the `agentic-qe-fleet` Claude Code plugin is enabled for
+ * `projectRoot`. Never throws.
+ */
+export function detectAqeFleetPlugin(projectRoot, options = {}) {
+    try {
+        const merged = new Map();
+        for (const { scope, path } of claudeSettingsPaths(projectRoot, options)) {
+            const plugins = readEnabledPlugins(path);
+            if (!plugins)
+                continue;
+            for (const [key, value] of Object.entries(plugins)) {
+                if (isFleetPluginKey(key))
+                    merged.set(key, { value, scope, path });
+            }
+        }
+        for (const [key, entry] of merged) {
+            if (entry.value === true) {
+                return { enabled: true, pluginKey: key, scope: entry.scope, settingsPath: entry.path };
+            }
+        }
+    }
+    catch {
+        // Detection is advisory; fall through to "not enabled".
+    }
+    return { enabled: false };
+}
+/** One-line notice printed when init skips the project MCP entry. */
+export const AQE_PLUGIN_MCP_SKIP_MESSAGE = '  MCP: skipped — the agentic-qe-fleet plugin already provides the AQE MCP server ' +
+    '(mcp__plugin_agentic-qe-fleet_agentic-qe__* tools); run `aqe init --with-mcp` to add the project entry anyway';
+/**
+ * One-line notice printed when the plugin is enabled but `.mcp.json` already
+ * has an `agentic-qe` entry (e.g. an upgrade from 3.15.1). Init never deletes
+ * user config, so the entry is kept and the user is told how to remove it.
+ */
+export const AQE_PLUGIN_MCP_EXISTING_ENTRY_MESSAGE = '  MCP: kept the existing project `agentic-qe` entry in .mcp.json — it duplicates the agentic-qe-fleet ' +
+    "plugin's AQE MCP server (mcp__plugin_agentic-qe-fleet_agentic-qe__* tools); to remove it, delete the " +
+    '`agentic-qe` key from .mcp.json or run `claude mcp remove agentic-qe -s project`';
+/** True when `<projectRoot>/.mcp.json` declares an `agentic-qe` server. Never throws. */
+export function hasProjectAqeMcpEntry(projectRoot) {
+    try {
+        const parsed = safeJsonParse(readFileSync(join(projectRoot, '.mcp.json'), 'utf-8'));
+        if (!parsed || typeof parsed !== 'object')
+            return false;
+        const servers = parsed.mcpServers;
+        return !!servers && typeof servers === 'object' && !Array.isArray(servers) &&
+            Object.prototype.hasOwnProperty.call(servers, 'agentic-qe');
+    }
+    catch {
+        return false;
+    }
+}
+/** The notice to print when init skips the project entry because of the plugin. */
+export function aqePluginMcpSkipMessage(projectRoot) {
+    return hasProjectAqeMcpEntry(projectRoot)
+        ? AQE_PLUGIN_MCP_EXISTING_ENTRY_MESSAGE
+        : AQE_PLUGIN_MCP_SKIP_MESSAGE;
+}
+//# sourceMappingURL=claude-plugin-detection.js.map

package/dist/init/init-wizard-hooks.d.ts

@@ -22,8 +22,13 @@ export declare function configureHooks(projectRoot: string, config: AQEInitConfi
  * Configure MCP server.
  * Creates .mcp.json (root level) with AQE v3 MCP server configuration.
  * Uses npx to run the MCP server without requiring global installation.
+ *
+ * #922: skipped when the agentic-qe-fleet Claude Code plugin is enabled (it
+ * already provides the AQE MCP server) unless `force` is set (--with-mcp).
  */
-export declare function configureMCP(projectRoot: string): Promise<boolean>;
+export declare function configureMCP(projectRoot: string, options?: {
+    force?: boolean;
+}): Promise<boolean>;
 /**
  * Generate CLAUDE.md for the project.
  * Creates a comprehensive guide for Claude Code with V3-specific instructions.

package/dist/init/init-wizard-hooks.js

@@ -12,6 +12,7 @@
 import { existsSync, mkdirSync, writeFileSync, readFileSync, copyFileSync } from 'fs';
 import { join, dirname } from 'path';
 import { safeJsonParse } from '../shared/safe-json.js';
+import { aqePluginMcpSkipMessage, detectAqeFleetPlugin } from './claude-plugin-detection.js';
 import { mergeHooksSmart, generateAqeEnvVars, generateV3SettingsSections, applyV3Sections, mergeAqeEnv, backupSettingsFile, } from './settings-merge.js';
 // ============================================================================
 // Hook Configuration
@@ -272,8 +273,15 @@ routing:
  * Configure MCP server.
  * Creates .mcp.json (root level) with AQE v3 MCP server configuration.
  * Uses npx to run the MCP server without requiring global installation.
+ *
+ * #922: skipped when the agentic-qe-fleet Claude Code plugin is enabled (it
+ * already provides the AQE MCP server) unless `force` is set (--with-mcp).
  */
-export async function configureMCP(projectRoot) {
+export async function configureMCP(projectRoot, options = {}) {
+    if (!options.force && detectAqeFleetPlugin(projectRoot).enabled) {
+        console.log(aqePluginMcpSkipMessage(projectRoot));
+        return false;
+    }
     const mcpPath = join(projectRoot, '.mcp.json');
     let mcpConfig = {};
     if (existsSync(mcpPath)) {

package/dist/init/init-wizard.d.ts

@@ -26,6 +26,10 @@ export interface InitOrchestratorOptions {
     wizardAnswers?: Record<string, unknown>;
     /** Install n8n workflow testing agents and skills */
     withN8n?: boolean;
+    /** Write the .mcp.json entry even when the agentic-qe-fleet plugin is enabled (#922) */
+    withMcp?: boolean;
+    /** Skip the .mcp.json entry entirely (--no-mcp, #931) */
+    noMcp?: boolean;
     /** N8n API configuration */
     n8nApiConfig?: {
         baseUrl?: string;

package/dist/init/init-wizard.js

@@ -146,7 +146,9 @@ export class InitOrchestrator {
             });
             // Step 6: Configure MCP server
             const mcpConfigured = await this.runStep('MCP Configuration', async () => {
-                return await configureMCP(this.projectRoot);
+                if (this.options.noMcp)
+                    return false;
+                return await configureMCP(this.projectRoot, { force: this.options.withMcp });
             });
             // Step 7: Generate CLAUDE.md
             const claudeMdGenerated = await this.runStep('CLAUDE.md Generation', async () => {

package/dist/init/orchestrator.js

@@ -52,6 +52,7 @@ export class ModularInitOrchestrator {
                 wizardAnswers: options.wizardAnswers,
                 noGovernance: options.noGovernance,
                 noMcp: options.noMcp,
+                withMcp: options.withMcp,
                 noClaude: options.noClaude,
                 noStatusLine: options.noStatusLine,
                 memoryBackend: options.memoryBackend,

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

@@ -259,10 +259,13 @@ export class HooksPhase extends BasePhase {
             mkdirSync(helpersDir, { recursive: true });
         }
         const destPath = join(helpersDir, 'brain-checkpoint.cjs');
-        // Try to copy from our own installation first
+        // Try to copy from our own installation first. The last candidate is this
+        // package's own copy (relative to the compiled init module), so a GLOBAL
+        // install also refreshes an existing project's helper on re-init (#872).
         const sourcePaths = [
             join(projectRoot, '.claude', 'helpers', 'brain-checkpoint.cjs'),
             join(projectRoot, 'node_modules', 'agentic-qe', '.claude', 'helpers', 'brain-checkpoint.cjs'),
+            join(__dirname, '..', '..', '..', '.claude', 'helpers', 'brain-checkpoint.cjs'),
         ];
         for (const src of sourcePaths) {
             if (existsSync(src) && src !== destPath) {
@@ -399,16 +402,39 @@ const AQE_DIR = path.join(PROJECT_ROOT, '.agentic-qe');
 const RVF_PATH = path.join(AQE_DIR, 'aqe.rvf');
 const DB_PATH = path.join(AQE_DIR, 'memory.db');
 const MAX_AGE_HOURS = 24;
-const AQE_BIN = process.env.AQE_HOOK_BIN || (process.platform === 'win32' ? 'aqe.cmd' : 'aqe');
+// Windows (#872): never execFile aqe.cmd (EINVAL without a shell); reuse the
+// hook shim's resolver, which runs the AQE bundle via node instead.
+function aqeInvocation() {
+  if (process.platform !== 'win32') return { cmd: process.env.AQE_HOOK_BIN || 'aqe', args: [] };
+  const shimPath = path.join(__dirname, '..', 'hooks', 'aqe-hook.cjs');
+  let src = '';
+  try { src = fs.readFileSync(shimPath, 'utf8'); } catch { /* missing */ }
+  // An older shim runs its hook main (spawn + exit) when required.
+  if (!src.includes('resolveAqeInvocation') || !src.includes('require.main === module')) {
+    return { cmd: null, args: [], reason: '.claude/hooks/aqe-hook.cjs is missing or predates #872; re-run aqe init' };
+  }
+  try {
+    return require(shimPath).resolveAqeInvocation({ project: PROJECT_ROOT });
+  } catch (e) {
+    return { cmd: null, args: [], reason: 'aqe-hook.cjs failed to load: ' + e.message };
+  }
+}
 
 function log(msg) { process.stderr.write('[brain-checkpoint] ' + msg + '\\n'); }
 
 function exportBrain() {
   if (!fs.existsSync(DB_PATH)) { log('No memory.db, skipping'); return { exported: false }; }
+  const aqe = aqeInvocation();
+  if (!aqe.cmd) { log('Export skipped: ' + aqe.reason); return { exported: false, reason: aqe.reason }; }
+  // Never write through a committed symlink: .agentic-qe must be a real dir, and
+  // unlink (not existsSync) drops a planted aqe.rvf link, even a dangling one.
+  let st; try { st = fs.lstatSync(AQE_DIR); } catch { /* missing */ }
+  if (!st || !st.isDirectory()) { log('Export skipped: .agentic-qe is a symlink'); return { exported: false }; }
+  for (const f of [RVF_PATH, RVF_PATH + '.idmap.json']) { try { fs.unlinkSync(f); } catch { /* absent */ } }
   try {
     const result = execFileSync(
-      AQE_BIN, ['brain', 'export', '-o', RVF_PATH, '--format', 'rvf'],
-      { timeout: 60000, encoding: 'utf-8' }
+      aqe.cmd, [...aqe.args, 'brain', 'export', '-o', RVF_PATH, '--format', 'rvf'],
+      { timeout: 60000, encoding: 'utf-8', windowsHide: true }
     );
     const m = result.match(/Patterns:\\s+(\\d+)/);
     const p = m ? m[1] : '0';

package/dist/init/phases/08-mcp.d.ts

@@ -11,21 +11,28 @@
  * walks up looking for .agentic-qe/, .git/, or package.json. This
  * makes the config portable across machines, devcontainers, and CI.
  */
+import { type PluginDetectionResult } from '../claude-plugin-detection.js';
 import { BasePhase, type InitContext } from './phase-interface.js';
 export interface MCPResult {
     configured: boolean;
     mcpPath: string;
     serverName: string;
+    /** Set when the entry was skipped because the agentic-qe-fleet plugin provides it (#922). */
+    skippedForPlugin?: string;
 }
+/** Plugin detector signature — injectable for tests. */
+export type FleetPluginDetector = (projectRoot: string) => PluginDetectionResult;
 /**
  * MCP phase - configures MCP server
  */
 export declare class MCPPhase extends BasePhase<MCPResult> {
+    private readonly detectPlugin;
     readonly name = "mcp";
     readonly description = "Configure MCP server";
     readonly order = 80;
     readonly critical = false;
     readonly requiresPhases: readonly ["configuration", "database"];
+    constructor(detectPlugin?: FleetPluginDetector);
     protected run(context: InitContext): Promise<MCPResult>;
 }
 //# sourceMappingURL=08-mcp.d.ts.map