agentic-qe 3.10.9 → 3.11.1

package/dist/routing/free-tier/types.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Free-tier provider configuration (cross-pollination plan 06, D7).
+ *
+ * Lets a user place a FREE / low-cost model at the BOTTOM of the escalation
+ * ladder (below haiku), served by any OpenAI-compatible endpoint:
+ *   - local-ollama     — Ollama on the dev box / M5 host (zero cost, private)
+ *   - cloud-ollama     — ollama.com hosted models (free + paid tiers)
+ *   - openrouter       — OpenRouter free models (e.g. *:free) and paid
+ *   - openai-compatible — any other `/v1/chat/completions` server (vLLM, LM Studio,
+ *                         Groq, Together, llama.cpp, ruvllm serve, …)
+ *
+ * Secrets are NEVER stored here: a provider names the ENV VAR to read its key
+ * from (`apiKeyEnv`); the key itself is read at resolve time and never persisted.
+ */
+import type { AgentTier } from '../routing-config.js';
+export type FreeTierKind = 'local-ollama' | 'cloud-ollama' | 'openrouter' | 'openai-compatible';
+export interface FreeTierProviderConfig {
+    /** Which family of OpenAI-compatible endpoint to talk to. */
+    kind: FreeTierKind;
+    /** Model id passed in the request body (e.g. 'qwen3:8b', 'mistralai/devstral-small:free'). */
+    model: string;
+    /** Override the endpoint base URL (required for 'openai-compatible'; optional otherwise). */
+    baseUrl?: string;
+    /** Name of the ENV VAR holding the API key (never the key itself). */
+    apiKeyEnv?: string;
+    /** Per-call wall-clock budget. Default 120_000 (reasoning models need ≥120s). */
+    timeoutMs?: number;
+    /** Token budget. Default 2048 (covers a reasoning channel + answer). */
+    maxTokens?: number;
+    /** Sampling temperature. Default 0.2. */
+    temperature?: number;
+    /**
+     * Some local models (qwen3, gemma) emit a separate `reasoning` field and put
+     * the answer in `content`. When true, ignore `reasoning` and read `content`
+     * only (the default — matches the OpenAI shape). Set false to concatenate.
+     */
+    contentOnly?: boolean;
+}
+/** A fully-resolved provider ready to call (preset merged, key read from env). */
+export interface ResolvedFreeTierProvider {
+    kind: FreeTierKind;
+    model: string;
+    baseUrl: string;
+    /** Request headers incl. Authorization when a key was found. */
+    headers: Record<string, string>;
+    timeoutMs: number;
+    maxTokens: number;
+    temperature: number;
+    contentOnly: boolean;
+    /** True when the preset wants a key but none was found in env (call will likely 401). */
+    missingKey: boolean;
+}
+/**
+ * A routing-ladder entry: a tier name maps EITHER to an existing Claude tier
+ * (handled by the normal router) OR to a free-tier provider (the new bottom).
+ */
+export type TierBinding = {
+    provider: 'claude';
+    claudeTier: AgentTier;
+} | {
+    provider: 'free-tier';
+    config: FreeTierProviderConfig;
+};
+/**
+ * A complete QE routing ladder: the ordered tiers, the per-tier bindings, and
+ * the de-/escalation bounds. Feeds `createFreeTierEscalation()`.
+ */
+export interface QeRoutingLadder {
+    /** Tiers in ascending order of capability/cost, e.g. ['local','haiku','sonnet','opus']. */
+    tierOrder: string[];
+    /** Binding per tier name (must cover every entry in tierOrder). */
+    bindings: Record<string, TierBinding>;
+    /** Lowest tier to de-escalate to (default: first of tierOrder). */
+    minTier?: string;
+    /** Highest tier to escalate to (default: last of tierOrder). */
+    maxTier?: string;
+    escalateAfterFailures?: number;
+    deEscalateAfterSuccesses?: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/routing/free-tier/types.js

@@ -0,0 +1,16 @@
+/**
+ * Free-tier provider configuration (cross-pollination plan 06, D7).
+ *
+ * Lets a user place a FREE / low-cost model at the BOTTOM of the escalation
+ * ladder (below haiku), served by any OpenAI-compatible endpoint:
+ *   - local-ollama     — Ollama on the dev box / M5 host (zero cost, private)
+ *   - cloud-ollama     — ollama.com hosted models (free + paid tiers)
+ *   - openrouter       — OpenRouter free models (e.g. *:free) and paid
+ *   - openai-compatible — any other `/v1/chat/completions` server (vLLM, LM Studio,
+ *                         Groq, Together, llama.cpp, ruvllm serve, …)
+ *
+ * Secrets are NEVER stored here: a provider names the ENV VAR to read its key
+ * from (`apiKeyEnv`); the key itself is read at resolve time and never persisted.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/routing/value-score.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Cost-Pareto Value Score (plan 05 / A13).
+ *
+ * Ruv's leaderboard lesson (ADR-179): rank by quality-PER-DOLLAR, not absolute
+ * quality. This operationalizes ADR-111's "competitive QE quality cheaper than
+ * frontier" — pure functions to (a) compute a tunable value score, (b) rank a
+ * candidate pool, and (c) extract the cost-Pareto frontier (the non-dominated set
+ * a router should choose from). Pure + dependency-free.
+ *
+ * Companion: model→QE-role fit must be MEASURED, not assumed (the qwen3-coder
+ * leaderboard-rank-did-not-transfer lesson). {@link MEASURED_QE_TEST_GEN} is a
+ * dated snapshot from D3/A12; the router should refresh it from routing-feedback.
+ */
+export interface ModelEconomics {
+    model: string;
+    /** Measured QE quality on the role, 0..1 (e.g. ADR-104 composite). NOT a vendor claim. */
+    quality: number;
+    /** USD per instance (0 for free/local tiers). */
+    costPerInstance: number;
+}
+export interface ValueScoreOptions {
+    /** 0 = rank by pure quality, 1 = pure cost-efficiency. Default 0.5 (the slider). */
+    costWeight?: number;
+    /** USD ceiling to normalize cost into [0,1]. Default = max cost in the set (or the value's own cost). */
+    costCap?: number;
+}
+/**
+ * Value score in [0,1]: a `costWeight`-weighted blend of quality and cost-
+ * efficiency (1 − normalizedCost). A $0 tier has perfect cost-efficiency, so its
+ * value is dominated by its quality.
+ */
+export declare function valueScore(m: ModelEconomics, opts?: ValueScoreOptions): number;
+/** Rank a candidate pool by value score (desc). Cost is normalized across the pool. */
+export declare function rankByValue<T extends ModelEconomics>(models: T[], opts?: ValueScoreOptions): Array<T & {
+    value: number;
+}>;
+/**
+ * The cost-Pareto frontier: models NOT dominated by another (none is both
+ * cheaper AND ≥ quality). These are the only rational router choices — everything
+ * else is strictly worse on both axes. Sorted cheapest → most expensive.
+ */
+export declare function paretoFrontier<T extends ModelEconomics>(models: T[]): T[];
+/**
+ * MEASURED QE test-generation economics (snapshot 2026-06-24, D3/A12). Quality =
+ * composite (0.6·killRate + 0.3·coverage) on the 5-module corpus; cost is the
+ * per-instance estimate. NOT vendor claims — refresh from routing-feedback.
+ */
+export declare const MEASURED_QE_TEST_GEN: readonly ModelEconomics[];
+//# sourceMappingURL=value-score.d.ts.map

package/dist/routing/value-score.js

@@ -0,0 +1,54 @@
+/**
+ * Cost-Pareto Value Score (plan 05 / A13).
+ *
+ * Ruv's leaderboard lesson (ADR-179): rank by quality-PER-DOLLAR, not absolute
+ * quality. This operationalizes ADR-111's "competitive QE quality cheaper than
+ * frontier" — pure functions to (a) compute a tunable value score, (b) rank a
+ * candidate pool, and (c) extract the cost-Pareto frontier (the non-dominated set
+ * a router should choose from). Pure + dependency-free.
+ *
+ * Companion: model→QE-role fit must be MEASURED, not assumed (the qwen3-coder
+ * leaderboard-rank-did-not-transfer lesson). {@link MEASURED_QE_TEST_GEN} is a
+ * dated snapshot from D3/A12; the router should refresh it from routing-feedback.
+ */
+const clamp01 = (x) => Math.max(0, Math.min(1, x));
+/**
+ * Value score in [0,1]: a `costWeight`-weighted blend of quality and cost-
+ * efficiency (1 − normalizedCost). A $0 tier has perfect cost-efficiency, so its
+ * value is dominated by its quality.
+ */
+export function valueScore(m, opts = {}) {
+    const costWeight = clamp01(opts.costWeight ?? 0.5);
+    const cap = opts.costCap && opts.costCap > 0 ? opts.costCap : Math.max(m.costPerInstance, 1e-9);
+    const costEfficiency = clamp01(1 - m.costPerInstance / cap);
+    return clamp01((1 - costWeight) * clamp01(m.quality) + costWeight * costEfficiency);
+}
+/** Rank a candidate pool by value score (desc). Cost is normalized across the pool. */
+export function rankByValue(models, opts = {}) {
+    const cap = opts.costCap && opts.costCap > 0 ? opts.costCap : Math.max(...models.map((m) => m.costPerInstance), 1e-9);
+    return models
+        .map((m) => ({ ...m, value: valueScore(m, { ...opts, costCap: cap }) }))
+        .sort((a, b) => b.value - a.value);
+}
+/**
+ * The cost-Pareto frontier: models NOT dominated by another (none is both
+ * cheaper AND ≥ quality). These are the only rational router choices — everything
+ * else is strictly worse on both axes. Sorted cheapest → most expensive.
+ */
+export function paretoFrontier(models) {
+    const dominated = (m) => models.some((o) => o !== m && o.costPerInstance <= m.costPerInstance && o.quality >= m.quality &&
+        (o.costPerInstance < m.costPerInstance || o.quality > m.quality));
+    return models.filter((m) => !dominated(m)).sort((a, b) => a.costPerInstance - b.costPerInstance);
+}
+/**
+ * MEASURED QE test-generation economics (snapshot 2026-06-24, D3/A12). Quality =
+ * composite (0.6·killRate + 0.3·coverage) on the 5-module corpus; cost is the
+ * per-instance estimate. NOT vendor claims — refresh from routing-feedback.
+ */
+export const MEASURED_QE_TEST_GEN = [
+    { model: 'qwen3:8b', quality: 0.0, costPerInstance: 0 }, // D3: below the generation floor (0/3 valid)
+    { model: 'qwen3:30b-a3b', quality: 0.62, costPerInstance: 0 }, // D3: clears the floor (best-of-k ~0.673 on judged)
+    { model: 'z-ai/glm-5.2', quality: 0.71, costPerInstance: 0.0065 }, // A12: diverse, higher per-model best
+    { model: 'claude-sonnet-4-6', quality: 0.83, costPerInstance: 0.045 }, // D3: frontier ceiling
+];
+//# sourceMappingURL=value-score.js.map

package/dist/shared/optional-module.d.ts

@@ -0,0 +1,23 @@
+export interface OptionalModuleAvailable<T> {
+    available: true;
+    degraded: false;
+    module: T;
+}
+export interface OptionalModuleDegraded {
+    available: false;
+    degraded: true;
+    name: string;
+    reason: string;
+}
+export type OptionalModuleResult<T> = OptionalModuleAvailable<T> | OptionalModuleDegraded;
+/** True iff `err` means the module is genuinely NOT INSTALLED (vs. failed to load). */
+export declare function isModuleAbsent(err: unknown): boolean;
+/**
+ * Load an optional module. Returns `{available:true, module}` when present,
+ * `{available:false, degraded:true}` when genuinely absent, and RE-THROWS on any
+ * other load error (so real failures are never masked). Inject `req` for testing.
+ */
+export declare function loadOptionalModule<T = unknown>(name: string, req?: NodeRequire): OptionalModuleResult<T>;
+/** Convenience: the module if available, else `undefined` (degradation is silent here). */
+export declare function optionalModule<T = unknown>(name: string, req?: NodeRequire): T | undefined;
+//# sourceMappingURL=optional-module.d.ts.map

package/dist/shared/optional-module.js

@@ -0,0 +1,46 @@
+/**
+ * Graceful optional-module loading (plan 05 / A9; ADR-150 pattern).
+ *
+ * AQE has many native/optional deps (@ruvector/{gnn,attention,sona,...},
+ * hnswlib-node, rvlite) declared in `optionalDependencies`, so a platform without
+ * a prebuilt binary (or a Dependabot-pruned lockfile) must DEGRADE, not crash.
+ *
+ * The hazard (AQE #528 lesson): the ad-hoc `try { require(x) } catch {}` scattered
+ * across the wrappers swallows EVERY error — so a binary that is PRESENT but fails
+ * to load (ABI mismatch, corrupt .node) is silently reported "unavailable",
+ * masking a real failure. This helper degrades ONLY on genuine absence
+ * (MODULE_NOT_FOUND) and RE-THROWS any other load error.
+ */
+import { createRequire } from 'node:module';
+const ABSENT_CODES = new Set(['MODULE_NOT_FOUND', 'ERR_MODULE_NOT_FOUND']);
+/** True iff `err` means the module is genuinely NOT INSTALLED (vs. failed to load). */
+export function isModuleAbsent(err) {
+    const e = err;
+    if (e?.code && ABSENT_CODES.has(e.code))
+        return true;
+    // Some loaders throw a plain Error; fall back to the canonical message shape.
+    return typeof e?.message === 'string' && /Cannot find module/.test(e.message);
+}
+const defaultRequire = createRequire(import.meta.url);
+/**
+ * Load an optional module. Returns `{available:true, module}` when present,
+ * `{available:false, degraded:true}` when genuinely absent, and RE-THROWS on any
+ * other load error (so real failures are never masked). Inject `req` for testing.
+ */
+export function loadOptionalModule(name, req = defaultRequire) {
+    try {
+        return { available: true, degraded: false, module: req(name) };
+    }
+    catch (err) {
+        if (isModuleAbsent(err)) {
+            return { available: false, degraded: true, name, reason: `optional module "${name}" not installed (running degraded)` };
+        }
+        throw err; // present but broken — do NOT mask a real failure (#528)
+    }
+}
+/** Convenience: the module if available, else `undefined` (degradation is silent here). */
+export function optionalModule(name, req) {
+    const r = loadOptionalModule(name, req);
+    return r.available ? r.module : undefined;
+}
+//# sourceMappingURL=optional-module.js.map

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

@@ -0,0 +1,32 @@
+/**
+ * @ruvector/adversarial-verify — calibration (plan 05 / A2 step 5).
+ *
+ * Measure the verifier against a LABELED set (findings tagged real/false) to get
+ * the operating point: false-kill (a REAL finding wrongly refuted — the costly
+ * error) and false-keep (a FALSE finding that survives). Works with any `Judge`
+ * — 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';
+export interface LabeledFinding {
+    finding: Finding;
+    /** Ground truth: is this a genuine, actionable problem? */
+    isReal: boolean;
+}
+export interface CalibrationReport {
+    total: number;
+    realCount: number;
+    falseCount: number;
+    /** REAL findings wrongly refuted (the costly error). */
+    falseKill: number;
+    falseKillRate: number;
+    /** FALSE findings wrongly upheld (survived verification). */
+    falseKeep: number;
+    falseKeepRate: number;
+    correctConfirm: number;
+    correctKill: number;
+    uncertain: number;
+}
+/** Run the verifier over a labeled set and report the confusion vs ground truth. */
+export declare function calibrate(labeled: LabeledFinding[], opts: AdversarialVerifyOptions): Promise<CalibrationReport>;
+//# sourceMappingURL=calibrate.d.ts.map

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

