@tangle-network/agent-runtime 0.195.1 → 0.196.0

package/dist/{environment-provider-adVa6X7a.d.ts → environment-provider-B-I2jlQy.d.ts}

@@ -1,5 +1,5 @@
-import { E as SandboxClient, k as Validator } from "./types-BdolQ6Zi.js";
-import { p as ExecutorFactory, z as Runtime } from "./types-B_pNTBjK.js";
+import { E as SandboxClient, k as Validator } from "./types-Q0PMagdm.js";
+import { p as ExecutorFactory, z as Runtime } from "./types-DFLZMaeh.js";
 import { AgentProfile, AgentProfileValidationResult } from "@tangle-network/agent-interface";
 import { BackendType, CreateSandboxOptions, PromptOptions, Sandbox } from "@tangle-network/sandbox";
 import { AgentEnvironment as AgentEnvironment$1, AgentEnvironmentCapabilities, AgentEnvironmentCapabilities as AgentEnvironmentCapabilities$1, AgentEnvironmentEvent, AgentEnvironmentEvent as AgentEnvironmentEvent$1, AgentEnvironmentProvider, AgentEnvironmentProvider as AgentEnvironmentProvider$1, AgentEnvironmentQuery, AgentEnvironmentStatus, AgentEnvironmentSummary, AgentProfileRef, AgentProfileRef as AgentProfileRef$1, AgentSession, AgentSessionRef, AgentSessionStatus as AgentSessionStatus$1, AgentTurnInput, AgentTurnInput as AgentTurnInput$1, AgentTurnResult as AgentTurnResult$1, CheckpointRef, CheckpointRequest, CreateAgentEnvironmentInput, CreateAgentEnvironmentInput as CreateAgentEnvironmentInput$1, ExecRequest, ExecResult, ForkRequest, PlacementInfo, ResourceRequest, WorkspaceRequest } from "@tangle-network/agent-interface/environment-provider";
