agentic-qe 3.13.11 → 3.14.0

package/dist/shared/llm/router/external-provider-config.js

@@ -0,0 +1,105 @@
+/**
+ * Agentic QE v3 — Config-driven external provider registration
+ * ADR-127 (issue #628)
+ *
+ * Turns the `externalProviders` block of `.agentic-qe/llm-config.json` into
+ * live entries in the provider registry.
+ *
+ * This is the half of ADR-127 that actually unblocks the requester. An
+ * in-process `registerProvider()` call cannot reach the `aqe` CLI bundle or the
+ * MCP server bundle — they are separate esbuild artifacts spawned as
+ * subprocesses — but both call `loadRouterConfig()`, so a declaration on disk
+ * reaches both. No third-party code is imported: a declaration is data, and the
+ * provider it produces is AQE's own `ExternalCliProvider`.
+ *
+ * Untrusted-input discipline (inherited from ADR-125's `sanitizeAgentOverrides`):
+ * entries are validated and dropped **individually** with a warning. One
+ * malformed declaration must never fail router construction for the project.
+ */
+import { ExternalCliProvider, validateExternalCliConfig, } from '../providers/external-cli.js';
+import { tryRegisterProvider, unregisterProvider, validateProviderType, } from '../provider-registry.js';
+/**
+ * Types THIS module registered on the last load. Reaping is keyed off actual
+ * ownership rather than off the `source` metadata field, because that field is
+ * caller-supplied: an in-process embedder that passes `source: 'config'` must
+ * not have its registration silently reaped by an unrelated config reload.
+ */
+const configOwnedTypes = new Set();
+/**
+ * Register every valid declaration in an `externalProviders` block.
+ *
+ * Idempotent: re-registering the same type replaces the previous entry, and
+ * config-sourced registrations that are no longer declared are removed. API
+ * registrations (`registerProvider()`) are never touched — a config reload must
+ * not silently unregister a provider an embedder installed in-process.
+ */
+export function registerExternalProviders(declarations, options = {}) {
+    const registered = [];
+    const warnings = [];
+    const sourceDetail = options.sourceDetail ?? '.agentic-qe/llm-config.json';
+    const declared = new Set(Object.keys(declarations ?? {}));
+    // Drop declarations this module previously registered that are no longer in
+    // the file, so removing an entry actually removes the provider. Types we do
+    // not own are left alone. If the registry was reset out from under us,
+    // `unregisterProvider` simply no-ops and the set is rebuilt below.
+    for (const owned of configOwnedTypes) {
+        if (!declared.has(owned)) {
+            unregisterProvider(owned);
+        }
+    }
+    configOwnedTypes.clear();
+    for (const [type, declaration] of Object.entries(declarations ?? {})) {
+        const typeProblem = validateProviderType(type);
+        if (typeProblem) {
+            warnings.push(`externalProviders["${type}"] ignored: ${typeProblem}`);
+            continue;
+        }
+        const configProblem = validateExternalCliConfig(type, declaration);
+        if (configProblem) {
+            warnings.push(`${configProblem} — ignoring this entry.`);
+            continue;
+        }
+        const registrationProblem = tryRegisterProvider(type, 
+        // The declaration is captured here, so each construction gets a fresh
+        // provider built from the same validated data.
+        () => new ExternalCliProvider(type, declaration), {
+            billingMode: declaration.billingMode,
+            displayName: declaration.displayName,
+            models: declaration.models,
+            config: declaration,
+            source: 'config',
+            sourceDetail,
+        });
+        if (registrationProblem) {
+            warnings.push(`externalProviders["${type}"] ignored: ${registrationProblem}`);
+            continue;
+        }
+        configOwnedTypes.add(type);
+        registered.push(type);
+    }
+    return { registered, warnings };
+}
+/**
+ * Extract and shallow-validate an `externalProviders` block read off disk.
+ * Returns only entries that are objects; deeper validation happens at
+ * registration so every rejection is reported through one path.
+ */
+export function sanitizeExternalProviders(raw) {
+    const declarations = {};
+    const warnings = [];
+    if (raw === undefined)
+        return { declarations, warnings };
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        warnings.push('externalProviders must be an object keyed by provider type; ignoring it.');
+        return { declarations, warnings };
+    }
+    for (const [type, value] of Object.entries(raw)) {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            warnings.push(`externalProviders["${type}"] must be an object; ignoring this entry.`);
+            continue;
+        }
+        declarations[type] = value;
+    }
+    return { declarations, warnings };
+}
+//# sourceMappingURL=external-provider-config.js.map