@@ -0,0 +1,33 @@
+import { adversarialVerify } from './verify.js';
+/** Run the verifier over a labeled set and report the confusion vs ground truth. */
+export async function calibrate(labeled, opts) {
+    const verdicts = await adversarialVerify(labeled.map((l) => l.finding), opts);
+    const r = {
+        total: labeled.length, realCount: 0, falseCount: 0,
+        falseKill: 0, falseKillRate: 0, falseKeep: 0, falseKeepRate: 0,
+        correctConfirm: 0, correctKill: 0, uncertain: 0,
+    };
+    labeled.forEach((l, i) => {
+        const v = verdicts[i].verdict;
+        if (v === 'uncertain')
+            r.uncertain++;
+        if (l.isReal) {
+            r.realCount++;
+            if (v === 'refuted')
+                r.falseKill++;
+            else if (v === 'upheld')
+                r.correctConfirm++;
+        }
+        else {
+            r.falseCount++;
+            if (v === 'upheld')
+                r.falseKeep++;
+            else if (v === 'refuted')
+                r.correctKill++;
+        }
+    });
+    r.falseKillRate = r.realCount ? r.falseKill / r.realCount : 0;
+    r.falseKeepRate = r.falseCount ? r.falseKeep / r.falseCount : 0;
+    return r;
+}
+//# sourceMappingURL=calibrate.js.map

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

