agentic-qe 3.10.9 → 3.11.1

package/dist/mcp/tool-scoping.d.ts

@@ -9,13 +9,19 @@ export type AgentRole = 'test-generator' | 'coverage-analyzer' | 'security-scann
  * Tool scope definition for an agent role
  */
 export interface ToolScope {
-    /** Tools the agent can use (if empty/undefined, uses allowAll) */
+    /**
+     * Tools the agent can use. DEFAULT-DENY: if this is empty/undefined and
+     * `allowAll` is not set, the role is denied EVERY tool (`isToolAllowed`
+     * falls through to `return false`). It does NOT grant allowAll.
+     */
     allowed?: string[];
     /** Tools explicitly denied (overrides allowed) */
     denied?: string[];
-    /** Allow all tools (default for fleet-admin and unrestricted) */
+    /** Allow all tools — admin tiers only (fleet-admin, unrestricted). */
     allowAll?: boolean;
 }
+/** Every agent role, in declaration order — for governance/policy iteration. */
+export declare const ALL_AGENT_ROLES: AgentRole[];
 /**
  * Check if an agent role is allowed to use a specific tool
  */

package/dist/mcp/tool-scoping.js

@@ -4,6 +4,19 @@
  * Restricts MCP tool access by agent role for security isolation.
  * Each agent type has a defined set of tools it can invoke.
  */
+/** Every agent role, in declaration order — for governance/policy iteration. */
+export const ALL_AGENT_ROLES = [
+    'test-generator',
+    'coverage-analyzer',
+    'security-scanner',
+    'quality-assessor',
+    'defect-predictor',
+    'contract-validator',
+    'accessibility-tester',
+    'chaos-engineer',
+    'fleet-admin',
+    'unrestricted',
+];
 /**
  * Default tool scopes per agent role
  */

package/dist/routing/escalation/auto-escalation-tracker.d.ts

@@ -5,23 +5,40 @@
  * Tracks consecutive failures/successes per agent and recommends
  * tier escalation (after N failures) or de-escalation (after M successes).
  * Uses existing AgentTier and FallbackConfig.chain for tier ordering.
