agentic-qe 3.14.4 → 3.14.5

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,6 +68,25 @@ 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 this.cleanupAndExit(1);
         try {
@@ -294,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:
@@ -303,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/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
 // ============================================================================
@@ -144,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();
@@ -156,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) {
@@ -176,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;
     }
 }
@@ -216,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)
 // ============================================================================
@@ -338,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',
@@ -402,6 +397,7 @@ async function main() {
         console.log(VERSION);
         process.exit(0);
     }
+    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 !== '--');
@@ -421,7 +417,7 @@ async function main() {
         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

package/dist/cli/log-gate.js

@@ -0,0 +1,170 @@
+/**
+ * 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 { format } from 'node:util';
+import { LogLevel, LoggerFactory } from '../logging/index.js';
+/** Default threshold for CLI commands when nothing is configured. */
+export const DEFAULT_CLI_LOG_LEVEL = LogLevel.WARN;
+const LEVEL_NAMES = {
+    debug: LogLevel.DEBUG,
+    info: LogLevel.INFO,
+    warn: LogLevel.WARN,
+    warning: LogLevel.WARN,
+    error: LogLevel.ERROR,
+    silent: LogLevel.SILENT,
+    none: LogLevel.SILENT,
+    off: LogLevel.SILENT,
+};
+const TRUTHY = new Set(['1', 'true', 'yes', 'on']);
+// eslint-disable-next-line no-control-regex
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+/** "[10:01:10.407] [INFO ] ..." or "[2026-09-28T10:01:10.407Z] [WARN ] ..." */
+const STRUCTURED_RE = /^\[(?:\d{2}:\d{2}:\d{2}\.\d{3}|\d{4}-\d{2}-\d{2}T[^\]]+)\]\s+\[(DEBUG|INFO|WARN|ERROR)\s*\]/;
+/**
+ * "[UnifiedMemory] ...", "[sona-three-loop] ...", "[quality-assessment/rl] ...".
+ * Requires a letter first and whitespace after the closing bracket so JSON
+ * arrays such as '["a"]' or '[true]' are never mistaken for diagnostics.
+ *
+ * Only a tag at column 0 counts. Indented bracketed text is command output:
+ * severity markers ("    [critical] Code Injection ..." from `aqe security`,
+ * "  [high] ..." from `aqe status` / `aqe coverage`) and user data such as a
+ * stored memory value "[TODO] fix auth" printed by `aqe memory get`.
+ */
+const TAGGED_RE = /^\[[A-Za-z][\w./:-]*\]\s/;
+const TAG_METHOD_LEVEL = {
+    debug: LogLevel.DEBUG,
+    log: LogLevel.INFO,
+    info: LogLevel.INFO,
+    warn: LogLevel.WARN,
+    error: LogLevel.ERROR,
+};
+let currentLevel = DEFAULT_CLI_LOG_LEVEL;
+function parseLevel(value) {
+    if (!value)
+        return undefined;
+    return LEVEL_NAMES[value.trim().toLowerCase()];
+}
+/**
+ * Resolve the effective CLI log level from the environment.
+ * Unrecognised values are ignored rather than silently mapped to INFO.
+ */
+export function resolveCliLogLevel(env = process.env, defaultLevel = DEFAULT_CLI_LOG_LEVEL) {
+    const explicit = parseLevel(env.AQE_LOG_LEVEL) ?? parseLevel(env.LOG_LEVEL);
+    if (explicit !== undefined)
+        return explicit;
+    if (env.AQE_VERBOSE && TRUTHY.has(env.AQE_VERBOSE.trim().toLowerCase())) {
+        return LogLevel.INFO;
+    }
+    return defaultLevel;
+}
+/**
+ * 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 function classifyConsoleLine(method, firstArg) {
+    if (typeof firstArg !== 'string')
+        return null;
+    const text = firstArg.replace(ANSI_RE, '');
+    const structured = STRUCTURED_RE.exec(text.trimStart());
+    if (structured) {
+        return LEVEL_NAMES[structured[1].toLowerCase()];
+    }
+    if (TAGGED_RE.test(text)) {
+        return TAG_METHOD_LEVEL[method];
+    }
+    return null;
+}
+/** True when AQE_LOG_LEVEL or LOG_LEVEL holds a recognised level. */
+export function hasExplicitCliLogLevel(env = process.env) {
+    return parseLevel(env.AQE_LOG_LEVEL) !== undefined || parseLevel(env.LOG_LEVEL) !== undefined;
+}
+/**
+ * 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 function applyCommandVerbosity(options, env = process.env) {
+    if (options.verbose !== true || hasExplicitCliLogLevel(env))
+        return false;
+    if (isCliLogLevelEnabled(LogLevel.INFO))
+        return false;
+    setCliLogLevel(LogLevel.INFO);
+    return true;
+}
+/** Current CLI log threshold. */
+export function getCliLogLevel() {
+    return currentLevel;
+}
+/** True when diagnostics at `level` should be printed. */
+export function isCliLogLevelEnabled(level) {
+    return level >= currentLevel && currentLevel !== LogLevel.SILENT;
+}
+/**
+ * Change the threshold at runtime. Also reconfigures LoggerFactory so loggers
+ * created afterwards filter at the source instead of relying on the gate.
+ */
+export function setCliLogLevel(level) {
+    currentLevel = level;
+    LoggerFactory.setLevel(level);
+}
+/**
+ * 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 function installCliLogGate(options = {}) {
+    const target = options.target ?? console;
+    const writeStderr = options.writeStderr ?? ((text) => { process.stderr.write(text); });
+    setCliLogLevel(options.level ?? resolveCliLogLevel());
+    const original = {
+        log: target.log.bind(target),
+        info: target.info.bind(target),
+        debug: target.debug.bind(target),
+        warn: target.warn.bind(target),
+        error: target.error.bind(target),
+    };
+    const toStderr = (args) => writeStderr(format(...args) + '\n');
+    const gate = (method, passthrough, emit) => (...args) => {
+        const level = classifyConsoleLine(method, args[0]);
+        if (level === null) {
+            passthrough(args);
+        }
+        else if (isCliLogLevelEnabled(level)) {
+            emit(args);
+        }
+    };
+    // log/debug output normally goes to stdout; diagnostics are moved to stderr.
+    target.log = gate('log', args => original.log(...args), toStderr);
+    target.debug = gate('debug', args => original.debug(...args), toStderr);
+    // console.info has always been redirected to stderr by the CLI.
+    target.info = gate('info', toStderr, toStderr);
+    // warn/error already target stderr; keep their native formatting.
+    target.warn = gate('warn', args => original.warn(...args), args => original.warn(...args));
+    target.error = gate('error', args => original.error(...args), args => original.error(...args));
+    return () => {
+        target.log = original.log;
+        target.info = original.info;
+        target.debug = original.debug;
+        target.warn = original.warn;
+        target.error = original.error;
+    };
+}
+//# sourceMappingURL=log-gate.js.map

package/dist/init/codex-installer.js

@@ -9,6 +9,7 @@ import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSyn
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { toErrorMessage } from '../shared/error-utils.js';
+import { findPackageRoot } from './find-package-root.js';
 import { selectCodexSkills } from './codex-skill-manifest.js';
 import { createPlatformConfigGenerator, } from './platform-config-generator.js';
 export const CODEX_COMPACT_GUIDANCE_MAX_BYTES = 512;
@@ -111,7 +112,7 @@ export class CodexInstaller {
                 result.ownedGuidanceBytes = Buffer.byteLength(marked);
                 result.components.rules.status = 'installed';
             }
-            else if (this.overwrite || policy === 'compact') {
+            else {
                 const content = policy === 'compact' ? COMPACT_CODEX_GUIDANCE : rules.content;
                 const existing = readFileSync(agentsMdPath, 'utf-8');
                 const merged = this.mergeExistingAgentsMdContent(existing, content);
@@ -125,10 +126,6 @@ export class CodexInstaller {
                 }
                 result.ownedGuidanceBytes = this.measureOwnedAgentsSection(merged);
             }
-            else {
-                result.components.rules.status = 'preserved';
-                result.ownedGuidanceBytes = this.measureOwnedAgentsSection(readFileSync(agentsMdPath, 'utf-8'));
-            }
         }
         catch (error) {
             this.recordComponentFailure(result, 'rules', error);
@@ -147,6 +144,13 @@ export class CodexInstaller {
         catch (error) {
             this.recordComponentFailure(result, 'skills', error);
         }
+        for (const component of ['hooks', 'skills']) {
+            if (result.components[component].status === 'unavailable') {
+                const message = `Codex ${component} unavailable: packaged assets could not be located`;
+                result.components[component].error = message;
+                result.errors.push(message);
+            }
+        }
         result.success = result.errors.length === 0;
         return result;
     }
@@ -297,6 +301,11 @@ export class CodexInstaller {
         }
     }
     resolvePackageRoot() {
+        // Bundled chunks retain their real package location even when npm's aqe
+        // bin is a symlink in a global prefix.
+        const packagedRoot = findPackageRoot(import.meta.url);
+        if (packagedRoot)
+            return packagedRoot;
         const moduleDir = dirname(fileURLToPath(import.meta.url));
         const candidates = [
             join(moduleDir, '..', '..'),
@@ -348,7 +357,10 @@ export class CodexInstaller {
             return merged;
         if (existing.length === 0)
             return marked;
-        return existing.trimEnd() + `${eol}${eol}---${eol}${eol}` + marked;
+        // The owned block starts at the original EOF. Keeping every pre-existing
+        // byte outside the sentinel lets `none` remove the block exactly, even
+        // when the user's file has no trailing newline.
+        return existing + marked;
     }
     removeOwnedAgentsSections(existing) {
         this.assertOwnedAgentsSectionsWellFormed(existing);

package/dist/init/orchestrator.js

@@ -158,6 +158,7 @@ export class ModularInitOrchestrator {
                 claudeMdGenerated: claudeMdResult?.data?.generated ?? false,
                 workersStarted: workersResult?.data?.workersConfigured ?? 0,
                 codexGuidance: assetsResult?.data?.codexGuidance,
+                codexComponents: assetsResult?.data?.codexComponents,
             },
             totalDurationMs: Date.now() - startTime,
             timestamp: new Date(),

package/dist/init/phases/09-assets.d.ts

@@ -20,6 +20,16 @@ export interface AssetsResult {
         policy: 'full' | 'compact' | 'none';
         ownedBytes: number;
     };
+    codexComponents?: {
+        hooks: {
+            status: string;
+            error?: string;
+        };
+        skills: {
+            status: string;
+            error?: string;
+        };
+    };
 }
 /**
  * Assets phase - installs skills and agents

package/dist/init/phases/09-assets.js

@@ -37,6 +37,7 @@ export class AssetsPhase extends BasePhase {
         let kiroSkills = 0;
         let kiroHooks = 0;
         let codexGuidance;
+        let codexComponents;
         if (options.upgrade) {
             context.services.log(`  Upgrade mode: overwriting existing files`);
         }
@@ -303,6 +304,7 @@ export class AssetsPhase extends BasePhase {
             });
             const res = await installer.install();
             codexGuidance = { policy: res.guidancePolicy, ownedBytes: res.ownedGuidanceBytes };
+            codexComponents = { hooks: res.components.hooks, skills: res.components.skills };
             if (res.mcpConfigured)
                 platformsConfigured.push('codex');
             if (res.errors.length > 0)
@@ -361,6 +363,7 @@ export class AssetsPhase extends BasePhase {
             platformsConfigured,
             browserEngine,
             codexGuidance,
+            codexComponents,
         };
     }
     /**

package/dist/init/token-bootstrap.d.ts

@@ -13,7 +13,7 @@ export interface TokenBootstrapConfig {
     enableOptimization: boolean;
     /** Enable persistence (default: true) */
     enablePersistence: boolean;
-    /** Storage directory for metrics (default: .aqe) */
+    /** Storage directory for metrics (default: <project>/.agentic-qe) */
     storagePath: string;
     /** Auto-save interval in ms (default: 60000 = 1 minute) */
     autoSaveIntervalMs: number;