@tangle-network/agent-eval 0.216.0 → 0.217.1

package/dist/{index-DHKEAv3s.d.ts → index-9jJ2fKSX.d.ts}

@@ -26,11 +26,6 @@ interface AtomicFileLockOptions {
   readonly lockPath: string;
   readonly pid?: number;
 }
-declare class AtomicFileLockError extends Error {
-  readonly name = "AtomicFileLockError";
-}
-/** Report whether another lock path prevents acquisition without modifying it. */
-declare function probeAtomicFileLock(options: AtomicFileLockOptions): AtomicFileLockUnavailable | null;
 /**
  * Try to acquire a complete, uniquely-owned lock inode.
  *
@@ -49,14 +44,10 @@ interface LedgerFileContext {
     cause?: unknown;
   }): Error;
 }
-/** Append one already-serialized line; the write is fsynced (file and directory)
- * before returning so an acknowledged append survives a crash. */
-declare function appendLedgerLine(path: string, line: string, context: LedgerFileContext): void;
 /** Replace a small sidecar file whole: write a temporary sibling, fsync it,
  * then rename over the target. A reader therefore sees the previous contents
  * or the new ones, never a partial file. */
 declare function writeLedgerFileAtomically(path: string, contents: string, context: LedgerFileContext): void;
-declare function withLedgerFileLock<T>(path: string, context: LedgerFileContext, run: () => T): T;
 type FileLockResult<T> = {
   acquired: true;
   value: T;
@@ -76,14 +67,6 @@ interface LedgerAnchoredEntry {
   sequence: number;
   entryHash: LedgerHash;
 }
-/** Sibling pin file for a journal — deliberately NOT the journal, so rewriting
- * the log is not enough to rewrite the trust recorded about it. */
-declare function trustedHeadPathFor(journalPath: string): string;
-/** The pin, or null when this journal has never been pinned. A pin that exists
- * but does not parse is corruption or tamper of the trust record itself and
- * fails loudly: reporting it as "no pin" would silently downgrade what the
- * journal can prove. */
-declare function readTrustedHeadFile(path: string, context: LedgerFileContext): LedgerTrustedHead | null;
 /** Outcome of discarding a pin: the guarantee that was given up. `unreadable`
  * carries why the discarded pin could not be named — corruption, a permission
  * fault, a wrong file type — so a caller recording the decision never has to
@@ -111,12 +94,6 @@ interface LedgerTrustedHeadSubject {
    * of the two files carries the claim being enforced. */
   trustedHeadPath: string;
 }
-/** The entry at exactly `head.sequence` must still carry `head.entryHash`.
- * Entries must already have passed chain verification, which is what makes
- * index and sequence interchangeable here. An array serves as `entries`; a
- * journal that keeps no entries in memory passes a reader with the same
- * `length` and `at`. */
-declare function verifyEntriesAgainstTrustedHead(entries: Pick<readonly LedgerAnchoredEntry[], 'length' | 'at'>, head: LedgerTrustedHead, context: LedgerFileContext, naming: LedgerTrustedHeadSubject): void;
 //#endregion
 //#region src/ledger-core/journal.d.ts
 /** Minimum shape of a journal event: the idempotency key. */
@@ -312,28 +289,6 @@ interface LedgerTextStore {
   read(path: string): string | undefined;
   write(path: string, text: string): void;
 }
-/**
- * A journal for runs without a filesystem. It keeps its rows as text in a
- * store and applies the file journal's rules: the same row parse, hash chain,
- * idempotent append by `eventId`, and projector transition before a row is
- * kept. It has no lock, fsync or trusted head, because its rows live and die
- * with the process that holds the store.
- */
-declare class MemoryLedgerJournal<Header extends object, Event extends LedgerEventBase, Projection> {
-  readonly path: string;
-  private readonly codec;
-  private readonly store;
-  private verified;
-  constructor(path: string, codec: LedgerJournalCodec<Header, Event, Projection>, store: LedgerTextStore);
-  replay(): Promise<Projection>;
-  append(event: Event): Promise<LedgerAppendResult<LedgerEntryOf<Header, Event>, Projection>>;
-  /** Verify the stored text again whenever it is not the text this instance wrote. */
-  private sync;
-  /** A refused transition can leave the projector half applied; discard it. */
-  private guarded;
-}
-/** Verify and replay resolved immutable journal bytes without filesystem I/O. */
-declare function replayLedgerText<Header extends object, Event extends LedgerEventBase, Projection>(text: string, path: string, codec: LedgerJournalCodec<Header, Event, Projection>): Projection;
 //#endregion
 //#region src/ledger-core/merkle.d.ts
 /** Proof that one leaf is at `leafIndex` in a tree of `treeSize` leaves. */
@@ -354,8 +309,6 @@ type MerkleVerification = {
   readonly verified: false;
   readonly reason: string;
 };
-/** Root of the empty tree: SHA-256 of no bytes. */
-declare const MERKLE_EMPTY_ROOT: LedgerHash;
 /** A fresh random salt for {@link merkleLeafHash}: 32 bytes as 64 lowercase hex characters. */
 declare function merkleSalt(): string;
 /**
@@ -367,15 +320,8 @@ declare function merkleLeafHash(content: Uint8Array | string, salt?: string): Le
 declare function merkleRoot(leaves: readonly LedgerHash[]): LedgerHash;
 /** Inclusion proof for the leaf at `leafIndex` (RFC 9162 §2.1.3.1). */
 declare function merkleInclusionProof(leaves: readonly LedgerHash[], leafIndex: number): MerkleInclusionProof;
-/**
- * Consistency proof that the first `oldSize` leaves are the tree of that size
- * (RFC 9162 §2.1.4.1). Sizes 0 and `leaves.length` need no path.
- */
-declare function merkleConsistencyProof(leaves: readonly LedgerHash[], oldSize: number): MerkleConsistencyProof;
 /** Check that `leaf` is in the tree with `root` at the proof's index (RFC 9162 §2.1.3.2). */
 declare function verifyMerkleInclusion(leaf: LedgerHash, proof: MerkleInclusionProof, root: LedgerHash): MerkleVerification;
-/** Check that the tree with `newRoot` extends the tree with `oldRoot` (RFC 9162 §2.1.4.2). */
-declare function verifyMerkleConsistency(proof: MerkleConsistencyProof, oldRoot: LedgerHash, newRoot: LedgerHash): MerkleVerification;
 //#endregion
 //#region src/ledger-core/projector-snapshot.d.ts
 /** A cached projection and the pinned entry it was taken after. */
@@ -388,14 +334,6 @@ interface LedgerProjectorSnapshot {
   /** The codec's serialized projection. Opaque to this module. */
   projection: unknown;
 }
