@tangle-network/agent-eval 0.182.0 → 0.184.0

package/dist/{index-CJ3LhKIX.d.ts → index-CKZa_rnt.d.ts}

@@ -1,158 +1,6 @@
-import { a as RunRecord } from "./run-record-BiTWauyO.js";
-import { s as TraceStore } from "./store-BErPvYBr.js";
-import { S as ToolDef, a as MintedRolloutLine, b as RolloutStep, h as RolloutOutcome, i as GatedEvidence, m as RolloutLine, t as ChatMessage, v as RolloutRole, y as RolloutSplit } from "./schema-BzWDXhOR.js";
+import { S as ToolDef, a as MintedRolloutLine, h as RolloutOutcome, i as GatedEvidence, m as RolloutLine, t as ChatMessage, y as RolloutSplit } from "./schema-BzWDXhOR.js";
+import { b as VerifiersRolloutOutput, g as RftItem, v as SftRow } from "./mint-BI14xehJ.js";
 import { DatabaseSync } from "node:sqlite";
-//#region src/rollout/exporters.d.ts
-/**
- * The gate's two claims, which travel TOGETHER on every emitted row.
- *
- * `realness_gated` alone is ambiguous, and the ambiguity is exploitable:
- * `false` reads as "we screened it and nothing fired", so a producer that has no
- * screen at all emitted rows indistinguishable from screened-clean ones, and
- * every consumer of the published dataset read them as clean. The second field
- * is what separates the two claims, and it only removes the ambiguity if it
- * reaches the WIRE — for a round it existed on `RolloutOutcome` and on no
- * exported row shape at all, which left the published rows exactly as ambiguous
- * as before.
- *
- * So there is one helper and every row shape spreads it. A row that states one
- * claim without the other is not constructible by copying the pattern, and
- * `exporters.test.ts` walks every emitted shape to prove none does.
- */
-interface RealnessLabels {
-  /** The screen's VERDICT: the run faked its success signal. */
-  realness_gated: boolean;
-  /**
-   * Whether a screen RAN at all. `true` = it ran, so `realness_gated` is its
-   * verdict. `false` = the producer declares it has none. `null` = not stated
-   * (pre-unification producers), which is "unknown" and never "clean".
-   */
-  realness_screened: boolean | null;
-}
-interface TrainingExportOptions {
-  /** Include held-out evaluation data in training output. Default false. */
-  allowHeldOutTrainingData?: boolean;
-  /** Require reward to be strictly greater than this value. Default 0. */
-  minimumQualityExclusive?: number;
-}
-/**
- * What a signed-signal exporter (verifiers, RFT) does with lines that are not
- * clean trainable successes — realness-gated lines above all.
- *
- *   - 'exclude'       — the default, the same fail-closed policy as every
- *                       other training export: positive, completed,
- *                       non-gated rows on a trainable split.
- *   - 'zero-and-flag' — keep them, at their non-positive (or null) reward,
- *                       with `RealnessLabels` on the row. The dataset release
- *                       sets this per `FORMAT_GATE_DISPOSITION`: in these
- *                       formats the reward is a signed learning signal, so a
- *                       gamed trajectory at reward 0 is a correct negative,
- *                       and dropping it would bias the negative population
- *                       toward honest failures and leave a trainer no example
- *                       of gaming being penalized. The split policy is NOT
- *                       relaxed: held-out lines still need the named opt-in.
- *
- * SFT deliberately has no such option — an SFT row is an imitation target and
- * a gamed trajectory must never appear in one at any weight.
- */
-type GatedLineDisposition = 'exclude' | 'zero-and-flag';
-interface SignedSignalExportOptions extends TrainingExportOptions {
-  /** Disposition for non-trainable lines. Default 'exclude'. */
-  gatedLines?: GatedLineDisposition;
-}
-type SftExportOptions = TrainingExportOptions;
-interface SftRow {
-  messages: ChatMessage[];
-  metadata: {
-    rollout_id: string;
-    run_id: string;
-    candidate_id: string | null;
-    instance_id: string;
-    reward: number;
-  } & RealnessLabels;
-}
-/**
- * Supervised fine-tune rows: the completed conversation of each qualifying
- * line. Fail-closed filters: trainable split only (never holdout/canary),
- * reward strictly above `minimumQualityExclusive` (default 0), realness-gated
- * lines never qualify, gap lines carry no trainable content, and
- * copied-context turns are dropped from the transcript (Harbor ATIF RFC 0001
- * rule 7 — see `ChatMessage.is_copied_context`).
- *
- * `realness_gated` is therefore always `false` on an emitted row. It is carried
- * anyway: an SFT row is a pure imitation target, so the row states its realness
- * claims instead of making the reader know the format's policy, and carrying
- * both flags on all four shapes is what lets the release accounting measure
- * every config with one rule rather than skipping the one whose row shape
- * happened to omit the field.
- */
-declare function toSftRows(lines: MintedRolloutLine[], options?: SftExportOptions): SftRow[];
-interface RewardRow {
-  /** First user turn — the task prompt. */
-  prompt: string;
-  steps: RolloutStep[];
-  reward: number;
-  metadata: {
-    rollout_id: string;
-    run_id: string;
-    candidate_id: string | null;
-    instance_id: string;
-    split: RolloutSplit;
-  } & RealnessLabels;
-}
-/**
- * Reward-labeled rows for completed, positive-quality training runs.
- */
-declare function toRewardRows(lines: MintedRolloutLine[], options?: TrainingExportOptions): RewardRow[];
-interface VerifiersTokenUsage {
-  input_tokens: number | null;
-  output_tokens: number | null;
-  reasoning_tokens: number | null;
-  cache_read_tokens: number | null;
-  cache_write_tokens: number | null;
-}
-interface VerifiersRolloutOutput {
-  /** Messages through the last turn BEFORE the first assistant turn. */
-  prompt: ChatMessage[];
-  /** The first assistant turn onward — what the policy produced. */
-  completion: ChatMessage[];
-  reward: number | null;
-  metrics: Record<string, unknown>;
-  tool_defs: ToolDef[];
-  token_usage: VerifiersTokenUsage;
-  info: {
-    task: RolloutLine['task'];
-    policy: RolloutLine['policy'];
-    rollout_id: string;
-    run_id: string;
-    experiment_id: string | null;
-    candidate_id: string | null;
-    generation: number | null;
-    candidate_index: number | null;
-    role: RolloutLine['role'];
-  } & RealnessLabels;
-}
-declare function toVerifiersRolloutOutput(line: MintedRolloutLine): VerifiersRolloutOutput;
-declare function toVerifiersRolloutOutputs(lines: MintedRolloutLine[], options?: SignedSignalExportOptions): VerifiersRolloutOutput[];
-interface RftItem {
-  /** Prompt turns only — the graded completion is re-sampled during RFT. */
-  messages: ChatMessage[];
-  /** Verdict/label fields the grader references as item.reference.* */
-  reference: {
-    reward: number | null;
-    reward_source: string | null;
-    verdict: unknown;
-    instance_id: string;
-    suite: string;
-    split: RolloutSplit;
-    rollout_id: string;
-  } & RealnessLabels;
-}
-declare function toRftItem(line: MintedRolloutLine): RftItem;
-/** RFT needs a real prompt: lines whose transcript starts with prompt turns. */
-declare function toRftItems(lines: MintedRolloutLine[], options?: SignedSignalExportOptions): RftItem[];
-declare function toJsonl(rows: ReadonlyArray<unknown>): string;
-//#endregion
 //#region src/rollout/gate-checks.d.ts
 /**
  * Every gate check in the package, in the order they are applied.
@@ -513,121 +361,6 @@ declare function readRolloutLedger(path: string): Promise<MintedRolloutLine[]>;
  */
 declare function readRolloutJournal(path: string): Promise<RolloutLine[]>;
 //#endregion
