@tangle-network/agent-runtime 0.103.1 → 0.105.0

package/dist/{completion-gate-DLINnrkM.d.ts → completion-gate-BMy5LGoP.d.ts}

@@ -1,6 +1,6 @@
 import { WorkspacePlanReceipt } from '@tangle-network/agent-profile-materialize';
-import { L as LocalHarness, C as CodexTokenUsage, c as CodexExecutionPolicy } from './local-harness-CtK9dSny.js';
-import { f as Executor } from './types-lZTE_LBd.js';
+import { L as LocalHarness, C as CodexTokenUsage, a as CodexExecutionPolicy } from './local-harness-BDNcl6jI.js';
+import { f as Executor } from './types-CvNwMzQt.js';
 
 /**
  *
@@ -100,7 +100,7 @@ declare function removeWorktree(options: RemoveWorktreeOptions): Promise<void>;
  * worktree off `repoRoot`, capture the diff, derive the test/typecheck PASS signals, then clean
  * up — lives here ONCE. Two executors adapt it to two ports without re-implementing it:
  *   - `createWorktreeCliExecutor` — the `Scope`/`Supervisor` leaf `Executor`.
- *   - `createInProcessExecutor`   — the `runLoop` `SandboxClient` / coder-delegate path.
+ *   - `createInProcessExecutor`   — the `runAgentRounds` `SandboxClient` / coder-delegate path.
  *
  * §1.5 by construction: prompt + model reach the direct invocation, while file-backed resources
  * are lowered by the shared profile materializer and applied before spawn. Resource instructions

package/dist/{coordination-DTehA977.d.ts → coordination-BZZSVYpZ.d.ts}

@@ -1,13 +1,13 @@
-import { R as Runtime, E as ExecutorFactory, U as UsageEvent, k as ExecutorProgress, T as TraceSource, g as Spend, i as ExecutorRegistry, A as Agent, S as Scope, b as ResultBlobStore, B as Budget } from './types-lZTE_LBd.js';
+import { R as Runtime, E as ExecutorFactory, U as UsageEvent, k as ExecutorProgress, T as TraceSource, g as Spend, i as ExecutorRegistry, A as Agent, S as Scope, b as ResultBlobStore, B as Budget } from './types-CvNwMzQt.js';
 import { StreamingDetector, DetectorSignal, ToolSpan, AgentEvalError } from '@tangle-network/agent-eval';
 import { AgentProfile as AgentProfile$1 } from '@tangle-network/agent-interface';
 import { a as UiLens, U as UiFinding, C as CoderTask } from './substrate-Dyiqmd3o.js';
-import { S as SandboxClient, E as ExecCtx, t as LoopTraceEmitter, c as LoopTraceEvent, A as AgentRunSpec } from './types-DK11_O4L.js';
+import { a as SandboxClient, E as ExecCtx, t as LoopTraceEmitter, c as LoopTraceEvent, A as AgentRunSpec } from './types-BCoemcXU.js';
 import { AgentProfile, BackendType, SandboxEvent, SandboxInstance } from '@tangle-network/sandbox';
 import { b as ToolSpec, c as RuntimeTelemetryOptions, R as RouterConfig } from './sanitize-DEbPNtyI.js';
 import { R as RuntimeStreamEvent } from './types-BwoZWq-i.js';
-import { G as GitRunner, a as WorktreeCheckRunner, D as DeliverableSpec } from './completion-gate-DLINnrkM.js';
-import { L as LocalHarness } from './local-harness-CtK9dSny.js';
+import { G as GitRunner, a as WorktreeCheckRunner, D as DeliverableSpec } from './completion-gate-BMy5LGoP.js';
+import { L as LocalHarness } from './local-harness-BDNcl6jI.js';
 import { ProviderExecutorOptions, AgentEnvironmentProviderRegistry } from './environment-provider.js';
 import { AgentEnvironmentProvider } from '@tangle-network/agent-interface/environment-provider';
 
@@ -23,7 +23,7 @@ import { AgentEnvironmentProvider } from '@tangle-network/agent-interface/enviro
  * verb pi already has:
  *
  *   `execute`        → `prompt`, draining pi's event stream until `agent_end`
- *   `deliver`        → `steer` (forceful) / `follow_up` (queued) — pi owns the queue, we do not
+ *   `deliver`        → `prompt` with `streamingBehavior` — pi owns the queue, we do not
  *   `teardown`       → `abort`, then close stdin and reap the process
  *   `progress`       → pi's `tool_execution_start`/`_end` + `turn_end` events, plus `get_state`'s
  *                      `pendingMessageCount` mirrored locally so the read stays synchronous
@@ -111,7 +111,7 @@ declare function createInbox(): Inbox;
  * The STEERABLE sandbox worker: one box, one server-side session, MANY turns — so a message
  * from the driver has a boundary to be folded into.
  *
- * The default cloud worker was built on `singleShotDriver`: one `runLoop` shot, no turn
+ * The default cloud worker was built on `singleShotDriver`: one `runAgentRounds` shot, no turn
  * boundary, and no `Executor.deliver`. `Scope.send` therefore returned `false` for it and
  * `steer_agent` reported `delivered:false` on every call — steering the DEFAULT worker was
  * mechanically impossible, not merely unused. This module is the missing continuation loop.
@@ -141,7 +141,7 @@ declare function createInbox(): Inbox;
  *  this bounds how many times a supervisor may redirect ONE worker before it must respawn. */
 declare const DEFAULT_SANDBOX_STEERING_MAX_TURNS = 24;
 /** Opt-in configuration for the steerable sandbox worker (`SandboxSeam.steering`). Absent, the
- *  sandbox executor keeps its historical single-shot `runLoop` composition verbatim. */
+ *  sandbox executor keeps its historical single-shot `runAgentRounds` composition verbatim. */
 interface SandboxSteeringOptions {
     /** Max turns for one worker (turn 0 + folded steers). Default {@link DEFAULT_SANDBOX_STEERING_MAX_TURNS}. */
     readonly maxTurns?: number;
@@ -186,7 +186,7 @@ declare function createSteerableSandboxSession(args: SteerableSandboxArgs): Stee
  *
  * The interface is the extension point, not a closed `inline|sandbox|cli` union:
  *   - router/inline : a direct OpenAI-compatible Router call, no box (one-shot).
- *   - sandbox       : COMPOSES the existing `runLoop` kernel as a single-task
+ *   - sandbox       : COMPOSES the existing `runAgentRounds` kernel as a single-task
  *                     leaf and surfaces its token/cost usage as `UsageEvent`s;
  *                     forwards PR #150's optional `lineage` passthrough WITHOUT
  *                     reinventing checkpoint/fork (streaming).
@@ -198,7 +198,7 @@ declare function createSteerableSandboxSession(args: SteerableSandboxArgs): Stee
  * pass it as `AgentSpec.executor`.
  *
  * Layering: `estimateCost`/`isModelPriced` are substrate primitives from
- * `@tangle-network/agent-eval`; `runLoop`/`acquireSandbox` are runtime kernels
+ * `@tangle-network/agent-eval`; `runAgentRounds`/`acquireSandbox` are runtime kernels
  * from this package. No per-vendor adapters live here.
  *
  * @experimental
@@ -215,29 +215,29 @@ interface RouterSeam {
     model?: string;
 }
 /**
- * Sandbox executor seam. The `sandboxClient` the composed `runLoop` creates
+ * Sandbox executor seam. The `sandboxClient` the composed `runAgentRounds` creates
  * boxes through, plus the optional trace/run/lineage wiring forwarded into the
- * loop. `lineage` is opaque here (PR #150's `RunLoopOptions.lineage`): forwarded
+ * loop. `lineage` is opaque here (PR #150's `RunAgentRoundsOptions.lineage`): forwarded
  * forward-compatibly, never inspected — this executor does NOT reinvent
  * checkpoint/fork.
  */
 interface SandboxSeam {
     sandboxClient: SandboxClient;
-    /** Forwarded into the composed `runLoop`'s `ctx` (trace emitter, run handle, etc.). */
+    /** Forwarded into the composed `runAgentRounds`'s `ctx` (trace emitter, run handle, etc.). */
     loopCtx?: Partial<Omit<ExecCtx, 'sandboxClient' | 'signal'>>;
-    /** PR #150 `RunLoopOptions.lineage` passthrough — opaque; forwarded, not parsed. */
+    /** PR #150 `RunAgentRoundsOptions.lineage` passthrough — opaque; forwarded, not parsed. */
     lineage?: unknown;
     /** Hard cap on the composed loop's iterations. The budget pool reserves against
      *  the spawn `Budget.maxIterations`; this is the leaf's own ceiling. Default 1. */
     maxIterations?: number;
     /**
      * OPT-IN: run this worker as a multi-turn, STEERABLE session instead of the historical
-     * single-shot `runLoop` composition. Setting it gives the sandbox worker an `Executor.deliver`
+     * single-shot `runAgentRounds` composition. Setting it gives the sandbox worker an `Executor.deliver`
      * inbox (so `Scope.send` / `steer_agent` actually reach it), a live tool-activity trace, and a
      * `progress()` read — turning the default cloud worker from something a supervisor can only
      * wait on into something it can watch and correct.
      *
-     * Absent, nothing changes: the same `runLoop` leaf, no inbox, `steer_agent` still reports
+     * Absent, nothing changes: the same `runAgentRounds` leaf, no inbox, `steer_agent` still reports
      * `delivered:false`. Opt-in because a steerable worker holds ONE box across several turns,
      * which is a different resource profile from a fire-and-forget shot.
      */
@@ -973,7 +973,7 @@ declare function exportEvalRuns(events: EvalRunEvent[], config?: EvalRunsExportC
  *   PARENT_SPAN_ID=<span-that-dispatched-the-delegation>
  *
  * The MCP server reads these at startup and uses them as the root of its
- * internal trace tree. All spans emitted by `runLoop` invocations inside
+ * internal trace tree. All spans emitted by `runAgentRounds` invocations inside
  * the MCP are children of the parent's delegation span.
  *
  * When these env vars are absent, the MCP generates a fresh trace root —
@@ -1310,7 +1310,7 @@ interface DelegationHistoryResult {
  * Each `submit` returns a `taskId` immediately and kicks the work off in the
  * background. The work function receives an `AbortSignal` the queue fires
  * when `cancel(taskId)` is called. The queue does NOT supervise runtime
- * timeouts — the underlying `runLoop` driver / sandbox imposes those.
+ * timeouts — the underlying `runAgentRounds` driver / sandbox imposes those.
  *
  * Idempotency: callers may supply an `idempotencyKey` (hash of the input).
  * A duplicate `submit` with a known key returns the existing task instead of
@@ -1416,7 +1416,7 @@ interface DelegationRunContext {
      * Per-delegation loop-trace sink, always provided by the queue. Events
      * emitted here are journaled onto the record as a compact span tree
      * (`record.trace`) when each loop run ends and at the delegation's
-     * terminal transition. Delegates forward it into their `runLoop` ctx,
+     * terminal transition. Delegates forward it into their `runAgentRounds` ctx,
      * composed with any process-wide OTEL emitter
      * (`composeLoopTraceEmitters`). Optional in the type so consumer-built
      * contexts stay source-compatible.
@@ -1639,7 +1639,7 @@ declare function hashIdempotencyInput(value: unknown): string;
  * loop event stream (see `RunDetachedTurnOptions.traceEmitter`) so the span
  * topology joins the inherited trace context, with cost/tokens reported as 0
  * under the `'detached-turn'` driver tag. Multi-variant fanout stays on the
- * streaming `runLoop` path — N concurrent sessions cannot be expressed as one
+ * streaming `runAgentRounds` path — N concurrent sessions cannot be expressed as one
  * resume key, and winner selection needs every candidate.
  *
  * @experimental
@@ -1745,7 +1745,7 @@ interface RunDetachedTurnOptions {
      * Loop-trace sink. When set, the detached turn synthesizes a
      * single-iteration loop span tree (`runId` = `sessionId`, driver
      * `'detached-turn'`) so trace-context inheritance survives the detached
-     * path — the same events the streaming `runLoop` path would emit, minus
+     * path — the same events the streaming `runAgentRounds` path would emit, minus
      * per-token telemetry: `driveTurn` yields one terminal payload, so token
      * and cost figures are structurally unavailable and reported as 0 under
      * this driver tag.
@@ -1911,7 +1911,7 @@ declare function createFleetWorkspaceExecutor(options: FleetWorkspaceExecutorOpt
 
 /**
  *
- * `detachedSessionDelegate` — the sandbox-session coder delegate: a closure that drives `runLoop`
+ * `detachedSessionDelegate` — the sandbox-session coder delegate: a closure that drives `runAgentRounds`
  * against a `SandboxClient` + a caller-supplied (or minimal model-only default) worker profile, to a
  * mechanically-validated `CoderOutput`. The caller invokes the returned delegate directly with its
  * coder args; when wired into a durable queue it also settles cross-restart-resumed records.
@@ -2012,7 +2012,7 @@ interface DetachedSessionDelegateOptions {
     sandboxClient?: SandboxClient;
     /**
      * The worker's authored `AgentProfile` (§1.5: the system authors profiles). Spread onto the
-     * sandbox-session run spec → `runLoop` → the executor's `harnessInvocation`, so the harness runs
+     * sandbox-session run spec → `runAgentRounds` → the executor's `harnessInvocation`, so the harness runs
      * under the caller's stance. Omit to use a minimal model-only default (no hardcoded skills/tools);
      * `harness` / `model` / `systemPrompt` below are convenience overrides layered onto whichever
      * profile is used.
@@ -2024,7 +2024,7 @@ interface DetachedSessionDelegateOptions {
     model?: string;
     /**
      * The worker's authored system prompt (§1.5). Flows onto the run spec's
-     * `profile.prompt.systemPrompt` → through `runLoop` → the executor's `harnessInvocation`, so the
+     * `profile.prompt.systemPrompt` → through `runAgentRounds` → the executor's `harnessInvocation`, so the
      * harness runs under this stance. Omit to keep the profile's own prompt.
      */
     systemPrompt?: string;
@@ -2044,14 +2044,14 @@ interface DetachedSessionDelegateOptions {
     /** Winner-selection strategy among eligible candidates. Default `highest-score`. */
     winnerSelection?: DetachedWinnerSelection;
     /**
-     * Loop trace emitter forwarded into every delegated `runLoop`. Wire
+     * Loop trace emitter forwarded into every delegated `runAgentRounds`. Wire
      * `createPropagatingTraceEmitter(readTraceContextFromEnv())` here (the bin
      * does) so delegated build-loops export their topology spans to the OTLP /
      * Tangle Intelligence sink when `OTEL_EXPORTER_OTLP_ENDPOINT` is set — and
      * are a cheap no-op when it isn't. Configurable by construction.
      *
      * Detached single-variant turns (taken when `ctx.detachedSessionRef` is set)
-     * bypass `runLoop`; `runDetachedTurn` synthesizes a single-iteration loop
+     * bypass `runAgentRounds`; `runDetachedTurn` synthesizes a single-iteration loop
      * event stream for them so this emitter observes detached work too.
      */
     traceEmitter?: LoopTraceEmitter;
@@ -2061,7 +2061,7 @@ interface DetachedSessionDelegateOptions {
     detachedWallCapMs?: number;
 }
 /**
- * Build the sandbox-session coder delegate. It drives `runLoop` against the project's
+ * Build the sandbox-session coder delegate. It drives `runAgentRounds` against the project's
  * sandbox client + coder profile; when `args.variants > 1` it switches to the multi-harness fanout
  * topology.
  *
@@ -2106,7 +2106,7 @@ interface SettleDetachedCoderTurnOptions {
  * detached run must not return an unvalidated patch.
  *
  * SCOPE NOTE (detached/resume): the detached `driveTurn`-tick + cross-restart resume path is
- * bound to the `runLoop` + sandbox-session substrate. The recursive `Scope`/worktree-CLI leaf has
+ * bound to the `runAgentRounds` + sandbox-session substrate. The recursive `Scope`/worktree-CLI leaf has
  * journal→replay but no driveTurn-over-a-detached-sandbox-session equivalent yet, so resume is NOT
  * advertised on the generic `worktreeFanout` path. This helper (with `coderTaskFromArgs` and
  * `createDetachedTurnResumeDriver`) stays as the resume seam `bin.ts` wires for in-flight records.
@@ -2285,7 +2285,7 @@ interface McpServerOptions {
     delegateSupervisor?: DelegateHandlerOptions;
     /**
      * Required to enable delegate_ui_audit. Wire one that closes over your
-     * `runLoop` + `uiAuditorProfile` + a `SandboxClient` (the
+     * `runAgentRounds` + `uiAuditorProfile` + a `SandboxClient` (the
      * canonical in-process choice is `createInProcessUiAuditClient` from
      * `@tangle-network/agent-runtime/profiles`) + your vision judge.
      */

package/dist/environment-provider.d.ts

@@ -1,12 +1,23 @@
 import { AgentProfile, AgentProfileValidationResult } from '@tangle-network/agent-interface';
-import { CreateAgentEnvironmentInput, AgentTurnInput, AgentEnvironmentProvider, AgentEnvironmentCapabilities, AgentProfileRef } from '@tangle-network/agent-interface/environment-provider';
+import { AgentEnvironmentProvider, CreateAgentEnvironmentInput, AgentTurnInput, AgentEnvironmentCapabilities, AgentProfileRef } from '@tangle-network/agent-interface/environment-provider';
 export { AgentEnvironment, AgentEnvironmentCapabilities, AgentEnvironmentEvent, AgentEnvironmentProvider, AgentEnvironmentQuery, AgentEnvironmentStatus, AgentEnvironmentSummary, AgentProfileRef, AgentSession, AgentSessionRef, AgentSessionStatus, AgentTurnInput, AgentTurnResult, CheckpointRef, CheckpointRequest, CreateAgentEnvironmentInput, ExecRequest, ExecResult, ForkRequest, PlacementInfo, ResourceRequest, WorkspaceRequest } from '@tangle-network/agent-interface/environment-provider';
-import { CreateSandboxOptions, BackendType } from '@tangle-network/sandbox';
-import { R as Runtime, E as ExecutorFactory } from './types-lZTE_LBd.js';
-import { S as SandboxClient } from './types-DK11_O4L.js';
+import { SandboxClient, CreateSandboxOptions, BackendType } from '@tangle-network/sandbox';
+import { R as Runtime, E as ExecutorFactory } from './types-CvNwMzQt.js';
+import { a as SandboxClient$1 } from './types-BCoemcXU.js';
 import '@tangle-network/agent-eval';
 import './types-BwoZWq-i.js';
 
+interface CreateTangleSandboxExactProcessProviderOptions {
+    name?: string;
+}
+/**
+ * Adapt Tangle Sandbox's managed control runtime to Runtime's exact-process provider.
+ *
+ * The adapter deliberately exposes no ordinary agent environment: an exact experiment
+ * must start a fresh Sandbox with no managed agent and launch its declared argv directly.
+ */
+declare function createTangleSandboxExactProcessProvider(client: SandboxClient, options?: CreateTangleSandboxExactProcessProviderOptions): AgentEnvironmentProvider;
+
 /** Provider object or registry name accepted by runtime provider adapters.
  * @experimental */
 type AgentEnvironmentProviderRef = AgentEnvironmentProvider | string;
@@ -38,7 +49,7 @@ interface ProviderAsSandboxClientOptions {
 }
 /** Adapt a neutral environment provider to the `SandboxClient` interface used by existing loop paths.
  * @experimental */
-declare function providerAsSandboxClient(provider: AgentEnvironmentProvider, options?: ProviderAsSandboxClientOptions): SandboxClient;
+declare function providerAsSandboxClient(provider: AgentEnvironmentProvider, options?: ProviderAsSandboxClientOptions): SandboxClient$1;
 /** Options for wrapping the current Tangle sandbox client as an environment provider.
  * @experimental */
 interface SandboxClientProviderOptions {
@@ -50,7 +61,7 @@ interface SandboxClientProviderOptions {
 }
 /** Adapt a `SandboxClient` into the shared `AgentEnvironmentProvider` contract.
  * @experimental */
-declare function sandboxClientAsProvider(client: SandboxClient, options?: SandboxClientProviderOptions): AgentEnvironmentProvider;
+declare function sandboxClientAsProvider(client: SandboxClient$1, options?: SandboxClientProviderOptions): AgentEnvironmentProvider;
 /** Options for running a provider as a supervise-mode executor.
  * @experimental */
 interface ProviderExecutorOptions {
@@ -64,4 +75,4 @@ interface ProviderExecutorOptions {
  * @experimental */
 declare function providerAsExecutor(provider: AgentEnvironmentProvider, options?: ProviderExecutorOptions): ExecutorFactory<unknown>;
 
-export { type AgentEnvironmentProviderRef, type AgentEnvironmentProviderRegistry, type ProviderAsSandboxClientOptions, type ProviderExecutorOptions, type SandboxClientProviderOptions, createAgentEnvironmentProviderRegistry, providerAsExecutor, providerAsSandboxClient, resolveAgentEnvironmentProvider, sandboxClientAsProvider };
+export { type AgentEnvironmentProviderRef, type AgentEnvironmentProviderRegistry, type CreateTangleSandboxExactProcessProviderOptions, type ProviderAsSandboxClientOptions, type ProviderExecutorOptions, type SandboxClientProviderOptions, createAgentEnvironmentProviderRegistry, createTangleSandboxExactProcessProvider, providerAsExecutor, providerAsSandboxClient, resolveAgentEnvironmentProvider, sandboxClientAsProvider };

package/dist/environment-provider.js

@@ -1,13 +1,15 @@
 import {
   createAgentEnvironmentProviderRegistry,
+  createTangleSandboxExactProcessProvider,
   providerAsExecutor,
   providerAsSandboxClient,
   resolveAgentEnvironmentProvider,
   sandboxClientAsProvider
-} from "./chunk-M6MD6JBS.js";
+} from "./chunk-KRBFHMV6.js";
 import "./chunk-3MDZX7YU.js";
 export {
   createAgentEnvironmentProviderRegistry,
+  createTangleSandboxExactProcessProvider,
   providerAsExecutor,
   providerAsSandboxClient,
   resolveAgentEnvironmentProvider,