agentic-qe 3.14.3 → 3.14.5

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

@@ -18,6 +18,17 @@ import { toErrorMessage } from '../../shared/error-utils.js';
 // Helpers
 // ============================================================================
 const VALID_PLATFORM_IDS = Object.keys(PLATFORM_REGISTRY);
+// Literal import paths let esbuild include every installer in the shipped CLI.
+const PLATFORM_INSTALLERS = {
+    copilot: () => import('../../init/copilot-installer.js'),
+    cursor: () => import('../../init/cursor-installer.js'),
+    cline: () => import('../../init/cline-installer.js'),
+    kilocode: () => import('../../init/kilocode-installer.js'),
+    roocode: () => import('../../init/roocode-installer.js'),
+    codex: () => import('../../init/codex-installer.js'),
+    windsurf: () => import('../../init/windsurf-installer.js'),
+    continuedev: () => import('../../init/continuedev-installer.js'),
+};
 function isValidPlatformId(name) {
     return VALID_PLATFORM_IDS.includes(name);
 }
@@ -205,8 +216,8 @@ export function createPlatformCommand() {
         console.log(chalk.gray('  ─────────────────────────────────'));
         console.log('');
         try {
-            // Dynamic import of the installer
-            const installerModule = await import(`../../init/${name}-installer.js`);
+            // Load the selected installer from a statically declared import.
+            const installerModule = await PLATFORM_INSTALLERS[name]();
             // Resolve the factory function name: create<Name>Installer
             const factoryName = `create${name.charAt(0).toUpperCase()}${name.slice(1).replace(/([a-z])([A-Z])/g, '$1$2')}Installer`;
             // Find the factory function (try common naming patterns)
@@ -267,10 +278,12 @@ export function createPlatformCommand() {
                         console.log(chalk.red(`    ${err}`));
                     }
                 }
+                process.exit(1);
             }
         }
         catch (error) {
             console.log(chalk.red(`  Failed to set up ${platform.name}: ${toErrorMessage(error)}`));
+            process.exit(1);
         }
         console.log('');
     });

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

@@ -2,9 +2,9 @@
  * `aqe upgrade` — read-only advisory
  *
  * Detects which optional native bindings load on this platform and prints a
- * report with recommendations. Does NOT modify feature flags, env vars, or
- * config files — it only tells the user what they'd gain by installing the
- * missing optional deps.
+ * report with recommendations. It reports the effective runtime flags after
+ * CLI startup applies environment overrides, but does not persist changes to
+ * environment variables or config files.
  *
  * Related: issue #383 item 2.
  */

package/dist/cli/commands/upgrade.js

@@ -2,9 +2,9 @@
  * `aqe upgrade` — read-only advisory
  *
  * Detects which optional native bindings load on this platform and prints a
- * report with recommendations. Does NOT modify feature flags, env vars, or
- * config files — it only tells the user what they'd gain by installing the
- * missing optional deps.
+ * report with recommendations. It reports the effective runtime flags after
+ * CLI startup applies environment overrides, but does not persist changes to
+ * environment variables or config files.
  *
  * Related: issue #383 item 2.
  */

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/init-handler.d.ts

@@ -70,6 +70,16 @@ export interface InitJsonOutput {
             policy: 'full' | 'compact' | 'none';
             ownedBytes: number;
         };
+        codexComponents?: {
+            hooks: {
+                status: string;
+                error?: string;
+            };
+            skills: {
+                status: string;
+                error?: string;
+            };
+        };
     };
     totalDurationMs: number;
     timestamp: string;

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

@@ -5,6 +5,7 @@
  */
 import chalk from 'chalk';
 import { getStatusColor, formatDuration, } from './interfaces.js';
+import { ALL_DOMAINS, isDomainName } from '../../shared/types/index.js';
 import { createTimedSpinner } from '../utils/progress.js';
 import { parseJsonOption } from '../helpers/safe-json.js';
 import { writeOutput, toJSON } from '../utils/ci-output.js';
