@tangle-network/agent-runtime 0.135.3 → 0.137.0

package/dist/{runtime-WugWo__W.d.ts → runtime-DhPCNvuH.d.ts}

@@ -1,10 +1,197 @@
 import { E as SandboxClient, i as ExecCtx, k as Validator } from "./types-BBwGSiAj.js";
-import { Q as UsageEvent, U as Spend, d as ExecutorFactory, gn as ExecutorProgress, ln as TraceSource, m as ExecutorRegistry } from "./types-BCkweg3w.js";
+import { I as Scope, Q as UsageEvent, U as Spend, d as ExecutorFactory, gn as ExecutorProgress, ln as TraceSource, m as ExecutorRegistry } from "./types-BCkweg3w.js";
 import { i as AgentEnvironmentProvider, o as AgentEnvironmentProviderRegistry, w as ProviderExecutorOptions } from "./environment-provider-DA8LqBV-.js";
 import { AgentProfile, AgentProfileMcpServer, HarnessType, ReasoningEffort } from "@tangle-network/agent-interface";
 import { WorkspacePlanReceipt } from "@tangle-network/agent-profile-materialize";
 import { ChildProcess } from "node:child_process";
 import { BackendType, SandboxEvent } from "@tangle-network/sandbox";
+//#region src/mcp/protocol.d.ts
+/**
+ * Shared wire contracts for the in-process stdio MCP servers.
+ *
+ * Keeping these types in one module prevents the delegation and generic tool
+ * servers from accepting subtly different JSON-RPC messages.
+ *
+ * @experimental
+ */
+/** A callable MCP tool exposed by either stdio server. @experimental */
+interface McpToolDescriptor {
+  name: string;
+  description: string;
+  inputSchema: Record<string, unknown>;
+  handler: (raw: unknown) => Promise<unknown>;
+}
+/** Stdio-shaped transport used by the shared JSON-RPC server implementation. @experimental */
+interface McpTransport {
+  input: NodeJS.ReadableStream;
+  output: NodeJS.WritableStream;
+}
+/** One JSON-RPC 2.0 request or notification. @experimental */
+interface JsonRpcMessage {
+  jsonrpc: '2.0';
+  id?: number | string | null;
+  method: string;
+  params?: unknown;
+}
+/** One JSON-RPC 2.0 response. @experimental */
+interface JsonRpcResponse {
+  jsonrpc: '2.0';
+  id: number | string | null;
+  result?: unknown;
+  error?: {
+    code: number;
+    message: string;
+    data?: unknown;
+  };
+}
+//#endregion
+//#region src/runtime/supervise/peer-mail.d.ts
+/**
+ * What one envelope IS, typed so a reader can act on it without parsing prose.
+ *
+ *  - `ask` — request a fact the sender lacks; expects an `answer`.
+ *  - `tell` — share a result; MUST carry evidence refs.
+ *  - `challenge` — dispute a peer's claim; MUST cite the refs of the claim it disputes.
+ *  - `answer` — reply to an `ask` or a `challenge`.
+ */
+type PeerMailKind = 'ask' | 'tell' | 'challenge' | 'answer';
+/** One admitted peer message. `threadId` is the root mail's id; `depth` is 0 for a root mail and
+ *  one more than its parent for a reply, which is what the reply-depth cap counts. */
+interface PeerMailEnvelope {
+  readonly mailId: string;
+  readonly threadId: string;
+  readonly depth: number;
+  /** The bound sender — resolved from the capability, never from a tool argument. */
+  readonly from: string;
+  readonly to: string;
+  readonly kind: PeerMailKind;
+  readonly subject: string;
+  readonly body: string;
+  /** Evidence the receiver can re-check for itself. Required for `tell` and `challenge`. */
+  readonly evidenceRefs: ReadonlyArray<string>;
+  /** The mail id this replies to. Never a coordination question id — a peer cannot address the
+   *  parent's answer channel. */
+  readonly replyTo?: string;
+  readonly at: number;
+}
+/** Why an attempt did not reach a sibling. Each value is a fact the sender can read and act on. */
+type PeerMailRefusal = 'sender-unbound' | 'self-addressed' | 'send-quota-exhausted' | 'mailbox-full' | 'thread-depth-exceeded' | 'thread-stopped' | 'unknown-reply-target' | 'evidence-required' | 'subject-too-large' | 'body-too-large' | 'forged-authority' | 'unknown-worker' | 'already-settled' | 'worker-has-no-inbox' | 'scope-stopped' | 'runtime-error';
+type PeerMailOutcome = 'delivered' | PeerMailRefusal;
+/** The audit record for one attempt — published whether it delivered or was refused, because a
+ *  refused attempt is exactly what a parent auditing a channel needs to see. */
+interface PeerMailEvent {
+  readonly envelope: PeerMailEnvelope;
+  readonly delivered: boolean;
+  readonly outcome: PeerMailOutcome;
+  /** Canonical digest of the exact admitted body, so a later claim can name the bytes it read. */
+  readonly bodyDigest: string;
+  readonly error?: string;
+}
+/** Hard bounds. Every one fails closed with a refusal the sender can read. */
+interface PeerMailLimits {
+  /** Mail one worker may attempt to send for the whole run. */
+  readonly maxSentPerWorker: number;
+  /** Mail one worker may receive for the whole run. */
+  readonly maxInboxPerWorker: number;
+  /** Total admitted body bytes one worker may receive for the whole run. */
+  readonly maxInboxBytesPerWorker: number;
+  /** Maximum reply depth; a root mail is depth 0, so `2` allows ask → answer → answer. */
+  readonly maxThreadDepth: number;
+  readonly maxBodyBytes: number;
+  readonly maxSubjectBytes: number;
+}
+/** Bounds chosen so a peer channel cannot become the dominant cost of a run: eight sends and
+ *  sixteen receives per worker, 32 KiB of received body, and a reply chain that terminates. */
+declare const DEFAULT_PEER_MAIL_LIMITS: PeerMailLimits;
+/**
+ * Phrases that mark the run's AUTHORITY in a folded prompt. A peer that writes one of these is
+ * trying to speak as the supervisor, so intake refuses the envelope outright.
+ *
+ * The render-time fence in the inbox is the second half of this defence and neither half is
+ * sufficient alone: a fence loses to a body that closes it, and an intake filter loses to a body
+ * that invents a new authority phrase. Together they make forgery mechanically detectable and give
+ * the standing prompt one concrete boundary to bind to. Neither makes a model OBEY a boundary.
+ */
+declare const AUTHORITY_MARKERS: ReadonlyArray<string>;
+/** The wire property carrying an envelope to a worker inbox. Deliberately its OWN discriminant:
+ *  reusing `steer`/`answer` would let a peer mint a message on the parent's channels. */
+declare const PEER_MAIL_WIRE_KEY = "mail";
+/** The tool names a mail capability endpoint serves. It serves NOTHING else. */
+declare const peerMailVerbNames: readonly ["send_mail", "read_mail"];
+/** What a worker sees when it reads its own mailbox. */
+interface PeerMailReadout {
+  /** The reading worker's own id, so a worker can address a reply correctly. */
+  readonly you: string;
+  /** Every envelope admitted to this worker so far, oldest first. */
+  readonly inbox: ReadonlyArray<PeerMailEnvelope>;
+  /** Live siblings this worker may write to (itself excluded). Without this a worker knows no
+   *  peer's id and the channel is unusable. */
+  readonly peers: ReadonlyArray<{
+    readonly workerId: string;
+    readonly label: string;
+  }>;
+  readonly sent: number;
+  /** Sends still allowed, or `null` when this run set no send quota. */
+  readonly sendQuotaLeft: number | null;
+  readonly limits: PeerMailLimits;
+}
+interface PeerMailSendInput {
+  readonly to: unknown;
+  readonly kind: unknown;
+  readonly subject: unknown;
+  readonly body: unknown;
+  readonly evidenceRefs?: unknown;
+  readonly replyTo?: unknown;
+}
+interface PeerMailbox {
+  readonly limits: PeerMailLimits;
+  /**
+   * Publish the base URL of the capability listener once it has a port. Until it is set no spawn
+   * receives a mail endpoint: a capability nobody can reach is not worth handing out, and a URL
+   * built from an unassigned port would be a lie.
+   */
+  setEndpoint(baseUrl: string): void;
+  /** Mint (idempotently, per assignment) the capability URL for one spawn. Undefined before the
+   *  listener has published its endpoint. */
+  mintCapability(assignmentId: string): string | undefined;
+  /** Bind a minted capability to the concrete worker the spawn produced. Until this runs the
+   *  capability can send nothing. */
+  bindCapability(assignmentId: string, workerId: string): void;
+  /** Resolve the capability path segment carried in a request URL. */
+  hasCapability(capabilityId: string): boolean;
+  /** The two tools a single capability serves, with the sender closed over. */
+  tools(capabilityId: string): McpToolDescriptor[];
+  send(capabilityId: string, input: PeerMailSendInput): Promise<PeerMailEvent>;
+  read(capabilityId: string): PeerMailReadout;
+  /** The parent's control: refuse every further mail on one thread. Returns false when the thread
+   *  was already stopped. Mail already delivered is not recalled — this stops the next reply. */
+  stopThread(threadId: string): boolean;
+  /** Every attempt in order — delivered and refused alike. */
+  history(): ReadonlyArray<PeerMailEvent>;
+}
+interface PeerMailboxOptions {
+  readonly scope: Scope<unknown>;
+  /** Publish one attempt as a coordination event. Awaited, so a durable subscriber commits the
+   *  record before the sender learns the outcome. */
+  readonly publish: (event: PeerMailEvent) => Promise<void>;
+  readonly limits?: Partial<PeerMailLimits>;
+  readonly now?: () => number;
+}
+/** True when `text` carries a phrase reserved for the run's authority. Case-insensitive, because
+ *  the render is read by a model and case is not what distinguishes an instruction. */
+declare function claimsAuthority(text: string): boolean;
+/** True when `value` is an envelope this runtime produced. The worker inbox parses with this, so a
+ *  malformed or partial wire object is discarded rather than rendered as a peer message. */
+declare function isPeerMailEnvelope(value: unknown): value is PeerMailEnvelope;
+/** Create the run's post office. One per manager scope; the manager's siblings are its addresses. */
+declare function createPeerMailbox(opts: PeerMailboxOptions): PeerMailbox;
+/**
+ * The two tools ONE capability serves. `capabilityId` is closed over and `from` is not a parameter,
+ * so the endpoint a worker holds can only ever speak as that worker. The descriptions carry the
+ * authority rule, because the receiving model reads them as part of the channel's contract.
+ */
+declare function peerMailTools(mailbox: PeerMailbox, capabilityId: string): McpToolDescriptor[];
+//#endregion
 //#region src/runtime/router-retry-policy.d.ts
 /** Exact retry controls accepted at `AgentProfile.model.metadata.retry`. */
 interface RouterRetryPolicy {
@@ -584,25 +771,8 @@ interface ResolvedMcpServerLaunch {
 declare function resolveMcpServerLaunch(server: AgentProfileMcpServer, keys: KeyProvider | undefined, label: string): Promise<ResolvedMcpServerLaunch>;
 //#endregion
 //#region src/runtime/supervise/inbox.d.ts
-/**
- *
- * The worker-side receive end of the down-leg: a per-worker inbox an executor exposes as
- * `Executor.deliver`. The driver's `steer_agent` / `answer_question` land here,
- * and the worker's agent loop drains them at two points (Drew's two delivery modes):
- *
- *   - QUEUED (default): the message accumulates and is FLUSHED at the next step boundary — folded
- *     into the conversation before the next think. A worker is also forced to flush BEFORE it may
- *     settle, so it can never finish while a steer/answer it never read is still pending.
- *   - FORCEFUL (`interrupt: true`): trips `freshInterrupt()`'s signal so the loop can abort its
- *     in-flight turn immediately, then re-plan with the message folded in — breaking the worker out
- *     of a wrong path mid-task instead of waiting for it to finish the step.
- *
- * `deliver` never throws — a malformed message is ignored and returns `false`, so no caller can
- * report delivery for bytes this inbox discarded.
- *
- * @experimental
- */
-interface InboxMessage {
+/** A message from the run's AUTHORITY — the parent driver. These two kinds carry instruction. */
+interface AuthorityInboxMessage {
   readonly kind: 'steer' | 'answer';
   readonly text: string;
   /** Forceful messages abort the in-flight turn; queued ones wait for the boundary flush. */
@@ -610,6 +780,16 @@ interface InboxMessage {
   /** Present for an `answer` — the question id it resolves. */
   readonly questionId?: string;
 }
+/** A message from a SIBLING worker. Information, never instruction — the parent stays the only
+ *  authority over this worker's task. */
+interface PeerInboxMessage {
+  readonly kind: 'mail';
+  readonly text: string;
+  /** Always false. Peer mail is queued by construction; see this file's header. */
+  readonly interrupt: false;
+  readonly envelope: PeerMailEnvelope;
+}
+type InboxMessage = AuthorityInboxMessage | PeerInboxMessage;
 interface Inbox {
   /** The `Executor.deliver` implementation. Returns false when the raw message is malformed and
    * therefore was not queued; callers must not acknowledge a message this inbox discarded. */
@@ -617,13 +797,17 @@ interface Inbox {
   /** Remove and return all pending messages (the flush). */
   drain(): InboxMessage[];
   pending(): number;
+  /** Pending messages from the run's AUTHORITY only. This is what the pre-settle fence counts:
+   *  a worker may not finish while a steer or answer it never read is queued, but peer mail must
+   *  never be able to hold a finished worker open. */
+  pendingAuthority(): number;
   /** Open a fresh per-turn interrupt signal; a later forceful `deliver` aborts it. The loop links
    *  this into the signal it passes to its inference call, then re-plans when it fires. */
   freshInterrupt(): AbortSignal;
   /** Render drained messages as ONE operator turn to fold into the worker's conversation. */
   fold(messages: ReadonlyArray<InboxMessage>): string;
 }
-/** Create the worker-side inbox for the down-leg: the driver's `steer_agent` / `answer_question` messages queue here and the worker's loop drains them at step boundaries and before settle. */
+/** Create the worker-side inbox for the down-leg: the driver's `steer_agent` / `answer_question` messages and a sibling's peer mail queue here, and the worker's loop drains them at step boundaries and before settle. */
 declare function createInbox(): Inbox;
 //#endregion
 //#region src/runtime/supervise/sandbox-session.d.ts
@@ -977,5 +1161,5 @@ declare function createExecutor(config: ExecutorConfig): ExecutorFactory<unknown
  */
 declare function createExecutorRegistry(): ExecutorRegistry;
 //#endregion
-export { createWorktree as $, WorktreeCheckRunner as A, LocalHarnessResult as B, KeyProvider as C, resolveMcpServerLaunch as D, mcpSecretEnvMetadataKey as E, CodexExecutionPolicy as F, runLocalHarness as G, harnessSupportsReasoningEffort as H, CodexTokenUsage as I, DiffResult as J, CreateWorktreeOptions as K, DEFAULT_LOCAL_HARNESS as L, WorktreeHarnessResult as M, WorktreeProfileMaterializationReceipt as N, resolveSecretEnv as O, CodexExecutionEvidence as P, captureWorktreeDiff as Q, LOCAL_HARNESSES as R, createInbox as S, envKeyProvider as T, localHarnessExecutable as U, RunLocalHarnessOptions as V, parseCodexTokenUsage as W, RemoveWorktreeOptions as X, GitRunner as Y, WorktreeHandle as Z, SteerableSandboxArgs as _, CliWorktreeSeam as a, ToolLoopCompaction as at, Inbox as b, RouterSeam as c, ToolLoopToolCall as ct, SandboxSeam as d, removeWorktree as et, cliWorktreeExecutor as f, SandboxSteeringOptions as g, DEFAULT_SANDBOX_STEERING_MAX_TURNS as h, CliWorktreeBridgeSeam as i, ToolLoopChat as it, WorktreeCommandResult as j, secretEnvOfMcpServer as k, RouterToolsSeam as l, createExecutorRegistry as m, BridgeSeam as n, ToolSpec as nt, ExecutorConfig as o, ToolLoopCompactionOptions as ot, createExecutor as p, DiffOptions as q, CliSeam as r, ToolLoopCallContext as rt, ProviderSeam as s, ToolLoopMessageRecord as st, BridgeModelCredential as t, RouterTransportConfig as tt, SandboxLeafOut as u, SteerableSandboxSession as v, ResolvedMcpServerLaunch as w, InboxMessage as x, createSteerableSandboxSession as y, LocalHarness as z };
-//# sourceMappingURL=runtime-WugWo__W.d.ts.map
+export { WorktreeHandle as $, resolveSecretEnv as A, JsonRpcResponse as At, LOCAL_HARNESSES as B, PeerInboxMessage as C, PeerMailboxOptions as Ct, envKeyProvider as D, peerMailTools as Dt, ResolvedMcpServerLaunch as E, isPeerMailEnvelope as Et, WorktreeProfileMaterializationReceipt as F, localHarnessExecutable as G, LocalHarnessResult as H, CodexExecutionEvidence as I, CreateWorktreeOptions as J, parseCodexTokenUsage as K, CodexExecutionPolicy as L, WorktreeCheckRunner as M, McpTransport as Mt, WorktreeCommandResult as N, mcpSecretEnvMetadataKey as O, peerMailVerbNames as Ot, WorktreeHarnessResult as P, RemoveWorktreeOptions as Q, CodexTokenUsage as R, InboxMessage as S, PeerMailbox as St, KeyProvider as T, createPeerMailbox as Tt, RunLocalHarnessOptions as U, LocalHarness as V, harnessSupportsReasoningEffort as W, DiffResult as X, DiffOptions as Y, GitRunner as Z, SteerableSandboxArgs as _, PeerMailLimits as _t, CliWorktreeSeam as a, ToolLoopCallContext as at, AuthorityInboxMessage as b, PeerMailRefusal as bt, RouterSeam as c, ToolLoopCompactionOptions as ct, SandboxSeam as d, AUTHORITY_MARKERS as dt, captureWorktreeDiff as et, cliWorktreeExecutor as f, DEFAULT_PEER_MAIL_LIMITS as ft, SandboxSteeringOptions as g, PeerMailKind as gt, DEFAULT_SANDBOX_STEERING_MAX_TURNS as h, PeerMailEvent as ht, CliWorktreeBridgeSeam as i, ToolSpec as it, secretEnvOfMcpServer as j, McpToolDescriptor as jt, resolveMcpServerLaunch as k, JsonRpcMessage as kt, RouterToolsSeam as l, ToolLoopMessageRecord as lt, createExecutorRegistry as m, PeerMailEnvelope as mt, BridgeSeam as n, removeWorktree as nt, ExecutorConfig as o, ToolLoopChat as ot, createExecutor as p, PEER_MAIL_WIRE_KEY as pt, runLocalHarness as q, CliSeam as r, RouterTransportConfig as rt, ProviderSeam as s, ToolLoopCompaction as st, BridgeModelCredential as t, createWorktree as tt, SandboxLeafOut as u, ToolLoopToolCall as ut, SteerableSandboxSession as v, PeerMailOutcome as vt, createInbox as w, claimsAuthority as wt, Inbox as x, PeerMailSendInput as xt, createSteerableSandboxSession as y, PeerMailReadout as yt, DEFAULT_LOCAL_HARNESS as z };
+//# sourceMappingURL=runtime-DhPCNvuH.d.ts.map

package/dist/{runtime-BQTE0RJS.js → runtime-yCuqlhou.js}

@@ -6,13 +6,13 @@ import { i as redactProtectedValue, r as redactProtectedReason } from "./protect
 import { a as notifySandboxEventObserver, c as parseCanonicalTransportEvent, s as extractTransportEventIdentity } from "./sandbox-events-CA2amHoA.js";
 import { c as profileProviderModel, i as concreteModelId, s as profileModelExecutionSettings, t as assertExecutableAgentProfile } from "./model-policy-UTTc9Z-A.js";
 import { E as executableAgentSpecSnapshot, T as executableAgentProfileSnapshot } from "./materialization-BP5zspr2.js";
-import { E as rollingDispatch, I as createExecutor, L as createExecutorRegistry, at as createSandboxLineage, ct as routerBrain, g as settledToIteration, it as runAgentRounds, l as withDriverExecutor, lt as runBrainLoop, n as createSupervisor, nt as defaultSelectWinner, ot as probeSandboxCapabilities, q as createPushTraceSource, ut as canonicalObservedModel, z as createWorktreeCliExecutor } from "./supervisor-mZ9Glkz7.js";
+import { E as rollingDispatch, I as createExecutor, L as createExecutorRegistry, _t as runBrainLoop, ft as runAgentRounds, g as settledToIteration, gt as routerBrain, l as withDriverExecutor, mt as probeSandboxCapabilities, n as createSupervisor, pt as createSandboxLineage, q as createPushTraceSource, ut as defaultSelectWinner, vt as canonicalObservedModel, z as createWorktreeCliExecutor } from "./supervisor-BfJNS2Z3.js";
 import "./environment-provider-CLNVqp6H.js";
 import { i as notifyRuntimeHookEvent } from "./runtime-hooks-C7iJOWm3.js";
-import { C as observe, O as strategyAuthorMethod, T as profileChatClient, b as sample, v as refine, x as sampleThenRefine, y as runAgentic } from "./structural-rollout-keBf4YEc.js";
-import { It as gateOnDeliverable, Lt as mapExecutorResult, n as supervise } from "./supervise-CVP9ku5U.js";
-import "./authoring-Cl5xwuKl.js";
-import "./graph-NKOjYL1z.js";
+import { C as observe, O as strategyAuthorMethod, T as profileChatClient, b as sample, v as refine, x as sampleThenRefine, y as runAgentic } from "./structural-rollout-2Z6J5ttt.js";
+import { It as gateOnDeliverable, Lt as mapExecutorResult, n as supervise } from "./supervise-to2ynnCG.js";
+import "./authoring-rEOOEWn6.js";
+import "./graph-yaEG0ZiR.js";
 import { CODING_HARNESSES, InMemoryTraceStore, OUTPUT_VALUE, benjaminiHochberg, buildTrajectory, computeFindingId as computeFindingId$1, confidenceInterval, expandProfileAxes, makeFinding as makeFinding$1, pairedBootstrap, paretoFrontier, wilcoxonSignedRank, wilson } from "@tangle-network/agent-eval";
 import { heldoutSignificance, runProfileMatrix } from "@tangle-network/agent-eval/campaign";
 import { AgentEnvironmentCapabilitiesSchema, AgentExactRunControlRefSchema, AgentNativeContextContinuationResultSchema, AgentRunCancellationAcknowledgementSchema, AgentRunCancellationRequestSchema, AgentTurnResultSchema, InteractionAcknowledgementSchema, InteractionResponseCommandSchema, NativeContextBoundaryProofSchema, NativeContextContinuationRequestSchema, RuntimeEventEnvelopeSchema, agentNativeContextContinuationResultMatchesRequest, agentProfileSchema, agentRunCancellationAcknowledgementMatchesRequest, agentRunCancellationRequestDigest, canonicalAgentProfileDigest, canonicalCandidateDigest, nativeContextContinuationTurnDigest, validateAgentProfileSecurity } from "@tangle-network/agent-interface";
@@ -6672,4 +6672,4 @@ function tail(s) {
 //#endregion
 export { FileCorpus as $, pickChampion as A, renderLeaderboardMarkdown as At, runBenchmark as B, envKeyProvider as Bt, analyzeTrace as C, completionAuthorizes as Ct, chatWorkerSeam as D, leaderboard as Dt, chatTransportExecutor as E, stopSentinel as Et, strategyAuthorContract as F, McpSpawnFault as Ft, promotionGate as G, recoverRetainedRun as H, resolveMcpServerLaunch as Ht, strategyAuthorSystemPrompt as I, connectStdioMcp as It, definePersona as J, equalKOnCost as K, SandboxRunAbortError as L, materializeLocalMcp as Lt, selectChampion as M, renderPairwiseMarkdown as Mt, assertStrategyContract as N, auditIntent as Nt, createChatSessionStore as O, pairwiseSignificance as Ot, authorStrategy as P, defaultAuditorInstruction as Pt, registerShape as Q, openSandboxRun as R, createMcpEnvironment as Rt, withUntrackedArtifacts as S, superviseDispatch as St, runCoderChecks as T, sentinelCompletion as Tt, startRetainedRun as U, resolveSecretEnv as Ut, reconnectRetainedRun as V, mcpSecretEnvMetadataKey as Vt, startRetainedRunInEnvironment as W, secretEnvOfMcpServer as Wt, builtinShapes as X, runPersonified as Y, createShapeRegistry as Z, VERIFY_TAIL_CHARS as _, resolveSandboxClient as _t, localShell as a, panel as at, settledWorkerOut as b, loopCampaignDispatch as bt, createVerifierEnvironment as c, verify as ct, harvestSurfaceDiffs as d, buildSteerContext as dt, InMemoryCorpus as et, failuresAnalyst as f, createScopeAnalyst as ft, NOTE_MAX_CHARS as g, defineLeaderboard as gt, EVIDENCE_MAX_CHARS as h, harvestCorpus as ht, jjWorkspace as i, loopUntil as it, runStrategyEvolution as j, renderLeaderboardSvg as jt, discriminatingMeans as k, renderLeaderboardHtml as kt, boxSurfaceReader as l, widen as lt, worktreeFanout as m, inProcessSandboxClient as mt, makeFinding$1 as n, fanout as nt, runInWorkspace as o, pipeline as ot, superviseSurface as p, registryScopeAnalyst as pt, trajectoryReport as q, gitWorkspace as r, flatWidenGate as rt, createWaterfallCollector as s, selectValidWinner as st, computeFindingId$1 as t, renderCorpusToInstructions as tt, fsSurfaceReader as u, assertTraceDerivedFindings as ut, closingWorkerNote as v, localSandboxClient as vt, patchDelivered as w, deterministicCompletion as wt, copyUntrackedIntoClone as x, loopDispatch as xt, composeWorkerEvidence as y, inlineSandboxClient as yt, printBenchmarkReport as z, sanitizeMcpToolSchema as zt };
 
-//# sourceMappingURL=runtime-BQTE0RJS.js.map
+//# sourceMappingURL=runtime-yCuqlhou.js.map