@tangle-network/agent-runtime 0.39.0 → 0.41.0

package/README.md

@@ -1,14 +1,38 @@
 # @tangle-network/agent-runtime
 
-Production runtime substrate for domain agents. Owns the chat-turn engine, task lifecycle, knowledge readiness, sanitized telemetry, OTEL export, model admission, and the declarative `defineAgent` manifest. Long-running execution durability lives in `@tangle-network/sandbox`.
+The task-lifecycle substrate for domain agents. It owns the **chat-turn engine**, the **driven-loop kernel** (refine / fanout-vote / agent-authored *dynamic* topologies), **delegated loops** (build-in-a-loop, valid-only research, review, audit, self-improve), **identity-gated prompt optimization**, **OpenTelemetry GenAI tracing**, knowledge readiness, sanitized telemetry, and the declarative `defineAgent` manifest — and delegates domain behavior (models, tools, KB) to adapters. Long-running execution durability lives in [`@tangle-network/sandbox`](https://www.npmjs.com/package/@tangle-network/sandbox); evals + gates in [`@tangle-network/agent-eval`](https://www.npmjs.com/package/@tangle-network/agent-eval).
 
 ```bash
 pnpm add @tangle-network/agent-runtime @tangle-network/agent-eval @tangle-network/sandbox
 ```
 
-## Hello world
+---
 
-Every product agent is a `handleChatTurn` call inside a route. This 20-line snippet is what gtm / creative / legal / tax all run:
+## Contents
+
+- [Getting started](#getting-started) — the 20-line production chat turn
+- [Which entry point do I reach for?](#which-entry-point-do-i-reach-for)
+- [Capabilities](#capabilities)
+  - [1. Chat turns — `handleChatTurn`](#1-chat-turns--handlechatturn)
+  - [2. Driven loops + topology drivers](#2-driven-loops--topology-drivers)
+  - [3. Agent-authored topology — `createDynamicDriver`](#3-agent-authored-topology--createdynamicdriver)
+  - [4. Delegated loop-runner — `runDelegatedLoop`](#4-delegated-loop-runner--rundelegatedloop)
+  - [5. Reliable build-in-a-loop — the coder delegate](#5-reliable-build-in-a-loop--the-coder-delegate)
+  - [6. Valid-only research — `createKbGate`](#6-valid-only-research--createkbgate)
+  - [7. Identity-gated prompt optimization — `optimizePrompt`](#7-identity-gated-prompt-optimization--optimizeprompt)
+  - [8. OpenTelemetry GenAI topology tracing](#8-opentelemetry-genai-topology-tracing)
+  - [9. MCP delegation server — `agent-runtime-mcp`](#9-mcp-delegation-server--agent-runtime-mcp)
+- [Defaults](#defaults)
+- [Composition with the stack](#composition-with-the-stack)
+- [Subpath exports](#subpath-exports)
+- [Adoption skill](#adoption-skill)
+- [Stability · Tests · Docs](#stability--tests--docs)
+
+---
+
+## Getting started
+
+Every product agent is a `handleChatTurn` call inside a route. This is what gtm / creative / legal / tax all run in production:
 
 ```ts
 import { handleChatTurn } from '@tangle-network/agent-runtime'
@@ -33,106 +57,278 @@ export async function POST({ request, env, ctx }: { request: Request; env: Env;
 }
 ```
 
-That's the centerpiece. Everything else is "when chat alone isn't enough."
+That's the centerpiece. Everything below is *"when one chat turn isn't enough"* — multi-shot loops, delegation, optimization, and the telemetry that makes them auditable.
+
+---
 
 ## Which entry point do I reach for?
 
+| You want to… | Reach for | Subpath |
+|---|---|---|
+| Run a production chat turn (90% of products) | `handleChatTurn` | root |
+| Declare an agent (profile + surfaces + adapters) | `defineAgent` | `/agent` |
+| One-shot task with verification + eval | `runAgentTask` | root |
+| Multi-shot loop (refine / fanout-vote) | `runLoop` + a driver | `/loops` |
+| Let the **agent choose** the loop shape per round | `createDynamicDriver` + `createSandboxPlanner` | `/loops` |
+| Delegate a disciplined loop by mode (code/research/…) | `runDelegatedLoop` / `agent-runtime-loop` | root |
+| Build code reliably (reviewed, gated) | `createDefaultCoderDelegate` | `/mcp` |
+| Grow a KB with only grounded facts | `createKbGate` | `/mcp` |
+| Improve a prompt safely (identity-gated) | `optimizePrompt` | `/improvement` |
+| Ship loop traces to a GenAI viewer | `buildLoopOtelSpans` + `createOtelExporter` | root |
+| Expose delegation as MCP tools to a sandbox agent | `createMcpServer` / `agent-runtime-mcp` | `/mcp` |
+| Mutate surfaces from trace findings | `runAnalystLoop` | `/analyst-loop` |
+| Persist a run + cost ledger | `startRuntimeRun` | root |
+
+---
+
+## Capabilities
+
+### 1. Chat turns — `handleChatTurn`
+
+The production turn envelope: frames a producer with the `session.run.*` NDJSON protocol, the persist → post-process → trace-flush hook order, and a stable execution id for client-retry replay. See [Getting started](#getting-started) and [`examples/chat-handler/`](./examples/chat-handler/).
+
+### 2. Driven loops + topology drivers
+
+`runLoop` is a topology-agnostic kernel: each iteration spawns a sandbox on an `AgentRunSpec`, decodes the output, validates it, and asks a **driver** what to do next. The driver owns topology; the validator owns scoring; the kernel owns iteration accounting, concurrency, cost/token aggregation, and trace emission.
+
+```ts
+import { runLoop, createFanoutVoteDriver } from '@tangle-network/agent-runtime/loops'
+
+const result = await runLoop({
+  driver: createFanoutVoteDriver({ n: 3 }),       // 3 parallel attempts, pick the best valid one
+  agentRuns: [claudeSpec, codexSpec, glmSpec],    // heterogeneous: one harness per branch
+  output,                                          // events → typed Output
+  validator,                                       // Output → { valid, score }
+  task,
+  ctx: { sandboxClient: sandbox },
+})
+result.winner // highest-scoring valid attempt
+```
+
+Shipped drivers (`/loops/drivers`): **`createRefineDriver`** (single task, iterate until valid) and **`createFanoutVoteDriver`** (N parallel, vote). See [`examples/coder-loop/`](./examples/coder-loop/) and [`examples/researcher-loop/`](./examples/researcher-loop/).
+
+### 3. Agent-authored topology — `createDynamicDriver`
+
+The third driver lets the **agent author the loop topology at runtime** — refine, fan out, or stop, decided per round by an injected planner. Topology is orthogonal to harness: the planner never names a backend; the kernel's `agentRuns` round-robin decides which harness runs each branch.
+
+```ts
+import { runLoop, createDynamicDriver, createSandboxPlanner } from '@tangle-network/agent-runtime/loops'
+
+const planner = createSandboxPlanner({
+  client: sandbox,
+  profile: { name: 'planner', metadata: { backendType: 'claude-code' } }, // cheap model is fine
+  decodeTask: (raw) => raw as Task,
+})
+
+const result = await runLoop({
+  driver: createDynamicDriver({ planner, maxIterations: 8 }),
+  agentRuns: [claudeSpec, codexSpec],   // the planner can fan a single round across both
+  output, validator, task,
+  ctx: { sandboxClient: sandbox },
+})
+```
+
+The planner emits one `TopologyMove` per round (`refine` | `fanout` | `stop`) with a rationale; a malformed move throws `PlannerError` (the loop never runs a topology nobody chose).
+
+### 4. Delegated loop-runner — `runDelegatedLoop`
+
+One configured entrypoint a worker agent (or a scheduled routine) calls to run a disciplined loop in a chosen **mode**, over the hardened engines below. Fail-loud on an unwired mode; a thrown engine is captured as `{ ok: false }` so unattended runs *record* rather than crash.
+
+```ts
+import {
+  runDelegatedLoop, coderLoopRunner, researchLoopRunner, type DelegatedLoopRegistry,
+} from '@tangle-network/agent-runtime'
+
+const registry: DelegatedLoopRegistry = {
+  code: coderLoopRunner({
+    sandboxClient,
+    args: { goal: 'fix the flaky retry test', repoRoot: '/repo' },
+    reviewer,                       // optional adversarial gate
+    winnerSelection: 'smallest-diff',
+  }),
+  research: researchLoopRunner({ research, gate: { selfArtifactKinds: ['spec'] }, maxRounds: 3 }),
+}
+
+const result = await runDelegatedLoop('code', registry)
+// → { mode: 'code', ok: true, output: CoderOutput, durationMs }
+```
+
+Modes: `code` · `review` · `research` · `audit` · `self-improve` · `dynamic` — each with a default factory (`coderLoopRunner`, `reviewLoopRunner`, `researchLoopRunner`, `dynamicLoopRunner`, `selfImproveLoopRunner`, `auditLoopRunner`).
+
+**Schedulable**: the `agent-runtime-loop` bin runs it from a cron/routine. The config module wires the registry (with full env/creds access):
+
+```bash
+agent-runtime-loop --mode research --config ./loops.config.js
+# exits 0 (ok) · 1 (recorded failure) · 2 (usage/config error); prints the result as JSON
+```
+
+```ts
+// loops.config.js — default-exports a DelegatedLoopRegistry (or a factory)
+import { researchLoopRunner } from '@tangle-network/agent-runtime'
+export default { research: researchLoopRunner({ research: myResearchEngine, maxRounds: 3 }) }
+```
+
+### 5. Reliable build-in-a-loop — the coder delegate
+
+`createDefaultCoderDelegate` drives a coder loop with **default-on safety gates** so it never ships junk:
+
+- **no-op rejection** — an empty patch can't "pass" trivially,
+- **secret-path floor** — always-on, independent of `forbiddenPaths` (`.env`, keys, wallets, …),
+- optional **`reviewer`** gate — a candidate must pass tests/typecheck **and** be approved to win,
+- **`winnerSelection`** — `highest-score` (default) · `smallest-diff` · `highest-readiness` · `first-approved`.
+
+```ts
+import { createDefaultCoderDelegate } from '@tangle-network/agent-runtime/mcp'
+
+const coder = createDefaultCoderDelegate({
+  sandboxClient,
+  fanoutHarnesses: ['claude-code', 'codex'],
+  reviewer: async (output, task) => ({ approved: output.testResult.passed, recommendation: 'ship', readiness: 0.9 }),
+  winnerSelection: 'highest-readiness',
+})
+const out = await coder({ goal: 'add a retry with backoff', repoRoot: '/repo', variants: 2 }, ctx)
+```
+
+See [`examples/coder-loop/`](./examples/coder-loop/) and [`examples/agent-into-reviewer/`](./examples/agent-into-reviewer/).
+
+### 6. Valid-only research — `createKbGate`
+
+A fail-closed gate so a knowledge base grows with **only grounded facts**. The always-on floor: a fact's `verbatimPassage` must literally appear in its `sourceText` (anti-hallucination), the asserted value must be in the passage, and citations can't point at self-generated artifacts (laundering). Plug in your own judges; verdict-only (remediation is yours).
+
+```ts
+import { createKbGate } from '@tangle-network/agent-runtime/mcp'
+
+const gate = createKbGate({ selfArtifactKinds: ['spec', 'cad_params'] })
+const verdict = await gate({
+  claim: 'revenue was $1.2B in 2025',
+  value: 1_200_000_000,
+  verbatimPassage: 'total revenue was $1,200,000,000 for the fiscal year',
+  sourceText: rawSource,
+})
+if (verdict.accepted) writeToKb(fact)
+else console.warn('vetoed by', verdict.vetoedBy, verdict.reason)
+```
+
+`researchLoopRunner` (mode `research`) wraps this with a correct-on-veto remediation loop: research → gate → re-research the vetoed gaps up to `maxRounds`, then **return** the unverified ones (escalate, never silently drop).
+
+### 7. Identity-gated prompt optimization — `optimizePrompt`
+
+Optimize any text prompt over agent-eval's `runImprovementLoop`, **identity-gated by construction**: it runs evals, proposes candidates (default `gepaDriver`), and the held-out gate compares candidate vs baseline. `result.prompt` is the **baseline unless the gate decided `ship`** — so registering a prompt for optimization can never regress it.
+
+```ts
+import { optimizePrompt } from '@tangle-network/agent-runtime/improvement'
+
+const { prompt, improved, delta } = await optimizePrompt({
+  baselinePrompt: CURRENT_SYSTEM_PROMPT,
+  runWithPrompt: (candidate, scenario, ctx) => runYourThing(candidate, scenario),
+  scenarios, holdoutScenarios, judges, runDir,
+  reflection: { llm, model: 'claude-sonnet-4-6' },
+})
+// assign `prompt` unconditionally — it's the safe one
+```
+
+See [`examples/self-improving-loop/`](./examples/self-improving-loop/).
+
+### 8. OpenTelemetry GenAI topology tracing
+
+`runLoop` emits a structured event stream; `buildLoopOtelSpans` turns it into a **nested, real-duration span tree** that any GenAI trace viewer (Phoenix, Langfuse, Grafana Tempo, Tangle Intelligence) renders natively. Attributes follow the current GenAI semantic conventions (`gen_ai.operation.name`, `gen_ai.agent.name`, `gen_ai.usage.input_tokens/output_tokens`) plus a `tangle.loop.*` extension for the topology (move kind/rationale, edge lineage, verdict, placement, cost).
+
+```ts
+import { buildLoopOtelSpans, createOtelExporter } from '@tangle-network/agent-runtime'
+
+const exporter = createOtelExporter() // reads OTEL_EXPORTER_OTLP_ENDPOINT
+for (const span of buildLoopOtelSpans(loopEvents, traceId)) exporter?.exportSpan(span)
+await exporter?.flush()
 ```
-Production chat turn (90% of products)     → handleChatTurn
-Declarative agent manifest                 → defineAgent (/agent)
-Cross-process reconnect (X-Execution-ID)   → deriveExecutionId
-One-shot task with verification + eval     → runAgentTask
-Streaming task without chat-turn envelope  → runAgentTaskStream
-Multi-iteration parallel fanout (coders /
-  researchers proposing N variants)        → runLoop + a Driver (/loops)
-Tool/MCP delegation server (stdio)         → createMcpServer (/mcp)
-Analyst surface mutations                  → runAnalystLoop (/analyst-loop)
-Production-run persistence + cost ledger   → startRuntimeRun
-Cross-site SSO / integrations hub          → PlatformAuthClient (/platform)
+
+The shape: `loop → loop.round (move + rationale) → loop.iteration (agent, usage, verdict, cost, parent edge)`. See [`examples/with-intelligence-export/`](./examples/with-intelligence-export/).
+
+### 9. MCP delegation server — `agent-runtime-mcp`
+
+Expose the five delegation tools (`delegate_code`, `delegate_research`, `delegate_feedback`, `delegation_status`, `delegation_history`) to a sandbox coding-harness agent — mount the canonical server, don't fork delegation logic.
+
+```ts
+import { createMcpServer, createDefaultCoderDelegate } from '@tangle-network/agent-runtime/mcp'
+
+const server = createMcpServer({
+  coderDelegate: createDefaultCoderDelegate({ sandboxClient }),
+  researcherDelegate, // wire your KB-backed researcher
+})
 ```
 
+Or mount the `agent-runtime-mcp` stdio bin on a production `AgentProfile.mcp`. See [`examples/mcp-delegation/`](./examples/mcp-delegation/) and [`examples/fleet-delegation/`](./examples/fleet-delegation/).
+
+---
+
 ## Defaults
 
 When nothing is specified:
 
 | Knob | Default | Override |
 |---|---|---|
-| Backend model | `gpt-4o-mini` (when via `createOpenAICompatibleBackend`) | `model` option, or `MODEL_NAME` env |
-| Backend provider | `openai-compat` when `TANGLE_API_KEY` present, else `openai` if `OPENAI_API_KEY` | `MODEL_PROVIDER` env |
+| Backend model | `gpt-4o-mini` (via `createOpenAICompatibleBackend`) | `model` option / `MODEL_NAME` env |
+| Backend provider | `openai-compat` when `TANGLE_API_KEY`, else `openai` if `OPENAI_API_KEY` | `MODEL_PROVIDER` env |
 | Router base URL | `https://router.tangle.tools/v1` | `TANGLE_ROUTER_BASE_URL` env |
 | Sandbox base URL | `https://sandbox.tangle.tools` | `SANDBOX_API_URL` env |
-| Loop iteration cap | 8 | `runLoop({ maxIterations })` |
-| Driver | none — required to pass `Refine` or `FanoutVote` | `createRefineDriver()` or `createFanoutVoteDriver({ n })` |
-| Validator | none — required if using `runLoop` | profile preset (e.g., `coderProfile().validator`) or your own |
+| Loop iteration cap | 10 (`runLoop`); dynamic driver 8 | `runLoop({ maxIterations })` |
+| Driver | none — required by `runLoop` | `createRefineDriver` / `createFanoutVoteDriver` / `createDynamicDriver` |
+| Winner selection (coder delegate) | `highest-score` | `winnerSelection` option |
+| KB gate min passage | 12 chars | `createKbGate({ minPassageChars })` |
+| `optimizePrompt` gate | `heldOutGate` | `defaultProductionGate` for red-team hardening |
 | OTEL export | off | set `OTEL_EXPORTER_OTLP_ENDPOINT` |
-| Trace propagation through MCP subprocess | off until product wires it | `env.TRACE_ID` + `env.PARENT_SPAN_ID` at MCP launch |
-
-## Composition with the rest of the stack
-
-```
-agent-runtime  ────  handleChatTurn (chat turn lifecycle)
-                     defineAgent    (declarative manifest)
-                     runLoop        (multi-shot kernel)
-                     createMcpServer (delegation tools server)
-                     OTEL export    (trace pipeline)
+| Loop-runner mode failure | recorded as `{ ok: false }` | `runDelegatedLoop` never crashes on a thrown engine |
 
-agent-eval     ────  runEvalCampaign / runProductionLoop / runAgentMatrix
-                     (consumes agent-runtime traces, scores, gates promotion)
+---
 
-agent-knowledge ───  proposeKnowledgeWrites / applyKnowledgeWriteBlocks
-                     (analyst-loop produces these; runtime consumes them)
+## Composition with the stack
 
-sandbox        ────  AgentProfile (substrate type), Sandbox.create, exportTraceBundle
-                     (provides the harness execution surface)
 ```
+agent-runtime  ──  handleChatTurn · runLoop + drivers · runDelegatedLoop · createMcpServer
+                   optimizePrompt · createKbGate · buildLoopOtelSpans · defineAgent
 
-Self-improving products consume all four. This package ships a self-contained adoption skill at [`skills/agent-runtime-adoption/SKILL.md`](./skills/agent-runtime-adoption/SKILL.md) — driven loops, topology drivers (refine / fanout-vote / dynamic), the `loopDispatch` campaign bridge, MCP delegation, and identity-gated `optimizePrompt`; it needs only this package + `@tangle-network/agent-eval`. For the end-to-end self-improving pipeline (trace sink → analyst loop → scorecard → production loop → CI), see the broader `agent-eval-adoption` / `agent-stack-adoption` skills.
+agent-eval     ──  runEvalCampaign · runImprovementLoop (gepaDriver) · heldOutGate · runAgentMatrix
+                   (consumes runtime traces, scores, gates promotion)
 
-## Examples
+agent-knowledge ─  proposeKnowledgeWrites / applyKnowledgeWriteBlocks
+                   (analyst-loop produces these; runtime + createKbGate consume them)
 
-Ordered as a learning progression — each example introduces one concept.
+sandbox        ──  AgentProfile · Sandbox.create · streamPrompt · exportTraceBundle
+                   (the harness execution surface every loop runs on)
+```
 
-**Start here:**
-- [`chat-handler/`](./examples/chat-handler/) — `handleChatTurn`, the production centerpiece
+---
 
-**Add observability + readiness:**
-- [`with-knowledge-readiness/`](./examples/with-knowledge-readiness/) — `requiredKnowledge` + `decideKnowledgeReadiness`
-- [`sanitized-telemetry-streaming/`](./examples/sanitized-telemetry-streaming/) — `createRuntimeStreamEventCollector` + redaction
-- [`runtime-run/`](./examples/runtime-run/) — `startRuntimeRun` + cost ledger persistence
+## Subpath exports
 
-**Add delegation:**
-- [`mcp-delegation/`](./examples/mcp-delegation/) — mount `agent-runtime-mcp` in an `AgentProfile`
+| Import | Owns |
+|---|---|
+| `@tangle-network/agent-runtime` | chat turns, delegated loop-runner, OTEL export, errors, model resolution |
+| `…/agent` | `defineAgent` + surfaces / outcome adapters |
+| `…/loops` | `runLoop` kernel + `refine` / `fanout-vote` / **`dynamic`** drivers + `loopDispatch` |
+| `…/profiles` | `coderProfile`, `researcherProfile` presets |
+| `…/mcp` | `createMcpServer`, `createDefaultCoderDelegate`, **`createKbGate`**, `agent-runtime-mcp` bin |
+| `…/improvement` | **`optimizePrompt`** (text) + `improvementDriver` (code/worktree) |
+| `…/analyst-loop` | `runAnalystLoop` — analyst registry driver |
+| `…/platform` | cross-site SSO + integrations hub |
 
-**Multi-agent fanout (advanced):**
-- [`coder-loop/`](./examples/coder-loop/) — `coderProfile` + `runLoop` + `FanoutVote`
-- [`researcher-loop/`](./examples/researcher-loop/) — `researcherProfile` + `runLoop` (peer dep: `@tangle-network/agent-knowledge`)
-- [`fleet-delegation/`](./examples/fleet-delegation/) — `TANGLE_FLEET_ID` + `createFleetWorkspaceExecutor`
+Bins: `agent-runtime-mcp` (delegation MCP server) · `agent-runtime-loop` (schedulable delegated loop-runner).
 
-## Stability
+---
 
-Every public export is annotated `@stable` or `@experimental`. `@stable` exports do not change shape inside a minor. `@experimental` exports may change inside a minor and require a deliberate consumer bump.
+## Adoption skill
 
-## Package boundaries
+This package ships a **self-contained adoption skill** at [`skills/agent-runtime-adoption/SKILL.md`](./skills/agent-runtime-adoption/SKILL.md) — driven loops, topology drivers, the `loopDispatch` campaign bridge, MCP delegation, and identity-gated `optimizePrompt`. It needs only this package + `@tangle-network/agent-eval`, so external consumers need nothing private. For the full self-improving pipeline (trace sink → analyst loop → scorecard → production loop → CI), see the `agent-eval-adoption` / `agent-stack-adoption` skills.
 
-| Package | Owns |
-|---|---|
-| `agent-runtime` | Task lifecycle, adapters, backends, chat-turn engine, model resolution, trace bridge, `defineAgent` |
-| `agent-runtime/platform` | Cross-site SSO + integrations hub |
-| `agent-runtime/agent` | `defineAgent` + surfaces / outcome adapters |
-| `agent-runtime/analyst-loop` | `runAnalystLoop` — analyst registry driver |
-| `agent-runtime/loops` | `runLoop` kernel + `Refine` / `FanoutVote` drivers |
-| `agent-runtime/profiles` | `coderProfile`, `researcherProfile` presets |
-| `agent-runtime/mcp` | `createMcpServer` + `agent-runtime-mcp` bin (5 delegation tools) |
-| `agent-eval` | Evals, judges, scorecards, RL bridge, release evidence, matrix |
-| `agent-knowledge` | Evidence, claims, wiki pages, retrieval |
-| `sandbox` | `AgentProfile`, `Sandbox.create`, `streamPrompt`, `exportTraceBundle` |
+---
 
-See [`docs/concepts.md`](./docs/concepts.md) for the deeper mental model. For multi-agent conversations see [`docs/agent-bus-protocol.md`](./docs/agent-bus-protocol.md) (cross-gateway header contract), [`docs/conversation-economics.md`](./docs/conversation-economics.md) (who pays for what — `authSource`), and [`docs/durability-adapters.md`](./docs/durability-adapters.md) (SQL-backed `ConversationJournal` for D1, postgres, sqlite, libSQL).
+## Stability · Tests · Docs
 
-## Tests
+Every public export is annotated `@stable` or `@experimental`. `@stable` exports don't change shape inside a minor; `@experimental` ones may and require a deliberate consumer bump.
 
 ```bash
-pnpm test       # 283+ tests across the kernel + drivers + MCP + backends + analyst-loop
+pnpm test       # full suite across the kernel, drivers, MCP, delegate hardening, kb-gate, loop-runner, backends
 pnpm typecheck
 pnpm build
 ```
+
+Deeper docs: [`docs/concepts.md`](./docs/concepts.md) (mental model) · [`docs/agent-bus-protocol.md`](./docs/agent-bus-protocol.md) (cross-gateway header contract) · [`docs/conversation-economics.md`](./docs/conversation-economics.md) (who pays — `authSource`) · [`docs/durability-adapters.md`](./docs/durability-adapters.md) (SQL-backed `ConversationJournal`).

package/dist/{chunk-AXWGLYSF.js → chunk-4GI7C36B.js}

@@ -9,11 +9,11 @@ import {
 } from "./chunk-FNMGYYSS.js";
 import {
   createDefaultCoderDelegate
-} from "./chunk-VLXRXMTF.js";
+} from "./chunk-FJ4GDNVN.js";
 import {
   createDynamicDriver,
   runLoop
-} from "./chunk-7JBDJQLO.js";
+} from "./chunk-OISRXLWI.js";
 import {
   ConfigError
 } from "./chunk-SQSCRJ7U.js";
@@ -198,4 +198,4 @@ export {
   runLoopRunnerCli,
   parseLoopRunnerArgv
 };
-//# sourceMappingURL=chunk-AXWGLYSF.js.map
+//# sourceMappingURL=chunk-4GI7C36B.js.map

package/dist/{chunk-VLXRXMTF.js → chunk-FJ4GDNVN.js}

@@ -1,6 +1,6 @@
 import {
   runLoop
-} from "./chunk-7JBDJQLO.js";
+} from "./chunk-OISRXLWI.js";
 import {
   coderProfile,
   multiHarnessCoderFanout
@@ -78,6 +78,7 @@ function createDefaultCoderDelegate(options) {
   const sandboxClient = executor.client;
   const fanoutHarnesses = options.fanoutHarnesses;
   const maxConcurrency = options.maxConcurrency ?? 4;
+  const traceEmitter = options.traceEmitter;
   return async (args, ctx) => {
     const task = {
       goal: buildCoderGoal(args),
@@ -97,7 +98,7 @@ function createDefaultCoderDelegate(options) {
         output,
         validator,
         task,
-        ctx: { sandboxClient, signal: ctx.signal },
+        ctx: { sandboxClient, signal: ctx.signal, ...traceEmitter ? { traceEmitter } : {} },
         maxIterations: 1,
         maxConcurrency
       });
@@ -122,7 +123,7 @@ function createDefaultCoderDelegate(options) {
       output: fanout.output,
       validator: fanout.validator,
       task,
-      ctx: { sandboxClient, signal: ctx.signal },
+      ctx: { sandboxClient, signal: ctx.signal, ...traceEmitter ? { traceEmitter } : {} },
       maxIterations: variants,
       maxConcurrency: Math.min(maxConcurrency, variants)
     });
@@ -209,4 +210,4 @@ export {
   createFleetWorkspaceExecutor,
   createDefaultCoderDelegate
 };
-//# sourceMappingURL=chunk-VLXRXMTF.js.map
+//# sourceMappingURL=chunk-FJ4GDNVN.js.map

package/dist/chunk-FJ4GDNVN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/mcp/executor.ts","../src/mcp/delegates.ts"],"sourcesContent":["/**\n * @experimental\n *\n * Delegation executors — the layer between MCP delegates and the sandbox\n * substrate. Each executor exposes a {@link LoopSandboxClient} the kernel\n * consumes plus a placement tag so the trace pipeline can correlate workers\n * with their physical placement.\n *\n * Two implementations ship in-box:\n *\n * - {@link createSiblingSandboxExecutor} — every delegation spawns a fresh\n *   sandbox sibling to the caller. Default when the MCP server runs as a\n *   standalone CLI mounted outside a fleet.\n *\n * - {@link createFleetWorkspaceExecutor} — delegations dispatch onto machines\n *   in the caller's existing fleet so worker diffs land directly on the\n *   caller's filesystem (the fleet's shared workspace). Selected when the\n *   parent sandbox passes `TANGLE_FLEET_ID` into the MCP server's env.\n */\n\nimport type { CreateSandboxOptions, SandboxInstance } from '@tangle-network/sandbox'\nimport type { LoopSandboxClient, LoopSandboxPlacement } from '../loops'\n\n/** @experimental */\nexport interface DelegationExecutor {\n  /** Sandbox client the kernel calls. Returned with `describePlacement` set. */\n  readonly client: LoopSandboxClient\n  /** Best-effort one-liner used in stderr boot logs and diagnostics. */\n  describe(): string\n}\n\n/** @experimental */\nexport interface SiblingSandboxExecutorOptions {\n  client: LoopSandboxClient\n}\n\n/**\n * Wrap a raw sandbox SDK client so the kernel emits\n * `loop.iteration.dispatch` events with `{ placement: 'sibling', sandboxId }`.\n *\n * The returned client `.create()` delegates to the underlying client; the\n * only added behavior is a `describePlacement` tag the kernel reads.\n *\n * @experimental\n */\nexport function createSiblingSandboxExecutor(\n  options: SiblingSandboxExecutorOptions,\n): DelegationExecutor {\n  const underlying = options.client\n  const client: LoopSandboxClient = {\n    create(opts?: CreateSandboxOptions): Promise<SandboxInstance> {\n      return underlying.create(opts)\n    },\n    describePlacement(box: SandboxInstance): LoopSandboxPlacement {\n      return { kind: 'sibling', sandboxId: readId(box) }\n    },\n  }\n  return {\n    client,\n    describe(): string {\n      return 'sibling-sandbox (each delegation = fresh sandbox via client.create)'\n    },\n  }\n}\n\n/**\n * Minimal `SandboxFleet` surface the fleet executor calls. Declared\n * structurally so tests can pass an in-memory stub without instantiating the\n * sandbox SDK.\n *\n * @experimental\n */\nexport interface FleetHandle {\n  readonly fleetId: string\n  /** Machine ids in dispatch-eligible order. The executor round-robins. */\n  readonly ids: ReadonlyArray<string>\n  /** Resolve a machine id to its `SandboxInstance` — that machine is mounted\n   * on the fleet's shared workspace, so any diff the worker writes lands on\n   * every other fleet machine's filesystem too. */\n  sandbox(machineId: string): Promise<SandboxInstance>\n}\n\n/** @experimental */\nexport interface FleetWorkspaceExecutorOptions {\n  fleet: FleetHandle\n  /**\n   * Override the machine-selection policy. Default = round-robin across\n   * `fleet.ids`, skipping the optional `excludeMachineIds` set (typically the\n   * coordinator machine the MCP server is running on).\n   */\n  selectMachine?: (call: { callIndex: number; ids: ReadonlyArray<string> }) => string\n  /**\n   * Machine ids to skip during default round-robin. Set to the caller's own\n   * machineId so workers don't compete with the orchestrator on the same VM.\n   */\n  excludeMachineIds?: ReadonlyArray<string>\n}\n\n/**\n * Build an executor that resolves each delegated iteration to an existing\n * machine in `fleet`. The fleet's shared-workspace policy means the worker\n * machine sees the caller's filesystem — diffs land in-place with no\n * cross-sandbox copy step.\n *\n * @experimental\n */\nexport function createFleetWorkspaceExecutor(\n  options: FleetWorkspaceExecutorOptions,\n): DelegationExecutor {\n  const fleet = options.fleet\n  const exclude = new Set(options.excludeMachineIds ?? [])\n  let callIndex = 0\n  // machineId-by-sandboxId, populated as we resolve machines so\n  // `describePlacement` can recover the assignment from the SandboxInstance\n  // the kernel hands back.\n  const placementBySandboxId = new Map<string, { machineId: string }>()\n\n  const client: LoopSandboxClient = {\n    async create(): Promise<SandboxInstance> {\n      const ids = fleet.ids.filter((id) => !exclude.has(id))\n      if (ids.length === 0) {\n        throw new Error(\n          `agent-runtime: fleet ${fleet.fleetId} has no eligible worker machines (ids=[${fleet.ids.join(',')}], excluded=[${[...exclude].join(',')}])`,\n        )\n      }\n      const selector = options.selectMachine\n      const machineId = selector ? selector({ callIndex, ids }) : ids[callIndex % ids.length]\n      callIndex += 1\n      if (typeof machineId !== 'string' || machineId.length === 0) {\n        throw new Error('agent-runtime: fleet executor selectMachine returned an empty machine id')\n      }\n      const box = await fleet.sandbox(machineId)\n      const sandboxId = readId(box)\n      if (sandboxId) placementBySandboxId.set(sandboxId, { machineId })\n      return box\n    },\n    describePlacement(box: SandboxInstance): LoopSandboxPlacement {\n      const sandboxId = readId(box)\n      const recorded = sandboxId ? placementBySandboxId.get(sandboxId) : undefined\n      return {\n        kind: 'fleet',\n        sandboxId,\n        fleetId: fleet.fleetId,\n        machineId: recorded?.machineId,\n      }\n    },\n  }\n\n  return {\n    client,\n    describe(): string {\n      const excluded = exclude.size > 0 ? ` (excluded=[${[...exclude].join(',')}])` : ''\n      return `fleet-workspace (fleetId=${fleet.fleetId}, machines=[${fleet.ids.join(',')}]${excluded})`\n    },\n  }\n}\n\nfunction readId(box: SandboxInstance): string | undefined {\n  const raw = (box as unknown as { id?: unknown }).id\n  return typeof raw === 'string' && raw.length > 0 ? raw : undefined\n}\n","/**\n * @experimental\n *\n * Delegate factories — the layer between MCP tool handlers and the\n * underlying `runLoop` runners.\n *\n * The MCP server is profile-agnostic: it owns the task queue + feedback\n * store + transport. Each `*Delegate` is the closure that the queue\n * invokes when a task runs. Consumers can override either delegate to\n * inject custom drivers, mocks, fleet-aware dispatchers, etc.\n *\n * The default coder delegate is wired here because we own\n * `coderProfile` / `multiHarnessCoderFanout`. The default researcher\n * delegate is **not** wired in this file — `agent-knowledge` cannot be\n * imported from `agent-runtime` without inducing a cycle. Consumers\n * pass `researcherDelegate` explicitly when constructing the server.\n */\n\nimport type { Iteration, LoopSandboxClient, LoopTraceEmitter } from '../loops'\nimport { runLoop } from '../loops'\nimport { type CoderOutput, coderProfile, multiHarnessCoderFanout } from '../profiles/coder'\nimport { createSiblingSandboxExecutor, type DelegationExecutor } from './executor'\nimport type {\n  CoderTask,\n  DelegateCodeArgs,\n  DelegateResearchArgs,\n  DelegationProgress,\n  ResearchOutputShape,\n} from './types'\n\n/** @experimental */\nexport interface DelegateRunCtx {\n  signal: AbortSignal\n  report(progress: DelegationProgress): void\n}\n\n/** @experimental */\nexport type CoderDelegate = (\n  args: DelegateCodeArgs,\n  ctx: DelegateRunCtx,\n) => Promise<import('../profiles/coder').CoderOutput>\n\n/** @experimental */\nexport type ResearcherDelegate = (\n  args: DelegateResearchArgs,\n  ctx: DelegateRunCtx,\n) => Promise<ResearchOutputShape>\n\n/** @experimental Structured review verdict over a coder candidate. */\nexport interface CoderReview {\n  /** Gate: only approved candidates are eligible to win. */\n  approved: boolean\n  /** Reviewer's recommendation — surfaced in traces. */\n  recommendation: 'ship' | 'approve-with-nits' | 'changes-requested' | 'reject'\n  /** Readiness 0..1, used by the `highest-readiness` winner-selection strategy. */\n  readiness: number\n  notes?: string\n}\n\n/**\n * @experimental\n *\n * Optional adversarial reviewer over a coder candidate that already passed\n * mechanical validation (tests/typecheck/forbidden/diff/no-op/secrets). Folded\n * from the ai-trading-blueprint delegation MCP: a candidate is only eligible to\n * win if the reviewer approves it. The reviewer is the consumer's seam — an LLM\n * judge, a `pnpm review` command, anything returning a `CoderReview`.\n */\nexport type CoderReviewer = (\n  output: import('../profiles/coder').CoderOutput,\n  task: CoderTask,\n  ctx: { signal: AbortSignal },\n) => Promise<CoderReview> | CoderReview\n\n/**\n * @experimental Winner-selection strategy among validated (+ reviewed)\n * candidates. `highest-readiness` requires a `reviewer`. Default `highest-score`\n * (the kernel's behavior — preserves backward compatibility).\n */\nexport type CoderWinnerSelection =\n  | 'highest-score'\n  | 'smallest-diff'\n  | 'highest-readiness'\n  | 'first-approved'\n\n/** @experimental */\nexport interface CreateDefaultCoderDelegateOptions {\n  /**\n   * Execution placement. Pass a {@link DelegationExecutor} (sibling or fleet)\n   * to control where worker iterations land. `sandboxClient` is a\n   * convenience shorthand that wraps the client in a sibling executor — pass\n   * one or the other, not both.\n   */\n  executor?: DelegationExecutor\n  /**\n   * Convenience shorthand for sibling placement. Equivalent to\n   * `executor: createSiblingSandboxExecutor({ client: sandboxClient })`.\n   */\n  sandboxClient?: LoopSandboxClient\n  /** Default `['claude-code', 'codex', 'opencode/zai-coding-plan/glm-5.1']` when variants > 1. */\n  fanoutHarnesses?: string[]\n  /** Hard cap on the kernel's per-batch concurrency. Default 4. */\n  maxConcurrency?: number\n  /**\n   * Optional adversarial reviewer. When set, a candidate must pass mechanical\n   * validation AND `reviewer.approved` to be eligible to win — empty/secret/\n   * test-failing patches are already gone; this catches the \"compiles + passes\n   * but wrong/unsafe\" class the deterministic validator can't see.\n   */\n  reviewer?: CoderReviewer\n  /** Winner-selection strategy among eligible candidates. Default `highest-score`. */\n  winnerSelection?: CoderWinnerSelection\n  /**\n   * Loop trace emitter forwarded into every delegated `runLoop`. Wire\n   * `createPropagatingTraceEmitter(readTraceContextFromEnv())` here (the bin\n   * does) so delegated build-loops export their topology spans to the OTLP /\n   * Tangle Intelligence sink when `OTEL_EXPORTER_OTLP_ENDPOINT` is set — and\n   * are a cheap no-op when it isn't. Configurable by construction.\n   */\n  traceEmitter?: LoopTraceEmitter\n}\n\n/**\n * Build a coder delegate that drives `runLoop` against the project's\n * sandbox client + coder profile. When `args.variants > 1` it switches\n * to the multi-harness fanout topology.\n *\n * @experimental\n */\nexport function createDefaultCoderDelegate(\n  options: CreateDefaultCoderDelegateOptions,\n): CoderDelegate {\n  const executor = resolveExecutor(options)\n  const sandboxClient = executor.client\n  const fanoutHarnesses = options.fanoutHarnesses\n  const maxConcurrency = options.maxConcurrency ?? 4\n  const traceEmitter = options.traceEmitter\n  return async (args, ctx) => {\n    const task: CoderTask = {\n      goal: buildCoderGoal(args),\n      repoRoot: args.repoRoot,\n      testCmd: args.config?.testCmd,\n      typecheckCmd: args.config?.typecheckCmd,\n      forbiddenPaths: args.config?.forbiddenPaths,\n      maxDiffLines: args.config?.maxDiffLines,\n    }\n    const variants = Math.max(1, Math.trunc(args.variants ?? 1))\n    ctx.report({ iteration: 0, phase: 'starting' })\n    if (variants <= 1) {\n      const { agentRunSpec, output, validator } = coderProfile({ task })\n      const result = await runLoop({\n        driver: singleShotDriver,\n        agentRun: agentRunSpec,\n        output,\n        validator,\n        task,\n        ctx: { sandboxClient, signal: ctx.signal, ...(traceEmitter ? { traceEmitter } : {}) },\n        maxIterations: 1,\n        maxConcurrency,\n      })\n      const chosen = await pickCoderWinner({\n        iterations: result.iterations,\n        reviewer: options.reviewer,\n        selection: options.winnerSelection ?? 'highest-score',\n        task,\n        signal: ctx.signal,\n      })\n      if (!chosen) throw new Error(noWinnerMessage(options.reviewer))\n      ctx.report({ iteration: 1, phase: 'completed' })\n      return chosen\n    }\n    const fanout = multiHarnessCoderFanout(\n      fanoutHarnesses && fanoutHarnesses.length > 0\n        ? { harnesses: fanoutHarnesses.slice(0, variants) }\n        : { harnesses: undefined },\n    )\n    const agentRuns = fanout.agentRuns.slice(0, variants)\n    const result = await runLoop({\n      driver: fanout.driver,\n      agentRuns,\n      output: fanout.output,\n      validator: fanout.validator,\n      task,\n      ctx: { sandboxClient, signal: ctx.signal, ...(traceEmitter ? { traceEmitter } : {}) },\n      maxIterations: variants,\n      maxConcurrency: Math.min(maxConcurrency, variants),\n    })\n    const chosen = await pickCoderWinner({\n      iterations: result.iterations,\n      reviewer: options.reviewer,\n      selection: options.winnerSelection ?? 'highest-score',\n      task,\n      signal: ctx.signal,\n    })\n    if (!chosen) throw new Error(noWinnerMessage(options.reviewer))\n    ctx.report({ iteration: agentRuns.length, phase: 'completed' })\n    return chosen\n  }\n}\n\ninterface PickCoderWinnerArgs {\n  iterations: ReadonlyArray<Iteration<CoderTask, CoderOutput>>\n  reviewer: CoderReviewer | undefined\n  selection: CoderWinnerSelection\n  task: CoderTask\n  signal: AbortSignal\n}\n\ninterface CoderCandidate {\n  index: number\n  output: CoderOutput\n  score: number\n  readiness: number\n}\n\n/**\n * Pick the winning coder candidate from a finished loop's iterations:\n *   1. keep only mechanically-VALID candidates (the validator already gated\n *      tests/typecheck/forbidden/diff/no-op/secrets),\n *   2. if a `reviewer` is wired, keep only those it APPROVES,\n *   3. select among survivors by the chosen strategy.\n * Returns `undefined` when nothing survives — the delegate fails loud.\n */\nasync function pickCoderWinner(args: PickCoderWinnerArgs): Promise<CoderOutput | undefined> {\n  const valid: CoderCandidate[] = []\n  for (const iter of args.iterations) {\n    if (iter.output === undefined || iter.error || iter.verdict?.valid !== true) continue\n    valid.push({\n      index: iter.index,\n      output: iter.output,\n      score: iter.verdict.score ?? 0,\n      readiness: iter.verdict.score ?? 0,\n    })\n  }\n  if (valid.length === 0) return undefined\n\n  let eligible = valid\n  if (args.reviewer) {\n    eligible = []\n    for (const c of valid) {\n      const review = await args.reviewer(c.output, args.task, { signal: args.signal })\n      if (review.approved) eligible.push({ ...c, readiness: review.readiness })\n    }\n    if (eligible.length === 0) return undefined\n  }\n\n  return selectCoderCandidate(eligible, args.selection).output\n}\n\n/** Apply the winner-selection strategy; ties broken by earliest iteration. */\nfunction selectCoderCandidate(\n  candidates: CoderCandidate[],\n  selection: CoderWinnerSelection,\n): CoderCandidate {\n  const diffLines = (c: CoderCandidate) =>\n    c.output.diffStats.insertions + c.output.diffStats.deletions\n  const sorted = [...candidates].sort((a, b) => {\n    switch (selection) {\n      case 'smallest-diff':\n        return diffLines(a) - diffLines(b) || a.index - b.index\n      case 'highest-readiness':\n        return b.readiness - a.readiness || a.index - b.index\n      case 'first-approved':\n        return a.index - b.index\n      default:\n        return b.score - a.score || a.index - b.index\n    }\n  })\n  return sorted[0]!\n}\n\nfunction noWinnerMessage(reviewer: CoderReviewer | undefined): string {\n  return reviewer\n    ? 'coder delegate: no candidate passed validation + review'\n    : 'coder delegate: no candidate passed validation'\n}\n\nfunction buildCoderGoal(args: DelegateCodeArgs): string {\n  if (!args.contextHint) return args.goal\n  return [args.goal, '', '## Context', args.contextHint].join('\\n')\n}\n\nfunction resolveExecutor(options: CreateDefaultCoderDelegateOptions): DelegationExecutor {\n  if (options.executor && options.sandboxClient) {\n    throw new Error('createDefaultCoderDelegate: pass exactly one of `executor` or `sandboxClient`')\n  }\n  if (options.executor) return options.executor\n  if (options.sandboxClient) {\n    return createSiblingSandboxExecutor({ client: options.sandboxClient })\n  }\n  throw new Error('createDefaultCoderDelegate: `executor` or `sandboxClient` is required')\n}\n\n/**\n * Single-shot driver — plan one task on iteration 0, stop after one\n * iteration. Used by the coder delegate when `variants <= 1`. Keeps the\n * runLoop kernel-level accounting (timing, cost, trace emission) while\n * skipping fanout/refine topology overhead.\n */\nconst singleShotDriver = {\n  name: 'mcp-single-shot',\n  async plan<Task>(task: Task, history: ReadonlyArray<unknown>): Promise<Task[]> {\n    return history.length === 0 ? [task] : []\n  },\n  decide(history: ReadonlyArray<unknown>): 'pick-winner' | 'fail' {\n    return history.length > 0 ? 'pick-winner' : 'fail'\n  },\n}\n"],"mappings":";;;;;;;;;AA6CO,SAAS,6BACd,SACoB;AACpB,QAAM,aAAa,QAAQ;AAC3B,QAAM,SAA4B;AAAA,IAChC,OAAO,MAAuD;AAC5D,aAAO,WAAW,OAAO,IAAI;AAAA,IAC/B;AAAA,IACA,kBAAkB,KAA4C;AAC5D,aAAO,EAAE,MAAM,WAAW,WAAW,OAAO,GAAG,EAAE;AAAA,IACnD;AAAA,EACF;AACA,SAAO;AAAA,IACL;AAAA,IACA,WAAmB;AACjB,aAAO;AAAA,IACT;AAAA,EACF;AACF;AA2CO,SAAS,6BACd,SACoB;AACpB,QAAM,QAAQ,QAAQ;AACtB,QAAM,UAAU,IAAI,IAAI,QAAQ,qBAAqB,CAAC,CAAC;AACvD,MAAI,YAAY;AAIhB,QAAM,uBAAuB,oBAAI,IAAmC;AAEpE,QAAM,SAA4B;AAAA,IAChC,MAAM,SAAmC;AACvC,YAAM,MAAM,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,QAAQ,IAAI,EAAE,CAAC;AACrD,UAAI,IAAI,WAAW,GAAG;AACpB,cAAM,IAAI;AAAA,UACR,wBAAwB,MAAM,OAAO,0CAA0C,MAAM,IAAI,KAAK,GAAG,CAAC,gBAAgB,CAAC,GAAG,OAAO,EAAE,KAAK,GAAG,CAAC;AAAA,QAC1I;AAAA,MACF;AACA,YAAM,WAAW,QAAQ;AACzB,YAAM,YAAY,WAAW,SAAS,EAAE,WAAW,IAAI,CAAC,IAAI,IAAI,YAAY,IAAI,MAAM;AACtF,mBAAa;AACb,UAAI,OAAO,cAAc,YAAY,UAAU,WAAW,GAAG;AAC3D,cAAM,IAAI,MAAM,0EAA0E;AAAA,MAC5F;AACA,YAAM,MAAM,MAAM,MAAM,QAAQ,SAAS;AACzC,YAAM,YAAY,OAAO,GAAG;AAC5B,UAAI,UAAW,sBAAqB,IAAI,WAAW,EAAE,UAAU,CAAC;AAChE,aAAO;AAAA,IACT;AAAA,IACA,kBAAkB,KAA4C;AAC5D,YAAM,YAAY,OAAO,GAAG;AAC5B,YAAM,WAAW,YAAY,qBAAqB,IAAI,SAAS,IAAI;AACnE,aAAO;AAAA,QACL,MAAM;AAAA,QACN;AAAA,QACA,SAAS,MAAM;AAAA,QACf,WAAW,UAAU;AAAA,MACvB;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AAAA,IACL;AAAA,IACA,WAAmB;AACjB,YAAM,WAAW,QAAQ,OAAO,IAAI,eAAe,CAAC,GAAG,OAAO,EAAE,KAAK,GAAG,CAAC,OAAO;AAChF,aAAO,4BAA4B,MAAM,OAAO,eAAe,MAAM,IAAI,KAAK,GAAG,CAAC,IAAI,QAAQ;AAAA,IAChG;AAAA,EACF;AACF;AAEA,SAAS,OAAO,KAA0C;AACxD,QAAM,MAAO,IAAoC;AACjD,SAAO,OAAO,QAAQ,YAAY,IAAI,SAAS,IAAI,MAAM;AAC3D;;;AC/BO,SAAS,2BACd,SACe;AACf,QAAM,WAAW,gBAAgB,OAAO;AACxC,QAAM,gBAAgB,SAAS;AAC/B,QAAM,kBAAkB,QAAQ;AAChC,QAAM,iBAAiB,QAAQ,kBAAkB;AACjD,QAAM,eAAe,QAAQ;AAC7B,SAAO,OAAO,MAAM,QAAQ;AAC1B,UAAM,OAAkB;AAAA,MACtB,MAAM,eAAe,IAAI;AAAA,MACzB,UAAU,KAAK;AAAA,MACf,SAAS,KAAK,QAAQ;AAAA,MACtB,cAAc,KAAK,QAAQ;AAAA,MAC3B,gBAAgB,KAAK,QAAQ;AAAA,MAC7B,cAAc,KAAK,QAAQ;AAAA,IAC7B;AACA,UAAM,WAAW,KAAK,IAAI,GAAG,KAAK,MAAM,KAAK,YAAY,CAAC,CAAC;AAC3D,QAAI,OAAO,EAAE,WAAW,GAAG,OAAO,WAAW,CAAC;AAC9C,QAAI,YAAY,GAAG;AACjB,YAAM,EAAE,cAAc,QAAQ,UAAU,IAAI,aAAa,EAAE,KAAK,CAAC;AACjE,YAAMA,UAAS,MAAM,QAAQ;AAAA,QAC3B,QAAQ;AAAA,QACR,UAAU;AAAA,QACV;AAAA,QACA;AAAA,QACA;AAAA,QACA,KAAK,EAAE,eAAe,QAAQ,IAAI,QAAQ,GAAI,eAAe,EAAE,aAAa,IAAI,CAAC,EAAG;AAAA,QACpF,eAAe;AAAA,QACf;AAAA,MACF,CAAC;AACD,YAAMC,UAAS,MAAM,gBAAgB;AAAA,QACnC,YAAYD,QAAO;AAAA,QACnB,UAAU,QAAQ;AAAA,QAClB,WAAW,QAAQ,mBAAmB;AAAA,QACtC;AAAA,QACA,QAAQ,IAAI;AAAA,MACd,CAAC;AACD,UAAI,CAACC,QAAQ,OAAM,IAAI,MAAM,gBAAgB,QAAQ,QAAQ,CAAC;AAC9D,UAAI,OAAO,EAAE,WAAW,GAAG,OAAO,YAAY,CAAC;AAC/C,aAAOA;AAAA,IACT;AACA,UAAM,SAAS;AAAA,MACb,mBAAmB,gBAAgB,SAAS,IACxC,EAAE,WAAW,gBAAgB,MAAM,GAAG,QAAQ,EAAE,IAChD,EAAE,WAAW,OAAU;AAAA,IAC7B;AACA,UAAM,YAAY,OAAO,UAAU,MAAM,GAAG,QAAQ;AACpD,UAAM,SAAS,MAAM,QAAQ;AAAA,MAC3B,QAAQ,OAAO;AAAA,MACf;AAAA,MACA,QAAQ,OAAO;AAAA,MACf,WAAW,OAAO;AAAA,MAClB;AAAA,MACA,KAAK,EAAE,eAAe,QAAQ,IAAI,QAAQ,GAAI,eAAe,EAAE,aAAa,IAAI,CAAC,EAAG;AAAA,MACpF,eAAe;AAAA,MACf,gBAAgB,KAAK,IAAI,gBAAgB,QAAQ;AAAA,IACnD,CAAC;AACD,UAAM,SAAS,MAAM,gBAAgB;AAAA,MACnC,YAAY,OAAO;AAAA,MACnB,UAAU,QAAQ;AAAA,MAClB,WAAW,QAAQ,mBAAmB;AAAA,MACtC;AAAA,MACA,QAAQ,IAAI;AAAA,IACd,CAAC;AACD,QAAI,CAAC,OAAQ,OAAM,IAAI,MAAM,gBAAgB,QAAQ,QAAQ,CAAC;AAC9D,QAAI,OAAO,EAAE,WAAW,UAAU,QAAQ,OAAO,YAAY,CAAC;AAC9D,WAAO;AAAA,EACT;AACF;AAyBA,eAAe,gBAAgB,MAA6D;AAC1F,QAAM,QAA0B,CAAC;AACjC,aAAW,QAAQ,KAAK,YAAY;AAClC,QAAI,KAAK,WAAW,UAAa,KAAK,SAAS,KAAK,SAAS,UAAU,KAAM;AAC7E,UAAM,KAAK;AAAA,MACT,OAAO,KAAK;AAAA,MACZ,QAAQ,KAAK;AAAA,MACb,OAAO,KAAK,QAAQ,SAAS;AAAA,MAC7B,WAAW,KAAK,QAAQ,SAAS;AAAA,IACnC,CAAC;AAAA,EACH;AACA,MAAI,MAAM,WAAW,EAAG,QAAO;AAE/B,MAAI,WAAW;AACf,MAAI,KAAK,UAAU;AACjB,eAAW,CAAC;AACZ,eAAW,KAAK,OAAO;AACrB,YAAM,SAAS,MAAM,KAAK,SAAS,EAAE,QAAQ,KAAK,MAAM,EAAE,QAAQ,KAAK,OAAO,CAAC;AAC/E,UAAI,OAAO,SAAU,UAAS,KAAK,EAAE,GAAG,GAAG,WAAW,OAAO,UAAU,CAAC;AAAA,IAC1E;AACA,QAAI,SAAS,WAAW,EAAG,QAAO;AAAA,EACpC;AAEA,SAAO,qBAAqB,UAAU,KAAK,SAAS,EAAE;AACxD;AAGA,SAAS,qBACP,YACA,WACgB;AAChB,QAAM,YAAY,CAAC,MACjB,EAAE,OAAO,UAAU,aAAa,EAAE,OAAO,UAAU;AACrD,QAAM,SAAS,CAAC,GAAG,UAAU,EAAE,KAAK,CAAC,GAAG,MAAM;AAC5C,YAAQ,WAAW;AAAA,MACjB,KAAK;AACH,eAAO,UAAU,CAAC,IAAI,UAAU,CAAC,KAAK,EAAE,QAAQ,EAAE;AAAA,MACpD,KAAK;AACH,eAAO,EAAE,YAAY,EAAE,aAAa,EAAE,QAAQ,EAAE;AAAA,MAClD,KAAK;AACH,eAAO,EAAE,QAAQ,EAAE;AAAA,MACrB;AACE,eAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE;AAAA,IAC5C;AAAA,EACF,CAAC;AACD,SAAO,OAAO,CAAC;AACjB;AAEA,SAAS,gBAAgB,UAA6C;AACpE,SAAO,WACH,4DACA;AACN;AAEA,SAAS,eAAe,MAAgC;AACtD,MAAI,CAAC,KAAK,YAAa,QAAO,KAAK;AACnC,SAAO,CAAC,KAAK,MAAM,IAAI,cAAc,KAAK,WAAW,EAAE,KAAK,IAAI;AAClE;AAEA,SAAS,gBAAgB,SAAgE;AACvF,MAAI,QAAQ,YAAY,QAAQ,eAAe;AAC7C,UAAM,IAAI,MAAM,+EAA+E;AAAA,EACjG;AACA,MAAI,QAAQ,SAAU,QAAO,QAAQ;AACrC,MAAI,QAAQ,eAAe;AACzB,WAAO,6BAA6B,EAAE,QAAQ,QAAQ,cAAc,CAAC;AAAA,EACvE;AACA,QAAM,IAAI,MAAM,uEAAuE;AACzF;AAQA,IAAM,mBAAmB;AAAA,EACvB,MAAM;AAAA,EACN,MAAM,KAAW,MAAY,SAAkD;AAC7E,WAAO,QAAQ,WAAW,IAAI,CAAC,IAAI,IAAI,CAAC;AAAA,EAC1C;AAAA,EACA,OAAO,SAAyD;AAC9D,WAAO,QAAQ,SAAS,IAAI,gBAAgB;AAAA,EAC9C;AACF;","names":["result","chosen"]}