@tangle-network/agent-eval 0.109.1 → 0.110.0

package/dist/{default-registry-BswHCXnU.d.ts → default-registry-Bcf1uKVI.d.ts}

@@ -1,6 +1,5 @@
 import { AxAIService } from '@ax-llm/ax';
-import { T as TraceAnalystKindSpec } from './kind-factory-DvIGo_cP.js';
-import { a as Analyst, b as AnalystContext, c as AnalystRunSummary, A as AnalystFinding, d as AnalystRunResult, C as ChatClient, e as AnalystRunInputs, f as AnalystRunEvent } from './types-D1ytG0Yg.js';
+import { a as Analyst, b as AnalystContext, c as AnalystRunSummary, A as AnalystFinding, d as AnalystRunResult, C as ChatClient, e as AnalystRunInputs, f as AnalystRunEvent, T as TraceAnalystKindSpec } from './kind-factory-20hcaYpf.js';
 
 /**
  * AnalystRegistry — orchestrate N analysts against one run.

package/dist/{emitter-C2rqGH_l.d.ts → emitter-BRchAAAx.d.ts}

@@ -1,5 +1,5 @@
-import { b as RunOutcome, R as Run, S as Span, c as SpanKind, L as LlmSpan, T as ToolSpan, d as RetrievalSpan, J as JudgeSpan, e as SandboxSpan, E as EventKind, a as TraceEvent, B as BudgetLedgerEntry, A as Artifact, M as Message } from './schema-m0gsnbt3.js';
-import { T as TraceStore } from './store-BcFXE6LG.js';
+import { a as RunOutcome, R as Run, S as Span, b as SpanKind, L as LlmSpan, T as ToolSpan, c as RetrievalSpan, J as JudgeSpan, d as SandboxSpan, E as EventKind, e as TraceEvent, B as BudgetLedgerEntry, A as Artifact, M as Message } from './schema-SGWcK9wa.js';
+import { T as TraceStore } from './store-BsVi7ncX.js';
 
 /**
  * TraceEmitter — hierarchical span builder that auto-parents using an

package/dist/{failure-cluster-DH9Flgcf.d.ts → failure-cluster-C48PiReX.d.ts}

@@ -1,5 +1,5 @@
-import { R as Run, S as Span, a as TraceEvent, F as FailureClass } from './schema-m0gsnbt3.js';
-import { T as TraceStore } from './store-BcFXE6LG.js';
+import { R as Run, S as Span, e as TraceEvent, F as FailureClass } from './schema-SGWcK9wa.js';
+import { T as TraceStore } from './store-BsVi7ncX.js';
 
 /**
  * Failure taxonomy — canonical classes + a default classifier.

package/dist/feedback-trajectory-pDcz1lQ1.d.ts

@@ -0,0 +1,348 @@
+import { T as TraceEmitter } from './emitter-BRchAAAx.js';
+import { F as FailureClass } from './schema-SGWcK9wa.js';
+import { T as TraceStore } from './store-BsVi7ncX.js';
+import { a as DatasetSplit, D as DatasetScenario } from './dataset-NENEzRgk.js';
+
+/**
+ * Policy-based agent control runtime.
+ *
+ * This is the minimal reusable loop behind driver-agent patterns:
+ *
+ *   observe state -> validate -> decide next action -> act -> observe -> ...
+ *
+ * It deliberately does not model named "topologies". Direct execution,
+ * critic/revise, driver intervention, specialist calls, and human escalation
+ * are all just actions chosen by the control policy.
+ */
+
+type ControlSeverity = 'info' | 'warning' | 'error' | 'critical';
+type ControlActionFailureMode = 'continue' | 'stop';
+interface ControlEvalResult {
+    /** Stable validator or judge id. */
+    id: string;
+    /** Whether this check passed. */
+    passed: boolean;
+    /** Optional normalized score. 1 = best, 0 = worst. */
+    score?: number;
+    /** Objective validators should usually be "error" or "critical" when failed. */
+    severity?: ControlSeverity;
+    /** Human-readable result. */
+    detail?: string;
+    /** Small evidence string or pointer. Avoid large payloads. */
+    evidence?: string;
+    /** True when the result came from deterministic state, not LLM judgment. */
+    objective?: boolean;
+    /** Structured details for downstream control policies and reports. */
+    metadata?: Record<string, unknown>;
+}
+interface ControlBudget {
+    maxSteps: number;
+    maxWallMs?: number;
+    maxCostUsd?: number;
+}
+interface ControlStopPolicies<TState, TAction> {
+    /**
+     * Stop after N consecutive steps with no state fingerprint change and
+     * less than `minScoreDelta` score movement. Disabled when omitted.
+     */
+    maxNoProgressSteps?: number;
+    /**
+     * Stop after the same action fingerprint is selected N consecutive
+     * times. Disabled when omitted.
+     */
+    maxRepeatedActions?: number;
+    /** Minimum score movement that counts as progress. Default 0.001. */
+    minScoreDelta?: number;
+    /** Override the default JSON/string fingerprint for state comparisons. */
+    stateFingerprint?: (state: TState) => string;
+    /** Override the default JSON/string fingerprint for repeated-action checks. */
+    actionFingerprint?: (action: TAction) => string;
+}
+interface ControlContext<TState, TAction, TActionResult, TEval extends ControlEvalResult = ControlEvalResult> {
+    intent: string;
+    state: TState;
+    evals: TEval[];
+    history: ControlStep<TState, TAction, TActionResult, TEval>[];
+    budget: ControlBudget;
+    stepIndex: number;
+    wallMs: number;
+    spentCostUsd: number;
+    remainingCostUsd?: number;
+    abortSignal: AbortSignal;
+    emitter?: TraceEmitter;
+}
+type ControlDecision<TAction> = {
+    type: 'continue';
+    action: TAction;
+    reason?: string;
+} | {
+    type: 'stop';
+    reason: string;
+    pass?: boolean;
+    score?: number;
+};
+interface StopDecision {
+    stop: boolean;
+    pass: boolean;
+    reason: string;
+    score?: number;
+    failureClass?: FailureClass;
+}
+interface ControlActionOutcome<TActionResult> {
+    ok: boolean;
+    result?: TActionResult;
+    error?: string;
+    costUsd?: number;
+    durationMs: number;
+}
+interface ControlRuntimeError {
+    phase: 'observe' | 'validate' | 'decide' | 'act' | 'stop-policy' | 'on-step' | 'trace';
+    stepIndex: number;
+    message: string;
+}
+interface ControlStep<TState, TAction, TActionResult, TEval extends ControlEvalResult = ControlEvalResult> {
+    index: number;
+    decision: ControlDecision<TAction>;
+    beforeState: TState;
+    afterState: TState;
+    evalsBefore: TEval[];
+    evalsAfter: TEval[];
+    actionOutcome?: ControlActionOutcome<TActionResult>;
+    startedAt: string;
+    endedAt: string;
+}
+interface ControlRunResult<TState, TAction, TActionResult, TEval extends ControlEvalResult = ControlEvalResult> {
+    intent: string;
+    pass: boolean;
+    completed: boolean;
+    reason: string;
+    score?: number;
+    steps: ControlStep<TState, TAction, TActionResult, TEval>[];
+    finalState: TState | undefined;
+    finalEvals: TEval[];
+    wallMs: number;
+    spentCostUsd: number;
+    /** null when the run executed without a TraceEmitter wired (no run record was persisted). */
+    runId: string | null;
+    failureClass?: FailureClass;
+    runtimeErrors: ControlRuntimeError[];
+    stoppedBy: 'policy' | 'stop-policy' | 'budget' | 'abort' | 'runtime-error';
+}
+interface ControlRuntimeConfig<TState, TAction, TActionResult, TEval extends ControlEvalResult = ControlEvalResult> {
+    intent: string;
+    budget?: Partial<ControlBudget>;
+    signal?: AbortSignal;
+    /** Defaults to `continue`: action failures are recorded, then the policy gets another chance. */
+    actionFailure?: ControlActionFailureMode;
+    /**
+     * Extract cost from an action result. Used for `maxCostUsd` budget
+     * enforcement and trace budget ledger emission.
+     */
+    getActionCostUsd?: (ctx: {
+        action: TAction;
+        result: TActionResult;
+        state: TState;
+        evals: TEval[];
+        history: ControlStep<TState, TAction, TActionResult, TEval>[];
+    }) => number | undefined;
+    /** Read typed task/product state. Prefer structured state over transcript-only context. */
+    observe: (ctx: {
+        history: ControlStep<TState, TAction, TActionResult, TEval>[];
+        abortSignal: AbortSignal;
+    }) => Promise<TState> | TState;
+    /** Objective validators first, subjective judges only where objective state is insufficient. */
+    validate: (ctx: {
+        intent: string;
+        state: TState;
+        history: ControlStep<TState, TAction, TActionResult, TEval>[];
+        abortSignal: AbortSignal;
+    }) => Promise<TEval[]> | TEval[];
+    /** Choose the next control action. Can call a worker, ask user, run critic, inspect state, or stop. */
+    decide: (ctx: ControlContext<TState, TAction, TActionResult, TEval>) => Promise<ControlDecision<TAction>> | ControlDecision<TAction>;
+    /** Execute the action selected by the policy. */
+    act: (action: TAction, ctx: ControlContext<TState, TAction, TActionResult, TEval>) => Promise<TActionResult> | TActionResult;
+    /** Final stopping policy. Called before decide and after each action. */
+    shouldStop?: (ctx: ControlContext<TState, TAction, TActionResult, TEval>) => Promise<StopDecision> | StopDecision;
+    /** Optional hook for tracing or live progress updates. */
+    onStep?: (step: ControlStep<TState, TAction, TActionResult, TEval>) => Promise<void> | void;
+    /** Optional generic stuck-loop policies. Custom `shouldStop` still runs first. */
+    stopPolicies?: ControlStopPolicies<TState, TAction>;
+    /** Optional trace sink. Emits one run plus one span per control step. */
+    store?: TraceStore;
+    scenarioId?: string;
+    projectId?: string;
+    variantId?: string;
+}
+declare function runAgentControlLoop<TState, TAction, TActionResult, TEval extends ControlEvalResult = ControlEvalResult>(config: ControlRuntimeConfig<TState, TAction, TActionResult, TEval>): Promise<ControlRunResult<TState, TAction, TActionResult, TEval>>;
+declare function stopOnNoProgress<TState, TAction>(maxNoProgressSteps: number, options?: Omit<ControlStopPolicies<TState, TAction>, 'maxNoProgressSteps'>): ControlStopPolicies<TState, TAction>;
+declare function stopOnRepeatedAction<TState, TAction>(maxRepeatedActions: number, options?: Omit<ControlStopPolicies<TState, TAction>, 'maxRepeatedActions'>): ControlStopPolicies<TState, TAction>;
+declare function objectiveEval(input: Omit<ControlEvalResult, 'objective'>): ControlEvalResult;
+declare function subjectiveEval(input: Omit<ControlEvalResult, 'objective'>): ControlEvalResult;
+declare function allCriticalPassed(evals: ControlEvalResult[]): boolean;
+
+type FeedbackArtifactType = 'text' | 'code' | 'plan' | 'research' | 'action' | 'ui' | 'decision' | 'data' | 'other';
+type FeedbackLabelSource = 'user' | 'judge' | 'environment' | 'metric' | 'policy' | 'system';
+type FeedbackLabelKind = 'approve' | 'reject' | 'select' | 'edit' | 'rank' | 'rate' | 'comment' | 'metric_outcome' | 'policy_block' | 'revision_request';
+type FeedbackSeverity = 'info' | 'warning' | 'error' | 'critical';
+interface FeedbackTask {
+    intent: string;
+    context?: unknown;
+}
+interface ProposedSideEffect {
+    type: string;
+    risk?: 'low' | 'medium' | 'high';
+    costUsd?: number;
+    externalSideEffect?: boolean;
+    requiresApproval?: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface FeedbackLabel {
+    id?: string;
+    source: FeedbackLabelSource;
+    kind: FeedbackLabelKind;
+    value: unknown;
+    reason?: string;
+    severity?: FeedbackSeverity;
+    createdAt: string;
+    metadata?: Record<string, unknown>;
+}
+interface FeedbackAttempt {
+    id: string;
+    stepIndex: number;
+    artifactType: FeedbackArtifactType;
+    artifact: unknown;
+    options?: unknown[];
+    proposedAction?: ProposedSideEffect;
+    evals?: ControlEvalResult[];
+    feedback?: FeedbackLabel[];
+    createdAt: string;
+    metadata?: Record<string, unknown>;
+}
+interface FeedbackOutcome {
+    success?: boolean;
+    score?: number;
+    metrics?: Record<string, number>;
+    costUsd?: number;
+    detail?: string;
+    observedAt?: string;
+    metadata?: Record<string, unknown>;
+}
+interface FeedbackTrajectory {
+    id: string;
+    projectId?: string;
+    scenarioId?: string;
+    task: FeedbackTask;
+    attempts: FeedbackAttempt[];
+    labels: FeedbackLabel[];
+    outcome?: FeedbackOutcome;
+    split?: DatasetSplit;
+    tags?: Record<string, string>;
+    createdAt: string;
+    updatedAt?: string;
+    metadata?: Record<string, unknown>;
+}
+interface FeedbackTrajectoryStore {
+    save(trajectory: FeedbackTrajectory): Promise<void>;
+    get(id: string): Promise<FeedbackTrajectory | null>;
+    list(filter?: FeedbackTrajectoryFilter): Promise<FeedbackTrajectory[]>;
+    appendAttempt(id: string, attempt: FeedbackAttempt): Promise<FeedbackTrajectory>;
+    appendLabel(id: string, label: FeedbackLabel, attemptId?: string): Promise<FeedbackTrajectory>;
+}
+interface FeedbackTrajectoryFilter {
+    projectId?: string;
+    scenarioId?: string;
+    split?: DatasetSplit;
+    tag?: [string, string];
+}
+interface FeedbackSplitPolicy {
+    trainPct?: number;
+    devPct?: number;
+    testPct?: number;
+    holdoutPct?: number;
+}
+interface PreferenceMemoryEntry {
+    instruction: string;
+    rationale: string;
+    weight: number;
+    sourceTrajectoryId: string;
+    sourceLabelId?: string;
+    category?: string;
+}
+interface FeedbackOptimizerRow {
+    scenarioId: string;
+    trajectoryId: string;
+    labelKinds: FeedbackLabelKind[];
+    score?: number;
+    metadata?: Record<string, unknown>;
+}
+interface FeedbackReplayResult {
+    trajectoryId: string;
+    pass: boolean;
+    score?: number;
+    labels: FeedbackLabel[];
+    outcome?: FeedbackOutcome;
+    metadata?: Record<string, unknown>;
+}
+interface FeedbackReplayAdapter {
+    replay(trajectory: FeedbackTrajectory): Promise<Omit<FeedbackReplayResult, 'trajectoryId'>> | Omit<FeedbackReplayResult, 'trajectoryId'>;
+}
+declare class InMemoryFeedbackTrajectoryStore implements FeedbackTrajectoryStore {
+    private readonly trajectories;
+    save(trajectory: FeedbackTrajectory): Promise<void>;
+    get(id: string): Promise<FeedbackTrajectory | null>;
+    list(filter?: FeedbackTrajectoryFilter): Promise<FeedbackTrajectory[]>;
+    appendAttempt(id: string, attempt: FeedbackAttempt): Promise<FeedbackTrajectory>;
+    appendLabel(id: string, label: FeedbackLabel, attemptId?: string): Promise<FeedbackTrajectory>;
+}
+declare class FileSystemFeedbackTrajectoryStore implements FeedbackTrajectoryStore {
+    private readonly dir;
+    private readonly memory;
+    private loaded;
+    constructor(options: {
+        dir: string;
+    });
+    save(trajectory: FeedbackTrajectory): Promise<void>;
+    get(id: string): Promise<FeedbackTrajectory | null>;
+    list(filter?: FeedbackTrajectoryFilter): Promise<FeedbackTrajectory[]>;
+    appendAttempt(id: string, attempt: FeedbackAttempt): Promise<FeedbackTrajectory>;
+    appendLabel(id: string, label: FeedbackLabel, attemptId?: string): Promise<FeedbackTrajectory>;
+    private append;
+    private load;
+}
+declare function createFeedbackTrajectory(input: {
+    id?: string;
+    projectId?: string;
+    scenarioId?: string;
+    task: FeedbackTask;
+    attempts?: FeedbackAttempt[];
+    labels?: FeedbackLabel[];
+    outcome?: FeedbackOutcome;
+    split?: DatasetSplit;
+    tags?: Record<string, string>;
+    createdAt?: string;
+    metadata?: Record<string, unknown>;
+}): FeedbackTrajectory;
+declare function assignFeedbackSplit(trajectory: Pick<FeedbackTrajectory, 'id' | 'projectId' | 'scenarioId' | 'task'>, policy?: FeedbackSplitPolicy): DatasetSplit;
+declare function withAssignedFeedbackSplit(trajectory: FeedbackTrajectory, policy?: FeedbackSplitPolicy): FeedbackTrajectory;
+declare function feedbackTrajectoryToDatasetScenario(trajectory: FeedbackTrajectory): DatasetScenario;
+declare function feedbackTrajectoriesToDatasetScenarios(trajectories: FeedbackTrajectory[]): DatasetScenario[];
+declare function feedbackTrajectoryToOptimizerRow(trajectory: FeedbackTrajectory): FeedbackOptimizerRow;
+declare function feedbackTrajectoriesToOptimizerRows(trajectories: FeedbackTrajectory[]): FeedbackOptimizerRow[];
+declare function replayFeedbackTrajectory(trajectory: FeedbackTrajectory, adapter: FeedbackReplayAdapter): Promise<FeedbackReplayResult>;
+declare function replayFeedbackTrajectories(trajectories: FeedbackTrajectory[], adapter: FeedbackReplayAdapter): Promise<FeedbackReplayResult[]>;
+declare function summarizePreferenceMemory(trajectories: FeedbackTrajectory[], options?: {
+    maxEntries?: number;
+}): PreferenceMemoryEntry[];
+declare function renderPreferenceMemoryMarkdown(entries: PreferenceMemoryEntry[]): string;
+declare function serializeFeedbackTrajectoriesJsonl(trajectories: FeedbackTrajectory[]): string;
+declare function parseFeedbackTrajectoriesJsonl(jsonl: string): FeedbackTrajectory[];
+declare function controlRunToFeedbackTrajectory<TState, TAction, TActionResult>(run: ControlRunResult<TState, TAction, TActionResult>, options?: {
+    projectId?: string;
+    scenarioId?: string;
+    artifactType?: FeedbackArtifactType;
+    artifactFromStep?: (step: ControlStep<TState, TAction, TActionResult>) => unknown;
+    proposedActionFromStep?: (step: ControlStep<TState, TAction, TActionResult>) => ProposedSideEffect | undefined;
+    createdAt?: string;
+}): FeedbackTrajectory;
+
+export { type ProposedSideEffect as A, allCriticalPassed as B, type ControlSeverity as C, assignFeedbackSplit as D, controlRunToFeedbackTrajectory as E, type FeedbackTrajectoryStore as F, createFeedbackTrajectory as G, feedbackTrajectoriesToDatasetScenarios as H, InMemoryFeedbackTrajectoryStore as I, feedbackTrajectoriesToOptimizerRows as J, feedbackTrajectoryToDatasetScenario as K, feedbackTrajectoryToOptimizerRow as L, objectiveEval as M, parseFeedbackTrajectoriesJsonl as N, renderPreferenceMemoryMarkdown as O, type PreferenceMemoryEntry as P, replayFeedbackTrajectories as Q, replayFeedbackTrajectory as R, type StopDecision as S, runAgentControlLoop as T, serializeFeedbackTrajectoriesJsonl as U, stopOnNoProgress as V, stopOnRepeatedAction as W, subjectiveEval as X, summarizePreferenceMemory as Y, withAssignedFeedbackSplit as Z, type ControlEvalResult as a, type FeedbackLabel as b, type FeedbackTrajectory as c, type ControlActionFailureMode as d, type ControlActionOutcome as e, type ControlBudget as f, type ControlContext as g, type ControlDecision as h, type ControlRunResult as i, type ControlRuntimeConfig as j, type ControlRuntimeError as k, type ControlStep as l, type ControlStopPolicies as m, type FeedbackArtifactType as n, type FeedbackAttempt as o, type FeedbackLabelKind as p, type FeedbackLabelSource as q, type FeedbackOptimizerRow as r, type FeedbackOutcome as s, type FeedbackReplayAdapter as t, type FeedbackReplayResult as u, type FeedbackSeverity as v, type FeedbackSplitPolicy as w, type FeedbackTask as x, type FeedbackTrajectoryFilter as y, FileSystemFeedbackTrajectoryStore as z };

package/dist/{gepa-B3x5Ulcv.d.ts → gepa-BUNP3606.d.ts}

@@ -1,7 +1,148 @@
-import { S as Scenario, C as CampaignResult, G as GateResult, D as DispatchFn, a as JudgeConfig, L as LabeledScenarioStore, c as CampaignTraceWriter, d as GenerationRecord, M as MutableSurface, P as ParetoParent, e as SurfaceProposer, f as Gate } from './types-BdIv5dvA.js';
+import { D as DatasetScenario, c as Dataset } from './dataset-NENEzRgk.js';
+import { T as TraceStore } from './store-BsVi7ncX.js';
+import { S as Scenario, C as CampaignResult, G as GateResult, c as DispatchFn, b as JudgeConfig, L as LabeledScenarioStore, d as CampaignTraceWriter, e as GenerationRecord, M as MutableSurface, P as ParetoParent, f as SurfaceProposer, g as Gate } from './types-v--ctu-b.js';
 import { C as CampaignStorage } from './storage-Dw_f7WMt.js';
 import { L as LlmClientOptions } from './llm-client-DyqEH4jH.js';
 
+/**
+ * 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;
+}>;
+
+/**
+ * Red-team battery — adversarial scenario corpus with per-category
+ * scorers.
+ *
+ * Every scenario is a `DatasetScenario` with a `redTeam: {...}` payload
+ * that declares: category, expected refusal, attack surface. Scorers
+ * inspect the agent's output + trajectory and return a PASS/FAIL per
+ * category. Aggregated via `redTeamReport`.
+ *
+ * The built-in corpus is intentionally conservative — 40 cases
+ * covering the most-seen attack patterns. Extend via `extendCorpus`.
+ */
+
+type RedTeamCategory = 'prompt_injection_direct' | 'prompt_injection_indirect' | 'jailbreak_persona' | 'jailbreak_dan' | 'pii_leak' | 'permission_escalation' | 'data_exfil' | 'policy_override';
+interface RedTeamPayload {
+    category: RedTeamCategory;
+    /** The hostile input the agent sees. */
+    input: string;
+    /**
+     * What a safe agent should do: "refuse" means explicit refusal,
+     * "ignore" means process benignly without executing the attack.
+     */
+    expected: 'refuse' | 'ignore';
+    /** Substring(s) that MUST NOT appear in output. */
+    forbiddenStrings?: string[];
+    /** Tool names the agent MUST NOT call for this scenario. */
+    forbiddenTools?: string[];
+}
+interface RedTeamCase extends DatasetScenario {
+    payload: RedTeamPayload;
+}
+interface RedTeamFinding {
+    scenarioId: string;
+    category: RedTeamCategory;
+    passed: boolean;
+    reason: string;
+    evidence?: string;
+}
+interface RedTeamReport {
+    findings: RedTeamFinding[];
+    passRateByCategory: Record<RedTeamCategory, number>;
+    overallPassRate: number;
+}
+/** Ship a canonical, small corpus. Consumers extend via `extendCorpus`. */
+declare const DEFAULT_RED_TEAM_CORPUS: RedTeamCase[];
+declare function redTeamDataset(extraCases?: RedTeamCase[]): Dataset;
+/**
+ * Score a single agent response against the red-team case.
+ * `toolCalls` should be the names of tools the agent invoked during the run.
+ */
+declare function scoreRedTeamOutput(output: string, toolCalls: string[], rtCase: RedTeamCase): RedTeamFinding;
+/** Aggregate red-team findings into per-category pass rates. */
+declare function redTeamReport(findings: RedTeamFinding[]): RedTeamReport;
+/**
+ * Extract the tool-call names from a corpus run — convenience for the
+ * common pipeline (run the scenario → score the run).
+ */
+declare function toolNamesForRun(store: TraceStore, runId: string): Promise<string[]>;
+
 /**
  * `openAutoPr` — thin shell-out helper for the `runImprovementLoop` preset's
  * `autoOnPromote: 'pr'` mode. Substitutes for the per-product PR-opening
@@ -448,4 +589,4 @@ declare function extractH2Sections(text: string): string[];
  *  whitespace as identical. Exported for tests + consumer-side validators. */
 declare function countSentenceEdits(baseline: string, candidate: string): number;
 
-export { type CampaignRunPlan as C, type GepaProposerOptions as G, type OpenAutoPrOptions as O, type PlanCampaignRunOptions as P, type RunOptimizationOptions as R, type RunImprovementLoopResult as a, type RunCampaignOptions as b, type RunImprovementLoopOptions as c, runImprovementLoop as d, type CampaignRunPlanCell as e, type GepaProposerConstraints as f, gepaProposer as g, type OpenAutoPrResult as h, type RunOptimizationResult as i, countSentenceEdits as j, defaultRenderDiff as k, extractH2Sections as l, runOptimization as m, openAutoPr as o, planCampaignRun as p, runCampaign as r, surfaceHash as s };
+export { dominates as A, paretoFrontier as B, type CampaignRunPlan as C, type Direction as D, paretoFrontierWithCrowding as E, redTeamDataset as F, type GepaProposerOptions as G, redTeamReport as H, scalarScore as I, scoreRedTeamOutput as J, toolNamesForRun as K, type OpenAutoPrOptions as O, type PlanCampaignRunOptions as P, type RunOptimizationOptions as R, type RunImprovementLoopResult as a, type RunCampaignOptions as b, type RunImprovementLoopOptions as c, runImprovementLoop as d, type RedTeamCase as e, type CampaignRunPlanCell as f, gepaProposer as g, type GepaProposerConstraints as h, type OpenAutoPrResult as i, type RunOptimizationResult as j, countSentenceEdits as k, defaultRenderDiff as l, extractH2Sections as m, runOptimization as n, openAutoPr as o, planCampaignRun as p, type Objective as q, runCampaign as r, surfaceHash as s, type ParetoResult as t, DEFAULT_RED_TEAM_CORPUS as u, type RedTeamCategory as v, type RedTeamFinding as w, type RedTeamPayload as x, type RedTeamReport as y, crowdingDistance as z };

package/dist/hosted/index.d.ts

@@ -1,12 +1,12 @@
-import { M as MutableSurface, h as GateDecision } from '../types-BdIv5dvA.js';
-import { I as InsightReport } from '../insight-report-B4xrdwEK.js';
-import '../run-record-I-Z3JNvO.js';
+import { M as MutableSurface, h as GateDecision } from '../types-v--ctu-b.js';
+import { I as InsightReport } from '../insight-report-D4cXFsLt.js';
+import '../run-record-DksGsfgv.js';
 import '@tangle-network/agent-interface';
 import '../errors-oeQrLqXC.js';
-import '../schema-m0gsnbt3.js';
-import '../summary-report-QMZVe3P-.js';
-import '../failure-cluster-DH9Flgcf.js';
-import '../store-BcFXE6LG.js';
+import '../schema-SGWcK9wa.js';
+import '../summary-report-Bz-0-t8v.js';
+import '../failure-cluster-C48PiReX.js';
+import '../store-BsVi7ncX.js';
 import '../judge-calibration-7C-IDmKr.js';
 
 /**

package/dist/{index-pPtfoIJO.d.ts → index-Dc3VLGhp.d.ts}

@@ -1,5 +1,5 @@
-import { S as Scenario, b as DispatchContext, C as CampaignResult } from './types-BdIv5dvA.js';
-import { b as RunSplitTag } from './run-record-I-Z3JNvO.js';
+import { S as Scenario, D as DispatchContext, C as CampaignResult } from './types-v--ctu-b.js';
+import { b as RunSplitTag } from './run-record-DksGsfgv.js';
 import { C as CampaignStorage } from './storage-Dw_f7WMt.js';
 
 /**