package/dist/shared/llm/router/types.d.ts

@@ -18,12 +18,33 @@
  * @see ADR-011 - LLM Provider System for QE (foundation)
  * @see ADR-043 - Vendor-Independent LLM Support (this extension)
  */
-import { LLMProviderType, LLMProvider, Message, GenerateOptions, TokenUsage, CostInfo, HealthCheckResult } from '../interfaces';
+import type { ExternalCliProviderConfig } from '../providers/external-cli';
+import { BuiltinProviderType, LLMProviderType, LLMProvider, Message, GenerateOptions, TokenUsage, CostInfo, HealthCheckResult } from '../interfaces';
 /**
- * Extended provider types including new ADR-043 providers
- * Extends LLMProviderType from ADR-011: 'claude' | 'openai' | 'ollama'
+ * The closed set of extended provider types AQE ships. Exhaustive — this is
+ * what a `Record` of per-provider constants must be keyed on, so that adding a
+ * built-in provider still fails the build until every map is updated.
+ *
+ * ADR-127: `BuiltinProviderType` covers the ten runtime-constructible
+ * providers; `onnx` exists in the type system (routing/translation know about
+ * it) but `ProviderManager` has no case for it yet.
+ */
+export type BuiltinExtendedProviderType = BuiltinProviderType | 'onnx';
+/**
+ * Extended provider types including new ADR-043 providers.
+ *
+ * ADR-127: open, because `LLMProviderType` is open — a registered external
+ * provider is a valid routing target everywhere an extended type is accepted.
+ * Use `BuiltinExtendedProviderType` when you need exhaustiveness.
  */
-export type ExtendedProviderType = LLMProviderType | 'openrouter' | 'gemini' | 'azure-openai' | 'bedrock' | 'onnx';
+export type ExtendedProviderType = LLMProviderType | 'onnx';
+/**
+ * Type guard for the closed extended set. Use before indexing any
+ * `Record<BuiltinExtendedProviderType, _>` with an open provider type, so the
+ * external-provider case is handled explicitly rather than yielding
+ * `undefined` at a site the compiler believed was total (ADR-127).
+ */
+export declare function isBuiltinExtendedProviderType(type: string): type is BuiltinExtendedProviderType;
 /**
  * All supported provider types as a const array for iteration
  */
@@ -585,6 +606,31 @@ export interface RouterConfig {
      * Unset fields keep their category default. Never put API keys here.
      */
     agentOverrides?: Record<string, AgentProviderOverride>;
+    /**
+     * ADR-127 (issue #628): external provider declarations. Each key becomes a
+     * selectable provider identity — `AQE_LLM_PROVIDER=<key>`,
+     * `defaultProvider`, `fallbackChain`, and `agentOverrides` all accept it —
+     * backed by a generic subprocess provider built from the declaration.
+     *
+     * Declared by data, never by a module path: AQE does not import third-party
+     * code on the strength of a config file. See ADR-127 for why.
+     *
+     * @example
+     * ```jsonc
+     * {
+     *   "externalProviders": {
+     *     "my-host": {
+     *       "kind": "cli",
+     *       "command": ["my-host", "exec"],
+     *       "billingMode": "subscription",
+     *       "models": ["default"]
+     *     }
+     *   }
+     * }
+     * ```
+     * Declaring a host also enables it. Never put API keys here.
+     */
+    externalProviders?: Record<string, ExternalCliProviderConfig>;
 }
 /**
  * On-disk, per-agent-type routing override (issue #568).

package/dist/shared/llm/router/types.js

@@ -18,6 +18,16 @@
  * @see ADR-011 - LLM Provider System for QE (foundation)
  * @see ADR-043 - Vendor-Independent LLM Support (this extension)
  */
