@tangle-network/agent-runtime 0.70.1 → 0.71.1

package/dist/intelligence.js

@@ -2,7 +2,7 @@ import {
   buildLoopOtelSpans,
   createOtelExporter,
   loopEventToOtelSpan
-} from "./chunk-G3RGMA7C.js";
+} from "./chunk-VMNEQHJR.js";
 import "./chunk-DGUM43GV.js";
 
 // src/intelligence/effort.ts

package/dist/{loop-runner-bin-a8bu4O5-.d.ts → loop-runner-bin-DLM_bVQO.d.ts}

@@ -1,10 +1,10 @@
 import { Scenario } from '@tangle-network/agent-eval/campaign';
 import { SelfImproveOptions, SelfImproveResult } from '@tangle-network/agent-eval/contract';
 import { R as RunAnalystLoopOpts, a as RunAnalystLoopResult } from './types-BC3bZpH0.js';
-import { D as DelegateCodeArgs, C as CoderReviewer, a as DetachedWinnerSelection, B as Budget, b as CoderOutput } from './delegates-DqAgo32T.js';
+import { D as DelegateCodeArgs, C as CoderReviewer, a as DetachedWinnerSelection, B as Budget, b as CoderOutput } from './delegates-CsXJPZDH.js';
 import { F as FactCandidate, C as CreateKbGateOptions } from './kb-gate-CuzMYGYM.js';
