agentic-qe 3.10.3 → 3.10.5

package/.claude/skills/qcsd-development-swarm/SKILL.md

@@ -3,7 +3,7 @@ name: qcsd-development-swarm
 description: "Use when monitoring in-sprint code quality with TDD adherence checks, complexity analysis, coverage gap detection, or defect prediction in the QCSD Development phase."
 category: qcsd-phases
 priority: critical
-version: 1.0.0
+version: 1.1.0
 tokenEstimate: 3400
 # DDD Domain Mapping (from QCSD-AGENTIC-QE-MAPPING-FRAMEWORK.md)
 domains:
@@ -34,13 +34,14 @@ agents:
   total: 10
   sub_agents: 0
 skills: [tdd-london-chicago, mutation-testing, performance-testing, security-testing]
-# Execution Models (Task Tool is PRIMARY)
+# Execution Models (Workflow is PRIMARY where the harness supports it — ADR-102)
 execution:
-  primary: task-tool
-  alternatives: [mcp-tools, cli]
+  primary: workflow
+  workflow_name: qcsd-development-review
+  alternatives: [task-tool, mcp-tools, cli]
 swarm_pattern: true
 parallel_batches: 3
-last_updated: 2026-02-03
+last_updated: 2026-06-10
 enforcement_level: strict
 tags: [qcsd, development, tdd, complexity, coverage, security, performance, mutation, defect-prediction, swarm, parallel, ddd]
 trust_tier: 3
@@ -192,10 +193,30 @@ skip to step N. Ensure you have the required prerequisite data from prior steps.
 
 | Model | When to Use | Agent Spawn |
 |-------|-------------|-------------|
-| **Task Tool** (PRIMARY) | Claude Code sessions | `Task({ subagent_type, run_in_background: true })` |
+| **Workflow** (PRIMARY, ADR-102) | Harness with the Workflow tool | `Workflow({ name: "qcsd-development-review", args: { sourcePath, testPath } })` |
+| **Task Tool** (fallback) | Claude Code sessions without Workflow support | `Task({ subagent_type, run_in_background: true })` |
 | **MCP Tools** | MCP server available | `fleet_init({})` / `task_submit({})` |
 | **CLI** | Terminal/scripts | `swarm init` / `agent spawn` |
 
