@tangle-network/agent-eval 0.117.0 → 0.118.0

package/dist/kind-factory-ClZmO25A.d.ts

@@ -1,171 +0,0 @@
-import { AxAIService, AxFunction } from '@ax-llm/ax';
-import { T as TraceAnalysisStore } from './store-C1YxJDEK.js';
-import { z } from 'zod';
-import { g as AnalystCost, a as AnalystContext, A as Analyst } from './policy-edit-wG9uFEFm.js';
-
-/**
- * Typed Ax output for analyst findings.
- *
- * Replaces the legacy `findings:string[]` pattern (where every bullet
- * became a flat-severity `AnalystFinding`) with a structured object
- * array. Ax binds the field as `findings:json[]` so the provider emits
- * native structured output; at the kind-factory boundary we Zod-validate
- * each emitted finding so malformed rows fail loud instead of being
- * silently lifted with default severity.
- *
- * Why not `f.object().array()` directly in the signature? The Ax
- * signature string `question:string -> findings:json[]` already lets
- * the provider emit JSON arrays. A Zod boundary is required either
- * way (the provider can return any JSON), and Zod gives us a single
- * validation surface independent of which Ax version is installed.
- */
-
-declare const ANALYST_SEVERITIES: readonly ["critical", "high", "medium", "low", "info"];
-declare const RawAnalystFindingSchema: z.ZodObject<{
-    severity: z.ZodEnum<{
-        info: "info";
-        critical: "critical";
-        medium: "medium";
-        low: "low";
-        high: "high";
-    }>;
-    claim: z.ZodString;
-    subject: z.ZodOptional<z.ZodString>;
-    evidence_uri: z.ZodString;
-    evidence_excerpt: z.ZodOptional<z.ZodString>;
-    confidence: z.ZodNumber;
-    rationale: z.ZodOptional<z.ZodString>;
-    recommended_action: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-type RawAnalystFinding = z.infer<typeof RawAnalystFindingSchema>;
-/**
- * Description embedded into the actor prompt so the LLM knows what
- * shape to emit. Kept here so kinds share one source of truth rather
- * than restating the schema in every prompt.
- */
-declare const RAW_FINDING_SCHEMA_PROMPT = "Each finding MUST be a JSON object with these fields:\n  - severity: one of \"critical\" | \"high\" | \"medium\" | \"low\" | \"info\"\n  - claim: one-sentence statement (max 2000 chars)\n  - subject?: the routing locus this finding is about. It MUST be one of the exact subject forms listed in this kind's instructions above (e.g. `system-prompt:<section>`, `agent-knowledge:wiki:<slug>`, `tool-doc:<tool>`). A free phrase, a bare noun, or any form not in that list is REJECTED at parse time and the finding is discarded \u2014 omit subject entirely rather than guess a form.\n  - evidence_uri: REQUIRED, never blank. Exactly one of \"span://<trace_id>/<span_id>\" (trace evidence), \"artifact://<relative-path>\" (files), \"metric://<name>\" (named scalars) \u2014 ALWAYS cite a real id surfaced by the tools. If you have no citable id, do not emit the finding.\n  - evidence_excerpt?: short quote (<=2000 chars) from the cited span/artifact\n  - confidence: number 0..1 \u2014 0.9+ when backed by exact quotes, 0.6-0.8 for inferred patterns, <0.5 for speculative\n  - rationale?: one or two sentences explaining the reasoning\n  - recommended_action?: concrete change phrased as an imperative (\"Add ...\", \"Replace ...\", \"Stop ...\") \u2014 omit when the finding is purely descriptive\n\nEmit an empty array when the question has no findings to report. Do not fabricate evidence.";
-/**
- * Validate one row emitted by the LLM. Returns the typed finding on
- * success; returns `null` and logs the reason on failure so the kind
- * factory can skip-and-count rather than abort the whole analyst run.
- */
-declare function parseRawFinding(row: unknown, log?: (msg: string, fields?: Record<string, unknown>) => void): RawAnalystFinding | null;
-
-/**
- * Analyst-kind factory — the typed way to define trace analysts.
- *
- * A "kind" is a specialized analyst whose actor prompt, tool subset,
- * and Ax recursion config target one failure-mode lens (failure-mode
- * classification, knowledge gap discovery, knowledge poisoning, recursive
- * self-improvement, ...). Kinds emit findings in the typed `RawAnalystFinding`
- * shape via a JSON-array Ax output; the factory validates each row with
- * Zod and lifts it into `AnalystFinding[]` with no shape guessing.
- *
- * Composition rules:
- *   - Each kind owns its actor description. No generic "answer this
- *     question" prompt — the prompt names the failure lens.
- *   - Each kind picks a narrow tool subset from `ANALYST_TOOL_GROUPS`.
- *     A kind that never needs full-trace dumps can drop `viewTrace` /
- *     `viewSpans` and stay cheap.
- *   - Each kind declares its recursion + parallelism budget. Discovery-
- *     heavy kinds (failure-mode) get higher `maxDepth`; lens kinds
- *     (poisoning) usually stay at 0 since they have a tighter brief.
- *
- * Optimizer hook: kinds may declare `goldens` — labeled examples used
- * by `AxMiPRO` / `AxBootstrapFewShot` / `AxGEPA` to fit the actor
- * description programmatically. Stored on the kind, not the registry,
- * because the right metric is kind-specific.
- */
-
-/**
- * Per-kind specification. The factory turns this into a regular
- * `Analyst<TraceAnalysisStore>` ready for `AnalystRegistry.register()`.
- */
-interface TraceAnalystKindSpec {
-    /** Stable id. Appears in finding_id, telemetry, and registry exclusions. */
-    id: string;
-    /** One-sentence description shown in `registry.list()`. */
-    description: string;
-    /** Coarse classification stamped on every emitted finding (`failure-mode`, `knowledge-gap`, ...). */
-    area: string;
-    /** Bump on any breaking change to the actor prompt or output schema. */
-    version: string;
-    /** Actor system prompt. Must instruct the LLM to emit `findings` per the schema. */
-    actorDescription: string;
-    /** Responder system prompt; falls back to a minimal "format the findings" instruction. */
-    responderDescription?: string;
-    /** Tool functions the actor may call. Pick narrow subsets via `ANALYST_TOOL_GROUPS`. */
-    buildTools: (store: TraceAnalysisStore) => AxFunction[];
-    /** Recursion budget. `maxDepth: 0` disables subagents. */
-    recursion?: {
-        maxDepth: number;
-        maxParallelSubagents?: number;
-    };
-    /** Actor turn cap. Default 12. */
-    maxTurns?: number;
-    /** Runtime char cap. Default 6000. */
-    maxRuntimeChars?: number;
-    /** Cost classification surfaced in `registry.list()` and budget enforcement. */
-    cost: AnalystCost;
-    /** Per-finding-row hook — kinds may reject / rewrite before lifting. */
-    postProcess?: (row: RawAnalystFinding, ctx: AnalystContext) => RawAnalystFinding | null;
-    /** Optional optimizer hook — populated when a kind wants to fit its prompt against labeled examples. */
-    goldens?: TraceAnalystGolden[];
-}
-/**
- * One labeled example consumed by Ax optimizers (MIPRO / GEPA / Bootstrap).
- * Each input is the same `{question}` an analyst would receive; `expected`
- * is the ground-truth finding set a fitted prompt should produce on this
- * input. Metric: kind-specific (default: F1 on `finding_id` overlap).
- */
-interface TraceAnalystGolden {
-    question: string;
-    expected: ReadonlyArray<Omit<RawAnalystFinding, 'confidence'>>;
-}
-interface CreateTraceAnalystKindOpts {
-    /** AxAIService bound at registration time. */
-    ai: AxAIService;
-    /** Optional model override; falls back to the AI service's default. */
-    model?: string;
-    /** Override the spec's `version` (e.g. when an optimizer has fitted a new prompt). */
-    versionSuffix?: string;
-    /**
-     * Optional two-phase recovery: when the agentic harvest is empty but the
-     * actor produced a substantive free-form `report`, extract findings from that
-     * prose via a tolerant chat-completions pass (`structureFindings`) — no
-     * strict-emission contract, so it works on weak models. Omit to leave the
-     * actor's harvest as-is (the report is still surfaced fail-loud either way).
-     */
-    recovery?: {
-        baseUrl: string;
-        apiKey?: string;
-        model?: string;
-        fetchImpl?: typeof fetch;
-    };
-}
-/**
- * Build an `Analyst<TraceAnalysisStore>` from a kind spec.
- *
- * Lifts the Ax pipeline once at registration time so the registry
- * gets a stateless analyst. The Ax agent is freshly constructed per
- * `analyze()` call (the agent carries chat-log + usage state we don't
- * want shared across analyst runs).
- */
-declare function createTraceAnalystKind(spec: TraceAnalystKindSpec, opts: CreateTraceAnalystKindOpts): Analyst<TraceAnalysisStore>;
-/**
- * Render a compact prior-findings block the actor reads alongside its
- * brief. Each row is one line so the actor can scan dozens cheaply.
- * The kind's prompt instructs the actor to (a) check whether a new
- * cluster matches a prior `finding_id` (carry the id forward via
- * `id_basis` to keep diffs stable) and (b) raise severity / confidence
- * when a prior finding has reappeared without remediation.
- *
- * Returns the empty string when there are no prior findings — most
- * runs are "first-of-its-kind" and the prompt stays unchanged.
- *
- * Exported for tests + for consumers that build their own actor
- * prompts (e.g. specialized analysts living outside the default kinds).
- */
-declare function renderPriorFindings(prior: AnalystContext['priorFindings']): string;
-
-export { ANALYST_SEVERITIES as A, type CreateTraceAnalystKindOpts as C, RAW_FINDING_SCHEMA_PROMPT as R, type TraceAnalystKindSpec as T, type RawAnalystFinding as a, RawAnalystFindingSchema as b, type TraceAnalystGolden as c, createTraceAnalystKind as d, parseRawFinding as p, renderPriorFindings as r };

package/dist/llm-client-qoDd18Qz.d.ts

@@ -1,289 +0,0 @@
-import { c as CostReceiptInput, M as MaximumCharge } from './cost-ledger-DWy3XdJc.js';
-import { A as AgentEvalError, C as CaptureIntegrityError } from './errors-oeQrLqXC.js';
-import { R as RawProviderSink, P as ProviderRedactor } from './raw-provider-sink-C46HDghv.js';
-
-/**
- * LLM client with graceful degrade.
- *
- * OpenAI-compatible `/v1/chat/completions` client with:
- *   - Exponential-backoff retry on 429 + 5xx gateway errors (502/503/504).
- *   - Retry on transient network errors (fetch failed, AbortError, ECONNRESET).
- *   - Graceful json_schema → json_object degrade on 400 with schema-reject body.
- *   - Fenced-JSON stripping (```json ... ```) for models that wrap structured output.
- *   - Configurable base URL + api key / bearer, works with LiteLLM proxies, OpenAI
- *     directly, cli-bridge subscriptions, and any router that speaks the spec.
- *
- * Usage:
- *   const { value, result } = await callLlmJson<MyType>(
- *     { model: 'gpt-4o', messages: [...], jsonSchema: { name: 'x', schema: {...} } },
- *     { baseUrl: 'https://router.tangle.tools/v1', apiKey: process.env.KEY },
- *   )
- *
- * This is THE llm-calling seam for agent-eval primitives that need structured
- * output (semantic concept judge, reviewer directives, critic scores). Primitives
- * that need free-form text use `callLlm` and parse output themselves.
- */
-
-interface LlmMessage {
-    role: 'system' | 'user' | 'assistant';
-    /**
-     * Either a plain text content string OR a multimodal content array
-     * (text + image_url parts) for vision-capable models.
-     */
-    content: string | Array<{
-        type: 'text';
-        text: string;
-    } | {
-        type: 'image_url';
-        image_url: {
-            url: string;
-            detail?: 'auto' | 'low' | 'high';
-        };
-    }>;
-}
-interface LlmCallRequest {
-    model: string;
-    messages: LlmMessage[];
-    /** Optional JSON-mode response format (response_format: json_object). */
-    jsonMode?: boolean;
-    /** Optional structured output via JSON Schema. Falls back to json_object on 400. */
-    jsonSchema?: {
-        name: string;
-        schema: Record<string, unknown>;
-    };
-    temperature?: number;
-    maxTokens?: number;
-    /** Per-call timeout, default 300s. */
-    timeoutMs?: number;
-}
-/** Conservative priced bound for the exact text request sent to a provider.
- * Returns undefined when output or multimodal input is not bounded, causing a
- * capped CostLedger to reject the call before execution. */
-declare function maximumChargeForLlmRequest(request: Pick<LlmCallRequest, 'model' | 'messages' | 'jsonSchema' | 'maxTokens'>, options?: LlmClientOptions): MaximumCharge | undefined;
-interface LlmUsage {
-    promptTokens: number;
-    completionTokens: number;
-    totalTokens: number;
-    /** False when the provider omitted or malformed prompt/completion usage. */
-    captured?: boolean;
-    /** Proxies populate this when prompt caching is on. */
-    cachedPromptTokens?: number;
-}
-interface LlmCallResult {
-    /** The text content of the first choice. Empty string if none. */
-    content: string;
-    usage: LlmUsage;
-    /**
-     * Cost in USD. Pulled from proxy's `_response_cost` field when present;
-     * `null` when neither the proxy nor the caller can derive it.
-     */
-    costUsd: number | null;
-    /** Model name actually used (echoed from response). */
-    model: string;
-    /** Wall-clock duration of the HTTP call (last attempt, if retried). */
-    durationMs: number;
-    /**
-     * `finish_reason` echoed from the first choice (`stop`, `length`,
-     * `content_filter`, `tool_calls`, ...). `null` when the provider omits it.
-     * Exposed so a free-form `callLlm` caller CAN detect a truncated answer
-     * (`length`) instead of treating a cut-off completion as complete. Note:
-     * `callLlm` does not itself reject on it — acting on this signal is the
-     * caller's responsibility (in-repo free-form drivers do not yet enforce it).
-     */
-    finishReason?: string | null;
-    /**
-     * True when `content.trim()` is empty. An empty completion is a silent zero
-     * for free-form `callLlm` callers; this flag is the signal a caller can
-     * inspect to fail loud rather than proceed on an empty string. `callLlm`
-     * surfaces it but does not throw on it.
-     */
-    contentEmpty?: boolean;
-    /** Raw response body. */
-    raw: Record<string, unknown>;
-}
-type LlmCallMetadata = Pick<LlmCallResult, 'usage' | 'costUsd' | 'model' | 'durationMs'>;
-/** Convert a provider result into the canonical paid-call receipt input. */
-declare function costReceiptFromLlm(result: LlmCallResult): CostReceiptInput;
-/** Structured-response failures retain their completed provider receipt. */
-declare function costReceiptFromLlmError(error: Error): CostReceiptInput | undefined;
-declare class LlmCallError extends AgentEvalError {
-    readonly status: number;
-    readonly body: string;
-    readonly model: string;
-    constructor(message: string, status: number, body: string, model: string);
-}
-/** A provider response completed and incurred measurable usage, but its content
- *  could not satisfy the caller's response contract. The response envelope is
- *  retained so accounting can commit the receipt before the error propagates. */
-declare class LlmResponseError extends AgentEvalError {
-    readonly result: LlmCallResult;
-    constructor(message: string, result: LlmCallResult, options?: {
-        cause?: unknown;
-    });
-}
-interface LlmClientOptions {
-    /** Base URL (without trailing slash). Must end at the `/v1` prefix. */
-    baseUrl?: string;
-    /** Bearer token — either `apiKey` or `bearer` populates `Authorization: Bearer ...`. */
-    apiKey?: string;
-    bearer?: string;
-    /** Override for the `Authorization` header (e.g. `X-Auth: ...`). Takes precedence over apiKey/bearer. */
-    authHeader?: {
-        name: string;
-        value: string;
-    };
-    /** Stable provider idempotency key, reused across retries of this logical call. */
-    idempotencyKey?: string;
-    /** Default timeout in ms. Per-call can override. */
-    defaultTimeoutMs?: number;
-    /**
-     * Caller-supplied abort signal — e.g. a campaign-wide cancel. Linked to
-     * each attempt's per-attempt timeout controller, so aborting it cancels
-     * the in-flight fetch. A caller abort is FATAL: it is not retried even
-     * though an AbortError otherwise matches the transient patterns.
-     */
-    signal?: AbortSignal;
-    /**
-     * Cross-attempt wall-clock budget in ms, measured from the first attempt.
-     * Before launching each attempt the loop checks the remaining budget and
-     * stops retrying once it is exhausted, rather than waiting the full
-     * per-attempt timeout on every retry. Bounds total time independent of
-     * total attempts × `timeoutMs`.
-     */
-    deadlineMs?: number;
-    /** Total provider attempts. Legacy option name; default 3 (1 initial + 2 retries). */
-    maxRetries?: number;
-    /** Fetch implementation — defaults to global `fetch`. Override for custom transport (e.g. tests). */
-    fetch?: typeof fetch;
-    /**
-     * Optional raw HTTP capture sink. When provided, every request, response,
-     * and error (across all retry attempts) is recorded to the sink, with auth
-     * headers and credential-shaped body fields redacted by default. This is
-     * the layer-1 forensics primitive: structured `LlmSpan`s record intent,
-     * raw events record what actually crossed the wire.
-     */
-    rawSink?: RawProviderSink;
-    /**
-     * Logical provider id attached to raw events. When omitted, derived from
-     * `baseUrl` via `providerFromBaseUrl`.
-     */
-    provider?: string;
-    /** Trace context attached to raw events; populated by emitter-aware callers. */
-    traceContext?: {
-        runId?: string;
-        spanId?: string;
-    };
-    /** Override the redaction strategy for this call. Defaults to `defaultProviderRedactor`. */
-    redactor?: ProviderRedactor;
-}
-/**
- * True when an error is a transient transport/network fault worth retrying,
- * as opposed to a deterministic failure (4xx schema reject, JSON parse) that
- * a retry cannot fix. Inspects `LlmCallError.status`, then the error's
- * name/message/code, then recurses into `error.cause` — undici nests the
- * real socket fault one or more levels under `.cause`.
- *
- * This is THE retry classifier for the package: `callLlm` and
- * `withJudgeRetry` both route through it, so a connection-class error is
- * treated identically whether it surfaces in the HTTP client or a
- * TCloud-backed judge.
- */
-declare function isTransientLlmError(err: unknown): boolean;
-/** Exponential backoff: 500ms, 1s, 2s, 4s, ... capped at 16s. Attempt is 0-indexed. */
-declare function backoffMs(attempt: number): number;
-/**
- * Strip a ```json / ``` code fence if the model emitted one.
- * Idempotent for naked JSON. Some models (claude-code via router, certain
- * deepseek models) wrap output even under json_object.
- */
-declare function stripFencedJson(raw: string): string;
-/**
- * Low-level call. Returns raw content + usage + cost. Retries on transient
- * failures; does NOT degrade schema here — callers that want graceful
- * degrade use `callLlmJson`.
- */
-declare function callLlm(req: LlmCallRequest, opts?: LlmClientOptions): Promise<LlmCallResult>;
-/**
- * Structured-output call. Returns parsed JSON plus the raw result envelope.
- * Degrades `jsonSchema` → `jsonMode` on a 400 that names the schema param —
- * critical for deepseek-v3/v4, kimi-k2.6, and other models that don't accept
- * the `response_format.json_schema` shape but DO accept `json_object`.
- */
-declare function callLlmJson<T = unknown>(req: LlmCallRequest, opts?: LlmClientOptions): Promise<{
-    value: T;
-    result: LlmCallResult;
-}>;
-type LlmRouteAssertionReason = 'no_explicit_base_url' | 'base_url_blocked' | 'base_url_not_allowed' | 'no_auth' | 'wrong_provider';
-declare class LlmRouteAssertionError extends CaptureIntegrityError {
-    readonly reason: LlmRouteAssertionReason;
-    readonly baseUrl: string;
-    constructor(message: string, reason: LlmRouteAssertionReason, baseUrl: string);
-}
-interface LlmRouteRequirements {
-    /**
-     * Throw if `opts.baseUrl` is undefined, i.e. the call would fall back to
-     * `DEFAULT_BASE_URL`. Set this for evaluation runs where silently using
-     * the public/free-tier router is a defect — the launch reviewer needs to
-     * know exactly which provider answered.
-     */
-    requireExplicitBaseUrl?: boolean;
-    /**
-     * Allowlist of acceptable base URLs. Strings match by prefix
-     * (case-insensitive); RegExps test against the full base URL.
-     */
-    allowedBaseUrls?: Array<string | RegExp>;
-    /** Blocklist that takes precedence over `allowedBaseUrls`. */
-    blockedBaseUrls?: Array<string | RegExp>;
-    /** Throw if no auth header / api key is configured. */
-    requireAuth?: boolean;
-    /**
-     * Logical provider id the configured `baseUrl` is expected to match (via
-     * `providerFromBaseUrl`). Mainly useful when paired with `requireExplicitBaseUrl`.
-     */
-    expectedProvider?: string;
-}
-/**
- * Fail-loud assertion that the configured LLM client points at the route
- * the caller intends. Designed for the matrix-runner preflight: invoke
- * once before any LLM call to catch misconfiguration before a sweep burns
- * dollars on the wrong provider.
- *
- * Throws `LlmRouteAssertionError`. Pure — no I/O — so it's safe to call
- * from constructors and CI gates.
- */
-declare function assertLlmRoute(opts: LlmClientOptions, req?: LlmRouteRequirements): void;
-/**
- * Probe whether a model is reachable. Returns latency + null error on
- * success; `ok=false` + error message on any failure (HTTP, timeout,
- * network, parse). Designed for sweep preflights — fail loud at the
- * boundary before burning a 30-leaf run on a misconfigured router.
- *
- * Sends a tiny `ping` message with `maxTokens=64`. Reasoning models
- * (glm-5.1, deepseek-v4) can burn the entire budget on internal reasoning
- * for short prompts, so don't tighten this further. We don't validate
- * content; HTTP 200 means reachable.
- */
-declare function probeLlm(model: string, opts?: LlmClientOptions & {
-    timeoutMs?: number;
-}): Promise<{
-    ok: boolean;
-    latencyMs: number;
-    error: string | null;
-}>;
-/**
- * Stateful client — construct once with defaults, call many times.
- * Thin wrapper around the free functions; exists for callers that want
- * to inject a single configured instance into multiple primitives.
- */
-declare class LlmClient {
-    readonly maximumAttempts: number;
-    private readonly opts;
-    constructor(opts?: LlmClientOptions);
-    call(req: LlmCallRequest, per?: LlmClientOptions): Promise<LlmCallResult>;
-    callJson<T = unknown>(req: LlmCallRequest, per?: LlmClientOptions): Promise<{
-        value: T;
-        result: LlmCallResult;
-    }>;
-}
-
-export { type LlmCallMetadata as L, type LlmClientOptions as a, type LlmRouteRequirements as b, type LlmCallRequest as c, type LlmCallResult as d, type LlmUsage as e, LlmCallError as f, LlmClient as g, type LlmMessage as h, LlmResponseError as i, LlmRouteAssertionError as j, assertLlmRoute as k, backoffMs as l, callLlm as m, callLlmJson as n, costReceiptFromLlm as o, costReceiptFromLlmError as p, isTransientLlmError as q, maximumChargeForLlmRequest as r, probeLlm as s, stripFencedJson as t };

package/dist/multi-layer-verifier-BsqKuLyN.d.ts

@@ -1,150 +0,0 @@
-import { D as DefaultVerdict } from './verdict-C9MlYujm.js';
-
-/**
- * Multi-layer verifier — ordered pipeline of verification layers.
- *
- * Different contract from {@link JudgeRunner} (which runs parallel
- * specs against a sandbox). MultiLayerVerifier is a DAG of layers
- * (install → typecheck → build → lint → serve → semantic → …) with
- * dependency-based skip, per-layer findings, soft-fail semantics, and
- * an aggregated `blendedScore` across all passed layers.
- *
- * Use when you want:
- *   - ordered stages where a failing upstream stage skips downstream ones
- *   - each stage produces rich `findings` (severity + message + evidence)
- *   - a single composite score across stages with per-stage weights
- *   - soft-fail stages whose failure doesn't abort the pipeline
- *
- * Use {@link JudgeRunner} when you want:
- *   - N independent judges running in parallel against the same artifact
- *   - no inter-judge dependencies
- *   - boolean `passed` per judge + overall
- *
- * Both primitives compose — JudgeRunner can be invoked as a single
- * layer inside a MultiLayerVerifier if that suits the caller.
- */
-
-type LayerStatus = 'pass' | 'fail' | 'skipped' | 'error' | 'timeout';
-type Severity = 'critical' | 'major' | 'minor' | 'info';
-interface Finding {
-    severity: Severity;
-    message: string;
-    evidence?: string;
-    /** Optional layer name the finding belongs to (set by the verifier if omitted). */
-    layer?: string;
-    /**
-     * Free-form structured payload — used by `multiToolchainLayer` to attach
-     * `{ adapter: 'pnpm' }`, by judges to attach evidence pointers, etc.
-     * Renderers MAY interrogate; agent-eval primitives never assume shape.
-     */
-    detail?: Record<string, unknown>;
-}
-interface LayerResult {
-    layer: string;
-    status: LayerStatus;
-    /** 0..1 score, optional — layers that don't produce a numeric score omit. */
-    score?: number;
-    durationMs: number;
-    findings: Finding[];
-    /** Short human-readable summary (one line). */
-    reason?: string;
-    /**
-     * Numeric layer-level diagnostics: error counts, warning counts,
-     * cyclomatic complexity, total adapter wall-time, etc. Keyed by
-     * diagnostic name; null = "diagnostic not applicable / not measured."
-     * Renderers that know the keys can display them; ones that don't,
-     * ignore. Free-form on purpose — consumers type the value shape in
-     * their own namespace.
-     */
-    diagnostics?: Record<string, number | null>;
-    /** Any rich per-layer detail — rendered as-is by consumers that know the layer. */
-    detail?: Record<string, unknown>;
-}
-interface VerifyContext<Env = unknown> {
-    /** Per-run opaque context the caller provides. Layers destructure what they need. */
-    env: Env;
-    /** Previously-computed results from layers that already ran. */
-    prior: Record<string, LayerResult>;
-    /** Signal — if aborted, layers MUST bail within reasonable wall. */
-    signal: AbortSignal;
-}
-interface Layer<Env = unknown> {
-    name: string;
-    /** Stages that must have `status: 'pass'` before this layer runs. */
-    dependsOn?: string[];
-    /**
-     * Weight in the composite `blendedScore`. Default 1.0. Layers with weight 0
-     * contribute findings but not score.
-     */
-    weight?: number;
-    /**
-     * If true, a `fail` status contributes to `blendedScore` (as 0) instead of
-     * being dropped — use for layers whose failure is a real signal. Default:
-     * fail drops from numerator + denominator, matching VB's existing semantics.
-     */
-    failContributesToScore?: boolean;
-    /** Optional per-layer wall-cap in ms. Honored by the verifier (AbortSignal). */
-    capMs?: number;
-    run: (ctx: VerifyContext<Env>) => Promise<LayerResult> | LayerResult;
-}
-interface VerifyOptions<Env = unknown> {
-    env: Env;
-    /**
-     * Overall wall cap. Default: sum of layer capMs, or Infinity if any layer
-     * omits a cap. The verifier short-circuits remaining layers on overall cap.
-     */
-    overallCapMs?: number;
-    /** Called with each layer result as it completes. */
-    onLayer?: (result: LayerResult) => void;
-}
-/** Extends the substrate verdict spine: `valid` = `allPass` and `score` =
- *  `blendedScore` — derived where the report is aggregated, so spine
- *  consumers (drivers, gates) read this report without an adapter. */
-interface VerificationReport extends DefaultVerdict {
-    layers: LayerResult[];
-    passCount: number;
-    failCount: number;
-    skippedCount: number;
-    errorCount: number;
-    /** True iff at least one scored layer ran AND every scored layer passed. */
-    allPass: boolean;
-    /**
-     * Weighted mean of `score` across contributing layers. 0 when no layers
-     * contributed. See {@link Layer.failContributesToScore} for fail semantics.
-     */
-    blendedScore: number;
-    durationMs: number;
-    startedAt: string;
-    finishedAt: string;
-}
-/**
- * Grade a semantic-concept-style judge result into a single layer status.
- *
- * Pass when overall score >= threshold AND no critical-severity concept gap.
- * Fail otherwise. Use inside a `Layer.run` when wrapping a concept judge.
- *
- * Generalized from VerticalBench H3 fix: `failingConcepts.length === 0` was
- * too strict — a single concept at 6/10 failed the entire layer despite
- * overall score being >= 0.7. Now we trust the judge's own `severity` field:
- * `critical` findings veto; `major`/`minor` reduce the score but don't veto.
- */
-declare function gradeSemanticStatus(input: {
-    score: number;
-    findings: Array<{
-        severity: Severity;
-        present?: boolean;
-        score?: number;
-    }>;
-    available: boolean;
-    threshold?: number;
-}): LayerStatus;
-/**
- * Ordered DAG of verification layers with dependency-based skipping, per-layer findings, soft-fail semantics, and a blended composite score across all passed layers.
- */
-declare class MultiLayerVerifier<Env = unknown> {
-    private readonly layers;
-    constructor(layers: Layer<Env>[]);
-    run(opts: VerifyOptions<Env>): Promise<VerificationReport>;
-}
-
-export { type Finding as F, type Layer as L, MultiLayerVerifier as M, type Severity as S, type VerifyOptions as V, type VerificationReport as a, type LayerResult as b, type VerifyContext as c, type LayerStatus as d, gradeSemanticStatus as g };