@@ -0,0 +1,38 @@
+/**
+ * @ruvector/adversarial-verify — output gate (plan 05 / A5).
+ *
+ * An opt-in "verify before you emit" gate any vertical/harness can embed: route
+ * emitted findings/claims through the blind refuters and DROP the refuted ones
+ * before acting. Default-off-able and cost-neutral when disabled (no Judge calls).
+ * Surfaces every verdict for witness/telemetry, and reports the gate's overhead.
+ *
+ * Vendor-ready: zero dependencies beyond this module, so MetaHarness (or any host)
+ * can embed it as a per-vertical `verify` hook.
+ */
+import type { AdversarialVerifyOptions, Finding, FindingVerdict } from './types.js';
+export interface VerifyGateOptions extends AdversarialVerifyOptions {
+    /** Off ⇒ no-op pass-through, ZERO Judge calls (cost-neutral). Default true. */
+    enabled?: boolean;
+    /** Also block `uncertain` verdicts (all refuters failed), not just `refuted`. Default false. */
+    dropUncertain?: boolean;
+}
+export interface VerifyGateResult {
+    enabled: boolean;
+    /** Findings that PASS the gate — emit these. */
+    emitted: FindingVerdict[];
+    /** Findings the gate blocked (refuted, + uncertain when `dropUncertain`). */
+    blocked: FindingVerdict[];
+    /** All verdicts (for witness/telemetry). */
+    all: FindingVerdict[];
+    /** Gate wall-clock overhead in ms (A5 (d) — measured cost). */
+    latencyMs: number;
+    /** Judge invocations the gate made (0 when disabled). Token cost ∝ this. */
+    judgeCalls: number;
+}
+/**
+ * Verify findings before emitting them. Returns the survivors (`emitted`), the
+ * killed (`blocked`), every verdict (`all`), and the gate's overhead. When
+ * `enabled === false` it is a no-op: no Judge calls, everything passes through.
+ */
+export declare function verifyGate(findings: Finding[], opts: VerifyGateOptions): Promise<VerifyGateResult>;
+//# sourceMappingURL=gate.d.ts.map

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