-import { S as SandboxClient } from './types-BYa2ZOAx.js';
-import { A as AuthoredHarness, W as WinnerStrategy, a as WorktreeFanoutOptions, b as WorktreePatchArtifact } from './worktree-fanout-gNfl0Byj.js';
+import { S as SandboxClient } from './types-CdnEAE3U.js';
+import { A as AuthoredHarness, W as WinnerStrategy, a as WorktreeFanoutOptions, b as WorktreePatchArtifact } from './worktree-fanout-CK2ypmEm.js';
 
 /**
  * @experimental

package/dist/loop-runner-bin.d.ts

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
-export { L as LoopRunnerCliArgs, e as LoopRunnerCliResult, p as parseLoopRunnerArgv, l as runLoopRunnerCli } from './loop-runner-bin-a8bu4O5-.js';
+export { L as LoopRunnerCliArgs, e as LoopRunnerCliResult, p as parseLoopRunnerArgv, l as runLoopRunnerCli } from './loop-runner-bin-DLM_bVQO.js';
 import '@tangle-network/agent-eval/campaign';
 import '@tangle-network/agent-eval/contract';
 import './types-BC3bZpH0.js';
 import '@tangle-network/agent-eval';
-import './delegates-DqAgo32T.js';
+import './delegates-CsXJPZDH.js';
 import 'node:child_process';
 import '@tangle-network/agent-interface';
 import '@tangle-network/sandbox';
-import './types-BYa2ZOAx.js';
+import './types-CdnEAE3U.js';
 import './substrate-BoRXgvka.js';
 import './kb-gate-CuzMYGYM.js';
-import './worktree-fanout-gNfl0Byj.js';
+import './worktree-fanout-CK2ypmEm.js';

package/dist/loop-runner-bin.js

@@ -2,12 +2,12 @@
 import {
   parseLoopRunnerArgv,
   runLoopRunnerCli
-} from "./chunk-BGOLR66M.js";
+} from "./chunk-K3RM4MPM.js";
 import "./chunk-P5OKDSLB.js";
 import "./chunk-FNMGYYSS.js";
-import "./chunk-HY4YOQM2.js";
-import "./chunk-YFOPWG74.js";
-import "./chunk-G3RGMA7C.js";
+import "./chunk-INXDNX2W.js";
+import "./chunk-5ISW5JUF.js";
+import "./chunk-VMNEQHJR.js";
 import "./chunk-VLF5RHEQ.js";
 import "./chunk-DVQGYDN5.js";
 import "./chunk-WIR4HOOJ.js";

package/dist/loops.d.ts

@@ -1,20 +1,20 @@
 import { ChatClient, AnalystFinding, AgentProfile, AnalystRunInputs, ToolSpan, StreamingDetector, DetectorSignal, buildTrajectory } from '@tangle-network/agent-eval';
 export { AnalystFinding, DefaultVerdict, computeFindingId, makeFinding } from '@tangle-network/agent-eval';
-import { SandboxInstance, CreateSandboxOptions, SandboxEvent, BackendType } from '@tangle-network/sandbox';
+import { SandboxInstance, CreateSandboxOptions, SandboxEvent } from '@tangle-network/sandbox';
 export { AgentProfile, CreateSandboxOptions, SandboxEvent, SandboxInstance } from '@tangle-network/sandbox';
-import { g as ResultBlobStore, i as SpawnJournal, N as NodeId, bb as SpawnEvent, bc as ExecutorFactory, A as Agent, B as Budget, S as Scope, l as Settled, k as SupervisedResult, m as Spend, bd as UsageEvent, E as ExecutorRegistry, L as LocalHarness, be as Supervisor } from './delegates-DqAgo32T.js';
-export { h as AgentSpec, n as Executor, bf as ExecutorContext, bg as ExecutorResult, bh as SupervisorOpts, bi as TreeView, bj as WidenGate } from './delegates-DqAgo32T.js';
-import { M as MakeWorkerAgent, a as CoordinationTools, A as AnalystRegistry, C as CoordinationEvent, j as QuestionPolicy } from './coordination-C7WxwHXq.js';
-export { B as BusEvent, p as BusRecord, q as BusStats, E as EventBus, P as PublishOptions, r as createEventBus } from './coordination-C7WxwHXq.js';
-import { b as RuntimeHooks, I as Iteration, S as SandboxClient, T as Driver, A as AgentRunSpec, a as OutputAdapter, V as Validator, U as ExecCtx, W as LoopWinner, X as LoopLineageOptions, Y as LoopResult, d as LoopTokenUsage, R as RuntimeStreamEvent } from './types-BYa2ZOAx.js';
-export { Z as LoopDecisionPayload, _ as LoopEndedPayload, $ as LoopIterationDispatchPayload, a0 as LoopIterationEndedPayload, a1 as LoopIterationStartedPayload, a2 as LoopPlanDescription, a3 as LoopPlanPayload, c as LoopSandboxPlacement, a4 as LoopStartedPayload, a5 as LoopTeardownFailedPayload, e as LoopTraceEmitter, L as LoopTraceEvent, a6 as ValidationCtx } from './types-BYa2ZOAx.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, t as DeliverableSpec } from './worktree-fanout-gNfl0Byj.js';
-export { A as AuthoredHarness, u as DefinePersona, v as EqualKOnCost, w as Fanout, x as FanoutSynthesis, y as FlatWidenGate, z as LoopUntil, B as LoopUntilState, G as Panel, H as PanelJudge, I as PanelVerdict, J as PatchDeliverableOptions, K as PersonaContext, M as PersonaExecutors, N as Pipeline, Q as RenderCorpusToInstructions, U as RunPersonified, X as ShapeBudget, Y as ShapeContext, Z as TrajectoryNode, _ as TrajectoryReportFn, $ as Verify, a0 as Widen, a1 as WidenDecision, a2 as WidenLineage, a3 as WorktreeCliExecutorOptions, a4 as WorktreeCommandResult, a as WorktreeFanoutOptions, b as WorktreePatchArtifact, a5 as createWorktreeCliExecutor, a6 as gateOnDeliverable, a7 as patchDelivered, a8 as worktreeFanout } from './worktree-fanout-gNfl0Byj.js';
+import { j as ResultBlobStore, l as SpawnJournal, N as NodeId, bd as SpawnEvent, E as ExecutorFactory, A as Agent, B as Budget, i as Scope, o as Settled, n as SupervisedResult, f as DeliverableSpec, S as Spend, be as UsageEvent, e as ExecutorRegistry, bf as Supervisor } from './delegates-CsXJPZDH.js';
+export { k as AgentSpec, p as Executor, bg as ExecutorContext, bh as ExecutorResult, bi as SupervisorOpts, bj as TreeView, bk as WidenGate, bl as gateOnDeliverable } from './delegates-CsXJPZDH.js';
+import { M as MakeWorkerAgent, a as CoordinationTools, A as AnalystRegistry, C as CoordinationEvent, o as QuestionPolicy, E as ExecutorConfig } from './coordination-BPQmuwv8.js';
+export { B as BusEvent, w as BusRecord, x as BusStats, y as EventBus, P as PublishOptions, z as cliWorktreeExecutor, G as createEventBus, H as createExecutor, K as createExecutorRegistry } from './coordination-BPQmuwv8.js';
+import { b as RuntimeHooks, I as Iteration, S as SandboxClient, U as Driver, A as AgentRunSpec, a as OutputAdapter, V as Validator, E as ExecCtx, W as LoopWinner, X as LoopLineageOptions, Y as LoopResult, d as LoopTokenUsage, R as RuntimeStreamEvent } from './types-CdnEAE3U.js';
+export { Z as LoopDecisionPayload, _ as LoopEndedPayload, $ as LoopIterationDispatchPayload, a0 as LoopIterationEndedPayload, a1 as LoopIterationStartedPayload, a2 as LoopPlanDescription, a3 as LoopPlanPayload, c as LoopSandboxPlacement, a4 as LoopStartedPayload, a5 as LoopTeardownFailedPayload, e as LoopTraceEmitter, L as LoopTraceEvent, a6 as ValidationCtx } from './types-CdnEAE3U.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-CK2ypmEm.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, a3 as WorktreeCommandResult, a as WorktreeFanoutOptions, b as WorktreePatchArtifact, a4 as createWorktreeCliExecutor, a5 as patchDelivered, a6 as worktreeFanout } from './worktree-fanout-CK2ypmEm.js';
 import { Scenario, 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, T as ToolSpec } from './router-client-C7kp_ECN.js';
-export { b as RouterChatResult, c as RouterChatToolsResult, d as RouterToolCall, e as RouterToolLoopResult, r as routerBrain, f as routerChatWithTools, g as routerChatWithUsage, h as routerToolLoop } from './router-client-C7kp_ECN.js';
+import { R as RouterConfig, a as ToolLoopChat } from './router-client-C7kp_ECN.js';
+export { b as RouterChatResult, c as RouterChatToolsResult, d as RouterToolCall, e as RouterToolLoopResult, T as ToolSpec, r as routerBrain, f as routerChatWithTools, g as routerChatWithUsage, h as routerToolLoop } from './router-client-C7kp_ECN.js';
 import { stuckLoopView, toolWasteView } from '@tangle-network/agent-eval/pipelines';
 import 'node:child_process';
 import './substrate-BoRXgvka.js';
@@ -2448,6 +2448,114 @@ declare function serveCoordinationMcp(opts: {
     questionPolicy?: QuestionPolicy;
 }): Promise<CoordinationMcpHandle>;
 
+/** The supervisor's profile — the subset of an `AgentProfile` that selects + shapes its brain.
+ *  `harness` is the backend-as-data discriminant; `systemPrompt` is the standing instruction. */
+interface SupervisorProfile {
+    readonly name?: string;
+    /** null/undefined → router brain (in-process tool-loop); a coding-CLI harness → sandboxed brain. */
+    readonly harness?: string | null;
+    /** The router model when the brain is router-driven (falls back to the deps router config). */
+    readonly model?: string;
+    /** The standing instructions ("you delegate, you do not solve"). */
+    readonly systemPrompt?: string;
+}
+/** How to run a sandboxed harness as the DRIVER, with the coordination verbs mounted — the substrate
+ *  seam the caller supplies (mirrors `makeWorkerAgent` for spawned children). It runs `profile` on
+ *  `task` in its backend (sandbox / cli-bridge) with `coordinationMcpUrl` mounted as an MCP server,
+ *  so the harness calls spawn_agent / await_event / stop as native tools over the live scope. */
+type DriveHarness = (args: {
+    readonly profile: SupervisorProfile;
+    readonly task: unknown;
+    readonly scope: Scope<unknown>;
+    readonly coordinationMcpUrl: string;
+}) => Promise<void>;
+interface SupervisorAgentDeps {
+    readonly blobs: ResultBlobStore;
+    /** Resolve a spawned worker `profile` to a leaf agent — the recursion seam (same for both arms). */
+    readonly makeWorkerAgent: MakeWorkerAgent;
+    /** Per-child budget reserved from the conserved pool on each spawn. */
+    readonly perWorker: Budget;
+    /** Router substrate for a router-brained supervisor (`harness` null). The profile's model wins. */
+    readonly router?: RouterConfig;
+    /** Inject the brain directly (tests / advanced) instead of resolving `routerBrain` from the profile. */
+    readonly brain?: ToolLoopChat;
+    /** Required for a sandboxed-harness supervisor (`harness` set): runs the harness as the driver. */
+    readonly driveHarness?: DriveHarness;
+    /** WORK tools the supervisor may call DIRECTLY (router arm) — so it can do simple work ITSELF and
+     *  only delegate when it needs parallelism. Pair with `executeExtraTool`. */
+    readonly extraTools?: ReadonlyArray<{
+        readonly name: string;
+        readonly description?: string;
+        readonly parameters: Record<string, unknown>;
+    }>;
+    /** Runs an `extraTools` call; null/undefined falls through to the coordination dispatch. */
+    readonly executeExtraTool?: (name: string, args: Record<string, unknown>) => Promise<string | null | undefined>;
+    readonly maxTurns?: number;
+}
+declare function supervisorAgent(profile: SupervisorProfile, deps: SupervisorAgentDeps): Agent<unknown, unknown>;
+
+/**
+ * @experimental
+ *
+ * `delegate` — the one generic delegation verb. You hand it an INTENT (what you want done) and it
+ * hands that intent to a default AUTHORING supervisor: a router-brained supervisor whose standing
+ * instruction is `supervisorInstructions()` (the authoring-agent-profiles skill). The supervisor
+ * DECOMPOSES the intent and AUTHORS the worker profile it needs per sub-task — there is NO hardcoded
+ * coder/researcher profile here. That is the whole point: `delegate('fix the failing test', …)` and
+ * `delegate('research X and cite sources', …)` route through the SAME front door; the supervisor
+ * writes a code-shaped or research-shaped worker on its own.
+ *
+ * It is a thin wrapper over `supervise()` — the one front door — so the conserved-budget pool, the
+ * completion oracle (`deliverable`), the coordination toolbox, and equal-compute accounting all come
+ * for free; nothing is hand-rolled. The result is `supervise()`'s `SupervisedResult` returned
+ * UNCHANGED, so its `spentTotal` (`{ iterations, tokens, usd, ms }`) rides straight back to the
+ * caller on BOTH paths — a `winner` carries the delivered worker's spend, a `no-winner` carries the
+ * spend incurred before it failed. That cost channel is exactly what `delegate_code` lacks — a
+ * `delegate()` caller always learns what the delegation actually spent.
+ */
+
+/** The conserved pool a `delegate()` call applies when the caller does not pass its own `budget`.
+ *  A modest token ceiling + a small iteration ceiling — generous enough for a few-worker decompose,
+ *  bounded enough that an unsupervised intent cannot run away. Callers override via `opts.budget`. */
+declare const defaultDelegateBudget: Budget;
+/** Inputs to {@link delegate}. The intent is the first positional arg; everything here is optional
+ *  with sensible defaults, so the common call is `delegate(intent, { backend, router })`. */
+interface DelegateOptions<Out = unknown> {
+    /** The completion oracle (settled ⟺ delivered) the authored workers settle against. Strongly
+     *  recommended — without it the supervisor trusts a worker's self-report. For a code intent,
+     *  `patchDelivered()` is the canonical example; for a free-form answer, a content check. */
+    readonly deliverable?: DeliverableSpec<Out>;
+    /** WHERE the authored workers run — the worker-execution backend (`router-tools` / `sandbox` /
+     *  `cli-worktree` / …). The supervisor authors the worker PROFILE; this is the substrate it runs
+     *  on. Provide this OR `makeWorkerAgent`-style wiring through `supervise()` is unavailable. */
+    readonly backend?: ExecutorConfig;
+    /** The conserved compute pool for the whole delegation. Defaults to {@link defaultDelegateBudget}. */
+    readonly budget?: Budget;
+    /** The model the supervisor BRAIN runs on (the router model). The brain must tool-call
+     *  (`spawn_agent` / `await_event`), so a delegator model, not a hidden-reasoning model. */
+    readonly model?: string;
+    /** The supervisor brain's router substrate. REQUIRED for the default router-brained supervisor
+     *  (the brain is resolved from this), unless a test injects `brain` directly. `model` overrides
+     *  `router.model`. (Design delta vs the bare `supervise()` profile: the brain needs a router.) */
+    readonly router?: RouterConfig;
+    /** Inject the supervisor brain directly (tests / advanced) instead of resolving it from `router`. */
+    readonly brain?: ToolLoopChat;
+    /** Override the default authoring-supervisor profile (name / extra system-prompt stance). The
+     *  default already carries the authoring skill; override only to add a goal or rename. */
+    readonly supervisor?: Partial<Pick<SupervisorProfile, 'name' | 'systemPrompt'>>;
+    /** Restrict the run to this subset of models (forwarded to `supervise()`). */
+    readonly allowedModels?: readonly string[];
+    readonly runId?: string;
+}
+/**
+ * Delegate an INTENT to a default authoring supervisor and return its `SupervisedResult` unchanged.
+ *
+ * The supervisor authors + spawns whatever worker the intent needs over the conserved-budget pool;
+ * `result.spentTotal` reports what the whole delegation actually cost. A `winner` result carries the
+ * authored worker's delivered output; a `no-winner` result names why (never a fabricated success).
+ */
+declare function delegate<Out = unknown>(intent: string, opts?: DelegateOptions<Out>): Promise<SupervisedResult<Out>>;
+
 /**
  * @experimental
  *
@@ -2647,189 +2755,6 @@ interface InMemoryRunContext {
  */
 declare function createInMemoryRunContext(opts?: InMemoryRunContextOptions): InMemoryRunContext;
 
