agentic-qe 3.10.9 → 3.11.1

package/dist/cli/chunks/workflow-orchestrator-QU652FLH.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.1");process.exit(0)}
+import{a,b,c,d}from"./chunk-7GP7ZG3K.js";import"./chunk-5PSIKJL5.js";import"./chunk-437XL5VZ.js";import"./chunk-W6RS5S4Q.js";import"./chunk-57WGS6BI.js";import"./chunk-S7IHSELP.js";import"./chunk-IUVAWWQG.js";import"./chunk-N6NSZG7Z.js";import"./chunk-S456W64P.js";import"./chunk-EQYDPF52.js";import"./chunk-QEDS3MOJ.js";import"./chunk-B6U56VWG.js";import"./chunk-X2OVUBF6.js";import"./chunk-FBOPSWF6.js";import"./chunk-FOD6JEEU.js";import"./chunk-NKCL6RAF.js";import"./chunk-VRHLHGKR.js";import"./chunk-44HXRFOP.js";import"./chunk-O75SVMMB.js";import"./chunk-D6MPGK7R.js";import"./chunk-N4OWZLH5.js";import"./chunk-7SRSOZMP.js";export{b as DEFAULT_WORKFLOW_CONFIG,a as WorkflowEvents,c as WorkflowOrchestrator,d as createWorkflowOrchestrator};