@@ -0,0 +1,32 @@
+import { adversarialVerify } from './verify.js';
+/** A finding passed through un-verified (gate disabled): honest `uncertain`. */
+function passthrough(f) {
+    return {
+        contract: 'finding-verdict@1',
+        id: f.id, title: f.title,
+        ...(f.file !== undefined ? { file: f.file } : {}),
+        severity: f.severity, confidence: f.confidence, evidence: f.evidence,
+        verdict: 'uncertain', refutations: [],
+    };
+}
+const isBlocked = (v, dropUncertain) => v.verdict === 'refuted' || (dropUncertain && v.verdict === 'uncertain');
+/**
+ * Verify findings before emitting them. Returns the survivors (`emitted`), the
+ * killed (`blocked`), every verdict (`all`), and the gate's overhead. When
+ * `enabled === false` it is a no-op: no Judge calls, everything passes through.
+ */
+export async function verifyGate(findings, opts) {
+    const t0 = Date.now();
+    if (opts.enabled === false) {
+        const emitted = findings.map(passthrough);
+        return { enabled: false, emitted, blocked: [], all: emitted, latencyMs: Date.now() - t0, judgeCalls: 0 };
+    }
+    let judgeCalls = 0;
+    const countingJudge = (prompt) => { judgeCalls++; return opts.judge(prompt); };
+    const all = await adversarialVerify(findings, { ...opts, judge: countingJudge });
+    const dropUncertain = opts.dropUncertain ?? false;
+    const blocked = all.filter((v) => isBlocked(v, dropUncertain));
+    const emitted = all.filter((v) => !isBlocked(v, dropUncertain));
+    return { enabled: true, emitted, blocked, all, latencyMs: Date.now() - t0, judgeCalls };
+}
+//# sourceMappingURL=gate.js.map

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

