@xl0/pi-lovely-agents 0.1.2 → 0.1.3

package/extensions/lovely-agents/agent.ts

@@ -12,18 +12,10 @@ import {
 } from "./child-session.js"
 import type { AgentsConfig } from "./config.js"
 import { resolveConfiguredModels } from "./config.js"
-import {
-	type AgentReservation,
-	getAgentCoordinator,
-	type ModelTuple,
-	type ResidentAgent,
-	type ResidentInputOptions,
-	type ResidentInputResult
-} from "./coordinator.js"
-import { type AgentDefinition, discoverAgentDefinitions } from "./definitions.js"
+import { getAgentCoordinator, type ResidentAgent, type ResidentInputOptions, type ResidentInputResult } from "./coordinator.js"
+import { type AgentDefinition, discoverAgentDefinitions, projectResourcesTrusted } from "./definitions.js"
 import { discardTask, stopOwnedTaskTree, stopTask } from "./lifecycle.js"
 import { appendTaskNotification, deliverTaskNotifications, prepareTaskNotification } from "./notifications.js"
-import { isProviderLimitError } from "./provider-limits.js"
 import { renderExpandableResult } from "./rendering.js"
 import {
 	type AgentTaskMetadata,
@@ -36,10 +28,10 @@ import {
 	MAX_AGENT_LABEL_BYTES,
 	MAX_QUEUED_FOLLOWUPS,
 	mutateTaskMetadata,
+	RETAINED_OUTPUT_MAX_WAIT_MS,
 	readRetainedOutput,
 	readTaskMetadata,
 	reserveTaskStorage,
-	retainedOutputSnapshot,
 	retainedPaths,
 	TASK_METADATA_VERSION,
 	TASK_REFERENCE_PATTERN,
@@ -49,7 +41,7 @@ import {
 	writeTaskMetadata,
 	writeTaskProgress
 } from "./state.js"
-import { loadTaskList } from "./tools.js"
+import { deferred } from "./utils.js"
 
 const ThinkingLevel = Type.Union([
 	Type.Literal("off"),
@@ -61,24 +53,6 @@ const ThinkingLevel = Type.Union([
 	Type.Literal("max")
 ])
 
-type RecoveryMode = "automatic" | "manual" | "stop"
-type SuspendedRuntime = {
-	wakeProviderRecovery(mode: RecoveryMode): boolean
-}
-const SUSPENDED_RUNTIMES_SYMBOL = Symbol.for("@xl0/pi-lovely-agents/suspended-runtimes/v1")
-
-/** Opens one tuple and wakes every process-resident run suspended on it. */
-export function recoverProviderTuple(tuple: ModelTuple): number {
-	getAgentCoordinator().openTuple(tuple)
-	const runtimes = suspendedRuntimes().get(modelTupleKey(tuple))
-	if (!runtimes) return 0
-	let recovered = 0
-	for (const runtime of [...runtimes]) {
-		if (runtime.wakeProviderRecovery("automatic")) recovered++
-	}
-	return recovered
-}
-
 export type AgentCreationResult = {
 	id: string
 	run: number
@@ -93,7 +67,6 @@ export type AgentCreationResult = {
 	detached: boolean
 	queuedFollowUps: number
 	output: Awaited<ReturnType<typeof readRetainedOutput>>
-	tasks: Awaited<ReturnType<typeof loadTaskList>>["details"]
 }
 
 export type TaskInputResult = {
@@ -106,27 +79,21 @@ export type TaskInputResult = {
 	state: TaskMetadata["state"]
 	latestOutcome: TaskMetadata["latestOutcome"]
 	queuedFollowUps: number
-	output?: Awaited<ReturnType<typeof readRetainedOutput>>
 }
 
 export type AgentToolOptions = {
 	getConfig: () => AgentsConfig
 	createChild?: typeof createChildSession
 	getAgentDir?: () => string
-	canDelegate?: () => boolean
-	/** Input-schema visibility from allowed producers plus retained owned kinds; not execution gates. */
-	agentInputEnabled?: () => boolean
-	bashInputEnabled?: () => boolean
 }
 
+/** Schemas and descriptions are static; config and depth limits are enforced at execution. */
 export function registerAgentTool(pi: ExtensionAPI, options: AgentToolOptions): void {
-	const background = options.getConfig().backgroundAgents
 	pi.registerTool({
 		name: "agent",
 		label: "Agent",
-		description: background
-			? "Create a durable Lovely Agent session and start its initial run. waitMs permits background detachment."
-			: "Create a durable Lovely Agent session and wait for its terminal result. Cancellation stops the accepted work.",
+		description:
+			"Create a durable Lovely Agent session and start its initial run. The call waits up to waitMs for the result, then detaches; a detached run notifies you when it ends. Cancellation before detachment stops the accepted work.",
 		promptSnippet: "Create or delegate work to a durable agent",
 		promptGuidelines: ["Call agent_roster before creating an agent and use task tools for existing work."],
 		parameters: Type.Object(
@@ -134,14 +101,14 @@ export function registerAgentTool(pi: ExtensionAPI, options: AgentToolOptions):
 				definition: Type.String({ minLength: 1, description: "Agent Definition name" }),
 				label: Type.String({ minLength: 1, description: "Short task label" }),
 				prompt: Type.String({ minLength: 1, description: "Initial task prompt" }),
-				...(background ? { waitMs: Type.Optional(Type.Integer({ minimum: 0, maximum: 600_000 })) } : {}),
+				waitMs: Type.Optional(
+					Type.Integer({ minimum: 0, maximum: RETAINED_OUTPUT_MAX_WAIT_MS, description: "Wait before detaching; 0 detaches immediately" })
+				),
 				model: Type.Optional(
 					Type.String({ minLength: 1, description: "Configured provider/model ID or an enabled alias from agent_roster" })
 				),
 				thinking: Type.Optional(ThinkingLevel),
-				...(options.canDelegate?.() === false
-					? {}
-					: { allowAgents: Type.Optional(Type.Boolean({ description: "Allow this child to create descendants" })) })
+				allowAgents: Type.Optional(Type.Boolean({ description: "Allow this child to create descendants, depth permitting" }))
 			},
 			{ additionalProperties: false }
 		),
@@ -181,17 +148,7 @@ export function registerAgentTool(pi: ExtensionAPI, options: AgentToolOptions):
 		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
 			if (signal?.aborted) throw abortError(signal)
 			const config = options.getConfig()
-			const background = config.backgroundAgents
-			if (!background && "waitMs" in params) throw new Error("waitMs requires backgroundAgents")
-			if (
-				"waitMs" in params &&
-				(typeof params.waitMs !== "number" || !Number.isInteger(params.waitMs) || params.waitMs < 0 || params.waitMs > 600_000)
-			) {
-				throw new Error("waitMs must be an integer from 0 to 600000")
-			}
-			if ("allowAgents" in params && typeof params.allowAgents !== "boolean") throw new Error("allowAgents must be boolean")
 			const allowAgents = params.allowAgents === true
-			if (allowAgents && options.canDelegate?.() === false) throw new Error("This child cannot delegate at the current maximum depth")
 			validateInput(params.label, "label", MAX_AGENT_LABEL_BYTES)
 			validateInput(params.prompt, "prompt", MAX_AGENT_INPUT_BYTES)
 			const parentSessionId = ctx.sessionManager.getSessionId()
@@ -199,6 +156,7 @@ export function registerAgentTool(pi: ExtensionAPI, options: AgentToolOptions):
 			const parentContext = coordinator.getSessionContext(parentSessionId)
 			if (parentContext && !parentContext.allowAgents) throw new Error("This parent agent is not allowed to delegate")
 			const parentDepth = parentContext?.depth ?? 0
+			if (allowAgents && parentDepth + 1 >= config.maxDepth) throw new Error("This child cannot delegate at the current maximum depth")
 			resolveChildToolPolicy({
 				parentDepth,
 				maximumDepth: config.maxDepth,
@@ -206,7 +164,7 @@ export function registerAgentTool(pi: ExtensionAPI, options: AgentToolOptions):
 			})
 			const discovered = discoverAgentDefinitions({
 				cwd: ctx.cwd,
-				projectTrusted: ctx.isProjectTrusted(),
+				projectTrusted: projectResourcesTrusted(ctx),
 				toolNames: pi.getAllTools().map(tool => tool.name),
 				models: ctx.modelRegistry.getAll(),
 				...(options.getAgentDir ? { agentDir: options.getAgentDir() } : {})
@@ -276,7 +234,6 @@ export function registerAgentTool(pi: ExtensionAPI, options: AgentToolOptions):
 						id: runId,
 						sequence: 1,
 						acceptanceOrder,
-						background,
 						kind: "initial",
 						state: "queued",
 						input: params.prompt,
@@ -288,27 +245,18 @@ export function registerAgentTool(pi: ExtensionAPI, options: AgentToolOptions):
 					createdAt: acceptedAt,
 					updatedAt: acceptedAt
 				}
-				await appendHistoryLog(paths, { type: "run-start", sequence: 1, kind: "initial", timestamp: acceptedAt })
-				await appendHistoryLog(paths, { type: "input", delivery: "initial", timestamp: acceptedAt, content: params.prompt })
 				await writeTaskMetadata(paths, metadata)
 				accepted = true
 
 				const runtime = new AgentRuntime(paths, child, metadata, config.expandPromptTemplates)
 				child = undefined
 				runtime.start()
-				if (!background) {
-					const completed = await runtime.waitForRun(runId, signal)
-					const tasks = (await loadTaskList(ctx.cwd, parentSessionId)).details
-					return buildAgentCreationToolResult(completed, false, retainedOutputSnapshot(paths, completed), tasks)
-				}
-				const waitMs = (params.waitMs as number | undefined) ?? config.waitMs
+				const waitMs = params.waitMs ?? config.waitMs
 				const wait = () => runtime.wait(waitMs, signal)
 				const detached = waitMs === 0 ? await wait() : await coordinator.withLentPermit(wait, signal)
 				const loaded = await readTaskMetadata(paths)
 				if (loaded.status !== "ok") throw new Error(`Could not read accepted task ${paths.taskRef}`)
-				const output = await readRetainedOutput(paths, { run: 1 })
-				const tasks = (await loadTaskList(ctx.cwd, parentSessionId)).details
-				return buildAgentCreationToolResult(loaded.metadata, detached, output, tasks)
+				return buildAgentCreationToolResult(loaded.metadata, detached, await readRetainedOutput(paths, { run: 1 }))
 			} finally {
 				child?.dispose()
 				if (!accepted) await rm(paths.taskDirectory, { recursive: true, force: true })
@@ -317,44 +265,25 @@ export function registerAgentTool(pi: ExtensionAPI, options: AgentToolOptions):
 	})
 }
 
+const TaskReference = Type.String({ pattern: TASK_REFERENCE_PATTERN.source, description: "Task Reference" })
+
 export function registerTaskInputTool(pi: ExtensionAPI, options: AgentToolOptions): void {
-	const background = options.getConfig().backgroundAgents
-	// Foreground agents remain a producer by default; the parent knows allowed producers and owned kinds.
-	const agentInput = options.agentInputEnabled?.() ?? true
-	const bashInput = options.bashInputEnabled?.() ?? options.getConfig().backgroundBash
 	pi.registerTool({
 		name: "task_input",
 		label: "Task Input",
 		description:
-			[
-				...(agentInput
-					? [
-							background
-								? "Send a durable Follow-up or live Steer to an owned Lovely Agent task."
-								: "Run a Follow-up on an idle owned task and wait for its terminal reply, or send a run-scoped live Steer. Busy tasks reject Follow-ups."
-						]
-					: []),
-				...(bashInput ? ["Write literal stdin to a running owned Bash task; eof closes stdin. Empty content requires eof:true."] : [])
-			].join(" ") || "Send input to an owned task.",
-		promptSnippet: agentInput
-			? `Send Follow-up work or a live Steer${bashInput ? ", or literal Bash stdin" : ""} to a durable task`
-			: bashInput
-				? "Write literal stdin to a running Bash task"
-				: "Send input to an owned task",
+			"Send a durable Follow-up or live Steer to an owned Lovely Agent task, or write literal stdin to a running owned Bash task; eof closes stdin. Empty content requires eof:true.",
+		promptSnippet: "Send Follow-up work or a live Steer, or literal Bash stdin, to a durable task",
 		promptGuidelines: [
-			...(agentInput
-				? [
-						"Use task_input Follow-up for a new run; Steer queues input for a live streaming run. Without a live steering target, Steer becomes a Follow-up (foreground busy tasks reject it). Acceptance does not guarantee observation before stop."
-					]
-				: []),
-			...(bashInput ? ["For Bash, omit delivery and write literal stdin; eof closes stdin without restarting the command."] : [])
+			"Use task_input Follow-up for a new run; Steer queues input for a live streaming run. Without a live steering target, Steer becomes a Follow-up. Acceptance does not guarantee observation before stop.",
+			"For Bash, omit delivery and write literal stdin; eof closes stdin without restarting the command."
 		],
 		parameters: Type.Object(
 			{
 				id: Type.String({ pattern: TASK_REFERENCE_PATTERN.source, description: "Task Reference" }),
-				content: Type.String({ minLength: bashInput ? 0 : 1, description: "Input text" }),
-				...(agentInput ? { delivery: Type.Optional(Type.Union([Type.Literal("followup"), Type.Literal("steer")])) } : {}),
-				...(bashInput ? { eof: Type.Optional(Type.Boolean({ description: "Close Bash stdin after writing content" })) } : {})
+				content: Type.String({ description: "Input text" }),
+				delivery: Type.Optional(Type.Union([Type.Literal("followup"), Type.Literal("steer")], { description: "Agent tasks only" })),
+				eof: Type.Optional(Type.Boolean({ description: "Bash only: close stdin after writing content" }))
 			},
 			{ additionalProperties: false }
 		),
@@ -369,11 +298,6 @@ export function registerTaskInputTool(pi: ExtensionAPI, options: AgentToolOption
 			)
 		},
 		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-			if ("waitMs" in params) throw new Error("task_input does not accept waitMs")
-			if (params.delivery !== undefined && params.delivery !== "followup" && params.delivery !== "steer") {
-				throw new Error("delivery must be followup or steer")
-			}
-			if (params.eof !== undefined && typeof params.eof !== "boolean") throw new Error("eof must be boolean")
 			const result = await sendTaskInput(
 				ctx,
 				options,
@@ -392,9 +316,7 @@ export function registerTaskInputTool(pi: ExtensionAPI, options: AgentToolOption
 								? `${result.id} run=${result.run}: stdin delivered${params.eof ? " (EOF)" : ""}`
 								: result.effectiveDelivery === "steer"
 									? `${result.id} run=${result.run}: steer queued for current run`
-									: result.output
-										? `${result.id} run=${result.run}: ${result.conversionReason ? `requested steer -> followup (${result.conversionReason}); ` : ""}followup ${result.latestOutcome}\n${result.output.text}`
-										: `${result.id} run=${result.run}: ${result.conversionReason ? `requested steer -> ` : ""}followup accepted${result.conversionReason ? `; ${result.conversionReason}` : ""} (position ${result.queuePosition}; task=${result.state}; ${result.queuedFollowUps} queued)`
+									: `${result.id} run=${result.run}: ${result.conversionReason ? `requested steer -> ` : ""}followup accepted${result.conversionReason ? `; ${result.conversionReason}` : ""} (position ${result.queuePosition}; task=${result.state}; ${result.queuedFollowUps} queued)`
 					}
 				],
 				details: result
@@ -408,8 +330,8 @@ export function registerTaskInputTool(pi: ExtensionAPI, options: AgentToolOption
 			label: action === "stop" ? "Task Stop" : "Task Discard",
 			description:
 				action === "stop"
-					? "Stop active or queued work for an owned Agent or Bash task while preserving its files."
-					: "Stop and permanently discard an owned task subtree from active work. Files stay at their original paths for read-only inspection. Unsupported metadata versions can also be discarded.",
+					? "Stop active or queued work for owned Agent or Bash tasks while preserving their files; id accepts one Task Reference or a list."
+					: "Stop and permanently discard owned task subtrees from active work; id accepts one Task Reference or a list. Files stay at their original paths for read-only inspection.",
 			promptSnippet: action === "stop" ? "Stop work for a durable task" : "Discard a durable task",
 			promptGuidelines:
 				action === "discard"
@@ -418,26 +340,39 @@ export function registerTaskInputTool(pi: ExtensionAPI, options: AgentToolOption
 						]
 					: [],
 			parameters: Type.Object(
-				{ id: Type.String({ pattern: TASK_REFERENCE_PATTERN.source, description: "Task Reference" }) },
+				{
+					id: Type.Union([TaskReference, Type.Array(TaskReference, { minItems: 1, maxItems: 64, uniqueItems: true })], {
+						description: "One Task Reference, or a list to handle in one call"
+					})
+				},
 				{ additionalProperties: false }
 			),
 			renderCall(args, theme) {
-				return new Text(`${theme.fg("toolTitle", theme.bold(`task_${action}`))}${args.id ? ` ${theme.fg("muted", args.id)}` : ""}`, 0, 0)
+				const ids = [args.id ?? []].flat().join(" ")
+				return new Text(`${theme.fg("toolTitle", theme.bold(`task_${action}`))}${ids ? ` ${theme.fg("muted", ids)}` : ""}`, 0, 0)
 			},
 			async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-				const details = await controlTaskLifecycle(ctx, params.id, action)
-				return {
-					content: [
-						{
-							type: "text",
-							text:
-								action === "discard"
-									? `${details.id}: discarded (files retained at ${details.taskDirectory})`
-									: `${details.id}: stop complete (${details.state}; outcome ${details.latestOutcome ?? "none"}; ${details.queuedFollowUps} queued)`
-						}
-					],
-					details
+				const describe = (details: Awaited<ReturnType<typeof controlTaskLifecycle>>) =>
+					action === "discard"
+						? `${details.id}: discarded (files retained at ${details.taskDirectory})`
+						: `${details.id}: stop complete (${details.state}; outcome ${details.latestOutcome ?? "none"}; ${details.queuedFollowUps} queued)`
+				if (typeof params.id === "string") {
+					const details = await controlTaskLifecycle(ctx, params.id, action)
+					return { content: [{ type: "text", text: describe(details) }], details }
+				}
+				// One bad reference must not abandon the rest of a batch; only a total failure is a tool error.
+				const tasks: Array<Awaited<ReturnType<typeof controlTaskLifecycle>>> = []
+				const errors: Array<{ id: string; message: string }> = []
+				for (const id of params.id) {
+					try {
+						tasks.push(await controlTaskLifecycle(ctx, id, action))
+					} catch (error) {
+						errors.push({ id, message: error instanceof Error ? error.message : String(error) })
+					}
 				}
+				const text = [...tasks.map(describe), ...errors.map(error => `${error.id}: failed: ${error.message}`)].join("\n")
+				if (tasks.length === 0) throw new Error(text)
+				return { content: [{ type: "text", text }], details: { tasks, errors } }
 			}
 		})
 	}
@@ -453,11 +388,6 @@ export async function sendTaskInput(
 	inputOptions: { eof?: boolean } = {}
 ): Promise<TaskInputResult> {
 	if (signal?.aborted) throw abortError(signal)
-	if (typeof content !== "string") throw new Error("content must be a string")
-	if (inputOptions.eof !== undefined && typeof inputOptions.eof !== "boolean") throw new Error("eof must be boolean")
-	if (requestedDelivery !== undefined && requestedDelivery !== "followup" && requestedDelivery !== "steer") {
-		throw new Error("delivery must be followup or steer")
-	}
 	if (!id.startsWith("b_")) validateInput(content, "content", MAX_AGENT_INPUT_BYTES)
 	const lease = await acquireParentLease(ctx.cwd, ctx.sessionManager.getSessionId())
 	const paths = taskStoragePaths(lease.paths, id)
@@ -494,10 +424,7 @@ export async function sendTaskInput(
 		if (signal?.aborted) throw abortError(signal)
 		const runtime = await controllableRuntime(ctx, paths, options)
 		try {
-			accepted = await runtime.input(content, delivery, {
-				background: options.getConfig().backgroundAgents,
-				...(signal ? { signal } : {})
-			})
+			accepted = await runtime.input(content, delivery, signal ? { signal } : {})
 		} catch (error) {
 			if (!isRuntimeClosingError(error)) throw error
 			await new Promise(resolve => setTimeout(resolve, 0))
@@ -512,10 +439,9 @@ export async function sendTaskInput(
 		requestedDelivery: delivery,
 		effectiveDelivery: accepted.delivery,
 		queuePosition: accepted.queuePosition,
-		state: accepted.completed?.state ?? current.metadata.state,
-		latestOutcome: accepted.completed?.latestOutcome ?? current.metadata.latestOutcome,
-		queuedFollowUps: accepted.completed?.queuedFollowUps.length ?? current.metadata.queuedFollowUps.length,
-		...(accepted.completed ? { output: retainedOutputSnapshot(paths, accepted.completed) } : {})
+		state: current.metadata.state,
+		latestOutcome: current.metadata.latestOutcome,
+		queuedFollowUps: current.metadata.queuedFollowUps.length
 	}
 }
 
@@ -559,41 +485,32 @@ class AgentRuntime implements ResidentAgent {
 	readonly #paths: TaskStoragePaths
 	readonly #child: ChildSessionHandle
 	readonly #expandPromptTemplates: boolean
-	readonly #tuple: ModelTuple
 	readonly #scheduleAbort = new AbortController()
 	readonly #initialRunId: string | undefined
 	readonly #initialCompletion = deferred<void>()
 	readonly #runtimeCompletion = deferred<void>()
 	readonly #toolArguments = new Map<string, { name: string; arguments: string }>()
-	readonly #pendingSteers: Array<{ content: string }> = []
-	readonly #reservations = new Map<string, AgentReservation>()
-	readonly #completions = new Map<string, ReturnType<typeof deferred<TaskMetadata | undefined>>>()
 	#unbindResident: (() => void) | undefined
-	#unbindSuspended: (() => void) | undefined
 	#unsubscribe: (() => void) | undefined
 	#eventWrites: Promise<void> = Promise.resolve()
-	#eventWriteFailed = false
 	#recordingRunId: string | undefined
 	#pendingProgress: ({ runId: string } & Partial<Pick<TaskMetadata, "latestReply" | "lastActivity">>) | undefined
 	#lastHeartbeatAt = 0
 	#progressWriteQueued = false
+	#progressTimer: ReturnType<typeof setTimeout> | undefined
+	#lastProgressWriteAt = 0
 	#started = false
 	#stopRequested = false
 	#accepting = true
 	#disposed = false
-	#awaitingPrimaryInput = false
+	#sawInput = false
 	#lastAssistantOutcome: NonNullable<TaskMetadata["latestOutcome"]> | undefined
-	#providerLimitReached = false
-	#recoveryWait: (ReturnType<typeof deferred<RecoveryMode>> & { mode: RecoveryMode | undefined }) | undefined
-	#recoveryMode: Exclude<RecoveryMode, "stop"> | undefined
 
 	constructor(paths: TaskStoragePaths, child: ChildSessionHandle, metadata: AgentTaskMetadata, expandPromptTemplates: boolean) {
 		this.#paths = paths
 		this.#child = child
 		this.#initialRunId = metadata.activeRun?.kind === "initial" ? metadata.activeRun.id : undefined
 		this.#expandPromptTemplates = expandPromptTemplates
-		this.#tuple = { provider: metadata.model.provider, model: metadata.model.id }
-		if (metadata.activeRun && !metadata.activeRun.background) this.#completions.set(metadata.activeRun.id, deferred())
 		this.#unbindResident = getAgentCoordinator().bindResident(paths.taskDirectory, this)
 		this.#unsubscribe = child.session.subscribe(event => this.recordEvent(event))
 	}
@@ -604,37 +521,12 @@ class AgentRuntime implements ResidentAgent {
 		void this.run().catch(() => {})
 	}
 
-	/** Run-specific synchronous wait; cancellation owns the accepted run and its descendants. */
-	async waitForRun(runId: string, signal?: AbortSignal): Promise<TaskMetadata> {
-		const completion = this.#completions.get(runId)
-		if (!completion) throw new Error(`Missing completion for run ${runId}`)
-		return getAgentCoordinator().withLentPermit(async () => {
-			const aborted = deferred<void>()
-			const onAbort = () => aborted.resolve(undefined)
-			signal?.addEventListener("abort", onAbort, { once: true })
-			if (signal?.aborted) onAbort()
-			try {
-				const result = await Promise.race([completion.promise, aborted.promise.then(() => undefined)])
-				if (signal?.aborted) {
-					await this.stop()
-					await stopOwnedTaskTree(this.#paths.workspace, this.#child.session.sessionId)
-					throw abortError(signal)
-				}
-				if (!result) throw new Error(`Agent run ${runId} ended without a retained terminal result`)
-				return result
-			} finally {
-				signal?.removeEventListener("abort", onAbort)
-				this.#completions.delete(runId)
-			}
-		}, signal)
-	}
-
 	async wait(waitMs: number, signal?: AbortSignal): Promise<boolean> {
 		if (waitMs === 0) {
 			await this.detach()
 			return true
 		}
-		if (signal?.aborted) await this.stop()
+		if (signal?.aborted) await this.stopTree()
 		let timer: ReturnType<typeof setTimeout> | undefined
 		let onAbort: (() => void) | undefined
 		const timeout = new Promise<"timeout">(resolve => {
@@ -655,7 +547,7 @@ class AgentRuntime implements ResidentAgent {
 		if (timer) clearTimeout(timer)
 		if (signal && onAbort) signal.removeEventListener("abort", onAbort)
 		if (result === "aborted") {
-			await this.stop()
+			await this.stopTree()
 			return false
 		}
 		if (result === "timeout") {
@@ -665,11 +557,16 @@ class AgentRuntime implements ResidentAgent {
 		return false
 	}
 
+	/** Cancellation owns the accepted run and any descendants it already detached. */
+	private async stopTree(): Promise<void> {
+		await this.stop()
+		await stopOwnedTaskTree(this.#paths.workspace, this.#child.session.sessionId)
+	}
+
 	async stop(): Promise<void> {
 		if (this.#stopRequested) return this.#runtimeCompletion.promise
 		this.#stopRequested = true
 		this.#accepting = false
-		this.wakeProviderRecovery("stop")
 		this.#scheduleAbort.abort(new Error("Agent run stopped"))
 		await this.#child.session.abort()
 		const loaded = await readTaskMetadata(this.#paths)
@@ -697,8 +594,6 @@ class AgentRuntime implements ResidentAgent {
 		this.#unsubscribe = undefined
 		this.#unbindResident?.()
 		this.#unbindResident = undefined
-		this.#unbindSuspended?.()
-		this.#unbindSuspended = undefined
 		this.#child.dispose()
 	}
 
@@ -706,24 +601,15 @@ class AgentRuntime implements ResidentAgent {
 		if (delivery === "stdin" || options.eof !== undefined) throw new Error("Agent tasks do not accept stdin or eof")
 		if (!this.#accepting || this.#disposed) throw new RuntimeClosingError()
 		let result: ResidentInputResult | undefined
-		let acceptedRun: NonNullable<TaskMetadata["activeRun"]> | undefined
 		try {
 			await mutateTaskMetadata(this.#paths, async metadata => {
 				if (options.signal?.aborted) throw abortError(options.signal)
 				if (!this.#accepting || this.#disposed) throw new RuntimeClosingError()
 				if (metadata.discardedAt !== null) throw new Error(`Task ${metadata.taskRef} has been discarded`)
 				if (delivery === "steer" && metadata.state === "running" && metadata.activeRun && this.#child.session.isStreaming) {
-					const pending = { content }
-					this.#pendingSteers.push(pending)
-					try {
-						// prompt() can yield in input hooks and start a new run after streaming ends.
-						if (this.#expandPromptTemplates) await this.#child.session.steer(content)
-						else this.#child.session.agent.steer({ role: "user", content, timestamp: Date.now() })
-					} catch (error) {
-						const index = this.#pendingSteers.indexOf(pending)
-						if (index >= 0) this.#pendingSteers.splice(index, 1)
-						throw error
-					}
+					// prompt() can yield in input hooks and start a new run after streaming ends.
+					if (this.#expandPromptTemplates) await this.#child.session.steer(content)
+					else this.#child.session.agent.steer({ role: "user", content, timestamp: Date.now() })
 					result = {
 						run: metadata.activeRun.sequence,
 						delivery: "steer",
@@ -732,12 +618,6 @@ class AgentRuntime implements ResidentAgent {
 					}
 					return metadata
 				}
-				if (
-					(!options.background && (metadata.activeRun || metadata.queuedFollowUps.length)) ||
-					(metadata.activeRun && !metadata.activeRun.background)
-				) {
-					throw new Error(`Task ${metadata.taskRef} is busy; foreground Follow-ups require an idle task`)
-				}
 				if (metadata.queuedFollowUps.length >= MAX_QUEUED_FOLLOWUPS) {
 					throw new Error(`Task ${metadata.taskRef} already has ${MAX_QUEUED_FOLLOWUPS} queued Follow-ups`)
 				}
@@ -753,11 +633,10 @@ class AgentRuntime implements ResidentAgent {
 					queuedFollowUps: metadata.queuedFollowUps.length + 1,
 					...(delivery === "steer" ? { conversionReason: `task ${metadata.state}, no live stream to steer` } : {})
 				}
-				acceptedRun = {
+				const acceptedRun: NonNullable<TaskMetadata["activeRun"]> = {
 					id: runId,
 					sequence,
 					acceptanceOrder,
-					background: options.background ?? false,
 					kind: "followup",
 					state: "queued",
 					input: content,
@@ -776,10 +655,7 @@ class AgentRuntime implements ResidentAgent {
 				return {
 					...metadata,
 					lastRunSequence: sequence,
-					queuedFollowUps: [
-						...metadata.queuedFollowUps,
-						{ id: runId, sequence, acceptanceOrder, background: options.background ?? false, content, acceptedAt }
-					],
+					queuedFollowUps: [...metadata.queuedFollowUps, { id: runId, sequence, acceptanceOrder, content, acceptedAt }],
 					updatedAt: acceptedAt
 				}
 			})
@@ -793,47 +669,19 @@ class AgentRuntime implements ResidentAgent {
 			throw error
 		}
 		if (!result) throw new Error("Task input was not accepted")
-		if (acceptedRun) {
-			if (!acceptedRun.background) this.#completions.set(acceptedRun.id, deferred())
-			// Inactive background reservations preserve acceptance order across promotion.
-			if (acceptedRun.background) this.reserveRun(acceptedRun)
-		}
 		this.start()
-		if (acceptedRun && !acceptedRun.background) result.completed = await this.waitForRun(acceptedRun.id, options.signal)
 		return result
 	}
 
-	recover(): boolean {
-		return this.wakeProviderRecovery("manual")
-	}
-
-	wakeProviderRecovery(mode: RecoveryMode): boolean {
-		const wait = this.#recoveryWait
-		if (!wait || wait.mode || this.#disposed || (this.#stopRequested && mode !== "stop")) return false
-		wait.mode = mode
-		this.#unbindSuspended?.()
-		this.#unbindSuspended = undefined
-		wait.resolve(mode)
-		return true
-	}
-
 	private async run(): Promise<void> {
 		try {
 			while (!this.#stopRequested) {
 				const activeRun = await this.nextRun()
 				if (!activeRun) break
-				if (await this.executeRun(activeRun)) {
-					const wait = this.#recoveryWait
-					if (!wait) throw new Error("Suspended run has no recovery wait")
-					const mode = await wait.promise
-					if (this.#recoveryWait === wait) this.#recoveryWait = undefined
-					if (mode === "stop") break
-					this.#recoveryMode = mode
-				}
+				await this.executeRun(activeRun)
 			}
 		} finally {
 			this.dispose()
-			for (const completion of this.#completions.values()) completion.resolve(undefined)
 			this.#initialCompletion.resolve(undefined)
 			this.#runtimeCompletion.resolve(undefined)
 		}
@@ -855,7 +703,6 @@ class AgentRuntime implements ResidentAgent {
 				id: next.id,
 				sequence: next.sequence,
 				...(next.acceptanceOrder ? { acceptanceOrder: next.acceptanceOrder } : {}),
-				background: next.background ?? false,
 				kind: "followup",
 				state: "queued",
 				input: next.content,
@@ -866,19 +713,17 @@ class AgentRuntime implements ResidentAgent {
 		return selected.run
 	}
 
-	private async executeRun(run: NonNullable<TaskMetadata["activeRun"]>): Promise<boolean> {
+	private async executeRun(run: NonNullable<TaskMetadata["activeRun"]>): Promise<void> {
 		this.#recordingRunId = run.id
 		this.#lastHeartbeatAt = 0
 		let outcome: NonNullable<TaskMetadata["latestOutcome"]> = "failed"
-		const recovering = run.state === "suspended"
 		this.#lastAssistantOutcome = undefined
-		this.#providerLimitReached = false
 		let settled = false
-		let suspended = false
 		try {
-			await this.reserveRun(run).run(async () => {
+			// The stored acceptance order puts a promoted Follow-up ahead of later-accepted work.
+			const schedule = { signal: this.#scheduleAbort.signal, ...(run.acceptanceOrder ? { acceptanceOrder: run.acceptanceOrder } : {}) }
+			await getAgentCoordinator().run(schedule, async () => {
 				if (this.#stopRequested) return
-				let promptCompleted = false
 				try {
 					let won = false
 					const startedAt = Date.now()
@@ -895,116 +740,33 @@ class AgentRuntime implements ResidentAgent {
 						}
 					})
 					if (!won) return
-					this.#recoveryMode = undefined
-					if (run.kind === "followup" && !recovering) {
-						await appendHistoryLog(this.#paths, {
-							type: "run-start",
-							sequence: run.sequence,
-							kind: "followup",
-							timestamp: startedAt
-						})
-						await appendHistoryLog(this.#paths, {
-							type: "input",
-							delivery: "followup",
-							timestamp: startedAt,
-							content: run.input
-						})
-					}
-					this.#awaitingPrimaryInput = true
-					await this.#child.prompt(
-						run.id,
-						recovering ? "Continue." : run.input,
-						childPromptOptions(recovering ? false : this.#expandPromptTemplates)
-					)
-					promptCompleted = true
+					// Inputs are logged as the child session observes them: the first is the run's
+					// prompt, later ones are delivered Steers.
+					this.#sawInput = false
+					this.queueEventWrite(() => appendHistoryLog(this.#paths, { type: "run-start", sequence: run.sequence, kind: run.kind }))
+					await this.#child.prompt(run.id, run.input, childPromptOptions(this.#expandPromptTemplates))
 					await this.#eventWrites
-					if (this.#eventWriteFailed) throw new Error("Could not retain one or more child session events")
 					outcome = this.#stopRequested ? "stopped" : (this.#lastAssistantOutcome ?? "failed")
 				} catch {
-					if (!promptCompleted) this.#providerLimitReached = false
 					await this.#eventWrites
 					outcome = this.#stopRequested ? "stopped" : "failed"
 				}
-				if (!this.#stopRequested && this.#providerLimitReached) {
-					suspended = await this.suspend(run)
-					if (suspended) return
-				}
-				const promoted = await this.settle(run, outcome, this.#stopRequested)
+				await this.settle(run, outcome, this.#stopRequested)
 				settled = true
-				if (promoted) this.reserveRun(promoted).activate()
 			})
-		} catch (error) {
+		} catch {
 			await this.#eventWrites
 			outcome = this.#stopRequested ? "stopped" : "failed"
-			if (!run.background && !this.#stopRequested) {
-				await mutateTaskMetadata(this.#paths, metadata =>
-					metadata.activeRun?.id === run.id
-						? {
-								...metadata,
-								latestReply: { text: error instanceof Error ? error.message : String(error), streaming: false },
-								updatedAt: Date.now()
-							}
-						: metadata
-				)
-			}
 		}
 		this.#child.session.clearQueue()
-		this.#pendingSteers.length = 0
-		this.#reservations.delete(run.id)
-		if (!settled && !suspended) {
-			const promoted = await this.settle(run, outcome, this.#stopRequested)
-			if (promoted) this.reserveRun(promoted).activate()
-		}
-		return suspended
-	}
-
-	private async suspend(run: NonNullable<TaskMetadata["activeRun"]>): Promise<boolean> {
-		// Provider evidence is tuple-global even if another task mutation wins.
-		getAgentCoordinator().closeTuple(this.#tuple)
-		if (!run.background) {
-			await writeTaskProgress(this.#paths, run.id, {
-				latestReply: { text: "Provider limit reached; foreground run failed and will not restart automatically.", streaming: false }
-			})
-			return false
-		}
-		const wait = Object.assign(deferred<RecoveryMode>(), { mode: undefined as RecoveryMode | undefined })
-		const unbind = bindSuspendedRuntime(this.#tuple, this)
-		this.#recoveryWait = wait
-		this.#unbindSuspended = unbind
-		let won = false
-		let notification: TaskMetadata["notifications"][number] | undefined
-		const timestamp = Date.now()
-		await mutateTaskMetadata(this.#paths, async metadata => {
-			const activeRun = metadata.activeRun
-			if (!activeRun || activeRun.id !== run.id) return metadata
-			won = true
-			if (run.kind === "followup" || activeRun.detachedAt !== undefined) {
-				notification = await prepareTaskNotification(this.#paths, metadata, activeRun, "suspension")
-			}
-			return {
-				...metadata,
-				state: "suspended",
-				activeRun: { ...activeRun, state: "suspended" },
-				...(notification ? { notifications: appendTaskNotification(metadata.notifications, notification) } : {}),
-				updatedAt: timestamp
-			}
-		})
-		if (won) {
-			if (run.id === this.#initialRunId) this.#initialCompletion.resolve(undefined)
-			if (notification) await deliverTaskNotifications(this.#paths).catch(() => {})
-		} else {
-			unbind()
-			if (this.#recoveryWait === wait) this.#recoveryWait = undefined
-			if (this.#unbindSuspended === unbind) this.#unbindSuspended = undefined
-		}
-		return won
+		if (!settled) await this.settle(run, outcome, this.#stopRequested)
 	}
 
 	private async detach(): Promise<void> {
 		const detachedAt = Date.now()
 		await mutateTaskMetadata(this.#paths, metadata => {
 			const activeRun = metadata.activeRun
-			if (!activeRun?.background || activeRun.id !== this.#initialRunId || activeRun.detachedAt !== undefined) return metadata
+			if (!activeRun || activeRun.id !== this.#initialRunId || activeRun.detachedAt !== undefined) return metadata
 			return { ...metadata, activeRun: { ...activeRun, detachedAt }, updatedAt: detachedAt }
 		})
 	}
@@ -1013,39 +775,24 @@ class AgentRuntime implements ResidentAgent {
 		run: NonNullable<TaskMetadata["activeRun"]>,
 		outcome: NonNullable<TaskMetadata["latestOutcome"]>,
 		clearFollowUps = false
-	): Promise<NonNullable<TaskMetadata["activeRun"]> | null> {
+	): Promise<void> {
 		let won = false
-		const promoted: { run: NonNullable<TaskMetadata["activeRun"]> | null } = { run: null }
 		let notification: TaskMetadata["notifications"][number] | undefined
-		let completed: TaskMetadata | undefined
 		const timestamp = Date.now()
 		await mutateTaskMetadata(this.#paths, async metadata => {
 			const activeRun = metadata.activeRun
 			if (activeRun?.id !== run.id) return clearFollowUps ? { ...metadata, queuedFollowUps: [], updatedAt: timestamp } : metadata
 			won = true
-			completed = {
-				...metadata,
-				state: "idle",
-				latestOutcome: outcome,
-				lastSettledRun: run.sequence,
-				activeRun: null,
-				queuedFollowUps: [],
-				updatedAt: timestamp
-			}
-			if (
-				activeRun.background &&
-				(outcome === "succeeded" || outcome === "failed") &&
-				(run.kind === "followup" || activeRun.detachedAt !== undefined)
-			) {
+			if ((outcome === "succeeded" || outcome === "failed") && (run.kind === "followup" || activeRun.detachedAt !== undefined)) {
 				notification = await prepareTaskNotification(this.#paths, metadata, activeRun, "completion", outcome)
 			}
 			const [next, ...remaining] = clearFollowUps ? [] : metadata.queuedFollowUps
 			if (next) {
-				promoted.run = {
+				// Promote atomically: an idle gap would let new input jump the queue.
+				const promoted: NonNullable<TaskMetadata["activeRun"]> = {
 					id: next.id,
 					sequence: next.sequence,
 					...(next.acceptanceOrder ? { acceptanceOrder: next.acceptanceOrder } : {}),
-					background: next.background ?? false,
 					kind: "followup",
 					state: "queued",
 					input: next.content,
@@ -1055,7 +802,7 @@ class AgentRuntime implements ResidentAgent {
 					...metadata,
 					state: "queued",
 					latestOutcome: outcome,
-					activeRun: promoted.run,
+					activeRun: promoted,
 					queuedFollowUps: remaining,
 					...(notification ? { notifications: appendTaskNotification(metadata.notifications, notification) } : {}),
 					updatedAt: timestamp
@@ -1071,28 +818,10 @@ class AgentRuntime implements ResidentAgent {
 				updatedAt: timestamp
 			}
 		})
-		if (won) await appendHistoryLog(this.#paths, { type: "run-end", sequence: run.sequence, outcome, timestamp })
+		// Observability only: a failed append must not skip notification delivery below.
+		if (won) await appendHistoryLog(this.#paths, { type: "run-end", sequence: run.sequence, outcome }).catch(() => {})
 		if (won && notification) await deliverTaskNotifications(this.#paths).catch(() => {})
-		if (won) this.#completions.get(run.id)?.resolve(completed)
 		if (run.id === this.#initialRunId) this.#initialCompletion.resolve(undefined)
-		return promoted.run
-	}
-
-	private reserveRun(run: NonNullable<TaskMetadata["activeRun"]>): AgentReservation {
-		const existing = this.#reservations.get(run.id)
-		if (existing) return existing
-		const tuple =
-			run.state === "suspended" && this.#recoveryMode === "manual"
-				? { provider: `${this.#tuple.provider}#manual#${this.#paths.taskRef}`, model: this.#tuple.model }
-				: this.#tuple
-		const reservation = getAgentCoordinator().reserve({
-			tuple,
-			signal: this.#scheduleAbort.signal,
-			rejectOnClosedTuple: !run.background,
-			...(run.acceptanceOrder ? { acceptanceOrder: run.acceptanceOrder } : {})
-		})
-		this.#reservations.set(run.id, reservation)
-		return reservation
 	}
 
 	private recordEvent(event: AgentSessionEvent): void {
@@ -1123,11 +852,7 @@ class AgentRuntime implements ResidentAgent {
 			event.message.role === "assistant" &&
 			(event.type !== "message_update" || event.assistantMessageEvent.type === "text_delta")
 		) {
-			const text = event.message.content
-				.filter(part => part.type === "text")
-				.map(part => part.text)
-				.join("")
-			latestReply = { text, streaming: event.type !== "message_end" }
+			latestReply = { text: messageText(event.message.content), streaming: event.type !== "message_end" }
 			action = latestReply.streaming ? "responding" : "reply complete"
 		}
 		if (runId && action) {
@@ -1137,21 +862,7 @@ class AgentRuntime implements ResidentAgent {
 				...(latestReply ? { latestReply } : {}),
 				lastActivity: { at, action }
 			}
-			if (!this.#progressWriteQueued) {
-				this.#progressWriteQueued = true
-				this.queueEventWrite(async () => {
-					try {
-						// Coalesce replies and activity together so bursts cannot reorder their last action.
-						while (this.#pendingProgress) {
-							const { runId, ...progress } = this.#pendingProgress
-							this.#pendingProgress = undefined
-							await writeTaskProgress(this.#paths, runId, progress)
-						}
-					} finally {
-						this.#progressWriteQueued = false
-					}
-				})
-			}
+			this.scheduleProgressWrite(latestReply?.streaming === true)
 		}
 		if (event.type === "tool_execution_start") {
 			this.#toolArguments.set(event.toolCallId, { name: event.toolName, arguments: renderUnknown(event.args) })
@@ -1159,37 +870,14 @@ class AgentRuntime implements ResidentAgent {
 		}
 		if (event.type === "message_end" && event.message.role === "assistant") {
 			this.#lastAssistantOutcome = event.message.stopReason === "error" || event.message.stopReason === "aborted" ? "failed" : "succeeded"
-			this.#providerLimitReached = event.message.stopReason === "error" && isProviderLimitError(event.message.errorMessage)
-			const content = event.message.content
-				.filter(part => part.type === "text")
-				.map(part => part.text)
-				.join("")
+			const content = messageText(event.message.content)
 			if (content) this.queueEventWrite(() => appendHistoryLog(this.#paths, { type: "assistant", content }))
 			return
 		}
-		if (event.type === "message_start" && event.message.role === "user" && this.#awaitingPrimaryInput) {
-			this.#awaitingPrimaryInput = false
-			return
-		}
-		if (event.type === "message_start" && event.message.role === "user" && this.#pendingSteers.length > 0) {
-			const delivered = this.#pendingSteers.shift()
-			if (delivered) {
-				const content =
-					typeof event.message.content === "string"
-						? event.message.content
-						: event.message.content
-								.filter(part => part.type === "text")
-								.map(part => part.text)
-								.join("")
-				this.queueEventWrite(() =>
-					appendHistoryLog(this.#paths, {
-						type: "input",
-						delivery: "steer",
-						timestamp: Date.now(),
-						content: content || delivered.content
-					})
-				)
-			}
+		if (event.type === "message_start" && event.message.role === "user") {
+			const entry = { type: this.#sawInput ? ("steer" as const) : ("user" as const), content: messageText(event.message.content) }
+			this.#sawInput = true
+			this.queueEventWrite(() => appendHistoryLog(this.#paths, entry))
 			return
 		}
 		if (event.type === "tool_execution_end") {
@@ -1207,11 +895,45 @@ class AgentRuntime implements ResidentAgent {
 		}
 	}
 
-	private queueEventWrite(write: () => Promise<void>): void {
-		this.#eventWrites = this.#eventWrites.then(write).catch(() => {
-			this.#eventWriteFailed = true
+	/**
+	 * Each write rewrites and fsyncs the whole snapshot, so streaming deltas are
+	 * capped at two per second; completed replies and tool activity flush at once.
+	 */
+	private scheduleProgressWrite(deferrable: boolean): void {
+		const wait = deferrable ? this.#lastProgressWriteAt + 500 - Date.now() : 0
+		if (wait > 0) {
+			this.#progressTimer ??= setTimeout(() => this.scheduleProgressWrite(false), wait)
+			this.#progressTimer.unref()
+			return
+		}
+		clearTimeout(this.#progressTimer)
+		this.#progressTimer = undefined
+		if (this.#progressWriteQueued) return
+		this.#progressWriteQueued = true
+		this.queueEventWrite(async () => {
+			try {
+				// Coalesce replies and activity together so bursts cannot reorder their last action.
+				// Drain inside this one chain link: settlement awaits the chain it saw, so a
+				// terminal reply arriving mid-write must not be deferred to a later link.
+				while (this.#pendingProgress) {
+					if (this.#pendingProgress.latestReply?.streaming === true && this.#lastProgressWriteAt + 500 > Date.now()) break
+					const { runId, ...progress } = this.#pendingProgress
+					this.#pendingProgress = undefined
+					this.#lastProgressWriteAt = Date.now()
+					await writeTaskProgress(this.#paths, runId, progress)
+				}
+			} finally {
+				this.#progressWriteQueued = false
+				// Only a throttled streaming snapshot can remain.
+				if (this.#pendingProgress) this.scheduleProgressWrite(true)
+			}
 		})
 	}
+
+	private queueEventWrite(write: () => Promise<void>): void {
+		// history.md and progress snapshots are observability; their I/O errors never decide a run's outcome.
+		this.#eventWrites = this.#eventWrites.then(write).catch(() => {})
+	}
 }
 
 class RuntimeClosingError extends Error {
@@ -1307,8 +1029,7 @@ function coldRuntimeLoads(): Map<string, Promise<AgentRuntime>> {
 function buildAgentCreationToolResult(
 	metadata: TaskMetadata,
 	detached: boolean,
-	output: Awaited<ReturnType<typeof readRetainedOutput>>,
-	tasks: Awaited<ReturnType<typeof loadTaskList>>["details"]
+	output: Awaited<ReturnType<typeof readRetainedOutput>>
 ): { content: [{ type: "text"; text: string }]; details: AgentCreationResult } {
 	if (metadata.kind !== "agent") throw new Error("Expected an Agent task")
 	const result: AgentCreationResult = {
@@ -1324,10 +1045,9 @@ function buildAgentCreationToolResult(
 		allowAgents: metadata.allowAgents,
 		detached,
 		queuedFollowUps: metadata.queuedFollowUps.length,
-		output,
-		tasks
+		output
 	}
-	const pending = detached && (result.state === "queued" || result.state === "running" || result.state === "suspended")
+	const pending = detached && (result.state === "queued" || result.state === "running")
 	return {
 		content: [
 			{
@@ -1360,6 +1080,10 @@ function createRunId(): string {
 	return `r_${randomBytes(8).toString("hex")}`
 }
 
+function messageText(content: string | ReadonlyArray<{ type: string; text?: string }>): string {
+	return typeof content === "string" ? content : content.map(part => (part.type === "text" ? (part.text ?? "") : "")).join("")
+}
+
 function renderUnknown(value: unknown): string {
 	if (typeof value === "string") return value
 	try {
@@ -1369,36 +1093,6 @@ function renderUnknown(value: unknown): string {
 	}
 }
 
-function suspendedRuntimes(): Map<string, Set<SuspendedRuntime>> {
-	const global = globalThis as typeof globalThis & { [SUSPENDED_RUNTIMES_SYMBOL]?: Map<string, Set<SuspendedRuntime>> }
-	global[SUSPENDED_RUNTIMES_SYMBOL] ??= new Map()
-	return global[SUSPENDED_RUNTIMES_SYMBOL]
-}
-
-function bindSuspendedRuntime(tuple: ModelTuple, runtime: SuspendedRuntime): () => void {
-	const registry = suspendedRuntimes()
-	const key = modelTupleKey(tuple)
-	const runtimes = registry.get(key) ?? new Set()
-	runtimes.add(runtime)
-	registry.set(key, runtimes)
-	return () => {
-		runtimes.delete(runtime)
-		if (runtimes.size === 0 && registry.get(key) === runtimes) registry.delete(key)
-	}
-}
-
-function modelTupleKey(tuple: ModelTuple): string {
-	return `${tuple.provider}\0${tuple.model}`
-}
-
 function abortError(signal: AbortSignal): Error {
 	return signal.reason instanceof Error ? signal.reason : new Error("Agent creation aborted")
 }
-
-function deferred<T>(): { promise: Promise<T>; resolve(value: T | PromiseLike<T>): void } {
-	let resolve!: (value: T | PromiseLike<T>) => void
-	const promise = new Promise<T>(resolvePromise => {
-		resolve = resolvePromise
-	})
-	return { promise, resolve }
-}