@tangle-network/agent-eval 0.117.0 → 0.118.0

package/dist/off-policy-DiwuKKg7.d.ts

@@ -1,132 +0,0 @@
-/**
- * Off-policy evaluation primitives.
- *
- * Standard inverse-probability-weighted (IPS), self-normalized
- * importance-weighted (SNIPS), and doubly-robust (DR) estimators for the
- * value of a *target* policy given trajectories collected under a
- * *behavior* policy. This is the canonical RL eval task: "we have last
- * week's runs, we changed the policy — how would the new one do without
- * re-running?"
- *
- * The math here is textbook (Dudík, Langford, Li 2011 for DR; Swaminathan
- * & Joachims 2015 for SNIPS) but the *application* to LLM-agent
- * evaluation needs care:
- *
- *   - The "policy" is the (prompt, tool config, model snapshot) triple.
- *     Two policies have the same probability over an action *iff* their
- *     LLM call would emit the same token with the same probability —
- *     which is generally unknowable without the model log-probs.
- *   - For LLM agents, propensity scores must be supplied by the caller
- *     (logged in the trace, recovered from token log-probs, or estimated
- *     via a learned propensity model). We do NOT estimate propensity here.
- *   - Doubly-robust requires a Q-function (model-based reward predictor).
- *     We accept any callable; consumers pass either a tabular average,
- *     a regression fit, or a learned reward model.
- *
- * Bias / variance tradeoffs:
- *   - IPS: unbiased; high variance for small overlap, infinite variance
- *     when target has support outside behavior.
- *   - SNIPS: lower variance, slight bias; usually preferred in practice.
- *   - DR: doubly-robust — unbiased if either propensity OR Q-function is
- *     correct. Lowest practical variance when Q is decent. Use this.
- *
- * Caveat the panel will land: on the LLM-agent setting, propensity scores
- * recovered from token log-probs are noisy, the action space is enormous,
- * and overlap is often poor. These estimators are useful but not magic;
- * complement with `replayCampaign` (exact replay where the request hashes
- * match) for high-confidence answers and OPE for the gap.
- */
-interface OffPolicyTrajectory {
-    /** Stable id, for traceability through the dataset. */
-    runId: string;
-    /** Reward observed under the behavior policy (the realized outcome). */
-    reward: number;
-    /**
-     * Behavior-policy probability of the action that was taken. For LLM
-     * agents this is typically `exp(sum(token_log_probs))` over the chosen
-     * trajectory. Must be in (0, 1].
-     */
-    behaviorProb: number;
-    /**
-     * Target-policy probability of the same action. For replay-style
-     * counterfactual evaluation this is what the *new* policy would have
-     * assigned to the *old* trajectory. Must be in [0, 1].
-     */
-    targetProb: number;
-    /**
-     * Optional model-based reward prediction at the same context. Used by
-     * `doublyRobust`. Set to `null` for IPS-only evaluation.
-     */
-    qHat?: number | null;
-}
-interface OffPolicyEstimate {
-    /** Estimated value of the target policy. */
-    value: number;
-    /** Standard error of the estimate. */
-    standardError: number;
-    /** Effective sample size (Kong 1992). Lower = more reliance on a few high-weight samples. */
-    effectiveSampleSize: number;
-    /** Number of trajectories used. */
-    n: number;
-    /**
-     * Diagnostic: maximum importance weight observed. Large values (>>10x
-     * mean) are a red flag — variance is dominated by a few outliers.
-     */
-    maxImportanceWeight: number;
-}
-interface OffPolicyOptions {
-    /**
-     * Cap importance weights at this value (Ionides 2008 truncated IS) to
-     * trade unbiasedness for variance reduction. Default `Infinity` (no cap).
-     * Set e.g. `10` for stable estimates when the policies are close.
-     */
-    weightCap?: number;
-    /** Reward clipping range. Default `[0, 1]`. */
-    rewardClip?: {
-        low: number;
-        high: number;
-    };
-}
-/**
- * Inverse Probability Weighting (Horvitz-Thompson). Unbiased estimator
- * of E[reward under target policy]. Variance scales with the spread of
- * target/behavior ratios.
- */
-declare function inverseProbabilityWeighting(trajectories: OffPolicyTrajectory[], opts?: OffPolicyOptions): OffPolicyEstimate;
-/**
- * Self-Normalized Importance Sampling. Lower variance than vanilla IPS at
- * the cost of small bias (vanishing as N grows). The right default for
- * LLM-agent evaluation where overlap is often poor.
- */
-declare function selfNormalizedImportanceWeighting(trajectories: OffPolicyTrajectory[], opts?: OffPolicyOptions): OffPolicyEstimate;
-/**
- * Doubly-robust off-policy estimator (Dudík, Langford, Li 2011).
- *
- *     V_DR = (1/N) * sum_i [ q_hat_i + (target_prob_i / behavior_prob_i) * (r_i - q_hat_i) ]
- *
- * Unbiased if EITHER:
- *   - the importance ratios are correct (IPS-style validity), OR
- *   - the Q-hat function is correct (model-based validity).
- *
- * In practice both are imperfect, but the residual bias is the *product*
- * of both errors — much smaller than either alone. This is why DR is the
- * default in production OPE pipelines.
- *
- * Requires `qHat` on every trajectory. If any are `null`, the estimator
- * falls back to SNIPS for those entries (loud-fallback behavior; the
- * report's `n` reflects the full set but `effectiveSampleSize` accounts
- * for the lost variance reduction).
- */
-declare function doublyRobust(trajectories: OffPolicyTrajectory[], opts?: OffPolicyOptions): OffPolicyEstimate;
-/**
- * Convenience: run all three estimators and return them side-by-side.
- * The recommended diagnostic — agreement across estimators is a much
- * stronger signal than any single one.
- */
-declare function offPolicyEstimateAll(trajectories: OffPolicyTrajectory[], opts?: OffPolicyOptions): {
-    ips: OffPolicyEstimate;
-    snips: OffPolicyEstimate;
-    dr: OffPolicyEstimate;
-};
-
-export { type OffPolicyEstimate as O, type OffPolicyOptions as a, type OffPolicyTrajectory as b, doublyRobust as d, inverseProbabilityWeighting as i, offPolicyEstimateAll as o, selfNormalizedImportanceWeighting as s };