-/**
- * @experimental
- *
- * The leaf runtime — the built-in `Executor` IMPLEMENTATIONS behind the ONE
- * open interface frozen in `./types`, plus the open resolver/registry that maps
- * an `AgentSpec` to one of them OR accepts a bring-your-own executor verbatim.
- *
- * 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
- *                     leaf and surfaces its token/cost usage as `UsageEvent`s;
- *                     forwards PR #150's optional `lineage` passthrough WITHOUT
- *                     reinventing checkpoint/fork (streaming).
- *   - cli           : a Halo/RLM subprocess; `budgetExempt` (no token accounting),
- *                     excluded from the equal-k arms by construction (streaming).
- * Every metered runtime reports through the SAME normalized `UsageEvent` channel
- * so the conserved budget pool meters them identically. A user's own agent is
- * first-class the moment it implements `Executor` — register it by name or
- * pass it as `AgentSpec.executor`.
- *
- * Layering: `estimateCost`/`isModelPriced` are substrate primitives from
- * `@tangle-network/agent-eval`; `runLoop`/`acquireSandbox` are runtime kernels
- * from this package. No per-vendor adapters live here.
- */
-
-/**
- * Router/inline connection seam. A direct OpenAI-compatible Router endpoint —
- * the cheapest leaf, no box, no tools. `model` overrides the profile's model
- * hint when present; otherwise the profile's `model.default` is required.
- */
-interface RouterSeam {
-    routerBaseUrl: string;
-    routerKey: string;
-    model?: string;
-}
-/**
- * Sandbox executor seam. The `sandboxClient` the composed `runLoop` creates
- * boxes through, plus the optional trace/run/lineage wiring forwarded into the
- * loop. `lineage` is opaque here (PR #150's `RunLoopOptions.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.). */
-    loopCtx?: Partial<Omit<ExecCtx, 'sandboxClient' | 'signal'>>;
-    /** PR #150 `RunLoopOptions.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;
-}
-/** CLI subprocess seam. `bin` + `args` describe the Halo/RLM process to spawn. */
-interface CliSeam {
-    bin: string;
-    args?: string[];
-    /** Extra environment for the subprocess (merged over `process.env`). */
-    env?: Record<string, string>;
-    /** Working directory for the subprocess. */
-    cwd?: string;
-}
-/**
- * cli-worktree seam. A supervisor-authored `AgentProfile` driving a local coding-harness CLI
- * (claude / codex / opencode) on its own git worktree — the leaf `createWorktreeCliExecutor`
- * named as data. `harness` + `repoRoot` + `taskPrompt` are required; the authored
- * `profile.prompt.systemPrompt` + `profile.model.default` reach the harness via the §1.5
- * `harnessInvocation` mapper. Everything else mirrors `WorktreeCliExecutorOptions`.
- */
-interface CliWorktreeSeam {
-    repoRoot: string;
-    harness: LocalHarness;
-    taskPrompt: string;
-    runId?: string;
-    baseRef?: string;
-    harnessTimeoutMs?: number;
-}
-/**
- * cli-bridge seam. A local OpenAI-compatible bridge that fronts harness CLIs
- * (claude-code / opencode / kimi / pi) behind one HTTP surface; `model` doubles
- * as the harness selector (e.g. `claude-code/sonnet`, `opencode/<provider>/<model>`).
- * `agentProfile` is the bridge-dialect profile (metadata.disallowedTools, mcp)
- * forwarded verbatim per request — how an arm disables native tools or injects
- * a provider search MCP.
- *
- * The executor opens a RESUMABLE cli-bridge session — structurally identical to the
- * sandbox executor's persistent box, just local. `sessionId` is the stable
- * caller-owned id cli-bridge maps to the harness's internal conversation id; a
- * follow-up steer/resume on the SAME id continues the SAME harness session (opencode
- * `-s`, claude `--resume`, …). Omit it and the executor mints a stable one per spawn.
- */
-interface BridgeSeam {
-    bridgeUrl: string;
-    bridgeBearer: string;
-    model: string;
-    agentProfile?: Record<string, unknown>;
-    timeoutMs?: number;
-    /** Stable, caller-owned cli-bridge session id for harness-side resume. Defaults
-     *  to a freshly minted per-spawn id so each worker is its own resumable session. */
-    sessionId?: string;
-    /** Per-resume-turn inference cap before the worker settles on its last output.
-     *  Mirrors `routerToolsInlineExecutor.maxTurns`; default 200 (runaway backstop). */
-    maxTurns?: number;
-}
-/**
- * Router seam WITH tool use — the tool-using router backend. Same direct
- * OpenAI-compatible endpoint as `RouterSeam`, but each turn passes `tools`; when
- * the model emits tool_calls they run via `executeToolCall` ON THIS HOST and the
- * results fold back as `tool` messages, repeating until the model answers without
- * a tool or `maxTurns` is hit. A real agentic loop, OFF-BOX — no sandbox, so it
- * is unaffected by a box's egress allowlist. One turn = one completion = the
- * equal-compute unit. `executeToolCall` receives the task so per-task tool
- * surfaces (e.g. a gym keyed by task) can dispatch correctly.
- */
-interface RouterToolsSeam {
-    routerBaseUrl: string;
-    routerKey: string;
-    model?: string;
-    tools: ReadonlyArray<ToolSpec>;
-    executeToolCall: (name: string, args: Record<string, unknown>, task: unknown) => Promise<string>;
-    /** Online observer of each tool step — the seam a `DetectorMonitor` taps to watch the live pipe
-     *  (raise a `finding` when the worker loops/errors). Called after every tool call resolves, with
-     *  real per-call wall-clock (`startedAt`/`endedAt`/`durationMs`) so a push `TraceSource` can carry
-     *  non-zero span durations onto the unified timeline. */
-    onToolStep?: (step: {
-        toolName: string;
-        args: Record<string, unknown>;
-        status: 'ok' | 'error';
-        startedAt?: number;
-        endedAt?: number;
-        durationMs?: number;
-    }) => void;
-    /** Max inference turns. Default 200 (runaway backstop — set far above any
-     *  legitimate workflow). For tighter per-workflow limits use a cost budget
-     *  or wall-clock deadline at the call site. */
-    maxTurns?: number;
-}
-/**
- * The leaf `createWorktreeCliExecutor` as a backend-as-data factory: a supervisor-authored
- * `AgentProfile` driving claude / codex / opencode on its own worktree. `budgetExempt` like
- * the other CLI leaves; the authored systemPrompt + model reach the harness via §1.5.
- */
-declare const cliWorktreeExecutor: ExecutorFactory<unknown>;
-/**
- * Config for {@link createExecutor}: the backend is DATA — the cost dial a profile,
- * an experiment config, or a replay journal can name — not an import choice. Each
- * variant carries its backend's seam (router/router-tools/bridge/cli/cli-worktree/sandbox).
- */
-type ExecutorConfig = ({
-    backend: 'router';
-} & RouterSeam) | ({
-    backend: 'router-tools';
-} & RouterToolsSeam) | ({
-    backend: 'bridge';
-} & BridgeSeam) | ({
-    backend: 'cli';
-} & CliSeam) | ({
-    backend: 'cli-worktree';
-} & CliWorktreeSeam) | ({
-    backend: 'sandbox';
-    harness?: BackendType;
-} & SandboxSeam);
-/**
- * The single built-in executor factory. Picks a leaf backend by data (`config.backend`),
- * injects the matching seam, and delegates to that backend's built-in implementation.
- * The `Executor` port stays OPEN: bring-your-own agents implement `Executor` directly
- * and never pass through here. Use this (or `createExecutorRegistry`) instead of a
- * per-vendor adapter or a closed `inline|sandbox|cli` switch — those bypass the
- * `UsageEvent` reporting channel.
- */
-declare function createExecutor(config: ExecutorConfig): ExecutorFactory<unknown>;
-/**
- * The open resolver/registry. Pre-registers the three built-ins under their
- * runtime tags (`'router'`, `'sandbox'`, `'cli'`) and accepts `register(name,
- * factory)` for any additional runtime — and a BYO `AgentSpec.executor` resolves
- * without touching the registry at all. NOT a closed switch; registration + BYO
- * ARE the extension points.
- *
- * `resolve` precedence (frozen in `ExecutorRegistry`): a BYO `spec.executor` →
- * `harness === null` → the `'router'` factory; else a registered factory for the
- * harness-derived runtime (`'sandbox'` for any `BackendType`); else fail loud.
- */
-declare function createExecutorRegistry(): ExecutorRegistry;
-
 /**
  * @experimental
  *
@@ -2901,52 +2826,6 @@ declare function createScope<Out>(args: ScopeArgs): Scope<Out>;
  */
 declare function settledToIteration<Out>(settled: Settled<Out>): Iteration<unknown, Out>;
 