-/** Sibling cache file for a journal, alongside its `.head` pin. */
-declare function projectorSnapshotPathFor(journalPath: string): string;
-/** The cached snapshot, or null when none has been written. Present but
- * unparseable is corruption of the cache itself, not its absence, and fails
- * loudly for the same reason `readTrustedHeadFile` does: silently treating it
- * as "no cache" would just make the next read replay from scratch without
- * ever explaining why the cache stopped working. */
-declare function readProjectorSnapshotFile(path: string, context: LedgerFileContext): LedgerProjectorSnapshot | null;
 //#endregion
-export { LedgerTrustedHead as A, withLedgerFileLock as B, LedgerLineContext as C, MemoryLedgerJournal as D, LedgerTextStore as E, verifyEntriesAgainstTrustedHead as F, AtomicFileLockOptions as G, AtomicFileLock as H, FileLockResult as I, probeAtomicFileLock as J, AtomicFileLockOwner as K, LedgerFileContext as L, LedgerTrustedHeadSubject as M, readTrustedHeadFile as N, replayLedgerText as O, trustedHeadPathFor as P, appendLedgerLine as R, LedgerJournalCodec as S, LedgerProjectorSnapshotCodec as T, AtomicFileLockAcquisition as U, writeLedgerFileAtomically as V, AtomicFileLockError as W, tryAcquireAtomicFileLock as Y, LedgerAppendOptions as _, MerkleConsistencyProof as a, LedgerEntryOf as b, merkleConsistencyProof as c, merkleRoot as d, merkleSalt as f, FileLedgerJournalOptions as g, FileLedgerJournal as h, MERKLE_EMPTY_ROOT as i, LedgerTrustedHeadRemoval as j, LedgerAnchoredEntry as k, merkleInclusionProof as l, verifyMerkleInclusion as m, projectorSnapshotPathFor as n, MerkleInclusionProof as o, verifyMerkleConsistency as p, AtomicFileLockUnavailable as q, readProjectorSnapshotFile as r, MerkleVerification as s, LedgerProjectorSnapshot as t, merkleLeafHash as u, LedgerAppendResult as v, LedgerProjector as w, LedgerEventBase as x, LedgerChainFields as y, tryWithLedgerFileLock as z };
-//# sourceMappingURL=index-DHKEAv3s.d.ts.map
+export { AtomicFileLock as A, LedgerTrustedHead as C, LedgerFileContext as D, FileLockResult as E, tryAcquireAtomicFileLock as F, AtomicFileLockOptions as M, AtomicFileLockOwner as N, tryWithLedgerFileLock as O, AtomicFileLockUnavailable as P, LedgerAnchoredEntry as S, LedgerTrustedHeadSubject as T, LedgerJournalCodec as _, merkleInclusionProof as a, LedgerProjectorSnapshotCodec as b, merkleSalt as c, FileLedgerJournalOptions as d, LedgerAppendOptions as f, LedgerEventBase as g, LedgerEntryOf as h, MerkleVerification as i, AtomicFileLockAcquisition as j, writeLedgerFileAtomically as k, verifyMerkleInclusion as l, LedgerChainFields as m, MerkleConsistencyProof as n, merkleLeafHash as o, LedgerAppendResult as p, MerkleInclusionProof as r, merkleRoot as s, LedgerProjectorSnapshot as t, FileLedgerJournal as u, LedgerLineContext as v, LedgerTrustedHeadRemoval as w, LedgerTextStore as x, LedgerProjector as y };
+//# sourceMappingURL=index-9jJ2fKSX.d.ts.map

package/dist/index-9jJ2fKSX.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-9jJ2fKSX.d.ts","names":[],"sources":["../src/ledger-core/atomic-file-lock.ts","../src/ledger-core/journal-file.ts","../src/ledger-core/trusted-head.ts","../src/ledger-core/journal.ts","../src/ledger-core/merkle.ts","../src/ledger-core/projector-snapshot.ts"],"mappings":";;;UAiBiB;WACN;WACA;WACA;;UAGM;WACN,OAAO;EAChB;;KAGU;WACG;WAA0B;WAAyB,QAAQ;;WAC3D;WAA0B;;KAE7B;WACG;WAAyB,MAAM;IAC1C;UAEa;WACN;WACA;;;;;;;;iBA8BK,yBACd,SAAS,wBACR;;;;;UCpDc;;EAEf;EACA,eAAe,iBAAiB;IAAY;MAAoB;;;;;iBAkDlD,0BACd,cACA,kBACA,SAAS;KA6CC,eAAe;EAAO;EAAgB,OAAO;;EAAQ;;iBAEjD,sBAAsB,GACpC,cACA,SAAS,mBACT,WAAW,IACV,eAAe;;;;UCnED;EACf;EACA,WAAW;;;UAII;EACf;EACA,WAAW;;;;;;;;KA8FD;EACN;EAAe,MAAM;EAAmB;;EACxC;EAAe;EAAY;EAAoB;;EAC/C;EAAgB;;;UAsCL;;EAEf;;;EAGA;;;;;UC7Ie;EACf;;;;;UAMe,kBAAkB,cAAc;EAC/C;EACA,cAAc;EACd,OAAO;EACP,WAAW;;KAGD,cAAc,uBAAuB,cAAc,mBAAmB,SAChF,kBAAkB;UAEH;EACf;EACA;;;;;;;;;;UAWe,gBAAgB,OAAO;EACtC,MAAM,OAAO,OAAO;;;;EAIpB,YAAY;;;;;;;;;;UAWG,6BAA6B,OAAO;EACnD,UAAU,YAAY;EACtB,QAAQ,sBAAsB,gBAAgB,OAAO;;UAGtC,mBACf,uBACA,cAAc,iBACd,oBACQ;;EAER,QAAQ;EACR,cAAc,kBAAkB;;;;;;EAMhC,WAAW,cAAc,SAAS,oBAAoB,cAAc,QAAQ;;EAE5E,iBAAiB,OAAO,cAAc,QAAQ,QAAQ;EACtD,mBAAmB,gBAAgB,cAAc,QAAQ,QAAQ;EACjE,qBAAqB,6BAA6B,cAAc,QAAQ,QAAQ;;UAGjE,mBAAmB,OAAO;EACzC,OAAO;;EAEP;EACA,YAAY;;UAGG;;;;;;;;;;;;;;EAcf;;UAGe;;;;;;;EAOf;;;;;;EAMA;IAAsB;;;;;;cA2CX,kBAAkB,uBAAuB,cAAc,iBAAiB;WAC1E;;WAEA;;;WAGA;mBACQ;mBACA;mBACA;mBACA;UACT;EAER,YACE,cACA,OAAO,mBAAmB,QAAQ,OAAO,aACzC,UAAS;EAcL,UAAU,QAAQ;EAIlB,OACJ,OAAO,OACP,UAAS,sBACR,QAAQ,mBAAmB,cAAc,QAAQ,QAAQ;;EA+CtD,eAAe,QAAQ;;;;EAWvB,kBAAkB,QAAQ;;;;;;;;EAkC1B,oBAAoB,QAAQ;;;;UAsB1B;;;;UAgBA;UAwCA;;;;;;;;;;;;;UA2CA;;;;;;;;UAuBA;;;;UAiBA;;;;;;;;;;;;;;;UAwBA;;;;;;UAqIA;;;;UA+CO;EACf,KAAK;EACL,MAAM,cAAc;;;;;UC9qBL;WACN;WACA;WACA,eAAe;;;UAIT;WACN;WACA;WACA,eAAe;;KAGd;WACG;;WACA;WAA0B;;;iBAWzB;;;;;iBAQA,eAAe,SAAS,qBAAqB,gBAAgB;;iBAU7D,WAAW,iBAAiB,eAAe;;iBAM3C,qBACd,iBAAiB,cACjB,oBACC;;iBAea,sBACd,MAAM,YACN,OAAO,sBACP,MAAM,aACL;;;;UCtDc;EACf,MAAM;;;;EAIN;;EAEA"}

