agentic-qe 3.10.8 → 3.11.0

package/dist/mcp/entry.js

@@ -363,5 +363,14 @@ async function main() {
         process.exit(1);
     }
 }
-main();
+// H3: main() runs fire-and-forget, so a rejection that escapes its internal
+// try/catch would otherwise hit the unhandledRejection handler above — which
+// deliberately keeps the server alive at *runtime*. A failed *startup* must
+// instead exit non-zero, especially on the in-process `agentic-qe mcp` path
+// (#528) where the CLI wrapper awaits a never-resolving promise and would
+// otherwise hang with a half-dead server and a zero exit code.
+main().catch((error) => {
+    process.stderr.write(`[MCP Entry] Fatal startup error: ${error instanceof Error ? error.stack || error.message : String(error)}\n`);
+    process.exit(1);
+});
 //# sourceMappingURL=entry.js.map

package/dist/mcp/protocol-server.js

@@ -472,6 +472,23 @@ export class MCPProtocolServer {
             success = true;
             // IMP-00: Execute post-tool-result middleware
             const processedResult = await this.middlewareChain.executePostHooks(processedCtx, result);
+            // Issue #535: a mutating tool must evict its domain's cached reads, or a
+            // follow-up read (e.g. memory_retrieve after memory_delete) serves a
+            // stale "found" result and the write looks like a no-op. Writes aren't
+            // cacheable themselves; gate on a mutation-verb suffix and invalidate the
+            // same domain the sibling reads were cached under. Best-effort.
+            if (!cacheable && process.env.AQE_SESSION_CACHE !== 'off' &&
+                /_(store|delete|set|share|update|remove|clear|promote|cleanup)$/.test(name) &&
+                this.isSuccessfulResult(processedResult)) {
+                try {
+                    const { getSessionCache } = await import('../optimization/session-cache.js');
+                    const { domain } = parseToolDomainAction(name);
+                    getSessionCache().invalidateDomain(domain);
+                }
+                catch {
+                    // never block tool execution on cache invalidation
+                }
+            }
             // Issue #473: Store successful results for future cache hits.
             // Only cache successful results — error objects shouldn't be served back.
             if (cacheable && cacheFingerprint && this.isSuccessfulResult(processedResult)) {

package/dist/optimization/session-cache.d.ts

@@ -69,10 +69,21 @@ export declare class SessionOperationCache {
     getStats(): SessionCacheStats;
     /** Clear all cache entries and reset counters */
     clear(): void;
+    /**
+     * Invalidate every cached entry for a domain. Issue #535: a mutating tool
+     * (e.g. memory_delete / memory_store) must evict the sibling read entries in
+     * its domain, or a follow-up memory_retrieve serves a stale "found" result
+     * from cache and the delete looks like a no-op. Also drops the persisted
+     * rows so a later loadFromDb() can't resurrect the stale entries. Returns the
+     * number of entries removed.
+     */
+    invalidateDomain(domain: string): number;
     /** Evict the oldest entry by cachedAt */
     private evictOldest;
     /** Persist a single entry to kv_store */
     private persistEntry;
+    /** Delete a single persisted entry from kv_store (used by invalidateDomain). */
+    private deletePersisted;
 }
 export declare function getSessionCache(config?: Partial<SessionCacheConfig>): SessionOperationCache;
 /** Reset the singleton (for testing) */

package/dist/optimization/session-cache.js

@@ -158,6 +158,25 @@ export class SessionOperationCache {
         this.hits = 0;
         this.misses = 0;
     }
+    /**
+     * Invalidate every cached entry for a domain. Issue #535: a mutating tool
+     * (e.g. memory_delete / memory_store) must evict the sibling read entries in
+     * its domain, or a follow-up memory_retrieve serves a stale "found" result
+     * from cache and the delete looks like a no-op. Also drops the persisted
+     * rows so a later loadFromDb() can't resurrect the stale entries. Returns the
+     * number of entries removed.
+     */
+    invalidateDomain(domain) {
+        let removed = 0;
+        for (const [key, entry] of this.cache) {
+            if (entry.domain === domain) {
+                this.cache.delete(key);
+                this.deletePersisted(entry.fingerprint);
+                removed++;
+            }
+        }
+        return removed;
+    }
     /** Evict the oldest entry by cachedAt */
     evictOldest() {
         let oldestKey = null;
@@ -184,6 +203,18 @@ export class SessionOperationCache {
             /* non-critical - cache works without persistence */
         }
     }
+    /** Delete a single persisted entry from kv_store (used by invalidateDomain). */
+    deletePersisted(fingerprint) {
+        try {
+            const db = tryGetDb();
+            if (!db)
+                return;
+            db.prepare(`DELETE FROM kv_store WHERE namespace = 'session_cache' AND key = ?`).run(`session_cache:${fingerprint}`);
+        }
+        catch {
+            /* non-critical */
+        }
+    }
 }
 // ============================================================================
 // DB Helper

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/executor.d.ts

@@ -0,0 +1,119 @@
+/**
+ * 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 } 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;
+}
+export interface TierAttempt {
+    tier: string;
+    provider: 'free-tier' | 'claude';
+    /** 0 = first try at this tier; 1.. = repair rounds (D8). */
+    repairRound: number;
+    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;
+    /** 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;
+    /** 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?;
+    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;
+    /** 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

package/dist/routing/free-tier/executor.js

@@ -0,0 +1,139 @@
+/**
+ * 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 { freeTierChat } from './provider.js';
+import { resolveTier } from './ladder.js';
+import { AutoEscalationTracker } from '../escalation/auto-escalation-tracker.js';
+function normalizeVerdict(v) {
+    return typeof v === 'boolean' ? { passed: v } : v;
+}
+/**
+ * Executes QE tasks cheap-first with repair-then-escalate. Holds the per-agent
+ * adaptive base tier in an `AutoEscalationTracker`.
+ */
+export class FreeTierEscalatingExecutor {
+    ladder;
+    claudeRunner;
+    tracker;
+    env;
+    baseTier;
+    defaultRepairAttempts;
+    onOutcome;
+    constructor(opts) {
+        this.ladder = opts.ladder;
+        this.claudeRunner = opts.claudeRunner;
+        this.env = opts.env ?? process.env;
+        this.onOutcome = opts.onOutcome;
+        this.defaultRepairAttempts = opts.defaultRepairAttempts ?? 0;
+        this.baseTier = opts.ladder.tierOrder[0];
+        this.tracker =
+            opts.tracker ??
+                new AutoEscalationTracker({
+                    tierOrder: opts.ladder.tierOrder,
+                    minTier: opts.ladder.minTier ?? opts.ladder.tierOrder[0],
+                    maxTier: opts.ladder.maxTier ?? opts.ladder.tierOrder[opts.ladder.tierOrder.length - 1],
+                    escalateAfterFailures: opts.ladder.escalateAfterFailures ?? 2,
+                    deEscalateAfterSuccesses: opts.ladder.deEscalateAfterSuccesses ?? 5,
+                });
+    }
+    /** Expose the tracker so a coordinator can inspect/share adaptation state. */
+    getTracker() {
+        return this.tracker;
+    }
+    /** Run ONE tier once; never throws — failure becomes `{ok:false}` so we repair/escalate. */
+    async runTier(resolved, messages) {
+        const started = Date.now();
+        if (resolved.provider === 'free-tier') {
+            const r = await freeTierChat(resolved.resolved, messages);
+            return { ok: r.ok, content: r.content, latencyMs: r.latencyMs, error: r.error };
+        }
+        if (!this.claudeRunner) {
+            return { ok: false, content: '', latencyMs: Date.now() - started, error: 'no claudeRunner (local-only mode)' };
+        }
+        try {
+            const r = await this.claudeRunner(resolved.claudeTier, messages);
+            return { ok: (r.content ?? '').trim().length > 0, content: r.content ?? '', latencyMs: Date.now() - started };
+        }
+        catch (e) {
+            return { ok: false, content: '', latencyMs: Date.now() - started, error: e.message };
+        }
+    }
+    /** Build the D8 repair turn: show the model its rejected output + why. */
+    repairMessages(base, lastOutput, feedback) {
+        return [
+            ...base,
+            { role: 'assistant', content: lastOutput },
+            {
+                role: 'user',
+                content: 'That output did not pass verification' +
+                    (feedback ? `: ${feedback}` : '.') +
+                    ' Fix it and return the corrected full output only.',
+            },
+        ];
+    }
+    /**
+     * 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.
+     */
+    async execute(req) {
+        const order = this.ladder.tierOrder;
+        const escalate = req.escalate ?? true;
+        const repairAttempts = req.repairAttempts ?? this.defaultRepairAttempts;
+        const startTier = this.tracker.getCurrentTier(req.agentId) ?? this.baseTier;
+        const startIdx = Math.max(0, order.indexOf(startTier));
+        const maxIdx = order.indexOf(this.ladder.maxTier ?? order[order.length - 1]);
+        const topIdx = escalate
+            ? (req.maxEscalations != null ? Math.min(startIdx + req.maxEscalations, maxIdx) : maxIdx)
+            : startIdx; // repair-only: never leave the start tier
+        const attempts = [];
+        let passedAtStart = false;
+        const t0 = Date.now();
+        let result = { ok: false, content: '', tierUsed: startTier, escalated: false, repaired: false, attempts };
+        outer: for (let idx = startIdx; idx <= topIdx; idx++) {
+            const tier = order[idx];
+            const resolved = resolveTier(this.ladder, tier, this.env);
+            // first try (round 0) + up to `repairAttempts` repair rounds
+            for (let round = 0; round <= repairAttempts; round++) {
+                const messages = round === 0 ? req.messages : this.repairMessages(req.messages, result.content, attempts[attempts.length - 1]?.feedback);
+                const run = await this.runTier(resolved, messages);
+                const verdict = run.ok ? normalizeVerdict(await Promise.resolve(req.verify(run.content))) : { passed: false, feedback: run.error };
+                attempts.push({ tier, provider: resolved.provider, repairRound: round, ok: run.ok, passed: verdict.passed, latencyMs: run.latencyMs, feedback: verdict.feedback, error: run.error });
+                if (idx === startIdx && round === 0)
+                    passedAtStart = verdict.passed;
+                if (verdict.passed) {
+                    result = { ok: true, content: run.content, tierUsed: tier, escalated: idx > startIdx, repaired: round > 0, attempts };
+                    break outer;
+                }
+                result = { ok: false, content: run.content || result.content, tierUsed: tier, escalated: idx > startIdx, repaired: round > 0, attempts };
+            }
+        }
+        // Cross-task adaptation: feed the START-tier verdict to the tracker so the
+        // base tier drifts up when the cheap tier keeps failing, down when it wins.
+        this.tracker.recordOutcome(req.agentId, passedAtStart, this.baseTier);
+        this.onOutcome?.({
+            agentId: req.agentId,
+            startTier,
+            tierUsed: result.tierUsed,
+            passed: result.ok,
+            escalated: result.escalated,
+            repaired: result.repaired,
+            durationMs: Date.now() - t0,
+            attempts: attempts.length,
+        });
+        return result;
+    }
+}
+//# sourceMappingURL=executor.js.map

package/dist/routing/free-tier/feedback-sink.d.ts

@@ -0,0 +1,49 @@
+/**
+ * D9 — route free-tier executor outcomes into the existing routing-feedback
+ * machinery so the stuck-at-40% routing confidence starts moving from REAL
+ * cheap-vs-escalated results.
+ *
+ * `RoutingFeedbackCollector.recordOutcome` already updates the calibrator, the
+ * auto-escalation tracker, the economic model, and the confidence metrics. This
+ * adapter maps a `FreeTierEscalatingExecutor.onOutcome` event onto that call,
+ * constructing a minimal-but-valid QETask + synthetic QERoutingDecision.
+ *
+ * Decoupled by a structural interface (`RoutingFeedbackLike`) so this module has
+ * no hard dependency on the concrete collector's constructor/DB — the coordinator
+ * passes whatever it already holds, and tests pass a stub.
+ */
+import type { QETask, QERoutingDecision, RoutingOutcome } from '../types.js';
+/** The slice of RoutingFeedbackCollector this adapter needs. */
+export interface RoutingFeedbackLike {
+    recordOutcome(task: QETask, decision: QERoutingDecision, usedAgent: string, outcome: {
+        success: boolean;
+        qualityScore: number;
+        durationMs: number;
+        error?: string;
+    }): RoutingOutcome;
+}
+/** The executor's onOutcome payload (kept structural to avoid a circular import). */
+export interface FreeTierOutcomeEvent {
+    agentId: string;
+    startTier: string;
+    tierUsed: string;
+    passed: boolean;
+    escalated: boolean;
+    repaired: boolean;
+    durationMs: number;
+    attempts: number;
+}
+export interface RoutingFeedbackSinkOptions {
+    /** Short label for the task description (e.g. 'test-generation'). */
+    taskKind?: string;
+    /** Confidence to attribute to the cheap-first decision (0..1). Default 0.5. */
+    decisionConfidence?: number;
+}
+/**
+ * Build an `onOutcome` handler that records each free-tier task result into the
+ * routing-feedback collector. `usedAgent` is set to the TIER that produced the
+ * result so the calibrator/escalation tracker learn per-tier reliability — i.e.
+ * sustained cheap-tier wins raise its confidence and keep work cheap.
+ */
+export declare function createRoutingFeedbackSink(collector: RoutingFeedbackLike, opts?: RoutingFeedbackSinkOptions): (o: FreeTierOutcomeEvent) => void;
+//# sourceMappingURL=feedback-sink.d.ts.map

package/dist/routing/free-tier/feedback-sink.js

@@ -0,0 +1,52 @@
+/**
+ * D9 — route free-tier executor outcomes into the existing routing-feedback
+ * machinery so the stuck-at-40% routing confidence starts moving from REAL
+ * cheap-vs-escalated results.
+ *
+ * `RoutingFeedbackCollector.recordOutcome` already updates the calibrator, the
+ * auto-escalation tracker, the economic model, and the confidence metrics. This
+ * adapter maps a `FreeTierEscalatingExecutor.onOutcome` event onto that call,
+ * constructing a minimal-but-valid QETask + synthetic QERoutingDecision.
+ *
+ * Decoupled by a structural interface (`RoutingFeedbackLike`) so this module has
+ * no hard dependency on the concrete collector's constructor/DB — the coordinator
+ * passes whatever it already holds, and tests pass a stub.
+ */
+/**
+ * Build an `onOutcome` handler that records each free-tier task result into the
+ * routing-feedback collector. `usedAgent` is set to the TIER that produced the
+ * result so the calibrator/escalation tracker learn per-tier reliability — i.e.
+ * sustained cheap-tier wins raise its confidence and keep work cheap.
+ */
+export function createRoutingFeedbackSink(collector, opts = {}) {
+    const kind = opts.taskKind ?? 'free-tier-qe';
+    const confidence = opts.decisionConfidence ?? 0.5;
+    return (o) => {
+        const task = {
+            description: `${kind} task for ${o.agentId} (start=${o.startTier}${o.repaired ? ', repaired' : ''}${o.escalated ? ', escalated' : ''})`,
+        };
+        const decision = {
+            recommended: o.startTier, // cheap-first recommended the bottom tier
+            confidence,
+            alternatives: [],
+            reasoning: `free-tier cheap-first; resolved at ${o.tierUsed} after ${o.attempts} attempt(s)`,
+            scores: { similarity: 0, performance: o.passed ? 1 : 0, capabilities: 0, combined: o.passed ? 1 : 0 },
+            latencyMs: o.durationMs,
+            timestamp: new Date(),
+        };
+        // qualityScore: full marks on a clean cheap win; reduced when repair/escalation
+        // was needed (still a success, but it cost more) so the calibrator learns nuance.
+        const qualityScore = o.passed ? (o.escalated ? 0.6 : o.repaired ? 0.8 : 1.0) : 0;
+        try {
+            collector.recordOutcome(task, decision, o.tierUsed, {
+                success: o.passed,
+                qualityScore,
+                durationMs: o.durationMs,
+            });
+        }
+        catch {
+            // Feedback recording is best-effort — never break the QE task on a sink error.
+        }
+    };
+}
+//# sourceMappingURL=feedback-sink.js.map

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

@@ -0,0 +1,14 @@
+/**
+ * Free-tier routing (cross-pollination plan 06, D7).
+ *
+ * Adds a configurable FREE / low-cost model tier below haiku in the escalation
+ * ladder: local Ollama, cloud Ollama, OpenRouter, or any OpenAI-compatible
+ * endpoint. Cheap-local handles the bulk; only failures escalate up the chain.
+ * See docs/metaharness/06-darwin-qe-self-learning-action-lane.md (D7).
+ */
+export type { FreeTierKind, FreeTierProviderConfig, ResolvedFreeTierProvider, TierBinding, QeRoutingLadder, } from './types.js';
+export { FREE_TIER_PRESETS, resolveFreeTierProvider, freeTierChat, freeTierHealth, type ChatMessage, type FreeTierChatResult, } from './provider.js';
+export { defaultFreeTierLadder, validateLadder, createFreeTierEscalation, resolveTier, type ResolvedTier, } from './ladder.js';
+export { FreeTierEscalatingExecutor, type ClaudeTierRunner, type QeVerifier, type QeVerdict, type QeTaskRequest, type QeExecutionResult, type TierAttempt, type FreeTierExecutorOptions, } from './executor.js';
+export { createRoutingFeedbackSink, type RoutingFeedbackLike, type FreeTierOutcomeEvent, type RoutingFeedbackSinkOptions, } from './feedback-sink.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/routing/free-tier/index.js

@@ -0,0 +1,5 @@
+export { FREE_TIER_PRESETS, resolveFreeTierProvider, freeTierChat, freeTierHealth, } from './provider.js';
+export { defaultFreeTierLadder, validateLadder, createFreeTierEscalation, resolveTier, } from './ladder.js';
+export { FreeTierEscalatingExecutor, } from './executor.js';
+export { createRoutingFeedbackSink, } from './feedback-sink.js';
+//# sourceMappingURL=index.js.map