@tangle-network/agent-runtime 0.134.1 → 0.134.3

package/dist/testing.d.ts

@@ -1,5 +1,5 @@
-import { Ja as superviseWithTestBrain, Ka as SuperviseTestOptions, Lt as RunGraphTestOptions, Vt as runGraphWithTestBrain, gn as driverAgent, hn as DriverAgentOptions, io as SupervisorAgentTestDeps, po as supervisorAgentWithTestBrain } from "./index-De10l_EU.js";
-import { it as ToolLoopChat, rt as ToolLoopCallContext } from "./runtime-DlxoqEj2.js";
+import { Ja as superviseWithTestBrain, Ka as SuperviseTestOptions, Lt as RunGraphTestOptions, Vt as runGraphWithTestBrain, gn as driverAgent, hn as DriverAgentOptions, io as SupervisorAgentTestDeps, po as supervisorAgentWithTestBrain } from "./index-gevMEHnE.js";
+import { it as ToolLoopChat, rt as ToolLoopCallContext } from "./runtime-CFD7S185.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,12 +1,12 @@
-import { $ as parseExactAgentProfile, K as applyExactAgentProfileDiff, rt as canonicalCandidateDigest$1, st as immutableCandidateValue } from "./prepare-BXEtLOj9.js";
-import { f as verifyAgentImprovementProposal } from "./improvement-cycle-CSBantKB.js";
-import { c as supervisorAgentWithTestBrain, dt as driverAgent, r as superviseWithTestBrain } from "./supervise-DhghNvl6.js";
-import { i as runGraphWithTestBrain } from "./graph-CKNenH2a.js";
+import { $ as parseExactAgentProfile, K as applyExactAgentProfileDiff, rt as canonicalCandidateDigest$1, st as immutableCandidateValue } from "./prepare-Cv7NzRZl.js";
+import { f as verifyAgentImprovementProposal } from "./improvement-cycle-fezPL8Th.js";
+import { c as supervisorAgentWithTestBrain, dt as driverAgent, r as superviseWithTestBrain } from "./supervise-BvjQqKsp.js";
+import { i as runGraphWithTestBrain } from "./graph-D0bln4rR.js";
 import { SANDBOX_SIZE_PRESET_NAMES } from "@tangle-network/agent-interface";
 //#region src/testing/fixtures/agent-improvement-proposal.json
 var agent_improvement_proposal_default = {
 	changedSurfaces: ["prompt"],
-	digest: "sha256:1f060b6f2e36df287e9eb377763752983d558b17087e842675656bbac2225153",
+	digest: "sha256:416095697d67b527763d3872ea497de9e90f21f0f06cb4ea001b8b72b2c84573",
 	evaluation: {
 		"decision": {
 			"contributingChecks": [
@@ -4565,7 +4565,7 @@ var agent_improvement_proposal_default = {
 		],
 		"metadata": {
 			"fixture": "agent-improvement-proposal",
-			"runtimeVersion": "0.134.1"
+			"runtimeVersion": "0.134.3"
 		},
 		"objectives": [
 			{
@@ -4676,8 +4676,8 @@ var agent_improvement_proposal_default = {
 			"baselineContentHash": "sha256:5c21ee53e513fc604cb09754e21c392b24a424da0ef37dbf8f1ee4a8a0b08f09",
 			"candidateContentHash": "sha256:60fcbb1c728194bd51d7d19cb732d1c3f1881dce7e0a6266b41c8b98cfd65693",
 			"kind": "agent-eval-loop",
-			"recordDigest": "sha256:6df4c838fd55296f7d6574171c1a3ad91ae43879869d8ba7f16b84605d379604",
-			"runId": "agent-runtime-0.134.1-proposal-fixture",
+			"recordDigest": "sha256:06a9df142cbdf228134e7548e97ec088d6f838dc9ce33648fe50694dbed642ea",
+			"runId": "agent-runtime-0.134.3-proposal-fixture",
 			"schema": "agent-candidate-experiment"
 		}
 	},
@@ -4700,13 +4700,13 @@ var agent_improvement_proposal_default = {
 	}],
 	kind: "agent-improvement-proposal",
 	proposedAt: "2026-07-10T01:00:00.000Z",
-	runId: "agent-runtime-0.134.1-proposal-fixture"
+	runId: "agent-runtime-0.134.3-proposal-fixture"
 };
 //#endregion
 //#region src/testing/fixtures/agent-profile-improvement-proposal.json
 var agent_profile_improvement_proposal_default = {
 	changedSurfaces: ["prompt", "skills"],
-	digest: "sha256:359e5a1f5192d915f2d24bc1fb3558c017881b59320c72d44c3c3d5f70ec0daa",
+	digest: "sha256:cb9b48c6a1b9e4042f0e0d6d4789f5ed9fc6ef4e56f6c4a64610e80a07510cbb",
 	evaluation: {
 		"decision": {
 			"contributingChecks": [
@@ -6340,7 +6340,7 @@ var agent_profile_improvement_proposal_default = {
 		],
 		"metadata": {
 			"fixture": "agent-profile-improvement-proposal",
-			"runtimeVersion": "0.134.1"
+			"runtimeVersion": "0.134.3"
 		},
 		"objectives": [
 			{
@@ -6451,7 +6451,7 @@ var agent_profile_improvement_proposal_default = {
 			"baselineContentHash": "sha256:21c495a37c418c10bde64fbaa188beddeed31f1f051ea60a6a6582a9ee0db704",
 			"candidateContentHash": "sha256:103f77bc8481601eef1ad5fe6ba84a40dffabc3a44f421f8c8559121edab84e9",
 			"kind": "agent-eval-loop",
-			"recordDigest": "sha256:4d25ec3f7deecdb4f89bffaa39d4e757b26b790ed04c5c8ff9a822d46f89a25c",
+			"recordDigest": "sha256:d759061e80f611f668b1c45bd074b2b5f106cf8892462b39ecca459ceafe5791",
 			"runId": "profile-improvement-1",
 			"schema": "agent-profile-improvement-experiment"
 		}

package/dist/{types-6zHo67jn.d.ts → types-Cz4m4Iv6.d.ts}

@@ -714,9 +714,9 @@ interface LoopTokenUsage {
   tokensKnown?: false;
   /** Prompt tokens newly processed by the provider, when every prompt class is known. */
   freshInput?: number;
-  /** Prompt tokens served from a provider cache, when every prompt class is known. */
+  /** Prompt tokens the provider reported serving from its cache. */
   cacheRead?: number;
-  /** Prompt tokens written to a provider cache, when every prompt class is known. */
+  /** Prompt tokens the provider reported writing to its cache. */
   cacheWrite?: number;
   /**
    * False when any positive-input observation omitted or contradicted the prompt-cache split.
@@ -1215,4 +1215,4 @@ interface ExecCtx {
 }
 //#endregion
 export { OpenAIChatToolChoice as $, RuntimeRunCompleteInput as A, AgentBackendInput as B, MountRecorder as C, SelectionReceipt as D, SandboxClient as E, RuntimeRunRow as F, AgentTaskContext as G, AgentKnowledgeProvider as H, RuntimeRunStatus as I, AgentTaskStatus as J, AgentTaskRunResult as K, startRuntimeRun as L, RuntimeRunHandle as M, RuntimeRunOptions as N, ValidationCtx as O, RuntimeRunPersistenceAdapter as P, OpenAIChatTool as Q, AgentAdapter as R, MountManifestEntry as S, RunProvenance as T, AgentRuntimeEvent as U, AgentExecutionBackend as V, AgentRuntimeEventSink as W, KnowledgeReadinessDecision as X, BackendErrorDetail as Y, OpenAIChatResponseFormat as Z, LoopTeardownFailedPayload as _, Iteration as a, LoopTraceEvent as b, LoopIterationDispatchPayload as c, LoopLineageOptions as d, RunAgentTaskOptions as et, LoopPlanDescription as f, LoopStartedPayload as g, LoopSandboxPlacement as h, ExecCtx as i, RuntimeStreamEvent as it, RuntimeRunCost as j, Validator as k, LoopIterationEndedPayload as l, LoopResult as m, DefaultVerdict as n, RuntimeSession as nt, LoopDecisionPayload as o, LoopPlanPayload as p, AgentTaskSpec as q, Driver as r, RuntimeSessionStore as rt, LoopEndedPayload as s, AgentRunSpec as t, RunAgentTaskStreamOptions as tt, LoopIterationStartedPayload as u, LoopTokenUsage as v, OutputAdapter as w, LoopWinner as x, LoopTraceEmitter as y, AgentBackendContext as z };
-//# sourceMappingURL=types-6zHo67jn.d.ts.map
+//# sourceMappingURL=types-Cz4m4Iv6.d.ts.map

package/dist/{types-D4BfurNs.d.ts → types-XtB9WZzr.d.ts}

@@ -1,4 +1,4 @@
-import { J as AgentTaskStatus, U as AgentRuntimeEvent, it as RuntimeStreamEvent, v as LoopTokenUsage, y as LoopTraceEmitter } from "./types-6zHo67jn.js";
+import { J as AgentTaskStatus, U as AgentRuntimeEvent, it as RuntimeStreamEvent, v as LoopTokenUsage, y as LoopTraceEmitter } from "./types-Cz4m4Iv6.js";
 import { l as RuntimeHooks } from "./runtime-hooks-sbRpjStq.js";
 import { ControlEvalResult, DefaultVerdict, KnowledgeReadinessReport, KnowledgeRequirement, ToolSpan } from "@tangle-network/agent-eval";
 import { AgentProfile as AgentProfile$1, Sha256Digest } from "@tangle-network/agent-interface";
@@ -896,17 +896,31 @@ type UsageEvent = {
   output: number;
   /** Newly processed prompt tokens. Present only with a complete cache split. */
   freshInput?: number;
-  /** Prompt tokens read from cache. Present only with a complete cache split. */
+  /** Prompt tokens the provider reported reading from cache. */
   cacheRead?: number;
-  /** Prompt tokens written to cache. Present only with a complete cache split. */
+  /** Prompt tokens the provider reported writing to cache. */
   cacheWrite?: number;
-  /** False when this observation cannot classify all positive prompt tokens. */
+  /**
+   * False when this observation cannot classify all positive prompt tokens — including a
+   * provider that reports a read with no write counter. The measured counters are still
+   * carried; the marker says the remaining prompt tokens are unclassified, so a charge over
+   * them is an upper bound. A counter the provider did not report is absent, never zero.
+   */
   cacheBreakdownKnown?: false;
 } | {
   kind: 'cost';
   /** Known dollar subtotal. When false, `usd` must not be treated as total cost. */
   usdKnown?: false;
   usd: number;
+  /**
+   * The part of `usd` this runtime priced from a model catalog because no provider receipt
+   * covered the work. Requires `usdKnown: false` — a catalog price approximates what a
+   * provider would bill and never measures what it did.
+   *
+   * Absence means this runtime priced nothing here, NOT that `usd` is a receipt. `usdKnown`
+   * is what says whether a dollar figure is measured.
+   */
+  usdEstimated?: number;
 } | {
   kind: 'iteration';
 };
@@ -1113,6 +1127,11 @@ interface Spend {
    *  when enforcing a dollar-denominated comparison or limit. */
   usdKnown?: boolean;
   usd: number;
+  /** The part of `usd` priced from a model catalog because no provider receipt covered the work.
+   *  `usd - usdEstimated` is what a provider is known to have billed. Present only with
+   *  `usdKnown: false`; absence means nothing here was catalog-priced, not that `usd` is
+   *  measured. */
+  usdEstimated?: number;
   ms: number;
 }
 /** OTP child-spec restart class. */
@@ -1560,6 +1579,8 @@ type SpawnEvent = {
   kind: 'metered';
   id: NodeId;
   spend: Spend;
+  /** Runtime bookkeeping only; this record carries no provider inference attempt. */
+  accountingOnly?: true;
   /** Runtime-owned provider attempt evidence for this driver's own inference turn. */
   providerModel?: ProviderModelExecutionEvidence;
   seq: number;
@@ -1905,4 +1926,4 @@ interface WidenGate<Out> {
 }
 //#endregion
 export { WaitOpts as $, WaitSpec as $t, ResumedWork as A, exportEvalRuns as At, SpawnOpts as B, RuntimeTelemetryOptions as Bt, NodeStatus as C, OtelSpan as Ct, Restart as D, buildRuntimeEventOtelSpans as Dt, ProviderModelExecutionEvidence as E, buildLoopSpanNodes as Et, Runtime as F, toOtelAttributes as Ft, SpendGap as G, sanitizeAgentRuntimeEvent as Gt, SpawnRejection as H, SanitizedKnowledgeRequirement as Ht, Scope as I, RuntimeEventCollector as It, Supervisor as J, PendingWait as Jt, SteerableRootHandle as K, sanitizeKnowledgeReadinessReport as Kt, Settled as L, RuntimeStreamEventCollector as Lt, RootMaterialization as M, loopEventToOtelSpan as Mt, RootProviderModelEvidence as N, padSpanId as Nt, ResultBlobStore as O, createOpenInferenceFileExporter as Ot, RootSignal as P, padTraceId as Pt, UsageEvent as Q, WaitRejection as Qt, SpawnEvent as R, RuntimeStreamEventSink as Rt, NodeSnapshot as S, OtelExporter as St, ProviderModelAttemptEvidence as T, buildLoopOtelSpans as Tt, Spend as U, createRuntimeEventCollector as Ut, SpawnPrior as V, SanitizedKnowledgeReadinessReport as Vt, SpendChannel as W, createRuntimeStreamEventCollector as Wt, TreeView as X, WaitProbe as Xt, SupervisorOpts as Y, WaitOutcome as Yt, UnknownMaterializationReason as Z, WaitProbeRegistry as Zt, MaterializedExecutionIdentity as _, ScopeProgressInput as _n, EvalRunsExportResult as _t, DefaultVerdict as a, waitUntil as an, readWorkerTraceContext as at, NodeExecutionIdentity as b, readWorkerProgress as bn, OtelAttribute as bt, ExecutorAccounting as c, ToolStepInput as cn, workerTraceSeamKey as ct, ExecutorFactory as d, decodeToolPart as dn, mergeTraceEnv as dt, createWaitProbes as en, WidenGate as et, ExecutorMaterialization as f, sandboxSessionTraceSource as fn, readTraceContextFromEnv as ft, Handle as g, ExecutorProgress as gn, EvalRunsExportConfig as gt, ExecutorResult as h, DEFAULT_STALL_AFTER_MS as hn, EvalRunGeneration as ht, Budget as i, validateWaitSpec as in, WorkerTraceSeamCarrier as it, RootHandle as j, generateSpanId as jt, ResumedKeyState as k, createOtelExporter as kt, ExecutorContext as l, TraceSource as ln, TraceContext as lt, ExecutorRegistry as m, ActivityNote as mn, EvalRunEvent as mt, AgentExecutionRef as n, pollFor as nn, WorkerTraceUnavailableReason as nt, ExecutionBindingReceipt as o, SessionMessageLike as on, workerTraceEnv as ot, ExecutorNodeContext as p, ActivityLog as pn, traceContextToEnv as pt, SupervisedResult as q, sanitizeRuntimeStreamEvent as qt, AgentSpec as r, timerAt as rn, WorkerTraceResolver as rt, Executor as s, SessionTraceBox as sn, workerTraceHeaders as st, Agent as t, isWaitOutcome as tn, WorkerTraceEvidence as tt, ExecutorExecutionBinding as u, createPushTraceSource as un, createPropagatingTraceEmitter as ut, MaterializedModelIdentity as v, WorkerProgress as vn, INTELLIGENCE_WIRE_VERSION as vt, ProfileMaterializationReceipt as w, RuntimeEventOtelOptions as wt, NodeId as x, OtelExportConfig as xt, NoWinnerError as y, createActivityLog as yn, LoopSpanNode as yt, SpawnJournal as z, RuntimeStreamEventSummary as zt };
-//# sourceMappingURL=types-D4BfurNs.d.ts.map
+//# sourceMappingURL=types-XtB9WZzr.d.ts.map

package/dist/util-C1bv6yog.js

@@ -0,0 +1,282 @@
+//#region src/runtime/util.ts
+/**
+* Best-effort sandbox delete. Skips instances without a `delete` (test fakes);
+* swallows errors (the platform reaps on expiry). Returns `false` when delete
+* threw, `true` otherwise, so callers can surface a leak if they choose.
+*/
+async function deleteBoxSafe(box) {
+	if (!box || typeof box.delete !== "function") return true;
+	try {
+		await box.delete();
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** Short base36 id for trace correlation. Not cryptographic, not collision-free. */
+function randomSuffix(len = 8) {
+	return Math.random().toString(36).slice(2, 2 + len);
+}
+/** Collision-resistant id for sandbox naming (find-by-name recovery must be unique). */
+function randomUuid() {
+	return crypto.randomUUID();
+}
+/** Construct an AbortError. Downstream code pattern-matches on `err.name`. */
+function abortError() {
+	const err = /* @__PURE__ */ new Error("aborted");
+	err.name = "AbortError";
+	return err;
+}
+/** Throw an AbortError. */
+function throwAbort() {
+	throw abortError();
+}
+/** Throw if the signal is already aborted; otherwise no-op. */
+function throwIfAborted(signal) {
+	if (signal?.aborted) throw abortError();
+}
+/** True for any error whose `name` is `AbortError` (the cross-kernel abort contract). */
+function isAbortError(err) {
+	return err instanceof Error && err.name === "AbortError";
+}
+/**
+* Sleep that resolves early on abort and always clears its timer so it never
+* keeps the event loop alive. Resolves (does not reject) on abort — callers
+* re-check the signal explicitly after the sleep.
+*/
+function sleep(ms, signal) {
+	return new Promise((resolve) => {
+		if (signal?.aborted) {
+			resolve();
+			return;
+		}
+		let onAbort;
+		const timer = setTimeout(() => {
+			if (onAbort && signal) signal.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		if (signal) {
+			onAbort = () => {
+				clearTimeout(timer);
+				resolve();
+			};
+			signal.addEventListener("abort", onAbort, { once: true });
+		}
+	});
+}
+/**
+* Race a promise against a timeout. Resolves with the value if it settles in
+* time, otherwise resolves with `undefined`. Always clears the timer.
+*/
+function withTimeout(promise, ms) {
+	return new Promise((resolve) => {
+		const timer = setTimeout(() => resolve(void 0), ms);
+		promise.then((value) => {
+			clearTimeout(timer);
+			resolve(value);
+		}, () => {
+			clearTimeout(timer);
+			resolve(void 0);
+		});
+	});
+}
+/**
+* `JSON.stringify` with a `String()` fallback on throw (cyclic / non-JSON).
+* Strings pass through unstringified so a preview of a string output is the
+* string itself, not a quoted re-encoding.
+*/
+function stringifySafe(value, opts = {}) {
+	let s;
+	try {
+		if (typeof value === "string") s = value;
+		else s = (opts.pretty ? JSON.stringify(value, null, 2) : JSON.stringify(value)) ?? String(value);
+	} catch {
+		s = String(value);
+	}
+	if (opts.max !== void 0 && s.length > opts.max) return `${s.slice(0, opts.max)}…`;
+	return s;
+}
+/** A fresh zero token-usage accumulator. */
+function zeroTokenUsage() {
+	return {
+		input: 0,
+		output: 0
+	};
+}
+/**
+* Sum the catalog-priced part of a dollar total across spends, as a field to spread.
+*
+* Returns nothing when no input carried one. A fold of pure provider receipts must not gain a
+* `usdEstimated: 0`, which would read as "this runtime checked and priced none" on a path that
+* never prices at all.
+*/
+function usdEstimatedOf(...spends) {
+	let total = 0;
+	let priced = false;
+	for (const spend of spends) {
+		if (spend.usdEstimated === void 0) continue;
+		priced = true;
+		total += spend.usdEstimated;
+	}
+	return priced ? { usdEstimated: total } : {};
+}
+/** Copy a token subtotal without dropping optional provider cache telemetry. */
+function cloneTokenUsage(usage) {
+	const cacheBreakdownUnknown = usage.cacheBreakdownKnown === false || usage.input > 0 && !hasClassifiedCacheBreakdown(usage);
+	return {
+		input: usage.input,
+		output: usage.output,
+		...usage.tokensKnown === false ? { tokensKnown: false } : {},
+		...usage.freshInput !== void 0 ? { freshInput: usage.freshInput } : {},
+		...usage.cacheRead !== void 0 ? { cacheRead: usage.cacheRead } : {},
+		...usage.cacheWrite !== void 0 ? { cacheWrite: usage.cacheWrite } : {},
+		...cacheBreakdownUnknown ? { cacheBreakdownKnown: false } : {}
+	};
+}
+/** True only when every positive prompt token has a consistent cache classification. */
+function hasCompleteCacheBreakdown(usage) {
+	if (usage.cacheBreakdownKnown === false) return false;
+	return hasClassifiedCacheBreakdown(usage);
+}
+function hasClassifiedCacheBreakdown(usage) {
+	if (usage.input === 0) return true;
+	if (usage.freshInput === void 0 || usage.cacheRead === void 0 || usage.cacheWrite === void 0) return false;
+	return usage.freshInput + usage.cacheRead + usage.cacheWrite === usage.input;
+}
+/**
+* The token charge for one observation: every token counted ONCE, at the moment it first enters
+* the context — `input − cacheRead + output`.
+*
+* `input` is a rolled-up prompt total that re-counts a cached prefix on every turn that reads it,
+* so charging `input` makes a 100K prefix read 40 times cost 4.1M for content authored once. A
+* cache read is content that was already charged when it was written, so it is the one class the
+* charge subtracts. Under a complete split the result is exactly `freshInput + cacheWrite`. No
+* price weight is involved: this counts work, and money is a separate channel.
+*
+* The subtraction form is what makes the charge ADDITIVE. `input` and `cacheRead` both accumulate
+* through `addTokenUsage`, so the charge on an aggregate equals the sum of the charges on the
+* records that built it — including an aggregate that mixes classified and unclassified turns,
+* where the unclassified remainder is charged in full and only the reported cache reads are
+* credited. A form that read `freshInput + cacheWrite` directly loses that: one unclassified turn
+* would drop the whole aggregate to `input + output` and over-charge every classified turn with it.
+*
+* The one arithmetic guarantee: a set of classes that does not FIT inside the prompt total it
+* partitions credits nothing, so the charge is never below `output` and a class that overflows its
+* own total buys no tokens. It is not a guarantee against a provider that reports a cache read it
+* never served — that provider can under-report `input` just as easily, and the token channel is an
+* accounting unit, not a trust boundary. Prompt tokens the provider left unclassified are charged
+* in full, so a spend with no readable split charges an upper bound on newly-presented work rather
+* than a measurement, and every caller that enforces a ceiling must report the difference
+* (`BudgetPool` does it through `readout().cacheBreakdownKnown`).
+*/
+function chargedTokens(usage) {
+	return usage.input - creditedCacheRead(usage) + usage.output;
+}
+/** `cacheRead` if the reported classes fit inside `input`, else nothing. */
+function creditedCacheRead(usage) {
+	const { cacheRead } = usage;
+	if (cacheRead === void 0) return 0;
+	return classifiedTotal(usage, cacheRead) > usage.input ? 0 : cacheRead;
+}
+function classifiedTotal(usage, cacheRead) {
+	return (usage.freshInput ?? 0) + cacheRead + (usage.cacheWrite ?? 0);
+}
+/**
+* Translate one provider prompt-cache report into the prompt token classes `addTokenUsage` folds
+* and `chargedTokens` credits.
+*
+* The input is the open `promptCache` record an `llm_call` carries, keyed by the `PromptCacheUsage`
+* vocabulary (`readTokens`, `writeTokens`). Providers report that vocabulary unevenly, and the
+* three outcomes are different facts that must not collapse into one another:
+*
+*  - **Nothing reported** — no classes and no marker. The caller's own unknown handling decides,
+*    because a provider that says nothing about caching has not said the split is unknowable.
+*  - **Read and write both reported, and fitting inside `input`** — a complete partition, so
+*    `freshInput` is the remainder and the split is known.
+*  - **One counter reported, or classes that overflow `input`** — the counters that ARE measured
+*    pass through and `cacheBreakdownKnown` is false. A read with no write counter (OpenAI reports
+*    no write) still credits the read it measured, while declaring the rest unclassified so the
+*    charge stays a declared upper bound. An overflowing claim buys nothing: it cannot be a
+*    partition of a total it exceeds.
+*
+* A counter the provider did not report stays absent. A zero would claim the provider measured no
+* cache, which is a different fact from a provider that did not report.
+*/
+function promptCacheTokenClasses(input, promptCache) {
+	if (promptCache === void 0) return {};
+	const read = tokenCount(promptCache.readTokens);
+	const write = tokenCount(promptCache.writeTokens);
+	if (read === void 0 && write === void 0) return {};
+	if (input === void 0 || (read ?? 0) + (write ?? 0) > input) return { cacheBreakdownKnown: false };
+	if (read !== void 0 && write !== void 0) return {
+		freshInput: input - read - write,
+		cacheRead: read,
+		cacheWrite: write
+	};
+	return {
+		...read !== void 0 ? { cacheRead: read } : {},
+		...write !== void 0 ? { cacheWrite: write } : {},
+		cacheBreakdownKnown: false
+	};
+}
+function tokenCount(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+}
+/**
+* Add the observed subtotal into `acc`; token and cache incompleteness are sticky.
+*
+* A delta whose classes do not FIT inside its own `input` contributes its prompt total and NO
+* classes. Folding them in would hide the overflow: the accumulator's larger `input` can absorb a
+* class total that overflowed the one delta that reported it, and `chargedTokens` would then credit
+* at the aggregate a cache read it refuses at the record. That is the one way the charge could come
+* out below the sum of the charges on the records that built it.
+*/
+function addTokenUsage(acc, delta) {
+	acc.input += delta.input ?? 0;
+	acc.output += delta.output ?? 0;
+	if (delta.tokensKnown === false) acc.tokensKnown = false;
+	const input = delta.input ?? 0;
+	const fits = classifiedTotal(delta, delta.cacheRead ?? 0) <= input;
+	if (fits) {
+		if (delta.freshInput !== void 0) acc.freshInput = (acc.freshInput ?? 0) + delta.freshInput;
+		if (delta.cacheRead !== void 0) acc.cacheRead = (acc.cacheRead ?? 0) + delta.cacheRead;
+		if (delta.cacheWrite !== void 0) acc.cacheWrite = (acc.cacheWrite ?? 0) + delta.cacheWrite;
+	}
+	const classified = fits && delta.freshInput !== void 0 && delta.cacheRead !== void 0 && delta.cacheWrite !== void 0 && delta.freshInput + delta.cacheRead + delta.cacheWrite === input;
+	if (delta.cacheBreakdownKnown === false || input > 0 && !classified) acc.cacheBreakdownKnown = false;
+}
+/**
+* Map `items` through `fn` with at most `limit` calls in flight at once,
+* preserving input order in the result. On the first `fn` rejection no NEW
+* items are picked up; already-in-flight calls are awaited, then the first
+* error is rethrown. `limit` is clamped to ≥ 1.
+*
+* Used where a burst of provisioning (e.g. forking N child boxes) must respect
+* the loop's concurrency bound instead of firing all N at once.
+*/
+async function mapWithConcurrency(items, limit, fn) {
+	const bound = Math.max(1, Math.floor(limit));
+	const results = new Array(items.length);
+	let next = 0;
+	let failed = false;
+	const worker = async () => {
+		while (!failed) {
+			const i = next;
+			next += 1;
+			if (i >= items.length) return;
+			try {
+				results[i] = await fn(items[i], i);
+			} catch (err) {
+				failed = true;
+				throw err;
+			}
+		}
+	};
+	const workerCount = Math.min(bound, items.length);
+	await Promise.all(Array.from({ length: workerCount }, () => worker()));
+	return results;
+}
+//#endregion
+export { zeroTokenUsage as _, hasCompleteCacheBreakdown as a, promptCacheTokenClasses as c, sleep as d, stringifySafe as f, withTimeout as g, usdEstimatedOf as h, deleteBoxSafe as i, randomSuffix as l, throwIfAborted as m, chargedTokens as n, isAbortError as o, throwAbort as p, cloneTokenUsage as r, mapWithConcurrency as s, addTokenUsage as t, randomUuid as u };
+
+//# sourceMappingURL=util-C1bv6yog.js.map

package/dist/util-C1bv6yog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"util-C1bv6yog.js","names":[],"sources":["../src/runtime/util.ts"],"sourcesContent":["/**\n *\n * Internal loop-kernel utilities shared across the kernel, drivers, and the\n * sandbox-acquire layer. Not part of the public barrel surface.\n *\n * @experimental\n */\n\nimport type { SandboxInstance } from '@tangle-network/sandbox'\nimport type { LoopTokenUsage } from './types'\n\n/**\n * Best-effort sandbox delete. Skips instances without a `delete` (test fakes);\n * swallows errors (the platform reaps on expiry). Returns `false` when delete\n * threw, `true` otherwise, so callers can surface a leak if they choose.\n */\nexport async function deleteBoxSafe(box: SandboxInstance | undefined): Promise<boolean> {\n  if (!box || typeof (box as { delete?: unknown }).delete !== 'function') return true\n  try {\n    await box.delete()\n    return true\n  } catch {\n    return false\n  }\n}\n\n/** Short base36 id for trace correlation. Not cryptographic, not collision-free. */\nexport function randomSuffix(len = 8): string {\n  return Math.random()\n    .toString(36)\n    .slice(2, 2 + len)\n}\n\n/** Collision-resistant id for sandbox naming (find-by-name recovery must be unique). */\nexport function randomUuid(): string {\n  return crypto.randomUUID()\n}\n\n/** Construct an AbortError. Downstream code pattern-matches on `err.name`. */\nexport function abortError(): Error {\n  const err = new Error('aborted')\n  err.name = 'AbortError'\n  return err\n}\n\n/** Throw an AbortError. */\nexport function throwAbort(): never {\n  throw abortError()\n}\n\n/** Throw if the signal is already aborted; otherwise no-op. */\nexport function throwIfAborted(signal: AbortSignal | undefined): void {\n  if (signal?.aborted) throw abortError()\n}\n\n/** True for any error whose `name` is `AbortError` (the cross-kernel abort contract). */\nexport function isAbortError(err: unknown): boolean {\n  return err instanceof Error && err.name === 'AbortError'\n}\n\n/**\n * Sleep that resolves early on abort and always clears its timer so it never\n * keeps the event loop alive. Resolves (does not reject) on abort — callers\n * re-check the signal explicitly after the sleep.\n */\nexport function sleep(ms: number, signal?: AbortSignal): Promise<void> {\n  return new Promise((resolve) => {\n    if (signal?.aborted) {\n      resolve()\n      return\n    }\n    let onAbort: (() => void) | undefined\n    const timer = setTimeout(() => {\n      if (onAbort && signal) signal.removeEventListener('abort', onAbort)\n      resolve()\n    }, ms)\n    if (signal) {\n      onAbort = () => {\n        clearTimeout(timer)\n        resolve()\n      }\n      signal.addEventListener('abort', onAbort, { once: true })\n    }\n  })\n}\n\n/**\n * Race a promise against a timeout. Resolves with the value if it settles in\n * time, otherwise resolves with `undefined`. Always clears the timer.\n */\nexport function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T | undefined> {\n  return new Promise<T | undefined>((resolve) => {\n    const timer = setTimeout(() => resolve(undefined), ms)\n    promise.then(\n      (value) => {\n        clearTimeout(timer)\n        resolve(value)\n      },\n      () => {\n        clearTimeout(timer)\n        resolve(undefined)\n      },\n    )\n  })\n}\n\ninterface StringifyOptions {\n  /** Pretty-print with 2-space indent. Default false (compact). */\n  pretty?: boolean\n  /** Truncate to this many chars, appending `…`. Default unbounded. */\n  max?: number\n}\n\n/**\n * `JSON.stringify` with a `String()` fallback on throw (cyclic / non-JSON).\n * Strings pass through unstringified so a preview of a string output is the\n * string itself, not a quoted re-encoding.\n */\nexport function stringifySafe(value: unknown, opts: StringifyOptions = {}): string {\n  let s: string\n  try {\n    if (typeof value === 'string') {\n      s = value\n    } else {\n      const json = opts.pretty ? JSON.stringify(value, null, 2) : JSON.stringify(value)\n      s = json ?? String(value)\n    }\n  } catch {\n    s = String(value)\n  }\n  if (opts.max !== undefined && s.length > opts.max) return `${s.slice(0, opts.max)}…`\n  return s\n}\n\n/** A fresh zero token-usage accumulator. */\nexport function zeroTokenUsage(): LoopTokenUsage {\n  return { input: 0, output: 0 }\n}\n\n/**\n * Sum the catalog-priced part of a dollar total across spends, as a field to spread.\n *\n * Returns nothing when no input carried one. A fold of pure provider receipts must not gain a\n * `usdEstimated: 0`, which would read as \"this runtime checked and priced none\" on a path that\n * never prices at all.\n */\nexport function usdEstimatedOf(...spends: ReadonlyArray<{ usdEstimated?: number }>): {\n  usdEstimated?: number\n} {\n  let total = 0\n  let priced = false\n  for (const spend of spends) {\n    if (spend.usdEstimated === undefined) continue\n    priced = true\n    total += spend.usdEstimated\n  }\n  return priced ? { usdEstimated: total } : {}\n}\n\n/** Copy a token subtotal without dropping optional provider cache telemetry. */\nexport function cloneTokenUsage(usage: LoopTokenUsage): LoopTokenUsage {\n  const cacheBreakdownUnknown =\n    usage.cacheBreakdownKnown === false || (usage.input > 0 && !hasClassifiedCacheBreakdown(usage))\n  return {\n    input: usage.input,\n    output: usage.output,\n    ...(usage.tokensKnown === false ? { tokensKnown: false as const } : {}),\n    ...(usage.freshInput !== undefined ? { freshInput: usage.freshInput } : {}),\n    ...(usage.cacheRead !== undefined ? { cacheRead: usage.cacheRead } : {}),\n    ...(usage.cacheWrite !== undefined ? { cacheWrite: usage.cacheWrite } : {}),\n    ...(cacheBreakdownUnknown ? { cacheBreakdownKnown: false as const } : {}),\n  }\n}\n\n/** True only when every positive prompt token has a consistent cache classification. */\nexport function hasCompleteCacheBreakdown(usage: LoopTokenUsage): boolean {\n  if (usage.cacheBreakdownKnown === false) return false\n  return hasClassifiedCacheBreakdown(usage)\n}\n\nfunction hasClassifiedCacheBreakdown(usage: LoopTokenUsage): boolean {\n  if (usage.input === 0) return true\n  if (\n    usage.freshInput === undefined ||\n    usage.cacheRead === undefined ||\n    usage.cacheWrite === undefined\n  ) {\n    return false\n  }\n  return usage.freshInput + usage.cacheRead + usage.cacheWrite === usage.input\n}\n\n/**\n * The token charge for one observation: every token counted ONCE, at the moment it first enters\n * the context — `input − cacheRead + output`.\n *\n * `input` is a rolled-up prompt total that re-counts a cached prefix on every turn that reads it,\n * so charging `input` makes a 100K prefix read 40 times cost 4.1M for content authored once. A\n * cache read is content that was already charged when it was written, so it is the one class the\n * charge subtracts. Under a complete split the result is exactly `freshInput + cacheWrite`. No\n * price weight is involved: this counts work, and money is a separate channel.\n *\n * The subtraction form is what makes the charge ADDITIVE. `input` and `cacheRead` both accumulate\n * through `addTokenUsage`, so the charge on an aggregate equals the sum of the charges on the\n * records that built it — including an aggregate that mixes classified and unclassified turns,\n * where the unclassified remainder is charged in full and only the reported cache reads are\n * credited. A form that read `freshInput + cacheWrite` directly loses that: one unclassified turn\n * would drop the whole aggregate to `input + output` and over-charge every classified turn with it.\n *\n * The one arithmetic guarantee: a set of classes that does not FIT inside the prompt total it\n * partitions credits nothing, so the charge is never below `output` and a class that overflows its\n * own total buys no tokens. It is not a guarantee against a provider that reports a cache read it\n * never served — that provider can under-report `input` just as easily, and the token channel is an\n * accounting unit, not a trust boundary. Prompt tokens the provider left unclassified are charged\n * in full, so a spend with no readable split charges an upper bound on newly-presented work rather\n * than a measurement, and every caller that enforces a ceiling must report the difference\n * (`BudgetPool` does it through `readout().cacheBreakdownKnown`).\n */\nexport function chargedTokens(usage: LoopTokenUsage): number {\n  return usage.input - creditedCacheRead(usage) + usage.output\n}\n\n/** `cacheRead` if the reported classes fit inside `input`, else nothing. */\nfunction creditedCacheRead(usage: LoopTokenUsage): number {\n  const { cacheRead } = usage\n  if (cacheRead === undefined) return 0\n  return classifiedTotal(usage, cacheRead) > usage.input ? 0 : cacheRead\n}\n\nfunction classifiedTotal(usage: Partial<LoopTokenUsage>, cacheRead: number): number {\n  return (usage.freshInput ?? 0) + cacheRead + (usage.cacheWrite ?? 0)\n}\n\n/** The prompt-cache token classes of one observation, as `LoopTokenUsage` members. */\nexport type PromptCacheTokenClasses = Pick<\n  LoopTokenUsage,\n  'freshInput' | 'cacheRead' | 'cacheWrite' | 'cacheBreakdownKnown'\n>\n\n/**\n * Translate one provider prompt-cache report into the prompt token classes `addTokenUsage` folds\n * and `chargedTokens` credits.\n *\n * The input is the open `promptCache` record an `llm_call` carries, keyed by the `PromptCacheUsage`\n * vocabulary (`readTokens`, `writeTokens`). Providers report that vocabulary unevenly, and the\n * three outcomes are different facts that must not collapse into one another:\n *\n *  - **Nothing reported** — no classes and no marker. The caller's own unknown handling decides,\n *    because a provider that says nothing about caching has not said the split is unknowable.\n *  - **Read and write both reported, and fitting inside `input`** — a complete partition, so\n *    `freshInput` is the remainder and the split is known.\n *  - **One counter reported, or classes that overflow `input`** — the counters that ARE measured\n *    pass through and `cacheBreakdownKnown` is false. A read with no write counter (OpenAI reports\n *    no write) still credits the read it measured, while declaring the rest unclassified so the\n *    charge stays a declared upper bound. An overflowing claim buys nothing: it cannot be a\n *    partition of a total it exceeds.\n *\n * A counter the provider did not report stays absent. A zero would claim the provider measured no\n * cache, which is a different fact from a provider that did not report.\n */\nexport function promptCacheTokenClasses(\n  input: number | undefined,\n  promptCache: Readonly<Record<string, number | string>> | undefined,\n): PromptCacheTokenClasses {\n  if (promptCache === undefined) return {}\n  const read = tokenCount(promptCache.readTokens)\n  const write = tokenCount(promptCache.writeTokens)\n  if (read === undefined && write === undefined) return {}\n  if (input === undefined || (read ?? 0) + (write ?? 0) > input) {\n    return { cacheBreakdownKnown: false }\n  }\n  if (read !== undefined && write !== undefined) {\n    return { freshInput: input - read - write, cacheRead: read, cacheWrite: write }\n  }\n  return {\n    ...(read !== undefined ? { cacheRead: read } : {}),\n    ...(write !== undefined ? { cacheWrite: write } : {}),\n    cacheBreakdownKnown: false,\n  }\n}\n\nfunction tokenCount(value: unknown): number | undefined {\n  return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : undefined\n}\n\n/**\n * Add the observed subtotal into `acc`; token and cache incompleteness are sticky.\n *\n * A delta whose classes do not FIT inside its own `input` contributes its prompt total and NO\n * classes. Folding them in would hide the overflow: the accumulator's larger `input` can absorb a\n * class total that overflowed the one delta that reported it, and `chargedTokens` would then credit\n * at the aggregate a cache read it refuses at the record. That is the one way the charge could come\n * out below the sum of the charges on the records that built it.\n */\nexport function addTokenUsage(acc: LoopTokenUsage, delta: Partial<LoopTokenUsage>): void {\n  acc.input += delta.input ?? 0\n  acc.output += delta.output ?? 0\n  if (delta.tokensKnown === false) acc.tokensKnown = false\n\n  const input = delta.input ?? 0\n  const fits = classifiedTotal(delta, delta.cacheRead ?? 0) <= input\n  if (fits) {\n    if (delta.freshInput !== undefined) acc.freshInput = (acc.freshInput ?? 0) + delta.freshInput\n    if (delta.cacheRead !== undefined) acc.cacheRead = (acc.cacheRead ?? 0) + delta.cacheRead\n    if (delta.cacheWrite !== undefined) acc.cacheWrite = (acc.cacheWrite ?? 0) + delta.cacheWrite\n  }\n\n  const classified =\n    fits &&\n    delta.freshInput !== undefined &&\n    delta.cacheRead !== undefined &&\n    delta.cacheWrite !== undefined &&\n    delta.freshInput + delta.cacheRead + delta.cacheWrite === input\n  // A provider that reports prompt input without all three classes leaves the\n  // split unknown. Do not let an earlier complete turn make the aggregate look\n  // complete after a later unclassified positive-input turn.\n  if (delta.cacheBreakdownKnown === false || (input > 0 && !classified)) {\n    acc.cacheBreakdownKnown = false\n  }\n}\n\n/**\n * Map `items` through `fn` with at most `limit` calls in flight at once,\n * preserving input order in the result. On the first `fn` rejection no NEW\n * items are picked up; already-in-flight calls are awaited, then the first\n * error is rethrown. `limit` is clamped to ≥ 1.\n *\n * Used where a burst of provisioning (e.g. forking N child boxes) must respect\n * the loop's concurrency bound instead of firing all N at once.\n */\nexport async function mapWithConcurrency<T, R>(\n  items: readonly T[],\n  limit: number,\n  fn: (item: T, index: number) => Promise<R>,\n): Promise<R[]> {\n  const bound = Math.max(1, Math.floor(limit))\n  const results = new Array<R>(items.length)\n  let next = 0\n  let failed = false\n  const worker = async (): Promise<void> => {\n    while (!failed) {\n      const i = next\n      next += 1\n      if (i >= items.length) return\n      try {\n        results[i] = await fn(items[i] as T, i)\n      } catch (err) {\n        failed = true\n        throw err\n      }\n    }\n  }\n  const workerCount = Math.min(bound, items.length)\n  await Promise.all(Array.from({ length: workerCount }, () => worker()))\n  return results\n}\n"],"mappings":"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"}

package/dist/{workspace-archive-B5oJu5mZ.js → workspace-archive-DFwzVhbk.js}

@@ -1,4 +1,4 @@
-import { A as verifyMaterializedWorkspace, C as assertNoGitIndirection, D as captureMaterializedWorkspace, E as candidateWorkspaceManifest, T as runCandidateGit, a as persistCandidateOutputArtifact, at as deepFreezeCandidate, ct as omitTopLevelDigest, k as verifyBytes, lt as sha256Bytes, nt as canonicalCandidateBytes, ot as embeddedCandidateArtifact, rt as canonicalCandidateDigest$1, st as immutableCandidateValue, w as readCandidateGitTreeFiles } from "./prepare-BXEtLOj9.js";
+import { A as verifyMaterializedWorkspace, C as assertNoGitIndirection, D as captureMaterializedWorkspace, E as candidateWorkspaceManifest, T as runCandidateGit, a as persistCandidateOutputArtifact, at as deepFreezeCandidate, ct as omitTopLevelDigest, k as verifyBytes, lt as sha256Bytes, nt as canonicalCandidateBytes, ot as embeddedCandidateArtifact, rt as canonicalCandidateDigest$1, st as immutableCandidateValue, w as readCandidateGitTreeFiles } from "./prepare-Cv7NzRZl.js";
 import { agentCandidateBundleSchema } from "@tangle-network/agent-interface";
 import { randomUUID } from "node:crypto";
 import { dirname, isAbsolute, join, resolve, sep, win32 } from "node:path";
@@ -572,4 +572,4 @@ const typedArrayByteLengthGetter = requireTypedArrayGetter("byteLength");
 //#endregion
 export { sealAgentCandidateBundle as i, captureAgentCandidateWorkspaceFiles as n, createAgentCandidateWorkspacePort as r, captureAgentCandidateWorkspace as t };
 
-//# sourceMappingURL=workspace-archive-B5oJu5mZ.js.map
+//# sourceMappingURL=workspace-archive-DFwzVhbk.js.map