+import { isBuiltinProviderType, } from '../interfaces.js';
+/**
+ * Type guard for the closed extended set. Use before indexing any
+ * `Record<BuiltinExtendedProviderType, _>` with an open provider type, so the
+ * external-provider case is handled explicitly rather than yielding
+ * `undefined` at a site the compiler believed was total (ADR-127).
+ */
+export function isBuiltinExtendedProviderType(type) {
+    return type === 'onnx' || isBuiltinProviderType(type);
+}
 /**
  * All supported provider types as a const array for iteration
  */

package/dist/shared/llm/translation/message-formatter.js

@@ -7,6 +7,7 @@
  * - Response normalization across formats
  * - Message role mapping
  */
+import { isBuiltinExtendedProviderType } from '../router/types.js';
 // ============================================================================
 // System Prompt Handling
 // ============================================================================
@@ -36,7 +37,12 @@ const SYSTEM_PROMPT_STRATEGIES = {
  * - Others: May need to prepend to first user message
  */
 export function handleSystemPrompt(systemPrompt, targetProvider) {
-    const strategy = SYSTEM_PROMPT_STRATEGIES[targetProvider] || 'first-message';
+    // ADR-127: an externally registered provider has no entry here. Falling back
+    // to 'first-message' is the safe default — it inlines the system prompt into
+    // the conversation, which every chat-shaped provider understands.
+    const strategy = isBuiltinExtendedProviderType(targetProvider)
+        ? SYSTEM_PROMPT_STRATEGIES[targetProvider]
+        : 'first-message';
     // Clean up the system prompt
     const cleanedPrompt = systemPrompt.trim();
     // For providers that don't support system prompts natively,

package/dist/shared/sql-safety.js

@@ -45,6 +45,10 @@ export const ALLOWED_TABLE_NAMES = new Set([
     // Learning/metrics tables
     'learning_daily_snapshots', 'metrics_outcomes',
     'experience_consolidation_log', 'qe_pattern_reuse',
+    // Qualified learning-evidence and lineage tables
+    'learning_evidence_manifests', 'learning_evidence_segments',
+    'learning_segment_edges', 'learning_evidence_admissions',
+    'pattern_manifest_lineage', 'pattern_segment_lineage',
     // Co-execution tables
     'qe_agent_co_execution',
 ]);

package/dist/skills/qe-court/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export declare function runRefereeCli(argv: string[]): number;
+//# sourceMappingURL=cli.d.ts.map

package/dist/skills/qe-court/cli.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+import { readFileSync, realpathSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { resolveVerdict, shouldEmitScore, validateCourtConfig, validatePanel, } from './referee.js';
+const MUTANT = {
+    id: 'boundary-off-by-one', fatal: true, reproduced: true, depthFound: 1,
+};
+export function runRefereeCli(argv) {
+    const [command, value] = argv;
+    if (command === 'validate-config' && value) {
+        const config = JSON.parse(readFileSync(value, 'utf8'));
+        const violations = validateCourtConfig(config);
+        process.stdout.write(JSON.stringify({ valid: violations.length === 0, violations }) + '\n');
+        return violations.length === 0 ? 0 : 2;
+    }
+    if (command === 'self-test' && value) {
+        const passed = runOracle(value);
+        process.stdout.write(JSON.stringify({ oracle: value, passed }) + '\n');
+        return passed ? 0 : 3;
+    }
+    process.stderr.write('Usage: aqe-court-referee validate-config <config.json> | self-test <oracle>\n');
+    return 64;
+}
+function runOracle(name) {
+    switch (name) {
+        case 'overturn-catches-mutant':
+            return resolveVerdict([MUTANT], 2) === 'BLOCK';
+        case 'overturn-disabled':
+            return resolveVerdict([MUTANT], 0) === 'SHIP';
+        case 'writer-not-juror':
+            return validatePanel([
+                { role: 'writer', provider: 'codex' },
+                { role: 'jury', provider: 'codex' },
+                { role: 'prosecutor', provider: 'claude-code' },
+            ]).includes('writerIsNeverJuror');
+        case 'vendor-diversity':
+            return validatePanel([
+                { role: 'writer', provider: 'cognitum-low' },
+                { role: 'jury', provider: 'cognitum-high' },
+            ]).includes('vendor-diversity');
+        case 'doe-score-gate':
+            return !shouldEmitScore(false, true) && shouldEmitScore(true, true);
+        case 'verdict-classes':
+            return resolveVerdict([{ ...MUTANT, depthFound: 0 }], 2) === 'BLOCK'
+                && resolveVerdict([{ ...MUTANT, fatal: false, depthFound: 0 }], 2) === 'REMAND'
+                && resolveVerdict([], 2) === 'SHIP';
+        default:
+            return false;
+    }
+}
+if (process.argv[1] && realpathSync(process.argv[1]) === fileURLToPath(import.meta.url)) {
+    process.exitCode = runRefereeCli(process.argv.slice(2));
+}
+//# sourceMappingURL=cli.js.map

package/dist/verification/adversarial-verify/calibrate.d.ts

@@ -7,11 +7,52 @@
  * — a deterministic stub (characterize the k-of-n aggregation) or a real LLM
  * (empirical false-kill on a labeled corpus).
  */
-import type { AdversarialVerifyOptions, Finding } from './types.js';
+import type { AdversarialVerifyOptions, Finding, FindingSeverity } from './types.js';
 export interface LabeledFinding {
     finding: Finding;
     /** Ground truth: is this a genuine, actionable problem? */
     isReal: boolean;
+    failureType?: string;
+    domain?: string;
+    expectedSeverity?: FindingSeverity;
+    source?: 'human' | 'oracle' | 'controlled-intervention';
+}
+export interface ConfidenceInterval {
+    low: number;
+    high: number;
+    level: 0.95;
+}
+export type QualificationDisposition = 'automate' | 'human-review' | 'abstain';
+export interface QualificationSlice {
+    key: string;
+    support: number;
+    precision: number;
+    recall: number;
+    falseKillRate: number;
+    falseKeepRate: number;
+    uncertainRate: number;
+    intervals: {
+        precision: ConfidenceInterval;
+        recall: ConfidenceInterval;
+        falseKillRate: ConfidenceInterval;
+        falseKeepRate: ConfidenceInterval;
+    };
+    disposition: QualificationDisposition;
+}
+export interface QualificationOptions {
+    minSupport?: number;
+    minRecall?: number;
+    minPrecision?: number;
+    maxFalseKillRate?: number;
+    maxFalseKeepRate?: number;
+    criticalSeverities?: FindingSeverity[];
+}
+export interface JudgeQualification {
+    status: 'qualified' | 'restricted' | 'unqualified';
+    automatedSlices: string[];
+    humanReviewSlices: string[];
+    abstainSlices: string[];
+    reasons: string[];
 }
 export interface CalibrationReport {
     total: number;
@@ -26,7 +67,10 @@ export interface CalibrationReport {
     correctConfirm: number;
     correctKill: number;
     uncertain: number;
+    slices: QualificationSlice[];
+    qualification: JudgeQualification;
 }
+export declare function qualifyJudge(slices: QualificationSlice[], criticalSliceKeys?: string[]): JudgeQualification;
 /** Run the verifier over a labeled set and report the confusion vs ground truth. */
-export declare function calibrate(labeled: LabeledFinding[], opts: AdversarialVerifyOptions): Promise<CalibrationReport>;
+export declare function calibrate(labeled: LabeledFinding[], opts: AdversarialVerifyOptions, qualificationOptions?: QualificationOptions): Promise<CalibrationReport>;
 //# sourceMappingURL=calibrate.d.ts.map

package/dist/verification/adversarial-verify/calibrate.js

@@ -1,11 +1,90 @@
 import { adversarialVerify } from './verify.js';
+const DEFAULT_QUALIFICATION = {
+    minSupport: 10,
+    minRecall: 0.8,
+    minPrecision: 0.8,
+    maxFalseKillRate: 0.1,
+    maxFalseKeepRate: 0.1,
+    criticalSeverities: ['critical', 'high'],
+};
+function wilson(successes, total) {
+    if (total === 0)
+        return { low: 0, high: 1, level: 0.95 };
+    const z = 1.959963984540054;
+    const p = successes / total;
+    const z2 = z * z;
+    const denominator = 1 + z2 / total;
+    const centre = (p + z2 / (2 * total)) / denominator;
+    const margin = z * Math.sqrt((p * (1 - p) + z2 / (4 * total)) / total) / denominator;
+    return { low: Math.max(0, centre - margin), high: Math.min(1, centre + margin), level: 0.95 };
+}
+function buildSlice(key, entries, policy) {
+    const real = entries.filter(entry => entry.label.isReal);
+    const falseEntries = entries.filter(entry => !entry.label.isReal);
+    const upheldReal = real.filter(entry => entry.verdict === 'upheld').length;
+    const upheldFalse = falseEntries.filter(entry => entry.verdict === 'upheld').length;
+    const falseKill = real.filter(entry => entry.verdict === 'refuted').length;
+    const falseKeep = upheldFalse;
+    const uncertain = entries.filter(entry => entry.verdict === 'uncertain').length;
+    const upheld = upheldReal + upheldFalse;
+    const precision = upheld ? upheldReal / upheld : 0;
+    const recall = real.length ? upheldReal / real.length : 0;
+    const falseKillRate = real.length ? falseKill / real.length : 0;
+    const falseKeepRate = falseEntries.length ? falseKeep / falseEntries.length : 0;
+    const intervals = {
+        precision: wilson(upheldReal, upheld),
+        recall: wilson(upheldReal, real.length),
+        falseKillRate: wilson(falseKill, real.length),
+        falseKeepRate: wilson(falseKeep, falseEntries.length),
+    };
+    let disposition = 'automate';
+    if (entries.length < policy.minSupport || real.length === 0)
+        disposition = 'abstain';
+    else if (intervals.recall.low < policy.minRecall
+        || intervals.precision.low < policy.minPrecision
+        || intervals.falseKillRate.high > policy.maxFalseKillRate
+        || intervals.falseKeepRate.high > policy.maxFalseKeepRate) {
+        disposition = 'human-review';
+    }
+    return {
+        key, support: entries.length, precision, recall, falseKillRate, falseKeepRate,
+        uncertainRate: entries.length ? uncertain / entries.length : 0,
+        intervals,
+        disposition,
+    };
+}
+export function qualifyJudge(slices, criticalSliceKeys = []) {
+    const automatedSlices = slices.filter(s => s.disposition === 'automate').map(s => s.key);
+    const humanReviewSlices = slices.filter(s => s.disposition === 'human-review').map(s => s.key);
+    const abstainSlices = slices.filter(s => s.disposition === 'abstain').map(s => s.key);
+    const presentKeys = new Set(slices.map(s => s.key));
+    const missingCriticalKeys = criticalSliceKeys.filter(key => !presentKeys.has(key));
+    const criticalFailures = slices.filter(s => criticalSliceKeys.includes(s.key) && s.disposition !== 'automate');
+    const status = criticalFailures.length > 0 || missingCriticalKeys.length > 0
+        ? 'unqualified'
+        : humanReviewSlices.length > 0 || abstainSlices.length > 0
+            ? 'restricted'
+            : 'qualified';
+    return {
+        status, automatedSlices, humanReviewSlices, abstainSlices,
+        reasons: [
+            ...criticalFailures.map(s => `Critical slice ${s.key} is ${s.disposition}`),
+            ...missingCriticalKeys.map(key => `Critical slice ${key} is missing`),
+        ],
+    };
+}
 /** Run the verifier over a labeled set and report the confusion vs ground truth. */
-export async function calibrate(labeled, opts) {
+export async function calibrate(labeled, opts, qualificationOptions = {}) {
     const verdicts = await adversarialVerify(labeled.map((l) => l.finding), opts);
+    const policy = { ...DEFAULT_QUALIFICATION, ...qualificationOptions };
     const r = {
         total: labeled.length, realCount: 0, falseCount: 0,
         falseKill: 0, falseKillRate: 0, falseKeep: 0, falseKeepRate: 0,
-        correctConfirm: 0, correctKill: 0, uncertain: 0,
+        correctConfirm: 0, correctKill: 0, uncertain: 0, slices: [],
+        qualification: {
+            status: 'restricted', automatedSlices: [], humanReviewSlices: [],
+            abstainSlices: [], reasons: [],
+        },
     };
     labeled.forEach((l, i) => {
         const v = verdicts[i].verdict;
@@ -28,6 +107,29 @@ export async function calibrate(labeled, opts) {
     });
     r.falseKillRate = r.realCount ? r.falseKill / r.realCount : 0;
     r.falseKeepRate = r.falseCount ? r.falseKeep / r.falseCount : 0;
+    const entries = labeled.map((label, index) => ({ label, verdict: verdicts[index].verdict }));
+    const groups = new Map();
+    const add = (key, entry) => {
+        const group = groups.get(key) ?? [];
+        group.push(entry);
+        groups.set(key, group);
+    };
+    entries.forEach(entry => {
+        add('overall', entry);
+        if (entry.label.failureType)
+            add(`failureType:${entry.label.failureType}`, entry);
+        if (entry.label.domain)
+            add(`domain:${entry.label.domain}`, entry);
+        const severity = entry.label.expectedSeverity ?? entry.label.finding.severity;
+        add(`severity:${severity}`, entry);
+    });
+    const criticalKeys = policy.criticalSeverities.map(severity => `severity:${severity}`);
+    for (const key of criticalKeys) {
+        if (!groups.has(key))
+            groups.set(key, []);
+    }
+    r.slices = [...groups.entries()].map(([key, group]) => buildSlice(key, group, policy));
+    r.qualification = qualifyJudge(r.slices, criticalKeys);
     return r;
 }
 //# sourceMappingURL=calibrate.js.map

package/dist/verification/adversarial-verify/index.d.ts

@@ -15,6 +15,6 @@ export type { Finding, FindingVerdict, FindingSeverity, FindingOutcome, RefuterV
 export { adversarialVerify, partitionVerdicts } from './verify.js';
 export { synthesizeVerdict, majorityKill, isFindingVerdict } from './synthesize.js';
 export { refuterPrompt, DEFAULT_LENSES } from './prompts.js';
-export { calibrate, type LabeledFinding, type CalibrationReport } from './calibrate.js';
+export { calibrate, qualifyJudge, type CalibrationReport, type ConfidenceInterval, type JudgeQualification, type LabeledFinding, type QualificationDisposition, type QualificationOptions, type QualificationSlice, } from './calibrate.js';
 export { verifyGate, type VerifyGateOptions, type VerifyGateResult } from './gate.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/verification/adversarial-verify/index.js

@@ -1,6 +1,6 @@
 export { adversarialVerify, partitionVerdicts } from './verify.js';
 export { synthesizeVerdict, majorityKill, isFindingVerdict } from './synthesize.js';
 export { refuterPrompt, DEFAULT_LENSES } from './prompts.js';
-export { calibrate } from './calibrate.js';
+export { calibrate, qualifyJudge, } from './calibrate.js';
 export { verifyGate } from './gate.js';
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-qe",
-  "version": "3.13.11",
+  "version": "3.14.0",
   "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",
@@ -22,6 +22,10 @@
       "import": "./dist/shared/index.js",
       "types": "./dist/shared/index.d.ts"
     },
+    "./shared/llm": {
+      "import": "./dist/shared/llm/index.js",
+      "types": "./dist/shared/llm/index.d.ts"
+    },
     "./cli": {
       "import": "./dist/cli/index.js"
     },
@@ -48,13 +52,18 @@
     "./verification/adversarial-verify": {
       "import": "./dist/verification/adversarial-verify/index.js",
       "types": "./dist/verification/adversarial-verify/index.d.ts"
+    },
+    "./skills/qe-court/referee": {
+      "import": "./dist/skills/qe-court/referee.js",
+      "types": "./dist/skills/qe-court/referee.d.ts"
     }
   },
   "bin": {
     "agentic-qe": "./dist/cli/bundle.js",
     "aqe": "./dist/cli/bundle.js",
     "aqe-v3": "./dist/cli/bundle.js",
-    "aqe-mcp": "./dist/mcp/bundle.js"
+    "aqe-mcp": "./dist/mcp/bundle.js",
+    "aqe-court-referee": "./dist/skills/qe-court/cli.js"
   },
   "scripts": {
     "preinstall": "node scripts/preinstall.cjs || true",
@@ -69,7 +78,7 @@
     "mcp": "tsx src/mcp/entry.ts",
     "test": "NODE_OPTIONS='--max-old-space-size=1024 --expose-gc' vitest run",
     "test:unit": "npm run test:unit:fast && npm run test:unit:heavy && npm run test:unit:mcp",
-    "test:unit:fast": "vitest run --exclude='**/qe-reasoning-bank.test.ts' --exclude='**/qe-reasoning-bank-feedback-loop.test.ts' --exclude='**/aqe-learning-engine.test.ts' --exclude='**/aqe-learning-engine-patterns.test.ts' tests/unit/adapters tests/unit/shared tests/unit/cli tests/unit/learning tests/unit/kernel tests/unit/workers tests/unit/routing tests/unit/strange-loop tests/unit/sync tests/unit/feedback tests/unit/error-paths tests/unit/early-exit tests/unit/causal-discovery tests/unit/neural-optimizer tests/unit/test-scheduling tests/unit/logging tests/unit/validation tests/unit/memory tests/unit/performance tests/unit/scripts tests/unit/planning",
+    "test:unit:fast": "vitest run --exclude='**/qe-reasoning-bank.test.ts' --exclude='**/qe-reasoning-bank-feedback-loop.test.ts' --exclude='**/aqe-learning-engine.test.ts' --exclude='**/aqe-learning-engine-patterns.test.ts' tests/unit/adapters tests/unit/shared tests/unit/cli tests/unit/learning tests/unit/kernel tests/unit/workers tests/unit/routing tests/unit/strange-loop tests/unit/sync tests/unit/feedback tests/unit/error-paths tests/unit/early-exit tests/unit/causal-discovery tests/unit/neural-optimizer tests/unit/test-scheduling tests/unit/logging tests/unit/validation tests/unit/memory tests/unit/performance tests/unit/scripts tests/unit/planning tests/context",
     "test:unit:heavy": "vitest run tests/unit/coordination tests/unit/domains tests/unit/integrations tests/unit/optimization tests/unit/init --exclude='**/browser/**' --exclude='**/*.e2e.test.ts' --exclude='**/vibium/**' --exclude='**/browser-swarm-coordinator.test.ts'",
     "test:unit:mcp": "vitest run tests/unit/mcp --exclude='**/mcp/handlers/domain-handlers.test.ts' --fileParallelism=false",
     "test:ci": "vitest run --exclude='**/browser/**' --exclude='**/*.e2e.test.ts' --exclude='**/vibium/**' --exclude='**/integration/browser/**' --exclude='**/browser-swarm-coordinator.test.ts' --exclude='**/mcp/handlers/domain-handlers.test.ts' --exclude='**/fixtures/init-corpus/**'",

package/dist/cli/chunks/adapter-YBSKQFQ4.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.13.11");process.exit(0)}
-import{a,b,c}from"./chunk-2BDTZYQN.js";import"./chunk-76NSSNB3.js";import"./chunk-UX5SM2PW.js";import"./chunk-TZA45FI7.js";import"./chunk-TCVEXQLL.js";import"./chunk-LUAXQB57.js";export{a as AgentBoosterAdapter,b as createAgentBoosterAdapter,c as createAgentBoosterAdapterSync};

package/dist/cli/chunks/aqe-learning-engine-3H7DRDD4.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.13.11");process.exit(0)}
-import{a,b,c,d,e,f}from"./chunk-2E2QCIGR.js";import"./chunk-GPJDZFFV.js";import"./chunk-JTQSXU6V.js";import"./chunk-GJTGHVAX.js";import"./chunk-TMY2Y7SC.js";import"./chunk-5364DBZG.js";import"./chunk-P736OKQN.js";import"./chunk-36ONUM43.js";import"./chunk-AFXMTSO3.js";import"./chunk-MWTFFGU3.js";import"./chunk-YEPJS4AM.js";import"./chunk-JWT675RM.js";import"./chunk-E54QUKAD.js";import"./chunk-UGFHEVG4.js";import"./chunk-TU4BYSXR.js";import"./chunk-T5M4TZRB.js";import"./chunk-2Y3PW5EJ.js";import"./chunk-SJJFU7KK.js";import"./chunk-WYQM7GXW.js";import"./chunk-CYQRZ645.js";import"./chunk-QYHRDBKI.js";import"./chunk-LREIHR2A.js";import"./chunk-TZA45FI7.js";import"./chunk-UPMQHCC2.js";import"./chunk-2D7SBOZ4.js";import"./chunk-FXKOHZBN.js";import"./chunk-XDK2TPI5.js";import"./chunk-TCVEXQLL.js";import"./chunk-PJNIDDER.js";import"./chunk-EI4KYBNI.js";import"./chunk-RGUKQXKL.js";import"./chunk-B646CE3C.js";import"./chunk-WJB6YYMJ.js";import"./chunk-AHG2O5HT.js";import"./chunk-23E37MDA.js";import"./chunk-NC7HTDH5.js";import"./chunk-PT6U3IIK.js";import"./chunk-NHL37QAZ.js";import"./chunk-LUAXQB57.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-ZTD6PFD7.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.13.11");process.exit(0)}
-import{a,b,c,d,e,f,g,h,i,j,k,l}from"./chunk-YRCNWQBO.js";import"./chunk-24XW7KUX.js";import"./chunk-2Y3PW5EJ.js";import"./chunk-SJJFU7KK.js";import"./chunk-WYQM7GXW.js";import"./chunk-CYQRZ645.js";import"./chunk-QYHRDBKI.js";import"./chunk-LREIHR2A.js";import"./chunk-TZA45FI7.js";import"./chunk-TCVEXQLL.js";import"./chunk-PJNIDDER.js";import"./chunk-4TUGQESL.js";import"./chunk-EI4KYBNI.js";import"./chunk-RGUKQXKL.js";import"./chunk-B646CE3C.js";import"./chunk-WJB6YYMJ.js";import"./chunk-AHG2O5HT.js";import"./chunk-23E37MDA.js";import"./chunk-NC7HTDH5.js";import"./chunk-PT6U3IIK.js";import"./chunk-NHL37QAZ.js";import"./chunk-LUAXQB57.js";export{l as MCPToolBase,k as defaultToolLogger,j as getKernel,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};