@@ -140,4 +140,4 @@ interface ProviderExecutorOptions {
 declare function providerAsExecutor(provider: AgentEnvironmentProvider, options?: ProviderExecutorOptions): ExecutorFactory<unknown>;
 //#endregion
 export { createAgentEnvironmentProviderRegistry as A, ProviderAsSandboxClientOptions as C, ResourceRequest as D, ProviderPromptOptions as E, CreateTangleSandboxExactProcessProviderOptions as F, SandboxControlClient as I, createTangleSandboxExactProcessProvider as L, providerAsSandboxClient as M, resolveAgentEnvironmentProvider as N, SandboxClientProviderOptions as O, sandboxClientAsProvider as P, PlacementInfo as S, ProviderLeafOut as T, CheckpointRequest as _, AgentEnvironmentProviderRef as a, ExecResult as b, AgentEnvironmentStatus as c, AgentSession as d, AgentSessionRef as f, CheckpointRef as g, AgentTurnResult$1 as h, AgentEnvironmentProvider$1 as i, providerAsExecutor as j, WorkspaceRequest as k, AgentEnvironmentSummary as l, AgentTurnInput$1 as m, AgentEnvironmentCapabilities$1 as n, AgentEnvironmentProviderRegistry as o, AgentSessionStatus$1 as p, AgentEnvironmentEvent$1 as r, AgentEnvironmentQuery as s, AgentEnvironment$1 as t, AgentProfileRef$1 as u, CreateAgentEnvironmentInput$1 as v, ProviderExecutorOptions as w, ForkRequest as x, ExecRequest as y };
-//# sourceMappingURL=environment-provider-adVa6X7a.d.ts.map
+//# sourceMappingURL=environment-provider-B-I2jlQy.d.ts.map

package/dist/environment-provider.d.ts

@@ -1,2 +1,2 @@
-import { A as createAgentEnvironmentProviderRegistry, C as ProviderAsSandboxClientOptions, D as ResourceRequest, E as ProviderPromptOptions, F as CreateTangleSandboxExactProcessProviderOptions, L as createTangleSandboxExactProcessProvider, M as providerAsSandboxClient, N as resolveAgentEnvironmentProvider, O as SandboxClientProviderOptions, P as sandboxClientAsProvider, S as PlacementInfo, T as ProviderLeafOut, _ as CheckpointRequest, a as AgentEnvironmentProviderRef, b as ExecResult, c as AgentEnvironmentStatus, d as AgentSession, f as AgentSessionRef, g as CheckpointRef, h as AgentTurnResult, i as AgentEnvironmentProvider, j as providerAsExecutor, k as WorkspaceRequest, l as AgentEnvironmentSummary, m as AgentTurnInput, n as AgentEnvironmentCapabilities, o as AgentEnvironmentProviderRegistry, p as AgentSessionStatus, r as AgentEnvironmentEvent, s as AgentEnvironmentQuery, t as AgentEnvironment, u as AgentProfileRef, v as CreateAgentEnvironmentInput, w as ProviderExecutorOptions, x as ForkRequest, y as ExecRequest } from "./environment-provider-adVa6X7a.js";
+import { A as createAgentEnvironmentProviderRegistry, C as ProviderAsSandboxClientOptions, D as ResourceRequest, E as ProviderPromptOptions, F as CreateTangleSandboxExactProcessProviderOptions, L as createTangleSandboxExactProcessProvider, M as providerAsSandboxClient, N as resolveAgentEnvironmentProvider, O as SandboxClientProviderOptions, P as sandboxClientAsProvider, S as PlacementInfo, T as ProviderLeafOut, _ as CheckpointRequest, a as AgentEnvironmentProviderRef, b as ExecResult, c as AgentEnvironmentStatus, d as AgentSession, f as AgentSessionRef, g as CheckpointRef, h as AgentTurnResult, i as AgentEnvironmentProvider, j as providerAsExecutor, k as WorkspaceRequest, l as AgentEnvironmentSummary, m as AgentTurnInput, n as AgentEnvironmentCapabilities, o as AgentEnvironmentProviderRegistry, p as AgentSessionStatus, r as AgentEnvironmentEvent, s as AgentEnvironmentQuery, t as AgentEnvironment, u as AgentProfileRef, v as CreateAgentEnvironmentInput, w as ProviderExecutorOptions, x as ForkRequest, y as ExecRequest } from "./environment-provider-B-I2jlQy.js";
 export { type AgentEnvironment, type AgentEnvironmentCapabilities, type AgentEnvironmentEvent, type AgentEnvironmentProvider, AgentEnvironmentProviderRef, AgentEnvironmentProviderRegistry, type AgentEnvironmentQuery, type AgentEnvironmentStatus, type AgentEnvironmentSummary, type AgentProfileRef, type AgentSession, type AgentSessionRef, type AgentSessionStatus, type AgentTurnInput, type AgentTurnResult, type CheckpointRef, type CheckpointRequest, type CreateAgentEnvironmentInput, type CreateTangleSandboxExactProcessProviderOptions, type ExecRequest, type ExecResult, type ForkRequest, type PlacementInfo, ProviderAsSandboxClientOptions, ProviderExecutorOptions, ProviderLeafOut, ProviderPromptOptions, type ResourceRequest, SandboxClientProviderOptions, type WorkspaceRequest, createAgentEnvironmentProviderRegistry, createTangleSandboxExactProcessProvider, providerAsExecutor, providerAsSandboxClient, resolveAgentEnvironmentProvider, sandboxClientAsProvider };

package/dist/environment-provider.js

@@ -1,2 +1,2 @@
-import { a as sandboxClientAsProvider, i as resolveAgentEnvironmentProvider, n as providerAsExecutor, o as createTangleSandboxExactProcessProvider, r as providerAsSandboxClient, t as createAgentEnvironmentProviderRegistry } from "./environment-provider-Z1JazbJ1.js";
+import { a as sandboxClientAsProvider, i as resolveAgentEnvironmentProvider, n as providerAsExecutor, o as createTangleSandboxExactProcessProvider, r as providerAsSandboxClient, t as createAgentEnvironmentProviderRegistry } from "./environment-provider-1fKZh2zl.js";
 export { createAgentEnvironmentProviderRegistry, createTangleSandboxExactProcessProvider, providerAsExecutor, providerAsSandboxClient, resolveAgentEnvironmentProvider, sandboxClientAsProvider };

package/dist/{errors-CDZ8XsVj.js → errors-DodWX-cb.js}

@@ -60,6 +60,13 @@ var BackendTransportError = class extends AgentEvalError {
 	*/
 	providerDispatch;
 	/**
+	* The upstream's own error class when it names one (the bridge's `parse_error`,
+	* `not_configured`, a provider's `invalid_request_error`). A class the upstream never
+	* retries is a decision about the request, so a retry policy may read it where no
+	* status arrived.
+	*/
+	upstreamCode;
+	/**
 	* Truncated upstream response body (≤2 KiB) when available. Diagnostic
 	* only — surfaces in `backend_error.error.body` and `final.error.body`
 	* so operators can see "free_tier_limit", "invalid_api_key", etc. without
@@ -70,6 +77,7 @@ var BackendTransportError = class extends AgentEvalError {
 		super("config", message, options);
 		this.backend = backend;
 		this.status = options?.status;
+		this.upstreamCode = options?.upstreamCode;
 		this.body = options?.body;
 		this.providerDispatch = options?.providerDispatch;
 	}
@@ -184,4 +192,4 @@ var RetainedRunDispatchBindingError = class extends AgentEvalError {
 //#endregion
 export { JudgeError as a, RetainedInteractiveAdmissionError as c, RetainedRunDispatchBindingError as d, RuntimeRunStateError as f, ConfigError as i, RetainedInteractiveBindingError as l, ValidationError as m, AnalystError as n, NotFoundError as o, SessionMismatchError as p, BackendTransportError as r, PlannerError as s, AgentEvalError$1 as t, RetainedRunAdmissionError as u };
 
-//# sourceMappingURL=errors-CDZ8XsVj.js.map
+//# sourceMappingURL=errors-DodWX-cb.js.map

package/dist/errors-DodWX-cb.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-DodWX-cb.js","names":[],"sources":["../src/errors.ts"],"sourcesContent":["/**\n *\n * Error taxonomy for `@tangle-network/agent-runtime`.\n *\n * Public contract: every error this package throws as part of its consumer-\n * facing API either extends `AgentEvalError` (re-exported here for ergonomic\n * `instanceof` checks at the runtime boundary) or extends one of the\n * runtime-specific subclasses below.\n *\n * Internal invariant guards (`throw new Error('this should never happen')`)\n * remain plain `Error` — they are programmer-mistake assertions, not\n * consumer-catchable contract failures.\n *\n * Subclassing strategy: where a runtime-specific failure maps cleanly to an\n * agent-eval code (validation, config, not_found), we re-use the agent-eval\n * subclass. Runtime-only failure modes (session resume against the wrong\n * backend, backend transport errors) get fresh subclasses that still carry an\n * `AgentEvalErrorCode` so cross-package handlers can pattern-match without\n * importing the runtime.\n *\n * @stable\n */\n\nimport { AgentEvalError } from '@tangle-network/agent-eval'\nimport type {\n  AgentInteractiveSessionRef,\n  AgentInteractiveSessionStart,\n  AgentInteractiveSessionStatus,\n} from '@tangle-network/agent-interface'\nimport type {\n  RetainedInteractiveAdmission,\n  RetainedRunAdmission,\n} from './runtime/retained-run-types'\n\nexport {\n  AgentEvalError,\n  type AgentEvalErrorCode,\n  ConfigError,\n  JudgeError,\n  NotFoundError,\n  ValidationError,\n} from '@tangle-network/agent-eval'\n\n/**\n *\n * Caller asked to resume a session against a backend whose `kind` does not\n * match the session's recorded backend. This is a routing bug — the same\n * session id was reused across two different backend implementations — and\n * is not retryable without picking the right backend.\n *\n * @stable\n */\nexport class SessionMismatchError extends AgentEvalError {\n  readonly sessionBackend: string\n  readonly requestedBackend: string\n\n  constructor(sessionBackend: string, requestedBackend: string, options?: { cause?: unknown }) {\n    super(\n      'validation',\n      `Cannot resume ${sessionBackend} session with ${requestedBackend} backend`,\n      options,\n    )\n    this.sessionBackend = sessionBackend\n    this.requestedBackend = requestedBackend\n  }\n}\n\n/**\n *\n * A backend transport call (HTTP, gRPC, sidecar IPC) failed with a non-success\n * status. Distinct from `JudgeError` (which is structural / unrecoverable)\n * because backend failures are sometimes retryable and consumers may want to\n * branch on the upstream status code.\n *\n * @stable\n */\nexport class BackendTransportError extends AgentEvalError {\n  readonly backend: string\n  readonly status?: number\n  /**\n   * Router-owned proof that a rejected request never reached a provider.\n   *\n   * This is intentionally one-sided. An absent value, or any value this\n   * package does not understand, remains unknown to Runtime.\n   */\n  readonly providerDispatch?: 'not_started'\n  /**\n   * The upstream's own error class when it names one (the bridge's `parse_error`,\n   * `not_configured`, a provider's `invalid_request_error`). A class the upstream never\n   * retries is a decision about the request, so a retry policy may read it where no\n   * status arrived.\n   */\n  readonly upstreamCode?: string\n  /**\n   * Truncated upstream response body (≤2 KiB) when available. Diagnostic\n   * only — surfaces in `backend_error.error.body` and `final.error.body`\n   * so operators can see \"free_tier_limit\", \"invalid_api_key\", etc. without\n   * cracking the log line open.\n   */\n  readonly body?: string\n\n  constructor(\n    backend: string,\n    message: string,\n    options?: {\n      cause?: unknown\n      status?: number\n      upstreamCode?: string\n      body?: string\n      providerDispatch?: 'not_started'\n    },\n  ) {\n    super('config', message, options)\n    this.backend = backend\n    this.status = options?.status\n    this.upstreamCode = options?.upstreamCode\n    this.body = options?.body\n    this.providerDispatch = options?.providerDispatch\n  }\n}\n\n/**\n *\n * A runtime-run lifecycle method was called in an order the state machine does\n * not allow: `persist()` before `complete()`, `complete()` twice, etc.\n *\n * @stable\n */\nexport class RuntimeRunStateError extends AgentEvalError {\n  constructor(message: string, options?: { cause?: unknown }) {\n    super('validation', message, options)\n  }\n}\n\n/**\n *\n * The dynamic-loop planner returned an unusable topology move — the LLM emitted\n * no parseable envelope, an unknown `kind`, or a structurally-invalid move\n * (e.g. a fanout with zero tasks). This is a structural failure of the\n * agent-authored topology, not a config mistake: the planner ran but its output\n * cannot drive the kernel. Carries `validation` so cross-package handlers can\n * pattern-match without importing the runtime. Fail loud — never substitute a\n * default move, or the loop silently runs a topology nobody chose.\n *\n * @stable\n */\nexport class PlannerError extends AgentEvalError {\n  constructor(message: string, options?: { cause?: unknown }) {\n    super('validation', message, options)\n  }\n}\n\n/**\n * The analyst loop could not read or run over a round's trace — e.g. an empty round\n * (no iterations to analyze) or a malformed trace projection. Fail loud: a silent empty\n * store would mask a broken capture path and the driver would steer on nothing.\n */\nexport class AnalystError extends AgentEvalError {\n  constructor(message: string, options?: { cause?: unknown }) {\n    super('validation', message, options)\n  }\n}\n\n/**\n *\n * The caller's `onAdmission` durability hook rejected, so a retained run's\n * admission record is not durable. For a pre-create intent, no provider work\n * has started. For a later record, provider state may already be live and the\n * environment remains available for recovery. Carries `capture_integrity`\n * because the required recovery record was not written.\n *\n * @stable\n */\nabstract class RetainedAdmissionError<\n  TAdmission extends RetainedRunAdmission | RetainedInteractiveAdmission,\n> extends AgentEvalError {\n  readonly phase: TAdmission['phase']\n  /** The exact record the hook failed to persist, for direct recovery. */\n  readonly admission: TAdmission\n\n  constructor(admission: TAdmission, options?: { cause?: unknown }) {\n    const recovery =\n      admission.phase === 'intent' || admission.phase === 'interactive_intent'\n        ? 'no provider work has started'\n        : 'the environment is kept for recovery'\n    super(\n      'capture_integrity',\n      `retained run admission (${admission.phase}) was not persisted; ${recovery}`,\n      options,\n    )\n    this.phase = admission.phase\n    this.admission = admission\n  }\n}\n\n/** The caller could not persist one detached-run recovery record. @stable */\nexport class RetainedRunAdmissionError extends RetainedAdmissionError<RetainedRunAdmission> {}\n\n/** The caller could not persist one exact interactive-process recovery record. @stable */\nexport class RetainedInteractiveAdmissionError extends RetainedAdmissionError<RetainedInteractiveAdmission> {}\n\n/**\n * A provider returned a valid interactive reference that does not bind to the\n * exact start request, or returned data that could not be parsed as one.\n *\n * The requested start and any valid provider reference are detached snapshots.\n * Malformed provider data is never copied into the error, so the error remains\n * safe to persist while the environment remains available for orphan cleanup.\n *\n * @stable\n */\nexport class RetainedInteractiveBindingError extends AgentEvalError {\n  /** The exact native-process start request sent to the provider. */\n  readonly requested: AgentInteractiveSessionStart\n  /** The valid provider data, when the provider returned a parseable value. */\n  readonly returned: {\n    readonly ref?: AgentInteractiveSessionRef\n    readonly status?: AgentInteractiveSessionStatus\n  }\n\n  constructor(\n    requested: AgentInteractiveSessionStart,\n    returned: RetainedInteractiveBindingError['returned'],\n    options?: { cause?: unknown },\n  ) {\n    super(\n      'backend_integrity',\n      'provider returned interactive data that does not bind to the requested start; the environment is kept for diagnosis and cleanup',\n      options,\n    )\n    this.requested = Object.freeze(requested)\n    this.returned = Object.freeze(returned)\n  }\n}\n\n/**\n *\n * A retained dispatch answered with coordinates that do not bind to the\n * identity the runtime requested, or failed exact verification. The\n * environment-phase admission is already durable at this point, so its\n * coordinates plus the provider reference carried here are the manual\n * recovery path. The environment is intentionally kept. Carries\n * `backend_integrity` because the provider violated its dispatch contract.\n *\n * @stable\n */\nexport class RetainedRunDispatchBindingError extends AgentEvalError {\n  /** The coordinates the runtime sent with the dispatch. */\n  readonly requested: {\n    readonly provider: string\n    readonly environmentId: string\n    readonly sessionId: string\n    readonly executionId: string\n  }\n  /** The loose reference the provider actually returned, for triage. */\n  readonly returned: {\n    readonly id?: string\n    readonly provider?: string\n    readonly controlRef?: unknown\n  }\n\n  constructor(\n    requested: RetainedRunDispatchBindingError['requested'],\n    returned: RetainedRunDispatchBindingError['returned'],\n    options?: { cause?: unknown },\n  ) {\n    super(\n      'backend_integrity',\n      'retained dispatch did not bind to the requested identity; the durable environment admission and the returned reference on this error are the recovery path',\n      options,\n    )\n    this.requested = requested\n    this.returned = returned\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDA,IAAa,uBAAb,cAA0C,eAAe;CACvD;CACA;CAEA,YAAY,gBAAwB,kBAA0B,SAA+B;EAC3F,MACE,cACA,iBAAiB,eAAe,gBAAgB,iBAAiB,WACjE,OACF;EACA,KAAK,iBAAiB;EACtB,KAAK,mBAAmB;CAC1B;AACF;;;;;;;;;;AAWA,IAAa,wBAAb,cAA2C,eAAe;CACxD;CACA;;;;;;;CAOA;;;;;;;CAOA;;;;;;;CAOA;CAEA,YACE,SACA,SACA,SAOA;EACA,MAAM,UAAU,SAAS,OAAO;EAChC,KAAK,UAAU;EACf,KAAK,SAAS,SAAS;EACvB,KAAK,eAAe,SAAS;EAC7B,KAAK,OAAO,SAAS;EACrB,KAAK,mBAAmB,SAAS;CACnC;AACF;;;;;;;;AASA,IAAa,uBAAb,cAA0C,eAAe;CACvD,YAAY,SAAiB,SAA+B;EAC1D,MAAM,cAAc,SAAS,OAAO;CACtC;AACF;;;;;;;;;;;;;AAcA,IAAa,eAAb,cAAkC,eAAe;CAC/C,YAAY,SAAiB,SAA+B;EAC1D,MAAM,cAAc,SAAS,OAAO;CACtC;AACF;;;;;;AAOA,IAAa,eAAb,cAAkC,eAAe;CAC/C,YAAY,SAAiB,SAA+B;EAC1D,MAAM,cAAc,SAAS,OAAO;CACtC;AACF;;;;;;;;;;;AAYA,IAAe,yBAAf,cAEU,eAAe;CACvB;;CAEA;CAEA,YAAY,WAAuB,SAA+B;EAChE,MAAM,WACJ,UAAU,UAAU,YAAY,UAAU,UAAU,uBAChD,iCACA;EACN,MACE,qBACA,2BAA2B,UAAU,MAAM,uBAAuB,YAClE,OACF;EACA,KAAK,QAAQ,UAAU;EACvB,KAAK,YAAY;CACnB;AACF;;AAGA,IAAa,4BAAb,cAA+C,uBAA6C,CAAC;;AAG7F,IAAa,oCAAb,cAAuD,uBAAqD,CAAC;;;;;;;;;;;AAY7G,IAAa,kCAAb,cAAqD,eAAe;;CAElE;;CAEA;CAKA,YACE,WACA,UACA,SACA;EACA,MACE,qBACA,mIACA,OACF;EACA,KAAK,YAAY,OAAO,OAAO,SAAS;EACxC,KAAK,WAAW,OAAO,OAAO,QAAQ;CACxC;AACF;;;;;;;;;;;;AAaA,IAAa,kCAAb,cAAqD,eAAe;;CAElE;;CAOA;CAMA,YACE,WACA,UACA,SACA;EACA,MACE,qBACA,8JACA,OACF;EACA,KAAK,YAAY;EACjB,KAAK,WAAW;CAClB;AACF"}

package/dist/{graph-DqPUeri6.js → graph-BuS-NxXD.js}

@@ -1,8 +1,8 @@
-import { i as ConfigError, m as ValidationError } from "./errors-CDZ8XsVj.js";
-import { f as harnessRunsAgent } from "./model-policy-Wf2MxXJ9.js";
-import { Ht as InMemorySpawnJournal, Vt as InMemoryResultBlobStore } from "./redact-Dv6PeuQz.js";
+import { i as ConfigError, m as ValidationError } from "./errors-DodWX-cb.js";
+import { f as harnessRunsAgent } from "./model-policy-DKDyr-fc.js";
+import { Ht as InMemorySpawnJournal, Vt as InMemoryResultBlobStore } from "./redact-Cbl2O-4N.js";
 import { t as composeRuntimeHooks } from "./runtime-hooks-tXpAarhW.js";
-import { n as supervise, r as superviseWithTestBrain, u as coordinationProfileToolPrefix } from "./supervise-BReI5ATC.js";
+import { n as supervise, r as superviseWithTestBrain, u as coordinationProfileToolPrefix } from "./supervise-D9aNi8_f.js";
 import { agentProfileSchema, canonicalCandidateDigest } from "@tangle-network/agent-interface";
 //#region src/runtime/supervise/prompt-registry.ts
 /**
@@ -476,6 +476,10 @@ function superviseAgentGraph(graph, opts, brain) {
 	const ledger = [];
 	const journaled = /* @__PURE__ */ new Set();
 	const traversalCounts = /* @__PURE__ */ new Map();
+	const capSpend = /* @__PURE__ */ new Map();
+	const spend = (edge) => {
+		capSpend.set(edge, (capSpend.get(edge) ?? 0) + 1);
+	};
 	const exhausted = /* @__PURE__ */ new Set();
 	const exhaustedDelegates = /* @__PURE__ */ new Set();
 	const journalWrites = [];
@@ -503,7 +507,17 @@ function superviseAgentGraph(graph, opts, brain) {
 		journalWrites.push(write);
 		return write;
 	};
-	const record = (entry, journalNow) => {
+	const settleUnbound = (pending) => {
+		const refused = {
+			...pending,
+			outcome: "unpropagated",
+			bytes: 0,
+			reason: `no-live-worker-bound (spawn refused after the factory, or a keyed re-spawn deduplicated to a completed result; ${pending.bytes} composed bytes never crossed)`
+		};
+		ledger[ledger.indexOf(pending)] = refused;
+		return appendJournal(refused, `graph:${refused.to}`);
+	};
+	const record = (entry, final) => {
 		const count = (traversalCounts.get(entry.edge) ?? 0) + 1;
 		traversalCounts.set(entry.edge, count);
 		const row = {
@@ -511,7 +525,10 @@ function superviseAgentGraph(graph, opts, brain) {
 			traversal: count
 		};
 		ledger.push(row);
-		if (journalNow) appendJournal(row, row.workerId ?? `graph:${row.to}`);
+		if (final) {
+			spend(row.edge);
+			appendJournal(row, row.workerId ?? `graph:${row.to}`);
+		}
 		return row;
 	};
 	const nodeByWorkerId = /* @__PURE__ */ new Map();
@@ -528,7 +545,7 @@ function superviseAgentGraph(graph, opts, brain) {
 		const edge = delegatesByWorker.get(node.id);
 		const id = edgeId(edge);
 		const cap = edge.maxTraversals ?? 32;
-		const used = traversalCounts.get(id) ?? 0;
+		const used = capSpend.get(id) ?? 0;
 		const spawnContinuity = input.continuity ?? "fresh";
 		if (used >= cap) {
 			exhausted.add(id);
@@ -560,6 +577,8 @@ function superviseAgentGraph(graph, opts, brain) {
 			bytes,
 			...bytes === 0 ? { reason: "no directive text and no task payload" } : {}
 		}, false);
+		const stale = pendingByAssignment.get(input.assignmentId);
+		if (stale !== void 0) settleUnbound(stale);
 		pendingByAssignment.set(input.assignmentId, row);
 		return directiveText.length === 0 ? node.profile : {
 			...node.profile,
@@ -635,7 +654,7 @@ function superviseAgentGraph(graph, opts, brain) {
 	for (const edge of analyzes) (edge.to === root.id ? driverAnalyzesByAnalyst : routedAnalyzesByAnalyst).set(edge.analyst, edge);
 	const analyzesCapReached = (edge) => {
 		const cap = edge.maxTraversals ?? 32;
-		if ((traversalCounts.get(edgeId(edge)) ?? 0) < cap) return false;
+		if ((capSpend.get(edgeId(edge)) ?? 0) < cap) return false;
 		exhausted.add(edgeId(edge));
 		return true;
 	};
@@ -707,6 +726,7 @@ function superviseAgentGraph(graph, opts, brain) {
 		};
 		ledger[ledger.indexOf(pending)] = bound;
 		nodeByWorkerId.set(payload.childId, bound.to);
+		spend(bound.edge);
 		return appendJournal(bound, payload.childId);
 	} }, opts.hooks);
 	const start = async () => {
@@ -734,16 +754,7 @@ function superviseAgentGraph(graph, opts, brain) {
 			...superviseOptions,
 			brain
 		});
-		for (const pending of pendingByAssignment.values()) {
-			const refused = {
-				...pending,
-				outcome: "unpropagated",
-				bytes: 0,
-				reason: `no-live-worker-bound (spawn refused after the factory, or a keyed re-spawn deduplicated to a completed result; ${pending.bytes} composed bytes never crossed)`
-			};
-			ledger[ledger.indexOf(pending)] = refused;
-			await appendJournal(refused, `graph:${refused.to}`);
-		}
+		for (const pending of pendingByAssignment.values()) await settleUnbound(pending);
 		pendingByAssignment.clear();
 		await Promise.all(journalWrites);
 		const exhaustedEdges = Object.freeze([...exhausted]);
@@ -767,4 +778,4 @@ function graphTask(graph, root) {
 //#endregion
 export { analyzesFindingsReportPrompt as a, dumbContinuationFailPrompt as c, kernelPromptRegistry as d, naiveContinuationPrompt as f, runGraphWithTestBrain as i, dumbContinuationPassPrompt as l, defaultEdgeTraversalCap as n, createPromptRegistry as o, promptHandle as p, runGraph as r, delegatesWorkerBriefPrompt as s, GraphEdgeCapError as t, formatPromptHandle as u };
 
-//# sourceMappingURL=graph-DqPUeri6.js.map
+//# sourceMappingURL=graph-BuS-NxXD.js.map