@tangle-network/agent-runtime 0.83.0 → 0.85.0

package/dist/loop-runner-bin.js

@@ -2,10 +2,10 @@
 import {
   parseLoopRunnerArgv,
   runLoopRunnerCli
-} from "./chunk-UJ3ONGHR.js";
+} from "./chunk-QSYPMMWS.js";
 import "./chunk-SGKPNBXE.js";
-import "./chunk-QDVLTRCP.js";
-import "./chunk-SSA6OERV.js";
+import "./chunk-DLAEEF26.js";
+import "./chunk-XN5TIJGP.js";
 import "./chunk-UD4BHQMI.js";
 import "./chunk-BZF3KQ6G.js";
 import "./chunk-YPA5MLVE.js";

package/dist/loops.d.ts

@@ -1,4 +1,4 @@
-import { ChatClient, RunRecord, AnalystFinding, AgentProfile, AnalystRunInputs, ToolSpan, StreamingDetector, DetectorSignal, buildTrajectory } from '@tangle-network/agent-eval';
+import { ChatClient, RunRecord, HarnessType, AgentProfile, AnalystFinding, AnalystRunInputs, ToolSpan, StreamingDetector, DetectorSignal, buildTrajectory } from '@tangle-network/agent-eval';
 export { AnalystFinding, DefaultVerdict, computeFindingId, makeFinding } from '@tangle-network/agent-eval';
 import { SandboxEvent, SandboxInstance, CreateSandboxOptions } from '@tangle-network/sandbox';
 export { AgentProfile, CreateSandboxOptions, SandboxEvent, SandboxInstance } from '@tangle-network/sandbox';
