@demicodes/agent 0.21.0 → 0.22.1

package/dist/index.mjs

@@ -1553,11 +1553,15 @@ var AgentSession = class AgentSession {
 		};
 	}
 	waitUntilDone() {
-		if (!this.workerRunning && this.pendingActions.length === 0) return Promise.resolve();
+		if (this.isSettled()) return Promise.resolve();
 		return new Promise((resolve) => {
 			this.idleResolvers.push(resolve);
 		});
 	}
+	/** True when no turn is running and no action (including queued user sends) is pending. */
+	isSettled() {
+		return !this.workerRunning && this.pendingActions.length === 0;
+	}
 	/**
 	* Tears the session down: aborts any in-flight turn and releases provider-held resources
 	* (e.g. a long-lived CLI subprocess). Called when the owning connection closes.
@@ -2652,23 +2656,112 @@ function shellCommandHandleRequired(result, budgetTokens) {
 }
 //#endregion
 //#region src/subagent.ts
+/** Default per-session live-children ceiling; override with `AgentServerOptions.subagents.maxLiveSubagents`. */
 const MAX_LIVE_SUBAGENTS = 8;
-const MAX_ARCHIVED_SUBAGENTS = 16;
 const SUBAGENT_RESULT_MAX_BYTES = 32768;
 const SHOW_RECENT_TOOLS = 8;
 const SPAWN_RUNNING_HINT = "next: the child agent is still working; a long-running spawn is normal. shell_write steers it, shell_abort aborts it. Otherwise stop attending and end the turn — the child's completion returns as this command's result and wakes the session when it is idle. Do not poll with shell_status or timed yields; use `demi agent show` only to decide a steer or abort.";
 const SPAWN_PROMPT_DESCRIPTION = "The child's first user message and only task brief. The child starts with an empty transcript and cannot see this conversation: do not refer to prior turns, and do not paste this conversation or the product user's message unchanged. Include the goal for this child, applicable decisions and constraints, whether to edit or only report, how to verify, and every concrete identifier it needs (paths, ids, error text, commands already tried and their key results). State the exact shape of the last assistant text it should return.";
 /**
-* Per-parent subagent supervisor. Owns every child `AgentSession` this parent
-* spawns: lifecycle (spawn / steer / abort / natural end), the `demi agent`
-* command tree, child shell environments, and the `subagent*` protocol frames
-* on the parent connection. Children persist exactly like the parent: each
-* live child keeps a checkpoint and job record under the parent's session
-* directory, and reopening the parent restores and resumes them (`restore`).
-* A closed child moves to the archive: its transcript checkpoint stays on
-* store and `demi agent resume` revives it with a new user message.
+* Connection-wide flat registry of every live session in the tree: the root
+* plus every subagent at any depth. The sole basis for cross-tree addressing —
+* `send`, `steer`, `show`, and `list` resolve here, with no routing rules
+* along the tree.
+*/
+var AgentDirectory = class {
+	root = null;
+	entries = /* @__PURE__ */ new Map();
+	attachRoot(session, supervisor) {
+		this.root = {
+			session,
+			supervisor
+		};
+	}
+	rootId() {
+		if (!this.root) throw new Error("agent directory has no root session");
+		return this.root.session.id();
+	}
+	rootSession() {
+		if (!this.root) throw new Error("agent directory has no root session");
+		return this.root.session;
+	}
+	register(job, owner) {
+		this.entries.set(job.id, {
+			job,
+			owner
+		});
+	}
+	unregister(id) {
+		this.entries.delete(id);
+	}
+	liveEntry(id) {
+		return this.entries.get(id) ?? null;
+	}
+	/** The parent session id of a live agent; null for the root, undefined for an unknown id. */
+	parentIdOf(id) {
+		if (this.root && this.root.session.id() === id) return null;
+		return this.entries.get(id)?.owner.ownerId();
+	}
+	/**
+	* The whole session tree: the root, every live agent, and each live node's
+	* archived children (their supervisors exist, so their archives are
+	* readable). Live children order by spawn time; archived newest first.
+	*/
+	async tree() {
+		if (!this.root) return [];
+		const build = async (id, parentId, job, owner, supervisor) => {
+			const liveChildren = [...this.entries.values()].filter((entry) => entry.owner === supervisor).sort((a, b) => a.job.spawnedAt - b.job.spawnedAt);
+			const children = [];
+			for (const entry of liveChildren) children.push(await build(entry.job.id, id, entry.job, entry.owner, entry.job.ownSupervisor));
+			const now = Date.now();
+			for (const archived of await supervisor.listArchivedJobs()) children.push({
+				id: archived.id,
+				parentId: id,
+				kind: "archived",
+				description: archived.meta.description,
+				profile: archived.meta.profileName,
+				phase: archived.meta.closedPhase ?? "completed",
+				closedAgoMs: archived.meta.closedAt === void 0 ? null : now - archived.meta.closedAt,
+				line: null,
+				children: []
+			});
+			if (job && owner) return {
+				id,
+				parentId,
+				kind: "live",
+				description: job.description,
+				profile: job.profileName,
+				phase: job.phase,
+				closedAgoMs: null,
+				line: owner.renderListLine(job),
+				children
+			};
+			return {
+				id,
+				parentId,
+				kind: "root",
+				description: "",
+				profile: null,
+				phase: "running",
+				closedAgoMs: null,
+				line: null,
+				children
+			};
+		};
+		return [await build(this.rootId(), null, null, null, this.root.supervisor)];
+	}
+};
+/**
+* Per-session subagent supervisor. Every session — root or subagent — owns one
+* and carries the identical `demi agent` command tree, so spawn nests to any
+* depth. The supervisor owns its direct children's lifecycle (spawn / abort /
+* resume / natural end), their shell environments, and the `subagent*`
+* protocol frames; communication and reads (`send` / `steer` / `show` /
+* `list`) resolve through the shared AgentDirectory and reach any live agent
+* in the tree. Children persist under the owner's session directory,
+* recursively, and reopening a session restores its whole subtree.
 */
