@tangle-network/agent-runtime 0.51.0 → 0.53.0

package/dist/mcp/index.js

@@ -14,12 +14,12 @@ import {
   removeWorktree,
   traceContextToEnv,
   validateDelegateUiAuditArgs
-} from "../chunk-HAA4KZUD.js";
+} from "../chunk-5M2WDWBI.js";
 import "../chunk-WIR4HOOJ.js";
 import {
   mcpToolsForRuntimeMcp,
   mcpToolsForRuntimeMcpSubset
-} from "../chunk-FKHNHUXP.js";
+} from "../chunk-P4QNEXFC.js";
 import {
   DELEGATE_CODE_DESCRIPTION,
   DELEGATE_CODE_INPUT_SCHEMA,
@@ -54,7 +54,7 @@ import {
   validateDelegateResearchArgs,
   validateDelegationHistoryArgs,
   validateDelegationStatusArgs
-} from "../chunk-47SWANFA.js";
+} from "../chunk-FO4DCM7R.js";
 import {
   createKbGate
 } from "../chunk-FNMGYYSS.js";
@@ -75,7 +75,7 @@ import {
   parseDetachedSessionRef,
   runDetachedTurn,
   settleDetachedCoderTurn
-} from "../chunk-HYG4ISNS.js";
+} from "../chunk-AYRQZRDV.js";
 import "../chunk-KADIJAD4.js";
 import {
   runLocalHarness
@@ -84,11 +84,11 @@ import {
   DELEGATION_MCP_SERVER_KEY,
   buildDelegationMcpServer,
   composeProductionAgentProfile
-} from "../chunk-7JITYN6T.js";
+} from "../chunk-JFIYKDXF.js";
 import "../chunk-G3RGMA7C.js";
 import {
   assertTraceDerivedFindings
-} from "../chunk-FQH33M5N.js";
+} from "../chunk-K6WP7PYW.js";
 import "../chunk-GSUO5QS6.js";
 import "../chunk-DGUM43GV.js";
 

package/dist/{openai-tools-D4HLDWgw.d.ts → openai-tools-CKfR3EMh.d.ts}