+### Workflow execution (ADR-102)
+
+`.claude/workflows/qcsd-development-review.js` runs the review as a deterministic
+pipeline: one finder per quality dimension (TDD adherence, complexity, coverage
+gaps — `args.dimensions` selects a subset) → **3 blind adversarial refuters per
+finding** (Loki-mode, ADR-074: refuters see only the bare claim + evidence,
+never the finder's confidence or each other; uncertainty defaults to refuted)
+→ deterministic synthesis into `finding-verdict@1` envelopes (ADR-103,
+`schemas/finding-verdict.schema.json`). A finding survives only if fewer than
+⌈N/2⌉ refuters kill it. The final report contains ONLY confirmed findings;
+killed findings are retained under `killed` with their refutations for audit.
+
+Args: `sourcePath` (required), `testPath`, `dimensions` (subset of
+`tdd-adherence|complexity|coverage-gaps`), `maxFindings` per dimension (default 5).
+
+When the Workflow tool is unavailable, fall back to the Task-tool protocol
+below — the report format and gates are identical, minus the adversarial
+verification stage (note this in the report header as `verification: none`).
+
 ---
 
 ## Key Principle

package/.claude/skills/skills-manifest.json

@@ -939,7 +939,7 @@
   },
   "metadata": {
     "generatedBy": "Agentic QE Fleet",
-    "fleetVersion": "3.10.3",
+    "fleetVersion": "3.10.5",
     "manifestVersion": "1.4.0",
     "lastUpdated": "2026-04-13T00:00:00.000Z",
     "contributors": [

package/CHANGELOG.md

@@ -5,6 +5,110 @@ All notable changes to the Agentic QE project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.10.5] - 2026-06-10
+
+The Fable 5 / harness-parity release (#520): the CLI's memory and fleet
+commands work for the first time, prompt caching actually engages, the
+self-learning pipeline stays clean under reasoning-heavy models, and two new
+capabilities land — adversarially verified QCSD reviews and competitive
+test-strategy tournaments. Seven improvements, each with its own ADR and a
+reproduction-first verification record on #520.
+
+### Added
+
+- **`aqe arena` — competitive test-strategy tournaments (ADR-104, Phase 1).**
+  Strategies compete on *real* fitness: built-in operator mutants executed via
+  `node --test`, real line coverage, and a deterministic suite-cost term.
+  `aqe arena run --target fixtures/arena-demo --seed 42` produces a ranked
+  competitive array that reproduces byte-identically under the same seed;
+  `--evolve` hill-climbs the winner; runs persist to memory.db (`aqe arena list`).
+- **Adversarially verified QCSD reviews (ADR-102).** The development-phase
+  swarm now runs as a deterministic workflow: one finder per quality dimension,
+  then 3 blind refuters per finding (majority kill, Loki-mode rules from
+  ADR-074), then code-only synthesis. Reports contain only confirmed findings;
+  killed findings are retained with their refutations. In the validation run,
+  the gate filtered a factually-wrong finding that the old prompt-driven
+  fan-out would have shipped.
+- **Structured verdict contracts (ADR-103).** Versioned, additive envelopes —
+  `RiskDecision`, `FindingVerdict`, `CoverageGap` — with dependency-free
+  validators and published JSON Schemas (`schemas/*.schema.json`). The
+  `quality_assess` MCP tool now attaches a validated `riskDecision` envelope.
+- **Tool-loop circuit breaker (ADR-100).** When the same Bash command fails
+  3× consecutively the pre-command hook warns; at 5× it emits a block
+  recommendation with a recovery hint (`AQE_STRICT_TOOL_LOOP=1` upgrades to a
+  hard deny). Success resets; an open breaker grants a probe after 2 minutes.
+- **Nested-subagent readiness (ADR-101).** Anthropic announced depth-5 nested
+  subagents on 2026-06-09; AQE is ready the day the gate lifts: post-task
+  hooks accept `--parent-agent-id`/`--depth` (validated, persisted into
+  trajectory metadata for per-hierarchy-level learning), and a committed probe
+  script (`scripts/probe-nested-spawn-depth.mjs`) detects the upstream
+  rollout — current verdict: `NO_AGENT_TOOL`, denylist still active.
+- **LLM judge benchmark harness** (`scripts/judge-benchmark.ts`) with Phase-1
+  results.
+
+### Fixed
+
+- **`aqe memory` / `agent` / `task` / `team` / `pipeline` CLI commands always
+  failed with "Fleet not initialized".** The CLI initialized a full kernel but
+  never registered it with the shared MCP handlers' fleet state. A new bridge
+  (`adoptExternalFleet`) gives both entry points one fleet state — these
+  commands now work from the terminal for the first time.
+- **Prompt caching was dead code (ADR-088 amendment).** `enableCache: true`
+  existed but never set `cache_control`; every advisor/LLM call paid full
+  input price. The Anthropic provider now marks the system prompt as an
+  ephemeral cache breakpoint, surfaces `cacheRead/cacheCreation` tokens, and
+  bills them at the real 0.1×/1.25× rates in cost tracking.
+- **Pattern embeddings were contaminated by extended-thinking blocks
+  (ADR-099).** Reasoning-heavy models (Fable 5 era) emit large scratchpads
+  inside task results; these are now scrubbed (boundary-gated) at trajectory
+  ingestion, distillation, embedding backfill, and query time — prose that
+  merely mentions a tag survives byte-identical.
+- **Fresh-install learning silently no-oped.** `persistTaskOutcome` assumed
+  middleware-created tables (`captured_experiences`, `experience_applications`);
+  on a fresh `.agentic-qe` the whole post-task learning transaction failed
+  silently. The hook path now ensures the canonical schema.
+
+### Changed
+
+- Devcontainer now mounts `node_modules` as a named volume and installs
+  in-container, so Linux containers stop tripping over host (macOS) native
+  binaries (contributors only; takes effect on container rebuild).
+- Setup docs and the devcontainer install script no longer pin the long-stale
+  `ruflo@3.5.18` (now `ruflo@3` + global `ruflo mcp start`).
+
+## [3.10.4] - 2026-06-08
+
+Two correctness fixes that keep a project's self-learning where it belongs and
+stop orphaned MCP servers from burning CPU, plus opt-in support for running your
+own local Nagual pattern hub and LLM judge.
+
+### Added
+
+- **Optional local Nagual pattern hub + local LLM judge (opt-in).** Point the
+  cross-project knowledge hub at a locally-run `nagual serve` instance via
+  `NAGUAL_URL`, and score pattern quality with a local Ollama-compatible model
+  via `NAGUAL_JUDGE_URL` / `NAGUAL_JUDGE_MODEL`. When configured, pre-task
+  analysis surfaces relevant cross-project patterns for complex tasks in QE
+  domains. Entirely best-effort and disabled unless the env vars are set — no
+  behavior change for existing users.
+
+### Fixed
+
+- **Project learning was being written outside its own `.agentic-qe/` (#516).**
+  Two root-resolution defects are fixed: (1) `findProjectRoot()` now prefers the
+  **nearest** `.agentic-qe` instead of the topmost, so an ancestor store (e.g.
+  `~/.agentic-qe`, created by any `aqe` run from `$HOME`) no longer hijacks every
+  descendant project and fragments its learning into `$HOME`; (2) the RVF
+  substrate (`patterns.rvf` / `brain.rvf`) now resolves its location through the
+  project root instead of a cwd-relative default, so running a hook, worker, or
+  `aqe` command from a subfolder no longer scatters stray, orphaned stores.
+- **Orphaned `aqe-mcp` server busy-looped at high CPU and ignored SIGTERM (#513).**
+  When the parent Claude Code session exited, the stdio MCP server was reparented
+  and spun at 70–98% CPU indefinitely, surviving `kill` (only `kill -9` worked).
+  Stdin EOF is now treated as terminal — the server shuts down gracefully instead
+  of entering a reconnect busy-loop — backed by an idempotent shutdown path with a
+  watchdog timeout and `unref()`'d background timers so an orphan can never linger.
+
 ## [3.10.3] - 2026-06-03
 
 Code-intelligence overhaul for the JS/TS ecosystem (#511) plus a critical fix for

package/assets/skills/skills-manifest.json

@@ -939,7 +939,7 @@
   },
   "metadata": {
     "generatedBy": "Agentic QE Fleet",
-    "fleetVersion": "3.10.3",
+    "fleetVersion": "3.10.4",
     "manifestVersion": "1.4.0",
     "lastUpdated": "2026-04-13T00:00:00.000Z",
     "contributors": [

package/dist/arena/arena.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Agentic QE v3 - Competitive Test-Strategy Arena (ADR-104, Phase 1)
+ *
+ * Strategies are deterministic selections of fixture test groups; fitness
+ * comes from REAL runs: mutation kill rate (built-in operator mutants,
+ * `node --test` per mutant) + line coverage − a runtime penalty. The
+ * tournament produces Wolfram-style pairwise competitive arrays; optional
+ * hill-climb evolves the winner by seeded group flips with re-evaluation.
+ *
+ * Reproducibility contract: with the same seed and fixture, every field
+ * of the result envelope is identical across runs EXCEPT
+ * `informational.runtimesMs` (real wall-clock, reported but excluded —
+ * the fitness runtime term uses ordinal rank, which is stable because
+ * group runtimes differ by design).
+ */
+import { type Rng } from './rng.js';
+export interface ArenaStrategy {
+    id: string;
+    name: string;
+    groups: string[];
+}
+export interface EvaluatedStrategy extends ArenaStrategy {
+    baselinePassed: boolean;
+    mutantsKilled: number;
+    mutantsTotal: number;
+    killRate: number;
+    coveragePct: number | null;
+    /** Deterministic runtime proxy: selected groups / total groups (0..1) */
+    suiteCostRatio: number;
+    fitness: number;
+}
+export interface ArenaResult {
+    contract: 'arena-result@1';
+    seed: number;
+    target: string;
+    weights: {
+        kill: number;
+        coverage: number;
+        runtimePenalty: number;
+    };
+    mutantsTotal: number;
+    strategies: EvaluatedStrategy[];
+    /** strategy ids best→worst */
+    ranking: string[];
+    /** competitiveArray[i][j]: 1 if strategies[i] beats [j], -1 if loses, 0 tie (by fitness) */
+    competitiveArray: number[][];
+    evolution: Array<{
+        step: number;
+        groups: string[];
+        fitness: number;
+        accepted: boolean;
+    }>;
+    informational: {
+        runtimesMs: Record<string, number>;
+    };
+}
+export interface ArenaOptions {
+    target: string;
+    strategies?: number;
+    seed?: number;
+    maxMutants?: number;
+    evolveSteps?: number;
+    log?: (line: string) => void;
+}
+/** First strategy is always the full suite; the rest are seeded distinct subsets. */
+export declare function buildStrategies(groups: string[], n: number, rng: Rng): ArenaStrategy[];
+export declare function runArena(options: ArenaOptions): ArenaResult;
+//# sourceMappingURL=arena.d.ts.map

package/dist/arena/arena.js

@@ -0,0 +1,169 @@
+/**
+ * Agentic QE v3 - Competitive Test-Strategy Arena (ADR-104, Phase 1)
+ *
+ * Strategies are deterministic selections of fixture test groups; fitness
+ * comes from REAL runs: mutation kill rate (built-in operator mutants,
+ * `node --test` per mutant) + line coverage − a runtime penalty. The
+ * tournament produces Wolfram-style pairwise competitive arrays; optional
+ * hill-climb evolves the winner by seeded group flips with re-evaluation.
+ *
+ * Reproducibility contract: with the same seed and fixture, every field
+ * of the result envelope is identical across runs EXCEPT
+ * `informational.runtimesMs` (real wall-clock, reported but excluded —
+ * the fitness runtime term uses ordinal rank, which is stable because
+ * group runtimes differ by design).
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { mulberry32, nextInt } from './rng.js';
+import { enumerateMutants, applyMutant } from './mutator.js';
+import { discoverFixture, prepareWorkspace, runNodeTest, makeTmpRoot, cleanupTmpRoot, } from './runner.js';
+const WEIGHTS = { kill: 0.6, coverage: 0.3, runtimePenalty: 0.1 };
+/** First strategy is always the full suite; the rest are seeded distinct subsets. */
+export function buildStrategies(groups, n, rng) {
+    const sorted = [...groups].sort();
+    const seen = new Set([sorted.join('+')]);
+    const strategies = [
+        { id: 's1', name: `all(${sorted.join('+')})`, groups: sorted },
+    ];
+    let guard = 0;
+    while (strategies.length < n && guard++ < 200) {
+        const subset = sorted.filter(() => rng() < 0.5);
+        if (subset.length === 0)
+            continue;
+        const key = subset.join('+');
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        strategies.push({ id: `s${strategies.length + 1}`, name: key, groups: subset });
+    }
+    return strategies;
+}
+/**
+ * Fitness with a DETERMINISTIC runtime term: at fixture scale, measured
+ * wall-clock is jitter-dominated (node boot ≈ the suite runtime), so the
+ * penalty uses suite-size ratio as the runtime proxy. Real per-strategy
+ * milliseconds are still reported under `informational`.
+ */
+function fitnessOf(killRate, coveragePct, suiteCostRatio) {
+    const coverageTerm = coveragePct === null ? 0 : coveragePct / 100;
+    const f = WEIGHTS.kill * killRate + WEIGHTS.coverage * coverageTerm - WEIGHTS.runtimePenalty * suiteCostRatio;
+    return Math.round(f * 10000) / 10000;
+}
+function evaluateStrategy(layout, strategy, mutantsByFile, tmpRoot) {
+    const baselineDir = prepareWorkspace({ layout, groups: strategy.groups }, tmpRoot);
+    const baseline = runNodeTest(baselineDir, { coverage: true });
+    if (!baseline.ok) {
+        return { baselinePassed: false, killed: 0, total: 0, coveragePct: baseline.coveragePct, runtimeMs: baseline.durationMs };
+    }
+    let killed = 0;
+    let total = 0;
+    for (const file of mutantsByFile) {
+        for (const mutant of file.mutants) {
+            total++;
+            const dir = prepareWorkspace({ layout, groups: strategy.groups, mutatedFile: { relPath: file.relPath, content: applyMutant(file.source, mutant) } }, tmpRoot);
+            const run = runNodeTest(dir);
+            if (!run.ok)
+                killed++;
+        }
+    }
+    return { baselinePassed: true, killed, total, coveragePct: baseline.coveragePct, runtimeMs: baseline.durationMs };
+}
+export function runArena(options) {
+    const seed = options.seed ?? 42;
+    const log = options.log ?? (() => { });
+    const rng = mulberry32(seed);
+    const layout = discoverFixture(options.target);
+    const tmpRoot = makeTmpRoot();
+    try {
+        // Enumerate + deterministically sample mutants
+        const maxMutants = options.maxMutants ?? 24;
+        const mutantsByFile = layout.sourceFiles.map((relPath) => {
+            const source = fs.readFileSync(path.join(layout.root, relPath), 'utf8');
+            return { relPath, source, mutants: enumerateMutants(source, relPath) };
+        });
+        let allMutants = mutantsByFile.flatMap((f) => f.mutants.map((m) => ({ file: f.relPath, m })));
+        if (allMutants.length > maxMutants) {
+            const picked = new Set();
+            while (picked.size < maxMutants) {
+                picked.add(allMutants[nextInt(rng, allMutants.length)].m.id);
+            }
+            for (const f of mutantsByFile) {
+                f.mutants = f.mutants.filter((m) => picked.has(m.id));
+            }
+            allMutants = mutantsByFile.flatMap((f) => f.mutants.map((m) => ({ file: f.relPath, m })));
+        }
+        log(`mutants: ${allMutants.length} (of ${mutantsByFile.reduce((n, f) => n + enumerateMutants(f.source, f.relPath).length, 0)} enumerated)`);
+        // Build + evaluate strategies (real runs)
+        const strategies = buildStrategies(Object.keys(layout.testGroups), options.strategies ?? 4, rng);
+        const runtimesMs = {};
+        const raw = strategies.map((s) => {
+            log(`evaluating ${s.id} [${s.name}] ...`);
+            const e = evaluateStrategy(layout, s, mutantsByFile, tmpRoot);
+            runtimesMs[s.id] = e.runtimeMs;
+            return { s, e };
+        });
+        const totalGroups = Object.keys(layout.testGroups).length;
+        const evaluated = raw.map(({ s, e }) => {
+            const killRate = e.total > 0 ? Math.round((e.killed / e.total) * 10000) / 10000 : 0;
+            const suiteCostRatio = Math.round((s.groups.length / totalGroups) * 10000) / 10000;
+            return {
+                ...s,
+                baselinePassed: e.baselinePassed,
+                mutantsKilled: e.killed,
+                mutantsTotal: e.total,
+                killRate,
+                coveragePct: e.coveragePct,
+                suiteCostRatio,
+                fitness: e.baselinePassed ? fitnessOf(killRate, e.coveragePct, suiteCostRatio) : 0,
+            };
+        });
+        const ranking = [...evaluated]
+            .sort((a, b) => b.fitness - a.fitness || a.id.localeCompare(b.id))
+            .map((s) => s.id);
+        const competitiveArray = evaluated.map((a) => evaluated.map((b) => (a.fitness > b.fitness ? 1 : a.fitness < b.fitness ? -1 : 0)));
+        // Optional hill-climb from the winner: seeded single-group flips,
+        // accept only on real fitness improvement
+        const evolution = [];
+        if (options.evolveSteps && options.evolveSteps > 0) {
+            const allGroups = Object.keys(layout.testGroups).sort();
+            let bestGroups = evaluated.find((s) => s.id === ranking[0]).groups;
+            let bestFitness = evaluated.find((s) => s.id === ranking[0]).fitness;
+            for (let step = 1; step <= options.evolveSteps; step++) {
+                const flip = allGroups[nextInt(rng, allGroups.length)];
+                const candidate = bestGroups.includes(flip)
+                    ? bestGroups.filter((g) => g !== flip)
+                    : [...bestGroups, flip].sort();
+                if (candidate.length === 0) {
+                    evolution.push({ step, groups: candidate, fitness: 0, accepted: false });
+                    continue;
+                }
+                const e = evaluateStrategy(layout, { id: `evo${step}`, name: candidate.join('+'), groups: candidate }, mutantsByFile, tmpRoot);
+                const killRate = e.total > 0 ? e.killed / e.total : 0;
+                const f = e.baselinePassed ? fitnessOf(killRate, e.coveragePct, candidate.length / allGroups.length) : 0;
+                const accepted = f > bestFitness;
+                evolution.push({ step, groups: candidate, fitness: f, accepted });
+                if (accepted) {
+                    bestGroups = candidate;
+                    bestFitness = f;
+                }
+            }
+        }
+        return {
+            contract: 'arena-result@1',
+            seed,
+            target: path.relative(process.cwd(), layout.root) || '.',
+            weights: { ...WEIGHTS },
+            mutantsTotal: allMutants.length,
+            strategies: evaluated,
+            ranking,
+            competitiveArray,
+            evolution,
+            informational: { runtimesMs },
+        };
+    }
+    finally {
+        cleanupTmpRoot(tmpRoot);
+    }
+}
+//# sourceMappingURL=arena.js.map

package/dist/arena/mutator.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Agentic QE v3 - Operator Mutator for qe-arena (ADR-104)
+ *
+ * Generates first-order operator mutants from JavaScript source text:
+ * comparison flips, boundary shifts, arithmetic swaps, logical swaps.
+ * String literals, template literals, comments, and arrow tokens are
+ * excluded so mutants change behavior, not error messages. Enumeration
+ * order is deterministic (position-sorted), so seeded sampling over the
+ * mutant list is reproducible.
+ */
+export interface Mutant {
+    id: string;
+    /** Byte offset in the source file */
+    index: number;
+    from: string;
+    to: string;
+    line: number;
+}
+/** Enumerate all first-order mutants of a source text, position-sorted. */
+export declare function enumerateMutants(source: string, fileLabel: string): Mutant[];
+/** Apply one mutant to the source text. */
+export declare function applyMutant(source: string, mutant: Mutant): string;
+//# sourceMappingURL=mutator.d.ts.map

package/dist/arena/mutator.js

@@ -0,0 +1,112 @@
+/**
+ * Agentic QE v3 - Operator Mutator for qe-arena (ADR-104)
+ *
+ * Generates first-order operator mutants from JavaScript source text:
+ * comparison flips, boundary shifts, arithmetic swaps, logical swaps.
+ * String literals, template literals, comments, and arrow tokens are
+ * excluded so mutants change behavior, not error messages. Enumeration
+ * order is deterministic (position-sorted), so seeded sampling over the
+ * mutant list is reproducible.
+ */
+/** Longest-first so '<=' is claimed before '<', '===' before '==' etc. */
+const OPERATOR_SUBSTITUTIONS = [
+    ['===', '!=='],
+    ['!==', '==='],
+    ['<=', '<'],
+    ['>=', '>'],
+    ['&&', '||'],
+    ['||', '&&'],
+    ['<', '<='],
+    ['>', '>='],
+    ['+', '-'],
+    ['*', '+'],
+];
+/**
+ * Mark every index that sits inside a string literal, template literal,
+ * or comment — operators there must not be mutated.
+ */
+function excludedRanges(source) {
+    const excluded = new Array(source.length).fill(false);
+    let i = 0;
+    let mode = 'code';
+    while (i < source.length) {
+        const c = source[i];
+        const next = source[i + 1];
+        if (mode === 'code') {
+            if (c === "'")
+                mode = 'single';
+            else if (c === '"')
+                mode = 'double';
+            else if (c === '`')
+                mode = 'template';
+            else if (c === '/' && next === '/')
+                mode = 'line-comment';
+            else if (c === '/' && next === '*')
+                mode = 'block-comment';
+            if (mode !== 'code')
+                excluded[i] = true;
+        }
+        else {
+            excluded[i] = true;
+            if (mode === 'single' && c === "'" && source[i - 1] !== '\\')
+                mode = 'code';
+            else if (mode === 'double' && c === '"' && source[i - 1] !== '\\')
+                mode = 'code';
+            else if (mode === 'template' && c === '`' && source[i - 1] !== '\\')
+                mode = 'code';
+            else if (mode === 'line-comment' && c === '\n')
+                mode = 'code';
+            else if (mode === 'block-comment' && c === '*' && next === '/') {
+                excluded[i + 1] = true;
+                i++;
+                mode = 'code';
+            }
+        }
+        i++;
+    }
+    return excluded;
+}
+function lineOf(source, index) {
+    let line = 1;
+    for (let i = 0; i < index; i++) {
+        if (source[i] === '\n')
+            line++;
+    }
+    return line;
+}
+/** Enumerate all first-order mutants of a source text, position-sorted. */
+export function enumerateMutants(source, fileLabel) {
+    const excluded = excludedRanges(source);
+    const claimed = new Array(source.length).fill(false);
+    const mutants = [];
+    for (const [from, to] of OPERATOR_SUBSTITUTIONS) {
+        let pos = source.indexOf(from);
+        while (pos !== -1) {
+            const end = pos + from.length;
+            const overlapsClaim = claimed.slice(pos, end).some(Boolean);
+            const overlapsExcluded = excluded.slice(pos, end).some(Boolean);
+            // '=>' protection: never mutate the '>' of an arrow; '>=' handled by ordering
+            const isArrow = from === '>' && source[pos - 1] === '=';
+            // avoid '<=' / '>=' double-claim from the 1-char pass
+            const widerLeft = (from === '<' || from === '>') && (source[end] === '=' || source[pos - 1] === '<' || source[pos - 1] === '>');
+            if (!overlapsClaim && !overlapsExcluded && !isArrow && !widerLeft) {
+                for (let i = pos; i < end; i++)
+                    claimed[i] = true;
+                mutants.push({
+                    id: `${fileLabel}:${lineOf(source, pos)}:${pos}:${from}->${to}`,
+                    index: pos,
+                    from,
+                    to,
+                    line: lineOf(source, pos),
+                });
+            }
+            pos = source.indexOf(from, pos + 1);
+        }
+    }
+    return mutants.sort((a, b) => a.index - b.index);
+}
+/** Apply one mutant to the source text. */
+export function applyMutant(source, mutant) {
+    return source.slice(0, mutant.index) + mutant.to + source.slice(mutant.index + mutant.from.length);
+}
+//# sourceMappingURL=mutator.js.map

package/dist/arena/rng.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Agentic QE v3 - Seeded RNG for qe-arena (ADR-104)
+ *
+ * mulberry32 — tiny deterministic PRNG. Everything the arena randomizes
+ * (strategy subset sampling, mutant sampling, hill-climb flips) draws from
+ * one seeded stream so identical seeds reproduce identical tournaments.
+ * No Math.random()/Date.now() anywhere in scoring paths.
+ */
+export type Rng = () => number;
+export declare function mulberry32(seed: number): Rng;
+/** Deterministic integer in [0, maxExclusive) */
+export declare function nextInt(rng: Rng, maxExclusive: number): number;
+/** Deterministic sample of k distinct items (order-stable Fisher-Yates prefix) */
+export declare function sample<T>(rng: Rng, items: readonly T[], k: number): T[];
+//# sourceMappingURL=rng.d.ts.map

package/dist/arena/rng.js

@@ -0,0 +1,34 @@
+/**
+ * Agentic QE v3 - Seeded RNG for qe-arena (ADR-104)
+ *
+ * mulberry32 — tiny deterministic PRNG. Everything the arena randomizes
+ * (strategy subset sampling, mutant sampling, hill-climb flips) draws from
+ * one seeded stream so identical seeds reproduce identical tournaments.
+ * No Math.random()/Date.now() anywhere in scoring paths.
+ */
+export function mulberry32(seed) {
+    let a = seed >>> 0;
+    return function () {
+        a |= 0;
+        a = (a + 0x6d2b79f5) | 0;
+        let t = Math.imul(a ^ (a >>> 15), 1 | a);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+/** Deterministic integer in [0, maxExclusive) */
+export function nextInt(rng, maxExclusive) {
+    return Math.floor(rng() * maxExclusive);
+}
+/** Deterministic sample of k distinct items (order-stable Fisher-Yates prefix) */
+export function sample(rng, items, k) {
+    const pool = [...items];
+    const out = [];
+    const n = Math.min(k, pool.length);
+    for (let i = 0; i < n; i++) {
+        const idx = nextInt(rng, pool.length);
+        out.push(pool.splice(idx, 1)[0]);
+    }
+    return out;
+}
+//# sourceMappingURL=rng.js.map

package/dist/arena/runner.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Agentic QE v3 - Fixture Runner for qe-arena (ADR-104)
+ *
+ * Materializes a strategy's workspace (fixture sources — optionally with
+ * one mutant applied — plus only the test groups the strategy selects)
+ * in a temp directory and runs it with `node --test`. Real test runs,
+ * real exit codes; nothing simulated.
+ */
+export interface FixtureLayout {
+    /** Absolute path of the fixture project */
+    root: string;
+    /** Source files, relative to root (mutation targets) */
+    sourceFiles: string[];
+    /** Test group name → test file relative path */
+    testGroups: Record<string, string>;
+}
+export interface RunResult {
+    ok: boolean;
+    durationMs: number;
+    /** Line-coverage percent parsed from --experimental-test-coverage, when requested */
+    coveragePct: number | null;
+}
+/** Discover the conventional fixture layout: src/*.mjs + tests/<group>.test.mjs */
+export declare function discoverFixture(root: string): FixtureLayout;
+export interface WorkspaceSpec {
+    layout: FixtureLayout;
+    groups: string[];
+    /** When set, this source file's content replaces the original */
+    mutatedFile?: {
+        relPath: string;
+        content: string;
+    };
+}
+/** Build a throwaway workspace for one (strategy, mutant?) evaluation. */
+export declare function prepareWorkspace(spec: WorkspaceSpec, tmpRoot: string): string;
+/** Run `node --test` on the workspace's test files (explicit paths — a bare
+ * directory argument is not portably supported by the node test runner). */
+export declare function runNodeTest(dir: string, options?: {
+    coverage?: boolean;
+    timeoutMs?: number;
+}): RunResult;
+export declare function makeTmpRoot(): string;
+export declare function cleanupTmpRoot(tmpRoot: string): void;
+//# sourceMappingURL=runner.d.ts.map