@@ -0,0 +1,20 @@
+/**
+ * @ruvector/adversarial-verify (plan 05 / A2).
+ *
+ * Host-agnostic blind-refuter verification: turn raw findings into adversarially
+ * verified finding-verdict@1 envelopes. N blind refuters per finding (anti-
+ * sycophancy, default-refuted on uncertainty) → deterministic majority-kill.
+ * The LLM is injected as a `Judge`, so this has ZERO AQE/Claude-Code dependency
+ * and is publishable as `@ruvector/adversarial-verify`.
+ *
+ * @example
+ *   const verdicts = await adversarialVerify(findings, { judge, refuters: 3 });
+ *   const { confirmed, killed } = partitionVerdicts(verdicts);
+ */
+export type { Finding, FindingVerdict, FindingSeverity, FindingOutcome, RefuterVote, Judge, AdversarialVerifyOptions, } from './types.js';
+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 { verifyGate, type VerifyGateOptions, type VerifyGateResult } from './gate.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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 { verifyGate } from './gate.js';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,14 @@
+/**
+ * @ruvector/adversarial-verify — blind refuter prompt (ADR-074 Loki-mode).
+ *
+ * The refuter sees ONLY the bare claim + evidence + a lens — never the finder's
+ * confidence, dimension, or other refuters' votes. Anti-sycophancy: its job is to
+ * ATTACK the claim, and uncertainty defaults to refuted (unverifiable claims must
+ * not survive).
+ */
+import type { Finding } from './types.js';
+/** Default refutation lenses — distinct angles of attack (one per refuter). */
+export declare const DEFAULT_LENSES: string[];
+/** Build the blind refuter prompt for one finding under one lens. */
+export declare function refuterPrompt(finding: Finding, lens: string): string;
+//# sourceMappingURL=prompts.d.ts.map

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