@@ -1,4 +1,4 @@
-import { c as OpenAIChatTool } from './types-BEQsBhOE.js';
+import { c as OpenAIChatTool } from './types-CklkW4Eh.js';
 
 /**
  * @experimental

package/dist/profiles.d.ts

@@ -1,5 +1,5 @@
-export { C as CoderOutput, a as CoderProfileOptions, b as CoderTask, M as MultiHarnessCoderFanoutOptions, c as coderProfile, d as createCoderValidator, m as multiHarnessCoderFanout } from './coder-_YCf3BAK.js';
-import { S as SandboxClient, O as OutputAdapter, V as Validator, A as AgentRunSpec } from './types-BEQsBhOE.js';
+export { C as CoderOutput, a as CoderProfileOptions, b as CoderTask, M as MultiHarnessCoderFanoutOptions, c as coderProfile, d as createCoderValidator, m as multiHarnessCoderFanout } from './coder-LKm3Mczw.js';
+import { S as SandboxClient, O as OutputAdapter, V as Validator, A as AgentRunSpec } from './types-CklkW4Eh.js';
 import { a as UiLens, U as UiFinding } from './substrate-CUgk7F7s.js';
 export { b as UI_FINDING_SEVERITIES, c as UI_LENSES, d as UiFindingScreenshot, e as UiFindingSeverity } from './substrate-CUgk7F7s.js';
 import { SandboxEvent, AgentProfile } from '@tangle-network/sandbox';

package/dist/router-client-B0Qi1NiN.d.ts

@@ -0,0 +1,120 @@
+/**
+ * The one router chat client: direct OpenAI-compatible completions through the
+ * Tangle router — the cheapest dial, no sandbox. Three layers: `routerChatWithUsage`
+ * (chat-only), `routerChatWithTools` (one completion with function tools), and
+ * `routerToolLoop` (the off-box agentic loop over tool-calling). Shared by the
+ * built-in executors and the bench/lab harnesses.
+ *
+ * Reports REAL token usage so the backend-integrity guard sees a real backend.
+ * Returns `undefined` usage when the provider omitted it — never a fabricated 0
+ * (a phantom 0 reads as a free call downstream, which the gate would act on).
+ */
+interface RouterConfig {
+    routerBaseUrl: string;
+    routerKey: string;
+    model: string;
+}
+interface RouterChatResult {
+    content: string;
+    /** REAL usage, or undefined when the provider reported none. */
+    usage?: {
+        input: number;
+        output: number;
+    };
+    /** Derived from usage via `estimateCost` when the model is priced; else undefined. */
+    costUsd?: number;
+}
+declare function routerChatWithUsage(cfg: RouterConfig, messages: Array<{
+    role: string;
+    content: string;
+}>, opts?: {
+    temperature?: number;
+    signal?: AbortSignal;
+    maxTokens?: number;
+}): Promise<RouterChatResult>;
+/** A tool-call the model emitted (provider-neutral; mirrors the runtime's ToolCallRequest). */
+interface RouterToolCall {
+    id: string;
+    name: string;
+    /** Raw JSON arguments string as emitted by the model. */
+    arguments: string;
+}
+interface RouterChatToolsResult {
+    content: string | null;
+    toolCalls: RouterToolCall[];
+    usage?: {
+        input: number;
+        output: number;
+    };
+    costUsd?: number;
+}
+/**
+ * A router completion WITH tool-calling — the operator driver's LLM seam. Passes OpenAI-shape
+ * `messages` (system/user/assistant-with-tool_calls/tool roles) + function `tools`, and returns the
+ * assistant text plus the tool calls the model wants run. Same fail-loud + real-usage discipline as
+ * `routerChatWithUsage`. `tool_choice: 'auto'` lets the model decide; the driver loops on the result.
+ */
+declare function routerChatWithTools(cfg: RouterConfig, messages: ReadonlyArray<Record<string, unknown>>, tools: ReadonlyArray<{
+    type: 'function';
+    function: {
+        name: string;
+        description?: string;
+        parameters: unknown;
+    };
+}>, opts?: {
+    temperature?: number;
+    signal?: AbortSignal;
+    toolChoice?: 'auto' | 'required' | 'none';
+    maxTokens?: number;
+}): Promise<RouterChatToolsResult>;
+interface ToolSpec {
+    type: 'function';
+    function: {
+        name: string;
+        description?: string;
+        parameters: unknown;
+    };
+}
+interface RouterToolLoopResult {
+    /** The model's final assistant text (the turn where it stopped calling tools, or the budget turn). */
+    final: string;
+    /** Inference turns spent (≤ maxTurns) — the equal-budget unit vs random@k. */
+    turns: number;
+    toolCalls: number;
+    /** The behavior trace: each tool call + its result, in order. What a trace-analyst
+     *  steerer reads (behavior, never the verdict) to diagnose + redirect the next shot. */
+    toolTrace: Array<{
+        name: string;
+        args: string;
+        result: string;
+    }>;
+    usage: {
+        input: number;
+        output: number;
+    };
+    /** The full conversation after the loop (seed + every assistant/tool turn). Lets a caller
+     *  CARRY the messages into the next shot (depth continuation) and read the trajectory. */
+    messages: Array<Record<string, unknown>>;
+}
+/**
+ * The tool-using router backend: a real agentic loop OVER the Tangle router (which
+ * supports tool-calling), off-box — no sandbox. Each turn is one router completion
+ * with `tools`; if the model emits tool_calls, `execute` runs them on the host and
+ * their results are folded back as `tool` messages; the loop repeats until the
+ * model answers without a tool call or the turn budget is hit. One turn = one
+ * inference call, so `maxTurns` is the equal-compute unit against random@k.
+ *
+ * This is the depth substrate for agentic gates (the worker ACTS, observes the real
+ * result, and continues) that the chat-only `routerChatWithUsage` cannot express.
+ */
+declare function routerToolLoop(cfg: RouterConfig, system: string, user: string, tools: ReadonlyArray<ToolSpec>, execute: (name: string, args: Record<string, unknown>) => Promise<string>, opts?: {
+    maxTurns?: number;
+    temperature?: number;
+    signal?: AbortSignal;
+    maxTokens?: number;
+    /** Seed the loop with an existing conversation (depth continuation) instead of
+     *  `[system, user]`. When set, `system`/`user` are ignored. The array is copied. */
+    initialMessages?: ReadonlyArray<Record<string, unknown>>;
+}): Promise<RouterToolLoopResult>;
+
+export { type RouterChatResult as R, type ToolSpec as T, type RouterChatToolsResult as a, type RouterConfig as b, type RouterToolCall as c, type RouterToolLoopResult as d, routerChatWithUsage as e, routerToolLoop as f, routerChatWithTools as r };

package/dist/{run-loop-BIineL1T.d.ts → run-loop-DgVhucoR.d.ts}

@@ -1,5 +1,5 @@
 import { SandboxInstance } from '@tangle-network/sandbox';
