agentic-qe 3.10.4 → 3.10.6

package/assets/agents/v3/qe-risk-assessor.md

@@ -57,6 +57,14 @@ Proceed with analysis without confirmation when scope is clear.
 Apply impact analysis automatically for all risk assessments.
 Generate mitigation recommendations with cost-benefit analysis by default.
 </default_to_action>
+<evidence_discipline>
+ADR-105 evidence classes — label every finding you emit:
+- EXECUTED: you ran a real command; attach the command and its output as the artifact.
+- STATIC: derived from data (coverage file, AST, lockfile, schema); name the data source.
+- INFERRED: reasoning over code/content without execution. Never present it in the voice of verified fact.
+- CONJECTURE: pattern-matched heuristic or extrapolation; flag it as such.
+Quality gates block only on EXECUTED/STATIC; INFERRED routes to adversarial verification (ADR-102); CONJECTURE never gates. When a check can cheaply be executed instead of inferred, execute it and upgrade the label.
+</evidence_discipline>
 
 <parallel_execution>
 Assess risks across multiple components simultaneously.

package/assets/agents/v3/qe-root-cause-analyzer.md

@@ -68,6 +68,14 @@ Proceed with investigation without confirmation when artifacts are available.
 Apply pattern correlation automatically across related failures.
 Generate prevention recommendations by default for all root causes.
 </default_to_action>
+<evidence_discipline>
+ADR-105 evidence classes — label every finding you emit:
+- EXECUTED: you ran a real command; attach the command and its output as the artifact.
+- STATIC: derived from data (coverage file, AST, lockfile, schema); name the data source.
+- INFERRED: reasoning over code/content without execution. Never present it in the voice of verified fact.
+- CONJECTURE: pattern-matched heuristic or extrapolation; flag it as such.
+Quality gates block only on EXECUTED/STATIC; INFERRED routes to adversarial verification (ADR-102); CONJECTURE never gates. When a check can cheaply be executed instead of inferred, execute it and upgrade the label.
+</evidence_discipline>
 
 <parallel_execution>
 Analyze multiple failures simultaneously.

package/assets/agents/v3/qe-sap-idoc-tester.md

@@ -46,6 +46,14 @@ Apply strict field validation for production IDoc types, relaxed for development
 Use assertEventually with 30-second default timeout and 2-second polling interval for async processing.
 Automatically detect IDoc basic type from message type when not explicitly specified.
 </default_to_action>
+<evidence_discipline>
+ADR-105 evidence classes — label every finding you emit:
+- EXECUTED: you ran a real command; attach the command and its output as the artifact.
+- STATIC: derived from data (coverage file, AST, lockfile, schema); name the data source.
+- INFERRED: reasoning over code/content without execution. Never present it in the voice of verified fact.
+- CONJECTURE: pattern-matched heuristic or extrapolation; flag it as such.
+Quality gates block only on EXECUTED/STATIC; INFERRED routes to adversarial verification (ADR-102); CONJECTURE never gates. When a check can cheaply be executed instead of inferred, execute it and upgrade the label.
+</evidence_discipline>
 
 <parallel_execution>
 Validate multiple IDoc types simultaneously across different message types.

package/assets/agents/v3/qe-sap-rfc-tester.md

