@tangle-network/agent-runtime 0.94.6 → 0.94.7

package/dist/agent.d.ts

@@ -1,7 +1,7 @@
 import * as _tangle_network_agent_eval from '@tangle-network/agent-eval';
 import { TraceAnalystKindSpec, AnalystFinding } from '@tangle-network/agent-eval';
 import { A as ArtifactKind, C as CandidateGenerator, P as PromotionGate } from './generator-YkAQrOoD.js';
-import { a as RuntimeStreamEvent, S as SandboxClient, c as OutputAdapter, d as AgentRunSpec } from './types-Kjr5W6OF.js';
+import { a as RuntimeStreamEvent, S as SandboxClient, c as OutputAdapter, d as AgentRunSpec } from './types-CKmyZ9TP.js';
 import { A as AgentSurfaces } from './improvement-adapter-BieWeK5J.js';
 export { C as CreateSurfaceImprovementAdapterOpts, D as DraftPatchInput, a as DraftPatchOutput, R as ResolvedSurface, S as SurfaceImprovementEdit, b as SurfaceValidationIssue, c as createSurfaceImprovementAdapter, r as renderSurfaceIssues, d as resolveSubjectPath, v as validateSurfaces } from './improvement-adapter-BieWeK5J.js';
 import { K as KnowledgeAdapter, a as RunAnalystLoopResult } from './types-BC3bZpH0.js';

package/dist/agent.js

@@ -1,7 +1,7 @@
-import "./chunk-GKZ6DFDN.js";
+import "./chunk-7HH22XN4.js";
 import {
   createSandboxForSpec
-} from "./chunk-LWNMCOEA.js";
+} from "./chunk-FRXDOBFP.js";
 import "./chunk-DPEUKJRO.js";
 import "./chunk-ISTDY47H.js";
 import "./chunk-WIPGQ4GT.js";
@@ -9,8 +9,8 @@ import "./chunk-VSWBYWFK.js";
 import "./chunk-3MDZX7YU.js";
 import {
   mapSandboxEvent
-} from "./chunk-FVJ7M3DA.js";
-import "./chunk-WQA5Y6PD.js";
+} from "./chunk-M22PL4GH.js";
+import "./chunk-EP6RVHMX.js";
 import {
   ValidationError
 } from "./chunk-YEJR7IXO.js";

package/dist/{agentic-generator-CL1q0H91.d.ts → agentic-generator-1g7GDba7.d.ts}

