agentic-qe 3.10.9 → 3.11.0

package/dist/cli/chunks/workflow-orchestrator-42B62D3V.js

@@ -0,0 +1,2 @@
+import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.11.0");process.exit(0)}
+import{a,b,c,d}from"./chunk-I2HQLBWG.js";import"./chunk-RPYYS6BX.js";import"./chunk-QYXTESM3.js";import"./chunk-L7GQKJLV.js";import"./chunk-C4OYHUJV.js";import"./chunk-F62ZQZQQ.js";import"./chunk-T6KT63NC.js";import"./chunk-Y7TBCHW4.js";import"./chunk-RVQW6CBF.js";import"./chunk-XMZ2DHUL.js";import"./chunk-BA4WZIAQ.js";import"./chunk-JN3IQB4L.js";import"./chunk-ZT4NPTML.js";import"./chunk-FGOVDO3R.js";import"./chunk-RKDNLPZM.js";import"./chunk-G5VE3HQW.js";import"./chunk-LCDRRAES.js";import"./chunk-XVQUVCFR.js";import"./chunk-J425SQFE.js";import"./chunk-73EWPVBJ.js";import"./chunk-YQIMO7VJ.js";import"./chunk-ACV2WVMX.js";export{b as DEFAULT_WORKFLOW_CONFIG,a as WorkflowEvents,c as WorkflowOrchestrator,d as createWorkflowOrchestrator};

package/dist/cli/chunks/{wrappers-ERTQNIPK.js → wrappers-M5C7DONW.js}

@@ -1,2 +1,2 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.10.9");process.exit(0)}
-import{a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v as L,w as M,x as N}from"./chunk-JZNMU63B.js";import{a as v,b as w,c as x,d as y,e as z,f as A,g as B,h as C,i as D,j as E,k as F,l as G,m as H,n as I,o as J,p as K}from"./chunk-KJA5A3TV.js";import"./chunk-L5NEEGKO.js";import"./chunk-TOGD2JH2.js";import"./chunk-OPKEQYAC.js";import"./chunk-VHYNRISI.js";import"./chunk-ZT2DGSIO.js";import"./chunk-246Z3PH6.js";import"./chunk-OSP5AJAB.js";import"./chunk-5U5SEO7C.js";import"./chunk-D7NWDUY3.js";import"./chunk-L5IO7QNO.js";import"./chunk-4BB75U6N.js";import"./chunk-WOGWIMQK.js";import"./chunk-XEMP2PNW.js";import"./chunk-C6GQIUKW.js";import"./chunk-CWRSQQHV.js";import"./chunk-3HT4CT6F.js";import"./chunk-KRAWWBX5.js";import"./chunk-ABJPFKHE.js";export{z as GNNLayerFactory,i as QEFlashAttention,x as QEGNNEmbeddingIndex,y as QEGNNIndexFactory,a as QESONA,e as QE_FLASH_ATTENTION_CONFIG,g as QE_PERFORMANCE_TARGETS,f as QE_SONA_CONFIG,A as TensorCompressionFactory,u as batchComputeAttention,K as batchDifferentiableSearch,M as checkRuvectorPackagesAvailable,c as createDomainQESONA,j as createQEFlashAttention,b as createQESONA,D as getDifferentiableSearch,F as getGetCompressionLevel,E as getHierarchicalForward,G as getInit,h as getOptimalBlockConfig,k as getQEFlashAttentionConfig,n as getRuvectorDotProductAttention,m as getRuvectorFlashAttention,p as getRuvectorHyperbolicAttention,B as getRuvectorLayer,q as getRuvectorLinearAttention,r as getRuvectorMoEAttention,o as getRuvectorMultiHeadAttention,L as getRuvectorPackageVersions,C as getTensorCompress,l as getWorkloadTypes,N as initAllRuvectorPackages,w as initGNN,d as isAttentionAvailable,v as isGNNAvailable,s as toFloat32Array,H as toFloat32ArrayGNN,J as toIEmbedding,t as toNumberArrayAttn,I as toNumberArrayGNN};
+import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.11.0");process.exit(0)}
+import{a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v as L,w as M,x as N}from"./chunk-MTSMFEWK.js";import{a as v,b as w,c as x,d as y,e as z,f as A,g as B,h as C,i as D,j as E,k as F,l as G,m as H,n as I,o as J,p as K}from"./chunk-QZQGYSDG.js";import"./chunk-QYXTESM3.js";import"./chunk-L7GQKJLV.js";import"./chunk-C4OYHUJV.js";import"./chunk-F62ZQZQQ.js";import"./chunk-T6KT63NC.js";import"./chunk-Y7TBCHW4.js";import"./chunk-RVQW6CBF.js";import"./chunk-BA4WZIAQ.js";import"./chunk-ZT4NPTML.js";import"./chunk-FGOVDO3R.js";import"./chunk-RKDNLPZM.js";import"./chunk-G5VE3HQW.js";import"./chunk-LCDRRAES.js";import"./chunk-XVQUVCFR.js";import"./chunk-J425SQFE.js";import"./chunk-73EWPVBJ.js";import"./chunk-YQIMO7VJ.js";import"./chunk-ACV2WVMX.js";export{z as GNNLayerFactory,i as QEFlashAttention,x as QEGNNEmbeddingIndex,y as QEGNNIndexFactory,a as QESONA,e as QE_FLASH_ATTENTION_CONFIG,g as QE_PERFORMANCE_TARGETS,f as QE_SONA_CONFIG,A as TensorCompressionFactory,u as batchComputeAttention,K as batchDifferentiableSearch,M as checkRuvectorPackagesAvailable,c as createDomainQESONA,j as createQEFlashAttention,b as createQESONA,D as getDifferentiableSearch,F as getGetCompressionLevel,E as getHierarchicalForward,G as getInit,h as getOptimalBlockConfig,k as getQEFlashAttentionConfig,n as getRuvectorDotProductAttention,m as getRuvectorFlashAttention,p as getRuvectorHyperbolicAttention,B as getRuvectorLayer,q as getRuvectorLinearAttention,r as getRuvectorMoEAttention,o as getRuvectorMultiHeadAttention,L as getRuvectorPackageVersions,C as getTensorCompress,l as getWorkloadTypes,N as initAllRuvectorPackages,w as initGNN,d as isAttentionAvailable,v as isGNNAvailable,s as toFloat32Array,H as toFloat32ArrayGNN,J as toIEmbedding,t as toNumberArrayAttn,I as toNumberArrayGNN};