package/dist/outcome-store-rnXLEqSn.d.ts

@@ -1,63 +0,0 @@
-/**
- * OutcomeStore — deployment outcomes attached to Run IDs.
- *
- * Outcomes arrive asynchronously from production telemetry after the
- * eval run completed: user ratings, retention flags, conversion events,
- * revenue, support-ticket rate, anything a product team can measure.
- * The store is a peer to TraceStore — separate lifecycle, same runId
- * foreign key.
- *
- * The whole point of this module is to make the meta-eval correlation
- * question computable: `correlate(evalMetric, outcomeMetric) → r, ρ, n, CI`.
- */
-interface DeploymentOutcome {
-    runId: string;
-    capturedAt: number;
-    /** Numeric outcomes keyed by name — retention_7d, csat, revenue_usd, etc. */
-    metrics: Record<string, number>;
-    /** Dimensions for stratified analysis — cohort, region, user_segment. */
-    labels?: Record<string, string>;
-    /** Free-form provenance (source system, pipeline version). */
-    source?: string;
-}
-interface OutcomeFilter {
-    runIds?: string[];
-    since?: number;
-    until?: number;
-    label?: {
-        key: string;
-        value: string;
-    };
-    source?: string;
-}
-interface OutcomeStore {
-    append(outcome: DeploymentOutcome): Promise<void>;
-    /** All outcomes attached to this run (a single run can have many — multiple
-     *  capture windows over deployment time). */
-    forRun(runId: string): Promise<DeploymentOutcome[]>;
-    list(filter?: OutcomeFilter): Promise<DeploymentOutcome[]>;
-}
-declare class InMemoryOutcomeStore implements OutcomeStore {
-    private items;
-    append(outcome: DeploymentOutcome): Promise<void>;
-    forRun(runId: string): Promise<DeploymentOutcome[]>;
-    list(filter?: OutcomeFilter): Promise<DeploymentOutcome[]>;
-}
-interface FileSystemOutcomeStoreOptions {
-    dir: string;
-    maxBytes?: number;
-}
-declare class FileSystemOutcomeStore implements OutcomeStore {
-    private dir;
-    private maxBytes;
-    private memo?;
-    private loaded;
-    constructor(options: FileSystemOutcomeStoreOptions);
-    private ensureDir;
-    append(outcome: DeploymentOutcome): Promise<void>;
-    private load;
-    forRun(runId: string): Promise<DeploymentOutcome[]>;
-    list(filter?: OutcomeFilter): Promise<DeploymentOutcome[]>;
-}
-
-export { type DeploymentOutcome as D, FileSystemOutcomeStore as F, InMemoryOutcomeStore as I, type OutcomeFilter as O, type FileSystemOutcomeStoreOptions as a, type OutcomeStore as b };

