@tangle-network/agent-eval 0.109.1 → 0.110.1

package/dist/harness-optimizer-mOl9XX_O.d.ts

@@ -1,106 +0,0 @@
-import { O as Objective, P as ParetoResult } from './pareto-E-pembql.js';
-import { R as RunScore, a as RunTrace, b as RunScoreWeights } from './run-critic-CmMf05uV.js';
-
-interface SteeringRolePrompt {
-    system?: string;
-    append?: string;
-}
-interface SteeringBundle {
-    id: string;
-    coderPrompt?: string;
-    continuePrompt?: string;
-    reviewerPrompts?: Record<string, string>;
-    skills?: string[];
-    rolePrompts?: Record<string, SteeringRolePrompt>;
-    metadata?: Record<string, unknown>;
-}
-interface SteeringDelta {
-    coderPrompt?: string;
-    continuePrompt?: string;
-    reviewerPrompts?: Record<string, string>;
-    skills?: string[];
-    rolePrompts?: Record<string, SteeringRolePrompt>;
-    metadata?: Record<string, unknown>;
-}
-declare function mergeSteeringBundle(base: SteeringBundle, delta: SteeringDelta): SteeringBundle;
-declare function renderSteeringText(bundle: SteeringBundle): string;
-
-type HarnessIntervention = 'continue' | 'plan' | 'audit' | 'recover' | 'repair' | 'verify' | 'final_gate' | 'wait_for_measurement' | 'abort';
-interface WorkflowTopology {
-    id: string;
-    interventions: HarnessIntervention[];
-    maxParallelBranches?: number;
-    metadata?: Record<string, unknown>;
-}
-interface MeasurementPolicy {
-    required: string[];
-    optional?: string[];
-    promoteOn?: Array<keyof RunScore | 'aggregate'>;
-}
-interface HarnessVariant {
-    id: string;
-    steering?: SteeringBundle;
-    topology?: WorkflowTopology;
-    measurement?: MeasurementPolicy;
-    budgets?: Record<string, number>;
-    models?: Record<string, string>;
-    reviewers?: Record<string, string>;
-    metadata?: Record<string, unknown>;
-}
-interface HarnessScenario {
-    id: string;
-    task: string;
-    split?: 'train' | 'validation' | 'test' | string;
-    metadata?: Record<string, unknown>;
-}
-interface HarnessRunRequest {
-    variant: HarnessVariant;
-    scenario: HarnessScenario;
-    trialIndex: number;
-}
-interface HarnessAdapter {
-    run(request: HarnessRunRequest): Promise<RunTrace>;
-}
-interface HarnessRunResult {
-    variant: HarnessVariant;
-    scenario: HarnessScenario;
-    trialIndex: number;
-    trace: RunTrace;
-    score: RunScore;
-    aggregate: number;
-}
-interface HarnessVariantReport {
-    variant: HarnessVariant;
-    runs: HarnessRunResult[];
-    aggregateMean: number;
-    passRate: number;
-    costUsdMean: number;
-    wallSecondsMean: number;
-    scoreMean: RunScore;
-}
-interface HarnessSelection {
-    winner: HarnessVariantReport;
-    frontier: ParetoResult<HarnessVariantReport>;
-    reports: HarnessVariantReport[];
-}
-interface HarnessExperimentResult {
-    results: HarnessRunResult[];
-    selection: HarnessSelection;
-}
-interface HarnessExperimentConfig {
-    adapter: HarnessAdapter;
-    variants: HarnessVariant[];
-    scenarios: HarnessScenario[];
-    trialsPerScenario?: number;
-    parallelism?: number;
-    weights?: Partial<RunScoreWeights>;
-    objectives?: Array<Objective<HarnessVariantReport>>;
-    score?: (trace: RunTrace, request: HarnessRunRequest) => RunScore | Promise<RunScore>;
-    onResult?: (result: HarnessRunResult) => void | Promise<void>;
-}
-declare const DEFAULT_HARNESS_OBJECTIVES: Array<Objective<HarnessVariantReport>>;
-declare function runHarnessExperiment(config: HarnessExperimentConfig): Promise<HarnessExperimentResult>;
-declare function selectHarnessVariant(results: HarnessRunResult[], objectives?: Array<Objective<HarnessVariantReport>>): HarnessSelection;
-declare function summarizeHarnessResults(results: HarnessRunResult[]): HarnessVariantReport[];
-
-export { DEFAULT_HARNESS_OBJECTIVES as D, type HarnessAdapter as H, type MeasurementPolicy as M, type SteeringBundle as S, type WorkflowTopology as W, type HarnessExperimentConfig as a, type HarnessExperimentResult as b, type HarnessIntervention as c, type HarnessRunRequest as d, type HarnessRunResult as e, type HarnessScenario as f, type HarnessSelection as g, type HarnessVariant as h, type HarnessVariantReport as i, type SteeringDelta as j, type SteeringRolePrompt as k, runHarnessExperiment as l, mergeSteeringBundle as m, summarizeHarnessResults as n, renderSteeringText as r, selectHarnessVariant as s };