-import { D as Driver, A as AgentRunSpec, O as OutputAdapter, V as Validator, E as ExecCtx, I as Iteration, L as LoopWinner, a as LoopLineageOptions, S as SandboxClient, b as LoopResult } from './types-BEQsBhOE.js';
+import { D as Driver, A as AgentRunSpec, O as OutputAdapter, V as Validator, E as ExecCtx, I as Iteration, L as LoopWinner, a as LoopLineageOptions, S as SandboxClient, b as LoopResult } from './types-CklkW4Eh.js';
 
 /**
  * @experimental

package/dist/runtime.d.ts

@@ -1,16 +1,19 @@
 import { AgentProfile, BackendType, CreateSandboxOptions, SandboxInstance, SandboxEvent } from '@tangle-network/sandbox';
 export { AgentProfile, CreateSandboxOptions, SandboxEvent, SandboxInstance } from '@tangle-network/sandbox';
-import { R as ResultBlobStore, a as SpawnJournal, N as NodeId, b as SpawnEvent, T as TreeView, c as Settled, d as AgentSpec, E as ExecutorRegistry, B as Budget, A as Agent, e as RootHandle, f as SupervisedResult, g as Spend, S as Scope, h as ExecutorFactory, U as UsageEvent, i as Supervisor } from './types-5MGt5KTY.js';
-export { j as Executor, k as ExecutorContext, l as ExecutorResult, H as Handle, m as NodeSnapshot, n as NodeStatus, o as Restart, p as RootSignal, q as Runtime, r as SpawnOpts, s as SupervisorOpts, W as WidenGate } from './types-5MGt5KTY.js';
+import { R as ResultBlobStore, a as SpawnJournal, N as NodeId, b as SpawnEvent, T as TreeView, c as Settled, d as AgentSpec, E as ExecutorRegistry, B as Budget, A as Agent, e as RootHandle, f as SupervisedResult, g as Spend, S as Scope, h as ExecutorFactory, U as UsageEvent, i as Supervisor } from './types-CNDJCL_0.js';
+export { j as Executor, k as ExecutorContext, l as ExecutorResult, H as Handle, m as NodeSnapshot, n as NodeStatus, o as Restart, p as RootSignal, q as Runtime, r as SpawnOpts, s as SupervisorOpts, W as WidenGate } from './types-CNDJCL_0.js';
 import { R as RuntimeHooks } from './runtime-hooks-C7JwKb9E.js';
-import { ChatClient, AnalystFinding, DefaultVerdict, AgentProfile as AgentProfile$1 } from '@tangle-network/agent-eval';
+import { ChatClient, AnalystFinding, DefaultVerdict, AgentProfile as AgentProfile$1, AnalystRunInputs } from '@tangle-network/agent-eval';
 export { DefaultVerdict } from '@tangle-network/agent-eval';
-export { A as AnalyzeInput, a as CompletionAnalyst, b as CompletionEvidence, c as CompletionPolicy, d as CompletionVerdict, C as CreateDriverOptions, D as DriverDecision, P as PlannerContext, e as TopologyMove, T as TopologyPlanner, f as completionAuthorizes, g as createDriver, h as deterministicCompletion, r as renderAnalyses, s as sentinelCompletion, i as stopSentinel } from './driver-DLI1io57.js';
-import { S as SandboxClient, b as LoopResult, d as LoopTokenUsage, R as RuntimeStreamEvent, A as AgentRunSpec, E as ExecCtx, I as Iteration } from './types-BEQsBhOE.js';
-export { D as Driver, F as LoopDecisionPayload, G as LoopEndedPayload, H as LoopIterationDispatchPayload, J as LoopIterationEndedPayload, M as LoopIterationStartedPayload, a as LoopLineageOptions, N as LoopPlanDescription, P as LoopPlanPayload, e as LoopSandboxPlacement, Q as LoopStartedPayload, T as LoopTeardownFailedPayload, f as LoopTraceEmitter, g as LoopTraceEvent, L as LoopWinner, O as OutputAdapter, U as ValidationCtx, V as Validator } from './types-BEQsBhOE.js';
+export { A as AnalyzeInput, a as CompletionAnalyst, b as CompletionEvidence, c as CompletionPolicy, d as CompletionVerdict, C as CreateDriverOptions, D as DriverDecision, P as PlannerContext, e as TopologyMove, T as TopologyPlanner, f as completionAuthorizes, g as createDriver, h as deterministicCompletion, r as renderAnalyses, s as sentinelCompletion, i as stopSentinel } from './driver-B2RKkVJW.js';
+import { S as SandboxClient, b as LoopResult, d as LoopTokenUsage, R as RuntimeStreamEvent, A as AgentRunSpec, E as ExecCtx, I as Iteration } from './types-CklkW4Eh.js';
+export { D as Driver, F as LoopDecisionPayload, G as LoopEndedPayload, H as LoopIterationDispatchPayload, J as LoopIterationEndedPayload, M as LoopIterationStartedPayload, a as LoopLineageOptions, N as LoopPlanDescription, P as LoopPlanPayload, f as LoopSandboxPlacement, Q as LoopStartedPayload, T as LoopTeardownFailedPayload, g as LoopTraceEmitter, e as LoopTraceEvent, L as LoopWinner, O as OutputAdapter, U as ValidationCtx, V as Validator } from './types-CklkW4Eh.js';
 import { Scenario, ProfileDispatchFn } from '@tangle-network/agent-eval/campaign';
-import { R as RunLoopOptions } from './run-loop-BIineL1T.js';
-export { c as createSandboxForSpec, d as defaultSelectWinner, r as runLoop } from './run-loop-BIineL1T.js';
+import { R as RunLoopOptions } from './run-loop-DgVhucoR.js';
+export { c as createSandboxForSpec, d as defaultSelectWinner, r as runLoop } from './run-loop-DgVhucoR.js';
+import { b as AnalystRegistryLike } from './types-p8dWBIXL.js';
+import { T as ToolSpec } from './router-client-B0Qi1NiN.js';
+export { R as RouterChatResult, a as RouterChatToolsResult, b as RouterConfig, c as RouterToolCall, d as RouterToolLoopResult, r as routerChatWithTools, e as routerChatWithUsage, f as routerToolLoop } from './router-client-B0Qi1NiN.js';
 
 /**
  * @experimental
@@ -464,6 +467,9 @@ interface ShapeContext<D = unknown> {
     /** Derive a child `AgentSpec` from the persona's root spec with an overridden profile —
      *  the seam a shape uses to give a worker a narrower role/prompt than the root persona. */
     childSpec(profile: AgentProfile, harness?: BackendType | null): AgentSpec;