@@ -1,5 +1,6 @@
-import { AnalystFinding } from '@tangle-network/agent-eval';
-import { L as LocalHarness, r as runLocalHarness } from './local-harness-CePtFrwu.js';
+import { AnalystFinding, CostLedger, MaximumCharge } from '@tangle-network/agent-eval';
+import { AgentProfile, ReasoningEffort } from '@tangle-network/agent-interface';
+import { L as LocalHarness, C as CodexTokenUsage, a as CodexExecutionEvidence, r as runLocalHarness } from './local-harness-ZLMkKdZc.js';
 import { LabeledScenarioStore, WorktreeAdapter, SurfaceProposer } from '@tangle-network/agent-eval/campaign';
 
 /**
@@ -42,7 +43,7 @@ interface CandidateGenerator {
      *  for a guaranteed no-op. Default `false`. */
     proposesWithoutFindings?: boolean;
     generate(args: {
-        /** The candidate worktree — a fresh checkout of baseRef. Write changes here. */
+        /** The candidate worktree — a clean checkout of the current incumbent. */
         worktreePath: string;
         /** Phase-2 research report (analyst findings + diff), opaque. */
         report: unknown;
@@ -54,6 +55,13 @@ interface CandidateGenerator {
          *  reflective generator ignores it). */
         maxShots: number;
         signal: AbortSignal;
+        /** Improvement-loop coordinates. Present when called through improvementDriver. */
+        generation?: number;
+        candidateIndex?: number;
+        /** Shared run-wide paid-call account supplied by agent-eval 0.117+. */
+        costLedger?: CostLedger;
+        /** Receipt attribution phase supplied alongside `costLedger`. */
+        costPhase?: string;
     }): Promise<{
         applied: boolean;
         summary: string;
@@ -62,11 +70,12 @@ interface CandidateGenerator {
 interface ImprovementDriverOptions {
     worktree: WorktreeAdapter;
     generator: CandidateGenerator;
-    /** Base ref candidate worktrees fork from. Default `main`. */
+    /** Root ref for first-generation/direct callers. Default `main`.
+     *  Later code generations retain the incumbent's original root. */
     baseRef?: string;
 }
 interface ManagedImprovementDriver extends SurfaceProposer<AnalystFinding> {
-    /** Remove every finalized candidate except explicitly retained winners. */
+    /** Remove every owned candidate except explicitly retained finalized winners. */
     cleanup(retainWorktreeRefs?: readonly string[]): Promise<void>;
 }
 /** The one reflective/agentic improvement proposer (`SurfaceProposer`): owns the candidate worktree lifecycle and delegates HOW a change is produced to a pluggable `CandidateGenerator`. */
@@ -106,6 +115,9 @@ declare function improvementDriver(opts: ImprovementDriverOptions): ManagedImpro
  * @experimental
  */
 
+/** Dedicated ephemeral root for generic author-profile files. Every declared
+ * file must live below this root so cleanup cannot alter candidate-owned files. */
+declare const AGENTIC_PROFILE_RESOURCE_ROOT = ".agent-runtime-profile-resources";
 /** Outcome of verifying a candidate worktree. `feedback` (compiler errors,
  *  failing test output) is fed into the next shot when `ok` is false. */
 interface VerifyResult {
@@ -116,9 +128,64 @@ interface VerifyResult {
  *  (a candidate that fails verification returns `{ok:false}`, it does not
  *  throw). */
 type Verifier = (worktreePath: string) => Promise<VerifyResult> | VerifyResult;
+interface AgenticGeneratorShotReceipt {
+    readonly schemaVersion: 1;
+    readonly generation: number | null;
+    readonly candidateIndex: number | null;
+    /** One-based shot number within this candidate. */
+    readonly shot: number;
+    readonly maxShots: number;
+    readonly harness: LocalHarness;
+    readonly model: string | null;
+    readonly reasoningEffort: ReasoningEffort | null;
+    readonly promptSha256: `sha256:${string}`;
+    readonly startedAt: string;
+    readonly completedAt: string;
+    readonly durationMs: number;
+    readonly exitCode: number | null;
+    readonly timedOut: boolean;
+    readonly killedBySignal: NodeJS.Signals | null;
+    readonly stdoutBytes: number | null;
+    readonly stdoutSha256: `sha256:${string}` | null;
+    readonly stderrBytes: number | null;
+    readonly stderrSha256: `sha256:${string}` | null;
+    readonly usage: CodexTokenUsage | null;
+    /** Digest of the exact profile-file workspace plan applied for this shot. */
+    readonly profileWorkspacePlanDigest: string | null;
+    readonly profileWorkspaceFileCount: number;
+    /** Shared run-ledger call id for this exact shot. */
+    readonly costCallId: string | null;
+    /** Whether dollars came from the provider, the pricing table, or are unknown. */
+    readonly costBasis: 'provider-reported' | 'estimated-pricing' | 'unknown';
+    readonly costUsd: number | null;
+    /** True only for a provider-reported amount, never for a pricing estimate. */
+    readonly costUsdKnown: boolean;
+    readonly evidence: CodexExecutionEvidence | null;
+    readonly error: {
+        readonly name: string;
+        readonly message: string;
+    } | null;
+}
 interface AgenticGeneratorOptions {
     /** Local coding harness to run in the worktree. Default `claude`. */
     harness?: LocalHarness;
+    /** Author profile rendered through the canonical harness mapper. Required
+     *  for reproducible Codex so model and reasoning settings are explicit. */
+    profile?: AgentProfile;
+    /** Run Codex with isolated configuration, exact prompt evidence, and required
+     *  terminal token usage. Requires `harness: 'codex'` and `profile`. */
+    codexReproducible?: boolean;
+    /** Absolute paths reproducible Codex must not read. A function can derive
+     *  candidate-specific paths after the driver creates its worktree. */
+    codexReadDeniedPaths?: ReadonlyArray<string> | ((worktreePath: string) => ReadonlyArray<string>);
+    /** Awaited once for every attempted author shot, including process failures.
+     *  Throwing aborts the candidate so receipt persistence can fail closed. */
+    onShotCompleted?: (receipt: AgenticGeneratorShotReceipt) => void | Promise<void>;
+    /** Optional hard upper bound passed to the run-wide CostLedger before each
+     *  author shot. This MUST be enforced by the provider or executor; a planning
+     *  estimate is not an admissible bound. Omit for an uncapped ledger. A capped
+     *  ledger rejects before model dispatch when this is absent. */
+    maximumCharge?: MaximumCharge;
     /** Per-shot wall-clock timeout (ms). Default = `runLocalHarness` default (5m). */
     timeoutMs?: number;
     /** Build the harness task prompt from the report + findings. Override for
@@ -148,4 +215,4 @@ declare function agenticGenerator(opts?: AgenticGeneratorOptions): CandidateGene
  *  silent fallback). */
 declare function commandVerifier(command: string, args?: string[], timeoutMs?: number): Verifier;
 
-export { type AgenticGeneratorOptions as A, type CandidateGenerator as C, type ImprovementDriverOptions as I, type ManagedImprovementDriver as M, type Verifier as V, type VerifyResult as a, agenticGenerator as b, commandVerifier as c, improvementDriver as i };
+export { AGENTIC_PROFILE_RESOURCE_ROOT as A, type CandidateGenerator as C, type ImprovementDriverOptions as I, type ManagedImprovementDriver as M, type Verifier as V, type AgenticGeneratorOptions as a, type AgenticGeneratorShotReceipt as b, type VerifyResult as c, agenticGenerator as d, commandVerifier as e, improvementDriver as i };

package/dist/analyst-loop.d.ts

@@ -1,5 +1,5 @@
 import { TraceAnalystByteBudgets, TraceAnalysisStore } from '@tangle-network/agent-eval';
-import { I as Iteration } from './types-Kjr5W6OF.js';
+import { I as Iteration } from './types-CKmyZ9TP.js';
 import { R as RunAnalystLoopOpts, a as RunAnalystLoopResult } from './types-BC3bZpH0.js';
 export { A as AnalystLoopEvent, b as AnalystRegistryLike, c as AnalystRegistryStreamingLike, d as AutoApplyPolicy, F as FindingsStoreLike, I as ImprovementAdapter, e as ImprovementEditBatch, f as ImprovementReport, K as KnowledgeAdapter, g as KnowledgeProposalBatch, h as KnowledgeReport } from './types-BC3bZpH0.js';
 import '@tangle-network/sandbox';

package/dist/analyst-loop.js

@@ -1,8 +1,8 @@
 import {
   iterationsToTraceStore,
   runAnalystLoop
-} from "./chunk-ZQZX77MM.js";
-import "./chunk-FVJ7M3DA.js";
+} from "./chunk-QDSOD7RC.js";
+import "./chunk-M22PL4GH.js";
 import "./chunk-YEJR7IXO.js";
 import "./chunk-DGUM43GV.js";
 export {

package/dist/{chunk-GKZ6DFDN.js → chunk-7HH22XN4.js}

@@ -13,7 +13,7 @@ import {
   settledToIteration,
   supervise,
   withDriverExecutor
-} from "./chunk-LWNMCOEA.js";
+} from "./chunk-FRXDOBFP.js";
 import {
   InMemoryResultBlobStore,
   InMemorySpawnJournal
@@ -30,7 +30,7 @@ import {
   createSandboxToolPartState,
   mapSandboxEvent,
   mapSandboxToolEvent
-} from "./chunk-FVJ7M3DA.js";
+} from "./chunk-M22PL4GH.js";
 import {
   AnalystError,
   BackendTransportError,
@@ -627,12 +627,6 @@ import {
 } from "@tangle-network/agent-eval/campaign";
 import { collectAgentResponseText } from "@tangle-network/sandbox";
 
-// src/runtime/report-usage.ts
-function reportLoopUsage(cost, result, source = "loop") {
-  cost.observe(result.costUsd, source);
-  cost.observeTokens(result.tokenUsage);
-}
-
 // src/runtime/loop-dispatch.ts
 function campaignTraceToLoopEmitter(trace) {
   return {
@@ -643,23 +637,61 @@ function campaignTraceToLoopEmitter(trace) {
 }
 async function runLoopForCell(opts, scenario, profile, ctx) {
   const loopOptions = opts.toLoopOptions(scenario, profile);
-  return runLoopWithCampaignContext(opts, loopOptions, ctx);
+  return runLoopWithCampaignContext(opts, loopOptions, ctx, {
+    model: profile.model?.default ?? modelFromLoopOptions(loopOptions),
+    maximumCharge: typeof opts.maximumCharge === "function" ? opts.maximumCharge(scenario, profile) : opts.maximumCharge,
+    resolveModel: opts.resolveCostModel ? (result) => opts.resolveCostModel?.(result, scenario, profile) : void 0
+  });
 }
-async function runLoopWithCampaignContext(opts, loopOptions, ctx) {
-  const result = await runLoop({
-    ...loopOptions,
-    ctx: {
-      sandboxClient: opts.sandboxClient,
-      signal: ctx.signal,
-      traceEmitter: opts.forwardTrace === false ? void 0 : campaignTraceToLoopEmitter(ctx.trace)
-    }
+async function runLoopWithCampaignContext(opts, loopOptions, ctx, cost) {
+  const paid = await ctx.cost.runPaidCall({
+    channel: "agent",
+    actor: opts.costSource ?? "loop",
+    model: cost.model,
+    signal: ctx.signal,
+    ...cost.maximumCharge ? { maximumCharge: cost.maximumCharge } : {},
+    execute: (executionSignal) => runLoop({
+      ...loopOptions,
+      ctx: {
+        sandboxClient: opts.sandboxClient,
+        signal: executionSignal,
+        traceEmitter: opts.forwardTrace === false ? void 0 : campaignTraceToLoopEmitter(ctx.trace)
+      }
+    }),
+    receipt: (result2) => loopCostReceipt(result2, cost.resolveModel?.(result2) ?? cost.model)
   });
-  reportLoopUsage(ctx.cost, result, opts.costSource ?? "loop");
+  if (!paid.succeeded) {
+    throw paid.error;
+  }
+  const result = paid.value;
   const toArtifact = opts.toArtifact ?? ((r) => r.winner?.output);
   return toArtifact(result);
 }
+function loopCostReceipt(result, model) {
+  return {
+    model,
+    inputTokens: result.tokenUsage.input,
+    outputTokens: result.tokenUsage.output,
+    ...result.costUsd > 0 ? { actualCostUsd: result.costUsd } : {}
+  };
+}
+function modelFromLoopOptions(options) {
+  const profiles = options.agentRun ? [options.agentRun.profile] : options.agentRuns?.map((run) => run.profile) ?? [];
+  const models = new Set(
+    profiles.map((profile) => profile.model?.default).filter((model) => !!model)
+  );
+  if (models.size === 1) return [...models][0];
+  return models.size > 1 ? "mixed" : "unknown";
+}
 function loopCampaignDispatch(opts) {
-  return (scenario, ctx) => runLoopWithCampaignContext(opts, opts.toLoopOptions(scenario), ctx);
+  return (scenario, ctx) => {
+    const loopOptions = opts.toLoopOptions(scenario);
+    return runLoopWithCampaignContext(opts, loopOptions, ctx, {
+      model: modelFromLoopOptions(loopOptions),
+      maximumCharge: typeof opts.maximumCharge === "function" ? opts.maximumCharge(scenario) : opts.maximumCharge,
+      resolveModel: opts.resolveCostModel ? (result) => opts.resolveCostModel?.(result, scenario) : void 0
+    });
+  };
 }
 function loopDispatch(opts) {
   return (profile, scenario, ctx) => runLoopForCell(opts, scenario, profile, ctx);
@@ -981,9 +1013,23 @@ function defineLeaderboard(spec) {
       return p;
     };
     let shotNonce = 0;
+    const maximumCharge = spec.maximumCharge;
     const dispatch = spec.dispatch ?? ((profile, scenario, dispatchCtx) => {
       const cellDispatch = loopDispatch({
         sandboxClient,
+        maximumCharge: typeof maximumCharge === "function" ? (cellScenario, cellProfile) => maximumCharge(cellProfile, cellScenario) : maximumCharge,
+        resolveCostModel: (result, _cellScenario, cellProfile) => {
+          if (!spec.resolveModel) return cellProfile.model?.default;
+          const served = new Set(
+            result.iterations.map((iteration) => spec.resolveModel?.(iteration.events)).filter((model) => model !== void 0)
+          );
+          if (served.size > 1) {
+            throw new Error(
+              `defineLeaderboard(${spec.name}): one cell reported multiple served models: ${[...served].join(", ")}`
+            );
+          }
+          return [...served][0] ?? cellProfile.model?.default;
+        },
         toLoopOptions: (cellScenario, cellProfile) => {
           const axis = harnessAxisOf(cellProfile);
           const modelId = bareModel(axis?.model ?? models[0] ?? "");
@@ -1034,10 +1080,6 @@ function defineLeaderboard(spec) {
               ...iter.error ? { error: iter.error.message } : {},
               ...iter.verdict ? { verdict: { score: iter.verdict.score } } : {}
             });
-            if (spec.resolveModel) {
-              const served = spec.resolveModel(iter.events);
-              if (served !== void 0) dispatchCtx.cost.observeModel?.(served);
-            }
           }
           return result.winner?.output;
         }
@@ -2648,6 +2690,12 @@ function promotionGate(opts) {
   };
 }
 
+// src/runtime/report-usage.ts
+function reportLoopUsage(cost, result, source = "loop") {
+  cost.observe(result.costUsd, source);
+  cost.observeTokens(result.tokenUsage);
+}
+
 // src/runtime/run-benchmark.ts
 import { pairedBootstrap as pairedBootstrap2, paretoFrontier } from "@tangle-network/agent-eval";
 
@@ -5740,13 +5788,43 @@ import { stuckLoopView, toolWasteView } from "@tangle-network/agent-eval/pipelin
 async function analyzeTrace(source, runId = "worker") {
   const spans = await source.collect();
   const store = new InMemoryTraceStore();
+  const laneSpanId = `${runId}-session-lane`;
+  if (spans.length > 0) {
+    const startedAt = Math.min(...spans.map((span) => span.startedAt));
+    const endedAt = Math.max(...spans.map((span) => span.endedAt ?? span.startedAt));
+    const agentSpanId = `${runId}-agent`;
+    await store.appendSpan({
+      spanId: agentSpanId,
+      runId,
+      kind: "agent",
+      name: "trace-source-agent",
+      startedAt,
+      endedAt
+    });
+    await store.appendSpan({
+      spanId: laneSpanId,
+      parentSpanId: agentSpanId,
+      runId,
+      kind: "custom",
+      name: "trace-source-session",
+      startedAt,
+      endedAt
+    });
+  }
   for (let i = 0; i < spans.length; i += 1) {
     const s = spans[i];
-    if (s) await store.appendSpan({ ...s, runId, spanId: `${runId}-t${i}` });
+    if (s) {
+      await store.appendSpan({
+        ...s,
+        runId,
+        spanId: `${runId}-t${i}`,
+        parentSpanId: laneSpanId
+      });
+    }
   }
   const [trajectory, stuckLoop, toolWaste] = await Promise.all([
     buildTrajectory(store, runId),
-    stuckLoopView(store, { runId }),
+    stuckLoopView(store, { runId, maxInterveningToolCalls: 1 }),
     toolWasteView(store, { runId })
   ]);
   return { trajectory, stuckLoop, toolWaste };
@@ -6248,7 +6326,6 @@ export {
   stopSentinel,
   sentinelCompletion,
   deterministicCompletion,
-  reportLoopUsage,
   loopCampaignDispatch,
   loopDispatch,
   inlineSandboxClient,
@@ -6285,6 +6362,7 @@ export {
   trajectoryReport,
   equalKOnCost,
   promotionGate,
+  reportLoopUsage,
   depthStrategy,
   breadthStrategy,
   sample,
@@ -6339,4 +6417,4 @@ export {
   computeFindingId,
   makeFinding2 as makeFinding
 };
-//# sourceMappingURL=chunk-GKZ6DFDN.js.map
+//# sourceMappingURL=chunk-7HH22XN4.js.map