-//#region src/rollout/reward.d.ts
-/**
- * Which split's score wins when a record carries both. `'holdout'` is the
- * canonical "real signal" default; `'search'` exists because some callers
- * deliberately score on the search split when both are present.
- */
-type ScorePreference = 'holdout' | 'search';
-/** Only the outcome is read, so every accessor here accepts anything carrying one. */
-type Scored = Pick<RunRecord, 'outcome'>;
-/** True when the authenticity gate flagged the run as gamed (`realness.gated`). */
-declare function isRealnessGated(record: Scored): boolean;
-/**
- * The RAW score recorded on ONE split, with no cross-split fallback and no
- * anti-Goodhart gate.
- *
- * The narrowest of the three raw readers, and the one every split-scoped
- * consumer wants: a per-split report, a promotion gate, or a paired comparison
- * asks "what did this run score on the split I am summarising", and answering
- * it with the other split's number silently mixes populations. `undefined` =
- * that split was never scored.
- *
- * Same warning as `observedScore`: this INCLUDES runs flagged as gamed. Never
- * feed it into training data.
- */
-declare function observedSplitScore(record: Scored, split: ScorePreference): number | undefined;
-/**
- * The RAW split score the run carries, with NO anti-Goodhart gate applied.
- *
- * INCLUDES RUNS FLAGGED AS GAMED (`outcome.realness.gated === true`); NEVER
- * feed this into training data — a fine-tune that sees it learns from gamed
- * successes. It is exported anyway because analysis, reporting, and
- * reward-hacking detection legitimately need the ungated number: forcing a
- * gamed run to 0 collapses the proxy signal toward ground truth and makes a
- * detector report "clean" on exactly the population that is being gamed.
- *
- * Returns `undefined` when the record carries neither score — an unscored run
- * is a labeled gap, not a measured zero, and each caller picks its own
- * sentinel (`?? 0`, `?? null`, skip, throw). Non-finite values are returned
- * as-is; callers that care keep their own `Number.isFinite` guard.
- */
-declare function observedScore(record: Scored, prefer?: ScorePreference): number | undefined;
-/** Which split actually carried the score, or that none did. */
-type ScoreOrigin = 'holdout' | 'search' | 'unscored';
-/**
- * Where `observedScore` / `trainingScore` read their number from — the
- * provenance label a rollout line's `reward_source` is built from, and the
- * only supported way to ask "was this run scored at all" without respelling
- * the field access.
- */
-declare function scoreOrigin(record: Scored, prefer?: ScorePreference): ScoreOrigin;
-/**
- * The GATED score — the only derivation allowed to reach training data.
- *
- * A realness-gated run scores 0 no matter what it claims, so a fine-tune
- * cannot learn from a gamed success. An unscored run stays `undefined` (a
- * labeled gap), keeping "we never measured this" distinct from "we measured
- * zero"; callers that need a number apply their own sentinel.
- */
-declare function trainingScore(record: Scored, prefer?: ScorePreference): number | undefined;
-/**
- * `{reward, gated}` as written onto a minted `RolloutLine` — `trainingScore`
- * plus the flag itself, so the gate travels into the exported row and a
- * downstream filter can drop or down-weight the line.
- *
- * An unscored record yields `reward: null`, matching the schema's "no verdict
- * exists — a labeled gap, never 0" rule. It previously collapsed to 0, which
- * made a run nobody graded indistinguishable from one graded as a total
- * failure, and taught any trainer reading the row that the trajectory was bad.
- * A gated run still yields 0, because that IS a verdict: the gate decided.
- */
-declare function trainingReward(record: Scored): {
-  reward: number | null;
-  gated: boolean;
-};
-//#endregion
-//#region src/rollout/mint.d.ts
-/** Redactor applied to every exported string (secrets, PII). Identity by default. */
-type RolloutScrubber = (text: string) => string;
-interface MintRolloutOptions {
-  scrub?: RolloutScrubber;
-  /** Cap steps per line (longest runs first drop middle steps). Default: no cap. */
-  maxSteps?: number;
-  /** Role recorded on every minted line. Default 'agent' (a solo eval run). */
-  role?: RolloutRole;
-  /** Task suite label. Default: the record's `experimentId`. */
-  suite?: string;
-  /** Injected clock for deterministic output. */
-  now?: () => Date;
-}
-interface MintRolloutResult {
-  rows: MintedRolloutLine[];
-  /** runIds that had a RunRecord but no spans — emitted as gap lines AND listed here. */
-  missingTraces: string[];
-}
-/**
- * Why a record cannot be minted, one entry per missing field, empty when it can.
- *
- * Exported so a caller can partition a whole ledger — "which of my 2742 records
- * predate 0.126" — without catching an exception per record, and without
- * re-deriving the field list on their side. A re-derived list is a list that
- * drifts from the door it is supposed to predict.
- *
- * Takes a `RunRecord` because that is what the caller holds and what the
- * compiler agrees they hold. The type is precisely the thing that is wrong, so
- * the checks read the record as the untyped bag it actually is on disk.
- */
-declare function unmintableReasons(record: RunRecord): string[];
-/**
- * Join RunRecords with their traces into canonical rollout lines. Records
- * without spans are emitted as labeled gap lines and reported in
- * `missingTraces`. Execution-only records without a task score are rejected
- * because a missing training label is not a zero reward.
- */
-declare function mintRolloutRows(records: RunRecord[], store: TraceStore, options?: MintRolloutOptions): Promise<MintRolloutResult>;
-//#endregion
 //#region src/rollout/readers/claude-jsonl.d.ts
 declare const DEFAULT_CLAUDE_PROJECTS_DIR: string;
 /** Claude Code's project-directory slug for a working directory. */