+ *
+ * D7 (cross-pollination plan 06): the class is generic over the tier-name type
+ * and the ladder is configurable via `EscalationConfig.tierOrder`. This lets a
+ * caller insert a FREE local tier BELOW haiku (e.g.
+ * `['local','haiku','sonnet','opus']`) so cheap/local models handle the bulk and
+ * only failures escalate up the chain (Ruv's SWE-bench Round-3 economics).
+ * Default behaviour is byte-identical to before: with no `tierOrder`, the ladder
+ * is the original `['booster','haiku','sonnet','opus']` over `AgentTier`.
  */
 import type { AgentTier } from '../routing-config.js';
-export interface EscalationConfig {
+export interface EscalationConfig<Tier extends string = AgentTier> {
     /** Consecutive failures before escalation (default: 2) */
     escalateAfterFailures: number;
     /** Consecutive successes before de-escalation (default: 5) */
     deEscalateAfterSuccesses: number;
     /** Maximum tier to escalate to (default: 'opus') */
-    maxTier: AgentTier;
+    maxTier: Tier;
     /** Minimum tier to de-escalate to (default: 'haiku') */
-    minTier: AgentTier;
+    minTier: Tier;
+    /**
+     * Tier ladder in ascending order of capability/cost. Optional — when omitted,
+     * resolves to the default Claude ladder `['booster','haiku','sonnet','opus']`.
+     * Supply a custom ladder to prepend a free local tier, e.g.
+     * `['local','haiku','sonnet','opus']`.
+     */
+    tierOrder?: Tier[];
 }
 export declare const DEFAULT_ESCALATION_CONFIG: EscalationConfig;
-export interface EscalationState {
+/** The default Claude ladder (kept out of DEFAULT_ESCALATION_CONFIG for back-compat). */
+export declare const DEFAULT_TIER_ORDER: AgentTier[];
+export interface EscalationState<Tier extends string = AgentTier> {
     agentId: string;
-    currentTier: AgentTier;
-    baseTier: AgentTier;
+    currentTier: Tier;
+    baseTier: Tier;
     consecutiveFailures: number;
     consecutiveSuccesses: number;
     escalationCount: number;
@@ -29,31 +46,33 @@ export interface EscalationState {
     lastAction: 'escalate' | 'de-escalate' | 'none';
     lastActionTimestamp: Date;
 }
-export type EscalationAction = {
+export type EscalationAction<Tier extends string = AgentTier> = {
     action: 'escalate' | 'de-escalate' | 'none';
-    previousTier: AgentTier;
-    newTier: AgentTier;
+    previousTier: Tier;
+    newTier: Tier;
 };
-export declare class AutoEscalationTracker {
+export declare class AutoEscalationTracker<Tier extends string = AgentTier> {
     private readonly config;
+    private readonly tierOrder;
     private states;
-    constructor(config?: Partial<EscalationConfig>);
+    constructor(config?: Partial<EscalationConfig<Tier>>);
+    private tierIndex;
     /**
      * Record an outcome for an agent and determine escalation action.
      */
-    recordOutcome(agentId: string, success: boolean, baseTier: AgentTier): EscalationAction;
+    recordOutcome(agentId: string, success: boolean, baseTier: Tier): EscalationAction<Tier>;
     /**
      * Get the current tier for an agent, or null if not tracked.
      */
-    getCurrentTier(agentId: string): AgentTier | null;
+    getCurrentTier(agentId: string): Tier | null;
     /**
      * Get full escalation state for an agent, or null if not tracked.
      */
-    getState(agentId: string): EscalationState | null;
+    getState(agentId: string): EscalationState<Tier> | null;
     /**
      * Get all tracked escalation states.
      */
-    getAllStates(): EscalationState[];
+    getAllStates(): EscalationState<Tier>[];
     /**
      * Reset state for a specific agent, or all agents if no ID provided.
      */

package/dist/routing/escalation/auto-escalation-tracker.js

@@ -5,6 +5,14 @@
  * Tracks consecutive failures/successes per agent and recommends
  * tier escalation (after N failures) or de-escalation (after M successes).
  * Uses existing AgentTier and FallbackConfig.chain for tier ordering.
+ *
+ * D7 (cross-pollination plan 06): the class is generic over the tier-name type
+ * and the ladder is configurable via `EscalationConfig.tierOrder`. This lets a
+ * caller insert a FREE local tier BELOW haiku (e.g.
+ * `['local','haiku','sonnet','opus']`) so cheap/local models handle the bulk and
+ * only failures escalate up the chain (Ruv's SWE-bench Round-3 economics).
+ * Default behaviour is byte-identical to before: with no `tierOrder`, the ladder
+ * is the original `['booster','haiku','sonnet','opus']` over `AgentTier`.
  */
 export const DEFAULT_ESCALATION_CONFIG = {
     escalateAfterFailures: 2,
@@ -12,22 +20,23 @@ export const DEFAULT_ESCALATION_CONFIG = {
     maxTier: 'opus',
     minTier: 'haiku',
 };
-// ============================================================================
-// Tier Ordering
-// ============================================================================
-/** Tiers in ascending order of capability/cost */
-const TIER_ORDER = ['booster', 'haiku', 'sonnet', 'opus'];
-function tierIndex(tier) {
-    return TIER_ORDER.indexOf(tier);
-}
+/** The default Claude ladder (kept out of DEFAULT_ESCALATION_CONFIG for back-compat). */
+export const DEFAULT_TIER_ORDER = ['booster', 'haiku', 'sonnet', 'opus'];
 // ============================================================================
 // Auto-Escalation Tracker
 // ============================================================================
 export class AutoEscalationTracker {
     config;
+    tierOrder;
     states = new Map();
     constructor(config) {
         this.config = { ...DEFAULT_ESCALATION_CONFIG, ...config };
+        // Resolve the ladder here (not in DEFAULT_ESCALATION_CONFIG) so the exported
+        // default object stays a pure {failures, successes, maxTier, minTier}.
+        this.tierOrder = this.config.tierOrder ?? DEFAULT_TIER_ORDER;
+    }
+    tierIndex(tier) {
+        return this.tierOrder.indexOf(tier);
     }
     /**
      * Record an outcome for an agent and determine escalation action.
@@ -53,10 +62,10 @@ export class AutoEscalationTracker {
             state.consecutiveFailures++;
             state.consecutiveSuccesses = 0;
             if (state.consecutiveFailures >= this.config.escalateAfterFailures) {
-                const currentIdx = tierIndex(state.currentTier);
-                const maxIdx = tierIndex(this.config.maxTier);
-                if (currentIdx < maxIdx) {
-                    state.currentTier = TIER_ORDER[currentIdx + 1];
+                const currentIdx = this.tierIndex(state.currentTier);
+                const maxIdx = this.tierIndex(this.config.maxTier);
+                if (currentIdx >= 0 && currentIdx < maxIdx) {
+                    state.currentTier = this.tierOrder[currentIdx + 1];
                     state.escalationCount++;
                     state.consecutiveFailures = 0;
                     state.lastAction = 'escalate';
@@ -69,10 +78,10 @@ export class AutoEscalationTracker {
             state.consecutiveSuccesses++;
             state.consecutiveFailures = 0;
             if (state.consecutiveSuccesses >= this.config.deEscalateAfterSuccesses) {
-                const currentIdx = tierIndex(state.currentTier);
-                const minIdx = tierIndex(this.config.minTier);
+                const currentIdx = this.tierIndex(state.currentTier);
+                const minIdx = this.tierIndex(this.config.minTier);
                 if (currentIdx > minIdx) {
-                    state.currentTier = TIER_ORDER[currentIdx - 1];
+                    state.currentTier = this.tierOrder[currentIdx - 1];
                     state.deEscalationCount++;
                     state.consecutiveSuccesses = 0;
                     state.lastAction = 'de-escalate';

package/dist/routing/free-tier/coordinator-support.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Coordinator free-tier support (cross-pollination plan 06 — broadening the
+ * opt-in beyond test generation; ADR-111 escalation lane).
+ *
+ * Extracts the generic "build a FreeTierEscalatingExecutor from a coordinator's
+ * config + router" wiring that was inline in the test-generation coordinator, so
+ * ANY domain coordinator can opt in with a few lines instead of duplicating it.
+ *
+ * The opt-in lane is justified only for tasks that match the D3 criterion:
+ * BOUNDED generation graded by an OBJECTIVE oracle (a test+assertion, valid
+ * Gherkin, a schema). Do NOT wire it into analysis/judgement coordinators — the
+ * §11 "coder binds" finding means a cheap model can't carry open-ended reasoning.
+ */
+import { FreeTierEscalatingExecutor, type QeExecutionResult, type QeVerifier } from './executor.js';
+import { type RoutingFeedbackLike } from './feedback-sink.js';
+import type { FreeTierProviderConfig } from './types.js';
+/** Default cheap tier. qwen3:30b-a3b, NOT qwen3:8b — D3 (2026-06-23) measured the
+ *  8B below the QE generation floor (0/3 baseline-valid); the 30B MoE clears it. */
+export declare const DEFAULT_FREE_TIER_MODEL = "qwen3:30b-a3b";
+/** Per-coordinator config knobs (mix into a coordinator's CoordinatorConfig). */
+export interface FreeTierCoordinatorConfig {
+    /** Opt-in the cheap-first free local tier. Also via env `AQE_FREE_TIER=1`. */
+    enableFreeTier?: boolean;
+    /** Local model id (default {@link DEFAULT_FREE_TIER_MODEL} or env AQE_FREE_TIER_MODEL). */
+    freeTierModel?: string;
+    /** Default same-tier D8 repair retries before escalating. Benchmarked at 2 (D3). */
+    freeTierRepairAttempts?: number;
+    /**
+     * Best-of-k diverse attempts per tier's first round (06 §12). D3 validated k=2
+     * (lifted cheap composite +16.7, baseline-valid 50%→70%). Costs an extra local
+     * call ONLY when variant 0 fails (the loop breaks on first pass). Default 2.
+     */
+    freeTierBestOfK?: number;
+    /**
+     * Cross-model best-of-k generator pool (A12, measured +6 composite over single-
+     * model via mutual validity rescue). When set, round-0 best-of-k draws candidates
+     * across these providers (e.g. local qwen + an OpenRouter model) instead of one
+     * model's variants. Omit ⇒ single-model. Set `freeTierBestOfK ≥ pool size`.
+     */
+    freeTierCandidateProviders?: FreeTierProviderConfig[];
+}
+/** Structural view of the HybridRouter — avoids a hard import (decoupling). */
+export interface FreeTierLlmRouter {
+    chat(args: {
+        messages: Array<{
+            role: 'system' | 'user' | 'assistant';
+            content: string;
+        }>;
+        agentType: string;
+        complexity: 'low' | 'medium' | 'high';
+    }): Promise<{
+        content: string;
+    }>;
+}
+export interface BuildFreeTierExecutorOptions {
+    config: FreeTierCoordinatorConfig;
+    /** Router agentType hint for escalated (paid) tiers, e.g. 'qe-test-architect'. */
+    agentType: string;
+    /** D9 sink label, e.g. 'test-generation'. */
+    taskKind: string;
+    /** Delegate Claude tiers to the host router; omit → local-only (no escalation). */
+    llmRouter?: FreeTierLlmRouter | null;
+    /** D9: feed cheap-vs-escalated outcomes into routing-feedback. */
+    routingFeedback?: RoutingFeedbackLike | null;
+    env?: NodeJS.ProcessEnv;
+    logger?: {
+        info: (m: string) => void;
+    };
+}
+/**
+ * Build a cheap-first escalating executor from coordinator config + (optional)
+ * router. Returns `null` when the free tier is not opted in — callers store the
+ * result and fall through to their normal path when it is null.
+ */
+export declare function buildFreeTierExecutor(opts: BuildFreeTierExecutorOptions): FreeTierEscalatingExecutor | null;
+/**
+ * Run one bounded generation task cheap-first: best-of-k diverse attempts +
+ * D8 repair on the local tier, escalating the hard tail. Returns `null` when no
+ * executor (not opted in). The `verify` MUST be an objective oracle (06 §10).
+ */
+export declare function runFreeTierTextTask(executor: FreeTierEscalatingExecutor | null, args: {
+    agentId: string;
+    system: string;
+    user: string;
+    verify: QeVerifier;
+    repairAttempts?: number;
+    escalate?: boolean;
+    bestOfK?: number;
+}): Promise<QeExecutionResult | null>;
+//# sourceMappingURL=coordinator-support.d.ts.map

package/dist/routing/free-tier/coordinator-support.js

@@ -0,0 +1,78 @@
+/**
+ * Coordinator free-tier support (cross-pollination plan 06 — broadening the
+ * opt-in beyond test generation; ADR-111 escalation lane).
+ *
+ * Extracts the generic "build a FreeTierEscalatingExecutor from a coordinator's
+ * config + router" wiring that was inline in the test-generation coordinator, so
+ * ANY domain coordinator can opt in with a few lines instead of duplicating it.
+ *
+ * The opt-in lane is justified only for tasks that match the D3 criterion:
+ * BOUNDED generation graded by an OBJECTIVE oracle (a test+assertion, valid
+ * Gherkin, a schema). Do NOT wire it into analysis/judgement coordinators — the
+ * §11 "coder binds" finding means a cheap model can't carry open-ended reasoning.
+ */
+import { FreeTierEscalatingExecutor } from './executor.js';
+import { defaultFreeTierLadder } from './ladder.js';
+import { createRoutingFeedbackSink } from './feedback-sink.js';
+/** Default cheap tier. qwen3:30b-a3b, NOT qwen3:8b — D3 (2026-06-23) measured the
+ *  8B below the QE generation floor (0/3 baseline-valid); the 30B MoE clears it. */
+export const DEFAULT_FREE_TIER_MODEL = 'qwen3:30b-a3b';
+/**
+ * Build a cheap-first escalating executor from coordinator config + (optional)
+ * router. Returns `null` when the free tier is not opted in — callers store the
+ * result and fall through to their normal path when it is null.
+ */
+export function buildFreeTierExecutor(opts) {
+    const env = opts.env ?? process.env;
+    const on = opts.config.enableFreeTier === true || env.AQE_FREE_TIER === '1';
+    if (!on)
+        return null;
+    const model = opts.config.freeTierModel || env.AQE_FREE_TIER_MODEL || DEFAULT_FREE_TIER_MODEL;
+    // Paid escalation: map the ladder tier to a complexity hint so the host router
+    // picks that tier. No router → executor stays local-only (Claude tiers unavailable).
+    const claudeRunner = opts.llmRouter
+        ? async (tier, msgs) => {
+            const complexity = tier === 'opus' ? 'high' : tier === 'sonnet' ? 'medium' : 'low';
+            const resp = await opts.llmRouter.chat({
+                messages: msgs.map((m) => ({ role: m.role, content: m.content })),
+                agentType: opts.agentType,
+                complexity,
+            });
+            return { content: resp.content };
+        }
+        : undefined;
+    const exec = new FreeTierEscalatingExecutor({
+        ladder: defaultFreeTierLadder(model),
+        claudeRunner,
+        defaultRepairAttempts: opts.config.freeTierRepairAttempts ?? 1,
+        candidateProviders: opts.config.freeTierCandidateProviders, // A12 cross-model (off unless set)
+        onOutcome: opts.routingFeedback
+            ? createRoutingFeedbackSink(opts.routingFeedback, { taskKind: opts.taskKind })
+            : undefined,
+    });
+    opts.logger?.info(`Free-tier enabled for ${opts.taskKind} (model=${model}, ` +
+        `${claudeRunner ? 'escalation→router' : 'local-only'})`);
+    return exec;
+}
+/**
+ * Run one bounded generation task cheap-first: best-of-k diverse attempts +
+ * D8 repair on the local tier, escalating the hard tail. Returns `null` when no
+ * executor (not opted in). The `verify` MUST be an objective oracle (06 §10).
+ */
+export async function runFreeTierTextTask(executor, args) {
+    if (!executor)
+        return null;
+    return executor.execute({
+        agentId: args.agentId,
+        messages: [
+            { role: 'system', content: args.system },
+            { role: 'user', content: args.user },
+        ],
+        verify: args.verify,
+        repairAttempts: args.repairAttempts,
+        escalate: args.escalate ?? true,
+        bestOfK: args.bestOfK,
+        oracleKind: 'objective',
+    });
+}
+//# sourceMappingURL=coordinator-support.js.map

package/dist/routing/free-tier/executor.d.ts

@@ -0,0 +1,161 @@
+/**
+ * Free-tier escalating executor (cross-pollination plan 06, D7-wire + D8).
+ *
+ * Implements Ruv's SWE-bench economics for a QE task:
+ *   1. run on the CHEAP/free local tier
+ *   2. verify with an objective QE oracle (pass/fail [+ feedback])
+ *   3. D8 REPAIR LOOP: on failure, feed the failure back to the SAME tier and
+ *      retry (Round-2 lever: 7.7% -> 15.3% on a fixed model), up to `repairAttempts`
+ *   4. only then escalate up the ladder (when `escalate` is true)
+ *   5. record the start-tier outcome so the base tier adapts across tasks
+ *
+ * Decoupled by injection: free tiers via `freeTierChat`; Claude tiers via an
+ * injected `ClaudeTierRunner` (no Anthropic SDK dep; coordinator delegates to
+ * its HybridRouter). No runner → local-only. `escalate:false` = repair-only,
+ * never leaves the start tier (the "no escalation yet" mode).
+ */
+import { type ChatMessage } from './provider.js';
+import { AutoEscalationTracker } from '../escalation/auto-escalation-tracker.js';
+import type { QeRoutingLadder, FreeTierProviderConfig } from './types.js';
+import type { AgentTier } from '../routing-config.js';
+/** Serves a Claude tier. Injected by the host (e.g. delegates to HybridRouter). */
+export type ClaudeTierRunner = (claudeTier: AgentTier, messages: ChatMessage[]) => Promise<{
+    content: string;
+}>;
+/** Rich verdict — lets the repair loop feed *why* it failed back to the model. */
+export interface QeVerdict {
+    passed: boolean;
+    /** Human/model-readable reason a failed output was rejected (drives repair). */
+    feedback?: string;
+}
+/** The objective QE oracle: did the tier's output satisfy the task? */
+export type QeVerifier = (output: string) => boolean | QeVerdict | Promise<boolean | QeVerdict>;
+export interface QeTaskRequest {
+    /** Tracker key — usually `${agentRole}:${repo}` so adaptation is per-context. */
+    agentId: string;
+    /** The QE prompt sent to whichever tier handles it. */
+    messages: ChatMessage[];
+    /** Objective pass/fail check on the produced output (coverage run, arena, schema, …). */
+    verify: QeVerifier;
+    /** D8: same-tier repair retries after a failure, before escalating. Default 0. */
+    repairAttempts?: number;
+    /** Climb the ladder on failure. Default true; set false for repair-only (local). */
+    escalate?: boolean;
+    /** Cap on tiers tried for one task (default: full ladder). */
+    maxEscalations?: number;
+    /**
+     * Best-of-k diverse attempts at each tier's first round (06 §12 correction).
+     * Ruv's ablation: a single repro-gated shot Goodharts the oracle (0 gold); k>1
+     * diverse attempts picked by the objective verifier are what convert. Default 1.
+     */
+    bestOfK?: number;
+    /**
+     * Goodhart guard (06 §10). `objective` = the verifier is a deterministic
+     * ground-truth oracle (arena/coverage/schema). `self-authored` = the verifier
+     * is the model's own test — an unreliable selection target, so its outcomes are
+     * NOT recorded into routing-feedback (they must not lift confidence). Default
+     * `objective` (existing callers inject real oracles, e.g. a coverage/test run).
+     */
+    oracleKind?: 'objective' | 'self-authored';
+}
+export interface TierAttempt {
+    tier: string;
+    provider: 'free-tier' | 'claude';
+    /** 0 = first try at this tier; 1.. = repair rounds (D8). */
+    repairRound: number;
+    /** Best-of-k variant index within round 0 (0 = primary, 1.. = diversified). */
+    variant?: number;
+    /** Generator model that produced this candidate (set for cross-model best-of-k). */
+    model?: string;
+    ok: boolean;
+    passed: boolean;
+    latencyMs: number;
+    feedback?: string;
+    error?: string;
+}
+export interface QeExecutionResult {
+    /** True iff some attempt produced output that passed `verify`. */
+    ok: boolean;
+    /** The passing output (or the last output tried). */
+    content: string;
+    /** The tier that produced the passing output, or the last tier tried. */
+    tierUsed: string;
+    /** True iff the task needed a tier above the starting one. */
+    escalated: boolean;
+    /** True iff a same-tier repair round produced the passing output. */
+    repaired: boolean;
+    /** True iff best-of-k (k>1) diversity at a round produced the passing output. */
+    bestOf: boolean;
+    /**
+     * True iff the outcome was withheld from routing-feedback because the gate was
+     * a self-authored oracle (06 §10 Goodhart guard) — it cannot lift confidence.
+     */
+    goodhartGuarded: boolean;
+    /** Per-attempt trace, cheapest → most capable. */
+    attempts: TierAttempt[];
+}
+export interface FreeTierExecutorOptions {
+    ladder: QeRoutingLadder;
+    /** Serves Claude tiers; omit for local-only operation. */
+    claudeRunner?: ClaudeTierRunner;
+    /** Reuse an existing tracker (e.g. the coordinator's) or create one. */
+    tracker?: AutoEscalationTracker<string>;
+    /** Read env for free-tier keys (injectable for tests). */
+    env?: NodeJS.ProcessEnv;
+    /** Default same-tier repair retries when a request omits `repairAttempts`. */
+    defaultRepairAttempts?: number;
+    /**
+     * Cross-model best-of-k (A12, measured +6 composite over single-model). When set
+     * AND the START tier is free-tier, round-0 best-of-k draws each candidate from a
+     * DIFFERENT provider in this pool (e.g. local qwen + an OpenRouter model) instead
+     * of one model's temperature/prompt variants — diverse models cover each other's
+     * failures and raise the union. Selection stays the objective verifier (first-pass).
+     * Omit ⇒ single-model best-of-k (unchanged).
+     */
+    candidateProviders?: FreeTierProviderConfig[];
+    /** D9 sink: record each completed task outcome (→ routing-feedback). */
+    onOutcome?: (o: {
+        agentId: string;
+        startTier: string;
+        tierUsed: string;
+        passed: boolean;
+        escalated: boolean;
+        repaired: boolean;
+        durationMs: number;
+        attempts: number;
+    }) => void;
+}
+/**
+ * Executes QE tasks cheap-first with repair-then-escalate. Holds the per-agent
+ * adaptive base tier in an `AutoEscalationTracker`.
+ */
+export declare class FreeTierEscalatingExecutor {
+    private readonly ladder;
+    private readonly claudeRunner?;
+    private readonly tracker;
+    private readonly env;
+    private readonly baseTier;
+    private readonly defaultRepairAttempts;
+    private readonly onOutcome?;
+    /** Resolved cross-model generator pool (A12); undefined ⇒ single-model best-of-k. */
+    private readonly candidateProviders?;
+    constructor(opts: FreeTierExecutorOptions);
+    /** Expose the tracker so a coordinator can inspect/share adaptation state. */
+    getTracker(): AutoEscalationTracker<string>;
+    /** Run ONE tier once; never throws — failure becomes `{ok:false}` so we repair/escalate. */
+    private runTier;
+    /**
+     * Best-of-k diversity turn (06 §12): nudge the model toward a structurally
+     * different valid solution. Deterministic by `variant` index (no RNG) so runs
+     * replay identically.
+     */
+    private diversify;
+    /** Build the D8 repair turn: show the model its rejected output + why. */
+    private repairMessages;
+    /**
+     * Execute a QE task cheap-first: try a tier, repair in place on failure, then
+     * (optionally) escalate to the next tier; repeat until pass or top.
+     */
+    execute(req: QeTaskRequest): Promise<QeExecutionResult>;
+}
+//# sourceMappingURL=executor.d.ts.map