@@ -0,0 +1,17 @@
+/** Default refutation lenses — distinct angles of attack (one per refuter). */
+export const DEFAULT_LENSES = [
+    'does-the-evidence-reproduce',
+    'is-it-actually-a-problem',
+    'is-the-cited-code-really-doing-this',
+];
+/** Build the blind refuter prompt for one finding under one lens. */
+export function refuterPrompt(finding, lens) {
+    return (`You are an adversarial reviewer. Try to REFUTE this code-review claim using the ${lens} lens.\n` +
+        `Claim: "${finding.title}"${finding.file ? ` in ${finding.file}` : ''}\n` +
+        `Evidence offered: ${finding.evidence.join(' | ')}\n` +
+        `Read the actual code at the cited locations and judge ONLY what you can verify yourself. ` +
+        `Set refuted=true unless the evidence checks out AND the claim is a real, actionable problem ` +
+        `(default to refuted=true when uncertain — unverifiable claims must not survive). ` +
+        `Give one-sentence reasoning.`);
+}
+//# sourceMappingURL=prompts.js.map

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

@@ -0,0 +1,18 @@
+/**
+ * @ruvector/adversarial-verify — deterministic verdict synthesis (pure).
+ *
+ * The k-of-n majority-kill math (ADR-074): a finding is `refuted` when at least
+ * ⌈n/2⌉ of the CAST votes refute it; `uncertain` when no votes were cast (all
+ * refuters failed); else `upheld`. No LLM, no I/O — byte-identical across runs.
+ */
+import type { Finding, FindingVerdict, RefuterVote } from './types.js';
+/** Default kill threshold: simple majority of cast votes (2-of-3, 1-of-1, 2-of-2). */
+export declare const majorityKill: (castVotes: number) => number;
+/**
+ * Fold a finding + its refuter votes into a finding-verdict@1 envelope.
+ * `votes` must already exclude failed refuters (null/throw → omitted upstream).
+ */
+export declare function synthesizeVerdict(finding: Finding, votes: RefuterVote[], killThreshold?: (castVotes: number) => number): FindingVerdict;
+/** Runtime guard: does `x` conform to finding-verdict@1 at the boundary? */
+export declare function isFindingVerdict(x: unknown): x is FindingVerdict;
+//# sourceMappingURL=synthesize.d.ts.map

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