@@ -930,5 +663,5 @@ declare function parseRolloutReleaseArgs(argv: string[]): RolloutReleaseCliArgs;
 /** CLI driver for `agent-eval rollout-release`. Returns the process exit code. */
 declare function runRolloutReleaseCli(argv: string[]): Promise<number>;
 //#endregion
-export { observedSplitScore as $, measureFormatGate as A, GateCheckDisposition as At, DEFAULT_CLAUDE_PROJECTS_DIR as B, SftExportOptions as Bt, FORMAT_GATE_DISPOSITION as C, relabelImportedSplit as Ct, ReleaseRowRef as D, GATE_CHECK_IDS as Dt, GateReport as E, GATE_CHECKS as Et, openOpencodeDb as F, gateErrors as Ft, MintRolloutResult as G, toRewardRows as Gt, findClaudeTranscripts as H, VerifiersRolloutOutput as Ht, readOpencodeSessionMessages as I, gatedEvidenceOf as It, unmintableReasons as J, toSftRows as Jt, RolloutScrubber as K, toRftItem as Kt, ClaudeTranscript as L, RealnessLabels as Lt, DEFAULT_OPENCODE_DB as M, GateCheckedOutcome as Mt, OpencodeSessionRow as N, GateEntryPoint as Nt, assertGateReport as O, GATE_POLICIES as Ot, findOpencodeSessionsByDirectory as P, GatePolicy as Pt, observedScore as Q, ClaudeTranscriptRef as R, RewardRow as Rt, EmittedEvidence as S, fromHarborTrajectory as St, GateDisposition as T, toHarborTrajectory as Tt, readClaudeTranscript as U, VerifiersTokenUsage as Ut, claudeProjectSlug as V, SftRow as Vt, MintRolloutOptions as W, toJsonl as Wt, ScorePreference as X, toVerifiersRolloutOutputs as Xt, ScoreOrigin as Y, toVerifiersRolloutOutput as Yt, isRealnessGated as Z, defaultRolloutScrubber as _, HarborStep as _t, buildHfDataset as a, readRolloutLedger as at, scrubRolloutLine as b, HarborToolCall as bt, runRolloutReleaseCli as c, FromHarborOptions as ct, RELEASE_FORMATS as d, HarborContentPart as dt, scoreOrigin as et, ReleaseFormat as f, HarborFinalMetrics as ft, addScrubCounts as g, HarborObservationResult as gt, ScrubRule as h, HarborObservation as ht, ScrubReport as i, readRolloutJournal as it, releaseRowRefs as j, GateCheckId as jt, gatedRolloutIds as k, GateCheck as kt, DatasetCardInputs as l, HARBOR_IMPORT_GAP as lt, ScrubCounts as m, HarborMetrics as mt, BuildSummary as n, trainingScore as nt, parseRolloutReleaseArgs as o, writeRolloutLedger as ot, buildDatasetCard as p, HarborImageSource as pt, mintRolloutRows as q, toRftItems as qt, RolloutReleaseCliArgs as r, appendRolloutLines as rt, planPushCommand as s, ATIF_SCHEMA_VERSION as st, BuildOptions as t, trainingReward as tt, FORMAT_FILES as u, HarborAgent as ut, emptyScrubCounts as v, HarborStepSource as vt, FormatGateCounts as w, toHarborTrajectories as wt, scrubText as x, HarborTrajectory as xt, scrubLines as y, HarborSubagentTrajectoryRef as yt, ClaudeUsageTotals as z, RftItem as zt };
-//# sourceMappingURL=index-CJ3LhKIX.d.ts.map
+export { HarborFinalMetrics as $, measureFormatGate as A, DEFAULT_CLAUDE_PROJECTS_DIR as B, FORMAT_GATE_DISPOSITION as C, gatedEvidenceOf as Ct, ReleaseRowRef as D, GateReport as E, openOpencodeDb as F, readRolloutJournal as G, findClaudeTranscripts as H, readOpencodeSessionMessages as I, ATIF_SCHEMA_VERSION as J, readRolloutLedger as K, ClaudeTranscript as L, DEFAULT_OPENCODE_DB as M, OpencodeSessionRow as N, assertGateReport as O, findOpencodeSessionsByDirectory as P, HarborContentPart as Q, ClaudeTranscriptRef as R, EmittedEvidence as S, gateErrors as St, GateDisposition as T, readClaudeTranscript as U, claudeProjectSlug as V, appendRolloutLines as W, HARBOR_IMPORT_GAP as X, FromHarborOptions as Y, HarborAgent as Z, defaultRolloutScrubber as _, GateCheckDisposition as _t, buildHfDataset as a, HarborStepSource as at, scrubRolloutLine as b, GateEntryPoint as bt, runRolloutReleaseCli as c, HarborTrajectory as ct, RELEASE_FORMATS as d, toHarborTrajectories as dt, HarborImageSource as et, ReleaseFormat as f, toHarborTrajectory as ft, addScrubCounts as g, GateCheck as gt, ScrubRule as h, GATE_POLICIES as ht, ScrubReport as i, HarborStep as it, releaseRowRefs as j, gatedRolloutIds as k, DatasetCardInputs as l, fromHarborTrajectory as lt, ScrubCounts as m, GATE_CHECK_IDS as mt, BuildSummary as n, HarborObservation as nt, parseRolloutReleaseArgs as o, HarborSubagentTrajectoryRef as ot, buildDatasetCard as p, GATE_CHECKS as pt, writeRolloutLedger as q, RolloutReleaseCliArgs as r, HarborObservationResult as rt, planPushCommand as s, HarborToolCall as st, BuildOptions as t, HarborMetrics as tt, FORMAT_FILES as u, relabelImportedSplit as ut, emptyScrubCounts as v, GateCheckId as vt, FormatGateCounts as w, scrubText as x, GatePolicy as xt, scrubLines as y, GateCheckedOutcome as yt, ClaudeUsageTotals as z };
+//# sourceMappingURL=index-CKZa_rnt.d.ts.map

