@tangle-network/agent-eval 0.216.0 → 0.217.1

package/dist/{evaluation-Cn2dRZIz.d.ts → evaluation-jTjC_QQD.d.ts}

@@ -1,6 +1,6 @@
-import { a as CostChannel, c as CostLedgerHandle, g as CostReceiptInput, m as CostReceipt, x as MaximumCharge } from "./cost-ledger-CO7UyEcQ.js";
-import { a as AnalystFinding, n as Analyst, r as AnalystContext } from "./types-oKRhQAde.js";
-import { R as Scenario, S as JudgeConfig, w as JudgeScore } from "./types-B4C5nFw6.js";
+import { a as CostLedgerHandle, d as CostReceiptInput, m as MaximumCharge, r as CostChannel, u as CostReceipt } from "./cost-ledger-Jk62OBfF.js";
+import { i as AnalystFinding, n as AnalystContext, t as Analyst } from "./types-CW8ewATZ.js";
+import { R as Scenario, S as JudgeConfig, w as JudgeScore } from "./types-D8GhJoHk.js";
 //#region src/evaluation.d.ts
 interface EvaluationResult<T> {
   value: T;
@@ -21,7 +21,7 @@ interface EvaluationContext {
   /** Awaited after accounting and before validation or result delivery. */
   onReceipt?: (receipt: CostReceipt) => void | Promise<void>;
 }
-type Evaluator<I, O> = (input: I, context?: EvaluationContext) => Promise<EvaluationResult<O>>;
+type CostedEvaluator<I, O> = (input: I, context?: EvaluationContext) => Promise<EvaluationResult<O>>;
 interface EvaluatorOptions<I, O> {
   execute: (input: I, context: {
     signal: AbortSignal;
@@ -36,12 +36,12 @@ interface EvaluatorOptions<I, O> {
   validate?: (value: O, input: I) => void | Promise<void>;
 }
 /** A metered function, independent of providers, question formats, and application policy. */
-declare function createEvaluator<I, O>(options: EvaluatorOptions<I, O>): Evaluator<I, O>;
+declare function createEvaluator<I, O>(options: EvaluatorOptions<I, O>): CostedEvaluator<I, O>;
 interface EvaluationJudgeOptions<A, S extends Scenario, O> {
   name: string;
   version: string;
   dimensions: JudgeConfig<A, S>['dimensions'];
-  evaluate: Evaluator<{
+  evaluate: CostedEvaluator<{
     artifact: A;
     scenario: S;
   }, O>;
@@ -71,5 +71,5 @@ interface EvaluationAnalystOptions<I, O> {
 /** Registry, graph, and trace consumers keep the same Analyst interface. */
 declare function asAnalyst<I, O>(options: EvaluationAnalystOptions<I, O>): Analyst<I>;
 //#endregion
-export { Evaluator as a, asJudge as c, EvaluationResult as i, createEvaluator as l, EvaluationContext as n, EvaluatorOptions as o, EvaluationJudgeOptions as r, asAnalyst as s, EvaluationAnalystOptions as t };
-//# sourceMappingURL=evaluation-Cn2dRZIz.d.ts.map
+export { EvaluationResult as a, asJudge as c, EvaluationJudgeOptions as i, createEvaluator as l, EvaluationAnalystOptions as n, EvaluatorOptions as o, EvaluationContext as r, asAnalyst as s, CostedEvaluator as t };
+//# sourceMappingURL=evaluation-jTjC_QQD.d.ts.map

package/dist/evaluation-jTjC_QQD.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluation-jTjC_QQD.d.ts","names":[],"sources":["../src/evaluation.ts"],"mappings":";;;;UAWiB,iBAAiB;EAChC,OAAO;EACP,SAAS;EACT;;UAGe;;;EAGf;EACA,SAAS;EACT,aAAa;EACb;EACA,UAAU;EACV;EACA,WAAW;EACX,gBAAgB;;EAEhB,aAAa,SAAS,uBAAuB;;KAGnC,gBAAgB,GAAG,MAC7B,OAAO,GACP,UAAU,sBACP,QAAQ,iBAAiB;UAEb,iBAAiB,GAAG;EACnC,UAAU,OAAO,GAAG;IAAW,QAAQ;IAAa;QAA6B,QAAQ;EACzF,UAAU,OAAO,MAAM;EACvB,oBAAoB,OAAO,UAAU;EACrC,mBAAmB,OAAO;EAC1B,aAAa;EACb,gBAAgB;;EAEhB,YAAY,OAAO,GAAG,OAAO,aAAa;;;iBAI5B,gBAAgB,GAAG,GAAG,SAAS,iBAAiB,GAAG,KAAK,gBAAgB,GAAG;UA6B1E,uBAAuB,GAAG,UAAU,UAAU;EAC7D;EACA;EACA,YAAY,YAAY,GAAG;EAC3B,UAAU;IAAkB,UAAU;IAAG,UAAU;KAAK;EACxD,MAAM,OAAO,GAAG;IAAS,UAAU;IAAG,UAAU;QAAQ,aAAa,QAAQ;;EAE7E,UACE,QAAQ,iBAAiB,IACzB;IAAS,UAAU;IAAG,UAAU;eACtB;EACZ,aAAa,UAAU;;;iBAIT,QAAQ,GAAG,UAAU,UAAU,GAC7C,SAAS,uBAAuB,GAAG,GAAG,KACrC,YAAY,GAAG;UA4BD,yBAAyB,GAAG;EAC3C;EACA;EACA;EACA,WAAW,QAAQ;EACnB,MAAM,QAAQ;EACd,WACE,OAAO,GACP,SAAS,mBACT,gBAAgB,mBACb,QAAQ,iBAAiB;EAC9B,MAAM,OAAO,GAAG,OAAO,GAAG,SAAS,mBAAmB,mBAAmB,QAAQ;EACjF,UAAU,QAAQ,iBAAiB,IAAI,OAAO,GAAG,SAAS,0BAA0B;;;iBAItE,UAAU,GAAG,GAAG,SAAS,yBAAyB,GAAG,KAAK,QAAQ"}

package/dist/evaluation.d.ts

@@ -1,2 +1,2 @@
-import { a as Evaluator, c as asJudge, i as EvaluationResult, l as createEvaluator, n as EvaluationContext, o as EvaluatorOptions, r as EvaluationJudgeOptions, s as asAnalyst, t as EvaluationAnalystOptions } from "./evaluation-Cn2dRZIz.js";
-export { EvaluationAnalystOptions, EvaluationContext, EvaluationJudgeOptions, EvaluationResult, Evaluator, EvaluatorOptions, asAnalyst, asJudge, createEvaluator };
+import { a as EvaluationResult, c as asJudge, i as EvaluationJudgeOptions, l as createEvaluator, n as EvaluationAnalystOptions, o as EvaluatorOptions, r as EvaluationContext, s as asAnalyst, t as CostedEvaluator } from "./evaluation-jTjC_QQD.js";
+export { CostedEvaluator, EvaluationAnalystOptions, EvaluationContext, EvaluationJudgeOptions, EvaluationResult, EvaluatorOptions, asAnalyst, asJudge, createEvaluator };

package/dist/evaluation.js

@@ -1,4 +1,4 @@
-import { i as CostLedger } from "./cost-ledger-D2FnJPBF.js";
+import { t as CostLedger } from "./cost-ledger-D0352Z4d.js";
 //#region src/evaluation.ts
 /** A metered function, independent of providers, question formats, and application policy. */
 function createEvaluator(options) {

package/dist/evaluation.js.map

@@ -1 +1 @@
-{"version":3,"file":"evaluation.js","names":[],"sources":["../src/evaluation.ts"],"sourcesContent":["import type { Analyst, AnalystContext, AnalystFinding } from './analyst/types'\nimport type { JudgeConfig, JudgeScore, Scenario } from './campaign/types'\nimport type {\n  CostChannel,\n  CostLedgerHandle,\n  CostReceipt,\n  CostReceiptInput,\n  MaximumCharge,\n} from './cost-ledger'\nimport { CostLedger } from './cost-ledger'\n\nexport interface EvaluationResult<T> {\n  value: T\n  receipt: CostReceipt\n  durationMs: number\n}\n\nexport interface EvaluationContext {\n  /** Physical paid-call identity, forwarded through the existing ledger and transport.\n   * Reusing it in one ledger conflicts; it is not an automatic result-replay policy. */\n  callId?: string\n  signal?: AbortSignal\n  costLedger?: CostLedgerHandle\n  actor?: string\n  channel?: CostChannel\n  costPhase?: string\n  costTags?: Record<string, string>\n  maximumCharge?: MaximumCharge\n  /** Awaited after accounting and before validation or result delivery. */\n  onReceipt?: (receipt: CostReceipt) => void | Promise<void>\n}\n\nexport type Evaluator<I, O> = (\n  input: I,\n  context?: EvaluationContext,\n) => Promise<EvaluationResult<O>>\n\nexport interface EvaluatorOptions<I, O> {\n  execute: (input: I, context: { signal: AbortSignal; idempotencyKey: string }) => Promise<O>\n  receipt: (value: O) => CostReceiptInput\n  receiptFromError?: (error: Error) => CostReceiptInput | undefined\n  model?: string | ((input: I) => string)\n  costLedger?: CostLedgerHandle\n  maximumCharge?: MaximumCharge\n  /** Awaited after accounting, so invalid output never erases paid work. */\n  validate?: (value: O, input: I) => void | Promise<void>\n}\n\n/** A metered function, independent of providers, question formats, and application policy. */\nexport function createEvaluator<I, O>(options: EvaluatorOptions<I, O>): Evaluator<I, O> {\n  const defaults = { ...options }\n  const ledger = defaults.costLedger ?? new CostLedger()\n  return async (input, context = {}) => {\n    context.signal?.throwIfAborted()\n    const started = performance.now()\n    const paid = await (context.costLedger ?? ledger).runPaidCall({\n      callId: context.callId,\n      actor: context.actor ?? 'evaluation',\n      channel: context.channel ?? 'evaluation',\n      phase: context.costPhase ?? 'evaluation',\n      tags: context.costTags,\n      model: typeof defaults.model === 'function' ? defaults.model(input) : defaults.model,\n      signal: context.signal,\n      maximumCharge: context.maximumCharge ?? defaults.maximumCharge,\n      execute: (signal, idempotencyKey) => defaults.execute(input, { signal, idempotencyKey }),\n      receipt: defaults.receipt,\n      receiptFromError: defaults.receiptFromError,\n    })\n    if (paid.receipt) await context.onReceipt?.(paid.receipt)\n    if (!paid.succeeded) throw paid.error\n    // A transport can complete after cancellation. Keep its paid receipt, not a live decision.\n    context.signal?.throwIfAborted()\n    await defaults.validate?.(paid.value, input)\n    context.signal?.throwIfAborted()\n    return { value: paid.value, receipt: paid.receipt, durationMs: performance.now() - started }\n  }\n}\n\nexport interface EvaluationJudgeOptions<A, S extends Scenario, O> {\n  name: string\n  version: string\n  dimensions: JudgeConfig<A, S>['dimensions']\n  evaluate: Evaluator<{ artifact: A; scenario: S }, O>\n  map: (value: O, input: { artifact: A; scenario: S }) => JudgeScore | Promise<JudgeScore>\n  /** Persist the complete observation before reducing it to a verdict. */\n  record?: (\n    result: EvaluationResult<O>,\n    input: { artifact: A; scenario: S },\n  ) => void | Promise<void>\n  appliesTo?: (scenario: S) => boolean\n}\n\n/** Return the existing contract. Mapping never performs another inference call. */\nexport function asJudge<A, S extends Scenario, O>(\n  options: EvaluationJudgeOptions<A, S, O>,\n): JudgeConfig<A, S> {\n  // The version describes these callbacks, not later mutations of the caller's options.\n  const config = { ...options, dimensions: structuredClone(options.dimensions) }\n  return {\n    name: config.name,\n    judgeVersion: config.version,\n    dimensions: config.dimensions,\n    appliesTo: config.appliesTo,\n    async score({ artifact, scenario, signal, costLedger, costPhase, costTags }) {\n      signal.throwIfAborted()\n      const input = { artifact, scenario }\n      const result = await config.evaluate(input, {\n        signal,\n        costLedger,\n        actor: config.name,\n        channel: 'judge',\n        costPhase,\n        costTags: { ...costTags, scenarioId: scenario.id },\n      })\n      await config.record?.(result, input)\n      signal.throwIfAborted()\n      const score = await config.map(result.value, input)\n      signal.throwIfAborted()\n      return score\n    },\n  }\n}\n\nexport interface EvaluationAnalystOptions<I, O> {\n  id: string\n  version: string\n  description: string\n  inputKind: Analyst<I>['inputKind']\n  cost: Analyst<I>['cost']\n  evaluate: (\n    input: I,\n    context: EvaluationContext,\n    analystContext: AnalystContext,\n  ) => Promise<EvaluationResult<O>>\n  map: (value: O, input: I, context: AnalystContext) => AnalystFinding[] | Promise<AnalystFinding[]>\n  record?: (result: EvaluationResult<O>, input: I, context: AnalystContext) => void | Promise<void>\n}\n\n/** Registry, graph, and trace consumers keep the same Analyst interface. */\nexport function asAnalyst<I, O>(options: EvaluationAnalystOptions<I, O>): Analyst<I> {\n  const config = { ...options, cost: structuredClone(options.cost) }\n  return {\n    id: config.id,\n    version: config.version,\n    description: config.description,\n    inputKind: config.inputKind,\n    cost: config.cost,\n    async analyze(input, context) {\n      const signals = context.signal ? [context.signal] : []\n      if (context.deadlineMs !== undefined) {\n        const remaining = context.deadlineMs - Date.now()\n        if (!Number.isFinite(remaining)) throw new TypeError('Analyst deadline must be finite')\n        if (remaining <= 0) throw new DOMException('Analyst deadline exceeded', 'TimeoutError')\n        signals.push(AbortSignal.timeout(Math.ceil(remaining)))\n      }\n      const signal = AbortSignal.any(signals)\n      signal.throwIfAborted()\n      const analystContext = { ...context, signal }\n      const result = await config.evaluate(\n        input,\n        {\n          signal,\n          // No implicit account may override the evaluator's configured spending authority.\n          costLedger:\n            context.costLedger ??\n            (context.budgetUsd === undefined\n              ? undefined\n              : new CostLedger({ costCeilingUsd: context.budgetUsd })),\n          actor: config.id,\n          channel: 'analyst',\n          costPhase: context.costPhase,\n          costTags: { ...context.tags, runId: context.runId, correlationId: context.correlationId },\n          onReceipt: (receipt) =>\n            context.recordUsage?.({\n              calls: 1,\n              tokens: receipt.usageUnknown\n                ? null\n                : { input: receipt.inputTokens, output: receipt.outputTokens },\n              cost: receipt.costUnknown\n                ? { kind: 'uncaptured', usd: null }\n                : {\n                    kind: receipt.actualCostUsd === undefined ? 'estimated' : 'observed',\n                    usd: receipt.costUsd,\n                  },\n            }),\n        },\n        analystContext,\n      )\n      await config.record?.(result, input, analystContext)\n      signal.throwIfAborted()\n      const findings = await config.map(result.value, input, analystContext)\n      signal.throwIfAborted()\n      return findings\n    },\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"evaluation.js","names":[],"sources":["../src/evaluation.ts"],"sourcesContent":["import type { Analyst, AnalystContext, AnalystFinding } from './analyst/types'\nimport type { JudgeConfig, JudgeScore, Scenario } from './campaign/types'\nimport type {\n  CostChannel,\n  CostLedgerHandle,\n  CostReceipt,\n  CostReceiptInput,\n  MaximumCharge,\n} from './cost-ledger'\nimport { CostLedger } from './cost-ledger'\n\nexport interface EvaluationResult<T> {\n  value: T\n  receipt: CostReceipt\n  durationMs: number\n}\n\nexport interface EvaluationContext {\n  /** Physical paid-call identity, forwarded through the existing ledger and transport.\n   * Reusing it in one ledger conflicts; it is not an automatic result-replay policy. */\n  callId?: string\n  signal?: AbortSignal\n  costLedger?: CostLedgerHandle\n  actor?: string\n  channel?: CostChannel\n  costPhase?: string\n  costTags?: Record<string, string>\n  maximumCharge?: MaximumCharge\n  /** Awaited after accounting and before validation or result delivery. */\n  onReceipt?: (receipt: CostReceipt) => void | Promise<void>\n}\n\nexport type CostedEvaluator<I, O> = (\n  input: I,\n  context?: EvaluationContext,\n) => Promise<EvaluationResult<O>>\n\nexport interface EvaluatorOptions<I, O> {\n  execute: (input: I, context: { signal: AbortSignal; idempotencyKey: string }) => Promise<O>\n  receipt: (value: O) => CostReceiptInput\n  receiptFromError?: (error: Error) => CostReceiptInput | undefined\n  model?: string | ((input: I) => string)\n  costLedger?: CostLedgerHandle\n  maximumCharge?: MaximumCharge\n  /** Awaited after accounting, so invalid output never erases paid work. */\n  validate?: (value: O, input: I) => void | Promise<void>\n}\n\n/** A metered function, independent of providers, question formats, and application policy. */\nexport function createEvaluator<I, O>(options: EvaluatorOptions<I, O>): CostedEvaluator<I, O> {\n  const defaults = { ...options }\n  const ledger = defaults.costLedger ?? new CostLedger()\n  return async (input, context = {}) => {\n    context.signal?.throwIfAborted()\n    const started = performance.now()\n    const paid = await (context.costLedger ?? ledger).runPaidCall({\n      callId: context.callId,\n      actor: context.actor ?? 'evaluation',\n      channel: context.channel ?? 'evaluation',\n      phase: context.costPhase ?? 'evaluation',\n      tags: context.costTags,\n      model: typeof defaults.model === 'function' ? defaults.model(input) : defaults.model,\n      signal: context.signal,\n      maximumCharge: context.maximumCharge ?? defaults.maximumCharge,\n      execute: (signal, idempotencyKey) => defaults.execute(input, { signal, idempotencyKey }),\n      receipt: defaults.receipt,\n      receiptFromError: defaults.receiptFromError,\n    })\n    if (paid.receipt) await context.onReceipt?.(paid.receipt)\n    if (!paid.succeeded) throw paid.error\n    // A transport can complete after cancellation. Keep its paid receipt, not a live decision.\n    context.signal?.throwIfAborted()\n    await defaults.validate?.(paid.value, input)\n    context.signal?.throwIfAborted()\n    return { value: paid.value, receipt: paid.receipt, durationMs: performance.now() - started }\n  }\n}\n\nexport interface EvaluationJudgeOptions<A, S extends Scenario, O> {\n  name: string\n  version: string\n  dimensions: JudgeConfig<A, S>['dimensions']\n  evaluate: CostedEvaluator<{ artifact: A; scenario: S }, O>\n  map: (value: O, input: { artifact: A; scenario: S }) => JudgeScore | Promise<JudgeScore>\n  /** Persist the complete observation before reducing it to a verdict. */\n  record?: (\n    result: EvaluationResult<O>,\n    input: { artifact: A; scenario: S },\n  ) => void | Promise<void>\n  appliesTo?: (scenario: S) => boolean\n}\n\n/** Return the existing contract. Mapping never performs another inference call. */\nexport function asJudge<A, S extends Scenario, O>(\n  options: EvaluationJudgeOptions<A, S, O>,\n): JudgeConfig<A, S> {\n  // The version describes these callbacks, not later mutations of the caller's options.\n  const config = { ...options, dimensions: structuredClone(options.dimensions) }\n  return {\n    name: config.name,\n    judgeVersion: config.version,\n    dimensions: config.dimensions,\n    appliesTo: config.appliesTo,\n    async score({ artifact, scenario, signal, costLedger, costPhase, costTags }) {\n      signal.throwIfAborted()\n      const input = { artifact, scenario }\n      const result = await config.evaluate(input, {\n        signal,\n        costLedger,\n        actor: config.name,\n        channel: 'judge',\n        costPhase,\n        costTags: { ...costTags, scenarioId: scenario.id },\n      })\n      await config.record?.(result, input)\n      signal.throwIfAborted()\n      const score = await config.map(result.value, input)\n      signal.throwIfAborted()\n      return score\n    },\n  }\n}\n\nexport interface EvaluationAnalystOptions<I, O> {\n  id: string\n  version: string\n  description: string\n  inputKind: Analyst<I>['inputKind']\n  cost: Analyst<I>['cost']\n  evaluate: (\n    input: I,\n    context: EvaluationContext,\n    analystContext: AnalystContext,\n  ) => Promise<EvaluationResult<O>>\n  map: (value: O, input: I, context: AnalystContext) => AnalystFinding[] | Promise<AnalystFinding[]>\n  record?: (result: EvaluationResult<O>, input: I, context: AnalystContext) => void | Promise<void>\n}\n\n/** Registry, graph, and trace consumers keep the same Analyst interface. */\nexport function asAnalyst<I, O>(options: EvaluationAnalystOptions<I, O>): Analyst<I> {\n  const config = { ...options, cost: structuredClone(options.cost) }\n  return {\n    id: config.id,\n    version: config.version,\n    description: config.description,\n    inputKind: config.inputKind,\n    cost: config.cost,\n    async analyze(input, context) {\n      const signals = context.signal ? [context.signal] : []\n      if (context.deadlineMs !== undefined) {\n        const remaining = context.deadlineMs - Date.now()\n        if (!Number.isFinite(remaining)) throw new TypeError('Analyst deadline must be finite')\n        if (remaining <= 0) throw new DOMException('Analyst deadline exceeded', 'TimeoutError')\n        signals.push(AbortSignal.timeout(Math.ceil(remaining)))\n      }\n      const signal = AbortSignal.any(signals)\n      signal.throwIfAborted()\n      const analystContext = { ...context, signal }\n      const result = await config.evaluate(\n        input,\n        {\n          signal,\n          // No implicit account may override the evaluator's configured spending authority.\n          costLedger:\n            context.costLedger ??\n            (context.budgetUsd === undefined\n              ? undefined\n              : new CostLedger({ costCeilingUsd: context.budgetUsd })),\n          actor: config.id,\n          channel: 'analyst',\n          costPhase: context.costPhase,\n          costTags: { ...context.tags, runId: context.runId, correlationId: context.correlationId },\n          onReceipt: (receipt) =>\n            context.recordUsage?.({\n              calls: 1,\n              tokens: receipt.usageUnknown\n                ? null\n                : { input: receipt.inputTokens, output: receipt.outputTokens },\n              cost: receipt.costUnknown\n                ? { kind: 'uncaptured', usd: null }\n                : {\n                    kind: receipt.actualCostUsd === undefined ? 'estimated' : 'observed',\n                    usd: receipt.costUsd,\n                  },\n            }),\n        },\n        analystContext,\n      )\n      await config.record?.(result, input, analystContext)\n      signal.throwIfAborted()\n      const findings = await config.map(result.value, input, analystContext)\n      signal.throwIfAborted()\n      return findings\n    },\n  }\n}\n"],"mappings":"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"}

package/dist/{exact-types-CD0lf5Qd.d.ts → exact-types-CflbJ9f3.d.ts}

@@ -1,4 +1,4 @@
-import { d as AnalystRunResult, f as AnalystRunSummary, l as AnalystRunEvent, n as Analyst } from "./types-oKRhQAde.js";
+import { c as AnalystRunEvent, d as AnalystRunSummary, t as Analyst, u as AnalystRunResult } from "./types-CW8ewATZ.js";
 import { z } from "zod";
 //#region src/analyst/exact-types.d.ts
 /** Analyst metadata required before the exact registry path will execute it. */
@@ -231,4 +231,4 @@ declare const exactExecutionPlanSchema: z.ZodObject<{
 }, z.core.$strict>;
 //#endregion
 export { ExactAnalystRunPolicySnapshot as a, ExactAnalystSnapshot as c, ExactExecutionComponentSnapshot as d, ExactAnalystRunEvent as i, ExactCapableAnalyst as l, ExactAnalystExecutionPlanSnapshot as n, ExactAnalystRunResult as o, ExactAnalystRunCompletion as r, ExactAnalystRunSummary as s, ExactAnalystBudgetSnapshot as t, ExactExecutionComponentIdentity as u };
-//# sourceMappingURL=exact-types-CD0lf5Qd.d.ts.map
+//# sourceMappingURL=exact-types-CflbJ9f3.d.ts.map

package/dist/{exact-types-CD0lf5Qd.d.ts.map → exact-types-CflbJ9f3.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"exact-types-CD0lf5Qd.d.ts","names":[],"sources":["../src/analyst/exact-types.ts"],"mappings":";;;;UAMiB,oBAAoB,0BAA0B,QAAQ;;WAE5D,iBAAiB,SAAS;;KAGhC,aAAa,KAAK,0BAA0B,mBACpC,aAAa,UACtB,+BACc,aAAa,IAAI,aAAa,EAAE,WAC5C;KAEM,uBAAuB,aAAa,EAAE,aAAa;KACnD,6BAA6B,aAAa,EAAE,aAAa;;UAGpD;EACf;EACA;EACA,QAAQ,SAAS;;;UAIF;EACf;EACA;EACA;;KAyBU,gCAAgC,aAAa,EAAE,aAAa;KAC5D,oCAAoC,aAC9C,EAAE,aAAa;KAGL,yBAAyB;;EAEnC;;KAGU;EACN;;EAEA;EACA;IAAS;IAAe;;;UAGb,8BAA8B;EAC7C,aAAa;EACb,gBAAgB;EAChB,YAAY;;;KAIF,wBACP,QAAQ;EAAmB;;EAC1B,gBAAgB;MAEjB,KAAK,QAAQ;EAAmB;;EAC/B,SAAS;KAEX,QAAQ;EAAmB;MAC1B,KAAK,QAAQ;EAAmB;;EAC/B,SAAS;MAEV,KAAK,QAAQ;EAAmB;;EAC/B,QAAQ;;cAwCR,uBAAqB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAOzB,EAAA,KAAA;cAII,sBAAoB,EAAA,uBAAA,EAAA;;;;;;;;;;;GAaxB,EAAA,KAAA;cAiBI,sBAAoB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAYxB,EAAA,KAAA;cAEI,0BAAwB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+E1B,EAAA,KAAA"}
+{"version":3,"file":"exact-types-CflbJ9f3.d.ts","names":[],"sources":["../src/analyst/exact-types.ts"],"mappings":";;;;UAMiB,oBAAoB,0BAA0B,QAAQ;;WAE5D,iBAAiB,SAAS;;KAGhC,aAAa,KAAK,0BAA0B,mBACpC,aAAa,UACtB,+BACc,aAAa,IAAI,aAAa,EAAE,WAC5C;KAEM,uBAAuB,aAAa,EAAE,aAAa;KACnD,6BAA6B,aAAa,EAAE,aAAa;;UAGpD;EACf;EACA;EACA,QAAQ,SAAS;;;UAIF;EACf;EACA;EACA;;KAyBU,gCAAgC,aAAa,EAAE,aAAa;KAC5D,oCAAoC,aAC9C,EAAE,aAAa;KAGL,yBAAyB;;EAEnC;;KAGU;EACN;;EAEA;EACA;IAAS;IAAe;;;UAGb,8BAA8B;EAC7C,aAAa;EACb,gBAAgB;EAChB,YAAY;;;KAIF,wBACP,QAAQ;EAAmB;;EAC1B,gBAAgB;MAEjB,KAAK,QAAQ;EAAmB;;EAC/B,SAAS;KAEX,QAAQ;EAAmB;MAC1B,KAAK,QAAQ;EAAmB;;EAC/B,SAAS;MAEV,KAAK,QAAQ;EAAmB;;EAC/B,QAAQ;;cAwCR,uBAAqB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAOzB,EAAA,KAAA;cAII,sBAAoB,EAAA,uBAAA,EAAA;;;;;;;;;;;GAaxB,EAAA,KAAA;cAiBI,sBAAoB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAYxB,EAAA,KAAA;cAEI,0BAAwB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+E1B,EAAA,KAAA"}

package/dist/{exec-ChJ6d5if.js → exec-CpbtOXVt.js}

@@ -168,28 +168,6 @@ function finalRecordedOutcome(steps) {
 		reason: kind
 	};
 }
-/**
-* Steps whose recorded exit a replay cannot check.
-*
-* A killed step counts: the recording holds no exit status to compare a replay
-* against, so agreement on it cannot be measured either way.
-*/
-function unreadableExitCount(steps) {
-	return steps.filter((step) => classifyObservation(step.observation) !== "command-result").length;
-}
-/**
-* Throw unless every recorded command survived the dump.
-*
-* A replay executes `steps` verbatim, so one elision marker in an action means
-* the replay runs the literal two-to-four characters of the marker instead of
-* the command the run executed. The guard is here so a replayer needs one call
-* rather than a field check it can forget.
-*/
-function assertReplayableTrajectory(decoded) {
-	if (decoded.elidedCommands === 0) return;
-	const markers = decoded.steps.filter((step) => isElidedField(step.action)).map((step) => step.action);
-	throw new Error(`trajectory holds ${decoded.elidedCommands} command(s) the dump elided (${markers.slice(0, 5).join(", ")}); no dictionary maps a marker back to its text, so this trajectory cannot be replayed`);
-}
 //#endregion
 //#region src/trajectory-replay/exec.ts
 /**
@@ -203,6 +181,6 @@ function wrapActionForExec(action, cwd) {
 	return `cd ${`'${cwd.replaceAll("'", `'\\''`)}'`} && printf %s ${b64} | base64 -d | sh`;
 }
 //#endregion
-export { assertReplayableTrajectory as a, deriveFailureSignature as c, isRecordedTimeout as d, isSubmitAction as f, unreadableExitCount as g, parseRecordedReturncode as h, TIMEOUT_OBSERVATION_MARKER as i, finalRecordedOutcome as l, parseObservationOutput as m, FORMAT_ERROR_OBSERVATION_PREFIX as n, classifyObservation as o, isSubmitOnlyAction as p, SUBMIT_ACTION_SIGNATURE as r, decodeRecordedTurns as s, wrapActionForExec as t, isElidedField as u };
+export { classifyObservation as a, finalRecordedOutcome as c, isSubmitOnlyAction as d, parseObservationOutput as f, TIMEOUT_OBSERVATION_MARKER as i, isRecordedTimeout as l, FORMAT_ERROR_OBSERVATION_PREFIX as n, decodeRecordedTurns as o, parseRecordedReturncode as p, SUBMIT_ACTION_SIGNATURE as r, deriveFailureSignature as s, wrapActionForExec as t, isSubmitAction as u };
 
-//# sourceMappingURL=exec-ChJ6d5if.js.map
+//# sourceMappingURL=exec-CpbtOXVt.js.map

package/dist/{exec-ChJ6d5if.js.map → exec-CpbtOXVt.js.map}

@@ -1 +1 @@
-{"version":3,"file":"exec-ChJ6d5if.js","names":[],"sources":["../src/trajectory-replay/steps.ts","../src/trajectory-replay/exec.ts"],"sourcesContent":["/**\n * Recorded shell-trajectory steps and the observation grammar they carry.\n *\n * A recorded trajectory is the action/observation sequence an agent actually\n * ran. Scaffolds that execute one shell command per step (mini-SWE and the\n * CodeTracer-normalized corpora built from it) tag each observation with the\n * command's returncode and its combined output:\n *\n *     <returncode>2</returncode>\n *     <output>\n *     …command output…\n *     </output>\n *\n * That is one of four shapes a recorded turn carries, and the other three are\n * not command results at all:\n *\n *   - a timeout notice, when the environment killed the command at its bound;\n *   - a format-error notice, when the scaffold rejected the turn and ran\n *     nothing;\n *   - an elision marker `$<hex>`, when the published dump dropped the string.\n *\n * A turn also carries no observation when it is the run's last turn, because\n * the scaffold records an observation only when it hands one back to the model.\n *\n * The parsers here are the only place that grammar is decoded. Everything\n * downstream — replay verdicts, corpus enumeration, admission funnels, fix\n * prompts — reads the returncode, the output, and the failure signature through\n * these functions. A second decoder elsewhere is how a corpus reads as\n * unreplayable when it is not.\n */\n\n/**\n * One step of a recorded shell trajectory. Structural: any richer step record\n * (file refs, thinking text, tool type) satisfies it.\n */\nexport interface RecordedTrajectoryStep {\n  /** 1-based position in the trajectory. */\n  readonly step_id: number\n  readonly action: string\n  /** Null when the step recorded no observation (terminal submit steps). */\n  readonly observation: string | null\n}\n\n/** Recorded returncode of a step, or null when the observation carries none. */\nexport function parseRecordedReturncode(observation: string | null): number | null {\n  if (!observation) return null\n  const m = /<returncode>(-?\\d+)<\\/returncode>/.exec(observation)\n  return m ? Number(m[1]) : null\n}\n\n/** Text between the observation's <output> tags, or the raw observation when\n *  the tags are absent. */\nexport function parseObservationOutput(observation: string | null): string {\n  if (!observation) return ''\n  const m = /<output>\\n?([\\s\\S]*?)\\n?<\\/output>/.exec(observation)\n  return m ? m[1]! : observation\n}\n\n/**\n * Stable failure-signature candidate: the first error line, or a shell\n * command-not-found suffix. Null when neither exists — a verdict then falls\n * back to returncode-only matching and says so.\n * Pass an explicit signature to override (compiler quote glyphs vary with\n * locale, so a hand-picked ASCII substring is often more robust).\n */\nexport function deriveFailureSignature(observation: string | null): string | null {\n  for (const line of parseObservationOutput(observation).split('\\n')) {\n    if (/\\berror\\b/i.test(line)) return line.trim().slice(0, 200)\n    // The shell prefix differs between recorded bash and replayed /bin/sh.\n    const missingCommand = /([A-Za-z0-9_.+/-]+: (?:command )?not found)\\b/.exec(line)\n    if (missingCommand) return missingCommand[1]!.slice(0, 200)\n  }\n  return null\n}\n\n/** mini-SWE's end-of-run submit convention: the agent echoes this sentinel\n *  and dumps the diff. A label on this step marks a bad SUBMIT DECISION, not a\n *  failed command — there is no executable failure to reproduce, so it is\n *  never a counterfactual replay target. */\nexport const SUBMIT_ACTION_SIGNATURE = 'COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT'\n\nexport function isSubmitAction(action: string): boolean {\n  return action.includes(SUBMIT_ACTION_SIGNATURE)\n}\n\n/**\n * True when the action is the sentinel echo and nothing else.\n *\n * The distinction decides whether a step may be dropped. An agent is told to\n * issue the sentinel alone, and 5.7% of recorded runs end on a command that\n * writes files or edits them and then echoes it. Dropping such a step because\n * it holds the sentinel would remove the run's last state change from the\n * replay, so the recorded end state and the replayed one would differ.\n */\nexport function isSubmitOnlyAction(action: string): boolean {\n  return /^echo\\s+(?:\"COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT\"|'COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT'|COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT)$/.test(\n    action.trim(),\n  )\n}\n\n// ── Fields the published dump dropped ────────────────────────────────\n\n/**\n * A field the dump replaced with a counter instead of its text.\n *\n * The counter is hexadecimal and rises by one per dropped string in document\n * order, so a decimal-only reading (`$12`) accepts every marker that carries a\n * letter (`$3a`) as if it were real text. A command read that way replays as\n * the literal two-to-four characters `$3a`, which is not the command the run\n * executed.\n *\n * Nothing in the dump maps a marker back to its text: the same marker carries\n * different content in different rows, so there is no dictionary to read. A\n * field that matches is unrecoverable, so a caller rejects the row that holds\n * it rather than replaying the marker.\n */\nconst RECORDED_ELISION_PATTERN = /^\\$[0-9a-f]+$/\n\nexport function isElidedField(value: string | null | undefined): boolean {\n  return typeof value === 'string' && RECORDED_ELISION_PATTERN.test(value)\n}\n\n// ── Observation grammar ──────────────────────────────────────────────\n\n/** Substring the timeout notice always carries, whatever the command was. */\nexport const TIMEOUT_OBSERVATION_MARKER = 'timed out and has been killed'\n\n/** Opening of the notice the scaffold writes when a turn held no single action. */\nexport const FORMAT_ERROR_OBSERVATION_PREFIX =\n  'Please always provide EXACTLY ONE action in triple backticks, found '\n\n/**\n * What a recorded observation is.\n *\n * `command-result` is the only kind that carries an exit status. `timeout` and\n * `format-error` are the scaffold speaking rather than a command: the first\n * says the environment killed the command, the second says no command ran at\n * all. `elided` and `absent` carry no information about the step, and\n * `unreadable` is a shape this grammar does not know — never assumed to be\n * anything.\n */\nexport type RecordedObservationKind =\n  | 'command-result'\n  | 'timeout'\n  | 'format-error'\n  | 'elided'\n  | 'absent'\n  | 'unreadable'\n\nexport function classifyObservation(observation: string | null): RecordedObservationKind {\n  if (observation === null) return 'absent'\n  if (isElidedField(observation)) return 'elided'\n  if (parseRecordedReturncode(observation) !== null) return 'command-result'\n  if (observation.startsWith(FORMAT_ERROR_OBSERVATION_PREFIX)) return 'format-error'\n  if (observation.includes(TIMEOUT_OBSERVATION_MARKER)) return 'timeout'\n  return 'unreadable'\n}\n\n/** True when the recording shows the environment killed this step at its\n *  wall-clock bound. Such a step carries no returncode, so no replay can\n *  confirm or contradict it. */\nexport function isRecordedTimeout(observation: string | null): boolean {\n  return classifyObservation(observation) === 'timeout'\n}\n\n// ── Turns to steps ───────────────────────────────────────────────────\n\n/**\n * One turn as the published trajectory dump holds it.\n *\n * A turn is not a step: the system prompt, the task statement and every turn\n * the scaffold rejected are turns that executed nothing.\n */\nexport interface RecordedTrajectoryTurn {\n  readonly src?: string | null\n  readonly msg?: string | null\n  readonly tools?: readonly { readonly cmd?: string | null }[] | null\n  readonly obs?: string | null\n}\n\nexport interface DecodedTrajectory {\n  /** Executed commands in recorded order, each holding its OWN observation. */\n  readonly steps: readonly RecordedTrajectoryStep[]\n  /** Turns the scaffold rejected before anything ran. */\n  readonly formatErrorTurns: number\n  /**\n   * Executed commands whose text the dump dropped.\n   *\n   * The step stays in `steps` carrying the marker, because the run did execute\n   * a command there and a shorter list would misreport the trajectory. The\n   * marker is not a command, so any count above zero means this trajectory\n   * cannot be replayed: gate on it, or call `assertReplayableTrajectory`.\n   */\n  readonly elidedCommands: number\n  /** True when the run's last turn was the submit sentinel with no observation. */\n  readonly endedOnSubmitSentinel: boolean\n  /** Turns carrying an observation this grammar cannot read. */\n  readonly unreadableTurns: number\n}\n\n/**\n * Pair every recorded command with the observation of its own turn.\n *\n * Collecting commands and observations into two lists and zipping them is the\n * decode that looks right and is not: a turn the scaffold rejected carries an\n * observation of its own, so from the first such turn onward every observation\n * belongs to a different command than the one it is read against.\n *\n * A rejected turn executed nothing, so it is never a step — including when the\n * dump recorded a command for it. The scaffold rejects a turn holding several\n * bash blocks and runs none of them, while the dump keeps one of the blocks in\n * the command field. Replaying that field would execute a command the recorded\n * run did not, which is a worse corpus than a smaller one.\n *\n * A rejected turn is recognised by its observation, so a rejected turn whose\n * observation the dump elided is indistinguishable from an executed command\n * whose observation it elided. Both read as a step. Nothing in the dump\n * separates them, and the row-level defence is the share of unreadable exits a\n * caller admits: a row with no elided observation cannot hold this case at all.\n *\n * A trailing step that echoes the sentinel and nothing else, with no\n * observation, is dropped from `steps` and reported as `endedOnSubmitSentinel`.\n * The scaffold records an observation only when it hands one to the model, and\n * the sentinel ends the run, so the missing observation is the end of the\n * transcript rather than a gap in it. Echoing the sentinel changes no state, so\n * the recorded end state is the state the step before it left.\n *\n * A step that DID get an observation stays a step: the run continued past it.\n * So does a step that echoes the sentinel after doing real work — its state\n * change is part of the recorded end state, and with no observation its exit is\n * unknown, which `finalRecordedOutcome` reports rather than hides.\n */\nexport function decodeRecordedTurns(turns: readonly RecordedTrajectoryTurn[]): DecodedTrajectory {\n  const steps: RecordedTrajectoryStep[] = []\n  let formatErrorTurns = 0\n  let unreadableTurns = 0\n  for (const turn of turns) {\n    const command = turn.tools?.[0]?.cmd ?? null\n    const observation = turn.obs ?? null\n    const kind = classifyObservation(observation)\n    if (kind === 'format-error') {\n      formatErrorTurns += 1\n      continue\n    }\n    if (command === null) {\n      if (kind === 'unreadable' || kind === 'elided') unreadableTurns += 1\n      continue\n    }\n    steps.push({ step_id: steps.length + 1, action: command, observation })\n  }\n  const last = steps[steps.length - 1]\n  const endedOnSubmitSentinel =\n    last !== undefined && last.observation === null && isSubmitOnlyAction(last.action)\n  if (endedOnSubmitSentinel) steps.pop()\n  return {\n    steps,\n    formatErrorTurns,\n    elidedCommands: steps.filter((step) => isElidedField(step.action)).length,\n    endedOnSubmitSentinel,\n    unreadableTurns,\n  }\n}\n\n// ── The state a trajectory ended in ──────────────────────────────────\n\n/**\n * How the recorded run's last executed command ended.\n *\n * `killed` is a measured outcome, not a missing one: the environment stopped\n * the command at its bound and wrote a notice instead of an exit status.\n * `unreadable` names the observation kind that blocked the read, so a funnel\n * can report which shape cost it the row.\n */\nexport type RecordedFinalOutcome =\n  | { readonly kind: 'returncode'; readonly value: number }\n  | { readonly kind: 'killed' }\n  | { readonly kind: 'unreadable'; readonly reason: RecordedObservationKind }\n\n/**\n * The outcome of the last step, or `null` when the trajectory has no steps.\n *\n * Reads only the last step. `decodeRecordedTurns` has already removed the turns\n * that executed nothing, so the last step is the last command the run ran.\n */\nexport function finalRecordedOutcome(\n  steps: readonly RecordedTrajectoryStep[],\n): RecordedFinalOutcome | null {\n  const last = steps[steps.length - 1]\n  if (last === undefined) return null\n  const kind = classifyObservation(last.observation)\n  if (kind === 'command-result') {\n    return { kind: 'returncode', value: parseRecordedReturncode(last.observation)! }\n  }\n  if (kind === 'timeout') return { kind: 'killed' }\n  return { kind: 'unreadable', reason: kind }\n}\n\n/**\n * Steps whose recorded exit a replay cannot check.\n *\n * A killed step counts: the recording holds no exit status to compare a replay\n * against, so agreement on it cannot be measured either way.\n */\nexport function unreadableExitCount(steps: readonly RecordedTrajectoryStep[]): number {\n  return steps.filter((step) => classifyObservation(step.observation) !== 'command-result').length\n}\n\n/**\n * Throw unless every recorded command survived the dump.\n *\n * A replay executes `steps` verbatim, so one elision marker in an action means\n * the replay runs the literal two-to-four characters of the marker instead of\n * the command the run executed. The guard is here so a replayer needs one call\n * rather than a field check it can forget.\n */\nexport function assertReplayableTrajectory(decoded: DecodedTrajectory): void {\n  if (decoded.elidedCommands === 0) return\n  const markers = decoded.steps\n    .filter((step) => isElidedField(step.action))\n    .map((step) => step.action)\n  throw new Error(\n    `trajectory holds ${decoded.elidedCommands} command(s) the dump elided (${markers.slice(0, 5).join(', ')}); ` +\n      'no dictionary maps a marker back to its text, so this trajectory cannot be replayed',\n  )\n}\n","/**\n * The execution boundary replay runs across.\n *\n * A replay needs one thing from its environment: a session that runs a shell\n * command inside the trajectory's own image and reports the exit code and\n * output. That is the whole contract. Concrete backends — a sandbox platform\n * client, a docker exec, an SSH shell — live with the consumer that owns the\n * infrastructure, so this package depends on no sandbox client.\n */\n\nexport interface ReplayExecResult {\n  exitCode: number\n  stdout: string\n  stderr: string\n}\n\nexport interface ReplayExecSession {\n  exec(command: string, timeoutMs: number): Promise<ReplayExecResult>\n  close(): Promise<void>\n}\n\nexport interface ReplayExecBackend {\n  /** One fresh execution environment per call; the caller closes it. */\n  open(): Promise<ReplayExecSession>\n}\n\n/** Builds a backend pinned to one image. Callers that resolve images\n *  internally (batch, corpus wire, finding verification) take this instead of\n *  a backend, so every case runs against its own image. */\nexport type ReplayExecBackendFactory = (image: string) => ReplayExecBackend\n\n/**\n * mini-SWE runs every action as a fresh /bin/sh subshell from a fixed\n * workdir. Reproduce that exactly — and stay quote-proof for arbitrary\n * recorded actions — by piping the base64 of the action into `sh` after\n * cd-ing to the workdir. Exit code is sh's, i.e. the action's.\n */\nexport function wrapActionForExec(action: string, cwd: string): string {\n  const b64 = Buffer.from(action, 'utf8').toString('base64')\n  const quotedCwd = `'${cwd.replaceAll(\"'\", `'\\\\''`)}'`\n  return `cd ${quotedCwd} && printf %s ${b64} | base64 -d | sh`\n}\n"],"mappings":"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"}
+{"version":3,"file":"exec-CpbtOXVt.js","names":[],"sources":["../src/trajectory-replay/steps.ts","../src/trajectory-replay/exec.ts"],"sourcesContent":["/**\n * Recorded shell-trajectory steps and the observation grammar they carry.\n *\n * A recorded trajectory is the action/observation sequence an agent actually\n * ran. Scaffolds that execute one shell command per step (mini-SWE and the\n * CodeTracer-normalized corpora built from it) tag each observation with the\n * command's returncode and its combined output:\n *\n *     <returncode>2</returncode>\n *     <output>\n *     …command output…\n *     </output>\n *\n * That is one of four shapes a recorded turn carries, and the other three are\n * not command results at all:\n *\n *   - a timeout notice, when the environment killed the command at its bound;\n *   - a format-error notice, when the scaffold rejected the turn and ran\n *     nothing;\n *   - an elision marker `$<hex>`, when the published dump dropped the string.\n *\n * A turn also carries no observation when it is the run's last turn, because\n * the scaffold records an observation only when it hands one back to the model.\n *\n * The parsers here are the only place that grammar is decoded. Everything\n * downstream — replay verdicts, corpus enumeration, admission funnels, fix\n * prompts — reads the returncode, the output, and the failure signature through\n * these functions. A second decoder elsewhere is how a corpus reads as\n * unreplayable when it is not.\n */\n\n/**\n * One step of a recorded shell trajectory. Structural: any richer step record\n * (file refs, thinking text, tool type) satisfies it.\n */\nexport interface RecordedTrajectoryStep {\n  /** 1-based position in the trajectory. */\n  readonly step_id: number\n  readonly action: string\n  /** Null when the step recorded no observation (terminal submit steps). */\n  readonly observation: string | null\n}\n\n/** Recorded returncode of a step, or null when the observation carries none. */\nexport function parseRecordedReturncode(observation: string | null): number | null {\n  if (!observation) return null\n  const m = /<returncode>(-?\\d+)<\\/returncode>/.exec(observation)\n  return m ? Number(m[1]) : null\n}\n\n/** Text between the observation's <output> tags, or the raw observation when\n *  the tags are absent. */\nexport function parseObservationOutput(observation: string | null): string {\n  if (!observation) return ''\n  const m = /<output>\\n?([\\s\\S]*?)\\n?<\\/output>/.exec(observation)\n  return m ? m[1]! : observation\n}\n\n/**\n * Stable failure-signature candidate: the first error line, or a shell\n * command-not-found suffix. Null when neither exists — a verdict then falls\n * back to returncode-only matching and says so.\n * Pass an explicit signature to override (compiler quote glyphs vary with\n * locale, so a hand-picked ASCII substring is often more robust).\n */\nexport function deriveFailureSignature(observation: string | null): string | null {\n  for (const line of parseObservationOutput(observation).split('\\n')) {\n    if (/\\berror\\b/i.test(line)) return line.trim().slice(0, 200)\n    // The shell prefix differs between recorded bash and replayed /bin/sh.\n    const missingCommand = /([A-Za-z0-9_.+/-]+: (?:command )?not found)\\b/.exec(line)\n    if (missingCommand) return missingCommand[1]!.slice(0, 200)\n  }\n  return null\n}\n\n/** mini-SWE's end-of-run submit convention: the agent echoes this sentinel\n *  and dumps the diff. A label on this step marks a bad SUBMIT DECISION, not a\n *  failed command — there is no executable failure to reproduce, so it is\n *  never a counterfactual replay target. */\nexport const SUBMIT_ACTION_SIGNATURE = 'COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT'\n\nexport function isSubmitAction(action: string): boolean {\n  return action.includes(SUBMIT_ACTION_SIGNATURE)\n}\n\n/**\n * True when the action is the sentinel echo and nothing else.\n *\n * The distinction decides whether a step may be dropped. An agent is told to\n * issue the sentinel alone, and 5.7% of recorded runs end on a command that\n * writes files or edits them and then echoes it. Dropping such a step because\n * it holds the sentinel would remove the run's last state change from the\n * replay, so the recorded end state and the replayed one would differ.\n */\nexport function isSubmitOnlyAction(action: string): boolean {\n  return /^echo\\s+(?:\"COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT\"|'COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT'|COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT)$/.test(\n    action.trim(),\n  )\n}\n\n// ── Fields the published dump dropped ────────────────────────────────\n\n/**\n * A field the dump replaced with a counter instead of its text.\n *\n * The counter is hexadecimal and rises by one per dropped string in document\n * order, so a decimal-only reading (`$12`) accepts every marker that carries a\n * letter (`$3a`) as if it were real text. A command read that way replays as\n * the literal two-to-four characters `$3a`, which is not the command the run\n * executed.\n *\n * Nothing in the dump maps a marker back to its text: the same marker carries\n * different content in different rows, so there is no dictionary to read. A\n * field that matches is unrecoverable, so a caller rejects the row that holds\n * it rather than replaying the marker.\n */\nconst RECORDED_ELISION_PATTERN = /^\\$[0-9a-f]+$/\n\nexport function isElidedField(value: string | null | undefined): boolean {\n  return typeof value === 'string' && RECORDED_ELISION_PATTERN.test(value)\n}\n\n// ── Observation grammar ──────────────────────────────────────────────\n\n/** Substring the timeout notice always carries, whatever the command was. */\nexport const TIMEOUT_OBSERVATION_MARKER = 'timed out and has been killed'\n\n/** Opening of the notice the scaffold writes when a turn held no single action. */\nexport const FORMAT_ERROR_OBSERVATION_PREFIX =\n  'Please always provide EXACTLY ONE action in triple backticks, found '\n\n/**\n * What a recorded observation is.\n *\n * `command-result` is the only kind that carries an exit status. `timeout` and\n * `format-error` are the scaffold speaking rather than a command: the first\n * says the environment killed the command, the second says no command ran at\n * all. `elided` and `absent` carry no information about the step, and\n * `unreadable` is a shape this grammar does not know — never assumed to be\n * anything.\n */\nexport type RecordedObservationKind =\n  | 'command-result'\n  | 'timeout'\n  | 'format-error'\n  | 'elided'\n  | 'absent'\n  | 'unreadable'\n\nexport function classifyObservation(observation: string | null): RecordedObservationKind {\n  if (observation === null) return 'absent'\n  if (isElidedField(observation)) return 'elided'\n  if (parseRecordedReturncode(observation) !== null) return 'command-result'\n  if (observation.startsWith(FORMAT_ERROR_OBSERVATION_PREFIX)) return 'format-error'\n  if (observation.includes(TIMEOUT_OBSERVATION_MARKER)) return 'timeout'\n  return 'unreadable'\n}\n\n/** True when the recording shows the environment killed this step at its\n *  wall-clock bound. Such a step carries no returncode, so no replay can\n *  confirm or contradict it. */\nexport function isRecordedTimeout(observation: string | null): boolean {\n  return classifyObservation(observation) === 'timeout'\n}\n\n// ── Turns to steps ───────────────────────────────────────────────────\n\n/**\n * One turn as the published trajectory dump holds it.\n *\n * A turn is not a step: the system prompt, the task statement and every turn\n * the scaffold rejected are turns that executed nothing.\n */\nexport interface RecordedTrajectoryTurn {\n  readonly src?: string | null\n  readonly msg?: string | null\n  readonly tools?: readonly { readonly cmd?: string | null }[] | null\n  readonly obs?: string | null\n}\n\nexport interface DecodedTrajectory {\n  /** Executed commands in recorded order, each holding its OWN observation. */\n  readonly steps: readonly RecordedTrajectoryStep[]\n  /** Turns the scaffold rejected before anything ran. */\n  readonly formatErrorTurns: number\n  /**\n   * Executed commands whose text the dump dropped.\n   *\n   * The step stays in `steps` carrying the marker, because the run did execute\n   * a command there and a shorter list would misreport the trajectory. The\n   * marker is not a command, so any count above zero means this trajectory\n   * cannot be replayed: gate on it, or call `assertReplayableTrajectory`.\n   */\n  readonly elidedCommands: number\n  /** True when the run's last turn was the submit sentinel with no observation. */\n  readonly endedOnSubmitSentinel: boolean\n  /** Turns carrying an observation this grammar cannot read. */\n  readonly unreadableTurns: number\n}\n\n/**\n * Pair every recorded command with the observation of its own turn.\n *\n * Collecting commands and observations into two lists and zipping them is the\n * decode that looks right and is not: a turn the scaffold rejected carries an\n * observation of its own, so from the first such turn onward every observation\n * belongs to a different command than the one it is read against.\n *\n * A rejected turn executed nothing, so it is never a step — including when the\n * dump recorded a command for it. The scaffold rejects a turn holding several\n * bash blocks and runs none of them, while the dump keeps one of the blocks in\n * the command field. Replaying that field would execute a command the recorded\n * run did not, which is a worse corpus than a smaller one.\n *\n * A rejected turn is recognised by its observation, so a rejected turn whose\n * observation the dump elided is indistinguishable from an executed command\n * whose observation it elided. Both read as a step. Nothing in the dump\n * separates them, and the row-level defence is the share of unreadable exits a\n * caller admits: a row with no elided observation cannot hold this case at all.\n *\n * A trailing step that echoes the sentinel and nothing else, with no\n * observation, is dropped from `steps` and reported as `endedOnSubmitSentinel`.\n * The scaffold records an observation only when it hands one to the model, and\n * the sentinel ends the run, so the missing observation is the end of the\n * transcript rather than a gap in it. Echoing the sentinel changes no state, so\n * the recorded end state is the state the step before it left.\n *\n * A step that DID get an observation stays a step: the run continued past it.\n * So does a step that echoes the sentinel after doing real work — its state\n * change is part of the recorded end state, and with no observation its exit is\n * unknown, which `finalRecordedOutcome` reports rather than hides.\n */\nexport function decodeRecordedTurns(turns: readonly RecordedTrajectoryTurn[]): DecodedTrajectory {\n  const steps: RecordedTrajectoryStep[] = []\n  let formatErrorTurns = 0\n  let unreadableTurns = 0\n  for (const turn of turns) {\n    const command = turn.tools?.[0]?.cmd ?? null\n    const observation = turn.obs ?? null\n    const kind = classifyObservation(observation)\n    if (kind === 'format-error') {\n      formatErrorTurns += 1\n      continue\n    }\n    if (command === null) {\n      if (kind === 'unreadable' || kind === 'elided') unreadableTurns += 1\n      continue\n    }\n    steps.push({ step_id: steps.length + 1, action: command, observation })\n  }\n  const last = steps[steps.length - 1]\n  const endedOnSubmitSentinel =\n    last !== undefined && last.observation === null && isSubmitOnlyAction(last.action)\n  if (endedOnSubmitSentinel) steps.pop()\n  return {\n    steps,\n    formatErrorTurns,\n    elidedCommands: steps.filter((step) => isElidedField(step.action)).length,\n    endedOnSubmitSentinel,\n    unreadableTurns,\n  }\n}\n\n// ── The state a trajectory ended in ──────────────────────────────────\n\n/**\n * How the recorded run's last executed command ended.\n *\n * `killed` is a measured outcome, not a missing one: the environment stopped\n * the command at its bound and wrote a notice instead of an exit status.\n * `unreadable` names the observation kind that blocked the read, so a funnel\n * can report which shape cost it the row.\n */\nexport type RecordedFinalOutcome =\n  | { readonly kind: 'returncode'; readonly value: number }\n  | { readonly kind: 'killed' }\n  | { readonly kind: 'unreadable'; readonly reason: RecordedObservationKind }\n\n/**\n * The outcome of the last step, or `null` when the trajectory has no steps.\n *\n * Reads only the last step. `decodeRecordedTurns` has already removed the turns\n * that executed nothing, so the last step is the last command the run ran.\n */\nexport function finalRecordedOutcome(\n  steps: readonly RecordedTrajectoryStep[],\n): RecordedFinalOutcome | null {\n  const last = steps[steps.length - 1]\n  if (last === undefined) return null\n  const kind = classifyObservation(last.observation)\n  if (kind === 'command-result') {\n    return { kind: 'returncode', value: parseRecordedReturncode(last.observation)! }\n  }\n  if (kind === 'timeout') return { kind: 'killed' }\n  return { kind: 'unreadable', reason: kind }\n}\n\n/**\n * Steps whose recorded exit a replay cannot check.\n *\n * A killed step counts: the recording holds no exit status to compare a replay\n * against, so agreement on it cannot be measured either way.\n */\nexport function unreadableExitCount(steps: readonly RecordedTrajectoryStep[]): number {\n  return steps.filter((step) => classifyObservation(step.observation) !== 'command-result').length\n}\n\n/**\n * Throw unless every recorded command survived the dump.\n *\n * A replay executes `steps` verbatim, so one elision marker in an action means\n * the replay runs the literal two-to-four characters of the marker instead of\n * the command the run executed. The guard is here so a replayer needs one call\n * rather than a field check it can forget.\n */\nexport function assertReplayableTrajectory(decoded: DecodedTrajectory): void {\n  if (decoded.elidedCommands === 0) return\n  const markers = decoded.steps\n    .filter((step) => isElidedField(step.action))\n    .map((step) => step.action)\n  throw new Error(\n    `trajectory holds ${decoded.elidedCommands} command(s) the dump elided (${markers.slice(0, 5).join(', ')}); ` +\n      'no dictionary maps a marker back to its text, so this trajectory cannot be replayed',\n  )\n}\n","/**\n * The execution boundary replay runs across.\n *\n * A replay needs one thing from its environment: a session that runs a shell\n * command inside the trajectory's own image and reports the exit code and\n * output. That is the whole contract. Concrete backends — a sandbox platform\n * client, a docker exec, an SSH shell — live with the consumer that owns the\n * infrastructure, so this package depends on no sandbox client.\n */\n\nexport interface ReplayExecResult {\n  exitCode: number\n  stdout: string\n  stderr: string\n}\n\nexport interface ReplayExecSession {\n  exec(command: string, timeoutMs: number): Promise<ReplayExecResult>\n  close(): Promise<void>\n}\n\nexport interface ReplayExecBackend {\n  /** One fresh execution environment per call; the caller closes it. */\n  open(): Promise<ReplayExecSession>\n}\n\n/** Builds a backend pinned to one image. Callers that resolve images\n *  internally (batch, corpus wire, finding verification) take this instead of\n *  a backend, so every case runs against its own image. */\nexport type ReplayExecBackendFactory = (image: string) => ReplayExecBackend\n\n/**\n * mini-SWE runs every action as a fresh /bin/sh subshell from a fixed\n * workdir. Reproduce that exactly — and stay quote-proof for arbitrary\n * recorded actions — by piping the base64 of the action into `sh` after\n * cd-ing to the workdir. Exit code is sh's, i.e. the action's.\n */\nexport function wrapActionForExec(action: string, cwd: string): string {\n  const b64 = Buffer.from(action, 'utf8').toString('base64')\n  const quotedCwd = `'${cwd.replaceAll(\"'\", `'\\\\''`)}'`\n  return `cd ${quotedCwd} && printf %s ${b64} | base64 -d | sh`\n}\n"],"mappings":"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"}

package/dist/execution-tracks-CpgFPpS5.js.map

@@ -1 +1 @@
-{"version":3,"file":"execution-tracks-CpgFPpS5.js","names":[],"sources":["../src/trace/execution-tracks.ts"],"sourcesContent":["export interface ExecutionLane {\n  key: string\n  scopeKey: string\n  start: number | null\n  end: number | null\n}\n\n/** Assign lanes to serial tracks without joining concurrent or ambiguously timed work. */\nexport function executionTrackByLane(lanes: readonly ExecutionLane[]): Map<string, string> {\n  const unique = new Map<string, ExecutionLane>()\n  for (const lane of lanes) {\n    const existing = unique.get(lane.key)\n    if (existing && !sameLane(existing, lane)) {\n      throw new Error(`execution lane '${lane.key}' has conflicting scope or timing`)\n    }\n    unique.set(lane.key, lane)\n  }\n\n  const trackByLane = new Map<string, string>()\n  const lanesByScope = new Map<string, ExecutionLane[]>()\n  for (const lane of unique.values()) {\n    const scoped = lanesByScope.get(lane.scopeKey) ?? []\n    scoped.push(lane)\n    lanesByScope.set(lane.scopeKey, scoped)\n  }\n\n  for (const [scopeKey, scoped] of lanesByScope) {\n    if (scoped.some((lane) => lane.start === null && lane.end === null)) {\n      for (const lane of scoped) trackByLane.set(lane.key, trackId('lane', lane.key))\n      continue\n    }\n    const incompleteKeys = new Set<string>()\n    const boundarySet = new Set<number>()\n    for (const lane of scoped) {\n      if (lane.start !== null && lane.end !== null && lane.end > lane.start) continue\n      incompleteKeys.add(lane.key)\n      const boundary = lane.start ?? lane.end\n      if (boundary !== null) boundarySet.add(boundary)\n      trackByLane.set(lane.key, trackId('lane', lane.key))\n    }\n    const boundaries = [...boundarySet].sort((a, b) => a - b)\n    const completeBySegment = new Map<number, ExecutionLane[]>()\n    for (const lane of scoped) {\n      if (incompleteKeys.has(lane.key)) continue\n      const segment = upperBound(boundaries, lane.start!)\n      const nextBoundary = boundaries[segment]\n      if (nextBoundary !== undefined && nextBoundary < lane.end!) {\n        trackByLane.set(lane.key, trackId('lane', lane.key))\n        continue\n      }\n      const complete = completeBySegment.get(segment) ?? []\n      complete.push(lane)\n      completeBySegment.set(segment, complete)\n    }\n\n    let serialTrack = 0\n    for (const [, segment] of [...completeBySegment].sort(([a], [b]) => a - b)) {\n      const ordered = [...segment].sort(\n        (a, b) => a.start! - b.start! || a.end! - b.end! || a.key.localeCompare(b.key),\n      )\n      let component: ExecutionLane[] = []\n      let componentEnd = Number.NEGATIVE_INFINITY\n      const flush = () => {\n        if (component.length === 1) {\n          trackByLane.set(component[0]!.key, trackId('serial', scopeKey, serialTrack))\n        } else if (component.length > 1) {\n          for (const lane of component) trackByLane.set(lane.key, trackId('lane', lane.key))\n          serialTrack += 1\n        }\n        component = []\n        componentEnd = Number.NEGATIVE_INFINITY\n      }\n\n      for (const lane of ordered) {\n        if (component.length > 0 && lane.start! >= componentEnd) flush()\n        component.push(lane)\n        componentEnd = Math.max(componentEnd, lane.end!)\n      }\n      flush()\n      serialTrack += 1\n    }\n  }\n\n  return trackByLane\n}\n\nfunction sameLane(a: ExecutionLane, b: ExecutionLane): boolean {\n  return a.scopeKey === b.scopeKey && a.start === b.start && a.end === b.end\n}\n\nfunction trackId(kind: string, key: string, index?: number): string {\n  return JSON.stringify(index === undefined ? [kind, key] : [kind, key, index])\n}\n\nfunction upperBound(sorted: readonly number[], target: number): number {\n  let low = 0\n  let high = sorted.length\n  while (low < high) {\n    const middle = (low + high) >>> 1\n    if (sorted[middle]! <= target) low = middle + 1\n    else high = middle\n  }\n  return low\n}\n"],"mappings":"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"}
+{"version":3,"file":"execution-tracks-CpgFPpS5.js","names":[],"sources":["../src/trace/execution-tracks.ts"],"sourcesContent":["interface ExecutionLane {\n  key: string\n  scopeKey: string\n  start: number | null\n  end: number | null\n}\n\n/** Assign lanes to serial tracks without joining concurrent or ambiguously timed work. */\nexport function executionTrackByLane(lanes: readonly ExecutionLane[]): Map<string, string> {\n  const unique = new Map<string, ExecutionLane>()\n  for (const lane of lanes) {\n    const existing = unique.get(lane.key)\n    if (existing && !sameLane(existing, lane)) {\n      throw new Error(`execution lane '${lane.key}' has conflicting scope or timing`)\n    }\n    unique.set(lane.key, lane)\n  }\n\n  const trackByLane = new Map<string, string>()\n  const lanesByScope = new Map<string, ExecutionLane[]>()\n  for (const lane of unique.values()) {\n    const scoped = lanesByScope.get(lane.scopeKey) ?? []\n    scoped.push(lane)\n    lanesByScope.set(lane.scopeKey, scoped)\n  }\n\n  for (const [scopeKey, scoped] of lanesByScope) {\n    if (scoped.some((lane) => lane.start === null && lane.end === null)) {\n      for (const lane of scoped) trackByLane.set(lane.key, trackId('lane', lane.key))\n      continue\n    }\n    const incompleteKeys = new Set<string>()\n    const boundarySet = new Set<number>()\n    for (const lane of scoped) {\n      if (lane.start !== null && lane.end !== null && lane.end > lane.start) continue\n      incompleteKeys.add(lane.key)\n      const boundary = lane.start ?? lane.end\n      if (boundary !== null) boundarySet.add(boundary)\n      trackByLane.set(lane.key, trackId('lane', lane.key))\n    }\n    const boundaries = [...boundarySet].sort((a, b) => a - b)\n    const completeBySegment = new Map<number, ExecutionLane[]>()\n    for (const lane of scoped) {\n      if (incompleteKeys.has(lane.key)) continue\n      const segment = upperBound(boundaries, lane.start!)\n      const nextBoundary = boundaries[segment]\n      if (nextBoundary !== undefined && nextBoundary < lane.end!) {\n        trackByLane.set(lane.key, trackId('lane', lane.key))\n        continue\n      }\n      const complete = completeBySegment.get(segment) ?? []\n      complete.push(lane)\n      completeBySegment.set(segment, complete)\n    }\n\n    let serialTrack = 0\n    for (const [, segment] of [...completeBySegment].sort(([a], [b]) => a - b)) {\n      const ordered = [...segment].sort(\n        (a, b) => a.start! - b.start! || a.end! - b.end! || a.key.localeCompare(b.key),\n      )\n      let component: ExecutionLane[] = []\n      let componentEnd = Number.NEGATIVE_INFINITY\n      const flush = () => {\n        if (component.length === 1) {\n          trackByLane.set(component[0]!.key, trackId('serial', scopeKey, serialTrack))\n        } else if (component.length > 1) {\n          for (const lane of component) trackByLane.set(lane.key, trackId('lane', lane.key))\n          serialTrack += 1\n        }\n        component = []\n        componentEnd = Number.NEGATIVE_INFINITY\n      }\n\n      for (const lane of ordered) {\n        if (component.length > 0 && lane.start! >= componentEnd) flush()\n        component.push(lane)\n        componentEnd = Math.max(componentEnd, lane.end!)\n      }\n      flush()\n      serialTrack += 1\n    }\n  }\n\n  return trackByLane\n}\n\nfunction sameLane(a: ExecutionLane, b: ExecutionLane): boolean {\n  return a.scopeKey === b.scopeKey && a.start === b.start && a.end === b.end\n}\n\nfunction trackId(kind: string, key: string, index?: number): string {\n  return JSON.stringify(index === undefined ? [kind, key] : [kind, key, index])\n}\n\nfunction upperBound(sorted: readonly number[], target: number): number {\n  let low = 0\n  let high = sorted.length\n  while (low < high) {\n    const middle = (low + high) >>> 1\n    if (sorted[middle]! <= target) low = middle + 1\n    else high = middle\n  }\n  return low\n}\n"],"mappings":"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"}