agentic-qe 3.14.2 → 3.14.4

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/pipeline.js

@@ -170,6 +170,9 @@ export function createPipelineCommand(context, cleanupAndExit, ensureInitialized
                 if (status.error)
                     console.log(`  Error:   ${chalk.red(status.error)}`);
             }
+            console.log('');
+            await cleanupAndExit(status?.status === 'completed' ? 0 : 1);
+            return;
         }
         console.log('');
         await cleanupAndExit(0);
@@ -250,6 +253,12 @@ export function createPipelineCommand(context, cleanupAndExit, ensureInitialized
         if (status.error) {
             console.log(`  Error:      ${chalk.red(status.error)}`);
         }
+        for (const receipt of status.parallelCompositionReceipts ?? []) {
+            console.log(`  Composition ${receipt.groupId}: ${receipt.disposition}`);
+            for (const conflict of receipt.conflicts) {
+                console.log(`    ${conflict.kind}: ${conflict.stepA}.${conflict.pathA} / ${conflict.stepB}.${conflict.pathB}`);
+            }
+        }
         console.log('');
         await cleanupAndExit(0);
     });