-/** The supervisor's profile — the subset of an `AgentProfile` that selects + shapes its brain.
- *  `harness` is the backend-as-data discriminant; `systemPrompt` is the standing instruction. */
-interface SupervisorProfile {
-    readonly name?: string;
-    /** null/undefined → router brain (in-process tool-loop); a coding-CLI harness → sandboxed brain. */
-    readonly harness?: string | null;
-    /** The router model when the brain is router-driven (falls back to the deps router config). */
-    readonly model?: string;
-    /** The standing instructions ("you delegate, you do not solve"). */
-    readonly systemPrompt?: string;
-}
-/** How to run a sandboxed harness as the DRIVER, with the coordination verbs mounted — the substrate
- *  seam the caller supplies (mirrors `makeWorkerAgent` for spawned children). It runs `profile` on
- *  `task` in its backend (sandbox / cli-bridge) with `coordinationMcpUrl` mounted as an MCP server,
- *  so the harness calls spawn_agent / await_event / stop as native tools over the live scope. */
-type DriveHarness = (args: {
-    readonly profile: SupervisorProfile;
-    readonly task: unknown;
-    readonly scope: Scope<unknown>;
-    readonly coordinationMcpUrl: string;
-}) => Promise<void>;
-interface SupervisorAgentDeps {
-    readonly blobs: ResultBlobStore;
-    /** Resolve a spawned worker `profile` to a leaf agent — the recursion seam (same for both arms). */
-    readonly makeWorkerAgent: MakeWorkerAgent;
-    /** Per-child budget reserved from the conserved pool on each spawn. */
-    readonly perWorker: Budget;
-    /** Router substrate for a router-brained supervisor (`harness` null). The profile's model wins. */
-    readonly router?: RouterConfig;
-    /** Inject the brain directly (tests / advanced) instead of resolving `routerBrain` from the profile. */
-    readonly brain?: ToolLoopChat;
-    /** Required for a sandboxed-harness supervisor (`harness` set): runs the harness as the driver. */
-    readonly driveHarness?: DriveHarness;
-    /** WORK tools the supervisor may call DIRECTLY (router arm) — so it can do simple work ITSELF and
-     *  only delegate when it needs parallelism. Pair with `executeExtraTool`. */
-    readonly extraTools?: ReadonlyArray<{
-        readonly name: string;
-        readonly description?: string;
-        readonly parameters: Record<string, unknown>;
-    }>;
-    /** Runs an `extraTools` call; null/undefined falls through to the coordination dispatch. */
-    readonly executeExtraTool?: (name: string, args: Record<string, unknown>) => Promise<string | null | undefined>;
-    readonly maxTurns?: number;
-}
-declare function supervisorAgent(profile: SupervisorProfile, deps: SupervisorAgentDeps): Agent<unknown, unknown>;
-
 /** Build the worker seam from a backend (WHERE workers run) + an optional completion oracle (the
  *  deliverable check that makes "settled ⟺ delivered" true — the guard against "ran but didn't
  *  deliver"). The ONE place a backend becomes a spawnable worker. */