+    /** The scope analyst (selector≠judge firewall) the combinator steers from. Absent ⇒ the
+     *  dormant default (empty findings → gates read deliverables/state only). */
+    readonly analyst?: ScopeAnalyst<D>;
 }
 /**
  * A reusable act-body factory. Given the persona's content + seams (`ShapeContext`), it
@@ -521,6 +527,15 @@ interface RunPersonifiedOptions<Task, D> {
     readonly handle?: RootHandle<Outcome<D>>;
     readonly now?: () => number;
     readonly signal?: AbortSignal;
+    /** Optional scope analyst threaded into the shape's ShapeContext so loopUntil/widen steer
+     *  on trace-derived findings instead of the dormant empty default. */
+    readonly analyst?: ScopeAnalyst<D>;
+    /**
+     * Lifecycle stream sink, forwarded to `SupervisorOpts.hooks` so the root `Scope`'s
+     * `agent.spawn`/`agent.child` events flow to an observer (e.g. the Intelligence SDK's
+     * trace export). Absent ⇒ no stream (the run is silent, as today).
+     */
+    readonly hooks?: RuntimeHooks;
 }
 /** The composed run signature. */
 type RunPersonified = <Task, D>(options: RunPersonifiedOptions<Task, D>) => Promise<SupervisedResult<Outcome<D>>>;