package/dist/cli/chunks/{wrappers-ERTQNIPK.js → wrappers-3STST7QW.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.1");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-SZPTUV3B.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-ZKPOKMJZ.js";import"./chunk-437XL5VZ.js";import"./chunk-W6RS5S4Q.js";import"./chunk-57WGS6BI.js";import"./chunk-S7IHSELP.js";import"./chunk-IUVAWWQG.js";import"./chunk-N6NSZG7Z.js";import"./chunk-S456W64P.js";import"./chunk-QEDS3MOJ.js";import"./chunk-X2OVUBF6.js";import"./chunk-FBOPSWF6.js";import"./chunk-FOD6JEEU.js";import"./chunk-NKCL6RAF.js";import"./chunk-VRHLHGKR.js";import"./chunk-44HXRFOP.js";import"./chunk-O75SVMMB.js";import"./chunk-D6MPGK7R.js";import"./chunk-N4OWZLH5.js";import"./chunk-7SRSOZMP.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/requirements-validation/coordinator.d.ts

@@ -9,6 +9,7 @@
 import { Result } from '../../shared/types/index.js';
 import { EventBus, MemoryBackend, AgentCoordinator } from '../../kernel/interfaces.js';
 import type { HybridRouter } from '../../shared/llm/router/hybrid-router.js';
+import { type FreeTierCoordinatorConfig, type RoutingFeedbackLike } from '../../routing/free-tier/index.js';
 import { IRequirementsValidationCoordinator, RequirementAnalysis, TestArtifacts, SprintValidation } from './interfaces.js';
 import { BaseDomainCoordinator, type BaseDomainCoordinatorConfig } from '../base-domain-coordinator.js';
 import { type DomainFinding } from '../../coordination/consensus/domain-findings.js';
@@ -22,7 +23,7 @@ export declare const RequirementsValidationEvents: {
 /**
  * CQ-002: Extends BaseDomainCoordinatorConfig — removes duplicate fields
  */
-export interface CoordinatorConfig extends BaseDomainCoordinatorConfig {
+export interface CoordinatorConfig extends BaseDomainCoordinatorConfig, FreeTierCoordinatorConfig {
     minTestabilityThreshold: number;
     enablePPO: boolean;
     enableSONA: boolean;
@@ -45,10 +46,14 @@ export declare class RequirementsValidationCoordinator extends BaseDomainCoordin
     private readonly bddWriter;
     private readonly testabilityScorer;
     private readonly repository;
+    /** Opt-in cheap-first BDD scenario generation (plan 06, ADR-111). Null = off. */
+    private readonly freeTierExecutor;
     private ppoAlgorithm?;
     private sonaEngine?;
     private rlInitialized;
-    constructor(eventBus: EventBus, memory: MemoryBackend, agentCoordinator: AgentCoordinator, config?: Partial<CoordinatorConfig>, llmRouter?: HybridRouter);
+    constructor(eventBus: EventBus, memory: MemoryBackend, agentCoordinator: AgentCoordinator, config?: Partial<CoordinatorConfig>, llmRouter?: HybridRouter, 
+    /** Optional D9 sink — when provided, free-tier outcomes feed routing-feedback. */
+    routingFeedback?: RoutingFeedbackLike | null);
     /**
      * Initialize the coordinator
      * CQ-002: Domain-specific initialization
@@ -74,6 +79,15 @@ export declare class RequirementsValidationCoordinator extends BaseDomainCoordin
     /**
      * Generate test artifacts from requirement
      */
+    /**
+     * Cheap-first BDD generation (plan 06 broadening; ADR-111 escalation lane).
+     * Generates raw Gherkin on the free local tier (best-effort), verifies Gherkin
+     * STRUCTURE as the objective oracle (§10 — never the model's own judgement),
+     * parses it back into structured scenarios, and escalates the hard tail via the
+     * router. Returns null when off or nothing usable → caller falls back to the
+     * normal structured path. Off by default.
+     */
+    private tryFreeTierScenarios;
     generateTestArtifacts(requirementId: string): Promise<Result<TestArtifacts>>;
     /**
      * Validate sprint requirements

package/dist/domains/requirements-validation/coordinator.js

@@ -10,6 +10,7 @@ import { v4 as uuidv4 } from 'uuid';
 import { LoggerFactory } from '../../logging/index.js';
 import { ok, err } from '../../shared/types/index.js';
 import { toError } from '../../shared/error-utils.js';
+import { buildFreeTierExecutor, } from '../../routing/free-tier/index.js';
 import { createEvent } from '../../shared/events/domain-events.js';
 import { RequirementsValidatorService } from './services/requirements-validator.js';
 import { BDDScenarioWriterService } from './services/bdd-scenario-writer.js';
@@ -93,6 +94,25 @@ class InMemoryRequirementRepository {
  * CQ-002: Extends BaseDomainCoordinator
  */
 const logger = LoggerFactory.create('requirements-validation');
+/** Strip a ```gherkin fence (truncation-robust); else return the text as-is. */
+function stripGherkinFence(s) {
+    s = (s ?? '').trim();
+    const full = /```(?:gherkin|feature)?\s*([\s\S]*?)```/.exec(s);
+    if (full)
+        return full[1].trim();
+    const open = /```(?:gherkin|feature)?[^\n]*\n([\s\S]*)$/.exec(s);
+    return open ? open[1].trim() : s;
+}
+const GHERKIN_STOPWORDS = new Set([
+    'given', 'when', 'then', 'scenario', 'feature', 'with', 'that', 'this', 'from', 'into',
+    'should', 'must', 'have', 'will', 'shall', 'able', 'user', 'users', 'system', 'value',
+    'valid', 'invalid', 'returns', 'return', 'apply', 'using', 'based', 'their', 'they',
+]);
+/** Significant lowercased terms (>3 chars, non-stopword) from a requirement. */
+function significantTerms(requirement) {
+    const src = `${requirement.title} ${(requirement.acceptanceCriteria ?? []).join(' ')}`.toLowerCase();
+    return Array.from(new Set(src.match(/[a-z][a-z0-9]{3,}/g) ?? [])).filter((w) => !GHERKIN_STOPWORDS.has(w));
+}
 export class RequirementsValidationCoordinator extends BaseDomainCoordinator {
     memory;
     agentCoordinator;
@@ -100,11 +120,15 @@ export class RequirementsValidationCoordinator extends BaseDomainCoordinator {
     bddWriter;
     testabilityScorer;
     repository;
+    /** Opt-in cheap-first BDD scenario generation (plan 06, ADR-111). Null = off. */
+    freeTierExecutor;
     // V3: RL and SONA integrations
     ppoAlgorithm;
     sonaEngine;
     rlInitialized = false;
-    constructor(eventBus, memory, agentCoordinator, config = {}, llmRouter) {
+    constructor(eventBus, memory, agentCoordinator, config = {}, llmRouter, 
+    /** Optional D9 sink — when provided, free-tier outcomes feed routing-feedback. */
+    routingFeedback) {
         const fullConfig = { ...DEFAULT_CONFIG, ...config };
         super(eventBus, 'requirements-validation', fullConfig, {
             verifyFindingTypes: ['requirement-conflict', 'testability-assessment', 'ambiguous-requirement'],
@@ -116,6 +140,16 @@ export class RequirementsValidationCoordinator extends BaseDomainCoordinator {
         this.bddWriter = new BDDScenarioWriterService(memory);
         this.testabilityScorer = new TestabilityScorerService(memory);
         this.repository = new InMemoryRequirementRepository(memory);
+        // Opt-in cheap-first BDD generation (plan 06 broadening; ADR-111 escalation
+        // lane). OFF by default; BDD/Gherkin is a bounded-gen + objective-oracle fit.
+        this.freeTierExecutor = buildFreeTierExecutor({
+            config: this.config,
+            agentType: 'qe-requirements-validator',
+            taskKind: 'requirements-validation',
+            llmRouter,
+            routingFeedback, // D9 sink (undefined unless wired by the plugin)
+            logger,
+        });
     }
     // ==========================================================================
     // BaseDomainCoordinator Template Methods
@@ -294,6 +328,72 @@ export class RequirementsValidationCoordinator extends BaseDomainCoordinator {
     /**
      * Generate test artifacts from requirement
      */
+    /**
+     * Cheap-first BDD generation (plan 06 broadening; ADR-111 escalation lane).
+     * Generates raw Gherkin on the free local tier (best-effort), verifies Gherkin
+     * STRUCTURE as the objective oracle (§10 — never the model's own judgement),
+     * parses it back into structured scenarios, and escalates the hard tail via the
+     * router. Returns null when off or nothing usable → caller falls back to the
+     * normal structured path. Off by default.
+     */
+    async tryFreeTierScenarios(requirement, scenarioCount) {
+        if (!this.freeTierExecutor)
+            return null;
+        const ac = (requirement.acceptanceCriteria ?? []).map((c, i) => `${i + 1}. ${c}`).join('\n');
+        const system = 'You write Gherkin .feature files. Output ONLY a single fenced ```gherkin code block — no prose.';
+        const user = `Write a Gherkin feature with ~${scenarioCount} scenarios for this requirement. ` +
+            'Use Feature/Scenario/Given/When/Then; cover the acceptance criteria and edge cases.\n\n' +
+            `Title: ${requirement.title}\nDescription: ${requirement.description}\n` +
+            (ac ? `Acceptance criteria:\n${ac}\n` : '');
+        // Objective oracle (structural proxy — does NOT execute the scenarios). Beyond
+        // bare structure it requires: parses to >=1 scenario, EVERY scenario has a
+        // non-empty Given/When/Then, AND the feature is RELEVANT to the requirement
+        // (token overlap) — so generic off-topic boilerplate is rejected, not rewarded
+        // (resists the §10 Goodhart trap). Still a proxy, not semantic ground truth.
+        const sigTerms = significantTerms(requirement);
+        const verify = (out) => {
+            const text = stripGherkinFence(out);
+            const structural = /\bFeature:/i.test(text) && /\bScenario:/i.test(text) &&
+                /\bGiven\b/i.test(text) && /\bWhen\b/i.test(text) && /\bThen\b/i.test(text);
+            if (!structural) {
+                return { passed: false, feedback: 'must be valid Gherkin: Feature:, Scenario:, and Given/When/Then steps' };
+            }
+            const parsed = this.bddWriter.parseGherkin(text);
+            if (!parsed.success || parsed.value.length === 0) {
+                return { passed: false, feedback: 'Gherkin did not parse into any scenario' };
+            }
+            const wellFormed = parsed.value.every((s) => s.given.length > 0 && s.when.length > 0 && s.then.length > 0);
+            if (!wellFormed) {
+                return { passed: false, feedback: 'every scenario needs at least one Given, one When, and one Then step' };
+            }
+            if (sigTerms.length > 0) {
+                const lower = text.toLowerCase();
+                const hits = sigTerms.filter((t) => lower.includes(t)).length;
+                if (hits < Math.min(2, sigTerms.length)) {
+                    return { passed: false, feedback: `scenarios must address THIS requirement — reference its terms (e.g. ${sigTerms.slice(0, 6).join(', ')})` };
+                }
+            }
+            return { passed: true };
+        };
+        const r = await this.freeTierExecutor.execute({
+            agentId: `requirements:${requirement.id}`,
+            messages: [
+                { role: 'system', content: system },
+                { role: 'user', content: user },
+            ],
+            verify,
+            escalate: true,
+            bestOfK: this.config.freeTierBestOfK ?? 2, // §12, matches the D3-validated config
+            repairAttempts: this.config.freeTierRepairAttempts ?? 1,
+        });
+        if (!r.ok)
+            return null;
+        const parsed = this.bddWriter.parseGherkin(stripGherkinFence(r.content));
+        if (!parsed.success || parsed.value.length === 0)
+            return null;
+        logger.info(`Free-tier BDD scenarios for ${requirement.id} via tier=${r.tierUsed} (${parsed.value.length} scenarios)`);
+        return parsed.value;
+    }
     async generateTestArtifacts(requirementId) {
         const workflowId = uuidv4();
         try {
@@ -320,15 +420,20 @@ export class RequirementsValidationCoordinator extends BaseDomainCoordinator {
                     logger.info(`[PPO] Optimized scenario count to ${optimizedScenarioCount}`);
                 }
             }
-            // Generate BDD scenarios with optimized count
-            const scenariosResult = await this.bddWriter.generateScenariosWithExamples(requirement, optimizedScenarioCount);
-            if (!scenariosResult.success) {
-                this.failWorkflow(workflowId, scenariosResult.error.message);
-                return err(scenariosResult.error);
+            // Cheap-first (opt-in, ADR-111): generate Gherkin on the free local tier,
+            // verify its structure (objective oracle), parse back to scenarios. Falls
+            // through to the normal structured path on any miss (off by default).
+            let scenarios = await this.tryFreeTierScenarios(requirement, optimizedScenarioCount);
+            if (!scenarios) {
+                const scenariosResult = await this.bddWriter.generateScenariosWithExamples(requirement, optimizedScenarioCount);
+                if (!scenariosResult.success) {
+                    this.failWorkflow(workflowId, scenariosResult.error.message);
+                    return err(scenariosResult.error);
+                }
+                scenarios = scenariosResult.value;
             }
             this.updateWorkflowProgress(workflowId, 50);
             // V3: Use PPO to optimize scenario ordering
-            let scenarios = scenariosResult.value;
             if (this.config.enablePPO && this.ppoAlgorithm) {
                 scenarios = await this.optimizeScenarioOrdering(requirement, scenarios);
             }

package/dist/domains/requirements-validation/plugin.js

@@ -9,6 +9,7 @@ import { RequirementsValidatorService, } from './services/requirements-validator
 import { BDDScenarioWriterService, } from './services/bdd-scenario-writer.js';
 import { TestabilityScorerService, } from './services/testability-scorer.js';
 import { createQCSDIdeationPlugin, } from './qcsd-ideation-plugin.js';
+import { RoutingFeedbackCollector } from '../../routing/routing-feedback.js';
 import { toError } from '../../shared/error-utils.js';
 // ============================================================================
 // Plugin Implementation
@@ -171,8 +172,26 @@ export class RequirementsValidationPlugin extends BaseDomainPlugin {
         this.validator = new RequirementsValidatorService({ memory: this.memory, llmRouter: this.llmRouter }, this.pluginConfig.validator);
         this.bddWriter = new BDDScenarioWriterService(this.memory, this.pluginConfig.bddWriter);
         this.testabilityScorer = new TestabilityScorerService(this.memory, this.pluginConfig.testabilityScorer);
+        // D9: when the free tier is opted in, stand up a live RoutingFeedbackCollector
+        // (calibrator + auto-escalation) so each cheap-vs-escalated BDD 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 and initialize coordinator
-        this.coordinator = new RequirementsValidationCoordinator(this.eventBus, this.memory, this.agentCoordinator, this.pluginConfig.coordinator, this.llmRouter);
+        this.coordinator = new RequirementsValidationCoordinator(this.eventBus, this.memory, this.agentCoordinator, this.pluginConfig.coordinator, this.llmRouter, routingFeedback // D9 sink (undefined unless free tier is on)
+        );
         await this.coordinator.initialize();
         // Create and initialize QCSD Ideation Plugin
         this.qcsdIdeationPlugin = createQCSDIdeationPlugin(this.memory);

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,18 @@ 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:30b-a3b or env AQE_FREE_TIER_MODEL). */
+    freeTierModel?: string;
+    /** Same-tier repair retries on a failed free-tier generation (D8). Default 1. */
+    freeTierRepairAttempts?: number;
+    /** Best-of-k diverse local attempts per tier (§12; D3-validated k=2). Default 2. */
+    freeTierBestOfK?: number;
 }
 type TestGenWorkflowType = 'generate' | 'tdd' | 'property' | 'data' | 'learn';
 export declare class TestGenerationCoordinator extends BaseDomainCoordinator<CoordinatorConfig, TestGenWorkflowType> implements ITestGenerationCoordinator {
@@ -70,13 +83,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 +115,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 { buildFreeTierExecutor, } 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,16 @@ 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; ADR-111).
+        // OFF by default. Generic wiring lives in the shared factory now.
+        this.freeTierExecutor = buildFreeTierExecutor({
+            config: this.config,
+            agentType: 'qe-test-architect',
+            taskKind: 'test-generation',
+            llmRouter,
+            routingFeedback,
+            logger,
+        });
         // 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 +247,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 +404,80 @@ 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: best-of-k (§12) + repair on the local tier, then escalate the
+            // hard tail up the ladder via the HybridRouter (when wired). Matches the D3
+            // config that was validated (k=2). Local-only if no router.
+            escalate: true,
+            bestOfK: this.config.freeTierBestOfK ?? 2,
+            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