package/dist/domains/test-generation/coordinator.d.ts

@@ -8,6 +8,7 @@
  * - DecisionTransformer for test case selection
  */
 import { Result } from '../../shared/types';
+import { type RoutingFeedbackLike } from '../../routing/free-tier/index.js';
 import { EventBus, MemoryBackend, AgentCoordinator } from '../../kernel/interfaces';
 import type { HybridRouter } from '../../shared/llm/router/hybrid-router.js';
 import { GenerateTestsRequest, GeneratedTests, TDDRequest, TDDResult, PropertyTestRequest, PropertyTests, TestDataRequest, TestData, LearnPatternsRequest, LearnedPatterns, TestGenerationAPI } from './interfaces';
@@ -61,6 +62,16 @@ export interface CoordinatorConfig extends BaseDomainCoordinatorConfig {
     blockOnIncoherentRequirements: boolean;
     enrichOnRetrievalLane: boolean;
     consensusConfig?: Partial<ConsensusEnabledConfig>;
+    /**
+     * Opt-in (plan 06, D7-wire): try a FREE local model first for test generation,
+     * with a same-tier repair loop (D8), before the normal LLM path. OFF by default
+     * — also enables via env `AQE_FREE_TIER=1`. Local-only / no paid escalation yet.
+     */
+    enableFreeTier?: boolean;
+    /** Local model id for the free tier (default 'qwen3:8b' or env AQE_FREE_TIER_MODEL). */
+    freeTierModel?: string;
+    /** Same-tier repair retries on a failed free-tier generation (D8). Default 1. */
+    freeTierRepairAttempts?: number;
 }
 type TestGenWorkflowType = 'generate' | 'tdd' | 'property' | 'data' | 'learn';
 export declare class TestGenerationCoordinator extends BaseDomainCoordinator<CoordinatorConfig, TestGenWorkflowType> implements ITestGenerationCoordinator {
@@ -70,13 +81,17 @@ export declare class TestGenerationCoordinator extends BaseDomainCoordinator<Coo
     private readonly hookRegistry?;
     private readonly testGenerator;
     private readonly patternMatcher;
+    /** Opt-in free-tier local executor (null unless enabled). */
+    private freeTierExecutor;
     private qesona;
     private flashAttention;
     private decisionTransformer;
     private testEmbeddings;
     private recentDreamInsights;
     private coherenceGate;
-    constructor(eventBus: EventBus, memory: MemoryBackend, agentCoordinator: AgentCoordinator, config?: Partial<CoordinatorConfig>, llmRouter?: HybridRouter, coherenceService?: (ICoherenceService | null) | undefined, hookRegistry?: (QEHookRegistry | null) | undefined);
+    constructor(eventBus: EventBus, memory: MemoryBackend, agentCoordinator: AgentCoordinator, config?: Partial<CoordinatorConfig>, llmRouter?: HybridRouter, coherenceService?: (ICoherenceService | null) | undefined, hookRegistry?: (QEHookRegistry | null) | undefined, 
+    /** Optional D9 sink — when provided, free-tier outcomes feed routing-feedback. */
+    routingFeedback?: RoutingFeedbackLike | null);
     protected onInitialize(): Promise<void>;
     protected onDispose(): Promise<void>;
     /**
@@ -98,6 +113,14 @@ export declare class TestGenerationCoordinator extends BaseDomainCoordinator<Coo
      * - Verifies test pattern selections for high-stakes decisions
      */
     generateTests(request: GenerateTestsRequest): Promise<Result<GeneratedTests, Error>>;
+    /**
+     * Opt-in free-tier local test generation (plan 06, D7-wire/D8/D9).
+     * Reads the first source file, asks the FREE local model to write tests,
+     * verifies the output is a real test (has a test + an assertion) with a
+     * same-tier repair loop, and parses it into a minimal GeneratedTests.
+     * Returns null on ANY miss so the caller falls back to the normal path.
+     */
+    private tryFreeTierGeneration;
     /**
      * Generate tests using TDD workflow
      */

package/dist/domains/test-generation/coordinator.js

@@ -9,8 +9,11 @@
  */
 import { LoggerFactory } from '../../logging/index.js';
 import { v4 as uuidv4 } from 'uuid';
-import { err, } from '../../shared/types';
+import { readFile } from 'node:fs/promises';
+import { ok, err, } from '../../shared/types';
 import { toError } from '../../shared/error-utils.js';
+// Opt-in free-tier local test generation (cross-pollination plan 06, D7-wire/D8/D9).
+import { FreeTierEscalatingExecutor, defaultFreeTierLadder, createRoutingFeedbackSink, } from '../../routing/free-tier/index.js';
 import { TestGenerationEvents, LearningOptimizationEvents, createEvent, } from '../../shared/events/domain-events';
 import { createTestGeneratorServiceWithDependencies, } from './services/test-generator';
 import { PatternMatcherService, } from './services/pattern-matcher';
@@ -52,6 +55,8 @@ const DEFAULT_CONFIG = {
     consensusThreshold: 0.7,
     consensusStrategy: 'weighted',
     consensusMinModels: 2,
+    // Free-tier local generation is OFF by default (opt-in).
+    enableFreeTier: false,
 };
 /**
  * Test Generation Coordinator
@@ -71,6 +76,15 @@ const DEFAULT_CONFIG = {
  * - Verifies test patterns, mock strategies, and edge cases
  */
 const logger = LoggerFactory.create('test-generation');
+/** Strip a single ```fenced``` block if the model wrapped its output (free-tier path). */
+function stripFence(text) {
+    const m = text.match(/```(?:[a-zA-Z0-9]+)?\n([\s\S]*?)\n```/);
+    return (m ? m[1] : text).trim();
+}
+/** Derive a test file path from a source path: `foo.ts` → `foo.test.ts` (free-tier path). */
+function deriveTestFilePath(src) {
+    return src.replace(/\.([cm]?[jt]sx?)$/, '.test.$1');
+}
 export class TestGenerationCoordinator extends BaseDomainCoordinator {
     memory;
     agentCoordinator;
@@ -78,6 +92,8 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
     hookRegistry;
     testGenerator;
     patternMatcher;
+    /** Opt-in free-tier local executor (null unless enabled). */
+    freeTierExecutor = null;
     // @ruvector integrations (ADR-040)
     qesona = null;
     flashAttention = null;
@@ -87,7 +103,9 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
     recentDreamInsights = [];
     // Coherence gate (ADR-052)
     coherenceGate = null;
-    constructor(eventBus, memory, agentCoordinator, config = {}, llmRouter, coherenceService, hookRegistry) {
+    constructor(eventBus, memory, agentCoordinator, config = {}, llmRouter, coherenceService, hookRegistry, 
+    /** Optional D9 sink — when provided, free-tier outcomes feed routing-feedback. */
+    routingFeedback) {
         const fullConfig = { ...DEFAULT_CONFIG, ...config };
         super(eventBus, 'test-generation', fullConfig, {
             verifyFindingTypes: [
@@ -105,6 +123,36 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
         // ADR-043 wiring: dependencies factory accepts llmRouter.
         this.testGenerator = createTestGeneratorServiceWithDependencies({ memory, llmRouter });
         this.patternMatcher = new PatternMatcherService(memory);
+        // Opt-in free-tier local generation (plan 06, D7-wire/D8/D9). OFF by default;
+        // local-only with a same-tier repair loop and NO paid escalation yet.
+        const freeTierOn = this.config.enableFreeTier === true || process.env.AQE_FREE_TIER === '1';
+        if (freeTierOn) {
+            const model = this.config.freeTierModel || process.env.AQE_FREE_TIER_MODEL || 'qwen3:8b';
+            // Paid escalation: delegate Claude tiers to the existing HybridRouter, mapping
+            // the ladder tier to a complexity hint so the router selects that tier. When no
+            // router is wired, the executor stays local-only (Claude tiers report unavailable).
+            const claudeRunner = llmRouter
+                ? async (tier, msgs) => {
+                    const complexity = tier === 'opus' ? 'high' : tier === 'sonnet' ? 'medium' : 'low';
+                    const resp = await llmRouter.chat({
+                        messages: msgs.map((m) => ({ role: m.role, content: m.content })),
+                        agentType: 'qe-test-architect',
+                        complexity,
+                    });
+                    return { content: resp.content };
+                }
+                : undefined;
+            this.freeTierExecutor = new FreeTierEscalatingExecutor({
+                ladder: defaultFreeTierLadder(model),
+                claudeRunner,
+                defaultRepairAttempts: this.config.freeTierRepairAttempts ?? 1,
+                onOutcome: routingFeedback
+                    ? createRoutingFeedbackSink(routingFeedback, { taskKind: 'test-generation' }) // D9
+                    : undefined,
+            });
+            logger.info(`Free-tier local test generation enabled (model=${model}, repair, ` +
+                `${claudeRunner ? 'escalation→HybridRouter' : 'local-only'})`);
+        }
         // Initialize coherence gate if service is provided (ADR-052)
         if (this.config.enableCoherenceGate && coherenceService) {
             this.coherenceGate = createTestGenerationCoherenceGate(coherenceService, undefined, // Use default embedding service
@@ -219,6 +267,21 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
         try {
             // Create workflow tracking
             this.startWorkflow(workflowId, 'generate');
+            // Opt-in (plan 06, D7-wire): try the FREE local model first with a repair
+            // loop. Fully guarded — any miss falls through to the normal LLM path.
+            if (this.freeTierExecutor) {
+                try {
+                    const ft = await this.tryFreeTierGeneration(request);
+                    if (ft) {
+                        this.completeWorkflow(workflowId);
+                        logger.info(`Free-tier local generation produced ${ft.tests.length} test file(s); skipped paid path`);
+                        return ok(ft);
+                    }
+                }
+                catch (e) {
+                    logger.debug('Free-tier generation failed; falling back to the normal path');
+                }
+            }
             // ADR-047: Check topology health before expensive operations
             if (this.config.enableMinCutAwareness && !this.isTopologyHealthy()) {
                 logger.warn('Topology degraded, using conservative strategy');
@@ -361,6 +424,78 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
             return { success: false, error: err };
         }
     }
+    /**
+     * Opt-in free-tier local test generation (plan 06, D7-wire/D8/D9).
+     * Reads the first source file, asks the FREE local model to write tests,
+     * verifies the output is a real test (has a test + an assertion) with a
+     * same-tier repair loop, and parses it into a minimal GeneratedTests.
+     * Returns null on ANY miss so the caller falls back to the normal path.
+     */
+    async tryFreeTierGeneration(request) {
+        if (!this.freeTierExecutor)
+            return null;
+        // Single-file only: the cheap-first path generates one test file. For
+        // multi-file requests fall back to the normal path so EVERY file is covered.
+        if (!request.sourceFiles || request.sourceFiles.length !== 1)
+            return null;
+        const src = request.sourceFiles[0];
+        if (!src)
+            return null;
+        let code = '';
+        try {
+            code = await readFile(src, 'utf8');
+        }
+        catch {
+            return null; // unreadable → fall back
+        }
+        if (!code.trim())
+            return null;
+        const framework = request.framework ?? 'vitest';
+        const messages = [
+            { role: 'system', content: `You write ${framework} tests. Output ONLY a single fenced code block — no prose.` },
+            {
+                role: 'user',
+                content: `Write ${framework} ${request.testType ?? 'unit'} tests for this file ` +
+                    `(aim for ~${request.coverageTarget ?? 80}% coverage). Use real assertions.\n\n` +
+                    '```\n' + code.slice(0, 6000) + '\n```',
+            },
+        ];
+        // Objective oracle: output must contain a test block AND an assertion.
+        const verify = (out) => {
+            const hasTest = /\b(test|it|describe)\s*\(/.test(out);
+            const hasAssert = /\b(expect|assert)\s*\(/.test(out);
+            return hasTest && hasAssert
+                ? { passed: true }
+                : { passed: false, feedback: 'output must contain a test (test/it/describe) with an assertion (expect/assert)' };
+        };
+        const r = await this.freeTierExecutor.execute({
+            agentId: `test-gen:${src}`,
+            messages,
+            verify,
+            // Cheap-first: try local + repair, then escalate the hard tail up the
+            // ladder via the HybridRouter (when wired). Local-only if no router.
+            escalate: true,
+            repairAttempts: this.config.freeTierRepairAttempts ?? 1,
+        });
+        if (!r.ok)
+            return null;
+        const testCode = stripFence(r.content);
+        const assertions = (testCode.match(/\b(?:expect|assert)\s*\(/g) ?? []).length;
+        if (assertions === 0)
+            return null;
+        const test = {
+            id: uuidv4(),
+            name: `free-tier:${src.split('/').pop() ?? src}`,
+            sourceFile: src,
+            testFile: deriveTestFilePath(src),
+            testCode,
+            type: request.testType ?? 'unit',
+            assertions,
+            framework,
+            llmEnhanced: true,
+        };
+        return { tests: [test], coverageEstimate: 0, patternsUsed: ['free-tier-local', `tier:${r.tierUsed}`] };
+    }
     /**
      * Generate tests using TDD workflow
      */

package/dist/domains/test-generation/plugin.js

@@ -5,6 +5,8 @@
 import { err } from '../../shared/types';
 import { BaseDomainPlugin } from '../domain-interface';
 import { TestGenerationCoordinator, } from './coordinator';
+// D9: live routing-feedback so free-tier outcomes lift routing confidence.
+import { RoutingFeedbackCollector } from '../../routing/routing-feedback.js';
 import { createTestGeneratorServiceWithDependencies, } from './services/test-generator';
 import { toError } from '../../shared/error-utils.js';
 import { PatternMatcherService, } from './services/pattern-matcher';
@@ -149,8 +151,28 @@ export class TestGenerationPlugin extends BaseDomainPlugin {
         // so analyzeXxxWithLLM branches become reachable.
         this.testGenerator = createTestGeneratorServiceWithDependencies({ memory: this.memory, llmRouter: this.llmRouter }, this.pluginConfig.testGenerator);
         this.patternMatcher = new PatternMatcherService(this.memory, this.pluginConfig.patternMatcher);
+        // D9: when the free tier is opted in, stand up a live RoutingFeedbackCollector
+        // (calibrator + auto-escalation enabled) so each cheap-vs-escalated outcome
+        // feeds routing confidence. Memory-only fallback if the DB is unavailable.
+        let routingFeedback;
+        const freeTierOn = this.pluginConfig.coordinator?.enableFreeTier === true || process.env.AQE_FREE_TIER === '1';
+        if (freeTierOn) {
+            routingFeedback = new RoutingFeedbackCollector(10000, {
+                enableEMACalibration: true,
+                enableAutoEscalation: true,
+            });
+            try {
+                await routingFeedback.initialize();
+            }
+            catch {
+                // memory-only is fine — recording still drives calibration/escalation
+            }
+        }
         // Create coordinator
-        this.coordinator = new TestGenerationCoordinator(this.eventBus, this.memory, this.agentCoordinator, this.pluginConfig.coordinator, this.llmRouter);
+        this.coordinator = new TestGenerationCoordinator(this.eventBus, this.memory, this.agentCoordinator, this.pluginConfig.coordinator, this.llmRouter, undefined, // coherenceService
+        undefined, // hookRegistry
+        routingFeedback // D9 sink (undefined unless free tier is on)
+        );
         // Initialize coordinator
         await this.coordinator.initialize();
         // Issue #205 fix: Start with 'idle' status (0 agents)

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

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

@@ -0,0 +1,62 @@
+/**
+ * Darwin Mode integration — local type mirror (Phase-0, zero-coupling).
+ *
+ * These interfaces STRUCTURALLY mirror `@metaharness/darwin`'s
+ * `packages/darwin-mode/src/types.ts` (ADR-072 ScoreCard) so AQE can produce
+ * Darwin-compatible scores WITHOUT a build-time dependency on the pre-1.0
+ * MetaHarness package (per cross-pollination plan 05: Phase-0 actions stay
+ * decoupled). If/when a version contract lands (plan A8), replace this with a
+ * real import.
+ *
+ * Source of truth at time of writing: @metaharness/darwin@0.2.1.
+ */
+/** The seven mutation surfaces (mirror of Darwin's MutationSurface). */
+export type MutationSurface = 'planner' | 'contextBuilder' | 'reviewer' | 'retryPolicy' | 'toolPolicy' | 'memoryPolicy' | 'scorePolicy';
+/**
+ * Mirror of Darwin's `ScoreCard` (ADR-072). All terms/penalties ∈ [0,1].
+ * Darwin's frozen scorer folds the positive terms with fixed weights:
+ *   baseScore = 0.35·taskSuccess + 0.20·testPassRate + 0.15·traceQuality
+ *             + 0.10·costEfficiency + 0.10·latencyEfficiency + 0.10·safetyScore
+ * then subtracts the penalty layer to get finalScore.
+ */
+export interface DarwinScoreCard {
+    variantId: string;
+    taskSuccess: number;
+    testPassRate: number;
+    traceQuality: number;
+    costEfficiency: number;
+    latencyEfficiency: number;
+    safetyScore: number;
+    secretExposure: number;
+    destructiveAction: number;
+    hallucinatedFile: number;
+    toolLoop: number;
+    costOverrun: number;
+    baseScore: number;
+    finalScore: number;
+    promoted: boolean;
+    reason: string;
+}
+/**
+ * The objective QE outcome of evaluating one harness variant on a QE task.
+ * Shaped to AQE's ADR-104 arena `EvaluatedStrategy`, but generic enough for any
+ * QE scorer (mutation, coverage, false-finding).
+ */
+export interface QeFitness {
+    /** Did the suite pass on un-mutated code? A regression here disqualifies. */
+    baselinePassed: boolean;
+    /** Mutation kill-rate ∈ [0,1] — the headline QE quality signal. */
+    killRate: number;
+    /** Line coverage percentage ∈ [0,100], or null when uncollected. */
+    coveragePct: number | null;
+    /** Deterministic cost proxy ∈ [0,1] (selected groups / total). */
+    suiteCostRatio: number;
+    /**
+     * Blended QE fitness (ADR-104): 0.6·killRate + 0.3·(coverage/100) − 0.1·cost.
+     * Optional — recomputed from the parts when omitted.
+     */
+    fitness?: number;
+    /** False-finding rate ∈ [0,1] — drives a hallucination penalty when > 0. */
+    falseFindingRate?: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/integrations/darwin/types.js

@@ -0,0 +1,14 @@
+/**
+ * Darwin Mode integration — local type mirror (Phase-0, zero-coupling).
+ *
+ * These interfaces STRUCTURALLY mirror `@metaharness/darwin`'s
+ * `packages/darwin-mode/src/types.ts` (ADR-072 ScoreCard) so AQE can produce
+ * Darwin-compatible scores WITHOUT a build-time dependency on the pre-1.0
+ * MetaHarness package (per cross-pollination plan 05: Phase-0 actions stay
+ * decoupled). If/when a version contract lands (plan A8), replace this with a
+ * real import.
+ *
+ * Source of truth at time of writing: @metaharness/darwin@0.2.1.
+ */
+export {};
+//# sourceMappingURL=types.js.map