@tangle-network/agent-runtime 0.123.1 → 0.126.0

package/dist/mcp/index.d.ts

@@ -1,4 +1,4 @@
-import { $d as createDelegationTraceCollector, $u as createDetachedTurnResumeDriver, Ad as DelegationHistoryEntry, Al as McpServer, Au as CoderDelegate, Bd as ResearchOutputShape, Bl as DelegateResult, Bu as settleDetachedCoderTurn, Cd as DelegateUiAuditArgs, Cl as QuestionUrgency, Cu as JsonRpcResponse, Dd as DelegationError, Du as FeedbackStore, Ed as DelegateUiAuditRoute, El as WorkerWatchOptions, Eu as FeedbackEvent, Fd as DelegationStatus, Fl as DELEGATE_INPUT_SCHEMA, Fu as DetachedWinnerSelection, Gd as DELEGATION_TRACE_MAX_BYTES, Gu as createFleetWorkspaceExecutor, Hd as UiAuditLensFilter, Hl as validateDelegateArgs, Hu as FleetHandle, Id as DelegationStatusArgs, Il as DELEGATE_TOOL_NAME, Iu as SettleDetachedCoderTurnOptions, Jd as DelegationTraceCollector, Ju as DetachedTurn, Kd as DELEGATION_TRACE_MAX_SPANS, Ku as createSiblingSandboxExecutor, Ld as DelegationStatusResult, Ll as DelegateArgs, Lu as UiAuditorDelegate, Md as DelegationProfile, Ml as createInProcessTransport, Mu as CoderReviewer, Nd as DelegationProgress, Nl as createMcpServer, Nu as DelegateRunCtx, Od as DelegationFeedbackSnapshot, Ol as createCoordinationTools, Ou as InMemoryFeedbackStore, Pd as DelegationResultPayload, Pl as DELEGATE_DESCRIPTION, Pu as DetachedSessionDelegateOptions, Qd as composeLoopTraceEmitters, Qu as RunDetachedTurnOptions, Rd as FeedbackRating, Rl as DelegateError, Ru as coderTaskFromArgs, Sd as DelegateResearchResult, Sl as QuestionRecord, Su as JsonRpcMessage, Td as DelegateUiAuditResult, Tl as WorkerSpawnContext, Tu as McpTransport, Ud as UiAuditorDelegationOutput, Uu as FleetWorkspaceExecutorOptions, Vd as ResearchSource, Vl as createDelegateHandler, Vu as DelegationExecutor, Wd as CappedDelegationTrace, Wu as SiblingSandboxExecutorOptions, Xd as buildDelegationTraceSpans, Xu as DriveTurnCapableBox, Yd as DelegationTraceSpan, Yu as DetachedTurnResumeDriverOptions, Zd as capDelegationTrace, Zu as DriveTurnTick, _d as DelegateCodeResult, _l as Question, _u as RemoveWorktreeOptions, ad as DelegationRecord, af as InMemoryDelegationStore, al as AuthorizeDownMessage, bd as DelegateResearchArgs, bl as QuestionOption, bu as createWorktree, cd as DelegationResumeTick, cl as CoordinationEvent, dd as DelegationTaskQueueOptions, dl as DEFAULT_AWAIT_EVENT_TIMEOUT_MS, ed as detachedTurnEvents, ef as DelegationPersistenceError, fd as SubmitInput, fl as DownMessageAuthorizationInput, gd as DelegateCodeConfig, gl as MakeWorkerAgent, gu as GitRunner, hd as DelegateCodeArgs, hf as CoderOutput, hl as DownMessageEvent, hu as DiffResult, id as DelegationArgs, if as FileDelegationStoreOptions, jd as DelegationHistoryResult, jl as McpServerOptions, ju as CoderReview, kd as DelegationHistoryArgs, ku as eventToSnapshot, ld as DelegationRunContext, ll as CoordinationTools, md as hashIdempotencyInput, ml as DownMessageDeliveryOutcome, mu as DiffOptions, nd as parseDetachedSessionRef, nf as DelegationStore, nl as AnalystFindingEvent, od as DelegationResumeContext, ol as AuthorizedDownMessage, pd as SubmitOutput, pl as DownMessageDeliveryAttempt, pu as CreateWorktreeOptions, qd as DelegationTraceCaps, qu as DetachedSessionRefParts, rd as runDetachedTurn, rf as FileDelegationStore, rl as AnalystRegistry, sd as DelegationResumeDriver, sl as ContinuationInstruction, td as formatDetachedSessionRef, tf as DelegationStateCorruptError, ud as DelegationTaskQueue, ul as CoordinationToolsOptions, vd as DelegateFeedbackArgs, vl as QuestionDecision, vu as WorktreeHandle, wd as DelegateUiAuditConfig, wl as SettledWorker, wu as McpToolDescriptor, xd as DelegateResearchConfig, xl as QuestionPolicy, xu as removeWorktree, yd as DelegateFeedbackResult, yl as QuestionLevel, yu as captureWorktreeDiff, zd as FeedbackRefersTo, zl as DelegateHandlerOptions, zu as detachedSessionDelegate } from "../index-xP27vtnt.js";
+import { $c as ContinuationInstruction, $u as DelegationResumeDriver, Ad as FeedbackRating, Al as DelegateError, Au as coderTaskFromArgs, Bd as DelegationTraceCollector, Bu as DetachedTurn, Cd as DelegationHistoryResult, Cl as McpServerOptions, Cu as CoderReview, Dd as DelegationStatus, Dl as DELEGATE_INPUT_SCHEMA, Du as DetachedWinnerSelection, Ed as DelegationResultPayload, El as DELEGATE_DESCRIPTION, Eu as DetachedSessionDelegateOptions, Fd as UiAuditorDelegationOutput, Fu as FleetWorkspaceExecutorOptions, Gd as createDelegationTraceCollector, Gu as createDetachedTurnResumeDriver, Hd as buildDelegationTraceSpans, Hu as DriveTurnCapableBox, Id as CappedDelegationTrace, Iu as SiblingSandboxExecutorOptions, Jc as AnalystFindingEvent, Jd as DelegationStore, Ju as parseDetachedSessionRef, Kd as DelegationPersistenceError, Ku as detachedTurnEvents, Ld as DELEGATION_TRACE_MAX_BYTES, Lu as createFleetWorkspaceExecutor, Md as ResearchOutputShape, Ml as DelegateResult, Mu as settleDetachedCoderTurn, Nd as ResearchSource, Nl as createDelegateHandler, Nu as DelegationExecutor, Od as DelegationStatusArgs, Ol as DELEGATE_TOOL_NAME, Ou as SettleDetachedCoderTurnOptions, Pd as UiAuditLensFilter, Pl as validateDelegateArgs, Pu as FleetHandle, Qc as AuthorizedDownMessage, Qu as DelegationResumeContext, Rd as DELEGATION_TRACE_MAX_SPANS, Ru as createSiblingSandboxExecutor, Sd as DelegationHistoryEntry, Sl as McpServer, Su as CoderDelegate, Td as DelegationProgress, Tl as createMcpServer, Tu as DelegateRunCtx, Ud as capDelegationTrace, Uu as DriveTurnTick, Vd as DelegationTraceSpan, Vu as DetachedTurnResumeDriverOptions, Wd as composeLoopTraceEmitters, Wu as RunDetachedTurnOptions, Xd as FileDelegationStoreOptions, Xu as DelegationArgs, Yc as AnalystRegistry, Yd as FileDelegationStore, Yu as runDetachedTurn, Zc as AuthorizeDownMessage, Zd as InMemoryDelegationStore, Zu as DelegationRecord, _d as DelegateUiAuditResult, _l as WorkerSpawnContext, _u as McpTransport, ad as SubmitOutput, al as DownMessageDeliveryAttempt, au as CreateWorktreeOptions, bd as DelegationFeedbackSnapshot, bl as createCoordinationTools, bu as InMemoryFeedbackStore, cd as DelegateCodeConfig, cl as MakeWorkerAgent, cu as GitRunner, dd as DelegateFeedbackResult, dl as QuestionLevel, du as captureWorktreeDiff, ed as DelegationResumeTick, el as CoordinationEvent, fd as DelegateResearchArgs, fl as QuestionOption, fu as createWorktree, gd as DelegateUiAuditConfig, gl as SettledWorker, gu as McpToolDescriptor, hd as DelegateUiAuditArgs, hl as QuestionUrgency, hu as JsonRpcResponse, id as SubmitInput, il as DownMessageAuthorizationInput, jd as FeedbackRefersTo, jl as DelegateHandlerOptions, ju as detachedSessionDelegate, kd as DelegationStatusResult, kl as DelegateArgs, ku as UiAuditorDelegate, ld as DelegateCodeResult, ll as Question, lu as RemoveWorktreeOptions, md as DelegateResearchResult, ml as QuestionRecord, mu as JsonRpcMessage, nd as DelegationTaskQueue, nl as CoordinationToolsOptions, od as hashIdempotencyInput, ol as DownMessageDeliveryOutcome, ou as DiffOptions, pd as DelegateResearchConfig, pl as QuestionPolicy, pu as removeWorktree, qd as DelegationStateCorruptError, qu as formatDetachedSessionRef, rd as DelegationTaskQueueOptions, rl as DEFAULT_AWAIT_EVENT_TIMEOUT_MS, sd as DelegateCodeArgs, sf as CoderOutput, sl as DownMessageEvent, su as DiffResult, td as DelegationRunContext, tl as CoordinationTools, ud as DelegateFeedbackArgs, ul as QuestionDecision, uu as WorktreeHandle, vd as DelegateUiAuditRoute, vl as WorkerWatchOptions, vu as FeedbackEvent, wd as DelegationProfile, wl as createInProcessTransport, wu as CoderReviewer, xd as DelegationHistoryArgs, xu as eventToSnapshot, yd as DelegationError, yu as FeedbackStore, zd as DelegationTraceCaps, zu as DetachedSessionRefParts } from "../index-EdjCQBV9.js";
 import { E as SandboxClient, h as LoopSandboxPlacement } from "../types-DnNGJ5Gz.js";
 import { Bt as mergeTraceEnv, Ht as traceContextToEnv, Rt as TraceContext, Vt as readTraceContextFromEnv, zt as createPropagatingTraceEmitter } from "../environment-provider-PM9PeW_J.js";
 import { o as UiLens } from "../substrate-BcnuSHXm.js";

