agentic-qe 3.14.3 → 3.14.4

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);
     });

package/dist/cli/commands/workflow.js

@@ -29,7 +29,6 @@ export function createWorkflowCommand(context, cleanupAndExit, ensureInitialized
         .action(async (file, options) => {
         if (!await ensureInitialized())
             return;
-        const fs = await import('fs');
         const pathModule = await import('path');
         const filePath = pathModule.resolve(file);
         try {
@@ -123,6 +122,9 @@ export function createWorkflowCommand(context, cleanupAndExit, ensureInitialized
                         console.log(chalk.yellow(`Workflow ${finalStatus.status}`));
                     }
                 }
+                console.log('');
+                await cleanupAndExit(finalStatus?.status === 'completed' ? 0 : 1);
+                return;
             }
             else {
                 console.log(chalk.green('Workflow execution started'));
@@ -424,6 +426,12 @@ export function createWorkflowCommand(context, cleanupAndExit, ensureInitialized
             if (status.error) {
                 console.log(chalk.red(`\n  Error: ${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}`);
+                }
+            }
             if (options.verbose && status.stepResults.size > 0) {
                 console.log(chalk.cyan('\n  Step Results:'));
                 for (const [stepId, result] of status.stepResults) {

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

@@ -68,7 +68,7 @@ export class TaskHandler {
     }
     async executeSubmit(type, options, context) {
         if (!await this.ensureInitialized())
-            return;
+            return this.cleanupAndExit(1);
         try {
             const taskType = type;
             const payload = parseJsonOption(options.payload, 'payload');
@@ -112,9 +112,9 @@ export class TaskHandler {
                                 waitSpinner.succeed('Task completed successfully');
                                 completed = true;
                             }
-                            else if (taskStatus.status === 'failed') {
-                                waitSpinner.fail(`Task failed: ${taskStatus.error || 'Unknown error'}`);
-                                completed = true;
+                            else if (taskStatus.status === 'failed' || taskStatus.status === 'cancelled') {
+                                waitSpinner.fail(`Task ${taskStatus.status}: ${taskStatus.error || 'No successful result'}`);
+                                return this.cleanupAndExit(1);
                             }
                             else {
                                 // Update spinner with progress info
@@ -127,11 +127,13 @@ export class TaskHandler {
                     }
                     if (!completed) {
                         waitSpinner.fail('Task timed out');
+                        return this.cleanupAndExit(1);
                     }
                 }
             }
             else {
                 console.log(chalk.red(`   Error: ${result.error.message}`));
+                return this.cleanupAndExit(1);
             }
             console.log('');
         }
@@ -142,7 +144,7 @@ export class TaskHandler {
     }
     async executeList(options, context) {
         if (!await this.ensureInitialized())
-            return;
+            return this.cleanupAndExit(1);
         try {
             const tasks = context.queen.listTasks({
                 status: options.status,
@@ -155,6 +157,7 @@ export class TaskHandler {
                     taskId: task.taskId,
                     type: task.task.type,
                     status: task.status,
+                    cancellationResultPending: task.cancellationResultPending,
                     priority: task.task.priority,
                     domain: task.assignedDomain || null,
                     startedAt: task.startedAt?.toISOString() || null,
@@ -189,11 +192,14 @@ export class TaskHandler {
     }
     async executeCancel(taskId, context) {
         if (!await this.ensureInitialized())
-            return;
+            return this.cleanupAndExit(1);
         try {
             const result = await context.queen.cancelTask(taskId);
             if (result.success) {
-                console.log(chalk.green(`\n  Task cancelled: ${taskId}\n`));
+                console.log(chalk.green(`\n  Cancellation requested: ${taskId}\n`));
+                if (context.queen.getTaskStatus(taskId)?.cancellationResultPending) {
+                    console.log(chalk.yellow('  Task result pending; work may continue.'));
+                }
             }
             else {
                 console.log(chalk.red(`\n  Failed to cancel task: ${result.error.message}\n`));
@@ -206,12 +212,12 @@ export class TaskHandler {
     }
     async executeTaskStatus(taskId, options, context) {
         if (!await this.ensureInitialized())
-            return;
+            return this.cleanupAndExit(1);
         try {
             const task = context.queen.getTaskStatus(taskId);
             if (!task) {
                 console.log(chalk.red(`\n  Task not found: ${taskId}\n`));
-                return;
+                return this.cleanupAndExit(1);
             }
             const format = (options.format || 'text');
             if (format === 'json') {
@@ -219,6 +225,7 @@ export class TaskHandler {
                     taskId,
                     type: task.task.type,
                     status: task.status,
+                    cancellationResultPending: task.cancellationResultPending,
                     priority: task.task.priority,
                     domain: task.assignedDomain || null,
                     agents: task.assignedAgents,
@@ -237,6 +244,9 @@ export class TaskHandler {
             console.log(chalk.blue(`\n  Task: ${taskId}\n`));
             console.log(`  Type: ${task.task.type}`);
             console.log(`  Status: ${getStatusColor(task.status)}`);
+            if (task.cancellationResultPending) {
+                console.log(chalk.yellow('  Task result pending; work may continue.'));
+            }
             console.log(`  Priority: ${task.task.priority}`);
             if (task.assignedDomain) {
                 console.log(`  Domain: ${task.assignedDomain}`);

package/dist/cli/helpers/domain-plugins.d.ts

@@ -0,0 +1,5 @@
+import type { DomainPlugin, PluginLoader } from '../../kernel/interfaces.js';
+import type { DomainName } from '../../shared/types/index.js';
+/** Supply the Queen with the actual plugin instances that execute CLI tasks. */
+export declare function loadCLIDomainPlugins(loader: PluginLoader): Promise<Map<DomainName, DomainPlugin>>;
+//# sourceMappingURL=domain-plugins.d.ts.map

package/dist/cli/helpers/domain-plugins.js

@@ -0,0 +1,11 @@
+/** Supply the Queen with the actual plugin instances that execute CLI tasks. */
+export async function loadCLIDomainPlugins(loader) {
+    await loader.loadAll();
+    const plugins = new Map();
+    for (const domain of loader.getLoaded()) {
+        // load() returns the cached instance after loadAll(), including dependencies.
+        plugins.set(domain, await loader.load(domain));
+    }
+    return plugins;
+}
+//# sourceMappingURL=domain-plugins.js.map

package/dist/cli/index.js

@@ -98,6 +98,7 @@ async function autoInitialize() {
     const { WorkflowOrchestrator } = await import('../coordination/workflow-orchestrator.js');
     const { createQueenCoordinator } = await import('../coordination/queen-coordinator.js');
     const { createPersistentScheduler } = await import('./scheduler/index.js');
+    const { loadCLIDomainPlugins } = await import('./helpers/domain-plugins.js');
     context.kernel = new QEKernelImpl({
         maxConcurrentAgents: 15,
         memoryBackend: 'sqlite',
@@ -105,10 +106,11 @@ async function autoInitialize() {
         lazyLoading: true,
         enabledDomains: [...ALL_DOMAINS],
         // CLI commands are short-lived and don't benefit from the bridge's
-        // event-driven domain reactions. Skip the eager plugin-load cost.
+        // event-driven domain reactions.
         enableExperienceBridge: false,
     });
     await context.kernel.initialize();
+    const domainPlugins = await loadCLIDomainPlugins(context.kernel.plugins);
     context.router = new CrossDomainEventRouter(context.kernel.eventBus);
     await context.router.initialize();
     const getDomainAPI = (domain) => {
@@ -119,7 +121,7 @@ async function autoInitialize() {
     await context.workflowOrchestrator.initialize();
     registerDomainWorkflowActions(context.kernel, context.workflowOrchestrator);
     context.persistentScheduler = createPersistentScheduler();
-    context.queen = createQueenCoordinator(context.kernel, context.router, protocolExecutor, undefined);
+    context.queen = createQueenCoordinator(context.kernel, context.router, protocolExecutor, undefined, domainPlugins);
     await context.queen.initialize();
     // Bridge the CLI-initialized components into the MCP handlers' fleet state.
     // The memory/agent/task/team/pipeline handlers are shared between the MCP
@@ -400,12 +402,19 @@ async function main() {
         console.log(VERSION);
         process.exit(0);
     }
-    const { bootstrapTokenTracking } = await import('../init/token-bootstrap.js');
-    await bootstrapTokenTracking({
-        enableOptimization: true,
-        enablePersistence: true,
-        verbose: process.env.AQE_VERBOSE === 'true',
-    });
+    // File recovery must validate its input before anything opens, migrates, or
+    // auto-restores the project's database. Commander accepts `--` separators.
+    const commandArgs = process.argv.slice(2).filter(arg => arg !== '--');
+    const learningSnapshot = commandArgs[0] === 'learning'
+        && (commandArgs[1] === 'backup' || commandArgs[1] === 'restore');
+    if (!learningSnapshot) {
+        const { bootstrapTokenTracking } = await import('../init/token-bootstrap.js');
+        await bootstrapTokenTracking({
+            enableOptimization: true,
+            enablePersistence: true,
+            verbose: process.env.AQE_VERBOSE === 'true',
+        });
+    }
     await program.parseAsync();
     // Foreground commands own their process lifetime after command dispatch.
     if (isForegroundCommandActive())

package/dist/cli/utils/ci-config.d.ts

@@ -72,7 +72,10 @@ export interface CIRunResult {
     completedAt: Date;
     duration: number;
     phases: CIPhaseResult[];
+    /** True only when at least one gate ran and every gate passed. */
     qualityGatePassed: boolean;
+    qualityGateStatus: 'passed' | 'failed' | 'not-run';
+    qualityGateEnforced: boolean;
     overallStatus: 'passed' | 'failed' | 'warning';
     exitCode: number;
 }

package/dist/context/sources/git-source.d.ts

@@ -3,10 +3,12 @@
  */
 import type { ContextSource, ContextRequest, ContextFragment } from './types.js';
 export declare class GitContextSource implements ContextSource {
+    private readonly cwd?;
     id: string;
     name: string;
     priority: number;
     maxTokens: number;
+    constructor(cwd?: string | undefined);
     gather(request: ContextRequest): Promise<ContextFragment[]>;
 }
 //# sourceMappingURL=git-source.d.ts.map

package/dist/context/sources/git-source.js

@@ -1,17 +1,24 @@
 /**
  * Git Source - Recent commit context for target files
  */
-import { execSync } from 'child_process';
+import { execFileSync } from 'node:child_process';
 export class GitContextSource {
+    cwd;
     id = 'git';
     name = 'Git History';
     priority = 60;
     maxTokens = 1500;
+    constructor(cwd) {
+        this.cwd = cwd;
+    }
     async gather(request) {
         const fragments = [];
         for (const file of request.targetFiles.slice(0, 5)) { // Cap at 5 files
             try {
-                const log = execSync(`git log --oneline -5 -- "${file}" 2>/dev/null || true`, { encoding: 'utf-8', timeout: 5000 }).trim();
+                // filePaths can originate from MCP tool arguments. Pass each path as
+                // one argv element; interpolating it into a shell command would allow
+                // command execution via quotes or shell metacharacters.
+                const log = execFileSync('git', ['log', '--oneline', '-5', '--', file], { cwd: this.cwd ?? process.cwd(), encoding: 'utf-8', timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'] }).trim();
                 if (log) {
                     const content = `Recent commits for ${file}:\n${log}`;
                     fragments.push({

package/dist/coordination/cancelled-task-settlement.d.ts

@@ -0,0 +1,11 @@
+import type { TaskExecution } from './queen-types.js';
+/**
+ * A late domain result closes the callback boundary after cancellation, but
+ * must not replace the terminal decision or count as a normal task outcome.
+ * A settled callback does not prove that arbitrary external effects stopped.
+ */
+export declare function settleCancelledTask(tasks: Map<string, TaskExecution>, taskId: string): {
+    ignored: boolean;
+    settledNow: boolean;
+};
+//# sourceMappingURL=cancelled-task-settlement.d.ts.map

package/dist/coordination/cancelled-task-settlement.js

@@ -0,0 +1,15 @@
+/**
+ * A late domain result closes the callback boundary after cancellation, but
+ * must not replace the terminal decision or count as a normal task outcome.
+ * A settled callback does not prove that arbitrary external effects stopped.
+ */
+export function settleCancelledTask(tasks, taskId) {
+    const execution = tasks.get(taskId);
+    if (execution?.status !== 'cancelled')
+        return { ignored: false, settledNow: false };
+    if (!execution.cancellationResultPending)
+        return { ignored: true, settledNow: false };
+    tasks.set(taskId, { ...execution, cancellationResultPending: false });
+    return { ignored: true, settledNow: true };
+}
+//# sourceMappingURL=cancelled-task-settlement.js.map

package/dist/coordination/consensus/providers/claude-provider.d.ts

@@ -3,7 +3,7 @@
  * MM-003: Claude implementation for multi-model consensus verification
  *
  * Provides security finding verification using Claude models from Anthropic.
- * Supports Claude 3.5 Sonnet and Claude 3 Opus with configurable parameters.
+ * Supports current Claude models (Sonnet 5, Opus 5.5, Haiku 4.5) with configurable parameters.
  *
  * @see docs/plans/AQE_V3_IMPROVEMENTS_PLAN.md - Phase 2: Multi-Model Verification
  */
@@ -12,7 +12,7 @@ import { BaseModelProvider } from '../model-provider';
 /**
  * Claude-specific API model versions (distinct from routing ClaudeModel)
  */
-export type ClaudeAPIModel = 'claude-sonnet-4-6' | 'claude-opus-4-7' | 'claude-haiku-4-5' | 'claude-3-5-sonnet-20241022' | 'claude-3-5-sonnet-latest' | 'claude-3-opus-20240229' | 'claude-3-opus-latest';
+export type ClaudeAPIModel = 'claude-sonnet-5' | 'claude-opus-5' | 'claude-opus-5-5' | 'claude-haiku-4-5' | 'claude-sonnet-4-6' | 'claude-opus-4-7';
 /**
  * Configuration for Claude provider
  */

package/dist/coordination/consensus/providers/claude-provider.js

@@ -3,13 +3,15 @@
  * MM-003: Claude implementation for multi-model consensus verification
  *
  * Provides security finding verification using Claude models from Anthropic.
- * Supports Claude 3.5 Sonnet and Claude 3 Opus with configurable parameters.
+ * Supports current Claude models (Sonnet 5, Opus 5.5, Haiku 4.5) with configurable parameters.
  *
  * @see docs/plans/AQE_V3_IMPROVEMENTS_PLAN.md - Phase 2: Multi-Model Verification
  */
 import { toErrorMessage, toError } from '../../../shared/error-utils.js';
 import { BaseModelProvider, } from '../model-provider.js';
 import { PromptCacheLatch } from '../../../shared/prompt-cache-latch.js';
+import { getAnthropicParamPolicy } from '../../../shared/llm/anthropic-params.js';
+import { DEFAULT_SONNET_MODEL, getModelCost } from '../../../shared/llm/model-registry.js';
 // ============================================================================
 // Claude Model Provider Implementation
 // ============================================================================
@@ -34,21 +36,18 @@ export class ClaudeModelProvider extends BaseModelProvider {
     id = 'claude';
     name = 'Claude (Anthropic)';
     type = 'claude';
-    // Cost per million tokens (as of 2024)
-    // Claude 3.5 Sonnet: $3 input, $15 output per 1M tokens
-    // Claude 3 Opus: $15 input, $75 output per 1M tokens
+    // Per-token cost; set from the model registry in updateCostForModel().
     costPerToken = {
         input: 3 / 1_000_000, // Will be overridden per model
         output: 15 / 1_000_000,
     };
     supportedModels = [
+        'claude-sonnet-5',
+        'claude-opus-5',
+        'claude-opus-5-5',
+        'claude-haiku-4-5',
         'claude-sonnet-4-6',
         'claude-opus-4-7',
-        'claude-haiku-4-5',
-        'claude-3-5-sonnet-20241022',
-        'claude-3-5-sonnet-latest',
-        'claude-3-opus-20240229',
-        'claude-3-opus-latest',
     ];
     config;
     apiKey;
@@ -72,7 +71,7 @@ export class ClaudeModelProvider extends BaseModelProvider {
         this.baseUrl = config.baseUrl || process.env.ANTHROPIC_BASE_URL || 'https://api.anthropic.com';
         this.config = {
             apiKey,
-            defaultModel: config.defaultModel || 'claude-sonnet-4-6',
+            defaultModel: config.defaultModel || DEFAULT_SONNET_MODEL,
             baseUrl: this.baseUrl,
             defaultTimeout: config.defaultTimeout || 30000,
             maxRetries: config.maxRetries ?? 3,
@@ -118,7 +117,8 @@ export class ClaudeModelProvider extends BaseModelProvider {
         const request = {
             model,
             max_tokens: maxTokens,
-            temperature,
+            // Omitted for models that reject sampling params (Opus 4.7+, Sonnet 5).
+            temperature: getAnthropicParamPolicy(model).sendSampling ? temperature : undefined,
             system: systemPrompt,
             messages: [
                 {
@@ -253,20 +253,13 @@ Focus on accuracy over speed. It's better to mark something as "INCONCLUSIVE" if
      * Update cost based on model selection
      */
     updateCostForModel(model) {
-        if (model.includes('opus')) {
-            // Claude 3 Opus: $15 input, $75 output per 1M tokens
-            this.costPerToken = {
-                input: 15 / 1_000_000,
-                output: 75 / 1_000_000,
-            };
-        }
-        else {
-            // Claude 3.5 Sonnet: $3 input, $15 output per 1M tokens
-            this.costPerToken = {
-                input: 3 / 1_000_000,
-                output: 15 / 1_000_000,
-            };
-        }
+        // Registry pricing; unknown models fall back to Sonnet-class pricing.
+        const cost = getModelCost(model);
+        const known = cost.inputCostPerMillion > 0 || cost.outputCostPerMillion > 0;
+        this.costPerToken = {
+            input: (known ? cost.inputCostPerMillion : 3) / 1_000_000,
+            output: (known ? cost.outputCostPerMillion : 15) / 1_000_000,
+        };
     }
     /**
      * Sleep for specified milliseconds