@@ -32,7 +33,7 @@ export class TaskHandler {
             .option('-d, --domain <domain>', 'Target domain')
             .option('-t, --timeout <ms>', 'Task timeout in ms', '300000')
             .option('--payload <json>', 'Task payload as JSON', '{}')
-            .option('--wait', 'Wait for task completion with progress')
+            .option('--wait', 'Wait for task completion (required: CLI tasks are not persisted)')
             .option('--no-progress', 'Disable progress indicator')
             .action(async (type, options) => {
             await this.executeSubmit(type, options, context);
@@ -67,8 +68,27 @@ export class TaskHandler {
         });
     }
     async executeSubmit(type, options, context) {
+        // #734 D: reject an unknown domain up front instead of accepting work that
+        // no domain will ever run.
+        if (options.domain !== undefined && !isDomainName(options.domain)) {
+            console.error(chalk.red(`\n  Unknown domain: ${options.domain}`));
+            console.error(chalk.gray(`  Valid domains: ${ALL_DOMAINS.join(', ')}\n`));
+            return this.cleanupAndExit(1);
+        }
+        // #734 C: a CLI-submitted task runs inside this process and is not
+        // persisted, so a detached submit would report an ID for work that is
+        // abandoned when the command exits. Refuse it rather than claim success.
+        if (!options.wait) {
+            console.error(chalk.red('\n  Detached task submission is not supported.'));
+            console.error(chalk.gray('  Tasks submitted from the CLI run inside this process and are not persisted;'));
+            console.error(chalk.gray('  the task would be abandoned when the command exits, and `aqe task status`'));
+            console.error(chalk.gray('  from another process could not find it.'));
+            console.error(chalk.gray('  Re-run with --wait to execute the task and report its result, or submit it'));
+            console.error(chalk.gray('  through the MCP server (task_submit), which keeps a long-lived coordinator.\n'));
+            return this.cleanupAndExit(1);
+        }
         if (!await this.ensureInitialized())
-            return;
+            return this.cleanupAndExit(1);
         try {
             const taskType = type;
             const payload = parseJsonOption(options.payload, 'payload');
@@ -112,9 +132,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 +147,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 +164,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 +177,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 +212,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 +232,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 +245,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 +264,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}`);
@@ -284,7 +314,8 @@ Submit Options:
   -d, --domain <domain>       Target domain
   -t, --timeout <ms>          Task timeout in milliseconds (default: 300000)
   --payload <json>            Task payload as JSON
-  --wait                      Wait for task completion with progress
+  --wait                      Wait for task completion (required; CLI-submitted
+                              tasks run in this process and are not persisted)
   --no-progress               Disable progress indicator
 
 List Options:
@@ -293,7 +324,7 @@ List Options:
   -d, --domain <domain>       Filter by domain
 
 Examples:
-  aqe task submit generate-tests --domain test-generation
+  aqe task submit generate-tests --domain test-generation --wait
   aqe task submit analyze-coverage --wait --timeout 60000
   aqe task list --status running
   aqe task status task-123

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/helpers/standalone-memory.d.ts

@@ -0,0 +1,12 @@
+import type { CLIContext } from '../handlers/interfaces.js';
+/**
+ * Build the readiness check for `aqe memory` subcommands.
+ *
+ * Memory operations only need the project memory backend, so this opens
+ * .agentic-qe/memory.db directly instead of booting the full v3 system
+ * (kernel, Queen Coordinator, every domain coordinator, SONA engines,
+ * DreamScheduler). If a fleet is already running in this process, its kernel
+ * memory is used as before.
+ */
+export declare function createEnsureMemoryBackend(context: CLIContext): () => Promise<boolean>;
+//# sourceMappingURL=standalone-memory.d.ts.map

package/dist/cli/helpers/standalone-memory.js

@@ -0,0 +1,46 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import chalk from 'chalk';
+import { toErrorMessage } from '../../shared/error-utils.js';
+/**
+ * Build the readiness check for `aqe memory` subcommands.
+ *
+ * Memory operations only need the project memory backend, so this opens
+ * .agentic-qe/memory.db directly instead of booting the full v3 system
+ * (kernel, Queen Coordinator, every domain coordinator, SONA engines,
+ * DreamScheduler). If a fleet is already running in this process, its kernel
+ * memory is used as before.
+ */
+export function createEnsureMemoryBackend(context) {
+    let ready = null;
+    const open = async () => {
+        try {
+            const [{ findProjectRoot }, { createKernelMemoryBackend }, { setStandaloneMemoryBackend }] = await Promise.all([
+                import('../../kernel/project-root.js'),
+                import('../../kernel/hybrid-backend.js'),
+                import('../../mcp/handlers/memory-handlers.js'),
+            ]);
+            // Same data directory the kernel resolves when auto-initializing.
+            const dataDir = path.join(findProjectRoot(), '.agentic-qe');
+            fs.mkdirSync(dataDir, { recursive: true });
+            const backend = createKernelMemoryBackend(dataDir);
+            await backend.initialize();
+            setStandaloneMemoryBackend(backend);
+            return true;
+        }
+        catch (error) {
+            console.error(chalk.red(`  Failed to open memory store: ${toErrorMessage(error)}`));
+            // Callers `return` on false; main() then exits with this code, matching
+            // ensureInitialized()'s failure path (#758).
+            process.exitCode = 1;
+            return false;
+        }
+    };
+    return () => {
+        if (context.initialized)
+            return Promise.resolve(true);
+        ready ??= open();
+        return ready;
+    };
+}
+//# sourceMappingURL=standalone-memory.js.map

package/dist/cli/index.js

@@ -10,47 +10,18 @@
  * See: cli/commands/ for additional command modules
  */
 import { toErrorMessage } from '../shared/error-utils.js';
+import { initFeatureFlagsFromEnv } from '../integrations/ruvector/feature-flags.js';
 import { createRequire } from 'node:module';
 import { Command } from 'commander';
 import chalk from 'chalk';
 import { ALL_DOMAINS } from '../shared/types/index.js';
 // ============================================================================
-// Redirect internal domain logs to stderr so stdout stays clean for CI/JSON
+// Route internal diagnostics to stderr, filtered by AQE_LOG_LEVEL / LOG_LEVEL /
+// AQE_VERBOSE (default: warn), so stdout stays clean for CI/JSON.
 // ============================================================================
-const INTERNAL_LOG_PREFIXES = [
-    '[UnifiedMemory]', '[HybridBackend]', '[UnifiedPersistence]',
-    '[PersistentSONAEngine]', '[QueenGovernance]', '[QueenCoordinator]',
-    '[Queen]', '[QUEEN]', '[DomainBreakerRegistry]',
-    '[RealEmbeddings]', '[HNSWIndex]', '[PatternStore]',
-    '[TestGenerationCoordinator]', '[CodeIntelligence]', '[ProductFactorsBridge]',
-    '[LearningOptimizationCoordinator]', '[DreamEngine]', '[DreamScheduler]',
-    '[SecurityCompliance]', '[Providers]', '[GNN]',
-    '[test-generation]', '[test-execution]', '[coverage-analysis]',
-    '[quality-assessment]', '[defect-intelligence]', '[requirements-validation]',
-    '[code-intelligence]', '[security-compliance]', '[contract-testing]',
-    '[visual-accessibility]', '[chaos-resilience]', '[learning-optimization]',
-    '[enterprise-integration]', '[coordination]', '[PatternLearnerService]',
-    '[RequirementsValidation]', '[ParserRegistry]', '[AdversarialDefense]',
-    '[ContinueGateIntegration]', '[ContinueGate]', '[SQLitePatternStore]',
-    '[TokenTracking]', '[InfraHealing]', '[ExperienceCapture]',
-];
-/** Timestamped log pattern: [HH:MM:SS.sss] [LEVEL] */
-const TIMESTAMPED_LOG_RE = /^\[\d{2}:\d{2}:\d{2}\.\d{3}\]\s+\[/;
-const originalConsoleLog = console.log.bind(console);
-console.log = (...args) => {
-    const first = typeof args[0] === 'string' ? args[0] : '';
-    const trimmed = first.trimStart();
-    if (INTERNAL_LOG_PREFIXES.some(prefix => trimmed.startsWith(prefix)) ||
-        TIMESTAMPED_LOG_RE.test(trimmed)) {
-        process.stderr.write(args.map(String).join(' ') + '\n');
-        return;
-    }
-    originalConsoleLog(...args);
-};
-// Also redirect timestamped INFO/WARN/ERROR log lines (e.g. "[07:12:24.372] [INFO ]")
-console.info = (...args) => {
-    process.stderr.write(args.map(String).join(' ') + '\n');
-};
+import { applyCommandVerbosity, installCliLogGate, isCliLogLevelEnabled } from './log-gate.js';
+import { LogLevel } from '../logging/index.js';
+installCliLogGate();
 // ============================================================================
 // CLI State
 // ============================================================================
@@ -98,6 +69,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 +77,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 +92,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
@@ -142,10 +115,12 @@ async function ensureInitializedStrict() {
     // For diagnostic commands: check if project was explicitly initialized
     const fs = await import('fs');
     const path = await import('path');
-    const configDir = path.resolve('.agentic-qe');
+    const { findProjectRoot } = await import('../kernel/project-root.js');
+    const configDir = path.join(findProjectRoot(), '.agentic-qe');
     if (!fs.existsSync(configDir)) {
         console.error(chalk.red('\nError: AQE system not initialized in this directory.'));
         console.log(chalk.yellow('Run `aqe init` first to set up this project.\n'));
+        process.exitCode = 1;
         return false;
     }
     return ensureInitialized();
@@ -154,14 +129,19 @@ async function ensureInitialized() {
     if (context.initialized && context.kernel && context.queen) {
         return true;
     }
-    process.stderr.write(chalk.gray('Auto-initializing v3 system...') + '\n');
+    const showProgress = isCliLogLevelEnabled(LogLevel.INFO);
+    if (showProgress) {
+        process.stderr.write(chalk.gray('Auto-initializing v3 system...') + '\n');
+    }
     const timeout = 30000;
     const timeoutPromise = new Promise((_, reject) => {
         setTimeout(() => reject(new Error('Initialization timeout after 30 seconds')), timeout);
     });
     try {
         await Promise.race([autoInitialize(), timeoutPromise]);
-        process.stderr.write(chalk.green('System ready') + '\n\n');
+        if (showProgress) {
+            process.stderr.write(chalk.green('System ready') + '\n\n');
+        }
         return true;
     }
     catch (err) {
@@ -174,6 +154,8 @@ async function ensureInitialized() {
             console.error(chalk.red('Failed to auto-initialize:'), err);
             console.log(chalk.yellow('Try running `aqe init` manually.'));
         }
+        // Callers `return` on false; main() then exits with this code (#758).
+        process.exitCode = 1;
         return false;
     }
 }
@@ -214,7 +196,18 @@ const VERSION = typeof __CLI_VERSION__ !== 'undefined' ? __CLI_VERSION__ : packa
 program
     .name('aqe')
     .description('Agentic QE - Domain-Driven Quality Engineering')
-    .version(VERSION);
+    .version(VERSION)
+    .addHelpText('after', `
+Environment:
+  AQE_LOG_LEVEL   Internal log level: debug | info | warn | error | silent (default: warn)
+  LOG_LEVEL       Same as AQE_LOG_LEVEL; AQE_LOG_LEVEL takes precedence
+  AQE_VERBOSE=1   Shorthand for info-level logging (full system-init output)
+Diagnostics are written to stderr; stdout carries command output only.`);
+// A command's own --verbose flag (aqe sync|status|workflow|eval ... --verbose)
+// raises the log gate to INFO for that run; AQE_LOG_LEVEL / LOG_LEVEL win.
+program.hook('preAction', (_thisCommand, actionCommand) => {
+    applyCommandVerbosity(actionCommand.opts());
+});
 // ============================================================================
 // Register Handlers (lazy — each handler loads only when its command runs)
 // ============================================================================
@@ -336,7 +329,11 @@ registerLazyCommand(program, {
 registerLazyCommand(program, {
     name: 'memory',
     description: 'Memory store, retrieve, search, and delete operations',
-    factory: () => import('./commands/memory.js').then(m => m.createMemoryCommand(context, cleanupAndExit, ensureInitialized)),
+    // Memory subcommands open only the memory store, not the full v3 system.
+    factory: () => Promise.all([
+        import('./commands/memory.js'),
+        import('./helpers/standalone-memory.js'),
+    ]).then(([m, h]) => m.createMemoryCommand(context, cleanupAndExit, h.createEnsureMemoryBackend(context))),
 });
 registerLazyCommand(program, {
     name: 'mcp',
@@ -400,19 +397,27 @@ 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',
-    });
+    initFeatureFlagsFromEnv();
+    // 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())
         return;
     // If the command didn't explicitly exit, clean up and exit now.
     // This prevents process hangs from active handles (domain init, embeddings, etc.)
-    await cleanupAndExit(0);
+    await cleanupAndExit(process.exitCode ?? 0);
 }
 main().catch(async (error) => {
     console.error(chalk.red('Fatal error:'), error);

package/dist/cli/log-gate.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Agentic QE v3 - CLI Log Gate
+ *
+ * Single place that decides how much internal diagnostic output a CLI
+ * invocation prints. Two kinds of diagnostics exist in the codebase:
+ *
+ *   1. Structured logger output (LoggerFactory / ConsoleLogger), formatted as
+ *      "[HH:MM:SS.mmm] [INFO ] [domain] message".
+ *   2. Ad-hoc console calls with a bracketed tag, e.g.
+ *      console.log('[UnifiedMemory] Initialized: ...').
+ *
+ * Both are routed to stderr (stdout stays clean for JSON/CI consumers) and
+ * filtered against one threshold resolved from the environment:
+ *
+ *   AQE_LOG_LEVEL  debug | info | warn | error | silent   (highest precedence)
+ *   LOG_LEVEL      same values
+ *   AQE_VERBOSE    1 | true | yes | on  -> info
+ *   (default)      warn
+ *
+ * Regular command output (anything without a bracketed tag) is never touched.
+ */
+import { LogLevel } from '../logging/index.js';
+type ConsoleMethod = 'log' | 'info' | 'debug' | 'warn' | 'error';
+type ConsoleLike = Pick<Console, ConsoleMethod>;
+/** Default threshold for CLI commands when nothing is configured. */
+export declare const DEFAULT_CLI_LOG_LEVEL = LogLevel.WARN;
+/**
+ * Resolve the effective CLI log level from the environment.
+ * Unrecognised values are ignored rather than silently mapped to INFO.
+ */
+export declare function resolveCliLogLevel(env?: NodeJS.ProcessEnv, defaultLevel?: LogLevel): LogLevel;
+/**
+ * Classify a console call. Returns the diagnostic level of the line, or null
+ * when the line is regular command output that must pass through untouched.
+ */
+export declare function classifyConsoleLine(method: ConsoleMethod, firstArg: unknown): LogLevel | null;
+/** True when AQE_LOG_LEVEL or LOG_LEVEL holds a recognised level. */
+export declare function hasExplicitCliLogLevel(env?: NodeJS.ProcessEnv): boolean;
+/**
+ * Honour a command's own `--verbose` flag (e.g. `aqe sync --verbose`): raise
+ * the threshold to INFO so the diagnostics the user explicitly asked for are
+ * printed (on stderr). An explicit AQE_LOG_LEVEL / LOG_LEVEL still wins.
+ * Returns true when the level was raised.
+ */
+export declare function applyCommandVerbosity(options: Record<string, unknown>, env?: NodeJS.ProcessEnv): boolean;
+/** Current CLI log threshold. */
+export declare function getCliLogLevel(): LogLevel;
+/** True when diagnostics at `level` should be printed. */
+export declare function isCliLogLevelEnabled(level: LogLevel): boolean;
+/**
+ * Change the threshold at runtime. Also reconfigures LoggerFactory so loggers
+ * created afterwards filter at the source instead of relying on the gate.
+ */
+export declare function setCliLogLevel(level: LogLevel): void;
+export interface InstallCliLogGateOptions {
+    level?: LogLevel;
+    target?: ConsoleLike;
+    writeStderr?: (text: string) => void;
+}
+/**
+ * Patch the console so internal diagnostics are routed to stderr and filtered
+ * by the CLI log level. Returns a function that restores the original methods.
+ */
+export declare function installCliLogGate(options?: InstallCliLogGateOptions): () => void;
+export {};
+//# sourceMappingURL=log-gate.d.ts.map