package/dist/kind-factory-DvIGo_cP.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, b as AnalystContext, a as Analyst } from './types-D1ytG0Yg.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/knowledge/index.d.ts

@@ -1,103 +0,0 @@
-import { j as ControlSeverity, C as ControlEvalResult } from '../control-runtime-Acf9CGhw.js';
-import { T as TraceEmitter } from '../emitter-C2rqGH_l.js';
-import '../schema-m0gsnbt3.js';
-import '../store-BcFXE6LG.js';
-
-type KnowledgeRequirementCategory = 'user_specific' | 'company_specific' | 'domain_specific' | 'codebase_specific' | 'market_specific' | 'regulatory' | 'tool_api' | 'credential_or_secret' | 'runtime_environment' | 'preference' | 'historical_context';
-type KnowledgeAcquisitionMode = 'ask_user' | 'search_web' | 'query_connector' | 'inspect_repo' | 'run_command' | 'infer_low_confidence' | 'not_available';
-type KnowledgeImportance = 'blocking' | 'high' | 'medium' | 'low';
-type KnowledgeFreshness = 'static' | 'monthly' | 'weekly' | 'daily' | 'realtime';
-type KnowledgeSensitivity = 'public' | 'private' | 'secret';
-type KnowledgeFallbackPolicy = 'block' | 'ask' | 'continue_with_caveat' | 'use_default';
-interface KnowledgeRequirement {
-    id: string;
-    description: string;
-    requiredFor: string[];
-    category: KnowledgeRequirementCategory;
-    acquisitionMode: KnowledgeAcquisitionMode;
-    importance: KnowledgeImportance;
-    freshness: KnowledgeFreshness;
-    sensitivity: KnowledgeSensitivity;
-    confidenceNeeded: number;
-    currentConfidence: number;
-    evidenceIds: string[];
-    fallbackPolicy: KnowledgeFallbackPolicy;
-    /**
-     * ISO timestamp after which this requirement must be treated as stale.
-     * Stale requirements score as missing even when they still have evidence.
-     */
-    validUntil?: string;
-    /** ISO timestamp for the last source-grounding or human verification pass. */
-    lastVerifiedAt?: string;
-    metadata?: Record<string, unknown>;
-}
-interface KnowledgeBundle {
-    taskId: string;
-    requirements: KnowledgeRequirement[];
-    evidenceIds: string[];
-    claimIds: string[];
-    wikiPageIds: string[];
-    userAnswers: Record<string, string>;
-    missing: KnowledgeRequirement[];
-    readinessScore: number;
-    metadata?: Record<string, unknown>;
-}
-type KnowledgeRecommendedAction = 'run_agent' | 'ask_user' | 'collect_web_data' | 'query_connectors' | 'inspect_repo' | 'build_domain_wiki' | 'continue_with_caveat' | 'abort_or_rescope';
-interface KnowledgeReadinessReport {
-    taskId: string;
-    readinessScore: number;
-    blockingMissingRequirements: KnowledgeRequirement[];
-    nonBlockingGaps: KnowledgeRequirement[];
-    recommendedAction: KnowledgeRecommendedAction;
-    bundle: KnowledgeBundle;
-    severity: ControlSeverity;
-    reason: string;
-}
-interface UserQuestion {
-    id: string;
-    question: string;
-    reason: string;
-    requirementId: string;
-    importance: KnowledgeImportance;
-    answerType: 'free_text' | 'select_one' | 'multi_select' | 'file_upload' | 'credential' | 'url';
-    defaultIfSkipped?: string;
-    impactIfUnknown: string;
-    options?: string[];
-    metadata?: Record<string, unknown>;
-}
-interface DataAcquisitionPlan {
-    id: string;
-    requirementIds: string[];
-    mode: Exclude<KnowledgeAcquisitionMode, 'not_available' | 'infer_low_confidence'> | 'build_domain_wiki';
-    description: string;
-    priority: KnowledgeImportance;
-    expectedEvidenceIds?: string[];
-    questions?: UserQuestion[];
-    metadata?: Record<string, unknown>;
-}
-type KnowledgeResponsibleSurface = 'knowledge-requirements' | 'data-acquisition' | 'retrieval-policy' | 'user-question-policy';
-
-interface ScoreKnowledgeReadinessOptions {
-    taskId: string;
-    requirements: KnowledgeRequirement[];
-    evidenceIds?: string[];
-    claimIds?: string[];
-    wikiPageIds?: string[];
-    userAnswers?: Record<string, string>;
-    metadata?: Record<string, unknown>;
-    now?: Date;
-}
-declare function scoreKnowledgeReadiness(options: ScoreKnowledgeReadinessOptions): KnowledgeReadinessReport;
-declare function blockingKnowledgeEval(report: KnowledgeReadinessReport, options?: {
-    id?: string;
-    minimumScore?: number;
-    emitter?: TraceEmitter;
-}): ControlEvalResult;
-declare function knowledgeReadinessTracePayload(report: KnowledgeReadinessReport, options?: {
-    passed?: boolean;
-    minimumScore?: number;
-}): Record<string, unknown>;
-declare function userQuestionsForKnowledgeGaps(gaps: KnowledgeRequirement[]): UserQuestion[];
-declare function acquisitionPlansForKnowledgeGaps(gaps: KnowledgeRequirement[]): DataAcquisitionPlan[];
-
-export { type DataAcquisitionPlan, type KnowledgeAcquisitionMode, type KnowledgeBundle, type KnowledgeFallbackPolicy, type KnowledgeFreshness, type KnowledgeImportance, type KnowledgeReadinessReport, type KnowledgeRecommendedAction, type KnowledgeRequirement, type KnowledgeRequirementCategory, type KnowledgeResponsibleSurface, type KnowledgeSensitivity, type ScoreKnowledgeReadinessOptions, type UserQuestion, acquisitionPlansForKnowledgeGaps, blockingKnowledgeEval, knowledgeReadinessTracePayload, scoreKnowledgeReadiness, userQuestionsForKnowledgeGaps };