@@ -0,0 +1,35 @@
+/** Default kill threshold: simple majority of cast votes (2-of-3, 1-of-1, 2-of-2). */
+export const majorityKill = (castVotes) => Math.ceil(castVotes / 2);
+/**
+ * Fold a finding + its refuter votes into a finding-verdict@1 envelope.
+ * `votes` must already exclude failed refuters (null/throw → omitted upstream).
+ */
+export function synthesizeVerdict(finding, votes, killThreshold = majorityKill) {
+    const refutations = votes.filter((v) => v.refuted).map((v) => v.reasoning);
+    const killed = votes.length > 0 && refutations.length >= killThreshold(votes.length);
+    return {
+        contract: 'finding-verdict@1',
+        id: finding.id,
+        title: finding.title,
+        ...(finding.file !== undefined ? { file: finding.file } : {}),
+        severity: finding.severity,
+        confidence: finding.confidence,
+        evidence: finding.evidence,
+        verdict: votes.length === 0 ? 'uncertain' : killed ? 'refuted' : 'upheld',
+        refutations,
+    };
+}
+/** Runtime guard: does `x` conform to finding-verdict@1 at the boundary? */
+export function isFindingVerdict(x) {
+    if (!x || typeof x !== 'object')
+        return false;
+    const v = x;
+    return (v.contract === 'finding-verdict@1' &&
+        typeof v.id === 'string' &&
+        typeof v.title === 'string' &&
+        typeof v.confidence === 'number' &&
+        Array.isArray(v.evidence) &&
+        Array.isArray(v.refutations) &&
+        (v.verdict === 'upheld' || v.verdict === 'refuted' || v.verdict === 'uncertain'));
+}
+//# sourceMappingURL=synthesize.js.map

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