package/dist/index-CKZa_rnt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-CKZa_rnt.d.ts","names":[],"sources":["../src/rollout/gate-checks.ts","../src/rollout/interchange/harbor.ts","../src/rollout/ledger.ts","../src/rollout/readers/claude-jsonl.ts","../src/rollout/readers/opencode-sqlite.ts","../src/rollout/release/gate-report.ts","../src/rollout/release/scrub.ts","../src/rollout/release/card.ts","../src/rollout/release/hf-dataset.ts"],"mappings":";;;;;;;;;;;cA2Ca;KAOD,sBAAsB;;;;;;;;;KAUtB,qBAAqB,QAAQ,kBAAkB,SAAS;;;;;;;;;;;;;;;;;UAkBnD;EACf,SAAS;;EAET;;UAOe;EACf,IAAI;;EAEJ;;EAEA,SAAS,SAAS;;;;;;;;;;;;EAYlB,WAAW;;;;;;;;;;;;;iBA6LG,gBAAgB,SAAS,cAAc;;;;;;cA6I1C,yBAAyB,KAAK,cAAc;;;;;;;;;KAe7C;WACG;;;;WAEA;WAAyB;;;;WAEzB;WAAuB;;;KAU1B,yBAAyB,KAAK,cAAc;;;;;;;;;cAU3C;;;;;;;aAWT;eAnCiB;;aAoCjB,kBAAgB;aAMhB,2BAAyB;aAMzB,qBAAmB;;;;;;;;aAenB;;;aACA,kBAAgB;aAChB,2BAAyB;aACzB;;;;;;;;;;;aASA;;;aACA;;;aACA;;;aACA;;;;;;;;;;;aASA;;;aACA;;;aACA;;;aACA;;;;;;KAKQ,8BAA8B;;;;;;iBAO1B,WAAW,SAAS,aAAa,QAAQ;;;cCxd5C;;cAGA;KAwBD;UAEK;EACf;EACA;;UAGe;EACf;EACA;EACA,SAAS;;UAGM;EACf;EACA;;EAEA,WAAW;EACX,QAAQ;;UAGO;EACf;EACA;;EAEA;EACA,QAAQ;;UAGO;EACf;EACA,mBAAmB;EACnB,0BAA0B;EAC1B,QAAQ;;UAGO;EACf,SAAS;;UAGM;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA,QAAQ;;UAGO;;EAEf;EACA;EACA,QAAQ;EACR;EACA;EACA,kBAAkB;EAClB;EACA,aAAa;EACb,cAAc;EACd,UAAU;EACV;EACA;EACA,QAAQ;;UAGO;EACf;EACA;EACA;;EAEA,mBAAmB;EACnB,QAAQ;;UAGO;EACf;EACA;EACA;EACA;EACA;EACA,QAAQ;;UAGO;EACf;EACA;;EAEA;EACA,OAAO;EACP,OAAO;EACP;EACA,gBAAgB;EAChB;EACA,wBAAwB;EACxB,QAAQ;;;;;;;;;;;;;;;;;;iBAmXM,mBAAmB,OAAO,gBAAgB;;iBAa1C,qBAAqB,OAAO,gBAAgB;UA2O3C;;EAEf,YAAY;;;;;;;;;;;iBAwGE,qBACd,YAAY,kBACZ,UAAS,oBACR;;;;;;;;;;;;;;;iBAiCa,qBACd,gBAAgB,eAChB,OAAO,eACN;;;;iBC/6BmB,mBAAmB,cAAc,OAAO,gBAAgB;;iBAOxD,mBAAmB,cAAc,OAAO,gBAAgB;;;;;;;;;;;iBAiBxD,kBAAkB,eAAe,QAAQ;;;;;;;;;;;;;;;iBAkBzC,mBAAmB,eAAe,QAAQ;;;cClDnD;;iBAGG,kBAAkB;UAIjB;EACf;EACA;;;iBAIoB,sBACpB,aACA,uBACC,QAAQ;UASM;EACf;EACA;EACA;EACA;;UAGe;EACf,UAAU;EACV,OAAO;;EAEP;EACA;EACA;;UAyDe;;;;;;WAMN;;;iBAgBW,qBACpB,cACA,UAAS,8BACR,QAAQ;;;cCnHE;UAEI;EACf;EACA;EACA;EACA;;EAEA;IAAS;IAAa;;EACtB;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;iBAYoB,eACpB,gBACC,QAAQ;;iBAiDK,gCACd,IAAI,cACJ,oBACC;;;;;;;iBA2Ba,4BAA4B,IAAI,cAAc,oBAAoB;;;;KC5EtE;cAEC,yBAAyB,OAAO,eAAe;;UAQ3C;EACf;EACA;;;;;;;;;;;;EAYA;;;;;;;;EAQA;;;;;;;;;;;;EAYA;;;UAIe;;EAEf;EACA;;UAGe;;EAEf;;EAEA;;;;;;EAMA;;EAEA;;;;;;;;;;;;;;EAcA,oBAAoB;;;;;;;;;;;;EAYpB;;EAEA;;;;;;;;;;EAUA,wBAAwB;;UAGT;;EAEf;EACA,UAAU,QAAQ,OAAO,eAAe;;;iBAI1B,gBAAgB,gBAAgB,sBAAsB;;;;;;;cAUzD;EAIX,MAAG,eAAkB,aAAW;EAShC,YAAS,eAAkB,6BAA2B;EAStD,MAAG,eAAkB,cAAY;EAOjC,MAAG,gBAAmB,wBAAsB;;;iBAgC9B,kBACd,OAAO,qBACP,eAAe,kBACd;;;;;;;;;;;;;;;;iBA+Fa,iBAAiB,QAAQ;;;UCrUxB;EACf;EACA,SAAS;;EAET,UAAU,eAAe;;;KAqEf,cAAc;iBAEV,oBAAoB;iBAIpB,eAAe,MAAM,aAAa,MAAM,cAAc;iBAKtD,UAAU,cAAc,QAAQ;;;;;;;;;iBA8BhC,iBAAiB,MAAM,mBAAmB,QAAQ,cAAc;iBAIhE,WAAW,OAAO;EAChC,OAAO;EACP,QAAQ;;;;;;;;;iBAaM,uBAAuB;;;cCrI1B;KACD,wBAAwB;;cAGvB,cAAc,OAAO;UAejB;;EAEf,OAAO;EACP,SAAS;EACT;;EAEA;EACA,aAAa;EACb;IAAY;IAAmB;;EAC/B,cAAc,QAAQ,OAAO;;;;;;;EAO7B,MAAM;;iBA4GQ,iBAAiB,QAAQ;;;UC1HxB;EACf;EACA,SAAS;EACT;;UAGe;;EAEf,OAAO,eAAe;EACtB,QAAQ;EACR;IAAY;IAAmB;;;UAGhB;EACf;EACA;EACA;EACA,OAAO;EACP,cAAc,QAAQ,OAAO;;EAE7B,MAAM;EACN;;iBAGoB,eACpB,kBACA,SAAS,eACR,QAAQ;iBAuGK,gBAAgB,cAAc;UAoB7B,8BAA8B;EAC7C;EACA;;iBAMc,wBAAwB,iBAAiB;;iBA0CnC,qBAAqB,iBAAiB"}

