pi-ptc-subagents 0.1.2 → 0.1.3

package/dist/index.js

@@ -1,3130 +1,32 @@
-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 { existsSync, readFileSync, writeFileSync } from "node:fs";
-import * as os from "node:os";
-import { tmpdir } from "node:os";
-import * as path from "node:path";
-import { dirname, join, resolve } from "node:path";
-import { randomUUID } from "node:crypto";
-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: the parallel binding that spawns a fresh pi subprocess per call.
-*
-* 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:
-* does not require the user to install pi's subagent extension. See ADR-0016 section 2.
-*/
-/**
-* The CLI command used to invoke a fresh pi subprocess for one dispatch.
-*
-* Always `"pi"` — pi-ptc is a library, not a CLI, and `dispatch` must spawn the
-* separate `pi` binary regardless of how the host process was launched. An
-* earlier copy of this function mirrored pi's own subagent extension and tried
-* to reuse `process.execPath + process.argv[1]`, which works only when the host
-* is `pi` itself; in any other host (test scripts, the dispatcher host process,
-* etc.) the function would spawn the host script in place of `pi`, producing
-* infinite recursion and a stdout pipe that never drains (so `proc.on('close')`
-* never fires). The caller surfaces a missing-binary condition via the child's
-* `error` event — `spawn` itself does not throw synchronously on ENOENT, the
-* async `error` listener does.
-*/
-const PI_COMMAND = "pi";
-/**
-* Compose the system prompt handed to the child subprocess.
-*
-* The agent's own markdown body is the user-supplied content; pi-ptc appends a
-* `<pi-ptc-context depth="N" max-depth="M">...</pi-ptc-context>` hint so the child
-* agent can see how much recursion room it has. The shape mirrors DSH's existing
-* subagent-context injection so the field recognises it.
-*/
-function appendDepthHint(systemPrompt, depth, maxDepth) {
-	const hint = [
-		"<pi-ptc-context depth=\"" + depth + "\" max-depth=\"" + maxDepth + "\">",
-		"You are a PTC run at depth " + depth + " (root is depth 0). You may write PTC programs and you may",
-		"call pi.dispatch(...) to spawn further children, but each level costs a fresh pi subprocess.",
-		"The remaining depth budget is " + maxDepth + " - " + depth + ". Beyond it, pi.dispatch rejects with",
-		"{ status: \"rejected\", errorMessage: \"dispatch depth limit reached\" }.",
-		"</pi-ptc-context>"
-	].join("\n");
-	return systemPrompt.length === 0 ? hint : systemPrompt + "\n\n" + hint;
-}
-/** 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"
-	};
-}
-/**
-* 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
-	};
-}
-/**
-* Decide the outcome of one `dispatch(...)` based on the child's `close` event.
-*
-* Cancellation has priority over every other branch: when the host's signal
-* aborted the run, the child exited because we asked it to, and the contract
-* (ADR-0016 §4) is to surface "dispatch cancelled" rather than leave the
-* caller guessing why an aborted run came back `rejected`.
-*
-* Non-cancellation cases follow the original close-handler ladder:
-*   - exit 0 with final text → fulfilled
-*   - exit 0 without final text → rejected (the model never answered)
-*   - any other exit code → rejected, no errorMessage (spawn-error path labels
-*     its own failures with `failed to spawn pi: ...`)
-*/
-function decideCloseOutcome(input) {
-	if (input.aborted) return {
-		status: "rejected",
-		errorMessage: "dispatch cancelled"
-	};
-	if (input.exitCode === 0 && input.finalText.length > 0) return { status: "fulfilled" };
-	if (input.exitCode === 0) return {
-		status: "rejected",
-		errorMessage: "dispatch produced no final text"
-	};
-	return { status: "rejected" };
-}
-/**
-* Send `signal` to `proc` iff the process is still attached, swallowing
-* "process already gone" throws. Returns whether a kill was actually issued.
-*
-* `proc.pid === undefined` happens for processes spawned without a usable
-* pid (rare, but TS-strict demands the guard); `proc.kill` throwing happens
-* for processes that exited between the guard and the syscall (the OS hands
-* back ESRCH). Both are "no-op successfully" for our purposes.
-*/
-function safeKill(proc, signal) {
-	if (proc.pid === void 0) return false;
-	try {
-		proc.kill(signal);
-		return true;
-	} catch {
-		return false;
-	}
-}
-/**
-* Minimal YAML frontmatter scalar parser. Returns the trimmed value, with surrounding
-* double or single quotes stripped when both are present.
-*/
-function extractYamlString(yaml, key) {
-	const m = yaml.match(new RegExp("^" + key + ":\\s*(.+)$", "m"));
-	if (!m) return void 0;
-	let v = (m[1] ?? "").trim();
-	if (v.length >= 2) {
-		const first = v[0];
-		const last = v[v.length - 1];
-		if (first === "\"" && last === "\"" || first === "'" && last === "'") v = v.slice(1, -1);
-	}
-	return v.length === 0 ? void 0 : v;
-}
-/**
-* Minimal YAML list parser: accepts inline `[a, b, c]` and bare `a, b, c`.
-*/
-function extractYamlList(yaml, key) {
-	const m = yaml.match(new RegExp("^" + key + ":\\s*(.+)$", "m"));
-	if (!m) return void 0;
-	let inner = (m[1] ?? "").trim();
-	if (inner.startsWith("[") && inner.endsWith("]")) inner = inner.slice(1, -1);
-	const parts = inner.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
-	return parts.length === 0 ? void 0 : parts;
-}
-/**
-* Parse an agent markdown file: YAML frontmatter (name / description / model / tools)
-* plus the body, returned as the system prompt. Tolerates a missing or partial
-* frontmatter; the caller falls back to defaults when this returns null.
-*/
-function parseAgentMarkdown(content) {
-	const fmMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
-	if (!fmMatch) return null;
-	const frontmatter = fmMatch[1] ?? "";
-	const body = fmMatch[2] ?? "";
-	const name = extractYamlString(frontmatter, "name");
-	if (!name) return null;
-	const description = extractYamlString(frontmatter, "description") ?? "";
-	const model = extractYamlString(frontmatter, "model") ?? "";
-	const tools = extractYamlList(frontmatter, "tools");
-	const out = {
-		name,
-		systemPrompt: body.trim()
-	};
-	if (description !== void 0) out.description = description;
-	if (model !== void 0) out.model = model;
-	if (tools !== void 0) out.tools = tools;
-	return out;
-}
-/**
-* Discover an agent by name. Mirrors pi's subagent extension agentScope behaviour:
-* user-level (`~/.pi/agent/agents/`) is loaded by default; project-level
-* (`<cwd>/.pi/agents/`) is loaded only when agentScope includes it.
-*/
-function discoverAgent(name, cwd, agentScope) {
-	const userDir = path.join(os.homedir(), ".pi", "agent", "agents");
-	const projectDir = path.join(cwd, ".pi", "agents");
-	const candidates = [];
-	if (agentScope === "user" || agentScope === "both") candidates.push({
-		path: path.join(userDir, name + ".md"),
-		source: "user"
-	});
-	if (agentScope === "project" || agentScope === "both") candidates.push({
-		path: path.join(projectDir, name + ".md"),
-		source: "project"
-	});
-	for (const c of candidates) {
-		let raw;
-		try {
-			raw = fs.readFileSync(c.path, "utf-8");
-		} catch {
-			continue;
-		}
-		const parsed = parseAgentMarkdown(raw);
-		if (parsed && parsed.name === name) {
-			const out = {
-				name: parsed.name,
-				source: c.source,
-				systemPrompt: parsed.systemPrompt
-			};
-			if (parsed.model !== void 0) out.model = parsed.model;
-			if (parsed.tools !== void 0) out.tools = parsed.tools;
-			return out;
-		}
-	}
-	return null;
-}
-/**
-* Build the argv handed to the child pi subprocess. Model / thinking / tools / agentScope
-* precedence: dispatch input (call site) > agent markdown frontmatter > nothing.
-* The agent's system prompt (with the depth hint appended) is materialised to a tmpfile
-* and passed via --append-system-prompt, exactly as the subagent extension does.
-*/
-function buildArgv(input, agent, promptFilePath) {
-	const args = [
-		"--mode",
-		"json",
-		"-p",
-		"--no-session"
-	];
-	const model = input.model ?? agent.model;
-	if (model) args.push("--model", model);
-	const thinking = input.thinkingLevel ?? "off";
-	args.push("--thinking", thinking);
-	if (agent.tools && agent.tools.length > 0) args.push("--tools", agent.tools.join(","));
-	args.push("--append-system-prompt", promptFilePath);
-	args.push("Task: " + input.task);
-	return args;
-}
-function parseAgentEvent(line) {
-	const trimmed = line.trim();
-	if (trimmed.length === 0) return null;
-	try {
-		return JSON.parse(trimmed);
-	} catch {
-		return null;
-	}
-}
-/**
-* Write the system prompt (with depth hint appended) to a tmpfile. The caller is
-* responsible for cleanup; we use mkdtemp + 0o600 to keep the prompt private, then
-* best-effort cleanup in the dispatch() Promise.
-*/
-async function writePromptToTempFile(agentName, prompt) {
-	const tmpDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "pi-dispatch-"));
-	const safeName = agentName.replace(/[^\w.-]+/g, "_");
-	const filePath = path.join(tmpDir, "prompt-" + safeName + ".md");
-	await fs.promises.writeFile(filePath, prompt, {
-		encoding: "utf-8",
-		mode: 384
-	});
-	return {
-		dir: tmpDir,
-		filePath
-	};
-}
-/**
-* Best-effort cleanup of the tmpfile + dir used for the system prompt. Errors are
-* deliberately swallowed: leaving a tmpfile around is preferable to crashing the run.
-*/
-function cleanupTmp(tmp) {
-	try {
-		fs.unlinkSync(tmp.filePath);
-	} catch {}
-	try {
-		fs.rmdirSync(tmp.dir);
-	} catch {}
-}
-/**
-* Spawn one pi subprocess for one dispatch and resolve with a DispatchResult.
-*
-* Behavioural contract (ADR-0016 sections 1, 3, 4):
-*   - Resolves with status: fulfilled when the child exits 0 and emits at least one
-*     assistant message whose text is non-empty.
-*   - Resolves with status: rejected on non-zero exit, signal kill, spawn failure,
-*     unknown agent, or no usable final text.
-*   - Never rejects. The caller can pattern-match on outcome.status the same way
-*     it would pattern-match a Promise.allSettled record.
-*   - Honours signal with SIGTERM, then SIGKILL after a 5s grace window.
-*/
-async function dispatch(input, ctx) {
-	const childDepth = ctx.depth + 1;
-	if (childDepth > ctx.maxDispatchDepth) return dispatchDepthLimitReached();
-	const cwd = input.cwd ?? ctx.cwd;
-	const agentScope = input.agentScope ?? "user";
-	const start = Date.now();
-	const agent = discoverAgent(input.agent, cwd, agentScope);
-	if (!agent) return {
-		text: "",
-		status: "rejected",
-		agentName: input.agent,
-		durationMs: Date.now() - start,
-		exitCode: 1,
-		errorMessage: "unknown agent: " + input.agent + " (agentScope=" + agentScope + ", cwd=" + cwd + ")"
-	};
-	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) => {
-		let stdoutBuffer = "";
-		let stderrBuf = "";
-		let finalText = "";
-		let usage;
-		let exitCode = -1;
-		let resolved = false;
-		let killTimer;
-		let proc;
-		let aborted = false;
-		const finalize = (status, errorMessage) => {
-			if (resolved) return;
-			resolved = true;
-			if (killTimer) clearTimeout(killTimer);
-			if (ctx.signal) ctx.signal.removeEventListener("abort", onAbort);
-			cleanupTmp(tmp);
-			const out = {
-				text: finalText,
-				status,
-				agentName: agent.name,
-				durationMs: Date.now() - start,
-				exitCode
-			};
-			if (usage) out.usage = usage;
-			if (stderrBuf.length > 0) out.stderr = stderrBuf;
-			if (errorMessage) out.errorMessage = errorMessage;
-			resolve(out);
-		};
-		const onAbort = () => {
-			if (!proc || proc.killed || resolved) return;
-			aborted = true;
-			safeKill(proc, "SIGTERM");
-			killTimer = setTimeout(() => {
-				if (proc && !proc.killed) safeKill(proc, "SIGKILL");
-			}, 5e3);
-		};
-		try {
-			proc = spawn(PI_COMMAND, argv, {
-				cwd,
-				shell: false,
-				stdio: [
-					"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)));
-			return;
-		}
-		if (ctx.signal) {
-			if (ctx.signal.aborted) onAbort();
-			else ctx.signal.addEventListener("abort", onAbort, { once: true });
-		}
-		const stdout = proc.stdout;
-		if (!stdout) return;
-		stdout.on("data", (data) => {
-			stdoutBuffer += data.toString("utf-8");
-			let nl = stdoutBuffer.indexOf("\n");
-			while (nl >= 0) {
-				const line = stdoutBuffer.slice(0, nl);
-				stdoutBuffer = stdoutBuffer.slice(nl + 1);
-				const ev = parseAgentEvent(line);
-				if (!ev) {
-					nl = stdoutBuffer.indexOf("\n");
-					continue;
-				}
-				if (ev.type === "message_end" && ev.message && ev.message.role === "assistant") {
-					const m = ev.message;
-					if (m.usage) {
-						const cur = usage ?? {
-							input: 0,
-							output: 0,
-							cacheRead: 0,
-							cacheWrite: 0,
-							cost: 0,
-							turns: 0
-						};
-						cur.input += m.usage.input ?? 0;
-						cur.output += m.usage.output ?? 0;
-						cur.cacheRead += m.usage.cacheRead ?? 0;
-						cur.cacheWrite += m.usage.cacheWrite ?? 0;
-						cur.cost += m.usage.cost?.total ?? 0;
-						cur.turns += 1;
-						usage = cur;
-					}
-					if (Array.isArray(m.content)) {
-						for (const part of m.content) if (part && part.type === "text" && typeof part.text === "string") finalText = part.text;
-					}
-				}
-				nl = stdoutBuffer.indexOf("\n");
-			}
-		});
-		const stderrStream = proc.stderr;
-		if (!stderrStream) return;
-		stderrStream.on("data", (data) => {
-			stderrBuf += data.toString("utf-8");
-		});
-		proc.on("close", (code) => {
-			exitCode = code ?? -1;
-			const { status, errorMessage } = decideCloseOutcome({
-				exitCode,
-				finalText,
-				aborted
-			});
-			finalize(status, errorMessage);
-		});
-		proc.on("error", (err) => {
-			stderrBuf += "[spawn-error] " + err.message + "\n";
-			finalize("rejected", "failed to spawn pi: " + err.message);
-		});
-	});
-}
-//#endregion
-//#region src/runtime/bindings.ts
-/**
-* Bindings: the pi tools a PTC program may call as `tools.<name>(args)`.
-*
-* R5 found that pi's extension API exposes no tool-dispatch surface — `pi.on('tool_call')`
-* only fires from the agent loop, `extensionsResult.runtime` is state plumbing, and
-* `pi.exec` has no `execArgv`/`resourceLimits`/`stdio`. So a binding builds the tool with
-* pi's own SDK factory and calls `execute()` on it directly. That keeps the tool
-* implementation identical to the native one, but it also means worker-driven calls are
-* **not** seen by pi's tool-call pipeline: `tool_call` guards, `protected-paths`-style
-* extensions, permission gates and sandbox overrides never run for them. This is the
-* inherited risk ADR-0005 accepts and records — it must not be described as resolved, and
-* nothing here may pretend to route through `pi.on('tool_call')`.
-*
-* Arguments are validated with pi's own `validateToolArguments`, the same helper the agent
-* loop uses, so a bad call fails with the same message (and the same coercion) it would
-* get from the native pipeline.
-*/
-/** pi's built-in tools that can be exposed as bindings, in native order. */
-const BUILTIN_BINDING_NAMES = [
-	"read",
-	"bash",
-	"edit",
-	"write",
-	"grep",
-	"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.
-*
-* `bash` is included on purpose: DSH's PTC preset still mounts `tool-bash`/`tool-pwsh`
-* (R1 §2 — PTC mode hides the tools from the wire list and re-exposes the same registry
-* as bindings), so a PTC program written against DSH may run shell commands. Leaving it
-* out would silently shrink the surface relative to DSH. Callers that want a read-only
-* PTC surface pass an explicit subset.
-*/
-const DEFAULT_BINDING_NAMES = BUILTIN_BINDING_NAMES;
-const BUILTIN_TOOL_FACTORIES = {
-	read: createReadTool,
-	bash: createBashTool,
-	edit: createEditTool,
-	write: createWriteTool,
-	grep: createGrepTool,
-	find: createFindTool,
-	ls: createLsTool
-};
-/**
-* Build the binding table for one run.
-*
-* Tools are created once per table and reused across calls, matching pi's own extension
-* examples (`createXxxTool(cwd)` caches nothing internally, so one instance per run is
-* the intended granularity).
-*/
-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];
-		if (!factory) throw new TypeError(`unknown PTC binding "${name}"; known bindings: ${BUILTIN_BINDING_NAMES.join(", ")}`);
-		const tool = factory(options.cwd);
-		table.set(name, {
-			name,
-			execute: async (args, context) => {
-				const toolCallId = `ptc:${context.callId}`;
-				const toolCall = {
-					type: "toolCall",
-					id: toolCallId,
-					name: tool.name,
-					arguments: args
-				};
-				const validated = validateToolArguments(tool, toolCall);
-				const result = await tool.execute(toolCallId, validated, context.signal, void 0);
-				return {
-					content: result.content,
-					details: result.details === void 0 ? null : result.details
-				};
-			}
-		});
-	}
-	if (includeDispatch) table.set(DISPATCH_BINDING_NAME, {
-		name: DISPATCH_BINDING_NAME,
-		execute: async (args, context) => {
-			return dispatch(args, {
-				signal: context.signal,
-				callId: context.callId,
-				cwd: options.cwd,
-				depth: context.depth,
-				maxDispatchDepth: context.maxDispatchDepth
-			});
-		}
-	});
-	return table;
-}
-//#endregion
-//#region src/runtime/limits.ts
-const DEFAULT_CONFIG = Object.freeze({
-	timeoutMs: 12e4,
-	maxTimeoutMs: 6e5,
-	maxOutputBytes: 67108864,
-	maxMessageBytes: 134217728,
-	maxPendingCalls: 128,
-	maxParallelSubCalls: 10,
-	dispatchConcurrency: 8,
-	maxDispatchDepth: 3,
-	maxItemsPerCall: 4096,
-	graceMs: 3e3,
-	maxOldGenerationSizeMb: 512,
-	maxYoungGenerationSizeMb: 64,
-	poolSize: 4,
-	poolAcquireTimeoutMs: 3e4,
-	drainGraceMs: 5e3
-});
-/**
-* F1 — the only environment variables a PTC worker may inherit.
-*
-* These are what a shell needs to resolve binaries on each platform; everything
-* else the host has (tokens, API keys, proxies, home paths) stays out of the worker.
-*/
-const WORKER_ENV_ALLOW_LIST = Object.freeze([
-	"PATH",
-	"PATHEXT",
-	"SYSTEMROOT",
-	"WINDIR",
-	"TEMP",
-	"TMP"
-]);
-/**
-* Build the per-run environment snapshot: the allow-list entries that actually exist.
-*
-* Unset or empty entries are dropped rather than passed through as empty strings, so
-* `Object.keys(workerEnv)` is exactly what the worker sees in `process.env`.
-*/
-function createWorkerEnv(source = process.env) {
-	const env = {};
-	for (const name of WORKER_ENV_ALLOW_LIST) {
-		const value = source[name];
-		if (typeof value === "string" && value.length > 0) env[name] = value;
-	}
-	return env;
-}
-/**
-* Merge per-run overrides onto `DEFAULT_CONFIG`.
-*
-* Overrides are validated rather than coerced: a negative or non-numeric limit is a
-* caller bug, and silently substituting a default would hide it.
-*/
-function resolveConfig(overrides = {}) {
-	const resolved = { ...DEFAULT_CONFIG };
-	for (const key of Object.keys(DEFAULT_CONFIG)) {
-		const override = overrides[key];
-		if (override === void 0) continue;
-		if (typeof override !== "number" || !Number.isFinite(override) || override <= 0) throw new TypeError(`invalid PTC config override for ${key}: ${String(override)}`);
-		resolved[key] = override;
-	}
-	return resolved;
-}
-/**
-* Resolve the effective deadline for one run.
-*
-* DSH semantics (R1 §3): `0` does not disable the deadline, it falls back to the
-* default; anything larger is clamped to `maxTimeoutMs`.
-*/
-function effectiveTimeoutMs(requested, config = DEFAULT_CONFIG) {
-	if (requested === void 0 || !Number.isFinite(requested) || requested <= 0) return config.timeoutMs;
-	return Math.min(requested, config.maxTimeoutMs);
-}
-//#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 {
-		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
-		}
-	};
-}
-/**
-* 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 = [];
-	/**
-	* 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).
-	*/
-	#lastSettledAt = /* @__PURE__ */ new WeakMap();
-	#totalAcquires = 0;
-	#poolExhaustions = 0;
-	/**
-	* `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).
-	*/
-	#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;
-		}
-		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,
-				timer,
-				startedAt
-			});
-		});
-	}
-	/**
-	* 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.
-	*/
-	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();
-	}
-	/**
-	* 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).
-	*/
-	lastSettledAt(worker) {
-		return this.#lastSettledAt.get(worker);
-	}
-	/**
-	* 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.
-	*
-	* 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.
-	*/
-	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
-		};
-	}
-	/**
-	* 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).
-	*/
-	#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;
-			}
-			this.#inFlight.delete(worker);
-		});
-		return worker;
-	}
-	/**
-	* 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.
-	*
-	* 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.
-	*/
-	#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
-/**
-* 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 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) — 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
-*   `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 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.
-*/
-function messageOf(error) {
-	return error instanceof Error ? error.message : String(error);
-}
-/** 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 {
-		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;
-	}
-}
-/**
-* Run one PTC program in a fresh worker and resolve with its outcome.
-*
-* Never rejects for program/ limit / cancellation failures — those are reported as
-* `outcome.error` so callers have one place to render from. It only throws on caller bugs
-* (invalid config overrides).
-*/
-async function runPtcProgram(options) {
-	const config = resolveConfig(options.config);
-	const env = createWorkerEnv();
-	const runId = options.runId ?? randomUUID();
-	const timeoutMs = effectiveTimeoutMs(options.timeoutMs, config);
-	const logs = [];
-	const narrations = [];
-	const phases = [];
-	if (options.signal?.aborted) return {
-		logs,
-		narrations,
-		phases,
-		error: {
-			kind: PTC_ERROR_KIND.abort,
-			message: "run cancelled before start"
-		}
-	};
-	let worker;
-	try {
-		if (options.pool) worker = await options.pool.acquire();
-		else worker = new Worker(buildWorkerUrl(), workerSpawnOptions({
-			surface: options.surface,
-			env,
-			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;
-		/**
-		* 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 = [];
-		/**
-		* Capture the image blocks from one binding result.
-		*
-		* `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.
-		*
-		* 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 captureImages = (value) => {
-			const captured = [];
-			const content = value?.content;
-			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;
-				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;
-			if (runTimer) clearTimeout(runTimer);
-			if (graceTimer) clearTimeout(graceTimer);
-			options.signal?.removeEventListener("abort", onAbortSignal);
-			bindingAbort.abort();
-			control.close();
-			if (options.pool) options.pool.release(worker);
-			else worker.terminate();
-			resolve(outcome);
-		};
-		const fail = (kind, message, stack) => {
-			finish({
-				logs,
-				narrations,
-				phases,
-				error: stack === void 0 ? {
-					kind,
-					message
-				} : {
-					kind,
-					message,
-					stack
-				}
-			});
-		};
-		const sendControl = (frame) => {
-			if (settled) return;
-			if (!isPtcHostFrame(frame)) {
-				fail(PTC_ERROR_KIND.protocol, "internal error: malformed host frame");
-				return;
-			}
-			control.postMessage(frame);
-		};
-		const sendInit = () => {
-			const frame = {
-				kind: HOST_FRAME_KIND.init,
-				runId,
-				surface: options.surface,
-				code: options.code,
-				bindings: [...options.bindings.keys()],
-				bindingCandidates: [...BUILTIN_BINDING_NAMES],
-				maxItemsPerCall: config.maxItemsPerCall,
-				maxPendingCalls: config.maxPendingCalls,
-				...options.args === void 0 ? {} : { args: options.args }
-			};
-			if (!isPtcHostFrame(frame)) {
-				fail(PTC_ERROR_KIND.protocol, "internal error: malformed init frame");
-				return;
-			}
-			const bytes = serializedBytes(frame);
-			if (bytes > config.maxMessageBytes) {
-				fail(PTC_ERROR_KIND.protocol, `init frame of ${bytes} bytes exceeds maxMessageBytes (${config.maxMessageBytes})`);
-				return;
-			}
-			sendControl(frame);
-		};
-		const accountOutput = (bytes, source) => {
-			outputBytes += bytes;
-			if (outputBytes <= config.maxOutputBytes) return true;
-			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 acquireBuiltinSlot = async () => {
-			if (activeBuiltinCalls < config.maxParallelSubCalls) {
-				activeBuiltinCalls += 1;
-				return;
-			}
-			await new Promise((slot) => {
-				builtinWaiters.push(slot);
-			});
-		};
-		const releaseBuiltinSlot = () => {
-			const next = builtinWaiters.shift();
-			if (next) {
-				next();
-				return;
-			}
-			activeBuiltinCalls -= 1;
-		};
-		const handleCall = (frame) => {
-			pendingCalls += 1;
-			if (pendingCalls > config.maxPendingCalls) {
-				fail(PTC_ERROR_KIND.protocol, `more than maxPendingCalls (${config.maxPendingCalls}) binding calls in flight`);
-				return;
-			}
-			dispatchCall(frame).finally(() => {
-				pendingCalls -= 1;
-			});
-		};
-		const dispatchCall = async (frame) => {
-			const binding = options.bindings.get(frame.tool);
-			if (!binding) {
-				postCallResult({
-					kind: HOST_FRAME_KIND.callResult,
-					callId: frame.callId,
-					tool: frame.tool,
-					ok: false,
-					message: `no binding named "${frame.tool}" in this run; available bindings: ` + ([...options.bindings.keys()].join(", ") || "(none)")
-				});
-				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, {
-					signal: bindingAbort.signal,
-					callId: frame.callId,
-					depth: runDepth,
-					maxDispatchDepth: config.maxDispatchDepth
-				});
-				const captured = captureImages(value);
-				const callFrame = {
-					kind: HOST_FRAME_KIND.callResult,
-					callId: frame.callId,
-					tool: frame.tool,
-					ok: true,
-					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,
-					callId: frame.callId,
-					tool: frame.tool,
-					ok: false,
-					message: messageOf(error)
-				});
-			} finally {
-				if (isDispatch) activeDispatches -= 1;
-				else releaseBuiltinSlot();
-			}
-		};
-		/** `true` when the worker actually received the result (see the hoist at the call site). */
-		const postCallResult = (frame) => {
-			if (settled) return false;
-			try {
-				control.postMessage(frame);
-				return true;
-			} catch (error) {
-				try {
-					control.postMessage({
-						kind: HOST_FRAME_KIND.callResult,
-						callId: frame.callId,
-						tool: frame.tool,
-						ok: false,
-						message: `binding result could not be transferred: ${messageOf(error)}`
-					});
-				} catch {
-					fail(PTC_ERROR_KIND.protocol, "binding result is not transferable");
-				}
-				return false;
-			}
-		};
-		const settleTerminal = (outcome) => {
-			if (!cancelling) return outcome;
-			return {
-				logs,
-				narrations,
-				phases,
-				error: {
-					kind: cancelErrorKind(cancelling),
-					message: cancelMessage(cancelling)
-				}
-			};
-		};
-		const handleFrame = (frame) => {
-			if (settled) return;
-			if (!isPtcWorkerFrame(frame)) {
-				fail(PTC_ERROR_KIND.protocol, "malformed worker frame");
-				return;
-			}
-			const bytes = frame.kind === WORKER_FRAME_KIND.ready ? 0 : serializedBytes(frame);
-			if (!Number.isFinite(bytes)) {
-				fail(PTC_ERROR_KIND.protocol, "worker frame could not be serialized for accounting");
-				return;
-			}
-			if (bytes > config.maxMessageBytes) {
-				fail(PTC_ERROR_KIND.protocol, `control frame of ${bytes} bytes exceeds maxMessageBytes (${config.maxMessageBytes})`);
-				return;
-			}
-			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:
-					handleCall(frame);
-					return;
-				case WORKER_FRAME_KIND.log:
-					if (accountOutput(bytes, "console output")) logs.push(frame.text);
-					return;
-				case WORKER_FRAME_KIND.narration:
-					if (accountOutput(bytes, "workflow narration")) narrations.push(frame.message);
-					return;
-				case WORKER_FRAME_KIND.phase:
-					if (accountOutput(bytes, "workflow phase")) phases.push(frame.title);
-					return;
-				case WORKER_FRAME_KIND.result: {
-					if (!accountOutput(bytes, "completion value")) return;
-					const base = {
-						logs,
-						narrations,
-						phases,
-						...images.length > 0 ? { images } : {}
-					};
-					finish(settleTerminal(frame.value === void 0 ? base : {
-						...base,
-						value: frame.value
-					}));
-					return;
-				}
-				case WORKER_FRAME_KIND.error:
-					finish(settleTerminal({
-						logs,
-						narrations,
-						phases,
-						error: frame.error
-					}));
-					return;
-				default: fail(PTC_ERROR_KIND.protocol, "unknown worker frame");
-			}
-		};
-		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) return;
-			if (cancelling) {
-				fail(cancelErrorKind(cancelling), cancelMessage(cancelling));
-				return;
-			}
-			cancelling = reason;
-			bindingAbort.abort();
-			sendControl({
-				kind: HOST_FRAME_KIND.cancel,
-				reason
-			});
-			armGraceTimer(reason);
-		}
-		worker.on("error", (error) => {
-			fail(PTC_ERROR_KIND.workerExit, `worker failed: ${messageOf(error)}`);
-		});
-		worker.on("exit", (code) => {
-			fail(PTC_ERROR_KIND.workerExit, `worker exited with code ${code} before the run completed`);
-		});
-		control.on("message", handleFrame);
-		control.on("messageerror", () => {
-			fail(PTC_ERROR_KIND.protocol, "worker sent a frame that could not be deserialized");
-		});
-		options.signal?.addEventListener("abort", onAbortSignal, { once: true });
-		runTimer = setTimeout(() => {
-			beginCancel("timeout");
-		}, timeoutMs);
-		const connectFrame = {
-			kind: HOST_FRAME_KIND.connect,
-			port: workerPort
-		};
-		if (!isPtcHostFrame(connectFrame)) fail(PTC_ERROR_KIND.protocol, "internal error: malformed connect frame");
-		else worker.postMessage(connectFrame, [workerPort]);
-	});
-}
-//#endregion
-//#region src/tools/text.ts
-/** Hard cap for one rendered line; longer lines are truncated with `…`. */
-const MAX_LINE_CHARS = 200;
-/** A value stays on one line while its inline form fits this; otherwise it renders as a block. */
-const INLINE_MAX_CHARS = 100;
-/** Indent applied per nesting level in block form. */
-const INDENT = "  ";
-/**
-* ANSI escapes, in the two shapes that matter: OSC (\`ESC ] …\` to BEL, \`ESC \\\\` or C1 ST) and
-* CSI plus friends (introducer, optional intermediates, optional params, final byte).
-*
-* Built through the \`RegExp\` constructor from an escaped source so no control character appears
-* literally — the repo lints via oxlint, whose \`no-control-regex\` rule rejects that.
-*/
-const ANSI_PATTERN = new RegExp(["(?:\\u001B\\][\\s\\S]*?(?:\\u0007|\\u001B\\u005C|\\u009C))", "[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]"].join("|"), "g");
-/** Drop ANSI escape sequences (colours, cursor moves, OSC hyperlinks). */
-function stripAnsi(value) {
-	if (!value.includes(String.fromCharCode(27)) && !value.includes(String.fromCharCode(155))) return value;
-	return value.replace(ANSI_PATTERN, "");
-}
-/**
-* Make arbitrary program output safe to hand the model.
-*
-* Same three steps as pi's built-ins: strip ANSI, remove `\r` (a progress bar's carriage
-* return is not a line break), then drop control characters other than `\n`/`\t` and the
-* Unicode format characters that break width math. Lone surrogates fall out of code-point
-* iteration for free.
-*/
-function sanitizeText(value) {
-	const stripped = stripAnsi(value).replace(/\r/g, "");
-	if (stripped.length === 0) return stripped;
-	let out = "";
-	for (const char of stripped) {
-		const code = char.codePointAt(0);
-		if (code === void 0) continue;
-		if (code === 10 || code === 9) {
-			out += char;
-			continue;
-		}
-		if (code <= 31) continue;
-		if (code >= 65529 && code <= 65531) continue;
-		out += char;
-	}
-	return out;
-}
-/** Object keys that read as identifiers in the summary style are left unquoted. */
-const BARE_KEY = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
-function keyText(key) {
-	return BARE_KEY.test(key) ? key : JSON.stringify(key);
-}
-/**
-* The inline form of a value, or `undefined` when it cannot be inlined.
-*
-* A string with a real newline is never inlined: keeping its line structure is the whole point
-* (see ADR-0012), and quoting it would turn one readable block back into `\n` escapes.
-*/
-function inlineForm(value) {
-	if (value === null) return "null";
-	if (typeof value === "number" || typeof value === "boolean") return String(value);
-	if (typeof value === "string") {
-		const sanitized = sanitizeText(value);
-		return sanitized.includes("\n") ? void 0 : JSON.stringify(sanitized);
-	}
-	if (Array.isArray(value)) {
-		const items = [];
-		for (const item of value) {
-			const rendered = inlineForm(item);
-			if (rendered === void 0) return void 0;
-			items.push(rendered);
-		}
-		return `[${items.join(", ")}]`;
-	}
-	const keys = Object.keys(value);
-	if (keys.length === 0) return "{}";
-	const parts = [];
-	for (const key of keys) {
-		const rendered = inlineForm(value[key] ?? null);
-		if (rendered === void 0) return void 0;
-		parts.push(`${keyText(key)}: ${rendered}`);
-	}
-	return `{${parts.join(", ")}}`;
-}
-/** Inline rendering, but only while it stays short enough to read on one line. */
-function tryInline(value) {
-	const rendered = inlineForm(value);
-	if (rendered === void 0) return void 0;
-	return rendered.length <= INLINE_MAX_CHARS ? rendered : void 0;
-}
-/** A non-container value on its own line (block form only meets these defensively). */
-function scalarText(value) {
-	if (value === null) return "null";
-	return typeof value === "string" ? sanitizeText(value) : String(value);
-}
-/** One key per line, braces kept, string values raw (real newlines preserved, indented). */
-function blockLines(value, indent) {
-	if (value === null || typeof value !== "object") return [`${indent}${scalarText(value)}`];
-	if (Array.isArray(value)) {
-		if (value.length === 0) return [`${indent}[]`];
-		const lines = [`${indent}[`];
-		for (const item of value) {
-			const inline = tryInline(item);
-			if (inline !== void 0) {
-				lines.push(`${indent}${INDENT}${inline}`);
-				continue;
-			}
-			lines.push(...valueLines(item, indent + INDENT));
-		}
-		lines.push(`${indent}]`);
-		return lines;
-	}
-	const keys = Object.keys(value);
-	if (keys.length === 0) return [`${indent}{}`];
-	const lines = [`${indent}{`];
-	const inner = indent + INDENT;
-	for (const key of keys) {
-		const child = value[key] ?? null;
-		const inline = tryInline(child);
-		if (inline !== void 0) {
-			lines.push(`${inner}${keyText(key)}: ${inline}`);
-			continue;
-		}
-		if (typeof child === "string") {
-			lines.push(`${inner}${keyText(key)}:`);
-			for (const line of sanitizeText(child).split("\n")) lines.push(line.length === 0 ? "" : `${inner}${INDENT}${line}`);
-			continue;
-		}
-		const nested = blockLines(child, inner);
-		lines.push(`${inner}${keyText(key)}: ${(nested[0] ?? "").trimStart()}`.trimEnd(), ...nested.slice(1));
-	}
-	lines.push(`${indent}}`);
-	return lines;
-}
-function valueLines(value, indent) {
-	if (typeof value === "string") return sanitizeText(value).split("\n");
-	if (value === null || typeof value !== "object") return [String(value)];
-	return blockLines(value, indent);
-}
-/** Truncate every line that exceeds {@link MAX_LINE_CHARS}. */
-function capLines(text) {
-	return text.split("\n").map((line) => line.length > 200 ? `${line.slice(0, 199)}…` : line).join("\n");
-}
-/**
-* Render a completion value for the model: strings verbatim, everything else as a compact
-* `{key: value}` summary or an indented block — never `JSON.stringify` on the whole value, whose
-* escaping destroys exactly the content a reader needs (newlines, quotes, non-ASCII spacing).
-*/
-function renderModelValue(value) {
-	if (typeof value === "string") return capLines(sanitizeText(value));
-	if (value === null || typeof value !== "object") return String(value);
-	const inline = tryInline(value);
-	return capLines((inline !== void 0 ? [inline] : valueLines(value, "")).join("\n"));
-}
-//#endregion
-//#region src/tools/common.ts
-/**
-* Shared plumbing for the two model-facing PTC tools (`ptc_run_code`, `ptc_workflow`).
-*
-* Both tools are thin. They resolve the run's working directory, hand the program to
-* `runPtcProgram()` (T3), and turn the dispatcher's outcome into one of pi's two tool-result
-* shapes:
-*
-* - **success** — `content` carries one text block (logs, workflow narration, phases, then the
-*   completion value) and `details` carries the same facts structurally for rendering and logs;
-* - **failure** — the tool *throws* (pi's convention: `AgentTool.execute` — "Throw on failure
-*   instead of encoding errors in `content`"), with R1 §3's message shape
-*   `code run failed (<kind>): <message>` plus a `Captured output:` block.
-*
-* The dispatcher never rejects for program failures — it reports them as `outcome.error` — so
-* "did the run fail" is one check in one place, shared by both tools.
-*
-* The text block is the model's copy, so it is cleaned and laid out for reading (`./text.ts`:
-* ANSI stripped, control characters dropped, strings with real newlines kept multi-line) while
-* `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
-* with `--tools read` or `--no-builtin-tools` must not be escapable through `tools.<name>`
-* calls. Names outside the built-in factory set are ignored: only tools this package can
-* build adapters for can be bound.
-*/
-function resolveBindingNames(activeToolNames) {
-	if (activeToolNames === void 0) return BUILTIN_BINDING_NAMES;
-	const active = new Set(activeToolNames);
-	return BUILTIN_BINDING_NAMES.filter((name) => active.has(name));
-}
-/**
-* One-line entry for the system prompt's "Available tools" section.
-*
-* Custom tools are omitted from that section unless they set this, which matters most in PTC mode:
-* there the two PTC surfaces are the *only* callable tools, so a prompt that lists no usable tool
-* would contradict the tool declarations. `promptGuidelines` cannot substitute for it — those
-* bullets land in the flat `Guidelines` section, which does not tell the model what it can call.
-*/
-const PTC_RUN_CODE_SNIPPET = "Run a TypeScript program that composes pi's tools in one shot (tools.<name>(args)); only its return value and console.log come back";
-const PTC_WORKFLOW_SNIPPET = "Run a structured TypeScript workflow with named phases, narration (log/phase) and structured concurrency (parallel/pipeline)";
-/**
-* Guidelines are appended flat to the `Guidelines` section with no tool-name prefix, so each bullet
-* must name its tool explicitly (pi's docs call this out; "Use this tool when…" is ambiguous).
-* These are the normal-mode hints — in PTC mode the injected briefing supersedes them.
-*/
-const PTC_TOOL_GUIDELINES = [
-	"Image-bearing tool results inside a program (a `tools.read` on a PNG, say) are attached to you after the run — never return image data as the completion value.",
-	"Use ptc_run_code when a task needs several tool calls whose intermediate output you do not need to see — gather it inside the program and return only the final value.",
-	"Use ptc_workflow instead of ptc_run_code when the work has named phases and the user benefits from seeing progress narration."
-];
-/** Tool name per worker surface — the names the model calls and reads in failure messages. */
-const SURFACE_TOOL_NAME = {
-	run_code: "ptc_run_code",
-	workflow: "ptc_workflow"
-};
-/**
-* Resolve the run's working directory from pi's tool execution context.
-*
-* Investigated against `@earendil-works/pi-coding-agent@0.86.1`: `execute`'s fifth parameter is
-* `ExtensionContext`, and the type *does* expose `cwd: string` — documented there as "Current
-* working directory" (`dist/core/extensions/types.d.ts`), the same value pi's own built-in tools
-* resolve relative paths against (`ToolRenderContext.cwd`, and the extension guide's
-* `resolve(ctx.cwd, params.path)` pattern). So the session cwd comes from pi, and this package
-* never has to guess from `process.cwd()`.
-*
-* The `process.cwd()` fallback stays for hand-built contexts (tests, or a future caller passing a
-* partial object); pi always supplies the field.
-*/
-function resolveToolCwd(ctx) {
-	const cwd = ctx?.cwd;
-	return typeof cwd === "string" && cwd.length > 0 ? cwd : process.cwd();
-}
-/**
-* The captured-output lines R1 §3 appends when a run fails.
-*
-* Phases and narrations are prefixed because they are workflow bookkeeping rather than console
-* output; `ptc_run_code` has neither, so its block is exactly the `logs` join R1 describes.
-*/
-function capturedOutputLines(outcome) {
-	return [
-		...outcome.phases.map((title) => `[phase] ${sanitizeText(title)}`),
-		...outcome.narrations.map((message) => `[log] ${sanitizeText(message)}`),
-		...outcome.logs.map((line) => sanitizeText(line))
-	];
-}
-/**
-* Build the error a failed run is surfaced with (R1 §3's `CodeRunFailedError` message).
-*
-* The model must be able to fix its program from this message alone: the error kind and message
-* explain what broke, and the captured output shows how far the program got before it did. There
-* is no `sandbox` text and no escalation guidance — ADR-0007 ships no OS sandbox, so the only
-* failure classes are the protocol ones.
-*/
-function codeRunFailedError(outcome) {
-	const error = outcome.error;
-	if (error === void 0) return /* @__PURE__ */ new Error("internal error: a successful PTC run was rendered as a failure");
-	const captured = capturedOutputLines(outcome);
-	const block = captured.length === 0 ? "" : `\nCaptured output:\n${captured.join("\n")}`;
-	const failure = new Error(sanitizeText(`code run failed (${error.kind}): ${error.message}${block}`));
-	failure.name = "CodeRunFailedError";
-	return failure;
-}
-/**
-* Write the untruncated text block to a temp file and return its path.
-*
-* Mirrors what pi's own `bash` does with a long output (its `fullOutputPath`): the run is the only
-* place the text ever existed, so a file under the OS temp dir is the difference between "the rest is
-* gone" and "the rest is one `tools.read` away".
-*/
-function writeFullOutput(text) {
-	const filePath = join(tmpdir(), `pi-ptc-output-${randomUUID()}.txt`);
-	writeFileSync(filePath, text, "utf8");
-	return filePath;
-}
-/**
-* The `[Showing … Full output: path]` footer pi's built-ins use, worded for the same numbers.
-*
-* `truncatedBy` decides the wording: a line cut reports the line range, a byte cut also names the
-* ceiling, and a single oversized last line reports its own size — exactly what `bash` prints.
-*/
-function truncationFooter(truncation, fullOutputPath) {
-	const startLine = truncation.totalLines - truncation.outputLines + 1;
-	const endLine = truncation.totalLines;
-	if (truncation.lastLinePartial) return `[Showing last ${formatSize(truncation.outputBytes)} of line ${endLine}. Full output: ${fullOutputPath}]`;
-	if (truncation.truncatedBy === "lines") return `[Showing lines ${startLine}-${endLine} of ${truncation.totalLines}. Full output: ${fullOutputPath}]`;
-	return `[Showing lines ${startLine}-${endLine} of ${truncation.totalLines} (${formatSize(DEFAULT_MAX_BYTES)} limit). Full output: ${fullOutputPath}]`;
-}
-/**
-* Render one successful outcome as pi's tool result.
-*
-* `content` is ordered the way a reader reconstructs the run: the phase roll-up, then workflow
-* narration, then console output, then the completion value, then warnings. Empty runs get R1's
-* placeholder (`(run_code completed with no output)`) so the model always sees a non-empty text
-* block — a tool result with nothing in it looks like a harness failure.
-*
-* `details` is deliberately the *uncleaned* copy: logs keep their ANSI so the TUI can still
-* colour them, and `result` stays structured for `render.ts`.
-*/
-function renderToolResult(input) {
-	const { outcome, surface } = input;
-	const warnings = [...input.warnings ?? []];
-	const images = outcome.images ?? [];
-	const parts = [];
-	if (outcome.phases.length > 0) parts.push(`Phases: ${outcome.phases.map((title) => sanitizeText(title)).join(" → ")}`);
-	if (outcome.narrations.length > 0) parts.push(outcome.narrations.map((message) => sanitizeText(message)).join("\n"));
-	if (outcome.logs.length > 0) parts.push(outcome.logs.map((line) => sanitizeText(line)).join("\n"));
-	if (outcome.value !== void 0) parts.push(renderModelValue(outcome.value));
-	for (const warning of warnings) parts.push(`Warning: ${sanitizeText(warning)}`);
-	const built = parts.length > 0 ? parts.join("\n") : `(${SURFACE_TOOL_NAME[surface]} completed with no output)`;
-	const truncation = truncateTail(built, {
-		maxLines: DEFAULT_MAX_LINES,
-		maxBytes: DEFAULT_MAX_BYTES
-	});
-	let fullOutputPath;
-	let text = truncation.content;
-	if (truncation.truncated) {
-		fullOutputPath = writeFullOutput(built);
-		text += `\n\n${truncationFooter(truncation, fullOutputPath)}`;
-	}
-	return {
-		content: [{
-			type: "text",
-			text
-		}, ...images.map((image) => ({
-			type: "image",
-			data: image.data,
-			mimeType: image.mimeType
-		}))],
-		details: {
-			surface,
-			logs: [...outcome.logs],
-			narrations: [...outcome.narrations],
-			phases: [...outcome.phases],
-			warnings,
-			...outcome.value === void 0 ? {} : { result: outcome.value },
-			durationMs: input.durationMs,
-			imageCount: images.length,
-			...fullOutputPath === void 0 ? {} : { fullOutputPath }
-		}
-	};
-}
-//#endregion
-//#region src/tools/render.ts
-/** Call-row label per surface; `ptc_workflow` gets its own so the two rows stay tellable apart. */
-const TOOL_TITLE = {
-	run_code: "PTC",
-	workflow: "PTC workflow"
-};
-/**
-* Tree-connector layout. The call row owns column 0–2 (`└─ `); everything below it sits at column 3.
-* Children are siblings of the call's content (the summary line `→ {hint}`), so a child row needs a
-* connector to distinguish itself from the summary — and a continuation prefix to distinguish its
-* own wrapped lines from the child's first line.
-*
-*  - Root call row:         `└─ PTC  …`
-*  - Root continuation:     `   → {hint}` or `   failed: …`    (summary; same column as children)
-*  - First / middle child:  `   ├─ code    …`
-*  - First / middle cont.:  `   │          …`
-*  - Last child:            `   └─ image   …`
-*  - Last cont.:            `      …`         (no connector — same shape as a wrapped value line)
-*
-* `TREE_INDENT` (3 spaces) is the column children and root continuations share.
-*/
-const TREE_ROOT = "└─ ";
-const TREE_ROOT_CONT = "   ";
-const TREE_INDENT = "   ";
-const TREE_FIRST = "├─ ";
-const TREE_LAST = "└─ ";
-const TREE_CONT_FIRST = "│  ";
-const TREE_CONT_LAST = "   ";
-/**
-* Gutter width for child labels. `code` / `out` / `value` / `warn` / `image` are 3–5 chars; `phases`
-* is 6 — pad to 8 so the longest label gets two trailing spaces before its content.
-*/
-const LABEL_WIDTH = 8;
-const MAX_CODE_LINES_EXPANDED = 3;
-const MAX_CODE_LINE_CHARS = 120;
-const MAX_LOG_LINES_EXPANDED = 12;
-const MAX_PHASES_EXPANDED = 8;
-const MAX_WARNINGS_EXPANDED = 4;
-const MAX_RESULT_HINT_CHARS = 60;
-const MAX_ERROR_CHARS = 120;
-/**
-* A `Component` that right-aligns one meta segment per line.
-*
-* Stateless: it holds already-styled strings and pads them at render time, so pi can re-render at a
-* new width (terminal resize) without any invalidation bookkeeping.
-*/
-var PtcRow = class {
-	lines;
-	constructor(lines) {
-		this.lines = lines;
-	}
-	/** Part of the `Component` contract; nothing is cached, so nothing has to be dropped. */
-	invalidate() {}
-	render(width) {
-		const safeWidth = Math.max(1, Math.floor(width));
-		return this.lines.map((line) => alignRow(line, safeWidth));
-	}
-};
-/**
-* Lay out one row inside `width` columns.
-*
-* With no meta segment the line is simply truncated. With one, the meta is what must survive — a
-* count that has been cut in half (`• 19 outpu…`) tells the reader nothing — so the left side gives
-* up room first, and only a meta wider than the whole viewport is truncated itself.
-*/
-function alignRow(line, width) {
-	const { left, right } = line;
-	if (right === void 0) return truncateToWidth(left, width, "…");
-	const rightWidth = visibleWidth(right);
-	if (rightWidth >= width) return truncateToWidth(right, width, "…");
-	const leftText = truncateToWidth(left, Math.max(0, width - rightWidth - 1), "…");
-	const pad = Math.max(1, width - rightWidth - visibleWidth(leftText));
-	return leftText + " ".repeat(pad) + right;
-}
-/** Truncate `s` to `n` chars, appending `…` when the input was longer. */
-function truncateChars(s, n) {
-	return s.length > n ? `${s.slice(0, n - 1)}…` : s;
-}
-/** First non-blank line of a block of text, sanitized and capped. */
-function firstLine(value) {
-	return truncateChars((sanitizeText(value).split("\n").find((candidate) => candidate.trim().length > 0) ?? "").trim(), MAX_ERROR_CHARS);
-}
-/** `n` rendered as `1.2s` / `850ms` (so users can tell short from long at a glance). */
-function formatDuration(ms) {
-	if (ms < 1e3) return `${ms}ms`;
-	return `${(ms / 1e3).toFixed(2).replace(/\.?0+$/, "")}s`;
-}
-/** `3 phases` / `1 phase` — singular and plural are both reachable from a real run. */
-function plural(count, noun) {
-	return `${count} ${noun}${count === 1 ? "" : "s"}`;
-}
-/**
-* Pull the first line of code that is actually doing something — not a leading comment, blank
-* line, or import. Used as the call row's fallback when the model sent no description.
-*/
-function firstMeaningfulCodeLine(code) {
-	for (const raw of code.split("\n")) {
-		const line = raw.trim();
-		if (line.length === 0) continue;
-		if (line.startsWith("//")) continue;
-		if (line.startsWith("/*")) continue;
-		if (line.startsWith("*")) continue;
-		return truncateChars(line.replace(/\s*\/\/.*$/, ""), MAX_CODE_LINE_CHARS);
-	}
-}
-/**
-* The completion value as a single line a human can read: the value itself while it stays short
-* and single-line, otherwise its shape (`{version, node}`, `Array(3)`).
-*
-* A multi-line string contributes its first non-blank line plus a `+N lines` tail, which is the
-* whole difference between one readable row and the escaped wall this replaces.
-*/
-function resultHint(value) {
-	if (value === void 0) return void 0;
-	if (typeof value === "string") {
-		const lines = sanitizeText(value).split("\n");
-		const first = lines.find((line) => line.trim().length > 0)?.trim() ?? "";
-		const extra = lines.length > 1 ? ` (+${lines.length - 1} lines)` : "";
-		if (first.length === 0 && extra.length === 0) return `""`;
-		return truncateChars(first, MAX_RESULT_HINT_CHARS) + extra;
-	}
-	if (value === null || typeof value !== "object") return String(value);
-	const inline = renderModelValue(value);
-	if (!inline.includes("\n") && inline.length <= MAX_RESULT_HINT_CHARS) return inline;
-	if (Array.isArray(value)) return `Array(${value.length})`;
-	const keys = Object.keys(value);
-	if (keys.length === 0) return "{}";
-	return `{${keys.slice(0, 4).join(", ")}${keys.length > 4 ? `, +${keys.length - 4}` : ""}}`;
-}
-/**
-* Right-aligned meta: the run's countable facts, in the order a reader asks for them — how much
-* output, how long it took, how many phases (workflow), and anything that went wrong.
-*/
-function metaText(details, theme) {
-	if (details === void 0) return void 0;
-	const segments = [];
-	const outputLines = details.logs.length + details.narrations.length;
-	if (outputLines > 0) segments.push(theme.fg("dim", plural(outputLines, "output line")));
-	if (details.imageCount > 0) segments.push(theme.fg("toolOutput", plural(details.imageCount, "image")));
-	if (details.surface === "workflow" && details.phases.length > 0) segments.push(theme.fg("dim", plural(details.phases.length, "phase")));
-	if (details.warnings.length > 0) segments.push(theme.fg("warning", plural(details.warnings.length, "warning")));
-	if (details.fullOutputPath !== void 0) segments.push(theme.fg("warning", "truncated"));
-	segments.push(theme.fg("dim", formatDuration(details.durationMs)));
-	return `${theme.fg("dim", "•")} ${segments.join(theme.fg("dim", " · "))}`;
-}
-/** Render one child block as `RowLine[]`, with `├─` / `│` / `└─` connectors decided by position. */
-function renderChildBlock(child, isLast, theme) {
-	const firstPrefix = TREE_INDENT + (isLast ? TREE_LAST : TREE_FIRST);
-	const contPrefix = TREE_INDENT + (isLast ? TREE_CONT_LAST : TREE_CONT_FIRST);
-	const gutter = " ".repeat(LABEL_WIDTH);
-	const rows = [];
-	const first = child.lines[0] ?? "";
-	rows.push({ left: `${firstPrefix}${child.label.padEnd(LABEL_WIDTH)}${theme.fg("dim", first)}` });
-	for (let i = 1; i < child.lines.length; i++) rows.push({ left: `${contPrefix}${gutter}${theme.fg("dim", child.lines[i] ?? "")}` });
-	if (child.more !== void 0 && child.more > 0) rows.push({ left: `${contPrefix}${gutter}…+${child.more} more lines` });
-	return rows;
-}
-/** A JSON value is "expandable" when it is a non-empty object or array. */
-function isExpandableContainer(value) {
-	if (value === null || typeof value !== "object") return false;
-	if (Array.isArray(value)) return value.length > 0;
-	return Object.keys(value).length > 0;
-}
-/** Object keys that read as identifiers are left unquoted; the rest get JSON quoting. */
-const TREE_BARE_KEY = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
-function treeFormatKey(key) {
-	return TREE_BARE_KEY.test(key) ? key : JSON.stringify(key);
-}
-/** A scalar JSON value as a single readable token; strings are JSON-quoted, newlines folded. */
-function treeScalarPreview(value, maxChars) {
-	if (value === null) return "null";
-	if (typeof value === "boolean" || typeof value === "number") return String(value);
-	if (typeof value === "string") {
-		const sanitized = sanitizeText(value);
-		if (sanitized.length === 0) return "\"\"";
-		if (sanitized.includes("\n")) {
-			const head = truncateChars(sanitized.replace(/\n/g, " "), Math.max(2, maxChars - 5));
-			return JSON.stringify(head) + "…";
-		}
-		if (sanitized.length + 2 <= maxChars) return JSON.stringify(sanitized);
-		return JSON.stringify(truncateChars(sanitized, Math.max(2, maxChars - 5))) + "…";
-	}
-	return "?";
-}
-function treeIsScalarJson(value) {
-	return value === null || typeof value !== "object";
-}
-/** Try to render a container as a one-liner bracket form ({k: v} / [v, v]); undefined when it does not fit or children are deep. */
-function treeInlinePreview(value, maxChars) {
-	if (maxChars < 8) return void 0;
-	if (Array.isArray(value)) {
-		if (value.length === 0) return "[]";
-		if (value.length > 5 || !value.every(treeIsScalarJson)) return void 0;
-		const inline = "[" + value.map((item) => treeScalarPreview(item, Math.max(2, Math.floor(maxChars / 4)))).join(", ") + "]";
-		return inline.length <= maxChars ? inline : void 0;
-	}
-	if (value === null || typeof value !== "object") return void 0;
-	const keys = Object.keys(value);
-	if (keys.length === 0) return "{}";
-	if (keys.length > 5 || !Object.values(value).every(treeIsScalarJson)) return void 0;
-	const inline = "{" + keys.map((key) => {
-		const child = value[key] ?? null;
-		return treeFormatKey(key) + ": " + treeScalarPreview(child, Math.max(2, Math.floor(maxChars / 4)));
-	}).join(", ") + "}";
-	return inline.length <= maxChars ? inline : void 0;
-}
-/**
-* Append one pre-prefixed tree row to out, recursing for containers. Each level passes the
-* continuation indent its children should use; the connector itself encodes "more siblings".
-*/
-function treeAppendNode(value, label, parentPrefix, isLast, maxDepth, maxChildren, maxLineChars, depth, out) {
-	const ownPrefix = parentPrefix + (isLast ? "└─ " : "├─ ");
-	const continuation = parentPrefix + (isLast ? "   " : "│  ");
-	if (depth >= maxDepth) {
-		out.push(treeTruncateIndent(ownPrefix + label + "…", maxLineChars));
-		return;
-	}
-	if (Array.isArray(value) && value.length === 0) {
-		out.push(treeTruncateIndent(ownPrefix + label + "[]", maxLineChars));
-		return;
-	}
-	if (!Array.isArray(value) && value !== null && typeof value === "object" && Object.keys(value).length === 0) {
-		out.push(treeTruncateIndent(ownPrefix + label + "{}", maxLineChars));
-		return;
-	}
-	if (value === null || typeof value !== "object") {
-		const budget = Math.max(0, maxLineChars - visibleWidth(ownPrefix) - label.length);
-		out.push(treeTruncateIndent(ownPrefix + label + treeScalarPreview(value, budget), maxLineChars));
-		return;
-	}
-	const inline = treeInlinePreview(value, Math.max(0, maxLineChars - visibleWidth(ownPrefix) - label.length));
-	if (inline !== void 0) {
-		out.push(treeTruncateIndent(ownPrefix + label + inline, maxLineChars));
-		return;
-	}
-	const listLike = Array.isArray(value);
-	const childCount = listLike ? value.length : Object.keys(value).length;
-	let header;
-	if (listLike) header = "Array(" + childCount + ")";
-	else header = childCount > maxChildren ? "{" + maxChildren + " of " + childCount + "}" : "{" + childCount + " keys}";
-	out.push(treeTruncateIndent(ownPrefix + label + header, maxLineChars));
-	const limit = Math.min(maxChildren, childCount);
-	if (listLike) for (let index = 0; index < limit; index += 1) {
-		const isChildLast = index === limit - 1 && childCount <= limit;
-		treeAppendNode(value[index] ?? null, "[" + index + "] ", continuation, isChildLast, maxDepth, maxChildren, maxLineChars, depth + 1, out);
-	}
-	else {
-		const keys = Object.keys(value);
-		for (let index = 0; index < limit; index += 1) {
-			const isChildLast = index === limit - 1 && childCount <= limit;
-			const key = keys[index];
-			treeAppendNode(value[key] ?? null, treeFormatKey(key) + ": ", continuation, isChildLast, maxDepth, maxChildren, maxLineChars, depth + 1, out);
-		}
-	}
-	if (childCount > limit) {
-		const tail = listLike ? "items" : "keys";
-		out.push(treeTruncateIndent(continuation + "└─ …+" + (childCount - limit) + " more " + tail, maxLineChars));
-	}
-}
-/** Truncate a rendered row, preserving the leading tree-prefix indent (│/├/└ etc.). */
-function treeTruncateIndent(line, maxLineChars) {
-	if (visibleWidth(line) <= maxLineChars) return line;
-	const match = line.match(/^([\s│├└─]*)/);
-	const indent = match && match[1] ? match[1] : "";
-	const indentWidth = visibleWidth(indent);
-	const budget = Math.max(0, maxLineChars - indentWidth - 1);
-	let body = "";
-	let used = 0;
-	for (const ch of line.slice(indent.length)) {
-		const w = visibleWidth(ch);
-		if (used + w > budget) break;
-		body += ch;
-		used += w;
-	}
-	return indent + body + "…";
-}
-/**
-* Render a JSON value as an array of indented tree rows.
-*
-* Each row is a complete prefixed line ready to live under the call row's "   " indent
-* (TREE_ROOT_CONT): root children start at "├─ " / "└─ ", deeper levels add their own
-* connectors on top of the continuation bar. Caller supplies the row's TREE_ROOT_CONT — a
-* row that starts with "├─ " lands at column 3, exactly where other call-row children sit.
-*
-* Empty / scalar values return a one-row preview; non-empty containers recurse.
-*/
-function renderValueTree(value, options = {}) {
-	const maxDepth = options.maxDepth ?? 4;
-	const maxChildren = options.maxChildren ?? 6;
-	const maxLineChars = options.maxLineChars ?? 120;
-	const moreAfter = options.moreAfter === true;
-	if (!isExpandableContainer(value)) {
-		if (value !== null && typeof value === "object") return [Array.isArray(value) ? "[]" : "{}"];
-		return [treeScalarPreview(value, maxLineChars)];
-	}
-	const out = [];
-	if (Array.isArray(value)) {
-		const total = value.length;
-		const limit = Math.min(maxChildren, total);
-		for (let index = 0; index < limit; index += 1) {
-			const isLast = !moreAfter && index === limit - 1 && total <= limit;
-			treeAppendNode(value[index] ?? null, "[" + index + "] ", "", isLast, maxDepth, maxChildren, maxLineChars, 0, out);
-		}
-		if (total > limit) out.push((moreAfter ? "├─ " : "└─ ") + "…+" + (total - limit) + " more items");
-		return out;
-	}
-	const keys = Object.keys(value);
-	const total = keys.length;
-	const limit = Math.min(maxChildren, total);
-	for (let index = 0; index < limit; index += 1) {
-		const isLast = !moreAfter && index === limit - 1 && total <= limit;
-		const key = keys[index];
-		treeAppendNode(value[key] ?? null, treeFormatKey(key) + ": ", "", isLast, maxDepth, maxChildren, maxLineChars, 0, out);
-	}
-	if (total > limit) out.push((moreAfter ? "├─ " : "└─ ") + "…+" + (total - limit) + " more keys");
-	return out;
-}
-/**
-* One-line tool-call header: the tree root, then the tool label, then the model's own description.
-*
-* The description is the only detail that gets to sit next to the label — the previous renderer
-* appended the first code line as well, which is what made the call row read as a paragraph rather
-* than a heading. The code is one `ctrl+e` away in the expanded view.
-*/
-function renderPtcToolCall(args, theme, surface = "run_code") {
-	const description = (typeof args.description === "string" && args.description.trim().length > 0 ? args.description.trim() : args.meta?.name) ?? "";
-	const fallback = firstMeaningfulCodeLine(args.code ?? args.script ?? "");
-	const detail = description.length > 0 ? description : fallback ?? "(no description)";
-	const left = `${theme.fg("toolTitle", theme.bold(TOOL_TITLE[surface]))} ${theme.fg("accent", detail)}`;
-	return new PtcRow([{ left: `${TREE_ROOT}${left}` }]);
-}
-/** Text body of a failed run — pi surfaces the thrown error in the first text block. */
-function errorText(result) {
-	const text = result.content?.find((block) => block.type === "text" && (block.text ?? "").length > 0);
-	return firstLine(text?.text ?? "") || "failed";
-}
-/**
-* The result area under the call row.
-*
-* One of four shapes, all hanging at column 3 so a column of PTC rows stays scannable:
-* - error:                    one line with the failure reason in the error colour.
-* - no completion value:      one line, "done".
-* - scalar / empty container: one line, `→ <hint>` (or "done" for null).
-* - non-empty container:      a tree of rows (recursive `├─/└─/│` connectors from
-*                             `renderValueTree`), with the right-aligned meta pinned to
-*                             the tree's first row. ADR-0013 §5.
-*
-* Each row returns its left-side text WITHOUT the `TREE_ROOT_CONT` prefix being in scope;
-* we prepend it here so the same output works for both surfaces.
-*/
-function resultArea(result, isError, theme, moreAfter = false) {
-	const right = metaText(result.details, theme);
-	const attachRight = (row) => right === void 0 ? row : {
-		...row,
-		right
-	};
-	if (isError) return [attachRight({ left: `${TREE_ROOT_CONT}${theme.fg("error", `failed: ${errorText(result)}`)}` })];
-	const value = result.details?.result;
-	if (value === void 0) return [attachRight({ left: `${TREE_ROOT_CONT}${theme.fg("muted", "done")}` })];
-	if (isExpandableContainer(value)) return renderValueTree(value, {
-		maxDepth: 4,
-		maxChildren: 6,
-		maxLineChars: 120,
-		moreAfter
-	}).map((line, index) => {
-		const row = { left: `${TREE_ROOT_CONT}${line}` };
-		return index === 0 && right !== void 0 ? {
-			...row,
-			right
-		} : row;
-	});
-	const hint = resultHint(value);
-	if (hint === void 0) return [attachRight({ left: `${TREE_ROOT_CONT}${theme.fg("muted", "done")}` })];
-	return [attachRight({ left: `${TREE_ROOT_CONT}${theme.fg("dim", `→ ${hint}`)}` })];
-}
-/**
-* Collapsed result: the result area only.
-*
-* A scalar row fits on one line; a container value expands into a tree (1+ lines). Right-aligned
-* meta (output lines / phases / warnings / duration) is pinned to the first row of the area.
-*/
-function renderPtcToolResultCollapsed(result, isError, theme) {
-	return new PtcRow(resultArea(result, isError, theme));
-}
-/**
-* Expanded view: the result area, then the run's children as labelled blocks.
-*
-* Each child block opens with a fixed-width gutter (`code`, `phases`, `log`, `out`, `warn`,
-* `image`); the `value` block is gone — for a scalar value the result area already shows the
-* hint, and for a container value the area shows the full tree (ADR-0013 §5). Children that
-* overflow cap themselves and report `+N more lines`; the view stays bounded.
-*/
-function renderPtcToolResultExpanded(result, args, isError, theme) {
-	if (isError) {
-		const lines = resultArea(result, true, theme);
-		const text = sanitizeText(result.content?.find((block) => block.type === "text")?.text ?? errorText(result));
-		for (const line of text.split("\n").slice(0, MAX_LOG_LINES_EXPANDED)) lines.push({ left: `${TREE_ROOT_CONT}${theme.fg("error", line)}` });
-		return new PtcRow(lines);
-	}
-	const details = result.details;
-	const children = [];
-	const code = args.code ?? args.script ?? "";
-	if (code.length > 0) {
-		const codeLines = code.split("\n").map((line) => truncateChars(line, MAX_CODE_LINE_CHARS));
-		const shown = codeLines.slice(0, MAX_CODE_LINES_EXPANDED);
-		children.push({
-			label: "code",
-			lines: shown,
-			...codeLines.length > shown.length ? { more: codeLines.length - shown.length } : {}
-		});
-	}
-	if (details !== void 0 && details.surface === "workflow" && details.phases.length > 0) {
-		const shown = details.phases.slice(0, MAX_PHASES_EXPANDED);
-		const tail = details.phases.length > shown.length ? " …" : "";
-		children.push({
-			label: "phases",
-			lines: [`${shown.join(" → ")}${tail}`]
-		});
-	}
-	if (details !== void 0 && details.narrations.length > 0) {
-		const shown = details.narrations.slice(0, MAX_LOG_LINES_EXPANDED);
-		children.push({
-			label: "log",
-			lines: shown.map((message) => sanitizeText(message)),
-			...details.narrations.length > shown.length ? { more: details.narrations.length - shown.length } : {}
-		});
-	}
-	if (details !== void 0 && details.logs.length > 0) {
-		const shown = details.logs.slice(0, MAX_LOG_LINES_EXPANDED);
-		children.push({
-			label: "out",
-			lines: shown.map((line) => sanitizeText(line)),
-			...details.logs.length > shown.length ? { more: details.logs.length - shown.length } : {}
-		});
-	}
-	if (details !== void 0 && details.warnings.length > 0) {
-		const shown = details.warnings.slice(0, MAX_WARNINGS_EXPANDED);
-		children.push({
-			label: "warn",
-			lines: shown.map((warning) => sanitizeText(warning)),
-			...details.warnings.length > shown.length ? { more: details.warnings.length - shown.length } : {}
-		});
-	}
-	if (details !== void 0 && details.imageCount > 0) {
-		const desc = details.imageCount === 1 ? "1 image attached" : `${details.imageCount} images attached`;
-		children.push({
-			label: "image",
-			lines: [desc]
-		});
-	}
-	const lines = resultArea(result, false, theme, children.length > 0);
-	for (let index = 0; index < children.length; index += 1) {
-		const isLast = index === children.length - 1;
-		lines.push(...renderChildBlock(children[index] ?? {
-			label: "",
-			lines: []
-		}, isLast, theme));
-	}
-	return new PtcRow(lines);
-}
-//#endregion
-//#region src/tools/run-code.ts
-/**
-* `ptc_run_code` — the unstructured PTC surface.
-*
-* The model writes the body of an async function; inside it, pi's built-in tools are reachable as
-* `tools.<name>(args)` (all seven: read, bash, edit, write, grep, find, ls — ADR-0005's set), and
-* the program's return value plus `console.log` output are what come back. There are no helpers
-* on this surface: `log` / `phase` / `parallel` / `pipeline` belong to `ptc_workflow` (G1 #13 →
-* decision B; a call to a helper that does not exist is a plain `ReferenceError` through the
-* normal code-run error path).
-*
-* Scope notes, so this stays a faithful subset of DSH's `run_code`:
-* - DSH's `sandbox_permissions` / `justification` are deliberately absent — they exist to request
-*   a wider sandbox from an approval pipeline this package does not have (ADR-0007 ships no OS
-*   sandbox, and the map decision on #8 dropped the approval path).
-* - `timeoutMs: 0` does not disable the deadline; it falls back to `DEFAULT_CONFIG.timeoutMs`,
-*   exactly as DSH's resolver does (R1 §3). The description names the default and the ceiling.
-*/
-const DESCRIPTION$1 = [
-	"Run a TypeScript program that composes pi's tools in one shot. Required arguments: `code` —",
-	"the body of an async function (top-level `return` and `await` work; type annotations are",
-	"advisory, the code runs type-stripped) — and `description`, a 5-10 word summary of what the",
-	"program does.",
-	"",
-	"Inside the program, call this session's enabled built-in tools as `tools.<name>(args)` — e.g.",
-	"`await tools.read({ path: \"src/index.ts\" })` or `await tools.bash({ command: \"npm test\" })`.",
-	"The bound names mirror the session's active tools (a default session has `read`, `bash`, `edit`,",
-	"`write`); calling a name that is not bound rejects with an error the program can catch, and",
-	"independent calls may overlap under `Promise.all`.",
-	"",
-	"Only the program's return value and its `console.log` output come back. This surface has no",
-	"helpers: `log` / `phase` / `parallel` / `pipeline` exist only in `ptc_workflow`.",
-	"",
-	"Image-bearing tool results inside the program (a `tools.read` on a PNG, say) are attached to you",
-	"after the run, so never return image data as the completion value — that only spends your context",
-	"on base64."
-].join("\n");
-const PARAMETERS$1 = Type.Object({
-	code: Type.String({ description: "The program: the body of an async TypeScript function." }),
-	description: Type.String({ description: "Clear, concise description of what this program does in active voice, 5-10 words (shown in the UI)." }),
-	timeoutMs: Type.Optional(Type.Number({ description: `Elapsed deadline in milliseconds for the whole run, including tool calls. Omit it (or pass 0) for the default of ${DEFAULT_CONFIG.timeoutMs / 1e3} s; anything above ${DEFAULT_CONFIG.maxTimeoutMs / 1e3} s is capped.` }))
-});
-/**
-* Build the `ptc_run_code` tool definition.
-*
-* 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({
-		name: "ptc_run_code",
-		label: "PTC Run Code",
-		description: DESCRIPTION$1,
-		promptSnippet: PTC_RUN_CODE_SNIPPET,
-		promptGuidelines: [...PTC_TOOL_GUIDELINES],
-		parameters: PARAMETERS$1,
-		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-			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,
-					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 },
-				...pool === void 0 ? {} : { pool }
-			});
-			if (outcome.error !== void 0) throw codeRunFailedError(outcome);
-			return renderToolResult({
-				outcome,
-				surface: "run_code",
-				durationMs: Date.now() - startedAt
-			});
-		},
-		renderCall(args, theme) {
-			return renderPtcToolCall(args, theme, "run_code");
-		},
-		renderResult(result, options, theme, context) {
-			if (options.expanded) return renderPtcToolResultExpanded(result, context.args, context.isError, theme);
-			return renderPtcToolResultCollapsed(result, context.isError, theme);
-		}
-	});
-}
-//#endregion
-//#region src/tools/workflow.ts
-/**
-* `ptc_workflow` — the structured PTC surface.
-*
-* 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).
-*
-* Three decisions recorded here rather than re-litigated per call:
-* - **Language**: the same type-stripping pipeline as `ptc_run_code`. The worker compiles both
-*   surfaces through one `compileProgram`, and the pipeline is type-*strip* only — it adds no
-*   runtime semantics that a workflow could not tolerate. There is no JS-only mode because there
-*   is no concrete reason for one (the old pi-ptc "JS-only" idea is explicitly not inherited).
-* - **Phase strictness**: warning, not error. A `phase(title)` outside `meta.phases` is a plan
-*   drift — usually a typo or a forgotten declaration — but the run has already happened by the
-*   time the titles are known, and failing then would discard a completed result over a cosmetic
-*   mismatch. Each distinct unlisted title is reported once, as a `Warning:` line in `content`
-*   and in `details.warnings`. When `meta.phases` is absent there is no declared plan to drift
-*   from, so nothing is reported.
-* - **`args`**: validated as plain JSON before dispatch (see `validateWorkflowArgs`), because a
-*   function/symbol/`undefined`/cycle would otherwise be silently dropped or mangled by the
-*   structured clone on its way to the worker.
-*/
-const DESCRIPTION = [
-	"Run a structured TypeScript workflow: a named plan that reports phases and narration as it",
-	"goes. `script` is the body of an async function, `meta` names it (`{ name, description, phases? }`,",
-	"where `phases` is the ordered plan), and optional `args` is plain-JSON input bound to the",
-	"program's `args` global.",
-	"",
-	"Helpers inside the script: `log(message)` narrates progress; `phase(title)` frames the workflow",
-	"(titles outside `meta.phases` are reported as warnings); `parallel(thunks)` runs thunks",
-	"concurrently, a failed item becoming `null`; `pipeline(items, ...stages)` chains stages per item",
-	"with the same per-item `null` on failure. There is no `agent()` helper.",
-	"",
-	"Tools are reachable as `tools.<name>(args)` exactly as in `ptc_run_code`, and the bound names",
-	"mirror the session's enabled tools. What comes back is the script's return value, its",
-	"`log`/`phase` narration and its `console.log` output.",
-	"",
-	"Image-bearing tool results inside the script are attached to you after the run — never return",
-	"image data as the script's value."
-].join("\n");
-const PARAMETERS = Type.Object({
-	meta: Type.Object({
-		name: Type.String({ description: "Short workflow name, shown in the UI." }),
-		description: Type.String({ description: "What this workflow does, in active voice." }),
-		phases: Type.Optional(Type.Array(Type.Object({ name: Type.String({ description: "Phase title, matched against phase(title) calls." }) }), { description: "Ordered plan of the workflow's phases. phase() titles outside this list are reported as warnings." }))
-	}, { description: "Workflow metadata: what this run is and which phases it declares." }),
-	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." }))
-});
-/**
-* Reject anything that is not plain JSON, with a path-qualified reason.
-*
-* The rule is the worker's own result rule (`toJsonValue`) applied one direction earlier, so both
-* ends agree on what "plain JSON" means: objects with `Object.prototype` (or null), arrays,
-* strings, finite numbers, booleans and null. Class instances, functions, symbols, bigints,
-* non-finite numbers, circular references and `undefined` values are all rejected — `undefined`
-* because the ticket calls it out and because a structured clone would drop it silently, leaving
-* the script reading a key that is not there.
-*/
-function validateWorkflowArgs(args) {
-	if (args === void 0) return;
-	if (typeof args !== "object" || args === null || Array.isArray(args)) throw new TypeError(`ptc_workflow args must be a plain JSON object, received ${describeValue(args)}`);
-	for (const key of Object.keys(args)) {
-		const problem = findJsonProblem(args[key], `args.${key}`, /* @__PURE__ */ new Set());
-		if (problem !== void 0) throw new TypeError(`ptc_workflow args must be plain JSON: ${problem}`);
-	}
-}
-/** Path-qualified reason a value cannot cross the wire as plain JSON, or `undefined` when it can. */
-function findJsonProblem(value, path, seen) {
-	if (value === null || typeof value === "string" || typeof value === "boolean") return void 0;
-	if (typeof value === "undefined") return `${path} is undefined`;
-	if (typeof value === "number") return Number.isFinite(value) ? void 0 : `${path} is ${String(value)}, which is not representable as JSON`;
-	if (typeof value !== "object") return `${path} is ${describeValue(value)}`;
-	const container = value;
-	if (seen.has(container)) return `${path} is a circular reference`;
-	seen.add(container);
-	try {
-		if (Array.isArray(container)) {
-			for (let index = 0; index < container.length; index += 1) {
-				const problem = findJsonProblem(container[index], `${path}[${index}]`, seen);
-				if (problem !== void 0) return problem;
-			}
-			return;
-		}
-		const prototype = Object.getPrototypeOf(container);
-		if (prototype !== Object.prototype && prototype !== null) {
-			const name = container.constructor?.name;
-			return `${path} is a ${typeof name === "string" && name.length > 0 ? name : "non-plain object"}, not plain JSON`;
-		}
-		for (const key of Object.keys(container)) {
-			const problem = findJsonProblem(container[key], `${path}.${key}`, seen);
-			if (problem !== void 0) return problem;
-		}
-		return;
-	} finally {
-		seen.delete(container);
-	}
-}
-/**
-* Collect the plan-drift warnings for one workflow run: distinct `phase()` titles the declared
-* `meta.phases` list does not mention, in first-seen order.
-*/
-function unlistedPhaseWarnings(outcome, declared) {
-	if (declared === void 0 || declared.length === 0) return [];
-	const known = new Set(declared);
-	const reported = /* @__PURE__ */ new Set();
-	const warnings = [];
-	for (const title of outcome.phases) {
-		if (known.has(title) || reported.has(title)) continue;
-		reported.add(title);
-		warnings.push(`phase "${title}" is not listed in meta.phases (declared: ${[...known].join(", ")})`);
-	}
-	return warnings;
-}
-/**
-* Build the `ptc_workflow` tool definition.
-*
-* `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({
-		name: "ptc_workflow",
-		label: "PTC Workflow",
-		description: DESCRIPTION,
-		promptSnippet: PTC_WORKFLOW_SNIPPET,
-		promptGuidelines: [...PTC_TOOL_GUIDELINES],
-		parameters: PARAMETERS,
-		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-			validateWorkflowArgs(params.args);
-			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,
-					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 },
-				...pool === void 0 ? {} : { pool }
-			});
-			if (outcome.error !== void 0) throw codeRunFailedError(outcome);
-			const declared = params.meta.phases?.map((phase) => phase.name);
-			return renderToolResult({
-				outcome,
-				surface: "workflow",
-				warnings: unlistedPhaseWarnings(outcome, declared),
-				durationMs: Date.now() - startedAt
-			});
-		},
-		renderCall(args, theme) {
-			return renderPtcToolCall(args, theme, "workflow");
-		},
-		renderResult(result, options, theme, context) {
-			if (options.expanded) return renderPtcToolResultExpanded(result, context.args, context.isError, theme);
-			return renderPtcToolResultCollapsed(result, context.isError, theme);
-		}
-	});
-}
-//#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.
-*
-* ## What "mode" means here
-*
-* While enabled, the session's visible tool loadout is narrowed so the model reaches
-* `read` / `bash` / `edit` / `write` / `grep` / `find` / `ls` only from *inside* a program
-* (`tools.<name>(args)`). That is DSH's PTC-preset shape, and it is what makes the mode visible
-* in the TUI: the transcript stops showing file-operation rows and shows PTC rows instead.
-*
-* The mode is decided per session (`session_start`), announced once, and always reversible.
-*
-* ## Why bindings need a base snapshot (the trap this module exists to avoid)
-*
-* `resolveBindingNames()` computes bindings as `BUILTIN_BINDING_NAMES ∩ pi.getActiveTools()`
-* (T7, ADR-0005 addendum). But `pi.getActiveTools()` reads the *live* loadout — the very set this
-* mode narrows. Hiding the built-ins therefore empties the binding table, and every
-* `tools.read(...)` fails with "not bound": the extension would neuter itself.
-*
-* The fix is a **base snapshot**. `base` is captured *before* the mode hides anything, and
-* bindings derive from `base` rather than the live loadout while the mode is on. T7's invariant
-* survives, because `base` is itself read from `pi.getActiveTools()`: a session launched with
-* `--tools read` has `base = ["read"]`, so bindings stay `["read"]`. The mode never widens access
-* beyond what the session was launched with — it only makes its **own** narrowing transparent to
-* the binding table.
-*
-* ## Fail-safe on external loadout changes
-*
-* Another extension can call `setActiveTools()` (pi's own `preset.ts` and `tools.ts` examples do).
-* `ourLoadout` records the exact array this mode wrote, so a mismatch means someone else owns the
-* loadout now. The mode then exits and restores `base` instead of fighting over it.
-*
-* ## Where the mode never runs
-*
-* Print / JSON / RPC sessions (`ctx.mode !== "tui"`) are left alone: forcing the shape on CI
-* scripts buys nothing and breaks them. A session that was *launched* with an explicit tool
-* restriction is left alone too — see `decideModeEntry`.
-*/
-/** The two surfaces this package exposes. `/ptc on` needs at least one of them active. */
-const PTC_MODE_TOOL_NAMES = ["ptc_run_code", "ptc_workflow"];
-/**
-* Tools that must all be present for the **automatic** entry path to proceed.
-*
-* These four are pi's default session surface (`agent-session.js`: "["read", "bash", "edit",
-* "write"]"), so "all four present" means "this session was not narrowed". Comparing against
-* `BUILTIN_BINDING_NAMES` instead would be wrong: that list is the set of names that *can* be
-* bound, not what a default session has (`grep` / `find` / `ls` are bindable but off by default),
-* so requiring all seven would misread every ordinary session as restricted and never turn on.
-*/
-const MODE_REQUIRED_TOOL_NAMES = [
-	"read",
-	"bash",
-	"edit",
-	"write"
-];
-/** `customType` for the persisted mode entry (`pi.appendEntry`). */
-const PTC_MODE_ENTRY_TYPE = "ptc-mode";
-/** Footer status key (`ctx.ui.setStatus`). */
-const PTC_MODE_STATUS_KEY = "ptc-mode";
-/** Config file name, resolved against pi's agent dir (`~/.pi/agent/`). */
-const PTC_MODE_CONFIG_FILE = "ptc.json";
-/**
-* Which tools the mode hides while it is on.
-*
-* - `"builtins-only"` (default) — hide the seven built-in tools; tools contributed by *other*
-*   extensions (`web_search`, `todo`, `subagent`, …) stay visible and directly callable. The
-*   model is forced to program for file and shell work, which is the bulk of a coding session,
-*   without losing capabilities this package cannot re-expose: extension tools have no bindings
-*   (`pi.getAllTools()` returns metadata only — no `execute`), so hiding one makes it
-*   unreachable for the whole session.
-* - `"all-but-ptc"` — hide everything except the two PTC surfaces. Closest to a strict reading of
-*   DSH's preset, at the cost of making other extensions' tools unreachable until `/ptc off`.
-*/
-const DEFAULT_HIDE_STRATEGY = "builtins-only";
-/** Fresh, disabled state. */
-function initialModeState() {
-	return {
-		enabled: false,
-		base: void 0,
-		ourLoadout: void 0
-	};
-}
-/**
-* Read `defaultMode` from the agent-dir config file.
-*
-* Absent file → on (this package is default-on by design; see CONTEXT.md). A present file with a
-* non-boolean `defaultMode`, or unparseable JSON, is reported as `invalid` **and still defaults to
-* on** — the caller should surface the problem rather than silently changing behavior.
-*/
-function readDefaultModeConfig(agentDir) {
-	const path = join(agentDir, PTC_MODE_CONFIG_FILE);
-	let raw;
-	try {
-		raw = readFileSync(path, "utf8");
-	} catch {
-		return {
-			defaultMode: true,
-			source: "default"
-		};
-	}
-	let parsed;
-	try {
-		parsed = JSON.parse(raw);
-	} catch (error) {
-		return {
-			defaultMode: true,
-			source: "invalid",
-			error: `${path} is not valid JSON (${error instanceof Error ? error.message : String(error)})`
-		};
-	}
-	if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return {
-		defaultMode: true,
-		source: "invalid",
-		error: `${path} must contain a JSON object`
-	};
-	const value = parsed.defaultMode;
-	if (value === void 0) return {
-		defaultMode: true,
-		source: "default"
-	};
-	if (typeof value !== "boolean") return {
-		defaultMode: true,
-		source: "invalid",
-		error: `${path}: "defaultMode" must be a boolean, received ${typeof value}`
-	};
-	return {
-		defaultMode: value,
-		source: "file"
-	};
-}
-/** Normalize to a de-duplicated name list, preserving order. */
-function uniqueNames(names) {
-	return [...new Set(names)];
-}
-/** Order- and duplicate-insensitive set equality, for loadout comparison. */
-function sameToolSet(a, b) {
-	if (a.length !== b.length) return false;
-	const left = [...a].sort();
-	const right = [...b].sort();
-	return left.every((name, index) => name === right[index]);
-}
-/**
-* The loadout applied while the mode is on, given the session's current one.
-*
-* Always keeps the PTC surfaces; what else survives depends on the hide strategy (see
-* `DEFAULT_HIDE_STRATEGY`). Order follows `active`, so the visible list reads the way the session
-* was configured.
-*/
-function modeLoadout(active, hide) {
-	const isPtc = (name) => PTC_MODE_TOOL_NAMES.includes(name);
-	if (hide === "all-but-ptc") return uniqueNames(active.filter(isPtc));
-	const builtins = new Set(BUILTIN_BINDING_NAMES);
-	return uniqueNames(active.filter((name) => isPtc(name) || !builtins.has(name)));
-}
-/**
-* Decide whether the mode turns on for this session.
-*
-* The policy, in order:
-* 1. **TUI only** — print / JSON / RPC sessions are never touched.
-* 2. **Config** — `{"defaultMode": false}` opts out; `/ptc on` overrides it.
-* 3. **PTC tools must exist** — if this session has them disabled, there is nothing to run.
-* 4. **Explicit restriction wins** — a session launched with `--tools` / `--exclude-tools` /
-*    `--no-builtin-tools` that is missing any of `MODE_REQUIRED_TOOL_NAMES` (pi's default four)
-*    stays as launched. Narrowing *further* would be the extension overriding a deliberate user
-*    instruction, and the PTC surface would be degraded anyway (bindings = `BUILTIN ∩ base`).
-*    `/ptc on` overrides this: the manual path enters with the restricted loadout as `base`, so
-*    bindings stay inside the user's allowlist.
-*/
-function decideModeEntry(input) {
-	const { mode, defaultMode, active, manual } = input;
-	if (mode !== "tui") return {
-		enter: false,
-		reason: "not-tui"
-	};
-	if (!defaultMode && !manual) return {
-		enter: false,
-		reason: "config-off"
-	};
-	if (!PTC_MODE_TOOL_NAMES.some((name) => active.includes(name))) return {
-		enter: false,
-		reason: "tools-unavailable"
-	};
-	if (!manual) {
-		if (MODE_REQUIRED_TOOL_NAMES.filter((name) => !active.includes(name)).length > 0) return {
-			enter: false,
-			reason: "restricted-session"
-		};
-	}
-	return {
-		enter: true,
-		base: uniqueNames(active),
-		loadout: modeLoadout(active, input.hide ?? "builtins-only")
-	};
-}
-/**
-* Tool names the binding table should be built from.
-*
-* While the mode is on this is the base snapshot (so the built-ins the mode just hid remain
-* callable from inside a program); otherwise it is simply the live loadout, i.e. T7's rule.
-*/
-function bindingSource(state, active) {
-	return state.enabled && state.base !== void 0 ? state.base : active;
-}
-/**
-* Whether the live loadout is no longer the one this mode wrote — i.e. another extension (or the
-* user) took ownership of the tool set. Always false while the mode is off.
-*/
-function detectExternalLoadoutChange(state, active) {
-	if (!state.enabled || state.ourLoadout === void 0) return false;
-	return !sameToolSet(state.ourLoadout, active);
-}
-/**
-* Reconstruct the base loadout on `session_start`.
-*
-* Two shapes are possible:
-* - The session is still narrowed from a previous run of this mode (a `/reload`, or a resumed
-*   session): the live loadout is a subset of the PTC tools and the persisted record says the mode
-*   was on. The persisted `base` is then authoritative — but only to *undo our own hiding*.
-* - Otherwise the live loadout is whatever this pi process was launched with, and it wins. That is
-*   what keeps a new `--tools …` choice from being overridden by an older session's snapshot.
-*/
-function resolveBaseOnStart(persisted, active) {
-	const looksNarrowedByUs = active.length > 0 && active.every((name) => PTC_MODE_TOOL_NAMES.includes(name));
-	if (persisted?.enabled === true && looksNarrowedByUs && persisted.base !== void 0) return {
-		base: persisted.base,
-		restoreFirst: true
-	};
-	return {
-		base: active,
-		restoreFirst: false
-	};
-}
-/**
-* Build the system-visible briefing for the mode.
-*
-* Generated from the *actual* binding list rather than hardcoded, because bindings vary by session
-* (`base` is whatever the session was launched with) and a stale list would have the model calling
-* names that are not bound.
-*/
-function buildModeInstruction(bindings, hide) {
-	const builtinNote = hide === "all-but-ptc" ? "Every built-in tool is hidden from you, and so are other extensions' tools." : "The built-in tools (read, bash, edit, write, grep, find, ls) are hidden from you.";
-	const callable = bindings.map((name) => `tools.${name}(args)`);
-	const examples = bindings.slice(0, 2).map((name) => name === "read" ? "await tools.read({ path: \"src/index.ts\" })" : name === "bash" ? "await tools.bash({ command: \"pnpm test\" })" : `await tools.${name}({ /* … */ })`).join("\n");
-	return [
-		"[PTC MODE ACTIVE]",
-		"This session runs in PTC mode. " + builtinNote,
-		"",
-		"Work by writing one TypeScript program per task and running it:",
-		"  - ptc_run_code for a plain program (its return value and console.log come back to you)",
-		"  - ptc_workflow when the task has named phases and you want narration (log / phase /",
-		"    parallel / pipeline are available there)",
-		"",
-		`The program body is an async function. Available inside it: ${callable.join(", ")}.`,
-		examples.length > 0 ? `Examples:\n${examples}` : "",
-		"",
-		"Batch a task's steps into ONE program instead of issuing many tool calls — gathering",
-		"intermediate output yourself and returning only what matters is the point of this mode.",
-		"Image-bearing tool results inside a program are attached to you after the run — never return",
-		"base64 image data as your program's value.",
-		"If the PTC surfaces cannot express what you need, say so and the user can run /ptc off."
-	].filter((line) => line.length > 0).join("\n");
-}
-//#endregion
-//#region src/mode/skills-section.ts
-/**
-* The system-prompt skills section, restored for PTC mode.
-*
-* pi advertises skills only when the session can actually open one:
-*
-*   const skillFileReadTool = ["read", "bash"].find((tool) => selectedTools.includes(tool));
-*   if (skillFileReadTool && skills.length > 0) promptSections.skills = ...
-*                                      (pi-coding-agent: dist/core/system-prompt.js)
-*
-* PTC mode hides exactly those two tools, so that gate drops the section — and with it the model's
-* only way to learn that skills exist. Measured on real session files: sessions before
-* PTC-mode-by-default carried 43 skills in `SystemMessage.sections.skills`; PTC sessions carried
-* no `skills` section at all. See ADR-0011.
-*
-* The list body stays pi's own — `formatSkillsForPrompt` is a public export and its XML shape is
-* the agentskills.io spec, so re-deriving it here would only create drift. Only the loading
-* sentence changes: "Use the read tool" is false in a session where `read` is hidden, and the way
-* in is `tools.read` from inside a program.
-*/
-/** The two tools pi accepts as "this session can read a skill file". */
-const SKILL_READING_TOOL_NAMES = ["read", "bash"];
-/** pi's sentence, which names a tool PTC mode hides. */
-const PI_LOAD_INSTRUCTION = "Use the read tool to load a skill's file when the task matches its description.";
-/** What replaces it: the same instruction, in the only call form this session has. */
-const PTC_SKILL_LOAD_INSTRUCTION = "Use tools.read({ path }) inside a ptc_run_code program to load a skill's file when the task matches its description.";
-/**
-* Would pi withhold the skills section for this loadout?
-*
-* Mirrors the gate rather than guessing: it is true exactly when neither `read` nor `bash` is
-* directly callable, which is the state the mode deliberately puts an ordinary session in.
-*/
-function skillsSectionDropped(visibleTools) {
-	return !SKILL_READING_TOOL_NAMES.some((name) => visibleTools.includes(name));
-}
-/**
-* Build the `skills` section body (pi wraps it in `<skills>…</skills>` itself).
-*
-* Returns `""` when nothing is advertisable — pi's formatter filters out skills marked
-* `disable-model-invocation`, which is the correct behaviour to inherit: those are
-* `/skill:name`-only by design.
-*
-* `format` is injectable so a test can drive the reworded-header branch without patching pi.
-*/
-function buildPtcSkillsSection(skills, format = formatSkillsForPrompt) {
-	const section = format([...skills], "read").trim();
-	if (section.length === 0) return "";
-	if (section.includes(PI_LOAD_INSTRUCTION)) return section.replace(PI_LOAD_INSTRUCTION, PTC_SKILL_LOAD_INSTRUCTION);
-	return `${PTC_SKILL_LOAD_INSTRUCTION}\n\n${section}`;
-}
-//#endregion
-//#region src/index.ts
-/**
-* pi-ptc-subagents — DSH PTC mode (Programmable Tool Calling) for pi.
-*
-* This module is the extension entrypoint pi loads (`package.json` → `pi.extensions`).
-* The PTC machinery it exposes is complete and tested (T3): wire protocol, dispatcher,
-* bindings and the two worker surfaces. On top of it sit the two model-facing tools:
-*
-*   - `ptc_run_code` — bindings + Node + `console.log`, program's return value is the result
-*   - `ptc_workflow` — the same plus `log` / `phase` / `parallel` / `pipeline` and `args`
-*
-* There is no `agent()` helper on either surface (G1 #13 → decision B): calling it produces
-* a plain `ReferenceError` through the normal code-run error path.
-*/
-/** Footer status label shown while the mode is on. */
-const MODE_STATUS_TEXT = "PTC";
-/**
-* Which tools the mode hides. The shipped extension always uses the default; it is a named
-* constant so a future settings surface (or a test) has one place to change it.
-*/
-const MODE_HIDE_STRATEGY = DEFAULT_HIDE_STRATEGY;
-/**
-* What to tell the user when the mode turns on. Names what became unreachable, because that is the
-* part that surprises people — and the binding list, because that is the part they need in order
-* to know what a program can still do.
-*/
-function describeEntry(base, hide) {
-	return [
-		`PTC mode on — ${hide === "all-but-ptc" ? "all other tools" : "built-in tools (now reachable only as tools.<name> inside a program)"} hidden.`,
-		`Bindings available inside a program: ${resolveBindingNames(base).join(", ") || "(none)"}.`,
-		"Run /ptc off to restore the normal tool set."
-	].join("\n");
-}
-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());
-	/**
-	* 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);
-	};
-	const enterMode = (base, loadout, ctx, announcement) => {
-		mode.enabled = true;
-		mode.base = base;
-		mode.ourLoadout = loadout;
-		pi.setActiveTools([...loadout]);
-		briefingPending = true;
-		pi.appendEntry(PTC_MODE_ENTRY_TYPE, {
-			enabled: true,
-			base: [...base]
-		});
-		paintStatus(ctx);
-		ctx.ui.notify(announcement, "info");
-	};
-	const exitMode = (ctx, opts) => {
-		const base = mode.base;
-		mode.enabled = false;
-		mode.base = void 0;
-		mode.ourLoadout = void 0;
-		briefingPending = false;
-		if (base !== void 0) pi.setActiveTools([...base]);
-		pi.appendEntry(opts.customType, { enabled: false });
-		paintStatus(ctx);
-		if (opts.announce) ctx.ui.notify("PTC mode off — built-in tools are directly callable again.", "info");
-	};
-	/** Restore the persisted mode record, if this session has one. */
-	const readPersistedMode = (ctx) => {
-		const entries = ctx.sessionManager.getEntries();
-		for (let index = entries.length - 1; index >= 0; index -= 1) {
-			const entry = entries[index];
-			if (entry?.type !== "custom" || entry.customType !== "ptc-mode") continue;
-			const data = entry.data;
-			const base = Array.isArray(data?.base) ? data.base.filter((name) => typeof name === "string") : void 0;
-			return {
-				enabled: data?.enabled === true,
-				...base === void 0 ? {} : { base }
-			};
-		}
-	};
-	pi.registerCommand("ptc", {
-		description: "Show or toggle PTC mode (built-in tools reachable only from inside a PTC program)",
-		handler: async (args, ctx) => {
-			const action = args.trim().toLowerCase();
-			if (action === "off") {
-				if (!mode.enabled) {
-					ctx.ui.notify("PTC mode is already off.", "info");
-					return;
-				}
-				exitMode(ctx, {
-					announce: true,
-					customType: PTC_MODE_ENTRY_TYPE
-				});
-				return;
-			}
-			if (action !== "on") {
-				ctx.ui.notify(mode.enabled ? `PTC mode is ON — run /ptc off to restore built-in tools.\nBindings: ${resolveBindingNames(mode.base).join(", ") || "(none)"}` : "PTC mode is OFF — run /ptc on to enter it.", "info");
-				return;
-			}
-			if (mode.enabled) {
-				ctx.ui.notify("PTC mode is already on.", "info");
-				return;
-			}
-			const decision = decideModeEntry({
-				mode: ctx.mode,
-				defaultMode: true,
-				active: pi.getActiveTools(),
-				manual: true,
-				hide: MODE_HIDE_STRATEGY
-			});
-			if (!decision.enter) {
-				ctx.ui.notify(decision.reason === "tools-unavailable" ? "Cannot enter PTC mode: ptc_run_code / ptc_workflow are not active in this session." : "Cannot enter PTC mode in this run mode.", "warning");
-				return;
-			}
-			enterMode(decision.base, decision.loadout, ctx, describeEntry(decision.base, MODE_HIDE_STRATEGY));
-		}
-	});
-	pi.on("session_start", async (_event, ctx) => {
-		const config = readDefaultModeConfig(getAgentDir());
-		if (config.error !== void 0) ctx.ui.notify(`pi-ptc-subagents: ${config.error}`, "warning");
-		const persisted = readPersistedMode(ctx);
-		const { base, restoreFirst } = resolveBaseOnStart(persisted, pi.getActiveTools());
-		if (restoreFirst) pi.setActiveTools([...base]);
-		const decision = decideModeEntry({
-			mode: ctx.mode,
-			defaultMode: config.defaultMode,
-			active: base,
-			manual: false,
-			hide: MODE_HIDE_STRATEGY
-		});
-		const wantMode = persisted?.enabled ?? decision.enter;
-		if (decision.enter && wantMode) {
-			enterMode(base, decision.loadout, ctx, describeEntry(base, MODE_HIDE_STRATEGY));
-			return;
-		}
-		paintStatus(ctx);
-		if (!decision.enter && decision.reason !== "not-tui" && persisted === void 0) {
-			if (decision.reason === "restricted-session") ctx.ui.notify("PTC mode skipped: this session was launched with an explicit tool restriction.", "info");
-		}
-	});
-	/**
-	* Put back the skills section pi withholds while the mode hides `read`/`bash` (ADR-0011).
-	*
-	* pi advertises skills only when the session can open a skill file at all (`read` or `bash`
-	* among the selected tools), so a PTC session silently loses the whole `<available_skills>`
-	* list: the model stops knowing skills exist. Writing `sections.skills` here is the seam pi
-	* leaves open — custom sections are merged after its own, so this one wins.
-	*
-	* The same options object is reused across turns and sessions of a resume, so the injection is
-	* undone the moment the mode stops hiding those tools: a `/ptc off` must not leave PTC-flavoured
-	* loading instructions behind while `read` is directly callable again.
-	*/
-	let skillsSectionInjected = false;
-	const syncSkillsSection = (options, hidden) => {
-		if (options === void 0) return;
-		if (!mode.enabled || !hidden) {
-			if (skillsSectionInjected) {
-				delete options.sections.skills;
-				skillsSectionInjected = false;
-			}
-			return;
-		}
-		const section = buildPtcSkillsSection(options.skills);
-		if (section.length === 0) return;
-		options.sections.skills = section;
-		skillsSectionInjected = true;
-	};
-	pi.on("before_agent_start", async (event, ctx) => {
-		const options = event.systemPromptOptions;
-		syncSkillsSection(options, skillsSectionDropped(pi.getActiveTools()));
-		if (!mode.enabled) return;
-		if (detectExternalLoadoutChange(mode, pi.getActiveTools())) {
-			exitMode(ctx, {
-				announce: false,
-				customType: PTC_MODE_ENTRY_TYPE
-			});
-			syncSkillsSection(options, skillsSectionDropped(pi.getActiveTools()));
-			ctx.ui.notify("PTC mode off — another extension changed the active tool set.", "warning");
-			return;
-		}
-		if (!briefingPending) return;
-		briefingPending = false;
-		return { message: {
-			customType: "ptc-mode-briefing",
-			content: buildModeInstruction(resolveBindingNames(mode.base), MODE_HIDE_STRATEGY),
-			display: false
-		} };
-	});
-}
-//#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, 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 };
+import{a as e,i as t,n,o as r,r as i,s as a,t as o}from"./protocol-CfOgxz3u.js";import{DEFAULT_MAX_BYTES as s,DEFAULT_MAX_LINES as c,createBashTool as l,createEditTool as u,createFindTool as d,createGrepTool as f,createLsTool as p,createReadTool as m,createWriteTool as h,defineTool as g,formatSize as _,formatSkillsForPrompt as v,getAgentDir as y,truncateTail as b}from"@earendil-works/pi-coding-agent";import{Type as x}from"typebox";import{validateToolArguments as S}from"@earendil-works/pi-ai";import{spawn as ee}from"node:child_process";import*as C from"node:fs";import{existsSync as w,readFileSync as T,writeFileSync as E}from"node:fs";import*as D from"node:os";import{tmpdir as te}from"node:os";import*as O from"node:path";import{dirname as k,join as A,resolve as ne}from"node:path";import{randomUUID as j}from"node:crypto";import{MessageChannel as re,Worker as M}from"node:worker_threads";import N from"node:diagnostics_channel";import{fileURLToPath as P,pathToFileURL as ie}from"node:url";import{truncateToWidth as ae,visibleWidth as F}from"@earendil-works/pi-tui";function oe(e,t,n){let r=[`<pi-ptc-context depth="`+t+`" max-depth="`+n+`">`,`You are a PTC run at depth `+t+` (root is depth 0). You may write PTC programs and you may`,`call pi.dispatch(...) to spawn further children, but each level costs a fresh pi subprocess.`,`The remaining depth budget is `+n+` - `+t+`. Beyond it, pi.dispatch rejects with`,`{ status: "rejected", errorMessage: "dispatch depth limit reached" }.`,`</pi-ptc-context>`].join(`
+`);return e.length===0?r:e+`
 
+`+r}function se(){return{text:``,status:`rejected`,started:!1,agentName:`unknown`,durationMs:0,exitCode:-1,errorMessage:`dispatch depth limit reached`}}function ce(){return{text:``,status:`rejected`,started:!1,agentName:`unknown`,durationMs:0,exitCode:-1,errorMessage:`dispatch concurrency limit reached`}}function le(e){return e.aborted?{status:`rejected`,errorMessage:`dispatch cancelled`}:e.exitCode===0&&e.finalText.length>0?{status:`fulfilled`}:e.exitCode===0?{status:`rejected`,errorMessage:`dispatch produced no final text`}:{status:`rejected`}}function ue(e,t){if(e.pid===void 0)return!1;try{return e.kill(t),!0}catch{return!1}}function I(e,t){let n=e.match(RegExp(`^`+t+`:\\s*(.+)$`,`m`));if(!n)return;let r=(n[1]??``).trim();if(r.length>=2){let e=r[0],t=r[r.length-1];(e===`"`&&t===`"`||e===`'`&&t===`'`)&&(r=r.slice(1,-1))}return r.length===0?void 0:r}function de(e,t){let n=e.match(RegExp(`^`+t+`:\\s*(.+)$`,`m`));if(!n)return;let r=(n[1]??``).trim();r.startsWith(`[`)&&r.endsWith(`]`)&&(r=r.slice(1,-1));let i=r.split(`,`).map(e=>e.trim()).filter(e=>e.length>0);return i.length===0?void 0:i}function fe(e){let t=e.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);if(!t)return null;let n=t[1]??``,r=t[2]??``,i=I(n,`name`);if(!i)return null;let a=I(n,`description`)??``,o=I(n,`model`)??``,s=de(n,`tools`),c={name:i,systemPrompt:r.trim()};return a!==void 0&&(c.description=a),o!==void 0&&(c.model=o),s!==void 0&&(c.tools=s),c}function pe(e,t,n){let r=O.join(D.homedir(),`.pi`,`agent`,`agents`),i=O.join(t,`.pi`,`agents`),a=[];(n===`user`||n===`both`)&&a.push({path:O.join(r,e+`.md`),source:`user`}),(n===`project`||n===`both`)&&a.push({path:O.join(i,e+`.md`),source:`project`});for(let t of a){let n;try{n=C.readFileSync(t.path,`utf-8`)}catch{continue}let r=fe(n);if(r&&r.name===e){let e={name:r.name,source:t.source,systemPrompt:r.systemPrompt};return r.model!==void 0&&(e.model=r.model),r.tools!==void 0&&(e.tools=r.tools),e}}return null}function me(e,t,n){let r=[`--mode`,`json`,`-p`,`--no-session`],i=e.model??t.model;i&&r.push(`--model`,i);let a=e.thinkingLevel??`off`;return r.push(`--thinking`,a),t.tools&&t.tools.length>0&&r.push(`--tools`,t.tools.join(`,`)),r.push(`--append-system-prompt`,n),r.push(`Task: `+e.task),r}function he(e){let t=e.trim();if(t.length===0)return null;try{return JSON.parse(t)}catch{return null}}async function ge(e,t){let n=await C.promises.mkdtemp(O.join(D.tmpdir(),`pi-dispatch-`)),r=e.replace(/[^\w.-]+/g,`_`),i=O.join(n,`prompt-`+r+`.md`);return await C.promises.writeFile(i,t,{encoding:`utf-8`,mode:384}),{dir:n,filePath:i}}function _e(e){try{C.unlinkSync(e.filePath)}catch{}try{C.rmdirSync(e.dir)}catch{}}async function ve(e,t){let n=t.depth+1;if(n>t.maxDispatchDepth)return se();let r=e.cwd??t.cwd,i=e.agentScope??`user`,a=Date.now(),o=pe(e.agent,r,i);if(!o)return{text:``,status:`rejected`,started:!1,agentName:e.agent,durationMs:Date.now()-a,exitCode:1,errorMessage:`unknown agent: `+e.agent+` (agentScope=`+i+`, cwd=`+r+`)`};let s=oe(o.systemPrompt,n,t.maxDispatchDepth),c=await ge(o.name,s),l=me(e,o,c.filePath);return await new Promise(e=>{let i=``,s=``,u=``,d,f=-1,p=!1,m,h,g=!1,_=(n,r,i=!0)=>{if(p)return;p=!0,m&&clearTimeout(m),t.signal&&t.signal.removeEventListener(`abort`,v),_e(c);let l={text:u,status:n,started:i,agentName:o.name,durationMs:Date.now()-a,exitCode:f};d&&(l.usage=d),s.length>0&&(l.stderr=s),r&&(l.errorMessage=r),e(l)},v=()=>{!h||h.killed||p||(g=!0,ue(h,`SIGTERM`),m=setTimeout(()=>{h&&!h.killed&&ue(h,`SIGKILL`)},5e3))};try{h=ee(`pi`,l,{cwd:r,shell:!1,stdio:[`ignore`,`pipe`,`pipe`],env:{...process.env,PI_PTC_DEPTH:String(n)}})}catch(e){_(`rejected`,`failed to spawn pi: `+(e instanceof Error?e.message:String(e)),!1);return}t.signal&&(t.signal.aborted?v():t.signal.addEventListener(`abort`,v,{once:!0}));let y=h.stdout;if(!y)return;y.on(`data`,e=>{i+=e.toString(`utf-8`);let t=i.indexOf(`
+`);for(;t>=0;){let e=i.slice(0,t);i=i.slice(t+1);let n=he(e);if(!n){t=i.indexOf(`
+`);continue}if(n.type===`message_end`&&n.message&&n.message.role===`assistant`){let e=n.message;if(e.usage){let t=d??{input:0,output:0,cacheRead:0,cacheWrite:0,cost:0,turns:0};t.input+=e.usage.input??0,t.output+=e.usage.output??0,t.cacheRead+=e.usage.cacheRead??0,t.cacheWrite+=e.usage.cacheWrite??0,t.cost+=e.usage.cost?.total??0,t.turns+=1,d=t}if(Array.isArray(e.content))for(let t of e.content)t&&t.type===`text`&&typeof t.text==`string`&&(u=t.text)}t=i.indexOf(`
+`)}});let b=h.stderr;b&&(b.on(`data`,e=>{s+=e.toString(`utf-8`)}),h.on(`close`,e=>{f=e??-1;let{status:t,errorMessage:n}=le({exitCode:f,finalText:u,aborted:g});_(t,n)}),h.on(`error`,e=>{s+=`[spawn-error] `+e.message+`
+`,_(`rejected`,`failed to spawn pi: `+e.message,!1)}))})}const L=[`read`,`bash`,`edit`,`write`,`grep`,`find`,`ls`],ye=`pi.dispatch`,be=L,xe={read:m,bash:l,edit:u,write:h,grep:f,find:d,ls:p};function Se(e){let t=e.names??be,n=e.includeDispatch??e.names===void 0,r=/* @__PURE__ */ new Map;for(let n of t){let t=xe[n];if(!t)throw TypeError(`unknown PTC binding "${n}"; known bindings: ${L.join(`, `)}`);let i=t(e.cwd);r.set(n,{name:n,execute:async(e,t)=>{let n=`ptc:${t.callId}`,r={type:`toolCall`,id:n,name:i.name,arguments:e},a=S(i,r),o=await i.execute(n,a,t.signal,void 0);return{content:o.content,details:o.details===void 0?null:o.details}}})}return n&&r.set(ye,{name:ye,execute:async(t,n)=>ve(t,{signal:n.signal,callId:n.callId,cwd:e.cwd,depth:n.depth,maxDispatchDepth:n.maxDispatchDepth})}),r}const R=Object.freeze({timeoutMs:12e4,maxTimeoutMs:6e5,maxOutputBytes:67108864,maxMessageBytes:134217728,maxPendingCalls:128,maxParallelSubCalls:10,dispatchConcurrency:8,maxDispatchDepth:3,maxItemsPerCall:4096,graceMs:3e3,maxOldGenerationSizeMb:512,maxYoungGenerationSizeMb:64,poolSize:4,poolAcquireTimeoutMs:3e4,drainGraceMs:5e3}),Ce=Object.freeze([`PATH`,`PATHEXT`,`SYSTEMROOT`,`WINDIR`,`TEMP`,`TMP`]);function we(e=process.env){let t={};for(let n of Ce){let r=e[n];typeof r==`string`&&r.length>0&&(t[n]=r)}return t}function Te(e={}){let t={...R};for(let n of Object.keys(R)){let r=e[n];if(r!==void 0){if(typeof r!=`number`||!Number.isFinite(r)||r<=0)throw TypeError(`invalid PTC config override for ${n}: ${String(r)}`);t[n]=r}}return t}function Ee(e,t=R){return e===void 0||!Number.isFinite(e)||e<=0?t.timeoutMs:Math.min(e,t.maxTimeoutMs)}function De(){let e=/* @__PURE__ */ new Map;return{recordStart(t,n,r){if(e.has(t))throw Error(`duplicate sub-call callId ${t}`);e.set(t,{callId:t,name:n,args:r,status:`running`,startMs:Date.now()})},recordEnd(t,n,r){let i=e.get(t);if(i===void 0)throw Error(`recordEnd on unknown callId ${t}`);return i.status=n,i.endMs=Date.now(),i.durationMs=i.endMs-i.startMs,n===`rejected`&&(i.durationMs=0),r?.errorMessage!==void 0&&(i.errorMessage=r.errorMessage),r?.resultSummary!==void 0&&(i.resultSummary=r.resultSummary),i},snapshot(){return[...e.values()].map(e=>({...e}))}}}function Oe(e){return{name:`ptc-${e.surface}`,env:e.env,workerData:e.runId===void 0?{env:e.env}:{runId:e.runId,env:e.env},resourceLimits:{maxOldGenerationSizeMb:e.limits.maxOldGenerationSizeMb,maxYoungGenerationSizeMb:e.limits.maxYoungGenerationSizeMb}}}const z={acquireLatency:N.channel(`ptc:pool:acquire-latency`),resetTime:N.channel(`ptc:worker:reset-time`),imageBytes:N.channel(`ptc:image:hoist-bytes`)};function B(e,t){e.publish(t)}var ke=class{#e;#t;#n;#r;#i;#a=[];#o=/* @__PURE__ */ new Set;#s=[];#c=/* @__PURE__ */ new WeakMap;#l=0;#u=0;#d=!1;constructor(e){if(typeof e.buildWorkerUrl!=`function`)throw TypeError(`WorkerPool: buildWorkerUrl must be a function`);if(e.size!==void 0&&(typeof e.size!=`number`||!Number.isFinite(e.size)||e.size<=0))throw TypeError(`WorkerPool: size must be a positive finite number, received ${String(e.size)}`);if(e.acquireTimeoutMs!==void 0&&(typeof e.acquireTimeoutMs!=`number`||!Number.isFinite(e.acquireTimeoutMs)||e.acquireTimeoutMs<=0))throw TypeError(`WorkerPool: acquireTimeoutMs must be a positive finite number, received ${String(e.acquireTimeoutMs)}`);if(e.drainGraceMs!==void 0&&(typeof e.drainGraceMs!=`number`||!Number.isFinite(e.drainGraceMs)||e.drainGraceMs<=0))throw TypeError(`WorkerPool: drainGraceMs must be a positive finite number, received ${String(e.drainGraceMs)}`);this.#e=e.buildWorkerUrl,this.#t=e.size??4,this.#n=e.acquireTimeoutMs??3e4,this.#r=e.drainGraceMs??5e3,this.#i=e.workerOptions}async acquire(){if(this.#d)throw Error(`pool has been drained and can no longer serve workers`);this.#l+=1;let e=Date.now(),t=this.#a.shift();for(;t!==void 0&&!this.#p(t);)t=this.#a.shift();if(t!==void 0)return this.#o.add(t),t.ref(),B(z.acquireLatency,{poolSize:this.#t,waiters:this.#s.length,durationMs:Date.now()-e}),t;if(this.#o.size<this.#t){let t=this.#f();return this.#o.add(t),B(z.acquireLatency,{poolSize:this.#t,waiters:this.#s.length,durationMs:Date.now()-e}),t}return this.#u+=1,await new Promise((t,n)=>{let r=setTimeout(()=>{let e=this.#s.findIndex(e=>e.timer===r);e>=0&&this.#s.splice(e,1),n(/* @__PURE__ */ Error(`pool acquire timed out after ${this.#n} ms`))},this.#n);this.#s.push({resolve:t,reject:n,timer:r,startedAt:e})})}release(e){if(!this.#o.delete(e)||!this.#p(e))return;this.#c.set(e,Date.now());let t=this.#s.shift();if(t){clearTimeout(t.timer),this.#o.add(e),B(z.acquireLatency,{poolSize:this.#t,waiters:this.#s.length,durationMs:Date.now()-t.startedAt}),t.resolve(e);return}this.#a.push(e),e.unref()}lastSettledAt(e){return this.#c.get(e)}async drain(){for(;this.#s.length>0;){let e=this.#s.shift();if(!e)break;clearTimeout(e.timer),e.reject(/* @__PURE__ */ Error(`pool drained before acquire could be satisfied`))}let e=Date.now()+this.#r;for(;this.#o.size>0&&Date.now()<e;)await new Promise(e=>setTimeout(e,5));let t=[...this.#a,...this.#o];this.#a.length=0,this.#o.clear(),await Promise.all(t.map(e=>e.terminate().catch(()=>void 0))),this.#d=!0}stats(){return{resident:this.#o.size+this.#a.length,inFlight:this.#o.size,waiters:this.#s.length,totalAcquires:this.#l,poolExhaustions:this.#u}}#f(){let e=new M(this.#e(),this.#i);return e.once(`exit`,()=>{let t=this.#a.indexOf(e);if(t>=0){this.#a.splice(t,1);return}this.#o.delete(e)}),e}#p(e){return e.threadId!==-1}};function Ae(e){B(z.imageBytes,{byteLength:e})}function je(e){B(z.resetTime,{durationMs:e})}function Me(){let e=k(P(import.meta.url)),t=[ne(e,`worker.js`),ne(e,`worker-entry.ts`)];for(let e of t)if(w(e))return ie(e);throw Error(`worker entry not found; tried: ${t.join(`, `)}`)}function Ne(e){if(typeof e!=`object`||!e)return;let t=e;if(t.status!==`rejected`)return;let n=typeof t.errorMessage==`string`?t.errorMessage:t.started===!1?`dispatch refused`:`dispatch failed`;return{kind:t.started===!1?`refused`:`failed`,message:n}}function V(e){return e instanceof Error?e.message:String(e)}function Pe(e){if(typeof e!=`object`||!e)return;let t=e.content;if(Array.isArray(t)&&t.length>0){let e=t[0];if(typeof e==`object`&&e){let t=e.text;if(typeof t==`string`&&t.length>0){let e=t.indexOf(`
+`);return e===-1?t:t.slice(0,e)}}}}function Fe(e){return e instanceof ArrayBuffer||ArrayBuffer.isView(e)}function Ie(e,t){let n=/* @__PURE__ */ new WeakSet,r=e=>{if(e!=null){if(e instanceof ArrayBuffer){t(e);return}if(ArrayBuffer.isView(e)){t(e);return}if(typeof e==`object`&&!n.has(e)){if(n.add(e),Array.isArray(e)){for(let t of e)r(t);return}for(let t of Object.keys(e))r(e[t])}}};r(e)}function Le(e){try{let t=Buffer.byteLength(JSON.stringify(e,(e,t)=>Fe(t)?null:t)??``,`utf8`),n=0;return Ie(e,e=>{n+=e.byteLength}),t+n}catch{return 1/0}}async function Re(e){let i=Te(e.config),s=we(),c=e.runId??j(),l=Ee(e.timeoutMs,i),u=[],d=[],f=[];if(e.signal?.aborted)return{logs:u,narrations:d,phases:f,error:{kind:n.abort,message:`run cancelled before start`}};let p;try{p=e.pool?await e.pool.acquire():new M(Me(),Oe({surface:e.surface,env:s,limits:i,runId:c}))}catch(e){return{logs:u,narrations:d,phases:f,error:{kind:n.workerExit,message:`pool acquire failed: ${V(e)}`}}}return await new Promise(s=>{let m=new re,h=m.port1,g=m.port2,_=new AbortController,v=!1,y=De(),b=()=>{v||e.onSubCallChange?.(()=>y.snapshot())},x={recordStart(e,t,n){y.recordStart(e,t,n),b()},recordEnd(e,t,n){let r=y.recordEnd(e,t,n);return b(),r},snapshot:()=>y.snapshot()},S,ee=!1,C=0,w=0,T=0,E=0,D=[],te=e.depth??0,O,k,A=[],ne=e=>{let t=[],n=e?.content;if(!Array.isArray(n))return t;for(let e of n){if(typeof e!=`object`||!e)continue;let n=e;if(n.type!==`image`)continue;let r;typeof n.data==`string`&&n.data.length>0?r=n.data:n.bytes instanceof ArrayBuffer&&n.bytes.byteLength>0&&(r=Buffer.from(n.bytes).toString(`base64`)),r!==void 0&&t.push({data:r,mimeType:typeof n.mimeType==`string`?n.mimeType:`application/octet-stream`})}return t},j=e=>e===`timeout`?`run timed out after ${l} ms`:`run cancelled`,M=e=>e===`timeout`?n.timeout:n.abort,N=t=>{if(v)return;v=!0,O&&clearTimeout(O),k&&clearTimeout(k),e.signal?.removeEventListener(`abort`,pe),_.abort(),h.close(),e.pool?e.pool.release(p):p.terminate();let n=x.snapshot();s(n.length>0?{...t,subCalls:n}:t)},P=(e,t,n)=>{N({logs:u,narrations:d,phases:f,error:n===void 0?{kind:e,message:t}:{kind:e,message:t,stack:n}})},ie=e=>{if(!v){if(!r(e)){P(n.protocol,`internal error: malformed host frame`);return}h.postMessage(e)}},ae=()=>{let t={kind:o.init,runId:c,surface:e.surface,code:e.code,bindings:[...e.bindings.keys()],bindingCandidates:[...L],maxItemsPerCall:i.maxItemsPerCall,maxPendingCalls:i.maxPendingCalls,...e.args===void 0?{}:{args:e.args}};if(!r(t)){P(n.protocol,`internal error: malformed init frame`);return}let a=Le(t);if(a>i.maxMessageBytes){P(n.protocol,`init frame of ${a} bytes exceeds maxMessageBytes (${i.maxMessageBytes})`);return}ie(t)},F=(e,t)=>(w+=e,w<=i.maxOutputBytes||(P(n.outputLimit,`${t} exceeded the output budget: logs + result reached ${w} bytes (maxOutputBytes=${i.maxOutputBytes}); ${u.length} log line(s) retained`),!1)),oe=async()=>{if(E<i.maxParallelSubCalls){E+=1;return}await new Promise(e=>{D.push(e)})},se=()=>{let e=D.shift();if(e){e();return}--E},le=e=>{if(x.recordStart(e.callId,e.tool,e.args),C+=1,C>i.maxPendingCalls){x.recordEnd(e.callId,`error`,{errorMessage:`more than maxPendingCalls (${i.maxPendingCalls}) binding calls in flight`}),P(n.protocol,`more than maxPendingCalls (${i.maxPendingCalls}) binding calls in flight`);return}ue(e).finally(()=>{--C})},ue=async t=>{let r=e.bindings.get(t.tool);if(!r){x.recordEnd(t.callId,`error`,{errorMessage:`no binding named "${t.tool}" in this run; available bindings: `+([...e.bindings.keys()].join(`, `)||`(none)`)}),I({kind:o.callResult,callId:t.callId,tool:t.tool,ok:!1,message:`no binding named "${t.tool}" in this run; available bindings: `+([...e.bindings.keys()].join(`, `)||`(none)`)});return}let a=t.tool===ye;if(a){if(T>=i.dispatchConcurrency){x.recordEnd(t.callId,`rejected`,{errorMessage:`dispatch concurrency limit reached`}),I({kind:o.callResult,callId:t.callId,tool:t.tool,ok:!0,value:ce()});return}T+=1}else if(await oe(),v){x.recordEnd(t.callId,`cancelled`,{errorMessage:`run settled before binding started`}),se();return}try{let e=await r.execute(t.args,{signal:_.signal,callId:t.callId,depth:te,maxDispatchDepth:i.maxDispatchDepth}),s=ne(e),c={kind:o.callResult,callId:t.callId,tool:t.tool,ok:!0,value:e},l=Le(c);if(l>i.maxMessageBytes){x.recordEnd(t.callId,`error`,{errorMessage:`callResult frame of ${l} bytes exceeds maxMessageBytes (${i.maxMessageBytes})`}),P(n.protocol,`callResult frame of ${l} bytes exceeds maxMessageBytes (${i.maxMessageBytes})`);return}if(I(c))for(let e of s)A.push(e),Ae(Buffer.byteLength(e.data,`base64`));if(_.signal.aborted)x.recordEnd(t.callId,`cancelled`,{errorMessage:`binding aborted by run cancellation`});else{let n=a?Ne(e):void 0;n===void 0?x.recordEnd(t.callId,`ok`,{resultSummary:Pe(e)}):x.recordEnd(t.callId,n.kind===`refused`?`rejected`:`error`,{errorMessage:n.message})}}catch(e){_.signal.aborted?x.recordEnd(t.callId,`cancelled`,{errorMessage:V(e)}):x.recordEnd(t.callId,`error`,{errorMessage:V(e)}),I({kind:o.callResult,callId:t.callId,tool:t.tool,ok:!1,message:V(e)})}finally{a?--T:se()}},I=e=>{if(v)return!1;try{return h.postMessage(e),!0}catch(t){try{h.postMessage({kind:o.callResult,callId:e.callId,tool:e.tool,ok:!1,message:`binding result could not be transferred: ${V(t)}`})}catch{P(n.protocol,`binding result is not transferable`)}return!1}},de=e=>S?{logs:u,narrations:d,phases:f,error:{kind:M(S),message:j(S)}}:e,fe=r=>{if(v)return;if(!a(r)){P(n.protocol,`malformed worker frame`);return}let o=r.kind===t.ready?0:Le(r);if(!Number.isFinite(o)){P(n.protocol,`worker frame could not be serialized for accounting`);return}if(o>i.maxMessageBytes){P(n.protocol,`control frame of ${o} bytes exceeds maxMessageBytes (${i.maxMessageBytes})`);return}switch(r.kind){case t.ready:if(e.pool){let t=e.pool.lastSettledAt(p);t!==void 0&&je(Date.now()-t)}if(!ee&&(ee=!0,S)){me(S);return}ae();return;case t.call:le(r);return;case t.log:F(o,`console output`)&&u.push(r.text);return;case t.narration:F(o,`workflow narration`)&&d.push(r.message);return;case t.phase:F(o,`workflow phase`)&&f.push(r.title);return;case t.result:{if(!F(o,`completion value`))return;let e={logs:u,narrations:d,phases:f,...A.length>0?{images:A}:{}};N(de(r.value===void 0?e:{...e,value:r.value}));return}case t.error:N(de({logs:u,narrations:d,phases:f,error:r.error}));return;default:P(n.protocol,`unknown worker frame`)}};function pe(){he(`abort`)}let me=e=>{k&&clearTimeout(k),k=setTimeout(()=>{P(M(e),j(e))},i.graceMs)};function he(e){if(!v){if(S){P(M(S),j(S));return}S=e,_.abort(),ie({kind:o.cancel,reason:e}),me(e)}}p.on(`error`,e=>{P(n.workerExit,`worker failed: ${V(e)}`)}),p.on(`exit`,e=>{P(n.workerExit,`worker exited with code ${e} before the run completed`)}),h.on(`message`,fe),h.on(`messageerror`,()=>{P(n.protocol,`worker sent a frame that could not be deserialized`)}),e.signal?.addEventListener(`abort`,pe,{once:!0}),O=setTimeout(()=>{he(`timeout`)},l);let ge={kind:o.connect,port:g};r(ge)?p.postMessage(ge,[g]):P(n.protocol,`internal error: malformed connect frame`)})}const ze=200,Be=new RegExp([`(?:\\u001B\\][\\s\\S]*?(?:\\u0007|\\u001B\\u005C|\\u009C))`,`[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]`].join(`|`),`g`);function Ve(e){return!e.includes(`\x1B`)&&!e.includes(`›`)?e:e.replace(Be,``)}function H(e){let t=Ve(e).replace(/\r/g,``);if(t.length===0)return t;let n=``;for(let e of t){let t=e.codePointAt(0);if(t!==void 0){if(t===10||t===9){n+=e;continue}t<=31||t>=65529&&t<=65531||(n+=e)}}return n}const He=/^[A-Za-z_$][A-Za-z0-9_$]*$/;function U(e){return He.test(e)?e:JSON.stringify(e)}function Ue(e){if(e===null)return`null`;if(typeof e==`number`||typeof e==`boolean`)return String(e);if(typeof e==`string`){let t=H(e);return t.includes(`
+`)?void 0:JSON.stringify(t)}if(Array.isArray(e)){let t=[];for(let n of e){let e=Ue(n);if(e===void 0)return;t.push(e)}return`[${t.join(`, `)}]`}let t=Object.keys(e);if(t.length===0)return`{}`;let n=[];for(let r of t){let t=Ue(e[r]??null);if(t===void 0)return;n.push(`${U(r)}: ${t}`)}return`{${n.join(`, `)}}`}function We(e){let t=Ue(e);if(t!==void 0)return t.length<=100?t:void 0}function Ge(e){return e===null?`null`:typeof e==`string`?H(e):String(e)}function Ke(e,t){if(typeof e!=`object`||!e)return[`${t}${Ge(e)}`];if(Array.isArray(e)){if(e.length===0)return[`${t}[]`];let n=[`${t}[`];for(let r of e){let e=We(r);if(e!==void 0){n.push(`${t}  ${e}`);continue}n.push(...qe(r,t+`  `))}return n.push(`${t}]`),n}let n=Object.keys(e);if(n.length===0)return[`${t}{}`];let r=[`${t}{`],i=t+`  `;for(let t of n){let n=e[t]??null,a=We(n);if(a!==void 0){r.push(`${i}${U(t)}: ${a}`);continue}if(typeof n==`string`){r.push(`${i}${U(t)}:`);for(let e of H(n).split(`
+`))r.push(e.length===0?``:`${i}  ${e}`);continue}let o=Ke(n,i);r.push(`${i}${U(t)}: ${(o[0]??``).trimStart()}`.trimEnd(),...o.slice(1))}return r.push(`${t}}`),r}function qe(e,t){return typeof e==`string`?H(e).split(`
+`):typeof e!=`object`||!e?[String(e)]:Ke(e,t)}function Je(e){return e.split(`
+`).map(e=>e.length>200?`${e.slice(0,199)}…`:e).join(`
+`)}function Ye(e){if(typeof e==`string`)return Je(H(e));if(typeof e!=`object`||!e)return String(e);let t=We(e);return Je((t===void 0?qe(e,``):[t]).join(`
+`))}function Xe(e=process.env){let t=e.PI_PTC_DEPTH;return t===void 0||!/^\d+$/.test(t)?0:Number.parseInt(t,10)}function W(e){if(e===void 0)return L;let t=new Set(e);return L.filter(e=>t.has(e))}const Ze=["Image-bearing tool results inside a program (a `tools.read` on a PNG, say) are attached to you after the run — never return image data as the completion value.",`Use ptc_run_code when a task needs several tool calls whose intermediate output you do not need to see — gather it inside the program and return only the final value.`,`Use ptc_workflow instead of ptc_run_code when the work has named phases and the user benefits from seeing progress narration.`],Qe={run_code:`ptc_run_code`,workflow:`ptc_workflow`};function $e(e){let t=e?.cwd;return typeof t==`string`&&t.length>0?t:process.cwd()}function et(e){let{surface:t,startedAt:n,onUpdate:r}=e;if(r===void 0)return{update:()=>{},cancel:()=>{}};let i=0,a,o,s=()=>{if(o===void 0)return;let e=o;o=void 0,i=Date.now(),r({content:[],details:{surface:t,logs:[],narrations:[],phases:[],warnings:[],durationMs:Date.now()-n,imageCount:0,subCalls:e()}})};return{update(e){o=e;let t=100-(Date.now()-i);if(t<=0){a!==void 0&&(clearTimeout(a),a=void 0),s();return}a??=setTimeout(()=>{a=void 0,s()},t)},cancel(){a!==void 0&&(clearTimeout(a),a=void 0),o=void 0}}}function tt(e){return[...e.phases.map(e=>`[phase] ${H(e)}`),...e.narrations.map(e=>`[log] ${H(e)}`),...e.logs.map(e=>H(e))]}function nt(e){let t=e.error;if(t===void 0)return/* @__PURE__ */ Error(`internal error: a successful PTC run was rendered as a failure`);let n=tt(e),r=n.length===0?``:`\nCaptured output:\n${n.join(`
+`)}`,i=Error(H(`code run failed (${t.kind}): ${t.message}${r}`));return i.name=`CodeRunFailedError`,i}function rt(e){let t=A(te(),`pi-ptc-output-${j()}.txt`);return E(t,e,`utf8`),t}function it(e,t){let n=e.totalLines-e.outputLines+1,r=e.totalLines;return e.lastLinePartial?`[Showing last ${_(e.outputBytes)} of line ${r}. Full output: ${t}]`:e.truncatedBy===`lines`?`[Showing lines ${n}-${r} of ${e.totalLines}. Full output: ${t}]`:`[Showing lines ${n}-${r} of ${e.totalLines} (${_(s)} limit). Full output: ${t}]`}function at(e){let{outcome:t,surface:n}=e,r=[...e.warnings??[]],i=t.images??[],a=[];t.phases.length>0&&a.push(`Phases: ${t.phases.map(e=>H(e)).join(` → `)}`),t.narrations.length>0&&a.push(t.narrations.map(e=>H(e)).join(`
+`)),t.logs.length>0&&a.push(t.logs.map(e=>H(e)).join(`
+`)),t.value!==void 0&&a.push(Ye(t.value));for(let e of r)a.push(`Warning: ${H(e)}`);let o=a.length>0?a.join(`
+`):`(${Qe[n]} completed with no output)`,l=b(o,{maxLines:c,maxBytes:s}),u,d=l.content;return l.truncated&&(u=rt(o),d+=`\n\n${it(l,u)}`),{content:[{type:`text`,text:d},...i.map(e=>({type:`image`,data:e.data,mimeType:e.mimeType}))],details:{surface:n,logs:[...t.logs],narrations:[...t.narrations],phases:[...t.phases],warnings:r,...t.value===void 0?{}:{result:t.value},durationMs:e.durationMs,imageCount:i.length,...u===void 0?{}:{fullOutputPath:u},...t.subCalls===void 0?{}:{subCalls:t.subCalls}}}}const ot=/^(.*?)(└─ |├─ |   )(?:PTC(?: workflow)?)([ ].*)$/;function st(e){return e.replace(/\x1b\[[0-9;]*m|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b\[\?[0-9;]*[a-zA-Z]/g,``)}function ct(e,t){if(e.charCodeAt(t)!==27)return t;let n=e.charCodeAt(t+1);if(n===93){let n=t+2;for(;n<e.length;){let t=e.charCodeAt(n);if(t===7)return n+1;if(t===27&&e.charCodeAt(n+1)===92)return n+2;n+=1}return n}if(n===91){let n=t+2;for(;n<e.length;){let t=e.charCodeAt(n);if(t>=64&&t<=126)return n+1;n+=1}return n}return t+2}function lt(e,t){let n=0,r=0;for(;r<t&&n<e.length;)e.charCodeAt(n)===27?n=ct(e,n):(n+=1,r+=1);return n}function ut(e,t){let n=t.intervalMs??150,{state:r}=t;t.isPartial?(r.startedAt??=Date.now(),r.interval??=setInterval(()=>t.requestInvalidate(),n)):(r.interval!==void 0&&(clearInterval(r.interval),r.interval=void 0),r.startedAt=void 0);let i=e.render.bind(e),a=e;return a.render=e=>{let a=i(e);return r.startedAt===void 0?a:dt(a,Math.floor((Date.now()-r.startedAt)/n),t.theme)},a.dispose=()=>{r.interval!==void 0&&(clearInterval(r.interval),r.interval=void 0)},e}function dt(e,t,n){return e.map(e=>{let r=st(e),i=ot.exec(r);if(i===null)return e;let a=(i[3]??``).slice(1);if(a.length===0)return e;let o=t%(a.length+1),s=i[0].length-a.length,c=lt(e,s),l=lt(e,s+a.length),u=o>=a.length?n.fg(`dim`,a):`${o>0?n.fg(`dim`,a.slice(0,o)):``}${n.fg(`accent`,a.slice(o,o+1))}${n.fg(`dim`,a.slice(o+1))}`;return`${e.slice(0,c)}${u}${e.slice(l)}`})}const ft={run_code:`PTC`,workflow:`PTC workflow`};var G=class{items;constructor(e){this.items=e}invalidate(){}render(e){let t=Math.max(1,Math.floor(e));return this.items.map(e=>pt(e,t))}};function pt(e,t){let{left:n,right:r}=e;if(r===void 0)return ae(n,t,`…`);let i=F(r);if(i>=t)return ae(r,t,`…`);let a=ae(n,Math.max(0,t-i-1),`…`),o=Math.max(1,t-i-F(a));return a+` `.repeat(o)+r}function K(e,t){return e.length>t?`${e.slice(0,t-1)}…`:e}function mt(e){return K((H(e).split(`
+`).find(e=>e.trim().length>0)??``).trim(),120)}function ht(e){return e<1e3?`${e}ms`:`${(e/1e3).toFixed(2).replace(/\.?0+$/,``)}s`}function q(e,t){return`${e} ${t}${e===1?``:`s`}`}function gt(e){for(let t of e.split(`
+`)){let e=t.trim();if(e.length!==0&&!e.startsWith(`//`)&&!e.startsWith(`/*`)&&!e.startsWith(`*`))return K(e.replace(/\s*\/\/.*$/,``),120)}}function _t(e){if(e===void 0)return;if(typeof e==`string`){let t=H(e).split(`
+`),n=t.find(e=>e.trim().length>0)?.trim()??``,r=t.length>1?` (+${t.length-1} lines)`:``;return n.length===0&&r.length===0?`""`:K(n,60)+r}if(typeof e!=`object`||!e)return String(e);let t=Ye(e);if(!t.includes(`
+`)&&t.length<=60)return t;if(Array.isArray(e))return`Array(${e.length})`;let n=Object.keys(e);return n.length===0?`{}`:`{${n.slice(0,4).join(`, `)}${n.length>4?`, +${n.length-4}`:``}}`}function vt(e,t){if(e===void 0)return;let n=[],r=e.logs.length+e.narrations.length;if(r>0&&n.push(t.fg(`dim`,q(r,`output line`))),e.imageCount>0&&n.push(t.fg(`toolOutput`,q(e.imageCount,`image`))),e.surface===`workflow`&&e.phases.length>0&&n.push(t.fg(`dim`,q(e.phases.length,`phase`))),e.warnings.length>0&&n.push(t.fg(`warning`,q(e.warnings.length,`warning`))),e.fullOutputPath!==void 0&&n.push(t.fg(`warning`,`truncated`)),e.durationMs>0&&n.push(t.fg(`dim`,ht(e.durationMs))),n.length!==0)return`${t.fg(`dim`,`•`)} ${n.join(t.fg(`dim`,` · `))}`}function yt(e){if(e!==void 0)return{surface:e.surface??`run_code`,logs:e.logs??[],narrations:e.narrations??[],phases:e.phases??[],warnings:e.warnings??[],durationMs:e.durationMs??0,imageCount:e.imageCount??0,...e.result===void 0?{}:{result:e.result},...e.fullOutputPath===void 0?{}:{fullOutputPath:e.fullOutputPath},...e.subCalls===void 0?{}:{subCalls:e.subCalls}}}function bt(e,t,n){let r=`   `+(t?`└─ `:`├─ `),i=`   `+(t?`   `:`│  `),a=` `.repeat(8),o=[],s=e.lines[0]??``;o.push({left:`${r}${e.label.padEnd(8)}${n.fg(`dim`,s)}`});for(let t=1;t<e.lines.length;t++)o.push({left:`${i}${a}${n.fg(`dim`,e.lines[t]??``)}`});return e.more!==void 0&&e.more>0&&o.push({left:`${i}${a}…+${e.more} more lines`}),o}function xt(e){return typeof e!=`object`||!e?!1:Array.isArray(e)?e.length>0:Object.keys(e).length>0}const St=/^[A-Za-z_$][A-Za-z0-9_$]*$/;function Ct(e){return St.test(e)?e:JSON.stringify(e)}function J(e,t){if(e===null)return`null`;if(typeof e==`boolean`||typeof e==`number`)return String(e);if(typeof e==`string`){let n=H(e);if(n.length===0)return`""`;if(n.includes(`
+`)){let e=K(n.replace(/\n/g,` `),Math.max(2,t-5));return JSON.stringify(e)+`…`}return n.length+2<=t?JSON.stringify(n):JSON.stringify(K(n,Math.max(2,t-5)))+`…`}return`?`}function wt(e){return typeof e!=`object`||!e}function Tt(e,t){if(t<8)return;if(Array.isArray(e)){if(e.length===0)return`[]`;if(e.length>5||!e.every(wt))return;let n=`[`+e.map(e=>J(e,Math.max(2,Math.floor(t/4)))).join(`, `)+`]`;return n.length<=t?n:void 0}if(typeof e!=`object`||!e)return;let n=Object.keys(e);if(n.length===0)return`{}`;if(n.length>5||!Object.values(e).every(wt))return;let r=`{`+n.map(n=>{let r=e[n]??null;return Ct(n)+`: `+J(r,Math.max(2,Math.floor(t/4)))}).join(`, `)+`}`;return r.length<=t?r:void 0}function Y(e,t,n,r,i,a,o,s,c){let l=n+(r?`└─ `:`├─ `),u=n+(r?`   `:`│  `);if(s>=i){c.push(X(l+t+`…`,o));return}if(Array.isArray(e)&&e.length===0){c.push(X(l+t+`[]`,o));return}if(!Array.isArray(e)&&typeof e==`object`&&e&&Object.keys(e).length===0){c.push(X(l+t+`{}`,o));return}if(typeof e!=`object`||!e){let n=Math.max(0,o-F(l)-t.length);c.push(X(l+t+J(e,n),o));return}let d=Tt(e,Math.max(0,o-F(l)-t.length));if(d!==void 0){c.push(X(l+t+d,o));return}let f=Array.isArray(e),p=f?e.length:Object.keys(e).length,m;m=f?`Array(`+p+`)`:p>a?`{`+a+` of `+p+`}`:`{`+p+` keys}`,c.push(X(l+t+m,o));let h=Math.min(a,p);if(f)for(let t=0;t<h;t+=1){let n=t===h-1&&p<=h;Y(e[t]??null,`[`+t+`] `,u,n,i,a,o,s+1,c)}else{let t=Object.keys(e);for(let n=0;n<h;n+=1){let r=n===h-1&&p<=h,l=t[n];Y(e[l]??null,Ct(l)+`: `,u,r,i,a,o,s+1,c)}}if(p>h){let e=f?`items`:`keys`;c.push(X(u+`└─ …+`+(p-h)+` more `+e,o))}}function X(e,t){if(F(e)<=t)return e;let n=e.match(/^([\s│├└─]*)/),r=n&&n[1]?n[1]:``,i=F(r),a=Math.max(0,t-i-1),o=``,s=0;for(let t of e.slice(r.length)){let e=F(t);if(s+e>a)break;o+=t,s+=e}return r+o+`…`}function Et(e,t={}){let n=t.maxDepth??4,r=t.maxChildren??6,i=t.maxLineChars??120,a=t.moreAfter===!0;if(!xt(e))return typeof e==`object`&&e?[Array.isArray(e)?`[]`:`{}`]:[J(e,i)];let o=[];if(Array.isArray(e)){let t=e.length,s=Math.min(r,t);for(let c=0;c<s;c+=1){let l=!a&&c===s-1&&t<=s;Y(e[c]??null,`[`+c+`] `,``,l,n,r,i,0,o)}return t>s&&o.push((a?`├─ `:`└─ `)+`…+`+(t-s)+` more items`),o}let s=Object.keys(e),c=s.length,l=Math.min(r,c);for(let t=0;t<l;t+=1){let u=!a&&t===l-1&&c<=l,d=s[t];Y(e[d]??null,Ct(d)+`: `,``,u,n,r,i,0,o)}return c>l&&o.push((a?`├─ `:`└─ `)+`…+`+(c-l)+` more keys`),o}function Dt(e,t,n=`run_code`,r={}){let i=(typeof e.description==`string`&&e.description.trim().length>0?e.description.trim():e.meta?.name)??``,a=gt(e.code??e.script??``),o=i.length>0?i:a??`(no description)`;return ut(new G([{left:`└─ ${`${t.fg(`toolTitle`,t.bold(ft[n]))} ${t.fg(`accent`,o)}`}`}]),{intervalMs:150,isPartial:r.isPartial??!1,theme:t,requestInvalidate:r.requestInvalidate??Ot,state:r.state??{}})}function Ot(){}function kt(e){let t=e.content?.find(e=>e.type===`text`&&(e.text??``).length>0);return mt(t?.text??``)||`failed`}function At(e,t){if(e===`pi.dispatch`&&typeof t==`object`&&t&&`agent`in t)return`→ ${String(t.agent)}`;if(typeof t==`object`&&t){let n=t,r=e=>typeof n[e]==`string`?n[e]:void 0,i=e===`read`?r(`path`):e===`bash`?r(`command`):e===`grep`||e===`find`?r(`pattern`):e===`ls`||e===`edit`||e===`write`?r(`path`):void 0;if(typeof i==`string`)return i}try{let e=JSON.stringify(t).replace(/\n/g,` `);return e.length>40?`${e.slice(0,39)}…`:e}catch{return String(t).slice(0,40)}}const jt={running:{text:()=>`running`,themeSlot:`muted`},ok:{text:e=>e.durationMs===void 0?`ok`:`ok ${ht(e.durationMs)}`,themeSlot:`accent`},error:{text:e=>`failed: ${e.errorMessage??`error`}`,themeSlot:`error`},cancelled:{text:()=>`cancelled`,themeSlot:`muted`},rejected:{text:e=>`rejected: ${e.errorMessage??`concurrency`}`,themeSlot:`warning`}};function Mt(e,t){if(e.length===0)return[];let n=e.slice(0,32),r=e.length>32?e.length-32:0,i=[];return n.forEach((e,a)=>{let o=a===n.length-1&&r===0?`└─ `:`├─ `,s=e.name.length>=8?`${e.name} `:e.name.padEnd(8),c=At(e.name,e.args),l=jt[e.status];i.push({left:`   ${o}${t.fg(`toolTitle`,s)}${t.fg(l.themeSlot,l.text(e))}${t.fg(`dim`,` `+c)}`})}),r>0&&i.push({left:`   └─ …+${r} more calls`}),i}function Nt(e,t,n,r=!1,i=!1){let a=vt(e.details,n),o=e=>a===void 0?e:{...e,right:a};if(t)return[o({left:`   ${n.fg(`error`,`failed: ${kt(e)}`)}`})];if(i&&e.details?.result===void 0)return[];let s=e.details?.result;if(s===void 0)return[o({left:`   ${n.fg(`muted`,`done`)}`})];if(xt(s))return Et(s,{maxDepth:4,maxChildren:6,maxLineChars:120,moreAfter:r}).map((e,t)=>{let n={left:`   ${e}`};return t===0&&a!==void 0?{...n,right:a}:n});let c=_t(s);return c===void 0?[o({left:`   ${n.fg(`muted`,`done`)}`})]:[o({left:`   ${n.fg(`dim`,`→ ${c}`)}`})]}function Pt(e,t,n,r={}){let i=yt(e.details),a=[...Nt({...e,details:i},t,n,!1,r.isPartial===!0)];return i?.subCalls!==void 0&&a.push(...Mt(i.subCalls,n)),new G(a)}function Ft(e,t,n,r,i={}){let a=yt(e.details);if(n){let t=[...Nt({...e,details:a},!0,r)];a?.subCalls!==void 0&&t.push(...Mt(a.subCalls,r));let n=H(e.content?.find(e=>e.type===`text`)?.text??kt(e));for(let e of n.split(`
+`).slice(0,12))t.push({left:`   ${r.fg(`error`,e)}`});return new G(t)}let o=[],s=t.code??t.script??``;if(s.length>0){let e=s.split(`
+`).map(e=>K(e,120)),t=e.slice(0,3);o.push({label:`code`,lines:t,...e.length>t.length?{more:e.length-t.length}:{}})}if(a!==void 0&&a.surface===`workflow`&&a.phases.length>0){let e=a.phases.slice(0,8),t=a.phases.length>e.length?` …`:``;o.push({label:`phases`,lines:[`${e.join(` → `)}${t}`]})}if(a!==void 0&&a.narrations.length>0){let e=a.narrations.slice(0,12);o.push({label:`log`,lines:e.map(e=>H(e)),...a.narrations.length>e.length?{more:a.narrations.length-e.length}:{}})}if(a!==void 0&&a.logs.length>0){let e=a.logs.slice(0,12);o.push({label:`out`,lines:e.map(e=>H(e)),...a.logs.length>e.length?{more:a.logs.length-e.length}:{}})}if(a!==void 0&&a.warnings.length>0){let e=a.warnings.slice(0,4);o.push({label:`warn`,lines:e.map(e=>H(e)),...a.warnings.length>e.length?{more:a.warnings.length-e.length}:{}})}if(a!==void 0&&a.imageCount>0){let e=a.imageCount===1?`1 image attached`:`${a.imageCount} images attached`;o.push({label:`image`,lines:[e]})}let c=a?.subCalls,l=c!==void 0&&c.length>0||o.length>0,u=Nt({...e,details:a},!1,r,l,i.isPartial===!0);c!==void 0&&u.push(...Mt(c,r));for(let e=0;e<o.length;e+=1){let t=e===o.length-1;u.push(...bt(o[e]??{label:``,lines:[]},t,r))}return new G(u)}function It(e){return{renderCall(t,n,r){return Dt(t,n,e,{...r?.invalidate===void 0?{}:{requestInvalidate:r.invalidate},...r?.isPartial===void 0?{}:{isPartial:r.isPartial},...r?.state===void 0?{}:{state:r.state}})},renderResult(e,t,n,r){let i=t.isPartial===!0;return t.expanded===!0?Ft(e,r?.args??{},r?.isError===!0,n,{isPartial:i}):Pt(e,r?.isError===!0,n,{isPartial:i})}}}const Lt=["Run a TypeScript program that composes pi's tools in one shot. Required arguments: `code` —","the body of an async function (top-level `return` and `await` work; type annotations are","advisory, the code runs type-stripped) — and `description`, a 5-10 word summary of what the",`program does.`,``,"Inside the program, call this session's enabled built-in tools as `tools.<name>(args)` — e.g.",'`await tools.read({ path: "src/index.ts" })` or `await tools.bash({ command: "npm test" })`.',"The bound names mirror the session's active tools (a default session has `read`, `bash`, `edit`,","`write`); calling a name that is not bound rejects with an error the program can catch, and","independent calls may overlap under `Promise.all`.",``,"Only the program's return value and its `console.log` output come back. This surface has no","helpers: `log` / `phase` / `parallel` / `pipeline` exist only in `ptc_workflow`.",``,"Image-bearing tool results inside the program (a `tools.read` on a PNG, say) are attached to you",`after the run, so never return image data as the completion value — that only spends your context`,`on base64.`].join(`
+`),Rt=x.Object({code:x.String({description:`The program: the body of an async TypeScript function.`}),description:x.String({description:`Clear, concise description of what this program does in active voice, 5-10 words (shown in the UI).`}),timeoutMs:x.Optional(x.Number({description:`Elapsed deadline in milliseconds for the whole run, including tool calls. Omit it (or pass 0) for the default of ${R.timeoutMs/1e3} s; anything above ${R.maxTimeoutMs/1e3} s is capped.`}))});function zt(e={}){return g({name:`ptc_run_code`,label:`PTC Run Code`,description:Lt,promptSnippet:`Run a TypeScript program that composes pi's tools in one shot (tools.<name>(args)); only its return value and console.log come back`,promptGuidelines:[...Ze],parameters:Rt,async execute(t,n,r,i,a){let o=$e(a),s=W(e.getBindingSourceNames?.()),c=Date.now(),l=e.getPool?.(),u=et({surface:`run_code`,startedAt:c,onUpdate:i}),d;try{d=await Re({code:n.code,surface:`run_code`,cwd:o,bindings:Se({cwd:o,names:s,includeDispatch:!0}),...e.depth===void 0?{}:{depth:e.depth},...n.timeoutMs===void 0?{}:{timeoutMs:n.timeoutMs},...r===void 0?{}:{signal:r},...e.config===void 0?{}:{config:e.config},...l===void 0?{}:{pool:l},onSubCallChange:e=>u.update(e)})}finally{u.cancel()}if(d.error!==void 0)throw nt(d);return at({outcome:d,surface:`run_code`,durationMs:Date.now()-c})},...It(`run_code`)})}const Bt=[`Run a structured TypeScript workflow: a named plan that reports phases and narration as it`,"goes. `script` is the body of an async function, `meta` names it (`{ name, description, phases? }`,","where `phases` is the ordered plan), and optional `args` is plain-JSON input bound to the","program's `args` global.",``,"Helpers inside the script: `log(message)` narrates progress; `phase(title)` frames the workflow","(titles outside `meta.phases` are reported as warnings); `parallel(thunks)` runs thunks","concurrently, a failed item becoming `null`; `pipeline(items, ...stages)` chains stages per item","with the same per-item `null` on failure. There is no `agent()` helper.",``,"Tools are reachable as `tools.<name>(args)` exactly as in `ptc_run_code`, and the bound names",`mirror the session's enabled tools. What comes back is the script's return value, its`,"`log`/`phase` narration and its `console.log` output.",``,`Image-bearing tool results inside the script are attached to you after the run — never return`,`image data as the script's value.`].join(`
+`),Vt=x.Object({meta:x.Object({name:x.String({description:`Short workflow name, shown in the UI.`}),description:x.String({description:`What this workflow does, in active voice.`}),phases:x.Optional(x.Array(x.Object({name:x.String({description:`Phase title, matched against phase(title) calls.`})}),{description:`Ordered plan of the workflow's phases. phase() titles outside this list are reported as warnings.`}))},{description:`Workflow metadata: what this run is and which phases it declares.`}),script:x.String({description:`The program: the body of an async TypeScript function.`}),args:x.Optional(x.Record(x.String(),x.Unknown(),{description:"Plain-JSON input bound to the program's `args` global. No functions, symbols, undefined values or cycles."}))});function Ht(t){if(t!==void 0){if(typeof t!=`object`||!t||Array.isArray(t))throw TypeError(`ptc_workflow args must be a plain JSON object, received ${e(t)}`);for(let e of Object.keys(t)){let n=Ut(t[e],`args.${e}`,/* @__PURE__ */ new Set);if(n!==void 0)throw TypeError(`ptc_workflow args must be plain JSON: ${n}`)}}}function Ut(t,n,r){if(t===null||typeof t==`string`||typeof t==`boolean`)return;if(t===void 0)return`${n} is undefined`;if(typeof t==`number`)return Number.isFinite(t)?void 0:`${n} is ${String(t)}, which is not representable as JSON`;if(typeof t!=`object`)return`${n} is ${e(t)}`;let i=t;if(r.has(i))return`${n} is a circular reference`;r.add(i);try{if(Array.isArray(i)){for(let e=0;e<i.length;e+=1){let t=Ut(i[e],`${n}[${e}]`,r);if(t!==void 0)return t}return}let e=Object.getPrototypeOf(i);if(e!==Object.prototype&&e!==null){let e=i.constructor?.name;return`${n} is a ${typeof e==`string`&&e.length>0?e:`non-plain object`}, not plain JSON`}for(let e of Object.keys(i)){let t=Ut(i[e],`${n}.${e}`,r);if(t!==void 0)return t}return}finally{r.delete(i)}}function Wt(e,t){if(t===void 0||t.length===0)return[];let n=new Set(t),r=/* @__PURE__ */ new Set,i=[];for(let t of e.phases)n.has(t)||r.has(t)||(r.add(t),i.push(`phase "${t}" is not listed in meta.phases (declared: ${[...n].join(`, `)})`));return i}function Gt(e={}){return g({name:`ptc_workflow`,label:`PTC Workflow`,description:Bt,promptSnippet:`Run a structured TypeScript workflow with named phases, narration (log/phase) and structured concurrency (parallel/pipeline)`,promptGuidelines:[...Ze],parameters:Vt,async execute(t,n,r,i,a){Ht(n.args);let o=$e(a),s=W(e.getBindingSourceNames?.()),c=Date.now(),l=e.getPool?.(),u=et({surface:`workflow`,startedAt:c,onUpdate:i}),d;try{d=await Re({code:n.script,surface:`workflow`,cwd:o,bindings:Se({cwd:o,names:s,includeDispatch:!0}),...n.args===void 0?{}:{args:n.args},...e.depth===void 0?{}:{depth:e.depth},...r===void 0?{}:{signal:r},...e.config===void 0?{}:{config:e.config},...l===void 0?{}:{pool:l},onSubCallChange:e=>u.update(e)})}finally{u.cancel()}if(d.error!==void 0)throw nt(d);let f=n.meta.phases?.map(e=>e.name);return at({outcome:d,surface:`workflow`,warnings:Wt(d,f),durationMs:Date.now()-c})},...It(`workflow`)})}var Kt=class{#e;#t=/* @__PURE__ */ new Map;constructor(e={}){this.#e=Te(e.config)}get(e){let t=this.#t.get(e);if(t!==void 0)return t;let n=we(),r=new ke({buildWorkerUrl:Me,size:this.#e.poolSize,acquireTimeoutMs:this.#e.poolAcquireTimeoutMs,drainGraceMs:this.#e.drainGraceMs,workerOptions:Oe({surface:e,env:n,limits:this.#e})});return this.#t.set(e,r),r}async drain(){let e=[...this.#t.values()];this.#t.clear(),await Promise.all(e.map(e=>e.drain()))}};const Z=[`ptc_run_code`,`ptc_workflow`],qt=[`read`,`bash`,`edit`,`write`],Q=`ptc-mode`,Jt=`ptc-mode`,Yt=`ptc.json`,Xt=`builtins-only`;function Zt(){return{enabled:!1,base:void 0,ourLoadout:void 0}}function Qt(e){let t=A(e,Yt),n;try{n=T(t,`utf8`)}catch{return{defaultMode:!0,source:`default`}}let r;try{r=JSON.parse(n)}catch(e){return{defaultMode:!0,source:`invalid`,error:`${t} is not valid JSON (${e instanceof Error?e.message:String(e)})`}}if(typeof r!=`object`||!r||Array.isArray(r))return{defaultMode:!0,source:`invalid`,error:`${t} must contain a JSON object`};let i=r.defaultMode;return i===void 0?{defaultMode:!0,source:`default`}:typeof i==`boolean`?{defaultMode:i,source:`file`}:{defaultMode:!0,source:`invalid`,error:`${t}: "defaultMode" must be a boolean, received ${typeof i}`}}function $t(e){return[...new Set(e)]}function en(e,t){if(e.length!==t.length)return!1;let n=[...e].sort(),r=[...t].sort();return n.every((e,t)=>e===r[t])}function tn(e,t){let n=e=>Z.includes(e);if(t===`all-but-ptc`)return $t(e.filter(n));let r=new Set(L);return $t(e.filter(e=>n(e)||!r.has(e)))}function nn(e){let{mode:t,defaultMode:n,active:r,manual:i}=e;return t===`tui`?!n&&!i?{enter:!1,reason:`config-off`}:Z.some(e=>r.includes(e))?!i&&qt.filter(e=>!r.includes(e)).length>0?{enter:!1,reason:`restricted-session`}:{enter:!0,base:$t(r),loadout:tn(r,e.hide??`builtins-only`)}:{enter:!1,reason:`tools-unavailable`}:{enter:!1,reason:`not-tui`}}function rn(e,t){return e.enabled&&e.base!==void 0?e.base:t}function an(e,t){return!e.enabled||e.ourLoadout===void 0?!1:!en(e.ourLoadout,t)}function on(e,t){let n=t.length>0&&t.every(e=>Z.includes(e));return e?.enabled===!0&&n&&e.base!==void 0?{base:e.base,restoreFirst:!0}:{base:t,restoreFirst:!1}}function sn(e,t){let n=t===`all-but-ptc`?`Every built-in tool is hidden from you, and so are other extensions' tools.`:`The built-in tools (read, bash, edit, write, grep, find, ls) are hidden from you.`,r=e.map(e=>`tools.${e}(args)`),i=e.slice(0,2).map(e=>e===`read`?`await tools.read({ path: "src/index.ts" })`:e===`bash`?`await tools.bash({ command: "pnpm test" })`:`await tools.${e}({ /* … */ })`).join(`
+`);return[`[PTC MODE ACTIVE]`,`This session runs in PTC mode. `+n,``,`Work by writing one TypeScript program per task and running it:`,`  - ptc_run_code for a plain program (its return value and console.log come back to you)`,`  - ptc_workflow when the task has named phases and you want narration (log / phase /`,`    parallel / pipeline are available there)`,``,`The program body is an async function. Available inside it: ${r.join(`, `)}.`,i.length>0?`Examples:\n${i}`:``,``,`Batch a task's steps into ONE program instead of issuing many tool calls — gathering`,`intermediate output yourself and returning only what matters is the point of this mode.`,`Image-bearing tool results inside a program are attached to you after the run — never return`,`base64 image data as your program's value.`,`If the PTC surfaces cannot express what you need, say so and the user can run /ptc off.`].filter(e=>e.length>0).join(`
+`)}const cn=[`read`,`bash`],ln=`Use the read tool to load a skill's file when the task matches its description.`,un=`Use tools.read({ path }) inside a ptc_run_code program to load a skill's file when the task matches its description.`;function dn(e){return!cn.some(t=>e.includes(t))}function fn(e,t=v){let n=t([...e],`read`).trim();return n.length===0?``:n.includes(ln)?n.replace(ln,un):`${un}\n\n${n}`}const $=Xt;function pn(e,t){return[`PTC mode on — ${t===`all-but-ptc`?`all other tools`:`built-in tools (now reachable only as tools.<name> inside a program)`} hidden.`,`Bindings available inside a program: ${W(e).join(`, `)||`(none)`}.`,`Run /ptc off to restore the normal tool set.`].join(`
+`)}function mn(e){let t=Zt(),n=!1,r=new Kt,i=()=>rn(t,e.getActiveTools()),a=Xe();e.registerTool(zt({getBindingSourceNames:i,getPool:()=>r.get(`run_code`),depth:a})),e.registerTool(Gt({getBindingSourceNames:i,getPool:()=>r.get(`workflow`),depth:a})),e.on(`turn_end`,async()=>{let e=r;r=new Kt,await e.drain()});let o=e=>{e.ui.setStatus(Jt,t.enabled?e.ui.theme.fg(`accent`,`PTC`):void 0)},s=(r,i,a,s)=>{t.enabled=!0,t.base=r,t.ourLoadout=i,e.setActiveTools([...i]),n=!0,e.appendEntry(Q,{enabled:!0,base:[...r]}),o(a),a.ui.notify(s,`info`)},c=(r,i)=>{let a=t.base;t.enabled=!1,t.base=void 0,t.ourLoadout=void 0,n=!1,a!==void 0&&e.setActiveTools([...a]),e.appendEntry(i.customType,{enabled:!1}),o(r),i.announce&&r.ui.notify(`PTC mode off — built-in tools are directly callable again.`,`info`)},l=e=>{let t=e.sessionManager.getEntries();for(let e=t.length-1;e>=0;--e){let n=t[e];if(n?.type!==`custom`||n.customType!==`ptc-mode`)continue;let r=n.data,i=Array.isArray(r?.base)?r.base.filter(e=>typeof e==`string`):void 0;return{enabled:r?.enabled===!0,...i===void 0?{}:{base:i}}}};e.registerCommand(`ptc`,{description:`Show or toggle PTC mode (built-in tools reachable only from inside a PTC program)`,handler:async(n,r)=>{let i=n.trim().toLowerCase();if(i===`off`){if(!t.enabled){r.ui.notify(`PTC mode is already off.`,`info`);return}c(r,{announce:!0,customType:Q});return}if(i!==`on`){r.ui.notify(t.enabled?`PTC mode is ON — run /ptc off to restore built-in tools.\nBindings: ${W(t.base).join(`, `)||`(none)`}`:`PTC mode is OFF — run /ptc on to enter it.`,`info`);return}if(t.enabled){r.ui.notify(`PTC mode is already on.`,`info`);return}let a=nn({mode:r.mode,defaultMode:!0,active:e.getActiveTools(),manual:!0,hide:$});if(!a.enter){r.ui.notify(a.reason===`tools-unavailable`?`Cannot enter PTC mode: ptc_run_code / ptc_workflow are not active in this session.`:`Cannot enter PTC mode in this run mode.`,`warning`);return}s(a.base,a.loadout,r,pn(a.base,$))}}),e.on(`session_start`,async(t,n)=>{let r=Qt(y());r.error!==void 0&&n.ui.notify(`pi-ptc-subagents: ${r.error}`,`warning`);let i=l(n),{base:a,restoreFirst:c}=on(i,e.getActiveTools());c&&e.setActiveTools([...a]);let u=nn({mode:n.mode,defaultMode:r.defaultMode,active:a,manual:!1,hide:$}),d=i?.enabled??u.enter;if(u.enter&&d){s(a,u.loadout,n,pn(a,$));return}o(n),!u.enter&&u.reason!==`not-tui`&&i===void 0&&u.reason===`restricted-session`&&n.ui.notify(`PTC mode skipped: this session was launched with an explicit tool restriction.`,`info`)});let u=!1,d=(e,n)=>{if(e===void 0)return;if(!t.enabled||!n){u&&=(delete e.sections.skills,!1);return}let r=fn(e.skills);r.length!==0&&(e.sections.skills=r,u=!0)};e.on(`before_agent_start`,async(r,i)=>{let a=r.systemPromptOptions;if(d(a,dn(e.getActiveTools())),t.enabled){if(an(t,e.getActiveTools())){c(i,{announce:!1,customType:Q}),d(a,dn(e.getActiveTools())),i.ui.notify(`PTC mode off — another extension changed the active tool set.`,`warning`);return}if(n)return n=!1,{message:{customType:`ptc-mode-briefing`,content:sn(W(t.base),$),display:!1}}}})}export{L as BUILTIN_BINDING_NAMES,be as DEFAULT_BINDING_NAMES,R as DEFAULT_CONFIG,Xt as DEFAULT_HIDE_STRATEGY,o as HOST_FRAME_KIND,ze as MAX_LINE_CHARS,qt as MODE_REQUIRED_TOOL_NAMES,n as PTC_ERROR_KIND,i as PTC_LOG_LEVEL,Yt as PTC_MODE_CONFIG_FILE,Q as PTC_MODE_ENTRY_TYPE,Jt as PTC_MODE_STATUS_KEY,Z as PTC_MODE_TOOL_NAMES,un as PTC_SKILL_LOAD_INSTRUCTION,cn as SKILL_READING_TOOL_NAMES,Kt as TurnPools,Ce as WORKER_ENV_ALLOW_LIST,t as WORKER_FRAME_KIND,ke as WorkerPool,rn as bindingSource,sn as buildModeInstruction,fn as buildPtcSkillsSection,Se as createBuiltinBindings,we as createWorkerEnv,nn as decideModeEntry,mn as default,an as detectExternalLoadoutChange,Ee as effectiveTimeoutMs,Zt as initialModeState,tn as modeLoadout,Qt as readDefaultModeConfig,Ye as renderModelValue,on as resolveBaseOnStart,Te as resolveConfig,Re as runPtcProgram,en as sameToolSet,H as sanitizeText,dn as skillsSectionDropped,Ve as stripAnsi};
 //# sourceMappingURL=index.js.map