agentic-qe 3.11.2 → 3.11.3

package/dist/shared/llm/providers/openrouter.js

@@ -61,7 +61,7 @@ export const OPENROUTER_PRICING = {
  * OpenRouter LLM provider implementation
  */
 export class OpenRouterProvider {
-    type = 'openai'; // Compatible with OpenAI interface
+    type = 'openrouter';
     name = 'OpenRouter';
     config;
     requestId = 0;
@@ -138,7 +138,7 @@ export class OpenRouterProvider {
     async generate(input, options) {
         const apiKey = this.getApiKey();
         if (!apiKey) {
-            throw createLLMError('OpenRouter API key not configured', 'API_KEY_MISSING', { provider: 'openai', retryable: false });
+            throw createLLMError('OpenRouter API key not configured', 'API_KEY_MISSING', { provider: 'openrouter', retryable: false });
         }
         const messages = this.formatMessages(input, options?.systemPrompt);
         const model = options?.model ?? this.config.model;
@@ -193,7 +193,7 @@ export class OpenRouterProvider {
             return {
                 content,
                 model: data.model,
-                provider: 'openai', // Report as openai for compatibility
+                provider: 'openrouter',
                 usage,
                 cost,
                 latencyMs,
@@ -206,7 +206,7 @@ export class OpenRouterProvider {
             if (error instanceof Error && 'code' in error) {
                 throw error; // Re-throw LLM errors
             }
-            throw createLLMError(error instanceof Error ? error.message : 'Request failed', 'NETWORK_ERROR', { provider: 'openai', model, retryable: true, cause: error });
+            throw createLLMError(error instanceof Error ? error.message : 'Request failed', 'NETWORK_ERROR', { provider: 'openrouter', model, retryable: true, cause: error });
         }
     }
     /**
@@ -216,7 +216,7 @@ export class OpenRouterProvider {
     async *generateStream(input, options) {
         const apiKey = this.getApiKey();
         if (!apiKey) {
-            throw createLLMError('OpenRouter API key not configured', 'API_KEY_MISSING', { provider: 'openai', retryable: false });
+            throw createLLMError('OpenRouter API key not configured', 'API_KEY_MISSING', { provider: 'openrouter', retryable: false });
         }
         const messages = this.formatMessages(input, options?.systemPrompt);
         const model = options?.model ?? this.config.model;
@@ -246,7 +246,7 @@ export class OpenRouterProvider {
             throw this.handleApiError(response.status, errorData, model);
         }
         if (!response.body) {
-            throw createLLMError('No response body for streaming', 'NETWORK_ERROR', { provider: 'openai', model, retryable: true });
+            throw createLLMError('No response body for streaming', 'NETWORK_ERROR', { provider: 'openrouter', model, retryable: true });
         }
         let fullContent = '';
         let finishReason = 'stop';
@@ -311,7 +311,7 @@ export class OpenRouterProvider {
         return {
             content: fullContent,
             model: responseModel,
-            provider: 'openai',
+            provider: 'openrouter',
             usage,
             cost,
             latencyMs,
@@ -327,7 +327,7 @@ export class OpenRouterProvider {
     async embed(text, options) {
         const apiKey = this.getApiKey();
         if (!apiKey) {
-            throw createLLMError('OpenRouter API key not configured', 'API_KEY_MISSING', { provider: 'openai', retryable: false });
+            throw createLLMError('OpenRouter API key not configured', 'API_KEY_MISSING', { provider: 'openrouter', retryable: false });
         }
         const model = options?.model ?? 'openai/text-embedding-3-small';
         const start = Date.now();
@@ -351,7 +351,7 @@ export class OpenRouterProvider {
             return {
                 embedding: data.data[0].embedding,
                 model: data.model,
-                provider: 'openai',
+                provider: 'openrouter',
                 tokenCount: data.usage.total_tokens,
                 latencyMs,
                 cached: false,
@@ -361,7 +361,7 @@ export class OpenRouterProvider {
             if (error instanceof Error && 'code' in error) {
                 throw error;
             }
-            throw createLLMError(error instanceof Error ? error.message : 'Embedding request failed', 'NETWORK_ERROR', { provider: 'openai', model, retryable: true, cause: error });
+            throw createLLMError(error instanceof Error ? error.message : 'Embedding request failed', 'NETWORK_ERROR', { provider: 'openrouter', model, retryable: true, cause: error });
         }
     }
     /**
@@ -378,7 +378,7 @@ export class OpenRouterProvider {
         return {
             completion: response.content,
             model: response.model,
-            provider: 'openai',
+            provider: 'openrouter',
             usage: response.usage,
             latencyMs: response.latencyMs,
             cached: response.cached,
@@ -525,19 +525,19 @@ export class OpenRouterProvider {
         switch (status) {
             case 401:
                 throw createLLMError(message, 'API_KEY_INVALID', {
-                    provider: 'openai',
+                    provider: 'openrouter',
                     model,
                     retryable: false,
                 });
             case 402:
                 throw createLLMError(message, 'COST_LIMIT_EXCEEDED', {
-                    provider: 'openai',
+                    provider: 'openrouter',
                     model,
                     retryable: false,
                 });
             case 429:
                 throw createLLMError(message, 'RATE_LIMITED', {
-                    provider: 'openai',
+                    provider: 'openrouter',
                     model,
                     retryable: true,
                     retryAfterMs: 60000,
@@ -545,19 +545,19 @@ export class OpenRouterProvider {
             case 400:
                 if (errorCode === 'context_length_exceeded' || errorType === 'invalid_request_error') {
                     throw createLLMError(message, 'CONTEXT_LENGTH_EXCEEDED', {
-                        provider: 'openai',
+                        provider: 'openrouter',
                         model,
                         retryable: false,
                     });
                 }
                 throw createLLMError(message, 'UNKNOWN', {
-                    provider: 'openai',
+                    provider: 'openrouter',
                     model,
                     retryable: false,
                 });
             case 404:
                 throw createLLMError(message, 'MODEL_NOT_FOUND', {
-                    provider: 'openai',
+                    provider: 'openrouter',
                     model,
                     retryable: false,
                 });
@@ -565,14 +565,14 @@ export class OpenRouterProvider {
             case 502:
             case 503:
                 throw createLLMError(message, 'PROVIDER_UNAVAILABLE', {
-                    provider: 'openai',
+                    provider: 'openrouter',
                     model,
                     retryable: true,
                     retryAfterMs: 5000,
                 });
             default:
                 throw createLLMError(message, 'UNKNOWN', {
-                    provider: 'openai',
+                    provider: 'openrouter',
                     model,
                     retryable: false,
                 });
@@ -594,7 +594,7 @@ export class OpenRouterProvider {
         catch (error) {
             if (error instanceof Error && error.name === 'AbortError') {
                 throw createLLMError('Request timed out', 'TIMEOUT', {
-                    provider: 'openai',
+                    provider: 'openrouter',
                     retryable: true,
                 });
             }

package/dist/validation/conservation-guard.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Conservation Guard (Phoenix essay 14 "UI Is a Conservation Layer", ADR-114)
+ *
+ * AQE's human/agent-facing surfaces — CLI commands, output schemas, MCP tools,
+ * the dashboard — are its conservation layer: users and CI pipelines build muscle
+ * memory and scripts around them. Internals may regenerate freely; these surfaces
+ * must change slowly and ADDITIVELY. This module diffs a captured baseline against
+ * the current surface and flags breaking removals/renames that are not in the
+ * deprecation registry.
+ *
+ * Pure functions only — extraction + I/O live in scripts/conservation-guard.ts.
+ */
+export interface SurfaceDiff {
+    surface: string;
+    /** Entries present now but not in the baseline — additive, always allowed. */
+    added: string[];
+    /** Entries removed from the baseline and NOT in the deprecation registry — breaking. */
+    removedBreaking: string[];
+    /** Entries removed but listed as deprecated — an allowed, deliberate removal. */
+    removedDeprecated: string[];
+    /** True when there are no breaking removals. */
+    clean: boolean;
+}
+/**
+ * Diff one surface. Additive changes pass; a removal/rename is breaking unless the
+ * removed entry appears in `deprecated` (the deprecation window has been honored).
+ */
+export declare function diffSurface(surface: string, baseline: string[], current: string[], deprecated?: string[]): SurfaceDiff;
+export interface ConservationReport {
+    diffs: SurfaceDiff[];
+    clean: boolean;
+    /** Total breaking removals across all surfaces. */
+    breakingCount: number;
+}
+/** Aggregate per-surface diffs into an overall verdict. */
+export declare function aggregate(diffs: SurfaceDiff[]): ConservationReport;
+/** Human-readable report (used by the CLI guard and CI logs). */
+export declare function formatReport(report: ConservationReport): string;
+//# sourceMappingURL=conservation-guard.d.ts.map

package/dist/validation/conservation-guard.js

@@ -0,0 +1,54 @@
+/**
+ * Conservation Guard (Phoenix essay 14 "UI Is a Conservation Layer", ADR-114)
+ *
+ * AQE's human/agent-facing surfaces — CLI commands, output schemas, MCP tools,
+ * the dashboard — are its conservation layer: users and CI pipelines build muscle
+ * memory and scripts around them. Internals may regenerate freely; these surfaces
+ * must change slowly and ADDITIVELY. This module diffs a captured baseline against
+ * the current surface and flags breaking removals/renames that are not in the
+ * deprecation registry.
+ *
+ * Pure functions only — extraction + I/O live in scripts/conservation-guard.ts.
+ */
+/**
+ * Diff one surface. Additive changes pass; a removal/rename is breaking unless the
+ * removed entry appears in `deprecated` (the deprecation window has been honored).
+ */
+export function diffSurface(surface, baseline, current, deprecated = []) {
+    const cur = new Set(current);
+    const dep = new Set(deprecated);
+    const added = current.filter((e) => !baseline.includes(e)).sort();
+    const removed = baseline.filter((e) => !cur.has(e));
+    const removedBreaking = removed.filter((e) => !dep.has(e)).sort();
+    const removedDeprecated = removed.filter((e) => dep.has(e)).sort();
+    return {
+        surface,
+        added,
+        removedBreaking,
+        removedDeprecated,
+        clean: removedBreaking.length === 0,
+    };
+}
+/** Aggregate per-surface diffs into an overall verdict. */
+export function aggregate(diffs) {
+    const breakingCount = diffs.reduce((n, d) => n + d.removedBreaking.length, 0);
+    return { diffs, clean: breakingCount === 0, breakingCount };
+}
+/** Human-readable report (used by the CLI guard and CI logs). */
+export function formatReport(report) {
+    const lines = [];
+    for (const d of report.diffs) {
+        const status = d.clean ? '✓' : '✗ BREAKING';
+        lines.push(`${status} ${d.surface}: +${d.added.length} added, -${d.removedBreaking.length} breaking, -${d.removedDeprecated.length} deprecated`);
+        for (const r of d.removedBreaking)
+            lines.push(`    REMOVED (breaking): ${r}`);
+        for (const r of d.removedDeprecated)
+            lines.push(`    removed (deprecated, ok): ${r}`);
+    }
+    lines.push('');
+    lines.push(report.clean
+        ? '✓ conservation guard: no breaking surface changes'
+        : `✗ conservation guard: ${report.breakingCount} breaking surface change(s) — add to the deprecation registry (with a deprecation window) or restore them. To intentionally rebaseline: --update.`);
+    return lines.join('\n');
+}
+//# sourceMappingURL=conservation-guard.js.map

package/dist/validation/oracle-eval.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Agentic QE v3 - Oracle Evaluator for skill evals (Oracle-Evals plan, Phase 0/1)
+ *
+ * Turns a skill eval from a keyword grep into a real ORACLE: it RUNS a
+ * generated test against a reference implementation (must pass) and against
+ * first-order operator mutants of that implementation (each surviving mutant
+ * is a bug the test failed to catch). The mutation kill rate is the eval's
+ * pass signal — a test that asserts nothing scores 0 and fails.
+ *
+ * Reuses the proven qe-arena primitives (ADR-104): the deterministic operator
+ * mutator and the real `node --test` fixture runner. Nothing is simulated.
+ */
+export interface OracleSpec {
+    /** Base name (no extension) for the module under test, e.g. "inRange". */
+    moduleName: string;
+    /** ESM source of the correct implementation, e.g. `export function inRange(...) {...}`. */
+    referenceImpl: string;
+    /** Generated test source. Imports the impl as `../src/<moduleName>.mjs`. */
+    generatedTest: string;
+    /** Cap on mutants evaluated (deterministic prefix of the position-sorted list). */
+    maxMutants?: number;
+    /** Minimum mutation kill rate required to pass. Default 0.5. */
+    threshold?: number;
+    /** Per-`node --test` timeout in ms. Default 30s (evals run many subprocesses). */
+    timeoutMs?: number;
+}
+export interface OracleResult {
+    /** Did the generated test pass against the unmutated reference implementation? */
+    baselinePassed: boolean;
+    mutantsTotal: number;
+    mutantsKilled: number;
+    /** killed / total, rounded to 4dp (0 when there are no mutants). */
+    mutationScore: number;
+    /** Mutant ids the test failed to catch (bugs it would let through). */
+    survivedMutantIds: string[];
+    /** baselinePassed AND mutationScore >= threshold AND at least one mutant existed. */
+    passed: boolean;
+    /** Human-readable explanation of the verdict. */
+    reason: string;
+}
+/**
+ * Evaluate a generated test as an oracle against a reference implementation.
+ * Real `node --test` runs; deterministic mutant enumeration.
+ */
+export declare function evaluateOracle(spec: OracleSpec): OracleResult;
+//# sourceMappingURL=oracle-eval.d.ts.map

package/dist/validation/oracle-eval.js

@@ -0,0 +1,108 @@
+/**
+ * Agentic QE v3 - Oracle Evaluator for skill evals (Oracle-Evals plan, Phase 0/1)
+ *
+ * Turns a skill eval from a keyword grep into a real ORACLE: it RUNS a
+ * generated test against a reference implementation (must pass) and against
+ * first-order operator mutants of that implementation (each surviving mutant
+ * is a bug the test failed to catch). The mutation kill rate is the eval's
+ * pass signal — a test that asserts nothing scores 0 and fails.
+ *
+ * Reuses the proven qe-arena primitives (ADR-104): the deterministic operator
+ * mutator and the real `node --test` fixture runner. Nothing is simulated.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { enumerateMutants, applyMutant } from '../arena/mutator.js';
+import { runNodeTest, makeTmpRoot, cleanupTmpRoot } from '../arena/runner.js';
+/** Write a throwaway { src/<m>.mjs, tests/<m>.test.mjs } workspace and return its dir. */
+function materialize(tmpRoot, moduleName, impl, test) {
+    const dir = fs.mkdtempSync(path.join(tmpRoot, 'oracle-ws-'));
+    fs.mkdirSync(path.join(dir, 'src'), { recursive: true });
+    fs.mkdirSync(path.join(dir, 'tests'), { recursive: true });
+    fs.writeFileSync(path.join(dir, 'src', `${moduleName}.mjs`), impl);
+    fs.writeFileSync(path.join(dir, 'tests', `${moduleName}.test.mjs`), test);
+    return dir;
+}
+/**
+ * Evaluate a generated test as an oracle against a reference implementation.
+ * Real `node --test` runs; deterministic mutant enumeration.
+ */
+export function evaluateOracle(spec) {
+    const threshold = spec.threshold ?? 0.5;
+    const timeoutMs = spec.timeoutMs ?? 30_000;
+    const tmpRoot = makeTmpRoot();
+    try {
+        // 0. Sanity: reject output that is not a runnable, asserting test. An empty
+        // or assertion-less file passes `node --test` (exit 0) but proves nothing —
+        // catch it here so the verdict is honest rather than relying on a 0 kill rate.
+        if (!/assert\s*[.(]|expect\s*\(|\.(toBe|toEqual|toThrow|toMatch)\b/.test(spec.generatedTest)) {
+            return {
+                baselinePassed: false,
+                mutantsTotal: 0,
+                mutantsKilled: 0,
+                mutationScore: 0,
+                survivedMutantIds: [],
+                passed: false,
+                reason: 'generated output contains no assertions — not a runnable test',
+            };
+        }
+        // 1. Baseline: the test must pass against the correct implementation.
+        const baselineDir = materialize(tmpRoot, spec.moduleName, spec.referenceImpl, spec.generatedTest);
+        const baseline = runNodeTest(baselineDir, { timeoutMs });
+        if (!baseline.ok) {
+            return {
+                baselinePassed: false,
+                mutantsTotal: 0,
+                mutantsKilled: 0,
+                mutationScore: 0,
+                survivedMutantIds: [],
+                passed: false,
+                reason: 'generated test does not pass against the reference implementation',
+            };
+        }
+        // 2. Mutants: each one the test fails to fail-on is a missed bug.
+        let mutants = enumerateMutants(spec.referenceImpl, spec.moduleName);
+        if (spec.maxMutants !== undefined && mutants.length > spec.maxMutants) {
+            mutants = mutants.slice(0, spec.maxMutants);
+        }
+        if (mutants.length === 0) {
+            return {
+                baselinePassed: true,
+                mutantsTotal: 0,
+                mutantsKilled: 0,
+                mutationScore: 0,
+                survivedMutantIds: [],
+                passed: false,
+                reason: 'no operator mutants could be generated for the reference implementation (cannot prove the test catches anything)',
+            };
+        }
+        let killed = 0;
+        const survived = [];
+        for (const mutant of mutants) {
+            const dir = materialize(tmpRoot, spec.moduleName, applyMutant(spec.referenceImpl, mutant), spec.generatedTest);
+            const run = runNodeTest(dir, { timeoutMs });
+            if (!run.ok)
+                killed++;
+            else
+                survived.push(mutant.id);
+        }
+        const total = mutants.length;
+        const score = Math.round((killed / total) * 10000) / 10000;
+        const passed = score >= threshold;
+        return {
+            baselinePassed: true,
+            mutantsTotal: total,
+            mutantsKilled: killed,
+            mutationScore: score,
+            survivedMutantIds: survived,
+            passed,
+            reason: passed
+                ? `killed ${killed}/${total} mutants (score ${(score * 100).toFixed(0)}%)`
+                : `mutation score ${(score * 100).toFixed(0)}% < threshold ${(threshold * 100).toFixed(0)}% — ${survived.length} mutant(s) survived`,
+        };
+    }
+    finally {
+        cleanupTmpRoot(tmpRoot);
+    }
+}
+//# sourceMappingURL=oracle-eval.js.map

package/dist/validation/skill-parity.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Skill Tree Parity (ADR-113, P4)
+ *
+ * AQE skills are duplicated across trees (.claude/skills is canonical; assets/skills
+ * is the npm-distributed mirror; plugins/ and .kiro/ are independent distributions
+ * with their own frontmatter conventions). The mirror has silently drifted from
+ * canonical before — this module detects that drift so CI can fail loud.
+ *
+ * Comparison is frontmatter-AGNOSTIC: only the markdown body (after the YAML block)
+ * is compared, because legitimate per-tree frontmatter (allowed-tools, inclusion)
+ * differs by design. Pure functions — fs walking lives in scripts/check-skill-parity.ts.
+ */
+export type ParityStatus = 'match' | 'drift' | 'absent';
+export interface ParityEntry {
+    skill: string;
+    status: ParityStatus;
+}
+export interface ParityReport {
+    /** Mirror tree compared against canonical, e.g. "assets/skills". */
+    mirror: string;
+    total: number;
+    match: number;
+    drift: number;
+    absent: number;
+    entries: ParityEntry[];
+    /** True when no skill in the mirror has drifted (absent is allowed). */
+    clean: boolean;
+}
+/**
+ * Remove a leading YAML frontmatter block (between the first two `---` lines)
+ * and normalize trailing whitespace. Body-only so frontmatter may differ per tree.
+ */
+export declare function stripFrontmatter(markdown: string): string;
+/** True when two skill docs share the same body (ignoring frontmatter + edge whitespace). */
+export declare function bodiesMatch(canonical: string, copy: string): boolean;
+/**
+ * Split a skill doc into its leading YAML frontmatter block (including the `---`
+ * delimiters) and the markdown body. When there is no frontmatter, `frontmatter`
+ * is empty and `body` is the whole document.
+ */
+export declare function splitFrontmatter(markdown: string): {
+    frontmatter: string;
+    body: string;
+};
+/**
+ * Reconcile a mirror copy to canonical: keep the MIRROR's frontmatter (per-tree
+ * conventions like allowed-tools / inclusion) but replace its body with canonical's.
+ * This is how a faithful mirror is resynced without losing its frontmatter.
+ */
+export declare function reconcileBody(mirrorContent: string, canonicalContent: string): string;
+/**
+ * Build a parity report from already-read file contents.
+ * `canonical` maps skill name → SKILL.md content (the source of truth).
+ * `mirror` maps skill name → SKILL.md content (undefined when absent in the mirror).
+ * Only skills present in canonical are evaluated.
+ */
+export declare function buildParityReport(mirror: string, canonical: Record<string, string>, mirrorContents: Record<string, string | undefined>): ParityReport;
+//# sourceMappingURL=skill-parity.d.ts.map

package/dist/validation/skill-parity.js

@@ -0,0 +1,94 @@
+/**
+ * Skill Tree Parity (ADR-113, P4)
+ *
+ * AQE skills are duplicated across trees (.claude/skills is canonical; assets/skills
+ * is the npm-distributed mirror; plugins/ and .kiro/ are independent distributions
+ * with their own frontmatter conventions). The mirror has silently drifted from
+ * canonical before — this module detects that drift so CI can fail loud.
+ *
+ * Comparison is frontmatter-AGNOSTIC: only the markdown body (after the YAML block)
+ * is compared, because legitimate per-tree frontmatter (allowed-tools, inclusion)
+ * differs by design. Pure functions — fs walking lives in scripts/check-skill-parity.ts.
+ */
+/**
+ * Remove a leading YAML frontmatter block (between the first two `---` lines)
+ * and normalize trailing whitespace. Body-only so frontmatter may differ per tree.
+ */
+export function stripFrontmatter(markdown) {
+    const lines = markdown.split('\n');
+    if (lines[0]?.trim() === '---') {
+        for (let i = 1; i < lines.length; i++) {
+            if (lines[i].trim() === '---') {
+                return lines.slice(i + 1).join('\n').trim();
+            }
+        }
+    }
+    return markdown.trim();
+}
+/** True when two skill docs share the same body (ignoring frontmatter + edge whitespace). */
+export function bodiesMatch(canonical, copy) {
+    return stripFrontmatter(canonical) === stripFrontmatter(copy);
+}
+/**
+ * Split a skill doc into its leading YAML frontmatter block (including the `---`
+ * delimiters) and the markdown body. When there is no frontmatter, `frontmatter`
+ * is empty and `body` is the whole document.
+ */
+export function splitFrontmatter(markdown) {
+    const lines = markdown.split('\n');
+    if (lines[0]?.trim() === '---') {
+        for (let i = 1; i < lines.length; i++) {
+            if (lines[i].trim() === '---') {
+                return {
+                    frontmatter: lines.slice(0, i + 1).join('\n'),
+                    body: lines.slice(i + 1).join('\n'),
+                };
+            }
+        }
+    }
+    return { frontmatter: '', body: markdown };
+}
+/**
+ * Reconcile a mirror copy to canonical: keep the MIRROR's frontmatter (per-tree
+ * conventions like allowed-tools / inclusion) but replace its body with canonical's.
+ * This is how a faithful mirror is resynced without losing its frontmatter.
+ */
+export function reconcileBody(mirrorContent, canonicalContent) {
+    const mirror = splitFrontmatter(mirrorContent);
+    const canon = splitFrontmatter(canonicalContent);
+    if (!mirror.frontmatter)
+        return canonicalContent; // no frontmatter to preserve
+    return `${mirror.frontmatter}\n${canon.body.replace(/^\n+/, '')}`;
+}
+/**
+ * Build a parity report from already-read file contents.
+ * `canonical` maps skill name → SKILL.md content (the source of truth).
+ * `mirror` maps skill name → SKILL.md content (undefined when absent in the mirror).
+ * Only skills present in canonical are evaluated.
+ */
+export function buildParityReport(mirror, canonical, mirrorContents) {
+    const entries = [];
+    for (const skill of Object.keys(canonical).sort()) {
+        const copy = mirrorContents[skill];
+        if (copy === undefined) {
+            entries.push({ skill, status: 'absent' });
+        }
+        else if (bodiesMatch(canonical[skill], copy)) {
+            entries.push({ skill, status: 'match' });
+        }
+        else {
+            entries.push({ skill, status: 'drift' });
+        }
+    }
+    const drift = entries.filter((e) => e.status === 'drift').length;
+    return {
+        mirror,
+        total: entries.length,
+        match: entries.filter((e) => e.status === 'match').length,
+        drift,
+        absent: entries.filter((e) => e.status === 'absent').length,
+        entries,
+        clean: drift === 0,
+    };
+}
+//# sourceMappingURL=skill-parity.js.map

package/dist/validation/test-gen-prompt.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Durable-first test-generation prompt (ADR-113).
+ *
+ * Builds the instruction sent to a model when generating a test for oracle
+ * grading: the test must import the module under test from `../src/<name>.mjs`
+ * and assert boundaries/branches (durable), not a single happy path — so the
+ * mutation oracle can actually measure fault detection. Pure + testable.
+ */
+export declare function buildTestGenPrompt(codeUnderTest: string, moduleName: string): string;
+//# sourceMappingURL=test-gen-prompt.d.ts.map

package/dist/validation/test-gen-prompt.js

@@ -0,0 +1,26 @@
+/**
+ * Durable-first test-generation prompt (ADR-113).
+ *
+ * Builds the instruction sent to a model when generating a test for oracle
+ * grading: the test must import the module under test from `../src/<name>.mjs`
+ * and assert boundaries/branches (durable), not a single happy path — so the
+ * mutation oracle can actually measure fault detection. Pure + testable.
+ */
+export function buildTestGenPrompt(codeUnderTest, moduleName) {
+    return `You are AQE's test generator. Write JavaScript tests for the function below using Node's built-in test runner.
+
+Strict requirements:
+- Use: import test from 'node:test';
+- Use: import assert from 'node:assert/strict';
+- Import the function under test EXACTLY as: import { ${moduleName} } from '../src/${moduleName}.mjs';
+- Write DURABLE tests: assert boundary values and every branch/decision of the logic, not just one happy path. The tests should still pass if the function were reimplemented in another language.
+- Every test must contain at least one assert.* call.
+- Output ONLY the test code inside a single \`\`\`js code block. No prose, no explanation.
+
+Function under test:
+\`\`\`js
+${codeUnderTest}
+\`\`\`
+`;
+}
+//# sourceMappingURL=test-gen-prompt.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-qe",
-  "version": "3.11.2",
+  "version": "3.11.3",
   "description": "Agentic Quality Engineering V3 - Domain-Driven Design Architecture with 13 Bounded Contexts, O(log n) coverage analysis, ReasoningBank learning, 60 specialized QE agents, mathematical Coherence verification, deep Claude Flow integration",
   "type": "module",
   "main": "./dist/index.js",
@@ -85,6 +85,13 @@
     "mcp:report": "echo 'MCP Report: uses vitest for test reporting' && exit 0",
     "test:code-intelligence": "npm test -- --run tests/unit/domains/code-intelligence/ tests/unit/coordination/mincut/",
     "verify:invariants": "tsx scripts/verify-shipped-invariants.ts",
+    "verify:skill-parity": "tsx scripts/check-skill-parity.ts",
+    "eval:live:claude": "EVAL_PROVIDER=claude tsx scripts/validate-live-oracle.ts",
+    "eval:live:ollama": "EVAL_PROVIDER=ollama tsx scripts/validate-live-oracle.ts",
+    "eval:models": "tsx scripts/oracle-model-bench.ts",
+    "eval:models:list": "tsx scripts/openrouter-models.ts",
+    "providers:health": "tsx scripts/provider-health.ts",
+    "verify:conservation": "tsx scripts/conservation-guard.ts --ci",
     "verify:counts": "node -e \"const fs=require('fs'),g=require('glob'),p=require('path');const src=g.globSync('src/**/*.ts',{ignore:'src/**/*.test.ts'});const tests=g.globSync('tests/**/*.test.ts');const agents=g.globSync('.claude/agents/v3/qe-*.md');const skills=g.globSync('.claude/skills/**/*.md');const ok=src.length>500&&tests.length>300;const r={status:ok?'pass':'fail',srcFiles:src.length,testFiles:tests.length,agents:agents.length,skills:skills.length};fs.mkdirSync('reports',{recursive:true});fs.writeFileSync(p.join('reports','verification-counts.json'),JSON.stringify(r,null,2));console.log('Counts:',JSON.stringify(r));if(!ok)process.exit(1)\"",
     "verify:agent-skills": "node -e \"const fs=require('fs'),g=require('glob'),p=require('path');const agents=g.globSync('.claude/agents/v3/qe-*.md');const skills=g.globSync('.claude/skills/**/*.md');const missing=[];for(const a of agents){const name=p.basename(a,'.md');const hasSkill=skills.some(s=>s.includes(name.replace('qe-','')));if(!hasSkill)missing.push(name)}const ok=missing.length<agents.length/2;const r={status:ok?'pass':'fail',agents:agents.length,skills:skills.length,unmatchedAgents:missing.length,missing:missing.slice(0,10)};fs.mkdirSync('reports',{recursive:true});fs.writeFileSync(p.join('reports','verification-agent-skills.json'),JSON.stringify(r,null,2));console.log('Agent-Skills:',JSON.stringify(r));if(!ok)process.exit(1)\"",
     "verify:features": "node -e \"const fs=require('fs'),p=require('path');const pkg=JSON.parse(fs.readFileSync('package.json','utf8'));const hasBin=!!pkg.bin&&Object.keys(pkg.bin).length>=2;const hasExports=!!pkg.exports&&Object.keys(pkg.exports).length>=3;const cliBundleExists=fs.existsSync('dist/cli/bundle.js');const mcpBundleExists=fs.existsSync('dist/mcp/bundle.js');const ok=hasBin&&hasExports&&cliBundleExists&&mcpBundleExists;const r={status:ok?'pass':'fail',binCount:Object.keys(pkg.bin||{}).length,exportsCount:Object.keys(pkg.exports||{}).length,cliBundleExists,mcpBundleExists};fs.mkdirSync('reports',{recursive:true});fs.writeFileSync(p.join('reports','verification-features.json'),JSON.stringify(r,null,2));console.log('Features:',JSON.stringify(r));if(!ok)process.exit(1)\"",

package/dist/cli/chunks/adapter-LDNYC4GH.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.11.2");process.exit(0)}
-import{a,b,c}from"./chunk-EIWZDVMT.js";import"./chunk-OC2W7KIW.js";import"./chunk-X36TZXDK.js";import"./chunk-LY6PTRVL.js";import"./chunk-FYY7OJ6Y.js";import"./chunk-LIEA5EON.js";export{a as AgentBoosterAdapter,b as createAgentBoosterAdapter,c as createAgentBoosterAdapterSync};

package/dist/cli/chunks/aqe-learning-engine-CA4CT5Q7.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.11.2");process.exit(0)}
-import{a,b,c,d,e,f}from"./chunk-LAY35POY.js";import"./chunk-2Q65LTJN.js";import"./chunk-IO7ZUP2G.js";import"./chunk-H3LGBH4Y.js";import"./chunk-7KHZZVF2.js";import"./chunk-K6IQBVD7.js";import"./chunk-I7UWFV6N.js";import"./chunk-P7MIOTVP.js";import"./chunk-VNFL2TPU.js";import"./chunk-AK5Q2WCJ.js";import"./chunk-H5TM4KIB.js";import"./chunk-IMPSB5WW.js";import"./chunk-ZWMXF6AX.js";import"./chunk-P3VRXQ3H.js";import"./chunk-4PYJCIRO.js";import"./chunk-Y4M2HMPR.js";import"./chunk-72VVTMEL.js";import"./chunk-5BDVFFYF.js";import"./chunk-JCH2FHJ7.js";import"./chunk-LY6PTRVL.js";import"./chunk-AKZK46TQ.js";import"./chunk-CUDGKSFX.js";import"./chunk-IXYF5BZY.js";import"./chunk-QZLTIGLB.js";import"./chunk-FYY7OJ6Y.js";import"./chunk-76RO2RHG.js";import"./chunk-AZQ6HDPM.js";import"./chunk-Z2QNTRUX.js";import"./chunk-6SOGYNJG.js";import"./chunk-7MKF52GT.js";import"./chunk-XY2B2BEJ.js";import"./chunk-AINAWVGD.js";import"./chunk-NIW4CLN2.js";import"./chunk-UCXW24HY.js";import"./chunk-WKIYYF3G.js";import"./chunk-LIEA5EON.js";export{b as AQELearningEngine,a as DEFAULT_ENGINE_CONFIG,c as DEFAULT_META_LEARNING_CONFIG,d as MetaLearningEngine,e as createAQELearningEngine,f as createDefaultLearningEngine};

package/dist/cli/chunks/base-TSDAEMT4.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.11.2");process.exit(0)}
-import{a,b,c,d,e,f,g,h,i,j,k}from"./chunk-CZYSCUJ4.js";import"./chunk-DU4GQKTH.js";import"./chunk-4PYJCIRO.js";import"./chunk-Y4M2HMPR.js";import"./chunk-72VVTMEL.js";import"./chunk-5BDVFFYF.js";import"./chunk-JCH2FHJ7.js";import"./chunk-LY6PTRVL.js";import"./chunk-IXYF5BZY.js";import"./chunk-FYY7OJ6Y.js";import"./chunk-76RO2RHG.js";import"./chunk-EDH4H55B.js";import"./chunk-AZQ6HDPM.js";import"./chunk-Z2QNTRUX.js";import"./chunk-6SOGYNJG.js";import"./chunk-7MKF52GT.js";import"./chunk-XY2B2BEJ.js";import"./chunk-AINAWVGD.js";import"./chunk-NIW4CLN2.js";import"./chunk-UCXW24HY.js";import"./chunk-WKIYYF3G.js";import"./chunk-LIEA5EON.js";export{k as MCPToolBase,j as defaultToolLogger,i as getLLMRouter,e as getMemoryBackend,g as getSharedLLMRouter,c as getSharedMemoryBackend,a as isMemoryOnlyMode,b as registerRvfResetFn,h as resetSharedLLMRouter,d as resetSharedMemoryBackend,f as setSharedLLMRouter};