@@ -3148,4 +3027,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, type AnytimeReport, type AnytimeStrategySummary, type AnytimeTaskCurve, 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 Deliverable, DeliverableSpec, type DriveHarness, Driver, type DriverAgentOptions, type Environment, EqualKArm, EqualKOnCostOptions, EqualKVerdict, type EvolutionArchiveNode, type EvolutionAuthor, type EvolutionBandInfo, type EvolutionCandidate, type EvolutionGeneration, type EvolutionReport, ExecCtx, type ExecutorConfig, FanoutOptions, FanoutWinnerSelector, FileCorpus, type ForkCapableBox, type GitWorkspaceOptions, type HarvestCorpusOptions, type HarvestFailure, type HarvestReport, InMemoryCorpus, InMemoryResultBlobStore, type InMemoryRunContext, type InMemoryRunContextOptions, InMemorySpawnJournal, type Inbox, type InboxMessage, type IntentAudit, Iteration, type LoopDispatchOptions, LoopLineageOptions, type LoopOptionsForDispatch, LoopResult, LoopShape, LoopTokenUsage, LoopUntilSpec, LoopWinner, type McpEndpoint, type McpEnvironmentOptions, type Observation, type ObserveInput, type ObserveOptions, type OpenSandboxRunOptions, Outcome, OutputAdapter, PanelSpec, Persona, PipelineStage, type ProfileRichness, type ProfileRichnessThresholds, type PromotionGateOptions, type PromotionVerdict, type RegistryAnalyzeProjection, RenderCorpusToInstructionsOptions, type ReservationTicket, ResultBlobStore, RouterConfig, type RunAgenticOptions, RunPersonifiedOptions, type SandboxCapabilities, SandboxClient, type SandboxLineage, type SandboxLineageHandle, type SandboxRun, Scope, ScopeAnalyst, ScopeAnalyzeInput, ScopeWidenGate, type SessionCapableBox, type SessionTraceBox, Settled, ShapeRegistry, type Shell, type ShotPersona, type ShotSpec, Spend, SteerContext, type Strategy, type StrategyCtx, type StrategyEvolutionConfig, type StrategyResult, type SuperviseOptions, SupervisedResult, Supervisor, type SupervisorAgentDeps, type SupervisorProfile, type SurfaceScore, ToolLoopChat, ToolSpec, 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, cliWorktreeExecutor, completionAuthorizes, contentAddress, createBudgetPool, createExecutor, createExecutorRegistry, createInMemoryRunContext, createInbox, createMcpEnvironment, createPushTraceSource, createSandboxLineage, createScope, createScopeAnalyst, createShapeRegistry, createSupervisor, createVerifierEnvironment, createWaterfallCollector, decodeToolPart, defaultAnalystInstruction, defaultAuditorInstruction, defaultProfileRichnessThresholds, defaultSelectWinner, defaultToolDetectors, definePersona, defineStrategy, depthStrategy, deterministicCompletion, discriminatingMeans, driverAgent, equalKOnCost, extractLlmCallEvent, fanout, finalizeBestDelivered, flatWidenGate, gitWorkspace, harvestCorpus, inlineSandboxClient, jjWorkspace, localShell, loopDispatch, loopUntil, mapSandboxEvent, observe, openSandboxRun, panel, pickChampion, pipeline, printBenchmarkReport, probeSandboxCapabilities, profileRichnessFinding, promotionGate, refine, registerShape, registryScopeAnalyst, renderAnytimeTable, renderCorpusToInstructions, renderReport, reportLoopUsage, runAgentic, runBenchmark, runInWorkspace, runLoop, runPersonified, runStrategyEvolution, sample, sampleThenRefine, sandboxSessionTraceSource, selectChampion, selectValidWinner, sentinelCompletion, serveCoordinationMcp, settledToIteration, spendFromUsageEvents, stopSentinel, strategyAuthorContract, supervise, supervisorAgent, supervisorInstructions, trajectoryReport, verify, watchTrace, widen, workerFromBackend };
+export { Agent, AgentRunSpec, type AgenticOptions, type AgenticRunResult, type AgenticSurface, type AgenticTask, type AgenticTool, type AnytimeReport, type AnytimeStrategySummary, type AnytimeTaskCurve, 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 Environment, EqualKArm, EqualKOnCostOptions, EqualKVerdict, type EvolutionArchiveNode, type EvolutionAuthor, type EvolutionBandInfo, type EvolutionCandidate, type EvolutionGeneration, type EvolutionReport, ExecCtx, ExecutorConfig, FanoutOptions, FanoutWinnerSelector, FileCorpus, type ForkCapableBox, type GitWorkspaceOptions, type HarvestCorpusOptions, type HarvestFailure, type HarvestReport, InMemoryCorpus, InMemoryResultBlobStore, type InMemoryRunContext, type InMemoryRunContextOptions, InMemorySpawnJournal, type Inbox, type InboxMessage, type IntentAudit, Iteration, type LoopDispatchOptions, LoopLineageOptions, type LoopOptionsForDispatch, LoopResult, LoopShape, LoopTokenUsage, LoopUntilSpec, LoopWinner, type McpEndpoint, type McpEnvironmentOptions, type Observation, type ObserveInput, type ObserveOptions, type OpenSandboxRunOptions, Outcome, OutputAdapter, PanelSpec, Persona, PipelineStage, type ProfileRichness, type ProfileRichnessThresholds, type PromotionGateOptions, type PromotionVerdict, type RegistryAnalyzeProjection, RenderCorpusToInstructionsOptions, type ReservationTicket, ResultBlobStore, RouterConfig, type RunAgenticOptions, RunPersonifiedOptions, type SandboxCapabilities, SandboxClient, type SandboxLineage, type SandboxLineageHandle, type SandboxRun, Scope, ScopeAnalyst, ScopeAnalyzeInput, ScopeWidenGate, type SessionCapableBox, type SessionTraceBox, Settled, ShapeRegistry, type Shell, type ShotPersona, type ShotSpec, Spend, SteerContext, type Strategy, type StrategyCtx, type StrategyEvolutionConfig, type StrategyResult, type SuperviseOptions, SupervisedResult, Supervisor, type SupervisorAgentDeps, type SupervisorProfile, type SurfaceScore, ToolLoopChat, 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, equalKOnCost, extractLlmCallEvent, fanout, finalizeBestDelivered, flatWidenGate, gitWorkspace, harvestCorpus, inlineSandboxClient, jjWorkspace, localShell, loopDispatch, loopUntil, mapSandboxEvent, observe, openSandboxRun, panel, pickChampion, pipeline, printBenchmarkReport, probeSandboxCapabilities, profileRichnessFinding, promotionGate, refine, registerShape, registryScopeAnalyst, renderAnytimeTable, renderCorpusToInstructions, renderReport, reportLoopUsage, runAgentic, runBenchmark, runInWorkspace, runLoop, runPersonified, runStrategyEvolution, sample, sampleThenRefine, sandboxSessionTraceSource, selectChampion, selectValidWinner, sentinelCompletion, serveCoordinationMcp, settledToIteration, spendFromUsageEvents, stopSentinel, strategyAuthorContract, supervise, supervisorAgent, supervisorInstructions, trajectoryReport, verify, watchTrace, widen, workerFromBackend };