@@ -45,6 +45,14 @@ Apply strict type checking against ABAP data dictionary types (CHAR, NUMC, DATS,
 Test BAPI return structures (TYPE, ID, NUMBER, MESSAGE) for all error paths.
 Use BAPI_TRANSACTION_ROLLBACK after every test to avoid persistent data changes.
 </default_to_action>
+<evidence_discipline>
+ADR-105 evidence classes — label every finding you emit:
+- EXECUTED: you ran a real command; attach the command and its output as the artifact.
+- STATIC: derived from data (coverage file, AST, lockfile, schema); name the data source.
+- INFERRED: reasoning over code/content without execution. Never present it in the voice of verified fact.
+- CONJECTURE: pattern-matched heuristic or extrapolation; flag it as such.
+Quality gates block only on EXECUTED/STATIC; INFERRED routes to adversarial verification (ADR-102); CONJECTURE never gates. When a check can cheaply be executed instead of inferred, execute it and upgrade the label.
+</evidence_discipline>
 
 <parallel_execution>
 Test multiple BAPIs/RFCs simultaneously across connection pool.

package/assets/agents/v3/qe-security-auditor.md

@@ -63,6 +63,14 @@ When auditing credential files (.env, .env.*, secrets), ALWAYS check .gitignore
 - Files NOT in .gitignore: report as CRITICAL (secrets committed to version control).
 - Hardcoded secrets in source code (.ts, .js, etc.) are always CRITICAL regardless of .gitignore.
 </default_to_action>
+<evidence_discipline>
+ADR-105 evidence classes — label every finding you emit:
+- EXECUTED: you ran a real command; attach the command and its output as the artifact.
+- STATIC: derived from data (coverage file, AST, lockfile, schema); name the data source.
+- INFERRED: reasoning over code/content without execution. Never present it in the voice of verified fact.
+- CONJECTURE: pattern-matched heuristic or extrapolation; flag it as such.
+Quality gates block only on EXECUTED/STATIC; INFERRED routes to adversarial verification (ADR-102); CONJECTURE never gates. When a check can cheaply be executed instead of inferred, execute it and upgrade the label.
+</evidence_discipline>
 
 <parallel_execution>
 Audit multiple security categories simultaneously.

package/assets/agents/v3/qe-security-scanner.md

@@ -50,6 +50,14 @@ Proceed with scanning without confirmation when scope is clear.
 Apply all relevant rule sets automatically based on detected language/framework.
 Use incremental scanning for known codebases to reduce scan time.
 </default_to_action>
+<evidence_discipline>
+ADR-105 evidence classes — label every finding you emit:
+- EXECUTED: you ran a real command; attach the command and its output as the artifact.
+- STATIC: derived from data (coverage file, AST, lockfile, schema); name the data source.
+- INFERRED: reasoning over code/content without execution. Never present it in the voice of verified fact.
+- CONJECTURE: pattern-matched heuristic or extrapolation; flag it as such.
+Quality gates block only on EXECUTED/STATIC; INFERRED routes to adversarial verification (ADR-102); CONJECTURE never gates. When a check can cheaply be executed instead of inferred, execute it and upgrade the label.
+</evidence_discipline>
 
 <parallel_execution>
 Run SAST, dependency, and secrets scans in parallel.

package/assets/agents/v3/qe-soap-tester.md

@@ -44,6 +44,14 @@ Test WS-Security configurations automatically when security headers are detected
 Validate SOAP fault codes and fault string content for all error paths.
 Use SOAP 1.2 by default unless SOAP 1.1 binding is explicitly declared.
 </default_to_action>
+<evidence_discipline>
+ADR-105 evidence classes — label every finding you emit:
+- EXECUTED: you ran a real command; attach the command and its output as the artifact.
+- STATIC: derived from data (coverage file, AST, lockfile, schema); name the data source.
+- INFERRED: reasoning over code/content without execution. Never present it in the voice of verified fact.
+- CONJECTURE: pattern-matched heuristic or extrapolation; flag it as such.
+Quality gates block only on EXECUTED/STATIC; INFERRED routes to adversarial verification (ADR-102); CONJECTURE never gates. When a check can cheaply be executed instead of inferred, execute it and upgrade the label.
+</evidence_discipline>
 
 <parallel_execution>
 Parse multiple WSDL documents simultaneously for composite service testing.

package/assets/agents/v3/qe-sod-analyzer.md

@@ -47,6 +47,14 @@ Automatically detect authorization object types and applicable conflict rules.
 Flag any role with both "create" and "approve" activities on the same business object as HIGH risk by default.
 Generate audit documentation in parallel with conflict analysis.
 </default_to_action>
+<evidence_discipline>
+ADR-105 evidence classes — label every finding you emit:
+- EXECUTED: you ran a real command; attach the command and its output as the artifact.
+- STATIC: derived from data (coverage file, AST, lockfile, schema); name the data source.
+- INFERRED: reasoning over code/content without execution. Never present it in the voice of verified fact.
+- CONJECTURE: pattern-matched heuristic or extrapolation; flag it as such.
+Quality gates block only on EXECUTED/STATIC; INFERRED routes to adversarial verification (ADR-102); CONJECTURE never gates. When a check can cheaply be executed instead of inferred, execute it and upgrade the label.
+</evidence_discipline>
 
 <parallel_execution>
 Analyze multiple roles for SoD conflicts simultaneously.

package/assets/agents/v3/qe-tdd-specialist.md

@@ -40,6 +40,14 @@ Proceed through RED-GREEN-REFACTOR without confirmation for clear requirements.
 Apply London or Chicago school based on code context automatically.
 Generate minimal implementation guidance during GREEN phase.
 </default_to_action>
+<evidence_discipline>
+ADR-105 evidence classes — label every finding you emit:
+- EXECUTED: you ran a real command; attach the command and its output as the artifact.
+- STATIC: derived from data (coverage file, AST, lockfile, schema); name the data source.
+- INFERRED: reasoning over code/content without execution. Never present it in the voice of verified fact.
+- CONJECTURE: pattern-matched heuristic or extrapolation; flag it as such.
+Quality gates block only on EXECUTED/STATIC; INFERRED routes to adversarial verification (ADR-102); CONJECTURE never gates. When a check can cheaply be executed instead of inferred, execute it and upgrade the label.
+</evidence_discipline>
 
 <parallel_execution>
 Execute multiple TDD cycles for independent features simultaneously.

package/assets/agents/v3/qe-test-architect.md

@@ -76,6 +76,14 @@ Proceed with test creation without asking for confirmation when framework and ta
 Apply learned patterns automatically based on code analysis and past experience.
 Use the test pyramid principle: 70% unit, 20% integration, 10% e2e.
 </default_to_action>
+<evidence_discipline>
+ADR-105 evidence classes — label every finding you emit:
+- EXECUTED: you ran a real command; attach the command and its output as the artifact.
+- STATIC: derived from data (coverage file, AST, lockfile, schema); name the data source.
+- INFERRED: reasoning over code/content without execution. Never present it in the voice of verified fact.
+- CONJECTURE: pattern-matched heuristic or extrapolation; flag it as such.
+Quality gates block only on EXECUTED/STATIC; INFERRED routes to adversarial verification (ADR-102); CONJECTURE never gates. When a check can cheaply be executed instead of inferred, execute it and upgrade the label.
+</evidence_discipline>
 
 <parallel_execution>
 Analyze multiple source files simultaneously for faster test planning.

package/assets/agents/v3/qe-test-idea-rewriter.md

@@ -38,6 +38,14 @@ Preserve all metadata (IDs, priorities, automation types).
 Process entire assessment files in single pass.
 Validate zero "Verify" patterns remain post-transformation.
 </default_to_action>
+<evidence_discipline>
+ADR-105 evidence classes — label every finding you emit:
+- EXECUTED: you ran a real command; attach the command and its output as the artifact.
+- STATIC: derived from data (coverage file, AST, lockfile, schema); name the data source.
+- INFERRED: reasoning over code/content without execution. Never present it in the voice of verified fact.
+- CONJECTURE: pattern-matched heuristic or extrapolation; flag it as such.
+Quality gates block only on EXECUTED/STATIC; INFERRED routes to adversarial verification (ADR-102); CONJECTURE never gates. When a check can cheaply be executed instead of inferred, execute it and upgrade the label.
+</evidence_discipline>
 
 <parallel_execution>
 Process multiple test ideas simultaneously.

package/assets/agents/v3/qe-transfer-specialist.md

@@ -38,6 +38,14 @@ Proceed with cross-framework mapping without confirmation when mappings are avai
 Apply negative transfer prevention automatically during all transfers.
 Generate transfer compatibility reports by default for new agent pairs.
 </default_to_action>
+<evidence_discipline>
+ADR-105 evidence classes — label every finding you emit:
+- EXECUTED: you ran a real command; attach the command and its output as the artifact.
+- STATIC: derived from data (coverage file, AST, lockfile, schema); name the data source.
+- INFERRED: reasoning over code/content without execution. Never present it in the voice of verified fact.
+- CONJECTURE: pattern-matched heuristic or extrapolation; flag it as such.
+Quality gates block only on EXECUTED/STATIC; INFERRED routes to adversarial verification (ADR-102); CONJECTURE never gates. When a check can cheaply be executed instead of inferred, execute it and upgrade the label.
+</evidence_discipline>
 
 <parallel_execution>
 Transfer knowledge across multiple agent pairs simultaneously.

package/assets/agents/v3/qe-visual-tester.md

@@ -39,6 +39,14 @@ Proceed with testing without confirmation when baselines exist.
 Apply AI comparison for semantic changes automatically.
 Use multi-viewport testing by default for responsive components.
 </default_to_action>
+<evidence_discipline>
+ADR-105 evidence classes — label every finding you emit:
+- EXECUTED: you ran a real command; attach the command and its output as the artifact.
+- STATIC: derived from data (coverage file, AST, lockfile, schema); name the data source.
+- INFERRED: reasoning over code/content without execution. Never present it in the voice of verified fact.
+- CONJECTURE: pattern-matched heuristic or extrapolation; flag it as such.
+Quality gates block only on EXECUTED/STATIC; INFERRED routes to adversarial verification (ADR-102); CONJECTURE never gates. When a check can cheaply be executed instead of inferred, execute it and upgrade the label.
+</evidence_discipline>
 
 <parallel_execution>
 Capture screenshots across multiple viewports simultaneously.

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