pi-ptc-subagents 0.1.0 → 0.1.2

package/dist/index.js

@@ -1,26 +1,30 @@
+import { a as describeValue, i as WORKER_FRAME_KIND, n as PTC_ERROR_KIND, o as isPtcHostFrame, r as PTC_LOG_LEVEL, s as isPtcWorkerFrame, t as HOST_FRAME_KIND } from "./protocol-DUnAP1Ro.js";
 import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, createBashTool, createEditTool, createFindTool, createGrepTool, createLsTool, createReadTool, createWriteTool, defineTool, formatSize, formatSkillsForPrompt, getAgentDir, truncateTail } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { validateToolArguments } from "@earendil-works/pi-ai";
 import { spawn } from "node:child_process";
 import * as fs from "node:fs";
-import { readFileSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import * as os from "node:os";
 import { tmpdir } from "node:os";
 import * as path from "node:path";
-import { join } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { randomUUID } from "node:crypto";
-import { MessageChannel, MessagePort, Worker } from "node:worker_threads";
+import { MessageChannel, Worker } from "node:worker_threads";
+import diagnosticsChannel from "node:diagnostics_channel";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 //#region src/runtime/dispatch.ts
 /**
-* pi.dispatch: a parallel binding that spawns a fresh pi subprocess per call.
+* pi.dispatch: the parallel binding that spawns a fresh pi subprocess per call.
 *
-* ADR-0016 (2026-09-23) is the contract. This file is the type surface and the spawn
-* skeleton; the actual subprocess plumbing (agent-md resolution, JSON-line parser,
-* usage accumulator, signal propagation across worker_threads / child_process) is a
-* follow-up. The stubs here are typed against the contract so call sites can land
-* before the spawn path is finalised, and so a wrong shape is a compile error rather
-* than a runtime one.
+* ADR-0016 (2026-09-23) is the contract, and this file is the whole implementation:
+* agent-markdown discovery (`discoverAgent`, with the agentScope user/project split),
+* the recursion-depth hint appended to the child's system prompt (`appendDepthHint`),
+* the argv the child pi is launched with (`buildArgv`), and `dispatch()` itself —
+* spawn, JSON-line event parsing, usage accumulation, the close-outcome decision
+* (`decideCloseOutcome`), and SIGTERM → SIGKILL signal propagation when the run that
+* issued the dispatch is cancelled.
 *
 * Behaviourally compatible with pi's examples/extensions/subagent/index.ts reference
 * (--mode json, -p, --no-session, --append-system-prompt <tmpfile>), but not cooperative:
@@ -60,15 +64,32 @@ function appendDepthHint(systemPrompt, depth, maxDepth) {
 	].join("\n");
 	return systemPrompt.length === 0 ? hint : systemPrompt + "\n\n" + hint;
 }
-/** Default error returned when the depth limit is exceeded. */
-function dispatchDepthLimitReached(currentDepth) {
+/** Result returned when the depth limit is exceeded. */
+function dispatchDepthLimitReached() {
 	return {
 		text: "",
 		status: "rejected",
 		agentName: "unknown",
 		durationMs: 0,
 		exitCode: -1,
-		errorMessage: "dispatch depth limit reached (current depth " + currentDepth + ", max-depth exceeded)"
+		errorMessage: "dispatch depth limit reached"
+	};
+}
+/**
+* Verbatim ADR-0016 §2 message for the per-run dispatch concurrency cap. Exported as a
+* named constant so the contract string has one definition and cannot drift (tests pin
+* it character for character).
+*/
+const DISPATCH_CONCURRENCY_LIMIT_MESSAGE = "dispatch concurrency limit reached";
+/** Result returned when the per-run dispatch concurrency cap is exceeded (ADR-0016 §2). */
+function dispatchConcurrencyLimitReached() {
+	return {
+		text: "",
+		status: "rejected",
+		agentName: "unknown",
+		durationMs: 0,
+		exitCode: -1,
+		errorMessage: DISPATCH_CONCURRENCY_LIMIT_MESSAGE
 	};
 }
 /**
@@ -278,7 +299,7 @@ function cleanupTmp(tmp) {
 */
 async function dispatch(input, ctx) {
 	const childDepth = ctx.depth + 1;
-	if (childDepth > ctx.maxDepth) return dispatchDepthLimitReached(ctx.depth);
+	if (childDepth > ctx.maxDispatchDepth) return dispatchDepthLimitReached();
 	const cwd = input.cwd ?? ctx.cwd;
 	const agentScope = input.agentScope ?? "user";
 	const start = Date.now();
@@ -291,7 +312,7 @@ async function dispatch(input, ctx) {
 		exitCode: 1,
 		errorMessage: "unknown agent: " + input.agent + " (agentScope=" + agentScope + ", cwd=" + cwd + ")"
 	};
-	const fullPrompt = appendDepthHint(agent.systemPrompt, childDepth, ctx.maxDepth);
+	const fullPrompt = appendDepthHint(agent.systemPrompt, childDepth, ctx.maxDispatchDepth);
 	const tmp = await writePromptToTempFile(agent.name, fullPrompt);
 	const argv = buildArgv(input, agent, tmp.filePath);
 	return await new Promise((resolve) => {
@@ -338,7 +359,11 @@ async function dispatch(input, ctx) {
 					"ignore",
 					"pipe",
 					"pipe"
-				]
+				],
+				env: {
+					...process.env,
+					PI_PTC_DEPTH: String(childDepth)
+				}
 			});
 		} catch (err) {
 			finalize("rejected", "failed to spawn pi: " + (err instanceof Error ? err.message : String(err)));
@@ -436,6 +461,8 @@ const BUILTIN_BINDING_NAMES = [
 	"find",
 	"ls"
 ];
+/** Parallel binding name (ADR-0016). */
+const DISPATCH_BINDING_NAME = "pi.dispatch";
 /**
 * Bindings exposed when the caller does not pass an explicit name list.
 *
@@ -445,11 +472,6 @@ const BUILTIN_BINDING_NAMES = [
 * out would silently shrink the surface relative to DSH. Callers that want a read-only
 * PTC surface pass an explicit subset.
 */
-/** Parallel binding name (ADR-0016). Always bound alongside the builtin set;
-* opt-out is the callers responsibility via an explicit subset to
-* createBuiltinBindings (today the subset is restricted to builtin names,
-* so opt-out is effectively use a future flag). */
-const DISPATCH_BINDING_NAME = "pi.dispatch";
 const DEFAULT_BINDING_NAMES = BUILTIN_BINDING_NAMES;
 const BUILTIN_TOOL_FACTORIES = {
 	read: createReadTool,
@@ -469,6 +491,7 @@ const BUILTIN_TOOL_FACTORIES = {
 */
 function createBuiltinBindings(options) {
 	const names = options.names ?? DEFAULT_BINDING_NAMES;
+	const includeDispatch = options.includeDispatch ?? options.names === void 0;
 	const table = /* @__PURE__ */ new Map();
 	for (const name of names) {
 		const factory = BUILTIN_TOOL_FACTORIES[name];
@@ -493,7 +516,7 @@ function createBuiltinBindings(options) {
 			}
 		});
 	}
-	if (names === DEFAULT_BINDING_NAMES) table.set(DISPATCH_BINDING_NAME, {
+	if (includeDispatch) table.set(DISPATCH_BINDING_NAME, {
 		name: DISPATCH_BINDING_NAME,
 		execute: async (args, context) => {
 			return dispatch(args, {
@@ -501,7 +524,7 @@ function createBuiltinBindings(options) {
 				callId: context.callId,
 				cwd: options.cwd,
 				depth: context.depth,
-				maxDepth: context.maxDispatchDepth
+				maxDispatchDepth: context.maxDispatchDepth
 			});
 		}
 	});
@@ -521,7 +544,10 @@ const DEFAULT_CONFIG = Object.freeze({
 	maxItemsPerCall: 4096,
 	graceMs: 3e3,
 	maxOldGenerationSizeMb: 512,
-	maxYoungGenerationSizeMb: 64
+	maxYoungGenerationSizeMb: 64,
+	poolSize: 4,
+	poolAcquireTimeoutMs: 3e4,
+	drainGraceMs: 5e3
 });
 /**
 * F1 — the only environment variables a PTC worker may inherit.
@@ -577,619 +603,344 @@ function effectiveTimeoutMs(requested, config = DEFAULT_CONFIG) {
 	if (requested === void 0 || !Number.isFinite(requested) || requested <= 0) return config.timeoutMs;
 	return Math.min(requested, config.maxTimeoutMs);
 }
-const HOST_FRAME_KIND = Object.freeze({
-	connect: "connect",
-	init: "init",
-	callResult: "call-result",
-	cancel: "cancel"
-});
-const WORKER_FRAME_KIND = Object.freeze({
-	ready: "ready",
-	call: "call",
-	log: "log",
-	narration: "narration",
-	phase: "phase",
-	result: "result",
-	error: "error"
-});
-const PTC_LOG_LEVEL = Object.freeze({
-	log: "log",
-	info: "info",
-	warn: "warn",
-	error: "error",
-	debug: "debug"
-});
-const PTC_ERROR_KIND = Object.freeze({
-	/** Program parse error or thrown exception (includes `ReferenceError` from a helper that does not exist on this surface). */
-	exception: "exception",
-	/** Elapsed deadline expiry. */
-	timeout: "timeout",
-	/** Caller cancellation. */
-	abort: "abort",
-	/** Malformed or excessive control traffic. */
-	protocol: "protocol",
-	/** Early worker exit or a worker-level crash. */
-	workerExit: "worker-exit",
-	/** Completion value could not be materialized as lossless JSON. */
-	invalidOutput: "invalid-output",
-	/** Oversized outer result; collected logs are retained. */
-	outputLimit: "output-limit"
-});
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isPtcLogLevel(value) {
-	return typeof value === "string" && Object.values(PTC_LOG_LEVEL).some((level) => level === value);
-}
-function isPtcErrorKind(value) {
-	return typeof value === "string" && Object.values(PTC_ERROR_KIND).some((kind) => kind === value);
-}
-function isPtcCancelReason(value) {
-	return value === "timeout" || value === "abort";
-}
-function isPtcConnectFrame(value) {
-	return isRecord(value) && value.kind === HOST_FRAME_KIND.connect && value.port instanceof MessagePort;
-}
-function isPtcInitFrame(value) {
-	return isRecord(value) && value.kind === HOST_FRAME_KIND.init && typeof value.runId === "string" && (value.surface === "run_code" || value.surface === "workflow") && typeof value.code === "string" && Array.isArray(value.bindings) && value.bindings.every((name) => typeof name === "string") && Array.isArray(value.bindingCandidates) && value.bindingCandidates.every((name) => typeof name === "string") && typeof value.maxItemsPerCall === "number" && Number.isFinite(value.maxItemsPerCall) && typeof value.maxPendingCalls === "number" && Number.isFinite(value.maxPendingCalls);
-}
-function isPtcCallResultFrame(value) {
-	if (!isRecord(value) || value.kind !== HOST_FRAME_KIND.callResult) return false;
-	if (!Number.isInteger(value.callId) || typeof value.tool !== "string") return false;
-	if (value.ok === true) return "value" in value;
-	return value.ok === false && typeof value.message === "string";
-}
-function isPtcCancelFrame(value) {
-	return isRecord(value) && value.kind === HOST_FRAME_KIND.cancel && isPtcCancelReason(value.reason);
-}
-function isPtcHostFrame(value) {
-	return isPtcConnectFrame(value) || isPtcInitFrame(value) || isPtcCallResultFrame(value) || isPtcCancelFrame(value);
-}
-function isPtcReadyFrame(value) {
-	return isRecord(value) && value.kind === WORKER_FRAME_KIND.ready;
-}
-function isPtcCallFrame(value) {
-	return isRecord(value) && value.kind === WORKER_FRAME_KIND.call && Number.isInteger(value.callId) && typeof value.tool === "string" && value.tool.length > 0 && "args" in value;
-}
-function isPtcLogFrame(value) {
-	return isRecord(value) && value.kind === WORKER_FRAME_KIND.log && isPtcLogLevel(value.level) && typeof value.text === "string";
-}
-function isPtcNarrationFrame(value) {
-	return isRecord(value) && value.kind === WORKER_FRAME_KIND.narration && typeof value.message === "string";
-}
-function isPtcPhaseFrame(value) {
-	return isRecord(value) && value.kind === WORKER_FRAME_KIND.phase && typeof value.title === "string";
-}
-function isPtcResultFrame(value) {
-	return isRecord(value) && value.kind === WORKER_FRAME_KIND.result;
-}
-function isPtcErrorFrame(value) {
-	if (!isRecord(value) || value.kind !== WORKER_FRAME_KIND.error) return false;
-	const error = value.error;
-	return isRecord(error) && isPtcErrorKind(error.kind) && typeof error.message === "string" && (error.stack === void 0 || typeof error.stack === "string");
-}
-function isPtcWorkerFrame(value) {
-	return isPtcReadyFrame(value) || isPtcCallFrame(value) || isPtcLogFrame(value) || isPtcNarrationFrame(value) || isPtcPhaseFrame(value) || isPtcResultFrame(value) || isPtcErrorFrame(value);
-}
-function workerProtocolSpec() {
+//#endregion
+//#region src/runtime/worker-pool.ts
+/**
+* Per-turn worker pool: keeps `worker_threads` Workers warm across PTC runs so the
+* second `ptc_run_code` of a turn does not pay the V8 spin-up + module-graph load cost
+* the first one did (ADR-0017).
+*
+* The pool is created by the pi extension hook at turn entry, passed to
+* `runPtcProgram()` via `RunPtcProgramOptions.pool`, and drained at turn exit. Two
+* surfaces (`run_code`, `workflow`) do not share a pool: their worker programs are
+* different (`installWorkflowHelpers` in `worker-main.ts`), and one pool per surface
+* is the cleanest ownership story.
+*
+* Capacity model
+* ──────────────
+* "Resident workers" ≤ `size`, "in-flight calls" ≤ unbounded but queued when the pool
+* is full. An acquire when the pool is at capacity joins a FIFO wait list; a waiter is
+* served the instant an `acquire()` resolves with the released worker — the released
+* worker is handed directly to the next waiter rather than going through `idle`. This
+* matches the host's own `acquireDispatchSlot` semantics: the queue is the throughput
+* story, not the rejection story.
+*
+* Waiters time out after `acquireTimeoutMs`; on timeout the run fails with
+* `kind: workerExit` and a message naming the pool (ADR-0017 W-2 / §4).
+*
+* `drain()` — awaited by the pi extension hook at turn end — gives in-flight runs
+* `drainGraceMs` (default 5 000 ms) to release their worker. Whatever is still in flight
+* when the grace expires is terminated together with the idle workers: a worker whose
+* `release()` never arrives (a stuck dispatcher promise, a crash no one observed) must
+* bound the turn-end hook, not hang it. Drain therefore always resolves — expiry is not
+* an error, because a turn boundary should not fail over one bad worker.
+*
+* Health
+* ──────
+* A worker that has emitted `exit` is retired — it never re-enters `idle`. The pool
+* detects exit on the next `release()`: if `worker.threadId === -1` (Node marks a
+* terminated worker with a sentinel threadId) the worker is dropped rather than kept
+* idle. This keeps a worker that crashed between two runs from being handed out again.
+*/
+/**
+* Build the `Worker` options for one spawn (ADR-0005 F1–F3 hardening in one place).
+*
+* `runId` is optional and deliberately absent on the pooled path: a warm worker serves many runs,
+* so its spawn-time `workerData` cannot carry any single run's identity (each run's `runId`
+* travels in its `init` frame instead).
+*/
+function workerSpawnOptions(options) {
 	return {
-		hostFrame: HOST_FRAME_KIND,
-		workerFrame: WORKER_FRAME_KIND,
-		logLevel: PTC_LOG_LEVEL,
-		errorKind: PTC_ERROR_KIND
+		name: `ptc-${options.surface}`,
+		env: options.env,
+		workerData: options.runId === void 0 ? { env: options.env } : {
+			runId: options.runId,
+			env: options.env
+		},
+		resourceLimits: {
+			maxOldGenerationSizeMb: options.limits.maxOldGenerationSizeMb,
+			maxYoungGenerationSizeMb: options.limits.maxYoungGenerationSizeMb
+		}
 	};
 }
-//#endregion
-//#region src/runtime/worker-main.ts
-function workerMain(deps) {
-	const hostFrame = deps.protocol.hostFrame;
-	const workerFrame = deps.protocol.workerFrame;
-	const logLevel = deps.protocol.logLevel;
-	const errorKind = deps.protocol.errorKind;
-	/** Wrapper name used to compile a program body (`return …` is legal inside it). */
-	const programName = "__ptcProgram";
-	let control;
-	let started = false;
-	let cancelled;
-	let nextCallId = 1;
-	/** Call frames posted and not yet answered; capped by `maxPendingCalls` (ADR-0004). */
-	let inFlightCalls = 0;
-	let maxPendingCalls = Number.POSITIVE_INFINITY;
-	const admissionWaiters = [];
-	const pending = /* @__PURE__ */ new Map();
-	const globals = () => globalThis;
-	class ToolCallError extends Error {
-		toolName;
-		constructor(toolName, message) {
-			super(message);
-			this.name = "ToolCallError";
-			this.toolName = toolName;
-		}
-	}
-	const messageOf = (error) => error instanceof Error ? error.message : String(error);
+/**
+* Diagnostics channels the pool publishes to (ADR-0017 W-5, Addendum). Channels have
+* zero subscribers by default — `diagnostics_channel.channel(...)` always returns the
+* same instance, but `publish` short-circuits when no one is listening, so this is the
+* documented cheap path.
+*/
+const channels = {
+	acquireLatency: diagnosticsChannel.channel("ptc:pool:acquire-latency"),
+	resetTime: diagnosticsChannel.channel("ptc:worker:reset-time"),
+	imageBytes: diagnosticsChannel.channel("ptc:image:hoist-bytes")
+};
+function publish(channel, message) {
+	channel.publish(message);
+}
+/**
+* A fixed-capacity FIFO-served worker pool. Not safe for concurrent `acquire()` calls
+* beyond Node's microtask interleaving guarantees — callers (`runPtcProgram`) await
+* `acquire` before scheduling anything that touches the pool, so the only concurrent
+* surface is `release()` against an in-flight worker.
+*/
+var WorkerPool = class {
+	#buildWorkerUrl;
+	#size;
+	#acquireTimeoutMs;
+	#drainGraceMs;
+	#workerOptions;
+	#idle = [];
+	#inFlight = /* @__PURE__ */ new Set();
+	#waiters = [];
 	/**
-	* Trim a stack down to what a reader can act on.
-	*
-	* Frames inside the worker bootstrap point at the `data:` URL the worker was spawned
-	* from, which is tens of kilobytes of encoded source; dropping those lines and capping
-	* the depth keeps the model-facing stack (and the output budget) sane.
+	* When each worker was last released (i.e., the previous run settled). Used by the
+	* dispatcher to publish `ptc:worker:reset-time` when a warm worker emits its first
+	* `ready` frame — the time between settle and reset-complete is the worker's
+	* per-run reset cost (ADR-0017 Addendum).
 	*/
-	const stackOf = (error) => {
-		if (!(error instanceof Error) || typeof error.stack !== "string") return void 0;
-		const lines = error.stack.split("\n");
-		const kept = [lines[0] ?? ""];
-		for (const line of lines.slice(1)) {
-			if (line.includes("data:text/javascript")) continue;
-			kept.push(line);
-			if (kept.length >= 6) break;
-		}
-		return kept.join("\n");
-	};
-	const describeValue = (value) => {
-		if (value === null) return "null";
-		if (Array.isArray(value)) return "an array";
-		return `a ${typeof value}`;
-	};
-	const post = (frame) => {
-		if (!control) return false;
-		try {
-			control.postMessage(frame);
-			return true;
-		} catch {
-			return false;
-		}
-	};
-	const postLog = (level, text) => {
-		post({
-			kind: workerFrame.log,
-			level,
-			text
-		});
-	};
-	const postError = (kind, message, stack) => {
-		post(stack === void 0 ? {
-			kind: workerFrame.error,
-			error: {
-				kind,
-				message
-			}
-		} : {
-			kind: workerFrame.error,
-			error: {
-				kind,
-				message,
-				stack
-			}
-		});
-	};
-	const abortError = (reason) => {
-		const error = /* @__PURE__ */ new Error(reason === "timeout" ? "PTC run timed out" : "PTC run was cancelled");
-		error.name = "AbortError";
-		return error;
-	};
-	const closedError = () => {
-		const error = /* @__PURE__ */ new Error("the PTC control channel closed before the call completed");
-		error.name = "AbortError";
-		return error;
-	};
+	#lastSettledAt = /* @__PURE__ */ new WeakMap();
+	#totalAcquires = 0;
+	#poolExhaustions = 0;
 	/**
-	* Admission control for host binding calls.
-	*
-	* "Maximum simultaneous host binding calls" is the worker's invariant to keep: a call
-	* frame is only posted once fewer than `maxPendingCalls` are outstanding, so a wide
-	* `Promise.all` / `parallel()` burst queues here rather than arriving at the host in one
-	* tick. The host still counts arrivals as a backstop, but it must never see this budget
-	* exceeded by a well-behaved program.
-	*
-	* Waiting for a slot is cancel-aware: `cancel` and a closed control port reject waiters
-	* immediately, so an oversized burst unwinds at once instead of waiting out the grace
-	* window before the host terminates the worker.
+	* `true` once `drain()` has resolved. After this point every `acquire()` rejects
+	* — the pool is single-use, the parent turn owns it for one cycle (ADR-0017 §1).
 	*/
-	const acquireCallSlot = async () => {
-		if (inFlightCalls < maxPendingCalls) {
-			inFlightCalls += 1;
-			return;
+	#drained = false;
+	constructor(options) {
+		if (typeof options.buildWorkerUrl !== "function") throw new TypeError("WorkerPool: buildWorkerUrl must be a function");
+		if (options.size !== void 0 && (typeof options.size !== "number" || !Number.isFinite(options.size) || options.size <= 0)) throw new TypeError(`WorkerPool: size must be a positive finite number, received ${String(options.size)}`);
+		if (options.acquireTimeoutMs !== void 0 && (typeof options.acquireTimeoutMs !== "number" || !Number.isFinite(options.acquireTimeoutMs) || options.acquireTimeoutMs <= 0)) throw new TypeError(`WorkerPool: acquireTimeoutMs must be a positive finite number, received ${String(options.acquireTimeoutMs)}`);
+		if (options.drainGraceMs !== void 0 && (typeof options.drainGraceMs !== "number" || !Number.isFinite(options.drainGraceMs) || options.drainGraceMs <= 0)) throw new TypeError(`WorkerPool: drainGraceMs must be a positive finite number, received ${String(options.drainGraceMs)}`);
+		this.#buildWorkerUrl = options.buildWorkerUrl;
+		this.#size = options.size ?? 4;
+		this.#acquireTimeoutMs = options.acquireTimeoutMs ?? 3e4;
+		this.#drainGraceMs = options.drainGraceMs ?? 5e3;
+		this.#workerOptions = options.workerOptions;
+	}
+	/**
+	* Acquire an idle worker, spawn a new one if below capacity, or queue until capacity
+	* opens up. Throws `Error("pool acquire timed out after ${acquireTimeoutMs} ms")` on
+	* timeout; the dispatcher wraps that message with a `pool acquire failed: ` prefix (ADR-0017 §4).
+	*/
+	async acquire() {
+		if (this.#drained) throw new Error("pool has been drained and can no longer serve workers");
+		this.#totalAcquires += 1;
+		const startedAt = Date.now();
+		let idle = this.#idle.shift();
+		while (idle !== void 0 && !this.#isHealthy(idle)) idle = this.#idle.shift();
+		if (idle !== void 0) {
+			this.#inFlight.add(idle);
+			idle.ref();
+			publish(channels.acquireLatency, {
+				poolSize: this.#size,
+				waiters: this.#waiters.length,
+				durationMs: Date.now() - startedAt
+			});
+			return idle;
 		}
-		await new Promise((resolve, reject) => {
-			admissionWaiters.push({
+		if (this.#inFlight.size < this.#size) {
+			const worker = this.#spawn();
+			this.#inFlight.add(worker);
+			publish(channels.acquireLatency, {
+				poolSize: this.#size,
+				waiters: this.#waiters.length,
+				durationMs: Date.now() - startedAt
+			});
+			return worker;
+		}
+		this.#poolExhaustions += 1;
+		return await new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				const index = this.#waiters.findIndex((entry) => entry.timer === timer);
+				if (index >= 0) this.#waiters.splice(index, 1);
+				reject(/* @__PURE__ */ new Error(`pool acquire timed out after ${this.#acquireTimeoutMs} ms`));
+			}, this.#acquireTimeoutMs);
+			this.#waiters.push({
 				resolve,
-				reject
+				reject,
+				timer,
+				startedAt
 			});
 		});
-	};
-	const releaseCallSlot = () => {
-		const next = admissionWaiters.shift();
-		if (next) {
-			next.resolve();
-			return;
-		}
-		inFlightCalls -= 1;
-	};
-	const rejectAdmissionWaiters = (error) => {
-		while (admissionWaiters.length > 0) {
-			const waiter = admissionWaiters.shift();
-			if (waiter) waiter.reject(error);
-		}
-	};
-	/** Settle every outstanding call and every admission wait, so nothing can hang. */
-	const flushPendingCalls = (error) => {
-		rejectAdmissionWaiters(error);
-		for (const [callId, entry] of pending) {
-			pending.delete(callId);
-			entry.reject(error);
-		}
-	};
+	}
 	/**
-	* F3 — reinstall the frozen per-run environment carried in `workerData`.
-	*
-	* The spawn already passes the same snapshot as the worker's `env` option; rebuilding
-	* `process.env` from `workerData` here is what makes the snapshot the authority: the
-	* program's environment is the frozen record, never whatever `process.env` happened
-	* to hold when a binding call crossed the wire.
+	* Hand a worker back to the pool. If a waiter is queued, hand the worker directly to
+	* them (no idle round-trip). Otherwise park the worker in `idle` — unless it has
+	* already exited, in which case retire it.
 	*/
-	const installFrozenEnv = () => {
-		const data = deps.workerData;
-		if (typeof data !== "object" || data === null) return;
-		const snapshot = data.env;
-		if (typeof snapshot !== "object" || snapshot === null || Array.isArray(snapshot)) return;
-		const env = snapshot;
-		for (const key of Object.keys(process.env)) if (!(key in env)) delete process.env[key];
-		for (const key of Object.keys(env)) {
-			const value = env[key];
-			if (typeof value === "string") process.env[key] = value;
+	release(worker) {
+		if (!this.#inFlight.delete(worker)) return;
+		if (!this.#isHealthy(worker)) return;
+		this.#lastSettledAt.set(worker, Date.now());
+		const waiter = this.#waiters.shift();
+		if (waiter) {
+			clearTimeout(waiter.timer);
+			this.#inFlight.add(worker);
+			publish(channels.acquireLatency, {
+				poolSize: this.#size,
+				waiters: this.#waiters.length,
+				durationMs: Date.now() - waiter.startedAt
+			});
+			waiter.resolve(worker);
+			return;
 		}
-	};
+		this.#idle.push(worker);
+		worker.unref();
+	}
 	/**
-	* Lossless-JSON materialization of the program's return value (R1 §3 `invalid-output`).
-	*
-	* Plain JSON only: class instances, `Date`/`Map`/`Set`, functions, symbols, bigints,
-	* non-finite numbers and cycles are rejected with a path-qualified reason instead of
-	* being silently lossy through the transport. `undefined` follows `JSON.stringify`:
-	* object properties are dropped, array slots become `null`.
+	* Last time `release()` was called for `worker`. The dispatcher reads this to
+	* publish `ptc:worker:reset-time` on a warm `ready` frame: `now - lastSettledAt`
+	* is the worker's per-run reset cost (ADR-0017 Addendum). `undefined` for a worker
+	* the pool never released (cold-start).
 	*/
-	const toJsonValue = (value) => {
-		const seen = /* @__PURE__ */ new Set();
-		const walk = (candidate, path) => {
-			if (candidate === null) return {
-				ok: true,
-				value: null
-			};
-			if (typeof candidate === "string" || typeof candidate === "boolean") return {
-				ok: true,
-				value: candidate
-			};
-			if (typeof candidate === "undefined") return {
-				ok: true,
-				value: void 0
-			};
-			if (typeof candidate === "number") {
-				if (!Number.isFinite(candidate)) return {
-					ok: false,
-					reason: `${path} is ${String(candidate)}, which is not representable as JSON`
-				};
-				return {
-					ok: true,
-					value: candidate
-				};
-			}
-			if (typeof candidate !== "object") return {
-				ok: false,
-				reason: `${path} is ${describeValue(candidate)}; results must be lossless JSON`
-			};
-			if (Array.isArray(candidate)) {
-				if (seen.has(candidate)) return {
-					ok: false,
-					reason: `${path} is a circular reference`
-				};
-				seen.add(candidate);
-				const items = [];
-				for (let index = 0; index < candidate.length; index += 1) {
-					const item = walk(candidate[index], `${path}[${index}]`);
-					if (!item.ok) return item;
-					items.push(item.value === void 0 ? null : item.value);
-				}
-				seen.delete(candidate);
-				return {
-					ok: true,
-					value: items
-				};
-			}
-			const prototype = Object.getPrototypeOf(candidate);
-			if (prototype !== Object.prototype && prototype !== null) {
-				const ctor = candidate.constructor;
-				return {
-					ok: false,
-					reason: `${path} is a ${ctor && typeof ctor.name === "string" && ctor.name.length > 0 ? ctor.name : "an object"}; results must be plain JSON objects`
-				};
-			}
-			if (seen.has(candidate)) return {
-				ok: false,
-				reason: `${path} is a circular reference`
-			};
-			seen.add(candidate);
-			const entries = {};
-			for (const key of Object.keys(candidate)) {
-				const item = walk(candidate[key], `${path}.${key}`);
-				if (!item.ok) return item;
-				if (item.value !== void 0) entries[key] = item.value;
-			}
-			seen.delete(candidate);
-			return {
-				ok: true,
-				value: entries
-			};
-		};
-		return walk(value, "result");
-	};
-	const formatArgs = (args) => args.map((arg) => typeof arg === "string" ? arg : deps.inspect(arg, {
-		depth: 4,
-		breakLength: Infinity,
-		colors: false
-	})).join(" ");
+	lastSettledAt(worker) {
+		return this.#lastSettledAt.get(worker);
+	}
 	/**
-	* Capture `console` instead of letting worker stdio reach the host terminal.
+	* Wait for every in-flight worker to be released — bounded by `drainGraceMs` — then
+	* terminate every resident worker and reject every queued waiter. After `drain()`
+	* returns the pool is unusable.
 	*
-	* Only the printing methods exist on this surface; everything routes to `log` frames
-	* so the model (not the terminal) sees the program's output.
+	* The bound matters: `drain()` is awaited from the pi `turn_end` hook, so a worker
+	* whose `release()` never arrives (a stuck dispatcher promise, an unobserved crash)
+	* must not hold the turn open. Workers still in flight when the grace expires are
+	* terminated with the idle ones, and `drain()` resolves normally — a single bad worker
+	* is not a reason to fail the turn boundary.
 	*/
-	const installConsole = () => {
-		const write = (level) => {
-			return (...args) => {
-				postLog(level, formatArgs(args));
-			};
-		};
-		globals().console = {
-			log: write(logLevel.log),
-			info: write(logLevel.info),
-			warn: write(logLevel.warn),
-			error: write(logLevel.error),
-			debug: write(logLevel.debug)
+	async drain() {
+		while (this.#waiters.length > 0) {
+			const waiter = this.#waiters.shift();
+			if (!waiter) break;
+			clearTimeout(waiter.timer);
+			waiter.reject(/* @__PURE__ */ new Error("pool drained before acquire could be satisfied"));
+		}
+		const deadline = Date.now() + this.#drainGraceMs;
+		while (this.#inFlight.size > 0 && Date.now() < deadline) await new Promise((resolve) => setTimeout(resolve, 5));
+		const terminating = [...this.#idle, ...this.#inFlight];
+		this.#idle.length = 0;
+		this.#inFlight.clear();
+		await Promise.all(terminating.map((worker) => worker.terminate().catch(() => void 0)));
+		this.#drained = true;
+	}
+	/** Read-only snapshot of the pool's counters; useful for tests and diagnostics. */
+	stats() {
+		return {
+			resident: this.#inFlight.size + this.#idle.length,
+			inFlight: this.#inFlight.size,
+			waiters: this.#waiters.length,
+			totalAcquires: this.#totalAcquires,
+			poolExhaustions: this.#poolExhaustions
 		};
-	};
-	/**
-	* Route `process.emitWarning` output through `log` frames.
-	*
-	* Node's default warning printer writes to stderr, which is piped to the host terminal.
-	* `ExperimentalWarning`s are dropped rather than forwarded: the PTC runtime itself uses
-	* experimental Node APIs (type stripping, for one) and those warnings are about the
-	* harness, not about the program — forwarding them would put Node-internals noise into
-	* every run's logs.
-	*/
-	const installWarningCapture = () => {
-		if (typeof process.removeAllListeners !== "function" || typeof process.on !== "function") return;
-		process.removeAllListeners("warning");
-		process.on("warning", (warning) => {
-			const record = typeof warning === "object" && warning !== null ? warning : void 0;
-			const name = record && typeof record.name === "string" ? record.name : "Warning";
-			if (name === "ExperimentalWarning") return;
-			const detail = record && typeof record.message === "string" ? record.message : String(warning);
-			postLog(logLevel.warn, `${name}: ${detail}`);
-		});
-	};
+	}
 	/**
-	* Compile a program body into a callable.
-	*
-	* The body is wrapped in an async function so `return` and `await` work at the top
-	* level, then run through `stripTypeScriptTypes` so the same body may carry type
-	* annotations (DSH's "type annotations are advisory, the code runs type-stripped").
-	* JavaScript the TypeScript parser rejects falls back to the unstripped source; a
-	* genuine syntax error then surfaces from the `Function` constructor instead.
+	* Spawn one worker and wire its retirement listener. Private: the pool owns worker
+	* lifecycle, so a caller outside `acquire()` has no business growing the pool (the
+	* dispatcher spawns directly itself when no pool is configured).
 	*/
-	const compileProgram = (code) => {
-		const wrapped = `async function ${programName}() {\n${code}\n}`;
-		let source = wrapped;
-		try {
-			source = deps.stripTypes(wrapped, { mode: "strip" });
-		} catch {
-			source = wrapped;
-		}
-		return new Function(`${source}\nreturn ${programName}();`);
-	};
-	const runProgram = async (code) => {
-		let program;
-		try {
-			program = compileProgram(code);
-		} catch (error) {
-			postError(errorKind.exception, `program failed to compile: ${messageOf(error)}`, stackOf(error));
-			return;
-		}
-		try {
-			const value = await program();
-			const normalized = toJsonValue(value);
-			if (!normalized.ok) {
-				postError(errorKind.invalidOutput, normalized.reason);
+	#spawn() {
+		const worker = new Worker(this.#buildWorkerUrl(), this.#workerOptions);
+		worker.once("exit", () => {
+			const idleIndex = this.#idle.indexOf(worker);
+			if (idleIndex >= 0) {
+				this.#idle.splice(idleIndex, 1);
 				return;
 			}
-			post(normalized.value === void 0 ? { kind: workerFrame.result } : {
-				kind: workerFrame.result,
-				value: normalized.value
-			});
-		} catch (error) {
-			postError(cancelled ?? errorKind.exception, messageOf(error), stackOf(error));
-		}
-	};
+			this.#inFlight.delete(worker);
+		});
+		return worker;
+	}
 	/**
-	* `tools.<name>(args)` — acquire an admission slot, post a call frame, and await the
-	* matching `call-result`.
+	* A worker is healthy when it has not exited. Node marks a terminated worker with
+	* `threadId === -1`; the `'exit'` event path also clears it from our lists, but the
+	* `threadId` check is the cheap synchronous check for the common release path.
 	*
-	* The slot is released on every exit path (settled, admission refused by `post`, cancel),
-	* which is what keeps a burst draining instead of deadlocking.
+	* Known window: `threadId` flips to `-1` **asynchronously**, so a worker whose
+	* `terminate()` has been called but whose exit has not been processed yet still reads as
+	* healthy (measured). That is unreachable in-tree today — `terminate()` is only called by
+	* `drain()` (after which the pool refuses every `acquire`) and by the dispatcher's
+	* unpooled path (whose worker never enters this pool) — so this is a note for whoever
+	* adds a third caller, not a bug to chase.
 	*/
-	const makeBinding = (name) => {
-		return async (args) => {
-			if (cancelled) throw abortError(cancelled);
-			await acquireCallSlot();
-			try {
-				if (cancelled) throw abortError(cancelled);
-				const callId = nextCallId;
-				nextCallId += 1;
-				const promise = new Promise((resolve, reject) => {
-					pending.set(callId, {
-						resolve,
-						reject
-					});
-				});
-				if (!post({
-					kind: workerFrame.call,
-					callId,
-					tool: name,
-					args
-				})) {
-					pending.delete(callId);
-					throw new ToolCallError(name, `${name}() could not be called: the arguments are not transferable or the run has ended`);
-				}
-				return await promise;
-			} finally {
-				releaseCallSlot();
-			}
-		};
-	};
-	const settleCall = (frame) => {
-		const callId = frame.callId;
-		if (typeof callId !== "number") return;
-		const entry = pending.get(callId);
-		if (!entry) return;
-		pending.delete(callId);
-		if (frame.ok === true) {
-			entry.resolve(frame.value);
-			return;
-		}
-		entry.reject(new ToolCallError(typeof frame.tool === "string" ? frame.tool : "unknown", typeof frame.message === "string" ? frame.message : "binding call failed"));
-	};
-	const cancelPending = (reason) => {
-		cancelled = reason;
-		flushPendingCalls(abortError(reason));
-	};
-	const assertItemCount = (helper, count, maxItemsPerCall) => {
-		if (count > maxItemsPerCall) throw new RangeError(`${helper}() received ${count} items, exceeding maxItemsPerCall (${maxItemsPerCall})`);
-	};
-	const installWorkflowHelpers = (args, maxItemsPerCall) => {
-		const target = globals();
-		target.args = args === void 0 ? null : args;
-		target.log = (message) => {
-			if (typeof message !== "string") throw new TypeError(`log(message) expects a string, received ${describeValue(message)}`);
-			post({
-				kind: workerFrame.narration,
-				message
-			});
-		};
-		target.phase = (title) => {
-			if (typeof title !== "string") throw new TypeError(`phase(title) expects a string, received ${describeValue(title)}`);
-			post({
-				kind: workerFrame.phase,
-				title
-			});
-		};
-		target.parallel = async (thunks) => {
-			if (!Array.isArray(thunks)) throw new TypeError(`parallel(thunks) expects an array of functions, received ${describeValue(thunks)}`);
-			assertItemCount("parallel", thunks.length, maxItemsPerCall);
-			for (let index = 0; index < thunks.length; index += 1) if (typeof thunks[index] !== "function") throw new TypeError(`parallel(thunks) expects functions; item ${index} is ${describeValue(thunks[index])}`);
-			return await Promise.all(thunks.map(async (thunk) => {
-				try {
-					return await thunk();
-				} catch {
-					return null;
-				}
-			}));
-		};
-		target.pipeline = async (items, ...stages) => {
-			if (!Array.isArray(items)) throw new TypeError(`pipeline(items, ...stages) expects an array of items, received ${describeValue(items)}`);
-			assertItemCount("pipeline", items.length, maxItemsPerCall);
-			if (stages.length === 0) throw new TypeError("pipeline(items, ...stages) requires at least one stage function");
-			for (let index = 0; index < stages.length; index += 1) if (typeof stages[index] !== "function") throw new TypeError(`pipeline(items, ...stages) expects stage functions; stage ${index} is ${describeValue(stages[index])}`);
-			const stageFunctions = stages;
-			return await Promise.all(items.map(async (item, index) => {
-				try {
-					let current = item;
-					for (const stage of stageFunctions) current = await stage(current, item, index);
-					return current;
-				} catch {
-					return null;
-				}
-			}));
-		};
-	};
-	const startRun = (frame) => {
-		installFrozenEnv();
-		installConsole();
-		maxPendingCalls = typeof frame.maxPendingCalls === "number" && Number.isFinite(frame.maxPendingCalls) && frame.maxPendingCalls > 0 ? frame.maxPendingCalls : Number.POSITIVE_INFINITY;
-		const tools = {};
-		const bindingNames = Array.isArray(frame.bindings) ? frame.bindings.filter((name) => typeof name === "string") : [];
-		for (const name of bindingNames) tools[name] = makeBinding(name);
-		const available = bindingNames.join(", ") || "(none)";
-		const candidates = Array.isArray(frame.bindingCandidates) ? frame.bindingCandidates : [];
-		for (const name of candidates) {
-			if (typeof name !== "string" || tools[name]) continue;
-			tools[name] = async () => {
-				throw new ToolCallError(name, `no binding named "${name}" in this run; available bindings: ${available}`);
-			};
-		}
-		globals().tools = tools;
-		if (frame.surface === "workflow") {
-			const maxItemsPerCall = typeof frame.maxItemsPerCall === "number" ? frame.maxItemsPerCall : 0;
-			installWorkflowHelpers(frame.args, maxItemsPerCall);
-		}
-		runProgram(typeof frame.code === "string" ? frame.code : "");
-	};
-	const handleHostFrame = (raw) => {
-		if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return;
-		const frame = raw;
-		if (frame.kind === hostFrame.init) {
-			if (started) return;
-			started = true;
-			startRun(frame);
-			return;
-		}
-		if (frame.kind === hostFrame.callResult) {
-			settleCall(frame);
-			return;
-		}
-		if (frame.kind === hostFrame.cancel) cancelPending(frame.reason === "timeout" ? "timeout" : "abort");
-	};
-	deps.parentPort.on("message", (value) => {
-		if (typeof value !== "object" || value === null) return;
-		const frame = value;
-		if (frame.kind !== hostFrame.connect) return;
-		const port = frame.port;
-		if (typeof port !== "object" || port === null || typeof port.on !== "function") return;
-		control = port;
-		control.on("message", handleHostFrame);
-		control.on("close", () => {
-			flushPendingCalls(closedError());
-		});
-		installWarningCapture();
-		post({ kind: workerFrame.ready });
-	});
+	#isHealthy(worker) {
+		return worker.threadId !== -1;
+	}
+};
+/**
+* Publish a frame-transfer event when the dispatcher's callResult postMessage carries
+* image bytes. Called from the dispatcher, not the pool, but lives here so the channel
+* name and payload shape stay one-file-defined (ADR-0017 Addendum).
+*/
+function publishImageBytes(byteLength) {
+	publish(channels.imageBytes, { byteLength });
+}
+/**
+* Publish the warm-worker's reset cost when its first `ready` frame arrives at the
+* host. `previousSettledAt` is the wall-clock time the pool last released this worker;
+* the gap is what the worker spent clearing per-run state and re-installing the surface.
+*/
+function publishResetTime(durationMs) {
+	publish(channels.resetTime, { durationMs });
 }
 //#endregion
 //#region src/runtime/worker-source.ts
-/** Build the worker module source for one spawn. */
-function buildWorkerSource(protocol) {
-	return [
-		`import { parentPort, workerData } from "node:worker_threads";`,
-		`import { inspect } from "node:util";`,
-		`import { stripTypeScriptTypes } from "node:module";`,
-		`const ptcDeps = ${JSON.stringify({ protocol })};`,
-		`(${workerMain.toString()})({ ...ptcDeps, parentPort, workerData, inspect, stripTypes: stripTypeScriptTypes });`
-	].join("\n");
-}
-/** The worker entry as a `data:` module URL, ready for `new Worker(url, options)`. */
-function buildWorkerUrl(protocol) {
-	return new URL(`data:text/javascript,${encodeURIComponent(buildWorkerSource(protocol))}`);
+/**
+* Worker source location.
+*
+* The previous bootstrap assembled a `data:text/javascript,…` URL from
+* `Function.prototype.toString()` of `workerMain` plus a protocol literal —
+* a single self-contained file but with no V8 code-cache reuse across spawns
+* (ADR-0017 §7). The rolldown dual-entry build now emits `dist/worker.js`
+* alongside `dist/index.js`; the host loads that file directly, which lets
+* V8's code cache and Node's module cache survive across warm-reuse spawns.
+*
+* The two candidates the resolver tries:
+*
+* 1. `dist/worker.js` — the rolldown output, sibling of `dist/index.js`. The
+*    production path used by `pi install npm:pi-ptc-subagents`.
+* 2. `src/runtime/worker-entry.ts` — the source, used by `vitest` runs
+*    (vitest's transformer handles `.ts` and the worker is launched in-process
+*    so the relative path resolves).
+*/
+/**
+* Resolve the worker entry's `file://` URL.
+*
+* The function takes no arguments: the protocol tables now travel through the
+* worker file itself (rolldown bundles `./protocol.ts` into `dist/worker.js`),
+* so the host has nothing to compose at URL-build time.
+*/
+function buildWorkerUrl() {
+	const here = dirname(fileURLToPath(import.meta.url));
+	const candidates = [resolve(here, "worker.js"), resolve(here, "worker-entry.ts")];
+	for (const candidate of candidates) if (existsSync(candidate)) return pathToFileURL(candidate);
+	throw new Error(`worker entry not found; tried: ${candidates.join(", ")}`);
 }
 //#endregion
 //#region src/runtime/dispatcher.ts
 /**
-* Host-side dispatcher: one `runPtcProgram()` call = one worker = one program.
+* Host-side dispatcher: one `runPtcProgram()` call = one program in one worker.
+*
+* The worker's lifecycle depends on the path (ADR-0017 §1):
+* - **cold** (no `pool`): the dispatcher spawns a worker for the run and terminates it when the
+*   run settles — one run, one worker;
+* - **pooled** (`pool` set): the dispatcher acquires a warm worker from the turn's pool and
+*   releases it back when the run settles. The worker outlives the run — the turn's later runs
+*   reuse it, and the pool's `drain()` retires it at turn end, not this file.
 *
 * Responsibilities:
 * - spawn a hardened worker (F1 env scrub, F2 V8 caps, F3 frozen per-run env in
-*   `workerData`, F4 `cwd` carried in the run config and handed to the bindings),
+*   `workerData`, F4 `cwd` carried in the run config and handed to the bindings) — the
+*   hardening itself is defined once, in `workerSpawnOptions` (`worker-pool.ts`),
 * - complete the `MessageChannel` handshake and send the `init` frame,
 * - route `tools.*` calls to the binding table — concurrently, with DSH's
-*   `maxParallelSubCalls` forwarding cap and `maxPendingCalls` admission control,
+*   `maxPendingCalls` admission control, the `maxParallelSubCalls` builtin
+*   forwarding cap (ADR-0004 consequence: the overflow FIFO-queues for a
+*   slot), and the per-run `dispatchConcurrency` hard cap on in-flight
+*   `pi.dispatch` calls (ADR-0016 §2: the overflow resolves immediately as
+*   rejected, it is never queued). The two caps have independent counters:
+*   neither throttles the other.
 * - collect logs / narration / phases and enforce the joint output budget,
-* - enforce the deadline, honour caller cancellation, and always tear the worker down.
+* - enforce the deadline, honour caller cancellation, and settle the run: hand the worker
+*   back (pooled) or tear it down (cold).
 *
 * Everything the worker can influence is treated as untrusted input: every frame goes
 * through the protocol guards, is size-checked, and can only ever end the run.
@@ -1197,10 +948,72 @@ function buildWorkerUrl(protocol) {
 function messageOf(error) {
 	return error instanceof Error ? error.message : String(error);
 }
-/** Serialized byte size of a frame, the unit both the output and message budgets use. */
+/** A leaf whose bytes JSON cannot express: it is billed by `byteLength`, not by its JSON text. */
+function isBinaryLeaf(value) {
+	return value instanceof ArrayBuffer || ArrayBuffer.isView(value);
+}
+/**
+* Walk a value tree, calling `onBinary` on every binary leaf (`ArrayBuffer` and any
+* `ArrayBufferView`). Cycles and shared sub-objects are visited once, so a pathological frame
+* cannot wedge or inflate the walk.
+*
+* Binary leaves are billed here rather than by their JSON text for two reasons: `JSON.stringify`
+* serialises an `ArrayBuffer` as `{}` (the size vanishes) and explodes a typed-array view into
+* one key per element (the size is overstated by ~6 bytes per element). The walk therefore stops
+* at the leaf and never recurses into a view's `.buffer`, which would count the same bytes twice.
+* ADR-0017 W-6 spells out the refactor; this is its binary half.
+*/
+function walkBinaryLeaves(value, onBinary) {
+	const seen = /* @__PURE__ */ new WeakSet();
+	const visit = (candidate) => {
+		if (candidate === null || candidate === void 0) return;
+		if (candidate instanceof ArrayBuffer) {
+			onBinary(candidate);
+			return;
+		}
+		if (ArrayBuffer.isView(candidate)) {
+			onBinary(candidate);
+			return;
+		}
+		if (typeof candidate !== "object") return;
+		if (seen.has(candidate)) return;
+		seen.add(candidate);
+		if (Array.isArray(candidate)) {
+			for (const item of candidate) visit(item);
+			return;
+		}
+		for (const key of Object.keys(candidate)) visit(candidate[key]);
+	};
+	visit(value);
+}
+/**
+* Serialized byte size of a frame, the unit both the output and message budgets use.
+*
+* The count is the JSON text the frame becomes — every brace, bracket, separator, key name and
+* scalar — plus the bytes of any binary leaf, which that text cannot express. Two passes:
+*
+* 1. the whole value through `JSON.stringify` with binary leaves substituted by `null`: every
+*    structural character, key name and scalar is billed the way the old helper billed it, and a
+*    cyclic value throws here (as before);
+* 2. the binary leaves by `byteLength`, added on top.
+*
+* A frame with binary leaves therefore counts 4 bytes (its substituted `null`) more than the JSON
+* text it would have if the bytes vanished. That residue is deliberate and the safe direction:
+* under-counting the payload is the hole ADR-0017 W-6 closes, and the worker's channel clones
+* those bytes for real.
+*
+* A frame with no binary leaf produces exactly the previous helper's number — the substituter is
+* a no-op when there is nothing to substitute — and a cyclic or otherwise unaccountable payload
+* still reports `Number.POSITIVE_INFINITY` so the caller fails the run.
+*/
 function serializedBytes(value) {
 	try {
-		return Buffer.byteLength(JSON.stringify(value) ?? "", "utf8");
+		const text = Buffer.byteLength(JSON.stringify(value, (_key, item) => isBinaryLeaf(item) ? null : item) ?? "", "utf8");
+		let binary = 0;
+		walkBinaryLeaves(value, (leaf) => {
+			binary += leaf.byteLength;
+		});
+		return text + binary;
 	} catch {
 		return Number.POSITIVE_INFINITY;
 	}
@@ -1214,7 +1027,6 @@ function serializedBytes(value) {
 */
 async function runPtcProgram(options) {
 	const config = resolveConfig(options.config);
-	const protocol = workerProtocolSpec();
 	const env = createWorkerEnv();
 	const runId = options.runId ?? randomUUID();
 	const timeoutMs = effectiveTimeoutMs(options.timeoutMs, config);
@@ -1230,63 +1042,97 @@ async function runPtcProgram(options) {
 			message: "run cancelled before start"
 		}
 	};
-	return await new Promise((resolve) => {
-		const worker = new Worker(buildWorkerUrl(protocol), {
-			name: `ptc-${options.surface}`,
+	let worker;
+	try {
+		if (options.pool) worker = await options.pool.acquire();
+		else worker = new Worker(buildWorkerUrl(), workerSpawnOptions({
+			surface: options.surface,
 			env,
-			workerData: {
-				runId,
-				env
-			},
-			resourceLimits: {
-				maxOldGenerationSizeMb: config.maxOldGenerationSizeMb,
-				maxYoungGenerationSizeMb: config.maxYoungGenerationSizeMb
+			limits: config,
+			runId
+		}));
+	} catch (error) {
+		return {
+			logs,
+			narrations,
+			phases,
+			error: {
+				kind: PTC_ERROR_KIND.workerExit,
+				message: `pool acquire failed: ${messageOf(error)}`
 			}
-		});
+		};
+	}
+	return await new Promise((resolve) => {
 		const channel = new MessageChannel();
 		const control = channel.port1;
 		const workerPort = channel.port2;
 		const bindingAbort = new AbortController();
 		let settled = false;
+		/** Set once a stop is under way; owns the terminal state from then on (`settleTerminal`). */
 		let cancelling;
+		/**
+		* Whether the worker has emitted its first `ready` frame. A cancel that lands before it does
+		* still arms the grace window (the settle time must be bounded even for a worker that never
+		* becomes reachable); the `ready` handler restarts that window, so a merely slow spawn gets
+		* its full `graceMs` from the moment it can actually react.
+		*/
+		let workerReady = false;
 		let pendingCalls = 0;
 		let outputBytes = 0;
+		/**
+		* Concurrently in-flight `pi.dispatch` calls, counted so the per-run hard cap
+		* (ADR-0016 §2) can reject the overflow immediately. There is deliberately no
+		* waiter queue behind this counter: the N+1th concurrent call resolves as
+		* rejected instead of waiting for a slot. Independent of `activeBuiltinCalls`.
+		*/
 		let activeDispatches = 0;
-		const dispatchWaiters = [];
-		const runDepth = 0;
+		/**
+		* Concurrently in-flight builtin binding calls, counted against
+		* `maxParallelSubCalls` (ADR-0004 consequence). Unlike the dispatch cap,
+		* the overflow FIFO-queues for a slot — DSH's semantics for builtin fan-out.
+		* Independent of `activeDispatches`.
+		*/
+		let activeBuiltinCalls = 0;
+		const builtinWaiters = [];
+		const runDepth = options.depth ?? 0;
+		/** Deadline timer: fires `timeoutMs` after the run started. A cancel does not disarm it. */
 		let runTimer;
+		/** The cancel's cooperative window: armed and re-armed by `armGraceTimer` only. */
 		let graceTimer;
 		const images = [];
 		/**
-		* Hoist the images out of one successful binding result.
+		* Capture the image blocks from one binding result.
 		*
-		* DSH does this in its scheduler's commit step: a subtool result whose content carries an image
-		* block has that content attached to the caller's context after the run, so the picture reaches
-		* the model without travelling through the program's lossless-JSON return value (`dsh-tools`:
-		* `exec.deferContext(createUserMessage(...))`). The host sees every binding result before it is
-		* posted to the worker, so this is the same seam.
+		* `PtcImage` has exactly one representation — base64 `data`, the same shape pi's own `read`
+		* returns and the same shape the JSON-only worker channel carries. A binding that emits
+		* `data: <base64>` passes through untouched (no decode/encode round trip); a binding that
+		* produces raw bytes is normalised here, once, host-side.
 		*
-		* Everything is hoisted: no count cap, no byte cap, no dedupe. How much context a run spends on
-		* images is the program's call, and hiding a cap behind a warning would make this layer a
-		* gatekeeper DSH does not have. pi's per-model resize (`inputLimits.images.resize`) still bounds
-		* what a single attachment costs at the provider.
+		* The caller (`dispatchCall`) only keeps the captured list when `postCallResult` returned
+		* true: a frame the port rejected was not a successful subtool result (ADR-0014 §2).
 		*/
-		const hoistImages = (value) => {
+		const captureImages = (value) => {
+			const captured = [];
 			const content = value?.content;
-			if (!Array.isArray(content)) return;
+			if (!Array.isArray(content)) return captured;
 			for (const block of content) {
 				if (block === null || typeof block !== "object") continue;
 				const candidate = block;
 				if (candidate.type !== "image") continue;
-				const data = typeof candidate.data === "string" ? candidate.data : "";
-				if (data.length === 0) continue;
-				images.push({
+				let data;
+				if (typeof candidate.data === "string" && candidate.data.length > 0) data = candidate.data;
+				else if (candidate.bytes instanceof ArrayBuffer && candidate.bytes.byteLength > 0) data = Buffer.from(candidate.bytes).toString("base64");
+				if (data === void 0) continue;
+				captured.push({
 					data,
 					mimeType: typeof candidate.mimeType === "string" ? candidate.mimeType : "application/octet-stream"
 				});
 			}
+			return captured;
 		};
 		const cancelMessage = (reason) => reason === "timeout" ? `run timed out after ${timeoutMs} ms` : "run cancelled";
+		/** The error kind a stop reports: whichever reason asked for it. */
+		const cancelErrorKind = (reason) => reason === "timeout" ? PTC_ERROR_KIND.timeout : PTC_ERROR_KIND.abort;
 		const finish = (outcome) => {
 			if (settled) return;
 			settled = true;
@@ -1295,7 +1141,8 @@ async function runPtcProgram(options) {
 			options.signal?.removeEventListener("abort", onAbortSignal);
 			bindingAbort.abort();
 			control.close();
-			worker.terminate();
+			if (options.pool) options.pool.release(worker);
+			else worker.terminate();
 			resolve(outcome);
 		};
 		const fail = (kind, message, stack) => {
@@ -1350,22 +1197,22 @@ async function runPtcProgram(options) {
 			fail(PTC_ERROR_KIND.outputLimit, `${source} exceeded the output budget: logs + result reached ${outputBytes} bytes (maxOutputBytes=${config.maxOutputBytes}); ${logs.length} log line(s) retained`);
 			return false;
 		};
-		const acquireDispatchSlot = async () => {
-			if (activeDispatches < config.maxParallelSubCalls) {
-				activeDispatches += 1;
+		const acquireBuiltinSlot = async () => {
+			if (activeBuiltinCalls < config.maxParallelSubCalls) {
+				activeBuiltinCalls += 1;
 				return;
 			}
 			await new Promise((slot) => {
-				dispatchWaiters.push(slot);
+				builtinWaiters.push(slot);
 			});
 		};
-		const releaseDispatchSlot = () => {
-			const next = dispatchWaiters.shift();
+		const releaseBuiltinSlot = () => {
+			const next = builtinWaiters.shift();
 			if (next) {
 				next();
 				return;
 			}
-			activeDispatches -= 1;
+			activeBuiltinCalls -= 1;
 		};
 		const handleCall = (frame) => {
 			pendingCalls += 1;
@@ -1389,10 +1236,25 @@ async function runPtcProgram(options) {
 				});
 				return;
 			}
-			await acquireDispatchSlot();
-			if (settled) {
-				releaseDispatchSlot();
-				return;
+			const isDispatch = frame.tool === DISPATCH_BINDING_NAME;
+			if (isDispatch) {
+				if (activeDispatches >= config.dispatchConcurrency) {
+					postCallResult({
+						kind: HOST_FRAME_KIND.callResult,
+						callId: frame.callId,
+						tool: frame.tool,
+						ok: true,
+						value: dispatchConcurrencyLimitReached()
+					});
+					return;
+				}
+				activeDispatches += 1;
+			} else {
+				await acquireBuiltinSlot();
+				if (settled) {
+					releaseBuiltinSlot();
+					return;
+				}
 			}
 			try {
 				const value = await binding.execute(frame.args, {
@@ -1401,13 +1263,23 @@ async function runPtcProgram(options) {
 					depth: runDepth,
 					maxDispatchDepth: config.maxDispatchDepth
 				});
-				if (postCallResult({
+				const captured = captureImages(value);
+				const callFrame = {
 					kind: HOST_FRAME_KIND.callResult,
 					callId: frame.callId,
 					tool: frame.tool,
 					ok: true,
 					value
-				})) hoistImages(value);
+				};
+				const callFrameBytes = serializedBytes(callFrame);
+				if (callFrameBytes > config.maxMessageBytes) {
+					fail(PTC_ERROR_KIND.protocol, `callResult frame of ${callFrameBytes} bytes exceeds maxMessageBytes (${config.maxMessageBytes})`);
+					return;
+				}
+				if (postCallResult(callFrame)) for (const image of captured) {
+					images.push(image);
+					publishImageBytes(Buffer.byteLength(image.data, "base64"));
+				}
 			} catch (error) {
 				postCallResult({
 					kind: HOST_FRAME_KIND.callResult,
@@ -1417,7 +1289,8 @@ async function runPtcProgram(options) {
 					message: messageOf(error)
 				});
 			} finally {
-				releaseDispatchSlot();
+				if (isDispatch) activeDispatches -= 1;
+				else releaseBuiltinSlot();
 			}
 		};
 		/** `true` when the worker actually received the result (see the hoist at the call site). */
@@ -1448,7 +1321,7 @@ async function runPtcProgram(options) {
 				narrations,
 				phases,
 				error: {
-					kind: cancelling === "timeout" ? PTC_ERROR_KIND.timeout : PTC_ERROR_KIND.abort,
+					kind: cancelErrorKind(cancelling),
 					message: cancelMessage(cancelling)
 				}
 			};
@@ -1470,6 +1343,17 @@ async function runPtcProgram(options) {
 			}
 			switch (frame.kind) {
 				case WORKER_FRAME_KIND.ready:
+					if (options.pool) {
+						const previousSettled = options.pool.lastSettledAt(worker);
+						if (previousSettled !== void 0) publishResetTime(Date.now() - previousSettled);
+					}
+					if (!workerReady) {
+						workerReady = true;
+						if (cancelling) {
+							armGraceTimer(cancelling);
+							return;
+						}
+					}
 					sendInit();
 					return;
 				case WORKER_FRAME_KIND.call:
@@ -1512,21 +1396,34 @@ async function runPtcProgram(options) {
 		function onAbortSignal() {
 			beginCancel("abort");
 		}
+		/**
+		* Arm the cooperative-cancel window: `graceMs` from now the run settles with `reason`, unless
+		* the worker settles it first. Re-arming replaces the pending window.
+		*
+		* The invariant this guards: **from the moment a run starts, it settles in bounded time.**
+		* The window is therefore armed by `beginCancel` itself, not by the worker's `ready` frame —
+		* a worker that never becomes reachable (spawn failure, wedged module load, a thread the OS
+		* stopped scheduling) can no longer leave the run pending forever.
+		*/
+		const armGraceTimer = (reason) => {
+			if (graceTimer) clearTimeout(graceTimer);
+			graceTimer = setTimeout(() => {
+				fail(cancelErrorKind(reason), cancelMessage(reason));
+			}, config.graceMs);
+		};
 		function beginCancel(reason) {
-			if (settled || cancelling) return;
-			cancelling = reason;
-			if (runTimer) {
-				clearTimeout(runTimer);
-				runTimer = void 0;
+			if (settled) return;
+			if (cancelling) {
+				fail(cancelErrorKind(cancelling), cancelMessage(cancelling));
+				return;
 			}
+			cancelling = reason;
 			bindingAbort.abort();
 			sendControl({
 				kind: HOST_FRAME_KIND.cancel,
 				reason
 			});
-			graceTimer = setTimeout(() => {
-				fail(reason === "timeout" ? PTC_ERROR_KIND.timeout : PTC_ERROR_KIND.abort, cancelMessage(reason));
-			}, config.graceMs);
+			armGraceTimer(reason);
 		}
 		worker.on("error", (error) => {
 			fail(PTC_ERROR_KIND.workerExit, `worker failed: ${messageOf(error)}`);
@@ -1726,6 +1623,20 @@ function renderModelValue(value) {
 * `details` stays raw for the TUI. See ADR-0012.
 */
 /**
+* Read the depth baseline pi-ptc was started with inside a child pi process.
+*
+* `dispatch()` stamps `PI_PTC_DEPTH` (the child's own depth) onto the spawned subprocess's
+* environment, and the extension entrypoint reads it back here so a child PTC run's binding
+* context starts at the dispatched depth instead of at 0 — otherwise the recursion bound in
+* `dispatch()` could never bite below the first level. Only a pure non-negative integer is
+* accepted; a missing or malformed value means "not a dispatched child" and yields 0.
+*/
+function resolveDepthFromEnv(source = process.env) {
+	const raw = source.PI_PTC_DEPTH;
+	if (raw === void 0 || !/^\d+$/.test(raw)) return 0;
+	return Number.parseInt(raw, 10);
+}
+/**
 * Binding names for one run: the built-ins this session actually has enabled (T7, #21).
 *
 * A PTC program must never reach further than the session it runs in — a session started
@@ -2396,8 +2307,9 @@ const PARAMETERS$1 = Type.Object({
 /**
 * Build the `ptc_run_code` tool definition.
 *
-* Called once by the extension factory. Every run gets a fresh worker and a fresh binding table
-* built against the run's own cwd, so two concurrent calls cannot share state.
+* Called once by the extension factory. Each execute builds its own binding table against the
+* run's own cwd and reads `getPool()` for the surface's (possibly absent) pool — see
+* `PtcRunCodeToolOptions` for what pooling does and does not change about isolation.
 */
 function createPtcRunCodeTool(options = {}) {
 	return defineTool({
@@ -2411,17 +2323,21 @@ function createPtcRunCodeTool(options = {}) {
 			const cwd = resolveToolCwd(ctx);
 			const names = resolveBindingNames(options.getBindingSourceNames?.());
 			const startedAt = Date.now();
+			const pool = options.getPool?.();
 			const outcome = await runPtcProgram({
 				code: params.code,
 				surface: "run_code",
 				cwd,
 				bindings: createBuiltinBindings({
 					cwd,
-					names
+					names,
+					includeDispatch: true
 				}),
+				...options.depth === void 0 ? {} : { depth: options.depth },
 				...params.timeoutMs === void 0 ? {} : { timeoutMs: params.timeoutMs },
 				...signal === void 0 ? {} : { signal },
-				...options.config === void 0 ? {} : { config: options.config }
+				...options.config === void 0 ? {} : { config: options.config },
+				...pool === void 0 ? {} : { pool }
 			});
 			if (outcome.error !== void 0) throw codeRunFailedError(outcome);
 			return renderToolResult({
@@ -2444,7 +2360,7 @@ function createPtcRunCodeTool(options = {}) {
 /**
 * `ptc_workflow` — the structured PTC surface.
 *
-* Same worker, same bindings, same Node surface as `ptc_run_code`; what it adds is a plan
+* Same worker program, same bindings, same Node surface as `ptc_run_code`; what it adds is a plan
 * (`meta` with an ordered phase list), plain-JSON input (`args`, bound as the program's `args`
 * global) and the four workflow helpers: `log` / `phase` / `parallel` / `pipeline` (G1 #13 →
 * decision B — there is no `agent()`, not even a stub).
@@ -2491,11 +2407,6 @@ const PARAMETERS = Type.Object({
 	script: Type.String({ description: "The program: the body of an async TypeScript function." }),
 	args: Type.Optional(Type.Record(Type.String(), Type.Unknown(), { description: "Plain-JSON input bound to the program's `args` global. No functions, symbols, undefined values or cycles." }))
 });
-function describeValue(value) {
-	if (value === null) return "null";
-	if (Array.isArray(value)) return "an array";
-	return `a ${typeof value}`;
-}
 /**
 * Reject anything that is not plain JSON, with a path-qualified reason.
 *
@@ -2564,8 +2475,9 @@ function unlistedPhaseWarnings(outcome, declared) {
 /**
 * Build the `ptc_workflow` tool definition.
 *
-* `args` is validated before `runPtcProgram` is called, so a malformed payload never spawns a
-* worker. Everything after dispatch is identical to `ptc_run_code`, plus the phase roll-up.
+* `args` is validated before `runPtcProgram` is called, so a malformed payload never acquires or
+* spawns a worker. Everything after dispatch is identical to `ptc_run_code`, plus the phase
+* roll-up.
 */
 function createPtcWorkflowTool(options = {}) {
 	return defineTool({
@@ -2580,17 +2492,21 @@ function createPtcWorkflowTool(options = {}) {
 			const cwd = resolveToolCwd(ctx);
 			const names = resolveBindingNames(options.getBindingSourceNames?.());
 			const startedAt = Date.now();
+			const pool = options.getPool?.();
 			const outcome = await runPtcProgram({
 				code: params.script,
 				surface: "workflow",
 				cwd,
 				bindings: createBuiltinBindings({
 					cwd,
-					names
+					names,
+					includeDispatch: true
 				}),
 				...params.args === void 0 ? {} : { args: params.args },
+				...options.depth === void 0 ? {} : { depth: options.depth },
 				...signal === void 0 ? {} : { signal },
-				...options.config === void 0 ? {} : { config: options.config }
+				...options.config === void 0 ? {} : { config: options.config },
+				...pool === void 0 ? {} : { pool }
 			});
 			if (outcome.error !== void 0) throw codeRunFailedError(outcome);
 			const declared = params.meta.phases?.map((phase) => phase.name);
@@ -2611,6 +2527,61 @@ function createPtcWorkflowTool(options = {}) {
 	});
 }
 //#endregion
+//#region src/runtime/turn-pools.ts
+/**
+* Per-turn pool holder: one `WorkerPool` per PTC surface, created lazily on first use
+* and retired together at turn end (ADR-0017 §1–§2).
+*
+* The pi extension owns one `TurnPools` per agent turn and hands each tool a getter for
+* its own surface's pool. Lazy creation is what makes the cold turn cheap: a turn that
+* never runs a PTC program never spawns a worker, and a turn that runs one `ptc_run_code`
+* pays exactly one cold spawn (which the pool then keeps warm for the rest of the turn).
+*
+* `run_code` and `workflow` do not share a pool (ADR-0017 §2): their worker surfaces differ
+* (`installWorkflowHelpers` is conditional in `worker-main.ts`), and one pool per surface
+* keeps that story simple. The workers themselves carry no surface state — each run's
+* `init` frame names its surface — so the split is about ownership, not correctness.
+*/
+var TurnPools = class {
+	#config;
+	#pools = /* @__PURE__ */ new Map();
+	constructor(options = {}) {
+		this.#config = resolveConfig(options.config);
+	}
+	/**
+	* The pool for one surface, created on first request. Warm workers from an earlier
+	* run in this turn are served by the same pool (that is the point); a fresh
+	* `TurnPools` is how a turn gets a fresh set.
+	*/
+	get(surface) {
+		const existing = this.#pools.get(surface);
+		if (existing !== void 0) return existing;
+		const env = createWorkerEnv();
+		const pool = new WorkerPool({
+			buildWorkerUrl,
+			size: this.#config.poolSize,
+			acquireTimeoutMs: this.#config.poolAcquireTimeoutMs,
+			drainGraceMs: this.#config.drainGraceMs,
+			workerOptions: workerSpawnOptions({
+				surface,
+				env,
+				limits: this.#config
+			})
+		});
+		this.#pools.set(surface, pool);
+		return pool;
+	}
+	/**
+	* Terminate every pool this holder created. Idempotent, and safe to call from a turn
+	* boundary hook: a second call finds nothing to drain.
+	*/
+	async drain() {
+		const pools = [...this.#pools.values()];
+		this.#pools.clear();
+		await Promise.all(pools.map((pool) => pool.drain()));
+	}
+};
+//#endregion
 //#region src/mode/ptc-mode.ts
 /**
 * PTC default mode — the session-level tool-restriction state machine.
@@ -2963,14 +2934,46 @@ function ptcSubagents(pi) {
 	const mode = initialModeState();
 	let briefingPending = false;
 	/**
+	* Per-turn worker pools (ADR-0017 §1–§2): one warm set per surface, created lazily by the
+	* first PTC run of the turn and retired at the turn's end. The holder is swapped rather
+	* than mutated so a `turn_end` drain can never race a run that is still holding a worker —
+	* the outgoing holder owns everything the ending turn created.
+	*/
+	let turnPools = new TurnPools();
+	/**
 	* Bindings come from the mode's base snapshot while PTC mode is on, and from the live loadout
 	* otherwise (T7, #21). See `src/mode/ptc-mode.ts` for why the snapshot is required: the mode
 	* hides the built-ins, which would otherwise empty the binding table and make every
 	* `tools.<name>(...)` call fail.
 	*/
 	const getBindingSourceNames = () => bindingSource(mode, pi.getActiveTools());
-	pi.registerTool(createPtcRunCodeTool({ getBindingSourceNames }));
-	pi.registerTool(createPtcWorkflowTool({ getBindingSourceNames }));
+	/**
+	* Depth baseline for PTC runs this pi process starts (ADR-0016 Recursive section).
+	* Inside a pi process spawned by `pi.dispatch`, the env carries `PI_PTC_DEPTH`; a
+	* normal pi session has none, and the parent turn's runs stay at depth 0.
+	*/
+	const ptcDepth = resolveDepthFromEnv();
+	pi.registerTool(createPtcRunCodeTool({
+		getBindingSourceNames,
+		getPool: () => turnPools.get("run_code"),
+		depth: ptcDepth
+	}));
+	pi.registerTool(createPtcWorkflowTool({
+		getBindingSourceNames,
+		getPool: () => turnPools.get("workflow"),
+		depth: ptcDepth
+	}));
+	/**
+	* Retire the turn's pools. `drain()` terminates the warm workers, so nothing outlives the
+	* turn that spawned it; the next PTC run starts a fresh, lazily-created set. Idle workers are
+	* already `unref()`-ed by the pool, so a turn that ends without this hook firing can never
+	* keep the process alive either.
+	*/
+	pi.on("turn_end", async () => {
+		const draining = turnPools;
+		turnPools = new TurnPools();
+		await draining.drain();
+	});
 	const paintStatus = (ctx) => {
 		ctx.ui.setStatus(PTC_MODE_STATUS_KEY, mode.enabled ? ctx.ui.theme.fg("accent", MODE_STATUS_TEXT) : void 0);
 	};
@@ -3122,6 +3125,6 @@ function ptcSubagents(pi) {
 	});
 }
 //#endregion
-export { BUILTIN_BINDING_NAMES, DEFAULT_BINDING_NAMES, DEFAULT_CONFIG, DEFAULT_HIDE_STRATEGY, HOST_FRAME_KIND, MAX_LINE_CHARS, MODE_REQUIRED_TOOL_NAMES, PTC_ERROR_KIND, PTC_LOG_LEVEL, PTC_MODE_CONFIG_FILE, PTC_MODE_ENTRY_TYPE, PTC_MODE_STATUS_KEY, PTC_MODE_TOOL_NAMES, PTC_SKILL_LOAD_INSTRUCTION, SKILL_READING_TOOL_NAMES, WORKER_ENV_ALLOW_LIST, WORKER_FRAME_KIND, bindingSource, buildModeInstruction, buildPtcSkillsSection, createBuiltinBindings, createWorkerEnv, decideModeEntry, ptcSubagents as default, detectExternalLoadoutChange, effectiveTimeoutMs, initialModeState, modeLoadout, readDefaultModeConfig, renderModelValue, resolveBaseOnStart, resolveConfig, runPtcProgram, sameToolSet, sanitizeText, skillsSectionDropped, stripAnsi };
+export { BUILTIN_BINDING_NAMES, DEFAULT_BINDING_NAMES, DEFAULT_CONFIG, DEFAULT_HIDE_STRATEGY, HOST_FRAME_KIND, MAX_LINE_CHARS, MODE_REQUIRED_TOOL_NAMES, PTC_ERROR_KIND, PTC_LOG_LEVEL, PTC_MODE_CONFIG_FILE, PTC_MODE_ENTRY_TYPE, PTC_MODE_STATUS_KEY, PTC_MODE_TOOL_NAMES, PTC_SKILL_LOAD_INSTRUCTION, SKILL_READING_TOOL_NAMES, TurnPools, WORKER_ENV_ALLOW_LIST, WORKER_FRAME_KIND, WorkerPool, bindingSource, buildModeInstruction, buildPtcSkillsSection, createBuiltinBindings, createWorkerEnv, decideModeEntry, ptcSubagents as default, detectExternalLoadoutChange, effectiveTimeoutMs, initialModeState, modeLoadout, readDefaultModeConfig, renderModelValue, resolveBaseOnStart, resolveConfig, runPtcProgram, sameToolSet, sanitizeText, skillsSectionDropped, stripAnsi };
 
 //# sourceMappingURL=index.js.map