@@ -0,0 +1,59 @@
+/**
+ * @ruvector/adversarial-verify — types (plan 05 / A2).
+ *
+ * Host-agnostic blind-refuter verification, extracted from AQE's
+ * qcsd-development-review workflow (ADR-074 Loki-mode, ADR-103 finding-verdict@1).
+ * ZERO dependency on AQE/Claude-Code: the LLM call is injected as a `Judge`, so
+ * this module is reusable by any host (and publishable as @ruvector/*).
+ */
+export type FindingSeverity = 'critical' | 'high' | 'medium' | 'low' | 'info';
+export type FindingOutcome = 'upheld' | 'refuted' | 'uncertain';
+/** A claim to be adversarially verified (input). */
+export interface Finding {
+    /** Stable id; the verdict carries it verbatim (callers compose any prefix). */
+    id: string;
+    title: string;
+    file?: string;
+    severity: FindingSeverity;
+    /** Finder's self-reported confidence (0..1). NOT shown to refuters (blind). */
+    confidence: number;
+    evidence: string[];
+}
+/** One refuter's vote (the Judge's return). */
+export interface RefuterVote {
+    refuted: boolean;
+    reasoning: string;
+}
+/**
+ * The injected LLM refuter. Returns a vote, or `null`/throws on failure (failed
+ * calls are excluded from the tally — they neither refute nor uphold).
+ * Receives ONLY the blind refuter prompt — never the finder's confidence/dimension.
+ */
+export type Judge = (prompt: string) => Promise<RefuterVote | null>;
+/** finding-verdict@1 envelope (mirrors schemas/finding-verdict.schema.json). */
+export interface FindingVerdict {
+    contract: 'finding-verdict@1';
+    id: string;
+    title: string;
+    file?: string;
+    severity: FindingSeverity;
+    confidence: number;
+    evidence: string[];
+    verdict: FindingOutcome;
+    /** One entry per refuter that voted to refute (empty when none). */
+    refutations: string[];
+}
+export interface AdversarialVerifyOptions {
+    /** The injected LLM refuter. Required. */
+    judge: Judge;
+    /** Refuters per finding (default 3). Capped at `lenses.length`. */
+    refuters?: number;
+    /** Refutation lenses (one per refuter). Default {@link DEFAULT_LENSES}. */
+    lenses?: string[];
+    /**
+     * Kill threshold as a function of the number of CAST votes (default ⌈n/2⌉ —
+     * majority). A finding is `refuted` when refute-votes ≥ killThreshold(castVotes).
+     */
+    killThreshold?: (castVotes: number) => number;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,10 @@
+/**
+ * @ruvector/adversarial-verify — types (plan 05 / A2).
+ *
+ * Host-agnostic blind-refuter verification, extracted from AQE's
+ * qcsd-development-review workflow (ADR-074 Loki-mode, ADR-103 finding-verdict@1).
+ * ZERO dependency on AQE/Claude-Code: the LLM call is injected as a `Judge`, so
+ * this module is reusable by any host (and publishable as @ruvector/*).
+ */
+export {};
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1,20 @@
+/**
+ * @ruvector/adversarial-verify — the orchestrator.
+ *
+ * For each finding, run N BLIND refuters in parallel (each gets only the bare
+ * claim + evidence + a distinct lens), then deterministically synthesize the
+ * finding-verdict@1. The LLM is injected (`Judge`) — no host dependency.
+ */
+import type { AdversarialVerifyOptions, Finding, FindingVerdict } from './types.js';
+/**
+ * Adversarially verify findings: N blind refuters per finding → majority-kill →
+ * finding-verdict@1 envelopes (one per finding, in input order).
+ */
+export declare function adversarialVerify(findings: Finding[], opts: AdversarialVerifyOptions): Promise<FindingVerdict[]>;
+/** Convenience: split verdicts into confirmed (upheld) / killed (refuted) / uncertain. */
+export declare function partitionVerdicts(verdicts: FindingVerdict[]): {
+    confirmed: FindingVerdict[];
+    killed: FindingVerdict[];
+    uncertain: FindingVerdict[];
+};
+//# sourceMappingURL=verify.d.ts.map