@tangle-network/agent-eval 0.95.0 → 0.96.0

package/dist/index.js

@@ -132,7 +132,7 @@ import {
 import {
   buildDefaultAnalystRegistry,
   computeTraceMetrics
-} from "./chunk-AQ5WQAIV.js";
+} from "./chunk-3NHEO6ZC.js";
 import {
   LockedJsonlAppender,
   Mutex

package/dist/{contract/insight-report.d.ts → insight-report-BnRjTibG.d.ts}

@@ -1,3 +1,6 @@
+import { G as GainDistributionBin, P as ParetoFigureSpec } from './summary-report-CInXwsza.js';
+import { C as ContinuousAgreement } from './judge-calibration-0p2QcWNE.js';
+
 /**
  * # InsightReport — the rigorous decision packet for any set of agent runs.
  *
@@ -27,9 +30,8 @@
  * Consumers read the `recommendations` array first — that's the
  * actionable layer, ranked by priority. The numeric sections back it up.
  */
-import type { GainDistributionBin, ParetoFigureSpec } from '../summary-report';
-import type { ContinuousAgreement } from './insight-types-fwd';
-export interface InsightReport {
+
+interface InsightReport {
     /** Number of runs analyzed. */
     n: number;
     /** Composite-score distribution across all runs. Always present. */
@@ -94,7 +96,7 @@ export interface InsightReport {
     recommendations: Recommendation[];
 }
 /** Distributional summary of a scalar-valued metric. */
-export interface ScalarDistribution {
+interface ScalarDistribution {
     /** Sample count after dropping non-finite values. */
     n: number;
     mean: number;
@@ -114,7 +116,7 @@ export interface ScalarDistribution {
         score: number;
     }>;
 }
-export interface JudgeInsight {
+interface JudgeInsight {
     /** Number of times this judge scored a run. */
     n: number;
     /** Mean composite over this judge's runs. */
@@ -132,7 +134,7 @@ export interface JudgeInsight {
      *  quality? */
     verbosityBias?: number;
 }
-export interface InterRaterInsight {
+interface InterRaterInsight {
     /** Number of raters whose scores were aggregated. */
     raters: number;
     /** Number of runs every rater scored. */
@@ -151,7 +153,7 @@ export interface InterRaterInsight {
         range: number;
     }>;
 }
-export interface LiftInsight {
+interface LiftInsight {
     baselineMean: number;
     candidateMean: number;
     /** Candidate − baseline. */
@@ -169,7 +171,7 @@ export interface LiftInsight {
     /** Sample size needed to detect the observed delta at 80% power. */
     requiredN: number;
 }
-export interface FailureClusterInsight {
+interface FailureClusterInsight {
     /** All clusters identified by the registry, ranked by share descending. */
     clusters: Array<{
         id: string;
@@ -188,7 +190,7 @@ export interface FailureClusterInsight {
  *  is computed directly from the tags the harness already recorded — so a
  *  customer ingesting one batch with no judge/analyst still learns which
  *  named failure dominates. */
-export interface FailureModeTally {
+interface FailureModeTally {
     /** The `failureMode` tag. */
     mode: string;
     /** Number of runs carrying this tag. */
@@ -196,7 +198,7 @@ export interface FailureModeTally {
     /** Share of the whole corpus, 0..1. */
     share: number;
 }
-export interface ContaminationInsight {
+interface ContaminationInsight {
     /** Canary phrases that leaked into outputs. */
     leaks: number;
     /** Holdout audit verdict — did any holdout-tagged run end up in the
@@ -208,7 +210,7 @@ export interface ContaminationInsight {
         matched: string;
     }>;
 }
-export interface OutcomeCorrelationInsight {
+interface OutcomeCorrelationInsight {
     /** What outcome the consumer is correlating against (e.g.
      *  `'engagement_rate'`, `'approval_rate'`, `'downstream_pass'`). */
     metric: string;
@@ -225,7 +227,7 @@ export interface OutcomeCorrelationInsight {
         r2: number;
     };
 }
-export interface ReleaseSummary {
+interface ReleaseSummary {
     /** Overall verdict across axes — fail if any axis fails, else warn if any
      *  warns, else pass. */
     status: 'pass' | 'warn' | 'fail';
@@ -238,7 +240,7 @@ export interface ReleaseSummary {
      *  consumers can post-process to populate. */
     issues: string[];
 }
-export interface MetricDelta {
+interface MetricDelta {
     /** Current-period mean. */
     current: number;
     /** Baseline-period mean. */
@@ -262,7 +264,7 @@ export interface MetricDelta {
      *  tiny from triggering recommendations. */
     significant: boolean;
 }
-export interface PriorPeriodComparison {
+interface PriorPeriodComparison {
     /** Sample counts. */
     baselineN: number;
     currentN: number;
@@ -278,7 +280,7 @@ export interface PriorPeriodComparison {
     /** Metric names where current is significantly BETTER than baseline. */
     improvedMetrics: string[];
 }
-export interface Recommendation {
+interface Recommendation {
     priority: 'critical' | 'high' | 'medium' | 'low';
     kind: 'ship' | 'hold' | 'investigate' | 'fix' | 'recalibrate' | 'expand-corpus';
     title: string;
@@ -286,4 +288,5 @@ export interface Recommendation {
     /** Optional pointer back into the report for the evidence. */
     evidencePath?: string;
 }
-//# sourceMappingURL=insight-report.d.ts.map
+
+export type { FailureClusterInsight as F, InsightReport as I, JudgeInsight as J, LiftInsight as L, OutcomeCorrelationInsight as O, Recommendation as R, ScalarDistribution as S, InterRaterInsight as a, ReleaseSummary as b };

package/dist/{trace/integrity.d.ts → integrity-D2t12mMw.d.ts}

@@ -1,3 +1,7 @@
+import { C as CaptureIntegrityError } from './errors-CzMUYo7b.js';
+import { R as RawProviderSink } from './raw-provider-sink-C46HDghv.js';
+import { T as TraceStore } from './store-BcFXE6LG.js';
+
 /**
  * Run-completion integrity check — at end of run, verify the expected event
  * types were actually captured. The point is the launch-review failure mode:
@@ -18,10 +22,8 @@
  * the caller chooses the failure mode (throw, mark run failed, log warning).
  * `throwIfRunIncomplete` is the convenient strict mode.
  */
-import { CaptureIntegrityError } from '../errors';
-import type { RawProviderSink } from './raw-provider-sink';
-import type { TraceStore } from './store';
-export interface RunIntegrityExpectations {
+
+interface RunIntegrityExpectations {
     /** Minimum LLM span count. Default 0 (no requirement). */
     llmSpansMin?: number;
     /** Minimum judge span count. Default 0. */
@@ -44,13 +46,13 @@ export interface RunIntegrityExpectations {
     /** Run outcome must be set (not null/undefined). Default false. */
     requireOutcome?: boolean;
 }
-export type RunIntegrityIssueCode = 'no_run' | 'missing_llm_spans' | 'missing_judge_spans' | 'missing_tool_spans' | 'missing_raw_events' | 'no_raw_sink' | 'orphan_llm_span' | 'missing_outcome';
-export interface RunIntegrityIssue {
+type RunIntegrityIssueCode = 'no_run' | 'missing_llm_spans' | 'missing_judge_spans' | 'missing_tool_spans' | 'missing_raw_events' | 'no_raw_sink' | 'orphan_llm_span' | 'missing_outcome';
+interface RunIntegrityIssue {
     code: RunIntegrityIssueCode;
     message: string;
     detail?: Record<string, unknown>;
 }
-export interface RunIntegrityReport {
+interface RunIntegrityReport {
     ok: boolean;
     runId: string;
     llmSpanCount: number;
@@ -68,11 +70,12 @@ export interface RunIntegrityReport {
     };
     issues: RunIntegrityIssue[];
 }
-export declare class RunIntegrityError extends CaptureIntegrityError {
+declare class RunIntegrityError extends CaptureIntegrityError {
     readonly report: RunIntegrityReport;
     constructor(report: RunIntegrityReport);
 }
-export declare function assertRunCaptured(store: TraceStore, runId: string, expectations?: RunIntegrityExpectations): Promise<RunIntegrityReport>;
+declare function assertRunCaptured(store: TraceStore, runId: string, expectations?: RunIntegrityExpectations): Promise<RunIntegrityReport>;
 /** Strict mode: throws `RunIntegrityError` when the report isn't ok. */
-export declare function throwIfRunIncomplete(report: RunIntegrityReport): void;
-//# sourceMappingURL=integrity.d.ts.map
+declare function throwIfRunIncomplete(report: RunIntegrityReport): void;
+
+export { type RunIntegrityExpectations as R, type RunIntegrityReport as a, RunIntegrityError as b, type RunIntegrityIssue as c, type RunIntegrityIssueCode as d, assertRunCaptured as e, throwIfRunIncomplete as t };

package/dist/{judge-calibration.d.ts → judge-calibration-0p2QcWNE.d.ts}

@@ -18,19 +18,19 @@
  * Returns actionable diagnostics, not a single number. Consumers then
  * decide whether to trust the judge, retrain it, or add a tie-breaker.
  */
-export interface GoldenItem {
+interface GoldenItem {
     itemId: string;
     humanScore: number;
     /** Optional group used for per-group bias audits (e.g. model-of-output family). */
     group?: string;
 }
-export interface CandidateScore {
+interface CandidateScore {
     itemId: string;
     score: number;
     /** Optional — enables positional-bias analysis (did order matter?). */
     positionOfAInput?: 'first' | 'second';
 }
-export interface CalibrationResult {
+interface CalibrationResult {
     n: number;
     pearson: number;
     /** Cohen's κ with quadratic weights over integer-rounded scores. */
@@ -45,8 +45,8 @@ export interface CalibrationResult {
         delta: number;
     }>;
 }
-export declare function calibrateJudge(golden: GoldenItem[], candidate: CandidateScore[]): CalibrationResult;
-export interface PositionalBiasResult {
+declare function calibrateJudge(golden: GoldenItem[], candidate: CandidateScore[]): CalibrationResult;
+interface PositionalBiasResult {
     /**
      * Score delta (first-position - second-position) averaged across items
      * presented in both positions. Non-zero = positional bias.
@@ -58,17 +58,17 @@ export interface PositionalBiasResult {
  * Feed the same items to the judge twice with A/B swapped and pass all
  * results here. Items that don't appear in both positions are ignored.
  */
-export declare function positionalBias(scores: CandidateScore[]): PositionalBiasResult;
-export interface VerbosityBiasResult {
+declare function positionalBias(scores: CandidateScore[]): PositionalBiasResult;
+interface VerbosityBiasResult {
     /** Pearson correlation between output length and score. Strong positive = verbosity bias. */
     pearson: number;
     n: number;
 }
-export declare function verbosityBias(samples: Array<{
+declare function verbosityBias(samples: Array<{
     outputLen: number;
     score: number;
 }>): VerbosityBiasResult;
-export interface SelfPreferenceResult {
+interface SelfPreferenceResult {
     /** Mean judge score when judge's family matches output's family. */
     inFamilyMean: number;
     outOfFamilyMean: number;
@@ -80,11 +80,11 @@ export interface SelfPreferenceResult {
  * model X (in-family) and model Y (out-of-family). Non-zero delta
  * indicates self-preference.
  */
-export declare function selfPreference(samples: Array<{
+declare function selfPreference(samples: Array<{
     score: number;
     inFamily: boolean;
 }>): SelfPreferenceResult;
-export interface ContinuousAgreement {
+interface ContinuousAgreement {
     /** Cohen's κ_w with quadratic weights, computed on raw [0,1] scores. */
     weightedKappa: number;
     /** ICC(2,1): two-way random effects, absolute agreement, single rater. */
@@ -103,7 +103,7 @@ export interface ContinuousAgreement {
     /** Number of raters. */
     raters: number;
 }
-export interface ContinuousAgreementOptions {
+interface ContinuousAgreementOptions {
     /** Bootstrap iterations. Default 1000. Set to 0 to skip CIs (CI = [NaN, NaN]). */
     bootstrap?: number;
     /** κ weighting scheme. Default 'quadratic'. */
@@ -120,8 +120,8 @@ export interface ContinuousAgreementOptions {
  * are dropped. Returns NaN metrics if fewer than 2 raters or 2 complete
  * items remain.
  */
-export declare function continuousAgreement(scores: number[][], opts?: ContinuousAgreementOptions): ContinuousAgreement;
-export interface ContinuousCalibrationResult extends CalibrationResult {
+declare function continuousAgreement(scores: number[][], opts?: ContinuousAgreementOptions): ContinuousAgreement;
+interface ContinuousCalibrationResult extends CalibrationResult {
     /** Cohen's κ_w computed on raw (un-rounded) scores. */
     weightedKappaContinuous: number;
     /** ICC(2,1) treating golden + candidate as two raters. */
@@ -137,5 +137,6 @@ export interface ContinuousCalibrationResult extends CalibrationResult {
  * agreement metrics. The old fields (n, pearson, kappa, mae, worstItems)
  * are preserved unchanged so existing callers continue to work.
  */
-export declare function calibrateJudgeContinuous(golden: GoldenItem[], candidate: CandidateScore[], opts?: ContinuousAgreementOptions): ContinuousCalibrationResult;
-//# sourceMappingURL=judge-calibration.d.ts.map
+declare function calibrateJudgeContinuous(golden: GoldenItem[], candidate: CandidateScore[], opts?: ContinuousAgreementOptions): ContinuousCalibrationResult;
+
+export { type ContinuousAgreement as C, type GoldenItem as G, type PositionalBiasResult as P, type SelfPreferenceResult as S, type VerbosityBiasResult as V, type CalibrationResult as a, type ContinuousCalibrationResult as b, type CandidateScore as c, type ContinuousAgreementOptions as d, calibrateJudge as e, calibrateJudgeContinuous as f, continuousAgreement as g, positionalBias as p, selfPreference as s, verbosityBias as v };

package/dist/{analyst/kind-factory.d.ts → kind-factory-X3eDYbKn.d.ts}

@@ -1,3 +1,56 @@
+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 './types-B5x54y6n.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.
  *
@@ -23,15 +76,12 @@
  * description programmatically. Stored on the kind, not the registry,
  * because the right metric is kind-specific.
  */
-import type { AxAIService, AxFunction } from '@ax-llm/ax';
-import type { TraceAnalysisStore } from '../trace-analyst/store';
-import { type RawAnalystFinding } from './finding-signature';
-import type { Analyst, AnalystContext, AnalystCost } from './types';
+
 /**
  * Per-kind specification. The factory turns this into a regular
  * `Analyst<TraceAnalysisStore>` ready for `AnalystRegistry.register()`.
  */
-export interface TraceAnalystKindSpec {
+interface TraceAnalystKindSpec {
     /** Stable id. Appears in finding_id, telemetry, and registry exclusions. */
     id: string;
     /** One-sentence description shown in `registry.list()`. */
@@ -68,11 +118,11 @@ export interface TraceAnalystKindSpec {
  * is the ground-truth finding set a fitted prompt should produce on this
  * input. Metric: kind-specific (default: F1 on `finding_id` overlap).
  */
-export interface TraceAnalystGolden {
+interface TraceAnalystGolden {
     question: string;
     expected: ReadonlyArray<Omit<RawAnalystFinding, 'confidence'>>;
 }
-export interface CreateTraceAnalystKindOpts {
+interface CreateTraceAnalystKindOpts {
     /** AxAIService bound at registration time. */
     ai: AxAIService;
     /** Optional model override; falls back to the AI service's default. */
@@ -101,7 +151,7 @@ export interface CreateTraceAnalystKindOpts {
  * `analyze()` call (the agent carries chat-log + usage state we don't
  * want shared across analyst runs).
  */
-export declare function createTraceAnalystKind(spec: TraceAnalystKindSpec, opts: CreateTraceAnalystKindOpts): Analyst<TraceAnalysisStore>;
+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.
@@ -116,5 +166,6 @@ export declare function createTraceAnalystKind(spec: TraceAnalystKindSpec, opts:
  * Exported for tests + for consumers that build their own actor
  * prompts (e.g. specialized analysts living outside the default kinds).
  */
-export declare function renderPriorFindings(prior: AnalystContext['priorFindings']): string;
-//# sourceMappingURL=kind-factory.d.ts.map
+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,3 +1,103 @@
-export * from './readiness';
-export * from './types';
-//# sourceMappingURL=index.d.ts.map
+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/{llm-client.d.ts → llm-client-Bj7g0rqu.d.ts}

@@ -1,3 +1,6 @@
+import { A as AgentEvalError, C as CaptureIntegrityError } from './errors-CzMUYo7b.js';
+import { R as RawProviderSink, P as ProviderRedactor } from './raw-provider-sink-C46HDghv.js';
+
 /**
  * LLM client with graceful degrade.
  *
@@ -19,9 +22,8 @@
  * output (semantic concept judge, reviewer directives, critic scores). Primitives
  * that need free-form text use `callLlm` and parse output themselves.
  */
-import { AgentEvalError, CaptureIntegrityError } from './errors';
-import { type ProviderRedactor, type RawProviderSink } from './trace/raw-provider-sink';
-export interface LlmMessage {
+
+interface LlmMessage {
     role: 'system' | 'user' | 'assistant';
     /**
      * Either a plain text content string OR a multimodal content array
@@ -38,7 +40,7 @@ export interface LlmMessage {
         };
     }>;
 }
-export interface LlmCallRequest {
+interface LlmCallRequest {
     model: string;
     messages: LlmMessage[];
     /** Optional JSON-mode response format (response_format: json_object). */
@@ -53,14 +55,14 @@ export interface LlmCallRequest {
     /** Per-call timeout, default 300s. */
     timeoutMs?: number;
 }
-export interface LlmUsage {
+interface LlmUsage {
     promptTokens: number;
     completionTokens: number;
     totalTokens: number;
     /** Proxies populate this when prompt caching is on. */
     cachedPromptTokens?: number;
 }
-export interface LlmCallResult {
+interface LlmCallResult {
     /** The text content of the first choice. Empty string if none. */
     content: string;
     usage: LlmUsage;
@@ -92,13 +94,13 @@ export interface LlmCallResult {
     /** Raw response body. */
     raw: Record<string, unknown>;
 }
-export declare class LlmCallError extends AgentEvalError {
+declare class LlmCallError extends AgentEvalError {
     readonly status: number;
     readonly body: string;
     readonly model: string;
     constructor(message: string, status: number, body: string, model: string);
 }
-export interface LlmClientOptions {
+interface LlmClientOptions {
     /** Base URL (without trailing slash). Must end at the `/v1` prefix. */
     baseUrl?: string;
     /** Bearer token — either `apiKey` or `bearer` populates `Authorization: Bearer ...`. */
@@ -163,39 +165,38 @@ export interface LlmClientOptions {
  * treated identically whether it surfaces in the HTTP client or a
  * TCloud-backed judge.
  */
-export declare function isTransientLlmError(err: unknown): boolean;
+declare function isTransientLlmError(err: unknown): boolean;
 /** Exponential backoff: 500ms, 1s, 2s, 4s, ... capped at 16s. Attempt is 0-indexed. */
-export declare function backoffMs(attempt: number): number;
+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.
  */
-export declare function stripFencedJson(raw: string): string;
-export declare function extractJsonPayload(raw: string): string;
+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`.
  */
-export declare function callLlm(req: LlmCallRequest, opts?: LlmClientOptions): Promise<LlmCallResult>;
+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`.
  */
-export declare function callLlmJson<T = unknown>(req: LlmCallRequest, opts?: LlmClientOptions): Promise<{
+declare function callLlmJson<T = unknown>(req: LlmCallRequest, opts?: LlmClientOptions): Promise<{
     value: T;
     result: LlmCallResult;
 }>;
-export type LlmRouteAssertionReason = 'no_explicit_base_url' | 'base_url_blocked' | 'base_url_not_allowed' | 'no_auth' | 'wrong_provider';
-export declare class LlmRouteAssertionError extends CaptureIntegrityError {
+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);
 }
-export interface LlmRouteRequirements {
+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
@@ -227,7 +228,7 @@ export interface LlmRouteRequirements {
  * Throws `LlmRouteAssertionError`. Pure — no I/O — so it's safe to call
  * from constructors and CI gates.
  */
-export declare function assertLlmRoute(opts: LlmClientOptions, req?: LlmRouteRequirements): void;
+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,
@@ -239,7 +240,7 @@ export declare function assertLlmRoute(opts: LlmClientOptions, req?: LlmRouteReq
  * for short prompts, so don't tighten this further. We don't validate
  * content; HTTP 200 means reachable.
  */
-export declare function probeLlm(model: string, opts?: LlmClientOptions & {
+declare function probeLlm(model: string, opts?: LlmClientOptions & {
     timeoutMs?: number;
 }): Promise<{
     ok: boolean;
@@ -251,7 +252,7 @@ export declare function probeLlm(model: string, opts?: LlmClientOptions & {
  * Thin wrapper around the free functions; exists for callers that want
  * to inject a single configured instance into multiple primitives.
  */
-export declare class LlmClient {
+declare class LlmClient {
     private readonly opts;
     constructor(opts?: LlmClientOptions);
     call(req: LlmCallRequest, per?: LlmClientOptions): Promise<LlmCallResult>;
@@ -260,4 +261,5 @@ export declare class LlmClient {
         result: LlmCallResult;
     }>;
 }
-//# sourceMappingURL=llm-client.d.ts.map
+
+export { type LlmClientOptions as L, type LlmRouteRequirements as a, type LlmCallRequest as b, type LlmCallResult as c, LlmCallError as d, LlmClient as e, type LlmMessage as f, LlmRouteAssertionError as g, type LlmUsage as h, assertLlmRoute as i, backoffMs as j, callLlm as k, callLlmJson as l, isTransientLlmError as m, probeLlm as p, stripFencedJson as s };