package/dist/{index-oQ4aHziK.d.ts → index-BLGqZ81N.d.ts}

@@ -1,12 +1,12 @@
-import { b as CustomTokenPricing, c as CostLedgerHandle } from "./cost-ledger-CO7UyEcQ.js";
-import { a as AnalystFinding, r as AnalystContext } from "./types-oKRhQAde.js";
-import { R as LlmThinkingMode, x as ChatClient } from "./types-DBZ7keha.js";
-import { F as ExternalOptimizerCallbackLimits, V as ExternalOptimizerModelCall, W as ExternalOptimizerModelExecutionObservation, q as ExternalOptimizerRunnerCommand } from "./agent-profile-CIA2Atnt.js";
-import { o as Severity } from "./multi-layer-verifier-BUaQ4C17.js";
-import { l as ExactCapableAnalyst } from "./exact-types-CD0lf5Qd.js";
-import { i as TraceAnalystDefinition } from "./default-registry-BrWh62zf.js";
-import { n as TraceAnalysisEngine } from "./engine-C_zNWfM8.js";
-import { C as SupervisorRunSources, w as SupervisorRunTree } from "./types-BqkVmHfv.js";
+import { a as CostLedgerHandle, p as CustomTokenPricing } from "./cost-ledger-Jk62OBfF.js";
+import { i as AnalystFinding, n as AnalystContext } from "./types-CW8ewATZ.js";
+import { I as LlmThinkingMode, x as ChatClient } from "./types-D-mgRzlh.js";
+import { G as ExternalOptimizerRunnerCommand, H as ExternalOptimizerModelExecutionObservation, N as ExternalOptimizerCallbackLimits, z as ExternalOptimizerModelCall } from "./agent-profile-DTt8uGP9.js";
+import { o as Severity } from "./multi-layer-verifier-DEgMUk6v.js";
+import { l as ExactCapableAnalyst } from "./exact-types-CflbJ9f3.js";
+import { i as TraceAnalystDefinition } from "./default-registry-DXgLmoDI.js";
+import { t as TraceAnalysisEngine } from "./engine-BvZ0R-36.js";
+import { b as SupervisorRunSources, x as SupervisorRunTree } from "./types-CmXY0PQf.js";
 //#region src/semantic-concept-judge.d.ts
 /**
  * Implementation complexity class for weighted scoring.
@@ -419,11 +419,6 @@ interface DiffPolicy {
    */
   isMaterial?: (previous: AnalystFinding, current: AnalystFinding) => boolean;
 }
-/**
- * Default materiality test. Deliberately narrow so LLM-reword churn
- * doesn't flood the diff. Stricter tests are opt-in via DiffPolicy.
- */
-declare function defaultIsMaterial(a: AnalystFinding, b: AnalystFinding): boolean;
 /**
  * Diff two findings sets by stable finding_id. Callers typically load
  * the two run-id slices from the same store and pass them in.
@@ -475,5 +470,5 @@ 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-oQ4aHziK.d.ts.map
+export { SemanticConceptJudgeOptions as A, createDspyRlmTraceEngine as C, ConceptSpec as D, ConceptFinding as E, runSemanticConceptJudge as M, SEMANTIC_CONCEPT_JUDGE_VERSION as O, DspyRlmTraceEngineOptions as S, createChatTraceEngine as T, FindingSubjectKind as _, FAILURE_MODE_KIND_SPEC as a, parseFindingSubject as b, emitControlIntegrityFindings as c, FindingsStore as d, PersistedFinding as f, FindingSubject as g, FINDING_SUBJECT_SYNTAX as h, IMPROVEMENT_KIND_SPEC as i, SemanticConceptJudgeResult as j, SemanticConceptJudgeInput as k, DiffPolicy as l, FINDING_SUBJECT_KINDS as m, KNOWLEDGE_POISONING_KIND_SPEC as n, CONTROL_INTEGRITY_ANALYST as o, diffFindings as p, KNOWLEDGE_GAP_KIND_SPEC as r, ControlIntegrityAnalyst as s, DEFAULT_TRACE_ANALYST_KINDS as t, FindingsDiff as u, KIND_EXPECTED_SUBJECTS as v, ChatTraceEngineOptions as w, renderFindingSubject as x, findingSubjectGrammarPromptFor as y };
+//# sourceMappingURL=index-BLGqZ81N.d.ts.map

package/dist/{index-oQ4aHziK.d.ts.map → index-BLGqZ81N.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"index-oQ4aHziK.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-BLGqZ81N.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;;;UChMM;;;;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KCvClE;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;;;;;;;;;;;;;;;;;iBA0FlC,oBAAoB,iCAAiC;;;;;;;iBAoHrD,qBAAqB,GAAG;;;;;;;;;;cA8D3B,wBAAwB,SAAS,OAAO;;;;;;;;;cAoExC,wBAAwB,eAAe,cAAc;;iBAqElD,+BAA+B;;;;;;;;UClc9B,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;;;;;;iBAkBnC,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"}

package/dist/{index-DlH0Y9gI.d.ts → index-BiT6RtNH.d.ts}

@@ -1,15 +1,15 @@
-import { c as CostLedgerHandle } from "./cost-ledger-CO7UyEcQ.js";
-import { a as RunRecord, c as RunSplitTag, n as RunCostProvenance } from "./run-record-D1Hw-Jml.js";
-import "./types-oKRhQAde.js";
-import "./statistical-heldout-BeR4bOdg.js";
-import "./types-B4C5nFw6.js";
-import "./index-NvGBiO8H.js";
-import { p as TraceSpanEvent } from "./client-BzL9niqi.js";
-import { d as InsightReport, t as AnalyzeRunsOptions } from "./analyze-runs-CSDAh8A7.js";
-import "./define-agent-eval-CEWkX5wZ.js";
-import "./default-registry-BrWh62zf.js";
+import { a as CostLedgerHandle } from "./cost-ledger-Jk62OBfF.js";
+import { a as RunRecord, c as RunSplitTag, n as RunCostProvenance } from "./run-record-CaxbLq6Y.js";
+import "./types-CW8ewATZ.js";
+import "./statistical-heldout-C9AbgREN.js";
+import "./index-ZuWx52WG.js";
+import "./types-D8GhJoHk.js";
+import { f as TraceSpanEvent } from "./client-hwo3cJjR.js";
+import { d as InsightReport, t as AnalyzeRunsOptions } from "./analyze-runs-DyeNcenW.js";
+import "./define-agent-eval-BIkH_gAR.js";
+import "./default-registry-DXgLmoDI.js";
 import { AgentCandidateBenchmarkCellRef, AgentCandidateBenchmarkSuiteInputs, AgentCandidateBenchmarkTask, AgentCandidateBenchmarkTaskMaterial, AgentCandidateBundle, AgentCandidateEvaluationPolicy, AgentCandidateExperiment, AgentCandidateExperimentMaterial, AgentCandidateExperimentMeasurement, AgentImprovementCost, AgentImprovementMeasuredComparison, AgentProfileImprovementExperiment, AgentProfileImprovementExperimentMaterial, AgentProfileImprovementMeasuredComparison, AgentProfileImprovementMeasurement, AgentProfileImprovementRunCell, AgentProfileImprovementRunReceipt, AgentProfileImprovementSuiteInputs, AgentProfileImprovementTask, AgentProfileImprovementTaskMaterial, CandidateExecutionEvidence, Sha256Digest } from "@tangle-network/agent-interface";
-//#region src/contract/measured-comparison.d.ts
+//#region src/contract/measured-comparison-types.d.ts
 interface SealCandidateBenchmarkSuiteOptions {
   tasks: [AgentCandidateBenchmarkTask, ...AgentCandidateBenchmarkTask[]];
   reps: number;
@@ -89,6 +89,8 @@ type PairedMeasurementEvaluation = Pick<AgentImprovementMeasuredComparison, 'ove
   totalCost: AgentImprovementCost;
   measurementWorkDurationMs: number;
 };
+//#endregion
+//#region src/contract/candidate-experiment.d.ts
 /** Content-address one task before any measured execution can see it. */
 declare function sealCandidateBenchmarkTask(material: AgentCandidateBenchmarkTaskMaterial): AgentCandidateBenchmarkTask;
 /** Freeze task order, repetitions, and every seed before either arm runs. */