@@ -1635,6 +1650,32 @@ interface CreateScopeAnalystOptions<D> {
  *  - any finding cites judge-derived metric evidence → `PlannerError` via the firewall
  */
 declare function createScopeAnalyst<D>(scope: Scope<Outcome<D>>, options: CreateScopeAnalystOptions<D>): ScopeAnalyst<D>;
+/**
+ * Project a `ScopeAnalyzeInput` into the `AnalystRegistry.run` arguments. The registry runs over a
+ * `runId` + `AnalystRunInputs` (a trace store / run record / artifact dir), NOT in-memory scope
+ * settlements — so the CALLER owns the projection from the combinator's drained children to the
+ * registry's inputs (e.g. the trace store the run already wrote). This adapter never invents that
+ * bridge; it only runs the projected inputs and firewalls the merged findings.
+ */
+interface RegistryAnalyzeProjection {
+    readonly runId: string;
+    readonly inputs: AnalystRunInputs;
+    /** Optional `run` opts (e.g. `priorFindings`) forwarded verbatim to the registry. */
+    readonly opts?: Parameters<AnalystRegistryLike['run']>[2];
+}
+/**
+ * A `ScopeAnalyst` backed by an `AnalystRegistry` — the panel-of-analysts seam. The registry merges
+ * N analyst KINDS into one `AnalystRunResult.findings`; `analyze` runs it over the caller-projected
+ * `{ runId, inputs }` and pipes the merged findings through the SAME `assertTraceDerivedFindings`
+ * firewall `createScopeAnalyst` uses (single-sourced selector≠judge). Distinct from `panel()`
+ * (judges-vs-one-artifact) — this is analysts-over-a-trace, the diagnosis side of the wire.
+ *
+ * Fail loud: a registry that throws propagates; a judge-derived finding aborts via the firewall.
+ * The projection is the caller's (`buildInputs`) — if the scope settlements do not cleanly map to
+ * the registry's `AnalystRunInputs`, that is a caller-side contract gap, surfaced there, not papered
+ * over with a fabricated input here.
+ */
+declare function registryScopeAnalyst<D>(registry: AnalystRegistryLike, buildInputs: (input: ScopeAnalyzeInput<D>) => RegistryAnalyzeProjection): ScopeAnalyst<D>;
 /**
  * Build the `SteerContext` a combinator reads to steer (its `loopUntil.until`, `widen` gate, any
  * future steer). One place enforces the firewall: `findings` is asserted trace-derived before it is
@@ -1693,9 +1734,10 @@ declare function fanout<Task, Item, D>(items: ReadonlyArray<Item>, opts: FanoutO
  * the deployable stop. The conserved pool IS the loop bound: once `spawn` fails closed the loop
  * stops. A loop that exhausted the pool without `until` ever satisfying is a concrete blocker.
  *
- * Findings are threaded through the `SteerContext` firewall in the analyst seam (`analyst.ts`);
- * absent a wired analyst on this surface the firewall stays dormant and `until` is consulted with
- * an empty findings array — never a fabricated finding (fail-loud honesty over a silent default).
+ * When `ctx.analyst` is set, each round runs it over the children settled so far and steers
+ * `until` on the resulting trace-derived findings (the analyst spawns into THIS scope, so its
+ * compute is conserved-pooled — equal-k holds by construction). Absent an analyst the findings
+ * argument is the empty array — never a fabricated finding (fail-loud honesty over a silent default).
  */
 declare function loopUntil<Task, State, D>(seed: State, spec: LoopUntilSpec<Task, State, D>): CombinatorShape<Task, D>;
 /**
@@ -1721,9 +1763,14 @@ declare function verify<Task, Candidate, D>(spec: VerifySpec<Task, Candidate, D>
  * never a child's raw `verdict` — and the default gate (`flatWidenGate`) never widens, so the R2
  * firewall stays dormant. Terminal selection is `spec.synthesize` over every settled lineage.
  *
- * No analyst is wired on this frozen surface, so `decide` is consulted with an empty findings
- * array; a flat gate ignores it. A non-flat gate that wants findings reads them through the
- * `SteerContext` firewall the analyst seam owns — never fabricated here.
+ * When `ctx.analyst` is set, `decide` is consulted with that round's trace-derived findings;
+ * absent an analyst the findings argument is the empty array a flat gate ignores. The analyst
+ * spawns into THIS scope (conserved-pooled, so equal-k holds). Streaming caveat: a wired analyst
+ * drains its own child off the SHARED cursor by id-match, so on a NON-flat gate (which spawns
+ * widen children that are live concurrently) the analyst can consume a sibling's settlement before
+ * the widen loop sees it. The shipped default (`flatWidenGate`) never widens, so no widen child is
+ * ever live when the analyst runs and the wire is exact; a non-flat gate must drive the analyst on
+ * a scope whose siblings are quiesced, or read findings without the shared-cursor drain.
  */
 declare function widen<Task, Seed, D>(spec: WidenSpec<Seed, D>): CombinatorShape<Task, D>;
 /**
@@ -1996,117 +2043,6 @@ interface UsageSink {
  */
 declare function reportLoopUsage<Task, Output, Decision>(cost: UsageSink, result: Pick<LoopResult<Task, Output, Decision>, 'costUsd' | 'tokenUsage'>, source?: string): void;
 
-/**
- * The one router chat client: direct OpenAI-compatible completions through the
- * Tangle router — the cheapest dial, no sandbox. Three layers: `routerChatWithUsage`
- * (chat-only), `routerChatWithTools` (one completion with function tools), and
- * `routerToolLoop` (the off-box agentic loop over tool-calling). Shared by the
- * built-in executors and the bench/lab harnesses.
- *
- * Reports REAL token usage so the backend-integrity guard sees a real backend.
- * Returns `undefined` usage when the provider omitted it — never a fabricated 0
- * (a phantom 0 reads as a free call downstream, which the gate would act on).
- */
-interface RouterConfig {
-    routerBaseUrl: string;
-    routerKey: string;
-    model: string;
-}
-interface RouterChatResult {
-    content: string;
-    /** REAL usage, or undefined when the provider reported none. */
-    usage?: {
-        input: number;
-        output: number;
-    };
-    /** Derived from usage via `estimateCost` when the model is priced; else undefined. */
-    costUsd?: number;
-}
-declare function routerChatWithUsage(cfg: RouterConfig, messages: Array<{
-    role: string;
-    content: string;
-}>, opts?: {
-    temperature?: number;
-    signal?: AbortSignal;
-    maxTokens?: number;
-}): Promise<RouterChatResult>;
-/** A tool-call the model emitted (provider-neutral; mirrors the runtime's ToolCallRequest). */
-interface RouterToolCall {
-    id: string;
-    name: string;
-    /** Raw JSON arguments string as emitted by the model. */
-    arguments: string;
-}
-interface RouterChatToolsResult {
-    content: string | null;
-    toolCalls: RouterToolCall[];
-    usage?: {
-        input: number;
-        output: number;
-    };
-    costUsd?: number;
-}
-/**
- * A router completion WITH tool-calling — the operator driver's LLM seam. Passes OpenAI-shape
- * `messages` (system/user/assistant-with-tool_calls/tool roles) + function `tools`, and returns the
- * assistant text plus the tool calls the model wants run. Same fail-loud + real-usage discipline as
- * `routerChatWithUsage`. `tool_choice: 'auto'` lets the model decide; the driver loops on the result.
- */
-declare function routerChatWithTools(cfg: RouterConfig, messages: ReadonlyArray<Record<string, unknown>>, tools: ReadonlyArray<{
-    type: 'function';
-    function: {
-        name: string;
-        description?: string;
-        parameters: unknown;
-    };
-}>, opts?: {
-    temperature?: number;
-    signal?: AbortSignal;
-    toolChoice?: 'auto' | 'required' | 'none';
-}): Promise<RouterChatToolsResult>;
-interface ToolSpec {
-    type: 'function';
-    function: {
-        name: string;
-        description?: string;
-        parameters: unknown;
-    };
-}
-interface RouterToolLoopResult {
-    /** The model's final assistant text (the turn where it stopped calling tools, or the budget turn). */
-    final: string;
-    /** Inference turns spent (≤ maxTurns) — the equal-budget unit vs random@k. */
-    turns: number;
-    toolCalls: number;
-    /** The behavior trace: each tool call + its result, in order. What a trace-analyst
-     *  steerer reads (behavior, never the verdict) to diagnose + redirect the next shot. */
-    toolTrace: Array<{
-        name: string;
-        args: string;
-        result: string;
-    }>;
-    usage: {
-        input: number;
-        output: number;
-    };
-}
-/**
- * The tool-using router backend: a real agentic loop OVER the Tangle router (which
- * supports tool-calling), off-box — no sandbox. Each turn is one router completion
- * with `tools`; if the model emits tool_calls, `execute` runs them on the host and
- * their results are folded back as `tool` messages; the loop repeats until the
- * model answers without a tool call or the turn budget is hit. One turn = one
- * inference call, so `maxTurns` is the equal-compute unit against random@k.
- *
- * This is the depth substrate for agentic gates (the worker ACTS, observes the real
- * result, and continues) that the chat-only `routerChatWithUsage` cannot express.
- */
-declare function routerToolLoop(cfg: RouterConfig, system: string, user: string, tools: ReadonlyArray<ToolSpec>, execute: (name: string, args: Record<string, unknown>) => Promise<string>, opts?: {
-    maxTurns?: number;
-    temperature?: number;
-    signal?: AbortSignal;
-}): Promise<RouterToolLoopResult>;
-
 /**
  * @experimental
  *
@@ -3184,4 +3120,4 @@ declare function gitWorkspace(opts: GitWorkspaceOptions): Workspace;
  *  requires `jj` on the `Shell`'s host. */
 declare function jjWorkspace(opts: GitWorkspaceOptions): Workspace;
 
-export { Agent, AgentRunSpec, AgentSpec, type AgenticOptions, type AgenticRunResult, type AgenticSurface, type AgenticTask, type AgenticTool, type AnytimeReport, type AnytimeStrategySummary, type AnytimeTaskCurve, type ArtifactHandle, type AssertTraceDerivedFindings, type AuditIntentInput, type AuditIntentOptions, type AuthorStrategyOptions, type AuthoredStrategy, type BenchmarkCell, type BenchmarkConfig, type BenchmarkLift, type BenchmarkReport, type BenchmarkStrategySummary, type BenchmarkTaskRow, type BridgeSeam, Budget, type BudgetPool, type BudgetReadout, type ChampionPick, type ChampionPolicy, type CheckpointCapableBox, type CliSeam, type CombinatorShape, type Corpus, type CorpusFilter, type CorpusRecord, type CreateScopeAnalystOptions, type CriuCapableClient, type DefinePersona, type DefinePersonaInput, type Deliverable, type Environment, type EqualKArm, type EqualKOnCost, type EqualKOnCostOptions, type EqualKVerdict, type EvolutionArchiveNode, type EvolutionAuthor, type EvolutionBandInfo, type EvolutionCandidate, type EvolutionGeneration, type EvolutionReport, ExecCtx, type ExecutorConfig, ExecutorFactory, ExecutorRegistry, type Fanout, type FanoutOptions, type FanoutSynthesis, FileCorpus, FileResultBlobStore, FileSpawnJournal, type FlatWidenGate, type ForkCapableBox, type GitWorkspaceOptions, type HarvestCorpusOptions, type HarvestFailure, type HarvestReport, InMemoryCorpus, InMemoryResultBlobStore, InMemorySpawnJournal, type IntentAudit, Iteration, type LoopDispatchOptions, type LoopOptionsForDispatch, LoopResult, type LoopShape, LoopTokenUsage, type LoopUntil, type LoopUntilSpec, type LoopUntilState, type McpEndpoint, type McpEnvironmentOptions, NodeId, type Observation, type ObserveInput, type ObserveOptions, type OpenSandboxRunOptions, type Outcome, type Panel, type PanelJudge, type PanelSpec, type PanelVerdict, type Persona, type PersonaContext, type PersonaExecutors, type Pipeline, type PipelineStage, type PromotionGateOptions, type PromotionVerdict, type RenderCorpusToInstructions, type RenderCorpusToInstructionsOptions, type ReservationTicket, ResultBlobStore, RootHandle, type RouterChatResult, type RouterChatToolsResult, type RouterConfig, type RouterSeam, type RouterToolCall, type RouterToolLoopResult, type RouterToolsSeam, type RunAgenticOptions, RunLoopOptions, type RunPersonified, type RunPersonifiedOptions, type SandboxCapabilities, SandboxClient, type SandboxLineage, type SandboxLineageHandle, type SandboxRun, type SandboxSeam, Scope, type ScopeAnalyst, type ScopeAnalyzeInput, type ScopeWidenGate, type SessionCapableBox, Settled, type ShapeBudget, type ShapeContext, type ShapeRegistry, type Shell, type ShotPersona, type ShotSpec, SpawnEvent, SpawnJournal, Spend, type SteerContext, type Strategy, type StrategyCtx, type StrategyEvolutionConfig, type StrategyResult, SupervisedResult, Supervisor, type SurfaceScore, type ToolSpec, type TrajectoryNode, type TrajectoryReport, type TrajectoryReportFn, type TrajectoryReportOptions, TreeView, type TurnResult, UsageEvent, type UsageSink, type VerifierEnvironmentOptions, type Verify, type VerifySpec, type WaterfallCollector, type WaterfallReport, type WaterfallSpan, type Widen, type WidenDecision, type WidenLineage, type WidenSpec, type Workspace, type WorkspaceCommit, acquireSandbox, adaptiveRefine, anytimeReport, assertStrategyContract, assertTraceDerivedFindings, auditIntent, authorStrategy, breadthDriver, buildSteerContext, builtinShapes, contentAddress, createBudgetPool, createExecutor, createExecutorRegistry, createMcpEnvironment, createRootHandle, createSandboxLineage, createScope, createScopeAnalyst, createShapeRegistry, createSupervisor, createVerifierEnvironment, createWaterfallCollector, defaultAnalystInstruction, defaultAuditorInstruction, definePersona, defineStrategy, depthDriver, discriminatingMeans, equalKOnCost, extractLlmCallEvent, fanout, flatWidenGate, gitWorkspace, harvestCorpus, inlineSandboxClient, jjWorkspace, localShell, loopDispatch, loopUntil, mapSandboxEvent, materializeTreeView, observe, openSandboxRun, panel, pickChampion, pipeline, printBenchmarkReport, probeSandboxCapabilities, promotionGate, refine, registerShape, renderAnytimeTable, renderCorpusToInstructions, renderReport, replaySpawnTree, reportLoopUsage, routerChatWithTools, routerChatWithUsage, routerToolLoop, runAgentic, runBenchmark, runPersonified, runStrategyEvolution, sample, sampleThenRefine, selectChampion, settledToIteration, spendFromUsageEvents, strategyAuthorContract, trajectoryReport, verify, widen };
+export { Agent, AgentRunSpec, AgentSpec, type AgenticOptions, type AgenticRunResult, type AgenticSurface, type AgenticTask, type AgenticTool, type AnytimeReport, type AnytimeStrategySummary, type AnytimeTaskCurve, type ArtifactHandle, type AssertTraceDerivedFindings, type AuditIntentInput, type AuditIntentOptions, type AuthorStrategyOptions, type AuthoredStrategy, type BenchmarkCell, type BenchmarkConfig, type BenchmarkLift, type BenchmarkReport, type BenchmarkStrategySummary, type BenchmarkTaskRow, type BridgeSeam, Budget, type BudgetPool, type BudgetReadout, type ChampionPick, type ChampionPolicy, type CheckpointCapableBox, type CliSeam, type CombinatorShape, type Corpus, type CorpusFilter, type CorpusRecord, type CreateScopeAnalystOptions, type CriuCapableClient, type DefinePersona, type DefinePersonaInput, type Deliverable, type Environment, type EqualKArm, type EqualKOnCost, type EqualKOnCostOptions, type EqualKVerdict, type EvolutionArchiveNode, type EvolutionAuthor, type EvolutionBandInfo, type EvolutionCandidate, type EvolutionGeneration, type EvolutionReport, ExecCtx, type ExecutorConfig, ExecutorFactory, ExecutorRegistry, type Fanout, type FanoutOptions, type FanoutSynthesis, FileCorpus, FileResultBlobStore, FileSpawnJournal, type FlatWidenGate, type ForkCapableBox, type GitWorkspaceOptions, type HarvestCorpusOptions, type HarvestFailure, type HarvestReport, InMemoryCorpus, InMemoryResultBlobStore, InMemorySpawnJournal, type IntentAudit, Iteration, type LoopDispatchOptions, type LoopOptionsForDispatch, LoopResult, type LoopShape, LoopTokenUsage, type LoopUntil, type LoopUntilSpec, type LoopUntilState, type McpEndpoint, type McpEnvironmentOptions, NodeId, type Observation, type ObserveInput, type ObserveOptions, type OpenSandboxRunOptions, type Outcome, type Panel, type PanelJudge, type PanelSpec, type PanelVerdict, type Persona, type PersonaContext, type PersonaExecutors, type Pipeline, type PipelineStage, type PromotionGateOptions, type PromotionVerdict, type RegistryAnalyzeProjection, type RenderCorpusToInstructions, type RenderCorpusToInstructionsOptions, type ReservationTicket, ResultBlobStore, RootHandle, type RouterSeam, type RouterToolsSeam, type RunAgenticOptions, RunLoopOptions, type RunPersonified, type RunPersonifiedOptions, type SandboxCapabilities, SandboxClient, type SandboxLineage, type SandboxLineageHandle, type SandboxRun, type SandboxSeam, Scope, type ScopeAnalyst, type ScopeAnalyzeInput, type ScopeWidenGate, type SessionCapableBox, Settled, type ShapeBudget, type ShapeContext, type ShapeRegistry, type Shell, type ShotPersona, type ShotSpec, SpawnEvent, SpawnJournal, Spend, type SteerContext, type Strategy, type StrategyCtx, type StrategyEvolutionConfig, type StrategyResult, SupervisedResult, Supervisor, type SurfaceScore, ToolSpec, type TrajectoryNode, type TrajectoryReport, type TrajectoryReportFn, type TrajectoryReportOptions, TreeView, type TurnResult, UsageEvent, type UsageSink, type VerifierEnvironmentOptions, type Verify, type VerifySpec, type WaterfallCollector, type WaterfallReport, type WaterfallSpan, type Widen, type WidenDecision, type WidenLineage, type WidenSpec, type Workspace, type WorkspaceCommit, acquireSandbox, adaptiveRefine, anytimeReport, assertStrategyContract, assertTraceDerivedFindings, auditIntent, authorStrategy, breadthDriver, buildSteerContext, builtinShapes, contentAddress, createBudgetPool, createExecutor, createExecutorRegistry, createMcpEnvironment, createRootHandle, createSandboxLineage, createScope, createScopeAnalyst, createShapeRegistry, createSupervisor, createVerifierEnvironment, createWaterfallCollector, defaultAnalystInstruction, defaultAuditorInstruction, definePersona, defineStrategy, depthDriver, discriminatingMeans, equalKOnCost, extractLlmCallEvent, fanout, flatWidenGate, gitWorkspace, harvestCorpus, inlineSandboxClient, jjWorkspace, localShell, loopDispatch, loopUntil, mapSandboxEvent, materializeTreeView, observe, openSandboxRun, panel, pickChampion, pipeline, printBenchmarkReport, probeSandboxCapabilities, promotionGate, refine, registerShape, registryScopeAnalyst, renderAnytimeTable, renderCorpusToInstructions, renderReport, replaySpawnTree, reportLoopUsage, runAgentic, runBenchmark, runPersonified, runStrategyEvolution, sample, sampleThenRefine, selectChampion, settledToIteration, spendFromUsageEvents, strategyAuthorContract, trajectoryReport, verify, widen };

package/dist/runtime.js

@@ -60,6 +60,7 @@ import {
   promotionGate,
   refine,
   registerShape,
+  registryScopeAnalyst,
   renderAnalyses,
   renderAnytimeTable,
   renderCorpusToInstructions,
@@ -85,7 +86,7 @@ import {
   trajectoryReport,
   verify,
   widen
-} from "./chunk-FQH33M5N.js";
+} from "./chunk-K6WP7PYW.js";
 import {
   extractLlmCallEvent,
   mapSandboxEvent
@@ -155,6 +156,7 @@ export {
   promotionGate,
   refine,
   registerShape,
+  registryScopeAnalyst,
   renderAnalyses,
   renderAnytimeTable,
   renderCorpusToInstructions,

package/dist/{types-5MGt5KTY.d.ts → types-CNDJCL_0.d.ts}

@@ -1,7 +1,7 @@
 import { DefaultVerdict } from '@tangle-network/agent-eval';
 import { AgentProfile, BackendType } from '@tangle-network/sandbox';
 import { R as RuntimeHooks } from './runtime-hooks-C7JwKb9E.js';
-import { d as LoopTokenUsage } from './types-BEQsBhOE.js';
+import { d as LoopTokenUsage } from './types-CklkW4Eh.js';
 
 /**
  * @experimental

package/dist/{types-BEQsBhOE.d.ts → types-CklkW4Eh.d.ts}

@@ -319,6 +319,7 @@ type RuntimeStreamEvent = {
     proposalId: string;
     title: string;
     status?: 'pending' | 'approved' | 'rejected';
+    content?: string;
     timestamp?: string;
 } | {
     type: 'backend_error';
@@ -1096,4 +1097,4 @@ interface ExecCtx {
     parentSpanId?: string;
 }
 
-export { type AgentRunSpec as A, type BackendErrorDetail as B, startRuntimeRun as C, type Driver as D, type ExecCtx as E, type LoopDecisionPayload as F, type LoopEndedPayload as G, type LoopIterationDispatchPayload as H, type Iteration as I, type LoopIterationEndedPayload as J, type KnowledgeReadinessDecision as K, type LoopWinner as L, type LoopIterationStartedPayload as M, type LoopPlanDescription as N, type OutputAdapter as O, type LoopPlanPayload as P, type LoopStartedPayload as Q, type RuntimeStreamEvent as R, type SandboxClient as S, type LoopTeardownFailedPayload as T, type ValidationCtx as U, type Validator as V, type LoopLineageOptions as a, type LoopResult as b, type OpenAIChatTool as c, type LoopTokenUsage as d, type LoopSandboxPlacement as e, type LoopTraceEmitter as f, type LoopTraceEvent as g, type AgentBackendInput as h, type AgentExecutionBackend as i, type OpenAIChatToolChoice as j, type AgentBackendContext as k, type RunAgentTaskOptions as l, type AgentTaskRunResult as m, type RunAgentTaskStreamOptions as n, type AgentRuntimeEvent as o, type AgentTaskStatus as p, type RuntimeSessionStore as q, type RuntimeSession as r, type AgentAdapter as s, type AgentKnowledgeProvider as t, type AgentRuntimeEventSink as u, type AgentTaskContext as v, type AgentTaskSpec as w, type RuntimeRunHandle as x, type RuntimeRunPersistenceAdapter as y, type RuntimeRunRow as z };
+export { type AgentRunSpec as A, type BackendErrorDetail as B, startRuntimeRun as C, type Driver as D, type ExecCtx as E, type LoopDecisionPayload as F, type LoopEndedPayload as G, type LoopIterationDispatchPayload as H, type Iteration as I, type LoopIterationEndedPayload as J, type KnowledgeReadinessDecision as K, type LoopWinner as L, type LoopIterationStartedPayload as M, type LoopPlanDescription as N, type OutputAdapter as O, type LoopPlanPayload as P, type LoopStartedPayload as Q, type RuntimeStreamEvent as R, type SandboxClient as S, type LoopTeardownFailedPayload as T, type ValidationCtx as U, type Validator as V, type LoopLineageOptions as a, type LoopResult as b, type OpenAIChatTool as c, type LoopTokenUsage as d, type LoopTraceEvent as e, type LoopSandboxPlacement as f, type LoopTraceEmitter as g, type AgentBackendInput as h, type AgentExecutionBackend as i, type OpenAIChatToolChoice as j, type AgentBackendContext as k, type RunAgentTaskOptions as l, type AgentTaskRunResult as m, type RunAgentTaskStreamOptions as n, type AgentRuntimeEvent as o, type AgentTaskStatus as p, type RuntimeSessionStore as q, type RuntimeSession as r, type AgentAdapter as s, type AgentKnowledgeProvider as t, type AgentRuntimeEventSink as u, type AgentTaskContext as v, type AgentTaskSpec as w, type RuntimeRunHandle as x, type RuntimeRunPersistenceAdapter as y, type RuntimeRunRow as z };

package/dist/workflow.d.ts

@@ -1,6 +1,6 @@
 import { AgentProfile, CreateSandboxOptions, PromptOptions, TaskOptions, SandboxEvent } from '@tangle-network/sandbox';
-import { S as SandboxClient, O as OutputAdapter, e as LoopSandboxPlacement, b as LoopResult } from './types-BEQsBhOE.js';
-import { R as RunLoopOptions } from './run-loop-BIineL1T.js';
+import { S as SandboxClient, O as OutputAdapter, f as LoopSandboxPlacement, b as LoopResult } from './types-CklkW4Eh.js';
+import { R as RunLoopOptions } from './run-loop-DgVhucoR.js';
 import '@tangle-network/agent-eval';
 import './runtime-hooks-C7JwKb9E.js';
 

package/dist/workflow.js

@@ -2,7 +2,7 @@ import {
   createSandboxForSpec,
   describeSandboxPlacement,
   runLoop
-} from "./chunk-FQH33M5N.js";
+} from "./chunk-K6WP7PYW.js";
 import {
   ValidationError,
   extractLlmCallEvent

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-runtime",
-  "version": "0.51.0",
+  "version": "0.53.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": {