agentic-qe 3.15.16 → 3.15.18

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

@@ -14,6 +14,7 @@ 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 { runnerCwdFor, runnerFrameworkFor } from '../../../shared/test-runner-project.js';
 import { secureRandom } from '../../../shared/utils/crypto-random.js';
 import { redactFailureText } from './runner-test-cases.js';
 const DEFAULT_FLAKY_CONFIG = {
@@ -41,6 +42,19 @@ export class FlakyDetectorService {
     constructor(memory, config = {}) {
         this.memory = memory;
         this.config = { ...DEFAULT_FLAKY_CONFIG, ...config };
+        this.runnerConfigured = config.testRunner !== undefined || config.testRunnerArgs !== undefined;
+    }
+    /** True when the caller chose the runner command; else the project's config picks it. */
+    runnerConfigured;
+    /**
+     * #1272: the runner command for a run started in `cwd`. A configured command
+     * is used as given; the default runs Jest in a project configured for Jest.
+     */
+    runnerCommandIn(cwd) {
+        if (!this.runnerConfigured && runnerFrameworkFor(cwd) === 'jest') {
+            return { runner: 'npx', runnerArgs: ['jest', '--json'] };
+        }
+        return { runner: this.config.testRunner, runnerArgs: this.config.testRunnerArgs };
     }
     /**
      * Detect flaky tests by running them multiple times
@@ -259,20 +273,24 @@ export class FlakyDetectorService {
         const runId = uuidv4();
         const startTime = Date.now();
         return new Promise((resolve, reject) => {
-            const cwd = this.config.cwd ?? process.cwd();
+            const fileBase = this.config.cwd ?? process.cwd();
+            // #1272: a runner loads the config of the directory it starts in, so the
+            // file runs from its own runner project (the file path stays absolute).
+            const cwd = this.config.cwd ?? runnerCwdFor(file);
+            const { runner, runnerArgs } = this.runnerCommandIn(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];
+            const fileArg = isJestCommand([runner, ...runnerArgs])
+                ? jestExactPathPattern(file, fileBase)
+                : runnerFilePath(file, fileBase);
+            const baseArgs = [...runnerArgs, 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])
+            const report = needsVitestJsonReportFile([runner, ...baseArgs])
                 ? createVitestJsonReport()
                 : undefined;
             const args = report ? [...baseArgs, ...report.args] : baseArgs;
-            const child = spawn(this.config.testRunner, args, {
+            const child = spawn(runner, args, {
                 cwd,
                 env: { ...process.env, ...this.config.env },
                 stdio: ['ignore', 'pipe', 'pipe'],
@@ -295,7 +313,7 @@ export class FlakyDetectorService {
                 clearTimeout(timeout);
                 report?.cleanup();
                 reject(new Error(`Failed to execute test runner: ${error.message}. ` +
-                    `Ensure ${this.config.testRunner} is installed and accessible.`));
+                    `Ensure ${[runner, ...runnerArgs.slice(0, 1)].join(' ')} is installed and accessible.`));
             });
             child.on('close', (code) => {
                 clearTimeout(timeout);

package/dist/domains/test-execution/services/retry-handler.d.ts

@@ -8,7 +8,7 @@ import { MemoryBackend } from '../../../kernel/interfaces';
 /**
  * Supported test runners for retry execution
  */
-export type TestRunner = 'vitest' | 'jest' | 'mocha' | 'auto';
+export type TestRunner = 'vitest' | 'jest' | 'mocha' | 'pytest' | 'auto';
 /**
  * Configuration for the retry handler service
  */
@@ -159,6 +159,12 @@ export declare class RetryHandlerService implements IRetryHandler {
      * Spawn a test process and parse the result
      */
     private spawnTestProcess;
+    /**
+     * #1248: a pytest retry passes only when its JUnit report shows the test
+     * passed. A node id pytest cannot find (exit code 4) or no collected test
+     * (exit code 5) reran nothing.
+     */
+    private parsePytestRetry;
     /**
      * Parse test runner output to determine pass/fail status
      */

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

@@ -7,6 +7,7 @@ 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 { runnerCwdFor } from '../../../shared/test-runner-project.js';
+import { createPytestJunitReport, isPythonTestFile, parsePytestJunitXml, pytestCommand, PYTEST_ENV, } from '../../../shared/pytest-junit-report.js';
 import { existsSync, readFileSync, realpathSync } from 'node:fs';
 import { resolve as resolvePath } from 'node:path';
 import { ok, err } from '../../../shared/types/index.js';
@@ -300,8 +301,8 @@ export class RetryHandlerService {
         // projectRoot, else a configured directory, else the file's runner
         // project. The file path stays relative to `cwd`.
         const runCwd = projectRoot ?? this.config.cwd ?? runnerCwdFor(testFile);
-        // Detect or use configured test runner
-        const runner = await this.detectTestRunner(runCwd);
+        // Detect or use configured test runner. #1248: a Python file is pytest's.
+        const runner = isPythonTestFile(testFile) ? 'pytest' : await this.detectTestRunner(runCwd);
         if (!runner) {
             throw new Error(`No test runner detected or configured. Install vitest, jest, or mocha, ` +
                 `or configure testRunner in RetryHandlerConfig. Cannot execute retry for: ${testFile}`);
@@ -309,7 +310,7 @@ export class RetryHandlerService {
         // Build command based on runner
         const { command, args, report } = this.buildTestCommand(runner, testFile, testName, cwd);
         // Execute the test
-        return this.spawnTestProcess(command, args, runCwd, report, runner === 'vitest' ? testFile : undefined);
+        return this.spawnTestProcess(command, args, runCwd, report, runner === 'vitest' ? testFile : undefined, runner === 'pytest' ? (code, reportText, output) => this.parsePytestRetry(code, reportText, output) : undefined);
     }
     /**
      * Detect which test runner is available in the project
@@ -415,6 +416,13 @@ export class RetryHandlerService {
                         mochaArgs.push(nameFilterArg('mocha', testName));
                     return { command: npx, args: mochaArgs };
                 }
+            case 'pytest':
+                // #1248: the failed test's node id is <file>::<name> (name from the run).
+                {
+                    const report = createPytestJunitReport();
+                    const file = runnerFilePath(testFile, cwd);
+                    return { ...pytestCommand([filterByName ? `${file}::${testName}` : file], report.path), report };
+                }
             default:
                 throw new Error(`Unsupported test runner: ${runner}`);
         }
@@ -422,7 +430,7 @@ export class RetryHandlerService {
     /**
      * Spawn a test process and parse the result
      */
-    spawnTestProcess(command, args, cwd, report, targetFile) {
+    spawnTestProcess(command, args, cwd, report, targetFile, parseReport) {
         return new Promise((resolve, reject) => {
             const timeout = this.config.testTimeout;
             let stdout = '';
@@ -439,7 +447,7 @@ export class RetryHandlerService {
             const proc = spawn(command, args, {
                 cwd,
                 detached: process.platform !== 'win32',
-                env: { ...process.env, FORCE_COLOR: '0', CI: 'true' },
+                env: { ...process.env, FORCE_COLOR: '0', CI: 'true', ...PYTEST_ENV },
             });
             const untrackExit = trackTestRunnerExit(proc);
             const timeoutHandle = setTimeout(() => {
@@ -470,6 +478,10 @@ export class RetryHandlerService {
                 // report to the --outputFile; read it back rather than trusting stdout).
                 try {
                     const reportText = report ? report.read(stdout) : stdout;
+                    if (parseReport) {
+                        settle(resolve, parseReport(code, reportText, `${stderr}\n${stdout}`.trim()));
+                        return;
+                    }
                     if (reportText === undefined) {
                         throw new Error('The current Vitest JSON report is missing for the retry run.');
                     }
@@ -489,6 +501,33 @@ export class RetryHandlerService {
             });
         });
     }
+    /**
+     * #1248: a pytest retry passes only when its JUnit report shows the test
+     * passed. A node id pytest cannot find (exit code 4) or no collected test
+     * (exit code 5) reran nothing.
+     */
+    parsePytestRetry(exitCode, report, output) {
+        const failure = (text) => ({
+            passed: false,
+            error: redactFailureText(text || `pytest exited with code ${exitCode}`).substring(0, 1000),
+        });
+        if (exitCode === 4 || exitCode === 5)
+            return UNMATCHED;
+        if (report === undefined)
+            return failure(output);
+        try {
+            const cases = parsePytestJunitXml(report);
+            if (cases.length === 0)
+                return UNMATCHED;
+            const failed = cases.find(c => c.status === 'failed' || c.status === 'error');
+            if (exitCode === 0 && !failed && cases.some(c => c.status === 'passed'))
+                return { passed: true };
+            return failure(failed ? [failed.message, failed.details].filter(Boolean).join('\n') : output);
+        }
+        catch {
+            return failure(output);
+        }
+    }
     /**
      * Parse test runner output to determine pass/fail status
      */

package/dist/domains/test-execution/services/runner-test-cases.d.ts

@@ -6,6 +6,8 @@
  * derived from aggregate counts.
  */
 import type { ITestCaseResult } from '../interfaces';
+/** A test case's failure text: redacted (#1122) and capped. */
+export declare function testCaseFailureMessage(text: string): string | undefined;
 /**
  * #1122: failure text goes back over MCP and into saved results, so
  * credential-shaped values (e.g. a connection string) are redacted first.

package/dist/domains/test-execution/services/runner-test-cases.js

@@ -12,10 +12,14 @@ const MAX_FAILURE_MESSAGE_LENGTH = 4000;
 function failureMessageOf(assertion) {
     if (!Array.isArray(assertion.failureMessages))
         return undefined;
-    const joined = assertion.failureMessages.filter((m) => typeof m === 'string').join('\n').trim();
-    if (!joined)
+    return testCaseFailureMessage(assertion.failureMessages.filter((m) => typeof m === 'string').join('\n'));
+}
+/** A test case's failure text: redacted (#1122) and capped. */
+export function testCaseFailureMessage(text) {
+    const trimmed = text.trim();
+    if (!trimmed)
         return undefined;
-    const message = redactFailureText(joined);
+    const message = redactFailureText(trimmed);
     return message.length > MAX_FAILURE_MESSAGE_LENGTH
         ? `${message.slice(0, MAX_FAILURE_MESSAGE_LENGTH)}… [truncated]`
         : message;

package/dist/domains/test-execution/services/test-executor.d.ts

@@ -115,7 +115,7 @@ export declare class TestExecutorService implements ITestExecutionService {
     private executeTestFiles;
     private executeProjectFiles;
     /**
-     * Spawn actual test runner process (vitest, jest, mocha)
+     * Spawn actual test runner process (vitest, jest, mocha, node:test, pytest)
      */
     private spawnTestRunner;
     /**
@@ -126,6 +126,10 @@ export declare class TestExecutorService implements ITestExecutionService {
      * Parse test runner output to extract results
      */
     private parseTestOutput;
+    /**
+     * #1248: a pytest run from its JUnit report (undefined when pytest wrote none).
+     */
+    private parsePytestOutput;
     /**
      * Parse the TAP or spec summary emitted by Node's built-in test runner.
      */

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

@@ -11,17 +11,18 @@ import { isDeepStrictEqual } from 'node:util';
 import { v4 as uuidv4 } from 'uuid';
 import { ok, err } from '../../../shared/types/index.js';
 import { TEST_EXECUTION_CONSTANTS, LLM_ANALYSIS_CONSTANTS } from '../../constants.js';
-import { toErrorMessage, toError } from '../../../shared/error-utils.js';
+import { CallerInputError, isCallerInputError, toErrorMessage, toError } from '../../../shared/error-utils.js';
 import { safeJsonParse } from '../../../shared/safe-json.js';
 import { secureRandom, secureRandomInt } from '../../../shared/utils/crypto-random.js';
 import { writeTestRunEvidence } from '../../quality-assessment/quality-evidence.js';
 import { istanbulLineHits } from '../../../coordination/handlers/handler-utils.js';
 import { fileCoverageKey, projectFileCoverageKeys } from '../../coverage-analysis/collected-metrics.js';
-import { mergeTestCases, redactFailedTests, redactFailureText, testCasesFromRunnerReport } from './runner-test-cases.js';
+import { mergeTestCases, redactFailedTests, redactFailureText, testCaseFailureMessage, testCasesFromRunnerReport } from './runner-test-cases.js';
 import { capDiagnostics, getTestRunnerExecutionError, TestRunnerExecutionError } from '../../../shared/test-runner-verdict.js';
 import { createVitestJsonReport } from '../../../shared/vitest-json-report.js';
+import { createPytestJunitReport, isPythonTestFile, pytestCommand, pytestRunFromReport, PYTEST_ENV } from '../../../shared/pytest-junit-report.js';
 import { jestExactPathPattern, runnerFilePath } from '../../../shared/test-runner-args.js';
-import { groupByRunnerProject } from '../../../shared/test-runner-project.js';
+import { groupByRunnerProject, runnerFrameworkFor } from '../../../shared/test-runner-project.js';
 import { getClaudeModelForTier } from '../../../shared/llm/model-registry.js';
 import { terminateTestRunner, trackTestRunnerExit } from '../../../shared/test-runner-process.js';
 const DEFAULT_CONFIG = {
@@ -315,7 +316,7 @@ Provide:
         return ok(undefined);
     }
     async runTests(request) {
-        const { testFiles, framework, timeout = 30000, projectRoot } = request;
+        const { testFiles, framework, timeout = 30000, projectRoot, frameworkFromConfig } = request;
         const failedTests = [];
         const coverages = [];
         const allFileCoverages = [];
@@ -324,7 +325,7 @@ Provide:
         let failed = 0;
         let skipped = 0;
         for (const file of testFiles) {
-            const result = await this.executeTestFile(file, framework, timeout, projectRoot);
+            const result = await this.executeTestFile(file, framework, timeout, projectRoot, frameworkFromConfig);
             executionResults.push(result);
             passed += result.passed;
             failed += result.failed;
@@ -394,25 +395,40 @@ Provide:
         const coverage = this.extractCoverageFromJson({ coverageMap: merged });
         return coverage.summary ? { summary: coverage.summary, perFile: coverage.perFile } : undefined;
     }
-    async executeTestFile(file, framework, timeout, projectRoot) {
-        return this.executeTestFiles([file], framework, timeout, projectRoot);
+    async executeTestFile(file, framework, timeout, projectRoot, frameworkFromConfig = false) {
+        return this.executeTestFiles([file], framework, timeout, projectRoot, frameworkFromConfig);
     }
-    async executeTestFiles(files, framework, timeout, projectRoot) {
+    async executeTestFiles(files, framework, timeout, projectRoot, frameworkFromConfig = false) {
         // In simulation mode (for unit testing), use random behavior
         if (this.config.simulateForTesting) {
             return this.aggregateResults(files.map(file => this.simulateTestExecution(file)));
         }
         // #1247: a runner loads the config of the directory it starts in, so each
         // file runs from its own runner project (or the caller's projectRoot).
+        // #1248: Python files run apart from the others, with pytest.
         const groups = projectRoot
-            ? [{ cwd: projectRoot, files }]
+            ? [files.filter(isPythonTestFile), files.filter(file => !isPythonTestFile(file))]
+                .filter(group => group.length > 0)
+                .map(group => ({ cwd: projectRoot, files: group }))
             : groupByRunnerProject(files);
+        // #1272: an explicit framework wins; otherwise the project's config decides.
+        // #1248: Python files run with pytest, never with a JavaScript runner.
+        const frameworkIn = (group) => {
+            if (group.files.some(isPythonTestFile)) {
+                if (frameworkFromConfig || framework.toLowerCase() === 'pytest')
+                    return 'pytest';
+                throw new TestRunnerExecutionError(`Python test files cannot run with ${framework}: ${group.files.filter(isPythonTestFile).join(', ')}. ` +
+                    `Use framework 'pytest', or leave the framework unset.`);
+            }
+            return (frameworkFromConfig ? runnerFrameworkFor(group.cwd) : undefined) ?? framework;
+        };
         if (groups.length === 1) {
-            return this.executeProjectFiles(groups[0].files, framework, timeout, groups[0].cwd);
+            return this.executeProjectFiles(groups[0].files, frameworkIn(groups[0]), timeout, groups[0].cwd);
         }
         // Each project gets its own runner and timeout. Their coverage maps are
         // merged from raw counters, or left unmeasured (#1030).
-        const results = await Promise.all(groups.map(group => this.executeProjectFiles(group.files, framework, timeout, group.cwd)));
+        const frameworks = groups.map(frameworkIn);
+        const results = await Promise.all(groups.map((group, index) => this.executeProjectFiles(group.files, frameworks[index], timeout, group.cwd)));
         const combined = this.aggregateResults(results);
         const merged = this.mergeSequentialCoverage(results);
         combined.coverage = merged?.summary;
@@ -426,6 +442,10 @@ Provide:
             // Runner/suite errors have no trustworthy assertion receipt to aggregate.
             if (result.error instanceof TestRunnerExecutionError)
                 throw result.error;
+            // #1147: the caller's input (a test file that does not exist) is not a
+            // failed test, so it is never counted as a measured failure.
+            if (isCallerInputError(result.error))
+                throw result.error;
             // Return as a failed test rather than throwing — allows other files to still run
             return {
                 total: files.length,
@@ -445,13 +465,13 @@ Provide:
         return result.value;
     }
     /**
-     * Spawn actual test runner process (vitest, jest, mocha)
+     * Spawn actual test runner process (vitest, jest, mocha, node:test, pytest)
      */
     async spawnTestRunner(files, framework, timeout, cwd = process.cwd()) {
         // Verify test file exists
         const missingFile = files.find(file => !existsSync(file));
         if (missingFile) {
-            return err(new Error(`Test file not found: ${missingFile}`));
+            return err(new CallerInputError(`Test file not found: ${missingFile}`));
         }
         // Build command based on framework
         const { command, args, report, coverageDirectory } = this.buildTestCommand(files, framework);
@@ -490,6 +510,7 @@ Provide:
                     env: {
                         ...process.env,
                         FORCE_COLOR: '0', // Disable color codes for easier parsing
+                        ...PYTEST_ENV, // pytest reads any FORCE_COLOR as "force colour" (#1248)
                         CI: 'true', // Enable CI mode for consistent output
                     },
                 });
@@ -534,11 +555,15 @@ Provide:
                     finish(err(toError(error)));
                     return;
                 }
-                if (reportText === undefined) {
+                // #1248: pytest reports its own missing report (pytest not installed).
+                const pytest = framework.toLowerCase() === 'pytest';
+                if (reportText === undefined && !pytest) {
                     finish(err(new TestRunnerExecutionError(`The current Vitest JSON report is missing for ${fileLabel}.`)));
                     return;
                 }
-                const parseResult = this.parseTestOutput(reportText, stderr, fileLabel, framework, code);
+                const parseResult = pytest
+                    ? this.parsePytestOutput(reportText, `${stderr}\n${stdout}`, files, code, command)
+                    : this.parseTestOutput(reportText ?? '', stderr, fileLabel, framework, code);
                 // Read only this invocation's coverage artifacts. A previous or
                 // concurrent run's project coverage directory is not evidence.
                 if (parseResult.success && coverageDirectory) {
@@ -611,8 +636,14 @@ Provide:
                     command: process.execPath,
                     args: ['--test', ...files],
                 };
+            case 'pytest': {
+                // #1248: results come from the JUnit report file; no coverage is collected.
+                const report = createPytestJunitReport();
+                return { ...pytestCommand(files, report.path), report };
+            }
             default: {
-                // Default to vitest
+                // Default to vitest. Python files never get here: executeTestFiles
+                // sends them to pytest or refuses the run (#1248).
                 const coverageDirectory = createCoverageDirectory();
                 let report;
                 try {
@@ -655,6 +686,43 @@ Provide:
                 `stdout: ${capDiagnostics(stdout, 500)}\nstderr: ${capDiagnostics(stderr, 500)}`));
         }
     }
+    /**
+     * #1248: a pytest run from its JUnit report (undefined when pytest wrote none).
+     */
+    parsePytestOutput(report, output, files, exitCode, python) {
+        const run = pytestRunFromReport(report, files, exitCode, output, python);
+        if (!run.success)
+            return run;
+        const failedTests = run.value.tests
+            .filter(test => test.status === 'failed')
+            .map(test => ({
+            testId: uuidv4(),
+            testName: test.name,
+            file: test.file,
+            error: test.failureMessage ?? 'Test failed',
+            stack: test.failureMessage ?? '',
+            duration: test.duration ?? 0,
+        }));
+        const testCases = run.value.tests.map(test => {
+            const failureMessage = test.failureMessage && testCaseFailureMessage(test.failureMessage);
+            return {
+                name: test.name,
+                file: test.file,
+                status: test.status,
+                ...(test.duration !== undefined ? { duration: test.duration } : {}),
+                ...(failureMessage ? { failureMessage } : {}),
+            };
+        });
+        return ok({
+            total: run.value.total,
+            passed: run.value.passed,
+            failed: run.value.failed,
+            skipped: run.value.skipped,
+            failedTests,
+            testCases,
+            coverage: undefined,
+        });
+    }
     /**
      * Parse the TAP or spec summary emitted by Node's built-in test runner.
      */
@@ -1018,7 +1086,7 @@ Provide:
         return shards;
     }
     async executeWorker(files, _workerIndex, _isolation, request) {
-        return this.executeTestFiles(files, request.framework, request.timeout ?? 30000, request.projectRoot);
+        return this.executeTestFiles(files, request.framework, request.timeout ?? 30000, request.projectRoot, request.frameworkFromConfig);
     }
     aggregateResults(results) {
         const aggregated = {

package/dist/init/copilot-installer.d.ts

@@ -29,6 +29,12 @@ export declare class CopilotInstaller {
     private generator;
     constructor(options: CopilotInstallerOptions);
     install(): Promise<CopilotInstallResult>;
+    /**
+     * Replace AQE's server entry in an existing config, keeping everything else.
+     * Returns null when the file cannot be merged safely (e.g. JSONC comments,
+     * which VS Code accepts but JSON.parse does not) so the user's file is never
+     * clobbered wholesale.
+     */
     private mergeExistingConfig;
 }
 export declare function createCopilotInstaller(options: CopilotInstallerOptions): CopilotInstaller;

package/dist/init/copilot-installer.js

@@ -8,6 +8,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { join, dirname } from 'path';
 import { toErrorMessage } from '../shared/error-utils.js';
+import { writeFileIfChanged } from './idempotent-write.js';
 import { createPlatformConfigGenerator, } from './platform-config-generator.js';
 // ============================================================================
 // Copilot Installer Class
@@ -37,20 +38,28 @@ export class CopilotInstaller {
             const mcpConfig = this.generator.generateMcpConfig('copilot', { memoryBackend: this.options.memoryBackend });
             const configPath = join(this.projectRoot, mcpConfig.path);
             result.configPath = configPath;
-            if (!existsSync(configPath) || this.overwrite) {
+            // AQE's own server entry is refreshed on every init, independent of
+            // `overwrite` (#1269): its launch config is version-pinned, and a stale one
+            // leaves VS Code serving tool schemas cached from an older server. Other
+            // servers and top-level keys in the file are preserved.
+            if (!existsSync(configPath)) {
                 const configDir = dirname(configPath);
                 if (!existsSync(configDir)) {
                     mkdirSync(configDir, { recursive: true });
                 }
-                // Merge with existing if present
-                if (existsSync(configPath) && this.overwrite) {
-                    const merged = this.mergeExistingConfig(configPath, mcpConfig.content);
-                    writeFileSync(configPath, merged);
+                writeFileSync(configPath, mcpConfig.content);
+                result.mcpConfigured = true;
+            }
+            else {
+                const merged = this.mergeExistingConfig(configPath, mcpConfig.content);
+                if (merged === null) {
+                    result.errors.push(`${configPath} is not plain JSON (comments?) and was left unchanged; ` +
+                        `update its "agentic-qe" server entry by hand`);
                 }
                 else {
-                    writeFileSync(configPath, mcpConfig.content);
+                    writeFileIfChanged(configPath, merged);
+                    result.mcpConfigured = true;
                 }
-                result.mcpConfigured = true;
             }
             // Generate behavioral rules
             const rules = this.generator.generateBehavioralRules('copilot');
@@ -71,23 +80,34 @@ export class CopilotInstaller {
         }
         return result;
     }
+    /**
+     * Replace AQE's server entry in an existing config, keeping everything else.
+     * Returns null when the file cannot be merged safely (e.g. JSONC comments,
+     * which VS Code accepts but JSON.parse does not) so the user's file is never
+     * clobbered wholesale.
+     */
     mergeExistingConfig(configPath, newContent) {
+        let existing;
         try {
-            const existing = JSON.parse(readFileSync(configPath, 'utf-8'));
-            const incoming = JSON.parse(newContent);
-            // Merge servers
-            if (!existing.servers) {
-                existing.servers = {};
-            }
-            Object.assign(existing.servers, incoming.servers);
-            return JSON.stringify(existing, null, 2) + '\n';
+            existing = JSON.parse(readFileSync(configPath, 'utf-8'));
         }
         catch {
-            // If existing config is invalid, overwrite
-            return newContent;
+            return null;
         }
+        if (!isPlainObject(existing))
+            return null;
+        if (existing.servers === undefined)
+            existing.servers = {};
+        if (!isPlainObject(existing.servers))
+            return null;
+        const incoming = JSON.parse(newContent);
+        Object.assign(existing.servers, incoming.servers);
+        return JSON.stringify(existing, null, 2) + '\n';
     }
 }
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
 // ============================================================================
 // Factory Function
 // ============================================================================

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

@@ -13,6 +13,7 @@ import { createN8nInstaller } from './n8n-installer.js';
 import { toErrorMessage } from '../shared/error-utils.js';
 import { isNativeModuleLoadFailure, withNativeModuleRemedy } from '../shared/native-module-errors.js';
 import { openDatabase } from '../shared/safe-db.js';
+import { setJournalModeWithRetry } from '../shared/sqlite-journal-mode.js';
 import { safeJsonParse } from '../shared/safe-json.js';
 // ============================================================================
 // Version Management
@@ -128,8 +129,9 @@ export async function initializePersistenceDatabase(projectRoot) {
     const dbPath = join(dataDir, 'memory.db');
     try {
         const db = new Database(dbPath);
-        db.pragma('journal_mode = WAL');
+        // busy_timeout first; the WAL switch retries within it (#1164).
         db.pragma('busy_timeout = 5000');
+        setJournalModeWithRetry(db, 'WAL', 5000);
         db.exec(`
       CREATE TABLE IF NOT EXISTS kv_store (
         key TEXT NOT NULL,