@@ -6,12 +6,12 @@ import { d as ResultBlobStore, S as SpawnJournal, N as NodeId, j as SpawnEvent,
 export { A as AgentSpec, a as Executor, l as ExecutorContext, m as ExecutorResult, R as Runtime, n as SupervisorOpts, T as TreeView, W as WidenGate } from './types-Driepl87.js';
 import { ak as MakeWorkerAgent, A as AnalystRegistry, o as CoordinationTools, n as CoordinationEvent, ar as QuestionPolicy, a$ as ExecutorConfig } from './coordination-CuDLO8wj.js';
 export { b0 as BusEvent, b1 as BusRecord, b2 as BusStats, b3 as EventBus, b4 as ProviderSeam, b5 as PublishOptions, b6 as cliWorktreeExecutor, b7 as createEventBus, b8 as createExecutor, b9 as createExecutorRegistry } from './coordination-CuDLO8wj.js';
-import { R as RuntimeHooks, I as Iteration, S as SandboxClient, W as Driver, A as AgentRunSpec, b as OutputAdapter, V as Validator, E as ExecCtx, X as LoopWinner, Y as LoopLineageOptions, Z as LoopResult, L as LoopTokenUsage, a as RuntimeStreamEvent, _ as MountRecorder } from './types-ESeMOj94.js';
+import { R as RuntimeHooks, I as Iteration, S as SandboxClient, W as Driver, A as AgentRunSpec, b as OutputAdapter, V as Validator, E as ExecCtx, X as LoopWinner, Y as LoopLineageOptions, Z as LoopResult, L as LoopTokenUsage, a as RuntimeStreamEvent, _ as MountRecorder, i as AgentExecutionBackend, o as AgentTaskStatus, B as BackendErrorDetail } from './types-ESeMOj94.js';
 export { $ as LoopDecisionPayload, a0 as LoopEndedPayload, a1 as LoopIterationDispatchPayload, a2 as LoopIterationEndedPayload, a3 as LoopIterationStartedPayload, a4 as LoopPlanDescription, a5 as LoopPlanPayload, d as LoopSandboxPlacement, a6 as LoopStartedPayload, a7 as LoopTeardownFailedPayload, e as LoopTraceEmitter, c as LoopTraceEvent, a8 as MountManifestEntry, a9 as RunProvenance, aa as SelectionReceipt, ab as ValidationCtx } from './types-ESeMOj94.js';
+import { RunProfileMatrixResult, Scenario, ProfileDispatchFn, JudgeConfig, RunProfileMatrixOptions, DispatchFn } from '@tangle-network/agent-eval/campaign';
 export { AgentEnvironmentProviderRef, AgentEnvironmentProviderRegistry, ProviderAsSandboxClientOptions, ProviderExecutorOptions, SandboxClientProviderOptions, createAgentEnvironmentProviderRegistry, providerAsExecutor, providerAsSandboxClient, resolveAgentEnvironmentProvider, sandboxClientAsProvider } from './environment-provider.js';
 import { C as CorpusRecord, c as Corpus, O as Outcome, S as ScopeAnalyzeInput, d as AssertTraceDerivedFindings, e as SteerContext, f as ScopeAnalyst, F as FanoutOptions, g as CombinatorShape, h as ScopeWidenGate, L as LoopUntilSpec, P as PanelSpec, i as PipelineStage, W as WinnerStrategy, j as FanoutWinnerSelector, V as VerifySpec, k as WidenSpec, l as CorpusFilter, R as RenderCorpusToInstructionsOptions, D as DefinePersonaInput, m as Persona, n as RunPersonifiedOptions, o as ShapeRegistry, p as LoopShape, E as EqualKArm, q as EqualKOnCostOptions, r as EqualKVerdict, T as TrajectoryReportOptions, s as TrajectoryReport } from './worktree-fanout-D6xR2CIA.js';
 export { A as AuthoredHarness, t as DefinePersona, u as EqualKOnCost, v as Fanout, w as FanoutSynthesis, x as FlatWidenGate, y as LoopUntil, z as LoopUntilState, B as Panel, G as PanelJudge, H as PanelVerdict, I as PatchDeliverableOptions, J as PersonaContext, K as PersonaExecutors, M as Pipeline, N as RenderCorpusToInstructions, Q as RunPersonified, U as ShapeBudget, X as ShapeContext, Y as TrajectoryNode, Z as TrajectoryReportFn, _ as Verify, $ as Widen, a0 as WidenDecision, a1 as WidenLineage, a2 as WorktreeCliExecutorOptions, a as WorktreeFanoutOptions, b as WorktreePatchArtifact, a3 as createWorktreeCliExecutor, a4 as patchDelivered, a5 as worktreeFanout } from './worktree-fanout-D6xR2CIA.js';
-import { Scenario, DispatchFn, ProfileDispatchFn } from '@tangle-network/agent-eval/campaign';
 import { b as AnalystRegistryLike } from './types-BC3bZpH0.js';
 import { AgentProfile as AgentProfile$1 } from '@tangle-network/agent-interface';
 import { R as RouterConfig, a as ToolLoopChat, b as ToolLoopCompactionOptions } from './router-client-r8y_VFVM.js';
@@ -494,6 +494,158 @@ declare function deterministicCompletion<Task, Output>(check: (output: Output, h
     reasons?: string;
 }): CompletionAnalyst<Task, Output>;
 
+/** Structured per-case verdict a `score` function may return (a bare number is
+ *  shorthand for `{ composite }`). `composite` is the [0,1] leaderboard score;
+ *  `dimensions` are recorded as extra judge dimensions. */
+interface LeaderboardScore {
+    composite: number;
+    dimensions?: Record<string, number>;
+    notes?: string;
+}
+/** The campaign scenario a case is wrapped into: the case rides along so
+ *  judges and hooks can reach the full domain payload, not just its id. */
+interface LeaderboardScenario<TCase> extends Scenario {
+    case: TCase;
+}
+/** One extra CLI flag a spec declares. Parsed by `run()` as `--<name> <value>`
+ *  and surfaced to every hook via `ctx.args`. */
+interface LeaderboardFlagSpec {
+    default?: string;
+    description: string;
+}
+/** Resolved run configuration handed to `setup` / `teardown` / `export`. */
+interface LeaderboardRunContext {
+    name: string;
+    /** Execution backend name (`--backend`), a key of `backends`. */
+    backend: string;
+    runDir: string;
+    exportDir: string;
+    /** Every parsed flag (standard + `spec.flags`), by name without `--`. */
+    args: Record<string, string | undefined>;
+    harnesses: readonly HarnessType[];
+    /** Snapshot-stamped model ids (`name@snapshot`) — the eval identity models. */
+    models: readonly string[];
+    caseIds: readonly string[];
+    shots: number;
+    reps: number;
+}
+/** Structurally `BenchTask` (bench registry shape) — declared locally so this
+ *  module adds no dependency on a benchmark package. */
+interface LeaderboardBenchTask {
+    id: string;
+    prompt: string;
+    split?: string;
+    metadata?: Record<string, unknown>;
+}
+/** Structurally `BenchScore` (bench registry shape). */
+interface LeaderboardBenchScore {
+    resolved: boolean;
+    score: number;
+    detail?: string;
+}
+/** Structurally `BenchmarkAdapter` (bench registry shape): `name`,
+ *  `preflight()`, `loadTasks()`, deterministic `judge()`, `goldArtifact()`. */
+interface LeaderboardBenchmarkAdapter {
+    readonly name: string;
+    preflight(): Promise<void>;
+    loadTasks(opts?: {
+        limit?: number;
+        split?: string;
+        ids?: string[];
+    }): Promise<LeaderboardBenchTask[]>;
+    judge(task: LeaderboardBenchTask, artifact: string): Promise<LeaderboardBenchScore>;
+    goldArtifact(task: LeaderboardBenchTask): Promise<string | undefined>;
+}
+interface LeaderboardSpec<TCase> {
+    /** Leaderboard name — the scenario `kind`, default profile name, and report title. */
+    name: string;
+    /** The case corpus. Every case needs a stable string id (see `caseId`). */
+    cases: TCase[];
+    /** Stable id extractor. Default: the case's own `id` property (fail-loud
+     *  when absent or not a string). */
+    caseId?: (c: TCase) => string;
+    /** The per-case task prompt. May be async (e.g. built by shelling out to a
+     *  reference implementation); resolved ONCE per case before dispatch. */
+    prompt: (c: TCase) => string | Promise<string>;
+    /** The domain grader: agent output text → score. Used BOTH as the per-shot
+     *  validator (a shot with `composite > 0` stops the naive retry loop) and,
+     *  wrapped as a campaign judge, as the recorded leaderboard score. */
+    score: (output: string, c: TCase) => number | LeaderboardScore;
+    /** Harness × model axes for `expandProfileAxes`. Defaults: the canonical
+     *  `CODING_HARNESSES` × the base profile's `model.default`. `--harnesses` /
+     *  `--models` override per run. */
+    axis?: {
+        harnesses?: readonly HarnessType[];
+        models?: readonly string[];
+    };
+    /** Base profile the axes expand over (prompt/tools/skills held fixed).
+     *  Default: a minimal `{ name, model: { default: <first model> } }`. */
+    baseProfile?: AgentProfile;
+    /**
+     * Execution-backend registry: `--backend <name>` picks the factory that
+     * yields the `SandboxClient` every cell runs on. Merged over the defaults:
+     *   - `sandbox` — throws with guidance (a product must supply its real
+     *     Sandbox-backed client; the facade has no credentials).
+     *   - `cli-bridge` — `resolveSandboxClient({ backend: 'bridge' })` reading
+     *     `CLI_BRIDGE_URL` + `BRIDGE_BEARER`/`CLI_BRIDGE_BEARER`; the per-cell
+     *     harness/model ride in via `sandboxOverrides.backend`.
+     */
+    backends?: Record<string, (() => SandboxClient) | undefined>;
+    /** Extra `--flag value` CLI args `run()` parses and surfaces via `ctx.args`. */
+    flags?: Record<string, LeaderboardFlagSpec>;
+    /** Extra fields merged into each cell's `backend.model` create override —
+     *  e.g. `{ provider: 'openai-compat', apiKey, baseUrl }` for a router-backed
+     *  sandbox. The cell's bare model id is set by the facade from the axis. */
+    modelBackend?: Record<string, unknown>;
+    /** Runs once before the matrix (fetch fixtures, warm caches). */
+    setup?: (ctx: LeaderboardRunContext) => Promise<void> | void;
+    /** Runs once after the matrix, even on failure (reap boxes, close handles). */
+    teardown?: (ctx: LeaderboardRunContext) => Promise<void> | void;
+    /** Per-cell event tap: the raw sandbox events of each parsed iteration,
+     *  with the case — the seam for domain metric capture (search counts,
+     *  citations) without a substrate change. */
+    onCellEvents?: (events: readonly SandboxEvent[], c: TCase) => void;
+    /** Output decode override: raw events → the scored output text. Default:
+     *  the sandbox SDK's `collectAgentResponseText` (final answer text; empty
+     *  string when the stream carried none — which then scores 0). */
+    parseOutput?: (events: readonly SandboxEvent[], c: TCase) => string;
+    /** Result export. Default: write `matrix-result.json` under the run dir and
+     *  print (+ write) the ranked leaderboard markdown under the export dir. */
+    export?: (result: RunProfileMatrixResult<string, LeaderboardScenario<TCase>>, ctx: LeaderboardRunContext) => Promise<void> | void;
+    /** LEVEL 2 — full dispatch replacement (in-process products bring their own).
+     *  The default is `loopDispatch` + `naiveDriver` over the resolved backend. */
+    dispatch?: ProfileDispatchFn<LeaderboardScenario<TCase>, string>;
+    /** LEVEL 2 — full judge replacement. Default: `score` wrapped as one judge. */
+    judges?: JudgeConfig<string, LeaderboardScenario<TCase>>[];
+    /** Naive-retry shot cap per cell (`--shots`). Default 1. */
+    shots?: number;
+    /** Replicates per cell (`--reps`). Default 1. */
+    reps?: number;
+    /** Passthrough overrides spread onto the final `runProfileMatrix` call
+     *  (e.g. `maxConcurrency`, `costCeiling`, `integrity`, `storage`) — spread
+     *  LAST, so anything the facade wired can be overridden. */
+    matrix?: Partial<RunProfileMatrixOptions<LeaderboardScenario<TCase>, string>>;
+}
+interface DefinedLeaderboard<TCase> {
+    /**
+     * Parse flags, run the matrix, export, and return the raw result.
+     *
+     * Standard flags: `--backend <name>` (default `sandbox`), `--harnesses a,b`,
+     * `--models m1,m2`, `--cases id1,id2`, `--shots N`, `--reps N`,
+     * `--model-snapshot <tag>`, `--run-dir <path>`, `--export-dir <path>`,
+     * plus every `spec.flags` entry. `argv` defaults to `process.argv.slice(2)`.
+     *
+     * The default run dir is FRESH per invocation (timestamp+pid under the OS
+     * tmpdir). `runProfileMatrix` caches cells by run dir, and a stable default
+     * would silently reuse a prior FAILED zero-token cell and skip dispatch —
+     * only an explicit `--run-dir` opts into that resume behavior.
+     */
+    run(argv?: string[]): Promise<RunProfileMatrixResult<string, LeaderboardScenario<TCase>>>;
+    /** The same domain surface in the structural `BenchmarkAdapter` shape. */
+    toBenchmarkAdapter(): LeaderboardBenchmarkAdapter;
+}
+declare function defineLeaderboard<TCase>(spec: LeaderboardSpec<TCase>): DefinedLeaderboard<TCase>;
+
 /**
  * The third-person observer — the connective tissue that closes the loop.
  *
@@ -2593,6 +2745,136 @@ declare function selectChampion(report: BenchmarkReport, fieldOrder: string[], p
 /** Multi-generation strategy search: author candidates from tournament losses, play them against the incumbent at equal budget, promote via `promotionGate` on an untouched holdout slice. */
 declare function runStrategyEvolution(cfg: StrategyEvolutionConfig): Promise<EvolutionReport>;
 
+/**
+ * `streamAgentTurn` — the ONE run-a-turn event-stream contract over every
+ * execution substrate: a sandbox box (`SandboxInstance.streamPrompt`), a
+ * one-shot `Executor` (cli-bridge / router / BYO, via `ExecutorFactory`), and
+ * an in-process `AgentExecutionBackend` (the `resolveAgentBackend` output).
+ *
+ * One function, one vocabulary: every backend kind yields the existing
+ * `RuntimeStreamEvent` union incrementally and ALWAYS terminates with a
+ * `final` event whose `text` is the turn's final text and whose
+ * `metadata.tokenUsage` / `metadata.costUsd` / `metadata.model` carry the
+ * turn's metered usage. `collectAgentTurn` drains a stream into that terminal
+ * summary plus the full event list.
+ *
+ * This is a UNIFICATION seam, not a new stream parser — each kind is a thin
+ * adapter over code that already exists and is already hardened:
+ *   - `box`      — `mapSandboxEvent` + `extractLlmCallEvent` (sandbox-events.ts)
+ *                  project the sandbox event stream; nothing is re-mapped here.
+ *   - `executor` — `inlineSandboxClient` (the ONE executor→box adapter) turns
+ *                  the factory into a box, then the box path drives it. The
+ *                  executor's settle/teardown lifecycle stays in that adapter.
+ *   - `chat`     — the backend's own `stream()` surface, normalized by
+ *                  `normalizeBackendStreamEvent` (the same projection
+ *                  `runAgentTaskStream` applies).
+ *
+ * Distinct from `openSandboxRun` (box-only, session resume over one persistent
+ * artifact, raw `SandboxEvent` deliverables) and from `runAgentTaskStream`
+ * (full task lifecycle: knowledge preflight, session store, resume). This is
+ * the minimal turn primitive underneath both worlds: prompt in, one normalized
+ * event stream out, terminal result+usage guaranteed on every non-thrown path.
+ *
+ * Stream envelope: `backend_start` → incremental events → (`backend_error` on
+ * failure) → `final`. A caller-initiated abort terminates with
+ * `final.status: 'aborted'`; an expired `timeoutMs` deadline with
+ * `final.status: 'failed'` — so cancellation stays distinguishable from a
+ * blown deadline.
+ *
+ * @experimental
+ */
+
+/**
+ * The execution substrate one turn runs on — a closed discriminated union over
+ * the three stream surfaces the runtime already owns.
+ *
+ * @experimental
+ */
+type AgentTurnBackend = {
+    /** A live sandbox box: the turn is one `box.streamPrompt(prompt)` call. */
+    kind: 'box';
+    box: SandboxInstance;
+    /** Model label stamped on cost-only `llm_call` events. Default `'agent'`. */
+    agentRunName?: string;
+} | {
+    /**
+     * A one-shot `Executor` (cli-bridge / router / BYO): the factory is
+     * instantiated fresh for the turn via `inlineSandboxClient`, run once on
+     * the prompt, and torn down — the same per-spawn lifecycle the supervise
+     * runtime gives it.
+     */
+    kind: 'executor';
+    factory: ExecutorFactory<unknown>;
+    /** Model label stamped on cost-only `llm_call` events. Default `'agent'`. */
+    agentRunName?: string;
+} | {
+    /**
+     * An in-process `AgentExecutionBackend` (`resolveAgentBackend` output or
+     * any custom backend): the turn is one `backend.stream()` call.
+     */
+    kind: 'chat';
+    backend: AgentExecutionBackend;
+};
+/** @experimental */
+interface StreamAgentTurnOptions {
+    /** Caller-initiated cancellation. Terminates the stream with `final.status: 'aborted'`. */
+    signal?: AbortSignal;
+    /**
+     * Wall-clock deadline for the whole turn in ms. An expired deadline aborts
+     * the backend and terminates the stream with `final.status: 'failed'`
+     * (a blown deadline is a turn failure, not a caller cancellation).
+     */
+    timeoutMs?: number;
+}
+/**
+ * Metered usage of one turn, summed over every cost-bearing event the backend
+ * emitted. `input`/`output` are token counts (0 when the backend reported
+ * none — the honest sum, never a fabricated estimate). `costUsd`/`model` are
+ * present only when the backend actually reported them.
+ *
+ * @experimental
+ */
+interface AgentTurnUsage {
+    input: number;
+    output: number;
+    costUsd?: number;
+    model?: string;
+}
+/**
+ * A drained turn: the terminal summary plus every event the stream yielded.
+ * `status`/`error` mirror the terminal `final` event so a failed or aborted
+ * turn stays inspectable without re-scanning `events`.
+ *
+ * @experimental
+ */
+interface CollectedAgentTurn {
+    finalText: string;
+    usage: AgentTurnUsage;
+    events: RuntimeStreamEvent[];
+    status: AgentTaskStatus;
+    error?: BackendErrorDetail;
+}
+/**
+ * Run ONE agent turn on any backend kind and stream its events. Yields the
+ * `RuntimeStreamEvent` vocabulary incrementally and always ends with a `final`
+ * event carrying the turn's text and usage (`metadata.tokenUsage`,
+ * `metadata.costUsd?`, `metadata.model?`) — on success, failure, abort, and
+ * timeout alike. The generator never throws; failures surface in-band as
+ * `backend_error` + `final` with a typed `error` detail.
+ *
+ * @experimental
+ */
+declare function streamAgentTurn(backend: AgentTurnBackend, prompt: string, opts?: StreamAgentTurnOptions): AsyncGenerator<RuntimeStreamEvent>;
+/**
+ * Drain a `streamAgentTurn` stream (or any `RuntimeStreamEvent` stream that
+ * honors its terminal contract) into the turn summary plus the full event
+ * list. Fail-loud: throws when the stream ends without a terminal `final`
+ * event — a stream that violates the contract must not read as an empty turn.
+ *
+ * @experimental
+ */
+declare function collectAgentTurn(stream: AsyncIterable<RuntimeStreamEvent>): Promise<CollectedAgentTurn>;
+
 /**
  *
  * The supervisor's intelligence is AUTHORING the agents it spawns — not pressing buttons.
@@ -3626,4 +3908,4 @@ declare function runInWorkspace<T>(ws: Workspace, body: (cwd: string) => Promise
     commitOnInvalid?: boolean;
 }): Promise<WorkspaceRun<T>>;
 
-export { Agent, AgentRunSpec, type AgenticOptions, type AgenticRunResult, type AgenticSurface, type AgenticTask, type AgenticTool, AnalystRegistry, type AnytimeReport, type AnytimeStrategySummary, type AnytimeTaskCurve, type ApplyContinuation, type ArtifactHandle, AssertTraceDerivedFindings, type AuditIntentInput, type AuditIntentOptions, type AuthorStrategyOptions, type AuthoredProfile, type AuthoredStrategy, type BenchmarkCell, type BenchmarkConfig, type BenchmarkLift, type BenchmarkReport, type BenchmarkStrategySummary, type BenchmarkTaskRow, Budget, type BudgetPool, type BudgetReadout, type ChampionPick, type ChampionPolicy, type CheckpointCapableBox, CombinatorShape, type CompletionAnalyst, type CompletionEvidence, type CompletionPolicy, type CompletionVerdict, CoordinationEvent, type CoordinationMcpHandle, Corpus, CorpusFilter, CorpusRecord, type CreateScopeAnalystOptions, type CriuCapableClient, DefinePersonaInput, type DelegateOptions, type Deliverable, DeliverableSpec, type DriveHarness, Driver, type DriverAgentOptions, type DumbDriverOptions, type Environment, EqualKArm, EqualKOnCostOptions, EqualKVerdict, type EvolutionArchiveNode, type EvolutionAuthor, type EvolutionBandInfo, type EvolutionCandidate, type EvolutionGeneration, type EvolutionReport, ExecCtx, ExecutorConfig, ExecutorFactory, ExecutorRegistry, FanoutOptions, FanoutWinnerSelector, FileCorpus, type ForkCapableBox, type GitWorkspaceOptions, type HarvestCorpusOptions, type HarvestFailure, type HarvestReport, InMemoryCorpus, InMemoryResultBlobStore, type InMemoryRunContext, type InMemoryRunContextOptions, InMemorySpawnJournal, type InProcessOnPrompt, type InProcessPromptCtx, type InProcessSandboxClientOptions, type Inbox, type InboxMessage, type IntentAudit, type Interval, Iteration, type Leaderboard, type LeaderboardOptions, type LeaderboardRow, type LoopCampaignDispatchOptions, type LoopDispatchOptions, LoopLineageOptions, type LoopOptionsForDispatch, LoopResult, LoopShape, LoopTokenUsage, LoopUntilSpec, LoopWinner, MakeWorkerAgent, type McpEndpoint, type McpEnvironmentOptions, MountRecorder, type NaiveDriverOptions, type Observation, type ObserveInput, type ObserveOptions, type OpenSandboxRunOptions, Outcome, OutputAdapter, type PairwiseOptions, type PairwiseVerdict, PanelSpec, Persona, PipelineStage, type ProfileRichness, type ProfileRichnessThresholds, type PromotionGateOptions, type PromotionVerdict, type RegistryAnalyzeProjection, RenderCorpusToInstructionsOptions, type ReservationTicket, type ResolveSandboxClientOptions, ResultBlobStore, RouterConfig, type RunAgenticOptions, RunPersonifiedOptions, type SandboxCapabilities, SandboxClient, type SandboxLineage, type SandboxLineageHandle, type SandboxRun, SandboxRunAbortError, Scope, ScopeAnalyst, ScopeAnalyzeInput, ScopeWidenGate, type SessionCapableBox, type SessionTraceBox, Settled, ShapeRegistry, type Shell, type ShotPersona, type ShotSpec, Spend, SteerContext, type SteeringDecision, type Strategy, type StrategyCtx, type StrategyEvolutionConfig, type StrategyResult, type SuperviseOptions, type SuperviseSurfaceOptions, type SuperviseSurfaceResult, SupervisedResult, Supervisor, type SupervisorAgentDeps, type SupervisorProfile, type SurfaceScore, type SurfaceWorkerConfig, type SurfaceWorkerOut, ToolLoopChat, ToolLoopCompactionOptions, type TraceSource, type TrajectoryAnalysis, TrajectoryReport, TrajectoryReportOptions, type TurnResult, UsageEvent, type UsageSink, Validator, type VerifierEnvironmentOptions, VerifySpec, type WatchTraceOptions, type WaterfallCollector, type WaterfallReport, type WaterfallSpan, WidenSpec, WinnerStrategy, type Workspace, type WorkspaceCommit, type WorkspaceRun, acquireSandbox, adaptiveRefine, analyzeTrace, anytimeReport, asAuthoredProfile, assertModelAllowed, assertStrategyContract, assertTraceDerivedFindings, assessAuthoredProfile, auditIntent, authorStrategy, authoredWorker, breadthStrategy, buildSteerContext, builtinShapes, completionAuthorizes, contentAddress, createBudgetPool, createInMemoryRunContext, createInbox, createMcpEnvironment, createPushTraceSource, createSandboxLineage, createScope, createScopeAnalyst, createShapeRegistry, createSupervisor, createVerifierEnvironment, createWaterfallCollector, decodeToolPart, defaultAnalystInstruction, defaultAuditorInstruction, defaultDelegateBudget, defaultProfileRichnessThresholds, defaultSelectWinner, defaultToolDetectors, definePersona, defineStrategy, delegate, depthStrategy, deterministicCompletion, discriminatingMeans, driverAgent, dumbDriver, equalKOnCost, extractLlmCallEvent, failuresAnalyst, fanout, finalizeBestDelivered, flatWidenGate, gitWorkspace, harvestCorpus, inProcessSandboxClient, inlineSandboxClient, jjWorkspace, leaderboard, localShell, loopCampaignDispatch, loopDispatch, loopUntil, mapSandboxEvent, naiveDriver, observe, openSandboxRun, pairwiseSignificance, panel, pickChampion, pipeline, printBenchmarkReport, probeSandboxCapabilities, profileRichnessFinding, promotionGate, refine, registerShape, registryScopeAnalyst, renderAnytimeTable, renderCorpusToInstructions, renderLeaderboardHtml, renderLeaderboardMarkdown, renderLeaderboardSvg, renderPairwiseMarkdown, renderReport, reportLoopUsage, resolveSandboxClient, runAgentic, runBenchmark, runInWorkspace, runLoop, runPersonified, runStrategyEvolution, sample, sampleThenRefine, sandboxSessionTraceSource, selectChampion, selectValidWinner, sentinelCompletion, serveCoordinationMcp, settledToIteration, spendFromUsageEvents, stopSentinel, strategyAuthorContract, sumSandboxUsage, supervise, superviseSurface, supervisorAgent, supervisorInstructions, trajectoryReport, verify, watchTrace, widen, workerFromBackend };
+export { Agent, AgentRunSpec, type AgentTurnBackend, type AgentTurnUsage, type AgenticOptions, type AgenticRunResult, type AgenticSurface, type AgenticTask, type AgenticTool, AnalystRegistry, type AnytimeReport, type AnytimeStrategySummary, type AnytimeTaskCurve, type ApplyContinuation, type ArtifactHandle, AssertTraceDerivedFindings, type AuditIntentInput, type AuditIntentOptions, type AuthorStrategyOptions, type AuthoredProfile, type AuthoredStrategy, type BenchmarkCell, type BenchmarkConfig, type BenchmarkLift, type BenchmarkReport, type BenchmarkStrategySummary, type BenchmarkTaskRow, Budget, type BudgetPool, type BudgetReadout, type ChampionPick, type ChampionPolicy, type CheckpointCapableBox, type CollectedAgentTurn, CombinatorShape, type CompletionAnalyst, type CompletionEvidence, type CompletionPolicy, type CompletionVerdict, CoordinationEvent, type CoordinationMcpHandle, Corpus, CorpusFilter, CorpusRecord, type CreateScopeAnalystOptions, type CriuCapableClient, DefinePersonaInput, type DefinedLeaderboard, type DelegateOptions, type Deliverable, DeliverableSpec, type DriveHarness, Driver, type DriverAgentOptions, type DumbDriverOptions, type Environment, EqualKArm, EqualKOnCostOptions, EqualKVerdict, type EvolutionArchiveNode, type EvolutionAuthor, type EvolutionBandInfo, type EvolutionCandidate, type EvolutionGeneration, type EvolutionReport, ExecCtx, ExecutorConfig, ExecutorFactory, ExecutorRegistry, FanoutOptions, FanoutWinnerSelector, FileCorpus, type ForkCapableBox, type GitWorkspaceOptions, type HarvestCorpusOptions, type HarvestFailure, type HarvestReport, InMemoryCorpus, InMemoryResultBlobStore, type InMemoryRunContext, type InMemoryRunContextOptions, InMemorySpawnJournal, type InProcessOnPrompt, type InProcessPromptCtx, type InProcessSandboxClientOptions, type Inbox, type InboxMessage, type IntentAudit, type Interval, Iteration, type Leaderboard, type LeaderboardBenchScore, type LeaderboardBenchTask, type LeaderboardBenchmarkAdapter, type LeaderboardFlagSpec, type LeaderboardOptions, type LeaderboardRow, type LeaderboardRunContext, type LeaderboardScenario, type LeaderboardScore, type LeaderboardSpec, type LoopCampaignDispatchOptions, type LoopDispatchOptions, LoopLineageOptions, type LoopOptionsForDispatch, LoopResult, LoopShape, LoopTokenUsage, LoopUntilSpec, LoopWinner, MakeWorkerAgent, type McpEndpoint, type McpEnvironmentOptions, MountRecorder, type NaiveDriverOptions, type Observation, type ObserveInput, type ObserveOptions, type OpenSandboxRunOptions, Outcome, OutputAdapter, type PairwiseOptions, type PairwiseVerdict, PanelSpec, Persona, PipelineStage, type ProfileRichness, type ProfileRichnessThresholds, type PromotionGateOptions, type PromotionVerdict, type RegistryAnalyzeProjection, RenderCorpusToInstructionsOptions, type ReservationTicket, type ResolveSandboxClientOptions, ResultBlobStore, RouterConfig, type RunAgenticOptions, RunPersonifiedOptions, type SandboxCapabilities, SandboxClient, type SandboxLineage, type SandboxLineageHandle, type SandboxRun, SandboxRunAbortError, Scope, ScopeAnalyst, ScopeAnalyzeInput, ScopeWidenGate, type SessionCapableBox, type SessionTraceBox, Settled, ShapeRegistry, type Shell, type ShotPersona, type ShotSpec, Spend, SteerContext, type SteeringDecision, type Strategy, type StrategyCtx, type StrategyEvolutionConfig, type StrategyResult, type StreamAgentTurnOptions, type SuperviseOptions, type SuperviseSurfaceOptions, type SuperviseSurfaceResult, SupervisedResult, Supervisor, type SupervisorAgentDeps, type SupervisorProfile, type SurfaceScore, type SurfaceWorkerConfig, type SurfaceWorkerOut, ToolLoopChat, ToolLoopCompactionOptions, type TraceSource, type TrajectoryAnalysis, TrajectoryReport, TrajectoryReportOptions, type TurnResult, UsageEvent, type UsageSink, Validator, type VerifierEnvironmentOptions, VerifySpec, type WatchTraceOptions, type WaterfallCollector, type WaterfallReport, type WaterfallSpan, WidenSpec, WinnerStrategy, type Workspace, type WorkspaceCommit, type WorkspaceRun, acquireSandbox, adaptiveRefine, analyzeTrace, anytimeReport, asAuthoredProfile, assertModelAllowed, assertStrategyContract, assertTraceDerivedFindings, assessAuthoredProfile, auditIntent, authorStrategy, authoredWorker, breadthStrategy, buildSteerContext, builtinShapes, collectAgentTurn, completionAuthorizes, contentAddress, createBudgetPool, createInMemoryRunContext, createInbox, createMcpEnvironment, createPushTraceSource, createSandboxLineage, createScope, createScopeAnalyst, createShapeRegistry, createSupervisor, createVerifierEnvironment, createWaterfallCollector, decodeToolPart, defaultAnalystInstruction, defaultAuditorInstruction, defaultDelegateBudget, defaultProfileRichnessThresholds, defaultSelectWinner, defaultToolDetectors, defineLeaderboard, definePersona, defineStrategy, delegate, depthStrategy, deterministicCompletion, discriminatingMeans, driverAgent, dumbDriver, equalKOnCost, extractLlmCallEvent, failuresAnalyst, fanout, finalizeBestDelivered, flatWidenGate, gitWorkspace, harvestCorpus, inProcessSandboxClient, inlineSandboxClient, jjWorkspace, leaderboard, localShell, loopCampaignDispatch, loopDispatch, loopUntil, mapSandboxEvent, naiveDriver, observe, openSandboxRun, pairwiseSignificance, panel, pickChampion, pipeline, printBenchmarkReport, probeSandboxCapabilities, profileRichnessFinding, promotionGate, refine, registerShape, registryScopeAnalyst, renderAnytimeTable, renderCorpusToInstructions, renderLeaderboardHtml, renderLeaderboardMarkdown, renderLeaderboardSvg, renderPairwiseMarkdown, renderReport, reportLoopUsage, resolveSandboxClient, runAgentic, runBenchmark, runInWorkspace, runLoop, runPersonified, runStrategyEvolution, sample, sampleThenRefine, sandboxSessionTraceSource, selectChampion, selectValidWinner, sentinelCompletion, serveCoordinationMcp, settledToIteration, spendFromUsageEvents, stopSentinel, strategyAuthorContract, streamAgentTurn, sumSandboxUsage, supervise, superviseSurface, supervisorAgent, supervisorInstructions, trajectoryReport, verify, watchTrace, widen, workerFromBackend };

package/dist/loops.js

@@ -12,6 +12,7 @@ import {
   breadthStrategy,
   buildSteerContext,
   builtinShapes,
+  collectAgentTurn,
   completionAuthorizes,
   computeFindingId,
   createMcpEnvironment,
@@ -24,6 +25,7 @@ import {
   defaultAnalystInstruction,
   defaultAuditorInstruction,
   defaultToolDetectors,
+  defineLeaderboard,
   definePersona,
   defineStrategy,
   depthStrategy,
@@ -80,13 +82,14 @@ import {
   sentinelCompletion,
   stopSentinel,
   strategyAuthorContract,
+  streamAgentTurn,
   superviseSurface,
   trajectoryReport,
   verify,
   watchTrace,
   widen,
   worktreeFanout
-} from "./chunk-QDVLTRCP.js";
+} from "./chunk-DLAEEF26.js";
 import {
   InMemoryResultBlobStore,
   InMemorySpawnJournal,
@@ -128,7 +131,7 @@ import {
   supervisorAgent,
   supervisorInstructions,
   workerFromBackend
-} from "./chunk-SSA6OERV.js";
+} from "./chunk-XN5TIJGP.js";
 import "./chunk-UD4BHQMI.js";
 import {
   createAgentEnvironmentProviderRegistry,
@@ -168,6 +171,7 @@ export {
   buildSteerContext,
   builtinShapes,
   cliWorktreeExecutor,
+  collectAgentTurn,
   completionAuthorizes,
   computeFindingId,
   contentAddress,
@@ -195,6 +199,7 @@ export {
   defaultProfileRichnessThresholds,
   defaultSelectWinner,
   defaultToolDetectors,
+  defineLeaderboard,
   definePersona,
   defineStrategy,
   delegate,
@@ -271,6 +276,7 @@ export {
   spendFromUsageEvents,
   stopSentinel,
   strategyAuthorContract,
+  streamAgentTurn,
   sumSandboxUsage,
   supervise,
   superviseSurface,

package/dist/mcp/bin.js

@@ -9,7 +9,7 @@ import {
   DelegationTaskQueue,
   FileDelegationStore,
   createMcpServer
-} from "../chunk-SSA6OERV.js";
+} from "../chunk-XN5TIJGP.js";
 import "../chunk-UD4BHQMI.js";
 import "../chunk-BZF3KQ6G.js";
 import "../chunk-4J6RBI3K.js";

package/dist/mcp/index.js

@@ -6,7 +6,7 @@ import {
 import {
   mcpToolsForRuntimeMcp,
   mcpToolsForRuntimeMcpSubset
-} from "../chunk-J3N6GODQ.js";
+} from "../chunk-G7HQI6DB.js";
 import {
   createKbGate
 } from "../chunk-SGKPNBXE.js";
@@ -14,7 +14,7 @@ import {
   assertTraceDerivedFindings,
   runCoderChecks,
   selectValidWinner
-} from "../chunk-QDVLTRCP.js";
+} from "../chunk-DLAEEF26.js";
 import {
   DELEGATE_DESCRIPTION,
   DELEGATE_FEEDBACK_DESCRIPTION,
@@ -64,7 +64,7 @@ import {
   validateDelegateUiAuditArgs,
   validateDelegationHistoryArgs,
   validateDelegationStatusArgs
-} from "../chunk-SSA6OERV.js";
+} from "../chunk-XN5TIJGP.js";
 import "../chunk-UD4BHQMI.js";
 import {
   deleteBoxSafe,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-runtime",
-  "version": "0.83.0",
+  "version": "0.85.0",
   "description": "Shared task-lifecycle skeleton for agents: a recursive loop kernel for chat turns, one-shot tasks, and multi-attempt loops, with trace capture and eval-gated self-improvement. Domain behavior lives in adapters; scoring and ship-gates in @tangle-network/agent-eval.",
   "homepage": "https://github.com/tangle-network/agent-runtime#readme",
   "repository": {
@@ -94,7 +94,7 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.15",
-    "@tangle-network/agent-eval": ">=0.100.0 <1.0.0",
+    "@tangle-network/agent-eval": "^0.103.1",
     "@tangle-network/agent-interface": ">=0.14.0 <1.0.0",
     "@tangle-network/sandbox": ">=0.8.0 <1.0.0",
     "@types/node": "^25.9.3",
@@ -123,7 +123,7 @@
   "license": "MIT",
   "packageManager": "pnpm@10.28.0",
   "peerDependencies": {
-    "@tangle-network/agent-eval": ">=0.97.0 <1.0.0",
+    "@tangle-network/agent-eval": ">=0.101.0 <1.0.0",
     "@tangle-network/agent-interface": ">=0.14.0 <1.0.0",
     "@tangle-network/sandbox": ">=0.8.0 <1.0.0",
     "playwright": "^1.40.0"