@tangle-network/agent-runtime 0.117.0 → 0.120.0

package/dist/{supervise-U7_K5yuV.js → supervise-Cq50UT5-.js}

@@ -1,23 +1,43 @@
 import { c as RuntimeRunStateError, i as ConfigError, o as NotFoundError, t as AgentEvalError$1, u as ValidationError } from "./errors-DEAvWQPy.js";
-import { S as detachedSnapshot, b as workerTraceAnalysisStore, d as writeAllBytes, i as InMemorySpawnJournal, l as parseCommittedJsonLines, n as FileSpawnJournal, r as InMemoryResultBlobStore, t as FileResultBlobStore, u as prepareJsonlAppend, x as contentAddress } from "./spawn-journal-B_mu_oH2.js";
-import { a as mapWithConcurrency, c as sleep, d as throwIfAborted, f as withTimeout, l as stringifySafe, n as addTokenUsage, o as randomSuffix, p as zeroTokenUsage, r as deleteBoxSafe, s as randomUuid, t as abortError, u as throwAbort } from "./util-Cc9g9Y-o.js";
-import { C as buildLoopSpanNodes, Ct as controlProfileMaterialization, Dt as promptControlProfileMaterialization, E as createOtelExporter, Et as profileMaterializationAxes, Ot as promptModelProfileMaterialization, Pt as worktreeCliProfileMaterialization, Q as assertValidBudget, St as assertProfileMaterialization, Tt as fullProfileMaterialization, W as createActivityLog, X as DEFAULT_SUCCESSFUL_SHUTDOWN_MS, Z as teardownExecutor, _t as worktreeProfileExecutionPlan, a as pickBestDelivered, at as runtimeOwnedExecutorExecutionBinding, bt as removeWorktree, c as driverChild, ct as routerBrain, d as deriveNodeExecutionIdentity, et as spendFromUsageEvents, f as recordScopeOwnerMaterialization, g as workerTraceEnv, gt as runWorktreeHarness, ht as runWorktreeChecks, it as newExecutionAttemptId, j as toOtelAttributes, k as generateSpanId, l as withDriverExecutor, n as createSupervisor, nt as attestRuntimeOwnedScopeOwner, o as runFinalizer, ot as runtimeOwnedExecutorMaterialization, p as scopeOwnerExecutorNodeContext, pt as runBrainLoop, q as freeSlots, r as bestDelivered, rt as inheritRuntimeOwnedExecutorAttestation, s as runTree, st as runtimeOwnedScopeOwnerRuntime, tt as attestRuntimeOwnedExecutor, ut as routerChatWithUsage, vt as captureWorktreeDiff, wt as defineProfileMaterializationContract, yt as createWorktree } from "./supervisor-CAXiCKnX.js";
+import { S as detachedSnapshot, b as workerTraceAnalysisStore, d as writeAllBytes, i as InMemorySpawnJournal, l as parseCommittedJsonLines, n as FileSpawnJournal, r as InMemoryResultBlobStore, t as FileResultBlobStore, u as prepareJsonlAppend, x as contentAddress } from "./spawn-journal-IeXpidO2.js";
+import { a as randomSuffix, c as stringifySafe, d as withTimeout, f as zeroTokenUsage, i as mapWithConcurrency, l as throwAbort, n as deleteBoxSafe, o as randomUuid, s as sleep, t as addTokenUsage, u as throwIfAborted } from "./util-MVgdwuIS.js";
+import { $ as WORKER_TOKEN_FLOOR, At as promptControlProfileMaterialization, C as buildLoopSpanNodes, Ct as removeWorktree, Dt as defineProfileMaterializationContract, E as createOtelExporter, Et as controlProfileMaterialization, G as describeToolArgs, J as freeSlots, Lt as worktreeCliProfileMaterialization, Ot as fullProfileMaterialization, Q as teardownExecutor, St as createWorktree, Tt as assertProfileMaterialization, W as createActivityLog, Z as DEFAULT_SUCCESSFUL_SHUTDOWN_MS, a as pickBestDelivered, at as attestRuntimeOwnedScopeOwner, bt as worktreeProfileExecutionPlan, c as driverChild, ct as runtimeOwnedExecutorExecutionBinding, d as deriveNodeExecutionIdentity, dt as routerBrain, et as workerTokenFloor, f as recordScopeOwnerMaterialization, g as workerTraceEnv, gt as runBrainLoop, it as attestRuntimeOwnedExecutor, j as toOtelAttributes, jt as promptModelProfileMaterialization, k as generateSpanId, kt as profileMaterializationAxes, l as withDriverExecutor, lt as runtimeOwnedExecutorMaterialization, n as createSupervisor, o as runFinalizer, ot as inheritRuntimeOwnedExecutorAttestation, p as scopeOwnerExecutorNodeContext, pt as routerChatWithUsage, r as bestDelivered, rt as spendFromUsageEvents, s as runTree, st as newExecutionAttemptId, tt as assertValidBudget, ut as runtimeOwnedScopeOwnerRuntime, vt as runWorktreeChecks, xt as captureWorktreeDiff, yt as runWorktreeHarness } from "./supervisor-CpT9yAxL.js";
 import { i as notifyRuntimeHookEvent, t as composeRuntimeHooks } from "./runtime-hooks-C7iJOWm3.js";
 import { a as notifySandboxEventObserver, n as extractLlmCallEvent } from "./sandbox-events-Yhd1GYWl.js";
-import { i as resolveAgentEnvironmentProvider, n as providerAsExecutor, r as providerAsSandboxClient, s as buildBackendOptions } from "./environment-provider-CzcEyRL7.js";
+import { i as resolveAgentEnvironmentProvider, n as providerAsExecutor, r as providerAsSandboxClient, s as buildBackendOptions } from "./environment-provider-Cr75N-rU.js";
 import { t as createStdioToolServer } from "./tool-server-RcWgLIsL.js";
 import { n as UI_LENSES } from "./substrate-B0TYNrXn.js";
 import { argHash, computeFindingId, errorStreakDetector, estimateCost, isModelPriced, makeFinding, observeAll, repeatedActionDetector } from "@tangle-network/agent-eval";
 import { agentProfileSchema, canonicalCandidateDigest, mergeAgentProfiles, validateAgentProfileSecurity } from "@tangle-network/agent-interface";
 import { randomUUID } from "node:crypto";
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
-import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import path, { dirname, isAbsolute, join, resolve, sep } from "node:path";
+import path, { dirname, resolve } from "node:path";
 import { spawn } from "node:child_process";
-import { homedir, tmpdir } from "node:os";
 import { createServer, request } from "node:http";
 import { request as request$1 } from "node:https";
 import { Readable, Writable } from "node:stream";
