@tangle-network/agent-runtime 0.170.0 → 0.172.0

package/dist/{runtime-C-7uhhFs.js → runtime-ckAefgVV.js}

@@ -9,14 +9,14 @@ import { i as redactProtectedValue, r as redactProtectedReason } from "./protect
 import { c as notifySandboxEventObserver, m as parseCanonicalTransportEvent, p as extractTransportEventIdentity } from "./sandbox-events-BVjstFgb.js";
 import { n as executableAgentSpecSnapshot, t as executableAgentProfileSnapshot } from "./executable-spec-CkGvdPds.js";
 import { c as profileModelExecutionSettings, i as concreteModelId, l as profileProviderModel, o as enforceTokenLimits, t as assertExecutableAgentProfile } from "./model-policy-Sw4ywhtL.js";
-import { $ as createPushTraceSource, Et as canonicalObservedModel, G as createWorktreeCliExecutor, H as createExecutor, St as probeSandboxCapabilities, Tt as runBrainLoop, U as createExecutorRegistry, bt as runAgentRounds, f as withDriverExecutor, k as rollingDispatch, n as createSupervisor, vt as defaultSelectWinner, wt as routerBrain, xt as createSandboxLineage, y as settledToIteration } from "./supervisor-B-mmmiOU.js";
+import { $ as createPushTraceSource, Et as canonicalObservedModel, G as createWorktreeCliExecutor, H as createExecutor, St as probeSandboxCapabilities, Tt as runBrainLoop, U as createExecutorRegistry, bt as runAgentRounds, f as withDriverExecutor, k as rollingDispatch, n as createSupervisor, vt as defaultSelectWinner, wt as routerBrain, xt as createSandboxLineage, y as settledToIteration } from "./supervisor-Dw-5mGKr.js";
 import "./environment-provider-Bn3652YU.js";
 import { i as notifyRuntimeHookEvent } from "./runtime-hooks-tXpAarhW.js";
-import { C as observe, O as strategyAuthorMethod, T as profileChatClient, b as sample, v as refine, x as sampleThenRefine, y as runAgentic } from "./structural-rollout-C7nNNhri.js";
-import { At as gateOnDeliverable, jt as mapExecutorResult, n as supervise } from "./supervise-rEE46ruH.js";
-import { t as assertAuthoredCode } from "./authored-code-C2TGxNtf.js";
-import "./authoring-CUTgAxxE.js";
-import "./graph-ZDMygFIo.js";
+import { C as observe, O as strategyAuthorMethod, T as profileChatClient, b as sample, v as refine, x as sampleThenRefine, y as runAgentic } from "./structural-rollout-DjUoh2aA.js";
+import { At as gateOnDeliverable, jt as mapExecutorResult, n as supervise } from "./supervise-CnHd8x54.js";
+import { t as assertAuthoredCode } from "./authored-code-DzYtiflw.js";
+import "./authoring-c9yTIa3G.js";
+import "./graph-CtMnqYYC.js";
 import { AgentEnvironmentCapabilitiesSchema, AgentExactRunControlRefSchema, AgentInteractiveSessionControlClaimAcknowledgementSchema, AgentInteractiveSessionControlClaimSchema, AgentInteractiveSessionPromptAcknowledgementSchema, AgentInteractiveSessionRefSchema, AgentInteractiveSessionStatusSchema, AgentInteractiveSessionStopAcknowledgementSchema, AgentNativeContextContinuationResultSchema, AgentTurnResultSchema, InteractionAcknowledgementSchema, InteractionResponseCommandSchema, NativeContextBoundaryProofSchema, NativeContextContinuationRequestSchema, RuntimeEventEnvelopeSchema, TerminalReplayWindowSchema, TerminalSessionRefSchema, agentInteractiveSessionControlClaimAcknowledgementMatchesRequest, agentInteractiveSessionControlClaimMatchesRef, agentInteractiveSessionControlClaimRequestDigest, agentInteractiveSessionPromptAcknowledgementMatchesCommand, agentInteractiveSessionRefMatchesStart, agentInteractiveSessionRunRef, agentInteractiveSessionStatusMatchesRef, agentInteractiveSessionStopAcknowledgementMatchesCommand, agentNativeContextContinuationResultMatchesRequest, agentProfileSchema, canonicalAgentProfileDigest, canonicalCandidateDigest, exactAgentInteractiveSessionStart, nativeContextContinuationTurnDigest, validateAgentProfileSecurity } from "@tangle-network/agent-interface";
 import { CODING_HARNESSES, DEFAULT_TRACE_ANALYST_KINDS, InMemoryTraceStore, OUTPUT_VALUE, benjaminiHochberg, buildTrajectory, computeFindingId as computeFindingId$1, confidenceInterval, expandProfileAxes, makeFinding as makeFinding$1, pairedBootstrap, paretoFrontier, wilcoxonSignedRank, wilson } from "@tangle-network/agent-eval";
 import { heldoutSignificance, runProfileMatrix } from "@tangle-network/agent-eval/campaign";
