@tangle-network/agent-eval 0.216.1 → 0.217.1

package/dist/trajectory-replay/index.d.ts

@@ -1,16 +1,11 @@
-import { s as TraceStore } from "../store-C4avFjIi.js";
-import { t as DefaultVerdict } from "../verdict-E4eRNf7-.js";
-import { o as TraceEmitter } from "../emitter-HcCmFQl_.js";
-import { i as CounterfactualRunner, t as CounterfactualContext } from "../counterfactual-CPaWN99-.js";
-import { _ as isSubmitOnlyAction, a as RecordedTrajectoryStep, b as unreadableExitCount, c as TIMEOUT_OBSERVATION_MARKER, d as decodeRecordedTurns, f as deriveFailureSignature, g as isSubmitAction, h as isRecordedTimeout, i as RecordedObservationKind, l as assertReplayableTrajectory, m as isElidedField, n as FORMAT_ERROR_OBSERVATION_PREFIX, o as RecordedTrajectoryTurn, p as finalRecordedOutcome, r as RecordedFinalOutcome, s as SUBMIT_ACTION_SIGNATURE, t as DecodedTrajectory, u as classifyObservation, v as parseObservationOutput, y as parseRecordedReturncode } from "../steps-Bg5-KVx1.js";
+import { t as DefaultVerdict } from "../verdict-C24NELtN.js";
+import { a as RecordedTrajectoryTurn, c as finalRecordedOutcome, i as RecordedTrajectoryStep, n as RecordedFinalOutcome, o as classifyObservation, r as RecordedObservationKind, s as decodeRecordedTurns, t as DecodedTrajectory } from "../steps-DlepJPwD.js";
 //#region src/trajectory-replay/corpus.d.ts
 interface CorpusSpec {
   readonly name: string;
   readonly labelsPath: string;
   readonly preparedDir: string;
 }