+//#region src/runtime/harness-role.ts
+/**
+* Harness ids that select a router/no-agent mode rather than a coding-agent runtime.
+*
+* `nanoclaw` is deliberately ABSENT: the shared capability table clamps its reasoning ceiling the
+* same way it clamps `cli-base`, but nanoclaw does run an agent (a socket-bridge runner to the
+* NanoClaw daemon) and every caller here treats it as a full harness. Add a row only with the
+* behavior change stated, never to make the two clamps look symmetric.
+*/
+const NO_AGENT_HARNESSES = /* @__PURE__ */ new Set(["cli-base"]);
+/** Whether this profile harness selects a real coding-agent runtime (vs. the router/no-agent mode
+*  or no preference at all). Accepts the looser `string` some local profile shapes declare, and
+*  preserves the caller's own harness type when it is narrower. */
+function harnessRunsAgent(harness) {
+	return harness != null && !NO_AGENT_HARNESSES.has(harness);
+}
+/** The coding-agent harness this profile selects, or `undefined` when it selects none — the shape
+*  callers want when a no-agent mode must fall through to the router arm. */
+function agentHarness(harness) {
+	return harnessRunsAgent(harness) ? harness : void 0;
+}
+//#endregion
 //#region src/runtime/supervise/completion-gate.ts
 /**
 *
@@ -1949,402 +1969,16 @@ function createInbox() {
 	};
 }
 //#endregion
-//#region src/runtime/supervise/pi-mcp.ts
-/**
-*
-* MCP for the `pi` harness — the mount `piExecutor` performs before it spawns pi.
-*
-* pi ships NO MCP support of its own. MCP arrives through the `pi-mcp-adapter` extension, and the
-* adapter takes its config from a path the CALLER names: it registers a `--mcp-config <path>` flag
-* (`pi-mcp-adapter` `index.ts:252`, read back at `init.ts:101` and off raw argv at `utils.ts:55`).
-* So "give pi an MCP server" means: write the canonical `{ mcpServers: … }` object to a path this
-* run owns, pass that path with `--mcp-config`, make sure the adapter is loaded, and delete the
-* file afterwards. This module does exactly that and nothing else.
-*
-* Three rules carry the whole design:
-*
-* 1. **Fail loud, never fail safe.** If the profile declares MCP servers and `pi-mcp-adapter` is not
-*    installed, `preparePiMcp` throws BEFORE any file is written and before pi is spawned. A run
-*    whose tools never existed must fail, not score zero for the wrong reason.
-* 2. **`--no-extensions` is a trap.** When `extensions.pi.load` is an array, pi runs
-*    `--no-extensions`, which suppresses ALL auto-discovery — cwd `.pi/extensions`, global
-*    `~/.pi/agent/extensions`, AND the `settings.json` `packages` list that would otherwise have
-*    auto-loaded the adapter. So `load: ['pi-memory']` alongside `mcp` kills MCP dead even though
-*    the adapter IS installed. When MCP is declared, this module adds `pi-mcp-adapter` to the
-*    resolved load list and REPORTS that it did (`PiMcpReceipt.adapterInjected`). The caller's
-*    profile object is never mutated.
-* 3. **One config file per worker EXECUTION, never one per workspace.** `PiSeam.cwd` comes from the
-*    `ExecutorConfig` and is therefore shared by every worker the factory builds, so a config
-*    discovered by cwd is a file two concurrent siblings fight over. `mountPiMcpConfig` instead
-*    creates a fresh `mkdtemp` directory — OS-guaranteed unique, so no counter, lock, merge or
-*    restore is needed — and hands its path to `--mcp-config`. Concurrent workers built from ONE
-*    seam get ONE config each and never collide.
-*
-* Why the flag is safe to emit here even though pi only lists it under `Extension CLI Flags`: it is
-* emitted ONLY when the profile declares at least one usable MCP server, and that case has already
-* passed the `piMcpAdapterAvailable()` gate above, so the extension that registers the flag is
-* guaranteed loadable (auto-discovered, or force-loaded by the `--extension` this module appends).
-* A machine without the adapter never reaches the flag — it fails at the gate with an install
-* command instead.
-*
-* Where the run's servers sit in pi's config layering, stated plainly because it is a real
-* behavioral edge: `--mcp-config` REPLACES pi's user-global override file (`config.ts:310`,
-* `getPiGlobalConfigPath(overridePath)`), so the operator's own `~/.pi/agent/mcp.json` servers no
-* longer leak into a worker — good. It does NOT suppress project discovery: the adapter still
-* layers `<cwd>/.mcp.json` and `<cwd>/.pi/mcp.json` on top (`config.ts:352-373`), and those are
-* later sources, so a workspace that ships a server under the SAME NAME overrides this run's entry.
-* The consequence is worth naming: an A/B whose arms differ only in `profile.mcp` is confounded
-* when the shared workspace carries its own MCP config. Deleting a file the run did not create
-* would be worse — a run cannot quietly edit the repo it was pointed at.
-*
-* Upstream note: `@tangle-network/agent-profile-materialize` is the shared owner of profile → harness
-* mapping and already declares `pi` a first-class `HarnessId`, but as of 0.9.4 its pi arm answers
-* `unsupported('mcp', 'pi MCP requires a loaded MCP extension; the base Pi runtime has no MCP
-* control')` and its pi extensions arm answers `unsupported('extensions', …)`. That refusal is now
-* factually stale — the shape is exactly its `kimi-code` arm's (write a config file, push a config
-* flag, because the harness has no cwd discovery worth trusting). Teaching the materializer these
-* two rows is the durable home for this mapping; until it lands, this module is the only thing in
-* the `backend: 'pi'` path that can honor `profile.mcp` at all.
-*
-* Verified against pi 0.83.0 and pi-mcp-adapter 2.15.0.
-*
-* @experimental
-*/
-/** The pi extension that gives pi MCP at all. Everything here is gated on it being loadable. */
-const PI_MCP_ADAPTER = "pi-mcp-adapter";
-/** Overrides adapter detection for installs whose path does not carry the adapter's name. */
-const PI_MCP_ADAPTER_ENV = "AGENT_RUNTIME_PI_MCP_ADAPTER";
-/** The adapter-registered flag that names this run's config file (`pi-mcp-adapter` `index.ts:252`). */
-const PI_MCP_CONFIG_FLAG = "--mcp-config";
-/** pi's agent home. Holds `settings.json` and `npm/node_modules/<extension>`. */
-function piAgentDir() {
-	return process.env.PI_CODING_AGENT_DIR ?? join(homedir(), ".pi", "agent");
-}
-/** `<agentDir>/npm`, whose `node_modules/<pkg>` holds installed pi extensions. */
-function piNpmRoot() {
-	return join(piAgentDir(), "npm");
-}
-/**
-* True when pi can actually consume MCP config — i.e. `pi-mcp-adapter` is installed. Ported from
-* cli-bridge `pi.ts:189`: an env override first (for vendored installs whose path does not carry the
-* adapter's name), then the npm install directory, then a scan of `settings.json` `packages` in
-* which a local-path entry is resolved by reading the target's `package.json` `name`. An
-* unreadable or absent `settings.json` reports "not detected"; it never throws and never assumes.
-*/
-function piMcpAdapterAvailable() {
-	const override = process.env[PI_MCP_ADAPTER_ENV];
-	if (override === "1" || override === "true") return true;
-	if (override === "0" || override === "false") return false;
-	const agentDir = piAgentDir();
-	if (existsSync(join(agentDir, "npm", "node_modules", "pi-mcp-adapter"))) return true;
-	try {
-		const settings = JSON.parse(readFileSync(join(agentDir, "settings.json"), "utf-8"));
-		if (!Array.isArray(settings.packages)) return false;
-		return settings.packages.some((entry) => packageEntryIsAdapter(entry, agentDir));
-	} catch {
-		return false;
-	}
-}
-/** One `settings.json` `packages[]` entry: a name containing the adapter, or a local path to it. */
-function packageEntryIsAdapter(entry, agentDir) {
-	if (typeof entry !== "string") return false;
-	if (entry.includes("pi-mcp-adapter")) return true;
-	const spec = entry.replace(/^(file|path):(\/\/)?/, "");
-	const windowsAbsolute = /^[A-Za-z]:[\\/]/.test(spec);
-	if (!isAbsolute(spec) && !windowsAbsolute && !spec.startsWith(".")) return false;
-	return readPackageName(isAbsolute(spec) || windowsAbsolute ? spec : join(agentDir, spec)) === PI_MCP_ADAPTER;
-}
-function readPackageName(packageDir) {
-	try {
-		const manifest = JSON.parse(readFileSync(join(packageDir, "package.json"), "utf-8"));
-		return typeof manifest.name === "string" ? manifest.name : void 0;
-	} catch {
-		return;
-	}
-}
-/**
-* Read one `AgentProfileConfigValue` as public bytes. A `secret-ref` is REFUSED rather than
-* stringified: this executor has no secret provider, so the only alternatives are writing a
-* placeholder into the config (an auth failure disguised as a tool bug) or writing the literal
-* reference object (nonsense to the adapter). Plain strings, numbers and booleans are accepted
-* because profiles authored as JSON commonly carry them where the type says `{kind:'public'}`.
-*/
-function publicConfigString(value, where) {
-	if (typeof value === "string") return value;
-	if (typeof value === "number" || typeof value === "boolean") return String(value);
-	if (value && typeof value === "object" && value.kind === "public") return value.value;
-	if (value && typeof value === "object" && value.kind === "secret-ref") throw new ConfigError(`piExecutor: ${where} is a secret-ref ("${value.key}") and piExecutor has no secret provider; resolve it before handing the profile to the executor, or declare a public value`);
-	throw new ValidationError(`piExecutor: ${where} is not a public configuration value`);
-}
-/**
-* Build the canonical `{ mcpServers }` body the adapter reads, from `AgentProfile.mcp`.
-*
-* Every server is written with `directTools: true` (`pi-mcp-adapter` types.ts:351), which
-* registers its tools as NATIVE pi tools instead of hiding them behind the generic `mcp` tool.
-* Without it an agent must discover its own verbs before it can use them — connect to the server,
-* then describe each tool — and a measured run spent 58 turns and 639,632 input tokens doing that
-* before it could delegate once. A profile that declares an MCP server is asking for its tools,
-* not for a directory it has to browse.
-*
-* This is cli-bridge's `buildCanonicalMcpServers`
-* (`/home/drew/code/cli-bridge/src/backends/profile-support.ts:253`) reproduced field for field and
-* in the same key order — same drop of `enabled:false`, same stdio-versus-remote decision
-* (`isStdioMcpSpec`, `profile-support.ts:177`), same `{command, args, env}` and `{type, url,
-* headers}` bodies, same silent drop of an entry with nothing to connect to. For any server both
-* input types can express, the emitted JSON is byte-identical.
-*
-* The two input types are not the same type, so three differences remain and each is a field one
-* side cannot express:
-*
-* 1. **`cwd` (emitted here, absent there).** `AgentProfileLocalMcpServer` has `cwd`; cli-bridge's
-*    `McpServerSpec` (`src/backends/types.ts:53`) has no such field, so it can never emit one. The
-*    adapter honors it (`pi-mcp-adapter` `types.ts:325`, `ServerEntry.cwd`), so dropping it would
-*    silently discard a declared setting. It is emitted where cli-bridge emits `timeout`.
-* 2. **`timeout` (emitted there, absent here).** `AgentProfileMcpServer` has no timeout field, so
-*    there is nothing to emit. (The adapter's own knob is `requestTimeoutMs`, not `timeout`.)
-* 3. **A `url` with no declared transport.** cli-bridge DROPS it — its remote branch requires an
-*    explicit `spec.type` — even though its own `McpServerSpec` docstring says "http is implied if
-*    `url` is set" (`types.ts:53-56`). `transport` is optional on `AgentProfileRemoteMcpServer`, so
-*    dropping such a server here would be exactly the silent-drop bug this module exists to fix.
-*    We honor the documented convention and emit `type: 'http'`.
-*
-* `sse` is ACCEPTED and forwarded verbatim, as cli-bridge forwards it. The adapter connects a URL
-* server by probing StreamableHTTP and falling back to `SSEClientTransport` when the probe fails
-* (`pi-mcp-adapter` `server-manager.ts:765`), so an SSE-only endpoint does connect. Its
-* `ServerEntry` (`types.ts:319`) carries no transport discriminator at all, which means the `type`
-* key is inert to the adapter either way — but it is what cli-bridge writes, and a config file that
-* round-trips the caller's declared transport is the one that stays readable by both.
-*/
-function buildPiMcpServers(mcp) {
-	const out = {};
-	if (!mcp || typeof mcp !== "object") return out;
-	for (const [name, raw] of Object.entries(mcp)) {
-		if (!name || !raw || typeof raw !== "object") continue;
-		if (raw.enabled === false) continue;
-		const transport = raw.transport;
-		const command = typeof raw.command === "string" && raw.command.length > 0 ? raw.command : null;
-		const url = typeof raw.url === "string" && raw.url.length > 0 ? raw.url : null;
-		if ((transport === "http" || transport === "sse" ? false : command !== null) && command !== null) {
-			const args = Array.isArray(raw.args) ? raw.args.map((a, i) => publicConfigString(a, `mcp["${name}"].args[${i}]`)) : [];
-			const env = readConfigRecord(raw.env, `mcp["${name}"].env`);
-			out[name] = {
-				command,
-				...args.length > 0 ? { args } : {},
-				...Object.keys(env).length > 0 ? { env } : {},
-				...typeof raw.cwd === "string" && raw.cwd.length > 0 ? { cwd: raw.cwd } : {},
-				directTools: true
-			};
-			continue;
-		}
-		if (url !== null && transport !== "stdio") {
-			const headers = readConfigRecord(raw.headers, `mcp["${name}"].headers`);
-			out[name] = {
-				type: transport === "sse" ? "sse" : "http",
-				url,
-				...Object.keys(headers).length > 0 ? { headers } : {},
-				directTools: true
-			};
-		}
-	}
-	return out;
-}
-function readConfigRecord(record, where) {
-	if (!record || typeof record !== "object") return {};
-	const out = {};
-	for (const [key, value] of Object.entries(record)) {
-		if (value === void 0) continue;
-		out[key] = publicConfigString(value, `${where}["${key}"]`);
-	}
-	return out;
-}
-/**
-* Resolve one `extensions.pi.load` entry to an absolute extension entry file. Ported from cli-bridge
-* `resolvePiExtensionEntry` (`pi.ts:123`): an absolute path is used verbatim; a bare package name
-* resolves to `<npmRoot>/node_modules/<pkg>/<package.json main>`, `main` defaulting to `index.ts`.
-* The resolution is required because pi's per-file loader does NOT resolve bare specifiers against
-* `~/.pi/agent/npm/node_modules`. Fail-closed: an unreadable manifest or a missing entry file
-* rejects the run rather than letting an ablation arm run without the extension it declared.
-*/
-function resolvePiExtensionEntry(spec, npmRoot) {
-	let entry;
-	if (isAbsolute(spec)) entry = spec;
-	else {
-		const packageDir = join(npmRoot, "node_modules", spec);
-		let main = "index.ts";
-		try {
-			const manifest = JSON.parse(readFileSync(join(packageDir, "package.json"), "utf-8"));
-			if (typeof manifest.main === "string" && manifest.main) main = manifest.main;
-		} catch (err) {
-			throw new ConfigError(`piExecutor: cannot load pi extension "${spec}": ${join(packageDir, "package.json")} is not readable (install it with \`pi install npm:${spec}\`): ${err instanceof Error ? err.message : String(err)}`);
-		}
-		entry = join(packageDir, main);
-	}
-	if (!existsSync(entry)) throw new ConfigError(`piExecutor: cannot load pi extension "${spec}": resolved entry ${entry} does not exist`);
-	return entry;
-}
-/** Does this `load` entry name the MCP adapter, before resolution? */
-function entryNamesAdapter(spec) {
-	if (!isAbsolute(spec)) return spec === PI_MCP_ADAPTER;
-	if (spec.split(/[\\/]/).includes("pi-mcp-adapter")) return true;
-	const parent = spec.slice(0, spec.lastIndexOf(sep) + 1);
-	return parent.length > 0 && readPackageName(parent) === "pi-mcp-adapter";
-}
-/**
-* Lower `AgentProfile.extensions.pi.load` into pi argv, honoring the `--no-extensions` trap.
-*
-* `load` absent (not an array) → no flags at all, so pi keeps its default discovery and the adapter
-* auto-loads from `settings.json` `packages`. `load` present → `--no-extensions` plus one
-* `--extension <absolute entry>` per listed extension, which is what makes an ablation arm
-* reproducible and leak-free.
-*
-* When `mcpRequested` is true and an explicit `load` array does not already name the adapter, the
-* adapter is APPENDED — otherwise `--no-extensions` would suppress the very extension that turns
-* the `--mcp-config` file into tools. The caller's profile is not touched; the addition is reported
-* through `adapterInjected` so it reaches the executor receipt and the live progress channel.
-*
-* A non-string or blank entry is a schema error here, not a silent skip: an ablation arm that
-* quietly drops a typo'd extension is the same class of structural false-null this module exists to
-* eliminate.
-*/
-function derivePiExtensionArgs(profile, mcpRequested) {
-	const load = profile?.extensions?.pi?.load;
-	if (!Array.isArray(load)) return {
-		args: [],
-		entries: [],
-		adapterInjected: false
-	};
-	const declared = [];
-	for (const [index, entry] of load.entries()) {
-		if (typeof entry !== "string" || !entry.trim()) throw new ValidationError(`piExecutor: extensions.pi.load[${index}] must be a non-empty string (got ${entry === null ? "null" : typeof entry})`);
-		declared.push(entry.trim());
-	}
-	const adapterInjected = mcpRequested && !declared.some(entryNamesAdapter);
-	const resolvedSpecs = adapterInjected ? [...declared, PI_MCP_ADAPTER] : declared;
-	const npmRoot = piNpmRoot();
-	const entries = resolvedSpecs.map((spec) => resolvePiExtensionEntry(spec, npmRoot));
-	const args = ["--no-extensions"];
-	for (const entry of entries) args.push("--extension", entry);
-	return {
-		args,
-		entries,
-		adapterInjected
-	};
-}
-/** Directory-name-safe form of a run id; the `mkdtemp` suffix supplies the uniqueness. */
-function runIdSlug(runId) {
-	const slug = runId.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
-	return slug.length > 0 ? slug.slice(0, 60) : "worker";
-}
-/**
-* Write this worker execution's MCP config to a directory only it owns, and hand back the removal.
-*
-* Every property of the old cwd-discovered mount — a cross-process lock, a merge under whatever the
-* workspace already had, a verbatim byte restore, a symlink guard on `.pi` — existed because two
-* workers sharing a `PiSeam` shared one file path. `mkdtemp` deletes the shared path, and with it
-* the entire class of problem: the directory did not exist a moment ago, nothing else can name it,
-* `cleanup()` removes it whole, and two siblings started in the same millisecond get two configs.
-*
-* Returns `null` when there are no usable servers, so the no-MCP path writes nothing at all.
-*/
-function mountPiMcpConfig(mcpServers, options) {
-	const serverNames = Object.keys(mcpServers);
-	if (serverNames.length === 0) return null;
-	const slug = runIdSlug(options.runId);
-	const base = tmpdir();
-	const prefix = `agent-runtime-pi-mcp-${slug}-`;
-	let dir;
-	try {
-		dir = mkdtempSync(join(base, prefix));
-	} catch (err) {
-		throw new ConfigError(`piExecutor: cannot create a private MCP config directory under ${base}: ${err instanceof Error ? err.message : String(err)}`);
-	}
-	const configPath = join(dir, "mcp.json");
-	try {
-		writeFileSync(configPath, JSON.stringify({ mcpServers }, null, 2), {
-			flag: "wx",
-			mode: 384
-		});
-	} catch (err) {
-		rmSync(dir, {
-			recursive: true,
-			force: true
-		});
-		throw new ConfigError(`piExecutor: failed to write the MCP config at ${configPath}: ${err instanceof Error ? err.message : String(err)}`);
-	}
-	let cleaned = false;
-	return {
-		configPath,
-		serverNames,
-		cleanup: () => {
-			if (cleaned) return;
-			cleaned = true;
-			rmSync(dir, {
-				recursive: true,
-				force: true
-			});
-		}
-	};
-}
-/**
-* The one call `piExecutor` makes before spawning pi: decide what pi must be told, fail loud if it
-* cannot work, then mount.
-*
-* Order matters and is the point:
-*
-* 1. Canonicalize `profile.mcp` first, so the adapter gate keys off servers that would ACTUALLY be
-*    written — a block of `enabled:false` entries must not trip it.
-* 2. If any server survives and `pi-mcp-adapter` is not installed, throw. No file has been written
-*    and pi has not been spawned.
-* 3. Lower `extensions.pi.load` (which may itself throw on an unresolvable extension) — still before
-*    any file exists.
-* 4. Only then create this execution's private config directory and emit `--mcp-config`.
-*
-* A profile with no usable MCP server is a pure no-op: no adapter check, no directory, no flags, no
-* throw. `extensions.pi.load` on its own still produces flags, because reproducible ablation arms
-* need them whether or not MCP is involved.
-*
-* The caller MUST call `mount.cleanup()` on every exit path — settle, throw, abort, timeout, and
-* spawn failure — so the directory does not outlive the worker that owns it.
-*/
-function preparePiMcp(profile, options) {
-	const mcpServers = buildPiMcpServers(profile?.mcp);
-	const requested = Object.keys(mcpServers);
-	if (requested.length > 0 && !piMcpAdapterAvailable()) throw new ConfigError(`piExecutor: cannot mount MCP servers for pi (${requested.join(", ")}): the ${PI_MCP_ADAPTER} extension is not installed. pi ships no MCP support of its own, so these servers would never connect and the worker would run tool-less. Looked in ${join(piNpmRoot(), "node_modules", PI_MCP_ADAPTER)} and in the \`packages\` list of ${join(piAgentDir(), "settings.json")}. Install it with \`pi install npm:${PI_MCP_ADAPTER}\`, or set ${PI_MCP_ADAPTER_ENV}=1 if it is vendored somewhere this check cannot see.`);
-	const extensions = derivePiExtensionArgs(profile, requested.length > 0);
-	if (requested.length === 0) return {
-		args: extensions.args,
-		mount: null,
-		receipt: void 0
-	};
-	const mount = mountPiMcpConfig(mcpServers, options);
-	if (!mount) return {
-		args: extensions.args,
-		mount: null,
-		receipt: void 0
-	};
-	return {
-		args: [
-			...extensions.args,
-			PI_MCP_CONFIG_FLAG,
-			mount.configPath
-		],
-		mount,
-		receipt: {
-			servers: mount.serverNames,
-			configPath: mount.configPath,
-			extensions: extensions.entries,
-			adapterInjected: extensions.adapterInjected
-		}
-	};
-}
-//#endregion
 //#region src/runtime/supervise/trace-source.ts
 /** Project a normalized tool step into the canonical agent-eval `ToolSpan`. When the step carries
 *  real wall-clock (`startedAt`/`endedAt`) the span gets a true duration; otherwise it collapses to
-*  the single instant `at` (order + counts only — the historical behavior). */
+*  the single instant `at` (order + counts only — the historical behavior). A step whose source
+*  never saw the call finish (`statusCaptured: false`) gets NO `status` — `ToolSpan.status` is
+*  optional precisely so an unobserved outcome can stay unstated rather than defaulting to 'ok'. */
 function toToolSpan(input, runId, seq, at) {
 	const startedAt = typeof input.startedAt === "number" ? input.startedAt : at;
 	const endedAt = typeof input.endedAt === "number" ? input.endedAt : startedAt;
+	const status = input.statusCaptured === false ? void 0 : input.status ?? "ok";
 	return {
 		spanId: `${runId}-t${seq}`,
 		runId,
@@ -2353,7 +1987,7 @@ function toToolSpan(input, runId, seq, at) {
 		toolName: input.toolName,
 		args: input.args,
 		...input.argsCaptured === false ? { argsCaptured: false } : {},
-		status: input.status ?? "ok",
+		...status === void 0 ? {} : { status },
 		...input.error !== void 0 ? { error: input.error } : {},
 		startedAt,
 		endedAt,
@@ -2542,653 +2176,6 @@ function sandboxSessionTraceSource(box, sessionId, opts = {}) {
 	});
 }
 //#endregion
-//#region src/runtime/supervise/pi-executor.ts
-/**
-*
-* `piExecutor` — pi wrapped behind `Executor`, NOT forked.
-*
-* pi already implements everything a steerable worker needs, and implements it well: a queued
-* steering channel delivered between turns, follow-ups, abort, compaction, session persistence
-* with fork/branch, and an out-of-process line-delimited JSON protocol over stdin/stdout
-* (`pi --mode rpc`). Reimplementing any of that here would mean owning a turn loop someone else
-* already maintains. So this module is a thin protocol adapter, and every capability maps onto a
-* verb pi already has:
-*
-*   `execute`        → `prompt`, draining pi's event stream until `agent_settled`
-*   `deliver`        → `prompt` with `streamingBehavior` — pi owns the queue, we do not
-*   `teardown`       → `abort`, then close stdin and reap the process
-*   `progress`       → pi's `tool_execution_start`/`_end` + `turn_end` events, plus `get_state`'s
-*                      `pendingMessageCount` mirrored locally so the read stays synchronous
-*   `traceSource`    → the same tool events decoded into the shared `ToolSpan` currency
-*   `resultArtifact` → the terminal successful assistant turn
-*
-* It is registered through the DOCUMENTED extension point (`ExecutorRegistry.register('pi', …)`),
-* so nothing in the resolver switches on it and a consumer can replace it wholesale.
-*
-* agent-runtime does NOT take a dependency on pi. The wire shapes (`RpcCommand`, `AgentEvent`)
-* are read structurally off JSON lines, so a pi that adds commands stays compatible and a pi that
-* is not installed simply fails loud at spawn instead of at import.
-*
-* Usage accounting: pi repeats the same assistant receipt in `message_end` and `turn_end`.
-* Only `turn_end` is counted, once per model call. Pi reports cache traffic separately from fresh
-* input, so all three input classes are folded into Runtime's two-field token total. Subscription
-* usage whose dollar price is absent or zero stays explicitly unknown through the live usage
-* stream and terminal artifact.
-*
-* ## What of the `AgentProfile` this executor honors, and what it does not
-*
-* This adapter is NOT a profile materializer. It reads a deliberately small part of
-* `spec.profile`, and a caller who needs the rest must lower it before handing the profile over.
-* Stated exhaustively so a silent drop is never a surprise:
-*
-* | Field | Status |
-* | --- | --- |
-* | `profile.name` | honored — trace `runId` label only, no behavioral effect |
-* | `profile.prompt.systemPrompt` | honored — prepended to the task text (pi RPC takes no separate system-prompt channel) |
-* | `profile.mcp` | honored — written to this execution's own file and passed as `--mcp-config` for `pi-mcp-adapter`; see `pi-mcp.ts` |
-* | `profile.extensions.pi.load` | honored — lowered to `--no-extensions` + `--extension <abs>` |
-* | `profile.prompt.instructions` | honored — appended to the system prompt, one per line |
-* | `profile.model.default` | honored — overrides the seam's `model`; the seam is the fallback for profiles that select none |
-* | `profile.model.reasoningEffort` | DROPPED — no `--thinking` flag is emitted, so pi's configured `defaultThinkingLevel` applies |
-* | `profile.tools` | DROPPED — no `--no-tools` / allow-deny mapping; pi runs its full builtin tool set |
-* | `profile.permissions` | DROPPED |
-* | `profile.resources` (context / skills / commands / subagents / instructions) | DROPPED — nothing is written into the run cwd |
-* | `profile.hooks` | DROPPED |
-* | `profile.subagents`, `profile.connections`, `profile.modes`, `profile.confidential` | DROPPED |
-* | `profile.resources.failOnError` | not consulted — the MCP path above is unconditionally fail-closed, which is the stricter reading |
-* | every other `profile.extensions.<ns>` | DROPPED — only the `pi` namespace is read |
-*
-* Closing those gaps belongs in `@tangle-network/agent-profile-materialize`, whose plan this
-* executor would then apply, rather than in a second mapping grown here.
-*
-* @experimental
-*/
-/** The runtime name `piExecutor` registers under. */
-const PI_RUNTIME = "pi";
-/** Seam key the registry threads a `PiSeam` through (`ExecutorContext.seams['pi']`). */
-const piSeamKey = "pi";
-/** Build the `Executor` for one pi worker. Registered as runtime `'pi'`. */
-const piExecutor = (spec, ctx) => {
-	const seam = {
-		...readPiSeam(ctx),
-		...spec.profile.model?.default ? { model: spec.profile.model.default } : {}
-	};
-	const traceEnv = workerTraceEnv(ctx);
-	const inbox = createInbox();
-	const activity = createActivityLog(seam.activityWindow ?? 12);
-	const runId = `pi-${spec.profile.name ?? "worker"}-${Date.now()}`;
-	const trace = createPushTraceSource({ runId });
-	const executionId = ctx.node?.nodeId ?? `pi-run-${randomUUID()}`;
-	const attemptId = ctx.node?.attemptId ?? newExecutionAttemptId(executionId);
-	const derived = [];
-	const controller = new AbortController();
-	const cascade = () => controller.abort();
-	if (ctx.signal.aborted) controller.abort();
-	else ctx.signal.addEventListener("abort", cascade, { once: true });
-	const state = {
-		turns: 0,
-		lastText: "",
-		note: "starting",
-		proc: void 0,
-		artifact: void 0
-	};
-	const executor = {
-		runtime: "pi",
-		deliver: (m) => inbox.deliver(m),
-		progress: () => ({
-			turns: state.turns,
-			pendingMessages: inbox.pending(),
-			recentActivity: activity.read(),
-			...derived.length > 0 ? { derived: [...derived] } : {},
-			note: state.note
-		}),
-		traceSource: () => trace.source,
-		execute(task, signal) {
-			return streamPiSession({
-				task,
-				signal,
-				controller,
-				seam,
-				traceEnv,
-				spec,
-				runId,
-				inbox,
-				activity,
-				derived,
-				record: (step) => {
-					trace.record(step);
-				},
-				state
-			});
-		},
-		async teardown(grace) {
-			controller.abort();
-			const proc = state.proc;
-			if (!proc || proc.exitCode !== null || proc.killed) return { destroyed: true };
-			sendCommand(proc, { type: "abort" });
-			return killPi(proc, grace);
-		},
-		resultArtifact() {
-			if (!state.artifact) throw new ValidationError("piExecutor: resultArtifact() read before stream drained");
-			return state.artifact;
-		}
-	};
-	if (ctx.node === void 0) return executor;
-	return attestRuntimeOwnedExecutor(executor, {
-		effectiveProfile: spec.profile,
-		backend: "pi",
-		model: seam.model ? {
-			status: "known",
-			id: seam.model
-		} : {
-			status: "unknown",
-			reason: "pi selected its configured default model"
-		},
-		execution: {
-			kind: "run",
-			id: executionId
-		},
-		materializer: "pi-rpc-agent-profile",
-		plan: {
-			kind: "pi-rpc-session",
-			bin: seam.bin ?? "pi",
-			args: seam.args ?? [],
-			cwd: seam.cwd ?? null,
-			model: seam.model ?? null,
-			turnTimeoutMs: seam.turnTimeoutMs ?? null
-		}
-	}, {
-		attemptId,
-		binding: {
-			executionId,
-			bin: seam.bin ?? "pi",
-			cwd: seam.cwd ?? null,
-			model: seam.model ?? null
-		},
-		descriptor: {
-			kind: "pi-rpc-run",
-			transport: "process",
-			backend: "pi"
-		}
-	});
-};
-/**
-* One pi RPC session, run to `agent_settled`. Every steer delivered while the turn is in flight is
-* forwarded to pi IMMEDIATELY (pi queues and delivers it at its own turn boundary — the queue we
-* deliberately do not reimplement), and any steer still unread when pi settles re-prompts it.
-* `agent_end` is deliberately not terminal: Pi may auto-retry or compact after emitting it.
-*/
-async function* streamPiSession(args) {
-	const { seam, inbox, activity, state } = args;
-	const started = Date.now();
-	const tokens = {
-		input: 0,
-		output: 0
-	};
-	let usd = 0;
-	let usdKnown = true;
-	let tokensKnown = true;
-	throwIfAborted(args.signal);
-	throwIfAborted(args.controller.signal);
-	const piMcp = preparePiMcp(args.spec.profile, {
-		...seam.cwd !== void 0 ? { cwd: seam.cwd } : {},
-		runId: args.runId
-	});
-	if (piMcp.receipt) {
-		const injected = piMcp.receipt.adapterInjected ? ` (+${PI_MCP_ADAPTER} added)` : "";
-		activity.push({
-			at: Date.now(),
-			kind: "note",
-			label: "mcp",
-			detail: `${piMcp.receipt.servers.join(", ")}${injected}`
-		});
-		args.derived.push(`mcp: mounted ${piMcp.receipt.servers.join(", ")} via --mcp-config ${piMcp.receipt.configPath}`);
-		if (piMcp.receipt.adapterInjected) args.derived.push(`extensions: added ${PI_MCP_ADAPTER} to extensions.pi.load — the profile's own list would have run under --no-extensions and suppressed it, mounting zero servers`);
-	}
-	let proc;
-	try {
-		proc = spawnPi(seam, piMcp.args, args.traceEnv);
-	} catch (spawnFailure) {
-		piMcp.mount?.cleanup();
-		throw spawnFailure;
-	}
-	state.proc = proc;
-	state.note = "connected";
-	const events = [];
-	const pendingTools = /* @__PURE__ */ new Map();
-	const awaitingPromptResponses = /* @__PURE__ */ new Set();
-	let settled = false;
-	let acceptedPromptSinceSettlement = false;
-	let promptSequence = 0;
-	let lastAssistant;
-	let failure;
-	let abortDeadline;
-	let exited = false;
-	let exitCode;
-	let wake;
-	const notify = () => {
-		const w = wake;
-		wake = void 0;
-		w?.();
-	};
-	const stdoutLines = readJsonLines(proc, (value) => {
-		const ev = value;
-		events.push(ev);
-		notify();
-	});
-	proc.once("exit", (code) => {
-		exited = true;
-		exitCode = code;
-		notify();
-	});
-	proc.once("error", (e) => {
-		failure = new ValidationError(`piExecutor: pi failed to start: ${e.message}`);
-		notify();
-	});
-	const abortAll = () => {
-		if (abortDeadline !== void 0) return;
-		sendCommand(proc, { type: "abort" });
-		abortDeadline = Date.now() + PI_ABORT_RECEIPT_MS;
-		state.note = "aborting";
-		notify();
-	};
-	args.signal.addEventListener("abort", abortAll, { once: true });
-	args.controller.signal.addEventListener("abort", abortAll, { once: true });
-	const system = [args.spec.profile.prompt?.systemPrompt, ...args.spec.profile.prompt?.instructions ?? []].filter((line) => typeof line === "string" && line.trim().length > 0).join("\n");
-	const opening = system ? `${system}\n\n${taskText(args.task)}` : taskText(args.task);
-	const deadline = seam.turnTimeoutMs ? Date.now() + seam.turnTimeoutMs : void 0;
-	const sendPrompt = (message, streamingBehavior) => {
-		const id = `agent-runtime-prompt-${++promptSequence}`;
-		awaitingPromptResponses.add(id);
-		sendCommand(proc, {
-			id,
-			type: "prompt",
-			message,
-			...streamingBehavior ? { streamingBehavior } : {}
-		});
-	};
-	try {
-		if (args.signal.aborted || args.controller.signal.aborted) throw abortError();
-		sendPrompt(opening);
-		state.note = "turn 0";
-		for (;;) {
-			if (!settled && abortDeadline === void 0) forwardPending(inbox, activity, sendPrompt);
-			while (events.length > 0) {
-				const ev = events.shift();
-				if (ev.type === "response" && ev.command === "prompt" && typeof ev.id === "string" && awaitingPromptResponses.delete(ev.id)) if (ev.success === true) acceptedPromptSinceSettlement = true;
-				else failure = new ValidationError(`piExecutor: Pi rejected prompt: ${ev.error ?? "unknown RPC error"}`);
-				if (ev.type === "agent_start") settled = false;
-				if (ev.type === "agent_settled") {
-					settled = true;
-					acceptedPromptSinceSettlement = false;
-				}
-				const projected = projectPiEvent(ev, args, tokens, pendingTools);
-				if (projected.assistant) lastAssistant = projected.assistant;
-				if (projected.tokensUnknown) tokensKnown = false;
-				for (const usage of projected.events) {
-					if (usage.kind === "cost") {
-						usd += usage.usd;
-						if (usage.usdKnown === false) usdKnown = false;
-					}
-					yield usage;
-				}
-			}
-			if (failure) throw failure;
-			if (abortDeadline !== void 0 && (settled || exited)) throw abortError();
-			if (abortDeadline === void 0 && exited && (!settled || awaitingPromptResponses.size > 0 || acceptedPromptSinceSettlement)) throw new ValidationError(`piExecutor: pi exited before agent_settled (code ${exitCode ?? "unknown"})`);
-			if (abortDeadline === void 0 && deadline !== void 0 && Date.now() > deadline) throw new ValidationError("piExecutor: turn exceeded turnTimeoutMs");
-			if (abortDeadline !== void 0 && Date.now() > abortDeadline) {
-				const error = abortError();
-				error.message = `piExecutor: abort did not settle within ${PI_ABORT_RECEIPT_MS}ms`;
-				throw error;
-			}
-			if (settled && awaitingPromptResponses.size === 0 && !acceptedPromptSinceSettlement) {
-				const pending = inbox.drain();
-				if (pending.length === 0) break;
-				settled = false;
-				lastAssistant = void 0;
-				sendPrompt(inbox.fold(pending));
-				state.note = `turn ${state.turns}`;
-				continue;
-			}
-			await new Promise((resolve) => {
-				wake = resolve;
-				const t = setTimeout(() => {
-					if (wake === resolve) {
-						wake = void 0;
-						resolve();
-					}
-				}, 50);
-				if (typeof t.unref === "function") t.unref();
-			});
-		}
-	} finally {
-		stdoutLines();
-		state.note = "settled";
-		args.signal.removeEventListener("abort", abortAll);
-		args.controller.signal.removeEventListener("abort", abortAll);
-		await killPi(proc, 2e3).catch(() => ({ destroyed: false }));
-		piMcp.mount?.cleanup();
-	}
-	if (args.signal.aborted || args.controller.signal.aborted) throw abortError();
-	if (!lastAssistant) throw new ValidationError("piExecutor: agent_settled without an assistant turn");
-	if (lastAssistant.stopReason === "aborted") throw abortError();
-	if (lastAssistant.stopReason === "error") throw new ValidationError(`piExecutor: Pi assistant failed: ${lastAssistant.errorMessage ?? "unknown provider error"}`);
-	state.lastText = lastAssistant.text;
-	const spent = {
-		iterations: state.turns,
-		tokens,
-		...tokensKnown ? {} : { tokensKnown: false },
-		usd,
-		...usdKnown ? {} : { usdKnown: false },
-		ms: Date.now() - started
-	};
-	const out = {
-		content: state.lastText,
-		turns: state.turns,
-		...piMcp.receipt ? { mcp: piMcp.receipt } : {}
-	};
-	state.artifact = {
-		outRef: `pi:${hash(state.lastText)}`,
-		out,
-		spent
-	};
-}
-/** Route messages through pi's state-safe prompt command; pi owns the queue and idle transition. */
-function forwardPending(inbox, activity, sendPrompt) {
-	const pending = inbox.drain();
-	for (const m of pending) {
-		sendPrompt(renderOne(m), m.interrupt ? "steer" : "followUp");
-		activity.push({
-			at: Date.now(),
-			kind: "note",
-			label: m.interrupt ? "steer" : "follow-up",
-			detail: m.text.length > 80 ? `${m.text.slice(0, 77)}...` : m.text
-		});
-	}
-}
-function renderOne(m) {
-	if (m.kind === "answer") return `Answer to your question${m.questionId ? ` (${m.questionId})` : ""}: ${m.text}`;
-	return `New instruction from your supervisor: ${m.text}`;
-}
-/** Project one pi event onto usage events, updating turn count / activity / trace as a side
-*  effect. pi's tool events are the live trace; its `turn_end` bumps the turn counter. */
-function projectPiEvent(ev, args, tokens, pendingTools) {
-	const out = [];
-	const at = Date.now();
-	if (ev.type === "tool_execution_start" && typeof ev.toolName === "string") {
-		args.activity.push({
-			at,
-			kind: "tool",
-			label: ev.toolName,
-			detail: describeArgs$1(ev.args)
-		});
-		if (typeof ev.toolCallId === "string") pendingTools.set(ev.toolCallId, {
-			args: ev.args ?? {},
-			startedAt: at
-		});
-		return { events: out };
-	}
-	if (ev.type === "tool_execution_end" && typeof ev.toolName === "string") {
-		const status = ev.isError === true ? "error" : "ok";
-		const callId = typeof ev.toolCallId === "string" ? ev.toolCallId : void 0;
-		const started = callId ? pendingTools.get(callId) : void 0;
-		if (callId) pendingTools.delete(callId);
-		const error = status === "error" ? describeToolError(ev.result) : void 0;
-		args.activity.push({
-			at,
-			kind: "tool",
-			label: ev.toolName,
-			status
-		});
-		args.record({
-			toolName: ev.toolName,
-			args: started?.args ?? {},
-			...started ? {} : { argsCaptured: false },
-			status,
-			...ev.result !== void 0 ? { result: ev.result } : {},
-			...error !== void 0 ? { error } : {},
-			...callId ? { callId } : {},
-			...started ? { startedAt: started.startedAt } : {},
-			endedAt: at
-		});
-		return { events: out };
-	}
-	if (ev.type === "message_end") return { events: out };
-	if (ev.type === "turn_end") {
-		const usage = readUsage(ev.message);
-		if (usage && (usage.input || usage.output)) {
-			tokens.input += usage.input;
-			tokens.output += usage.output;
-			out.push({
-				kind: "tokens",
-				input: usage.input,
-				output: usage.output
-			});
-		}
-		out.push(usage?.usd !== void 0 ? {
-			kind: "cost",
-			usd: usage.usd
-		} : {
-			kind: "cost",
-			usd: 0,
-			usdKnown: false
-		});
-		args.state.turns += 1;
-		args.activity.push({
-			at,
-			kind: "turn",
-			label: `turn ${args.state.turns}`
-		});
-		out.push({ kind: "iteration" });
-		const assistant = readAssistantOutcome(ev.message);
-		const tokensUnknown = !usage || usage.tokensKnown === false;
-		return {
-			events: out,
-			...assistant ? { assistant } : {},
-			...tokensUnknown ? { tokensUnknown: true } : {}
-		};
-	}
-	return { events: out };
-}
-/** Pi's fresh input excludes cache reads and writes. Runtime's input channel includes all model
-* input, so combine them once at the assistant receipt. A missing or zero price is unknown because
-* subscription-backed providers report zero even when compute was not free. */
-function readUsage(message) {
-	if (!message || typeof message !== "object") return void 0;
-	const usage = message.usage;
-	if (!usage || typeof usage !== "object") return void 0;
-	const u = usage;
-	const promptTokens = num(u.prompt_tokens);
-	const freshInput = num(u.input) ?? num(u.inputTokens);
-	const outputRaw = num(u.output) ?? num(u.outputTokens) ?? num(u.completion_tokens);
-	const input = promptTokens ?? (freshInput ?? 0) + (num(u.cacheRead) ?? num(u.cache_read_input_tokens) ?? num(u.cacheReadInputTokens) ?? 0) + (num(u.cacheWrite) ?? num(u.cache_creation_input_tokens) ?? num(u.cacheCreationInputTokens) ?? 0);
-	const output = outputRaw ?? 0;
-	const costRaw = u.cost;
-	const reportedUsd = num(costRaw) ?? (costRaw && typeof costRaw === "object" ? num(costRaw.total) ?? num(costRaw.totalCost) : void 0);
-	return {
-		input,
-		output,
-		...reportedUsd !== void 0 && reportedUsd > 0 ? { usd: reportedUsd } : {},
-		tokensKnown: promptTokens !== void 0 || freshInput !== void 0 || outputRaw !== void 0
-	};
-}
-function readAssistantOutcome(message) {
-	if (!message || typeof message !== "object") return void 0;
-	const value = message;
-	if (value.role !== "assistant") return void 0;
-	return {
-		text: readText(message) ?? "",
-		...typeof value.stopReason === "string" ? { stopReason: value.stopReason } : {},
-		...typeof value.errorMessage === "string" ? { errorMessage: value.errorMessage } : {}
-	};
-}
-function readText(message) {
-	if (!message || typeof message !== "object") return void 0;
-	const content = message.content;
-	if (typeof content === "string" && content.length > 0) return content;
-	if (!Array.isArray(content)) return void 0;
-	const text = content.map((block) => block && typeof block === "object" && typeof block.text === "string" ? block.text ?? "" : "").join("");
-	return text.length > 0 ? text : void 0;
-}
-function num(v) {
-	return typeof v === "number" && Number.isFinite(v) && v >= 0 ? v : void 0;
-}
-function describeArgs$1(argsValue) {
-	if (!argsValue || typeof argsValue !== "object") return void 0;
-	const a = argsValue;
-	for (const key of [
-		"filePath",
-		"file_path",
-		"path",
-		"file",
-		"command",
-		"cmd",
-		"pattern"
-	]) {
-		const v = a[key];
-		if (typeof v === "string" && v.length > 0) return v.length > 120 ? `${v.slice(0, 117)}...` : v;
-	}
-}
-function describeToolError(result) {
-	if (typeof result === "string" && result.length > 0) return result;
-	if (result && typeof result === "object") {
-		const value = result;
-		const direct = value.error ?? value.message;
-		if (typeof direct === "string" && direct.length > 0) return direct;
-		if (Array.isArray(value.content)) {
-			const text = value.content.map((block) => block && typeof block === "object" && typeof block.text === "string" ? block.text : "").filter(Boolean).join("\n");
-			if (text.length > 0) return text;
-		}
-	}
-}
-function taskText(task) {
-	if (typeof task === "string") return task;
-	try {
-		return JSON.stringify(task) ?? String(task);
-	} catch {
-		return String(task);
-	}
-}
-/**
-* Launch `pi --mode rpc`, plus provider/model flags derived from the seam's `provider/model` and
-* the profile-derived extension flags (`--no-extensions` / `--extension`). Seam args go LAST so an
-* operator's explicit flag wins over a derived one under pi's last-flag-wins parsing; RPC mode has
-* no positional prompt, so nothing here has to precede an argument.
-*
-* `traceEnv` is the inherited `TRACE_ID` / `PARENT_SPAN_ID` pair (empty when the run records no
-* spans). It sits ABOVE the supervisor's ambient `process.env` — a supervisor that was itself
-* launched as someone's worker holds ids describing ITS place in an outer trace, which are the
-* wrong parent for this child — and BELOW `seam.env`, so an operator who sets either id explicitly
-* still wins. See `worker-trace.ts` for the full precedence rule.
-*/
-function spawnPi(seam, profileArgs = [], traceEnv = {}) {
-	const bin = seam.bin ?? "pi";
-	const argv = ["--mode", "rpc"];
-	if (seam.model) {
-		const slash = seam.model.indexOf("/");
-		if (slash > 0) argv.push("--provider", seam.model.slice(0, slash), "--model", seam.model.slice(slash + 1));
-		else argv.push("--model", seam.model);
-	}
-	argv.push(...profileArgs);
-	if (seam.args) argv.push(...seam.args);
-	return spawn(bin, argv, {
-		...seam.cwd ? { cwd: seam.cwd } : {},
-		env: {
-			...process.env,
-			...traceEnv,
-			...seam.env ?? {}
-		},
-		stdio: [
-			"pipe",
-			"pipe",
-			"pipe"
-		]
-	});
-}
-/** Write one `RpcCommand` as a JSON line on pi's stdin. Best-effort: a dead process is not an
-*  error here (the stream loop already observes the exit and fails loud there). */
-function sendCommand(proc, command) {
-	try {
-		proc.stdin?.write(`${JSON.stringify(command)}\n`);
-	} catch {}
-}
-/** Read newline-delimited JSON off pi's stdout; returns an unsubscribe. Malformed lines are
-*  ignored (pi writes only JSONL on stdout; anything else is noise from a wrapper script). */
-function readJsonLines(proc, onValue) {
-	let buffer = "";
-	const onData = (chunk) => {
-		buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
-		for (;;) {
-			const nl = buffer.indexOf("\n");
-			if (nl < 0) break;
-			const line = buffer.slice(0, nl).trim();
-			buffer = buffer.slice(nl + 1);
-			if (!line) continue;
-			try {
-				onValue(JSON.parse(line));
-			} catch {}
-		}
-	};
-	proc.stdout?.on("data", onData);
-	return () => {
-		proc.stdout?.off("data", onData);
-	};
-}
-/** The grace window pi gets to act on the `abort` it was just sent, before a signal is used.
-*  Without it the SIGTERM races the command down the pipe and pi never sees the abort at all —
-*  which defeats the reason to wrap pi rather than kill it (a clean abort finalizes its session). */
-const PI_ABORT_GRACE_MS = 500;
-/** Maximum wait for Pi's aborted receipt and `agent_settled` before forced teardown. */
-const PI_ABORT_RECEIPT_MS = 2e3;
-async function killPi(proc, grace) {
-	if (proc.exitCode !== null || proc.killed) return { destroyed: true };
-	if (grace === "brutalKill") {
-		endStdin(proc);
-		proc.kill("SIGKILL");
-		return { destroyed: true };
-	}
-	const total = grace === "infinity" ? 1e4 : Math.max(0, grace);
-	if (await waitForExit(proc, Math.min(PI_ABORT_GRACE_MS, total))) return { destroyed: true };
-	endStdin(proc);
-	proc.kill("SIGTERM");
-	if (await waitForExit(proc, Math.max(0, total - PI_ABORT_GRACE_MS))) return { destroyed: true };
-	proc.kill("SIGKILL");
-	return { destroyed: true };
-}
-function endStdin(proc) {
-	try {
-		proc.stdin?.end();
-	} catch {}
-}
-function waitForExit(proc, ms) {
-	if (proc.exitCode !== null) return Promise.resolve(true);
-	return new Promise((resolve) => {
-		const timer = setTimeout(() => resolve(false), ms);
-		if (typeof timer.unref === "function") timer.unref();
-		proc.once("exit", () => {
-			clearTimeout(timer);
-			resolve(true);
-		});
-	});
-}
-function readPiSeam(ctx) {
-	const seam = ctx.seams["pi"];
-	if (seam === void 0) return {};
-	if (!seam || typeof seam !== "object") throw new ValidationError(`piExecutor: seams['pi'] must be a PiSeam object`);
-	return seam;
-}
-/** FNV-1a over the terminal text — the same non-cryptographic content address the other leaf
-*  executors mint for their `outRef` dedup hint (the journal re-derives the canonical one). */
-function hash(value) {
-	let h = 2166136261;
-	for (let i = 0; i < value.length; i += 1) {
-		h ^= value.charCodeAt(i);
-		h = Math.imul(h, 16777619);
-	}
-	return (h >>> 0).toString(16).padStart(8, "0");
-}
-//#endregion
 //#region src/runtime/supervise/sandbox-session.ts
 /** Ceiling on continuation turns. Turn 0 is the task; every later turn is a folded steer, so
 *  this bounds how many times a supervisor may redirect ONE worker before it must respawn. */
@@ -3226,7 +2213,7 @@ function createSteerableSandboxSession(args) {
 						kind: "tool",
 						label: step.toolName,
 						...step.status ? { status: step.status } : {},
-						...describeArgs(step.args) ? { detail: describeArgs(step.args) } : {}
+						...describeToolArgs(step.args) ? { detail: describeToolArgs(step.args) } : {}
 					};
 					activity.push(note);
 				}
