agentic-qe 3.10.9 → 3.11.1

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

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

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

@@ -0,0 +1,69 @@
+/**
+ * Darwin Mode integration — local type mirror (Phase-0, zero-coupling).
+ *
+ * These interfaces STRUCTURALLY mirror `@metaharness/darwin`'s
+ * `packages/darwin-mode/src/types.ts` (ADR-072 ScoreCard) so AQE can produce
+ * Darwin-compatible scores WITHOUT a build-time dependency on the pre-1.0
+ * MetaHarness package (per cross-pollination plan 05: Phase-0 actions stay
+ * decoupled).
+ *
+ * VERSION CONTRACT (plan A8, verified 2026-06-25): `DarwinScoreCard` is byte-for-
+ * byte structurally identical to upstream `ScoreCard` from @metaharness/darwin@0.2.1
+ * THROUGH @0.7.0 (no drift across 5 minors). The mirror is INTENTIONALLY KEPT, not
+ * replaced by a real import: the upstream is a fast-moving pre-1.0 package whose
+ * tarball pulls napi/wasm transitive deps, so the zero-coupling mirror is the lower-
+ * risk substrate (see plan 05 "A8 — status"). `tests/.../darwin-version-contract.test.ts`
+ * pins the mirror's field set so any divergence is caught.
+ *
+ * Pinned upstream contract: @metaharness/darwin ScoreCard @ 0.2.1–0.7.0.
+ */
+/** The seven mutation surfaces (mirror of Darwin's MutationSurface). */
+export type MutationSurface = 'planner' | 'contextBuilder' | 'reviewer' | 'retryPolicy' | 'toolPolicy' | 'memoryPolicy' | 'scorePolicy';
+/**
+ * Mirror of Darwin's `ScoreCard` (ADR-072). All terms/penalties ∈ [0,1].
+ * Darwin's frozen scorer folds the positive terms with fixed weights:
+ *   baseScore = 0.35·taskSuccess + 0.20·testPassRate + 0.15·traceQuality
+ *             + 0.10·costEfficiency + 0.10·latencyEfficiency + 0.10·safetyScore
+ * then subtracts the penalty layer to get finalScore.
+ */
+export interface DarwinScoreCard {
+    variantId: string;
+    taskSuccess: number;
+    testPassRate: number;
+    traceQuality: number;
+    costEfficiency: number;
+    latencyEfficiency: number;
+    safetyScore: number;
+    secretExposure: number;
+    destructiveAction: number;
+    hallucinatedFile: number;
+    toolLoop: number;
+    costOverrun: number;
+    baseScore: number;
+    finalScore: number;
+    promoted: boolean;
+    reason: string;
+}
+/**
+ * The objective QE outcome of evaluating one harness variant on a QE task.
+ * Shaped to AQE's ADR-104 arena `EvaluatedStrategy`, but generic enough for any
+ * QE scorer (mutation, coverage, false-finding).
+ */
+export interface QeFitness {
+    /** Did the suite pass on un-mutated code? A regression here disqualifies. */
+    baselinePassed: boolean;
+    /** Mutation kill-rate ∈ [0,1] — the headline QE quality signal. */
+    killRate: number;
+    /** Line coverage percentage ∈ [0,100], or null when uncollected. */
+    coveragePct: number | null;
+    /** Deterministic cost proxy ∈ [0,1] (selected groups / total). */
+    suiteCostRatio: number;
+    /**
+     * Blended QE fitness (ADR-104): 0.6·killRate + 0.3·(coverage/100) − 0.1·cost.
+     * Optional — recomputed from the parts when omitted.
+     */
+    fitness?: number;
+    /** False-finding rate ∈ [0,1] — drives a hallucination penalty when > 0. */
+    falseFindingRate?: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/integrations/darwin/types.js

@@ -0,0 +1,21 @@
+/**
+ * Darwin Mode integration — local type mirror (Phase-0, zero-coupling).
+ *
+ * These interfaces STRUCTURALLY mirror `@metaharness/darwin`'s
+ * `packages/darwin-mode/src/types.ts` (ADR-072 ScoreCard) so AQE can produce
+ * Darwin-compatible scores WITHOUT a build-time dependency on the pre-1.0
+ * MetaHarness package (per cross-pollination plan 05: Phase-0 actions stay
+ * decoupled).
+ *
+ * VERSION CONTRACT (plan A8, verified 2026-06-25): `DarwinScoreCard` is byte-for-
+ * byte structurally identical to upstream `ScoreCard` from @metaharness/darwin@0.2.1
+ * THROUGH @0.7.0 (no drift across 5 minors). The mirror is INTENTIONALLY KEPT, not
+ * replaced by a real import: the upstream is a fast-moving pre-1.0 package whose
+ * tarball pulls napi/wasm transitive deps, so the zero-coupling mirror is the lower-
+ * risk substrate (see plan 05 "A8 — status"). `tests/.../darwin-version-contract.test.ts`
+ * pins the mirror's field set so any divergence is caught.
+ *
+ * Pinned upstream contract: @metaharness/darwin ScoreCard @ 0.2.1–0.7.0.
+ */
+export {};
+//# sourceMappingURL=types.js.map