-/** Parses `name=<labelsPath>::<preparedDir>` (paths may contain `=`, not `::`). */
-export declare function parseCorpusFlag(value: string): CorpusSpec;
 type ReplayExclusionReason = 'no-swe-raw-trajectory' | 'ambiguous-swe-raw-trajectory' | 'unreadable-raw-trajectory' | 'no-docker-image' | 'no-gold-incorrect-step' | 'gold-only-submit-step' | 'missing-steps-json' | 'gold-step-outside-steps' | 'cwd-underivable' | 'no-recorded-returncode-at-k';
 interface ExcludedCase {
   readonly corpus: string;
@@ -44,13 +39,6 @@ interface ReplayableCase extends CaseResources {
   /** Recorded returncode at k; null when the observation carries none. */
   readonly recordedReturncodeAtK: number | null;
 }
-interface LabelEntry {
-  readonly traj_id: string;
-  readonly incorrect_stages?: readonly {
-    readonly incorrect_step_ids?: readonly number[];
-  }[];
-}
-export declare function goldIncorrectSteps(entry: LabelEntry): number[];
 type ResourceResolution = {
   readonly resolved: true;
   readonly resources: CaseResources;
@@ -59,25 +47,11 @@ type ResourceResolution = {
   readonly reason: ReplayExclusionReason;
   readonly detail?: string;
 };
-/**
- * Resolves the replay resources for one trajectory, independent of gold
- * labels — the finding wire uses this with a finding-supplied step instead.
- */
-export declare function resolveCaseResources(corpus: CorpusSpec, trajId: string): ResourceResolution;
 interface EnumerationResult {
   readonly replayable: ReplayableCase[];
   readonly excluded: ExcludedCase[];
   readonly labelEntryCount: number;
 }
-/**
- * Replayable = a raw trajectory with a recorded image AND at least one gold
- * incorrect step that is a real mid-trajectory action. Gold steps whose action
- * is the submit command are skipped when choosing k (counted per case); a case
- * whose golds are ALL submit steps is excluded as gold-only-submit-step.
- * Exclusion reasons are reported in resolution order:
- * raw trajectory → image → gold labels → steps.json → k range → cwd.
- */
-export declare function enumerateReplayableCases(corpora: readonly CorpusSpec[]): EnumerationResult;
 //#endregion
 //#region src/trajectory-replay/exec.d.ts
 /**
@@ -106,13 +80,6 @@ interface ReplayExecBackend {
  *  internally (batch, corpus wire, finding verification) take this instead of
  *  a backend, so every case runs against its own image. */
 type ReplayExecBackendFactory = (image: string) => ReplayExecBackend;
-/**
- * mini-SWE runs every action as a fresh /bin/sh subshell from a fixed
- * workdir. Reproduce that exactly — and stay quote-proof for arbitrary
- * recorded actions — by piping the base64 of the action into `sh` after
- * cd-ing to the workdir. Exit code is sh's, i.e. the action's.
- */
-export declare function wrapActionForExec(action: string, cwd: string): string;
 //#endregion
 //#region src/trajectory-replay/fix.d.ts
 interface ChatUsage {
@@ -140,12 +107,6 @@ interface FixPromptInput {
   /** Steps of context on each side of k (default 3). */
   readonly contextRadius?: number;
 }
-/** Head+tail excerpt with an elision marker; identity below the limit. */
-export declare function clipText(text: string, limit: number): string;
-export declare function buildFixPrompt(input: FixPromptInput): {
-  system: string;
-  user: string;
-};
 /** One prior attempt of the fix loop, rendered into the retry prompt. */
 interface FailedFixAttempt {
   readonly attempt: number;
@@ -156,19 +117,6 @@ interface FailedFixAttempt {
   readonly stderrTail: string | null;
   readonly llmError: string | null;
 }
-/**
- * Retry prompt for fix-loop attempts ≥2: the original context plus every prior
- * attempt with its REAL executed output, and permission to answer with a short
- * script (the block still executes as one /bin/sh unit).
- */
-export declare function buildRetryFixPrompt(input: FixPromptInput, priorAttempts: readonly FailedFixAttempt[], maxScriptCommands?: number): {
-  system: string;
-  user: string;
-};
-/** Non-empty, non-comment lines of a fix script — the loop's script-size cap. */
-export declare function countScriptCommands(script: string): number;
-/** Last fenced code block, else the whole trimmed content; null when empty. */
-export declare function extractFixCommand(content: string): string | null;
 type FixGenerationOutcome = {
   readonly succeeded: true;
   readonly value: {
@@ -179,7 +127,6 @@ type FixGenerationOutcome = {
   readonly succeeded: false;
   readonly error: string;
 };
-export declare function generateFixCommand(caller: ChatCompletionCaller, input: FixPromptInput): Promise<FixGenerationOutcome>;
 //#endregion
 //#region src/trajectory-replay/fix-loop.d.ts
 /** Result of executing one corrected command as a full arm. */
@@ -240,7 +187,6 @@ interface FixLoopResult {
    *  bound rather than a measurement. */
   readonly callsWithoutUsage: number;
 }
-export declare function runFixLoop(caller: ChatCompletionCaller, input: FixPromptInput, executor: FixArmExecutor, options: FixLoopOptions): Promise<FixLoopResult>;
 //#endregion
 //#region src/trajectory-replay/image-preparer.d.ts
 /**
@@ -270,7 +216,6 @@ interface DockerImagePreparerOptions {
   readonly pullTimeoutMs?: number;
   readonly buildTimeoutMs?: number;
 }
-export declare function derivedImageTag(image: string, cwd: string): string;
 /**
  * Pulls the base image when absent and builds `FROM <base>; RUN chown -R
  * 1000:1000 <cwd>` tagged by content hash, so repeated batches reuse both
@@ -462,12 +407,6 @@ interface IngestedTrajectory {
   runId: string;
   stepCount: number;
 }
-/**
- * Emit one tool span per trajectory step, in order, with a monotonic
- * injected clock so `buildTrajectory` ordering is deterministic even when
- * two spans would share a Date.now() millisecond.
- */
-export declare function ingestRecordedTrajectory(store: TraceStore, steps: readonly RecordedTrajectoryStep[], caseId: string): Promise<IngestedTrajectory>;
 /** Why a replayed prefix step failed to confirm the recording. */
 type PrefixDivergenceKind =
 /** The recording carries a returncode and the replayed exit differs from it. */
@@ -499,13 +438,6 @@ interface PrefixReplayResult {
 /** Admission tolerance: a prefix replay is faithful enough to build a verdict
  *  on when at most this percentage of its executed steps diverged. */
 export declare const PREFIX_DIVERGENCE_TOLERANCE_PCT = 10;
-/**
- * Compare one replayed prefix step against its recording. Returns null only
- * when the recording positively confirms the replay.
- */
-export declare function classifyPrefixStep(step: number, expectedReturncode: number | null, actualExit: number): PrefixDivergence | null;
-/** Roll per-step classifications up into the rate the admission pre-pass gates on. */
-export declare function summarizePrefixReplay(prefixExecuted: number, prefixDivergences: PrefixDivergence[], wallMs: number): PrefixReplayResult;
 interface ArmExecutionResult {
   command: string;
   exitCode: number;
@@ -521,20 +453,6 @@ interface SandboxCounterfactualRunnerOptions {
   prefixLimit?: number;
   onProgress?: (message: string) => void;
 }
-/**
- * Replays `ctx.prefix` in a fresh session, then executes the mutated step.
- * Divergences are recorded and never abort the replay. Results land on
- * `lastPrefix` / `lastArm` for the caller; spans for every exec land in the
- * counterfactual meta-run.
- */
-export declare class SandboxCounterfactualRunner implements CounterfactualRunner {
-  private readonly backend;
-  private readonly options;
-  lastPrefix: PrefixReplayResult | null;
-  lastArm: ArmExecutionResult | null;
-  constructor(backend: ReplayExecBackend, options: SandboxCounterfactualRunnerOptions);
-  executeFrom(ctx: CounterfactualContext, emitter: TraceEmitter): Promise<void>;
-}
 interface ReplayVerifyOptions {
   stepsPath: string;
   image: string;
@@ -617,15 +535,6 @@ interface VerifiableFinding {
   }[];
   readonly metadata?: Readonly<Record<string, unknown>>;
 }
-/**
- * 1-based step the finding accuses, or null when the finding names none.
- * `metadata.block_first_step` wins over the subject: the analyst records the
- * block's first incorrect step there even when the subject names a later
- * step of the same block.
- */
-export declare function findingReplayStep(finding: VerifiableFinding): number | null;
-/** Trajectory id from the finding's `trace://<traj>/…` evidence refs, or null. */
-export declare function findingTrajectoryId(finding: VerifiableFinding): string | null;
 /**
  * Where the executable trajectory lives.
  * `direct` — one trajectory's steps.json plus a replay-ready image; the
@@ -664,12 +573,6 @@ type FindingReplayability = {
   readonly replayable: false;
   readonly reason: string;
 };
-/**
- * Decides whether one finding can be executed against the source, and with
- * what invocation. Never throws for a finding-shaped problem — every dead end
- * becomes a `not-replayable` reason the receipt can carry verbatim.
- */
-export declare function resolveFindingReplayability(finding: VerifiableFinding, source: FindingReplaySource): FindingReplayability;
 type FindingVerificationStatus = 'reproduced' | 'fix-flipped' | 'not-replayable' | 'divergent';
 interface FindingVerification {
   readonly finding_id: string | null;
@@ -728,14 +631,6 @@ export declare function classifyVerdict(verdict: ReplayVerdict): FindingVerifica
  * run-level verifications.json.
  */
 export declare function verifyFindings(findings: readonly VerifiableFinding[], options: VerifyFindingsOptions): Promise<VerifyFindingsRun>;
-/** Markdown section an analysis report appends when finding verification ran. */
-export declare function renderVerifiedFindingsSection(run: VerifyFindingsRun): string;
-/**
- * Accepts the two shapes findings travel in: a bare JSON array of analyst
- * findings, or an object with a `findings` array (e.g. an extracted
- * `observations[n]` from a result.json).
- */
-export declare function readFindingsFile(path: string): VerifiableFinding[];
 //#endregion
 //#region src/trajectory-replay/wire.d.ts
 interface IncorrectStepsSubject {
@@ -744,8 +639,6 @@ interface IncorrectStepsSubject {
   readonly escapeStatus: 'escaped' | 'unescaped';
   readonly consequenceStep: number;
 }
-/** Null when the subject is not an incorrect-steps finding subject. */
-export declare function parseIncorrectStepsSubject(subject: string): IncorrectStepsSubject | null;
 interface AnalystReplayFinding {
   readonly trajId: string;
   readonly subject: string;
@@ -756,13 +649,6 @@ interface ResolvedReplayInvocation {
   /** 1-based step_id arm A executes: the finding's first incorrect step. */
   readonly at: number;
 }
-/**
- * Maps a finding onto replay resources, searching the given corpora for the
- * trajectory. Throws with the precise reason when the finding cannot be
- * replayed (malformed subject, unknown trajectory, non-replayable case, step
- * out of range) — the caller surfaces that reason instead of a proof.
- */
-export declare function resolveFindingInvocation(finding: AnalystReplayFinding, corpora: readonly CorpusSpec[]): ResolvedReplayInvocation;
 interface ReplayFindingOptions {
   readonly corpora: readonly CorpusSpec[];
   readonly out: string;
@@ -788,5 +674,5 @@ interface ReplayFindingResult {
  */
 export declare function replayVerifyFinding(finding: AnalystReplayFinding, options: ReplayFindingOptions): Promise<ReplayFindingResult>;
 //#endregion
-export { type AnalystReplayFinding, type ArmExecutionResult, type CaseResources, type ChatCompletionCaller, type ChatOutcome, type ChatUsage, type CorpusSpec, type CwdSource, type DecodedTrajectory, type DockerImagePreparerOptions, type EnumerationResult, type ExcludedCase, FORMAT_ERROR_OBSERVATION_PREFIX, type FailedFixAttempt, type FindingReplaySource, type FindingReplayability, type FindingVerification, type FindingVerificationStatus, type FixArmExecution, type FixArmExecutor, type FixGenerationOutcome, type FixLoopAttemptRecord, type FixLoopOptions, type FixLoopResult, type FixPromptInput, type ImagePreparation, type ImagePreparer, type IncorrectStepsSubject, type IngestedTrajectory, type PrefixDivergence, type PrefixDivergenceKind, type PrefixReplayResult, type RecordedFinalOutcome, type RecordedObservationKind, type RecordedTrajectoryStep, type RecordedTrajectoryTurn, type ReplayArmVerdict, type ReplayBatchCaseRow, type ReplayBatchFixResult, type ReplayBatchOptions, type ReplayBatchReport, type ReplayExclusionReason, type ReplayExecBackend, type ReplayExecBackendFactory, type ReplayExecResult, type ReplayExecSession, type ReplayFindingOptions, type ReplayFindingResult, type ReplayVerdict, type ReplayVerifyOptions, type ReplayableCase, type ResolvedFindingReplay, type ResolvedReplayInvocation, type ResourceResolution, SUBMIT_ACTION_SIGNATURE, type SandboxCounterfactualRunnerOptions, TIMEOUT_OBSERVATION_MARKER, type VerifiableFinding, type VerifyFindingsOptions, type VerifyFindingsRun, assertReplayableTrajectory, classifyObservation, decodeRecordedTurns, deriveFailureSignature, finalRecordedOutcome, isElidedField, isRecordedTimeout, isSubmitAction, isSubmitOnlyAction, parseObservationOutput, parseRecordedReturncode, unreadableExitCount };
+export { type AnalystReplayFinding, type ArmExecutionResult, type CaseResources, type ChatCompletionCaller, type ChatOutcome, type ChatUsage, type CorpusSpec, type CwdSource, type DecodedTrajectory, type DockerImagePreparerOptions, type EnumerationResult, type ExcludedCase, type FailedFixAttempt, type FindingReplaySource, type FindingReplayability, type FindingVerification, type FindingVerificationStatus, type FixArmExecution, type FixArmExecutor, type FixGenerationOutcome, type FixLoopAttemptRecord, type FixLoopOptions, type FixLoopResult, type FixPromptInput, type ImagePreparation, type ImagePreparer, type IncorrectStepsSubject, type IngestedTrajectory, type PrefixDivergence, type PrefixDivergenceKind, type PrefixReplayResult, type RecordedFinalOutcome, type RecordedObservationKind, type RecordedTrajectoryStep, type RecordedTrajectoryTurn, type ReplayArmVerdict, type ReplayBatchCaseRow, type ReplayBatchFixResult, type ReplayBatchOptions, type ReplayBatchReport, type ReplayExclusionReason, type ReplayExecBackend, type ReplayExecBackendFactory, type ReplayExecResult, type ReplayExecSession, type ReplayFindingOptions, type ReplayFindingResult, type ReplayVerdict, type ReplayVerifyOptions, type ReplayableCase, type ResolvedFindingReplay, type ResolvedReplayInvocation, type ResourceResolution, type SandboxCounterfactualRunnerOptions, type VerifiableFinding, type VerifyFindingsOptions, type VerifyFindingsRun, classifyObservation, decodeRecordedTurns, finalRecordedOutcome };
 //# sourceMappingURL=index.d.ts.map

package/dist/trajectory-replay/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/trajectory-replay/corpus.ts","../../src/trajectory-replay/exec.ts","../../src/trajectory-replay/fix.ts","../../src/trajectory-replay/fix-loop.ts","../../src/trajectory-replay/image-preparer.ts","../../src/trajectory-replay/batch.ts","../../src/trajectory-replay/verify.ts","../../src/trajectory-replay/findings.ts","../../src/trajectory-replay/wire.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/trajectory-replay/corpus.ts","../../src/trajectory-replay/exec.ts","../../src/trajectory-replay/fix.ts","../../src/trajectory-replay/fix-loop.ts","../../src/trajectory-replay/image-preparer.ts","../../src/trajectory-replay/batch.ts","../../src/trajectory-replay/verify.ts","../../src/trajectory-replay/findings.ts","../../src/trajectory-replay/wire.ts"],"mappings":";;;UAyBiB;WACN;WACA;WACA;;KAgBC;UAYK;WACN;WACA;WACA,QAAQ;WACR;;KAGC;;UAGK;WACN;WACA;WACA;WACA,gBAAgB;WAChB;WACA;WACA;WACA,WAAW;;WAEX;;UAGM,uBAAuB;;WAE7B;;;;WAIA;;WAEA;;WAEA;;KA0EC;WACG;WAAyB,WAAW;;WACpC;WAA0B,QAAQ;WAAgC;;UAuEhE;WACN,YAAY;WACZ,UAAU;WACV;;;;;;;;;;;;;UCrOM;EACf;EACA;EACA;;UAGe;EACf,KAAK,iBAAiB,oBAAoB,QAAQ;EAClD,SAAS;;UAGM;;EAEf,QAAQ,QAAQ;;;;;KAMN,4BAA4B,kBAAkB;;;UCbzC;WACN;WACA;;KAGC;WACG;WAA0B;IAAS;IAAiB,OAAO;;;WAC3D;WAA2B;;UAEzB;EACf,SAAS,gBAAgB,eAAe,QAAQ;;UAGjC;WACN;WACA,gBAAgB;;WAEhB;;WAEA;;;UA4DM;WACN;;WAEA;WACA;WACA;WACA;WACA;;KAsEC;WACG;WAA0B;IAAS;IAAiB,OAAO;;;WAC3D;WAA2B;;;;;UClJzB;WACN;WACA;WACA;;WAEA;WACA;WACA;WACA;;;KAIC,kBAAkB,iBAAiB,oBAAoB,QAAQ;UAE1D;;WAEN;;WAEA;;WAEA;WACA,cAAc;;UAGR;WACN;WACA;WACA;WACA;aAAkB;aAA+B;;WACjD;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;UAGM;WACN;WACA;WACA,mBAAmB;;WAEnB;WACA;;;WAGA;WACA;WACA;;;;WAIA;;;;;;;;;;;;;KCjEC;WAEG;WACA;IAAS;IAAsB;IAAiB;;;WAEhD;WAA2B;;UAEzB;EACf,OAAO,eAAe,cAAc,QAAQ;;UAG7B;WACN;WACA;;;;;;;;wBAcK,oBAAoB,UAAS,6BAAkC;;;UCQ9D;WACN,kBAAkB;WAClB;;;;WAIA;;WAEA;WACA,YAAY;WACZ;;WAEA;WACA;;WAEA;WACA;;WAEA;;WAEA;;WAEA,WAAW;;WAEX,gBAAgB;WAChB,cAAc;;UAGR;;WAEN;WACA;WACA;WACA;;;WAGA,OAAO;WACP;WACA;WACA;WACA;WACA;WACA;;WAEA,mBAAmB;;;WAGnB;;UAGM;WACN;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;WAEA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;WAEA;WACA;;;WAGA;WACA;WACA;WACA;;;WAGA;WACA,KAAK;WACL;;UAGM;WACN;WACA;IAAoB;IAAc;IAAoB;;WACtD;aACE;aACA;aACA;aACA,kBAAkB;;;aAGlB,qBAAqB;MAE1B;MAAyB;;;WAGtB;aACE;MAAqB;MAAmB;MAAqB;;aAC7D;MAAuB;MAAmB;MAAqB;;;;;aAI/D;eACE;eACA;eACA;eACA;;eAEA;eACA;eACA;eACA;;aAEF;MAAe;MAAmB;MAAqB;;;aAEvD;MACP;MACA;MACA;;;;aAIO;MACP;MACA;MACA;;;aAGO,gBAAgB;;WAElB;aACE;aACA;aACA;aACA;aACA;;;;aAIA;;WAEF;IAAqB;IAAgB;IAAgB;IAAgB;;WACrE;IAAyB;IAAgB;IAAgB;IAAe;;WACxE,gBAAgB;;wBAGX,aAAa,GAAG,gBAAgB,KAAK,cAAc,eAAe,IAAI;wBAkFhE,eAAe,SAAS,qBAAqB,QAAQ;;;UC1O1D;EACf;EACA;;;KAyCU;;;;;UAMK;EACf;EACA,MAAM;;EAEN;EACA;;UAGe;EACf;;EAEA,mBAAmB;;EAEnB;EACA;EACA;;;EAGA;;EAEA;EACA;;;;qBAKW;UAiDI;EACf;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;;;EAGA;EACA,cAAc;;UAwGC;EACf;EACA;;EAEA;;EAEA;EACA;EACA;EACA;;EAEA;EACA;EACA;;EAEA;;EAEA,SAAS;EACT,cAAc;;UAGC;EACf;EACA;EACA;EACA,QAAQ;;;;;;;;UASO,sBAAsB;EACrC;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,mBAAmB;;EAEnB;EACA;EACA;EACA;EACA;EACA,MAAM;IAAqB;;EAC3B,OAAO;IAAqB;;EAC5B;IAAW;IAAgB;IAAuB;;EAClD;IAAU;IAAkB;IAAc;;;wBAUtB,aAAa,SAAS,sBAAsB,QAAQ;;;UC5TzD;WACN;WACA;WACA;WACA;WACA;WACA;aACE;aACA;aACA;;WAEF,WAAW,SAAS;;;;;;;;;;;KA+CnB;WAEG;WACA;WACA;WACA;WACA;;WAGA;WACA,kBAAkB;WAClB,WAAW;;UAGT;WACN;WACA;;WAEA;WACA;;WAEA;WACA;WACA;;KAGC;WACG;WAA2B,UAAU;;WACrC;WAA4B;;KAuH/B;UAMK;WACN;WACA;WACA;;WAEA;WACA,UAAU;;WAEV;;WAEA;WACA;;WAEA;;;;;;;;UASM,0BAA0B;WAChC;WACA,wBAAwB;WACxB,QAAQ,SAAS,OAAO;;WAExB;;UAGM;WACN,QAAQ;;WAER;;WAEA;WACA;WACA;;WAEA,gBAAgB;;;WAGhB,kBAAkB;WAClB,cAAc;;;;;;;;wBAST,gBAAgB,SAAS,gBAAgB;;;;;;;wBAyGnC,eACpB,mBAAmB,qBACnB,SAAS,wBACR,QAAQ;;;UC5YM;WACN;WACA;WACA;WACA;;UAiBM;WACN;WACA;;UAGM;WACN,WAAW;WACX,SAAS;;WAET;;UAmDM;WACN,kBAAkB;WAClB;;WAEA,YAAY;;WAEZ;WACA;WACA;;WAEA,gBAAgB;WAChB,cAAc;;UAGR;WACN,YAAY;WACZ;WACA,SAAS;;;;;;;wBAQE,oBACpB,SAAS,sBACT,SAAS,uBACR,QAAQ"}

package/dist/trajectory-replay/index.js

@@ -1,16 +1,109 @@
-import { t as mulberry32 } from "../random-ByUSnV9w.js";
-import { t as certificationEvidenceDigest } from "../verdict-Dl0tiT1X.js";
+import { o as NotFoundError, s as ValidationError } from "../errors-BcOs5MKW.js";
+import { t as mulberry32 } from "../random-DDDcC7YU.js";
+import { t as certificationEvidenceDigest } from "../verdict-BGQmxQ8A.js";
 import { t as TraceEmitter } from "../emitter-DbMXUIVP.js";
-import { t as runCounterfactual } from "../counterfactual-Dn3veueY.js";
 import { n as InMemoryTraceStore } from "../store-BhNuLdJw.js";
 import { t as packageVersion } from "../package-version-D7lQHt_-.js";
-import { a as assertReplayableTrajectory, c as deriveFailureSignature, d as isRecordedTimeout, f as isSubmitAction, g as unreadableExitCount, h as parseRecordedReturncode, i as TIMEOUT_OBSERVATION_MARKER, l as finalRecordedOutcome, m as parseObservationOutput, n as FORMAT_ERROR_OBSERVATION_PREFIX, o as classifyObservation, p as isSubmitOnlyAction, r as SUBMIT_ACTION_SIGNATURE, s as decodeRecordedTurns, t as wrapActionForExec, u as isElidedField } from "../exec-ChJ6d5if.js";
+import { t as buildTrajectory } from "../trajectory-D_7rLrvE.js";
+import { a as classifyObservation, c as finalRecordedOutcome, d as isSubmitOnlyAction, f as parseObservationOutput, o as decodeRecordedTurns, p as parseRecordedReturncode, s as deriveFailureSignature, t as wrapActionForExec, u as isSubmitAction } from "../exec-CpbtOXVt.js";
 import { createHash } from "node:crypto";
 import { appendFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
+//#region src/counterfactual.ts
+/**
+* Counterfactual replay — "what would have happened if we'd changed
+* exactly one thing at turn N?"
+*
+* The framework does NOT drive the agent — it sets up the replay
+* context (prior spans, prior state, mutation spec) and records the
+* resulting divergence. Consumers supply an `executeFrom(ctx)` callback
+* that runs their agent starting from turn N with the mutation applied.
+*
+* Counterfactual runs are recorded as a new Run with `layer='meta'` and
+* `parentRunId = originalRunId`, so downstream diff + correlation
+* pipelines see them natively.
+*/
+async function runCounterfactual(store, originalRunId, mutation, runner) {
+	const originalRun = await store.getRun(originalRunId);
+	if (!originalRun) throw new NotFoundError(`counterfactual: run ${originalRunId} not found`);
+	const trajectory = await buildTrajectory(store, originalRunId);
+	if (mutation.at < 0 || mutation.at >= trajectory.steps.length) throw new ValidationError(`counterfactual: mutation.at=${mutation.at} out of range [0, ${trajectory.steps.length})`);
+	const targetStep = trajectory.steps[mutation.at];
+	const mutatedStep = applyMutation(targetStep, mutation);
+	const cfEmitter = new TraceEmitter(store);
+	await cfEmitter.startRun({
+		scenarioId: originalRun.scenarioId,
+		variantId: originalRun.variantId ? `${originalRun.variantId}+cf:${mutation.kind}@${mutation.at}` : `cf:${mutation.kind}@${mutation.at}`,
+		projectId: originalRun.projectId,
+		parentRunId: originalRunId,
+		layer: "meta",
+		tags: {
+			counterfactual: "true",
+			mutationKind: mutation.kind,
+			mutationAt: String(mutation.at)
+		}
+	});
+	await runner.executeFrom({
+		originalRunId,
+		originalTrajectory: trajectory,
+		prefix: trajectory.steps.slice(0, mutation.at),
+		mutation,
+		mutatedStep
+	}, cfEmitter);
+	const counterfactual = await store.getRun(cfEmitter.runId);
+	const delta = {
+		originalOutcomeScore: originalRun.outcome?.score ?? null,
+		counterfactualOutcomeScore: counterfactual?.outcome?.score ?? null,
+		deltaScore: originalRun.outcome?.score !== void 0 && counterfactual?.outcome?.score !== void 0 ? counterfactual.outcome.score - originalRun.outcome.score : null
+	};
+	return {
+		counterfactualRunId: cfEmitter.runId,
+		originalRunId,
+		mutation,
+		delta
+	};
+}
+function applyMutation(step, mutation) {
+	if (mutation.kind === "swap-model" && step.span.kind === "llm") {
+		const llm = step.span;
+		return {
+			...step,
+			span: {
+				...llm,
+				model: mutation.newModel
+			}
+		};
+	}
+	if (mutation.kind === "swap-tool-result" && step.span.kind === "tool") {
+		const tool = step.span;
+		return {
+			...step,
+			span: {
+				...tool,
+				result: mutation.newResult
+			}
+		};
+	}
+	if (mutation.kind === "inject-system-message" && step.span.kind === "llm") {
+		const llm = step.span;
+		return {
+			...step,
+			span: {
+				...llm,
+				messages: [{
+					role: "system",
+					content: mutation.content
+				}, ...llm.messages]
+			}
+		};
+	}
+	if (mutation.kind === "custom") return mutation.apply(step);
+	return step;
+}
+//#endregion
 //#region src/trajectory-replay/corpus.ts
 /**
 * Corpus enumeration for batch replay verification.
@@ -27,20 +120,6 @@ import { promisify } from "node:util";
 * is returned with a machine-readable reason — the batch report surfaces the
 * full exclusion table, never a silently shrunk denominator.
 */
-/** Parses `name=<labelsPath>::<preparedDir>` (paths may contain `=`, not `::`). */
-function parseCorpusFlag(value) {
-	const eq = value.indexOf("=");
-	if (eq <= 0) throw new Error(`--corpus must be name=<labels>::<prepared>, got: ${value}`);
-	const name = value.slice(0, eq);
-	const rest = value.slice(eq + 1);
-	const sep = rest.indexOf("::");
-	if (sep <= 0 || sep === rest.length - 2) throw new Error(`--corpus must be name=<labels>::<prepared>, got: ${value}`);
-	return {
-		name,
-		labelsPath: rest.slice(0, sep),
-		preparedDir: rest.slice(sep + 2)
-	};
-}
 function readLabelEntries(labelsPath) {
 	const parsed = JSON.parse(readFileSync(labelsPath, "utf8"));
 	if (!Array.isArray(parsed)) throw new Error(`${labelsPath} is not a JSON array of label entries`);
@@ -2116,44 +2195,7 @@ async function verifyFindings(findings, options) {
 	}, null, 2)}\n`);
 	return run;
 }
-function verdictCell(verification) {
-	switch (verification.verified) {
-		case "reproduced": return "**VERIFIED** — reproduced";
-		case "fix-flipped": return "**VERIFIED** — fix-flipped";
-		case "divergent": return "DIVERGENT — recorded failure did not reproduce";
-		case "not-replayable": return `UNVERIFIABLE — ${verification.reason ?? "no reason recorded"}`;
-	}
-}
-/** Markdown section an analysis report appends when finding verification ran. */
-function renderVerifiedFindingsSection(run) {
-	const lines = ["## Verified findings (executed replay)", ""];
-	const total = run.verifications.length;
-	lines.push(`${total} finding(s) → ${run.counts.reproduced} reproduced, ${run.counts["fix-flipped"]} fix-flipped, ${run.counts.divergent} divergent, ${run.counts["not-replayable"]} not replayable (${run.executions} execution(s); findings accusing the same step share one proof).`);
-	lines.push("");
-	lines.push("| Finding | Subject | Step | Verdict | Receipt |");
-	lines.push("|---|---|---:|---|---|");
-	for (const verification of run.verifications) {
-		const shared = verification.deduplicated_with ? " (shared proof)" : "";
-		lines.push(`| \`${verification.finding_id ?? "—"}\` | \`${verification.subject ?? "—"}\` | ${verification.step ?? "—"} | ${verdictCell(verification)} | \`${verification.receipt}\`${shared} |`);
-	}
-	lines.push("");
-	lines.push("VERIFIED = the accused step was re-executed after replaying the trajectory prefix, and the recorded failure signature reproduced (fix-flipped: a corrected command additionally made it vanish). Each receipt directory carries receipt.json and, when executed, replay-verdict.json + report.md with real stdout/stderr.");
-	lines.push("");
-	return lines.join("\n");
-}
-/**
-* Accepts the two shapes findings travel in: a bare JSON array of analyst
-* findings, or an object with a `findings` array (e.g. an extracted
-* `observations[n]` from a result.json).
-*/
-function readFindingsFile(path) {
-	const parsed = JSON.parse(readFileSync(path, "utf8"));
-	const array = Array.isArray(parsed) ? parsed : parsed && typeof parsed === "object" && Array.isArray(parsed.findings) ? parsed.findings : null;
-	if (!array) throw new Error(`${path} is neither a findings array nor an object with a findings array`);
-	for (const entry of array) if (!entry || typeof entry !== "object") throw new Error(`${path}: every finding must be an object, got ${JSON.stringify(entry)}`);
-	return array;
-}
 //#endregion
-export { FORMAT_ERROR_OBSERVATION_PREFIX, PREFIX_DIVERGENCE_TOLERANCE_PCT, SUBMIT_ACTION_SIGNATURE, SandboxCounterfactualRunner, TIMEOUT_OBSERVATION_MARKER, assertReplayableTrajectory, buildFixPrompt, buildRetryFixPrompt, classifyObservation, classifyPrefixStep, classifyVerdict, clipText, countScriptCommands, decodeRecordedTurns, deriveFailureSignature, derivedImageTag, dockerImagePreparer, enumerateReplayableCases, extractFixCommand, finalRecordedOutcome, findingReplayStep, findingTrajectoryId, generateFixCommand, goldIncorrectSteps, ingestRecordedTrajectory, isElidedField, isRecordedTimeout, isSubmitAction, isSubmitOnlyAction, parseCorpusFlag, parseIncorrectStepsSubject, parseObservationOutput, parseRecordedReturncode, readFindingsFile, renderVerifiedFindingsSection, replayVerify, replayVerifyFinding, resolveCaseResources, resolveFindingInvocation, resolveFindingReplayability, runFixLoop, runReplayBatch, seededSample, summarizePrefixReplay, unreadableExitCount, verifyFindings, wrapActionForExec };
+export { PREFIX_DIVERGENCE_TOLERANCE_PCT, classifyObservation, classifyVerdict, decodeRecordedTurns, dockerImagePreparer, finalRecordedOutcome, replayVerify, replayVerifyFinding, runReplayBatch, seededSample, verifyFindings };
 
 //# sourceMappingURL=index.js.map