agentic-qe 3.13.3 → 3.13.5

package/dist/domains/test-generation/generators/jest-vitest-generator.js

@@ -214,16 +214,6 @@ ${importStatement}
                     code += `      expect(() => instance.${method.name}(${paramsWithUndefined})).toThrow();\n`;
                     code += `    });\n`;
                 }
-                else {
-                    // Use try-catch to handle both throwing (TypeError from property access) and non-throwing
-                    code += `\n    it('should handle undefined ${param.name}', ${asyncPrefix}() => {\n`;
-                    code += `      try {\n`;
-                    code += `        ${method.isAsync ? 'await ' : ''}instance.${method.name}(${paramsWithUndefined});\n`;
-                    code += `      } catch (e) {\n`;
-                    code += `        expect(e).toBeInstanceOf(Error);\n`;
-                    code += `      }\n`;
-                    code += `    });\n`;
-                }
             }
         }
         code += `  });\n\n`;
@@ -235,9 +225,10 @@ ${importStatement}
     generateStubTests(context) {
         const { moduleName, importPath, testType, patterns, dependencies, similarCode } = context;
         const patternComment = this.generatePatternComment(patterns);
-        const basicOpsTest = this.generateBasicOpsTest(moduleName, patterns);
-        const edgeCaseTest = this.generateEdgeCaseTest(moduleName, patterns);
-        const errorHandlingTest = this.generateErrorHandlingTest(moduleName, patterns);
+        const moduleIdentifier = 'moduleUnderTest';
+        const basicOpsTest = this.generateBasicOpsTest(moduleIdentifier, patterns);
+        const edgeCaseTest = this.generateEdgeCaseTest(moduleIdentifier, patterns);
+        const errorHandlingTest = this.generateErrorHandlingTest(moduleIdentifier, patterns);
         // KG: Generate mock declarations for external (non-relative) dependencies only
         let mockDeclarations = '';
         if (dependencies && dependencies.imports.length > 0) {
@@ -264,9 +255,9 @@ ${importStatement}
         if (dependencies && dependencies.imports.length > 0) {
             depTest += `\n    it('should interact with dependencies correctly', () => {\n`;
             depTest += `      // KG-informed: module depends on ${dependencies.imports.length} imports\n`;
-            depTest += `      const instance = typeof ${moduleName} === 'function'\n`;
-            depTest += `        ? new ${moduleName}()\n`;
-            depTest += `        : ${moduleName};\n`;
+            depTest += `      const instance = typeof ${moduleIdentifier} === 'function'\n`;
+            depTest += `        ? new ${moduleIdentifier}()\n`;
+            depTest += `        : ${moduleIdentifier};\n`;
             depTest += `      expect(instance).toBeDefined();\n`;
             depTest += `    });\n`;
         }
@@ -275,21 +266,21 @@ ${importStatement}
         if (dependencies && dependencies.importedBy.length > 0) {
             callerTest += `\n    it('should expose stable API for ${dependencies.importedBy.length} consumers', () => {\n`;
             callerTest += `      // KG-informed: used by ${dependencies.importedBy.slice(0, 3).join(', ')}\n`;
-            callerTest += `      const publicKeys = Object.keys(typeof ${moduleName} === 'function'\n`;
-            callerTest += `        ? ${moduleName}.prototype || {}\n`;
-            callerTest += `        : ${moduleName});\n`;
+            callerTest += `      const publicKeys = Object.keys(typeof ${moduleIdentifier} === 'function'\n`;
+            callerTest += `        ? ${moduleIdentifier}.prototype || {}\n`;
+            callerTest += `        : ${moduleIdentifier});\n`;
             callerTest += `      expect(publicKeys.length).toBeGreaterThan(0);\n`;
             callerTest += `    });\n`;
         }
         const stubImportSource = this.framework === 'vitest' ? 'vitest' : '@jest/globals';
         const stubMockImport = this.framework === 'vitest' ? ', vi' : ', jest';
-        return `${patternComment}import { describe, it, expect, beforeEach${stubMockImport} } from '${stubImportSource}';
-import { ${moduleName} } from '${importPath}';
-${mockDeclarations}
-describe('${moduleName}', () => {
-${similarityComment}  describe('${testType} tests', () => {
-    it('should be defined', () => {
-      expect(${moduleName}).toBeDefined();
+        return `${patternComment}import { describe, it, expect, beforeEach${stubMockImport} } from '${stubImportSource}';
+import * as ${moduleIdentifier} from '${importPath}';
+${mockDeclarations}
+describe('${moduleName}', () => {
+${similarityComment}  describe('${testType} tests', () => {
+    it('should be defined', () => {
+      expect(${moduleIdentifier}).toBeDefined();
     });
 
 ${basicOpsTest}

package/dist/domains/test-generation/services/test-generator.js

@@ -20,6 +20,7 @@ import { TestDataGeneratorService } from './test-data-generator';
 import { toError } from '../../../shared/error-utils.js';
 import { safeJsonParse } from '../../../shared/safe-json.js';
 import { TestQualityGate } from '../gates/index.js';
+import { getGeneratedTestSyntaxIssues } from '../gates/test-quality-gate.js';
 import { EdgeCaseInjector } from '../pattern-injection/index.js';
 import { treeSitterRegistry } from '../../../shared/parsers/multi-language-parser.js';
 import { getLanguageFromExtension } from '../../../shared/types/test-frameworks.js';
@@ -127,7 +128,7 @@ export class TestGeneratorService {
      * Enhance generated test code using LLM
      * Adds edge cases, improves assertions, and adds documentation
      */
-    async enhanceTestWithLLM(testCode, sourceCode, analysis, context) {
+    async enhanceTestWithLLM(testCode, sourceCode, analysis, sourceFilePath, context) {
         if (!this.llmRouter)
             return { code: testCode, enhanced: false };
         try {
@@ -202,6 +203,10 @@ Return ONLY the enhanced test code, no explanations.`,
                 if (codeMatch) {
                     enhancedCode = codeMatch[1].trim();
                 }
+                if (getGeneratedTestSyntaxIssues(enhancedCode, sourceFilePath).length > 0) {
+                    logger.warn('LLM enhancement produced invalid syntax, using deterministic template');
+                    return { code: testCode, enhanced: false };
+                }
                 // #567: only claim enhancement when the model actually returned code.
                 // An empty/unusable response falls back to the template, and the caller
                 // must be told that is what happened.
@@ -465,7 +470,7 @@ Return a JSON array of test suggestions, each with: { "name": "test name", "desc
         // report AI-enhanced output it did not produce.
         let llmEnhanced = false;
         if (this.isLLMEnhancementAvailable() && sourceContent) {
-            const result = await this.enhanceTestWithLLM(testCode, sourceContent, codeAnalysis, context);
+            const result = await this.enhanceTestWithLLM(testCode, sourceContent, codeAnalysis, sourceFile, context);
             testCode = result.code;
             llmEnhanced = result.enhanced;
         }

package/dist/init/codex-installer.d.ts

@@ -8,6 +8,10 @@
 export interface CodexInstallerOptions {
     projectRoot: string;
     overwrite?: boolean;
+    /** Whether to install the AQE MCP server entry. Defaults to true. */
+    installMcp?: boolean;
+    /** Install optional Ruflo guidance, adapter, runtime, and lifecycle groups. */
+    includeRuflo?: boolean;
     /**
      * Memory backend for this install. 'memory' => database-free: the MCP config
      * is written to run in-memory (AQE_MEMORY_BACKEND=memory, no AQE_MEMORY_PATH). (#533)
@@ -25,14 +29,28 @@ export interface CodexInstallResult {
     agentsMdPath: string;
     hooksPath: string;
     skillsPath: string;
+    /** Per-component outcomes. Legacy booleans above remain supported. */
+    components: {
+        mcp: CodexComponentOutcome;
+        rules: CodexComponentOutcome;
+        hooks: CodexComponentOutcome;
+        skills: CodexComponentOutcome;
+    };
+}
+export interface CodexComponentOutcome {
+    status: 'installed' | 'updated' | 'preserved' | 'skipped' | 'unavailable' | 'failed';
+    error?: string;
 }
 export declare class CodexInstaller {
     private projectRoot;
     private overwrite;
     private options;
     private generator;
+    private static readonly AGENTS_START;
+    private static readonly AGENTS_END;
     constructor(options: CodexInstallerOptions);
     install(): Promise<CodexInstallResult>;
+    private recordComponentFailure;
     /**
      * Install Codex-native lifecycle adapters and merge AQE/ruflo hook groups
      * without removing user-defined hooks.
@@ -44,15 +62,16 @@ export declare class CodexInstaller {
     private resolvePackageRoot;
     /**
      * Merge AQE MCP server config into existing TOML.
-     * Simple approach: if [mcp_servers.agentic-qe] already exists, skip.
-     * Otherwise, append the AQE block at the end.
+     * Replace only AQE-owned TOML tables, preserving every user-owned table and
+     * setting. AQE owns the exact `mcp_servers.agentic-qe` table prefix.
      */
     private mergeExistingTomlConfig;
     /**
      * Merge AQE section into existing AGENTS.md.
-     * Appends the AQE section if not already present.
+     * Replaces a previously marked AQE section or appends a new marked section.
      */
     private mergeExistingAgentsMd;
+    private markAgentsSection;
 }
 export declare function createCodexInstaller(options: CodexInstallerOptions): CodexInstaller;
 //# sourceMappingURL=codex-installer.d.ts.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 { selectCodexSkills } from './codex-skill-manifest.js';
 import { createPlatformConfigGenerator, } from './platform-config-generator.js';
 // ============================================================================
 // Codex Installer Class
@@ -18,6 +19,8 @@ export class CodexInstaller {
     overwrite;
     options;
     generator;
+    static AGENTS_START = '<!-- BEGIN AGENTIC-QE CODEX -->';
+    static AGENTS_END = '<!-- END AGENTIC-QE CODEX -->';
     constructor(options) {
         this.projectRoot = options.projectRoot;
         this.overwrite = options.overwrite ?? false;
@@ -36,13 +39,21 @@ export class CodexInstaller {
             agentsMdPath: '',
             hooksPath: join(this.projectRoot, '.codex', 'hooks.json'),
             skillsPath: join(this.projectRoot, '.agents', 'skills'),
+            components: {
+                mcp: { status: 'skipped' },
+                rules: { status: 'skipped' },
+                hooks: { status: 'unavailable' },
+                skills: { status: 'unavailable' },
+            },
         };
         try {
-            // Generate TOML MCP config
             const mcpConfig = this.generator.generateMcpConfig('codex', { memoryBackend: this.options.memoryBackend });
             const configPath = join(this.projectRoot, mcpConfig.path);
             result.configPath = configPath;
-            if (!existsSync(configPath) || this.overwrite) {
+            // Generate TOML MCP config unless the caller explicitly requested a
+            // platform-only install (rules, hooks, and skills remain useful).
+            const configExists = existsSync(configPath);
+            if (this.options.installMcp !== false && (!configExists || this.overwrite)) {
                 const configDir = dirname(configPath);
                 if (!existsSync(configDir)) {
                     mkdirSync(configDir, { recursive: true });
@@ -55,30 +66,61 @@ export class CodexInstaller {
                     writeFileSync(configPath, mcpConfig.content);
                 }
                 result.mcpConfigured = true;
+                result.components.mcp.status = configExists ? 'updated' : 'installed';
+            }
+            else if (this.options.installMcp !== false && configExists) {
+                result.components.mcp.status = 'preserved';
             }
+        }
+        catch (error) {
+            this.recordComponentFailure(result, 'mcp', error);
+        }
+        try {
             // Generate AGENTS.md behavioral rules
             const rules = this.generator.generateBehavioralRules('codex');
             const agentsMdPath = join(this.projectRoot, rules.path);
             result.agentsMdPath = agentsMdPath;
-            if (!existsSync(agentsMdPath) || this.overwrite) {
-                if (existsSync(agentsMdPath) && this.overwrite) {
+            const rulesExist = existsSync(agentsMdPath);
+            if (!rulesExist || this.overwrite) {
+                if (rulesExist && this.overwrite) {
                     const merged = this.mergeExistingAgentsMd(agentsMdPath, rules.content);
                     writeFileSync(agentsMdPath, merged);
                 }
                 else {
-                    writeFileSync(agentsMdPath, rules.content);
+                    writeFileSync(agentsMdPath, this.markAgentsSection(rules.content));
                 }
                 result.agentsMdInstalled = true;
+                result.components.rules.status = rulesExist ? 'updated' : 'installed';
+            }
+            else {
+                result.components.rules.status = 'preserved';
             }
-            this.installCodexHooks(result);
-            result.skillsInstalled = this.installCodexSkills();
         }
         catch (error) {
-            result.success = false;
-            result.errors.push(`Codex installation failed: ${toErrorMessage(error)}`);
+            this.recordComponentFailure(result, 'rules', error);
         }
+        try {
+            result.components.hooks.status = this.installCodexHooks(result);
+        }
+        catch (error) {
+            this.recordComponentFailure(result, 'hooks', error);
+        }
+        try {
+            const skills = this.installCodexSkills();
+            result.skillsInstalled = skills.count;
+            result.components.skills.status = skills.status;
+        }
+        catch (error) {
+            this.recordComponentFailure(result, 'skills', error);
+        }
+        result.success = result.errors.length === 0;
         return result;
     }
+    recordComponentFailure(result, component, error) {
+        const message = toErrorMessage(error);
+        result.components[component] = { status: 'failed', error: message };
+        result.errors.push(`Codex ${component} installation failed: ${message}`);
+    }
     /**
      * Install Codex-native lifecycle adapters and merge AQE/ruflo hook groups
      * without removing user-defined hooks.
@@ -86,15 +128,17 @@ export class CodexInstaller {
     installCodexHooks(result) {
         const sourceRoot = this.resolvePackageRoot();
         if (!sourceRoot)
-            return;
+            return 'unavailable';
         const sourceConfig = join(sourceRoot, '.codex', 'hooks.json');
         const sourceScripts = join(sourceRoot, '.codex', 'hooks');
         if (!existsSync(sourceConfig) || !existsSync(sourceScripts))
-            return;
+            return 'unavailable';
         const targetCodexDir = join(this.projectRoot, '.codex');
         const targetScripts = join(targetCodexDir, 'hooks');
         mkdirSync(targetScripts, { recursive: true });
         for (const file of readdirSync(sourceScripts)) {
+            if (!this.options.includeRuflo && file === 'ruflo-codex-hook.cjs')
+                continue;
             const source = join(sourceScripts, file);
             if (!statSync(source).isFile())
                 continue;
@@ -108,25 +152,31 @@ export class CodexInstaller {
                 source: join(sourceRoot, '.claude', 'hooks', 'aqe-hook.cjs'),
                 target: join(targetScripts, 'aqe-runtime.cjs'),
             },
-            {
-                source: join(sourceRoot, '.claude', 'helpers', 'ruflo-hook.cjs'),
-                target: join(targetScripts, 'ruflo-runtime.cjs'),
-            },
+            ...(this.options.includeRuflo ? [{
+                    source: join(sourceRoot, '.claude', 'helpers', 'ruflo-hook.cjs'),
+                    target: join(targetScripts, 'ruflo-runtime.cjs'),
+                }] : []),
         ];
         for (const runtime of runtimes) {
             if (existsSync(runtime.source) && (!existsSync(runtime.target) || this.overwrite)) {
                 copyFileSync(runtime.source, runtime.target);
             }
         }
-        const generated = JSON.parse(readFileSync(sourceConfig, 'utf-8'));
+        const generatedSource = JSON.parse(readFileSync(sourceConfig, 'utf-8'));
+        const isRufloGroup = (value) => JSON.stringify(value).includes('ruflo-codex-hook.cjs');
+        const generated = {
+            ...generatedSource,
+            hooks: Object.fromEntries(Object.entries(generatedSource.hooks || {}).map(([event, groups]) => [
+                event,
+                this.options.includeRuflo ? groups : groups.filter((group) => !isRufloGroup(group)),
+            ])),
+        };
         const targetConfig = join(targetCodexDir, 'hooks.json');
         if (!existsSync(targetConfig)) {
             writeFileSync(targetConfig, JSON.stringify(generated, null, 2) + '\n');
             result.hooksConfigured = true;
-            return;
+            return 'installed';
         }
-        if (!this.overwrite)
-            return;
         const existing = JSON.parse(readFileSync(targetConfig, 'utf-8'));
         const owned = (value) => JSON.stringify(value).includes('/.codex/hooks/aqe-codex-hook.cjs')
             || JSON.stringify(value).includes('/.codex/hooks/ruflo-codex-hook.cjs');
@@ -141,31 +191,54 @@ export class CodexInstaller {
         }
         writeFileSync(targetConfig, JSON.stringify({ ...existing, description: generated.description, hooks: mergedHooks }, null, 2) + '\n');
         result.hooksConfigured = true;
+        return 'updated';
     }
     /** Install the curated repo-scoped AQE skills Codex discovers automatically. */
     installCodexSkills() {
         const sourceRoot = this.resolvePackageRoot();
         if (!sourceRoot)
-            return 0;
+            return { count: 0, status: 'unavailable' };
         const sourceSkills = join(sourceRoot, '.agents', 'skills');
         if (!existsSync(sourceSkills))
-            return 0;
+            return { count: 0, status: 'unavailable' };
         const targetSkills = join(this.projectRoot, '.agents', 'skills');
         mkdirSync(targetSkills, { recursive: true });
         let installed = 0;
-        for (const skill of readdirSync(sourceSkills)) {
-            if (!skill.startsWith('aqe-'))
-                continue;
-            const source = join(sourceSkills, skill);
-            if (!statSync(source).isDirectory())
-                continue;
-            const target = join(targetSkills, skill);
+        let updated = 0;
+        for (const skill of selectCodexSkills({ includeRuflo: this.options.includeRuflo })) {
+            const source = join(sourceSkills, skill.name);
+            if (!existsSync(source) || !statSync(source).isDirectory()) {
+                throw new Error(`Missing packaged Codex skill directory: ${skill.name}`);
+            }
+            const target = join(targetSkills, skill.name);
             if (existsSync(target) && !this.overwrite)
                 continue;
-            this.copyDirectory(source, target);
-            installed++;
+            const targetExisted = existsSync(target);
+            if (skill.files) {
+                mkdirSync(target, { recursive: true });
+                for (const relativeFile of skill.files) {
+                    const from = join(source, relativeFile);
+                    if (!existsSync(from) || !statSync(from).isFile()) {
+                        throw new Error(`Missing packaged Codex skill file: ${skill.name}/${relativeFile}`);
+                    }
+                    const to = join(target, relativeFile);
+                    mkdirSync(dirname(to), { recursive: true });
+                    copyFileSync(from, to);
+                }
+            }
+            else {
+                this.copyDirectory(source, target);
+            }
+            if (targetExisted)
+                updated++;
+            else
+                installed++;
         }
-        return installed;
+        const count = installed + updated;
+        return {
+            count,
+            status: updated > 0 ? 'updated' : installed > 0 ? 'installed' : 'preserved',
+        };
     }
     copyDirectory(source, target) {
         mkdirSync(target, { recursive: true });
@@ -195,40 +268,45 @@ export class CodexInstaller {
     }
     /**
      * Merge AQE MCP server config into existing TOML.
-     * Simple approach: if [mcp_servers.agentic-qe] already exists, skip.
-     * Otherwise, append the AQE block at the end.
+     * Replace only AQE-owned TOML tables, preserving every user-owned table and
+     * setting. AQE owns the exact `mcp_servers.agentic-qe` table prefix.
      */
     mergeExistingTomlConfig(configPath, newContent) {
-        try {
-            const existing = readFileSync(configPath, 'utf-8');
-            // If AQE server already configured, return as-is
-            if (existing.includes('[mcp_servers.agentic-qe]')) {
-                return existing;
+        const existing = readFileSync(configPath, 'utf-8');
+        const aqeTable = /^\s*\[mcp_servers\.(?:agentic-qe|"agentic-qe")(?:\.(?:[^\]]+))?\]\s*(?:#.*)?$/;
+        const lines = existing.split(/\r?\n/);
+        const kept = [];
+        let inOwnedTable = false;
+        for (const line of lines) {
+            if (/^\s*\[[^\]]+\]\s*(?:#.*)?$/.test(line)) {
+                inOwnedTable = aqeTable.test(line);
             }
-            // Append AQE config block
-            return existing.trimEnd() + '\n\n' + newContent;
-        }
-        catch {
-            return newContent;
+            if (!inOwnedTable)
+                kept.push(line);
         }
+        return kept.join('\n').trimEnd() + '\n\n' + newContent.trim() + '\n';
     }
     /**
      * Merge AQE section into existing AGENTS.md.
-     * Appends the AQE section if not already present.
+     * Replaces a previously marked AQE section or appends a new marked section.
      */
     mergeExistingAgentsMd(agentsMdPath, newContent) {
-        try {
-            const existing = readFileSync(agentsMdPath, 'utf-8');
-            // If AQE section already present, return as-is
-            if (existing.includes('Agentic QE') || existing.includes('fleet_init')) {
-                return existing;
+        const existing = readFileSync(agentsMdPath, 'utf-8');
+        const marked = this.markAgentsSection(newContent);
+        const start = CodexInstaller.AGENTS_START;
+        const end = CodexInstaller.AGENTS_END;
+        const startIndex = existing.indexOf(start);
+        if (startIndex >= 0) {
+            const endIndex = existing.indexOf(end, startIndex);
+            if (endIndex >= 0) {
+                return existing.slice(0, startIndex) + marked
+                    + existing.slice(endIndex + end.length);
             }
-            // Append AQE section
-            return existing.trimEnd() + '\n\n---\n\n' + newContent;
-        }
-        catch {
-            return newContent;
         }
+        return existing.trimEnd() + '\n\n---\n\n' + marked;
+    }
+    markAgentsSection(content) {
+        return `${CodexInstaller.AGENTS_START}\n${content.trim()}\n${CodexInstaller.AGENTS_END}\n`;
     }
 }
 // ============================================================================

package/dist/init/codex-skill-manifest.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Skills shipped for repository-scoped Codex installs.
+ *
+ * Keep this list explicit: discovering skills by directory prefix makes the
+ * public package surface depend on unrelated files in a development checkout.
+ * Ruflo remains an opt-in, development-time integration and only its skill
+ * instructions are packaged; no Ruflo runtime code or dependency is shipped.
+ */
+export interface CodexSkillManifestEntry {
+    /** Directory name below `.agents/skills`. */
+    readonly name: string;
+    /** Install in every Codex configuration. */
+    readonly default: boolean;
+    /** Optional file allowlist relative to the skill directory. */
+    readonly files?: readonly string[];
+}
+export declare const CODEX_SKILL_MANIFEST: readonly [{
+    readonly name: "aqe-plan-quality";
+    readonly default: true;
+}, {
+    readonly name: "aqe-plan-work";
+    readonly default: true;
+}, {
+    readonly name: "aqe-research";
+    readonly default: true;
+}, {
+    readonly name: "aqe-review-quality";
+    readonly default: true;
+}, {
+    readonly name: "aqe-test-change";
+    readonly default: true;
+}, {
+    readonly name: "aqe-ruflo";
+    readonly default: false;
+    readonly files: readonly ["SKILL.md"];
+}];
+export interface SelectCodexSkillsOptions {
+    /** Include the Ruflo orchestration guidance without installing Ruflo itself. */
+    includeRuflo?: boolean;
+}
+/** Return the deterministic install set for a Codex project. */
+export declare function selectCodexSkills(options?: SelectCodexSkillsOptions): readonly CodexSkillManifestEntry[];
+//# sourceMappingURL=codex-skill-manifest.d.ts.map

package/dist/init/codex-skill-manifest.js

@@ -0,0 +1,21 @@
+/**
+ * Skills shipped for repository-scoped Codex installs.
+ *
+ * Keep this list explicit: discovering skills by directory prefix makes the
+ * public package surface depend on unrelated files in a development checkout.
+ * Ruflo remains an opt-in, development-time integration and only its skill
+ * instructions are packaged; no Ruflo runtime code or dependency is shipped.
+ */
+export const CODEX_SKILL_MANIFEST = [
+    { name: 'aqe-plan-quality', default: true },
+    { name: 'aqe-plan-work', default: true },
+    { name: 'aqe-research', default: true },
+    { name: 'aqe-review-quality', default: true },
+    { name: 'aqe-test-change', default: true },
+    { name: 'aqe-ruflo', default: false, files: ['SKILL.md'] },
+];
+/** Return the deterministic install set for a Codex project. */
+export function selectCodexSkills(options = {}) {
+    return CODEX_SKILL_MANIFEST.filter((skill) => skill.default || (skill.name === 'aqe-ruflo' && options.includeRuflo === true));
+}
+//# sourceMappingURL=codex-skill-manifest.js.map

package/dist/init/orchestrator.js

@@ -42,6 +42,7 @@ export class ModularInitOrchestrator {
                 withKiloCode: options.withKiloCode || allPlatforms,
                 withRooCode: options.withRooCode || allPlatforms,
                 withCodex: options.withCodex || allPlatforms,
+                withRuflo: options.withRuflo,
                 withWindsurf: options.withWindsurf || allPlatforms,
                 withContinueDev: options.withContinueDev || allPlatforms,
                 withAllPlatforms: options.withAllPlatforms,
@@ -50,6 +51,7 @@ export class ModularInitOrchestrator {
                 noGovernance: options.noGovernance,
                 noMcp: options.noMcp,
                 noClaude: options.noClaude,
+                noStatusLine: options.noStatusLine,
                 memoryBackend: options.memoryBackend,
             },
             config: {},

package/dist/init/phases/07-hooks.js

@@ -85,7 +85,9 @@ export class HooksPhase extends BasePhase {
         //  - statusLine / includeCoAuthoredBy preserved when user-set (#362 follow-up)
         //  - AQE-owned sections deep-merged so user additions survive
         const v3Sections = generateV3SettingsSections(config, projectRoot);
-        applyV3Sections(settings, v3Sections);
+        applyV3Sections(settings, v3Sections, {
+            statusLine: !context.options.noStatusLine,
+        });
         // Enable MCP servers (deduplicate, replace old 'aqe' with 'agentic-qe')
         let existingMcp = settings.enabledMcpjsonServers || [];
         // Remove legacy 'aqe' entry if present (renamed to 'agentic-qe')

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

@@ -293,7 +293,13 @@ export class AssetsPhase extends BasePhase {
         // P2 platforms: Codex (TOML), Windsurf (JSON), Continue.dev (YAML)
         if (options.withCodex || (options.autoMode && existsSync(join(projectRoot, '.codex')))) {
             const { createCodexInstaller } = await import('../codex-installer.js');
-            const installer = createCodexInstaller({ projectRoot, overwrite: shouldOverwrite, memoryBackend: options.memoryBackend === 'memory' ? 'memory' : undefined });
+            const installer = createCodexInstaller({
+                projectRoot,
+                overwrite: shouldOverwrite,
+                installMcp: !options.noMcp,
+                includeRuflo: options.withRuflo,
+                memoryBackend: options.memoryBackend === 'memory' ? 'memory' : undefined,
+            });
             const res = await installer.install();
             if (res.mcpConfigured)
                 platformsConfigured.push('codex');
@@ -307,6 +313,9 @@ export class AssetsPhase extends BasePhase {
                 context.services.log(`  Codex hooks: ${res.hooksPath}`);
             if (res.skillsInstalled > 0)
                 context.services.log(`  Codex skills: ${res.skillsInstalled} installed`);
+            context.services.log(options.withRuflo
+                ? '  Codex Ruflo integration: enabled'
+                : '  Codex Ruflo integration: not installed (opt in with --with-ruflo)');
         }
         if (options.withWindsurf || (options.autoMode && existsSync(join(projectRoot, '.windsurf')))) {
             const { createWindsurfInstaller } = await import('../windsurf-installer.js');

package/dist/init/phases/phase-interface.d.ts

@@ -121,6 +121,8 @@ export interface InitOptions {
     withRooCode?: boolean;
     /** Install OpenAI Codex CLI MCP, AGENTS.md, hooks, and QE skills */
     withCodex?: boolean;
+    /** Include optional Ruflo guidance and Codex lifecycle integration */
+    withRuflo?: boolean;
     /** Install Windsurf MCP config and rules */
     withWindsurf?: boolean;
     /** Install Continue.dev MCP config and rules */
@@ -137,6 +139,8 @@ export interface InitOptions {
      * unchanged. Pairs naturally with `--no-database`.
      */
     noClaude?: boolean;
+    /** Skip AQE's Claude Code status line and remove a previously AQE-owned one. */
+    noStatusLine?: boolean;
     /** @deprecated Use default behavior instead — MCP is now enabled by default */
     withMcp?: boolean;
     /**

package/dist/init/settings-merge.d.ts

@@ -70,7 +70,9 @@ export declare function isAqeStatusLine(statusLine: unknown): boolean;
  *
  * Mutates and returns `settings`.
  */
-export declare function applyV3Sections(settings: Record<string, unknown>, sections: Record<string, unknown>): Record<string, unknown>;
+export declare function applyV3Sections(settings: Record<string, unknown>, sections: Record<string, unknown>, options?: {
+    statusLine?: boolean;
+}): Record<string, unknown>;
 /**
  * Generate v3-specific settings sections for settings.json.
  * These sections enable the self-learning system, status line, and permissions.