@tangle-network/agent-runtime 2.3.7 → 2.3.8

package/dist/testing.d.ts

@@ -1,4 +1,4 @@
-import { Bv as DecideGate, By as McpToolDescriptor, Ch as ToolLoopCallContext, Ct as SuperviseProfileEntry, Dh as ToolLoopMessageRecord, Eh as ToolLoopCompactionOptions, Ip as PriorCoordination, Jv as ChildQuestionInbox, M as Budget, Nd as superviseWithTestBrain, Np as CoordinationDeliveryEvidence, Nv as CoordinationEvent, Oh as ToolLoopToolCall, Om as Inbox, Qf as ManagerWakePolicy, Rd as SuperviseTestOptions, Rf as supervisorAgentWithTestBrain, Sp as SupervisorFinalizer, Uy as BusRecord, Wv as RouteFlow, Yg as DeliverableSpec, Yv as EscalateQuestion, Zi as ResultBlobStore, _t as PeerAuditAccess, _y as MapOnSettleRoute, ap as StopRule, bt as SpawnPreflightContext, fd as runGraphWithTestBrain, ft as CoordinationTools, gt as MakeWorkerAgent, ht as GraphSubtasks, ld as RunGraphTestOptions, mt as GraphSubtaskPreparation, qf as SupervisorAgentTestDeps, rb as AnalyzeOnSettleRoute, sy as AuthorizeDownMessage, tb as AnalystRegistry, tm as SpawnResourceReader, ua as Agent, up as RunCancelRequest, uy as ContinuityMode, wh as ToolLoopChat, xt as SpawnRefusal, yh as RouterResponseReceipt, yt as SpawnPreflight, zv as WorkerWatchOptions, zx as HarnessTranscriptCapture } from "./types-BGGZDz0I.js";
+import { Bv as DecideGate, By as McpToolDescriptor, Ch as ToolLoopCallContext, Ct as SuperviseProfileEntry, Dh as ToolLoopMessageRecord, Eh as ToolLoopCompactionOptions, Ip as PriorCoordination, Jv as ChildQuestionInbox, M as Budget, Nd as superviseWithTestBrain, Np as CoordinationDeliveryEvidence, Nv as CoordinationEvent, Oh as ToolLoopToolCall, Om as Inbox, Qf as ManagerWakePolicy, Rd as SuperviseTestOptions, Rf as supervisorAgentWithTestBrain, Sp as SupervisorFinalizer, Uy as BusRecord, Wv as RouteFlow, Yg as DeliverableSpec, Yv as EscalateQuestion, Zi as ResultBlobStore, _t as PeerAuditAccess, _y as MapOnSettleRoute, ap as StopRule, bt as SpawnPreflightContext, fd as runGraphWithTestBrain, ft as CoordinationTools, gt as MakeWorkerAgent, ht as GraphSubtasks, ld as RunGraphTestOptions, mt as GraphSubtaskPreparation, qf as SupervisorAgentTestDeps, rb as AnalyzeOnSettleRoute, sy as AuthorizeDownMessage, tb as AnalystRegistry, tm as SpawnResourceReader, ua as Agent, up as RunCancelRequest, uy as ContinuityMode, wh as ToolLoopChat, xt as SpawnRefusal, yh as RouterResponseReceipt, yt as SpawnPreflight, zv as WorkerWatchOptions, zx as HarnessTranscriptCapture } from "./types-DzS0kBeK.js";
 import { AgentImprovementProposal, AgentProfile, AgentProfileImprovementMeasuredComparison, SandboxSizePreset } from "@tangle-network/agent-interface";
 /** What the brain returned for one turn, as the recorder keeps it. */
 interface RouterTranscriptReply {

package/dist/testing.js

@@ -1,13 +1,13 @@
 import { P as canonicalCandidateDigest$1, R as immutableCandidateValue } from "./sandbox-profile-compat-DRiz9kME.js";
 import { c as verifyAgentImprovementProposal } from "./activation-CDPbi8JA.js";
 import { a as applyExactAgentProfileDiff, v as parseExactAgentProfile } from "./profile-Dir2A1_2.js";
-import { f as supervisorAgentWithTestBrain, r as superviseWithTestBrain, v as driverAgent } from "./supervise-Dm0Goys6.js";
-import { r as runGraphWithTestBrain } from "./graph-FLVwpg79.js";
+import { f as supervisorAgentWithTestBrain, r as superviseWithTestBrain, v as driverAgent } from "./supervise-D1eYde7p.js";
+import { r as runGraphWithTestBrain } from "./graph-oOdDpXFH.js";
 import { SANDBOX_SIZE_PRESET_NAMES, canonicalAgentProfileDigest } from "@tangle-network/agent-interface";
 // src/testing/fixtures/agent-improvement-proposal.json
 var agent_improvement_proposal_default = {
 	changedSurfaces: ["prompt"],
-	digest: "sha256:16b6a316f916897b3c652801bc84f5912c9ebb58684419694968784f0dbb74f5",
+	digest: "sha256:bc2730ed12d5b692b51ff04ab6f92b0a6c29bf774d0f4ad072ac57ffd3b1b529",
 	evaluation: {
 		"decision": {
 			"contributingChecks": [
@@ -4578,7 +4578,7 @@ var agent_improvement_proposal_default = {
 		],
 		"metadata": {
 			"fixture": "agent-improvement-proposal",
-			"runtimeVersion": "2.3.7"
+			"runtimeVersion": "2.3.8"
 		},
 		"objectives": [
 			{
@@ -4689,8 +4689,8 @@ var agent_improvement_proposal_default = {
 			"baselineContentHash": "sha256:5c21ee53e513fc604cb09754e21c392b24a424da0ef37dbf8f1ee4a8a0b08f09",
 			"candidateContentHash": "sha256:60fcbb1c728194bd51d7d19cb732d1c3f1881dce7e0a6266b41c8b98cfd65693",
 			"kind": "agent-eval-loop",
-			"recordDigest": "sha256:caec57d2139050069151d57beffa96f506d3b9332ca58f252332f4d9e2357763",
-			"runId": "agent-runtime-2.3.7-proposal-fixture",
+			"recordDigest": "sha256:b659589da3f091ed34eed192410b09c50c83b71a1ee2570348f306850daebd43",
+			"runId": "agent-runtime-2.3.8-proposal-fixture",
 			"schema": "agent-candidate-experiment"
 		}
 	},
@@ -4713,12 +4713,12 @@ var agent_improvement_proposal_default = {
 	}],
 	kind: "agent-improvement-proposal",
 	proposedAt: "2026-07-10T01:00:00.000Z",
-	runId: "agent-runtime-2.3.7-proposal-fixture"
+	runId: "agent-runtime-2.3.8-proposal-fixture"
 };
 // src/testing/fixtures/agent-profile-improvement-proposal.json
 var agent_profile_improvement_proposal_default = {
 	changedSurfaces: ["prompt", "skills"],
-	digest: "sha256:52c87f024cf3b10015181251b59c8193ef45f19fccc8989731d14fafccc041c1",
+	digest: "sha256:7f128a6cc0c0ff12cf25fe766eca49dae02fccd3a54f6f614a8e7b56be536a8c",
 	evaluation: {
 		"decision": {
 			"contributingChecks": [
@@ -6352,7 +6352,7 @@ var agent_profile_improvement_proposal_default = {
 		],
 		"metadata": {
 			"fixture": "agent-profile-improvement-proposal",
-			"runtimeVersion": "2.3.7"
+			"runtimeVersion": "2.3.8"
 		},
 		"objectives": [
 			{
@@ -6463,7 +6463,7 @@ var agent_profile_improvement_proposal_default = {
 			"baselineContentHash": "sha256:21c495a37c418c10bde64fbaa188beddeed31f1f051ea60a6a6582a9ee0db704",
 			"candidateContentHash": "sha256:103f77bc8481601eef1ad5fe6ba84a40dffabc3a44f421f8c8559121edab84e9",
 			"kind": "agent-eval-loop",
-			"recordDigest": "sha256:3f9a3f013f1bd8822c41deca4f46df216d52a26cba175770e45611f433cfb8f4",
+			"recordDigest": "sha256:86ea45557fffc96f18e005100effa8e9a8349885f757a38c43d3e3cafeeeb7c8",
 			"runId": "profile-improvement-1",
 			"schema": "agent-profile-improvement-experiment"
 		}

package/dist/tui/index.d.ts

@@ -1,4 +1,4 @@
-import { Hr as provisionSupervisor, L as Spend, M as Budget, Wu as PursuitProjection } from "../types-BGGZDz0I.js";
+import { Hr as provisionSupervisor, L as Spend, M as Budget, Wu as PursuitProjection } from "../types-DzS0kBeK.js";
 interface TopSnapshot {
   readonly root: string;
   readonly generatedAt: number;

package/dist/{types-BGGZDz0I.d.ts → types-DzS0kBeK.d.ts}

@@ -10381,7 +10381,9 @@ interface AgentGraph {
   /** Setting it makes this a FLOW graph: Runtime spawns every entry at once, each with its task,
    *  and traverses `routes` edges itself. No node is a root and no caller brain runs; the run's
    *  output is `{ [node]: latest usable result }` over its terminal nodes and `finish` sources,
-   *  judged by `deliverable`. */
+   *  judged by `deliverable`. A stored route check (`checkRef: 'route'`) may also name a
+   *  non-terminal node: its condition reads that node's latest delivered output, while the output
+   *  stays terminal-only. */
   readonly entry?: ReadonlyArray<{
     readonly node: NodeId;
     readonly task: unknown;
@@ -19643,4 +19645,4 @@ interface KnowledgeReadinessDecision {
   nonBlockingGapIds: string[];
 }
 export { NoWinnerError as $, NativeContextContinuationInput as $S, WaterfallCollector as $_, filterAuthoredAsserts as $a, NodeExecutionIdentity as $b, defaultAnalystInstruction as $c, SeatSelectionInput as $d, SupervisorProfile as $f, verdictFromJudgeScore as $g, DelegationRunContext as $h, SpawnJournal as $i, LeaderboardFlagSpec as $l, BridgeHarnessStore as $m, validateStoredGraph as $n, profileChatClient as $o, SpawnResourceBytes as $p, InteractiveWorkerOptions as $r, inlineSandboxClient as $s, createVerifierEnvironment as $t, observerRecordDigest as $u, QuestionEscalationRecord as $v, resolveHarnessTranscriptCapture as $x, AnalystKind as $y, TraceRootArtifact as A, LoopTeardownFailedPayload as AS, GroupOf as A_, ProfileRichnessThresholds as Aa, InMemorySpawnJournal as Ab, AuthoredStrategy as Ac, RUN_FORK_CORRELATION_KEYS as Ad, ReservationStage as Af, ResearchOutput as Ag, FeedbackStore as Ah, lookupGraph as Ai, Widen as Al, InboxMessage as Am, settledWorkerOut as An, openSandboxRun as Ao, serveCoordinationMcp as Ap, RemoteSupervisorCancelResult as Ar, createMcpEnvironment as As, AgentEnvironmentStatus as At, SuperviseGraphPursuitOptions as Au, WorktreeProfileMaterializationReceipt as Av, readWorkerProgress as Ax, PeerMailbox as Ay, Handle as B, SelectionReceipt as BS, pairwiseSignificance as B_, CheckSource as Ba, ValidationError as Bb, sampleThenRefine as Bc, createWorkerSlots as Bd, CoordinationVerbs as Bf, DelegationPersistenceError as Bg, FleetHandle as Bh, RollingDispatchOptions as Bi, PersonaContext as Bl, ROUTER_CLIENT_HEADER as Bm, WorkspaceRun as Bn, PrivateCasNamespaceObject as Bo, ContinuationPanel as Bp, ProvisionedSupervisor as Br, runBenchmark as Bs, CreateAgentEnvironmentInput$1 as Bt, PursuitNodePlatform as Bu, DecideGate as Bv, HarnessTranscriptEvidence as Bx, McpToolDescriptor as By, RuntimeFailureCause as C, StartRetainedRunOptions as CC, LoopIterationStartedPayload as CS, CodeModeToolContext as C_, ChatTransportTool as Ca, SpawnForestNode as Cb, SurfaceScore as Cc, dumbContinuationFailPrompt as Cd, BudgetPoolRestore as Cf, UiAuditorDelegationOutput as Cg, ToolLoopCallContext as Ch, graphCorpusSummary as Ci, ScopeWidenGate as Cl, SandboxSteeringOptions as Cm, readWorkerInteractiveBinding as Cn, Deliverable as Co, bestDelivered as Cp, readWorkerSteerRequests as Cr, assertTraceDerivedFindings as Cs, SuperviseProfileEntry as Ct, PursuitVersionChain as Cu, createRuntimeEventCollector as Cv, ActivityNote as Cx, PeerMailEnvelope as Cy, RetainedPendingCause as D, LoopResult as DS, createCodeModeTools as D_, createChatSessionStore as Da, replaySpawnTree as Db, runAgentic as Dc, naiveContinuationPrompt as Dd, ReservationHolder as Df, UiLens as Dg, ToolLoopMessageRecord as Dh, graphRunsFor as Di, TrajectoryReportOptions as Dl, AuthorityInboxMessage as Dm, WorkerEvidenceInput as Dn, SandboxRun as Do, CoordinationPublicAddress as Dp, workerInboxFileFromEventDir as Dr, observationFromRegistry as Ds, AgentEnvironmentEvent$1 as Dt, VersionJudge as Du, WorktreeCheckRunner as Dv, TeamProgress as Dx, PeerMailReadout as Dy, EvidencePendingEvent as E, LoopPlanPayload as ES, RunCodeModeOptions as E_, chatWorkerSeam as Ea, FileResultBlobStore as Eb, refine as Ec, kernelPromptRegistry as Ed, ReservationFloor as Ef, UiFindingSeverity as Eg, ToolLoopCompactionOptions as Eh, graphRegistry as Ei, TrajectoryReport as El, createSteerableSandboxSession as Em, VERIFY_TAIL_CHARS as En, OpenSandboxRunPromptOptions as Eo, CoordinationMcpHandle as Ep, supervisorRunsRoot as Er, registryScopeAnalyst as Es, AgentEnvironmentCapabilities$1 as Et, SettledPursuitVersion as Eu, InPlaceHarnessResult as Ev, ScopeProgressInput as Ex, PeerMailOutcome as Ey, ResourceLimit as F, MountManifestEntry as FS, PairwiseOptions as F_, supervisorInstructions as Fa, AgentEvalErrorCode as Fb, StrategyResult as Fc, AuthorizedSpawn as Fd, readRootStream as Ff, TraceContext as Fg, DetachedSessionDelegateOptions as Fh, taskShapeDigest as Fi, DefinePersona as Fl, SharedBoxPlacement as Fm, withUntrackedArtifacts as Fn, acquireSandbox as Fo, FileCoordinationLog as Fp, RemoteWorkerEvents as Fr, BenchmarkReport as Fs, AgentSessionStatus$1 as Ft, supervisePursuit as Fu, LeadMessage as Fv, RetainedInteractiveRunHandle as Fx, peerMailTools as Fy, Settled as G, RuntimeRunHandle as GS, AnytimeReport as G_, StructuralRolloutPolicy as Ga, SpawnModelSubstitution as Gb, HarvestFailure as Gc, isPreSpawnExecutorFailure as Gd, ResolveSupervisorTools as Gf, CoderTask as Gg, DetachedTurn as Gh, DesignerToolsEnv as Gi, ShapeContext as Gl, createAgentEnvironmentProviderRegistry as Gm, TrajectoryAnalysis as Gn, startRetainedRunInEnvironment as Go, PanelFinding as Gp, bestProfileFor as Gr, SuperviseOptionsForDispatch as Gs, PlacementInfo as Gt, PursuitRunProjection as Gu, RouteGate as Gv, captureHarnessTranscript as Gx, EventBus as Gy, NodeSnapshot as H, Validator as HS, renderLeaderboardMarkdown as H_, RepairStop as Ha, ExecutorContext as Hb, strategyAuthorSystemPrompt as Hc, WorkerSpawnRetryAttempt as Hd, DriveHarnessOwnerContext as Hf, FileDelegationStore as Hg, SiblingSandboxExecutorOptions as Hh, queueOf as Hi, RunPersonified as Hl, sharedWorkerClientName as Hm, jjWorkspace as Hn, reconnectRetainedRun as Ho, ContinuationPanelResult as Hp, provisionSupervisor as Hr, LoopDispatchOptions as Hs, ExecRequest as Ht, PursuitNodeTiming as Hu, GateRequest as Hv, HarnessTranscriptUnavailable as Hx, BusEvent as Hy, ResourceSpend as I, MountRecorder as IS, PairwiseVerdict as I_, CheckExecChannel as Ia, BackendTransportError as Ib, adaptiveRefine as Ic, AuthorizedSpawnContext as Id, readRootStreamReceipt as If, createPropagatingTraceEmitter as Ig, DetachedWinnerSelection as Ih, GraphTriggerBinding as Ii, DefinePersonaInput as Il, SharedBoxPlacementOptions as Im, GitWorkspaceOptions as In, S3PrivateCasStore as Io, PriorCoordination as Ip, connectRemoteSupervisor as Ir, BenchmarkStrategySummary as Is, AgentTurnResult$2 as It, RunReopen as Iu, ManagerReentryState as Iv, RetainedInteractiveStartMaterial as Ix, peerMailVerbNames as Iy, SpawnRejection as J, RuntimeRunRow as JS, anytimeReport as J_, canDisplace as Ja, ExecutorExecutionBinding as Jb, Observation as Jc, withWorkerSpawnRetry as Jd, SupervisorNodeContext as Jf, CompletionCheckContext as Jg, DelegationArgs as Jh, DelegateOptions as Ji, providerAsSandboxClient as Jl, ProviderLeafOut as Jm, parseWorkerToolTraceArtifact as Jn, reconnectRetainedInteractiveRun as Jo, DriverContractState as Jp, profileRegistry as Jr, superviseDispatch as Js, SandboxInstance$1 as Jt, projectPursuit as Ju, ChildQuestionInbox as Jv, HarnessTranscriptMetadata as Jx, WatchTraceOptions as Jy, SpawnOpts as K, RuntimeRunOptions as KS, AnytimeStrategySummary as K_, StructuralRolloutResult as Ka, AgentExecutionRef as Kb, HarvestReport as Kc, resolveWorkerSpawnRetry as Kd, SupervisorAgentDeps as Kf, CheckUnavailableError as Kg, RunDetachedTurnOptions as Kh, GraphDesignerExtraTools as Ki, ShapeRegistry as Kl, resolveAgentEnvironmentProvider as Km, analyzeTrace as Kn, ClaimRetainedInteractiveControlOptions as Ko, VerdictSummary as Kp, loadProfile as Kr, loopCampaignDispatch as Ks, ResourceRequest as Kt, PursuitRunTotals as Ku, RouteMatch as Kv, harnessTranscriptArtifact as Kx, PublishOptions as Ky, Spend as L, OutputAdapter as LS, ProfileKeyOf as L_, CheckOutcome as La, ConfigError as Lb, assertStrategyContract as Lc, SuperviseOptions as Ld, supervisorAgent as Lf, readTraceContextFromEnv as Lg, UiAuditorDelegate as Lh, DispatchReport as Li, LoopShape as Ll, SharedBoxStats as Lm, Shell as Ln, S3PrivateCasStoreOptions as Lo, CheckRead as Lp, connectRemoteSupervisorControl as Lr, BenchmarkTaskRow as Ls, AnalystFinding$1 as Lt, PursuitObserverDelivery as Lu, ManagerWake as Lv, StartRetainedInteractiveRunOptions as Lx, JsonRpcMessage as Ly, Budget as M, LoopTraceEmitter as MS, Leaderboard as M_, assessAuthoredProfile as Ma, Redactor as Mb, Strategy as Mc, superviseFleetCapabilities as Md, ReserveOptions as Mf, ResearchTask as Mg, CoderReview as Mh, recordGraphRun as Mi, WidenLineage as Ml, DEFAULT_SHARED_BOX_RESOURCES as Mm, CopyOptions as Mn, SandboxLineageHandle as Mo, CoordinationRejectReason as Mp, RemoteSupervisorReader as Mr, BenchmarkCell as Ms, AgentProfile$2 as Mt, SupervisePursuitOptions as Mu, AwaitWakeInput as Mv, RecoverRetainedInteractiveRunOptions as Mx, claimsAuthority as My, BudgetOverspend as N, LoopTraceEvent as NS, LeaderboardOptions as N_, defaultProfileRichnessThresholds as Na, defaultRedactor as Nb, StrategyArtifacts as Nc, superviseWithTestBrain as Nd, createBudgetPool as Nf, ResearcherProfileOptions as Ng, CoderReviewer as Nh, recordStoredGraphRun as Ni, WidenSpec as Nl, DEFAULT_SHARED_BOX_WORKERS as Nm, UntrackedCopyStats as Nn, createSandboxLineage as No, CoordinationDeliveryEvidence as Np, RemoteSupervisorSteerResult as Nr, BenchmarkConfig as Ns, AgentSession as Nt, SupervisedPursuitResult as Nu, CoordinationEvent as Nv, RetainedInteractiveAdmissionHook as Nx, createPeerMailbox as Ny, TRACE_ROOT_SCHEMA as O, LoopSandboxPlacement as OS, runCodeMode as O_, AuthoredProfile as Oa, FileSpawnJournal as Ob, sample as Oc, promptHandle as Od, ReservationRejection as Of, KnowledgeItem as Og, ToolLoopToolCall as Oh, listGraphRuns as Oi, Verify as Ol, Inbox as Om, closingWorkerNote as On, SandboxRunAbortError as Oo, CoordinationReadAccess as Op, writeWorkerSteer as Or, McpEndpoint as Os, AgentEnvironmentProvider$1 as Ot, VersionVerdict as Ou, WorktreeCommandResult as Ov, WorkerProgress as Ox, PeerMailRefusal as Oy, BudgetViolation as P, LoopWinner as PS, LeaderboardRow as P_, profileRichnessFinding as Pa, AgentEvalError$1 as Pb, StrategyCtx as Pc, workerFromBackend as Pd, RootStreamRecord as Pf, researcherProfile as Pg, DelegateRunCtx as Ph, storedGraphDigests as Pi, WinnerStrategy as Pl, SharedBoxCloseReceipt as Pm, copyUntrackedIntoClone as Pn, AcquireOptions as Po, CoordinationLog as Pp, RemoteSupervisorTree as Pr, BenchmarkLift as Ps, AgentSessionRef as Pt, superviseGraphPursuit as Pu, EventAcknowledgement as Pv, RetainedInteractiveEnvironmentInput as Px, isPeerMailEnvelope as Py, FleetYield as Q, NativeContextContinuationHandle as QS, renderAnytimeTable as Q_, defaultStructuralRolloutPolicy as Qa, MaterializedModelIdentity as Qb, ObserveOptions as Qc, SeatSelection as Qd, ManagerWakePolicy as Qf, mapExecutorResult as Qg, DelegationResumeTick as Qh, SpawnEvent as Qi, LeaderboardBenchmarkAdapter as Ql, ProviderPlacement as Qm, ValidateStoredGraphOptions as Qn, resolveSandboxClient as Qo, ResolvedSpawnResourcePath as Qp, InteractiveWorkerKeyInput as Qr, defaultSelectWinner as Qs, VerifierEnvironmentOptions as Qt, ObserverRecordKind as Qu, QuestionEscalationOutcome as Qv, RetainedHarnessTranscriptDescriptor as Qx, AnalystFindingEvent as Qy, SpendChannel as R, RunProvenance as RS, ScoreOf as R_, CheckRunContext as Ra, JudgeError as Rb, authorStrategy as Rc, SuperviseTestOptions as Rd, supervisorAgentWithTestBrain as Rf, DelegationTraceSpan as Rg, detachedSessionDelegate as Rh, DispatchStopReason as Ri, Outcome as Rl, SharedWorkerIdentity as Rm, Workspace as Rn, createS3PrivateCasStore as Ro, ContinuationAppend as Rp, ProvisionSupervisorConnection as Rr, Environment as Rs, CheckpointRef as Rt, PursuitCostProvenance as Ru, ToolOutcomeEvent as Rv, HarnessTranscriptArtifact as Rx, JsonRpcResponse as Ry, RuntimeStreamEvent as S, StartRetainedRunInEnvironmentOptions as SC, LoopIterationEndedPayload as SS, CodeModeTool as S_, ChatTransportExecutorOptions as Sa, SpawnForestMissingTree as Sb, StrategyShotResult as Sc, delegatesWorkerBriefPrompt as Sd, BudgetPool as Sf, UiAuditLensFilter as Sg, ToolSpec as Sh, digestOfGraph as Si, ScopeAnalyzeInput as Sl, DEFAULT_SANDBOX_STEERING_MAX_TURNS as Sm, attachWorker as Sn, strategyTournament as So, SupervisorFinalizer as Sp, readWorkerSteerAcknowledgement as Sr, RegistryAnalyzeProjection as Ss, SpawnRefusalCause as St, NextPursuitVersionInput as Su, SanitizedKnowledgeRequirement as Sv, ActivityLog as Sx, PEER_MAIL_WIRE_KEY as Sy, RuntimeFailureOwner as T, LoopPlanDescription as TS, CodeModeToolset as T_, chatTransportExecutor as Ta, loadSpawnForest as Tb, depthStrategy as Tc, formatPromptHandle as Td, LeakedReservation as Tf, UiFindingScreenshot as Tg, ToolLoopCompaction as Th, graphFromStored as Ti, TrajectoryNode as Tl, SteerableSandboxSession as Tm, NOTE_MAX_CHARS as Tn, OpenSandboxRunOptions as To, CoordinationControlAccess as Tp, supervisorRunDir as Tr, createScopeAnalyst as Ts, AgentEnvironment$1 as Tt, PursuitVersions as Tu, sanitizeKnowledgeReadinessReport as Tv, ExecutorProgress as Tx, PeerMailLimits as Ty, NodeStatus as U, RuntimeRunCompleteInput as US, renderLeaderboardSvg as U_, StructuralRolloutConfig as Ua, ExecutorFactory as Ub, HarvestCorpusOptions as Uc, WorkerSpawnRetryHooks as Ud, ObserveSupervisorNodeEvent as Uf, FileDelegationStoreOptions as Ug, createFleetWorkspaceExecutor as Uh, rollingDispatch as Ui, RunPersonifiedOptions as Ul, AgentEnvironmentProviderRef as Um, localShell as Un, recoverRetainedRun as Uo, ContinuationPolicy as Up, ProfileRegistryDir as Ur, LoopOptionsForDispatch as Us, ExecResult as Ut, PursuitNodeUsage as Uu, JsonScalar as Uv, HarnessTranscriptUnavailableReason as Ux, BusRecord as Uy, NodeId as V, ValidationCtx as VS, renderLeaderboardHtml as V_, CheckSourceCtx as Va, AgentSpec as Vb, strategyAuthorContract as Vc, ResolvedWorkerSpawnRetry as Vd, DriveHarness as Vf, DelegationStore as Vg, FleetWorkspaceExecutorOptions as Vh, freeSlots as Vi, PersonaExecutors as Vl, sharedBoxRefusal as Vm, gitWorkspace as Vn, PrivateCasNamespaceRetirement as Vo, ContinuationPanelInput as Vp, SupervisorCleanupReceipt as Vr, LoopCampaignDispatchOptions as Vs, CreateSandboxOptions$1 as Vt, PursuitNodeProjection as Vu, GateDecision as Vv, HarnessTranscriptFile as Vx, McpTransport as Vy, RetainedExecutionState as W, RuntimeRunCost as WS, renderPairwiseMarkdown as W_, StructuralRolloutMessage as Wa, ExecutorRegistry as Wb, HarvestError as Wc, WorkerSpawnRetryPolicy as Wd, ResolveDriveHarness as Wf, CoderOutput as Wg, createSiblingSandboxExecutor as Wh, DesignerRunGraphEnv as Wi, ShapeBudget as Wl, AgentEnvironmentProviderRegistry as Wm, runInWorkspace as Wn, startRetainedRun as Wo, ContinuationProfile as Wp, ProfileRunRecord as Wr, SuperviseDispatchOptions as Ws, ForkRequest as Wt, PursuitProjection as Wu, RouteFlow as Wv, ReadableEnvironment as Wx, BusStats as Wy, SubtreeSummary as X, startRuntimeRun as XS, bestSoFar as X_, composeCheckSources as Xa, ExecutorNodeContext as Xb, ObservationError as Xc, SuperviseRegistryTable as Xd, SupervisorToolDescriptor as Xf, ExecutorResultMapping as Xg, DelegationResumeContext as Xh, delegate as Xi, LeaderboardBenchScore as Xl, providerAsExecutor as Xm, createSupervisor as Xn, startRetainedInteractiveRun as Xo, DriverRetryPolicy as Xp, recordProfileRun as Xr, TERMINAL_DECISIONS as Xs, computeFindingId$1 as Xt, ObserverJournal as Xu, Question as Xv, HarnessTranscriptReadOptions as Xx, watchTrace as Xy, SubtreeResult as Y, RuntimeRunStatus as YS, areaUnderCurve as Y_, compareCheckOutcomes as Ya, ExecutorMaterialization as Yb, ObservationAnalysis as Yc, SuperviseRegistry as Yd, SupervisorNodeContextSeed as Yf, DeliverableSpec as Yg, DelegationRecord as Yh, defaultDelegateBudget as Yi, DefinedLeaderboard as Yl, ProviderPromptOptions as Ym, DEFAULT_MAX_DEPTH as Yn, recoverRetainedInteractiveRun as Yo, DriverReentry as Yp, profileRunsForName as Yr, LocalSandboxClientOptions as Ys, WorkspaceRequest as Yt, FileObserverJournal as Yu, EscalateQuestion as Yv, HarnessTranscriptReadLimits as Yx, defaultToolDetectors as Yy, TreeView as Z, NativeContextContinuationExecution as ZS, plateauLength as Z_, defaultExtractCandidate as Za, MaterializedExecutionIdentity as Zb, ObserveInput as Zc, SeatSegment as Zd, SupervisorToolInvocationContext as Zf, gateOnDeliverable as Zg, DelegationResumeDriver as Zh, ResultBlobStore as Zi, LeaderboardBenchTask as Zl, UnavailablePausePolicy as Zm, createRootHandle as Zn, ResolveSandboxClientOptions as Zo, ResolveSpawnResourcePathsResult as Zp, InteractiveWorkerEnvironment as Zr, TerminalDecision as Zs, makeFinding$1 as Zt, ObserverRecord as Zu, QuestionDecision as Zv, RetainedHarnessTranscriptCapture as Zx, AnalystAssignmentRecord as Zy, RunAgentTaskOptions as _, RetainedRunIntentAdmission as _C, ExecCtx as _S, harnessUsageIsEmpty as __, WorkerEventCursor as _a, SqlAdapter as _b, AgenticTool as _c, PromptHandle as _d, ParkedRun as _f, DelegationStatus as _g, extractLlmCallEvent as _h, GraphRunQuery as _i, PanelSpec as _l, CliWorktreeSeam as _m, WorktreePatchArtifact as _n, StrategyEvolutionConfig as _o, UNPROVEN_CONTINUITY as _p, WorkerSteerRequest as _r, pipeline as _s, PeerAuditAccess as _t, IsolatedCheckOptions as _u, RuntimeStreamEventCollector as _v, WorkerTraceUnavailableReason as _x, MapOnSettleRoute as _y, AgentKnowledgeProvider as a, RetainedInteractiveEnvironmentAdmission as aC, ProviderWorkspaceCaptureReceipt as aS, deterministicCompletion as a_, RootSegmentEntry as aa, AuthoredAnalystLimits as ab, LocalMcpMaterialization as ac, GraphNode as ad, RunContext as af, DelegateCodeConfig as ag, mcpSecretEnvMetadataKey as ah, ObservedSessionFacts as ai, CorpusFilter as al, McpServerOptions as am, SurfaceReader as an, structuralRollout as ao, StopRule as ap, SearchSpec as ar, createPrivateCasArtifactPort as as, DriverAttemptRecord as at, defineLeaderboard as au, SandboxEvidenceContext as av, ExecutorAccounting as ax, QuestionUrgency as ay, RuntimeSession as b, RetainedRunStartMaterial as bC, LoopEndedPayload as bS, decodeHarnessUsage as b_, ChatCompletionsTransport as ba, SpawnForestEvent as bb, RunAgenticOptions as bc, analyzesFindingsReportPrompt as bd, RunParkingRecord as bf, FeedbackRefersTo as bg, RouterTransportConfig as bh, StoredGraph as bi, RenderCorpusToInstructionsOptions as bl, RouterToolsSeam as bm, WorkerInteractiveBinding as bn, TournamentRow as bo, FinalizeContext as bp, legacySupervisorRunDir as br, widen as bs, SpawnPreflightContext as bt, JudgedPursuitVersion as bu, RuntimeTelemetryOptions as bv, TraceSource as bx, AUTHORITY_MARKERS as by, AgentTaskContext as c, RetainedRunAdmission as cC, ProviderWorkspaceRetentionContext as cS, CodexForkBoundary as c_, Supervisor as ca, LocalHarnessResult as cb, McpSpawnFault as cc, RunGraphOptions as cd, createInMemoryRunContext as cf, DelegateUiAuditArgs as cg, secretEnvOfMcpServer as ch, graphRouteWhenSchema as ci, EqualKOnCostOptions as cl, DelegateHandlerOptions as cm, fsSurfaceReader as cn, AgentTurnInput$1 as co, noProgressFor as cp, assertSearchSpec as cr, definePersona as cs, DriverFailureClass as ct, DeclaredCheckStateCapture as cu, OtelAttribute as cv, ExecutorResult as cx, AuthorizedDownMessage as cy, AgentTaskStatus as d, RetainedRunCancellation as dC, ExecutorToolCall as dS, CodexRolloutStoreReader as d_, ReenteredWorkers as da, LOCAL_HARNESSES as db, connectStdioMcp as dc, runGraph as dd, SupervisorSpanOptions as df, DelegationError as dg, SandboxToolPartState as dh, LoadGraphFileOptions as di, FanoutSynthesis as dl, createExecutorRegistry as dm, analystsFromRegistry as dn, StreamAgentTurnOptions as do, RunCancellation as dp, searchSpecDigest as dr, InMemoryCorpus as ds, CoordinationStats as dt, declaredCheckDeliverable as du, OtelExporter as dv, HeldForContinuation as dx, DownMessageAuthorizationInput as dy, ReconnectRetainedRunOptions as eC, retainHarnessTranscript as eS, CompletionAnalyst as e_, TraceRootReceipt as ea, AnalystLensOutput as eb, InProcessOnPrompt as ec, AgentGraph as ed, SeatStage as ef, DelegationTaskQueue as eg, BridgeModelCredential as eh, InteractiveWorkerResult as ei, observe as el, SpawnResourceRead as em, BoxSurfaceReaderOptions as en, modelAuthoredChecks as eo, AllWorkersStalledOptions as ep, FencedSqlRunContext as er, profileOptimizerModelCall as es, ProviderModelAttemptEvidence as et, LeaderboardIterationInfo as eu, WaterfallReport as ev, ProfileMaterializationReceipt as ex, QuestionEscalationTarget as ey, BackendErrorDetail as f, RetainedRunDispatchedAdmission as fC, TokenUsageProvenance as fS, CodexRolloutStoreRef as f_, ResumedKeyState as fa, LocalHarness as fb, materializeLocalMcp as fc, runGraphWithTestBrain as fd, SupervisorSpanOutcome as ff, DelegationFeedbackSnapshot as fg, createSandboxToolPartState as fh, LoadedGraphFile as fi, FanoutWinnerSelector as fl, ExecutorConfig as fm, failuresAnalyst as fn, collectAgentTurn as fo, cancelRun as fp, settledToIteration as fr, renderCorpusToInstructions as fs, CoordinationTools as ft, declaredCheckDigest as fu, OtelSpan as fv, HeldRelease as fx, DownMessageDeliveryAttempt as fy, OpenAIChatToolChoice as g, RetainedRunHandle as gC, Driver as gS, createCodexRolloutStoreReader as g_, WidenGate as ga, openSqlRunStore as gb, AgenticTask as gc, GraphRouteError as gd, DeadlineCheckIn as gf, DelegationResultPayload as gg, SandboxUsageLedger as gh, GraphRegistryDir as gi, PanelJudge as gl, CliWorktreeBridgeSeam as gm, WorktreeCliExecutorOptions as gn, EvolutionStrategy as go, ReentryTaskInput as gp, WorkerSteerAcknowledgement as gr, panel as gs, MakeWorkerAgent as gt, IsolatedCheckBoxEvidence as gu, RuntimeEventCollector as gv, WorkerTraceEvidence as gx, MapItemFailurePolicy as gy, OpenAIChatTool as h, RetainedRunEventOptions as hC, DefaultVerdict$2 as hS, addHarnessUsage as h_, UnconfirmedTeardown as ha, SqlRunOwnershipError as hb, AgenticSurface as hc, defaultEdgeTraversalCap as hd, WorkerTraceResolver as hf, DelegationProgress as hg, SandboxServedBackend as hh, GraphCorpusSummary as hi, Panel as hl, CliSeam as hm, worktreeFanout as hn, EvolutionReport as ho, ReentryContinuity as hp, WorkerCancellation as hr, loopUntil as hs, GraphSubtasks as ht, IsolatedCheckBox as hu, loopEventToOtelSpan as hv, WorkerInteractiveUnavailableReason as hx, WorkerResumeContext as hy, AgentExecutionBackend as i, RetainedInteractiveAdmission as iC, ProviderWorkspaceCaptureProvenance as iS, completionAuthorizes as i_, RootSegment as ia, AuthoredAnalystDefinition as ib, HttpMcpServerSpec as ic, GraphEdgeCapError as id, InMemoryRunContextOptions as if, DelegateCodeArgs as ig, envKeyProvider as ih, GraphSessionObservationOptions as ii, Corpus as il, McpServer as im, SurfaceReadOutcome as in, selectBestIndex as io, StopDecision as ip, SEARCH_SPEC_CORRELATION_KEY as ir, PrivateCasOptions as is, SupervisedResult as it, LeaderboardSpec as iu, runAgentRounds as iv, Executor as ix, QuestionRecord as iy, TraceSummary as j, LoopTokenUsage as jS, Interval as j_, asAuthoredProfile as ja, contentAddress as jb, ShotSpec as jc, supervise as jd, ReservationTicket as jf, ResearchSource as jg, CoderDelegate as jh, pickBestGraph as ji, WidenDecision as jl, PeerInboxMessage as jm, spendFromUsageEvents as jn, SandboxLineage as jo, CoordinationHttpAudit as jp, RemoteSupervisorControl as jr, sanitizeMcpToolSchema as js, AgentEnvironmentSummary as jt, SupervisePursuitError as ju, GitRunner as jv, ReconnectRetainedInteractiveRunOptions as jx, PeerMailboxOptions as jy, TRACE_SUMMARY_SCHEMA as k, LoopStartedPayload as kS, AxisScoresOf as k_, ProfileRichness as ka, InMemoryResultBlobStore as kb, AuthorStrategyOptions as kc, PursuitFork as kd, ReservationShortfall as kf, KnowledgeUpdate as kg, FeedbackEvent as kh, loadGraph as ki, VerifySpec as kl, InboxLease as km, composeWorkerEvidence as kn, TurnResult as ko, CoordinationTransportOptions as kp, RemoteSupervisorAgent as kr, McpEnvironmentOptions as ks, AgentEnvironmentQuery as kt, assertPursuitVersions as ku, WorktreeHarnessResult as kv, createActivityLog as kx, PeerMailSendInput as ky, AgentTaskRunResult as l, RetainedRunAdmissionHook as lC, ProviderWorkspaceRetentionPort as lS, CodexRolloutIdentity as l_, SupervisorOpts as la, RunLocalHarnessOptions as lb, StdioMcpConnection as lc, RunGraphTestOptions as ld, withRunContext as lf, DelegateUiAuditConfig as lg, SandboxLeafOut as lh, GraphFileResolutionError as li, EqualKVerdict as ll, DelegateResult as lm, harvestSurfaceDiffs as ln, AgentTurnUsage as lo, plateau as lp, compileSearchSpec as lr, runPersonified as ls, DriverRepromptRefusal as lt, assertDeclaredCheck as lu, OtelExportConfig as lv, ExecutorTeardownWarning as lx, ContinuationInstruction as ly, OpenAIChatResponseFormat as m, RetainedRunEnvironmentAdmission as mC, AgentRunSpec as mS, CodexStoreDelta as m_, Scope as ma, CodexExecutionPolicy as mb, AgenticRunResult as mc, GraphFromStoredOptions as md, createSupervisorSpanRecorder as mf, DelegationHistoryEntry as mg, mapSandboxToolEvent as mh, GraphCorpusGroup as mi, LoopUntilState as ml, CliInPlaceSeam as mm, WorktreeFanoutOptions as mn, EvolutionAuthor as mo, readRunCancellation as mp, ScopeArgs as mr, flatWidenGate as ms, GraphSubtaskPreparation as mt, readDeclaredCheck as mu, createOtelExporter as mv, WorkerInteractiveSession as mx, DownMessageEvent as my, AgentBackendContext as n, RecoverRetainedRunOptions as nC, ProviderNativeCapturePhase as nS, CompletionPolicy as n_, RecursiveReservationPolicy as na, AnalystRunContext as nb, InProcessSandboxClientOptions as nc, EdgeTraversal as nd, subscriptionUsageLimitSignal as nf, SubmitInput as ng, KeyProvider as nh, InPlaceCliExecutorOptions as ni, AssertTraceDerivedFindings as nl, environmentReader as nm, SurfaceDiff as nn, resolveEntrySymbol as no, PlateauOptions as np, createFencedSqlRunContext as nr, PrivateCasDurableStore as ns, RootProviderModelEvidence as nt, LeaderboardScenario as nu, createWaterfallCollector as nv, UnknownMaterializationReason as nx, QuestionOption as ny, AgentRuntimeEvent as o, RetainedInteractiveIntentAdmission as oC, ProviderWorkspaceCaptureResult as oS, sentinelCompletion as o_, RootSignal as oa, DefinedAnalystRecord as ob, MaterializeLocalMcpOptions as oc, GraphResult as od, RunContextLease as of, DelegateResearchArgs as og, resolveMcpServerLaunch as oh, graphFromSessionFacts as oi, CorpusRecord as ol, createMcpServer as om, WatchedSurface as on, visibleCheckScore as oo, allWorkersStalled as op, SearchSpecInputs as or, equalKOnCost as os, DriverAttemptStop as ot, DeclaredCheck as ou, SandboxEvidenceReceipt as ov, ExecutorCancellation as ox, questionEscalationTargets as oy, KnowledgeReadinessDecision as p, RetainedRunEffect as pC, UsageEvent as pS, CodexRolloutTurn as p_, ResumedWork as pa, CodexTokenUsage as pb, AgenticOptions as pc, GraphCommandCheck as pd, SupervisorSpanRecorder as pf, DelegationHistoryArgs as pg, mapSandboxEvent as ph, loadGraphFile as pi, LoopUntilSpec as pl, createExecutor as pm, AuthoredHarness as pn, streamAgentTurn as po, readRunCancelRequest as pp, createScope as pr, fanout as ps, CoordinationToolsOptions as pt, declaredCheckJudge as pu, buildLoopOtelSpans as pv, Runtime as px, DownMessageDeliveryOutcome as py, SpawnPrior as q, RuntimeRunPersistenceAdapter as qS, AnytimeTaskCurve as q_, VisibleCheck as qa, ExecutionBindingReceipt as qb, harvestCorpus as qc, retryPreSpawnRefusals as qd, SupervisorAgentTestDeps as qf, CheckVerdict as qg, runDetachedTurn as qh, graphDesignerExtraTools as qi, ProviderAsSandboxClientOptions as ql, ProviderExecutorOptions as qm, WorkerToolTraceArtifact as qn, claimRetainedInteractiveControl as qo, admitContinuationPolicy as qp, pickBestProfile as qr, loopDispatch as qs, SandboxEvent$1 as qt, PursuitStatus as qu, RouteWhen as qv, persistHarnessTranscript as qx, createEventBus as qy, AgentBackendInput as r, RecoverRetainedRunResult as rC, ProviderWorkspaceAttemptProvenance as rS, CompletionVerdict as r_, RootHandle as ra, AnalyzeOnSettleRoute as rb, inProcessSandboxClient as rc, GraphEdge as rd, InMemoryRunContext as rf, SubmitOutput as rg, ResolvedMcpServerLaunch as rh, createInPlaceCliExecutor as ri, CombinatorShape as rl, resolveSpawnResourcePaths as rm, SurfaceReadBox as rn, sandboxCheckRunner as ro, ProgressView as rp, CompiledSearchSpec as rr, PrivateCasOffloadReport as rs, RootStreamReceipt as rt, LeaderboardScore as ru, RunAgentRoundsOptions as rv, EnvironmentTeardownReceipt as rx, QuestionPolicy as ry, AgentRuntimeEventSink as s, RetainedInteractiveStartedAdmission as sC, ProviderWorkspaceEntryMetadata as sS, stopSentinel as s_, SteerableRootHandle as sa, CodexExecutionEvidence as sb, McpListedTool as sc, GraphTopology as sd, createFileRunContext as sf, DelegateResearchConfig as sg, resolveSecretEnv as sh, graphFileSchema as si, EqualKArm as sl, DelegateError as sm, boxSurfaceReader as sn, AgentTurnBackend as so, anyOf as sp, SearchSpecOwnedOption as sr, trajectoryReport as ss, DriverContinuationRecord as st, DeclaredCheckPlacement as su, SandboxEvidenceRetentionPort as sv, ExecutorCancellationRequest as sx, AuthorizeDownMessage as sy, AgentAdapter as t, RecoverRetainedRunIntentOptions as tC, ProviderCheckpointCaptureContext as tS, CompletionEvidence as t_, WorkspaceCheckpointMarker as ta, AnalystRegistry$1 as tb, InProcessPromptCtx as tc, EdgeDeliveryOutcome as td, SelectSeat as tf, DelegationTaskQueueOptions as tg, BridgeSeam as th, workerFromInteractiveProvider as ti, renderReport as tl, SpawnResourceReader as tm, HarvestSurfaceDiffsOptions as tn, officialChecksFromMeta as to, NoProgressForOptions as tp, SqlRunContextOptions as tr, PrivateCasArtifactPort as ts, ProviderModelExecutionEvidence as tt, LeaderboardRunContext as tu, WaterfallSpan as tv, RootMaterialization as tx, QuestionLevel as ty, AgentTaskSpec as u, RetainedRunCancelOptions as uC, ExecutorProgressEvent as uS, CodexRolloutSession as u_, Agent as ua, runLocalHarness as ub, StdioMcpServerSpec as uc, TraversalContinuity as ud, SupervisorSpanAttributes as uf, DelegateUiAuditRoute as ug, SandboxOutputMarker as uh, GraphFileSeat as ui, FanoutOptions as ul, createDelegateHandler as um, AnalystAuthoring as un, CollectedAgentTurn as uo, RunCancelRequest as up, searchPresets as ur, FileCorpus as us, BlockedToolReport as ut, checkProgramDigest as uu, OtelExportStats as uv, HeldEnvironment as ux, ContinuityMode as uy, RunAgentTaskStreamOptions as v, RetainedRunReplayPoint as vC, Iteration as vS, readCodexRolloutSession as v_, WorkerEventEntry as va, materializeTreeView as vb, ArtifactHandle as vc, PromptRegistry as vd, RunParkedError as vf, DelegationStatusResult as vg, sumSandboxUsage as vh, GraphRunRecord as vi, PanelVerdict as vl, ProviderSeam as vm, createWorktreeCliExecutor as vn, StrategyTournament as vo, composeReentryTask as vp, WriteWorkerSteerOptions as vr, selectValidWinner as vs, SettledWorker as vt, IsolatedCheckResult as vu, RuntimeStreamEventSink as vv, SessionMessageLike as vx, MapSpawnMarker as vy, RuntimeFailureCode as w, LoopLineageOptions as wS, CodeModeToolsOptions as w_, ChatWorkerSeamOptions as wa, SpawnForestTree as wb, breadthStrategy as wc, dumbContinuationPassPrompt as wd, BudgetReadout as wf, UiFinding as wg, ToolLoopChat as wh, graphDigest as wi, SteerContext as wl, SteerableSandboxArgs as wm, EVIDENCE_MAX_CHARS as wn, OpenSandboxRunBeforeStartContext as wo, CoordinationAuthentication as wp, safeWorkerFile as wr, buildSteerContext as ws, WorkerSpawnContext as wt, PursuitVersionStop as wu, createRuntimeStreamEventCollector as wv, DEFAULT_STALL_AFTER_MS as wx, PeerMailEvent as wy, RuntimeSessionStore as x, RetainedRunTurnInput as xC, LoopIterationDispatchPayload as xS, CodeModeStore as x_, ChatSessionStore as xa, SpawnForestInDoubtNode as xb, StrategyMessage as xc, createPromptRegistry as xd, readRunParking as xf, ResearchOutputShape as xg, RouterRouting as xh, StoredGraphInput as xi, ScopeAnalyst as xl, SandboxSeam as xm, WorkerInteractiveProviderSource as xn, runStrategyEvolution as xo, FinalizerSettled as xp, readWorkerCancellation as xr, CreateScopeAnalystOptions as xs, SpawnRefusal as xt, NextPursuitVersion as xu, SanitizedKnowledgeReadinessReport as xv, createPushTraceSource as xx, DEFAULT_PEER_MAIL_LIMITS as xy, RuntimeCanonicalStreamEvent as y, RetainedRunSnapshot as yC, LoopDecisionPayload as yS, HarnessUsage as y_, WorkerEventPage as ya, SpawnForest as yb, CorpusReadbackOptions as yc, RegisteredPrompt as yd, RunParkingPolicy as yf, FeedbackRating as yg, RouterResponseReceipt as yh, GraphSelection as yi, PipelineStage as yl, RouterSeam as ym, AttachWorkerOptions as yn, TournamentCell as yo, DeliveredOutput as yp, cancelWorker as yr, verify as ys, SpawnPreflight as yt, runIsolatedCheck as yu, RuntimeStreamEventSummary as yv, ToolStepInput as yx, MapTraversalEvent as yy, SpendGap as z, SandboxClient as zS, leaderboard as z_, CheckRunner as za, NotFoundError as zb, defineStrategy as zc, WorkerSlots as zd, CoordinationToolFace as zf, composeLoopTraceEmitters as zg, DelegationExecutor as zh, DispatchUnit as zi, Persona as zl, sharedBoxPlacement as zm, WorkspaceCommit as zn, PrivateCasNamespaceInventory as zo, ContinuationEntry as zp, ProvisionSupervisorRequest as zr, printBenchmarkReport as zs, CheckpointRequest as zt, PursuitNodeCost as zu, WorkerWatchOptions as zv, HarnessTranscriptCapture as zx, McpToolAnnotations as zy };
-//# sourceMappingURL=types-BGGZDz0I.d.ts.map
+//# sourceMappingURL=types-DzS0kBeK.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-runtime",
-  "version": "2.3.7",
+  "version": "2.3.8",
   "description": "Shared task-lifecycle skeleton for agents: a recursive loop kernel for chat turns, one-shot tasks, and multi-attempt loops, with trace capture and eval-gated self-improvement. Domain behavior lives in adapters; scoring and ship-gates in @tangle-network/agent-eval.",
   "homepage": "https://github.com/tangle-network/agent-runtime#readme",
   "repository": {

package/dist/graph-FLVwpg79.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"graph-FLVwpg79.js","names":[],"sources":["../src/runtime/supervise/graph-backend.ts","../src/runtime/supervise/stored-graph-check.ts","../src/runtime/supervise/graph.ts"],"sourcesContent":["import { ValidationError } from '../../errors'\nimport type { RunGraphOptions } from './graph'\n\n/** Graph nodes share the same resumable Bridge transport as Braid. Hosts own its lifecycle. */\nexport function graphExecutionOptions(options: RunGraphOptions): RunGraphOptions {\n  if (options.makeLeafAgent) return options\n  const backend = options.backend\n  if (backend)\n    return backend.backend === 'bridge'\n      ? { ...options, backend: { ...backend, outputFormat: 'json' } }\n      : options\n  const bridgeUrl = process.env.CLI_BRIDGE_URL\n  const bridgeBearer = process.env.BRIDGE_BEARER ?? process.env.CLI_BRIDGE_BEARER\n  if (!bridgeUrl || !bridgeBearer)\n    throw new ValidationError(\n      'runGraph: start CLI Bridge and supply backend: { backend: \"bridge\", bridgeUrl, bridgeBearer, cwd }, or configure CLI_BRIDGE_URL and BRIDGE_BEARER',\n    )\n  return {\n    ...options,\n    backend: {\n      backend: 'bridge',\n      bridgeUrl,\n      bridgeBearer,\n      cwd: process.cwd(),\n      outputFormat: 'json',\n    },\n  }\n}\n","import { mkdirSync, realpathSync } from 'node:fs'\nimport { isAbsolute, join, relative } from 'node:path'\nimport { contentAddress } from '../../durable/content-address'\nimport {\n  appendCommittedJsonLine,\n  readCommittedJsonLines,\n  withJsonlFileLock,\n} from '../../durable/jsonl-file'\nimport { ValidationError } from '../../errors'\nimport { defaultRunCommand } from '../../mcp/worktree-harness'\nimport type { CompletionCheckContext } from './completion-gate'\nimport type { AgentGraph, RunGraphOptions } from './graph'\n\n/** An environment-owned check command, run outside the agent's conversation. */\nexport interface GraphCommandCheck {\n  readonly command: string\n  readonly timeoutMs?: number\n}\n\nexport interface GraphFromStoredOptions {\n  readonly trigger?: Readonly<Record<string, unknown>>\n  readonly checks?: Readonly<Record<string, AgentGraph['deliverable']['check'] | GraphCommandCheck>>\n}\n\ninterface CommandCheckReceipt {\n  readonly version: 1\n  readonly key: string\n  readonly binding: string\n  readonly checkDigest: string\n  readonly nodeName: string\n  readonly nodeId: string\n  readonly attemptId: string\n  readonly outputDigest: string\n  readonly exitCode: number | null\n  readonly output: string\n  readonly outputTruncated: boolean\n  readonly nativeValid: boolean\n  readonly valid: boolean\n}\n\n/** Driver-owned journal identity. Worker output never supplies any part of this authority. */\nfunction receiptKey(receipt: Omit<CommandCheckReceipt, 'key'>): string {\n  return contentAddress({\n    binding: receipt.binding,\n    checkDigest: receipt.checkDigest,\n    nodeName: receipt.nodeName,\n    nodeId: receipt.nodeId,\n    attemptId: receipt.attemptId,\n    outputDigest: receipt.outputDigest,\n  })\n}\n\nfunction isReceipt(value: unknown): value is CommandCheckReceipt {\n  if (!value || typeof value !== 'object' || Array.isArray(value)) return false\n  const row = value as Record<string, unknown>\n  if (\n    row.version !== 1 ||\n    ![\n      'key',\n      'binding',\n      'checkDigest',\n      'nodeName',\n      'nodeId',\n      'attemptId',\n      'outputDigest',\n      'output',\n    ].every((key) => typeof row[key] === 'string') ||\n    !row.nodeName ||\n    !row.nodeId ||\n    !row.attemptId ||\n    !(row.exitCode === null || Number.isSafeInteger(row.exitCode)) ||\n    typeof row.outputTruncated !== 'boolean' ||\n    typeof row.nativeValid !== 'boolean' ||\n    typeof row.valid !== 'boolean'\n  )\n    return false\n  const receipt = value as CommandCheckReceipt\n  return (\n    receipt.key === receiptKey(receipt) &&\n    receipt.valid === (receipt.exitCode === 0 && receipt.nativeValid)\n  )\n}\n\nfunction within(directory: string, path: string): boolean {\n  const offset = relative(directory, path)\n  return offset === '' || (!isAbsolute(offset) && offset !== '..' && !offset.startsWith('../'))\n}\n\n/** Lower a named check onto the local workspace, with evidence in the driver's durable state.\n * The run directory has the same trust boundary as RunContext journals: keep it outside the\n * worker workspace and do not mount it into the worker. A remote Bridge cannot run a host check.\n * Provider validators are refused because their context does not identify the admitted node.\n */\nexport function bindGraphCommand(\n  graph: AgentGraph,\n  options: RunGraphOptions,\n): { graph: AgentGraph; options: RunGraphOptions } {\n  const { command: definition, ...deliverable } = graph.deliverable\n  if (!definition) return { graph, options }\n  const { command, timeoutMs = 60_000 } = definition\n  if (!command.trim() || !Number.isSafeInteger(timeoutMs) || timeoutMs <= 0)\n    throw new ValidationError(\n      'graphFromStored: command check needs a command and positive timeoutMs',\n    )\n  const backend = options.backend\n  if (options.makeLeafAgent || !backend)\n    throw new ValidationError('runGraph: command checks require an explicit execution backend')\n  const workspace =\n    backend.backend === 'bridge'\n      ? backend.cwd\n      : backend.backend === 'cli-in-place'\n        ? backend.workspacePath\n        : undefined\n  if (\n    !workspace ||\n    (backend.backend === 'bridge' &&\n      !['localhost', '127.0.0.1', '[::1]'].includes(new URL(backend.bridgeUrl).hostname))\n  )\n    throw new ValidationError(\n      'runGraph: command checks require a loopback Bridge or local CLI workspace; provider node binding is unsupported',\n    )\n  if (!options.runDir)\n    throw new ValidationError(\n      'runGraph: command checks require a driver-owned runDir outside the workspace',\n    )\n  const cwd = realpathSync(workspace)\n  mkdirSync(options.runDir, { recursive: true })\n  const runDir = realpathSync(options.runDir)\n  if (within(cwd, runDir))\n    throw new ValidationError('runGraph: command check runDir must be outside the worker workspace')\n  const file = join(runDir, 'command-checks.jsonl')\n  const checkDigest = contentAddress({ command, timeoutMs, cwd })\n  const binding = contentAddress({\n    graph: { ...graph, deliverable: { ...deliverable, check: undefined } },\n    runId: options.runId ?? options.runContext?.runId,\n    checkDigest,\n  })\n  const nodeNames = new Set(graph.nodes.map((node) => node.id))\n\n  // The map is supplied by Runtime's flow finalizer. It contains terminal graph node IDs and\n  // outputs, never receipt metadata. Every match must come from this run's driver journal.\n  const checkFinal = async (out: unknown): Promise<boolean> => {\n    if (!out || typeof out !== 'object' || Array.isArray(out)) return false\n    const entries = Object.entries(out)\n    if (entries.length === 0 || entries.some(([name]) => !nodeNames.has(name))) return false\n    return withJsonlFileLock(file, async (canonicalPath) => {\n      if (within(cwd, canonicalPath)) return false\n      const latest = new Map<string, CommandCheckReceipt>()\n      for await (const raw of readCommittedJsonLines<unknown>(canonicalPath, {\n        allowMissing: true,\n      })) {\n        if (!isReceipt(raw)) return false\n        if (raw.binding !== binding || raw.checkDigest !== checkDigest) continue\n        latest.set(contentAddress([raw.nodeName, raw.outputDigest]), raw)\n      }\n      return entries.every(\n        ([name, output]) =>\n          latest.get(contentAddress([name, contentAddress(output)]))?.valid === true,\n      )\n    })\n  }\n\n  const checkLeaf = async (out: unknown, context: CompletionCheckContext): Promise<boolean> => {\n    const node = context.node\n    const nodeName = context.profile.name\n    if (!node || !node.nodeId || !node.attemptId || !nodeName || !nodeNames.has(nodeName))\n      return false\n    // Always execute for a fresh leaf. A prior success, even for identical output, never skips\n    // this check. gateFactoryOnDeliverable deduplicates only one invocation's exact artifact.\n    const outputDigest = contentAddress(out)\n    let result: { exitCode: number | null; output: string }\n    try {\n      result = await defaultRunCommand({ command, cwd, timeoutMs, signal: context.signal })\n    } catch (error) {\n      // An unavailable check invalidates an earlier identical output too; it cannot inherit\n      // a prior success just because the current command did not reach a normal exit.\n      result = { exitCode: null, output: error instanceof Error ? error.message : String(error) }\n    }\n    const bytes = Buffer.from(result.output)\n    const limit = 64 * 1024\n    const receipt: Omit<CommandCheckReceipt, 'key'> = {\n      version: 1,\n      binding,\n      checkDigest,\n      nodeName,\n      nodeId: node.nodeId,\n      attemptId: node.attemptId,\n      outputDigest,\n      exitCode: result.exitCode,\n      output: bytes.subarray(0, limit).toString('utf8'),\n      outputTruncated: bytes.length > limit,\n      nativeValid: context.originalVerdict?.valid !== false,\n      valid: result.exitCode === 0 && context.originalVerdict?.valid !== false,\n    }\n    await withJsonlFileLock(file, async (canonicalPath) => {\n      if (within(cwd, canonicalPath))\n        throw new ValidationError(\n          'runGraph: command receipt journal resolves inside worker workspace',\n        )\n      await appendCommittedJsonLine(canonicalPath, { ...receipt, key: receiptKey(receipt) })\n    })\n    return receipt.valid\n  }\n  return {\n    graph: {\n      ...graph,\n      deliverable: {\n        ...deliverable,\n        check: (out, context) =>\n          context === undefined ? checkFinal(out) : checkLeaf(out, context),\n      },\n    },\n    options,\n  }\n}\n","/**\n *\n * `runGraph` — agent graphs: profiles as nodes, registry-backed prompt directives as edges.\n *\n * A topology is PLAIN DATA an agent can author in a few lines: nodes are canonical\n * `AgentProfile`s (the ONLY way a node is described — no role-builder functions), edges are typed\n * values carrying versioned {@link PromptHandle} directives, `deliverable` (termination) and\n * `budget` (one conserved pool) are mandatory. Driver↔worker is the two-node cyclic instance;\n * \"agent 3 analyzes 1 and 2 and reports to 1\" is ONE edge, not a framework.\n *\n * NOT A SECOND SCHEDULER. `runGraph` is an interpretation layer over what already runs:\n * `supervise()` is the execution core — the same `supervisorAgent`/`driverAgent` machinery,\n * backend-derived worker path (authorized, classified, recursive), conserved-pool budget, and\n * deliverable-gated settlement every\n * supervised run uses. (`runAgentRounds` is deliberately NOT the substrate here.) What the graph\n * layer ADDS is exactly what a bespoke driver loop never\n * had:\n *\n *  1. **Node pinning** — a spawn names a node (`profile.name` = node id) and the node's canonical\n *     profile is what runs; a driver cannot smuggle capabilities into a worker it did not define.\n *  2. **Observable edges** — every delegates/analyzes/maps/routes traversal lands in an EDGE LEDGER\n *     (`delivered | stripped | empty | unpropagated | failed`, with byte counts), in memory on\n *     the result AND as `edge` events in the run journal. The motivating incident: a filter\n *     silently replaced 1,700-char steering with 241 chars of boilerplate for three rounds and\n *     NO artifact said so — an unobservable edge cannot be trusted and its directive cannot be\n *     optimized.\n *  3. **Directives as data** — edge text lives in the prompt registry (`<surface>/v<n>`), so every\n *     edge is a versioned optimization target, never prose hardcoded in a builder function.\n *  4. **Per-edge traversal caps** — the cyclic-graph backstop. A delegates edge whose cap is\n *     exhausted REFUSES further traversals (fail loud), so a cycle cannot spin the pool dry.\n *  5. **Continuity as data** — a delegates edge may declare `continuity: 'resume'`, so each spawn\n *     after the node's first re-attaches to its latest SETTLED session (the spawn context hands\n *     the executor seam `resume: { ofWorker, sequence }`; the kernel keeps identity, ordering,\n *     ledger truth, and the one conserved pool). Every ledger row states how its hop continued:\n *     `'fresh' | 'resume'` for spawns, `'steer'` for mid-run deliveries — fresh respawns, session\n *     resumes, and live steers are all plain data, each a ledgered fact.\n *  6. **Fan-out over a run-time list** — a `maps` edge takes the array a JSON pointer selects in a\n *     node's settled result and runs one item per element, then hands the ordered results to a\n *     join node. The runtime spawns every item and the join when the source settles, so the\n *     driver spends no model turn on them; each item is a spawn through the same authorized path,\n *     reserving from the same conserved pool, and every expansion, item and join is a ledger row.\n *  7. **Flow graphs** — with `entry` set, no node is a root: Runtime spawns the entries and fires\n *     `routes` edges on each settle (`graph-flow.ts`), so a fixed order, a branch, a bounded repair\n *     loop and a stop rule are graph data. The root manager is Runtime's own and never calls a\n *     model; every entry and route spawn takes the same authorized path a map item takes.\n *\n * ORACLES ARE ENVIRONMENT, NEVER WORKERS. Graders/verifiers must not be spawnable in the graph —\n * a delegates edge to them leaks the rubric. An `analyzes` edge names its analyst in one of two\n * forms: a LENS id from the environment's registry (a pure function over trace evidence), or the\n * id of a graph NODE — a tool-equipped analyst AGENT spawned on each matching settle with the\n * node's pinned profile, whose settle output IS the findings. Either way the oracle doctrine\n * holds: an analyst node can never be a delegates target (refused loudly), so no driver can hand\n * it work, and an id living in both the registry and the nodes is refused as ambiguous.\n *\n * @experimental\n */\n\nimport { resolve } from 'node:path'\nimport { type AgentProfile, canonicalCandidateDigest } from '@tangle-network/agent-interface'\nimport { ConfigError, ValidationError } from '../../errors'\nimport type { AnalystRegistry } from '../../mcp/tools/coordination-analysts'\nimport type { MakeWorkerAgent } from '../../mcp/tools/coordination-contracts'\nimport type { MapItemFailurePolicy } from '../../mcp/tools/coordination-map-contracts'\nimport type { ContinuityMode } from '../../mcp/tools/coordination-messages'\nimport type {\n  GateDecision,\n  GateDecisionRecord,\n  GateRequest,\n  RouteGate,\n  RouteWhen,\n} from '../../mcp/tools/coordination-route-contracts'\nimport { composeRuntimeHooks, type RuntimeHooks } from '../../runtime-hooks'\nimport { harnessRunsAgent } from '../harness-role'\nimport type { ToolLoopChat } from '../tool-loop'\nimport type { DeliverableSpec } from './completion-gate'\nimport { runtimeFlowBrain } from './flow-brain'\nimport { graphExecutionOptions } from './graph-backend'\nimport {\n  createFlowRun,\n  flowRootProfile,\n  GraphRouteError,\n  journaledGateDecider,\n  routeFlowOf,\n  validateFlowGraph,\n} from './graph-flow'\nimport { createGraphOverlay } from './graph-overlay'\nimport {\n  graphRootProfile,\n  type RootValidatedGraph,\n  type ValidatedGraph,\n  validateGraphTopology,\n} from './graph-topology'\nimport { kernelPromptRegistry, type PromptHandle, type PromptRegistry } from './prompt-registry'\nimport { createFileRunContext, createInMemoryRunContext, withRunContext } from './run-context'\nimport { bindGraphCommand, type GraphCommandCheck } from './stored-graph-check'\nimport {\n  profileGuidanceComposer,\n  type SuperviseOptions,\n  supervise,\n  superviseWithTestBrain,\n} from './supervise'\nimport type { Budget, NodeId, ResultBlobStore, SpawnJournal, SupervisedResult } from './types'\n\nexport type { MapItemFailurePolicy } from '../../mcp/tools/coordination-map-contracts'\nexport type {\n  GateDecision,\n  GateRequest,\n  JsonScalar,\n  RouteGate as GraphGate,\n  RouteMatch,\n  RouteWhen,\n} from '../../mcp/tools/coordination-route-contracts'\nexport { GraphRouteError } from './graph-flow'\nexport { defaultEdgeTraversalCap } from './graph-topology'\n\n// ── The algebra ────────────────────────────────────────────────────────────────\n\n/** A graph node: an id and a canonical `AgentProfile`. The profile is the ONLY way a node is\n *  described — its `prompt.systemPrompt` is the standing role (the 0.117 canonical resolution;\n *  never a legacy top-level-only reduction), its tools/mcp/resources are its capabilities. */\nexport interface GraphNode {\n  readonly id: NodeId\n  readonly profile: AgentProfile\n}\n\nexport type GraphEdge =\n  /** Work flows down. The delegation directive is DATA → versionable, sweepable, optimizable.\n   *  Each spawn of `to` by `from` — and each mid-run steer from `from` to a live `to` worker —\n   *  is one traversal. */\n  | {\n      readonly kind: 'delegates'\n      readonly from: NodeId\n      readonly to: NodeId\n      readonly directive: PromptHandle\n      /** Cyclic-graph backstop: traversals beyond this REFUSE (fail loud). Default\n       *  {@link defaultEdgeTraversalCap}. */\n      readonly maxTraversals?: number\n      /** Default continuity for this edge's SPAWN traversals. `'resume'` makes every spawn after\n       *  the node's first re-attach to its most recent SETTLED worker: a NEW live worker whose\n       *  spawn context carries `resume: { ofWorker, sequence }` for the executor seam, spending\n       *  from the same conserved pool — the node's first spawn is effectively `'fresh'`, and a\n       *  spawn while a prior worker is still live refuses loudly (steer is the live channel).\n       *  The driver's per-call `spawn_worker` `continuity` argument overrides either way. Omit =\n       *  `'fresh'` (today's behavior, byte-identical). Caps count resumes exactly like fresh\n       *  spawns. */\n      readonly continuity?: ContinuityMode\n    }\n  /** Findings flow anywhere: an analyst over N nodes' settled traces, delivered to ONE node.\n   *  With a LENS analyst the directive wraps the findings for the recipient; with a NODE analyst\n   *  the directive is the analyst agent's task and the findings are its settle output. */\n  | {\n      readonly kind: 'analyzes'\n      /** The analyst REFERENCE, in one of two forms: a lens id resolved against\n       *  `RunGraphOptions.analysts` (environment), or the id of a graph NODE with no delegates\n       *  edge pointing at it — then each matching settle spawns that node's pinned profile as a\n       *  tool-equipped analyst WORKER (same spawn machinery, conserved budget, trace join) whose\n       *  task is this edge's directive plus the settled worker's trace evidence and whose settle\n       *  output is the findings. An id that is both a node and a registry lens is refused. */\n      readonly analyst: string\n      readonly over: ReadonlyArray<NodeId>\n      readonly to: NodeId\n      readonly directive: PromptHandle\n      /** Observability cap: traversals beyond this are LEDGERED as exhausted (`unpropagated`).\n       *  Only delegates caps refuse traversal — they are what close the spawn cycle. */\n      readonly maxTraversals?: number\n    }\n  /**\n   * Fan-out over a list that exists only at run time, then one join. When `from` settles `done`,\n   * the array at `pointer` in its result is expanded: each element becomes the TASK of one item\n   * run, at most `concurrency` at a time, and once every item settled the `join` node runs with\n   * `{ map, source, items, results: [{ index, item, result }], failures: [{ index, item, outcome,\n   * reason }] }`, results in item order. The runtime spawns the items and the join (`from`'s\n   * driver spends no turn on them) through the same authorized spawn path a delegates spawn\n   * takes: each item reserves its budget from the one conserved pool and is pinned to the edge's\n   * profile, so an item's content can never choose what runs.\n   *\n   * An item is either the node `to` (its pinned profile plus this edge's directive) or the nested\n   * `graph`, started per item exactly as `run_graph` starts a graph. Refusals are loud and\n   * ledgered, and the driver is woken with them: a pointer that does not resolve to an array, more\n   * elements than `maxItems`, or a `concurrency` the run's worker-slot bound can never honor.\n   * `concurrency` otherwise THROTTLES (items wait for a free place); it never refuses an item.\n   *\n   * An edge rather than a node-level spec, because every kernel invariant a map must keep already\n   * attaches to edge traversal: pinning admits only the edge's item and join nodes (the spawn\n   * context carries a runtime-authored `map` marker), each item is admitted like a spawn and\n   * reserves from the conserved pool, each item settles under its own deliverable check, and each\n   * expansion, item and join is a ledger row with its journal twin. Topology stays static; only the\n   * traversal count is dynamic, so validation and the one-node-one-profile rule are unchanged.\n   */\n  | {\n      readonly kind: 'maps'\n      /** The source node: a delegates target, or the join of another maps edge. Each of its `done`\n       *  settles expands the map once. */\n      readonly from: NodeId\n      /** RFC 6901 JSON pointer into `from`'s settled result (`''` is the whole result). */\n      readonly pointer: string\n      /** The item node, run once per element with the element as its task. Exactly one of `to`\n       *  and `graph`. Reachable only through this edge: never a delegates target. */\n      readonly to?: NodeId\n      /** A graph run per element as one subtask, through the `run_graph` path. */\n      readonly graph?: GraphTopology\n      /** Receives the ordered results once every item settled. Reachable only through this edge. */\n      readonly join: NodeId\n      /** The item directive, appended to the item node's instructions per traversal. */\n      readonly directive: PromptHandle\n      /** Lists longer than this are refused before any item runs. */\n      readonly maxItems: number\n      /** How many items run at once. */\n      readonly concurrency: number\n      readonly onItemFailure: MapItemFailurePolicy\n      /** Each item's budget, merged over the per-worker default as `spawn_worker`'s `budget` is. */\n      readonly itemBudget?: Partial<Budget>\n    }\n  /**\n   * A route in a flow graph (one with `entry`): Runtime traverses it when `from` settles, so no\n   * root decides the order, the branch, the repair loop or the stop. On each usable settle of\n   * `from` its outgoing routes edges are tried in declaration order and the first whose `when`\n   * holds fires; an edge without `when` is the default branch and comes last. A node target is\n   * spawned with `{ from: { node, result }, evidence: { [id]: latest usable result } }` (a join's\n   * target with `{ from: { nodes }, evidence }`, see below) and the directive appended to its pinned instructions; `{ stop }` ends the run with no winner and\n   * `GraphResult.stopped`; `{ finish }` makes this settle part of the run's output.\n   *\n   * A fork lists two or more nodes in `to`: one traversal spawns each of them at once, each under\n   * its own key `route:<edge id>#<traversal>:<node>`. A join lists two or more nodes in `from`: it\n   * fires once every member has settled usably since it last fired, and the target's task is\n   * `{ from: { nodes: <members in declared order> }, evidence }` with each member's latest result\n   * in `evidence`, so it does not depend on which member settled last and a resumed run derives the\n   * same task. A routes edge that spawns a node with a settled worker in this flow (a back edge)\n   * names that node's latest settled worker as the spawn's `successorOf`. A join carries no `when`, and it is the only routes edge\n   * leaving each of its members. A route into a node that still has a running worker throws\n   * {@link GraphRouteError} with reason `target-live`: converging branches use a join.\n   */\n  | {\n      readonly kind: 'routes'\n      readonly from: NodeId | ReadonlyArray<NodeId>\n      readonly to:\n        | NodeId\n        | ReadonlyArray<NodeId>\n        | { readonly stop: string }\n        | { readonly finish: string }\n      readonly directive: PromptHandle\n      /** Absent on the default edge and on every join. A match reads `from` unless it names a node\n       *  in `evidence`. */\n      readonly when?: RouteWhen\n      /** Nodes whose latest usable result rides the target's task. */\n      readonly evidence?: ReadonlyArray<NodeId>\n      /** Traversals beyond this are skipped (ledgered `unpropagated`) and matching continues with\n       *  the next edge. Default {@link defaultEdgeTraversalCap}. Every routes cycle, each subcycle\n       *  included, must cross an edge that sets it. */\n      readonly maxTraversals?: number\n      /** `'resume'` re-attaches each spawn of the target to its latest settled session. Omit =\n       *  `'fresh'`. */\n      readonly continuity?: ContinuityMode\n    }\n\n/** A topology without the run's own budget and deliverable: the form a `maps` edge runs per item,\n *  as `run_graph` runs it. With `entry` it is a flow graph. Inside a maps item, the item value is\n *  the task of every entry whose task is the placeholder `{ item: true }`; a down settle inside the item ends\n *  that item only, and the maps edge's `onItemFailure` decides the join. */\nexport interface GraphTopology {\n  readonly nodes: ReadonlyArray<GraphNode>\n  readonly edges: ReadonlyArray<GraphEdge>\n  readonly entry?: AgentGraph['entry']\n  /** Refused here: a maps item's graph and a `run_graph` subtask have no `decideGate`. */\n  readonly gates?: AgentGraph['gates']\n}\n\nexport interface AgentGraph {\n  /** Preserve fully bound literal data when serializing a hydrated graph. */\n  readonly triggerBindings?: readonly []\n  readonly nodes: ReadonlyArray<GraphNode>\n  readonly edges: ReadonlyArray<GraphEdge>\n  /** Termination is mandatory, not optional: the independent completion oracle. */\n  readonly deliverable: DeliverableSpec<unknown> & {\n    readonly checkRef?: string\n    readonly command?: GraphCommandCheck\n    readonly when?: RouteWhen\n  }\n  /** One conserved pool across the whole graph — cycles without conservation never terminate. */\n  readonly budget: Budget\n  /** Setting it makes this a FLOW graph: Runtime spawns every entry at once, each with its task,\n   *  and traverses `routes` edges itself. No node is a root and no caller brain runs; the run's\n   *  output is `{ [node]: latest usable result }` over its terminal nodes and `finish` sources,\n   *  judged by `deliverable`. */\n  readonly entry?: ReadonlyArray<{ readonly node: NodeId; readonly task: unknown }>\n  /** Flow-graph vertices that are not agents: a routes edge into one awaits\n   *  `RunGraphOptions.decideGate`, and one edge per choice leaves it, matching\n   *  `{ pointer: '/choice', equals: <choice> }`. A `finish` leaving a gate outputs\n   *  `{ [gate]: { choice, by } }`. */\n  readonly gates?: ReadonlyArray<RouteGate>\n}\n\n// ── The edge ledger ────────────────────────────────────────────────────────────\n\n/** `failed` is a maps item or join that ran and settled without a usable result (down, or\n *  rejected by its deliverable check); a traversal that never reached a worker is `unpropagated`. */\nexport type EdgeDeliveryOutcome = 'delivered' | 'stripped' | 'empty' | 'unpropagated' | 'failed'\n\n/** How one ledgered hop CONTINUED: a spawn traversal stamps its effective spawn mode\n *  (`'fresh'` | `'resume'`), and every mid-run delivery into an already-live recipient — a\n *  driver steer leg and every analyzes delivery (routed steer or driver-destined finding) —\n *  stamps `'steer'`. Zero ambiguity: every row carries exactly one of the three. */\nexport type TraversalContinuity = ContinuityMode | 'steer'\n\n/** One recorded edge traversal — the in-memory row; the journal twin is the `edge` SpawnEvent. */\nexport interface EdgeTraversal {\n  /** Stable edge id: `delegates:<from>-><to>`, `analyzes:<analyst>:<over…>-><to>`,\n   *  `maps:<from>-><to | graph>-><join>`, `routes:<from>#<ordinal>-><to | stop:<reason> |\n   *  finish:<reason>>`, or `routes:entry-><node>` for an entry. */\n  readonly edge: string\n  readonly kind: 'delegates' | 'analyzes' | 'maps' | 'routes'\n  readonly from: string\n  readonly to: string\n  /** The resolved directive reference (`<surface>/v<n>`). */\n  readonly directive: string\n  /** 1-based per-edge ordinal. */\n  readonly traversal: number\n  readonly outcome: EdgeDeliveryOutcome\n  /** How this hop continued — see {@link TraversalContinuity}. */\n  readonly continuity: TraversalContinuity\n  /** Bytes of directive + payload that actually crossed the edge. */\n  readonly bytes: number\n  readonly reason?: string\n  /** The concrete worker node id, once known. A maps expansion names the source worker. */\n  readonly workerId?: string\n  /** Present on maps rows: the expansion of the source's list, one item by its index, or the\n   *  join. */\n  readonly map?: { readonly phase: 'expand' | 'item' | 'join'; readonly index?: number }\n  /** Present on a gate's decision row (`gate:<id>`, `traversal` = visit): who decided, and what. */\n  readonly gate?: GateDecisionRecord\n}\n\n/** A delegates edge exhausted its traversal cap and the run produced no winner: the cap, not the\n *  task, ended it. Carries the full evidence so failing loud loses nothing. */\nexport class GraphEdgeCapError extends Error {\n  readonly exhaustedEdges: ReadonlyArray<string>\n  readonly ledger: ReadonlyArray<EdgeTraversal>\n  readonly result: SupervisedResult<unknown>\n  constructor(\n    exhaustedEdges: ReadonlyArray<string>,\n    ledger: ReadonlyArray<EdgeTraversal>,\n    result: SupervisedResult<unknown>,\n  ) {\n    super(\n      `runGraph: edge traversal cap exhausted on ${exhaustedEdges.join(', ')} and the run ` +\n        'delivered no winner — the cap (the cyclic-graph backstop), not the task, ended this run. ' +\n        'Raise maxTraversals on the edge or fix the cycle; the full edge ledger and the ' +\n        'supervised result ride on this error.',\n    )\n    this.name = 'GraphEdgeCapError'\n    this.exhaustedEdges = exhaustedEdges\n    this.ledger = ledger\n    this.result = result\n  }\n}\n\n// ── Options / result ───────────────────────────────────────────────────────────\n\n/**\n * Every `SuperviseOptions` key, partitioned by what `runGraph` does with it.\n *\n * `runGraph` starts one `supervise()` run, so every option that run honors is a graph option too\n * unless the graph itself owns the value. This used to be an opt-in list written by hand, and the\n * hand lost: 25 of 49 keys never reached `supervise()` from a graph, including `childSettleGraceMs`\n * (a root-driver failure tore down children that had ALREADY computed the deliverable) and\n * `driverRetry` (agent-runtime#963). Each absence was discovered by losing a run.\n *\n * The four lists below must cover `keyof SuperviseOptions` exactly. `everySuperviseOptionIsClassified`\n * below fails to COMPILE, naming the offender, when a key belongs to none of them — so the next\n * option added to `supervise()` cannot go missing here silently. It has to be classified, and\n * classifying it as forwarded is one word.\n */\n\n/** The graph derives these from the `AgentGraph` itself; a caller value would be overwritten. */\nconst GRAPH_OWNED_SUPERVISE_OPTIONS = [\n  'rootDriverFromBackend',\n  'resolveSpawnProfile',\n  'budget',\n  'deliverable',\n  'makeWorkerAgent',\n  'onCoordinationEvent',\n  'analyzeOnSettle',\n  'mapOnSettle',\n  // A flow graph's entries and routes edges; its runtime-owned root runs them.\n  'routeFlow',\n  'continuityByProfile',\n  // A graph pins every node and its delegation edges; a node never gains spawn rights it lacks.\n  'inheritSpawnRights',\n] as const\n\n/** Caller-facing on `RunGraphOptions`, but the graph wraps or defaults the value before it goes in:\n *  `hooks` composes with the graph's own spawn-binding hook, `authorizeMessage` is wrapped so a\n *  narrowed instruction ledgers `stripped`, `authorizeSpawn` runs AFTER the graph has pinned the\n *  node (so a product sees the canonical profile, never the driver's stub), `makeLeafAgent` is the\n *  caller's leaf override slotted under the graph's pinning, `analysts` rides only with analyze\n *  routes, and `journal`/`blobs`/`runId` get graph defaults. */\nconst GRAPH_TRANSFORMED_SUPERVISE_OPTIONS = [\n  'hooks',\n  'authorizeMessage',\n  'authorizeSpawn',\n  'makeLeafAgent',\n  'analysts',\n  'journal',\n  'blobs',\n  'runId',\n  // Replays a journaled decision before asking the caller.\n  'decideGate',\n] as const\n\n/** Not reachable from a graph, with the reason. `registry` is a NAME COLLISION, not a policy:\n *  `RunGraphOptions.registry` is the directive `PromptRegistry` and `SuperviseOptions.registry` is\n *  the `SuperviseRegistry` name→value table. Two different types under one name; the graph's wins.\n *  Giving the supervise one a graph channel means renaming a public option, so it is recorded here\n *  rather than silently dropped. */\nconst GRAPH_REFUSED_SUPERVISE_OPTIONS = ['registry'] as const\n\n/**\n * Forwarded to the root `supervise()` VERBATIM. Everything not owned, transformed, or refused\n * above belongs here — the default is \"a graph honors it\", not \"someone remembered to add it\".\n */\nconst GRAPH_FORWARDED_SUPERVISE_OPTIONS = [\n  'parking',\n  'backend',\n  // Forwarded: composes guidance into the root and into profiles a manager authors. The graph also\n  // composes each PINNED node profile, because pinning replaces the composed `{ name }` stub.\n  'profileGuidance',\n  // Forwarded, not graph-owned: a graph pins WHICH nodes run, never who answers a question one of\n  // them raises. Without it a graph run's `ask_parent` would always report `no-parent` even when\n  // the caller wired an inbox.\n  'escalateQuestion',\n  'rootHandle',\n  'signal',\n  'execution',\n  'resolveDeliverable',\n  'coordination',\n  'peerMail',\n  'peerAudit',\n  'traceTools',\n  'driverBackend',\n  'profileSecurity',\n  'authorizeSpawn',\n  'router',\n  'driveHarness',\n  'selectSeat',\n  'driverRetry',\n  'onDriverAttempt',\n  'workerRetry',\n  'onWorkerRetry',\n  'continuation',\n  'childSettleGraceMs',\n  'teardownConfirmMs',\n  'retainedAtSettlement',\n  'resolveDriveHarness',\n  'driveHarnessMaterialization',\n  'resolveSupervisorTools',\n  'extraTools',\n  'executeExtraTool',\n  'recoverExecutor',\n  'perWorker',\n  'reservationPolicy',\n  'deadlineCheckIn',\n  'budgetStopHoldMs',\n  'workerSlots',\n  'watchWorkers',\n  'stallAfterMs',\n  'wake',\n  'runDir',\n  'resume',\n  'segment',\n  'runContext',\n  'steerDir',\n  'stopRule',\n  'onProgressStop',\n  'maxDepth',\n  'maxTurns',\n  'compaction',\n  'now',\n  'allowedModels',\n  'finalizer',\n  'otel',\n  // Forwarded: the registry a manager's `run_graph` resolves stored graphs against. A node of this\n  // graph cannot start another graph (pinning refuses it), so it matters to no node here.\n  'graphRegistry',\n] as const\n\ntype ClassifiedSuperviseOption =\n  | (typeof GRAPH_OWNED_SUPERVISE_OPTIONS)[number]\n  | (typeof GRAPH_TRANSFORMED_SUPERVISE_OPTIONS)[number]\n  | (typeof GRAPH_REFUSED_SUPERVISE_OPTIONS)[number]\n  | (typeof GRAPH_FORWARDED_SUPERVISE_OPTIONS)[number]\n\n/**\n * Every key `RunGraphOptions` accepts, as data: the forwarded and transformed `SuperviseOptions`\n * keys, the name-colliding `registry`, and the graph's own `brain`. `GRAPH_OWNED_SUPERVISE_OPTIONS`\n * is deliberately absent — a caller value for one of those is overwritten by the graph, so it is\n * refused by name rather than discarded.\n *\n * The assignment below fails to COMPILE, naming the key, when `RunGraphOptions` declares something\n * this list does not carry.\n */\nconst runGraphOptionKeys = [\n  ...GRAPH_FORWARDED_SUPERVISE_OPTIONS,\n  ...GRAPH_TRANSFORMED_SUPERVISE_OPTIONS,\n  ...GRAPH_REFUSED_SUPERVISE_OPTIONS,\n  'brain',\n] as const\n\ntype UnlistedRunGraphOption = Exclude<keyof RunGraphOptions, (typeof runGraphOptionKeys)[number]>\nconst everyRunGraphOptionIsListed: UnlistedRunGraphOption extends never\n  ? true\n  : UnlistedRunGraphOption = true\nvoid everyRunGraphOptionIsListed\n\nconst runGraphOptionKeySet: ReadonlySet<string> = new Set<string>(runGraphOptionKeys)\nconst graphOwnedOptionKeySet: ReadonlySet<string> = new Set<string>(GRAPH_OWNED_SUPERVISE_OPTIONS)\n\n/**\n * Refuse an option key the graph would not read, naming it and saying which kind it is.\n *\n * A graph-owned key is the sharper case: it type-checks against a widened `SuperviseOptions`\n * value, the graph derives its own value and overwrites the caller's, the run succeeds, and the\n * capability the caller asked for is not there. The rename of the leaf seam from `makeWorkerAgent`\n * to `makeLeafAgent` is the shape of the failure — the old name stayed a valid `SuperviseOptions`\n * key AND a graph-owned one, so a caller that kept passing it got a run with no leaf override and\n * no complaint.\n */\nfunction assertRunGraphOptionKeys(opts: RunGraphOptions): void {\n  const graphOwned: string[] = []\n  const unknown: string[] = []\n  for (const key of Object.keys(opts)) {\n    if (runGraphOptionKeySet.has(key)) continue\n    if (graphOwnedOptionKeySet.has(key)) graphOwned.push(key)\n    else unknown.push(key)\n  }\n  if (graphOwned.length > 0) {\n    throw new ConfigError(\n      `runGraph: ${graphOwned.sort().join(', ')} — the graph derives this from the AgentGraph ` +\n        'itself, so a caller value is overwritten and the capability it asks for would silently ' +\n        'be absent',\n    )\n  }\n  if (unknown.length > 0) {\n    throw new ConfigError(\n      `runGraph: unknown option ${unknown.sort().join(', ')} — no reader consults that name, so ` +\n        'the value would be discarded and the capability it asks for would silently be absent',\n    )\n  }\n}\n\n/** A `SuperviseOptions` key in none of the four lists makes this assignment fail, and the compiler\n *  error names the key. Classify it — `GRAPH_FORWARDED_SUPERVISE_OPTIONS` is usually the answer. */\ntype UnclassifiedSuperviseOption = Exclude<keyof SuperviseOptions, ClassifiedSuperviseOption>\nconst everySuperviseOptionIsClassified: UnclassifiedSuperviseOption extends never\n  ? true\n  : UnclassifiedSuperviseOption = true\nvoid everySuperviseOptionIsClassified\n\n/** `backend` and `driverBackend` keep graph-specific documentation below.\n *\n * Do not inherit and redeclare them through an indexed access type.\n * TypeScript 7 correctly treats `SuperviseOptions['backend']` as including `undefined`, which makes\n * that redeclaration wider than the exact optional property inherited from `SuperviseOptions`.\n */\ntype GraphInheritedSuperviseOption = Exclude<\n  (typeof GRAPH_FORWARDED_SUPERVISE_OPTIONS)[number],\n  'backend' | 'driverBackend'\n>\n\n/** Copy every forwarded option the caller actually set. Absent stays absent: `supervise()` and the\n *  graph must not disagree about what \"unset\" means. */\nfunction forwardedSuperviseOptions(\n  opts: RunGraphOptions,\n): Pick<SuperviseOptions, (typeof GRAPH_FORWARDED_SUPERVISE_OPTIONS)[number]> {\n  const forwarded: Record<string, unknown> = {}\n  for (const key of GRAPH_FORWARDED_SUPERVISE_OPTIONS) {\n    const value = (opts as Record<string, unknown>)[key]\n    if (value !== undefined) forwarded[key] = value\n  }\n  return forwarded as Pick<SuperviseOptions, (typeof GRAPH_FORWARDED_SUPERVISE_OPTIONS)[number]>\n}\n\n/**\n * Options for one `runGraph` run.\n *\n * Extends every forwarded `SuperviseOptions` key, so a graph honors what a `supervise()` run\n * honors WITHOUT anyone restating it here. Only the graph-specific members and the ones whose\n * graph semantics differ are declared below; everything else inherits its type AND its\n * documentation from `SuperviseOptions`, which is the one owner of both.\n */\nexport interface RunGraphOptions extends Pick<SuperviseOptions, GraphInheritedSuperviseOption> {\n  /** WHERE worker nodes run — the executor backend. Provide this OR `makeLeafAgent`. Forwarded to\n   *  `supervise()`, which derives every authorized leaf from it. A node that declares\n   *  `agent_runtime_coordination_spawn_worker` becomes a nested supervisor instead, whose own\n   *  leaves are derived the same way. */\n  readonly backend?: Exclude<SuperviseOptions['backend'], undefined>\n  /** WHERE the ROOT node's harness brain runs — forwarded to `supervise()` verbatim (see\n   *  `SuperviseOptions.driverBackend`). Needed when the root node's profile declares an external\n   *  harness (`codex`, `claude-code`, `opencode`): that root is driven by the harness, not by the\n   *  router brain, and automatic execution supports a local `bridge`. Unlike `supervise()`, this\n   *  does NOT default to `backend`: a graph's `backend` places WORKER nodes, so the root driver\n   *  is selected only by this field. Omit = no harness driver, which is correct for a root whose\n   *  `profile.harness` is omitted or `cli-base` (that root runs on the router brain). */\n  readonly driverBackend?: Exclude<SuperviseOptions['driverBackend'], undefined>\n  /** Leaf-execution override (offline tests / advanced). `runGraph` still owns node pinning,\n   *  directive delivery, and the edge ledger AROUND this seam — only the leaf `act` is yours.\n   *  Slots INSIDE the kernel's authorized path (`SuperviseOptions.makeLeafAgent`), so a node that\n   *  declares the spawn tool still becomes a nested supervisor even under an offline leaf. */\n  readonly makeLeafAgent?: MakeWorkerAgent\n  /** The ROOT driver's inference seam — a caller-owned `ToolLoopChat` that makes every root\n   *  model call. Use it when the root's decisions must be caller-owned orchestration (a\n   *  deterministic conversation driver, a persona loop with its own LLM calls) rather than a\n   *  router-derived model call. The graph machinery around the seam is unchanged: node pinning,\n   *  directive delivery, the edge ledger, and the journal twin all run the same shipped path,\n   *  and the root profile keeps prompt control (`prompt-control-execution` materialization —\n   *  `systemPrompt`/`instructions` still apply). What moves to the caller with the brain:\n   *  model selection and provider-identity validation (`expectedModel` cannot be enforced on a\n   *  call the runtime did not place) and per-turn usage reporting (a brain that reports no\n   *  usage meters nothing into the pool). Omit = the router brain derived from the root\n   *  profile — the unchanged default. Mutually exclusive with `driverBackend`, and refused\n   *  when the root profile declares an external harness (that root is driven BY the harness). */\n  readonly brain?: ToolLoopChat\n  /** Caller-side runtime hooks (telemetry, policy, product extensions). Composed AFTER the\n   *  graph's own spawn-binding hook on the SAME event stream — the graph never swallows the\n   *  seam supervise() exposes. */\n  readonly hooks?: RuntimeHooks\n  /** The analyst lens registry `analyzes` edges resolve against. ENVIRONMENT — needed only for\n   *  lens analysts; an analyzes edge naming a graph NODE as its analyst needs no registry. */\n  readonly analysts?: AnalystRegistry\n  /** Answers a flow gate while the process holds the run; the wait counts against its deadline.\n   *  ENVIRONMENT, like `analysts`; required when the graph declares gates. */\n  readonly decideGate?: (request: GateRequest) => Promise<GateDecision>\n  /** Directive registry. Default: the seeded kernel registry (`kernelPromptRegistry()`).\n   *\n   *  NOT `SuperviseOptions.registry`, which is the `SuperviseRegistry` name→value table for\n   *  code-valued options. The two share a name and nothing else, and this one wins here — see\n   *  `GRAPH_REFUSED_SUPERVISE_OPTIONS`. */\n  readonly registry?: PromptRegistry\n  /** The run journal the edge ledger and every spawn/settle ride. Default: in-memory. */\n  readonly journal?: SpawnJournal\n  readonly blobs?: ResultBlobStore\n  readonly runId?: string\n  /** Product authority over every steer/answer instruction (the filter seam). `runGraph` observes\n   *  what it CHANGES: a narrowed instruction ledgers its steer traversal as `stripped`. */\n  readonly authorizeMessage?: SuperviseOptions['authorizeMessage']\n}\n\nexport interface GraphResult<Out = unknown> {\n  readonly result: SupervisedResult<Out>\n  /** Every edge traversal, in occurrence order — the observable-edge contract. */\n  readonly ledger: ReadonlyArray<EdgeTraversal>\n  /** Edge ids whose traversal cap was hit — analyzes exhaustion included (observable here, never\n   *  a refusal). A DELEGATES cap paired with a `no-winner` result THROWS\n   *  ({@link GraphEdgeCapError}) instead of returning: only delegates caps refuse spawns, so only\n   *  they can have ended the run. A LIFECYCLE no-winner (`aborted` / `budget-exhausted`) returns\n   *  normally even with an exhausted delegates cap — the abort or the pool, not the cap, ended\n   *  that run, and the exhaustion stays observable here. */\n  readonly exhaustedEdges: ReadonlyArray<string>\n  readonly runId: string\n  /** Why a flow graph ended early: a `stop` edge fired (`edge` names it), or a flow node settled\n   *  down (no `edge`; `reason` is `down: <worker reason>`) or, where a route was needed, without a\n   *  usable result (no `edge`; `reason` is `unusable: <why>`). Live flow workers are aborted. */\n  readonly stopped?: {\n    readonly edge?: string\n    readonly at: NodeId\n    readonly workerId: string\n    readonly reason: string\n  }\n}\n\n/** `RunGraphOptions` with the brain REQUIRED — the shape the `/testing` entry's\n *  `runGraphWithTestBrain` keeps accepting now that `brain` is a production option. */\nexport interface RunGraphTestOptions extends RunGraphOptions {\n  readonly brain: ToolLoopChat\n}\n\n// ── Validation ─────────────────────────────────────────────────────────────────\n\n/** Validate the graph and resolve every directive BEFORE any compute is spent — an invalid\n *  topology or an unknown directive is a configuration fault, never a mid-run surprise. */\nfunction validateGraph(\n  graph: AgentGraph,\n  registry: PromptRegistry,\n  analysts: AnalystRegistry | undefined,\n): ValidatedGraph {\n  if (graph.entry === undefined) {\n    if (!Array.isArray(graph.nodes) || graph.nodes.length === 0) {\n      throw new ValidationError('runGraph: graph.nodes must be a non-empty array')\n    }\n    if (!Array.isArray(graph.edges) || graph.edges.length === 0) {\n      throw new ValidationError('runGraph: graph.edges must be a non-empty array')\n    }\n  }\n  if (typeof graph.deliverable?.check !== 'function') {\n    throw new ValidationError('runGraph: graph.deliverable is mandatory (termination oracle)')\n  }\n  if (typeof graph.budget !== 'object' || graph.budget === null) {\n    throw new ValidationError('runGraph: graph.budget is mandatory (the conserved pool)')\n  }\n  if (graph.entry !== undefined) return validateFlowGraph(graph, registry, analysts)\n  if (graph.gates !== undefined)\n    throw new ValidationError('runGraph: graph.gates needs graph.entry')\n  return validateGraphTopology(graph.nodes, graph.edges, registry, analysts)\n}\n\n// ── The runner ─────────────────────────────────────────────────────────────────\n\n/**\n * Execute an {@link AgentGraph}. A flow graph (`entry` set) runs from its entries and routes edges\n * under a runtime-owned root that places no model call. Otherwise the root node becomes the\n * supervisor (`supervise()` — the execution core), each worker node is spawnable BY NODE ID\n * (`spawn_worker` with `profile: { name: '<node id>' }`; the node's canonical profile is pinned by\n * the graph), each\n * delegates directive is appended to the worker profile's `prompt.instructions` per traversal,\n * and each analyzes edge becomes an analyst-on-settle route with a real DESTINATION. Every\n * traversal is ledgered and journaled.\n */\nexport function runGraph(graph: AgentGraph, opts: RunGraphOptions): Promise<GraphResult> {\n  const { brain, ...runtimeOptions } = graphExecutionOptions(opts)\n  return superviseAgentGraph(graph, runtimeOptions, brain)\n}\n\n/** Alias for graph tests written before `RunGraphOptions.brain` was production. The production\n *  entry accepts the same shape; this wrapper only keeps the `/testing` import path working. */\nexport function runGraphWithTestBrain(\n  graph: AgentGraph,\n  opts: RunGraphTestOptions,\n): Promise<GraphResult> {\n  const { brain, ...runtimeOptions } = opts\n  return superviseAgentGraph(graph, runtimeOptions, brain)\n}\n\n/**\n * The graph supervise run, as its own entry: the engine's `run-graph` preset node executes exactly\n * this, so the preset and `runGraph` are the same code path by construction (agent-runtime#982).\n */\n/**\n * Every refusal a graph earns before any compute, in one place: the authoring contract. `runGraph`\n * calls it FIRST so a malformed graph throws synchronously, exactly as it did before the engine\n * preset (agent-runtime#982) moved execution behind a promise.\n */\nexport function assertRunGraphAuthoring(\n  graph: AgentGraph,\n  opts: RunGraphOptions,\n  brain?: ToolLoopChat,\n): ReturnType<typeof validateGraph> {\n  assertRunGraphOptionKeys(opts)\n  const registry = opts.registry ?? kernelPromptRegistry()\n  const validated = validateGraph(graph, registry, opts.analysts)\n  const requireLeaves = (): void => {\n    if (!opts.backend && !opts.makeLeafAgent) {\n      throw new ValidationError(\n        'runGraph: provide opts.backend (where nodes run) or opts.makeLeafAgent',\n      )\n    }\n  }\n  if (validated.flow !== undefined) {\n    // A flow's root is Runtime's own: nothing a caller sets for a root manager has a reader.\n    const rootOptions = [\n      ...(brain ? ['brain'] : []),\n      ...(['driverBackend', 'finalizer', 'maxTurns', 'compaction'] as const).filter(\n        (key) => opts[key] !== undefined,\n      ),\n    ]\n    if (rootOptions.length > 0) {\n      throw new ValidationError(\n        `runGraph: ${rootOptions.join(', ')} with graph.entry — a flow graph has no root ` +\n          'manager: Runtime spawns its entries and traverses its routes edges, and the graph ' +\n          \"owns the run's output\",\n      )\n    }\n    if ((graph.gates?.length ?? 0) > 0 && opts.decideGate === undefined) {\n      throw new ValidationError('runGraph: graph.gates needs opts.decideGate to answer them')\n    }\n    requireLeaves()\n    return validated\n  }\n  const { root } = validated as RootValidatedGraph\n  // A caller brain and a harness driver are two answers to WHO makes the root's calls: refuse the\n  // contradiction before any compute, and refuse a harness-driven root outright — the harness IS\n  // that root's brain, so a supplied one would be silently ignored downstream.\n  if (brain && opts.driverBackend) {\n    throw new ValidationError(\n      'runGraph: brain and driverBackend are mutually exclusive — a caller brain makes the root model calls, a driverBackend places a harness that makes its own',\n    )\n  }\n  if (brain && harnessRunsAgent(root.profile.harness)) {\n    throw new ValidationError(\n      `runGraph: root node '${root.id}' declares harness '${root.profile.harness}', so the harness drives it — a caller brain applies only to a router-brained root (profile.harness omitted or 'cli-base')`,\n    )\n  }\n  requireLeaves()\n  return validated\n}\n\nexport function superviseAgentGraph(\n  graph: AgentGraph,\n  opts: RunGraphOptions,\n  brain?: ToolLoopChat,\n): Promise<GraphResult> {\n  if (graph.deliverable.command !== undefined) {\n    const bound = bindGraphCommand(graph, opts)\n    return superviseAgentGraph(bound.graph, bound.options, brain)\n  }\n  const registry = opts.registry ?? kernelPromptRegistry()\n  if (opts.runContext?.acquire !== undefined) {\n    return withRunContext(opts.runContext, opts.signal, (runContext, signal) =>\n      superviseAgentGraph(\n        graph,\n        {\n          ...opts,\n          runContext,\n          ...(signal === undefined ? {} : { signal }),\n        },\n        brain,\n      ),\n    )\n  }\n  const validated = assertRunGraphAuthoring(graph, opts, brain)\n  // A flow graph: Runtime schedules its nodes, and its root manager is Runtime's own.\n  const flow = validated.flow === undefined ? undefined : createFlowRun()\n  const context =\n    opts.runContext ??\n    (opts.runDir === undefined\n      ? createInMemoryRunContext()\n      : createFileRunContext(resolve(opts.runDir)))\n  const journal = opts.journal ?? context.journal\n  const blobs = opts.blobs ?? context.blobs\n  const runId =\n    opts.runId ??\n    opts.runContext?.runId ??\n    `graph-${canonicalCandidateDigest(graph.nodes.map((n) => n.id)).slice('sha256:'.length, 'sha256:'.length + 12)}`\n  const now = opts.now ?? Date.now\n\n  // The graph layer: node pinning, analyst routes, continuity defaults and the edge ledger. A\n  // `run_graph` subtask builds the same overlay around its nested manager.\n  // `profileGuidance` composes the profile a manager authors, but a graph then swaps that\n  // `{ name }` stub for the pinned node profile. Compose the pinned profile too, so every node\n  // that runs carries its harness and model guidance. Composition is idempotent.\n  const guidance = profileGuidanceComposer(opts.profileGuidance)\n  const overlay = createGraphOverlay(validated, {\n    registry,\n    journal,\n    runId,\n    now,\n    ...(guidance ? { guidance } : {}),\n    ...(opts.authorizeSpawn ? { authorizeSpawn: opts.authorizeSpawn } : {}),\n  })\n  // Always present: the kernel refuses steer/answer whenever spawn authorization is on (the\n  // graph's pinning IS spawn authorization), so a graph with no caller filter passes instructions\n  // through unchanged rather than losing its steer channel. Only a caller filter can strip.\n  const callerAuthorizeMessage = opts.authorizeMessage\n  const authorizeMessage = overlay.observeMessages<\n    Parameters<NonNullable<SuperviseOptions['authorizeMessage']>>[0]\n  >((input) =>\n    callerAuthorizeMessage ? callerAuthorizeMessage(input) : { instruction: input.instruction },\n  )\n\n  // ── Spawn-hook: bind ledger rows to concrete worker ids, then journal them ──\n  const graphHooks: RuntimeHooks = {\n    onEvent: (event) => {\n      if (event.target !== 'agent.spawn' || event.phase !== 'after') return\n      const payload = event.payload as { childId?: unknown; assignmentId?: unknown } | undefined\n      if (typeof payload?.childId !== 'string' || typeof payload.assignmentId !== 'string') return\n      return overlay.bindSpawn(event.parentId, payload.assignmentId, payload.childId)\n    },\n  }\n  const hooks = composeRuntimeHooks(graphHooks, opts.hooks)\n  const rootProfile =\n    flow === undefined\n      ? graphRootProfile(validated as RootValidatedGraph, registry)\n      : flowRootProfile\n  const rootBrain = flow === undefined ? brain : runtimeFlowBrain()\n  const task =\n    flow === undefined\n      ? graphTask(graph, (validated as RootValidatedGraph).root)\n      : (graph.deliverable.describe ?? 'Runtime runs this flow graph from its entries.')\n\n  // Every configuration fault above throws SYNCHRONOUSLY (matching `supervise()`'s own\n  // contract); only the run itself is asynchronous.\n  const start = async (): Promise<GraphResult> => {\n    const superviseOptions = {\n      // The backend also drives seat-bearing flow nodes, which use the managed driver lifecycle.\n      // A flow's root keeps Runtime's deterministic brain; deriving its child driver adds no root\n      // inference. Rooted graphs keep driverBackend explicit rather than inheriting backend.\n      ...forwardedSuperviseOptions(opts),\n      rootDriverFromBackend: flow !== undefined,\n      // Graph-owned values come after the spread: the graph, not the caller, decides these.\n      budget: graph.budget,\n      deliverable: graph.deliverable,\n      authorizeSpawn: overlay.authorizeSpawn,\n      resolveSpawnProfile: overlay.resolveSpawnProfile,\n      inheritSpawnRights: false,\n      ...(opts.makeLeafAgent ? { makeLeafAgent: opts.makeLeafAgent } : {}),\n      journal,\n      blobs,\n      runId,\n      hooks,\n      onCoordinationEvent: async (\n        context: { readonly depth: number },\n        _eventId: unknown,\n        record: { readonly event: Parameters<typeof overlay.onCoordinationEvent>[0] },\n      ) => {\n        // A route event belongs to the flow of the manager that published it: a flow inside a\n        // maps item or a run_graph subtask ledgers and concludes its own.\n        if (record.event.type === 'route' && context.depth !== 0) return\n        overlay.onCoordinationEvent(record.event)\n        flow?.observe(record.event)\n      },\n      // Lens routes resolve against the registry; agent routes carry their own analyst profile,\n      // so a graph whose only analysts are nodes needs no registry at all.\n      ...(overlay.routes.length > 0\n        ? {\n            analyzeOnSettle: overlay.routes,\n            ...(opts.analysts ? { analysts: opts.analysts } : {}),\n          }\n        : {}),\n      ...(overlay.maps.length > 0 ? { mapOnSettle: overlay.maps } : {}),\n      ...(Object.keys(overlay.continuityByProfile).length > 0\n        ? { continuityByProfile: overlay.continuityByProfile }\n        : {}),\n      // A flow root's wake batches nothing for a decision, so it ends its turn on the first event.\n      ...(flow === undefined\n        ? {}\n        : {\n            routeFlow: routeFlowOf(validated),\n            ...(opts.decideGate && {\n              decideGate: journaledGateDecider(opts.decideGate, journal, runId),\n            }),\n            finalizer: flow.finalizer,\n            wake: { debounceMs: 0, ...opts.wake },\n          }),\n      authorizeMessage,\n    } satisfies SuperviseOptions\n    // The flow root reaches supervise through the same brain seam a caller brain takes.\n    const supervised =\n      rootBrain === undefined\n        ? await supervise(rootProfile, task, superviseOptions)\n        : await superviseWithTestBrain(rootProfile, task, { ...superviseOptions, brain: rootBrain })\n\n    const { ledger, exhaustedEdges, exhaustedDelegates } = await overlay.settle()\n    const concluded = flow?.conclude(supervised)\n    if (concluded?.kind === 'unrouted') {\n      throw new GraphRouteError(concluded.unrouted, ledger, supervised)\n    }\n    const result = concluded?.result ?? supervised\n    const stopped = concluded?.stopped\n    // A LIFECYCLE ending (caller abort, exhausted budget, deadline) is its own complete explanation: the\n    // cap did not end that run even when it was exhausted along the way, and blaming it would\n    // misattribute the ending (and turn a caller-initiated abort into a throw). The exhaustion\n    // stays observable in `exhaustedEdges` either way.\n    const lifecycleEnded =\n      result.kind === 'no-winner' &&\n      (result.reason === 'aborted' ||\n        result.reason === 'cancelled' ||\n        result.reason === 'budget-exhausted' ||\n        result.reason === 'deadline')\n    if (result.kind !== 'winner' && !lifecycleEnded && exhaustedDelegates.length > 0) {\n      // Fail LOUD: the backstop, not the task, ended this run. The evidence rides on the error.\n      // Only DELEGATES caps refuse spawns, so only they can be the cause named here.\n      throw new GraphEdgeCapError(exhaustedDelegates, ledger, result)\n    }\n    return { result, ledger, exhaustedEdges, runId, ...(stopped ? { stopped } : {}) }\n  }\n\n  return start()\n}\n\n/** The root task: the graph's own framing. The deliverable (mandatory) is the termination; the\n *  task names what the topology exists to produce. */\nfunction graphTask(graph: AgentGraph, root: GraphNode): string {\n  const describe = graph.deliverable.describe\n  return (\n    describe ?? `Deliver the graph's deliverable by driving your worker nodes (root: '${root.id}').`\n  )\n}\n"],"mappings":"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"}