@@ -98,6 +100,12 @@ declare function sealCandidateExperiment(material: AgentCandidateExperimentMater
 declare function verifyCandidateExperiment(input: unknown): AgentCandidateExperiment;
 /** Execute each signed cell for both arms. The callback is Runtime's one executor. */
 declare function runCandidateExperiment(options: RunCandidateExperimentOptions): Promise<CandidateExperimentRun>;
+/** Build the only publishable comparison: paired statistics over Runtime receipts. */
+declare function measuredComparisonFromCandidateExperiment(options: CompareCandidateExperimentOptions): AgentImprovementMeasuredComparison;
+/** Recompute every statistic and decision from the signed experiment receipts. */
+declare function verifyCandidateExperimentComparison(input: unknown): AgentImprovementMeasuredComparison;
+//#endregion
+//#region src/contract/paired-measurement-evaluation.d.ts
 /**
  * Calculate the shared paired decision from any complete receipt shape.
  *
@@ -106,10 +114,6 @@ declare function runCandidateExperiment(options: RunCandidateExperimentOptions):
  * only validates the projected measurements and derives their shared decision.
  */
 declare function evaluatePairedMeasurements<TRun>(options: EvaluatePairedMeasurementsOptions<TRun>): PairedMeasurementEvaluation;
-/** Build the only publishable comparison: paired statistics over Runtime receipts. */
-declare function measuredComparisonFromCandidateExperiment(options: CompareCandidateExperimentOptions): AgentImprovementMeasuredComparison;
-/** Recompute every statistic and decision from the signed experiment receipts. */
-declare function verifyCandidateExperimentComparison(input: unknown): AgentImprovementMeasuredComparison;
 //#endregion
 //#region src/contract/profile-measured-comparison.d.ts
 interface SealAgentProfileImprovementSuiteOptions {
@@ -212,15 +216,6 @@ interface FromRunRecordDirResult {
   /** The files that were read, in the order they were processed. */
   files: string[];
 }
-/**
- * Resolve a file or directory path into validated `RunRecord[]`.
- *
- * A `.json` file must parse to a top-level array; a `.jsonl` file is one
- * record per non-empty line. Directories are read shallowly by default
- * (set `recursive` to descend); the `analysis.json` output artifact is
- * always excluded.
- */
-declare function fromRunRecordDir(path: string, options?: FromRunRecordDirOptions): Promise<FromRunRecordDirResult>;
 //#endregion
 //#region src/contract/eval-reporting-suite.d.ts
 /** Either records in hand or a path to a `.json` / `.jsonl` file or a
@@ -269,12 +264,6 @@ interface EvalReportingSuiteResult {
   /** The path `analysis.json` was written to, or null when `write` was unset. */
   writtenTo: string | null;
 }
-/**
- * Resolve runs (or a run dir/file), run `analyzeRuns`, and optionally persist a
- * single `analysis.json`. The only analysis logic lives in `analyzeRuns`; this
- * function is composition + I/O.
- */
-declare function evalReportingSuite(input: EvalReportingSuiteInput, options?: EvalReportingSuiteOptions): Promise<EvalReportingSuiteResult>;
 //#endregion
 //#region src/contract/intake/agent-trace.d.ts
 type AgentTraceContributorType = 'human' | 'ai' | 'mixed' | 'unknown';
@@ -354,6 +343,11 @@ interface PartitionByAuthoringModelResult {
 declare function partitionRunsByAuthoringModel(runs: RunRecord[], index: AgentTraceIndex): PartitionByAuthoringModelResult;
 //#endregion
 //#region src/contract/intake/code-agent-observation.d.ts
+/**
+ * Where a session came from. `pi` is a native Pi session (`~/.pi/agent/sessions/*.jsonl`), read
+ * through @tangle-network/harness-sessions; `pi-graph` is the graph IR a Pi graph run exports
+ * (`nodes[].ir.kind`), which is not a Pi session.
+ */
 type CodeAgentSessionSource = 'codex' | 'claude-code' | 'opencode' | 'kimi-code' | 'pi' | 'pi-graph';
 type CodeAgentSessionTerminalStatus = 'completed' | 'failed' | 'unknown';
 type CodeAgentSessionActionKind = 'tool' | 'patch' | 'terminal' | 'graph-completion';
@@ -398,7 +392,7 @@ interface ObserveCodeAgentSessionOptions {
  */
 declare function observeCodeAgentSession(options: ObserveCodeAgentSessionOptions): CodeAgentSessionObservation;
 //#endregion
-//#region src/contract/intake/code-agent-session.d.ts
+//#region src/contract/intake/code-agent-session-types.d.ts
 interface ParsedCodeAgentJsonl {
   entries: unknown[];
   malformedLines: number;
@@ -495,6 +489,8 @@ type CodeAgentJsonlLine = {
   kind: 'malformed';
   lineNumber: number;
 };
+//#endregion
+//#region src/contract/intake/code-agent-jsonl.d.ts
 declare function parseCodeAgentJsonl(jsonl: string): ParsedCodeAgentJsonl;
 /** Reads a transcript one line at a time and never holds the file as a single
  *  string. `parseCodeAgentJsonl` needs the whole file in one string, so a
@@ -511,14 +507,14 @@ declare function streamCodeAgentJsonlFile(path: string): AsyncGenerator<CodeAgen
  *  above the string ceiling. The entry array still grows with the transcript;
  *  consume `streamCodeAgentJsonlFile` directly when memory must stay flat. */
 declare function parseCodeAgentJsonlFile(path: string): Promise<ParsedCodeAgentJsonl>;
+//#endregion
+//#region src/contract/intake/code-agent-session.d.ts
 declare function fromCodexSession(options: CodeAgentSessionIntakeOptions): CodeAgentSessionIntakeResult;
 declare function fromClaudeCodeSession(options: CodeAgentSessionIntakeOptions): CodeAgentSessionIntakeResult;
 declare function fromOpenCodeSession(options: CodeAgentSessionIntakeOptions): CodeAgentSessionIntakeResult;
 declare function fromKimiCodeSession(options: CodeAgentSessionIntakeOptions): CodeAgentSessionIntakeResult;
 /** A native Pi session (`~/.pi/agent/sessions/<cwd>/<ts>_<id>.jsonl`), parsed entries in order. */
 declare function fromPiSession(options: CodeAgentSessionIntakeOptions): CodeAgentSessionIntakeResult;
-/** The graph IR a Pi graph run exports (`nodes[].ir`), which is not a Pi session. */
-declare function fromPiGraphSession(options: CodeAgentSessionIntakeOptions): CodeAgentSessionIntakeResult;
 //#endregion
 //#region src/contract/intake/code-agent-store.d.ts
 /** Which store to read, and what makes a session in it belong to this run. */
@@ -592,14 +588,6 @@ type CodeAgentStoreObservation = {
   readonly reason: string;
   readonly rejections: CodeAgentStoreRejections;
 };
-/**
- * Read every session this run captured under `scope.root` and project them.
- *
- * A store directory that does not exist, or that holds no session the scope attributes, returns
- * `status: 'unavailable'`. That is not an error: a run whose harness store was never synced back
- * has no evidence, and saying so is the correct answer.
- */
-declare function observeCodeAgentStore(scope: CodeAgentStoreScope): Promise<CodeAgentStoreObservation>;
 //#endregion
 //#region src/contract/intake/feedback-table.d.ts
 interface FeedbackTableRow {
@@ -689,5 +677,5 @@ interface FromOtelSpansOptions {
 }
 declare function fromOtelSpans(opts: FromOtelSpansOptions): RunRecord[];
 //#endregion
-export { FromRunRecordDirOptions as $, CodeAgentSessionActionKind as A, verifyCandidateExperimentComparison as At, AgentTraceConversation as B, fromOpenCodeSession as C, evaluatePairedMeasurements as Ct, parseCodeAgentJsonlFile as D, sealCandidateBenchmarkTask as Dt, parseCodeAgentJsonl as E, sealCandidateBenchmarkSuite as Et, CodeAgentSessionSource as F, AuthoringProvenance as G, AgentTraceIndex as H, CodeAgentSessionTerminalStatus as I, partitionRunsByAuthoringModel as J, PartitionByAuthoringModelResult as K, observeCodeAgentSession as L, CodeAgentSessionActionSurface as M, CodeAgentSessionExecutionReceipt as N, streamCodeAgentJsonlFile as O, sealCandidateExperiment as Ot, CodeAgentSessionObservation as P, evalReportingSuite as Q, AgentTraceContributor as R, fromKimiCodeSession as S, SealCandidateBenchmarkSuiteOptions as St, fromPiSession as T, runCandidateExperiment as Tt, AgentTraceRange as U, AgentTraceFile as V, AgentTraceRecord as W, EvalReportingSuiteOptions as X, EvalReportingSuiteInput as Y, EvalReportingSuiteResult as Z, CodeAgentSessionIntakeResult as _, EvaluatePairedMeasurementsOptions as _t, FromFeedbackTableOptions as a, CompareAgentProfileImprovementExperimentOptions as at, fromClaudeCodeSession as b, PairedMeasurementEvaluation as bt, CodeAgentStoreObservation as c, measuredComparisonFromAgentProfileImprovementExperiment as ct, CodeAgentStoreScope as d, sealAgentProfileImprovementSuite as dt, FromRunRecordDirResult as et, CodeAgentStoreSession as f, sealAgentProfileImprovementTask as ft, CodeAgentSessionIntakeOptions as g, CompareCandidateExperimentOptions as gt, CodeAgentSessionDiagnostic as h, CandidateExperimentRun as ht, FeedbackTableRow as i, AgentProfileImprovementExperimentRun as it, CodeAgentSessionActionStatus as j, CodeAgentSessionAction as k, verifyCandidateExperiment as kt, CodeAgentStoreRejection as l, runAgentProfileImprovementExperiment as lt, CodeAgentJsonlLine as m, CandidateExperimentExecutionInput as mt, fromOtelSpans as n, fromRunRecordDir as nt, FromFeedbackTableResult as o, RunAgentProfileImprovementExperimentOptions as ot, observeCodeAgentStore as p, verifyAgentProfileImprovementExperimentComparison as pt, parseAgentTrace as q, FeedbackTableMeta as r, AgentProfileImprovementExperimentExecutionInput as rt, fromFeedbackTable as s, SealAgentProfileImprovementSuiteOptions as st, FromOtelSpansOptions as t, RunRecordRejection as tt, CodeAgentStoreRejections as u, sealAgentProfileImprovementExperiment as ut, CodeAgentSessionMetrics as v, PairedMeasurement as vt, fromPiGraphSession as w, measuredComparisonFromCandidateExperiment as wt, fromCodexSession as x, RunCandidateExperimentOptions as xt, ParsedCodeAgentJsonl as y, PairedMeasurementAdapter as yt, AgentTraceContributorType as z };
-//# sourceMappingURL=index-DlH0Y9gI.d.ts.map
+export { AgentProfileImprovementExperimentExecutionInput as $, CodeAgentSessionActionSurface as A, AgentTraceIndex as B, CodeAgentSessionIntakeOptions as C, PairedMeasurementAdapter as Ct, CodeAgentSessionAction as D, ParsedCodeAgentJsonl as E, SealCandidateBenchmarkSuiteOptions as Et, observeCodeAgentSession as F, parseAgentTrace as G, AgentTraceRecord as H, AgentTraceContributor as I, EvalReportingSuiteOptions as J, partitionRunsByAuthoringModel as K, AgentTraceContributorType as L, CodeAgentSessionObservation as M, CodeAgentSessionSource as N, CodeAgentSessionActionKind as O, CodeAgentSessionTerminalStatus as P, RunRecordRejection as Q, AgentTraceConversation as R, CodeAgentSessionDiagnostic as S, PairedMeasurement as St, CodeAgentSessionMetrics as T, RunCandidateExperimentOptions as Tt, AuthoringProvenance as U, AgentTraceRange as V, PartitionByAuthoringModelResult as W, FromRunRecordDirOptions as X, EvalReportingSuiteResult as Y, FromRunRecordDirResult as Z, fromPiSession as _, verifyCandidateExperimentComparison as _t, FromFeedbackTableOptions as a, runAgentProfileImprovementExperiment as at, streamCodeAgentJsonlFile as b, CompareCandidateExperimentOptions as bt, CodeAgentStoreObservation as c, sealAgentProfileImprovementTask as ct, CodeAgentStoreScope as d, measuredComparisonFromCandidateExperiment as dt, AgentProfileImprovementExperimentRun as et, CodeAgentStoreSession as f, runCandidateExperiment as ft, fromOpenCodeSession as g, verifyCandidateExperiment as gt, fromKimiCodeSession as h, sealCandidateExperiment as ht, FeedbackTableRow as i, measuredComparisonFromAgentProfileImprovementExperiment as it, CodeAgentSessionExecutionReceipt as j, CodeAgentSessionActionStatus as k, CodeAgentStoreRejection as l, verifyAgentProfileImprovementExperimentComparison as lt, fromCodexSession as m, sealCandidateBenchmarkTask as mt, fromOtelSpans as n, RunAgentProfileImprovementExperimentOptions as nt, FromFeedbackTableResult as o, sealAgentProfileImprovementExperiment as ot, fromClaudeCodeSession as p, sealCandidateBenchmarkSuite as pt, EvalReportingSuiteInput as q, FeedbackTableMeta as r, SealAgentProfileImprovementSuiteOptions as rt, fromFeedbackTable as s, sealAgentProfileImprovementSuite as st, FromOtelSpansOptions as t, CompareAgentProfileImprovementExperimentOptions as tt, CodeAgentStoreRejections as u, evaluatePairedMeasurements as ut, parseCodeAgentJsonl as v, CandidateExperimentExecutionInput as vt, CodeAgentSessionIntakeResult as w, PairedMeasurementEvaluation as wt, CodeAgentJsonlLine as x, EvaluatePairedMeasurementsOptions as xt, parseCodeAgentJsonlFile as y, CandidateExperimentRun as yt, AgentTraceFile as z };
+//# sourceMappingURL=index-BiT6RtNH.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-BiT6RtNH.d.ts","names":[],"sources":["../src/contract/measured-comparison-types.ts","../src/contract/candidate-experiment.ts","../src/contract/paired-measurement-evaluation.ts","../src/contract/profile-measured-comparison.ts","../src/contract/intake/run-record-dir.ts","../src/contract/eval-reporting-suite.ts","../src/contract/intake/agent-trace.ts","../src/contract/intake/code-agent-observation.ts","../src/contract/intake/code-agent-session-types.ts","../src/contract/intake/code-agent-jsonl.ts","../src/contract/intake/code-agent-session.ts","../src/contract/intake/code-agent-store.ts","../src/contract/intake/feedback-table.ts","../src/contract/intake/otel-spans.ts"],"mappings":"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"}

package/dist/{index-Ch9VxCpK.d.ts → index-CX-GAUpw.d.ts}

@@ -1,5 +1,5 @@
-import { p as CostProvenance } from "./cost-ledger-CO7UyEcQ.js";
-import { t as DefaultVerdict } from "./verdict-E4eRNf7-.js";
+import { l as CostProvenance } from "./cost-ledger-Jk62OBfF.js";
+import { t as DefaultVerdict } from "./verdict-C24NELtN.js";
 //#region src/matrix/cell-spend.d.ts
 /**
  * Spend carrier for a cell that fails after it has already spent money.
@@ -43,10 +43,6 @@ interface CellSpend {
  * because `NaN >= ceiling` is false.
  */
 declare function withCellSpend(error: unknown, spend: CellSpend): unknown;
-/** Read the spend a thrown value carries. `undefined` when the value carries
- *  none, or carries one that does not satisfy `CellSpend` — the runner records
- *  both as `uncaptured`. */
-declare function readCellSpend(error: unknown): CellSpend | undefined;
 //#endregion
 //#region src/matrix/types.d.ts
 /** One axis = one dimension to iterate. `V` is the value type — pass any
@@ -194,5 +190,5 @@ interface RunAgentMatrixOptions<Output> {
 //#region src/matrix/runner.d.ts
 declare function runAgentMatrix<Output>(opts: RunAgentMatrixOptions<Output>): Promise<MatrixResult<Output>>;
 //#endregion
-export { MatrixCell as a, CellSpend as c, MatrixAxis as i, readCellSpend as l, AxisSummary as n, MatrixResult as o, CellResult as r, RunAgentMatrixOptions as s, runAgentMatrix as t, withCellSpend as u };
-//# sourceMappingURL=index-Ch9VxCpK.d.ts.map
+export { MatrixCell as a, CellSpend as c, MatrixAxis as i, withCellSpend as l, AxisSummary as n, MatrixResult as o, CellResult as r, RunAgentMatrixOptions as s, runAgentMatrix as t };
+//# sourceMappingURL=index-CX-GAUpw.d.ts.map

package/dist/index-CX-GAUpw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-CX-GAUpw.d.ts","names":[],"sources":["../src/matrix/cell-spend.ts","../src/matrix/types.ts","../src/matrix/runner.ts"],"mappings":";;;;;;;;;;;;;;;;;;UAsBiB;;;;EAIf;;EAEA;;;;EAIA;;;;;;;;;;;;;;;;iBAiBc,cAAc,gBAAgB,OAAO;;;;;UC/BpC,WAAW;;EAE1B;;EAEA,QAAQ;IAAQ;IAAY,OAAO;;;;EAGnC,SAAS,OAAO,GAAG;;;UAIJ;EACf,MAAM;IAAiB;IAAY;;;EAEnC;;EAEA;;UAGe,WAAW;EAC1B,QAAQ;EACR,SAAS;;;;EAIT;EACA;EACA;;;;;;;;;;;EAWA,iBAAiB;;;;EAIjB;IAAU;IAAiB;;;UAGZ;EACf;EACA;EACA;EACA;EACA;EACA;EACA;;;EAGA;;EAEA;EACA;;UAGe,aAAa;EAC5B,OAAO;IAAQ,MAAM;IAAY,MAAM,WAAW;;;;EAGlD,QAAQ,eAAe,eAAe;EACtC;IACE;IACA;;;IAGA;IACA;IACA;;;;IAIA;;;;IAIA;;;;IAIA;IACA;;;EAGF;;UAGe,sBAAsB;EACrC,MAAM;;;;;;EAMN,UAAU,MAAM,eAAe,QAAQ,WAAW;;EAElD;;EAEA,UAAU,MAAM,KAAK;;EAErB;;EAEA;;;;;EAKA;;;;;;;;;;;;;EAaA;;EAEA,kBAAkB,MAAM,YAAY,QAAQ,WAAW;;;EAGvD,SAAS;;;;iBC1BW,eAAe,QACnC,MAAM,sBAAsB,UAC3B,QAAQ,aAAa"}

package/dist/{index-CPJJr98o.d.ts → index-CiRwLv2R.d.ts}

@@ -1,7 +1,7 @@
 import { a as MintedRolloutLine, b as RolloutSplit, g as RolloutOutcome, h as RolloutLine, i as GatedEvidence, t as ChatMessage, w as ToolDef } from "./schema-C-ziyJD7.js";
-import "./mint-DCGoBYhB.js";
-import { a as SftRow, r as RftItem, s as VerifiersRolloutOutput } from "./exporters-ChTnR90l.js";
-import { HarnessSession, SessionRef } from "@tangle-network/harness-sessions";
+import "./reward-DrZ71vnf.js";
+import "./mint-BRZXuwRi.js";
+import "@tangle-network/harness-sessions";
 //#region src/rollout/gate-checks.d.ts
 /**
  * Every gate check in the package, in the order they are applied.
@@ -190,9 +190,6 @@ type GateEntryPoint = keyof typeof GATE_POLICIES;
 declare function gateErrors(subject: GateSubject, policy: GatePolicy): string[];
 //#endregion
 //#region src/rollout/interchange/harbor.d.ts
-declare const ATIF_SCHEMA_VERSION = "ATIF-v1.7";
-/** Gap note on every imported line — ATIF carries no verdict, so nothing is scored. */
-declare const HARBOR_IMPORT_GAP = "imported from Harbor ATIF; no verdict";
 type HarborStepSource = 'system' | 'user' | 'agent';
 interface HarborImageSource {
   media_type: string;
@@ -346,26 +343,9 @@ declare function appendRolloutLines(path: string, lines: RolloutLine[]): Promise
  * line is refused rather than exported.
  */
 declare function readRolloutLedger(path: string): Promise<MintedRolloutLine[]>;
-/**
- * Read a ledger under the WRITE-side policy (`validateRolloutLine`), which
- * omits the unscreened-reward check. `writeRolloutLedger` accepts a
- * supervision-journal row (`realness_screened: false` with a positive reward
- * — the documented `unscreenedRewardFields` shape), and `GATE_POLICIES` says
- * such rows "must stay writable, readable and reportable"; a read API that
- * only re-validated under `assertMinted` made every such file unreadable —
- * write-accepted but read-refused is a data-loss trap.
- *
- * The result is `RolloutLine[]`, NOT `MintedRolloutLine[]`: nothing read here
- * can reach a training exporter without passing `assertMinted`, so the
- * promotion gate (which DOES enforce unscreened-reward) is exactly as closed
- * as before. Use `readRolloutLedger` when the file is training data.
- */
-declare function readRolloutJournal(path: string): Promise<RolloutLine[]>;
 //#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. */
-declare function claudeProjectSlug(cwd: string): string;
 interface ClaudeTranscriptRef {
   sessionId: string;
   path: string;
@@ -396,11 +376,6 @@ interface ReadClaudeTranscriptOptions {
    */
   readonly includeSidechain?: boolean;
 }
-/**
- * The messages+usage projection of a normalized session. A usage field is null when any answered
- * model call did not report it, so a partial sum is never mistaken for the session's usage.
- */
-declare function transcriptFromSession(session: HarnessSession): ClaudeTranscript;
 /** Read one transcript file. */
 declare function readClaudeTranscript(path: string, options?: ReadClaudeTranscriptOptions): Promise<ClaudeTranscript>;
 /** Parse retained JSONL text without another file or store; source gaps remain explicit. */
@@ -408,17 +383,12 @@ declare function parseClaudeTranscript(raw: string, options?: ReadClaudeTranscri
 //#endregion
 //#region src/rollout/readers/opencode-sqlite.d.ts
 declare const DEFAULT_OPENCODE_DB: string;
-/** Sessions whose cwd is `directory` (the worker-clone join key), oldest first. */
-declare function findOpencodeSessionsByDirectory(directory: string, db?: string): Promise<SessionRef[]>;
-/** One session, normalized. */
-declare function readOpencodeSession(sessionId: string, db?: string): Promise<HarnessSession>;
 /** One session's canonical messages: each model step, then the results of its tool calls. */
 declare function readOpencodeSessionMessages(sessionId: string, db?: string): Promise<ChatMessage[]>;
 //#endregion
 //#region src/rollout/release/gate-report.d.ts
 /** What a format does with a line the realness gate flagged. */
 type GateDisposition = 'exclude' | 'zero-and-flag';
-declare const FORMAT_GATE_DISPOSITION: Record<ReleaseFormat, GateDisposition>;
 /** What the gate accounting reads off an emitted row, per format. */
 interface ReleaseRowRef {
   rollout_id: string;
@@ -519,22 +489,6 @@ interface GateReport {
   gatedLines: number;
   byFormat: Partial<Record<ReleaseFormat, FormatGateCounts>>;
 }
-/** Rollout ids of every gated line, the key the emitted rows are matched on. */
-declare function gatedRolloutIds(lines: readonly MintedRolloutLine[]): Set<string>;
-/**
- * Row refs per format. Written as one adapter per format so that the knowledge
- * of WHERE the id and reward live in each published shape sits next to the
- * assertion that uses it — an exporter that moves either field breaks here
- * rather than silently reporting zero gated rows.
- */
-declare const releaseRowRefs: {
-  sft: (rows: readonly SftRow[]) => ReleaseRowRef[];
-  verifiers: (rows: readonly VerifiersRolloutOutput[]) => ReleaseRowRef[];
-  rft: (rows: readonly RftItem[]) => ReleaseRowRef[];
-  raw: (lines: readonly MintedRolloutLine[]) => ReleaseRowRef[];
-};
-/** Measure one format's gated rows from the refs of the rows about to be written. */
-declare function measureFormatGate(gated: ReadonlySet<string>, refs: readonly ReleaseRowRef[]): FormatGateCounts;
 /**
  * Fail the build when the measurement disagrees with the declared policy.
  *
@@ -561,18 +515,7 @@ interface ScrubRule {
 }
 /** Rule name → number of matches rewritten. Always carries every rule (0 is data). */
 type ScrubCounts = Record<string, number>;
-declare function emptyScrubCounts(): ScrubCounts;
-declare function addScrubCounts(into: ScrubCounts, from: ScrubCounts): ScrubCounts;
 declare function scrubText(text: string, counts: ScrubCounts): string;
-/**
- * Scrub every string value in a line; structure and key order are preserved.
- *
- * `assertMinted` on the way out rather than a cast: scrubbing rebuilds the
- * object, so the brand has to be re-earned, and re-validating proves the rules
- * did not rewrite a field the schema constrains (`reward` is a number, not a
- * string, so no rule should ever touch it — this is what checks that).
- */
-declare function scrubRolloutLine(line: MintedRolloutLine, counts: ScrubCounts): MintedRolloutLine;
 declare function scrubLines(lines: MintedRolloutLine[]): {
   lines: MintedRolloutLine[];
   counts: ScrubCounts;
@@ -589,8 +532,6 @@ declare function defaultRolloutScrubber(text: string): string;
 //#region src/rollout/release/card.d.ts
 declare const RELEASE_FORMATS: readonly ['sft', 'verifiers', 'rft', 'raw'];
 type ReleaseFormat = (typeof RELEASE_FORMATS)[number];
-/** Format → data file path inside the dataset dir (train split only). */
-declare const FORMAT_FILES: Record<ReleaseFormat, string>;
 interface DatasetCardInputs {
   /** Scrubbed, release-filtered lines (what actually ships). */
   lines: MintedRolloutLine[];
@@ -640,14 +581,10 @@ interface BuildSummary {
   files: string[];
 }
 declare function buildHfDataset(inputs: string[], options: BuildOptions): Promise<BuildSummary>;
-declare function planPushCommand(repo: string, outDir: string): string[];
 interface RolloutReleaseCliArgs extends BuildOptions {
   inputs: string[];
   push: string | null;
 }
-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 { HarborAgent as $, measureFormatGate as A, ReadClaudeTranscriptOptions as B, FORMAT_GATE_DISPOSITION as C, GatePolicy as Ct, ReleaseRowRef as D, GateReport as E, readOpencodeSessionMessages as F, transcriptFromSession as G, findClaudeTranscripts as H, ClaudeTranscript as I, readRolloutLedger as J, appendRolloutLines as K, ClaudeTranscriptRef as L, DEFAULT_OPENCODE_DB as M, findOpencodeSessionsByDirectory as N, assertGateReport as O, readOpencodeSession as P, HARBOR_IMPORT_GAP as Q, ClaudeUsageTotals as R, EmittedEvidence as S, GateEntryPoint as St, GateDisposition as T, gatedEvidenceOf as Tt, parseClaudeTranscript as U, claudeProjectSlug as V, readClaudeTranscript as W, ATIF_SCHEMA_VERSION as X, writeRolloutLedger as Y, FromHarborOptions as Z, defaultRolloutScrubber as _, GATE_POLICIES as _t, buildHfDataset as a, HarborObservationResult as at, scrubRolloutLine as b, GateCheckId as bt, runRolloutReleaseCli as c, HarborSubagentTrajectoryRef as ct, RELEASE_FORMATS as d, fromHarborTrajectory as dt, HarborContentPart as et, ReleaseFormat as f, relabelImportedSplit as ft, addScrubCounts as g, GATE_CHECK_IDS as gt, ScrubRule as h, GATE_CHECKS as ht, ScrubReport as i, HarborObservation as it, releaseRowRefs as j, gatedRolloutIds as k, DatasetCardInputs as l, HarborToolCall as lt, ScrubCounts as m, toHarborTrajectory as mt, BuildSummary as n, HarborImageSource as nt, parseRolloutReleaseArgs as o, HarborStep as ot, buildDatasetCard as p, toHarborTrajectories as pt, readRolloutJournal as q, RolloutReleaseCliArgs as r, HarborMetrics as rt, planPushCommand as s, HarborStepSource as st, BuildOptions as t, HarborFinalMetrics as tt, FORMAT_FILES as u, HarborTrajectory as ut, emptyScrubCounts as v, GateCheck as vt, FormatGateCounts as w, gateErrors as wt, scrubText as x, GateCheckedOutcome as xt, scrubLines as y, GateCheckDisposition as yt, DEFAULT_CLAUDE_PROJECTS_DIR as z };
-//# sourceMappingURL=index-CPJJr98o.d.ts.map
+export { GateCheck as $, appendRolloutLines as A, HarborObservationResult as B, ClaudeTranscriptRef as C, findClaudeTranscripts as D, ReadClaudeTranscriptOptions as E, HarborContentPart as F, HarborTrajectory as G, HarborStepSource as H, HarborFinalMetrics as I, toHarborTrajectories as J, fromHarborTrajectory as K, HarborImageSource as L, writeRolloutLedger as M, FromHarborOptions as N, parseClaudeTranscript as O, HarborAgent as P, GATE_POLICIES as Q, HarborMetrics as R, ClaudeTranscript as S, DEFAULT_CLAUDE_PROJECTS_DIR as T, HarborSubagentTrajectoryRef as U, HarborStep as V, HarborToolCall as W, GATE_CHECKS as X, toHarborTrajectory as Y, GATE_CHECK_IDS as Z, GateReport as _, buildHfDataset as a, gateErrors as at, DEFAULT_OPENCODE_DB as b, buildDatasetCard as c, defaultRolloutScrubber as d, GateCheckDisposition as et, scrubLines as f, GateDisposition as g, FormatGateCounts as h, ScrubReport as i, GatePolicy as it, readRolloutLedger as j, readClaudeTranscript as k, ScrubCounts as l, EmittedEvidence as m, BuildSummary as n, GateCheckedOutcome as nt, DatasetCardInputs as o, gatedEvidenceOf as ot, scrubText as p, relabelImportedSplit as q, RolloutReleaseCliArgs as r, GateEntryPoint as rt, ReleaseFormat as s, BuildOptions as t, GateCheckId as tt, ScrubRule as u, ReleaseRowRef as v, ClaudeUsageTotals as w, readOpencodeSessionMessages as x, assertGateReport as y, HarborObservation as z };
+//# sourceMappingURL=index-CiRwLv2R.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-CiRwLv2R.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":"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"}