package/dist/knowledge/index.js

@@ -1,18 +0,0 @@
-import {
-  acquisitionPlansForKnowledgeGaps,
-  blockingKnowledgeEval,
-  knowledgeReadinessTracePayload,
-  scoreKnowledgeReadiness,
-  userQuestionsForKnowledgeGaps
-} from "../chunk-Q2JRAWRI.js";
-import "../chunk-YEHAEDUD.js";
-import "../chunk-TVVP3ZZQ.js";
-import "../chunk-PZ5AY32C.js";
-export {
-  acquisitionPlansForKnowledgeGaps,
-  blockingKnowledgeEval,
-  knowledgeReadinessTracePayload,
-  scoreKnowledgeReadiness,
-  userQuestionsForKnowledgeGaps
-};
-//# sourceMappingURL=index.js.map

package/dist/knowledge/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/pareto-E-pembql.d.ts

@@ -1,81 +0,0 @@
-/**
- * Pareto frontier — multi-objective optimization over candidate runs.
- *
- * Lifted from ADC pareto.ts and blueprint-agent frontier.ts. When you're
- * trading off (cost, latency, quality) or (passRate, tokenBudget,
- * ttfb), you rarely have a single "winner" — you have a set of
- * non-dominated candidates. This module exposes:
- *
- *   - `paretoFrontier`: filter a set of candidates to the non-dominated ones
- *   - `dominates`: does A dominate B across all objectives?
- *
- * Each objective is declared with a direction: 'maximize' (higher=better)
- * or 'minimize' (lower=better). Candidates are any object; pass an
- * `objective(candidate)` accessor.
- */
-type Direction = 'maximize' | 'minimize';
-interface Objective<T> {
-    /** Stable label used in reports. */
-    name: string;
-    direction: Direction;
-    value: (candidate: T) => number;
-}
-interface ParetoResult<T> {
-    frontier: T[];
-    dominated: T[];
-    /** Index map: frontier[i] dominates each of dominatedBy[i]. */
-    dominanceMap: Array<{
-        dominator: T;
-        dominated: T[];
-    }>;
-}
-/** Does candidate A weakly dominate B — strictly better on at least one objective and no worse on any? */
-declare function dominates<T>(a: T, b: T, objectives: Objective<T>[]): boolean;
-/**
- * Compute the non-dominated frontier. Candidates with NaN/Infinity on any
- * objective are excluded (can't rank them). A candidate enters the frontier
- * iff no other candidate dominates it.
- */
-declare function paretoFrontier<T>(candidates: T[], objectives: Objective<T>[]): ParetoResult<T>;
-/**
- * Weighted-sum scalarisation. Use as a tie-break / single-winner selector
- * when callers don't want to consume a frontier. Each objective contributes
- * its normalised value (0..1 via min-max across the candidate pool) times
- * its weight; missing weights default to 1/N.
- *
- * Direction is honoured automatically — `minimize` axes have their values
- * inverted before scaling so "higher scalar = better" always holds.
- */
-declare function scalarScore<T>(candidates: T[], objectives: Objective<T>[], options?: {
-    weights?: Partial<Record<string, number>>;
-}): Array<{
-    candidate: T;
-    score: number;
-}>;
-/**
- * NSGA-II crowding distance — secondary sort for ties on the frontier.
- *
- * When the Pareto front collapses to a single point (or many candidates tie
- * on dominance), naive selection picks arbitrarily and the population
- * degenerates over generations. NSGA-II preserves diversity by preferring
- * candidates with more empty space around them on the frontier.
- *
- * Returns an array of `{ candidate, distance }` in the SAME order as the
- * input. Higher distance = more isolated = should be preferred when
- * preserving diversity.
- */
-declare function crowdingDistance<T>(candidates: T[], objectives: Objective<T>[]): Array<{
-    candidate: T;
-    distance: number;
-}>;
-/**
- * Pareto frontier with tie-break by crowding distance — the canonical
- * NSGA-II selection step. Returns the frontier sorted by descending crowding
- * distance so callers can `.slice(0, k)` to pick K diverse winners.
- */
-declare function paretoFrontierWithCrowding<T>(candidates: T[], objectives: Objective<T>[]): Array<{
-    candidate: T;
-    distance: number;
-}>;
-
-export { type Direction as D, type Objective as O, type ParetoResult as P, paretoFrontierWithCrowding as a, crowdingDistance as c, dominates as d, paretoFrontier as p, scalarScore as s };

