agentic-qe 3.10.8 → 3.11.0

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

@@ -42,8 +42,8 @@ export class AssetsPhase extends BasePhase {
         else if (options.autoMode && isVersionUpgrade) {
             context.services.log(`  Version upgrade detected: updating skills and agents`);
         }
-        // Install skills
-        if (config.skills.install) {
+        // Install skills (Claude Code surface — skipped with --no-claude, #532)
+        if (!options.noClaude && config.skills.install) {
             const skillsInstaller = createSkillsInstaller({
                 projectRoot,
                 installV2Skills: config.skills.installV2,
@@ -56,25 +56,27 @@ export class AssetsPhase extends BasePhase {
                 context.services.warn(`Skills warnings: ${skillsResult.errors.join(', ')}`);
             }
         }
-        // Install agents
-        try {
-            const agentsInstaller = createAgentsInstaller({
-                projectRoot,
-                installQEAgents: true,
-                installSubagents: true,
-                overwrite: shouldOverwrite,
-            });
-            const agentsResult = await agentsInstaller.install();
-            agentsInstalled = agentsResult.installed.length;
-            if (agentsResult.errors.length > 0) {
-                context.services.warn(`Agents warnings: ${agentsResult.errors.join(', ')}`);
+        // Install agents (Claude Code surface — skipped with --no-claude, #532)
+        if (!options.noClaude) {
+            try {
+                const agentsInstaller = createAgentsInstaller({
+                    projectRoot,
+                    installQEAgents: true,
+                    installSubagents: true,
+                    overwrite: shouldOverwrite,
+                });
+                const agentsResult = await agentsInstaller.install();
+                agentsInstalled = agentsResult.installed.length;
+                if (agentsResult.errors.length > 0) {
+                    context.services.warn(`Agents warnings: ${agentsResult.errors.join(', ')}`);
+                }
             }
+            catch (error) {
+                context.services.warn(`Agents install error: ${error instanceof Error ? error.message : error}`);
+            }
+            // Initialize overlay configs in agent registry for runtime use
+            initializeOverlays(projectRoot);
         }
-        catch (error) {
-            context.services.warn(`Agents install error: ${error instanceof Error ? error.message : error}`);
-        }
-        // Initialize overlay configs in agent registry for runtime use
-        initializeOverlays(projectRoot);
         // Install Vibium browser engine for the qe-browser fleet skill.
         // Graceful — never fails init if Vibium cannot be installed.
         // Skipped in --minimal mode per ADR-086 minimal-footprint guidance.
@@ -204,6 +206,7 @@ export class AssetsPhase extends BasePhase {
                 installHooks: true,
                 installSteering: true,
                 overwrite: shouldOverwrite,
+                memoryBackend: options.memoryBackend === 'memory' ? 'memory' : undefined,
             });
             const kiroResult = await kiroInstaller.install();
             kiroAgents = kiroResult.agentsInstalled.length;
@@ -224,7 +227,7 @@ export class AssetsPhase extends BasePhase {
         const platformsConfigured = [];
         if (options.withCopilot || (options.autoMode && existsSync(join(projectRoot, '.vscode')))) {
             const { createCopilotInstaller } = await import('../copilot-installer.js');
-            const installer = createCopilotInstaller({ projectRoot, overwrite: shouldOverwrite });
+            const installer = createCopilotInstaller({ projectRoot, overwrite: shouldOverwrite, memoryBackend: options.memoryBackend === 'memory' ? 'memory' : undefined });
             const res = await installer.install();
             if (res.mcpConfigured)
                 platformsConfigured.push('copilot');
@@ -237,7 +240,7 @@ export class AssetsPhase extends BasePhase {
         }
         if (options.withCursor || (options.autoMode && existsSync(join(projectRoot, '.cursor')))) {
             const { createCursorInstaller } = await import('../cursor-installer.js');
-            const installer = createCursorInstaller({ projectRoot, overwrite: shouldOverwrite });
+            const installer = createCursorInstaller({ projectRoot, overwrite: shouldOverwrite, memoryBackend: options.memoryBackend === 'memory' ? 'memory' : undefined });
             const res = await installer.install();
             if (res.mcpConfigured)
                 platformsConfigured.push('cursor');
@@ -250,7 +253,7 @@ export class AssetsPhase extends BasePhase {
         }
         if (options.withCline) {
             const { createClineInstaller } = await import('../cline-installer.js');
-            const installer = createClineInstaller({ projectRoot, overwrite: shouldOverwrite });
+            const installer = createClineInstaller({ projectRoot, overwrite: shouldOverwrite, memoryBackend: options.memoryBackend === 'memory' ? 'memory' : undefined });
             const res = await installer.install();
             if (res.mcpConfigured)
                 platformsConfigured.push('cline');
@@ -263,7 +266,7 @@ export class AssetsPhase extends BasePhase {
         }
         if (options.withKiloCode || (options.autoMode && existsSync(join(projectRoot, '.kilocode')))) {
             const { createKiloCodeInstaller } = await import('../kilocode-installer.js');
-            const installer = createKiloCodeInstaller({ projectRoot, overwrite: shouldOverwrite });
+            const installer = createKiloCodeInstaller({ projectRoot, overwrite: shouldOverwrite, memoryBackend: options.memoryBackend === 'memory' ? 'memory' : undefined });
             const res = await installer.install();
             if (res.mcpConfigured)
                 platformsConfigured.push('kilocode');
@@ -276,7 +279,7 @@ export class AssetsPhase extends BasePhase {
         }
         if (options.withRooCode || (options.autoMode && existsSync(join(projectRoot, '.roo')))) {
             const { createRooCodeInstaller } = await import('../roocode-installer.js');
-            const installer = createRooCodeInstaller({ projectRoot, overwrite: shouldOverwrite });
+            const installer = createRooCodeInstaller({ projectRoot, overwrite: shouldOverwrite, memoryBackend: options.memoryBackend === 'memory' ? 'memory' : undefined });
             const res = await installer.install();
             if (res.mcpConfigured)
                 platformsConfigured.push('roocode');
@@ -290,7 +293,7 @@ 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 });
+            const installer = createCodexInstaller({ projectRoot, overwrite: shouldOverwrite, memoryBackend: options.memoryBackend === 'memory' ? 'memory' : undefined });
             const res = await installer.install();
             if (res.mcpConfigured)
                 platformsConfigured.push('codex');
@@ -303,7 +306,7 @@ export class AssetsPhase extends BasePhase {
         }
         if (options.withWindsurf || (options.autoMode && existsSync(join(projectRoot, '.windsurf')))) {
             const { createWindsurfInstaller } = await import('../windsurf-installer.js');
-            const installer = createWindsurfInstaller({ projectRoot, overwrite: shouldOverwrite });
+            const installer = createWindsurfInstaller({ projectRoot, overwrite: shouldOverwrite, memoryBackend: options.memoryBackend === 'memory' ? 'memory' : undefined });
             const res = await installer.install();
             if (res.mcpConfigured)
                 platformsConfigured.push('windsurf');
@@ -316,7 +319,7 @@ export class AssetsPhase extends BasePhase {
         }
         if (options.withContinueDev || (options.autoMode && existsSync(join(projectRoot, '.continue')))) {
             const { createContinueDevInstaller } = await import('../continuedev-installer.js');
-            const installer = createContinueDevInstaller({ projectRoot, overwrite: shouldOverwrite });
+            const installer = createContinueDevInstaller({ projectRoot, overwrite: shouldOverwrite, memoryBackend: options.memoryBackend === 'memory' ? 'memory' : undefined });
             const res = await installer.install();
             if (res.mcpConfigured)
                 platformsConfigured.push('continuedev');

package/dist/init/phases/11-claude-md.d.ts

@@ -17,6 +17,7 @@ export declare class ClaudeMdPhase extends BasePhase<ClaudeMdResult> {
     readonly order = 110;
     readonly critical = false;
     readonly requiresPhases: readonly ["configuration"];
+    shouldRun(context: InitContext): Promise<boolean>;
     protected run(context: InitContext): Promise<ClaudeMdResult>;
     /**
      * Generate CLAUDE.md content

package/dist/init/phases/11-claude-md.js

@@ -14,6 +14,14 @@ export class ClaudeMdPhase extends BasePhase {
     order = 110;
     critical = false;
     requiresPhases = ['configuration'];
+    async shouldRun(context) {
+        // #532: --no-claude suppresses the Claude Code surface, including CLAUDE.md.
+        if (context.options.noClaude) {
+            context.services.log('  CLAUDE.md skipped (--no-claude)');
+            return false;
+        }
+        return true;
+    }
     async run(context) {
         const config = context.config;
         const { projectRoot } = context;

package/dist/init/phases/13-governance.js

@@ -33,6 +33,11 @@ export class GovernancePhase extends BasePhase {
      * Run unless --no-governance flag is set
      */
     async shouldRun(context) {
+        // #532: governance is part of the Claude Code surface — skip with --no-claude.
+        if (context.options.noClaude) {
+            context.services.log('  Governance skipped (--no-claude)');
+            return false;
+        }
         // Check for --no-governance flag (via noGovernance option)
         if (context.options.noGovernance) {
             context.services.log('  Governance skipped (--no-governance flag)');

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

@@ -129,6 +129,14 @@ export interface InitOptions {
     withAllPlatforms?: boolean;
     /** Skip MCP server config (MCP is enabled by default) */
     noMcp?: boolean;
+    /**
+     * Suppress the default Claude Code surface (#532). When true, init does NOT
+     * write `.claude/` skills+agents, `.mcp.json`, `CLAUDE.md`, governance, or
+     * hooks — making `--with-<platform>` flags the only install targets (e.g. an
+     * OpenCode-only install). Opt-in via `--no-claude`; default install is
+     * unchanged. Pairs naturally with `--no-database`.
+     */
+    noClaude?: boolean;
     /** @deprecated Use default behavior instead — MCP is now enabled by default */
     withMcp?: boolean;
     /**

package/dist/init/platform-config-generator.d.ts

@@ -35,7 +35,9 @@ export declare class PlatformConfigGenerator {
     /**
      * Generate the MCP config for a platform
      */
-    generateMcpConfig(platformId: PlatformId): GeneratedConfig;
+    generateMcpConfig(platformId: PlatformId, opts?: {
+        memoryBackend?: 'memory' | 'sqlite' | 'agentdb' | 'hybrid';
+    }): GeneratedConfig;
     /**
      * Generate behavioral rules / instruction file for a platform
      */

package/dist/init/platform-config-generator.js

@@ -135,14 +135,22 @@ const SAFE_AUTO_APPROVE_TOOLS = [
 // ============================================================================
 // MCP Server Entry
 // ============================================================================
-function getMcpServerEntry(withAutoApprove) {
+/**
+ * Build the MCP server env. Issue #533: in database-free mode the server must
+ * run in-memory (AQE_MEMORY_BACKEND=memory) and must NOT be pointed at a
+ * persistent db path — otherwise launching via this client recreates
+ * .agentic-qe/memory.db at runtime and defeats the --no-database install.
+ */
+function getMcpServerEnv(dbFree) {
+    return dbFree
+        ? { AQE_MEMORY_BACKEND: 'memory', AQE_V3_MODE: 'true' }
+        : { AQE_MEMORY_PATH: '.agentic-qe/memory.db', AQE_V3_MODE: 'true' };
+}
+function getMcpServerEntry(withAutoApprove, dbFree) {
     const entry = {
         command: 'npx',
         args: ['-y', 'agentic-qe@latest', 'mcp'],
-        env: {
-            AQE_MEMORY_PATH: '.agentic-qe/memory.db',
-            AQE_V3_MODE: 'true',
-        },
+        env: getMcpServerEnv(dbFree),
     };
     if (withAutoApprove) {
         entry.disabled = false;
@@ -153,8 +161,8 @@ function getMcpServerEntry(withAutoApprove) {
 // ============================================================================
 // Config Generators
 // ============================================================================
-function generateJsonConfig(platform) {
-    const serverEntry = getMcpServerEntry(platform.supportsAutoApprove);
+function generateJsonConfig(platform, dbFree) {
+    const serverEntry = getMcpServerEntry(platform.supportsAutoApprove, dbFree);
     if (platform.id === 'copilot') {
         // Copilot uses "servers" key with "type": "stdio"
         const config = {
@@ -174,7 +182,10 @@ function generateJsonConfig(platform) {
     };
     return JSON.stringify(config, null, 2) + '\n';
 }
-function generateTomlConfig() {
+function generateTomlConfig(dbFree) {
+    const envLines = dbFree
+        ? `AQE_MEMORY_BACKEND = "memory"\nAQE_V3_MODE = "true"`
+        : `AQE_MEMORY_PATH = ".agentic-qe/memory.db"\nAQE_V3_MODE = "true"`;
     return `# Agentic QE MCP Server
 [mcp_servers.agentic-qe]
 type = "stdio"
@@ -182,11 +193,13 @@ command = "npx"
 args = ["-y", "agentic-qe@latest", "mcp"]
 
 [mcp_servers.agentic-qe.env]
-AQE_MEMORY_PATH = ".agentic-qe/memory.db"
-AQE_V3_MODE = "true"
+${envLines}
 `;
 }
-function generateYamlConfig() {
+function generateYamlConfig(dbFree) {
+    const envLines = dbFree
+        ? `      AQE_MEMORY_BACKEND: memory\n      AQE_V3_MODE: "true"`
+        : `      AQE_MEMORY_PATH: .agentic-qe/memory.db\n      AQE_V3_MODE: "true"`;
     return `# Agentic QE MCP Server
 mcpServers:
   - name: agentic-qe
@@ -196,8 +209,7 @@ mcpServers:
       - agentic-qe@latest
       - mcp
     env:
-      AQE_MEMORY_PATH: .agentic-qe/memory.db
-      AQE_V3_MODE: "true"
+${envLines}
 `;
 }
 // ============================================================================
@@ -281,19 +293,21 @@ export class PlatformConfigGenerator {
     /**
      * Generate the MCP config for a platform
      */
-    generateMcpConfig(platformId) {
+    generateMcpConfig(platformId, opts) {
         const platform = this.getPlatform(platformId);
+        // Issue #533: database-free installs propagate AQE_MEMORY_BACKEND=memory.
+        const dbFree = opts?.memoryBackend === 'memory';
         let content;
         switch (platform.configFormat) {
             case 'toml':
-                content = generateTomlConfig();
+                content = generateTomlConfig(dbFree);
                 break;
             case 'yaml':
-                content = generateYamlConfig();
+                content = generateYamlConfig(dbFree);
                 break;
             case 'json':
             default:
-                content = generateJsonConfig(platform);
+                content = generateJsonConfig(platform, dbFree);
                 break;
         }
         return {

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

@@ -8,6 +8,11 @@
 export interface RooCodeInstallerOptions {
     projectRoot: string;
     overwrite?: 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)
+     */
+    memoryBackend?: 'memory' | 'sqlite' | 'agentdb' | 'hybrid';
 }
 export interface RooCodeInstallResult {
     success: boolean;
@@ -20,6 +25,7 @@ export interface RooCodeInstallResult {
 export declare class RooCodeInstaller {
     private projectRoot;
     private overwrite;
+    private options;
     private generator;
     constructor(options: RooCodeInstallerOptions);
     install(): Promise<RooCodeInstallResult>;

package/dist/init/roocode-installer.js

@@ -15,10 +15,12 @@ import { createPlatformConfigGenerator, } from './platform-config-generator.js';
 export class RooCodeInstaller {
     projectRoot;
     overwrite;
+    options;
     generator;
     constructor(options) {
         this.projectRoot = options.projectRoot;
         this.overwrite = options.overwrite ?? false;
+        this.options = options;
         this.generator = createPlatformConfigGenerator();
     }
     async install() {
@@ -32,7 +34,7 @@ export class RooCodeInstaller {
         };
         try {
             // Generate MCP config
-            const mcpConfig = this.generator.generateMcpConfig('roocode');
+            const mcpConfig = this.generator.generateMcpConfig('roocode', { memoryBackend: this.options.memoryBackend });
             const configPath = join(this.projectRoot, mcpConfig.path);
             result.configPath = configPath;
             if (!existsSync(configPath) || this.overwrite) {

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

@@ -8,6 +8,11 @@
 export interface WindsurfInstallerOptions {
     projectRoot: string;
     overwrite?: 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)
+     */
+    memoryBackend?: 'memory' | 'sqlite' | 'agentdb' | 'hybrid';
 }
 export interface WindsurfInstallResult {
     success: boolean;
@@ -20,6 +25,7 @@ export interface WindsurfInstallResult {
 export declare class WindsurfInstaller {
     private projectRoot;
     private overwrite;
+    private options;
     private generator;
     constructor(options: WindsurfInstallerOptions);
     install(): Promise<WindsurfInstallResult>;

package/dist/init/windsurf-installer.js

@@ -15,10 +15,12 @@ import { createPlatformConfigGenerator, } from './platform-config-generator.js';
 export class WindsurfInstaller {
     projectRoot;
     overwrite;
+    options;
     generator;
     constructor(options) {
         this.projectRoot = options.projectRoot;
         this.overwrite = options.overwrite ?? false;
+        this.options = options;
         this.generator = createPlatformConfigGenerator();
     }
     async install() {
@@ -32,7 +34,7 @@ export class WindsurfInstaller {
         };
         try {
             // Generate MCP config (project-level .windsurf/mcp_config.json)
-            const mcpConfig = this.generator.generateMcpConfig('windsurf');
+            const mcpConfig = this.generator.generateMcpConfig('windsurf', { memoryBackend: this.options.memoryBackend });
             const configPath = join(this.projectRoot, mcpConfig.path);
             result.configPath = configPath;
             if (!existsSync(configPath) || this.overwrite) {

package/dist/integrations/darwin/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Darwin Mode integration (cross-pollination plan 05, D1).
+ *
+ * Folds AQE's objective QE metrics into `@metaharness/darwin`'s ScoreCard
+ * contract so a Darwin evolution loop can promote real QE improvements.
+ * See docs/metaharness/06-darwin-qe-self-learning-action-lane.md.
+ */
+export type { DarwinScoreCard, QeFitness, MutationSurface } from './types.js';
+export { qeFitnessToScoreCard, applyQePromotionGate, arenaStrategiesToScoreCards, computeQeFitness, QE_FITNESS_WEIGHTS, SAFETY_GATE, type QeScoreOptions, type EvaluatedStrategyLike, } from './qe-fitness.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/integrations/darwin/index.js

@@ -0,0 +1,2 @@
+export { qeFitnessToScoreCard, applyQePromotionGate, arenaStrategiesToScoreCards, computeQeFitness, QE_FITNESS_WEIGHTS, SAFETY_GATE, } from './qe-fitness.js';
+//# sourceMappingURL=index.js.map

package/dist/integrations/darwin/qe-fitness.d.ts

@@ -0,0 +1,83 @@
+/**
+ * QE → Darwin fitness adapter (cross-pollination plan 05, action D1).
+ *
+ * Darwin Mode evolves a harness against a frozen, pure-function scorer
+ * (`@metaharness/darwin` ADR-072). Its default substrates (`mock`/`agent`) score
+ * by whether synthetic surface params solve toy tasks — there is NO QE signal.
+ * This adapter folds AQE's OBJECTIVE QE metrics (mutation kill-rate, coverage,
+ * suite cost — the ADR-104 arena's validated fitness) into Darwin's `ScoreCard`
+ * contract, so Darwin's promotion gate promotes genuine QE improvements.
+ *
+ * QE-native finalScore: like Darwin's `benchSuite` path (which overrides the
+ * single-run promote flag), we set `finalScore` to the QE fitness rather than
+ * Darwin's generic weighted fold — QE has its own validated objective. The
+ * positive terms are still populated (for transparency + Darwin's gate clauses:
+ * `testPassRate` drives noRegression, `safetyScore` drives the safety clauses).
+ *
+ * Pure + deterministic + dependency-free: no model calls, no I/O. Unit-testable.
+ */
+import type { DarwinScoreCard, QeFitness } from './types.js';
+/** ADR-104 arena weights — kept in sync with src/arena/arena.ts. */
+export declare const QE_FITNESS_WEIGHTS: {
+    readonly kill: 0.6;
+    readonly coverage: 0.3;
+    readonly runtimePenalty: 0.1;
+};
+/** Recompute the ADR-104 blended fitness from its parts (used when not supplied). */
+export declare function computeQeFitness(killRate: number, coveragePct: number | null, suiteCostRatio: number): number;
+export interface QeScoreOptions {
+    /**
+     * Whether the variant cleared Darwin's safety gate (inspectVariant /
+     * validateGeneratedCode). Defaults to true — set false to model a blocked
+     * variant (collapses the score, exactly like a Darwin safety violation).
+     */
+    safe?: boolean;
+    /** Darwin's frozen positive-term weights (for the transparency baseScore). */
+    weights?: {
+        taskSuccess: number;
+        testPassRate: number;
+        traceQuality: number;
+        costEfficiency: number;
+        latencyEfficiency: number;
+        safetyScore: number;
+    };
+}
+/**
+ * Map one QE outcome to a Darwin `ScoreCard`.
+ *
+ * Term mapping (QE semantics):
+ *  - taskSuccess     = killRate when the baseline suite passes, else 0
+ *    (the QE "task" is catching injected faults; quality scales with kill-rate)
+ *  - testPassRate    = 1 if baseline passed, else 0   → Darwin's noRegression gate
+ *  - traceQuality    = coverage fraction               (how thoroughly code ran)
+ *  - costEfficiency  = 1 − suiteCostRatio
+ *  - latencyEfficiency = 1 (arena folds runtime into the cost proxy; no separate signal)
+ *  - safetyScore     = 1 if safe, else 0               → Darwin's safety clauses
+ *  - hallucinatedFile penalty = falseFindingRate       (a QE false positive is a hallucination)
+ *
+ * finalScore (QE-native): the ADR-104 fitness when safe AND baseline passed;
+ * −1 when unsafe (hard fail, mirrors Darwin "a single violation drives it
+ * negative"); 0 when safe but the baseline regressed.
+ */
+export declare function qeFitnessToScoreCard(variantId: string, qe: QeFitness, opts?: QeScoreOptions): DarwinScoreCard;
+/** Darwin's ADR-072 safety-gate floor (mirror of scorer.ts SAFETY_GATE). */
+export declare const SAFETY_GATE = 0.95;
+/**
+ * Apply Darwin's 4-clause promotion gate (ADR-072 / scorer.ts:149-154) to a
+ * QE-native score card, returning a copy with `promoted` + `reason` set. Kept a
+ * byte-faithful mirror so a host-scored variant promotes under the SAME rules
+ * Darwin uses internally: beatsParent ∧ safetyOk ∧ noRegression ∧ noBlocked.
+ */
+export declare function applyQePromotionGate(card: DarwinScoreCard, parentScore: DarwinScoreCard | null, promotionDelta: number): DarwinScoreCard;
+/** Minimal shape of an ADR-104 `EvaluatedStrategy` (decoupled from src/arena). */
+export interface EvaluatedStrategyLike {
+    id: string;
+    baselinePassed: boolean;
+    killRate: number;
+    coveragePct: number | null;
+    suiteCostRatio: number;
+    fitness: number;
+}
+/** Convert a whole ADR-104 arena result into per-strategy Darwin score cards. */
+export declare function arenaStrategiesToScoreCards(strategies: readonly EvaluatedStrategyLike[], opts?: QeScoreOptions): Record<string, DarwinScoreCard>;
+//# sourceMappingURL=qe-fitness.d.ts.map

package/dist/integrations/darwin/qe-fitness.js

@@ -0,0 +1,147 @@
+/**
+ * QE → Darwin fitness adapter (cross-pollination plan 05, action D1).
+ *
+ * Darwin Mode evolves a harness against a frozen, pure-function scorer
+ * (`@metaharness/darwin` ADR-072). Its default substrates (`mock`/`agent`) score
+ * by whether synthetic surface params solve toy tasks — there is NO QE signal.
+ * This adapter folds AQE's OBJECTIVE QE metrics (mutation kill-rate, coverage,
+ * suite cost — the ADR-104 arena's validated fitness) into Darwin's `ScoreCard`
+ * contract, so Darwin's promotion gate promotes genuine QE improvements.
+ *
+ * QE-native finalScore: like Darwin's `benchSuite` path (which overrides the
+ * single-run promote flag), we set `finalScore` to the QE fitness rather than
+ * Darwin's generic weighted fold — QE has its own validated objective. The
+ * positive terms are still populated (for transparency + Darwin's gate clauses:
+ * `testPassRate` drives noRegression, `safetyScore` drives the safety clauses).
+ *
+ * Pure + deterministic + dependency-free: no model calls, no I/O. Unit-testable.
+ */
+/** ADR-104 arena weights — kept in sync with src/arena/arena.ts. */
+export const QE_FITNESS_WEIGHTS = { kill: 0.6, coverage: 0.3, runtimePenalty: 0.1 };
+const clamp01 = (n) => (n < 0 ? 0 : n > 1 ? 1 : n);
+const round4 = (n) => Math.round(n * 10000) / 10000;
+/** Recompute the ADR-104 blended fitness from its parts (used when not supplied). */
+export function computeQeFitness(killRate, coveragePct, suiteCostRatio) {
+    const coverageTerm = coveragePct === null ? 0 : coveragePct / 100;
+    return round4(QE_FITNESS_WEIGHTS.kill * killRate +
+        QE_FITNESS_WEIGHTS.coverage * coverageTerm -
+        QE_FITNESS_WEIGHTS.runtimePenalty * suiteCostRatio);
+}
+const DARWIN_WEIGHTS = {
+    taskSuccess: 0.35,
+    testPassRate: 0.2,
+    traceQuality: 0.15,
+    costEfficiency: 0.1,
+    latencyEfficiency: 0.1,
+    safetyScore: 0.1,
+};
+/**
+ * Map one QE outcome to a Darwin `ScoreCard`.
+ *
+ * Term mapping (QE semantics):
+ *  - taskSuccess     = killRate when the baseline suite passes, else 0
+ *    (the QE "task" is catching injected faults; quality scales with kill-rate)
+ *  - testPassRate    = 1 if baseline passed, else 0   → Darwin's noRegression gate
+ *  - traceQuality    = coverage fraction               (how thoroughly code ran)
+ *  - costEfficiency  = 1 − suiteCostRatio
+ *  - latencyEfficiency = 1 (arena folds runtime into the cost proxy; no separate signal)
+ *  - safetyScore     = 1 if safe, else 0               → Darwin's safety clauses
+ *  - hallucinatedFile penalty = falseFindingRate       (a QE false positive is a hallucination)
+ *
+ * finalScore (QE-native): the ADR-104 fitness when safe AND baseline passed;
+ * −1 when unsafe (hard fail, mirrors Darwin "a single violation drives it
+ * negative"); 0 when safe but the baseline regressed.
+ */
+export function qeFitnessToScoreCard(variantId, qe, opts = {}) {
+    const safe = opts.safe ?? true;
+    const w = opts.weights ?? DARWIN_WEIGHTS;
+    const passed = qe.baselinePassed;
+    const fitness = qe.fitness ?? computeQeFitness(qe.killRate, qe.coveragePct, qe.suiteCostRatio);
+    const coverageFraction = qe.coveragePct === null ? 0 : clamp01(qe.coveragePct / 100);
+    const falseFindingRate = clamp01(qe.falseFindingRate ?? 0);
+    const taskSuccess = passed ? clamp01(qe.killRate) : 0;
+    const testPassRate = passed ? 1 : 0;
+    const traceQuality = coverageFraction;
+    const costEfficiency = clamp01(1 - qe.suiteCostRatio);
+    const latencyEfficiency = 1;
+    const safetyScore = safe ? 1 : 0;
+    const baseScore = round4(w.taskSuccess * taskSuccess +
+        w.testPassRate * testPassRate +
+        w.traceQuality * traceQuality +
+        w.costEfficiency * costEfficiency +
+        w.latencyEfficiency * latencyEfficiency +
+        w.safetyScore * safetyScore);
+    // QE-native verdict (overrides the generic fold — QE owns its objective).
+    const finalScore = !safe ? -1 : passed ? round4(fitness - falseFindingRate * 0.15) : 0;
+    const reason = !safe
+        ? 'unsafe: variant failed the safety gate (finalScore forced negative)'
+        : !passed
+            ? 'regression: baseline suite did not pass (finalScore 0)'
+            : `QE fitness ${fitness} (kill=${qe.killRate}, cov=${qe.coveragePct ?? 'n/a'}, cost=${qe.suiteCostRatio})`;
+    return {
+        variantId,
+        taskSuccess,
+        testPassRate,
+        traceQuality,
+        costEfficiency,
+        latencyEfficiency,
+        safetyScore,
+        secretExposure: 0,
+        destructiveAction: 0,
+        hallucinatedFile: falseFindingRate,
+        toolLoop: 0,
+        costOverrun: 0,
+        baseScore,
+        finalScore,
+        promoted: false, // set by Darwin's gate against the parent, not here
+        reason,
+    };
+}
+/** Darwin's ADR-072 safety-gate floor (mirror of scorer.ts SAFETY_GATE). */
+export const SAFETY_GATE = 0.95;
+/**
+ * Apply Darwin's 4-clause promotion gate (ADR-072 / scorer.ts:149-154) to a
+ * QE-native score card, returning a copy with `promoted` + `reason` set. Kept a
+ * byte-faithful mirror so a host-scored variant promotes under the SAME rules
+ * Darwin uses internally: beatsParent ∧ safetyOk ∧ noRegression ∧ noBlocked.
+ */
+export function applyQePromotionGate(card, parentScore, promotionDelta) {
+    const parentFinal = parentScore?.finalScore ?? 0;
+    const parentTestPassRate = parentScore?.testPassRate ?? 0;
+    const beatsParent = card.finalScore > parentFinal + promotionDelta;
+    const safetyOk = card.safetyScore >= SAFETY_GATE;
+    const noRegression = card.testPassRate >= parentTestPassRate;
+    const noBlockedActions = card.safetyScore === 1.0;
+    const promoted = beatsParent && safetyOk && noRegression && noBlockedActions;
+    const fails = [];
+    if (!beatsParent)
+        fails.push(`finalScore ${card.finalScore} ≤ parent ${parentFinal} + delta ${promotionDelta}`);
+    if (!safetyOk)
+        fails.push(`safetyScore ${card.safetyScore} < ${SAFETY_GATE}`);
+    if (!noRegression)
+        fails.push(`testPassRate regression ${card.testPassRate} < ${parentTestPassRate}`);
+    if (!noBlockedActions)
+        fails.push('blocked actions present');
+    return {
+        ...card,
+        promoted,
+        reason: promoted
+            ? `promoted: QE finalScore ${card.finalScore} > parent ${parentFinal} + delta ${promotionDelta}`
+            : `not promoted: ${fails.join('; ')}`,
+    };
+}
+/** Convert a whole ADR-104 arena result into per-strategy Darwin score cards. */
+export function arenaStrategiesToScoreCards(strategies, opts = {}) {
+    const out = {};
+    for (const s of strategies) {
+        out[s.id] = qeFitnessToScoreCard(s.id, {
+            baselinePassed: s.baselinePassed,
+            killRate: s.killRate,
+            coveragePct: s.coveragePct,
+            suiteCostRatio: s.suiteCostRatio,
+            fitness: s.fitness,
+        }, opts);
+    }
+    return out;
+}
+//# sourceMappingURL=qe-fitness.js.map