agentic-qe 3.14.3 → 3.14.5

package/dist/cli/commands/code.js

@@ -56,6 +56,12 @@ Examples:
                 const targetPath = path.resolve(target || '.');
                 let paths;
                 if (gitSince) {
+                    const { getGitRefError } = await import('../../shared/git/ref-validation.js');
+                    const refError = getGitRefError(gitSince, '--git-since ref');
+                    if (refError) {
+                        console.log(chalk.red(refError));
+                        return await cleanupAndExit(1);
+                    }
                     // Use git diff to find changed files since the ref
                     // SEC: Use execFileSync with array args to prevent shell injection (CWE-78)
                     const { execFileSync } = await import('child_process');

package/dist/cli/commands/eval.js

@@ -17,6 +17,7 @@ import * as path from 'path';
 import * as yaml from 'yaml';
 import { createParallelEvalRunner, DEFAULT_PARALLEL_EVAL_CONFIG, MockLLMExecutor, } from '../../validation/parallel-eval-runner.js';
 import { resolveEvalExecutor } from '../../validation/provider-llm-executor.js';
+import { DEFAULT_SONNET_MODEL } from '../../shared/llm/model-registry.js';
 import { createCommandEvalRunner, isCommandEvalSuite, } from '../../validation/command-eval-runner.js';
 import { createSkillValidationLearner, } from '../../learning/skill-validation-learner.js';
 import { createRealQEReasoningBank, } from '../../learning/real-qe-reasoning-bank.js';
@@ -585,7 +586,7 @@ export function createEvalCommand() {
         .command('run')
         .description('Run eval suite for a single skill')
         .requiredOption('-s, --skill <skill>', 'Skill name to evaluate')
-        .requiredOption('-m, --model <model>', 'Model to use (e.g., claude-sonnet-4-6)')
+        .requiredOption('-m, --model <model>', `Model to use (e.g., ${DEFAULT_SONNET_MODEL})`)
         .option('-p, --parallel', 'Enable parallel execution', false)
         .option('-w, --workers <n>', 'Number of parallel workers', parseInt, 5)
         .option('-b, --batch-size <n>', 'Test cases per batch', parseInt, 4)
@@ -615,7 +616,7 @@ export function createEvalCommand() {
         .command('run-all')
         .description('Run eval suites for multiple skills')
         .option('--skills-tier <tier>', 'Skill tier (1=all, 2=P0+P1, 3=P0 only)', parseInt, 3)
-        .option('--models <models>', 'Comma-separated models to test', 'claude-sonnet-4-6')
+        .option('--models <models>', 'Comma-separated models to test', DEFAULT_SONNET_MODEL)
         .option('-p, --parallel', 'Enable parallel execution', true)
         .option('-w, --workers <n>', 'Number of parallel workers', parseInt, 5)
         .option('-o, --output <path>', 'Output file path for report')

package/dist/cli/commands/fleet.js

@@ -4,8 +4,8 @@
  * Fleet operations with multi-agent progress tracking.
  */
 import { Command } from 'commander';
-import { secureRandomFloat } from '../../shared/utils/crypto-random.js';
 import chalk from 'chalk';
+import { loadCLIDomainPlugins } from '../helpers/domain-plugins.js';
 import { ALL_DOMAINS } from '../../shared/types/index.js';
 import { QEKernelImpl } from '../../kernel/kernel.js';
 import { CrossDomainEventRouter } from '../../coordination/cross-domain-router.js';
@@ -99,6 +99,7 @@ export function createFleetCommand(context, cleanupAndExit, ensureInitialized, r
                     enableExperienceBridge: false,
                 });
                 await context.kernel.initialize();
+                const domainPlugins = await loadCLIDomainPlugins(context.kernel.plugins);
                 console.log(chalk.green('  * Kernel initialized'));
                 context.router = new CrossDomainEventRouter(context.kernel.eventBus);
                 await context.router.initialize();
@@ -113,7 +114,7 @@ export function createFleetCommand(context, cleanupAndExit, ensureInitialized, r
                     return context.kernel.getDomainAPI(domain);
                 };
                 const protocolExecutor = new DefaultProtocolExecutor(context.kernel.eventBus, context.kernel.memory, getDomainAPI);
-                context.queen = createQueenCoordinator(context.kernel, context.router, protocolExecutor, undefined);
+                context.queen = createQueenCoordinator(context.kernel, context.router, protocolExecutor, undefined, domainPlugins);
                 await context.queen.initialize();
                 console.log(chalk.green('  * Queen coordinator initialized'));
                 context.initialized = true;
@@ -220,9 +221,15 @@ export function createFleetCommand(context, cleanupAndExit, ensureInitialized, r
         .option('--parallel <count>', 'Number of parallel agents', '4')
         .action(async (operation, options) => {
         if (!await ensureInitialized())
-            return;
+            return cleanupAndExit(1);
         try {
-            const parallelCount = parseInt(options.parallel, 10);
+            const parallelCount = Number(options.parallel);
+            if (!Number.isSafeInteger(parallelCount) || parallelCount < 1) {
+                throw new Error('--parallel must be a positive integer');
+            }
+            if (!['test', 'analyze', 'scan'].includes(operation)) {
+                throw new Error(`Unsupported operation: ${operation}`);
+            }
             console.log(chalk.blue(`\n Fleet Operation: ${operation}\n`));
             const progress = new FleetProgressManager({
                 title: `${operation.charAt(0).toUpperCase() + operation.slice(1)} Progress`,
@@ -234,7 +241,7 @@ export function createFleetCommand(context, cleanupAndExit, ensureInitialized, r
                 analyze: 'coverage-analysis',
                 scan: 'security-compliance',
             };
-            const domain = domainMap[operation] || 'test-generation';
+            const domain = domainMap[operation];
             const agentOperations = Array.from({ length: parallelCount }, (_, i) => {
                 const agentId = `${operation}-agent-${i + 1}`;
                 return {
@@ -251,16 +258,9 @@ export function createFleetCommand(context, cleanupAndExit, ensureInitialized, r
                     progress: 0,
                 });
             }
-            const results = await Promise.all(agentOperations.map(async (op, index) => {
-                await new Promise(resolve => setTimeout(resolve, index * 200));
+            const results = await Promise.all(agentOperations.map(async (op) => {
                 progress.updateAgent(op.id, 0, { status: 'running' });
                 try {
-                    for (let p = 10; p <= 90; p += 20) {
-                        await new Promise(resolve => setTimeout(resolve, secureRandomFloat(300, 500)));
-                        progress.updateAgent(op.id, p, {
-                            eta: Math.round((100 - p) * 50),
-                        });
-                    }
                     const taskResult = await context.queen.submitTask({
                         type: operation === 'test' ? 'generate-tests' :
                             operation === 'analyze' ? 'analyze-coverage' :
@@ -270,10 +270,29 @@ export function createFleetCommand(context, cleanupAndExit, ensureInitialized, r
                         payload: { target: options.target, workerId: op.id },
                         timeout: 60000,
                     });
-                    progress.completeAgent(op.id, taskResult.success);
-                    return { id: op.id, success: taskResult.success };
+                    if (!taskResult.success) {
+                        throw taskResult.error;
+                    }
+                    // Submission is only an acknowledgement. Keep the process alive
+                    // until the domain reports a terminal result or the task expires.
+                    const deadline = Date.now() + 60000;
+                    while (Date.now() < deadline) {
+                        const task = context.queen.getTaskStatus(taskResult.value);
+                        if (!task)
+                            throw new Error(`Task status unavailable: ${taskResult.value}`);
+                        if (task.status === 'completed') {
+                            progress.completeAgent(op.id, true);
+                            return { id: op.id, success: true };
+                        }
+                        if (task.status === 'failed' || task.status === 'cancelled') {
+                            throw new Error(task.error || `Task ${task.status}`);
+                        }
+                        await new Promise(resolve => setTimeout(resolve, 250));
+                    }
+                    throw new Error(`Task timed out: ${taskResult.value}`);
                 }
-                catch {
+                catch (error) {
+                    console.error(chalk.red(`   ${op.name}: ${error instanceof Error ? error.message : String(error)}`));
                     progress.completeAgent(op.id, false);
                     return { id: op.id, success: false };
                 }

package/dist/cli/commands/learning-snapshot.d.ts

@@ -0,0 +1,38 @@
+interface SnapshotInfo {
+    schemaVersion: number;
+    pages: number;
+    verification: {
+        valid: true;
+        message: string;
+    };
+}
+export interface LearningBackupResult {
+    backupPath: string;
+    sourceSizeKB: number;
+    backupSizeKB: number;
+    compressed: boolean;
+    schemaVersion: number;
+    verification: SnapshotInfo['verification'];
+}
+/** Publish only a complete standalone image; the existing artifact survives staging failures. */
+export declare function backupLearningDatabase(source: string, output: string, options?: {
+    compress?: boolean;
+    verify?: boolean;
+}): Promise<LearningBackupResult>;
+export interface LearningRestoreResult {
+    sizeKB: number;
+    schemaVersion: number;
+    wasCompressed: boolean;
+    safetyBackupPath?: string;
+}
+/**
+ * Validate before replacing anything and retain a verified pre-restore image.
+ * SQLite mediates the destination write: never unlink its DB/WAL/SHM files.
+ * Stop project writers before restore; this does not coordinate later writes
+ * from other processes or refresh their in-memory learning caches.
+ */
+export declare function restoreLearningDatabase(input: string, destination: string, options?: {
+    force?: boolean;
+}): Promise<LearningRestoreResult>;
+export {};
+//# sourceMappingURL=learning-snapshot.d.ts.map

package/dist/cli/commands/learning-snapshot.js

@@ -0,0 +1,171 @@
+/** Consistent, verified SQLite images for the learning backup/restore commands. */
+import { existsSync, realpathSync, statSync } from 'node:fs';
+import { mkdir, mkdtemp, rename, rm, stat } from 'node:fs/promises';
+import { basename, dirname, join, resolve } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { openDatabase } from '../../shared/safe-db.js';
+import { compressFile, decompressFile } from './learning-helpers.js';
+function inspectSnapshot(file) {
+    const db = openDatabase(file, { readonly: true, fileMustExist: true });
+    try {
+        const checks = db.pragma('integrity_check');
+        if (checks.length !== 1 || checks[0].integrity_check !== 'ok') {
+            throw new Error('Database integrity verification failed');
+        }
+        const hasVersion = db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='schema_version'").get();
+        const version = hasVersion
+            ? db.prepare('SELECT version FROM schema_version WHERE id = 1').get()
+            : undefined;
+        return {
+            schemaVersion: version?.version ?? 0,
+            pages: db.pragma('page_count', { simple: true }),
+            verification: { valid: true, message: 'Database integrity verified' },
+        };
+    }
+    finally {
+        db.close();
+    }
+}
+function canonicalPath(file) {
+    return existsSync(file) ? realpathSync(file) : join(realpathSync(dirname(file)), basename(file));
+}
+function sameFile(left, right) {
+    if (canonicalPath(left) === canonicalPath(right))
+        return true;
+    if (!existsSync(left) || !existsSync(right))
+        return false;
+    const a = statSync(left);
+    const b = statSync(right);
+    return a.dev === b.dev && a.ino === b.ino;
+}
+function assertDistinct(source, destination) {
+    const sourcePath = canonicalPath(source);
+    const destinationPath = canonicalPath(destination);
+    for (const suffix of ['', '-wal', '-shm', '-journal']) {
+        if (sameFile(`${sourcePath}${suffix}`, destination)
+            || sameFile(source, `${destinationPath}${suffix}`)) {
+            throw new Error('Backup source and destination must not alias the same database or its sidecars');
+        }
+    }
+}
+function assertRegularFile(file) {
+    if (!statSync(file).isFile())
+        throw new Error('Backup input must be a regular file');
+}
+/** Awaiting backup alone is insufficient: a busy destination can report 0/0. */
+async function copySqliteSnapshot(source, destination, options = {}) {
+    const db = openDatabase(source, { readonly: true, fileMustExist: true });
+    try {
+        const result = await db.backup(destination);
+        if (result.totalPages <= 0 || result.remainingPages !== 0
+            || (options.expectedPages !== undefined && result.totalPages !== options.expectedPages)) {
+            throw new Error('SQLite snapshot did not complete; the source may be empty or the destination busy');
+        }
+        if (options.standalone) {
+            // Only private new images are normalized. A WAL header otherwise makes
+            // SQLite try to create sidecars when reading an archive on readonly media.
+            const image = openDatabase(destination, { fileMustExist: true, walMode: false });
+            try {
+                if (image.pragma('journal_mode = DELETE', { simple: true }) !== 'delete') {
+                    throw new Error('Could not create a standalone SQLite image');
+                }
+            }
+            finally {
+                image.close();
+            }
+        }
+        const inspected = inspectSnapshot(destination);
+        if (inspected.pages !== result.totalPages) {
+            throw new Error('SQLite snapshot page count does not match the completed backup');
+        }
+        return inspected;
+    }
+    finally {
+        db.close();
+    }
+}
+/** Publish only a complete standalone image; the existing artifact survives staging failures. */
+export async function backupLearningDatabase(source, output, options = {}) {
+    assertRegularFile(source);
+    const finalPath = resolve(options.compress ? `${output}.gz` : output);
+    await mkdir(dirname(finalPath), { recursive: true });
+    assertDistinct(source, resolve(output));
+    assertDistinct(source, finalPath);
+    const staging = await mkdtemp(join(dirname(finalPath), '.aqe-backup-'));
+    try {
+        const image = join(staging, 'snapshot.db');
+        const info = await copySqliteSnapshot(source, image, { standalone: true });
+        const published = options.compress ? await compressFile(image) : image;
+        if (options.compress && options.verify) {
+            const checkedImage = join(staging, 'verified.db');
+            await decompressFile(published, checkedImage);
+            inspectSnapshot(checkedImage);
+        }
+        const sourceSizeKB = Number(((await stat(source)).size / 1024).toFixed(2));
+        const backupSizeKB = Number(((await stat(published)).size / 1024).toFixed(2));
+        // An existing DB+WAL pair may be live. Never replace its main file while
+        // leaving old sidecars that could be replayed against the new image.
+        if (['-wal', '-shm', '-journal'].some(suffix => existsSync(`${finalPath}${suffix}`))) {
+            throw new Error('Backup destination has SQLite sidecars; choose an unused output path');
+        }
+        await rename(published, finalPath);
+        return { backupPath: finalPath, sourceSizeKB, backupSizeKB, compressed: !!options.compress,
+            schemaVersion: info.schemaVersion, verification: info.verification };
+    }
+    finally {
+        await rm(staging, { recursive: true, force: true });
+    }
+}
+/**
+ * Validate before replacing anything and retain a verified pre-restore image.
+ * SQLite mediates the destination write: never unlink its DB/WAL/SHM files.
+ * Stop project writers before restore; this does not coordinate later writes
+ * from other processes or refresh their in-memory learning caches.
+ */
+export async function restoreLearningDatabase(input, destination, options = {}) {
+    assertRegularFile(input);
+    await mkdir(dirname(destination), { recursive: true });
+    assertDistinct(input, destination);
+    if (existsSync(destination) && !options.force) {
+        throw new Error(`Database already exists at: ${destination}. Use --force to overwrite`);
+    }
+    const staging = await mkdtemp(join(dirname(destination), '.aqe-restore-'));
+    let safetyBackupPath;
+    try {
+        const wasCompressed = input.endsWith('.gz');
+        const image = join(staging, 'snapshot.db');
+        let source = input;
+        if (wasCompressed) {
+            source = join(staging, 'decompressed.db');
+            await decompressFile(input, source);
+        }
+        // A legacy uncompressed backup may still need its companion WAL.
+        const info = await copySqliteSnapshot(source, image, { standalone: true });
+        const sizeKB = Number(((await stat(image)).size / 1024).toFixed(2));
+        if (existsSync(destination)) {
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+            const candidate = `${destination}.pre-restore-${timestamp}-${randomUUID()}.db`;
+            try {
+                await copySqliteSnapshot(destination, candidate, { standalone: true });
+                safetyBackupPath = candidate;
+            }
+            catch (error) {
+                await rm(candidate, { force: true });
+                throw new Error('Cannot create a verified safety backup of the existing database; restore refused. Stop project processes and preserve the database and its sidecars before restoring into an absent destination.', { cause: error });
+            }
+        }
+        await copySqliteSnapshot(image, destination, { expectedPages: info.pages });
+        return { sizeKB, schemaVersion: info.schemaVersion, wasCompressed, safetyBackupPath };
+    }
+    catch (error) {
+        if (safetyBackupPath) {
+            const detail = error instanceof Error ? error.message : 'SQLite snapshot failed';
+            throw new Error(`Restore failed: ${detail}; previous database snapshot preserved at ${safetyBackupPath}`, { cause: error });
+        }
+        throw error;
+    }
+    finally {
+        await rm(staging, { recursive: true, force: true });
+    }
+}
+//# sourceMappingURL=learning-snapshot.js.map

package/dist/cli/commands/learning.js

@@ -13,13 +13,14 @@ import { Command } from 'commander';
 import chalk from 'chalk';
 import path from 'node:path';
 import { findProjectRoot } from '../../kernel/unified-memory.js';
-import { existsSync, writeFileSync, readFileSync, mkdirSync, copyFileSync, renameSync } from 'node:fs';
+import { existsSync, writeFileSync, readFileSync, copyFileSync, renameSync } from 'node:fs';
 import { safeJsonParse } from '../../shared/safe-json.js';
 import { stat, unlink } from 'node:fs/promises';
 import { QE_DOMAIN_LIST } from '../../learning/qe-patterns.js';
 import { createLearningMetricsTracker, } from '../../learning/metrics-tracker.js';
 import { createRegretTracker, } from '../../learning/regret-tracker.js';
 import { openDatabase } from '../../shared/safe-db.js';
+import { backupLearningDatabase, restoreLearningDatabase } from './learning-snapshot.js';
 import { createSQLitePatternStore } from '../../learning/sqlite-persistence.js';
 import { getActiveEmbeddingSpaceIdentity } from '../../learning/real-embeddings.js';
 import { inspectEmbeddingSpaceRows } from '../../learning/embedding-space.js';
@@ -692,7 +693,7 @@ function registerBackupCommand(learning) {
     learning
         .command('backup')
         .description('Backup learning database to a file')
-        .option('-o, --output <path>', 'Output file path')
+        .option('-o, --output <path>', 'Dedicated backup artifact path; never another live database')
         .option('--compress', 'Compress backup with gzip')
         .option('--verify', 'Verify backup integrity after creation')
         .option('--json', 'Output as JSON')
@@ -704,30 +705,11 @@ function registerBackupCommand(learning) {
             const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
             const defaultOutput = path.join(process.cwd(), 'backups', `learning-${timestamp}.db`);
             const outputPath = options.output ? path.resolve(options.output) : defaultOutput;
-            const backupDir = path.dirname(outputPath);
-            if (!existsSync(backupDir))
-                mkdirSync(backupDir, { recursive: true });
-            const sourceStats = await stat(dbPath);
-            const sourceSizeKB = (sourceStats.size / 1024).toFixed(2);
-            copyFileSync(dbPath, outputPath);
-            const walPath = `${dbPath}-wal`;
-            if (existsSync(walPath))
-                copyFileSync(walPath, `${outputPath}-wal`);
-            let finalPath = outputPath;
-            if (options.compress) {
-                finalPath = await compressFile(outputPath);
-                await unlink(outputPath);
-                if (existsSync(`${outputPath}-wal`))
-                    await unlink(`${outputPath}-wal`);
-            }
-            const finalStats = await stat(finalPath);
-            const finalSizeKB = (finalStats.size / 1024).toFixed(2);
-            let verificationResult;
-            if (options.verify && !options.compress)
-                verificationResult = await verifyDatabaseIntegrity(outputPath);
-            const schemaVersion = await getSchemaVersion(dbPath);
+            const snapshot = await backupLearningDatabase(dbPath, outputPath, options);
+            const { backupPath: finalPath, sourceSizeKB, backupSizeKB: finalSizeKB, schemaVersion } = snapshot;
+            const verificationResult = options.verify ? snapshot.verification : undefined;
             if (options.json) {
-                printJson({ success: true, sourcePath: dbPath, backupPath: finalPath, sourceSizeKB: parseFloat(sourceSizeKB), backupSizeKB: parseFloat(finalSizeKB), compressed: options.compress || false, schemaVersion, verification: verificationResult, timestamp: new Date().toISOString() });
+                printJson({ success: true, sourcePath: dbPath, backupPath: finalPath, sourceSizeKB, backupSizeKB: finalSizeKB, compressed: options.compress || false, schemaVersion, verification: verificationResult, timestamp: new Date().toISOString() });
             }
             else {
                 console.log(chalk.bold('\n💾 Learning Database Backup\n'));
@@ -737,7 +719,7 @@ function registerBackupCommand(learning) {
                 console.log(`  Backup size: ${finalSizeKB} KB`);
                 console.log(`  Schema version: ${schemaVersion}`);
                 if (options.compress) {
-                    const compressionRatio = ((1 - finalStats.size / sourceStats.size) * 100).toFixed(1);
+                    const compressionRatio = ((1 - finalSizeKB / sourceSizeKB) * 100).toFixed(1);
                     console.log(`  Compression: ${compressionRatio}% reduction`);
                 }
                 if (verificationResult) {
@@ -759,9 +741,9 @@ function registerBackupCommand(learning) {
 function registerRestoreCommand(learning) {
     learning
         .command('restore')
-        .description('Restore learning database from backup')
+        .description('Restore a verified learning database backup (stop project writers first)')
         .requiredOption('-i, --input <path>', 'Backup file path to restore from')
-        .option('--verify', 'Verify backup integrity before restore')
+        .option('--verify', 'Verify backup integrity before restore (always enforced)')
         .option('--force', 'Overwrite existing database without confirmation')
         .option('--json', 'Output as JSON')
         .action(async (options) => {
@@ -770,49 +752,19 @@ function registerRestoreCommand(learning) {
             const dbPath = getDbPath();
             if (!existsSync(inputPath))
                 throw new Error(`Backup file not found: ${inputPath}`);
-            const isCompressed = inputPath.endsWith('.gz');
-            let restorePath = inputPath;
-            if (isCompressed) {
-                const tempPath = inputPath.replace('.gz', '.tmp');
-                await decompressFile(inputPath, tempPath);
-                restorePath = tempPath;
-            }
-            if (options.verify) {
-                const verificationResult = await verifyDatabaseIntegrity(restorePath);
-                if (!verificationResult.valid) {
-                    if (isCompressed && existsSync(restorePath))
-                        await unlink(restorePath);
-                    throw new Error(`Backup verification failed: ${verificationResult.message}`);
-                }
-            }
-            if (existsSync(dbPath) && !options.force) {
-                if (isCompressed && existsSync(restorePath))
-                    await unlink(restorePath);
-                throw new Error(`Database already exists at: ${dbPath}. Use --force to overwrite`);
-            }
-            const targetDir = path.dirname(dbPath);
-            if (!existsSync(targetDir))
-                mkdirSync(targetDir, { recursive: true });
-            if (existsSync(dbPath))
-                await unlink(dbPath);
-            if (existsSync(`${dbPath}-wal`))
-                await unlink(`${dbPath}-wal`);
-            if (existsSync(`${dbPath}-shm`))
-                await unlink(`${dbPath}-shm`);
-            copyFileSync(restorePath, dbPath);
-            if (isCompressed && existsSync(restorePath))
-                await unlink(restorePath);
-            const restoredStats = await stat(dbPath);
-            const schemaVersion = await getSchemaVersion(dbPath);
+            const restored = await restoreLearningDatabase(inputPath, dbPath, { force: options.force });
+            const { sizeKB, schemaVersion, wasCompressed: isCompressed, safetyBackupPath } = restored;
             if (options.json) {
-                printJson({ success: true, backupPath: inputPath, restoredPath: dbPath, sizeKB: parseFloat((restoredStats.size / 1024).toFixed(2)), schemaVersion, wasCompressed: isCompressed, timestamp: new Date().toISOString() });
+                printJson({ success: true, backupPath: inputPath, restoredPath: dbPath, sizeKB, schemaVersion, wasCompressed: isCompressed, safetyBackupPath, timestamp: new Date().toISOString() });
             }
             else {
                 console.log(chalk.bold('\n🔄 Learning Database Restore\n'));
                 console.log(`  Backup: ${inputPath}`);
                 console.log(`  Restored to: ${dbPath}`);
-                console.log(`  Size: ${(restoredStats.size / 1024).toFixed(2)} KB`);
+                console.log(`  Size: ${sizeKB.toFixed(2)} KB`);
                 console.log(`  Schema version: ${schemaVersion}`);
+                if (safetyBackupPath)
+                    console.log(`  Previous database: ${safetyBackupPath}`);
                 printSuccess('Database restored successfully\n');
             }
             return;

package/dist/cli/commands/llm-router.js

@@ -15,6 +15,7 @@ import { secureRandomInt } from '../../shared/utils/crypto-random.js';
 import chalk from 'chalk';
 import { ALL_PROVIDER_TYPES, DEFAULT_MODEL_MAPPINGS, isBuiltinExtendedProviderType, } from '../../shared/llm/router/types.js';
 import { getRegisteredProvider, isRegisteredProvider, registeredProviderTypes, } from '../../shared/llm/provider-registry.js';
+import { DEFAULT_OPUS_MODEL, DEFAULT_SONNET_MODEL } from '../../shared/llm/model-registry.js';
 import { resolvesOnPath } from '../../shared/llm/providers/external-cli.js';
 // ============================================================================
 // CLI config state (lazy-loaded from .agentic-qe/llm-config.json)
@@ -74,7 +75,7 @@ Examples:
   $ aqe llm route "security audit"     Test routing for a task
   $ aqe llm config --set mode=cost-optimized
   $ aqe llm health                 Check provider health
-  $ aqe llm cost claude-sonnet-4 --tokens 10000
+  $ aqe llm cost claude-sonnet-5 --tokens 10000
   $ aqe llm advise --transcript t.json --json   Consult advisor (ADR-092)
   $ aqe llm verify --session <id>               Check advisor quality gate
 `);
@@ -411,15 +412,15 @@ function formatCost(cost) {
 }
 function getDefaultModelForProvider(provider) {
     const defaults = {
-        claude: 'claude-sonnet-4-6',
+        claude: DEFAULT_SONNET_MODEL,
         'claude-code': 'sonnet',
-        codex: 'gpt-5-codex',
-        openai: 'gpt-4o',
-        ollama: 'llama3.1',
-        openrouter: 'anthropic/claude-sonnet-4',
-        gemini: 'gemini-2.0-pro',
+        codex: 'default',
+        openai: 'gpt-6-sol',
+        ollama: 'qwen3-coder:30b',
+        openrouter: 'anthropic/claude-sonnet-5',
+        gemini: 'gemini-2.5-flash',
         'azure-openai': 'gpt-4o',
-        bedrock: 'anthropic.claude-sonnet-4-v1:0',
+        bedrock: 'anthropic.claude-sonnet-4-6-v1:0',
         cognitum: 'cognitum-auto',
         onnx: 'phi-4',
     };
@@ -470,10 +471,10 @@ function simulateRoutingDecision(task, options) {
     if (agentType?.includes('security') || task.toLowerCase().includes('security')) {
         return {
             provider: 'claude',
-            model: 'claude-sonnet-4-6',
+            model: DEFAULT_SONNET_MODEL,
             reason: 'Security tasks require advanced reasoning (rule-match)',
             confidence: 0.95,
-            estimatedCost: { inputTokens: 2000, outputTokens: 1000, totalCostUsd: 0.021 },
+            estimatedCost: { inputTokens: 2000, outputTokens: 1000, totalCostUsd: 0.014 },
         };
     }
     if (mode === 'cost-optimized' || complexity === 'trivial' || complexity === 'low') {
@@ -488,10 +489,10 @@ function simulateRoutingDecision(task, options) {
     if (mode === 'performance-optimized' || complexity === 'expert') {
         return {
             provider: 'claude',
-            model: 'claude-opus-4-7',
+            model: DEFAULT_OPUS_MODEL,
             reason: 'Complex task requires flagship model',
             confidence: 0.92,
-            estimatedCost: { inputTokens: 2000, outputTokens: 1000, totalCostUsd: 0.105 },
+            estimatedCost: { inputTokens: 2000, outputTokens: 1000, totalCostUsd: 0.028 },
         };
     }
     // Default

package/dist/cli/commands/mcp.js

@@ -13,6 +13,8 @@ import { join, dirname } from 'path';
 import { existsSync } from 'fs';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { findPackageRoot } from '../../init/find-package-root.js';
+import { resolveCliLogLevel, setCliLogLevel } from '../log-gate.js';
+import { LogLevel } from '../../logging/index.js';
 /**
  * Create the MCP command
  */
@@ -28,6 +30,10 @@ export function createMcpCommand() {
         if (options.verbose) {
             process.env.AQE_VERBOSE = 'true';
         }
+        // The server runs in this process under the CLI log gate. Keep its
+        // historical INFO default (diagnostics go to stderr, never the stdio
+        // protocol stream) unless AQE_LOG_LEVEL / LOG_LEVEL say otherwise.
+        setCliLogLevel(resolveCliLogLevel(process.env, LogLevel.INFO));
         // Find the MCP entry point
         const entryPath = findMcpEntry();
         if (!entryPath) {

package/dist/cli/commands/memory.d.ts

@@ -7,5 +7,5 @@
  */
 import { Command } from 'commander';
 import type { CLIContext } from '../handlers/interfaces.js';
-export declare function createMemoryCommand(context: CLIContext, cleanupAndExit: (code: number) => Promise<never>, ensureInitialized: () => Promise<boolean>): Command;
+export declare function createMemoryCommand(context: CLIContext, cleanupAndExit: (code: number) => Promise<never>, ensureMemoryReady: () => Promise<boolean>): Command;
 //# sourceMappingURL=memory.d.ts.map

package/dist/cli/commands/memory.js

@@ -8,7 +8,7 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import { toErrorMessage } from '../../shared/error-utils.js';
-export function createMemoryCommand(context, cleanupAndExit, ensureInitialized) {
+export function createMemoryCommand(context, cleanupAndExit, ensureMemoryReady) {
     const memory = new Command('memory')
         .description('Memory store, retrieve, search, and delete operations')
         .addHelpText('after', `
@@ -47,7 +47,7 @@ Examples:
         .option('--ttl <seconds>', 'Time-to-live in seconds')
         .option('--json', 'Output as JSON')
         .action(async (options) => {
-        if (!await ensureInitialized())
+        if (!await ensureMemoryReady())
             return;
         try {
             const { handleMemoryStore } = await import('../../mcp/handlers/memory-handlers.js');
@@ -91,7 +91,7 @@ Examples:
         .option('--include-metadata', 'Include metadata in response')
         .option('--json', 'Output as JSON')
         .action(async (options) => {
-        if (!await ensureInitialized())
+        if (!await ensureMemoryReady())
             return;
         try {
             const { handleMemoryRetrieve } = await import('../../mcp/handlers/memory-handlers.js');
@@ -141,7 +141,7 @@ Examples:
             console.error(chalk.red('  Either --pattern or --query is required'));
             await cleanupAndExit(1);
         }
-        if (!await ensureInitialized())
+        if (!await ensureMemoryReady())
             return;
         try {
             const { handleMemoryQuery } = await import('../../mcp/handlers/memory-handlers.js');
@@ -186,7 +186,7 @@ Examples:
         .option('--limit <n>', 'Maximum results', '50')
         .option('--json', 'Output as JSON')
         .action(async (options) => {
-        if (!await ensureInitialized())
+        if (!await ensureMemoryReady())
             return;
         try {
             const { handleMemoryQuery } = await import('../../mcp/handlers/memory-handlers.js');
@@ -225,7 +225,7 @@ Examples:
         .option('--namespace <ns>', 'Namespace', 'default')
         .option('--json', 'Output as JSON')
         .action(async (options) => {
-        if (!await ensureInitialized())
+        if (!await ensureMemoryReady())
             return;
         try {
             const { handleMemoryDelete } = await import('../../mcp/handlers/memory-handlers.js');
@@ -264,7 +264,7 @@ Examples:
         .requiredOption('--content <json>', 'JSON content to share')
         .option('--json', 'Output as JSON')
         .action(async (options) => {
-        if (!await ensureInitialized())
+        if (!await ensureMemoryReady())
             return;
         try {
             const { handleMemoryShare } = await import('../../mcp/handlers/memory-handlers.js');
@@ -307,7 +307,7 @@ Examples:
         .description('Show memory usage statistics')
         .option('--json', 'Output as JSON')
         .action(async (options) => {
-        if (!await ensureInitialized())
+        if (!await ensureMemoryReady())
             return;
         try {
             const { handleMemoryUsage } = await import('../../mcp/handlers/memory-handlers.js');