@@ -30,6 +30,7 @@ import { createAgentRunOutcomeTracker } from "@tangle-network/sandbox/runtime";
 import { collectAgentResponseText } from "@tangle-network/sandbox";
 import { createInterface } from "node:readline";
 import { gzipSync } from "node:zlib";
+import { createContext, runInContext } from "node:vm";
 import { stuckLoopView, toolWasteView } from "@tangle-network/agent-eval/pipelines";
 //#region src/runtime/key-provider.ts
 /** The env-backed provider: reads the (dotenvx-loaded) process env. Empty /
@@ -5752,6 +5753,245 @@ function chatWorkerSeam(opts) {
 	};
 }
 //#endregion
+//#region src/runtime/supervise/code-mode.ts
+/**
+* Code mode — the pattern Cloudflare ("Code Mode") and Anthropic ("code execution with MCP")
+* define, over this runtime's coordination verbs: generate a typed API from the tools' schemas,
+* expose exactly two tools (`search`, `execute`), and run model-written code whose only intended
+* capability is the API bindings. One model turn where the tool-calling loop pays one round trip
+* per call; intermediates live in the program, not the context window.
+*
+* WHAT THIS RUNTIME OWNS AND THE SOURCES' CENTRAL PROPERTY — read this before choosing a runner.
+* The sources isolate execution in a REAL boundary: Cloudflare runs the code in a V8 isolate with
+* a separate heap; Anthropic runs it out of process. That is not a detail — it is the whole reason
+* "let the model write code" is safe. This runtime does NOT ship an isolate, so `execute`'s
+* execution boundary is a SEAM you must fill: `codeModeSupervisorTools(runner)` REQUIRES a
+* `CodeModeRunner`, and there is no default. For untrusted model output, supply a jailed runner
+* (a sub-sandbox, a worker isolate). {@link unsafeInProcessRunner} is provided for TRUSTED output
+* only — your own eval harness, an offline test, a model you control — and is named for what it is:
+* `node:vm` shares the host realm, so host code is reachable from inside it and it is not a
+* security boundary. Choosing it for a hostile model is remote code execution, by construction.
+*
+* WHAT IS GENUINELY THIS RUNTIME'S CONTRIBUTION, and survives audit: every call the program makes
+* crosses the IDENTICAL kernel path an MCP verb crosses. Bindings dispatch through `context.verbs`
+* → the live coordination descriptor's own handler → authorization, the conserved pool, the
+* journal ("there is no second spawn path"). The model authors a workflow as code at runtime and
+* the kernel still meters and records every edge of it — a dynamic workflow system, not a bypass.
+* Verb RESULTS are detached (JSON round-trip) before they re-enter the program, so in-code calls
+* cannot mutate live coordination state the MCP transport would have copied.
+*
+* WHAT STAYS THE MODEL'S: `submit_result`, `stop`, `ask_parent` are never in the API — a program
+* that could settle the run would be a second brain. `search` names them and says why. Code does
+* the mechanics; the model keeps the judgment, the same split the sources draw.
+*
+* THE GRANT CANNOT DRIFT FROM THE DOCS: `search` renders from `context.coordinationTools()`, the
+* same descriptor objects the verbs are served from — never prose written beside them.
+*/
+/** The seven coordination verbs callable in code, and the `context.verbs` member each maps to. */
+const CODE_CALLABLE_VERBS = {
+	spawn_agent: "spawnAgent",
+	await_event: "awaitEvent",
+	steer_agent: "steerAgent",
+	observe_agent: "observeAgent",
+	list_questions: "listQuestions",
+	answer_question: "answerQuestion",
+	run_analyst: "runAnalyst"
+};
+/** The manager's own lifecycle verbs — never callable from code; `search` names them and why. */
+const LIFECYCLE_VERBS = [
+	"submit_result",
+	"stop",
+	"ask_parent"
+];
+/** Render a JSON Schema as TypeScript type text. Bounded and structural: enough for tool input
+*  schemas (objects, enums, arrays, unions); anything unrecognized renders `unknown`, never a
+*  guess. Module-level (not root) export: consumed by `renderCodeModeApi` and its tests only. */
+function renderJsonSchemaType(schema, depth = 0) {
+	if (depth > 6 || typeof schema !== "object" || schema === null) return "unknown";
+	const node = schema;
+	if (node.const !== void 0) return JSON.stringify(node.const);
+	if (Array.isArray(node.enum)) return node.enum.map((value) => JSON.stringify(value)).join(" | ");
+	const variants = node.anyOf ?? node.oneOf;
+	if (Array.isArray(variants)) return variants.map((variant) => renderJsonSchemaType(variant, depth + 1)).join(" | ");
+	const type = Array.isArray(node.type) ? node.type : [node.type];
+	if (type.includes("object") || node.type === void 0 && node.properties !== void 0) {
+		const properties = node.properties ?? {};
+		const required = new Set(Array.isArray(node.required) ? node.required : []);
+		const fields = Object.entries(properties).map(([name, property]) => {
+			const doc = describeSchema(property);
+			const optional = required.has(name) ? "" : "?";
+			return `${doc}${JSON.stringify(name).slice(1, -1)}${optional}: ${renderJsonSchemaType(property, depth + 1)}`;
+		});
+		if (fields.length === 0) return "Record<string, unknown>";
+		const indent = "  ".repeat(depth + 1);
+		return `{\n${fields.map((field) => `${indent}${field}`).join("\n")}\n${"  ".repeat(depth)}}`;
+	}
+	if (type.includes("array")) return `Array<${renderJsonSchemaType(node.items, depth + 1)}>`;
+	const primitives = type.map((entry) => entry === "integer" ? "number" : typeof entry === "string" ? entry : void 0).filter((entry) => entry === "string" || entry === "number" || entry === "boolean" || entry === "null");
+	return primitives.length > 0 ? primitives.join(" | ") : "unknown";
+}
+function describeSchema(schema) {
+	const description = typeof schema === "object" && schema !== null ? schema.description : void 0;
+	if (typeof description !== "string" || description.length === 0) return "";
+	const first = description.split("\n")[0] ?? "";
+	return `/** ${first.length > 140 ? `${first.slice(0, 140)}…` : first} */ `;
+}
+/** Render the callable API from tool faces — `declare function` per tool, doc from its own
+*  description. This is the text `search` answers; generated, never hand-written. Module-level
+*  export for tests. */
+function renderCodeModeApi(tools, query) {
+	const needle = query?.trim().toLowerCase();
+	const blocks = tools.filter((tool) => !needle || tool.name.toLowerCase().includes(needle) || (tool.description ?? "").toLowerCase().includes(needle)).map((tool) => {
+		const doc = (tool.description ?? "").split("\n")[0] ?? "";
+		const args = tool.inputSchema === void 0 ? "unknown" : renderJsonSchemaType(tool.inputSchema);
+		return `/** ${doc} */\ndeclare function ${tool.name}(args: ${args}): Promise<unknown>`;
+	});
+	const header = [
+		"// Call these as `api.<name>(args)` from code passed to `execute`.",
+		"// Results are the same JSON the tools return. Intermediates stay in your program;",
+		"// return only what the next decision needs.",
+		`// NOT callable from code: ${LIFECYCLE_VERBS.join(", ")} — those are your own tools,`,
+		"// because a program that could settle the run would be a second brain."
+	].join("\n");
+	if (blocks.length === 0) return `${header}\n\n// No API member matches ${JSON.stringify(query ?? "")}. Call search with no query for the full API.`;
+	return `${header}\n\n${blocks.join("\n\n")}`;
+}
+/**
+* An in-process runner for TRUSTED model output ONLY. NOT a security boundary.
+*
+* It runs the program in a `node:vm` context whose globals are the bindings (`api`) and a
+* capturing `console`, with code generation disabled and inherited properties stripped. Those are
+* capability discipline, not containment: `node:vm` shares the host realm, and a host function's
+* `.constructor` is the host `Function`, so code that WANTS out can get out
+* (`api.<binding>.constructor('return process')()`). Use this for your own eval harness, offline
+* tests, or a model you trust; for untrusted output supply a jailed `CodeModeRunner` instead.
+*/
+function unsafeInProcessRunner() {
+	return { async run({ code, bindings, signal }) {
+		const logs = [];
+		const capture = (level) => (...args) => {
+			const line = args.map((value) => typeof value === "string" ? value : safeJson(value)).join(" ");
+			if (logs.length < 200) logs.push(level === "log" ? line : `[${level}] ${line}`);
+		};
+		const target = Object.create(null);
+		for (const [name, fn] of Object.entries(bindings)) target[name] = fn;
+		const sandbox = Object.create(null);
+		sandbox.api = new Proxy(Object.freeze(target), { get(owned, member) {
+			if (typeof member !== "string") return void 0;
+			if (Object.hasOwn(owned, member)) return owned[member];
+			throw new ValidationError(LIFECYCLE_VERBS.includes(member) ? `code mode: api.${member} is not callable from code — it is the manager's own lifecycle verb; return from your program and call it as a tool` : `code mode: api.${member} is not in the granted API — call search to see what is`);
+		} });
+		sandbox.console = Object.freeze({
+			log: capture("log"),
+			warn: capture("warn"),
+			error: capture("error")
+		});
+		const context = createContext(sandbox, { codeGeneration: {
+			strings: false,
+			wasm: false
+		} });
+		const program = runInContext(`(async () => {\n${code}\n})()`, context);
+		const aborted = new Promise((_resolve, reject) => {
+			if (signal.aborted) reject(abortReason(signal));
+			else signal.addEventListener("abort", () => reject(abortReason(signal)), { once: true });
+		});
+		return {
+			result: await Promise.race([program, aborted]) ?? null,
+			logs
+		};
+	} };
+}
+function abortReason(signal) {
+	const reason = signal.reason;
+	return reason instanceof Error ? reason : new ValidationError("code mode: program aborted");
+}
+function safeJson(value) {
+	try {
+		return JSON.stringify(value) ?? String(value);
+	} catch {
+		return String(value);
+	}
+}
+/** Detach a verb result before it re-enters the program — the deep copy the MCP transport makes,
+*  so in-code calls cannot mutate live coordination state. Matches the MCP path exactly (both
+*  JSON round-trip); a non-serializable result degrades to a marker rather than leaking a live
+*  reference. */
+function detach(value) {
+	if (value === void 0) return void 0;
+	try {
+		return JSON.parse(JSON.stringify(value));
+	} catch {
+		return { nonSerializable: true };
+	}
+}
+/**
+* Put a supervisor in code mode: its product tool surface becomes exactly `search` and `execute`.
+*
+* `runner` is REQUIRED and has no default — this runtime ships no isolate, so the execution
+* boundary is the caller's explicit choice (see the module doc). Use {@link unsafeInProcessRunner}
+* for trusted output; a jailed runner for untrusted models.
+*
+* Pass the result as `SuperviseOptions.resolveSupervisorTools` (which `runGraph` forwards to its
+* root supervisor). The graph engine's `supervisorKind` does not accept it yet, so a graph
+* supervisor node cannot be put in code mode through node config today.
+*/
+function codeModeSupervisorTools(runner, options = {}) {
+	if (runner === void 0 || typeof runner.run !== "function") throw new ValidationError("codeModeSupervisorTools: a CodeModeRunner is required (no default) — pass unsafeInProcessRunner() for trusted output, or a jailed runner for untrusted models");
+	const timeoutMs = options.timeoutMs ?? 6e4;
+	const faces = (context) => context.coordinationTools().filter((tool) => CODE_CALLABLE_VERBS[tool.name] !== void 0);
+	return () => [{
+		name: "search",
+		description: "Search the callable API. Returns TypeScript declarations for the operations your code may call, generated from the live grant. Optional `query` filters by name or description; omit it for the full API.",
+		inputSchema: {
+			type: "object",
+			properties: { query: {
+				type: "string",
+				description: "Substring filter over names and descriptions."
+			} }
+		},
+		handler: async (raw, context) => {
+			const query = typeof raw === "object" && raw !== null ? raw.query : void 0;
+			return renderCodeModeApi(faces(context), typeof query === "string" ? query : void 0);
+		}
+	}, {
+		name: "execute",
+		description: "Run JavaScript against the API from `search`. Write the BODY of an async function: call `api.<name>(args)` (await each call), use loops and Promise.all for fan-out, keep intermediates in variables, `return` only what the next decision needs. `console.log` lines come back beside the result. No imports, no network, no filesystem — the API is the intended capability.",
+		inputSchema: {
+			type: "object",
+			properties: { code: {
+				type: "string",
+				description: "The async function body to run."
+			} },
+			required: ["code"]
+		},
+		handler: async (raw, context) => {
+			const code = typeof raw === "object" && raw !== null ? raw.code : void 0;
+			if (typeof code !== "string" || code.trim().length === 0) throw new ValidationError("code mode: execute needs { code: string }");
+			assertAuthoredCode(code, { context: `code mode (${context.nodeId})` });
+			const deadline = new AbortController();
+			const onScopeAbort = () => deadline.abort(abortReason(context.signal));
+			const timer = setTimeout(() => deadline.abort(new ValidationError(`code mode: program timed out after ${timeoutMs}ms`)), timeoutMs);
+			if (context.signal.aborted) deadline.abort(abortReason(context.signal));
+			else context.signal.addEventListener("abort", onScopeAbort, { once: true });
+			const bindings = {};
+			for (const [wire, member] of Object.entries(CODE_CALLABLE_VERBS)) bindings[wire] = async (args) => {
+				if (deadline.signal.aborted) throw new ValidationError(`code mode: the execute deadline passed; api.${wire} is refused so no work outlives the call`);
+				return detach(await context.verbs[member](args));
+			};
+			try {
+				return await runner.run({
+					code,
+					bindings,
+					signal: deadline.signal
+				});
+			} finally {
+				clearTimeout(timer);
+				context.signal.removeEventListener("abort", onScopeAbort);
+			}
+		}
+	}];
+}
+//#endregion
 //#region src/runtime/supervise/patch-checks.ts
 const DEFAULT_MAX_DIFF_LINES = 400;
 /**
@@ -7118,6 +7358,6 @@ function tail(s) {
 	return s.slice(-400);
 }
 //#endregion
-export { definePersona as $, discriminatingMeans as A, sentinelCompletion as At, printBenchmarkReport as B, McpSpawnFault as Bt, withUntrackedArtifacts as C, localSandboxClient as Ct, chatTransportExecutor as D, superviseDispatch as Dt, runCoderChecks as E, loopDispatch as Et, authorStrategy as F, renderLeaderboardMarkdown as Ft, startRetainedInteractiveRun as G, envKeyProvider as Gt, claimRetainedInteractiveControl as H, materializeLocalMcp as Ht, strategyAuthorContract as I, renderLeaderboardSvg as It, startRetainedRun as J, resolveSecretEnv as Jt, reconnectRetainedRun as K, mcpSecretEnvMetadataKey as Kt, strategyAuthorSystemPrompt as L, renderPairwiseMarkdown as Lt, runStrategyEvolution as M, leaderboard as Mt, selectChampion as N, pairwiseSignificance as Nt, chatWorkerSeam as O, completionAuthorizes as Ot, assertStrategyContract as P, renderLeaderboardHtml as Pt, trajectoryReport as Q, SandboxRunAbortError as R, auditIntent as Rt, copyUntrackedIntoClone as S, resolveSandboxClient as St, patchDelivered as T, loopCampaignDispatch as Tt, reconnectRetainedInteractiveRun as U, createMcpEnvironment as Ut, runBenchmark as V, connectStdioMcp as Vt, recoverRetainedInteractiveRun as W, sanitizeMcpToolSchema as Wt, promotionGate as X, startRetainedRunInEnvironment as Y, secretEnvOfMcpServer as Yt, equalKOnCost as Z, NOTE_MAX_CHARS as _, createScopeAnalyst as _t, localShell as a, InMemoryCorpus as at, composeWorkerEvidence as b, harvestCorpus as bt, createVerifierEnvironment as c, flatWidenGate as ct, harvestSurfaceDiffs as d, pipeline as dt, runPersonified as et, analystsFromRegistry as f, selectValidWinner as ft, EVIDENCE_MAX_CHARS as g, buildSteerContext as gt, worktreeFanout as h, assertTraceDerivedFindings as ht, jjWorkspace as i, FileCorpus as it, pickChampion as j, stopSentinel as jt, createChatSessionStore as k, deterministicCompletion as kt, boxSurfaceReader as l, loopUntil as lt, superviseSurface as m, widen as mt, makeFinding$1 as n, createShapeRegistry as nt, runInWorkspace as o, renderCorpusToInstructions as ot, failuresAnalyst as p, verify as pt, recoverRetainedRun as q, resolveMcpServerLaunch as qt, gitWorkspace as r, registerShape as rt, createWaterfallCollector as s, fanout as st, computeFindingId$1 as t, builtinShapes as tt, fsSurfaceReader as u, panel as ut, VERIFY_TAIL_CHARS as v, registryScopeAnalyst as vt, analyzeTrace as w, inlineSandboxClient as wt, settledWorkerOut as x, defineLeaderboard as xt, closingWorkerNote as y, inProcessSandboxClient as yt, openSandboxRun as z, defaultAuditorInstruction as zt };
+export { equalKOnCost as $, chatWorkerSeam as A, completionAuthorizes as At, SandboxRunAbortError as B, auditIntent as Bt, withUntrackedArtifacts as C, defineLeaderboard as Ct, codeModeSupervisorTools as D, loopCampaignDispatch as Dt, runCoderChecks as E, inlineSandboxClient as Et, selectChampion as F, pairwiseSignificance as Ft, reconnectRetainedInteractiveRun as G, createMcpEnvironment as Gt, printBenchmarkReport as H, McpSpawnFault as Ht, assertStrategyContract as I, renderLeaderboardHtml as It, reconnectRetainedRun as J, mcpSecretEnvMetadataKey as Jt, recoverRetainedInteractiveRun as K, sanitizeMcpToolSchema as Kt, authorStrategy as L, renderLeaderboardMarkdown as Lt, discriminatingMeans as M, sentinelCompletion as Mt, pickChampion as N, stopSentinel as Nt, unsafeInProcessRunner as O, loopDispatch as Ot, runStrategyEvolution as P, leaderboard as Pt, promotionGate as Q, strategyAuthorContract as R, renderLeaderboardSvg as Rt, copyUntrackedIntoClone as S, harvestCorpus as St, patchDelivered as T, localSandboxClient as Tt, runBenchmark as U, connectStdioMcp as Ut, openSandboxRun as V, defaultAuditorInstruction as Vt, claimRetainedInteractiveControl as W, materializeLocalMcp as Wt, startRetainedRun as X, resolveSecretEnv as Xt, recoverRetainedRun as Y, resolveMcpServerLaunch as Yt, startRetainedRunInEnvironment as Z, secretEnvOfMcpServer as Zt, NOTE_MAX_CHARS as _, assertTraceDerivedFindings as _t, localShell as a, registerShape as at, composeWorkerEvidence as b, registryScopeAnalyst as bt, createVerifierEnvironment as c, renderCorpusToInstructions as ct, harvestSurfaceDiffs as d, loopUntil as dt, trajectoryReport as et, analystsFromRegistry as f, panel as ft, EVIDENCE_MAX_CHARS as g, widen as gt, worktreeFanout as h, verify as ht, jjWorkspace as i, createShapeRegistry as it, createChatSessionStore as j, deterministicCompletion as jt, chatTransportExecutor as k, superviseDispatch as kt, boxSurfaceReader as l, fanout as lt, superviseSurface as m, selectValidWinner as mt, makeFinding$1 as n, runPersonified as nt, runInWorkspace as o, FileCorpus as ot, failuresAnalyst as p, pipeline as pt, startRetainedInteractiveRun as q, envKeyProvider as qt, gitWorkspace as r, builtinShapes as rt, createWaterfallCollector as s, InMemoryCorpus as st, computeFindingId$1 as t, definePersona as tt, fsSurfaceReader as u, flatWidenGate as ut, VERIFY_TAIL_CHARS as v, buildSteerContext as vt, analyzeTrace as w, resolveSandboxClient as wt, settledWorkerOut as x, inProcessSandboxClient as xt, closingWorkerNote as y, createScopeAnalyst as yt, strategyAuthorSystemPrompt as z, renderPairwiseMarkdown as zt };
 
-//# sourceMappingURL=runtime-C-7uhhFs.js.map
+//# sourceMappingURL=runtime-ckAefgVV.js.map