package/dist/loops.js

@@ -41,11 +41,13 @@ import {
   decodeToolPart,
   defaultAnalystInstruction,
   defaultAuditorInstruction,
+  defaultDelegateBudget,
   defaultProfileRichnessThresholds,
   defaultSelectWinner,
   defaultToolDetectors,
   definePersona,
   defineStrategy,
+  delegate,
   depthStrategy,
   deterministicCompletion,
   discriminatingMeans,
@@ -110,8 +112,8 @@ import {
   widen,
   workerFromBackend,
   worktreeFanout
-} from "./chunk-YFOPWG74.js";
-import "./chunk-G3RGMA7C.js";
+} from "./chunk-5ISW5JUF.js";
+import "./chunk-VMNEQHJR.js";
 import {
   extractLlmCallEvent,
   mapSandboxEvent
@@ -161,11 +163,13 @@ export {
   decodeToolPart,
   defaultAnalystInstruction,
   defaultAuditorInstruction,
+  defaultDelegateBudget,
   defaultProfileRichnessThresholds,
   defaultSelectWinner,
   defaultToolDetectors,
   definePersona,
   defineStrategy,
+  delegate,
   depthStrategy,
   deterministicCompletion,
   discriminatingMeans,

package/dist/mcp/bin.js

@@ -6,12 +6,12 @@ import {
   createPropagatingTraceEmitter,
   detectExecutor,
   readTraceContextFromEnv
-} from "../chunk-LJZ5GC6C.js";
+} from "../chunk-74UAWZXE.js";
 import {
   coderTaskFromArgs,
   detachedSessionDelegate,
   settleDetachedCoderTurn
-} from "../chunk-HY4YOQM2.js";
+} from "../chunk-INXDNX2W.js";
 import {
   DEFAULT_SANDBOX_BASE_URL
 } from "../chunk-XRYEZPR6.js";
