@tangle-network/agent-runtime 0.266.0 → 0.271.0

package/dist/testing.d.ts

@@ -1,5 +1,5 @@
-import { $a as SuperviseTestOptions, Ao as supervisorAgentWithTestBrain, Tn as driverAgent, Zt as RunGraphTestOptions, tn as runGraphWithTestBrain, to as superviseWithTestBrain, wn as DriverAgentOptions, xo as SupervisorAgentTestDeps } from "./index-CU2mlMfc.js";
-import { Hn as ToolLoopChat, Vn as ToolLoopCallContext } from "./stream-agent-turn-Gw9hLpBn.js";
+import { $t as RunGraphTestOptions, Co as SupervisorAgentTestDeps, Dn as driverAgent, En as DriverAgentOptions, Mo as supervisorAgentWithTestBrain, rn as runGraphWithTestBrain, ro as superviseWithTestBrain, to as SuperviseTestOptions } from "./index-CL1dduJd.js";
+import { Hn as ToolLoopChat, Vn as ToolLoopCallContext } from "./stream-agent-turn-DbEsKgb_.js";
 import { AgentImprovementProposal, AgentProfile, AgentProfileImprovementMeasuredComparison, SandboxSizePreset } from "@tangle-network/agent-interface";
 //#region src/testing/index.d.ts
 /** A proposal produced by Runtime's opaque profile-improvement path. */

package/dist/testing.js

@@ -1,14 +1,14 @@
 import { C as canonicalCandidateDigest$1, D as immutableCandidateValue } from "./workspace-archive-C9lgf77y.js";
-import { f as verifyAgentImprovementProposal } from "./improvement-cycle-GRPoHLm1.js";
+import { f as verifyAgentImprovementProposal } from "./improvement-cycle-1IyRJo5h.js";
 import { i as applyExactAgentProfileDiff, p as parseExactAgentProfile } from "./profile-D3eXNBQV.js";
