@tangle-network/agent-runtime 0.132.0 → 0.132.3

package/dist/{supervisor-DAHeTMAT.js → supervisor-DlVTwwJb.js}

@@ -5599,17 +5599,19 @@ function readPromptOptions(loopCtx) {
 * (feed them from `readTraceContextFromEnv()`), which makes the recorder's own ids the outer ones
 * and so makes every stamped child inherit them too.
 *
-* WHICH BACKENDS PROPAGATE. Only a backend with a real environment channel to the worker can carry
-* this, and the ones that cannot say so here rather than dropping it silently:
+* WHICH BACKENDS PROPAGATE. Only a backend with a real channel to the worker can carry this, and
+* the ones that have none say so here rather than dropping it silently:
 *   - `cli`           YES — `CliSeam.env` → the spawned subprocess.
 *   - `sandbox`       YES — `CreateSandboxOptions.env` on the box the worker runs in (single-shot
 *                     and steerable). This is the cross-MACHINE case the feature exists for.
+*   - `bridge`        YES — request headers on the bridge POST (`traceparent` plus the legacy
+*                     `x-trace-id` / `x-parent-span-id` pair, {@link workerTraceHeaders}); the
+*                     bridge stamps them into the harness child's environment at spawn.
 *   - `router`,
 *     `router-tools`  NO — a direct model HTTP call. There is no worker process to inherit anything.
-*   - `bridge`,
-*     `cli-worktree`  NO — the work is dispatched over cli-bridge HTTP or through a local harness
-*                     transport that exposes no environment channel. Wiring these means adding that
-*                     channel to the transport first; until then they are honestly unpropagated.
+*   - `cli-worktree`  NO — the work is dispatched through a local harness transport that exposes
+*                     no environment channel. Wiring it means adding that channel to the transport
+*                     first; until then it is honestly unpropagated.
 *   - `provider`      NO — `AgentEnvironmentProvider` has no environment field on its port.
 */
 /**
@@ -5617,15 +5619,16 @@ function readPromptOptions(loopCtx) {
 * discriminant means an EIGHTH backend arm cannot be added without classifying it here — the prose
 * alone could go stale silently, which is the failure this table exists to prevent.
 *
-* `true` = the arm has a real environment channel to the worker and stamps the context.
-* `false` = it has none today; it is honestly unpropagated rather than silently dropping.
+* `true` = the arm has a real channel to the worker (environment or transport headers) and stamps
+* the context. `false` = it has none today; it is honestly unpropagated rather than silently
+* dropping.
 */
 const WORKER_TRACE_PROPAGATION = {
 	cli: true,
 	sandbox: true,
 	router: false,
 	"router-tools": false,
-	bridge: false,
+	bridge: true,
 	"cli-worktree": false,
 	provider: false
 };
@@ -5660,6 +5663,22 @@ function workerTraceEnv(ctx) {
 	const traceContext = readWorkerTraceContext(ctx);
 	return traceContext ? traceContextToEnv(traceContext) : {};
 }
+/**
+* The trace request headers for a worker dispatched over the cli-bridge HTTP transport — W3C
+* `traceparent` plus the legacy `x-trace-id` / `x-parent-span-id` pair the bridge also reads —
+* EMPTY when the run records no spans, which keeps the untraced request byte-identical. Derived
+* from the same dual-write the env channel uses ({@link workerTraceEnv}), so the header and env
+* spellings can never name different traces. `traceparent` is present only when a parent span id
+* exists (the W3C grammar requires one); the legacy pair still carries a lone trace id.
+*/
+function workerTraceHeaders(ctx) {
+	const env = workerTraceEnv(ctx);
+	return {
+		...env.TRACEPARENT !== void 0 ? { traceparent: env.TRACEPARENT } : {},
+		...env.TRACE_ID !== void 0 ? { "x-trace-id": env.TRACE_ID } : {},
+		...env.PARENT_SPAN_ID !== void 0 ? { "x-parent-span-id": env.PARENT_SPAN_ID } : {}
+	};
+}
 //#endregion
 //#region src/runtime/supervise/worktree-cli-executor.ts
 /**
@@ -6873,6 +6892,7 @@ const bridgeExecutor = (spec, ctx) => {
 	const maxReconnects = seam.maxReconnects ?? 3;
 	const sessionId = seam.sessionId ?? `bridge-${spec.profile.name ?? "worker"}-${randomUUID()}`;
 	const attemptId = ctx.node?.attemptId ?? newExecutionAttemptId(sessionId);
+	const traceHeaders = workerTraceHeaders(ctx);
 	const controller = new AbortController();
 	const abortIfSignalled = () => {
 		if (ctx.signal.aborted) controller.abort();
@@ -6966,6 +6986,7 @@ const bridgeExecutor = (spec, ctx) => {
 				sessionId,
 				maxTurns,
 				maxReconnects,
+				traceHeaders,
 				inbox,
 				controller,
 				activeRuns,
@@ -7200,7 +7221,8 @@ async function* streamBridgeSession(args) {
 				body: requestBody,
 				signal: turnController.signal,
 				run: activeRun,
-				maxReconnects: args.maxReconnects
+				maxReconnects: args.maxReconnects,
+				traceHeaders: args.traceHeaders
 			})) {
 				if (chunk.content) turnText += chunk.content;
 				for (const step of chunk.toolCalls ?? []) {
@@ -7338,7 +7360,8 @@ async function* streamDurableBridgeRun(args) {
 				runId: args.run.id,
 				afterEventId: args.run.lastEventId,
 				body: args.body,
-				signal: args.signal
+				signal: args.signal,
+				traceHeaders: args.traceHeaders
 			});
 		} catch (error) {
 			if (args.signal.aborted) throw error;
@@ -7462,6 +7485,7 @@ function bridgeStreamPost(url, args) {
 		const req = requestFn(target, {
 			method: "POST",
 			headers: {
+				...args.traceHeaders,
 				"content-type": "application/json",
 				authorization: `Bearer ${args.bearer}`,
 				"x-session-id": args.sessionId,
@@ -11444,10 +11468,16 @@ function assertRootIdentity(opts) {
 	const validCorrelation = correlation === void 0 || typeof correlation === "object" && correlation !== null && !Array.isArray(correlation) && Object.entries(correlation).every(([key, value]) => key.length > 0 && typeof value === "string" && value.length > 0);
 	if (unknownFields.length > 0 || !sha256DigestSchema.safeParse(identity.profileDigest).success || !sha256DigestSchema.safeParse(identity.taskDigest).success || identity.candidateDigest !== void 0 && !sha256DigestSchema.safeParse(identity.candidateDigest).success || !validCorrelation) throw new RuntimeRunStateError(`supervisor: run '${opts.runId}' requires an exact rootIdentity with valid profileDigest, taskDigest, candidateDigest, and correlation`);
 }
-function rootDeadline(root) {
+/** The instant the run's root was journaled — the anchor for both the absolute deadline and the
+*  terminal wall-clock `ms`, so a resumed run measures from its ORIGINAL start, not this
+*  process's. */
+function rootStartedAtMs(root) {
 	const startedAt = Date.parse(root.at);
 	if (!Number.isFinite(startedAt)) throw new RuntimeRunStateError(`supervisor: root event for '${root.id}' has an invalid timestamp '${root.at}'`);
-	return startedAt + (root.budget.deadlineMs ?? 0);
+	return startedAt;
+}
+function rootDeadline(root) {
+	return rootStartedAtMs(root) + (root.budget.deadlineMs ?? 0);
 }
 /** Child reservations whose spawn was durable but whose terminal record never landed. */
 function uncertainSpawnBudgets(events) {
@@ -11535,8 +11565,10 @@ function createSupervisor() {
 			const resuming = prior !== void 0 && prior.length > 0;
 			let resumeFrom;
 			let pool;
+			let runEpochMs = runStartedAtMs;
 			if (resuming) {
 				const rootEvent = assertResumeContract(prior, opts);
+				runEpochMs = rootStartedAtMs(rootEvent);
 				const measured = sumMeasuredSpendFromEvents(prior);
 				const uncertainReservations = uncertainSpawnBudgets(prior);
 				pool = createBudgetPool(opts.budget, now, {
@@ -11691,13 +11723,14 @@ function createSupervisor() {
 				if (out !== void 0) {
 					const outRef = contentAddress(out);
 					await opts.blobs.put(outRef, out);
-					const { childWork, driverInference } = await spentFromJournal(journal, opts.runId);
+					const { spentTotal, childWork, driverInference, gaps } = await terminalAccounting(journal, opts.runId, now() - runEpochMs);
 					return {
 						kind: "winner",
 						out,
 						outRef,
 						tree,
-						spentTotal: addSpend(childWork, driverInference),
+						spentTotal,
+						...gaps.length > 0 ? { spendGaps: gaps } : {},
 						...isNonEmptySpend(driverInference) ? { spentBreakdown: {
 							driverInference,
 							childWork
@@ -11708,12 +11741,13 @@ function createSupervisor() {
 			}
 			return noWinner({ error: actOutcome.error });
 			async function noWinner(rejection) {
-				const { childWork, driverInference } = await spentFromJournal(journal, opts.runId);
+				const { spentTotal, gaps } = await terminalAccounting(journal, opts.runId, now() - runEpochMs);
 				const common = {
 					kind: "no-winner",
 					tree,
 					downCount: breaker.downCount(),
-					spentTotal: addSpend(childWork, driverInference)
+					spentTotal,
+					...gaps.length > 0 ? { spendGaps: gaps } : {}
 				};
 				const lifecycle = classifyNoWinner(executionAborted, pool, opts, breaker, deadlineExceeded, allChildrenDownAtSettle, downCountAtSettle);
 				if (lifecycle !== void 0) return {
@@ -11954,16 +11988,81 @@ function poolExhausted(pool, opts) {
 	return false;
 }
 /**
-* Sum the conserved spend over every journaled `settled` event — the honest per-channel
-* total (input/output/usd/iterations all preserved), read off the same evidence replay
-* reads. Computed AFTER the join barrier so every child's settlement is recorded. Fails
-* loud if the tree was never journaled (the supervisor always `beginTree`s, so a missing
-* tree is a corrupted journal, not a normal path).
+* The run's terminal accounting, read off the one journal ledger — the honest per-channel
+* sums (input/output/usd/iterations all preserved), the named usage gaps, and the wall-clock
+* duration stamped onto `spentTotal.ms`. Computed AFTER the join barrier so every child's
+* settlement is recorded. Fails loud if the tree was never journaled (the supervisor always
+* `beginTree`s, so a missing tree is a corrupted journal, not a normal path).
+*
+* `spentTotal.ms` is `elapsedMs`, never the per-event sum: executors under-report their own
+* `ms` (most stamp 0) and parallel children overlap, so the sum cannot state the run's real
+* duration. The breakdown keeps the executor-reported sums.
+*
+* `tokensKnown`/`usdKnown` are stamped explicitly on the terminal total: `true` is a checked
+* claim (every spawn reached a terminal record AND every settled/metered record carried a
+* complete receipt on that channel), never the absence of bad news. The conjunction with the
+* summed flags is deliberately redundant — a future divergence between the sum and the gap
+* scan can only make the claim more conservative, never falsely `true`.
 */
-async function spentFromJournal(journal, root) {
+async function terminalAccounting(journal, root, elapsedMs) {
 	const events = await journal.loadTree(root);
 	if (events === void 0) throw new RuntimeRunStateError(`supervisor: spawn tree '${root}' is missing from the journal after run (corrupted log)`);
-	return sumSpendFromEvents(events);
+	const { childWork, driverInference } = sumSpendFromEvents(events);
+	const gaps = spendGapsFromEvents(events);
+	const summed = addSpend(childWork, driverInference);
+	return {
+		spentTotal: {
+			...summed,
+			ms: Math.max(0, elapsedMs),
+			tokensKnown: summed.tokensKnown !== false && !gaps.some((gap) => gap.channels.includes("tokens")),
+			usdKnown: summed.usdKnown !== false && !gaps.some((gap) => gap.channels.includes("usd"))
+		},
+		childWork,
+		driverInference,
+		gaps
+	};
+}
+/** The journaled nodes whose usage accounting is incomplete — one `SpendGap` per node+kind,
+*  channels merged. A spawn with no terminal record (`settled`/`cancelled`/`woken`) is
+*  unaccounted on every channel; a settled or metered record that flags a channel unknown is
+*  a floor on that channel. The root's own spawned event is exempt: its terminal state is the
+*  result this list rides on. */
+function spendGapsFromEvents(events) {
+	const labels = /* @__PURE__ */ new Map();
+	const terminal = /* @__PURE__ */ new Set();
+	for (const ev of events) if (ev.kind === "spawned") labels.set(ev.id, ev.label);
+	else if (ev.kind === "settled" || ev.kind === "cancelled" || ev.kind === "woken") terminal.add(ev.id);
+	const gaps = /* @__PURE__ */ new Map();
+	const record = (id, kind, channels) => {
+		if (channels.length === 0) return;
+		const key = `${kind}:${id}`;
+		const existing = gaps.get(key);
+		if (existing !== void 0) for (const channel of channels) existing.channels.add(channel);
+		else gaps.set(key, {
+			id,
+			kind,
+			channels: new Set(channels)
+		});
+	};
+	for (const ev of events) if (ev.kind === "spawned" && ev.parent !== void 0 && !terminal.has(ev.id)) record(ev.id, "never-settled", ["tokens", "usd"]);
+	else if (ev.kind === "settled") record(ev.id, "unreported", unknownChannels(ev.spent));
+	else if (ev.kind === "metered") record(ev.id, "unreported", unknownChannels(ev.spend));
+	return [...gaps.values()].map((gap) => {
+		const label = labels.get(gap.id);
+		return {
+			id: gap.id,
+			...label !== void 0 ? { label } : {},
+			kind: gap.kind,
+			channels: [...gap.channels]
+		};
+	});
+}
+/** The channels a single spend record explicitly marks incomplete. */
+function unknownChannels(spend) {
+	const channels = [];
+	if (spend.tokensKnown === false) channels.push("tokens");
+	if (spend.usdKnown === false) channels.push("usd");
+	return channels;
 }
 /** Per-channel sum over a journaled event list: `settled` = spawned-child work (reconciled);
 *  `metered` = driver inference (re-homed up the tree, so a single root-tree pass already
@@ -12035,6 +12134,6 @@ function isNonEmptySpend(s) {
 	return s.iterations > 0 || s.tokens.input > 0 || s.tokens.output > 0 || s.usd > 0 || s.ms > 0 || s.tokensKnown === false || s.usdKnown === false;
 }
 //#endregion
-export { createSandboxLineage as $, bindReusableExecutorExecutionId as A, removeWorktree as At, workerTraceSeamKey as B, defineProfileMaterializationContract as Bt, queueOf as C, sanitizeAgentRuntimeEvent as Ct, assertValidBudget as D, runWorktreeHarness as Dt, teardownExecutor as E, runSettledCommand as Et, snapshotExecutorConfig as F, parseCodexTokenUsage as Ft, sandboxSessionTraceSource as G, promptOnlyProfileMaterialization as Gt, createSteerableSandboxSession as H, profileMaterializationAxes$1 as Ht, createWorktreeCliExecutor as I, CodexExecutionDiagnosticError as It, readWorkerProgress as J, sandboxActProfileMaterialization as Jt, DEFAULT_STALL_AFTER_MS as K, promptResourceProfileMaterialization as Kt, WORKER_TRACE_PROPAGATION as L, AGENT_PROFILE_MATERIALIZATION_AXES as Lt, cliWorktreeExecutor as M, LOCAL_HARNESSES as Mt, createExecutor as N, harnessSupportsReasoningEffort as Nt, createBudgetPool as O, captureWorktreeDiff as Ot, createExecutorRegistry as P, localHarnessExecutable as Pt, runAgentRounds as Q, readWorkerTraceContext as R, assertProfileMaterialization as Rt, freeSlots as S, createRuntimeStreamEventCollector as St, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as T, sanitizeRuntimeStreamEvent as Tt, createPushTraceSource as U, promptControlProfileMaterialization as Ut, DEFAULT_SANDBOX_STEERING_MAX_TURNS as V, fullProfileMaterialization as Vt, decodeToolPart as W, promptModelProfileMaterialization as Wt, createSandboxForSpec as X, worktreeCliProfileMaterialization as Xt, createInbox as Y, validateProfileMaterialization as Yt, defaultSelectWinner as Z, pollFor as _, loopEventToOtelSpan as _t, pickBestDelivered as a, mergeTraceEnv as at, waitUntil as b, toOtelAttributes as bt, driverChild as c, INTELLIGENCE_WIRE_VERSION as ct, deriveNodeExecutionIdentity as d, buildRuntimeEventOtelSpans as dt, probeSandboxCapabilities as et, recordScopeOwnerMaterialization as f, createOpenInferenceFileExporter as ft, isWaitOutcome as g, generateSpanId as gt, createWaitProbes as h, flatOtelSpan as ht, collectDelivered as i, createPropagatingTraceEmitter as it, captureReusableExecutorConfig as j, DEFAULT_LOCAL_HARNESS as jt, spendFromUsageEvents as k, createWorktree as kt, withDriverExecutor as l, buildLoopOtelSpans as lt, settledToIteration as m, exportEvalRuns as mt, createSupervisor as n, routerBrain as nt, runFinalizer as o, readTraceContextFromEnv as ot, scopeOwnerExecutorNodeContext as p, createOtelExporter as pt, createActivityLog as q, renderProfileMaterializationIssues as qt, bestDelivered as r, runBrainLoop as rt, runTree as s, traceContextToEnv as st, createRootHandle as t, acquireSandbox as tt, createScope as u, buildLoopSpanNodes as ut, timerAt as v, padSpanId as vt, rollingDispatch as w, sanitizeKnowledgeReadinessReport as wt, effectiveConcurrency as x, createRuntimeEventCollector as xt, validateWaitSpec as y, padTraceId as yt, workerTraceEnv as z, controlProfileMaterialization as zt };
+export { runAgentRounds as $, bindReusableExecutorExecutionId as A, createWorktree as At, workerTraceHeaders as B, controlProfileMaterialization as Bt, queueOf as C, createRuntimeStreamEventCollector as Ct, assertValidBudget as D, runSettledCommand as Dt, teardownExecutor as E, sanitizeRuntimeStreamEvent as Et, snapshotExecutorConfig as F, localHarnessExecutable as Ft, decodeToolPart as G, promptModelProfileMaterialization as Gt, DEFAULT_SANDBOX_STEERING_MAX_TURNS as H, fullProfileMaterialization as Ht, createWorktreeCliExecutor as I, parseCodexTokenUsage as It, createActivityLog as J, renderProfileMaterializationIssues as Jt, sandboxSessionTraceSource as K, promptOnlyProfileMaterialization as Kt, WORKER_TRACE_PROPAGATION as L, CodexExecutionDiagnosticError as Lt, cliWorktreeExecutor as M, DEFAULT_LOCAL_HARNESS as Mt, createExecutor as N, LOCAL_HARNESSES as Nt, createBudgetPool as O, runWorktreeHarness as Ot, createExecutorRegistry as P, harnessSupportsReasoningEffort as Pt, defaultSelectWinner as Q, readWorkerTraceContext as R, AGENT_PROFILE_MATERIALIZATION_AXES as Rt, freeSlots as S, createRuntimeEventCollector as St, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as T, sanitizeKnowledgeReadinessReport as Tt, createSteerableSandboxSession as U, profileMaterializationAxes$1 as Ut, workerTraceSeamKey as V, defineProfileMaterializationContract as Vt, createPushTraceSource as W, promptControlProfileMaterialization as Wt, createInbox as X, validateProfileMaterialization as Xt, readWorkerProgress as Y, sandboxActProfileMaterialization as Yt, createSandboxForSpec as Z, worktreeCliProfileMaterialization as Zt, pollFor as _, generateSpanId as _t, pickBestDelivered as a, createPropagatingTraceEmitter as at, waitUntil as b, padTraceId as bt, driverChild as c, traceContextToEnv as ct, deriveNodeExecutionIdentity as d, buildLoopSpanNodes as dt, createSandboxLineage as et, recordScopeOwnerMaterialization as f, buildRuntimeEventOtelSpans as ft, isWaitOutcome as g, flatOtelSpan as gt, createWaitProbes as h, exportEvalRuns as ht, collectDelivered as i, runBrainLoop as it, captureReusableExecutorConfig as j, removeWorktree as jt, spendFromUsageEvents as k, captureWorktreeDiff as kt, withDriverExecutor as l, INTELLIGENCE_WIRE_VERSION as lt, settledToIteration as m, createOtelExporter as mt, createSupervisor as n, acquireSandbox as nt, runFinalizer as o, mergeTraceEnv as ot, scopeOwnerExecutorNodeContext as p, createOpenInferenceFileExporter as pt, DEFAULT_STALL_AFTER_MS as q, promptResourceProfileMaterialization as qt, bestDelivered as r, routerBrain as rt, runTree as s, readTraceContextFromEnv as st, createRootHandle as t, probeSandboxCapabilities as tt, createScope as u, buildLoopOtelSpans as ut, timerAt as v, loopEventToOtelSpan as vt, rollingDispatch as w, sanitizeAgentRuntimeEvent as wt, effectiveConcurrency as x, toOtelAttributes as xt, validateWaitSpec as y, padSpanId as yt, workerTraceEnv as z, assertProfileMaterialization as zt };
 
-//# sourceMappingURL=supervisor-DAHeTMAT.js.map
+//# sourceMappingURL=supervisor-DlVTwwJb.js.map