@@ -26,8 +26,8 @@ import {
   parseDetachedSessionRef,
   runDetachedTurn,
   runLoop
-} from "../chunk-YFOPWG74.js";
-import "../chunk-G3RGMA7C.js";
+} from "../chunk-5ISW5JUF.js";
+import "../chunk-VMNEQHJR.js";
 import "../chunk-VLF5RHEQ.js";
 import {
   coderTaskToPrompt
@@ -35,10 +35,43 @@ import {
 import "../chunk-WIR4HOOJ.js";
 import "../chunk-DGUM43GV.js";
 
+// src/mcp/delegate-supervisor-provisioning.ts
+var DEFAULT_SUPERVISOR_MODEL = "moonshotai/kimi-k2.6";
+var DEFAULT_WORKER_HARNESS = "opencode";
+function trimmed(value) {
+  const v = value?.trim();
+  return v ? v : void 0;
+}
+function delegateEnabled(env = process.env) {
+  return env.MCP_ENABLE_DELEGATE === "1";
+}
+function resolveRouter(env) {
+  const routerKey = trimmed(env.MCP_SUPERVISOR_ROUTER_KEY) ?? trimmed(env.TANGLE_API_KEY) ?? "";
+  const base = trimmed(env.MCP_SUPERVISOR_ROUTER_BASE_URL) ?? resolveRouterBaseUrl(env);
+  const routerBaseUrl = /\/v\d+\/?$/.test(base) ? base.replace(/\/$/, "") : `${base.replace(/\/$/, "")}/v1`;
+  const model = trimmed(env.MCP_SUPERVISOR_MODEL) ?? trimmed(env.MCP_WORKER_MODEL) ?? trimmed(env.WORKER_MODEL) ?? DEFAULT_SUPERVISOR_MODEL;
+  return { routerBaseUrl, routerKey, model };
+}
+function resolveDelegateSupervisor(sandboxClient, env = process.env) {
+  if (!delegateEnabled(env)) return void 0;
+  const router = resolveRouter(env);
+  const harness = trimmed(env.MCP_DELEGATE_WORKER_HARNESS) ?? DEFAULT_WORKER_HARNESS;
+  const backend = {
+    backend: "sandbox",
+    harness,
+    sandboxClient
+  };
+  return {
+    router,
+    backend,
+    model: router.model
+  };
+}
+
 // src/mcp/researcher-provisioning.ts
 var DEFAULT_HARNESS = "opencode";
 var DEFAULT_MODEL = "moonshotai/kimi-k2.6";
-function trimmed(value) {
+function trimmed2(value) {
   const t = value?.trim();
   return t ? t : void 0;
 }
@@ -47,10 +80,10 @@ function csv(value) {
   return list && list.length > 0 ? list : void 0;
 }
 function resolveResearcherProvisioning(env = process.env) {
-  const harness = trimmed(env.MCP_RESEARCHER_HARNESS) ?? DEFAULT_HARNESS;
-  const model = trimmed(env.MCP_RESEARCHER_MODEL) ?? trimmed(env.MCP_WORKER_MODEL) ?? trimmed(env.WORKER_MODEL) ?? DEFAULT_MODEL;
-  const routerKey = trimmed(env.MCP_RESEARCHER_ROUTER_KEY) ?? trimmed(env.TANGLE_API_KEY);
-  const base = trimmed(env.MCP_RESEARCHER_ROUTER_BASE_URL) ?? resolveRouterBaseUrl(env);
+  const harness = trimmed2(env.MCP_RESEARCHER_HARNESS) ?? DEFAULT_HARNESS;
+  const model = trimmed2(env.MCP_RESEARCHER_MODEL) ?? trimmed2(env.MCP_WORKER_MODEL) ?? trimmed2(env.WORKER_MODEL) ?? DEFAULT_MODEL;
+  const routerKey = trimmed2(env.MCP_RESEARCHER_ROUTER_KEY) ?? trimmed2(env.TANGLE_API_KEY);
+  const base = trimmed2(env.MCP_RESEARCHER_ROUTER_BASE_URL) ?? resolveRouterBaseUrl(env);
   const routerBaseUrl = /\/v\d+\/?$/.test(base) ? base.replace(/\/$/, "") : `${base.replace(/\/$/, "")}/v1`;
   const fanoutHarnesses = csv(env.MCP_RESEARCHER_FANOUT_HARNESSES);
   const fanoutModels = csv(env.MCP_RESEARCHER_FANOUT_MODELS);
@@ -81,8 +114,9 @@ async function main() {
   const maxConcurrency = parseConcurrency(process.env.MCP_MAX_CONCURRENT_SANDBOXES);
   const wantCoder = !process.env.MCP_DISABLE_CODER;
   const wantResearcher = !process.env.MCP_DISABLE_RESEARCHER;
+  const wantDelegate = delegateEnabled(process.env);
   const fleetId = parseFleetId(process.env.TANGLE_FLEET_ID);
-  const needsSandbox = wantCoder || wantResearcher;
+  const needsSandbox = wantCoder || wantResearcher || wantDelegate;
   let sandboxClient;
   let executor;
   if (needsSandbox) {
@@ -130,10 +164,15 @@ async function main() {
     );
   }
   const resumeDriver = detachedDispatch && sandboxClient ? buildResumeDriver({ sandboxClient, researcherResume: researcherSupport?.resume }) : void 0;
+  const delegateSupervisor = wantDelegate && sandboxClient ? resolveDelegateSupervisor(sandboxClient) : void 0;
+  if (wantDelegate && delegateSupervisor) {
+    process.stderr.write("agent-runtime-mcp: delegate enabled \u2014 generic authoring supervisor\n");
+  }
   const durableQueue = await buildDurableQueueFromEnv(resumeDriver, traceContext);
   const server = createMcpServer({
     coderDelegate,
     researcherDelegate: researcherSupport?.delegate,
+    ...delegateSupervisor ? { delegateSupervisor } : {},
     detachedDispatch,
     traceContext,
     ...durableQueue ? { queue: durableQueue } : {}
@@ -419,8 +458,8 @@ function parseHarnesses(raw) {
 }
 function parseFleetId(raw) {
   if (typeof raw !== "string") return void 0;
-  const trimmed2 = raw.trim();
-  return trimmed2.length > 0 ? trimmed2 : void 0;
+  const trimmed3 = raw.trim();
+  return trimmed3.length > 0 ? trimmed3 : void 0;
 }
 function parseConcurrency(raw) {
   if (!raw) return 4;