@@ -3392,25 +2379,6 @@ function readFinalText(event) {
 	const alt = data.text;
 	return typeof alt === "string" && alt.length > 0 ? alt : void 0;
 }
-/** A short, already-truncated descriptor of a tool call's target — the file/command a driver
-*  needs to tell "editing the right module" from "re-reading the same file for the fifth time",
-*  without pulling the worker's transcript across the wire. */
-function describeArgs(argsValue) {
-	if (!argsValue || typeof argsValue !== "object") return void 0;
-	const a = argsValue;
-	for (const key of [
-		"filePath",
-		"file_path",
-		"path",
-		"file",
-		"command",
-		"cmd",
-		"pattern"
-	]) {
-		const v = a[key];
-		if (typeof v === "string" && v.length > 0) return v.length > 120 ? `${v.slice(0, 117)}...` : v;
-	}
-}
 /** Prompt options the composed loop context already carries (agent profile / cwd), forwarded so
 *  a steerable worker runs with the same box configuration as the single-shot path. */
 function readPromptOptions(loopCtx) {
@@ -4374,11 +3342,25 @@ function killWithGrace(proc, grace) {
 */
 /** Resolve the bridge wire model for this spawn. Per-create matrix settings win, then the
 * canonical profile's harness/model preferences, then the bridge's configured fallback. */
+/**
+* A profile's selected model with its provider attached, the way a harness addresses one.
+*
+* Returns undefined when the profile selects no model, and the id unchanged when it is already
+* qualified or when the profile names no provider — there, the harness's own provider resolution
+* IS the caller's declared intent rather than a gap to fill.
+*/
+function qualifyProviderModel(model) {
+	const id = model?.default;
+	if (!id) return void 0;
+	const provider = model?.provider;
+	if (!provider || id.includes("/")) return id;
+	return `${provider}/${id}`;
+}
 function bridgeCellModel(seamModel, ctx, profile) {
 	const backend = ctx.seams.createOptions?.backend;
-	const profileHarness = profile.harness === "cli-base" ? void 0 : profile.harness;
+	const profileHarness = agentHarness(profile.harness);
 	const harness = backend?.type ?? profileHarness;
-	const model = backend?.model?.model ?? profile.model?.default;
+	const model = backend?.model?.model ?? qualifyProviderModel(profile.model);
 	if (!harness && !model) return seamModel;
 	if (!harness) return model;
 	if (model) return model.startsWith(`${harness}/`) ? model : `${harness}/${model}`;
@@ -4404,9 +3386,44 @@ const bridgeExecutor = (spec, ctx) => {
 	const inbox = createInbox();
 	let artifact;
 	const activeRuns = /* @__PURE__ */ new Map();
+	const observation = {
+		turns: 0,
+		note: "starting",
+		activity: createActivityLog(seam.activityWindow ?? 12),
+		derived: [],
+		refreshedAt: 0,
+		refreshing: false,
+		closed: false
+	};
+	if (base.agentProfile !== void 0) observation.derived.push("profile: merged the bridge seam's agentProfile over the spawn profile before materialization");
+	if (seam.model !== base.model) observation.derived.push(`model: resolved the bridge wire model to ${seam.model} (seam default ${base.model ?? "none"})`);
+	const trace = createPushTraceSource({ runId: sessionId });
 	return attestRuntimeOwnedExecutor({
 		runtime: "cli",
 		deliver: (m) => inbox.deliver(m),
+		/**
+		* The LIVE read of this worker, answered entirely from local mirrors so it is synchronous
+		* and cannot block or fail the run. The bridge's own run state is refreshed OUT OF BAND —
+		* a read schedules a fetch whose answer lands for the NEXT read — because the executor
+		* cannot know from its own stream whether a silent run is thinking, detached mid-reconnect,
+		* or already cancelled server-side, and that is exactly the distinction a supervisor's
+		* respawn decision turns on.
+		*/
+		progress: () => {
+			try {
+				scheduleBridgeRunStateRefresh(seam, activeRuns, observation);
+				return {
+					turns: observation.turns,
+					pendingMessages: inbox.pending(),
+					recentActivity: observation.activity.read(),
+					...observation.derived.length > 0 ? { derived: [...observation.derived] } : {},
+					note: bridgeProgressNote(observation, liveBridgeRunId(activeRuns))
+				};
+			} catch {
+				return;
+			}
+		},
+		traceSource: () => trace.source,
 		execute(task, signal) {
 			return streamBridgeSession({
 				task,
@@ -4418,6 +3435,10 @@ const bridgeExecutor = (spec, ctx) => {
 				inbox,
 				controller,
 				activeRuns,
+				observation,
+				record: (step) => {
+					trace.record(step);
+				},
 				onArtifact: (a) => {
 					artifact = a;
 				}
@@ -4471,6 +3492,103 @@ const bridgeExecutor = (spec, ctx) => {
 		}
 	});
 };
+/** Minimum spacing between out-of-band run-state reads. A driver polling `observe_agent` in a
+*  tight loop must not turn an observability read into load on the bridge. */
+const BRIDGE_RUN_STATE_REFRESH_MS = 1e3;
+/** Ceiling on one run-state read. A bridge that hangs must not pin `refreshing` forever and
+*  silently stop every later refresh. */
+const BRIDGE_RUN_STATE_TIMEOUT_MS = 2e3;
+/** One human-readable line: the local turn phase, plus the bridge's own run state when a snapshot
+*  has been read for a run that is still live. The snapshot's AGE is stated because a driver
+*  reading "running" must be able to tell a fresh read from a 40-second-old one; and once this
+*  executor holds terminal proof the line is DROPPED rather than left repeating a last-known
+*  "running" that stopped being true the moment the run ended. */
+function bridgeProgressNote(observation, liveRunId) {
+	const run = observation.runState;
+	if (!run || run.runId !== liveRunId) return observation.note;
+	const age = Math.max(0, Date.now() - run.at);
+	return `${observation.note} · bridge run ${run.state} (status ${run.status}, seq ${run.lastSeq}, read ${age}ms ago)`;
+}
+/** The run this executor still believes live, if any — the one worth reporting on and the only one
+*  worth asking the bridge about. */
+function liveBridgeRunId(activeRuns) {
+	for (const run of activeRuns.values()) if (!run.terminal) return run.id;
+}
+/**
+* Start a NON-BLOCKING read of the bridge's run state; the answer lands on `observation` for a
+* later `progress()` call. Nothing here is awaited by the caller and no failure escapes: a bridge
+* that is down, slow, or has forgotten the run leaves the previous snapshot in place, and
+* `progress()` still returns the local mirror.
+*/
+function scheduleBridgeRunStateRefresh(seam, activeRuns, observation) {
+	if (observation.closed) return;
+	if (observation.refreshing) return;
+	const now = Date.now();
+	if (now - observation.refreshedAt < BRIDGE_RUN_STATE_REFRESH_MS) return;
+	const runId = liveBridgeRunId(activeRuns);
+	if (runId === void 0) return;
+	observation.refreshedAt = now;
+	observation.refreshing = true;
+	(async () => {
+		try {
+			const snapshot = await bridgeRunStateGet(seam, runId);
+			if (snapshot) {
+				observation.runState = snapshot;
+				if (snapshot.terminal) observation.closed = true;
+			}
+		} catch {} finally {
+			observation.refreshing = false;
+		}
+	})();
+}
+/** `GET /v1/runs/:id` — the bridge's durable-run registry read. Resolves `undefined` for any
+*  non-200 or non-conforming body rather than throwing: this is only ever an observability read. */
+function bridgeRunStateGet(seam, runId) {
+	const target = new URL(`${seam.bridgeUrl.replace(/\/$/, "")}/v1/runs/${encodeURIComponent(runId)}`);
+	target.searchParams.set("wait_ms", "0");
+	const requestFn = target.protocol === "https:" ? request$1 : request;
+	return new Promise((resolve, reject) => {
+		const req = requestFn(target, {
+			method: "GET",
+			headers: { authorization: `Bearer ${seam.bridgeBearer}` },
+			timeout: BRIDGE_RUN_STATE_TIMEOUT_MS
+		}, (res) => {
+			(async () => {
+				const chunks = [];
+				for await (const chunk of res) chunks.push(Buffer.from(chunk));
+				if (res.statusCode !== 200) {
+					resolve(void 0);
+					return;
+				}
+				resolve(readBridgeRunState(runId, Buffer.concat(chunks).toString("utf8")));
+			})().catch(reject);
+		});
+		req.on("timeout", () => req.destroy(/* @__PURE__ */ new Error("bridgeExecutor: run state read timed out")));
+		req.on("error", reject);
+		req.end();
+	});
+}
+/** Decode one run snapshot. A body that does not carry the fields we report is `undefined`, never
+*  a partially-invented snapshot. */
+function readBridgeRunState(runId, body) {
+	let parsed;
+	try {
+		parsed = JSON.parse(body);
+	} catch {
+		return;
+	}
+	if (parsed.id !== runId) return void 0;
+	if (typeof parsed.status !== "string" || typeof parsed.state !== "string") return void 0;
+	if (typeof parsed.terminal !== "boolean" || typeof parsed.lastSeq !== "number") return void 0;
+	return {
+		runId,
+		status: parsed.status,
+		state: parsed.state,
+		terminal: parsed.terminal,
+		lastSeq: parsed.lastSeq,
+		at: Date.now()
+	};
+}
 /**
 * One resumable cli-bridge session, run as a streamed turn loop. Turn 0 sends the
 * task; each subsequent turn fires ONLY when the inbox has a steer/answer to fold —
@@ -4479,7 +3597,7 @@ const bridgeExecutor = (spec, ctx) => {
 * full streamed harness session call rather than a single chat round.
 */
 async function* streamBridgeSession(args) {
-	const { seam, inbox } = args;
+	const { seam, inbox, observation } = args;
 	const started = Date.now();
 	const external = mergeAbortSignals(args.signal, args.controller.signal);
 	const tokens = zeroTokenUsage();
@@ -4495,8 +3613,15 @@ async function* streamBridgeSession(args) {
 		if (pending.length) {
 			const folded = inbox.fold(pending);
 			nextPrompt = t === 0 && nextPrompt ? `${nextPrompt}\n\n${folded}` : folded;
+			for (const m of pending) observation.activity.push({
+				at: Date.now(),
+				kind: "note",
+				label: m.interrupt ? "steer" : "follow-up",
+				detail: m.text.length > 80 ? `${m.text.slice(0, 77)}...` : m.text
+			});
 		}
 		if (nextPrompt === void 0) break;
+		observation.note = `turn ${t}`;
 		const messages = [];
 		messages.push({
 			role: "user",
@@ -4546,7 +3671,16 @@ async function* streamBridgeSession(args) {
 				run: activeRun
 			})) {
 				if (chunk.content) turnText += chunk.content;
-				if (chunk.toolCall) toolCalls.push(chunk.toolCall);
+				for (const step of chunk.toolCalls ?? []) {
+					toolCalls.push(step.toolName);
+					observation.activity.push({
+						at: Date.now(),
+						kind: "tool",
+						label: step.toolName,
+						...describeToolArgs(step.args) ? { detail: describeToolArgs(step.args) } : {}
+					});
+					args.record(step);
+				}
 				if (chunk.usage) {
 					turnTokensKnown = true;
 					tokens.input += chunk.usage.input;
@@ -4581,13 +3715,23 @@ async function* streamBridgeSession(args) {
 		}
 		if (interruptSig.aborted && !args.signal.aborted && !args.controller.signal.aborted) interrupted = true;
 		turns += 1;
+		observation.turns = turns;
+		observation.activity.push({
+			at: Date.now(),
+			kind: "turn",
+			label: `turn ${turns}`
+		});
 		if (!turnTokensKnown) tokensKnown = false;
 		if (!turnUsdKnown) usdKnown = false;
 		yield { kind: "iteration" };
 		if (!interrupted && turnText) lastText = turnText;
-		if (interrupted) continue;
+		if (interrupted) {
+			observation.note = `turn ${turns} interrupted, resuming`;
+			continue;
+		}
 		if (inbox.pending() === 0) break;
 	}
+	observation.note = "settled";
 	const spent = {
 		iterations: turns,
 		tokens,
@@ -4833,6 +3977,50 @@ function errorMessage$1(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 /**
+* Decode the OpenAI-shaped `tool_calls` of one delta into the shared `ToolStepInput` currency,
+* through the SAME `decodeOpenAiPart` adapter the sandbox/parts trace source uses — the wire shape
+* cli-bridge emits (`{index, id, type:'function', function:{name, arguments}}`) is exactly the one
+* that decoder owns, so there is no second mapping to drift.
+*
+* FIDELITY, stated once: this wire carries the model's DECISION to call a tool. cli-bridge's
+* backends surface the call the moment the harness announces it and NEVER report the call
+* finishing, so no outcome, result, or duration exists to read. Each step is therefore marked
+* `statusCaptured: false` and carries no `startedAt`/`endedAt` — its span is an instant with no
+* status. Synthesising an end time would inject a fabricated 0ms latency, and defaulting to 'ok'
+* would count an unobserved call as a success; both would silently corrupt any downstream latency
+* or error-rate analysis. An honest lower-fidelity span beats a fabricated one. A harness whose
+* native protocol reports tool completion could carry true durations; this wire does not.
+*
+* cli-bridge emits each call complete in ONE delta (`{id, name, arguments}` together), so no
+* cross-delta argument-fragment assembly is needed; a frame that carries argument bytes without a
+* name decodes to nothing rather than to a nameless call.
+*/
+function decodeBridgeToolCalls(raw) {
+	if (!Array.isArray(raw)) return [];
+	const steps = [];
+	for (const call of raw) {
+		if (!call || typeof call !== "object") continue;
+		const record = call;
+		const fn = record.function;
+		const step = decodeOpenAiPart(typeof fn?.name === "string" && fn.name.length > 0 ? {
+			...record,
+			type: "function"
+		} : record);
+		if (!step) continue;
+		const rawArgs = fn?.arguments ?? record.arguments;
+		const argsCaptured = typeof rawArgs === "string" ? rawArgs.trim().length > 0 : rawArgs !== void 0;
+		steps.push({
+			...step,
+			...argsCaptured ? {} : {
+				args: {},
+				argsCaptured: false
+			},
+			statusCaptured: false
+		});
+	}
+	return steps;
+}
+/**
 * Parse cli-bridge's OpenAI-compatible SSE stream into normalized chunks. Each
 * `data:` line is an OpenAI chat-completion chunk (`choices[].delta`). Every
 * run-owned frame, including an id-only comment, is returned so the caller can
@@ -4919,8 +4107,8 @@ function parseSseFrame(frame) {
 	const choice = parsed.choices?.[0];
 	const content = choice?.delta?.content ?? choice?.message?.content;
 	if (typeof content === "string" && content.length > 0) out.content = content;
-	const toolName = choice?.delta?.tool_calls?.[0]?.function?.name;
-	if (typeof toolName === "string" && toolName.length > 0) out.toolCall = toolName;
+	const toolCalls = decodeBridgeToolCalls(choice?.delta?.tool_calls);
+	if (toolCalls.length > 0) out.toolCalls = toolCalls;
 	const u = parsed.usage;
 	if (u && (typeof u.prompt_tokens === "number" || typeof u.completion_tokens === "number")) out.usage = {
 		input: u.prompt_tokens ?? 0,
@@ -5221,8 +4409,7 @@ function snapshotExecutorConfig(config) {
 		}
 		case "router":
 		case "bridge":
-		case "cli":
-		case "pi": return detachedSnapshot(config, `createExecutor ${config.backend} config`);
+		case "cli": return detachedSnapshot(config, `createExecutor ${config.backend} config`);
 	}
 }
 /** A backend config reused for multiple workers/managers cannot pin execution identity or carry a
@@ -5254,7 +4441,6 @@ function bindReusableExecutorExecutionId(captured, executionId) {
 		case "router-tools":
 		case "cli":
 		case "provider":
-		case "pi":
 		case "sandbox": return captured;
 	}
 }
@@ -5284,7 +4470,6 @@ function createExecutor(config) {
 			case "bridge": return bridgeExecutor(spec, seamed);
 			case "cli": return cliExecutor(spec, seamed);
 			case "cli-worktree": return cliWorktreeExecutor(spec, seamed);
-			case "pi": return piExecutor(spec, seamed);
 			case "provider": {
 				const providerSeam = readSeam(seamed, providerSeamKey, "provider");
 				const provider = resolveAgentEnvironmentProvider(providerSeam.provider, providerSeam.registry);
@@ -5354,7 +4539,6 @@ function createExecutorRegistry() {
 	factories.set("inline", routerInlineExecutor);
 	factories.set("sandbox", sandboxExecutor);
 	factories.set("cli", cliExecutor);
-	factories.set("pi", piExecutor);
 	return {
 		register(runtime, factory) {
 			if (factories.has(runtime)) throw new ValidationError(`executor registry: runtime "${runtime}" already registered`);
@@ -5661,6 +4845,19 @@ function createEventBus(now = Date.now) {
 *
 * @experimental
 */
+const measuredFloors = Object.entries(WORKER_TOKEN_FLOOR).flatMap(([harness, floor]) => floor === null ? [] : [[harness, floor]]);
+const measuredFloorSentence = measuredFloors.length === 0 ? "" : " A harness child spends a measured minimum before any work — a maxTokens under that minimum is refused (`error: \"below-runtime-floor\"`). Measured floors (input tokens): " + measuredFloors.map(([harness, floor]) => `${harness}=${floor}`).join(", ") + ". Unmeasured harnesses have no floor and are admitted.";
+/**
+* The actionable fact behind a `below-runtime-floor` refusal: the floor for the harness the
+* root declared, and that the only fix is to raise maxTokens to at least that floor. Falls back
+* to the whole measured census if the declared harness resolves to no floor (a guard fired on a
+* spec-level harness this profile did not name).
+*/
+function belowFloorHint(harness) {
+	const floor = workerTokenFloor(harness ?? null);
+	if (floor !== null) return `The ${harness} harness spends a measured minimum of ${floor} input tokens before any work, so this budget's maxTokens can never be satisfied. Raise maxTokens to at least ${floor}; retrying with a smaller budget will fail identically.`;
+	return "This budget's maxTokens is below the measured minimum a harness child spends before any work, so it can never be satisfied. Raise maxTokens to at least the floor for the child harness — measured floors (input tokens): " + measuredFloors.map(([h, f]) => `${h}=${f}`).join(", ") + " — retrying with a smaller budget will fail identically.";
+}
 /** Default ceiling for a single `await_event` block (ms). Chosen well under any reasonable remote
 *  MCP client request timeout so the call returns a `pending` liveness snapshot instead of erroring;
 *  the supervisor re-polls until the worker settles. */
@@ -6366,7 +5563,7 @@ function createCoordinationTools(opts) {
 					},
 					budget: {
 						type: "object",
-						description: "Optional per-spawn budget that merges over the per-worker default (per field). Only set the ceilings this sub-task needs raised; the conserved pool still fences.",
+						description: "Optional per-spawn budget that merges over the per-worker default (per field). Only set the ceilings this sub-task needs raised; the conserved pool still fences." + measuredFloorSentence,
 						properties: {
 							maxIterations: {
 								type: "number",
@@ -6458,6 +5655,7 @@ function createCoordinationTools(opts) {
 				} : {
 					error: res.reason,
 					...res.reason === "usd-unbudgeted" ? { hint: "This run's root budget declares no maxUsd, so a child budget naming maxUsd can never be admitted — at any amount. Retrying with a smaller maxUsd will fail identically. Spawn with a budget that omits maxUsd, or ask the caller to give the run a root maxUsd." } : {},
+					...res.reason === "below-runtime-floor" ? { hint: belowFloorHint(profile.harness) } : {},
 					live: liveWorkerCount(),
 					freeSlots: freeWorkerSlots()
 				});
@@ -9537,7 +8735,7 @@ function supervisorAgent(profile, deps) {
 	const nodeContextSeed = deps.nodeContext === void 0 ? void 0 : detachedSnapshot(deps.nodeContext, "supervisorAgent node context");
 	if ((resolveTools || observeNodeEvent) && !nodeContextSeed) throw new ValidationError("supervisorAgent: nodeContext is required with resolveSupervisorTools or observeNodeEvent");
 	const name = stableProfile.name ?? "supervisor";
-	const harness = stableProfile.harness === void 0 || stableProfile.harness === null || stableProfile.harness === "cli-base" ? null : stableProfile.harness;
+	const harness = agentHarness(stableProfile.harness) ?? null;
 	const profilePrompt = resolveSupervisorSystemPrompt(stableProfile);
 	const coordination = deps.coordination ? { ...deps.coordination } : void 0;
 	assertCoordinationBinding(coordination);
@@ -9774,6 +8972,14 @@ function externalExecutionId(kind, identity) {
 		identity
 	}).slice(7)}`;
 }
+/**
+* NOT a harness-name test — `ExecutorConfig.backend` is a discriminated-union TAG naming HOW a
+* profile is materialized (bridge / sandbox / cli-worktree / router / cli / provider), which is a
+* different axis from WHICH CLI runs. An exhaustive switch on a closed union tag is the correct
+* shape and must stay: it is what makes a new executor kind a compile error here rather than a
+* silently weaker materialization contract. Every other `backend.backend === …` in this file and
+* in `runtime.ts` is the same tag; none of them are harness names.
+*/
 function backendProfileMaterialization(backend) {
 	switch (backend.backend) {
 		case "bridge":
@@ -9781,8 +8987,7 @@ function backendProfileMaterialization(backend) {
 		case "provider": return fullProfileMaterialization;
 		case "cli-worktree": return backend.bridge ? fullProfileMaterialization : worktreeCliProfileMaterialization;
 		case "router":
-		case "router-tools":
-		case "pi": return promptModelProfileMaterialization;
+		case "router-tools": return promptModelProfileMaterialization;
 		case "cli": return controlProfileMaterialization;
 	}
 }
@@ -9836,7 +9041,7 @@ const DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY = Object.freeze({
 	allowConnections: false
 });
 function isExternalSupervisor(profile) {
-	return profile.harness !== void 0 && profile.harness !== "cli-base";
+	return harnessRunsAgent(profile.harness);
 }
 function automaticDriverBackendSupported(backend) {
 	return backend.backend === "bridge";
@@ -10515,6 +9720,6 @@ function supervise(profile, task, opts) {
 	return start();
 }
 //#endregion
-export { allOf as $, profileRichnessFinding as $t, DELEGATE_DESCRIPTION as A, PI_MCP_ADAPTER as At, DELEGATION_TRACE_MAX_SPANS as B, runLoop as Bt, createDelegateUiAuditHandler as C, createSteerableSandboxSession as Ct, DELEGATE_FEEDBACK_TOOL_NAME as D, createPushTraceSource as Dt, DELEGATE_FEEDBACK_INPUT_SCHEMA as E, piSeamKey as Et, defaultDelegateBudget as F, preparePiMcp as Ft, DelegationPersistenceError as G, createSupervisorSpanRecorder as Gt, capDelegationTrace as H, probeSandboxCapabilities as Ht, delegate as I, createInbox as It, InMemoryDelegationStore as J, asAuthoredProfile as Jt, DelegationStateCorruptError as K, assertModelAllowed as Kt, DelegationTaskQueue as L, createSandboxForSpec as Lt, DELEGATE_TOOL_NAME as M, PI_MCP_CONFIG_FLAG as Mt, createDelegateHandler as N, buildPiMcpServers as Nt, createDelegateFeedbackHandler as O, decodeToolPart as Ot, validateDelegateArgs as P, piMcpAdapterAvailable as Pt, finalizeBestDelivered as Q, defaultProfileRichnessThresholds as Qt, hashIdempotencyInput as R, defaultSelectWinner as Rt, DELEGATE_UI_AUDIT_TOOL_NAME as S, DEFAULT_SANDBOX_STEERING_MAX_TURNS as St, DELEGATE_FEEDBACK_DESCRIPTION as T, piExecutor as Tt, composeLoopTraceEmitters as U, acquireSandbox as Ut, buildDelegationTraceSpans as V, createSandboxLineage as Vt, createDelegationTraceCollector as W, FileCoordinationLog as Wt, eventToSnapshot as X, authoredWorker as Xt, InMemoryFeedbackStore as Y, assessAuthoredProfile as Yt, driverAgent as Z, canonicalizeAuthoredProfile as Zt, DELEGATION_HISTORY_TOOL_NAME as _, createInMemoryRunContext as _t, resolveSupervisorProfile as a, sampleFromSettled as at, DELEGATE_UI_AUDIT_DESCRIPTION as b, createExecutorRegistry as bt, createInProcessTransport as c, bestSoFar as ct, DELEGATION_STATUS_INPUT_SCHEMA as d, DEFAULT_AWAIT_EVENT_TIMEOUT_MS as dt, supervisorInstructions as en, allWorkersStalled as et, DELEGATION_STATUS_TOOL_NAME as f, createCoordinationTools as ft, DELEGATION_HISTORY_INPUT_SCHEMA as g, createFileRunContext as gt, DELEGATION_HISTORY_DESCRIPTION as h, watchTrace as ht, assertCoordinationBinding as i, plateau as it, DELEGATE_INPUT_SCHEMA as j, PI_MCP_ADAPTER_ENV as jt, validateDelegateFeedbackArgs as k, sandboxSessionTraceSource as kt, createMcpServer as l, plateauLength as lt, validateDelegationStatusArgs as m, defaultToolDetectors as mt, supervise as n, createProgressTracker as nt, supervisorAgent as o, anytimeReport as ot, createDelegationStatusHandler as p, createEventBus as pt, FileDelegationStore as q, assertProfileModelsAllowed as qt, workerFromBackend as r, noProgressFor as rt, serveCoordinationMcp as s, areaUnderCurve as st, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as t, gateOnDeliverable as tn, anyOf as tt, DELEGATION_STATUS_DESCRIPTION as u, renderAnytimeTable as ut, createDelegationHistoryHandler as v, cliWorktreeExecutor as vt, validateDelegateUiAuditArgs as w, PI_RUNTIME as wt, DELEGATE_UI_AUDIT_INPUT_SCHEMA as x, createWorktreeCliExecutor as xt, validateDelegationHistoryArgs as y, createExecutor as yt, DELEGATION_TRACE_MAX_BYTES as z, runAgentRounds as zt };
+export { allOf as $, DELEGATE_DESCRIPTION as A, runAgentRounds as At, DELEGATION_TRACE_MAX_SPANS as B, assessAuthoredProfile as Bt, createDelegateUiAuditHandler as C, createSteerableSandboxSession as Ct, DELEGATE_FEEDBACK_TOOL_NAME as D, createInbox as Dt, DELEGATE_FEEDBACK_INPUT_SCHEMA as E, sandboxSessionTraceSource as Et, defaultDelegateBudget as F, FileCoordinationLog as Ft, DelegationPersistenceError as G, supervisorInstructions as Gt, capDelegationTrace as H, canonicalizeAuthoredProfile as Ht, delegate as I, createSupervisorSpanRecorder as It, InMemoryDelegationStore as J, DelegationStateCorruptError as K, gateOnDeliverable as Kt, DelegationTaskQueue as L, assertModelAllowed as Lt, DELEGATE_TOOL_NAME as M, createSandboxLineage as Mt, createDelegateHandler as N, probeSandboxCapabilities as Nt, createDelegateFeedbackHandler as O, createSandboxForSpec as Ot, validateDelegateArgs as P, acquireSandbox as Pt, finalizeBestDelivered as Q, hashIdempotencyInput as R, assertProfileModelsAllowed as Rt, DELEGATE_UI_AUDIT_TOOL_NAME as S, DEFAULT_SANDBOX_STEERING_MAX_TURNS as St, DELEGATE_FEEDBACK_DESCRIPTION as T, decodeToolPart as Tt, composeLoopTraceEmitters as U, defaultProfileRichnessThresholds as Ut, buildDelegationTraceSpans as V, authoredWorker as Vt, createDelegationTraceCollector as W, profileRichnessFinding as Wt, eventToSnapshot as X, InMemoryFeedbackStore as Y, driverAgent as Z, DELEGATION_HISTORY_TOOL_NAME as _, createInMemoryRunContext as _t, resolveSupervisorProfile as a, sampleFromSettled as at, DELEGATE_UI_AUDIT_DESCRIPTION as b, createExecutorRegistry as bt, createInProcessTransport as c, bestSoFar as ct, DELEGATION_STATUS_INPUT_SCHEMA as d, DEFAULT_AWAIT_EVENT_TIMEOUT_MS as dt, allWorkersStalled as et, DELEGATION_STATUS_TOOL_NAME as f, createCoordinationTools as ft, DELEGATION_HISTORY_INPUT_SCHEMA as g, createFileRunContext as gt, DELEGATION_HISTORY_DESCRIPTION as h, watchTrace as ht, assertCoordinationBinding as i, plateau as it, DELEGATE_INPUT_SCHEMA as j, runLoop as jt, validateDelegateFeedbackArgs as k, defaultSelectWinner as kt, createMcpServer as l, plateauLength as lt, validateDelegationStatusArgs as m, defaultToolDetectors as mt, supervise as n, createProgressTracker as nt, supervisorAgent as o, anytimeReport as ot, createDelegationStatusHandler as p, createEventBus as pt, FileDelegationStore as q, workerFromBackend as r, noProgressFor as rt, serveCoordinationMcp as s, areaUnderCurve as st, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as t, anyOf as tt, DELEGATION_STATUS_DESCRIPTION as u, renderAnytimeTable as ut, createDelegationHistoryHandler as v, cliWorktreeExecutor as vt, validateDelegateUiAuditArgs as w, createPushTraceSource as wt, DELEGATE_UI_AUDIT_INPUT_SCHEMA as x, createWorktreeCliExecutor as xt, validateDelegationHistoryArgs as y, createExecutor as yt, DELEGATION_TRACE_MAX_BYTES as z, asAuthoredProfile as zt };
 
-//# sourceMappingURL=supervise-U7_K5yuV.js.map
+//# sourceMappingURL=supervise-Cq50UT5-.js.map