package/dist/mcp/index.js

@@ -1,11 +1,11 @@
 import { u as ValidationError } from "../errors-DEAvWQPy.js";
 import { l as throwAbort, n as deleteBoxSafe, s as sleep, u as throwIfAborted } from "../util-MVgdwuIS.js";
 import { Ct as runWorktreeHarness, Dt as removeWorktree, Et as createWorktree, Gt as harnessSupportsReasoningEffort, Ht as DEFAULT_LOCAL_HARNESS, Jt as runLocalHarness, Kt as localHarnessExecutable, S as traceContextToEnv, Tt as captureWorktreeDiff, Ut as LOCAL_HARNESSES, Yt as CodexExecutionDiagnosticError, b as mergeTraceEnv, qt as parseCodexTokenUsage, x as readTraceContextFromEnv, y as createPropagatingTraceEmitter } from "../supervisor-DpjO0Gmy.js";
-import { S as runCoderChecks, tt as selectValidWinner } from "../runtime-DZblIf3R.js";
-import { A as DELEGATE_DESCRIPTION, At as createSandboxForSpec, B as DELEGATION_TRACE_MAX_SPANS, C as createDelegateUiAuditHandler, D as DELEGATE_FEEDBACK_TOOL_NAME, E as DELEGATE_FEEDBACK_INPUT_SCHEMA, G as DelegationPersistenceError, H as capDelegationTrace, J as InMemoryDelegationStore, K as DelegationStateCorruptError, L as DelegationTaskQueue, M as DELEGATE_TOOL_NAME, Mt as runAgentRounds, N as createDelegateHandler, O as createDelegateFeedbackHandler, P as validateDelegateArgs, R as hashIdempotencyInput, S as DELEGATE_UI_AUDIT_TOOL_NAME, T as DELEGATE_FEEDBACK_DESCRIPTION, U as composeLoopTraceEmitters, V as buildDelegationTraceSpans, W as createDelegationTraceCollector, X as eventToSnapshot, Y as InMemoryFeedbackStore, _ as DELEGATION_HISTORY_TOOL_NAME, b as DELEGATE_UI_AUDIT_DESCRIPTION, c as createInProcessTransport, d as DELEGATION_STATUS_INPUT_SCHEMA, dt as DEFAULT_AWAIT_EVENT_TIMEOUT_MS, f as DELEGATION_STATUS_TOOL_NAME, g as DELEGATION_HISTORY_INPUT_SCHEMA, h as DELEGATION_HISTORY_DESCRIPTION, j as DELEGATE_INPUT_SCHEMA, k as validateDelegateFeedbackArgs, l as createMcpServer, m as validateDelegationStatusArgs, p as createDelegationStatusHandler, pt as createCoordinationTools, q as FileDelegationStore, u as DELEGATION_STATUS_DESCRIPTION, v as createDelegationHistoryHandler, w as validateDelegateUiAuditArgs, x as DELEGATE_UI_AUDIT_INPUT_SCHEMA, y as validateDelegationHistoryArgs, z as DELEGATION_TRACE_MAX_BYTES } from "../supervise-Cx24b3lw.js";
+import { S as runCoderChecks, tt as selectValidWinner } from "../runtime-BzXz7OjS.js";
+import { A as DELEGATE_DESCRIPTION, At as createSandboxForSpec, B as DELEGATION_TRACE_MAX_SPANS, C as createDelegateUiAuditHandler, D as DELEGATE_FEEDBACK_TOOL_NAME, E as DELEGATE_FEEDBACK_INPUT_SCHEMA, G as DelegationPersistenceError, H as capDelegationTrace, J as InMemoryDelegationStore, K as DelegationStateCorruptError, L as DelegationTaskQueue, M as DELEGATE_TOOL_NAME, Mt as runAgentRounds, N as createDelegateHandler, O as createDelegateFeedbackHandler, P as validateDelegateArgs, R as hashIdempotencyInput, S as DELEGATE_UI_AUDIT_TOOL_NAME, T as DELEGATE_FEEDBACK_DESCRIPTION, U as composeLoopTraceEmitters, V as buildDelegationTraceSpans, W as createDelegationTraceCollector, X as eventToSnapshot, Y as InMemoryFeedbackStore, _ as DELEGATION_HISTORY_TOOL_NAME, b as DELEGATE_UI_AUDIT_DESCRIPTION, c as createInProcessTransport, d as DELEGATION_STATUS_INPUT_SCHEMA, dt as DEFAULT_AWAIT_EVENT_TIMEOUT_MS, f as DELEGATION_STATUS_TOOL_NAME, g as DELEGATION_HISTORY_INPUT_SCHEMA, h as DELEGATION_HISTORY_DESCRIPTION, j as DELEGATE_INPUT_SCHEMA, k as validateDelegateFeedbackArgs, l as createMcpServer, m as validateDelegationStatusArgs, p as createDelegationStatusHandler, pt as createCoordinationTools, q as FileDelegationStore, u as DELEGATION_STATUS_DESCRIPTION, v as createDelegationHistoryHandler, w as validateDelegateUiAuditArgs, x as DELEGATE_UI_AUDIT_INPUT_SCHEMA, y as validateDelegationHistoryArgs, z as DELEGATION_TRACE_MAX_BYTES } from "../supervise-Ds8FtyI9.js";
 import { t as createStdioToolServer } from "../tool-server-RcWgLIsL.js";
 import { t as createKbGate } from "../kb-gate-DpaSwXVx.js";