-import { r as driverAgent } from "./coordination-driver-DdZ-nh_4.js";
-import { a as superviseWithTestBrain, h as supervisorAgentWithTestBrain } from "./supervise--njTtSL3.js";
-import { i as runGraphWithTestBrain } from "./graph-CK50N9vG.js";
-import { SANDBOX_SIZE_PRESET_NAMES } from "@tangle-network/agent-interface";
+import { r as driverAgent } from "./coordination-driver-iBGMKDvB.js";
+import { a as superviseWithTestBrain, h as supervisorAgentWithTestBrain } from "./supervise-DJ_1i9vj.js";
+import { i as runGraphWithTestBrain } from "./graph-DnMcepkN.js";
+import { SANDBOX_SIZE_PRESET_NAMES, canonicalAgentProfileDigest } from "@tangle-network/agent-interface";
 //#region src/testing/fixtures/agent-improvement-proposal.json
 var agent_improvement_proposal_default = {
 	changedSurfaces: ["prompt"],
-	digest: "sha256:b4ce9950c510d96ecccbb6b3134cca32fe0dcf821aef326e0b34010471dc5fc1",
+	digest: "sha256:413fe1dbf8ef096c3466ce18d419991ee6cedc8a52db4ffe2bd0dec92cea08a9",
 	evaluation: {
 		"decision": {
 			"contributingChecks": [
@@ -4579,7 +4579,7 @@ var agent_improvement_proposal_default = {
 		],
 		"metadata": {
 			"fixture": "agent-improvement-proposal",
-			"runtimeVersion": "0.266.0"
+			"runtimeVersion": "0.271.0"
 		},
 		"objectives": [
 			{
@@ -4690,8 +4690,8 @@ var agent_improvement_proposal_default = {
 			"baselineContentHash": "sha256:5c21ee53e513fc604cb09754e21c392b24a424da0ef37dbf8f1ee4a8a0b08f09",
 			"candidateContentHash": "sha256:60fcbb1c728194bd51d7d19cb732d1c3f1881dce7e0a6266b41c8b98cfd65693",
 			"kind": "agent-eval-loop",
-			"recordDigest": "sha256:38b07934c181f4f92d397194fd50a1ddf303fe599d53feccced96ee75e3f0299",
-			"runId": "agent-runtime-0.266.0-proposal-fixture",
+			"recordDigest": "sha256:af7f71837ca1fe6a313b9148c03c2a7b392bd78850a1f50b3cff812bb6c38edf",
+			"runId": "agent-runtime-0.271.0-proposal-fixture",
 			"schema": "agent-candidate-experiment"
 		}
 	},
@@ -4714,13 +4714,13 @@ var agent_improvement_proposal_default = {
 	}],
 	kind: "agent-improvement-proposal",
 	proposedAt: "2026-07-10T01:00:00.000Z",
-	runId: "agent-runtime-0.266.0-proposal-fixture"
+	runId: "agent-runtime-0.271.0-proposal-fixture"
 };
 //#endregion
 //#region src/testing/fixtures/agent-profile-improvement-proposal.json
 var agent_profile_improvement_proposal_default = {
 	changedSurfaces: ["prompt", "skills"],
-	digest: "sha256:6320cd1100f5e0b06dd69176b4aa65ca738ab573b79edef05673db16357a4547",
+	digest: "sha256:3b05c402ea2f3e11b27026a375a54dde3d992f741c3821c35cae65e342993dfd",
 	evaluation: {
 		"decision": {
 			"contributingChecks": [
@@ -6354,7 +6354,7 @@ var agent_profile_improvement_proposal_default = {
 		],
 		"metadata": {
 			"fixture": "agent-profile-improvement-proposal",
-			"runtimeVersion": "0.266.0"
+			"runtimeVersion": "0.271.0"
 		},
 		"objectives": [
 			{
@@ -6465,7 +6465,7 @@ var agent_profile_improvement_proposal_default = {
 			"baselineContentHash": "sha256:21c495a37c418c10bde64fbaa188beddeed31f1f051ea60a6a6582a9ee0db704",
 			"candidateContentHash": "sha256:103f77bc8481601eef1ad5fe6ba84a40dffabc3a44f421f8c8559121edab84e9",
 			"kind": "agent-eval-loop",
-			"recordDigest": "sha256:76a0368ba73c6f3e5e4c18daab0019ef6b95e634fcffc4601d2436c4c8471db6",
+			"recordDigest": "sha256:8c5ca0d396134ff0e55451baf5a0c439375ac64a7533526723a42d4fe5fc7b81",
 			"runId": "profile-improvement-1",
 			"schema": "agent-profile-improvement-experiment"
 		}
@@ -6521,7 +6521,7 @@ function loadAgentProfileImprovementFixture() {
 	const baselineStateDigest = profileStateDigest(state.baselineProfile, state.recommendedSize);
 	const candidateStateDigest = profileStateDigest(state.candidateProfile, state.recommendedSize);
 	if (baselineStateDigest !== experiment.baseline.stateDigest || candidateStateDigest !== experiment.candidate.stateDigest) throw new Error("profile improvement fixture state does not match its proposal");
-	if (canonicalCandidateDigest$1(experiment.change.reduce((profile, change, index) => applyExactAgentProfileDiff(profile, change, `profile improvement fixture change ${index}`), state.baselineProfile)) !== canonicalCandidateDigest$1(state.candidateProfile)) throw new Error("profile improvement fixture candidate does not match its proposal changes");
+	if (canonicalAgentProfileDigest(experiment.change.reduce((profile, change, index) => applyExactAgentProfileDiff(profile, change, `profile improvement fixture change ${index}`), state.baselineProfile)) !== canonicalAgentProfileDigest(state.candidateProfile)) throw new Error("profile improvement fixture candidate does not match its proposal changes");
 	return immutableCandidateValue({
 		proposal,
 		...state

package/dist/testing.js.map

@@ -1 +1 @@
-{"version":3,"file":"testing.js","names":["canonicalAgentImprovementProposalFixture","canonicalAgentProfileImprovementProposalFixture","canonicalAgentProfileImprovementStateFixture","canonicalCandidateDigest"],"sources":["../src/testing/fixtures/agent-improvement-proposal.json","../src/testing/fixtures/agent-profile-improvement-proposal.json","../src/testing/fixtures/agent-profile-improvement-state.json","../src/testing/index.ts"],"sourcesContent":["","","","import {\n  type AgentImprovementProposal,\n  type AgentProfile,\n  type AgentProfileImprovementMeasuredComparison,\n  SANDBOX_SIZE_PRESET_NAMES,\n  type SandboxSizePreset,\n} from '@tangle-network/agent-interface'\n\nimport { canonicalCandidateDigest, immutableCandidateValue } from '../candidate-execution/digest'\nimport { applyExactAgentProfileDiff, parseExactAgentProfile } from '../candidate-execution/profile'\nimport { verifyAgentImprovementProposal } from '../intelligence/improvement-cycle'\nimport canonicalAgentImprovementProposalFixture from './fixtures/agent-improvement-proposal.json'\nimport canonicalAgentProfileImprovementProposalFixture from './fixtures/agent-profile-improvement-proposal.json'\nimport canonicalAgentProfileImprovementStateFixture from './fixtures/agent-profile-improvement-state.json'\n\nexport {\n  type DriverAgentOptions,\n  driverAgent,\n} from '../runtime/supervise/coordination-driver'\nexport {\n  type RunGraphTestOptions,\n  runGraphWithTestBrain,\n} from '../runtime/supervise/graph'\nexport {\n  type SuperviseTestOptions,\n  superviseWithTestBrain,\n} from '../runtime/supervise/supervise'\nexport {\n  type SupervisorAgentTestDeps,\n  supervisorAgentWithTestBrain,\n} from '../runtime/supervise/supervisor-agent'\nexport type { ToolLoopCallContext, ToolLoopChat } from '../runtime/tool-loop'\n\nconst serializedAgentImprovementProposalFixture = JSON.stringify(\n  canonicalAgentImprovementProposalFixture,\n)\nconst serializedAgentProfileImprovementProposalFixture = JSON.stringify(\n  canonicalAgentProfileImprovementProposalFixture,\n)\nconst serializedAgentProfileImprovementStateFixture = JSON.stringify(\n  canonicalAgentProfileImprovementStateFixture,\n)\n\n/** A proposal produced by Runtime's opaque profile-improvement path. */\nexport type AgentProfileImprovementProposalFixture = Omit<\n  AgentImprovementProposal,\n  'evaluation'\n> & {\n  evaluation: AgentProfileImprovementMeasuredComparison\n}\n\n/** Complete private state for exercising profile activation and restore in consumer tests. */\nexport interface AgentProfileImprovementFixture {\n  proposal: AgentProfileImprovementProposalFixture\n  baselineProfile: AgentProfile\n  candidateProfile: AgentProfile\n  recommendedSize: SandboxSizePreset\n}\n\n/** Load an isolated, production-validated Runtime proposal for consumer tests. */\nexport function loadAgentImprovementProposalFixture(): AgentImprovementProposal {\n  return verifyAgentImprovementProposal(JSON.parse(serializedAgentImprovementProposalFixture))\n}\n\n/** Load an isolated profile proposal and its private activation state for consumer tests. */\nexport function loadAgentProfileImprovementFixture(): AgentProfileImprovementFixture {\n  const proposal = loadAgentProfileImprovementProposal()\n  const state = parseAgentProfileImprovementState(\n    JSON.parse(serializedAgentProfileImprovementStateFixture),\n  )\n  const experiment = proposal.evaluation.experiment\n  const baselineStateDigest = profileStateDigest(state.baselineProfile, state.recommendedSize)\n  const candidateStateDigest = profileStateDigest(state.candidateProfile, state.recommendedSize)\n  if (\n    baselineStateDigest !== experiment.baseline.stateDigest ||\n    candidateStateDigest !== experiment.candidate.stateDigest\n  ) {\n    throw new Error('profile improvement fixture state does not match its proposal')\n  }\n  const appliedCandidate = experiment.change.reduce(\n    (profile, change, index) =>\n      applyExactAgentProfileDiff(profile, change, `profile improvement fixture change ${index}`),\n    state.baselineProfile,\n  )\n  if (\n    canonicalCandidateDigest(appliedCandidate) !== canonicalCandidateDigest(state.candidateProfile)\n  ) {\n    throw new Error('profile improvement fixture candidate does not match its proposal changes')\n  }\n  return immutableCandidateValue({ proposal, ...state })\n}\n\nfunction loadAgentProfileImprovementProposal(): AgentProfileImprovementProposalFixture {\n  const proposal = verifyAgentImprovementProposal(\n    JSON.parse(serializedAgentProfileImprovementProposalFixture),\n  )\n  if (proposal.evaluation.kind !== 'agent-profile-improvement-measured-comparison') {\n    throw new Error('profile improvement fixture contains a sealed candidate comparison')\n  }\n  return { ...proposal, evaluation: proposal.evaluation }\n}\n\nfunction parseAgentProfileImprovementState(\n  input: unknown,\n): Omit<AgentProfileImprovementFixture, 'proposal'> {\n  if (typeof input !== 'object' || input === null || Array.isArray(input)) {\n    throw new Error('profile improvement fixture state must be an object')\n  }\n  const record = input as Record<string, unknown>\n  const fields = Object.keys(record).sort()\n  const expectedFields = ['baselineProfile', 'candidateProfile', 'recommendedSize']\n  if (\n    fields.length !== expectedFields.length ||\n    fields.some((field, i) => field !== expectedFields[i])\n  ) {\n    throw new Error('profile improvement fixture state contains unsupported fields')\n  }\n  const recommendedSize = SANDBOX_SIZE_PRESET_NAMES.find((size) => size === record.recommendedSize)\n  if (!recommendedSize) {\n    throw new Error('profile improvement fixture has an invalid recommended size')\n  }\n  return {\n    baselineProfile: parseExactAgentProfile(\n      record.baselineProfile,\n      'profile improvement fixture baseline',\n    ),\n    candidateProfile: parseExactAgentProfile(\n      record.candidateProfile,\n      'profile improvement fixture candidate',\n    ),\n    recommendedSize,\n  }\n}\n\nfunction profileStateDigest(\n  profile: AgentProfile,\n  recommendedSize: SandboxSizePreset,\n): ReturnType<typeof canonicalCandidateDigest> {\n  return canonicalCandidateDigest({ definition: profile, recommendedSize })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AGiCA,MAAM,4CAA4C,KAAK,UACrDA,kCACF;AACA,MAAM,mDAAmD,KAAK,UAC5DC,0CACF;AACA,MAAM,gDAAgD,KAAK,UACzDC,uCACF;;AAmBA,SAAgB,sCAAgE;CAC9E,OAAO,+BAA+B,KAAK,MAAM,yCAAyC,CAAC;AAC7F;;AAGA,SAAgB,qCAAqE;CACnF,MAAM,WAAW,oCAAoC;CACrD,MAAM,QAAQ,kCACZ,KAAK,MAAM,6CAA6C,CAC1D;CACA,MAAM,aAAa,SAAS,WAAW;CACvC,MAAM,sBAAsB,mBAAmB,MAAM,iBAAiB,MAAM,eAAe;CAC3F,MAAM,uBAAuB,mBAAmB,MAAM,kBAAkB,MAAM,eAAe;CAC7F,IACE,wBAAwB,WAAW,SAAS,eAC5C,yBAAyB,WAAW,UAAU,aAE9C,MAAM,IAAI,MAAM,+DAA+D;CAOjF,IACEC,2BANuB,WAAW,OAAO,QACxC,SAAS,QAAQ,UAChB,2BAA2B,SAAS,QAAQ,sCAAsC,OAAO,GAC3F,MAAM,eAGkC,CAAC,MAAMA,2BAAyB,MAAM,gBAAgB,GAE9F,MAAM,IAAI,MAAM,2EAA2E;CAE7F,OAAO,wBAAwB;EAAE;EAAU,GAAG;CAAM,CAAC;AACvD;AAEA,SAAS,sCAA8E;CACrF,MAAM,WAAW,+BACf,KAAK,MAAM,gDAAgD,CAC7D;CACA,IAAI,SAAS,WAAW,SAAS,iDAC/B,MAAM,IAAI,MAAM,oEAAoE;CAEtF,OAAO;EAAE,GAAG;EAAU,YAAY,SAAS;CAAW;AACxD;AAEA,SAAS,kCACP,OACkD;CAClD,IAAI,OAAO,UAAU,YAAY,UAAU,QAAQ,MAAM,QAAQ,KAAK,GACpE,MAAM,IAAI,MAAM,qDAAqD;CAEvE,MAAM,SAAS;CACf,MAAM,SAAS,OAAO,KAAK,MAAM,CAAC,CAAC,KAAK;CACxC,MAAM,iBAAiB;EAAC;EAAmB;EAAoB;CAAiB;CAChF,IACE,OAAO,WAAW,eAAe,UACjC,OAAO,MAAM,OAAO,MAAM,UAAU,eAAe,EAAE,GAErD,MAAM,IAAI,MAAM,+DAA+D;CAEjF,MAAM,kBAAkB,0BAA0B,MAAM,SAAS,SAAS,OAAO,eAAe;CAChG,IAAI,CAAC,iBACH,MAAM,IAAI,MAAM,6DAA6D;CAE/E,OAAO;EACL,iBAAiB,uBACf,OAAO,iBACP,sCACF;EACA,kBAAkB,uBAChB,OAAO,kBACP,uCACF;EACA;CACF;AACF;AAEA,SAAS,mBACP,SACA,iBAC6C;CAC7C,OAAOA,2BAAyB;EAAE,YAAY;EAAS;CAAgB,CAAC;AAC1E"}
+{"version":3,"file":"testing.js","names":["canonicalAgentImprovementProposalFixture","canonicalAgentProfileImprovementProposalFixture","canonicalAgentProfileImprovementStateFixture","canonicalCandidateDigest"],"sources":["../src/testing/fixtures/agent-improvement-proposal.json","../src/testing/fixtures/agent-profile-improvement-proposal.json","../src/testing/fixtures/agent-profile-improvement-state.json","../src/testing/index.ts"],"sourcesContent":["","","","import {\n  type AgentImprovementProposal,\n  type AgentProfile,\n  type AgentProfileImprovementMeasuredComparison,\n  canonicalAgentProfileDigest,\n  SANDBOX_SIZE_PRESET_NAMES,\n  type SandboxSizePreset,\n} from '@tangle-network/agent-interface'\n\nimport { canonicalCandidateDigest, immutableCandidateValue } from '../candidate-execution/digest'\nimport { applyExactAgentProfileDiff, parseExactAgentProfile } from '../candidate-execution/profile'\nimport { verifyAgentImprovementProposal } from '../intelligence/improvement-cycle'\nimport canonicalAgentImprovementProposalFixture from './fixtures/agent-improvement-proposal.json'\nimport canonicalAgentProfileImprovementProposalFixture from './fixtures/agent-profile-improvement-proposal.json'\nimport canonicalAgentProfileImprovementStateFixture from './fixtures/agent-profile-improvement-state.json'\n\nexport {\n  type DriverAgentOptions,\n  driverAgent,\n} from '../runtime/supervise/coordination-driver'\nexport {\n  type RunGraphTestOptions,\n  runGraphWithTestBrain,\n} from '../runtime/supervise/graph'\nexport {\n  type SuperviseTestOptions,\n  superviseWithTestBrain,\n} from '../runtime/supervise/supervise'\nexport {\n  type SupervisorAgentTestDeps,\n  supervisorAgentWithTestBrain,\n} from '../runtime/supervise/supervisor-agent'\nexport type { ToolLoopCallContext, ToolLoopChat } from '../runtime/tool-loop'\n\nconst serializedAgentImprovementProposalFixture = JSON.stringify(\n  canonicalAgentImprovementProposalFixture,\n)\nconst serializedAgentProfileImprovementProposalFixture = JSON.stringify(\n  canonicalAgentProfileImprovementProposalFixture,\n)\nconst serializedAgentProfileImprovementStateFixture = JSON.stringify(\n  canonicalAgentProfileImprovementStateFixture,\n)\n\n/** A proposal produced by Runtime's opaque profile-improvement path. */\nexport type AgentProfileImprovementProposalFixture = Omit<\n  AgentImprovementProposal,\n  'evaluation'\n> & {\n  evaluation: AgentProfileImprovementMeasuredComparison\n}\n\n/** Complete private state for exercising profile activation and restore in consumer tests. */\nexport interface AgentProfileImprovementFixture {\n  proposal: AgentProfileImprovementProposalFixture\n  baselineProfile: AgentProfile\n  candidateProfile: AgentProfile\n  recommendedSize: SandboxSizePreset\n}\n\n/** Load an isolated, production-validated Runtime proposal for consumer tests. */\nexport function loadAgentImprovementProposalFixture(): AgentImprovementProposal {\n  return verifyAgentImprovementProposal(JSON.parse(serializedAgentImprovementProposalFixture))\n}\n\n/** Load an isolated profile proposal and its private activation state for consumer tests. */\nexport function loadAgentProfileImprovementFixture(): AgentProfileImprovementFixture {\n  const proposal = loadAgentProfileImprovementProposal()\n  const state = parseAgentProfileImprovementState(\n    JSON.parse(serializedAgentProfileImprovementStateFixture),\n  )\n  const experiment = proposal.evaluation.experiment\n  const baselineStateDigest = profileStateDigest(state.baselineProfile, state.recommendedSize)\n  const candidateStateDigest = profileStateDigest(state.candidateProfile, state.recommendedSize)\n  if (\n    baselineStateDigest !== experiment.baseline.stateDigest ||\n    candidateStateDigest !== experiment.candidate.stateDigest\n  ) {\n    throw new Error('profile improvement fixture state does not match its proposal')\n  }\n  const appliedCandidate = experiment.change.reduce(\n    (profile, change, index) =>\n      applyExactAgentProfileDiff(profile, change, `profile improvement fixture change ${index}`),\n    state.baselineProfile,\n  )\n  if (\n    canonicalAgentProfileDigest(appliedCandidate) !==\n    canonicalAgentProfileDigest(state.candidateProfile)\n  ) {\n    throw new Error('profile improvement fixture candidate does not match its proposal changes')\n  }\n  return immutableCandidateValue({ proposal, ...state })\n}\n\nfunction loadAgentProfileImprovementProposal(): AgentProfileImprovementProposalFixture {\n  const proposal = verifyAgentImprovementProposal(\n    JSON.parse(serializedAgentProfileImprovementProposalFixture),\n  )\n  if (proposal.evaluation.kind !== 'agent-profile-improvement-measured-comparison') {\n    throw new Error('profile improvement fixture contains a sealed candidate comparison')\n  }\n  return { ...proposal, evaluation: proposal.evaluation }\n}\n\nfunction parseAgentProfileImprovementState(\n  input: unknown,\n): Omit<AgentProfileImprovementFixture, 'proposal'> {\n  if (typeof input !== 'object' || input === null || Array.isArray(input)) {\n    throw new Error('profile improvement fixture state must be an object')\n  }\n  const record = input as Record<string, unknown>\n  const fields = Object.keys(record).sort()\n  const expectedFields = ['baselineProfile', 'candidateProfile', 'recommendedSize']\n  if (\n    fields.length !== expectedFields.length ||\n    fields.some((field, i) => field !== expectedFields[i])\n  ) {\n    throw new Error('profile improvement fixture state contains unsupported fields')\n  }\n  const recommendedSize = SANDBOX_SIZE_PRESET_NAMES.find((size) => size === record.recommendedSize)\n  if (!recommendedSize) {\n    throw new Error('profile improvement fixture has an invalid recommended size')\n  }\n  return {\n    baselineProfile: parseExactAgentProfile(\n      record.baselineProfile,\n      'profile improvement fixture baseline',\n    ),\n    candidateProfile: parseExactAgentProfile(\n      record.candidateProfile,\n      'profile improvement fixture candidate',\n    ),\n    recommendedSize,\n  }\n}\n\nfunction profileStateDigest(\n  profile: AgentProfile,\n  recommendedSize: SandboxSizePreset,\n): ReturnType<typeof canonicalCandidateDigest> {\n  return canonicalCandidateDigest({ definition: profile, recommendedSize })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AGkCA,MAAM,4CAA4C,KAAK,UACrDA,kCACF;AACA,MAAM,mDAAmD,KAAK,UAC5DC,0CACF;AACA,MAAM,gDAAgD,KAAK,UACzDC,uCACF;;AAmBA,SAAgB,sCAAgE;CAC9E,OAAO,+BAA+B,KAAK,MAAM,yCAAyC,CAAC;AAC7F;;AAGA,SAAgB,qCAAqE;CACnF,MAAM,WAAW,oCAAoC;CACrD,MAAM,QAAQ,kCACZ,KAAK,MAAM,6CAA6C,CAC1D;CACA,MAAM,aAAa,SAAS,WAAW;CACvC,MAAM,sBAAsB,mBAAmB,MAAM,iBAAiB,MAAM,eAAe;CAC3F,MAAM,uBAAuB,mBAAmB,MAAM,kBAAkB,MAAM,eAAe;CAC7F,IACE,wBAAwB,WAAW,SAAS,eAC5C,yBAAyB,WAAW,UAAU,aAE9C,MAAM,IAAI,MAAM,+DAA+D;CAOjF,IACE,4BANuB,WAAW,OAAO,QACxC,SAAS,QAAQ,UAChB,2BAA2B,SAAS,QAAQ,sCAAsC,OAAO,GAC3F,MAAM,eAGqC,CAAC,MAC5C,4BAA4B,MAAM,gBAAgB,GAElD,MAAM,IAAI,MAAM,2EAA2E;CAE7F,OAAO,wBAAwB;EAAE;EAAU,GAAG;CAAM,CAAC;AACvD;AAEA,SAAS,sCAA8E;CACrF,MAAM,WAAW,+BACf,KAAK,MAAM,gDAAgD,CAC7D;CACA,IAAI,SAAS,WAAW,SAAS,iDAC/B,MAAM,IAAI,MAAM,oEAAoE;CAEtF,OAAO;EAAE,GAAG;EAAU,YAAY,SAAS;CAAW;AACxD;AAEA,SAAS,kCACP,OACkD;CAClD,IAAI,OAAO,UAAU,YAAY,UAAU,QAAQ,MAAM,QAAQ,KAAK,GACpE,MAAM,IAAI,MAAM,qDAAqD;CAEvE,MAAM,SAAS;CACf,MAAM,SAAS,OAAO,KAAK,MAAM,CAAC,CAAC,KAAK;CACxC,MAAM,iBAAiB;EAAC;EAAmB;EAAoB;CAAiB;CAChF,IACE,OAAO,WAAW,eAAe,UACjC,OAAO,MAAM,OAAO,MAAM,UAAU,eAAe,EAAE,GAErD,MAAM,IAAI,MAAM,+DAA+D;CAEjF,MAAM,kBAAkB,0BAA0B,MAAM,SAAS,SAAS,OAAO,eAAe;CAChG,IAAI,CAAC,iBACH,MAAM,IAAI,MAAM,6DAA6D;CAE/E,OAAO;EACL,iBAAiB,uBACf,OAAO,iBACP,sCACF;EACA,kBAAkB,uBAChB,OAAO,kBACP,uCACF;EACA;CACF;AACF;AAEA,SAAS,mBACP,SACA,iBAC6C;CAC7C,OAAOC,2BAAyB;EAAE,YAAY;EAAS;CAAgB,CAAC;AAC1E"}

package/dist/{tool-server-x9NEhvHZ.js → tool-server-Dqer2M4_.js}

@@ -4,7 +4,9 @@ import { createInterface } from "node:readline";
 /**
 * `createStdioToolServer` — the generic newline-delimited JSON-RPC 2.0 MCP
 * server core: `initialize` / `notifications/initialized` / `tools/list` /
-* `tools/call` over a stdio-shaped transport, protocol 2024-11-05.
+* `ping` / `tools/call` over a stdio-shaped transport. It answers the
+* client's protocol version when listed in `SUPPORTED_PROTOCOL_VERSIONS`,
+* else 2024-11-05, and publishes tool annotations when a tool declares them.
 *
 * Extracted from `createMcpServer` (server.ts) so every in-repo MCP server —
 * the delegation server, the memory server — serves the ONE wire protocol the
@@ -15,6 +17,17 @@ import { createInterface } from "node:readline";
 * @experimental
 */
 const PROTOCOL_VERSION = "2024-11-05";
+/**
+* Protocol versions this server speaks, newest first. `initialize` answers with
+* the client's requested version when it is listed here, and otherwise with
+* `PROTOCOL_VERSION` (2024-11-05), which every client that speaks 2024-11-05 accepts.
+*/
+const SUPPORTED_PROTOCOL_VERSIONS = [
+	"2025-11-25",
+	"2025-06-18",
+	"2025-03-26",
+	PROTOCOL_VERSION
+];
 /** Build the generic stdio JSON-RPC tool server. */
 function createStdioToolServer(options) {
 	const tools = /* @__PURE__ */ new Map();
@@ -26,19 +39,24 @@ function createStdioToolServer(options) {
 	let activeReadline;
 	async function handle(message) {
 		if (stopped) return rpcError(message.id ?? null, -32099, "server stopped");
-		if (message.method === "initialize") return rpcResult(message.id ?? null, {
-			protocolVersion: PROTOCOL_VERSION,
-			capabilities: { tools: {} },
-			serverInfo: {
-				name: options.serverName,
-				version: options.serverVersion
-			}
-		});
+		if (message.method === "initialize") {
+			const requested = message.params?.protocolVersion;
+			return rpcResult(message.id ?? null, {
+				protocolVersion: typeof requested === "string" && SUPPORTED_PROTOCOL_VERSIONS.includes(requested) ? requested : PROTOCOL_VERSION,
+				capabilities: { tools: {} },
+				serverInfo: {
+					name: options.serverName,
+					version: options.serverVersion
+				}
+			});
+		}
 		if (message.method === "notifications/initialized") return null;
+		if (message.method === "ping") return rpcResult(message.id ?? null, {});
 		if (message.method === "tools/list") return rpcResult(message.id ?? null, { tools: [...tools.values()].map((tool) => ({
 			name: tool.name,
 			description: tool.description,
-			inputSchema: tool.inputSchema
+			inputSchema: tool.inputSchema,
+			...tool.annotations ? { annotations: tool.annotations } : {}
 		})) });
 		if (message.method === "tools/call") {
 			const params = message.params ?? {};
@@ -149,6 +167,6 @@ function writeResponse(output, response) {
 	output.write(`${JSON.stringify(response)}\n`);
 }
 //#endregion
-export { createStdioToolServer as n, PROTOCOL_VERSION as t };
+export { SUPPORTED_PROTOCOL_VERSIONS as n, createStdioToolServer as r, PROTOCOL_VERSION as t };
 
-//# sourceMappingURL=tool-server-x9NEhvHZ.js.map
+//# sourceMappingURL=tool-server-Dqer2M4_.js.map

package/dist/tool-server-Dqer2M4_.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-server-Dqer2M4_.js","names":[],"sources":["../src/mcp/tool-server.ts"],"sourcesContent":["/**\n * `createStdioToolServer` — the generic newline-delimited JSON-RPC 2.0 MCP\n * server core: `initialize` / `notifications/initialized` / `tools/list` /\n * `ping` / `tools/call` over a stdio-shaped transport. It answers the\n * client's protocol version when listed in `SUPPORTED_PROTOCOL_VERSIONS`,\n * else 2024-11-05, and publishes tool annotations when a tool declares them.\n *\n * Extracted from `createMcpServer` (server.ts) so every in-repo MCP server —\n * the delegation server, the memory server — serves the ONE wire protocol the\n * same-host client (`connectStdioMcp`, runtime/stdio-mcp-client.ts) speaks.\n * A second hand-rolled serve loop could drift from what the client expects;\n * this core makes that impossible by construction.\n *\n * @experimental\n */\n\nimport { createInterface, type Interface as ReadlineInterface } from 'node:readline'\nimport { ValidationError } from '../errors'\nimport type { JsonRpcMessage, JsonRpcResponse, McpToolDescriptor, McpTransport } from './protocol'\n\nexport type {\n  JsonRpcMessage,\n  JsonRpcResponse,\n  McpToolAnnotations,\n  McpToolDescriptor,\n  McpTransport,\n} from './protocol'\n\nexport const PROTOCOL_VERSION = '2024-11-05'\n\n/**\n * Protocol versions this server speaks, newest first. `initialize` answers with\n * the client's requested version when it is listed here, and otherwise with\n * `PROTOCOL_VERSION` (2024-11-05), which every client that speaks 2024-11-05 accepts.\n */\nexport const SUPPORTED_PROTOCOL_VERSIONS: readonly string[] = [\n  '2025-11-25',\n  '2025-06-18',\n  '2025-03-26',\n  PROTOCOL_VERSION,\n]\n\n/** @experimental */\nexport interface StdioToolServerOptions {\n  /** Server display name surfaced via `initialize`. */\n  serverName: string\n  /** Server version surfaced via `initialize`. */\n  serverVersion: string\n  /** The tools to serve. Duplicate names throw — a silent shadow would hide a tool. */\n  tools: readonly McpToolDescriptor[]\n}\n\n/** @experimental */\nexport interface StdioToolServer {\n  /** Tools currently registered, keyed by name. */\n  readonly tools: ReadonlyMap<string, McpToolDescriptor>\n  /** Handle a single parsed JSON-RPC message. Returns the response object (or `null` for notifications). */\n  handle(message: JsonRpcMessage): Promise<JsonRpcResponse | null>\n  /** Drive the server on a stdio-shaped transport until `stop()` is called. */\n  serve(transport?: McpTransport): Promise<void>\n  /** Stop a `serve` call. Subsequent requests are rejected. */\n  stop(): void\n}\n\n/** Build the generic stdio JSON-RPC tool server. */\nexport function createStdioToolServer(options: StdioToolServerOptions): StdioToolServer {\n  const tools = new Map<string, McpToolDescriptor>()\n  for (const tool of options.tools) {\n    if (tools.has(tool.name)) {\n      throw new ValidationError(`createStdioToolServer: duplicate tool name \"${tool.name}\"`)\n    }\n    tools.set(tool.name, tool)\n  }\n\n  let stopped = false\n  let activeReadline: ReadlineInterface | undefined\n\n  async function handle(message: JsonRpcMessage): Promise<JsonRpcResponse | null> {\n    if (stopped) {\n      return rpcError(message.id ?? null, -32099, 'server stopped')\n    }\n    if (message.method === 'initialize') {\n      const requested = (message.params as { protocolVersion?: unknown } | undefined)\n        ?.protocolVersion\n      return rpcResult(message.id ?? null, {\n        protocolVersion:\n          typeof requested === 'string' && SUPPORTED_PROTOCOL_VERSIONS.includes(requested)\n            ? requested\n            : PROTOCOL_VERSION,\n        capabilities: { tools: {} },\n        serverInfo: { name: options.serverName, version: options.serverVersion },\n      })\n    }\n    if (message.method === 'notifications/initialized') {\n      // MCP clients send this after the handshake; it has no id and expects\n      // no response.\n      return null\n    }\n    if (message.method === 'ping') {\n      return rpcResult(message.id ?? null, {})\n    }\n    if (message.method === 'tools/list') {\n      return rpcResult(message.id ?? null, {\n        tools: [...tools.values()].map((tool) => ({\n          name: tool.name,\n          description: tool.description,\n          inputSchema: tool.inputSchema,\n          ...(tool.annotations ? { annotations: tool.annotations } : {}),\n        })),\n      })\n    }\n    if (message.method === 'tools/call') {\n      const params = (message.params ?? {}) as { name?: unknown; arguments?: unknown }\n      const name = typeof params.name === 'string' ? params.name : ''\n      const tool = tools.get(name)\n      if (!tool) {\n        return rpcError(message.id ?? null, -32601, `unknown tool: ${name}`)\n      }\n      try {\n        const output = await tool.handler(params.arguments ?? {})\n        return rpcResult(message.id ?? null, toolCallResult(output))\n      } catch (err) {\n        const reason = err instanceof Error ? err.message : String(err)\n        const code = err instanceof TypeError || err instanceof RangeError ? -32602 : -32000\n        return rpcError(message.id ?? null, code, reason)\n      }\n    }\n    if (message.id === undefined || message.id === null) return null\n    return rpcError(message.id, -32601, `unknown method: ${message.method}`)\n  }\n\n  async function serve(transport?: McpTransport): Promise<void> {\n    const input = transport?.input ?? process.stdin\n    const output = transport?.output ?? process.stdout\n    const rl = createInterface({ input, crlfDelay: Number.POSITIVE_INFINITY })\n    activeReadline = rl\n    return new Promise<void>((resolve, reject) => {\n      rl.on('line', (line) => {\n        const trimmed = line.trim()\n        if (!trimmed) return\n        let parsed: JsonRpcMessage | undefined\n        try {\n          parsed = JSON.parse(trimmed) as JsonRpcMessage\n        } catch (err) {\n          writeResponse(output, rpcError(null, -32700, `parse error: ${(err as Error).message}`))\n          return\n        }\n        if (parsed?.jsonrpc !== '2.0' || typeof parsed.method !== 'string') {\n          writeResponse(output, rpcError(parsed?.id ?? null, -32600, 'invalid request'))\n          return\n        }\n        void handle(parsed).then((response) => {\n          if (response) writeResponse(output, response)\n        })\n      })\n      rl.on('close', () => resolve())\n      rl.on('error', (err) => reject(err))\n      if (stopped) {\n        rl.close()\n        resolve()\n      }\n    })\n  }\n\n  function stop(): void {\n    stopped = true\n    activeReadline?.close()\n    activeReadline = undefined\n  }\n\n  return { tools, handle, serve, stop }\n}\n\nfunction toolCallResult(output: unknown): {\n  content: [{ type: 'text'; text: string }]\n  structuredContent?: Record<string, unknown>\n  isError: false\n} {\n  let json: string | undefined\n  try {\n    json = JSON.stringify(output)\n  } catch (err) {\n    const reason = err instanceof Error ? `: ${err.message}` : ''\n    throw new TypeError(`MCP tool result must be JSON-serializable${reason}`, { cause: err })\n  }\n  if (json === undefined) {\n    throw new TypeError('MCP tool result must be JSON-serializable')\n  }\n\n  const serialized = JSON.parse(json) as unknown\n  // Preserve string content verbatim. MCP clients pass this text directly to the calling agent.\n  const result: {\n    content: [{ type: 'text'; text: string }]\n    structuredContent?: Record<string, unknown>\n    isError: false\n  } = {\n    content: [{ type: 'text', text: typeof serialized === 'string' ? serialized : json }],\n    isError: false,\n  }\n  if (serialized !== null && typeof serialized === 'object' && !Array.isArray(serialized)) {\n    result.structuredContent = serialized as Record<string, unknown>\n  }\n  return result\n}\n\nfunction rpcResult(id: number | string | null, result: unknown): JsonRpcResponse {\n  return { jsonrpc: '2.0', id, result }\n}\n\nfunction rpcError(\n  id: number | string | null,\n  code: number,\n  message: string,\n  data?: unknown,\n): JsonRpcResponse {\n  return {\n    jsonrpc: '2.0',\n    id,\n    error: data === undefined ? { code, message } : { code, message, data },\n  }\n}\n\nfunction writeResponse(output: NodeJS.WritableStream, response: JsonRpcResponse): void {\n  output.write(`${JSON.stringify(response)}\\n`)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AA4BA,MAAa,mBAAmB;;;;;;AAOhC,MAAa,8BAAiD;CAC5D;CACA;CACA;CACA;AACF;;AAyBA,SAAgB,sBAAsB,SAAkD;CACtF,MAAM,wBAAQ,IAAI,IAA+B;CACjD,KAAK,MAAM,QAAQ,QAAQ,OAAO;EAChC,IAAI,MAAM,IAAI,KAAK,IAAI,GACrB,MAAM,IAAI,gBAAgB,+CAA+C,KAAK,KAAK,EAAE;EAEvF,MAAM,IAAI,KAAK,MAAM,IAAI;CAC3B;CAEA,IAAI,UAAU;CACd,IAAI;CAEJ,eAAe,OAAO,SAA0D;EAC9E,IAAI,SACF,OAAO,SAAS,QAAQ,MAAM,MAAM,QAAQ,gBAAgB;EAE9D,IAAI,QAAQ,WAAW,cAAc;GACnC,MAAM,YAAa,QAAQ,QACvB;GACJ,OAAO,UAAU,QAAQ,MAAM,MAAM;IACnC,iBACE,OAAO,cAAc,YAAY,4BAA4B,SAAS,SAAS,IAC3E,YACA;IACN,cAAc,EAAE,OAAO,CAAC,EAAE;IAC1B,YAAY;KAAE,MAAM,QAAQ;KAAY,SAAS,QAAQ;IAAc;GACzE,CAAC;EACH;EACA,IAAI,QAAQ,WAAW,6BAGrB,OAAO;EAET,IAAI,QAAQ,WAAW,QACrB,OAAO,UAAU,QAAQ,MAAM,MAAM,CAAC,CAAC;EAEzC,IAAI,QAAQ,WAAW,cACrB,OAAO,UAAU,QAAQ,MAAM,MAAM,EACnC,OAAO,CAAC,GAAG,MAAM,OAAO,CAAC,CAAC,CAAC,KAAK,UAAU;GACxC,MAAM,KAAK;GACX,aAAa,KAAK;GAClB,aAAa,KAAK;GAClB,GAAI,KAAK,cAAc,EAAE,aAAa,KAAK,YAAY,IAAI,CAAC;EAC9D,EAAE,EACJ,CAAC;EAEH,IAAI,QAAQ,WAAW,cAAc;GACnC,MAAM,SAAU,QAAQ,UAAU,CAAC;GACnC,MAAM,OAAO,OAAO,OAAO,SAAS,WAAW,OAAO,OAAO;GAC7D,MAAM,OAAO,MAAM,IAAI,IAAI;GAC3B,IAAI,CAAC,MACH,OAAO,SAAS,QAAQ,MAAM,MAAM,QAAQ,iBAAiB,MAAM;GAErE,IAAI;IACF,MAAM,SAAS,MAAM,KAAK,QAAQ,OAAO,aAAa,CAAC,CAAC;IACxD,OAAO,UAAU,QAAQ,MAAM,MAAM,eAAe,MAAM,CAAC;GAC7D,SAAS,KAAK;IACZ,MAAM,SAAS,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG;IAC9D,MAAM,OAAO,eAAe,aAAa,eAAe,aAAa,SAAS;IAC9E,OAAO,SAAS,QAAQ,MAAM,MAAM,MAAM,MAAM;GAClD;EACF;EACA,IAAI,QAAQ,OAAO,KAAA,KAAa,QAAQ,OAAO,MAAM,OAAO;EAC5D,OAAO,SAAS,QAAQ,IAAI,QAAQ,mBAAmB,QAAQ,QAAQ;CACzE;CAEA,eAAe,MAAM,WAAyC;EAC5D,MAAM,QAAQ,WAAW,SAAS,QAAQ;EAC1C,MAAM,SAAS,WAAW,UAAU,QAAQ;EAC5C,MAAM,KAAK,gBAAgB;GAAE;GAAO,WAAW,OAAO;EAAkB,CAAC;EACzE,iBAAiB;EACjB,OAAO,IAAI,SAAe,SAAS,WAAW;GAC5C,GAAG,GAAG,SAAS,SAAS;IACtB,MAAM,UAAU,KAAK,KAAK;IAC1B,IAAI,CAAC,SAAS;IACd,IAAI;IACJ,IAAI;KACF,SAAS,KAAK,MAAM,OAAO;IAC7B,SAAS,KAAK;KACZ,cAAc,QAAQ,SAAS,MAAM,QAAQ,gBAAiB,IAAc,SAAS,CAAC;KACtF;IACF;IACA,IAAI,QAAQ,YAAY,SAAS,OAAO,OAAO,WAAW,UAAU;KAClE,cAAc,QAAQ,SAAS,QAAQ,MAAM,MAAM,QAAQ,iBAAiB,CAAC;KAC7E;IACF;IACA,OAAY,MAAM,CAAC,CAAC,MAAM,aAAa;KACrC,IAAI,UAAU,cAAc,QAAQ,QAAQ;IAC9C,CAAC;GACH,CAAC;GACD,GAAG,GAAG,eAAe,QAAQ,CAAC;GAC9B,GAAG,GAAG,UAAU,QAAQ,OAAO,GAAG,CAAC;GACnC,IAAI,SAAS;IACX,GAAG,MAAM;IACT,QAAQ;GACV;EACF,CAAC;CACH;CAEA,SAAS,OAAa;EACpB,UAAU;EACV,gBAAgB,MAAM;EACtB,iBAAiB,KAAA;CACnB;CAEA,OAAO;EAAE;EAAO;EAAQ;EAAO;CAAK;AACtC;AAEA,SAAS,eAAe,QAItB;CACA,IAAI;CACJ,IAAI;EACF,OAAO,KAAK,UAAU,MAAM;CAC9B,SAAS,KAAK;EACZ,MAAM,SAAS,eAAe,QAAQ,KAAK,IAAI,YAAY;EAC3D,MAAM,IAAI,UAAU,4CAA4C,UAAU,EAAE,OAAO,IAAI,CAAC;CAC1F;CACA,IAAI,SAAS,KAAA,GACX,MAAM,IAAI,UAAU,2CAA2C;CAGjE,MAAM,aAAa,KAAK,MAAM,IAAI;CAElC,MAAM,SAIF;EACF,SAAS,CAAC;GAAE,MAAM;GAAQ,MAAM,OAAO,eAAe,WAAW,aAAa;EAAK,CAAC;EACpF,SAAS;CACX;CACA,IAAI,eAAe,QAAQ,OAAO,eAAe,YAAY,CAAC,MAAM,QAAQ,UAAU,GACpF,OAAO,oBAAoB;CAE7B,OAAO;AACT;AAEA,SAAS,UAAU,IAA4B,QAAkC;CAC/E,OAAO;EAAE,SAAS;EAAO;EAAI;CAAO;AACtC;AAEA,SAAS,SACP,IACA,MACA,SACA,MACiB;CACjB,OAAO;EACL,SAAS;EACT;EACA,OAAO,SAAS,KAAA,IAAY;GAAE;GAAM;EAAQ,IAAI;GAAE;GAAM;GAAS;EAAK;CACxE;AACF;AAEA,SAAS,cAAc,QAA+B,UAAiC;CACrF,OAAO,MAAM,GAAG,KAAK,UAAU,QAAQ,EAAE,GAAG;AAC9C"}

package/dist/tui/index.d.ts

@@ -1,4 +1,4 @@
-import { Ct as ProvisionSupervisorConnection, Dt as provisionSupervisor, Et as SupervisorCleanupReceipt, Tt as ProvisionedSupervisor, wt as ProvisionSupervisorRequest } from "../index-CU2mlMfc.js";
+import { Dt as ProvisionedSupervisor, Et as ProvisionSupervisorRequest, Ot as SupervisorCleanupReceipt, Tt as ProvisionSupervisorConnection, kt as provisionSupervisor } from "../index-CL1dduJd.js";
 //#region src/tui/top-app.d.ts
 /**
  * The interactive side of the supervisor-run TUI: a keypress/mouse loop over the frames

package/dist/tui/index.js

@@ -1,3 +1,3 @@
-import { t as provisionSupervisor } from "../provision-supervisor-Bf_bPaCv.js";
+import { t as provisionSupervisor } from "../provision-supervisor-Cy8pqE95.js";
 import { a as renderTopFrameWithLayout, i as renderTopFrame, n as runTopApp, r as loadTopSnapshot, t as renderTopOnce } from "../top-app-VAOrBskv.js";
 export { loadTopSnapshot, provisionSupervisor, renderTopFrame, renderTopFrameWithLayout, renderTopOnce, runTopApp };

package/dist/{types-CrnwLVYQ.d.ts → types-Bo7z5aG5.d.ts}

@@ -2921,18 +2921,45 @@ interface OtelExportConfig {
   batchSize?: number;
   /** Flush interval ms. Default 5000. */
   flushIntervalMs?: number;
+  /**
+   * Most spans held at once, queued plus in flight. Default 2048, the OpenTelemetry batch
+   * processor's own default. A span that arrives when the queue is full is dropped and counted in
+   * {@link OtelExportStats.dropped}, so a stalled collector costs a bounded amount of memory.
+   */
+  maxQueueSize?: number;
+  /** Milliseconds one POST may take before it is abandoned and its spans count as dropped. Default 10000. */
+  timeoutMs?: number;
   /** Resource attributes stamped on every export. */
   resourceAttributes?: Record<string, string | number | boolean>;
   /** Service name. Default 'agent-runtime'. */
   serviceName?: string;
 }
 interface OtelExporter {
-  /** Export a span. */
+  /** Export a span. Never throws: a sink that cannot take the span counts it as dropped. */
   exportSpan(span: OtelSpan): void;
-  /** Force flush pending spans. */
+  /**
+   * Deliver everything queued so far. Rejects when spans were dropped since the previous `flush`,
+   * naming how many and the last error, because a caller that awaits delivery is owed the answer.
+   */
   flush(): Promise<void>;
-  /** Shutdown cleanly. */
+  /** Stop accepting spans and deliver what is queued. Never rejects. */
   shutdown(): Promise<void>;
+  /** What this sink has delivered and lost so far. */
+  stats(): OtelExportStats;
+}
+/**
+ * Delivery accounting for one exporter. `written + dropped + pending` covers every span handed to
+ * `exportSpan`, so a trace that arrives short can be told apart from a run that emitted less.
+ */
+interface OtelExportStats {
+  /** Spans the sink confirmed: a 2xx collector response, or a completed file append. */
+  written: number;
+  /** Spans lost: refused by the collector, failed in transit, over the queue bound, or unwritable. */
+  dropped: number;
+  /** Spans accepted and not yet written or dropped. */
+  pending: number;
+  /** The most recent failure, when there has been one. */
+  lastError?: string;
 }
 interface OtelSpan {
   traceId: string;
@@ -2978,7 +3005,13 @@ interface OtelAttribute {
  */
 declare function createOpenInferenceFileExporter(filePath: string): OtelExporter;
 /**
- * Create an OTEL exporter. Returns undefined when no endpoint is configured.
+ * Create an OTLP/HTTP exporter. Returns undefined when no endpoint is configured.
+ *
+ * One batch is in flight at a time; spans that arrive meanwhile wait in a queue bounded by
+ * `maxQueueSize`. Every span ends in exactly one of `written` or `dropped`: a non-2xx response, a
+ * network error, a timeout, an OTLP `partialSuccess.rejectedSpans` count and a full queue each count
+ * as drops and set `lastError`. Nothing here throws into the caller's run; `flush()` reports the
+ * loss, the same rule {@link createOpenInferenceFileExporter} follows.
  */
 declare function createOtelExporter(config?: OtelExportConfig): OtelExporter | undefined;
 /**
@@ -4029,10 +4062,14 @@ interface SpawnOpts {
    * idempotent per key: once a child spawned under a key settles `done` — in this process or in a
    * journaled prior one — spawning the same key returns that committed result (`prior.state:
    * 'completed'`) instead of paying for the work again. A key whose prior attempt settled `down`
-   * spawns fresh and says so explicitly (`prior.state: 'retried'`). A key whose prior attempt was
-   * journaled as started but never settled is refused (`'in-doubt'`): the remote execution may
-   * still exist and must be recovered before replacement. A key that is currently LIVE is refused
-   * (`'duplicate-key'`). Unkeyed spawns (the default) are position-identified and always run.
+   * spawns fresh and says so explicitly (`prior.state: 'retried'`); a resume DERIVES that same
+   * `down` for an interrupted `inline` attempt, because an in-process execution cannot outlive
+   * its process — so a worker killed mid-flight under a plain in-process executor retries under
+   * its own key instead of wedging. A key whose un-settled prior attempt may still exist
+   * elsewhere (`sandbox`/`cli`/`router` runtimes) is refused (`'in-doubt'`): the remote execution
+   * may still be running and must be recovered before replacement. A key that is currently LIVE
+   * is refused (`'duplicate-key'`). Unkeyed spawns (the default) are position-identified and
+   * always run.
    */
   readonly key?: string;
   /** The settled sibling node this spawn replaces, so a run's record names which worker took over
@@ -4149,8 +4186,9 @@ type Settled<Out> = {
   budgetViolation?: BudgetViolation;
   /** Present only when this child's provider execution was RETAINED (see
    *  `RetainedExecutionState`); absent on an ordinary down. `'pending'` on the settlement the
-   *  driver receives at the reconcile; `'released'` on the replayed settlement of a node the
-   *  release sweep closed. The driver and every replay reader see the fact the journal
+   *  driver receives at the reconcile; `'released'` or `'release-unconfirmed'` on the
+   *  replayed settlement of a node a final settlement closed. The driver and every replay
+   *  reader see the fact the journal
    *  states, so a reader never splits this population on `reason` text — which is identical
    *  on every one of these children. */
   retainedExecution?: RetainedExecutionState;
@@ -4419,8 +4457,12 @@ interface ResumedKeyState<Out = unknown> {
   /** Identity recorded when this key was first admitted. Every reuse must match it exactly. */
   readonly identity?: NodeExecutionIdentity;
   readonly state: 'completed' | 'down' | 'in-doubt';
-  /** The rehydrated settlement; absent exactly when `state` is `'in-doubt'`. */
+  /** The rehydrated settlement; absent when `state` is `'in-doubt'`, and when `'down'` was
+   * *derived* — the resume itself proved the execution dead (an `inline` runtime cannot outlive
+   * its process), so there is no settlement to rehydrate and `reason` says how it died. */
   readonly settled?: Settled<Out>;
+  /** Why a derived `'down'` state exists. Absent on every state backed by a settlement. */
+  readonly reason?: string;
 }
 interface NodeSnapshot {
   readonly id: NodeId;
@@ -4467,10 +4509,10 @@ interface NodeSnapshot {
   readonly trace?: WorkerTraceEvidence;
   /** Present once a settled node's measured spend exceeded its reservation. */
   readonly budgetViolation?: BudgetViolation;
-  /** Present on a retained child: `'pending'` while its cursor slot is open, `'released'` once
-   *  the release sweep closed it. The live view (`makeTreeView`) and the journal view
-   *  (`materializeTreeView`) state the same fact, so a settle record's `tree` answers the
-   *  retained-vs-down question without the observer journal. */
+  /** Present on a retained child: `'pending'` while its cursor slot is open, `'released'` or
+   *  `'release-unconfirmed'` once a final settlement closed it. The live view (`makeTreeView`)
+   *  and the journal view (`materializeTreeView`) state the same fact, so a settle record's
+   *  `tree` answers the retained-vs-down question without the observer journal. */
   readonly retainedExecution?: RetainedExecutionState;
   /** Why a retained child has no accepted result; see `RetainedPendingCause`. */
   readonly retainedPendingCause?: RetainedPendingCause;
@@ -4585,13 +4627,15 @@ type SpawnEvent = {
   harnessTranscript?: HarnessTranscriptEvidence;
   /** Present when the reconciled spend exceeded the reservation, on either status. */
   budgetViolation?: BudgetViolation;
-  /** Written by the release sweep in the settling process, on the same tree, after every
-   *  `environment-teardown` receipt for the node reads `destroyed: true` and the executor's
-   *  own teardown confirmed — or by `healReleasedSlots` on the next resume, when that process
-   *  died between the last `destroyed: true` receipt and this record: the same builder, `seq`
-   *  and `at`, read from the `reconciled` record, so the bytes are identical either way. A
-   *  `destroyed: false` receipt, an empty receipt set, or a `reconciled` record without
-   *  `settledSeq` leaves the slot open.
+  /** `'released'` is written by the release sweep in the settling process, on the same tree,
+   *  after every `environment-teardown` receipt for the node reads `destroyed: true` and the
+   *  executor's own teardown confirmed — or by `healReleasedSlots` on the next resume, when
+   *  that process died between the last `destroyed: true` receipt and this record: the same
+   *  builder, `seq` and `at`, read from the `reconciled` record, so the bytes are identical
+   *  either way. `'release-unconfirmed'` is written by the same builder at the end of a final
+   *  settlement for every retained node the release could not confirm: a `destroyed: false`
+   *  receipt, an empty receipt set, or a refused teardown probe. Only a crash before that point
+   *  or a `reconciled` record without `settledSeq` leaves the slot open.
    *  `spent` is this node's child-work component of the reconcile the pool committed — for
    *  a leaf the streamed floor itself, for a recursive executor its `accounting().reported`
    *  split with the remainder on its `metered` records — never the reservation ceiling.
@@ -4600,7 +4644,7 @@ type SpawnEvent = {
    *  delivery, so replay yields it at the position the driver saw it; `at` is the settlement
    *  instant, and the release instant is on the receipt immediately before it. Typed so a
    *  `'pending'` can never be journaled: the journal states that as `reconciled`. */
-  retainedExecution?: Extract<RetainedExecutionState, 'released'>;
+  retainedExecution?: Exclude<RetainedExecutionState, 'pending'>;
   retainedPendingCause?: RetainedPendingCause;
   /** The bounded account of the team this child led, when it led one. */
   subtree?: SubtreeSummary;
@@ -4622,7 +4666,7 @@ type SpawnEvent = {
   budgetViolation?: BudgetViolation;
   /** As on `settled`: a retained child that was cancelled settles `cancelled`, and the one
    *  builder writes whichever kind the settlement had. */
-  retainedExecution?: Extract<RetainedExecutionState, 'released'>;
+  retainedExecution?: Exclude<RetainedExecutionState, 'pending'>;
   retainedPendingCause?: RetainedPendingCause;
   /** The bounded account of the team this child led, when it led one. */
   subtree?: SubtreeSummary;
@@ -4729,12 +4773,14 @@ type SpawnEvent = {
    *  observed, while its cursor slot stays OPEN so a resume can recover the execution. It stands
    *  in for the `settled` record an open node cannot carry: cost readers and a restored pool
    *  charge this floor for the node instead of its declared ceiling, and a later `settled` or
-   *  `cancelled` record for the same node supersedes it. That record has three writers: a
+   *  `cancelled` record for the same node supersedes it. That record has four writers: a
    *  resumed process's recovered settlement, the release sweep's terminal record marked
-   *  `retainedExecution: 'released'`, or `healReleasedSlots` on the next resume when the
-   *  process died between the last `environment-teardown` receipt and that record. The last
-   *  two write the same bytes, because both read the settlement from THIS record: it is
-   *  literally the settlement it stands in for, minus the cursor position it cannot hold. A
+   *  `retainedExecution: 'released'`, the final settlement's record marked
+   *  `'release-unconfirmed'` for a node whose release it could not confirm, or
+   *  `healReleasedSlots` on the next resume when the process died between the last
+   *  `environment-teardown` receipt and the released record. The last three carry the same
+   *  settlement, because each reads it from THIS record or from the live child it mirrors: it
+   *  is literally the settlement it stands in for, minus the cursor position it cannot hold. A
    *  driver's own inference travels on its `metered` record as on every other path, so
    *  `reconciled + metered` is what the pool committed. Its `seq` lives outside the
    *  cursor-uniqueness namespace; `settledSeq` is the cursor seq. */
@@ -4836,8 +4882,10 @@ type SpawnEvent = {
    *  terminal `settled`/`cancelled` record with `retainedExecution: 'released'` follows on
    *  the same tree and closes the cursor slot; when the settling process dies between this
    *  receipt and that record, `healReleasedSlots` writes the same record on the next resume
-   *  from the `reconciled` record. A `destroyed: false` receipt, an empty receipt set, or an
-   *  unconfirmed teardown leaves the slot open because the environment may still exist.
+   *  from the `reconciled` record. After a `destroyed: false` receipt, an empty receipt set, or
+   *  an unconfirmed teardown, the environment may still exist: the node is journaled as
+   *  `teardown-unconfirmed`, and its slot closes with `retainedExecution:
+   *  'release-unconfirmed'` instead, because the settlement is final either way.
    *  Informational: replay, `materializeTreeView`, and cost readers skip it, and its `seq` is
    *  per node, outside the cursor-uniqueness namespace. */
   kind: 'environment-teardown';
@@ -5041,10 +5089,16 @@ interface SupervisorOpts {
    *   Sandbox fleet for 19 to 37 hours without it. It then closes each released child's cursor
    *   slot with a terminal record marked `retainedExecution: 'released'`, so `spendGaps` names
    *   it `unreported` (a floor) rather than `never-settled` (a ceiling) and
-   *   `fleetYield.releasedUnrecovered` counts it; a refused release leaves the slot open and
-   *   the node in `teardownUnconfirmed`. A process that dies between the last `destroyed: true`
-   *   receipt and that record leaves the slot open only until the next resume, whose
-   *   `healReleasedSlots` writes the identical record from the `reconciled` record.
+   *   `fleetYield.releasedUnrecovered` counts it. A release that is refused or cannot be
+   *   confirmed names the node in `teardownUnconfirmed` and its `teardown-unconfirmed` record,
+   *   and after the retry window closes its slot with `retainedExecution: 'release-unconfirmed'`,
+   *   counted by `fleetYield.releaseUnconfirmed`: the settlement is final, so the slot closes
+   *   whether or not the environment is confirmed gone. Measured 2026-09-23/24 on the Discovery
+   *   fleet (Runtime 0.249.1 to 0.261.0): 338 of 1,620 agents never settled, and 179 of the
+   *   retained ones had an admission that never named an environment. A process that dies
+   *   between the last `destroyed: true` receipt and the released record leaves the slot open
+   *   only until the next resume, whose `healReleasedSlots` writes the identical record from the
+   *   `reconciled` record.
    * - `'keep'`: a later process may resume this run, so the environments stay for its recovery.
    *
    * Default: `'keep'` when `resume` is true (a durable run a later process may continue), else
@@ -5169,13 +5223,20 @@ interface SpendGap {
  *   `destroyed: true` receipt and the record (same builder, `seq` and `at`, from the
  *   `reconciled` record). The pool's own admission fault, if the reconcile raised one, is not
  *   on this record.
+ * - `'release-unconfirmed'`: root settlement under `retainedAtSettlement: 'release'` ended with
+ *   the execution unrecovered and its environment NOT confirmed destroyed: the provider refused
+ *   the delete, the executor could not confirm it, or the admission never named an environment
+ *   (a create that timed out). The settlement is final, so no process will recover the execution
+ *   and the slot closes anyway, with the same builder, `seq` and `at` as `'released'`. What the
+ *   node may still hold stays named by its `teardown-unconfirmed` record and in
+ *   `teardownUnconfirmed`, for a sweeper.
  *
  * Absent = an ordinary child. The live `Settled` a driver branched on carried `'pending'` where
- * replay yields `'released'` for the same seq, so a resume-aware driver must not branch on the
- * two values. No `'recovered'` value exists yet: a live-adopted recovery settles on the ordinary
- * path and the recorded-result path writes no marker.
+ * replay yields `'released'` or `'release-unconfirmed'` for the same seq, so a resume-aware driver
+ * must not branch on these values. No `'recovered'` value exists yet: a live-adopted recovery
+ * settles on the ordinary path and the recorded-result path writes no marker.
  */
-type RetainedExecutionState = 'pending' | 'released';
+type RetainedExecutionState = 'pending' | 'released' | 'release-unconfirmed';
 /**
  * How this run's spawned CHILDREN ended, counted by node id off the complete journal FOREST at
  * root settlement — after the join barrier and the release sweep, so the terminal records the
@@ -5194,13 +5255,18 @@ interface FleetYield {
   /** `settled` records with `status: 'down'`, released records included. */
   readonly down: number;
   readonly cancelled: number;
-  /** Spawned with no terminal record: a crash-orphaned child, a refused release, or a retained
-   *  executor with nothing to release. Named after `SpendGap`'s `never-settled`. */
+  /** Spawned with no terminal record: a crash-orphaned child, or a retained child of a run that
+   *  keeps its environments for a resume (`retainedAtSettlement: 'keep'`). Named after
+   *  `SpendGap`'s `never-settled`. */
   readonly neverSettled: number;
   /** Terminal records marked `retainedExecution: 'released'` — a subset of `down + cancelled`.
    *  A nested manager whose OWN retained execution was released counts here beside the
    *  grandchildren it released, because its execution was destroyed unrecovered too. */
   readonly releasedUnrecovered: number;
+  /** Terminal records marked `retainedExecution: 'release-unconfirmed'` — a subset of
+   *  `down + cancelled`, disjoint from `releasedUnrecovered`: executions a final settlement left
+   *  unrecovered without confirming their environment destroyed. */
+  readonly releaseUnconfirmed: number;
 }
 /**
  * One channel on which a settled reservation's measured spend exceeded what it reserved.
@@ -5433,5 +5499,5 @@ interface WidenGate<Out> {
   readonly judgeExempt?: boolean;
 }
 //#endregion
-export { SpawnJournal as $, LoopWinner as $i, HarnessTranscriptEvidence as $n, RetainedInteractiveEnvironmentAdmission as $r, padSpanId as $t, NodeExecutionIdentity as A, OpenAIChatTool as Aa, ReserveOptions as Ai, createPushTraceSource as An, AgentEvalErrorCode as Ar, createPropagatingTraceEmitter as At, ResultBlobStore as B, LoopIterationDispatchPayload as Bi, TeamProgress as Bn, RuntimeRunStateError as Br, OtelAttribute as Bt, ExecutorToolCall as C, AgentTaskContext as Ca, ReservationFloor as Ci, timerAt as Cn, OnUnmetContract as Cr, WorkerTraceResolver as Ct, MaterializedExecutionIdentity as D, BackendErrorDetail as Da, ReservationStage as Di, SessionTraceBox as Dn, upstreamUnavailableSignal as Dr, workerTraceHeaders as Dt, HeldEnvironment as E, AgentTaskStatus as Ea, ReservationShortfall as Ei, SessionMessageLike as En, summarizeDriverAttempts as Er, workerTraceEnv as Et, ProviderModelAttemptEvidence as F, RuntimeSession as Fa, Driver as Fi, ActivityLog as Fn, PlannerError as Fr, EvalRunGeneration as Ft, RootMaterialization as G, LoopPlanPayload as Gi, RecoverRetainedInteractiveRunOptions as Gn, NativeContextContinuationExecution as Gr, buildLoopOtelSpans as Gt, ResumedWork as H, LoopIterationStartedPayload as Hi, createActivityLog as Hn, SlotPermit as Hr, OtelExporter as Ht, ProviderModelExecutionEvidence as I, RuntimeSessionStore as Ia, ExecCtx as Ii, ActivityNote as In, RetainedInteractiveAdmissionError as Ir, EvalRunsExportConfig as It, RootStreamReceipt as J, LoopStartedPayload as Ji, RetainedInteractiveRunHandle as Jn, ReconnectRetainedRunOptions as Jr, createOpenInferenceFileExporter as Jt, RootProviderModelEvidence as K, LoopResult as Ki, RetainedInteractiveAdmissionHook as Kn, NativeContextContinuationHandle as Kr, buildLoopSpanNodes as Kt, RecursiveReservationPolicy as L, RuntimeStreamEvent as La, Iteration as Li, DEFAULT_STALL_AFTER_MS as Ln, RetainedInteractiveBindingError as Lr, EvalRunsExportResult as Lt, NodeSnapshot as M, RunAgentTaskOptions as Ma, spendFromUsageEvents as Mi, sandboxSessionTraceSource as Mn, ConfigError as Mr, readTraceContextFromEnv as Mt, NodeStatus as N, RunAgentTaskStreamOptions as Na, AgentRunSpec as Ni, RetainedChildRecovery as Nn, JudgeError as Nr, traceContextToEnv as Nt, MaterializedModelIdentity as O, KnowledgeReadinessDecision as Oa, ReservationTicket as Oi, ToolStepInput as On, UnavailablePausePolicy as Or, workerTraceSeamKey as Ot, ProfileMaterializationReceipt as P, RuntimeCanonicalStreamEvent as Pa, DefaultVerdict$1 as Pi, RetainedPendingCause as Pn, NotFoundError as Pr, EvalRunEvent as Pt, SpawnEvent as Q, LoopTraceEvent as Qi, HarnessTranscriptCapture as Qn, RetainedInteractiveAdmission as Qr, loopEventToOtelSpan as Qt, ResourceLimit as R, LoopDecisionPayload as Ri, ExecutorProgress as Rn, RetainedRunAdmissionError as Rr, INTELLIGENCE_WIRE_VERSION as Rt, ExecutorTeardownWarning as S, AgentRuntimeEventSink as Sa, LeakedReservation as Si, pollFor as Sn, DriverUnmetContractDecision as Sr, WorkerTraceUnavailableReason as St, Handle as T, AgentTaskSpec as Ta, ReservationRejection as Ti, waitUntil as Tn, defaultUnmetContractSteer as Tr, readWorkerTraceContext as Tt, RetainedExecutionState as U, LoopLineageOptions as Ui, readWorkerProgress as Un, WorkerSlots as Ur, OtelSpan as Ut, ResumedKeyState as V, LoopIterationEndedPayload as Vi, WorkerProgress as Vn, ValidationError as Vr, OtelExportConfig as Vt, RootHandle as W, LoopPlanDescription as Wi, ReconnectRetainedInteractiveRunOptions as Wn, createWorkerSlots as Wr, RuntimeEventOtelOptions as Wt, Scope as X, LoopTokenUsage as Xi, StartRetainedInteractiveRunOptions as Xn, RecoverRetainedRunOptions as Xr, exportEvalRuns as Xt, Runtime as Y, LoopTeardownFailedPayload as Yi, RetainedInteractiveStartMaterial as Yn, RecoverRetainedRunIntentOptions as Yr, createOtelExporter as Yt, Settled as Z, LoopTraceEmitter as Zi, HarnessTranscriptArtifact as Zn, RecoverRetainedRunResult as Zr, generateSpanId as Zt, ExecutorMaterialization as _, AgentBackendContext as _a, StartRetainedRunOptions as _i, WaitProbeRegistry as _n, DriverReentry as _r, WaitOpts as _t, BudgetOverspend as a, SelectionReceipt as aa, RetainedRunCancellation as ai, RuntimeStreamEventSummary as an, harnessTranscriptArtifact as ar, SpendGap as at, ExecutorRegistry as b, AgentKnowledgeProvider as ba, BudgetReadout as bi, createWaitProbes as bn, DriverRetryPolicy as br, WorkerInteractiveUnavailableReason as bt, EnvironmentTeardownReceipt as c, RuntimeRunCompleteInput as ca, RetainedRunEnvironmentAdmission as ci, SanitizedKnowledgeRequirement as cn, DriverAttemptRecord as cr, SubtreeSummary as ct, ExecutorAccounting as d, RuntimeRunOptions as da, RetainedRunIntentAdmission as di, sanitizeAgentRuntimeEvent as dn, DriverBudgetReadout as dr, SupervisorOpts as dt, MountManifestEntry as ea, RetainedInteractiveIntentAdmission as ei, padTraceId as en, HarnessTranscriptFile as er, SpawnOpts as et, ExecutorCancellation as f, RuntimeRunPersistenceAdapter as fa, RetainedRunReplayPoint as fi, sanitizeKnowledgeReadinessReport as fn, DriverContinuationRecord as fr, TokenUsageProvenance as ft, ExecutorFactory as g, AgentAdapter as ga, StartRetainedRunInEnvironmentOptions as gi, WaitProbe as gn, DriverProgressMark as gr, UsageEvent as gt, ExecutorExecutionBinding as h, startRuntimeRun as ha, RetainedRunTurnInput as hi, WaitOutcome as hn, DriverLoopRecord as hr, UnknownMaterializationReason as ht, Budget as i, SandboxClient as ia, RetainedRunCancelOptions as ii, RuntimeStreamEventSink as in, captureHarnessTranscript as ir, SpendChannel as it, NodeId as j, OpenAIChatToolChoice as ja, createBudgetPool as ji, decodeToolPart as jn, BackendTransportError as jr, mergeTraceEnv as jt, NoWinnerError as k, OpenAIChatResponseFormat as ka, ReservationWaitRefused as ki, TraceSource as kn, AgentEvalError$1 as kr, TraceContext as kt, ExecutionBindingReceipt as l, RuntimeRunCost as la, RetainedRunEventOptions as li, createRuntimeEventCollector as ln, DriverAttemptStop as lr, SupervisedResult as lt, ExecutorContext as m, RuntimeRunStatus as ma, RetainedRunStartMaterial as mi, PendingWait as mn, DriverFailureClass as mr, UnconfirmedTeardown as mt, AgentExecutionRef as n, OutputAdapter as na, RetainedRunAdmission as ni, RuntimeEventCollector as nn, HarnessTranscriptUnavailableReason as nr, SpawnRejection as nt, BudgetViolation as o, ValidationCtx as oa, RetainedRunDispatchedAdmission as oi, RuntimeTelemetryOptions as on, persistHarnessTranscript as or, SteerableRootHandle as ot, ExecutorCancellationRequest as p, RuntimeRunRow as pa, RetainedRunSnapshot as pi, sanitizeRuntimeStreamEvent as pn, DriverContractState as pr, TreeView as pt, RootSignal as q, LoopSandboxPlacement as qi, RetainedInteractiveEnvironmentInput as qn, NativeContextContinuationInput as qr, buildRuntimeEventOtelSpans as qt, AgentSpec as r, RunProvenance as ra, RetainedRunAdmissionHook as ri, RuntimeStreamEventCollector as rn, ReadableEnvironment as rr, Spend as rt, DefaultVerdict as s, Validator as sa, RetainedRunEffect as si, SanitizedKnowledgeReadinessReport as sn, DEFAULT_MAX_BARREN_REPROMPTS as sr, SubtreeResult as st, Agent as t, MountRecorder as ta, RetainedInteractiveStartedAdmission as ti, toOtelAttributes as tn, HarnessTranscriptUnavailable as tr, SpawnPrior as tt, Executor as u, RuntimeRunHandle as ua, RetainedRunHandle as ui, createRuntimeStreamEventCollector as un, DriverAttemptsExhaustedError as ur, Supervisor as ut, ExecutorNodeContext as v, AgentBackendInput as va, BudgetPool as vi, WaitRejection as vn, DriverRepromptPolicy as vr, WidenGate as vt, FleetYield as w, AgentTaskRunResult as wa, ReservationHolder as wi, validateWaitSpec as wn, classifyDriverFailure as wr, WorkerTraceSeamCarrier as wt, ExecutorResult as x, AgentRuntimeEvent as xa, BudgetReconcileFault as xi, isWaitOutcome as xn, DriverUnmetContractContext as xr, WorkerTraceEvidence as xt, ExecutorProgressEvent as y, AgentExecutionBackend as ya, BudgetPoolRestore as yi, WaitSpec as yn, DriverRepromptRefusal as yr, WorkerInteractiveSession as yt, ResourceSpend as z, LoopEndedPayload as zi, ScopeProgressInput as zn, RetainedRunDispatchBindingError as zr, LoopSpanNode as zt };
-//# sourceMappingURL=types-CrnwLVYQ.d.ts.map
+export { SpawnJournal as $, LoopTraceEvent as $i, HarnessTranscriptCapture as $n, RetainedInteractiveAdmission as $r, loopEventToOtelSpan as $t, NodeExecutionIdentity as A, OpenAIChatResponseFormat as Aa, ReservationWaitRefused as Ai, TraceSource as An, AgentEvalError$1 as Ar, createPropagatingTraceEmitter as At, ResultBlobStore as B, LoopEndedPayload as Bi, ScopeProgressInput as Bn, RetainedRunDispatchBindingError as Br, OtelAttribute as Bt, ExecutorToolCall as C, AgentRuntimeEventSink as Ca, LeakedReservation as Ci, pollFor as Cn, DriverUnmetContractDecision as Cr, WorkerTraceResolver as Ct, MaterializedExecutionIdentity as D, AgentTaskStatus as Da, ReservationShortfall as Di, SessionMessageLike as Dn, summarizeDriverAttempts as Dr, workerTraceHeaders as Dt, HeldEnvironment as E, AgentTaskSpec as Ea, ReservationRejection as Ei, waitUntil as En, defaultUnmetContractSteer as Er, workerTraceEnv as Et, ProviderModelAttemptEvidence as F, RuntimeCanonicalStreamEvent as Fa, DefaultVerdict$1 as Fi, RetainedPendingCause as Fn, NotFoundError as Fr, EvalRunGeneration as Ft, RootMaterialization as G, LoopPlanDescription as Gi, ReconnectRetainedInteractiveRunOptions as Gn, createWorkerSlots as Gr, RuntimeEventOtelOptions as Gt, ResumedWork as H, LoopIterationEndedPayload as Hi, WorkerProgress as Hn, ValidationError as Hr, OtelExportStats as Ht, ProviderModelExecutionEvidence as I, RuntimeSession as Ia, Driver as Ii, ActivityLog as In, PlannerError as Ir, EvalRunsExportConfig as It, RootStreamReceipt as J, LoopSandboxPlacement as Ji, RetainedInteractiveEnvironmentInput as Jn, NativeContextContinuationInput as Jr, buildRuntimeEventOtelSpans as Jt, RootProviderModelEvidence as K, LoopPlanPayload as Ki, RecoverRetainedInteractiveRunOptions as Kn, NativeContextContinuationExecution as Kr, buildLoopOtelSpans as Kt, RecursiveReservationPolicy as L, RuntimeSessionStore as La, ExecCtx as Li, ActivityNote as Ln, RetainedInteractiveAdmissionError as Lr, EvalRunsExportResult as Lt, NodeSnapshot as M, OpenAIChatToolChoice as Ma, createBudgetPool as Mi, decodeToolPart as Mn, BackendTransportError as Mr, readTraceContextFromEnv as Mt, NodeStatus as N, RunAgentTaskOptions as Na, spendFromUsageEvents as Ni, sandboxSessionTraceSource as Nn, ConfigError as Nr, traceContextToEnv as Nt, MaterializedModelIdentity as O, BackendErrorDetail as Oa, ReservationStage as Oi, SessionTraceBox as On, upstreamUnavailableSignal as Or, workerTraceSeamKey as Ot, ProfileMaterializationReceipt as P, RunAgentTaskStreamOptions as Pa, AgentRunSpec as Pi, RetainedChildRecovery as Pn, JudgeError as Pr, EvalRunEvent as Pt, SpawnEvent as Q, LoopTraceEmitter as Qi, HarnessTranscriptArtifact as Qn, RecoverRetainedRunResult as Qr, generateSpanId as Qt, ResourceLimit as R, RuntimeStreamEvent as Ra, Iteration as Ri, DEFAULT_STALL_AFTER_MS as Rn, RetainedInteractiveBindingError as Rr, INTELLIGENCE_WIRE_VERSION as Rt, ExecutorTeardownWarning as S, AgentRuntimeEvent as Sa, BudgetReconcileFault as Si, isWaitOutcome as Sn, DriverUnmetContractContext as Sr, WorkerTraceUnavailableReason as St, Handle as T, AgentTaskRunResult as Ta, ReservationHolder as Ti, validateWaitSpec as Tn, classifyDriverFailure as Tr, readWorkerTraceContext as Tt, RetainedExecutionState as U, LoopIterationStartedPayload as Ui, createActivityLog as Un, SlotPermit as Ur, OtelExporter as Ut, ResumedKeyState as V, LoopIterationDispatchPayload as Vi, TeamProgress as Vn, RuntimeRunStateError as Vr, OtelExportConfig as Vt, RootHandle as W, LoopLineageOptions as Wi, readWorkerProgress as Wn, WorkerSlots as Wr, OtelSpan as Wt, Scope as X, LoopTeardownFailedPayload as Xi, RetainedInteractiveStartMaterial as Xn, RecoverRetainedRunIntentOptions as Xr, createOtelExporter as Xt, Runtime as Y, LoopStartedPayload as Yi, RetainedInteractiveRunHandle as Yn, ReconnectRetainedRunOptions as Yr, createOpenInferenceFileExporter as Yt, Settled as Z, LoopTokenUsage as Zi, StartRetainedInteractiveRunOptions as Zn, RecoverRetainedRunOptions as Zr, exportEvalRuns as Zt, ExecutorMaterialization as _, AgentAdapter as _a, StartRetainedRunInEnvironmentOptions as _i, WaitProbe as _n, DriverProgressMark as _r, WaitOpts as _t, BudgetOverspend as a, SandboxClient as aa, RetainedRunCancelOptions as ai, RuntimeStreamEventSink as an, captureHarnessTranscript as ar, SpendGap as at, ExecutorRegistry as b, AgentExecutionBackend as ba, BudgetPoolRestore as bi, WaitSpec as bn, DriverRepromptRefusal as br, WorkerInteractiveUnavailableReason as bt, EnvironmentTeardownReceipt as c, Validator as ca, RetainedRunEffect as ci, SanitizedKnowledgeReadinessReport as cn, DEFAULT_MAX_BARREN_REPROMPTS as cr, SubtreeSummary as ct, ExecutorAccounting as d, RuntimeRunHandle as da, RetainedRunHandle as di, createRuntimeStreamEventCollector as dn, DriverAttemptsExhaustedError as dr, SupervisorOpts as dt, LoopWinner as ea, RetainedInteractiveEnvironmentAdmission as ei, padSpanId as en, HarnessTranscriptEvidence as er, SpawnOpts as et, ExecutorCancellation as f, RuntimeRunOptions as fa, RetainedRunIntentAdmission as fi, sanitizeAgentRuntimeEvent as fn, DriverBudgetReadout as fr, TokenUsageProvenance as ft, ExecutorFactory as g, startRuntimeRun as ga, RetainedRunTurnInput as gi, WaitOutcome as gn, DriverLoopRecord as gr, UsageEvent as gt, ExecutorExecutionBinding as h, RuntimeRunStatus as ha, RetainedRunStartMaterial as hi, PendingWait as hn, DriverFailureClass as hr, UnknownMaterializationReason as ht, Budget as i, RunProvenance as ia, RetainedRunAdmissionHook as ii, RuntimeStreamEventCollector as in, ReadableEnvironment as ir, SpendChannel as it, NodeId as j, OpenAIChatTool as ja, ReserveOptions as ji, createPushTraceSource as jn, AgentEvalErrorCode as jr, mergeTraceEnv as jt, NoWinnerError as k, KnowledgeReadinessDecision as ka, ReservationTicket as ki, ToolStepInput as kn, UnavailablePausePolicy as kr, TraceContext as kt, ExecutionBindingReceipt as l, RuntimeRunCompleteInput as la, RetainedRunEnvironmentAdmission as li, SanitizedKnowledgeRequirement as ln, DriverAttemptRecord as lr, SupervisedResult as lt, ExecutorContext as m, RuntimeRunRow as ma, RetainedRunSnapshot as mi, sanitizeRuntimeStreamEvent as mn, DriverContractState as mr, UnconfirmedTeardown as mt, AgentExecutionRef as n, MountRecorder as na, RetainedInteractiveStartedAdmission as ni, toOtelAttributes as nn, HarnessTranscriptUnavailable as nr, SpawnRejection as nt, BudgetViolation as o, SelectionReceipt as oa, RetainedRunCancellation as oi, RuntimeStreamEventSummary as on, harnessTranscriptArtifact as or, SteerableRootHandle as ot, ExecutorCancellationRequest as p, RuntimeRunPersistenceAdapter as pa, RetainedRunReplayPoint as pi, sanitizeKnowledgeReadinessReport as pn, DriverContinuationRecord as pr, TreeView as pt, RootSignal as q, LoopResult as qi, RetainedInteractiveAdmissionHook as qn, NativeContextContinuationHandle as qr, buildLoopSpanNodes as qt, AgentSpec as r, OutputAdapter as ra, RetainedRunAdmission as ri, RuntimeEventCollector as rn, HarnessTranscriptUnavailableReason as rr, Spend as rt, DefaultVerdict as s, ValidationCtx as sa, RetainedRunDispatchedAdmission as si, RuntimeTelemetryOptions as sn, persistHarnessTranscript as sr, SubtreeResult as st, Agent as t, MountManifestEntry as ta, RetainedInteractiveIntentAdmission as ti, padTraceId as tn, HarnessTranscriptFile as tr, SpawnPrior as tt, Executor as u, RuntimeRunCost as ua, RetainedRunEventOptions as ui, createRuntimeEventCollector as un, DriverAttemptStop as ur, Supervisor as ut, ExecutorNodeContext as v, AgentBackendContext as va, StartRetainedRunOptions as vi, WaitProbeRegistry as vn, DriverReentry as vr, WidenGate as vt, FleetYield as w, AgentTaskContext as wa, ReservationFloor as wi, timerAt as wn, OnUnmetContract as wr, WorkerTraceSeamCarrier as wt, ExecutorResult as x, AgentKnowledgeProvider as xa, BudgetReadout as xi, createWaitProbes as xn, DriverRetryPolicy as xr, WorkerTraceEvidence as xt, ExecutorProgressEvent as y, AgentBackendInput as ya, BudgetPool as yi, WaitRejection as yn, DriverRepromptPolicy as yr, WorkerInteractiveSession as yt, ResourceSpend as z, LoopDecisionPayload as zi, ExecutorProgress as zn, RetainedRunAdmissionError as zr, LoopSpanNode as zt };
+//# sourceMappingURL=types-Bo7z5aG5.d.ts.map