package/dist/perf/index.d.ts

@@ -1,123 +0,0 @@
-/**
- * Journey × axes matrix for infra performance benchmarks.
- *
- * A journey is one measurable user path ("provision.cold", "chat.ttft");
- * axes are free-form scenario dimensions (driver, region, image…). The
- * matrix expansion is pure bookkeeping — running the scenarios and
- * recording metrics is the caller's job. This module complements the
- * judge-panel `BenchmarkRunner` (src/benchmark.ts): that one scores
- * QUALITY via judges, this one structures LATENCY / RELIABILITY runs
- * over flat metric records.
- */
-/** One measurable user journey (e.g. "provision.cold", "chat.ttft"). */
-interface JourneySpec {
-    id: string;
-    description: string;
-    /** Needs a real LLM call — schedule nightly, not per-PR. */
-    requiresLLM: boolean;
-    /**
-     * Fields that MUST be non-null on a passing record of this journey.
-     * A "passing" record missing one is an integrity violation, not a pass.
-     */
-    requiredFields: ReadonlyArray<string>;
-    /** Numeric floors, e.g. {field: 'event_count', min: 1} for streaming. */
-    minimums?: ReadonlyArray<{
-        field: string;
-        min: number;
-    }>;
-    /** Per-phase breakdown fields expected non-null (subset of requiredFields semantics, reported separately). */
-    phaseFields?: ReadonlyArray<string>;
-}
-interface ScenarioAxes {
-    /** e.g. driver: ['docker','firecracker'] — every key is a free-form dimension. */
-    [dimension: string]: ReadonlyArray<string>;
-}
-interface PerfScenario {
-    /** `${journeyId}|${dim1}=${v1}|${dim2}=${v2}` (dims sorted). */
-    key: string;
-    journey: JourneySpec;
-    axes: Record<string, string>;
-}
-/** Stable scenario key: journey id then `dim=value` pairs in sorted-dim order. */
-declare function scenarioKey(journeyId: string, axes: Record<string, string>): string;
-/** Cartesian expansion; `filter` lets callers drop invalid combos (e.g. firecracker×resume). */
-declare function expandMatrix(journeys: ReadonlyArray<JourneySpec>, axes: ScenarioAxes, filter?: (journeyId: string, combo: Record<string, string>) => boolean): PerfScenario[];
-
-/**
- * Record-integrity contracts for perf metric records.
- *
- * A record that claims `pass === true` must actually carry the journey's
- * required measurements — a "passing" provision run with a null
- * `total_ms` is a lying record, not a pass. Failed records are exempt:
- * a run that errored mid-flight legitimately has nulls.
- */
-
-interface IntegrityViolation {
-    recordIndex: number;
-    journeyId: string;
-    field: string;
-    reason: 'null-required-field' | 'below-minimum';
-    detail: string;
-}
-interface IntegrityResult {
-    succeeded: boolean;
-    violations: IntegrityViolation[];
-}
-/**
- * Validates flat metric records (Record<string, unknown> with a boolean
- * `pass` field) against their journey contract. Only records with
- * pass === true are checked — a failed record may legitimately have nulls.
- * resolveJourney maps a record to its JourneySpec (or null to skip).
- */
-declare function checkRecordIntegrity(records: ReadonlyArray<Record<string, unknown>>, resolveJourney: (record: Record<string, unknown>) => JourneySpec | null): IntegrityResult;
-/** Throws an Error listing every violation when the result fails. */
-declare function assertRecordIntegrity(records: ReadonlyArray<Record<string, unknown>>, resolveJourney: (record: Record<string, unknown>) => JourneySpec | null): void;
-
-/**
- * Percentile ratchet over perf metric records.
- *
- * `summarizeRecords` folds flat records into per-scenario p50/p90 stats;
- * `gatePerf` compares a current summary against a committed baseline and
- * trips on regressions beyond tolerance. Percentiles use nearest-rank on
- * sorted values. Null / non-numeric metric values are excluded from the
- * stat (n reflects only real samples); a field with zero samples is
- * omitted entirely — no fake zeros.
- */
-interface PerfStat {
-    p50: number;
-    p90: number;
-    n: number;
-}
-interface PerfBaseline {
-    version: 1;
-    /** key → metric field → stat. */
-    scenarios: Record<string, Record<string, PerfStat>>;
-}
-interface PerfRegression {
-    scenarioKey: string;
-    field: string;
-    baseline: PerfStat;
-    current: PerfStat;
-    /** percent over baseline p50 / p90, whichever tripped. */
-    overBy: {
-        p50Pct: number;
-        p90Pct: number;
-    };
-}
-interface PerfGateResult {
-    succeeded: boolean;
-    regressions: PerfRegression[];
-    /** Negative overBy: strictly better than baseline on both percentiles. */
-    improvements: PerfRegression[];
-    /** In baseline but absent (or under-sampled, n < minSamples) in current. */
-    missingScenarios: string[];
-    /** In records but absent from baseline. */
-    newScenarios: string[];
-}
-declare function summarizeRecords(records: ReadonlyArray<Record<string, unknown>>, keyOf: (record: Record<string, unknown>) => string | null, metricFields: ReadonlyArray<string>): PerfBaseline;
-declare function gatePerf(current: PerfBaseline, baseline: PerfBaseline, options?: {
-    tolerancePct?: number;
-    minSamples?: number;
-}): PerfGateResult;
-
-export { type IntegrityResult, type IntegrityViolation, type JourneySpec, type PerfBaseline, type PerfGateResult, type PerfRegression, type PerfScenario, type PerfStat, type ScenarioAxes, assertRecordIntegrity, checkRecordIntegrity, expandMatrix, gatePerf, scenarioKey, summarizeRecords };

package/dist/perf/index.js

@@ -1,18 +0,0 @@
-import {
-  assertRecordIntegrity,
-  checkRecordIntegrity,
-  expandMatrix,
-  gatePerf,
-  scenarioKey,
-  summarizeRecords
-} from "../chunk-STGVSCDH.js";
-import "../chunk-PZ5AY32C.js";
-export {
-  assertRecordIntegrity,
-  checkRecordIntegrity,
-  expandMatrix,
-  gatePerf,
-  scenarioKey,
-  summarizeRecords
-};
-//# sourceMappingURL=index.js.map

package/dist/perf/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}