@tangle-network/agent-runtime 0.104.0 → 0.105.0

package/README.md

@@ -1,6 +1,7 @@
 # @tangle-network/agent-runtime
 
-A TypeScript runtime for running AI agents — as a **chat turn**, a **one-shot task**, or a **team of agents** working toward a goal — that records every run and uses those records to **measure and improve** agents against real pass/fail checks. It is the engine Tangle's own production agents run on.
+A TypeScript runtime for chat agents, one-shot tasks, and agent teams.
+It records each run so you can measure changes against real pass/fail checks and improve the agent without changing your product integration.
 
 Domain behavior (models, tools, knowledge) plugs in as adapters; the scoring statistics and the ship decision come from [`@tangle-network/agent-eval`](https://www.npmjs.com/package/@tangle-network/agent-eval); sandboxed execution from [`@tangle-network/sandbox`](https://www.npmjs.com/package/@tangle-network/sandbox).
 
@@ -24,12 +25,15 @@ pnpm add @tangle-network/agent-runtime @tangle-network/agent-eval @tangle-networ
 
 ## Quickstart (offline, no API keys)
 
-The core move everything else builds on: a driver runs a worker, reads the worker's real output, and writes the next prompt from it until a check passes. This is the full working loop from [`examples/quickstart/quickstart.ts`](./examples/quickstart/quickstart.ts) (the worker is a scripted stand-in so it runs with zero credentials; swap it for a real sandbox, CLI-harness, or router backend without changing the driver):
+A driver runs a worker, reads its output, and writes the next prompt until a check passes.
+This excerpt shows the driver from the runnable [`examples/quickstart/quickstart.ts`](./examples/quickstart/quickstart.ts).
+That file defines the scripted `worker`, `output`, and `validator` used below so it runs without credentials.
+Replace the scripted worker with a sandbox, CLI bridge, or router backend without changing the driver.
 
 ```ts
-import { inProcessSandboxClient, runLoop } from '@tangle-network/agent-runtime/loops'
+import { inProcessSandboxClient, runAgentRounds } from '@tangle-network/agent-runtime/loops'
 
-const result = await runLoop<Task, Note, 'refine' | 'pick-winner' | 'fail'>({
+const result = await runAgentRounds<Task, Note, 'refine' | 'pick-winner' | 'fail'>({
   task: { prompt: 'Write a one-line release note for one-click restore.' },
   driver: {
     name: 'refine',
@@ -56,12 +60,12 @@ Run it from a clone of this repo and you get exactly this:
 ```bash
 $ pnpm i && pnpm build
 $ pnpm tsx examples/quickstart/quickstart.ts
-shot 0: reject — "Shipped one-click restore."
-shot 1: PASS — "Shipped one-click restore with an instant rollback path."
-decision: pick-winner — winner: shot 1
+shot 0: reject: "Shipped one-click restore."
+shot 1: PASS: "Shipped one-click restore with an instant rollback path."
+decision: pick-winner: winner: shot 1
 ```
 
-The fully annotated version of this loop, with every seam explained, is [`examples/driver-loop`](./examples/driver-loop).
+The annotated version is [`examples/driver-loop`](./examples/driver-loop).
 
 ## What you do with it
 
@@ -69,7 +73,7 @@ The fully annotated version of this loop, with every seam explained, is [`exampl
 |---|---|
 | Run a **chat turn** for a production product agent | `handleChatTurn(...)` |
 | Have one agent **supervise a team of agents** toward a goal | `supervise(profile, task, opts)` |
-| **Improve** an agent and prove the gain on fresh tasks | `improve(profile, findings, opts)` |
+| **Improve** an agent and prove the gain on fresh tasks | `improve(profile, opts)` |
 | Produce a measured knowledge-base candidate with agents and checks | `runKnowledgeImprovementJob(...)` |
 | Evaluate or train the same agent on **PrimeIntellect** | `createPrimeIntellectPackage(...)` |
 
@@ -107,38 +111,150 @@ const result = await supervise(
 
 ### Improve an agent
 
-`improve` optimizes one part of an agent and returns a detached winner plus a decision. The decision is `ship` only when the candidate beats the current agent on tasks it never practiced on.
-It accepts prompt, skill document, curated memory, tool, MCP, hook, subagent, whole-profile, and code surfaces through one call.
-Prompt, skill-document, and memory optimization have built-in generators; structured profile surfaces take an explicit generator, and code runs from isolated incumbent and candidate checkouts.
-Workflow and rollout-policy files use the code surface so the measured winner is an exact patch that can be sealed and executed; JSON parameter sweeps use agent-eval's `parameterSweepProposer` instead of a runtime-specific optimizer.
+`improve` runs one complete `OptimizationMethod` against one profile field.
+The method owns candidate generation and selection.
+Runtime keeps the final test set out of the method, scores the baseline and selected candidate on it, and returns `ship` only when the paired confidence interval clears `minimumLift`.
+The profile is never changed.
 
 ```ts
-import { improve } from '@tangle-network/agent-runtime'
+import { improve, officialGepa } from '@tangle-network/agent-runtime'
+import { canonicalCandidateDigest } from '@tangle-network/agent-interface'
 
-const { candidate, decision, lift } = await improve(baseProfile, findings, {
+const executionRef = canonicalCandidateDigest({
+  deployment: process.env.AGENT_DEPLOYMENT_SHA!,
+  model: process.env.AGENT_MODEL!,
+  tools: process.env.AGENT_TOOLSET_SHA!,
+})
+
+const optimizer = {
+  model: process.env.OPTIMIZER_MODEL!,
+  baseUrl: process.env.OPTIMIZER_BASE_URL!,
+  apiKey: process.env.OPTIMIZER_API_KEY!,
+  budget: {
+    maxCostUsd: 10,
+    maxRequests: 50,
+    maxRequestBytes: 2_000_000,
+    maxResponseBytes: 2_000_000,
+    maxOutputTokensPerRequest: 16_384,
+    pricing: {
+      inputUsdPerMillion: Number(process.env.OPTIMIZER_INPUT_USD_PER_MILLION),
+      outputUsdPerMillion: Number(process.env.OPTIMIZER_OUTPUT_USD_PER_MILLION),
+    },
+  },
+}
+
+const result = await improve(baseProfile, {
   surface: 'prompt',
-  gate: 'holdout',
-  scenarios,
-  judge,
-  agent,
+  executionRef,
+  method: officialGepa({
+    objective: 'Improve the complete support-agent prompt.',
+    recipe: {
+      kind: 'engine',
+      run: {
+        engine: 'gepa',
+        maxEvaluations: 40,
+        maxProposerCostUsd: 10,
+      },
+    },
+    optimizer,
+    resume: 'if-compatible',
+    trustResumeState: true,
+    describeScenario: ({ input }) => ({ input }),
+  }),
+  findings,
+  trainScenarios,
+  selectionScenarios,
+  testScenarios,
+  judges: [judge],
+  agent: (candidateProfile, scenario, ctx) =>
+    runProfile(candidateProfile, scenario, ctx),
+  runDir: '.runs/support-prompt',
+  costCeiling: 25,
 })
 
-if (decision === 'ship') console.log({ candidate, lift })
+if (result.decision === 'ship') {
+  console.log(result.candidate.profile, result.liftInterval)
+}
+```
+
+`officialGepa(...)` delegates the complete search to GEPA's upstream Optimize Anything API through agent-eval.
+Pass one explicit `engine`, `sequential`, `adaptive-sequential`, `best-of`, `vote`, or `omni` recipe.
+Runtime derives the upstream resume identity from `executionRef`, the complete baseline profile, and the selected surface.
+With `resume: 'if-compatible'`, agent-eval resumes only when the saved run identity matches the candidate, recipe, data, optimizer settings, runner, and derived execution identity.
+Set `trustResumeState: true` only when that run directory is private to the current operator.
+Use `resume: 'required'` to fail when no matching run exists.
+`result.provenance` reports the upstream package, run ID, resume status, evaluation count, and artifact directory.
+There is no local fallback.
+Install its optional Python process before using it:
+
+```bash
+python -m pip install "agent-eval-rpc==0.126.6"
+python -m pip install "gepa[full]==0.1.4"
+```
+
+The published GEPA 0.1.4 wheel supports the direct `gepa` engine.
+Sequential, adaptive, best-of, vote, Omni, AutoResearch, Meta Harness, and Best-of-N require the tested official source revision:
+
+```bash
+python -m pip install "gepa[full] @ git+https://github.com/gepa-ai/gepa.git@f919db0a622e2e9f9204779b81fe00cc1b2d808f"
 ```
 
-When the host runs complete profiles rather than mutable fields, use `profileDispatch(profile, scenario, ctx)` in place of `agent`.
-It is agent-eval's `ProfileDispatchFn`: Runtime gives it a frozen baseline or candidate profile and the same cost, trace, and cancellation context used for every measured cell.
-`profileDispatch` is unavailable for `surface: 'code'`, because code candidates require isolated worktrees.
+Use `officialSkillOpt(...)` for Microsoft's SkillOpt:
+
+```bash
+python -m pip install "agent-eval-rpc==0.126.6"
+python -m pip install "skillopt @ git+https://github.com/microsoft/SkillOpt.git@61735e3922efc2b90c6d6cab561e62e98452ca90"
+```
 
-Skill and curated-memory candidates are exact profile changes, not free-floating text.
-Name one inline skill through `skills.resourceName`; curated memory uses `profile.resources.instructions`.
-Both require `profile.resources.failOnError: true` so an unsupported resource cannot silently disappear.
+SkillOpt 0.2.0's published wheel omits prompt files required by `ReflACTTrainer`, so the tested SkillOpt source revision remains necessary.
+SkillOpt and GEPA's standard reflection engine require `optimizer: { model, baseUrl, apiKey, budget }`.
+Agent-based GEPA engines may own their model connection instead.
+Agent Eval proxies those model calls, enforces the nested budget, and records their cost.
+`costCeiling` is the total limit for optimizer calls, candidate runs, judges, and final scoring.
+Runtime returns `hold` when any part of that cost is unknown.
+Runtime rejects a reported total above the limit.
+
+SkillOpt accepts one text surface.
+GEPA accepts text or named components.
+Any complete method from `@tangle-network/agent-eval` uses the same call.
+The `agent` callback receives the complete immutable candidate profile, not a raw prompt or component fragment.
+Runtime uses that exact profile for every candidate run and returns the same measured profile in `result.candidate.profile`.
+`executionRef` is a content digest of the agent callback, profile component mapping, model, tools, and closure settings.
+Runtime combines it with the complete baseline profile and selected surface for saved work.
+Changing any of them runs the affected work again.
+For a skill, set `surface: 'skills'` and `skills.resourceName`.
+For the complete profile, set `surface: 'agent-profile'`.
+To optimize several named profile fields together, also provide `profileComponents.read` and `profileComponents.apply`.
+Tools, MCP, hooks, subagents, curated instructions, and rollout policy are also exact profile coordinates.
+Runtime does not choose an optimizer for them.
+
+Without `describeScenario`, the external optimizer receives only each development case ID.
+Without `describeArtifact`, evaluation feedback contains no artifact body.
+When either descriptor is present, its result passes through `redact` together with findings, background text, profile name, and judge notes.
+The built-in redactor removes common credentials and email addresses.
+Supply a domain redactor for customer names, account IDs, or other private data the built-in rules cannot identify.
+Runtime applies that hook first and then still applies its built-in scrubber.
+Set `redact: false` only when every outbound value is public and already reviewed.
+
+The selected profile surface is the optimizer's candidate and cannot be redacted without changing the measured candidate.
+Runtime always rejects recognized credentials in those bytes.
+It also rejects structurally sensitive fields such as MCP env, headers, URLs, metadata, and extensions.
+For `tools`, `mcp`, `hooks`, `subagents`, and `agent-profile`, Runtime treats the entire selected coordinate as execution-capable.
+Use `authorizeSensitiveCandidate` to inspect and accept each exact immutable profile containing public values or safe references.
+The callback runs for the baseline and every distinct candidate before either reaches your agent.
+Its `sensitivePaths` includes `$` when the whole coordinate requires review.
+
+Code is the exception.
+It uses Runtime's isolated git worktrees and coding-agent candidate execution:
 
 ```ts
-const skillResult = await improve(baseProfile, findings, {
-  surface: 'skills',
-  skills: { resourceName: 'incident-response' },
-  scenarios, judge, agent,
+const result = await improve({
+  surface: 'code',
+  code: { repoRoot, baseRef, generator },
+  scenarios,
+  judge,
+  agent,
+  budget,
 })
 ```
 
@@ -159,7 +275,16 @@ const result = await proposeAgentImprovement({
   runId,
   profile: liveProfile,
   analysis,
-  improvement: { surface: 'prompt', scenarios, judge, agent },
+  improvement: {
+    surface: 'prompt',
+    executionRef,
+    method,
+    trainScenarios,
+    selectionScenarios,
+    testScenarios,
+    judges: [judge],
+    agent,
+  },
   buildExperiment: ({ improvement }) =>
     buildExperimentMaterial({
       baseline,
@@ -191,10 +316,16 @@ const outcome = await executeAgentImprovementActivation(
 `buildExperimentMaterial`, `placeCell`, and the transaction functions are application ports because storage and compute differ by product.
 The builder returns only baseline, candidate, tasks, and policy; Runtime adds the search ancestry and seals the final experiment.
 Runtime owns candidate identity, measurement, review binding, expiry, retry identity, and result validation; the application owns its atomic write.
+Official optimizer proposals carry the observed package versions, optimizer model, evaluation and token usage, separate optimization and final-test costs, and resumed-run identity.
+`createOptimizationActivationReceipt(result)` exposes the same detached record for callers that need to inspect an `improve()` result before building a proposal.
 
 ### Improve a knowledge base
 
-`runKnowledgeImprovementJob` is the runtime-owned front door for KB, wiki, memory-backed, and RAG improvement jobs. It creates a candidate copy, runs supervised agents against it, checks readiness through `@tangle-network/agent-knowledge`, and returns frozen baseline and candidate snapshots with spend and timing. It never changes the live knowledge base. Use `improve(..., { surface: 'memory' })` for the agent's curated lesson document; use this job for source, retrieval, and knowledge-store changes.
+`runKnowledgeImprovementJob` runs KB, wiki, memory-backed, and RAG improvement jobs.
+It creates a candidate copy, runs agents against it, checks it through `@tangle-network/agent-knowledge`, and returns frozen baseline and candidate snapshots with spend and timing.
+It never changes the live knowledge base.
+Use `improve(profile, { surface: 'memory', ... })` for the agent's curated lesson document.
+Use this job for source, retrieval, and knowledge-store changes.
 
 ```ts
 import { runKnowledgeImprovementJob } from '@tangle-network/agent-runtime/knowledge'
@@ -202,6 +333,7 @@ import { runKnowledgeImprovementJob } from '@tangle-network/agent-runtime/knowle
 const result = await runKnowledgeImprovementJob({
   root: './kb',
   goal: 'Improve support refund-policy knowledge',
+  implementationRef: 'git:0123456789abcdef0123456789abcdef01234567',
   readinessSpecs,
   budget: { maxIterations: 8, maxTokens: 120_000, maxUsd: 10 },
   backend,
@@ -211,11 +343,13 @@ console.log(result.knowledge?.reference.candidateHash, result.measurement.superv
 ```
 
 Use it when the product needs one knob for "make this knowledge base better" instead of wiring `improveKnowledgeBase`, a runtime supervisor, candidate workspaces, and readiness checks by hand.
+Set `implementationRef` to the deployed `git:<40 hex>` revision or a `sha256:<64 hex>` digest covering every callback, model, index, and external setting that can change the result.
+The same run ID resumes only when this identity still matches.
 Measure the returned bundle pair, record the review, then activate through `executeAgentImprovementActivation`; activation is the only write path.
 
 ### Run on PrimeIntellect
 
-`@tangle-network/agent-runtime/primeintellect` packages typed train and eval tasks as a Verifiers v1 environment.
+`@tangle-network/agent-runtime/primeintellect` packages typed train and eval tasks as a PrimeIntellect Verifiers environment.
 Prime launches your actual runtime program against an intercepted model endpoint, so `runPersonified`, `runAgentic`, product agents, tool calls, and multiple rounds stay intact.
 Reference answers remain in Prime's task process and never enter the agent workspace.
 The runner file must be one executable bundle containing the app and its runtime dependencies.
@@ -229,7 +363,7 @@ import {
 
 const bundledRunner = await readFile('./dist/prime-runner.mjs', 'utf8')
 const bundle = createPrimeIntellectPackage({
-  name: 'support-agent-v1',
+  name: 'support-agent',
   version: '1.0.0',
   tasks: [
     {
@@ -253,7 +387,7 @@ const bundle = createPrimeIntellectPackage({
   },
 })
 
-await writePrimeIntellectPackage(bundle, './prime/support-agent-v1')
+await writePrimeIntellectPackage(bundle, './prime/support-agent')
 ```
 
 The runner reads the episode and uses the normal runtime APIs:
@@ -276,20 +410,20 @@ Use `importPrimeIntellectTraces(...)` to convert them to agent-eval `RunRecord`s
 
 ## How it works (the short version)
 
-- **One agent, run two ways.** The same agent runs at "do the task" speed and at "get better at the task" speed. "Driver", "worker", and "coordinator" are roles one agent plays, not separate types.
-- **Everything is measured.** Every run is a trace: tokens, dollars, time, and a pass/fail score from a real check. "Better" is a number with a denominator, not a vibe, and "equally good but cheaper" is a result you can prove.
-- **Improvement is gated.** A change ships only after it beats the current agent on fresh tasks no tuning step ever saw, with a statistical test, not a single lucky run.
-- **The grader is honest.** Whatever gives feedback never sees the answer key, and scores are recomputed from the attempts actually run. An agent cannot fabricate its own win.
+- **Roles are configuration.** Driver, worker, and coordinator describe what an agent does in a run. They are not separate agent types.
+- **Runs are recorded.** A run can report tokens, dollars, time, outputs, and scores.
+- **Candidates face fresh tasks.** The optimizer uses train and selection tasks. Promotion uses a separate final set.
+- **Scores come from executed attempts.** Runtime recomputes results from the recorded cells and rejects incomplete cost or source evidence.
 
 ## Primitives
 
-The general-purpose pieces, by import path. Every export with its one-line summary lives in the generated [`docs/api/primitive-catalog.md`](./docs/api/primitive-catalog.md) — check it before building anything new.
+The general-purpose pieces, by import path. Every export with its one-line summary lives in the generated [`docs/api/primitive-catalog.md`](./docs/api/primitive-catalog.md): check it before building anything new.
 
 | Primitive | What it does | Import |
 |---|---|---|
 | Chat-turn runtime | Stream, trace, and persist one production chat turn (`handleChatTurn`); normalize any backend's stream into one event shape (`streamAgentTurn`) | root · `/loops` |
 | Supervision | One agent spawns, budgets, and steers workers toward a goal (`supervise`, `delegate`), on an in-process loop or a sandboxed coding harness | `/loops` · `/mcp` |
-| Loop kernel + combinators | Write a driver (`plan`/`decide`) and run it (`runLoop`), or compose fixed shapes: refine (`loopUntil`), best-of-N (`fanout`), chain (`pipeline`), multi-judge (`panel`) | `/loops` |
+| Loop kernel + combinators | Write a driver (`plan`/`decide`) and run it (`runAgentRounds`), or compose fixed shapes: refine (`loopUntil`), best-of-N (`fanout`), chain (`pipeline`), multi-judge (`panel`) | `/loops` |
 | Improvement driver | Optimize one part of an agent and ship only if it wins on tasks it never practiced on (`improve`); production proposal/review/activation flow | root · `/intelligence` |
 | Benchmarks + leaderboards | Compare strategies with significance stats (`runBenchmark`), stand up a harness×model leaderboard (`defineLeaderboard`, `leaderboard`) | `/loops` |
 | Knowledge improvement | Produce a measured candidate copy of a KB/wiki/RAG corpus without touching the live one (`runKnowledgeImprovementJob`) | `/knowledge` |
@@ -324,7 +458,7 @@ All 29 live in [`examples/`](./examples).
 - New here? [`docs/concepts.md`](./docs/concepts.md), the mental model in plain terms.
 - [`docs/canonical-api.md`](./docs/canonical-api.md), find the primitive: "I want to ___ → use ___".
 - [`docs/api/primitive-catalog.md`](./docs/api/primitive-catalog.md), every export in one generated, never-stale list with its import path. Check it before building anything new.
-- [`docs/design.md`](./docs/design.md), the design philosophy and the internal research docs behind it — background reading, not required to use the package.
+- [`docs/design.md`](./docs/design.md), the design philosophy and the internal research docs behind it: background reading, not required to use the package.
 - [`bench/HARNESS.md`](./bench/HARNESS.md), the experiment harness and how to run a benchmark.
 
 **Contributing:** `pnpm i && pnpm build && pnpm test` gets you running; the full local gate is the [`package.json`](./package.json) scripts (`lint`, `typecheck`, `docs:check`).

package/dist/agent.js

@@ -1,13 +1,13 @@
-import "./chunk-ATDFUJYI.js";
+import "./chunk-WRTOVNN4.js";
 import "./chunk-Q2JSAVQ3.js";
 import {
   createSandboxForSpec
-} from "./chunk-5HNDYWUT.js";
+} from "./chunk-XBG2W2VW.js";
 import "./chunk-DPEUKJRO.js";
-import "./chunk-STJEHM5F.js";
+import "./chunk-YJZA2BIK.js";
 import "./chunk-UPWGXKXB.js";
 import "./chunk-2VZYRB55.js";
-import "./chunk-2X65HYMI.js";
+import "./chunk-HLKC4UYB.js";
 import "./chunk-ISPWRSEC.js";
 import "./chunk-KRBFHMV6.js";
 import "./chunk-3MDZX7YU.js";

package/dist/candidate-execution/index.d.ts

@@ -1,8 +1,8 @@
 import { CodeSurface } from '@tangle-network/agent-eval/campaign';
 import { AgentCandidateBundle, AgentCandidateCodeDisabled, AgentCandidateCodeNoOp, AgentCandidateGitHubRepository, AgentProfile, AgentProfileDiff, AgentCandidateProfile, AgentCandidateExecution, AgentCandidateKnowledge, AgentCandidateMemoryPolicy, AgentCandidateArtifactRef, Sha256Digest, AgentCandidateWorkspaceSnapshotEvidence } from '@tangle-network/agent-interface';
 export { AgentCandidateBenchmarkGraderIdentity } from '@tangle-network/agent-interface';
-import { c as AgentCandidateExecutionClaim, A as AgentCandidateExecutionClaimStore, d as AgentCandidateExecutionClaimResult, b as AgentCandidateExecutionAttemptRef, a as AgentCandidateExecutionAttemptRecord, h as AgentCandidateExecutionLease, j as AgentCandidateExecutionPhaseResult, n as AgentCandidateExecutionTerminalResult, l as AgentCandidateExecutionStageResult, g as AgentCandidateExecutionFinishResult, k as AgentCandidateExecutionRecoveryEvidence } from '../protected-model-port-DzkUY3HQ.js';
-export { e as AgentCandidateExecutionCleanupHandles, f as AgentCandidateExecutionFailureClass, i as AgentCandidateExecutionPhase, m as AgentCandidateExecutionTerminalRecord, o as AgentCandidateModelGrantActivateInput, q as AgentCandidateModelGrantClient, r as AgentCandidateModelGrantReservation, s as AgentCandidateModelGrantReserveInput, t as AgentCandidateModelGrantSettleInput, u as AgentCandidatePreparationEvidence, v as AgentCandidateRetryRejection, C as CreateProtectedAgentCandidateModelPortOptions, E as ExecutePreparedAgentCandidateOptions, I as InMemoryAgentCandidateExecutionClaimStore, P as PrepareAgentCandidateExecutionOptions, w as applyExactAgentProfileDiff, x as assertCandidateProfileBinding, y as createProtectedAgentCandidateModelPort, z as executePreparedAgentCandidate, B as parseExactAgentProfile, D as parseExactAgentProfileDiff, F as prepareAgentCandidateExecution } from '../protected-model-port-DzkUY3HQ.js';
+import { c as AgentCandidateExecutionClaim, A as AgentCandidateExecutionClaimStore, d as AgentCandidateExecutionClaimResult, b as AgentCandidateExecutionAttemptRef, a as AgentCandidateExecutionAttemptRecord, h as AgentCandidateExecutionLease, j as AgentCandidateExecutionPhaseResult, n as AgentCandidateExecutionTerminalResult, l as AgentCandidateExecutionStageResult, g as AgentCandidateExecutionFinishResult, k as AgentCandidateExecutionRecoveryEvidence } from '../protected-model-port-B4t-OQjL.js';
+export { e as AgentCandidateExecutionCleanupHandles, f as AgentCandidateExecutionFailureClass, i as AgentCandidateExecutionPhase, m as AgentCandidateExecutionTerminalRecord, o as AgentCandidateModelGrantActivateInput, q as AgentCandidateModelGrantClient, r as AgentCandidateModelGrantReservation, s as AgentCandidateModelGrantReserveInput, t as AgentCandidateModelGrantSettleInput, u as AgentCandidatePreparationEvidence, v as AgentCandidateRetryRejection, C as CreateProtectedAgentCandidateModelPortOptions, E as ExecutePreparedAgentCandidateOptions, I as InMemoryAgentCandidateExecutionClaimStore, P as PrepareAgentCandidateExecutionOptions, w as applyExactAgentProfileDiff, x as assertCandidateProfileBinding, y as createProtectedAgentCandidateModelPort, z as executePreparedAgentCandidate, B as parseExactAgentProfile, D as parseExactAgentProfileDiff, F as prepareAgentCandidateExecution } from '../protected-model-port-B4t-OQjL.js';
 import { P as PreparedAgentCandidateExecution, A as AgentCandidateExecutorPort, b as AgentCandidateOutputArtifactPort, w as AgentCandidateOutputPurpose, e as AgentCandidateExecutionPorts, z as AgentCandidateVerificationPorts, V as VerifiedAgentCandidate, r as AgentCandidateExecutorWorkspaceFile, B as AgentCandidateWorkspacePort } from '../types-Cbp72qyu.js';
 export { j as AgentCandidateArtifactPort, a as AgentCandidateBenchmarkGraderPort, k as AgentCandidateContainerPort, l as AgentCandidateExecutorFinalCapture, m as AgentCandidateExecutorMemoryCapture, n as AgentCandidateExecutorProfileFile, o as AgentCandidateExecutorRequest, p as AgentCandidateExecutorStopRequest, q as AgentCandidateExecutorTaskOutcomeCapture, s as AgentCandidateExecutorWorkspaceInput, t as AgentCandidateMemoryPort, u as AgentCandidateMemoryResetResult, v as AgentCandidateModelLimits, f as AgentCandidateModelPort, h as AgentCandidateProtectedModelActivation, g as AgentCandidateProtectedModelReservation, i as AgentCandidateProtectedModelSettlement, x as AgentCandidateProtectedRunCapture, y as AgentCandidateRepositoryPort, c as AgentCandidateRunFinalization, d as AgentCandidateTaskExecution, C as CANDIDATE_TRACE_ENV, D as CANDIDATE_TRACE_TAGS, E as CanonicalCandidateDocument, F as PreparedAgentCandidateInstruction, G as PreparedAgentCandidateKnowledge, H as PreparedAgentCandidateLaunch, I as PreparedAgentCandidateTrace, R as ResolvedAgentCandidateContainer, J as VerifiedAgentCandidateTaskOutcome } from '../types-Cbp72qyu.js';
 import { AgentEnvironmentProvider, AgentExactProcessResources } from '@tangle-network/agent-interface/environment-provider';

package/dist/candidate-execution/index.js

@@ -3,17 +3,17 @@ import {
   buildAgentCandidateBundle,
   disposePreparedAgentCandidateExecution,
   recoverExpiredAgentCandidateExecution
-} from "../chunk-SNSMRT6H.js";
+} from "../chunk-CTRA64LY.js";
 import {
   createProtectedAgentCandidateModelPort,
   exactProcessProviderAsCandidateExecutor
-} from "../chunk-ZXICDSAK.js";
+} from "../chunk-H5QPIZNX.js";
 import {
   captureAgentCandidateWorkspace,
   captureAgentCandidateWorkspaceFiles,
   createAgentCandidateWorkspacePort,
   sealAgentCandidateBundle
-} from "../chunk-B7K7V22Y.js";
+} from "../chunk-RDOAVVHY.js";
 import {
   AGENT_CANDIDATE_EXECUTION_SUPPORT,
   CANDIDATE_KNOWLEDGE_RETRIEVAL_CONFIG_ENV,
@@ -31,7 +31,7 @@ import {
   persistCandidateOutputArtifact,
   prepareAgentCandidateExecution,
   verifyAgentCandidateBundle
-} from "../chunk-SBTWKPVR.js";
+} from "../chunk-WSTRQZYQ.js";
 import "../chunk-UPWGXKXB.js";
 import "../chunk-ISPWRSEC.js";
 import "../chunk-3MDZX7YU.js";

package/dist/{chunk-2QJSNOGK.js → chunk-C5RTIBNZ.js}

@@ -8,7 +8,7 @@ import {
   DELEGATION_STATUS_DESCRIPTION,
   DELEGATION_STATUS_INPUT_SCHEMA,
   DELEGATION_STATUS_TOOL_NAME
-} from "./chunk-5HNDYWUT.js";
+} from "./chunk-XBG2W2VW.js";
 
 // src/mcp/openai-tools.ts
 function buildTool(name, description, parameters) {
@@ -45,4 +45,4 @@ export {
   mcpToolsForRuntimeMcp,
   mcpToolsForRuntimeMcpSubset
 };
-//# sourceMappingURL=chunk-2QJSNOGK.js.map
+//# sourceMappingURL=chunk-C5RTIBNZ.js.map

package/dist/{chunk-SNSMRT6H.js → chunk-CTRA64LY.js}

@@ -1,6 +1,6 @@
 import {
   sealAgentCandidateBundle
-} from "./chunk-B7K7V22Y.js";
+} from "./chunk-RDOAVVHY.js";
 import {
   RecoveryAgentCandidateTraceStore,
   applyExactAgentProfileDiff,
@@ -32,7 +32,7 @@ import {
   sealTerminalDigest,
   terminalRecord,
   withinCandidateCleanupDeadline
-} from "./chunk-SBTWKPVR.js";
+} from "./chunk-WSTRQZYQ.js";
 
 // src/candidate-execution/builder.ts
 import { verifyCodeSurface } from "@tangle-network/agent-eval/campaign";
@@ -677,4 +677,4 @@ export {
   disposePreparedAgentCandidateExecution,
   recoverExpiredAgentCandidateExecution
 };
-//# sourceMappingURL=chunk-SNSMRT6H.js.map
+//# sourceMappingURL=chunk-CTRA64LY.js.map

package/dist/{chunk-ZXICDSAK.js → chunk-H5QPIZNX.js}

@@ -9,7 +9,7 @@ import {
   sealAgentCandidateModelSettlement,
   sha256Bytes,
   usdToNanos
-} from "./chunk-SBTWKPVR.js";
+} from "./chunk-WSTRQZYQ.js";
 
 // src/candidate-execution/exact-process-executor.ts
 import { posix } from "path";
@@ -904,4 +904,4 @@ export {
   exactProcessProviderAsCandidateExecutor,
   createProtectedAgentCandidateModelPort
 };
-//# sourceMappingURL=chunk-ZXICDSAK.js.map
+//# sourceMappingURL=chunk-H5QPIZNX.js.map

package/dist/{chunk-2X65HYMI.js → chunk-HLKC4UYB.js}

@@ -9,7 +9,6 @@ import {
   zeroTokenUsage
 } from "./chunk-3MDZX7YU.js";
 import {
-  ConfigError,
   RuntimeRunStateError,
   ValidationError
 } from "./chunk-YEJR7IXO.js";
@@ -1371,16 +1370,6 @@ async function removeWorktree(options) {
   if (branchError) throw branchError;
 }
 
-// src/runtime/supervise/model-policy.ts
-function assertModelAllowed(model, allowed) {
-  if (!allowed || model === void 0) return;
-  if (!allowed.includes(model)) {
-    throw new ConfigError(
-      `model ${JSON.stringify(model)} is not in the allowed set ${JSON.stringify([...allowed])}`
-    );
-  }
-}
-
 // src/runtime/router-client.ts
 import { estimateCost, isModelPriced } from "@tangle-network/agent-eval";
 
@@ -3498,7 +3487,6 @@ export {
   runWorktreeChecks,
   runSettledCommand,
   runBrainLoop,
-  assertModelAllowed,
   routerChatWithUsage,
   routerChatWithTools,
   routerToolLoop,
@@ -3523,4 +3511,4 @@ export {
   createBudgetPool,
   createSupervisor
 };
-//# sourceMappingURL=chunk-2X65HYMI.js.map
+//# sourceMappingURL=chunk-HLKC4UYB.js.map