@tangle-network/agent-runtime 0.38.0 → 0.40.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-3WQJRSUJ.js

@@ -0,0 +1,201 @@
+import {
+  runAnalystLoop
+} from "./chunk-XBUG326M.js";
+import {
+  optimizePrompt
+} from "./chunk-VOX6Z3II.js";
+import {
+  createKbGate
+} from "./chunk-FNMGYYSS.js";
+import {
+  createDefaultCoderDelegate
+} from "./chunk-VFKBIZTY.js";
+import {
+  createDynamicDriver,
+  runLoop
+} from "./chunk-OISRXLWI.js";
+import {
+  ConfigError
+} from "./chunk-SQSCRJ7U.js";
+
+// src/loop-runner.ts
+var DELEGATED_LOOP_MODES = [
+  "code",
+  "review",
+  "research",
+  "audit",
+  "self-improve",
+  "dynamic"
+];
+function isDelegatedLoopMode(value) {
+  return typeof value === "string" && DELEGATED_LOOP_MODES.includes(value);
+}
+async function runDelegatedLoop(mode, registry, options = {}) {
+  const runner = registry[mode];
+  if (!runner) {
+    throw new ConfigError(
+      `runDelegatedLoop: no runner registered for mode '${mode}' (registered: ${Object.keys(registry).join(", ") || "none"})`
+    );
+  }
+  const now = options.now ?? Date.now;
+  const signal = options.signal ?? new AbortController().signal;
+  const start = now();
+  try {
+    const output = await runner(signal);
+    return { mode, ok: true, output, durationMs: now() - start };
+  } catch (err) {
+    return {
+      mode,
+      ok: false,
+      error: err instanceof Error ? err.message : String(err),
+      durationMs: now() - start
+    };
+  }
+}
+function coderLoopRunner(options) {
+  const delegate = createDefaultCoderDelegate({
+    sandboxClient: options.sandboxClient,
+    ...options.reviewer ? { reviewer: options.reviewer } : {},
+    ...options.winnerSelection ? { winnerSelection: options.winnerSelection } : {},
+    ...options.fanoutHarnesses ? { fanoutHarnesses: options.fanoutHarnesses } : {}
+  });
+  return async (signal) => {
+    const ctx = { signal, report: () => {
+    } };
+    return delegate(options.args, ctx);
+  };
+}
+function reviewLoopRunner(options) {
+  return coderLoopRunner(options);
+}
+function dynamicLoopRunner(o) {
+  return async (signal) => runLoop({
+    driver: createDynamicDriver({
+      planner: o.planner,
+      ...o.maxIterations !== void 0 ? { maxIterations: o.maxIterations } : {},
+      ...o.maxFanout !== void 0 ? { maxFanout: o.maxFanout } : {}
+    }),
+    ...o.agentRun ? { agentRun: o.agentRun } : {},
+    ...o.agentRuns ? { agentRuns: o.agentRuns } : {},
+    output: o.output,
+    ...o.validator ? { validator: o.validator } : {},
+    task: o.task,
+    ctx: { sandboxClient: o.sandboxClient, signal },
+    ...o.maxIterations !== void 0 ? { maxIterations: o.maxIterations } : {}
+  });
+}
+function researchLoopRunner(o) {
+  const gate = createKbGate(o.gate);
+  const maxRounds = Math.max(1, Math.trunc(o.maxRounds ?? 1));
+  return async (signal) => {
+    const accepted = [];
+    let vetoed = [];
+    let rounds = 0;
+    for (let round = 0; round < maxRounds; round += 1) {
+      if (signal.aborted) break;
+      rounds += 1;
+      const candidates = await o.research(round, vetoed);
+      if (candidates.length === 0) break;
+      vetoed = [];
+      for (const c of candidates) {
+        const v = await gate(c);
+        if (v.accepted) accepted.push(c);
+        else vetoed.push({ candidate: c, vetoedBy: v.vetoedBy, reason: v.reason });
+      }
+      if (vetoed.length === 0) break;
+    }
+    return { accepted, vetoed, rounds };
+  };
+}
+function selfImproveLoopRunner(options) {
+  return async () => optimizePrompt(options);
+}
+function auditLoopRunner(options) {
+  return async () => runAnalystLoop(options);
+}
+
+// src/loop-runner-bin.ts
+async function runLoopRunnerCli(args) {
+  if (!isDelegatedLoopMode(args.mode)) {
+    return {
+      exitCode: 2,
+      error: `unknown mode '${args.mode}' (expected one of: ${DELEGATED_LOOP_MODES.join(", ")})`
+    };
+  }
+  let registry;
+  try {
+    registry = await args.loadRegistry();
+  } catch (err) {
+    return { exitCode: 2, error: `failed to load registry: ${errMsg(err)}` };
+  }
+  if (!registry[args.mode]) {
+    return {
+      exitCode: 2,
+      error: `config registers no runner for mode '${args.mode}' (registered: ${Object.keys(registry).join(", ") || "none"})`
+    };
+  }
+  const result = await runDelegatedLoop(args.mode, registry, {
+    ...args.now ? { now: args.now } : {}
+  });
+  return { exitCode: result.ok ? 0 : 1, result };
+}
+function parseLoopRunnerArgv(argv) {
+  const out = {};
+  for (let i = 0; i < argv.length; i += 1) {
+    const a = argv[i];
+    if (a === "--mode") out.mode = argv[++i];
+    else if (a === "--config") out.config = argv[++i];
+    else if (a?.startsWith("--mode=")) out.mode = a.slice("--mode=".length);
+    else if (a?.startsWith("--config=")) out.config = a.slice("--config=".length);
+  }
+  return out;
+}
+function resolveRegistry(mod) {
+  const def = mod?.default ?? mod;
+  const value = typeof def === "function" ? def() : def;
+  return value;
+}
+function errMsg(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+async function main() {
+  const { mode, config } = parseLoopRunnerArgv(process.argv.slice(2));
+  if (!mode || !config) {
+    process.stderr.write(
+      `usage: agent-runtime-loop --mode <mode> --config <module>
+  modes: ${DELEGATED_LOOP_MODES.join(" | ")}
+  config: a JS/TS module default-exporting a DelegatedLoopRegistry (or a factory)
+`
+    );
+    process.exit(2);
+  }
+  const { pathToFileURL } = await import("url");
+  const { resolve } = await import("path");
+  const cli = await runLoopRunnerCli({
+    mode,
+    loadRegistry: async () => resolveRegistry(await import(pathToFileURL(resolve(config)).href))
+  });
+  process.stdout.write(`${JSON.stringify(cli.result ?? { error: cli.error }, null, 2)}
+`);
+  if (cli.error) process.stderr.write(`${cli.error}
+`);
+  process.exit(cli.exitCode);
+}
+if (process.argv[1] && /loop-runner-bin\.(js|ts|mjs)$/.test(process.argv[1])) {
+  void main();
+}
+
+export {
+  DELEGATED_LOOP_MODES,
+  isDelegatedLoopMode,
+  runDelegatedLoop,
+  coderLoopRunner,
+  reviewLoopRunner,
+  dynamicLoopRunner,
+  researchLoopRunner,
+  selfImproveLoopRunner,
+  auditLoopRunner,
+  runLoopRunnerCli,
+  parseLoopRunnerArgv
+};
+//# sourceMappingURL=chunk-3WQJRSUJ.js.map

package/dist/chunk-3WQJRSUJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/loop-runner.ts","../src/loop-runner-bin.ts"],"sourcesContent":["/**\n * @experimental\n *\n * `runDelegatedLoop` — the configured delegated loop-runner.\n *\n * One typed entrypoint a worker agent (or a scheduled routine) calls to run a\n * disciplined loop in a chosen MODE, over agent-runtime's hardened engines:\n *\n *   code         → build-in-a-loop via the coder delegate (no-op + secret floor,\n *                  optional reviewer gate, winner-selection)\n *   review       → code mode with a REQUIRED reviewer (the gate is the point)\n *   research     → research-in-a-loop with valid-only KB growth (createKbGate)\n *   audit        → analyze trace/run data → findings (runAnalystLoop, caller-wired)\n *   self-improve → identity-gated prompt optimization (optimizePrompt, caller-wired)\n *   dynamic      → agent-authored topology (runLoop + createDynamicDriver)\n *\n * It is intentionally a thin façade: the value is that EVERY product reuses the\n * one hardened engine instead of forking delegation logic. The dispatcher owns\n * mode routing, timing, fail-loud on an unregistered mode, and a uniform result\n * shape; each mode's engine is a pre-configured runner in the registry (build it\n * with the factories below, or inject your own / a stub).\n */\n\nimport type { Scenario } from '@tangle-network/agent-eval/campaign'\nimport { runAnalystLoop } from './analyst-loop'\nimport type { RunAnalystLoopOpts, RunAnalystLoopResult } from './analyst-loop/types'\nimport { ConfigError } from './errors'\nimport {\n  type OptimizePromptOptions,\n  type OptimizePromptResult,\n  optimizePrompt,\n} from './improvement/optimize-prompt'\nimport {\n  type AgentRunSpec,\n  createDynamicDriver,\n  type DynamicDecision,\n  type LoopResult,\n  type LoopSandboxClient,\n  type OutputAdapter,\n  runLoop,\n  type TopologyPlanner,\n  type Validator,\n} from './loops'\nimport {\n  type CoderReviewer,\n  type CoderWinnerSelection,\n  createDefaultCoderDelegate,\n  type DelegateRunCtx,\n} from './mcp/delegates'\nimport { type CreateKbGateOptions, createKbGate, type FactCandidate } from './mcp/kb-gate'\nimport type { DelegateCodeArgs } from './mcp/types'\nimport type { CoderOutput } from './profiles/coder'\n\n/** @experimental Every delegated-loop mode, for validation + CLI surfaces. */\nexport const DELEGATED_LOOP_MODES = [\n  'code',\n  'review',\n  'research',\n  'audit',\n  'self-improve',\n  'dynamic',\n] as const\n\n/** @experimental */\nexport type DelegatedLoopMode = (typeof DELEGATED_LOOP_MODES)[number]\n\n/** @experimental Type guard for an untrusted mode string (CLI / config input). */\nexport function isDelegatedLoopMode(value: unknown): value is DelegatedLoopMode {\n  return typeof value === 'string' && (DELEGATED_LOOP_MODES as readonly string[]).includes(value)\n}\n\n/** @experimental A pre-configured loop for one mode. Returns the mode's raw\n *  output; the dispatcher wraps it in a {@link DelegatedLoopResult}. */\nexport type DelegatedLoopRunner<T = unknown> = (signal: AbortSignal) => Promise<T>\n\n/** @experimental Mode → configured runner. Partial: only register the modes a\n *  given product/routine actually uses. */\nexport type DelegatedLoopRegistry = Partial<Record<DelegatedLoopMode, DelegatedLoopRunner>>\n\n/** @experimental Uniform result — never throws from a registered runner; a\n *  thrown engine becomes `{ ok: false, error }` so a routine can record + move on. */\nexport interface DelegatedLoopResult<T = unknown> {\n  mode: DelegatedLoopMode\n  ok: boolean\n  output?: T\n  error?: string\n  durationMs: number\n}\n\n/** @experimental */\nexport interface RunDelegatedLoopOptions {\n  signal?: AbortSignal\n  /** Clock override for deterministic tests. */\n  now?: () => number\n}\n\n/**\n * @experimental\n *\n * Dispatch a configured loop by mode. Fails loud (throws `ConfigError`) when no\n * runner is registered for the mode — a routine pointed at an unwired mode is a\n * config bug, not a silent no-op. A runner that throws is captured as\n * `{ ok: false }` so unattended runs record the failure rather than crash.\n */\nexport async function runDelegatedLoop<T = unknown>(\n  mode: DelegatedLoopMode,\n  registry: DelegatedLoopRegistry,\n  options: RunDelegatedLoopOptions = {},\n): Promise<DelegatedLoopResult<T>> {\n  const runner = registry[mode] as DelegatedLoopRunner<T> | undefined\n  if (!runner) {\n    throw new ConfigError(\n      `runDelegatedLoop: no runner registered for mode '${mode}' (registered: ${\n        Object.keys(registry).join(', ') || 'none'\n      })`,\n    )\n  }\n  const now = options.now ?? Date.now\n  const signal = options.signal ?? new AbortController().signal\n  const start = now()\n  try {\n    const output = await runner(signal)\n    return { mode, ok: true, output, durationMs: now() - start }\n  } catch (err) {\n    return {\n      mode,\n      ok: false,\n      error: err instanceof Error ? err.message : String(err),\n      durationMs: now() - start,\n    }\n  }\n}\n\n/** @experimental Options for the default `code`/`review` runner. */\nexport interface CoderLoopRunnerOptions {\n  sandboxClient: LoopSandboxClient\n  /** What to build — the delegate args (goal, repoRoot, variants, config, …). */\n  args: DelegateCodeArgs\n  /** Adversarial reviewer. REQUIRED for `review` mode (see `reviewLoopRunner`). */\n  reviewer?: CoderReviewer\n  /** Winner-selection strategy. Default `highest-score`. */\n  winnerSelection?: CoderWinnerSelection\n  /** Harnesses for `variants > 1` fanout. */\n  fanoutHarnesses?: string[]\n}\n\n/** @experimental Build a `code`-mode runner over the hardened coder delegate. */\nexport function coderLoopRunner(options: CoderLoopRunnerOptions): DelegatedLoopRunner<CoderOutput> {\n  const delegate = createDefaultCoderDelegate({\n    sandboxClient: options.sandboxClient,\n    ...(options.reviewer ? { reviewer: options.reviewer } : {}),\n    ...(options.winnerSelection ? { winnerSelection: options.winnerSelection } : {}),\n    ...(options.fanoutHarnesses ? { fanoutHarnesses: options.fanoutHarnesses } : {}),\n  })\n  return async (signal) => {\n    const ctx: DelegateRunCtx = { signal, report: () => {} }\n    return delegate(options.args, ctx)\n  }\n}\n\n/**\n * @experimental\n *\n * `review` mode = `code` with a REQUIRED reviewer. The gate is the whole point,\n * so the type forces a reviewer (a \"review loop\" with no reviewer is a code loop).\n */\nexport function reviewLoopRunner(\n  options: CoderLoopRunnerOptions & { reviewer: CoderReviewer },\n): DelegatedLoopRunner<CoderOutput> {\n  return coderLoopRunner(options)\n}\n\n/** @experimental Options for the default `dynamic` runner. */\nexport interface DynamicLoopRunnerOptions<Task, Output> {\n  sandboxClient: LoopSandboxClient\n  /** The agent-authored topology planner (e.g. `createSandboxPlanner(...)`). */\n  planner: TopologyPlanner<Task, Output>\n  task: Task\n  output: OutputAdapter<Output>\n  validator?: Validator<Output>\n  /** Exactly one of `agentRun` / `agentRuns` (runLoop validates). */\n  agentRun?: AgentRunSpec<Task>\n  agentRuns?: AgentRunSpec<Task>[]\n  maxIterations?: number\n  maxFanout?: number\n}\n\n/** @experimental `dynamic` mode — agent-authored topology over `runLoop`. */\nexport function dynamicLoopRunner<Task, Output>(\n  o: DynamicLoopRunnerOptions<Task, Output>,\n): DelegatedLoopRunner<LoopResult<Task, Output, DynamicDecision>> {\n  return async (signal) =>\n    runLoop<Task, Output, DynamicDecision>({\n      driver: createDynamicDriver<Task, Output>({\n        planner: o.planner,\n        ...(o.maxIterations !== undefined ? { maxIterations: o.maxIterations } : {}),\n        ...(o.maxFanout !== undefined ? { maxFanout: o.maxFanout } : {}),\n      }),\n      ...(o.agentRun ? { agentRun: o.agentRun } : {}),\n      ...(o.agentRuns ? { agentRuns: o.agentRuns } : {}),\n      output: o.output,\n      ...(o.validator ? { validator: o.validator } : {}),\n      task: o.task,\n      ctx: { sandboxClient: o.sandboxClient, signal },\n      ...(o.maxIterations !== undefined ? { maxIterations: o.maxIterations } : {}),\n    })\n}\n\n/** @experimental A fact rejected at the KB gate — surfaced, never dropped. */\nexport interface VetoedFact {\n  candidate: FactCandidate\n  vetoedBy?: string\n  reason?: string\n}\n\n/** @experimental */\nexport interface ResearchLoopResult {\n  /** Facts that passed the fail-closed gate — safe to write to the KB. */\n  accepted: FactCandidate[]\n  /** Facts the gate vetoed in the final round — escalate, do not silently drop. */\n  vetoed: VetoedFact[]\n  /** Research rounds actually run. */\n  rounds: number\n}\n\n/** @experimental Options for the default `research` runner. */\nexport interface ResearchLoopRunnerOptions {\n  /**\n   * The research engine (the consumer's web/doc searcher + extractor). Called\n   * each round with the prior round's vetoes so it can re-research the gaps.\n   * Returns fact candidates carrying their grounding (`verbatimPassage` +\n   * `sourceText`).\n   */\n  research: (round: number, vetoed: VetoedFact[]) => Promise<FactCandidate[]>\n  /** Gate config (extra judges, self-artifact kinds, …). The floor is always on. */\n  gate?: CreateKbGateOptions\n  /** Max research rounds (correct-on-veto remediation). Default 1. */\n  maxRounds?: number\n}\n\n/**\n * @experimental `research` mode — research-in-a-loop with valid-only KB growth.\n *\n * Each round: research → gate every candidate (fail-closed; passage MUST be in\n * the source) → accept the clean ones → re-research the vetoed ones next round,\n * up to `maxRounds`. Vetoed facts in the final round are RETURNED (escalate,\n * never silently dropped) so the caller audits vs retries.\n */\nexport function researchLoopRunner(\n  o: ResearchLoopRunnerOptions,\n): DelegatedLoopRunner<ResearchLoopResult> {\n  const gate = createKbGate(o.gate)\n  const maxRounds = Math.max(1, Math.trunc(o.maxRounds ?? 1))\n  return async (signal) => {\n    const accepted: FactCandidate[] = []\n    let vetoed: VetoedFact[] = []\n    let rounds = 0\n    for (let round = 0; round < maxRounds; round += 1) {\n      if (signal.aborted) break\n      rounds += 1\n      const candidates = await o.research(round, vetoed)\n      if (candidates.length === 0) break\n      vetoed = []\n      for (const c of candidates) {\n        const v = await gate(c)\n        if (v.accepted) accepted.push(c)\n        else vetoed.push({ candidate: c, vetoedBy: v.vetoedBy, reason: v.reason })\n      }\n      if (vetoed.length === 0) break\n    }\n    return { accepted, vetoed, rounds }\n  }\n}\n\n/** @experimental `self-improve` mode — identity-gated prompt optimization. */\nexport function selfImproveLoopRunner<TScenario extends Scenario, TArtifact>(\n  options: OptimizePromptOptions<TScenario, TArtifact>,\n): DelegatedLoopRunner<OptimizePromptResult<TArtifact, TScenario>> {\n  return async () => optimizePrompt<TScenario, TArtifact>(options)\n}\n\n/** @experimental `audit` mode — analyst loop over captured trace/run data. */\nexport function auditLoopRunner<TProposal = unknown, TEdit = unknown>(\n  options: RunAnalystLoopOpts,\n): DelegatedLoopRunner<RunAnalystLoopResult<TProposal, TEdit>> {\n  return async () => runAnalystLoop<TProposal, TEdit>(options)\n}\n","#!/usr/bin/env node\n/**\n * @experimental\n *\n * `agent-runtime-loop` — the schedulable entrypoint for the configured\n * delegated loop-runner. A cron job / routine / Makefile target invokes:\n *\n *   agent-runtime-loop --mode research --config ./loops.config.js\n *\n * The config module wires the registry (with full access to env / creds —\n * which is why the deps live there, not in this generic bin). It must default-\n * export a `DelegatedLoopRegistry`, or a `() => DelegatedLoopRegistry | Promise<…>`.\n * The bin runs the selected mode, prints the `DelegatedLoopResult` as JSON, and\n * exits 0 on `ok`, 1 on a recorded failure, 2 on a usage/config error.\n */\n\nimport {\n  DELEGATED_LOOP_MODES,\n  type DelegatedLoopMode,\n  type DelegatedLoopRegistry,\n  type DelegatedLoopResult,\n  isDelegatedLoopMode,\n  runDelegatedLoop,\n} from './loop-runner'\n\n/** @experimental Parsed CLI invocation. */\nexport interface LoopRunnerCliArgs {\n  mode: string\n  /** Loads the registry — the bin wires this from `--config`; tests inject a stub. */\n  loadRegistry: () => Promise<DelegatedLoopRegistry> | DelegatedLoopRegistry\n  now?: () => number\n}\n\n/** @experimental */\nexport interface LoopRunnerCliResult {\n  exitCode: number\n  result?: DelegatedLoopResult\n  error?: string\n}\n\n/**\n * @experimental\n *\n * Pure CLI core (no process / argv / IO) so it's unit-testable: validate the\n * mode, load the registry, dispatch, map to an exit code (0 ok / 1 failed /\n * 2 usage). Exported for embedding in custom runners + tests.\n */\nexport async function runLoopRunnerCli(args: LoopRunnerCliArgs): Promise<LoopRunnerCliResult> {\n  if (!isDelegatedLoopMode(args.mode)) {\n    return {\n      exitCode: 2,\n      error: `unknown mode '${args.mode}' (expected one of: ${DELEGATED_LOOP_MODES.join(', ')})`,\n    }\n  }\n  let registry: DelegatedLoopRegistry\n  try {\n    registry = await args.loadRegistry()\n  } catch (err) {\n    return { exitCode: 2, error: `failed to load registry: ${errMsg(err)}` }\n  }\n  if (!registry[args.mode]) {\n    return {\n      exitCode: 2,\n      error: `config registers no runner for mode '${args.mode}' (registered: ${\n        Object.keys(registry).join(', ') || 'none'\n      })`,\n    }\n  }\n  // runDelegatedLoop throws only on a missing runner (guarded above); a failing\n  // engine is captured as { ok: false } → exit 1, not a crash.\n  const result = await runDelegatedLoop(args.mode as DelegatedLoopMode, registry, {\n    ...(args.now ? { now: args.now } : {}),\n  })\n  return { exitCode: result.ok ? 0 : 1, result }\n}\n\n/** Parse `--mode X --config Y` from an argv tail (`process.argv.slice(2)`). */\nexport function parseLoopRunnerArgv(argv: string[]): { mode?: string; config?: string } {\n  const out: { mode?: string; config?: string } = {}\n  for (let i = 0; i < argv.length; i += 1) {\n    const a = argv[i]\n    if (a === '--mode') out.mode = argv[++i]\n    else if (a === '--config') out.config = argv[++i]\n    else if (a?.startsWith('--mode=')) out.mode = a.slice('--mode='.length)\n    else if (a?.startsWith('--config=')) out.config = a.slice('--config='.length)\n  }\n  return out\n}\n\n/** Normalize a config module's default export → a registry. */\nfunction resolveRegistry(mod: unknown): DelegatedLoopRegistry {\n  const def = (mod as { default?: unknown })?.default ?? mod\n  const value = typeof def === 'function' ? (def as () => unknown)() : def\n  return value as DelegatedLoopRegistry\n}\n\nfunction errMsg(err: unknown): string {\n  return err instanceof Error ? err.message : String(err)\n}\n\n/** The argv → IO → exit shell. Kept thin; logic lives in `runLoopRunnerCli`. */\nasync function main(): Promise<void> {\n  const { mode, config } = parseLoopRunnerArgv(process.argv.slice(2))\n  if (!mode || !config) {\n    process.stderr.write(\n      'usage: agent-runtime-loop --mode <mode> --config <module>\\n' +\n        `  modes: ${DELEGATED_LOOP_MODES.join(' | ')}\\n` +\n        '  config: a JS/TS module default-exporting a DelegatedLoopRegistry (or a factory)\\n',\n    )\n    process.exit(2)\n  }\n  const { pathToFileURL } = await import('node:url')\n  const { resolve } = await import('node:path')\n  const cli = await runLoopRunnerCli({\n    mode,\n    loadRegistry: async () => resolveRegistry(await import(pathToFileURL(resolve(config)).href)),\n  })\n  process.stdout.write(`${JSON.stringify(cli.result ?? { error: cli.error }, null, 2)}\\n`)\n  if (cli.error) process.stderr.write(`${cli.error}\\n`)\n  process.exit(cli.exitCode)\n}\n\n// Run only when executed as the bin (not when imported for the testable core).\nif (process.argv[1] && /loop-runner-bin\\.(js|ts|mjs)$/.test(process.argv[1])) {\n  void main()\n}\n"],"mappings":"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","names":[]}