package/dist/policy-edit-wG9uFEFm.d.ts

@@ -1,455 +0,0 @@
-import { R as RunRecord, A as AgentProfileCell, f as AgentProfileJson } from './run-record-BDH49H2E.js';
-import { V as ValidationError } from './errors-oeQrLqXC.js';
-import { T as TraceAnalysisStore } from './store-C1YxJDEK.js';
-import { a as JudgeInput } from './types-BkfcQnxV.js';
-import { c as LlmCallRequest, d as LlmCallResult } from './llm-client-qoDd18Qz.js';
-
-/**
- * ChatClient — the single LLM abstraction analysts call.
- *
- * agent-eval already ships an `LlmClient` (OpenAI-compatible, retry,
- * graceful JSON-schema degrade) and judges that talk to `TCloud`. Two
- * mixed patterns force every analyst author to pick a transport, which
- * couples analyst code to runtime concerns (cli-bridge vs router vs
- * sandbox-sdk) it shouldn't know about.
- *
- * `ChatClient` is one interface every analyst takes via `AnalystContext.chat`.
- * The operator decides at the registry boundary which transport binds
- * to it. Analyst code stays transport-agnostic; swapping production
- * (sandbox-sdk) for local dev (cli-bridge) or tests (mock) is a one-
- * line factory call.
- *
- * Designed to coexist: existing `LlmClient` callers and existing
- * `TCloud`-based judges keep working untouched. New analyst code uses
- * `ChatClient`. When old call sites migrate, they pick up budgeting,
- * cancellation, and unified telemetry for free.
- */
-
-/**
- * Unified chat interface. Mirrors LlmCallRequest/Result so the OpenAI-
- * compatible mental model stays. Two methods: a one-shot `chat()` and
- * an `streamChat()` for future agentic loops (not yet exposed).
- */
-interface ChatClient {
-    /** Display name of the bound transport — included in telemetry. */
-    readonly transport: ChatTransport;
-    /** Default model when caller omits — operators bind this per environment. */
-    readonly defaultModel?: string;
-    /** Total provider attempts this transport can make for one chat call. */
-    readonly maximumAttempts?: number;
-    /** Implementations must enforce `req.maxTokens` when it is present. */
-    chat(req: ChatRequest, opts?: ChatCallOpts): Promise<ChatResponse>;
-}
-type ChatTransport = 'router' | 'sandbox-sdk' | 'cli-bridge' | 'direct-provider' | 'mock';
-interface ChatRequest extends Omit<LlmCallRequest, 'model'> {
-    /** Optional — falls back to ChatClient.defaultModel. */
-    model?: string;
-}
-type ChatResponse = LlmCallResult;
-interface ChatCallOpts {
-    /** Cancel the in-flight request. */
-    signal?: AbortSignal;
-    /** Hard USD ceiling for this single call (informational; the underlying transport may not enforce). */
-    maxCostUsd?: number;
-    /** Correlation tag carried into request headers when the transport allows. */
-    correlationId?: string;
-    /** Stable provider idempotency key for retries/redrives of one paid call. */
-    idempotencyKey?: string;
-}
-type CreateChatClientOpts = RouterTransportOpts | CliBridgeTransportOpts | DirectProviderTransportOpts | SandboxSdkTransportOpts | MockTransportOpts;
-interface BaseTransportOpts {
-    defaultModel?: string;
-    /** Total provider attempts. Required for opaque transports used in capped runs. */
-    maximumAttempts?: number;
-}
-interface RouterTransportOpts extends BaseTransportOpts {
-    transport: 'router';
-    baseUrl?: string;
-    apiKey: string;
-}
-interface CliBridgeTransportOpts extends BaseTransportOpts {
-    transport: 'cli-bridge';
-    baseUrl?: string;
-    bearer?: string;
-}
-interface DirectProviderTransportOpts extends BaseTransportOpts {
-    transport: 'direct-provider';
-    baseUrl: string;
-    apiKey: string;
-}
-/**
- * Sandbox-SDK transport. Provided as a thin pass-through: the caller
- * supplies a callable that mimics LlmClient.chat() against an already-
- * configured Sandbox handle. We don't import the SDK here to keep
- * agent-eval dep-free of @tangle-network/sandbox.
- */
-interface SandboxSdkTransportOpts extends BaseTransportOpts {
-    transport: 'sandbox-sdk';
-    chat: (req: ChatRequest, opts?: ChatCallOpts) => Promise<ChatResponse>;
-}
-/**
- * Mock transport for tests. The handler receives the request and returns
- * whatever the test wants. No retries, no JSON-schema degrade.
- */
-interface MockTransportOpts extends BaseTransportOpts {
-    transport: 'mock';
-    handler: (req: ChatRequest, opts?: ChatCallOpts) => Promise<ChatResponse>;
-}
-/**
- * Build a ChatClient bound to a specific transport. The returned client
- * is safe to share across analysts in a single registry run.
- */
-declare function createChatClient(opts: CreateChatClientOpts): ChatClient;
-
-/**
- * Analyst contract — the missing orchestration layer over agent-eval's
- * existing analyzers (analyzeTraces, MultiLayerVerifier, RunCritic,
- * SemanticConceptJudge, JudgeFn, ...).
- *
- * Each existing primitive returns its own output shape. The Analyst
- * contract is the single envelope every primitive lifts into, so a
- * registry can run N analysts against a run and a single renderer can
- * compose findings without knowing which analyzer produced them.
- *
- * The contract is intentionally domain-agnostic: nothing here knows
- * about code, voice, RAG, or any particular agent stack. Analysts
- * declare what INPUT KIND they need (a trace store, an artifact dir,
- * a RunRecord, a JudgeInput, or `custom`), and the registry routes
- * the matching input from `AnalystRunInputs`.
- */
-
-/**
- * Unified envelope every analyst emits. Schema-versioned so renderers
- * and time-series diffs survive future field additions.
- */
-interface AnalystFinding {
-    schema_version: '1.0.0';
-    /**
-     * Stable hash over identity-defining fields (analyst_id + canonical
-     * claim + area + optional subject). Two findings from two runs that
-     * "are the same finding" share this id — that's what `diffFindings`
-     * uses to compute appeared/disappeared sets across runs.
-     */
-    finding_id: string;
-    analyst_id: string;
-    produced_at: string;
-    severity: AnalystSeverity;
-    /**
-     * Coarse classification. Renderers group by this. Free-form so
-     * domain-specific analysts can introduce categories without a
-     * schema change ('agent-reasoning', 'verification', 'cost',
-     * 'tool-use', 'safety', 'latency', 'data-quality', ...).
-     */
-    area: string;
-    claim: string;
-    rationale?: string;
-    evidence_refs: EvidenceRef[];
-    recommended_action?: string;
-    validation_plan?: string;
-    /** 0..1 — the analyst's own confidence. Not calibrated across analysts. */
-    confidence: number;
-    /**
-     * Optional subject the finding is about — leaf id, agent id, request
-     * id. Included in finding_id when present so per-subject findings
-     * diff cleanly across runs.
-     */
-    subject?: string;
-    /** FIREWALL provenance (docs/learning-flywheel.md): true iff this finding was
-     *  lifted from a JUDGE verdict (an acceptance score), not OBSERVED from the
-     *  agent's behavior. A judge-derived finding must NEVER be admitted as a
-     *  steering input — that is the held-out judge leaking into the loop. Set at
-     *  the lift site (createJudgeAdapter); checked by `assertNoJudgeVerdict`.
-     *  Provenance, not evidence presence, is the correct discriminator: an
-     *  evidence-less trace-analyst observation legitimately steers, while a judge
-     *  verdict that happens to cite an artifact must not. */
-    derived_from_judge?: boolean;
-    /** Analyst-private extras; renderers ignore unless they know the analyst. */
-    metadata?: Record<string, unknown>;
-}
-type AnalystSeverity = 'critical' | 'high' | 'medium' | 'low' | 'info';
-interface EvidenceRef {
-    /**
-     * Where the evidence lives. `span` and `event` refer to OTLP trace
-     * elements; `artifact` to a file inside the run's artifact tree;
-     * `finding` to another AnalystFinding (cross-analyst chaining);
-     * `metric` to a named scalar reading the renderer knows how to read.
-     */
-    kind: 'span' | 'event' | 'artifact' | 'finding' | 'metric';
-    uri: string;
-    excerpt?: string;
-}
-/**
- * The discriminator the registry uses to pass the right input.
- * `custom` is the escape hatch — analysts that need something else
- * (e.g. an embedding cache, a partner SDK handle) read it from
- * `AnalystRunInputs.custom[<analyst id>]`.
- */
-type AnalystInputKind = 'trace-store' | 'artifact-dir' | 'run-record' | 'judge-input' | 'custom';
-interface AnalystCost {
-    /** `deterministic` analysts MUST NOT call the LLM. */
-    kind: 'deterministic' | 'llm';
-    /** Optional declared upper bound; the registry can enforce a budget. */
-    est_usd_per_run?: number;
-    /** Models the analyst expects to use (informational). */
-    models?: string[];
-}
-interface AnalystRequirements {
-    /** Min number of shots / samples the analyst needs to produce signal. */
-    min_shots?: number;
-    /** Capabilities the runtime must supply (e.g. ['network', 'gpu']). */
-    capabilities?: string[];
-}
-/**
- * What's passed to every analyst call. The registry resolves which
- * field the analyst's `inputKind` selects and asserts it's present.
- */
-interface AnalystRunInputs {
-    traceStore?: TraceAnalysisStore;
-    artifactDir?: string;
-    runRecord?: RunRecord;
-    judgeInput?: JudgeInput;
-    /** Keyed by analyst id; populated by callers that registered custom analysts. */
-    custom?: Record<string, unknown>;
-}
-interface AnalystContext {
-    runId: string;
-    /** Stable correlation id so logs from a single registry.run() share a tag. */
-    correlationId: string;
-    /** Wall-clock deadline (epoch ms). Analysts SHOULD honor for graceful cancel. */
-    deadlineMs?: number;
-    /** Per-analyst USD budget. Analysts MAY check before issuing LLM calls. */
-    budgetUsd?: number;
-    /**
-     * Shared chat client. Analysts that call an LLM go through this so
-     * the operator picks transport (sandbox-sdk | router | cli-bridge |
-     * direct-provider | mock) at the registry boundary without touching
-     * analyst code.
-     */
-    chat?: ChatClient;
-    /**
-     * Findings from a prior run the operator wants the analyst to see as
-     * retrieval context. Kinds that take advantage of cross-run memory
-     * (failure-mode "I saw this cluster last run", knowledge-gap "the wiki
-     * page I asked for is still missing") render these into the actor's
-     * working set. Filtering is the operator's job: pass the slice that
-     * matches the analyst's id, or pass everything and let the kind
-     * filter. Empty / absent means no cross-run context.
-     */
-    priorFindings?: ReadonlyArray<AnalystFinding>;
-    /** Free-form runtime tags (env, host, op). Findings can echo these into metadata. */
-    tags?: Record<string, string>;
-    /** Logger callback — analysts SHOULD prefer this over console.* for testability. */
-    log?: (msg: string, fields?: Record<string, unknown>) => void;
-    /** Optional abort signal. Analysts SHOULD pass it through to LLM calls. */
-    signal?: AbortSignal;
-}
-/**
- * The minimal contract. Concrete analysts can refine `TInput` so
- * implementations stay type-safe (e.g. a trace analyst's `TInput` is
- * `TraceAnalysisStore`); the registry passes the right field from
- * `AnalystRunInputs` based on `inputKind`.
- */
-interface Analyst<TInput = unknown> {
-    /** Stable identifier — appears in finding_id, telemetry, and registry exclusion lists. */
-    readonly id: string;
-    /** Human-readable. One sentence. */
-    readonly description: string;
-    readonly inputKind: AnalystInputKind;
-    readonly cost: AnalystCost;
-    readonly requires?: AnalystRequirements;
-    /** Bump on breaking changes to claim wording or area so old finding_ids don't collide. */
-    readonly version: string;
-    analyze(input: TInput, ctx: AnalystContext): Promise<AnalystFinding[]>;
-}
-/**
- * Compute the stable finding_id from the identity-defining fields.
- * Default implementation hashes {analyst_id, area, subject, normalized claim}.
- * Analysts that emit findings whose claim text varies per run (timestamps,
- * counts) SHOULD either: (a) pass an explicit `id_basis` to fix the hash,
- * or (b) move the variable part into `rationale`/`metadata` and keep the
- * `claim` static.
- */
-declare function computeFindingId(input: {
-    analyst_id: string;
-    area: string;
-    subject?: string;
-    claim: string;
-    /** Override the claim for hashing — use when the displayed claim has run-specific bits. */
-    id_basis?: string;
-}): string;
-/**
- * Convenience factory: produce a fully-formed AnalystFinding with the
- * id computed automatically. Analyst code stays terse.
- */
-declare function makeFinding(init: Omit<AnalystFinding, 'schema_version' | 'finding_id' | 'produced_at'> & {
-    id_basis?: string;
-    produced_at?: string;
-}): AnalystFinding;
-interface AnalystRunSummary {
-    analyst_id: string;
-    status: 'ok' | 'skipped' | 'failed';
-    /** Why skipped — missing input, budget exceeded, capability unmet. */
-    reason?: string;
-    findings_count: number;
-    latency_ms: number;
-    cost_usd: number;
-    /** When `status='failed'`: the error class + message, never the full stack. */
-    error?: {
-        class: string;
-        message: string;
-    };
-}
-interface AnalystRunResult {
-    run_id: string;
-    correlation_id: string;
-    started_at: string;
-    ended_at: string;
-    findings: AnalystFinding[];
-    per_analyst: AnalystRunSummary[];
-    /** Total LLM cost in USD across all analysts in this registry.run(). */
-    total_cost_usd: number;
-}
-/**
- * Events emitted by `AnalystRegistry.runStream(...)` in real time as
- * the registry executes. UIs subscribe via `for await (const ev of
- * registry.runStream(...))`; `registry.run(...)` is a thin collector
- * over the same stream, so the two surfaces share their invariants.
- *
- * Per-finding events are intentionally omitted — analyzers are batch
- * operations (an Ax actor returns the full `findings:json[]` at the
- * end of the responder), so streaming inside one analyst would only
- * emit partial JSON consumers can't render. The kind-completion event
- * is the right granularity; subscribers wanting per-finding rendering
- * iterate `event.findings` themselves.
- */
-type AnalystRunEvent = {
-    type: 'run-started';
-    run_id: string;
-    correlation_id: string;
-    started_at: string;
-    /** The ordered list of analyst ids the registry will run. */
-    analyst_ids: ReadonlyArray<string>;
-} | {
-    type: 'analyst-skipped';
-    summary: AnalystRunSummary;
-} | {
-    type: 'analyst-started';
-    analyst_id: string;
-    started_at: string;
-} | {
-    type: 'analyst-completed';
-    /** `summary.status` is `'ok'` for clean completion or `'failed'` for thrown analysts. */
-    summary: AnalystRunSummary;
-    findings: ReadonlyArray<AnalystFinding>;
-} | {
-    type: 'run-completed';
-    result: AnalystRunResult;
-};
-
-type PolicyEditSchemaVersion = 'policy-edit/v1';
-declare const POLICY_EDIT_AXES: readonly ["carrier", "representation", "budget", "sampling", "output_contract", "tool_contract", "routing", "memory", "agent_profile", "deployment_target"];
-type PolicyEditAxis = (typeof POLICY_EDIT_AXES)[number];
-declare const POLICY_EDIT_TARGET_SURFACES: readonly ["prompt", "tool-contract", "runtime-config", "memory", "agent-profile", "code", "deployment"];
-type PolicyEditTargetSurface = (typeof POLICY_EDIT_TARGET_SURFACES)[number];
-type PolicyEditRisk = 'low' | 'medium' | 'high' | 'unknown';
-type PolicyEditGainDirection = 'increase' | 'decrease';
-type PolicyEditGainUnit = 'absolute' | 'relative' | 'percent' | 'score';
-interface PolicyEditTarget {
-    surface: PolicyEditTargetSurface;
-    /** Stable path inside the target surface, for example `system-prompt:tools`
-     * or `budget.maxTurns`. */
-    path?: string;
-    /** Optional canonical deployment identity. Store the existing cell, not a
-     * local profile shape. */
-    agentProfileCell?: AgentProfileCell;
-    /** Human label when the path is not enough for a readable audit trail. */
-    label?: string;
-}
-type PolicyEditChange = {
-    kind: 'text';
-    mode: 'append' | 'prepend' | 'replace';
-    value: string;
-    /** Required when `mode === 'replace'`; exact match only. */
-    find?: string;
-} | {
-    kind: 'json';
-    mode: 'set' | 'merge' | 'remove';
-    path: string;
-    value?: AgentProfileJson;
-};
-interface PolicyEditExpectedGain {
-    /** Metric this edit is expected to move, e.g. `holdout.composite`. */
-    metric: string;
-    direction: PolicyEditGainDirection;
-    /** Positive magnitude in the metric's native units. */
-    amount: number;
-    unit?: PolicyEditGainUnit;
-    rationale?: string;
-}
-interface PolicyEditSource {
-    findingIds: string[];
-    analystIds: string[];
-    evidenceRefs: EvidenceRef[];
-    /** Mirrors `AnalystFinding.derived_from_judge`; admission rejects it. */
-    derivedFromJudge?: boolean;
-}
-interface PolicyEdit {
-    schemaVersion: PolicyEditSchemaVersion;
-    editId: string;
-    axis: PolicyEditAxis;
-    target: PolicyEditTarget;
-    change: PolicyEditChange;
-    claim: string;
-    expectedGain: PolicyEditExpectedGain;
-    confidence: number;
-    risk: PolicyEditRisk;
-    source: PolicyEditSource;
-    rationale?: string;
-    validationPlan?: string;
-    metadata?: Record<string, unknown>;
-}
-declare const POLICY_EDIT_CANDIDATE_RECORD_SCHEMA: "tangle.policy-edit-candidate.v1";
-/** JSON-safe attribution carried with a measured candidate and its scores. */
-interface PolicyEditCandidateRecord {
-    schema: typeof POLICY_EDIT_CANDIDATE_RECORD_SCHEMA;
-    policyEdit: PolicyEdit;
-}
-type PolicyEditInit = Omit<PolicyEdit, 'schemaVersion' | 'editId'> & {
-    schemaVersion?: PolicyEditSchemaVersion;
-    editId?: string;
-};
-declare class PolicyEditValidationError extends ValidationError {
-    readonly path: string;
-    constructor(message: string, path?: string);
-}
-interface FindingToPolicyEditOptions {
-    expectedGain?: PolicyEditExpectedGain | ((finding: AnalystFinding) => PolicyEditExpectedGain | null | undefined);
-    risk?: PolicyEditRisk | ((finding: AnalystFinding) => PolicyEditRisk);
-    defaultAxis?: PolicyEditAxis;
-    defaultTargetSurface?: PolicyEditTargetSurface;
-}
-interface PolicyEditAdmissionOptions {
-    minScore?: number;
-    minExpectedGain?: number;
-    allowHighRisk?: boolean;
-    requireEvidence?: boolean;
-}
-interface PolicyEditAdmission {
-    edit: PolicyEdit;
-    decision: 'admit' | 'reject';
-    score: number;
-    reasons: string[];
-}
-declare function makePolicyEdit(init: PolicyEditInit): PolicyEdit;
-declare function computePolicyEditId(edit: Omit<PolicyEdit, 'editId'> | PolicyEdit): string;
-declare function validatePolicyEdit(input: unknown): PolicyEdit;
-declare function makePolicyEditCandidateRecord(edit: PolicyEdit): PolicyEditCandidateRecord;
-declare function validatePolicyEditCandidateRecord(input: unknown): PolicyEditCandidateRecord;
-declare function isPolicyEdit(input: unknown): input is PolicyEdit;
-declare function policyEditsFromFindings(findings: ReadonlyArray<AnalystFinding>, opts?: FindingToPolicyEditOptions): PolicyEdit[];
-declare function policyEditFromFinding(finding: AnalystFinding, opts?: FindingToPolicyEditOptions): PolicyEdit | null;
-declare function scorePolicyEditReadiness(edit: PolicyEdit, opts?: PolicyEditAdmissionOptions): number;
-declare function admitPolicyEdit(edit: PolicyEdit, opts?: PolicyEditAdmissionOptions): PolicyEditAdmission;
-declare function applyPolicyEditToSurface(surface: unknown, edit: PolicyEdit): unknown;
-
-export { policyEditsFromFindings as $, type Analyst as A, type PolicyEditGainUnit as B, type ChatClient as C, type DirectProviderTransportOpts as D, type EvidenceRef as E, type FindingToPolicyEditOptions as F, type PolicyEditInit as G, type PolicyEditRisk as H, type PolicyEditSchemaVersion as I, type PolicyEditSource as J, type PolicyEditTarget as K, type PolicyEditTargetSurface as L, type MockTransportOpts as M, PolicyEditValidationError as N, admitPolicyEdit as O, type PolicyEditCandidateRecord as P, applyPolicyEditToSurface as Q, type RouterTransportOpts as R, type SandboxSdkTransportOpts as S, computeFindingId as T, computePolicyEditId as U, createChatClient as V, isPolicyEdit as W, makeFinding as X, makePolicyEdit as Y, makePolicyEditCandidateRecord as Z, policyEditFromFinding as _, type AnalystContext as a, scorePolicyEditReadiness as a0, validatePolicyEdit as a1, validatePolicyEditCandidateRecord as a2, type AnalystRunSummary as b, type AnalystFinding as c, type AnalystRunResult as d, type AnalystRunInputs as e, type AnalystRunEvent as f, type AnalystCost as g, type AnalystSeverity as h, type AnalystInputKind as i, type AnalystRequirements as j, type ChatCallOpts as k, type ChatRequest as l, type ChatResponse as m, type ChatTransport as n, type CliBridgeTransportOpts as o, type CreateChatClientOpts as p, POLICY_EDIT_AXES as q, POLICY_EDIT_CANDIDATE_RECORD_SCHEMA as r, POLICY_EDIT_TARGET_SURFACES as s, type PolicyEdit as t, type PolicyEditAdmission as u, type PolicyEditAdmissionOptions as v, type PolicyEditAxis as w, type PolicyEditChange as x, type PolicyEditExpectedGain as y, type PolicyEditGainDirection as z };