-var ChildSupervisor = class {
+var ChildSupervisor = class ChildSupervisor {
 	options;
 	jobs = /* @__PURE__ */ new Map();
 	parentSession = null;
@@ -2679,18 +2772,35 @@ var ChildSupervisor = class {
 	attachParent(session) {
 		this.parentSession = session;
 	}
-	/** The `agent` node AgentServer grafts under the parent registry's `demi` root. */
+	ownerId() {
+		if (!this.parentSession) throw new Error("subagent supervisor has no owner session");
+		return this.parentSession.id();
+	}
+	hasLiveJobs() {
+		return this.jobs.size > 0;
+	}
+	/** The `agent` node AgentServer (and every child assembly) grafts under the registry's `demi` root. */
 	rootCommandNode() {
+		const full = this.spawnableCommandNode();
+		if (this.options.canSpawn) return full;
+		return {
+			name: "agent",
+			summary: "Agent tree communication. This session may not spawn subagents: send/steer message any live agent, list renders the tree, show snapshots one agent.",
+			subcommands: (full.subcommands ?? []).filter((command) => command.name !== "abort" && command.name !== "resume")
+		};
+	}
+	spawnableCommandNode() {
 		const profileNames = this.configuredProfileNames();
 		return {
 			name: "agent",
-			summary: "Start an isolated child agent session and wait for its result. The command stays running until the child session ends; stdout is the child's last assistant text. While it is the foreground job, shell_write steers the child and shell_abort aborts it. Run several in separate shell_exec calls with short timeoutMs to fan out, then end the turn — completion wakes an idle session; do not poll.",
+			summary: "Start an isolated child agent session and wait for its result. The command stays running until the child session ends; stdout is the child's last assistant text. While it is the foreground job, shell_write steers the child and shell_abort aborts it. Run several in separate shell_exec calls with short timeoutMs to fan out, then end the turn — completion wakes an idle session; do not poll. Children can spawn children of their own.",
 			successOutput: "first stderr line is \"subagentId: <id>\" at start; stdout is the child's last assistant text (empty is valid), written only at exit",
 			failureOutput: "non-zero exit with the abort or failure reason on stderr",
 			input: {
 				prompt: z.string().optional().describe(SPAWN_PROMPT_DESCRIPTION),
 				profile: z.string().optional().describe(`Named subagent profile configured at harness assembly. Available: ${profileNames.join(", ")}.`),
-				description: z.string().optional().describe("Short UI title distinguishing concurrent children.")
+				description: z.string().optional().describe("Short UI title distinguishing concurrent children."),
+				"no-subagents": z.boolean().optional().describe("Forbid this child from spawning subagents of its own; it can still send, steer, list, and show.")
 			},
 			positionals: ["prompt"],
 			stdinField: "prompt",
@@ -2710,7 +2820,8 @@ var ChildSupervisor = class {
 					job = await this.spawn({
 						prompt,
 						profileName: parsed.values.profile === void 0 ? void 0 : String(parsed.values.profile),
-						description: parsed.values.description === void 0 ? "" : String(parsed.values.description)
+						description: parsed.values.description === void 0 ? "" : String(parsed.values.description),
+						isSpawnForbidden: parsed.values["no-subagents"] === true
 					});
 				} catch (error) {
 					await io.stderr(`demi agent: ${errorMessage(error)}\n`);
@@ -2724,11 +2835,43 @@ var ChildSupervisor = class {
 				});
 			},
 			subcommands: [
+				{
+					name: "send",
+					summary: "Leave a message for any live agent in the tree (`demi agent list`), or `parent`. The target sees it as a new user turn at its next turn boundary, never mid-turn; a message to a finishing subagent extends its life by one turn. Fire-and-forget: queues and returns, never waits. An archived target fails — only its parent can revive it with resume.",
+					input: {
+						id: z.string().describe("Target agent id from the tree, or \"parent\" for the session that spawned this one"),
+						message: z.string().optional().describe("Message body; positional, or stdin/heredoc when omitted.")
+					},
+					positionals: ["id", "message"],
+					stdinField: "message",
+					output: { json: z.object({
+						id: z.string(),
+						accepted: z.boolean()
+					}) },
+					run: async ({ parsed, io }) => {
+						const message = String(parsed.values.message ?? "").trim();
+						if (!message) {
+							await io.stderr("demi agent send: message must not be empty\n");
+							return { exitCode: 1 };
+						}
+						try {
+							const targetId = this.deliverSend(String(parsed.values.id), message);
+							await io.stdout(parsed.json ? `${JSON.stringify({
+								id: targetId,
+								accepted: true
+							})}\n` : `sent to ${targetId}\n`);
+							return { exitCode: 0 };
+						} catch (error) {
+							await io.stderr(`demi agent send: ${errorMessage(error)}\n`);
+							return { exitCode: 1 };
+						}
+					}
+				},
 				{
 					name: "steer",
-					summary: "Send a user steer to a running child. Queues until the child can take it; does not wait.",
+					summary: "Chime into a running agent's current turn: the target sees the message at its next sampling/tool boundary and continues its current work with the new information. Nothing is cancelled and the turn does not restart. Fails when the target has no running turn — use send for that. Targets any live agent in the tree, or `parent`.",
 					input: {
-						id: z.string().describe("subagentId from spawn stderr"),
+						id: z.string().describe("Target agent id from the tree, or \"parent\" for the session that spawned this one"),
 						message: z.string().optional().describe("Message body; positional, or stdin/heredoc when omitted.")
 					},
 					positionals: ["id", "message"],
@@ -2738,29 +2881,28 @@ var ChildSupervisor = class {
 						accepted: z.boolean()
 					}) },
 					run: async ({ parsed, io }) => {
-						const id = String(parsed.values.id);
 						const message = String(parsed.values.message ?? "").trim();
 						if (!message) {
 							await io.stderr("demi agent steer: message must not be empty\n");
 							return { exitCode: 1 };
 						}
-						const job = this.jobs.get(id);
-						if (!job) {
-							await io.stderr(`demi agent steer: no running subagent "${id}"\n`);
+						try {
+							const targetId = await this.deliverSteer(String(parsed.values.id), message);
+							await io.stdout(parsed.json ? `${JSON.stringify({
+								id: targetId,
+								accepted: true
+							})}\n` : `steered ${targetId}\n`);
+							return { exitCode: 0 };
+						} catch (error) {
+							await io.stderr(`demi agent steer: ${errorMessage(error)}\n`);
 							return { exitCode: 1 };
 						}
-						await this.steerChild(job, message);
-						await io.stdout(parsed.json ? `${JSON.stringify({
-							id,
-							accepted: true
-						})}\n` : `steered ${id}\n`);
-						return { exitCode: 0 };
 					}
 				},
 				{
 					name: "abort",
-					summary: "Abort a running child and its subtree. Siblings are untouched.",
-					input: { id: z.string().describe("subagentId from spawn stderr") },
+					summary: "Abort one of your own running children and its whole subtree. Siblings are untouched; only the spawning session may abort a child.",
+					input: { id: z.string().describe("subagentId of one of your running children") },
 					positionals: ["id"],
 					output: { json: z.object({
 						id: z.string(),
@@ -2769,7 +2911,7 @@ var ChildSupervisor = class {
 					run: async ({ parsed, io }) => {
 						const id = String(parsed.values.id);
 						if (!this.jobs.has(id)) {
-							await io.stderr(`demi agent abort: no running subagent "${id}"\n`);
+							await io.stderr(`demi agent abort: "${id}" is not one of your running children\n`);
 							return { exitCode: 1 };
 						}
 						await this.abortSubtree(id);
@@ -2782,9 +2924,9 @@ var ChildSupervisor = class {
 				},
 				{
 					name: "resume",
-					summary: "Revive an archived (finished) child with a new user message on top of its preserved transcript. Behaves like the spawn command afterwards: stays running until the child ends again, stdout is its new last assistant text, shell_write steers, shell_abort aborts. Archived ids are in `demi agent list`.",
+					summary: "Revive one of your own archived (finished) children with a new user message on top of its preserved transcript. Behaves like the spawn command afterwards: stays running until the child ends again, stdout is its new last assistant text, shell_write steers, shell_abort aborts. Archived ids are in `demi agent list`; only the spawning session may resume its child.",
 					input: {
-						id: z.string().describe("subagentId of an archived child"),
+						id: z.string().describe("subagentId of one of your archived children"),
 						message: z.string().optional().describe("The reviving user message; positional, or stdin/heredoc when omitted.")
 					},
 					positionals: ["id", "message"],
@@ -2818,54 +2960,35 @@ var ChildSupervisor = class {
 				},
 				{
 					name: "list",
-					summary: "Snapshot roster of this session's running children, then its archived (finished, revivable via resume) children. One line per child with ages relative to now. A read, not a wait — not for polling loops.",
-					output: { json: z.object({
-						agents: z.array(z.unknown()),
-						archived: z.array(z.unknown())
-					}) },
+					summary: "Render the whole session tree from the root down, marking your own position. Live agents show phase, ages, execution, and activity; each node's archived (finished, revivable by its parent) children render beneath it. Every age is relative to now. A read, not a wait — not for polling loops.",
+					output: { json: z.object({ tree: z.array(z.unknown()) }) },
 					run: async ({ parsed, io }) => {
-						const jobs = [...this.jobs.values()];
-						const archived = await this.listArchivedJobs();
+						const nodes = await this.options.directory.tree();
 						if (parsed.json) {
-							await io.stdout(`${JSON.stringify({
-								agents: jobs.map((job) => this.snapshot(job, false)),
-								archived: archived.map(({ id, meta }) => ({
-									subagentId: id,
-									description: meta.description,
-									profile: meta.profileName,
-									phase: meta.closedPhase,
-									closedAgoMs: meta.closedAt === void 0 ? null : Date.now() - meta.closedAt
-								}))
-							})}\n`);
+							await io.stdout(`${JSON.stringify({ tree: flattenTree(nodes, this.ownerId()) })}\n`);
 							return { exitCode: 0 };
 						}
-						if (jobs.length === 0) await io.stdout("no running subagents\n");
-						for (const job of jobs) await io.stdout(`${this.renderListLine(job)}\n`);
-						if (archived.length > 0) {
-							await io.stdout("archived (revivable with `demi agent resume <id>`):\n");
-							for (const { id, meta } of archived) {
-								const closedAgo = meta.closedAt === void 0 ? "" : `  closed ${formatDuration(Date.now() - meta.closedAt)} ago`;
-								await io.stdout(`  ${id}  ${meta.closedPhase}${closedAgo}  ${meta.description ? `"${meta.description}"` : "(no description)"}\n`);
-							}
-						}
+						const lines = [];
+						for (const node of nodes) renderTreeNode(node, "", true, this.ownerId(), lines);
+						await io.stdout(`${lines.join("\n")}\n`);
 						return { exitCode: 0 };
 					}
 				},
 				{
 					name: "show",
-					summary: "Bounded snapshot of one running child: execution state, recent tool titles with durations, last assistant text. Every duration is relative to now — use the ages to tell motion from stall. Omits tool outputs, file contents, and older turns. A read, not a wait — not for polling loops.",
-					input: { id: z.string().describe("subagentId from spawn stderr") },
+					summary: "Bounded snapshot of any live agent in the tree (root excluded): execution state, recent tool titles with durations, last assistant text. Every duration is relative to now — use the ages to tell motion from stall. Omits tool outputs, file contents, and older turns. A read, not a wait — not for polling loops.",
+					input: { id: z.string().describe("Agent id from the tree") },
 					positionals: ["id"],
 					output: { json: z.object({ agent: z.unknown() }) },
 					run: async ({ parsed, io }) => {
 						const id = String(parsed.values.id);
-						const job = this.jobs.get(id);
-						if (!job) {
-							await io.stderr(`demi agent show: no running subagent "${id}"\n`);
+						const entry = this.options.directory.liveEntry(id);
+						if (!entry) {
+							await io.stderr(`demi agent show: no live agent "${id}"\n`);
 							return { exitCode: 1 };
 						}
-						if (parsed.json) await io.stdout(`${JSON.stringify({ agent: this.snapshot(job, true) })}\n`);
-						else await io.stdout(this.renderShow(job));
+						if (parsed.json) await io.stdout(`${JSON.stringify({ agent: entry.owner.snapshot(entry.job, true) })}\n`);
+						else await io.stdout(entry.owner.renderShow(entry.job));
 						return { exitCode: 0 };
 					}
 				}
@@ -2875,16 +2998,20 @@ var ChildSupervisor = class {
 	hasShell(shellId) {
 		return this.environmentScopeForShell(shellId) !== null;
 	}
-	/** Resolves the child scope owning a shell, for the command bridge dispatch. */
+	/** Resolves the descendant scope owning a shell (recursively), for the command bridge dispatch. */
 	environmentScopeForShell(shellId) {
-		for (const job of this.jobs.values()) for (const environment of job.environments.values()) if (environment.getShell(shellId)) return {
-			environment,
-			commandNames: new Set(job.commandNames),
-			agentSessionId: job.id
-		};
+		for (const job of this.jobs.values()) {
+			for (const environment of job.environments.values()) if (environment.getShell(shellId)) return {
+				environment,
+				commandNames: new Set(job.commandNames),
+				agentSessionId: job.id
+			};
+			const nested = job.ownSupervisor.environmentScopeForShell(shellId);
+			if (nested) return nested;
+		}
 		return null;
 	}
-	/** Re-emits `subagent started` + transcript reset for every running child (transcript resync). */
+	/** Re-emits `subagent started` + transcript reset for the whole live subtree (transcript resync). */
 	replay() {
 		for (const job of this.jobs.values()) {
 			this.options.emit({
@@ -2899,12 +3026,13 @@ var ChildSupervisor = class {
 				blocks: structuredClone(transcript.blocks),
 				revision: transcript.revision
 			});
+			job.ownSupervisor.replay();
 		}
 	}
 	/**
-	* Detaches every live child on connection teardown: aborts in-flight turns,
-	* flushes checkpoints, and keeps the persisted job so the next open of this
-	* parent restores it — the same dispose semantics as the parent session.
+	* Detaches the live subtree on connection teardown: aborts in-flight turns,
+	* flushes checkpoints, and keeps the persisted jobs so the next open of the
+	* owner restores them — the same dispose semantics as the owner session.
 	* No `closed` frame is emitted: the children are not done, just paused.
 	*/
 	async dispose() {
@@ -2913,21 +3041,24 @@ var ChildSupervisor = class {
 			job.isClosing = true;
 			job.unsubscribe();
 			this.jobs.delete(job.id);
+			this.options.directory.unregister(job.id);
+			await job.ownSupervisor.dispose();
 			await job.session.dispose().catch(noop);
 			await this.disposeJobShells(job);
 			job.settleClosed({ phase: "aborted" });
+			job.wake?.();
 		}
 	}
 	/**
-	* Rebuilds every persisted live child of this parent and finishes what it was
+	* Rebuilds every persisted live child of this owner and finishes what it was
 	* doing: an interrupted turn resumes from its resume point; an already
-	* quiescent child closes with its result. Children share the parent's
-	* persistence lifecycle — a parent restore is a child restore.
+	* quiescent child closes with its result. Recursive: each restored child
+	* restores its own subtree. Children share the owner's persistence
+	* lifecycle — a session restore is a subtree restore.
 	*/
 	async restore() {
-		const parent = this.parentSession;
-		if (!parent || this.isDisposed) return;
-		const prefix = `agent-sessions/${parent.id()}/subagents/`;
+		if (!this.parentSession || this.isDisposed) return;
+		const prefix = `${this.options.storePrefix}/subagents/`;
 		const keys = await this.options.store.list(prefix).catch(() => []);
 		const ids = [...new Set(keys.map((key) => key.slice(prefix.length).split("/")[0] ?? "").filter(Boolean))];
 		for (const id of ids) {
@@ -2946,12 +3077,14 @@ var ChildSupervisor = class {
 		const checkpoint = await this.childSessionStore(id).loadCheckpoint();
 		if (!meta || !checkpoint) throw new Error("incomplete persisted subagent");
 		const job = this.reassembleJob(id, meta, checkpoint);
-		this.watchTurn(job, job.session.resume(meta.metadata ? { metadata: meta.metadata } : {}));
+		this.trackTurn(job, job.session.resume(meta.metadata ? { metadata: meta.metadata } : {}));
+		this.settleJob(job);
+		await job.ownSupervisor.restore();
 	}
 	/** Shared by restore and resume: rebuild a persisted child's job and session from its checkpoint. */
 	reassembleJob(id, meta, checkpoint) {
 		const parent = this.parentSession;
-		if (!parent) throw new Error("subagent supervisor has no parent session");
+		if (!parent) throw new Error("subagent supervisor has no owner session");
 		const profile = this.resolveProfile(meta.profileName ?? void 0);
 		const { job, runtime } = this.assembleJob({
 			id,
@@ -2959,7 +3092,8 @@ var ChildSupervisor = class {
 			profileName: meta.profileName,
 			profile,
 			metadata: meta.metadata,
-			spawnedAt: meta.spawnedAt
+			spawnedAt: meta.spawnedAt,
+			canSpawnSubagents: meta.canSpawnSubagents !== false
 		});
 		const session = AgentSession.fromCheckpoint({
 			provider: parent.cloneProviderRuntime(),
@@ -2981,10 +3115,10 @@ var ChildSupervisor = class {
 	*/
 	async resumeArchived(id, message) {
 		const parent = this.parentSession;
-		if (!parent) throw new Error("subagent supervisor has no parent session");
-		if (this.isDisposed) throw new Error("parent session is closing");
-		if (this.jobs.has(id)) throw new Error(`subagent "${id}" is still running; steer it instead`);
-		if (this.jobs.size >= 8) throw new Error(`at most 8 running subagents per session; abort one or wait for a result`);
+		if (!parent) throw new Error("subagent supervisor has no owner session");
+		if (this.isDisposed) throw new Error("owner session is closing");
+		if (this.jobs.has(id)) throw new Error(`subagent "${id}" is still running; send or steer it instead`);
+		if (this.jobs.size >= this.options.maxLiveSubagents) throw new Error(`at most ${this.options.maxLiveSubagents} running subagents per session; abort one or wait for a result`);
 		const meta = await this.options.store.readJson(this.childStoreKey(id, "job.json"));
 		if (!meta?.closedPhase) throw new Error(`no archived subagent "${id}" (see \`demi agent list\`)`);
 		const checkpoint = await this.childSessionStore(id).loadCheckpoint();
@@ -2993,21 +3127,22 @@ var ChildSupervisor = class {
 			description: meta.description,
 			profileName: meta.profileName,
 			metadata: parent.actionMetadata(),
-			spawnedAt: Date.now()
+			spawnedAt: Date.now(),
+			...meta.canSpawnSubagents === false ? { canSpawnSubagents: false } : {}
 		};
 		await this.options.store.writeJson(this.childStoreKey(id, "job.json"), liveMeta);
 		const job = this.reassembleJob(id, liveMeta, checkpoint);
-		this.watchTurn(job, job.session.send([{
+		this.trackTurn(job, job.session.send([{
 			type: "text",
 			text: message
 		}], liveMeta.metadata ? { metadata: liveMeta.metadata } : {}));
+		this.settleJob(job);
 		return job;
 	}
-	/** Every archived (finished, revivable) child of this parent, newest first. */
+	/** Every archived (finished, revivable) child of this owner, newest first. */
 	async listArchivedJobs() {
-		const parent = this.parentSession;
-		if (!parent) return [];
-		const prefix = `agent-sessions/${parent.id()}/subagents/`;
+		if (!this.parentSession) return [];
+		const prefix = `${this.options.storePrefix}/subagents/`;
 		const keys = await this.options.store.list(prefix).catch(() => []);
 		const ids = [...new Set(keys.map((key) => key.slice(prefix.length).split("/")[0] ?? "").filter(Boolean))];
 		const archived = [];
@@ -3021,42 +3156,42 @@ var ChildSupervisor = class {
 		}
 		return archived.sort((a, b) => (b.meta.closedAt ?? 0) - (a.meta.closedAt ?? 0));
 	}
-	async pruneArchive() {
-		const archived = await this.listArchivedJobs();
-		for (const stale of archived.slice(16)) await this.deletePersistedJob(stale.id);
-	}
 	async abortSubtree(id) {
 		const job = this.jobs.get(id);
 		if (!job) return;
 		await this.closeJob(job, "aborted");
 	}
-	/** Aborts every live child; the archive is untouched. */
+	/** Aborts every live child (each with its subtree); the archive is untouched. */
 	async abortAll() {
 		for (const id of [...this.jobs.keys()]) await this.abortSubtree(id);
 	}
 	async spawn(input) {
 		const parent = this.parentSession;
-		if (!parent) throw new Error("subagent supervisor has no parent session");
-		if (this.isDisposed) throw new Error("parent session is closing");
-		if (this.jobs.size >= 8) throw new Error(`at most 8 running subagents per session; abort one or wait for a result`);
+		if (!parent) throw new Error("subagent supervisor has no owner session");
+		if (!this.options.canSpawn) throw new Error("this session may not spawn subagents");
+		if (this.isDisposed) throw new Error("owner session is closing");
+		if (this.jobs.size >= this.options.maxLiveSubagents) throw new Error(`at most ${this.options.maxLiveSubagents} running subagents per session; abort one or wait for a result`);
 		const profile = this.resolveProfile(input.profileName);
 		const id = createId();
 		const metadata = parent.actionMetadata();
 		const profileName = input.profileName ?? (this.options.profiles ? profile.name : null);
 		const spawnedAt = Date.now();
+		const canSpawnSubagents = !input.isSpawnForbidden && profile.canSpawnSubagents !== false;
 		const { job, runtime } = this.assembleJob({
 			id,
 			description: input.description,
 			profileName,
 			profile,
 			metadata,
-			spawnedAt
+			spawnedAt,
+			canSpawnSubagents
 		});
 		await this.options.store.writeJson(this.childStoreKey(id, "job.json"), {
 			description: input.description,
 			profileName,
 			metadata,
-			spawnedAt
+			spawnedAt,
+			...canSpawnSubagents ? {} : { canSpawnSubagents }
 		});
 		const session = new AgentSession({
 			provider: parent.cloneProviderRuntime(),
@@ -3070,18 +3205,22 @@ var ChildSupervisor = class {
 			...this.options.sessionOptions
 		});
 		this.attachSession(job, session);
-		this.watchChild(job, input.prompt);
+		this.trackTurn(job, session.send([{
+			type: "text",
+			text: input.prompt
+		}], metadata ? { metadata } : {}));
+		this.settleJob(job);
 		return job;
 	}
-	/** Everything spawn and restore share: the command tree, the harness runtime, and the job record (session attached separately). */
+	/**
+	* Everything spawn and restore share: the command tree (identical to the
+	* owner's — children spawn, message, and observe exactly like any session),
+	* the child's own supervisor, the harness runtime, and the job record
+	* (session attached separately).
+	*/
 	assembleJob(input) {
 		const { id, profile } = input;
-		const agentNode = this.createChildAgentNode(id, input.description);
-		const commands = injectSubagentCommand(profile.commands ? profile.commands([...this.options.parentCommands]) : [...this.options.parentCommands], agentNode);
-		const commandRegistry = new CommandRegistry();
-		for (const command of commands) commandRegistry.register(command);
-		const commandNames = commandRegistry.list().map((command) => command.name);
-		const commandsPrompt = commandRegistry.renderHelp();
+		const inherited = profile.commands ? profile.commands([...this.options.parentCommands]) : [...this.options.parentCommands];
 		let settleClosed;
 		const closed = new Promise((resolve) => {
 			settleClosed = resolve;
@@ -3093,8 +3232,9 @@ var ChildSupervisor = class {
 			profileName: input.profileName,
 			metadata: input.metadata,
 			session: null,
-			commandRegistry,
-			commandNames,
+			ownSupervisor: null,
+			commandRegistry: new CommandRegistry(),
+			commandNames: [],
 			environments: /* @__PURE__ */ new Map(),
 			pendingEnvironments: /* @__PURE__ */ new Map(),
 			readonlyHosts: /* @__PURE__ */ new WeakMap(),
@@ -3107,8 +3247,21 @@ var ChildSupervisor = class {
 			unsubscribe: noop,
 			closed,
 			settleClosed,
-			isClosing: false
+			isClosing: false,
+			wake: null
 		};
+		job.ownSupervisor = new ChildSupervisor({
+			...this.options,
+			parentCommands: inherited,
+			storePrefix: `${this.options.storePrefix}/subagents/${id}`,
+			canSpawn: input.canSpawnSubagents,
+			notifyParentOnIdle: true,
+			onJobsChanged: () => job.wake?.()
+		});
+		const commands = injectSubagentCommand(inherited, job.ownSupervisor.rootCommandNode());
+		for (const command of commands) job.commandRegistry.register(command);
+		job.commandNames = job.commandRegistry.list().map((command) => command.name);
+		const commandsPrompt = job.commandRegistry.renderHelp();
 		const agent = this.options.agent;
 		const preamble = this.subagentPreamble(id);
 		return {
@@ -3133,7 +3286,12 @@ var ChildSupervisor = class {
 	}
 	attachSession(job, session) {
 		job.session = session;
+		job.ownSupervisor.attachParent(session);
 		job.unsubscribe = session.subscribe((event) => {
+			if (event.type === "phase_changed") {
+				job.wake?.();
+				return;
+			}
 			if (event.type !== "transcript_changed") return;
 			this.recordTelemetry(job, event.patches);
 			this.options.emit({
@@ -3144,6 +3302,8 @@ var ChildSupervisor = class {
 			});
 		});
 		this.jobs.set(job.id, job);
+		this.options.directory.register(job, this);
+		this.options.onJobsChanged?.();
 		this.options.emit({
 			type: "subagent",
 			event: "started",
@@ -3158,7 +3318,7 @@ var ChildSupervisor = class {
 		});
 	}
 	childStoreKey(childId, file) {
-		return `agent-sessions/${this.parentSession?.id() ?? ""}/subagents/${childId}/${file}`;
+		return `${this.options.storePrefix}/subagents/${childId}/${file}`;
 	}
 	childSessionStore(childId) {
 		return {
@@ -3198,7 +3358,77 @@ var ChildSupervisor = class {
 		await io.stderr(`demi agent: subagent ${job.id} failed: ${close.failure ?? "unknown error"}\n`);
 		return { exitCode: 1 };
 	}
-	/** Delivers one steer to a child: mid-turn as a steer, idle as a new user turn. */
+	/**
+	* Resolves a send/steer target against the directory. `parent` is the
+	* session that spawned the caller; a caller cannot message itself.
+	*/
+	resolveTarget(rawId) {
+		const selfId = this.ownerId();
+		let id = rawId;
+		if (id === "parent") {
+			const parentId = this.options.directory.parentIdOf(selfId);
+			if (parentId === null) throw new Error("the root session has no parent");
+			if (parentId === void 0) throw new Error("this session is not in the agent directory");
+			id = parentId;
+		}
+		if (id === selfId) throw new Error("cannot message your own session");
+		if (id === this.options.directory.rootId()) return {
+			id,
+			session: this.options.directory.rootSession(),
+			job: null,
+			owner: null
+		};
+		const entry = this.options.directory.liveEntry(id);
+		if (!entry || entry.job.isClosing) throw new Error(`no live agent "${id}" (see \`demi agent list\`; an archived child is revived only by its parent via resume)`);
+		return {
+			id,
+			session: entry.job.session,
+			job: entry.job,
+			owner: entry.owner
+		};
+	}
+	/**
+	* Mailbox delivery: an ordinary user send on the target session. The
+	* session's own action queue is the inbox — a busy target sees it as a new
+	* user turn after the current one; an idle root wakes; a finishing subagent
+	* is kept open for one more turn by its settle loop (the enqueue lands
+	* before the loop's synchronous close check, so nothing drops silently).
+	*/
+	deliverSend(rawId, message) {
+		const target = this.resolveTarget(rawId);
+		const content = [{
+			type: "text",
+			text: `${this.senderPrefix()} ${message}`
+		}];
+		const metadata = target.job ? target.job.metadata : this.senderMetadata();
+		if (target.job && target.owner) {
+			target.owner.trackTurn(target.job, target.session.send(content, metadata ? { metadata } : {}));
+			target.job.wake?.();
+		} else target.session.send(content, metadata ? { metadata } : {}).catch(noop);
+		return target.id;
+	}
+	/** Chime-in delivery: injects into the target's running turn; no fallback when idle. */
+	async deliverSteer(rawId, message) {
+		const target = this.resolveTarget(rawId);
+		if (target.session.phase() === "idle") throw new Error(`agent "${target.id}" has no running turn to steer; use \`demi agent send\``);
+		const content = [{
+			type: "text",
+			text: `${this.senderPrefix()} ${message}`
+		}];
+		await target.session.steer(content);
+		return target.id;
+	}
+	senderPrefix() {
+		const selfId = this.ownerId();
+		const entry = this.options.directory.liveEntry(selfId);
+		const description = entry ? entry.job.description : "root session";
+		return `[agent ${selfId}${description ? ` — ${description}` : ""}]`;
+	}
+	/** Metadata for a turn on the root: the sender subtree's spawning round, or null from the root itself. */
+	senderMetadata() {
+		return this.options.directory.liveEntry(this.ownerId())?.job.metadata ?? null;
+	}
+	/** Delivers one stdin chunk from the attending spawner: mid-turn as a steer, otherwise as a new user turn. */
 	async steerChild(job, message) {
 		const content = [{
 			type: "text",
@@ -3208,7 +3438,7 @@ var ChildSupervisor = class {
 			await job.session.steer(content);
 			return;
 		} catch {}
-		this.watchTurn(job, job.session.send(content));
+		this.trackTurn(job, job.session.send(content));
 	}
 	async pumpStdinSteers(id, stdinStream) {
 		try {
@@ -3220,47 +3450,52 @@ var ChildSupervisor = class {
 			}
 		} catch {}
 	}
-	watchChild(job, prompt) {
-		const opening = job.session.send([{
-			type: "text",
-			text: prompt
-		}], job.metadata ? { metadata: job.metadata } : {});
-		this.watchTurn(job, opening);
-	}
-	/** Tracks one child turn to session quiescence, then closes the job with its outcome. */
-	async watchTurn(job, turn) {
-		try {
-			await turn;
-		} catch (error) {
+	/** Observes one turn promise of an own child: a non-abort failure closes the job as an error. */
+	trackTurn(job, turn) {
+		turn.catch((error) => {
+			if (job.isClosing) return;
 			job.failure = errorMessage(error);
-			await this.closeJob(job, "error");
-			return;
-		}
-		await this.waitForQuiescence(job);
-		if (job.phase === "running" && !job.isClosing) await this.closeJob(job, "completed");
-	}
-	/** Resolves when the child is idle with no pending yield wakeups (or the job closed). */
-	async waitForQuiescence(job) {
-		while (!job.isClosing && (job.session.phase() !== "idle" || job.session.hasPendingYields())) await new Promise((resolve) => {
-			let settled = false;
-			const finish = () => {
-				if (settled) return;
-				settled = true;
-				unsubscribe();
-				resolve();
-			};
-			const unsubscribe = job.session.subscribe((event) => {
-				if (event.type === "phase_changed") finish();
-			});
-			job.closed.then(finish);
+			this.closeJob(job, "error");
 		});
 	}
+	/**
+	* The one place a child closes naturally. Loops until the child is
+	* quiescent: no running or queued turn (the session action queue doubles as
+	* the mailbox), no pending yield wakeups, and no live children of its own.
+	* The final check-and-close is synchronous, so a send that lands before it
+	* is processed and one that lands after it fails on `isClosing` — nothing
+	* drops silently.
+	*/
+	async settleJob(job) {
+		while (!job.isClosing) {
+			if (job.session.isSettled() && !job.session.hasPendingYields() && !job.ownSupervisor.hasLiveJobs()) {
+				this.closeJob(job, "completed");
+				return;
+			}
+			await new Promise((resolve) => {
+				let settled = false;
+				const finish = () => {
+					if (settled) return;
+					settled = true;
+					job.wake = null;
+					resolve();
+				};
+				job.wake = finish;
+				job.closed.then(finish);
+				if (job.session.isSettled()) return;
+				job.session.waitUntilDone().then(finish);
+			});
+		}
+	}
 	async closeJob(job, phase) {
 		if (job.isClosing) return;
 		job.isClosing = true;
 		job.phase = phase;
 		job.unsubscribe();
 		this.jobs.delete(job.id);
+		this.options.directory.unregister(job.id);
+		job.wake?.();
+		await job.ownSupervisor.abortAll();
 		const result = phase === "completed" ? boundedResultText(lastAssistantText(job.session.transcript().blocks)) : void 0;
 		await job.session.dispose().catch(noop);
 		await this.disposeJobShells(job);
@@ -3272,7 +3507,6 @@ var ChildSupervisor = class {
 			closedPhase: phase,
 			closedAt: Date.now()
 		}).catch(noop);
-		await this.pruneArchive().catch(noop);
 		const close = {
 			phase,
 			...result !== void 0 ? { result } : {},
@@ -3284,6 +3518,7 @@ var ChildSupervisor = class {
 			job: this.wireJob(job, result)
 		});
 		job.settleClosed(close);
+		this.options.onJobsChanged?.();
 		this.notifyIdleParent(job, close);
 	}
 	async disposeJobShells(job) {
@@ -3294,7 +3529,7 @@ var ChildSupervisor = class {
 		}
 		for (const environment of environments) await environment.disposeAllShells().catch(noop);
 	}
-	/** Wakes an idle parent with a user send; a parent blocked in the spawn gets the tool result instead. */
+	/** Wakes an idle owner with a user send; an owner blocked in the spawn gets the tool result instead. */
 	notifyIdleParent(job, close) {
 		if (this.isDisposed || !this.options.notifyParentOnIdle) return;
 		const parent = this.parentSession;
@@ -3306,47 +3541,6 @@ var ChildSupervisor = class {
 			text: body
 		}], job.metadata ? { metadata: job.metadata } : {}).catch(noop);
 	}
-	createChildAgentNode(childId, description) {
-		return {
-			name: "agent",
-			summary: "Subagent bridge to the parent session.",
-			subcommands: [{
-				name: "send-parent",
-				summary: "Send an interim user message to the parent session. The parent sees it only when it is not blocked waiting on this session. Your result is still the last assistant text when this session ends, not this message.",
-				input: { message: z.string().optional().describe("Message body; positional, or stdin/heredoc when omitted.") },
-				positionals: ["message"],
-				stdinField: "message",
-				output: { json: z.object({ accepted: z.boolean() }) },
-				run: async ({ parsed, io }) => {
-					const message = String(parsed.values.message ?? "").trim();
-					if (!message) {
-						await io.stderr("demi agent send-parent: message must not be empty\n");
-						return { exitCode: 1 };
-					}
-					this.deliverToParent(childId, description, message);
-					await io.stdout(parsed.json ? `${JSON.stringify({ accepted: true })}\n` : "sent\n");
-					return { exitCode: 0 };
-				}
-			}]
-		};
-	}
-	deliverToParent(childId, description, message) {
-		const parent = this.parentSession;
-		if (!parent || this.isDisposed) return;
-		const content = [{
-			type: "text",
-			text: `[subagent ${childId}${description ? ` — ${description}` : ""}] ${message}`
-		}];
-		const metadata = this.jobs.get(childId)?.metadata ?? null;
-		const sendOptions = metadata ? { metadata } : {};
-		if (parent.phase() !== "idle") {
-			parent.steer(content).catch(() => {
-				parent.send(content, sendOptions).catch(noop);
-			});
-			return;
-		}
-		parent.send(content, sendOptions).catch(noop);
-	}
 	async childEnvironment(job, ctx) {
 		const resolved = await this.options.agent.host({
 			agentSessionId: job.id,
@@ -3386,8 +3580,7 @@ var ChildSupervisor = class {
 			initialEnv: {
 				...prepared.initialEnv,
 				DEMI_SUBAGENT_ID: job.id,
-				DEMI_PARENT_SESSION_ID: this.parentSession?.id() ?? "",
-				DEMI_SUBAGENT_DEPTH: "1"
+				DEMI_PARENT_SESSION_ID: this.ownerId()
 			},
 			host,
 			commands: job.commandRegistry
@@ -3415,9 +3608,9 @@ var ChildSupervisor = class {
 	}
 	subagentPreamble(childId) {
 		return [
-			`You are a subagent: an isolated child agent session (id ${childId}) spawned by a parent agent session. Your transcript starts empty; the task brief in the first user message is your entire context.`,
-			"When you end your turn with no scheduled wakeups, the session ends and your last assistant text is returned to the parent as the result. Write it for the parent agent, in the shape the task brief asked for.",
-			"`demi agent send-parent <message>` sends an interim user message to the parent; it is seen only when the parent is not blocked waiting on this session.",
+			`You are a subagent: an isolated child agent session (id ${childId}) spawned by parent agent session ${this.ownerId()}. Your transcript starts empty; the task brief in the first user message is your entire context.`,
+			"When you end your turn with nothing pending — no queued messages, no scheduled wakeups, no running children of your own — the session ends and your last assistant text is returned to the parent as the result. Write it for the parent agent, in the shape the task brief asked for.",
+			"`demi agent` spawns your own children. `demi agent send <id|parent> <message>` leaves a message any live agent sees at its next turn boundary; `demi agent steer <id> <message>` chimes into a running agent's current turn; `demi agent list` renders the whole agent tree with your position.",
 			"You are not talking to the product user; do not address them."
 		].join("\n");
 	}
@@ -3485,6 +3678,7 @@ var ChildSupervisor = class {
 		const execution = this.executionOf(job);
 		const base = {
 			subagentId: job.id,
+			parentSessionId: this.ownerId(),
 			description: job.description,
 			profile: job.profileName,
 			phase: job.phase,
@@ -3527,6 +3721,7 @@ var ChildSupervisor = class {
 		const execution = this.executionOf(job);
 		const lines = [
 			`id: ${job.id}`,
+			`parent: ${this.ownerId()}`,
 			`description: ${job.description || "(none)"}`,
 			`profile: ${job.profileName ?? "default"}`,
 			`phase: ${job.phase}`,
@@ -3551,7 +3746,7 @@ var ChildSupervisor = class {
 	wireJob(job, result) {
 		return {
 			subagentId: job.id,
-			parentSessionId: this.parentSession?.id() ?? "",
+			parentSessionId: this.ownerId(),
 			description: job.description,
 			profile: job.profileName,
 			phase: job.phase,
@@ -3560,6 +3755,34 @@ var ChildSupervisor = class {
 		};
 	}
 };
+function renderTreeNode(node, prefix, isLast, selfId, lines) {
+	const marker = node.id === selfId ? " ← you" : "";
+	const body = node.kind === "root" ? `● ${node.id}  (root session)${marker}` : node.kind === "archived" ? `○ ${node.id}  archived (${node.phase}${node.closedAgoMs === null ? "" : ` ${formatDuration(node.closedAgoMs)} ago`})  ${node.description ? `"${node.description}"` : "(no description)"}` : `● ${node.line}${marker}`;
+	if (node.parentId === null) lines.push(body);
+	else lines.push(`${prefix}${isLast ? "└─" : "├─"}${body}`);
+	const childPrefix = node.parentId === null ? "" : `${prefix}${isLast ? "  " : "│ "}`;
+	node.children.forEach((child, index) => {
+		renderTreeNode(child, childPrefix, index === node.children.length - 1, selfId, lines);
+	});
+}
+function flattenTree(nodes, selfId) {
+	const flat = [];
+	const visit = (node) => {
+		flat.push({
+			subagentId: node.id,
+			parentSessionId: node.parentId,
+			kind: node.kind,
+			description: node.description,
+			profile: node.profile,
+			phase: node.phase,
+			closedAgoMs: node.closedAgoMs,
+			self: node.id === selfId
+		});
+		node.children.forEach(visit);
+	};
+	nodes.forEach(visit);
+	return flat;
+}
 /**
 * Grafts the `agent` node under a `demi` root: onto an existing harness `demi`
 * tree, or as a new `demi` root when the harness has none.
@@ -3696,6 +3919,7 @@ var AgentServer = class {
 	sessionOptions;
 	prepareShell;
 	notifyParentOnIdle;
+	maxLiveSubagents;
 	bindings = /* @__PURE__ */ new Set();
 	sessionOwnership = new SessionOwnershipRegistry();
 	constructor(options) {
@@ -3705,6 +3929,7 @@ var AgentServer = class {
 		this.sessionOptions = options.session ?? {};
 		this.prepareShell = options.prepareShell ?? null;
 		this.notifyParentOnIdle = options.subagents?.notifyParentOnIdle ?? true;
+		this.maxLiveSubagents = options.subagents?.maxLiveSubagents ?? 8;
 	}
 	client() {
 		const transports = createInProcessTransportPair();
@@ -3720,6 +3945,7 @@ var AgentServer = class {
 			session: this.sessionOptions,
 			prepareShell: this.prepareShell,
 			notifyParentOnIdle: this.notifyParentOnIdle,
+			maxLiveSubagents: this.maxLiveSubagents,
 			sessions: this.sessionOwnership
 		});
 		this.bindings.add(binding);
@@ -3770,6 +3996,7 @@ var AgentTransportBindingImpl = class {
 	sessionOptions;
 	prepareShell;
 	notifyParentOnIdle;
+	maxLiveSubagents;
 	sessions;
 	session = null;
 	currentAgent = null;
@@ -3792,6 +4019,7 @@ var AgentTransportBindingImpl = class {
 		this.sessionOptions = options.session ?? {};
 		this.prepareShell = options.prepareShell;
 		this.notifyParentOnIdle = options.notifyParentOnIdle;
+		this.maxLiveSubagents = options.maxLiveSubagents;
 		this.sessions = options.sessions;
 		this.unsubscribeTransport = this.transport.onFrame((frame) => {
 			this.handleFrame(frame);
@@ -4003,6 +4231,7 @@ var AgentTransportBindingImpl = class {
 		};
 		const harnessCommands = await agent.commands?.(harnessContext) ?? [];
 		const profiles = await agent.agents?.(harnessContext) ?? null;
+		const directory = new AgentDirectory();
 		const supervisor = new ChildSupervisor({
 			agent,
 			cwd: frame.cwd,
@@ -4013,6 +4242,11 @@ var AgentTransportBindingImpl = class {
 			sessionOptions: this.sessionOptions,
 			notifyParentOnIdle: this.notifyParentOnIdle,
 			store: provisionalHost.store,
+			storePrefix: `agent-sessions/${agentSessionId}`,
+			directory,
+			maxLiveSubagents: this.maxLiveSubagents,
+			canSpawn: true,
+			onJobsChanged: null,
 			emit: (subagentFrame) => this.send(subagentFrame)
 		});
 		const commands = injectSubagentCommand(harnessCommands, supervisor.rootCommandNode());
@@ -4065,6 +4299,7 @@ var AgentTransportBindingImpl = class {
 		sessionRef = session;
 		this.session = session;
 		supervisor.attachParent(session);
+		directory.attachRoot(session, supervisor);
 		this.supervisor = supervisor;
 		this.currentAgent = agent;
 		this.currentCommandRegistry = commandRegistry;
@@ -4501,4 +4736,4 @@ function createProviderMap(providers) {
 	return map;
 }
 //#endregion
-export { AgentClient, AgentServer, AgentSession, ChildSupervisor, DEFAULT_MAX_MEDIA_BYTES, DEFAULT_TURN_RETRY_POLICY, MAX_ARCHIVED_SUBAGENTS, MAX_LIVE_SUBAGENTS, ProviderStreamError, RunCommandLineCommandNotRegisteredError, RunCommandLineShellNotFoundError, RunCommandLineTimeoutError, SHELL_VIEW_MAX_CHARS, SUBAGENT_RESULT_MAX_BYTES, TranscriptLog, applyTranscriptPatches, cloneBlocks, createInProcessTransportPair, createReadonlyHost, createStandardAgentTools, createWebSocketClientTransport, createWebSocketServerTransport, estimateTranscriptBlockTokens, findResumePoint, finishShellToolResult, injectSubagentCommand, isContextLengthExceeded, isRetryableCode, resolveRetryPolicy, retryDelayMs, shellCommandHandleRequired, shellPreviewBudgetTokens, toShellToolResult };
+export { AgentClient, AgentDirectory, AgentServer, AgentSession, ChildSupervisor, DEFAULT_MAX_MEDIA_BYTES, DEFAULT_TURN_RETRY_POLICY, MAX_LIVE_SUBAGENTS, ProviderStreamError, RunCommandLineCommandNotRegisteredError, RunCommandLineShellNotFoundError, RunCommandLineTimeoutError, SHELL_VIEW_MAX_CHARS, SUBAGENT_RESULT_MAX_BYTES, TranscriptLog, applyTranscriptPatches, cloneBlocks, createInProcessTransportPair, createReadonlyHost, createStandardAgentTools, createWebSocketClientTransport, createWebSocketServerTransport, estimateTranscriptBlockTokens, findResumePoint, finishShellToolResult, injectSubagentCommand, isContextLengthExceeded, isRetryableCode, resolveRetryPolicy, retryDelayMs, shellCommandHandleRequired, shellPreviewBudgetTokens, toShellToolResult };