package/dist/{index-DbG8QbH9.d.ts → index-DVrtLO5j.d.ts}

@@ -1,11 +1,11 @@
 import { b as CustomTokenPricing, c as CostLedgerHandle } from "./cost-ledger-DbQdN3nO.js";
-import { i as AnalystFinding, n as AnalystContext } from "./types-D7gEdPoQ.js";
+import { i as AnalystFinding, n as AnalystContext } from "./types-BjB2wZM9.js";
 import { R as LlmThinkingMode, x as ChatClient } from "./types-CBbLtr2J.js";
-import { F as ExternalOptimizerCallbackLimits, V as ExternalOptimizerModelCall, W as ExternalOptimizerModelExecutionObservation, q as ExternalOptimizerRunnerCommand } from "./agent-profile-CivaSsSy.js";
+import { F as ExternalOptimizerCallbackLimits, V as ExternalOptimizerModelCall, W as ExternalOptimizerModelExecutionObservation, q as ExternalOptimizerRunnerCommand } from "./agent-profile-uAIQK3Nr.js";
 import { o as Severity } from "./multi-layer-verifier-BUaQ4C17.js";
-import { l as ExactCapableAnalyst } from "./exact-types-BZDe0W2D.js";
-import { i as TraceAnalystDefinition } from "./default-registry-BwDSWVzg.js";
-import { n as TraceAnalysisEngine } from "./engine-DS1cysJy.js";
+import { l as ExactCapableAnalyst } from "./exact-types-BEHN7tnq.js";
+import { i as TraceAnalystDefinition } from "./default-registry-DYB4aHVn.js";
+import { n as TraceAnalysisEngine } from "./engine-D1ykrAKR.js";
 import { C as SupervisorRunSources, w as SupervisorRunTree } from "./types-BlIJ5URG.js";
 //#region src/semantic-concept-judge.d.ts
 /**
@@ -476,4 +476,4 @@ declare const KNOWLEDGE_POISONING_KIND_SPEC: TraceAnalystDefinition;
 declare const DEFAULT_TRACE_ANALYST_KINDS: readonly TraceAnalystDefinition[];
 //#endregion
 export { SemanticConceptJudgeInput as A, DspyRlmTraceEngineOptions as C, ConceptFinding as D, createChatTraceEngine as E, SemanticConceptJudgeResult as M, runSemanticConceptJudge as N, ConceptSpec as O, renderFindingSubject as S, ChatTraceEngineOptions as T, FindingSubject as _, FAILURE_MODE_KIND_SPEC as a, findingSubjectGrammarPromptFor as b, emitControlIntegrityFindings as c, FindingsStore as d, PersistedFinding as f, FINDING_SUBJECT_SYNTAX as g, FINDING_SUBJECT_KINDS as h, IMPROVEMENT_KIND_SPEC as i, SemanticConceptJudgeOptions as j, SEMANTIC_CONCEPT_JUDGE_VERSION as k, DiffPolicy as l, diffFindings as m, KNOWLEDGE_POISONING_KIND_SPEC as n, CONTROL_INTEGRITY_ANALYST as o, defaultIsMaterial as p, KNOWLEDGE_GAP_KIND_SPEC as r, ControlIntegrityAnalyst as s, DEFAULT_TRACE_ANALYST_KINDS as t, FindingsDiff as u, FindingSubjectKind as v, createDspyRlmTraceEngine as w, parseFindingSubject as x, KIND_EXPECTED_SUBJECTS as y };
-//# sourceMappingURL=index-DbG8QbH9.d.ts.map
+//# sourceMappingURL=index-DVrtLO5j.d.ts.map

package/dist/{index-DbG8QbH9.d.ts.map → index-DVrtLO5j.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"index-DbG8QbH9.d.ts","names":[],"sources":["../src/semantic-concept-judge.ts","../src/analyst/chat-trace-engine.ts","../src/analyst/trace-tool-callback.ts","../src/analyst/dspy-rlm-engine.ts","../src/analyst/finding-subject.ts","../src/analyst/findings-store.ts","../src/analyst/kinds/control-integrity.ts","../src/analyst/kinds/failure-mode.ts","../src/analyst/kinds/improvement.ts","../src/analyst/kinds/knowledge-gap.ts","../src/analyst/kinds/knowledge-poisoning.ts","../src/analyst/kinds/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAuDY;UAEK;EACf;;EAEA;;EAEA;;EAEA,aAAa;;UAGE;EACf;EACA;;EAEA;EACA;EACA,UAAU;;UAGK;;EAEf;;EAEA;;EAEA,aAAa;IAAQ;IAAc;;;EAEnC,kBAAkB;;EAElB;EACA;;UAGe;EACf;EACA;;EAEA;EACA;EACA;EACA,UAAU;EACV;EACA;EACA;;EAEA;EACA;;;;;;;;KASU;UAQK;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA,MAAM;;EAEN,UAAU;EACV,aAAa;EACb;EACA,WAAW;EACX,SAAS;;;;;;EAMT,iBAAiB;;EAEjB,oBAAoB,QAAQ,OAAO;;cAKxB;;;;;;iBAkGS,wBACpB,OAAO,2BACP,SAAS,8BACR,QAAQ;;;UCjMM;;;;;EAKf,MAAM;;EAEN;;EAEA,UAAU;;EAEV;;EAEA;;EAEA,WAAW;;EAEX;;;;;;;;;;EAUA;;;;;;iBAkCc,sBAAsB,SAAS,yBAAyB;;;KCrG5D,0BAA0B;;;UCYrB;;EAEf,MAAM;;EAEN;;EAEA,kBAAkB,aAAa;EAC/B;;EAEA,UAAU;;EAEV;;EAEA;;;;;;EAMA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA,kBAAkB,QAAQ;;EAE1B;;;;;;;;;;EAUA;;EAEA,SAAS;;EAET;;;iBAIc,yBAAyB,SAAS,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KCtClE;EAEN;EAAwB;EAAc;;EACtC;EAAyB;;EACzB;EAAuB;;EACvB;EAAyB;;EAGzB;EAAuB;;EACvB;EAAe;;EACf;EAAkB;EAAc;;EAChC;EAAkB;;EAClB;EAAa;EAAgB;;EAC7B;EAAc;;EACd;EAAkB;;EAClB;EAAkB;;EAClB;EAAwB;;EACxB;EAAuB;;EACvB;EAAc;;EACd;EAAa;EAAgB;;EAC7B;EAAgB;;EAChB;EAAqB;;EACrB;EAAuB;;EAEvB;EAA4B;;EAC5B;EAA2B;;EAE3B;EAAiB;;KAEX,qBAAqB;cAEpB,uBAAuB,cAAc;;;;;;;;;;;;;;;;;iBAgGlC,oBAAoB,iCAAiC;;;;;;;iBAoHrD,qBAAqB,GAAG;;;;;;;;;;cA8D3B,wBAAwB,SAAS,OAAO;;;;;;;;;cAoExC,wBAAwB,eAAe,cAAc;;iBAqElD,+BAA+B;;;;;;;;UCxc9B,yBAAyB;EACxC;;cAGW;WAGiB;mBAFX;EAEjB,YAA4B;EAItB,OAAO,eAAe,UAAU,mBAAmB;;EAQzD,WAAW;;EAkBX,QAAQ,gBAAgB;;UAOT;;EAEf,UAAU;;EAEV,aAAa;;EAEb,WAAW;;;;;EAKX,SAAS;IAAQ,UAAU;IAAkB,SAAS;;;UAGvC;;;;;;;;EAQf,cAAc,UAAU,gBAAgB,SAAS;;;;;;iBAOnC,kBAAkB,GAAG,gBAAgB,GAAG;;;;;iBAWxC,aACd,UAAU,oBACV,SAAS,oBACT,SAAQ,aACP;;;;iBC7Fa,6BACd,OAAO,uBAAuB,mBAC9B,qBACC;;cA4BU,mCACA,oBAAoB,uBAAuB;WAE7C;WACA;WAEA;WACA;IAAS;IAAgC;;WACzC;WACA;aACP;aACA;;EAGI,QACJ,OAAO,uBAAuB,mBAC9B,KAAK,iBACJ,QAAQ;;cAUA,2BAAyB;;;cCHzB,wBAAwB;;;cC3BxB,uBAAuB;;;cCGvB,yBAAyB;;;cCPzB,+BAA+B;;;;;;;;;;;;cCP/B,sCAAsC"}
+{"version":3,"file":"index-DVrtLO5j.d.ts","names":[],"sources":["../src/semantic-concept-judge.ts","../src/analyst/chat-trace-engine.ts","../src/analyst/trace-tool-callback.ts","../src/analyst/dspy-rlm-engine.ts","../src/analyst/finding-subject.ts","../src/analyst/findings-store.ts","../src/analyst/kinds/control-integrity.ts","../src/analyst/kinds/failure-mode.ts","../src/analyst/kinds/improvement.ts","../src/analyst/kinds/knowledge-gap.ts","../src/analyst/kinds/knowledge-poisoning.ts","../src/analyst/kinds/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAuDY;UAEK;EACf;;EAEA;;EAEA;;EAEA,aAAa;;UAGE;EACf;EACA;;EAEA;EACA;EACA,UAAU;;UAGK;;EAEf;;EAEA;;EAEA,aAAa;IAAQ;IAAc;;;EAEnC,kBAAkB;;EAElB;EACA;;UAGe;EACf;EACA;;EAEA;EACA;EACA;EACA,UAAU;EACV;EACA;EACA;;EAEA;EACA;;;;;;;;KASU;UAQK;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA,MAAM;;EAEN,UAAU;EACV,aAAa;EACb;EACA,WAAW;EACX,SAAS;;;;;;EAMT,iBAAiB;;EAEjB,oBAAoB,QAAQ,OAAO;;cAKxB;;;;;;iBAkGS,wBACpB,OAAO,2BACP,SAAS,8BACR,QAAQ;;;UCjMM;;;;;EAKf,MAAM;;EAEN;;EAEA,UAAU;;EAEV;;EAEA;;EAEA,WAAW;;EAEX;;;;;;;;;;EAUA;;;;;;iBAkCc,sBAAsB,SAAS,yBAAyB;;;KCrG5D,0BAA0B;;;UCYrB;;EAEf,MAAM;;EAEN;;EAEA,kBAAkB,aAAa;EAC/B;;EAEA,UAAU;;EAEV;;EAEA;;;;;;EAMA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA,kBAAkB,QAAQ;;EAE1B;;;;;;;;;;EAUA;;EAEA,SAAS;;EAET;;;iBAIc,yBAAyB,SAAS,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KCtClE;EAEN;EAAwB;EAAc;;EACtC;EAAyB;;EACzB;EAAuB;;EACvB;EAAyB;;EAGzB;EAAuB;;EACvB;EAAe;;EACf;EAAkB;EAAc;;EAChC;EAAkB;;EAClB;EAAa;EAAgB;;EAC7B;EAAc;;EACd;EAAkB;;EAClB;EAAkB;;EAClB;EAAwB;;EACxB;EAAuB;;EACvB;EAAc;;EACd;EAAa;EAAgB;;EAC7B;EAAgB;;EAChB;EAAqB;;EACrB;EAAuB;;EAEvB;EAA4B;;EAC5B;EAA2B;;EAE3B;EAAiB;;KAEX,qBAAqB;cAEpB,uBAAuB,cAAc;;;;;;;;;;;;;;;;;iBAgGlC,oBAAoB,iCAAiC;;;;;;;iBAoHrD,qBAAqB,GAAG;;;;;;;;;;cA8D3B,wBAAwB,SAAS,OAAO;;;;;;;;;cAoExC,wBAAwB,eAAe,cAAc;;iBAqElD,+BAA+B;;;;;;;;UCxc9B,yBAAyB;EACxC;;cAGW;WAGiB;mBAFX;EAEjB,YAA4B;EAItB,OAAO,eAAe,UAAU,mBAAmB;;EAQzD,WAAW;;EAkBX,QAAQ,gBAAgB;;UAOT;;EAEf,UAAU;;EAEV,aAAa;;EAEb,WAAW;;;;;EAKX,SAAS;IAAQ,UAAU;IAAkB,SAAS;;;UAGvC;;;;;;;;EAQf,cAAc,UAAU,gBAAgB,SAAS;;;;;;iBAOnC,kBAAkB,GAAG,gBAAgB,GAAG;;;;;iBAWxC,aACd,UAAU,oBACV,SAAS,oBACT,SAAQ,aACP;;;;iBC7Fa,6BACd,OAAO,uBAAuB,mBAC9B,qBACC;;cA4BU,mCACA,oBAAoB,uBAAuB;WAE7C;WACA;WAEA;WACA;IAAS;IAAgC;;WACzC;WACA;aACP;aACA;;EAGI,QACJ,OAAO,uBAAuB,mBAC9B,KAAK,iBACJ,QAAQ;;cAUA,2BAAyB;;;cCHzB,wBAAwB;;;cC3BxB,uBAAuB;;;cCGvB,yBAAyB;;;cCPzB,+BAA+B;;;;;;;;;;;;cCP/B,sCAAsC"}