-import { n as mcpToolsForRuntimeMcpSubset, t as mcpToolsForRuntimeMcp } from "../openai-tools-Bm1SDJIp.js";
+import { n as mcpToolsForRuntimeMcpSubset, t as mcpToolsForRuntimeMcp } from "../openai-tools-Bp1KSkP6.js";
 import { t as coderTaskToPrompt } from "../coder-yhVWbdWc.js";
 import { a as createMemoryToolServer, c as resolveMemoryFromEnv, i as MEMORY_NAME_ENV, n as MEMORY_ITEMS_ENV, o as parseMemoryItems, r as MEMORY_LOG_ENV, s as readMemoryItemsFile, t as MEMORY_FILE_ENV } from "../memory-server-DL6cE2Ag.js";
 import { randomUUID } from "node:crypto";

package/dist/{openai-tools-Bm1SDJIp.js → openai-tools-Bp1KSkP6.js}

@@ -1,4 +1,4 @@
-import { D as DELEGATE_FEEDBACK_TOOL_NAME, E as DELEGATE_FEEDBACK_INPUT_SCHEMA, T as DELEGATE_FEEDBACK_DESCRIPTION, _ as DELEGATION_HISTORY_TOOL_NAME, d as DELEGATION_STATUS_INPUT_SCHEMA, f as DELEGATION_STATUS_TOOL_NAME, g as DELEGATION_HISTORY_INPUT_SCHEMA, h as DELEGATION_HISTORY_DESCRIPTION, u as DELEGATION_STATUS_DESCRIPTION } from "./supervise-Cx24b3lw.js";
+import { D as DELEGATE_FEEDBACK_TOOL_NAME, E as DELEGATE_FEEDBACK_INPUT_SCHEMA, T as DELEGATE_FEEDBACK_DESCRIPTION, _ as DELEGATION_HISTORY_TOOL_NAME, d as DELEGATION_STATUS_INPUT_SCHEMA, f as DELEGATION_STATUS_TOOL_NAME, g as DELEGATION_HISTORY_INPUT_SCHEMA, h as DELEGATION_HISTORY_DESCRIPTION, u as DELEGATION_STATUS_DESCRIPTION } from "./supervise-Ds8FtyI9.js";
 //#region src/mcp/openai-tools.ts
 function buildTool(name, description, parameters) {
 	return {
@@ -41,4 +41,4 @@ function mcpToolsForRuntimeMcpSubset(names) {
 //#endregion
 export { mcpToolsForRuntimeMcpSubset as n, mcpToolsForRuntimeMcp as t };
 
-//# sourceMappingURL=openai-tools-Bm1SDJIp.js.map
+//# sourceMappingURL=openai-tools-Bp1KSkP6.js.map

package/dist/{openai-tools-Bm1SDJIp.js.map → openai-tools-Bp1KSkP6.js.map}

@@ -1 +1 @@
-{"version":3,"file":"openai-tools-Bm1SDJIp.js","names":[],"sources":["../src/mcp/openai-tools.ts"],"sourcesContent":["/**\n *\n * OpenAI Chat Completions `tools[]` projection of the queue-bound agent-runtime\n * MCP delegation tools.\n *\n * Use when configuring `createOpenAICompatibleBackend({ tools: ... })` so the\n * model can call `delegate_feedback`, `delegation_status`, and\n * `delegation_history` through the OpenAI-compat transport (tcloud, OpenRouter,\n * OpenAI direct, cli-bridge). The runtime surfaces tool calls as `tool_call`\n * stream events — execution is the caller's responsibility (typically the\n * parent sandbox runtime's MCP mount).\n *\n * Sandbox-SDK callers do NOT need this helper: the sandbox runtime mounts\n * MCP servers natively and the in-sandbox harness discovers tools via the\n * runtime, not via an OpenAI tools array.\n *\n * Tool name + description + JSON-schema are pulled from the canonical\n * `DELEGATE_*` constants exported by `./tools/*` so the projection cannot\n * drift from the server's own validators.\n *\n * @experimental\n */\n\nimport type { OpenAIChatTool } from '../types'\nimport {\n  DELEGATE_FEEDBACK_DESCRIPTION,\n  DELEGATE_FEEDBACK_INPUT_SCHEMA,\n  DELEGATE_FEEDBACK_TOOL_NAME,\n} from './tools/delegate-feedback'\nimport {\n  DELEGATION_HISTORY_DESCRIPTION,\n  DELEGATION_HISTORY_INPUT_SCHEMA,\n  DELEGATION_HISTORY_TOOL_NAME,\n} from './tools/delegation-history'\nimport {\n  DELEGATION_STATUS_DESCRIPTION,\n  DELEGATION_STATUS_INPUT_SCHEMA,\n  DELEGATION_STATUS_TOOL_NAME,\n} from './tools/delegation-status'\n\nfunction buildTool(\n  name: string,\n  description: string,\n  parameters: Readonly<Record<string, unknown>>,\n): OpenAIChatTool {\n  // `parameters` arrives as a deeply-readonly `as const` literal. The\n  // OpenAI-compat backend JSON-serializes the body so a shallow copy\n  // into a plain object is sufficient — and shields callers that mutate\n  // the returned descriptor from corrupting the source constant.\n  return {\n    type: 'function',\n    function: { name, description, parameters: { ...parameters } },\n  }\n}\n\n/**\n *\n * Returns the queue-bound delegation tools projected into OpenAI Chat\n * Completions `tools[]` shape. The order is stable: `delegate_feedback`,\n * `delegation_status`, `delegation_history`.\n *\n * @experimental\n */\nexport function mcpToolsForRuntimeMcp(): OpenAIChatTool[] {\n  return [\n    buildTool(\n      DELEGATE_FEEDBACK_TOOL_NAME,\n      DELEGATE_FEEDBACK_DESCRIPTION,\n      DELEGATE_FEEDBACK_INPUT_SCHEMA as Readonly<Record<string, unknown>>,\n    ),\n    buildTool(\n      DELEGATION_STATUS_TOOL_NAME,\n      DELEGATION_STATUS_DESCRIPTION,\n      DELEGATION_STATUS_INPUT_SCHEMA as Readonly<Record<string, unknown>>,\n    ),\n    buildTool(\n      DELEGATION_HISTORY_TOOL_NAME,\n      DELEGATION_HISTORY_DESCRIPTION,\n      DELEGATION_HISTORY_INPUT_SCHEMA as Readonly<Record<string, unknown>>,\n    ),\n  ]\n}\n\n/**\n *\n * Subset filter — return only the projected tools whose `function.name`\n * appears in `names`. Useful for curated mounts (e.g. only the queue-bound\n * delegation tools, omitting `delegate_feedback`). Unknown names are\n * silently ignored; pass an empty array to get an empty result.\n *\n * @experimental\n */\nexport function mcpToolsForRuntimeMcpSubset(names: ReadonlyArray<string>): OpenAIChatTool[] {\n  const allowed = new Set(names)\n  return mcpToolsForRuntimeMcp().filter((tool) => allowed.has(tool.function.name))\n}\n"],"mappings":";;AAwCA,SAAS,UACP,MACA,aACA,YACgB;CAKhB,OAAO;EACL,MAAM;EACN,UAAU;GAAE;GAAM;GAAa,YAAY,EAAE,GAAG,WAAW;EAAE;CAC/D;AACF;;;;;;;;;AAUA,SAAgB,wBAA0C;CACxD,OAAO;EACL,UACE,6BACA,+BACA,8BACF;EACA,UACE,6BACA,+BACA,8BACF;EACA,UACE,8BACA,gCACA,+BACF;CACF;AACF;;;;;;;;;;AAWA,SAAgB,4BAA4B,OAAgD;CAC1F,MAAM,UAAU,IAAI,IAAI,KAAK;CAC7B,OAAO,sBAAsB,CAAC,CAAC,QAAQ,SAAS,QAAQ,IAAI,KAAK,SAAS,IAAI,CAAC;AACjF"}
+{"version":3,"file":"openai-tools-Bp1KSkP6.js","names":[],"sources":["../src/mcp/openai-tools.ts"],"sourcesContent":["/**\n *\n * OpenAI Chat Completions `tools[]` projection of the queue-bound agent-runtime\n * MCP delegation tools.\n *\n * Use when configuring `createOpenAICompatibleBackend({ tools: ... })` so the\n * model can call `delegate_feedback`, `delegation_status`, and\n * `delegation_history` through the OpenAI-compat transport (tcloud, OpenRouter,\n * OpenAI direct, cli-bridge). The runtime surfaces tool calls as `tool_call`\n * stream events — execution is the caller's responsibility (typically the\n * parent sandbox runtime's MCP mount).\n *\n * Sandbox-SDK callers do NOT need this helper: the sandbox runtime mounts\n * MCP servers natively and the in-sandbox harness discovers tools via the\n * runtime, not via an OpenAI tools array.\n *\n * Tool name + description + JSON-schema are pulled from the canonical\n * `DELEGATE_*` constants exported by `./tools/*` so the projection cannot\n * drift from the server's own validators.\n *\n * @experimental\n */\n\nimport type { OpenAIChatTool } from '../types'\nimport {\n  DELEGATE_FEEDBACK_DESCRIPTION,\n  DELEGATE_FEEDBACK_INPUT_SCHEMA,\n  DELEGATE_FEEDBACK_TOOL_NAME,\n} from './tools/delegate-feedback'\nimport {\n  DELEGATION_HISTORY_DESCRIPTION,\n  DELEGATION_HISTORY_INPUT_SCHEMA,\n  DELEGATION_HISTORY_TOOL_NAME,\n} from './tools/delegation-history'\nimport {\n  DELEGATION_STATUS_DESCRIPTION,\n  DELEGATION_STATUS_INPUT_SCHEMA,\n  DELEGATION_STATUS_TOOL_NAME,\n} from './tools/delegation-status'\n\nfunction buildTool(\n  name: string,\n  description: string,\n  parameters: Readonly<Record<string, unknown>>,\n): OpenAIChatTool {\n  // `parameters` arrives as a deeply-readonly `as const` literal. The\n  // OpenAI-compat backend JSON-serializes the body so a shallow copy\n  // into a plain object is sufficient — and shields callers that mutate\n  // the returned descriptor from corrupting the source constant.\n  return {\n    type: 'function',\n    function: { name, description, parameters: { ...parameters } },\n  }\n}\n\n/**\n *\n * Returns the queue-bound delegation tools projected into OpenAI Chat\n * Completions `tools[]` shape. The order is stable: `delegate_feedback`,\n * `delegation_status`, `delegation_history`.\n *\n * @experimental\n */\nexport function mcpToolsForRuntimeMcp(): OpenAIChatTool[] {\n  return [\n    buildTool(\n      DELEGATE_FEEDBACK_TOOL_NAME,\n      DELEGATE_FEEDBACK_DESCRIPTION,\n      DELEGATE_FEEDBACK_INPUT_SCHEMA as Readonly<Record<string, unknown>>,\n    ),\n    buildTool(\n      DELEGATION_STATUS_TOOL_NAME,\n      DELEGATION_STATUS_DESCRIPTION,\n      DELEGATION_STATUS_INPUT_SCHEMA as Readonly<Record<string, unknown>>,\n    ),\n    buildTool(\n      DELEGATION_HISTORY_TOOL_NAME,\n      DELEGATION_HISTORY_DESCRIPTION,\n      DELEGATION_HISTORY_INPUT_SCHEMA as Readonly<Record<string, unknown>>,\n    ),\n  ]\n}\n\n/**\n *\n * Subset filter — return only the projected tools whose `function.name`\n * appears in `names`. Useful for curated mounts (e.g. only the queue-bound\n * delegation tools, omitting `delegate_feedback`). Unknown names are\n * silently ignored; pass an empty array to get an empty result.\n *\n * @experimental\n */\nexport function mcpToolsForRuntimeMcpSubset(names: ReadonlyArray<string>): OpenAIChatTool[] {\n  const allowed = new Set(names)\n  return mcpToolsForRuntimeMcp().filter((tool) => allowed.has(tool.function.name))\n}\n"],"mappings":";;AAwCA,SAAS,UACP,MACA,aACA,YACgB;CAKhB,OAAO;EACL,MAAM;EACN,UAAU;GAAE;GAAM;GAAa,YAAY,EAAE,GAAG,WAAW;EAAE;CAC/D;AACF;;;;;;;;;AAUA,SAAgB,wBAA0C;CACxD,OAAO;EACL,UACE,6BACA,+BACA,8BACF;EACA,UACE,6BACA,+BACA,8BACF;EACA,UACE,8BACA,gCACA,+BACF;CACF;AACF;;;;;;;;;;AAWA,SAAgB,4BAA4B,OAAgD;CAC1F,MAAM,UAAU,IAAI,IAAI,KAAK;CAC7B,OAAO,sBAAsB,CAAC,CAAC,QAAQ,SAAS,QAAQ,IAAI,KAAK,SAAS,IAAI,CAAC;AACjF"}

package/dist/primeintellect/index.d.ts

@@ -1,5 +1,5 @@
 import { i as AgentExecutionBackend, r as AgentBackendInput } from "../types-C9j4qg6l.js";
-import { lt as createOpenAICompatibleBackend } from "../index-CQBioeAj.js";
+import { lt as createOpenAICompatibleBackend } from "../index-D_M4d1_B.js";
 import { RunRecord } from "@tangle-network/agent-eval";
 //#region src/primeintellect/types.d.ts
 type PrimeIntellectSplit = 'train' | 'eval';

package/dist/{runtime-DZblIf3R.js → runtime-BzXz7OjS.js}

@@ -7,7 +7,7 @@ import { _t as routerChatWithUsage, bt as runBrainLoop, en as isHarnessNativeMod
 import { C as observe, O as strategyAuthorMethod, b as sample, v as refine, x as sampleThenRefine, y as runAgentic } from "./structural-rollout-zY0oqQzO.js";
 import { i as notifyRuntimeHookEvent, t as composeRuntimeHooks } from "./runtime-hooks-C7iJOWm3.js";
 import { a as notifySandboxEventObserver, i as mapSandboxToolEvent, r as mapSandboxEvent, t as createSandboxToolPartState } from "./sandbox-events-Yhd1GYWl.js";
-import { Ct as createWorktreeCliExecutor, Et as createPushTraceSource, Ft as probeSandboxCapabilities, Mt as runAgentRounds, Pt as createSandboxLineage, Qt as kernelPromptRegistry, St as createExecutorRegistry, Zt as formatPromptHandle, jt as defaultSelectWinner, n as supervise, nn as gateOnDeliverable, r as workerFromBackend, xt as createExecutor } from "./supervise-Cx24b3lw.js";
+import { Ct as createWorktreeCliExecutor, Et as createPushTraceSource, Ft as probeSandboxCapabilities, Mt as runAgentRounds, Pt as createSandboxLineage, Qt as kernelPromptRegistry, St as createExecutorRegistry, Zt as formatPromptHandle, jt as defaultSelectWinner, n as supervise, nn as gateOnDeliverable, r as workerFromBackend, xt as createExecutor } from "./supervise-Ds8FtyI9.js";
 import { CODING_HARNESSES, InMemoryTraceStore, OUTPUT_VALUE, benjaminiHochberg, buildTrajectory, computeFindingId as computeFindingId$1, confidenceInterval, expandProfileAxes, harnessAxisOf, makeFinding as makeFinding$1, pairedBootstrap, paretoFrontier, scoreKnowledgeReadiness, wilcoxonSignedRank, wilson } from "@tangle-network/agent-eval";
 import { heldoutSignificance, runProfileMatrix } from "@tangle-network/agent-eval/campaign";
 import { agentProfileSchema, canonicalCandidateDigest, validateAgentProfileSecurity } from "@tangle-network/agent-interface";
@@ -1295,106 +1295,13 @@ function resolveSandboxClient(opts) {
 	}
 }
 //#endregion
-//#region src/runtime/steering-drivers.ts
-/**
-* Interpret a {@link SteeringDirectiveData} as a loop `Driver` — the ONE interpreter both
-* control policies share. The directive is data; only `applyContinuation` (how the caller's
-* opaque Task carries a steering string) remains code, exactly as `taskToPrompt` does.
-*/
-function steeringDriver(directive, applyContinuation, name) {
-	const driverName = name ?? directive.kind;
-	const maxIterations = directive.maxTraversals;
-	const continuationFor = (passed) => directive.kind === "naive" ? directive.continuation : passed ? directive.onPass : directive.onFail;
-	const rationale = directive.kind === "naive" ? "naive fixed continuation (no grade signal)" : "dumb pass/fail-only continuation (no grader findings)";
-	return {
-		name: driverName,
-		plan(task, history) {
-			if (history.length === 0) return Promise.resolve([task]);
-			const passed = history[history.length - 1]?.verdict?.valid === true;
-			if (passed) return Promise.resolve([]);
-			if (history.length >= maxIterations) return Promise.resolve([]);
-			return Promise.resolve([applyContinuation(task, continuationFor(passed))]);
-		},
-		decide(history) {
-			return decideUntilValidOrCapped(history, maxIterations);
-		},
-		describePlan() {
-			return {
-				kind: "refine",
-				rationale
-			};
-		}
-	};
-}
-/**
-* Shared `decide()` for the steering drivers. Verbatim semantics of the
-* reference refine driver: a valid iteration anywhere → terminal `'pick-winner'`;
-* otherwise `'refine'` (non-terminal, run another shot) while history is under
-* the shot cap, else terminal `'fail'`. Pure over history; reads only
-* `verdict.valid` (never notes/scores) so it adds no leak of its own.
-*/
-function decideUntilValidOrCapped(history, maxIterations) {
-	if (history.some((it) => it.verdict?.valid)) return "pick-winner";
-	return history.length < maxIterations ? "refine" : "fail";
-}
-/**
-* `naiveDriver` — the no-signal steering control.
-*
-* `plan()` runs the initial `task` at shot 0, then issues the SAME fixed
-* `continuation` every subsequent round until a shot is valid or the cap is
-* hit. It reads NOTHING from `history[last].verdict` — not `.valid`, not
-* `.notes`, not `.scores`. It is the floor a coached loop must beat to earn its
-* coaching: any lift over naive that is not also present in `dumb` is
-* attributable to the pass/fail bit, and any lift of `refine` over `dumb` is
-* attributable to the grader's findings.
-*/
-/** Thin compatibility wrapper over {@link steeringDriver} for the naive (no-signal) control.
-*  @deprecated The policy is DATA now — build the directive and interpret it:
-*  `steeringDriver({ kind: 'naive', continuation, maxTraversals }, applyContinuation)`. This
-*  wrapper survives for existing callers and will be removed in the next major. */
-function naiveDriver(options) {
-	const { continuation, applyContinuation, maxIterations, name = "naive" } = options;
-	return steeringDriver({
-		kind: "naive",
-		continuation,
-		maxTraversals: maxIterations
-	}, applyContinuation, name);
-}
-/**
-* `dumbDriver` — the pass/fail-only steering control.
-*
-* `plan()` runs the initial `task` at shot 0, then reads ONLY
-* `history[last].verdict.valid` (the boolean) and issues `onPass` or `onFail`
-* accordingly. It MUST NOT read `.notes` or `.scores` — that boundary is the
-* leak-free firewall. A `verdict` with no `valid` set (or no verdict) is
-* treated as not-valid, so the driver is total and never throws on a
-* grader/transport gap.
-*
-* The `dumb → refine` gap is the headline measurement: refine reads the
-* grader's `notes`, dumb reads only the pass/fail bit, so the difference is
-* exactly the value the findings add over a bare boolean.
-*/
-/** Thin compatibility wrapper over {@link steeringDriver} for the dumb (pass/fail-only) control.
-*  @deprecated The policy is DATA now — build the directive and interpret it:
-*  `steeringDriver({ kind: 'dumb', onPass, onFail, maxTraversals }, applyContinuation)`. This
-*  wrapper survives for existing callers and will be removed in the next major. */
-function dumbDriver(options) {
-	const { onPass, onFail, applyContinuation, maxIterations, name = "dumb" } = options;
-	return steeringDriver({
-		kind: "dumb",
-		onPass,
-		onFail,
-		maxTraversals: maxIterations
-	}, applyContinuation, name);
-}
-//#endregion
 //#region src/runtime/define-leaderboard.ts
 /**
 * `defineLeaderboard` — the declarative eval-leaderboard facade.
 *
 * A product's harness×model leaderboard is always the same assembly: expand a
 * base profile across the harness×model axes (`expandProfileAxes`), run every
-* (profile, case) cell as a driven loop (`loopDispatch` + the naive steering directive), score
+* (profile, case) cell as a driven loop (`loopDispatch` + the naive retry driver), score
 * with the domain's grader, and emit ONE `runProfileMatrix` call. Each product
 * hand-rolled that assembly (~650 lines each) and re-hit the same footguns:
 * stale cell-cache reuse, zero-token stub cells, missing model snapshots.
@@ -1420,6 +1327,36 @@ function dumbDriver(options) {
 *
 * @experimental
 */
+/**
+* The no-signal retry floor as a bare `Driver` literal: re-run the case VERBATIM as an
+* independent attempt until one shot scores (`verdict.valid`) or the shot cap. It reads ONLY
+* `verdict.valid` — never `notes`/`scores` — so a leaderboard cell's retries carry no grader
+* findings into the next shot (the leak-free firewall). Steering POLICY texts are registry data
+* (`delegates/naive-continuation` and siblings in the kernel prompt registry) attached to graph
+* edges; this loop-kernel control folds no text in — each shot is the same task object, and the
+* per-shot nonce in `taskToPrompt` keeps the attempts independent at the router.
+*/
+function naiveRetryDriver(shots) {
+	return {
+		name: "naive",
+		plan(task, history) {
+			if (history.length === 0) return Promise.resolve([task]);
+			if (history[history.length - 1]?.verdict?.valid === true) return Promise.resolve([]);
+			if (history.length >= shots) return Promise.resolve([]);
+			return Promise.resolve([task]);
+		},
+		decide(history) {
+			if (history.some((it) => it.verdict?.valid)) return "pick-winner";
+			return history.length < shots ? "refine" : "fail";
+		},
+		describePlan() {
+			return {
+				kind: "refine",
+				rationale: "naive fixed continuation (no grade signal)"
+			};
+		}
+	};
+}
 /** Read `--name <value>` from an argv array. */
 function argOf(argv, name) {
 	const i = argv.indexOf(`--${name}`);
@@ -1588,11 +1525,7 @@ function defineLeaderboard(spec) {
 						...!isHarnessNativeModel(modelId) || backendName === "cli-bridge" ? { model: modelId } : {}
 					};
 					return {
-						driver: steeringDriver({
-							kind: "naive",
-							continuation: "",
-							maxTraversals: shots
-						}, (task) => task, "naive"),
+						driver: naiveRetryDriver(shots),
 						agentRun: {
 							profile: cellProfile,
 							taskToPrompt: (s) => `${promptOf(s)}\n\n<!-- independent-attempt:${shotNonce++} -->`,
@@ -4691,10 +4624,13 @@ function deriveTurnSignal(callerSignal, timeoutMs) {
 *  4. **Per-edge traversal caps** — the cyclic-graph backstop. A delegates edge whose cap is
 *     exhausted REFUSES further traversals (fail loud), so a cycle cannot spin the pool dry.
 *
-* ORACLES ARE ENVIRONMENT, NEVER NODES. Graders/verifiers must not be addressable in the graph —
-* an edge to them leaks the rubric. Analysts (`analyzes` edges) are LENSES from the environment's
-* registry reading trace evidence; they are not nodes either, and a graph that names a node id as
-* its analyst is refused.
+* ORACLES ARE ENVIRONMENT, NEVER WORKERS. Graders/verifiers must not be spawnable in the graph —
+* a delegates edge to them leaks the rubric. An `analyzes` edge names its analyst in one of two
+* forms: a LENS id from the environment's registry (a pure function over trace evidence), or the
+* id of a graph NODE — a tool-equipped analyst AGENT spawned on each matching settle with the
+* node's pinned profile, whose settle output IS the findings. Either way the oracle doctrine
+* holds: an analyst node can never be a delegates target (refused loudly), so no driver can hand
+* it work, and an id living in both the registry and the nodes is refused as ambiguous.
 *
 * @experimental
 */
@@ -4753,16 +4689,24 @@ function validateGraph(graph, registry, analysts) {
 	const root = requireNode(roots[0], "root resolution");
 	for (const edge of delegates) if (edge.from !== root.id) throw new ValidationError(`runGraph: ${edgeId(edge)} delegates from a non-root node — P0 executes one driver over its workers (the 2-node cyclic case, star-generalized); deeper delegation is P3`);
 	const analystIds = /* @__PURE__ */ new Set();
+	const analystNodes = /* @__PURE__ */ new Map();
 	for (const edge of analyzes) {
 		if (analystIds.has(edge.analyst)) throw new ValidationError(`runGraph: two analyzes edges share analyst '${edge.analyst}' — one analyzes edge per analyst lens (traversals are ledgered by analyst id; a second edge would silently absorb the first's). Register the lens under a second id for a second edge.`);
 		analystIds.add(edge.analyst);
-		if (byId.has(edge.analyst)) throw new ValidationError(`runGraph: ${edgeId(edge)} names node '${edge.analyst}' as its analyst — oracles and analysts are ENVIRONMENT, never nodes; pass a lens id from RunGraphOptions.analysts`);
-		if (!analysts) throw new ValidationError(`runGraph: ${edgeId(edge)} needs RunGraphOptions.analysts (the lens registry its analyst resolves against)`);
-		if (!analysts.kinds.some((kind) => kind.id === edge.analyst)) throw new ValidationError(`runGraph: ${edgeId(edge)} analyst '${edge.analyst}' is not in the analysts registry (known: ${analysts.kinds.map((kind) => kind.id).join(", ") || "none"})`);
+		const analystNode = byId.get(edge.analyst);
+		const inRegistry = analysts?.kinds.some((kind) => kind.id === edge.analyst) === true;
+		if (analystNode !== void 0 && inRegistry) throw new ValidationError(`runGraph: ${edgeId(edge)} analyst '${edge.analyst}' is BOTH a graph node and a lens in the analysts registry — the id alone distinguishes the two analyst forms, so this is ambiguous; rename the node or register the lens under another id`);
+		if (analystNode !== void 0) {
+			if (analystNode.id === root.id) throw new ValidationError(`runGraph: ${edgeId(edge)} names the ROOT as its analyst — the root is the driver; give the analyst its own node with no delegates edge pointing at it`);
+			if (delegatedTo.has(analystNode.id)) throw new ValidationError(`runGraph: ${edgeId(edge)} names node '${edge.analyst}' as its analyst, but that node is a delegates target — oracle doctrine: an analyst is never delegated to. An analyst NODE is legal only with NO delegates edge pointing at it; give the analyst its own delegates-free node or pass a lens id from RunGraphOptions.analysts.`);
+			analystNodes.set(analystNode.id, analystNode);
+		} else if (!analysts) throw new ValidationError(`runGraph: ${edgeId(edge)} analyst '${edge.analyst}' is not a graph node, and no RunGraphOptions.analysts registry was provided to resolve it as a lens`);
+		else if (!inRegistry) throw new ValidationError(`runGraph: ${edgeId(edge)} analyst '${edge.analyst}' is neither a graph node nor in the analysts registry (known lenses: ${analysts.kinds.map((kind) => kind.id).join(", ") || "none"})`);
 		if (edge.over.length === 0) throw new ValidationError(`runGraph: ${edgeId(edge)} must analyze at least one node`);
 		for (const over of edge.over) requireNode(over, edgeId(edge));
 		requireNode(edge.to, edgeId(edge));
 	}
+	for (const edge of analyzes) for (const over of edge.over) if (analystNodes.has(over)) throw new ValidationError(`runGraph: ${edgeId(edge)} analyzes '${over}', which is an analyst node — an analyst run settles as a finding, never as a worker, so this edge would silently never fire; analyst nodes are not analyzable`);
 	const workers = /* @__PURE__ */ new Map();
 	const delegatesByWorker = /* @__PURE__ */ new Map();
 	for (const edge of delegates) {
@@ -4770,12 +4714,13 @@ function validateGraph(graph, registry, analysts) {
 		delegatesByWorker.set(edge.to, edge);
 		workers.set(edge.to, requireNode(edge.to, edgeId(edge)));
 	}
-	for (const node of graph.nodes) if (node.id !== root.id && !workers.has(node.id)) throw new ValidationError(`runGraph: node '${node.id}' has no delegates edge to it — an unreachable node never runs`);
+	for (const node of graph.nodes) if (node.id !== root.id && !workers.has(node.id) && !analystNodes.has(node.id)) throw new ValidationError(`runGraph: node '${node.id}' has no delegates edge to it — an unreachable node never runs`);
 	return {
 		root,
 		workers,
 		delegatesByWorker,
-		analyzes
+		analyzes,
+		analystNodes
 	};
 }
 const byteLength = (text) => Buffer.byteLength(text, "utf8");
@@ -4797,7 +4742,7 @@ function stringifyPayload(payload) {
 */
 function runGraph(graph, opts) {
 	const registry = opts.registry ?? kernelPromptRegistry();
-	const { root, workers, delegatesByWorker, analyzes } = validateGraph(graph, registry, opts.analysts);
+	const { root, workers, delegatesByWorker, analyzes, analystNodes } = validateGraph(graph, registry, opts.analysts);
 	if (!opts.backend && !opts.makeWorkerAgent) throw new ValidationError("runGraph: provide opts.backend (where nodes run) or opts.makeWorkerAgent");
 	const journal = opts.journal ?? new InMemorySpawnJournal();
 	const blobs = opts.blobs ?? new InMemoryResultBlobStore();
@@ -4848,6 +4793,11 @@ function runGraph(graph, opts) {
 	const pendingByAssignment = /* @__PURE__ */ new Map();
 	const graphWorker = (authoredProfile, spawnContext) => {
 		const requested = typeof authoredProfile?.name === "string" ? authoredProfile.name : void 0;
+		if (spawnContext?.analyst !== void 0) {
+			const analystNode = analystNodes.get(spawnContext.analyst);
+			if (!analystNode || requested !== analystNode.id) throw new ValidationError(`runGraph: analyst run for ${JSON.stringify(spawnContext.analyst)} does not name an analyst node of this graph (analyst nodes: ${[...analystNodes.keys()].join(", ") || "none"})`);
+			return makeLeaf(analystNode.profile, spawnContext);
+		}
 		const node = requested !== void 0 ? workers.get(requested) : void 0;
 		if (!node) throw new ValidationError(`runGraph: spawn_agent named profile ${JSON.stringify(requested)} which is not a worker node of this graph (nodes: ${[...workers.keys()].join(", ")}). Spawn by node id: profile.name selects the node; the node profile itself is pinned by the graph.`);
 		const edge = delegatesByWorker.get(node.id);
@@ -4892,16 +4842,26 @@ function runGraph(graph, opts) {
 		};
 		return makeLeaf(pinned, spawnContext);
 	};
-	const routes = analyzes.map((edge) => edge.to === root.id ? {
-		kind: edge.analyst,
-		over: edge.over
-	} : {
-		kind: edge.analyst,
-		over: edge.over,
-		to: edge.to,
-		directive: registry.resolve(edge.directive).text
+	const routes = analyzes.map((edge) => {
+		const analystNode = analystNodes.get(edge.analyst);
+		if (analystNode) return {
+			kind: edge.analyst,
+			over: edge.over,
+			agent: analystNode.profile,
+			directive: registry.resolve(edge.directive).text,
+			...edge.to === root.id ? {} : { to: edge.to }
+		};
+		return edge.to === root.id ? {
+			kind: edge.analyst,
+			over: edge.over
+		} : {
+			kind: edge.analyst,
+			over: edge.over,
+			to: edge.to,
+			directive: registry.resolve(edge.directive).text
+		};
 	});
-	const driverAnalyzesBriefs = analyzes.filter((edge) => edge.to === root.id).map((edge) => `Findings from analyst '${edge.analyst}' (over: ${edge.over.join(", ")}) will arrive as finding events.\n${registry.resolve(edge.directive).text}`);
+	const driverAnalyzesBriefs = analyzes.filter((edge) => edge.to === root.id).map((edge) => analystNodes.has(edge.analyst) ? `Findings from analyst '${edge.analyst}' (a tool-equipped analyst agent node, over: ${edge.over.join(", ")}) will arrive as finding events.` : `Findings from analyst '${edge.analyst}' (over: ${edge.over.join(", ")}) will arrive as finding events.\n${registry.resolve(edge.directive).text}`);
 	const graphBrief = [
 		"AGENT GRAPH: you are the driver node of a fixed topology. You may spawn ONLY these worker",
 		"nodes, by EXACT name (spawn_agent with profile: { name: '<node id>' }; the node's full",
@@ -5013,10 +4973,11 @@ function runGraph(graph, opts) {
 			runId,
 			hooks,
 			onCoordinationEvent,
-			...routes.length > 0 && opts.analysts ? {
-				analysts: opts.analysts,
-				analyzeOnSettle: routes
+			...routes.length > 0 ? {
+				analyzeOnSettle: routes,
+				...opts.analysts ? { analysts: opts.analysts } : {}
 			} : {},
+			...opts.watchWorkers ? { watchWorkers: opts.watchWorkers } : {},
 			...opts.router ? { router: opts.router } : {},
 			...opts.brain ? { brain: opts.brain } : {},
 			...authorizeMessage ? { authorizeMessage } : {},
@@ -6189,6 +6150,6 @@ function tail(s) {
 	return s.slice(-400);
 }
 //#endregion
-export { panel as $, runStrategyEvolution as A, defaultAuditorInstruction as At, equalKOnCost as B, secretEnvOfMcpServer as Bt, GraphEdgeCapError as C, leaderboard as Ct, streamAgentTurn as D, renderLeaderboardSvg as Dt, collectAgentTurn as E, renderLeaderboardMarkdown as Et, SandboxRunAbortError as F, sanitizeMcpToolSchema as Ft, createShapeRegistry as G, definePersona as H, openSandboxRun as I, envKeyProvider as It, InMemoryCorpus as J, registerShape as K, printBenchmarkReport as L, mcpSecretEnvMetadataKey as Lt, assertStrategyContract as M, connectStdioMcp as Mt, authorStrategy as N, materializeLocalMcp as Nt, discriminatingMeans as O, renderPairwiseMarkdown as Ot, strategyAuthorContract as P, createMcpEnvironment as Pt, loopUntil as Q, runBenchmark as R, resolveMcpServerLaunch as Rt, runCoderChecks as S, stopSentinel as St, runGraph as T, renderLeaderboardHtml as Tt, runPersonified as U, trajectoryReport as V, builtinShapes as W, fanout as X, renderCorpusToInstructions as Y, flatWidenGate as Z, settledWorkerOut as _, loopCampaignDispatch as _t, localShell as a, buildSteerContext as at, analyzeTrace as b, deterministicCompletion as bt, createVerifierEnvironment as c, inProcessSandboxClient as ct, worktreeFanout as d, dumbDriver as dt, pipeline as et, EVIDENCE_MAX_CHARS as f, naiveDriver as ft, composeWorkerEvidence as g, inlineSandboxClient as gt, closingWorkerNote as h, localSandboxClient as ht, jjWorkspace as i, assertTraceDerivedFindings as it, selectChampion as j, McpSpawnFault as jt, pickChampion as k, auditIntent as kt, failuresAnalyst as l, harvestCorpus as lt, VERIFY_TAIL_CHARS as m, resolveSandboxClient as mt, makeFinding$1 as n, verify as nt, runInWorkspace as o, createScopeAnalyst as ot, NOTE_MAX_CHARS as p, steeringDriver as pt, FileCorpus as q, gitWorkspace as r, widen as rt, createWaterfallCollector as s, registryScopeAnalyst as st, computeFindingId$1 as t, selectValidWinner as tt, superviseSurface as u, defineLeaderboard as ut, copyUntrackedIntoClone as v, loopDispatch as vt, defaultEdgeTraversalCap as w, pairwiseSignificance as wt, patchDelivered as x, sentinelCompletion as xt, withUntrackedArtifacts as y, completionAuthorizes as yt, promotionGate as z, resolveSecretEnv as zt };
+export { panel as $, runStrategyEvolution as A, materializeLocalMcp as At, equalKOnCost as B, GraphEdgeCapError as C, renderLeaderboardMarkdown as Ct, streamAgentTurn as D, defaultAuditorInstruction as Dt, collectAgentTurn as E, auditIntent as Et, SandboxRunAbortError as F, resolveMcpServerLaunch as Ft, createShapeRegistry as G, definePersona as H, openSandboxRun as I, resolveSecretEnv as It, InMemoryCorpus as J, registerShape as K, printBenchmarkReport as L, secretEnvOfMcpServer as Lt, assertStrategyContract as M, sanitizeMcpToolSchema as Mt, authorStrategy as N, envKeyProvider as Nt, discriminatingMeans as O, McpSpawnFault as Ot, strategyAuthorContract as P, mcpSecretEnvMetadataKey as Pt, loopUntil as Q, runBenchmark as R, runCoderChecks as S, renderLeaderboardHtml as St, runGraph as T, renderPairwiseMarkdown as Tt, runPersonified as U, trajectoryReport as V, builtinShapes as W, fanout as X, renderCorpusToInstructions as Y, flatWidenGate as Z, settledWorkerOut as _, deterministicCompletion as _t, localShell as a, buildSteerContext as at, analyzeTrace as b, leaderboard as bt, createVerifierEnvironment as c, inProcessSandboxClient as ct, worktreeFanout as d, resolveSandboxClient as dt, pipeline as et, EVIDENCE_MAX_CHARS as f, localSandboxClient as ft, composeWorkerEvidence as g, completionAuthorizes as gt, closingWorkerNote as h, loopDispatch as ht, jjWorkspace as i, assertTraceDerivedFindings as it, selectChampion as j, createMcpEnvironment as jt, pickChampion as k, connectStdioMcp as kt, failuresAnalyst as l, harvestCorpus as lt, VERIFY_TAIL_CHARS as m, loopCampaignDispatch as mt, makeFinding$1 as n, verify as nt, runInWorkspace as o, createScopeAnalyst as ot, NOTE_MAX_CHARS as p, inlineSandboxClient as pt, FileCorpus as q, gitWorkspace as r, widen as rt, createWaterfallCollector as s, registryScopeAnalyst as st, computeFindingId$1 as t, selectValidWinner as tt, superviseSurface as u, defineLeaderboard as ut, copyUntrackedIntoClone as v, sentinelCompletion as vt, defaultEdgeTraversalCap as w, renderLeaderboardSvg as wt, patchDelivered as x, pairwiseSignificance as xt, withUntrackedArtifacts as y, stopSentinel as yt, promotionGate as z };
 
-//# sourceMappingURL=runtime-DZblIf3R.js.map
+//# sourceMappingURL=runtime-BzXz7OjS.js.map