@agimon-ai/po-team 0.0.0-alpha.2 → 0.0.0-alpha.21

package/dist/extensions/server.mjs

@@ -1,34 +1,36 @@
-import { I as SUBAGENT_RUN_ID_ENV, O as SUBAGENT_PARENT_DEPTH_ENV, W as runtimeBinaryEnvVar } from "../environment-DrqhrxG_.mjs";
-import { n as SubagentCapabilityPolicyStore } from "../capabilityCeiling-CF7kAS18.mjs";
-import { a as FABLE_PLAN_RUNTIME, f as FablePlanStartSchema, n as FABLE_PLAN_MODEL, o as FablePlanCancelSchema, r as FABLE_PLAN_PROFILE, t as DOOM_FABLE_PLAN_SERVICE } from "../fablePlanApi-BsHhgVFV.mjs";
-import { a as agentHasWriteTools, c as getProjectConfigDir, i as LruCache, n as resolveActiveTeamModelSpecs, o as canonicalizeDiscoveryCwd, r as resolveActiveTeamPackageConfig, s as getAgentDir, t as AgentDiscoveryService } from "../agentDiscovery-ZQlFkKvB.mjs";
-import { t as writeAtomicJson } from "../atomicJson-D2t0CDh9.mjs";
-import { n as SubagentPolicySchema, t as DOOM_SUBAGENT_POLICY_SERVICE } from "../subagentPolicy-DxjsKeyj.mjs";
-import { a as SubagentToolSchema, n as SUBAGENT_ACTIONS, r as SUBAGENT_ACTION_FIELDS, s as normalizeSubagentToolParams } from "../subagentTool-WOYrjxgT.mjs";
+import { I as SUBAGENT_RUN_ID_ENV, O as SUBAGENT_PARENT_DEPTH_ENV, W as runtimeBinaryEnvVar } from "../environment-BtvJI2S-.mjs";
+import { n as SubagentCapabilityPolicyStore } from "../capabilityCeiling-BaHT9v9S.mjs";
+import { a as FablePlanCancelSchema, d as FablePlanStartSchema, i as FABLE_PLAN_RUNTIME, m as PO_FABLE_PLAN_SERVICE, n as FABLE_PLAN_PROFILE, t as FABLE_PLAN_MODEL } from "../fablePlanApi-DuMg43Hu.mjs";
+import { a as getAgentDir, i as canonicalizeDiscoveryCwd, n as LruCache, o as getConfigDirName, r as agentHasWriteTools, s as getProjectConfigDir, t as AgentDiscoveryService } from "../agentDiscovery-ZNG8iZXV.mjs";
+import { n as SubagentPolicySchema, t as PO_SUBAGENT_POLICY_SERVICE } from "../subagentPolicy-LfcXuqO5.mjs";
+import { a as SubagentToolSchema, n as SUBAGENT_ACTIONS, r as SUBAGENT_ACTION_FIELDS, s as normalizeSubagentToolParams } from "../subagentTool-a2oh2v5B.mjs";
 import { n as readActiveTeamSnapshot, t as formatTeamContextSnapshot } from "../teamSnapshot-DgaANhBs.mjs";
-import { _ as sessionScopeEnvironment, a as parseExternalRunnerMessage, c as cleanupClaudeFableLaunch, f as createSessionScope, g as sessionScopeDir, h as scopeSuspendedDir, m as scopeRunsDir, n as ExternalProcessIpc, p as scopeResultsDir, r as childProcessEndpoint, s as CLAUDE_FABLE_PROFILE, u as prepareClaudeFableLaunch } from "../externalProcessIpc-C-15lJrB.mjs";
+import { _ as sessionScopeDir, a as childProcessEndpoint, f as prepareClaudeFableLaunch, g as scopeRunsDir, h as scopeResultsDir, i as ExternalProcessIpc, l as CLAUDE_FABLE_PROFILE, m as createSessionScope, s as parseExternalRunnerMessage, t as writeAtomicJson, u as cleanupClaudeFableLaunch, v as sessionScopeEnvironment } from "../atomicJson-VVM1iAPu.mjs";
 import { Buffer as Buffer$1 } from "node:buffer";
 import { resolveRootSessionId } from "@agimon-ai/po-core/childProcess";
-import { DOOM_DELEGATION_ACCEPTED_EVENT, DOOM_DELEGATION_CANCELLED_EVENT, DOOM_DELEGATION_FINISHED_EVENT, DOOM_DELEGATION_REQUESTED_EVENT, DOOM_DELEGATION_SERVICE, DOOM_DELEGATION_STARTED_EVENT, DOOM_DELEGATION_UPDATED_EVENT, DelegationCancelSchema, DelegationRequestSchema } from "@agimon-ai/po-core/delegation";
+import { DelegationCancelSchema, DelegationRequestSchema, PO_DELEGATION_ACCEPTED_EVENT, PO_DELEGATION_CANCELLED_EVENT, PO_DELEGATION_FINISHED_EVENT, PO_DELEGATION_REQUESTED_EVENT, PO_DELEGATION_SERVICE, PO_DELEGATION_STARTED_EVENT, PO_DELEGATION_UPDATED_EVENT } from "@agimon-ai/po-core/delegation";
 import { Type } from "typebox";
-import * as fs from "node:fs";
 import * as path from "node:path";
+import { BACKGROUND_CONTEXT, nodeHost, requirePoFs } from "@agimon-ai/po-core/platform";
+import * as fs from "node:fs";
 import * as os from "node:os";
-import { composeServerProviderOverrides, defineServerPlugin } from "@agimon-ai/po-core/serverFacet";
-import { composeRootHooks, defineChannel, defineResource, defineRoot, defineRoute, defineServerTool } from "@agimon-ai/po-core/extensionFile";
-import { readDoomBackgroundWorkService } from "@agimon-ai/po-core/backgroundWork";
-import { readDoomChildSessionService } from "@agimon-ai/po-core/childSession";
-import { DOOM_CONTEXT_CONTRIBUTIONS_SERVICE, requireDoomContextContributions } from "@agimon-ai/po-core/contextContributions";
-import { DOOM_MCP_TOOL_RESOLVER_SERVICE, requireDoomMcpToolResolver } from "@agimon-ai/po-core/mcpToolResolver";
-import { createDoomReadinessCoordinator, readDoomReadinessCoordinator } from "@agimon-ai/po-core/readiness";
-import { provideBackgroundWorkService, readDoomSessionDelivery } from "@agimon-ai/po-session";
-import { createDoomTelemetry } from "@agimon-ai/po-telemetry";
+import { composeServerProviderOverrides, defineServerPlugin } from "@agimon-ai/po-core/serverPlugin";
+import { composeRootHooks, composeRootInjects, defineChannel, defineHook, defineResource, defineRoot, defineRoute, defineServerTool, runCleanups } from "@agimon-ai/po-core/extensionFile";
+import { PO_CONFIG_SERVICE } from "@agimon-ai/po-config";
+import { readPoBackgroundWorkService } from "@agimon-ai/po-core/backgroundWork";
+import { PO_CHILD_SESSION_LABELS_SERVICE, readPoChildSessionService } from "@agimon-ai/po-core/childSession";
+import { PO_CONTEXT_CONTRIBUTIONS_SERVICE, requirePoContextContributions } from "@agimon-ai/po-core/contextContributions";
+import { PO_MCP_TOOL_RESOLVER_SERVICE, requirePoMcpToolResolver } from "@agimon-ai/po-core/mcpToolResolver";
+import { provideBackgroundWorkService, readPoSessionDelivery } from "@agimon-ai/po-session";
+import { createPoTelemetry } from "@agimon-ai/po-telemetry";
 import { Check } from "typebox/value";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { toDoomHeadlessToolResult } from "@agimon-ai/po-core/headless";
+import { toPoHeadlessToolResult } from "@agimon-ai/po-core/headless";
+import { readMajorModesConfig, readPackageConfigurations } from "@agimon-ai/po-config/majorModes";
 import "@agimon-ai/po-core/cordisHost";
+import { HOME_ENTITY_LIMIT } from "@agimon-ai/po-core/hubChannel";
 //#region src/services/config/index.ts
 /**
 * `subagent` tool config file: read/write, and the scoped `ExtensionConfig`
@@ -170,13 +172,13 @@ var AdmissionGate = class {
 			}
 			if (!waited) {
 				waited = true;
-				request.report?.("doom_team.admission_wait", {
+				request.report?.("po_team.admission_wait", {
 					"team.live_runs": live,
 					"team.max_live_runs": request.maxLiveRuns
 				});
 			}
 			if (this.now() >= deadline) {
-				request.report?.("doom_team.admission_timeout", {
+				request.report?.("po_team.admission_timeout", {
 					"team.live_runs": live,
 					"team.max_live_runs": request.maxLiveRuns,
 					duration_ms: this.now() - waitStartedAt
@@ -508,26 +510,6 @@ function claimAgentIdentity(scope, input) {
 	}
 	return degraded;
 }
-/**
-* Point an existing identity at a new run id.
-*
-* Restore mints a fresh run id for what is conceptually the same agent, so the
-* identity has to be carried across rather than derived again. This is a
-* single-writer rewrite of one claim, so the lost-update hazard that rules out
-* a shared registry file does not apply.
-*/
-function adoptAgentIdentity(scope, identity, runId) {
-	const file = path.join(agentIdentitiesDir(scope), `${identity}.json`);
-	const existing = readClaim(file);
-	if (!existing) return;
-	try {
-		fs.writeFileSync(file, `${JSON.stringify({
-			...existing,
-			runId,
-			claimedAt: Date.now()
-		})}\n`, { mode: 384 });
-	} catch {}
-}
 /** Render an identity for display, marking the inline case that has no agent file on disk. */
 function formatAgentIdentity(identity, inline) {
 	if (!identity) return void 0;
@@ -1063,7 +1045,7 @@ function preflightSubagentDepth(depth, config) {
 }
 //#endregion
 //#region src/services/errors/index.ts
-var DoomTeamExpectedError = class extends Error {
+var PoTeamExpectedError = class extends Error {
 	code;
 	retryable;
 	recovery;
@@ -1072,11 +1054,11 @@ var DoomTeamExpectedError = class extends Error {
 		this.code = code;
 		this.retryable = retryable;
 		this.recovery = recovery;
-		this.name = "DoomTeamExpectedError";
+		this.name = "PoTeamExpectedError";
 	}
 };
 function invalidRequest(message, recovery) {
-	return new DoomTeamExpectedError("invalid_request", message, false, recovery);
+	return new PoTeamExpectedError("invalid_request", message, false, recovery);
 }
 //#endregion
 //#region src/services/modelInfo/index.ts
@@ -1116,6 +1098,12 @@ function toModelInfo(model) {
 		thinkingLevelMap: model.thinkingLevelMap
 	};
 }
+/** The parent's authenticated models as the host lists them now; only the parent model when it cannot list. */
+async function availableModelInfos(execution) {
+	const models = await execution.getAvailableModels?.();
+	if (models) return models.map(toModelInfo);
+	return execution.model ? [toModelInfo(execution.model)] : [];
+}
 function splitKnownThinkingSuffix(model) {
 	const colonIdx = model.lastIndexOf(THINKING_SUFFIX_SEPARATOR);
 	if (colonIdx === -1) return {
@@ -1399,6 +1387,205 @@ function selectAvailableModel(primaryModel, fallbackModels, availableModels, pre
 	}
 }
 //#endregion
+//#region src/services/nativeRunCoordinator/index.ts
+/**
+* The root session's agent. Every Team launcher except the browser's is one of
+* its tools, so it is who sent a task or steer that arrives through them.
+*/
+const MAIN_AGENT_SENDER = {
+	kind: "agent",
+	id: "main",
+	name: "Main agent"
+};
+/** The person at the browser, who launches and guides runs from the Agents tab. */
+const HUMAN_SENDER = {
+	kind: "human",
+	name: "You"
+};
+function terminalState(event) {
+	return event.state === "completed" || event.state === "failed" || event.state === "stopped" ? event.state : void 0;
+}
+function entryKey(sessionId, runId) {
+	return JSON.stringify([sessionId, runId]);
+}
+/** A stored run's identity, as `start` put it in the request's `meta`. */
+function storedRunIdentity(run) {
+	const meta = run.request.meta;
+	if (typeof meta?.identity !== "string") return void 0;
+	return {
+		identity: meta.identity,
+		inline: meta.inline === true,
+		...typeof meta.agentDescription === "string" ? { agentDescription: meta.agentDescription } : {},
+		...typeof meta.agentFilePath === "string" ? { agentFilePath: meta.agentFilePath } : {}
+	};
+}
+var NativeRunCoordinator = class {
+	childSessions;
+	tracker;
+	notifier;
+	projection;
+	entries = /* @__PURE__ */ new Map();
+	closed = false;
+	closing;
+	constructor(childSessions, tracker, notifier, projection) {
+		this.childSessions = childSessions;
+		this.tracker = tracker;
+		this.notifier = notifier;
+		this.projection = projection;
+	}
+	service() {
+		if (this.closed) throw new Error("The native Team run coordinator is closed.");
+		const service = this.childSessions?.get();
+		if (!service) throw new Error("The in-process Pi child-session service is unavailable.");
+		return service;
+	}
+	async start(sessionId, request, identity) {
+		if (!sessionId.trim()) throw new Error("Native child runs require a session identity.");
+		const handle = await this.service().start({
+			...request,
+			...identity ? { meta: {
+				...request.meta,
+				...JSON.parse(JSON.stringify(identity))
+			} } : {}
+		});
+		return this.adopt(sessionId, request.scope, request, handle, identity);
+	}
+	async restore(sessionId, run, intercom) {
+		const service = this.service();
+		if (!service.restore) throw new Error("This child-session service cannot restore runs.");
+		const handle = await service.restore(run.request.runId, intercom ? { intercom } : void 0);
+		return this.adopt(sessionId, run.request.scope, run.request, handle, storedRunIdentity(run));
+	}
+	async adopt(sessionId, scope, request, handle, identity) {
+		if (this.closed) {
+			await handle.dispose();
+			throw new Error("The native Team run coordinator closed during child startup.");
+		}
+		const entry = {
+			sessionId,
+			scope,
+			request,
+			...identity ? { identity } : {},
+			handle,
+			terminal: false
+		};
+		const key = entryKey(sessionId, request.runId);
+		this.entries.set(key, entry);
+		try {
+			const unsubscribe = handle.subscribe((event) => this.onEvent(entry, event));
+			if (entry.terminal) unsubscribe();
+			else entry.unsubscribe = unsubscribe;
+			return handle;
+		} catch (error) {
+			this.entries.delete(key);
+			await handle.dispose().catch(() => void 0);
+			throw error;
+		}
+	}
+	get(sessionId, runId) {
+		return this.entries.get(entryKey(sessionId, runId))?.handle;
+	}
+	/**
+	* The newest entries of a run this session's child service stored, from its durable conversation, also once the
+	* run finished or the session restarted; undefined for a run it cannot read, such as an external one.
+	*/
+	async readTranscript(sessionId, runId, limit) {
+		const service = this.service();
+		if (!service.readTranscriptPage) return void 0;
+		try {
+			return (await service.readTranscriptPage(runId, { limit })).entries;
+		} catch (error) {
+			if (this.entries.has(entryKey(sessionId, runId))) throw error;
+			return;
+		}
+	}
+	status(sessionId, runId) {
+		return this.tracker.getNative(sessionId, runId);
+	}
+	async reported(runId) {
+		return this.service().reported?.(runId);
+	}
+	async steer(sessionId, runId, message, signal) {
+		const handle = this.get(sessionId, runId);
+		if (!handle) throw new Error(`No active native run matches '${runId}'.`);
+		await handle.steer(message, signal);
+	}
+	async stop(sessionId, runId, reason) {
+		const handle = this.get(sessionId, runId);
+		if (!handle) throw new Error(`No active native run matches '${runId}'.`);
+		await handle.stop(reason);
+	}
+	async close() {
+		this.closed = true;
+		this.closing ??= (async () => {
+			const active = [...this.entries.values()];
+			for (const entry of active) {
+				entry.unsubscribe?.();
+				this.entries.delete(entryKey(entry.sessionId, entry.request.runId));
+			}
+			const failures = (await Promise.allSettled(active.map((entry) => entry.handle.dispose()))).filter((outcome) => outcome.status === "rejected").map((outcome) => outcome.reason);
+			if (failures.length) throw new AggregateError(failures, "Native Team run shutdown failed.");
+		})();
+		return this.closing;
+	}
+	onEvent(entry, event) {
+		entry.startedAt ??= event.timestamp;
+		const status = terminalState(event);
+		const projection = {
+			runId: event.runId,
+			agent: entry.request.agent,
+			...entry.identity ? {
+				identity: entry.identity.identity,
+				inline: entry.identity.inline
+			} : {},
+			...entry.identity?.agentDescription ? { agentDescription: entry.identity.agentDescription } : {},
+			...entry.identity?.agentFilePath ? { agentFilePath: entry.identity.agentFilePath } : {},
+			task: entry.request.task,
+			cwd: entry.request.cwd,
+			runtime: "pi",
+			status: event.state === "starting" ? "queued" : event.state === "running" ? "running" : event.state,
+			startedAt: entry.startedAt,
+			updatedAt: event.timestamp,
+			...event.cost === void 0 ? {} : { cost: event.cost },
+			...event.tokens === void 0 ? {} : { tokens: event.tokens },
+			...event.toolCount === void 0 ? {} : { toolCount: event.toolCount },
+			...event.model === void 0 ? {} : { model: event.model },
+			...event.thinking === void 0 ? {} : { thinking: event.thinking },
+			...event.message ? {
+				error: status === "failed" || status === "stopped" ? event.message : void 0,
+				summary: event.message
+			} : {}
+		};
+		this.tracker.upsertNative(entry.sessionId, entry.scope, projection);
+		this.projection?.publish(entry.sessionId, projection);
+		if (!status || entry.terminal) return;
+		entry.terminal = true;
+		entry.unsubscribe?.();
+		this.entries.delete(entryKey(entry.sessionId, entry.request.runId));
+		const result = {
+			runId: entry.request.runId,
+			agent: entry.request.agent,
+			...entry.identity ? {
+				identity: entry.identity.identity,
+				inline: entry.identity.inline
+			} : {},
+			task: entry.request.task,
+			cwd: entry.request.cwd,
+			runtime: "pi",
+			state: status,
+			success: status === "completed",
+			summary: event.message ?? (status === "completed" ? "Native child run completed." : `Native child run ${status}.`),
+			durationMs: Math.max(0, event.timestamp - (this.tracker.getNative(entry.sessionId, entry.request.runId)?.startedAt ?? event.timestamp)),
+			sessionId: entry.sessionId
+		};
+		if (this.notifier) this.notifier.deliver(result).then(async (delivered) => {
+			if (!delivered) return;
+			this.tracker.acknowledgeHandoff(entry.sessionId, entry.request.runId);
+			await this.childSessions?.get()?.markReported?.(entry.request.runId);
+		}).catch(() => void 0);
+	}
+};
+//#endregion
 //#region src/services/runtimeRegistry/index.ts
 /**
 * Which agent runtime executes a run, and how to invoke it.
@@ -1515,12 +1702,12 @@ async function runWithConcurrency(factories, concurrency, report) {
 			}
 		}
 	}
-	report?.("doom_team.concurrency_started", {
+	report?.("po_team.concurrency_started", {
 		"team.task_count": factories.length,
 		"team.concurrency": effectiveConcurrency
 	});
 	await Promise.all(Array.from({ length: effectiveConcurrency }, () => worker()));
-	report?.("doom_team.concurrency_finished", {
+	report?.("po_team.concurrency_finished", {
 		"team.task_count": factories.length,
 		"team.concurrency": effectiveConcurrency,
 		"team.failure_count": results.filter((result) => result?.status === "rejected").length,
@@ -1567,8 +1754,8 @@ async function runWithConcurrency(factories, concurrency, report) {
 *   be worse than not checking at all (false confidence). Wiring this needs
 *   a real session-scoped store owned by a lifecycle-bound service - a
 *   follow-up, not guessed here.
-* - Fork context is resolved here and requires a captured persisted Pi source;
-*   unavailable or non-Pi fork requests fail closed rather than becoming fresh
+* - Fork context is resolved here and requires the parent session's branch;
+*   unavailable fork requests fail closed rather than becoming fresh
 *   launches.
 * - Per-task overrides with no direct `BuildPiArgsInput` field confirmed yet
 *   (`skill`, `toolBudget`, `turnBudget`, `outputSchema`/structured output,
@@ -1604,9 +1791,8 @@ function describeForkFailure(reason) {
 /**
 * Map a captured parent branch onto the spawn request's fork fields.
 *
-* `parentSessionFile` and `parentLeafId` describe a terminal Pi capture only. A
-* v4 source already carries its own file and branch, so flattening it into
-* those fields would describe it in the wrong vocabulary and lose the branch.
+* A headless host's branch forks a native child inside its own Harness. A
+* terminal Pi capture describes a branch for an external runtime only.
 */
 function forkRequestFields(captured) {
 	if (!captured) return { parentForkFailure: "no-capture-installed" };
@@ -1614,7 +1800,6 @@ function forkRequestFields(captured) {
 	if (!captured.ok) return { parentForkFailure: captured.reason };
 	const { source } = captured;
 	return {
-		parentForkSource: source.terminalSource,
 		...source.sessionFile ? { parentSessionFile: source.sessionFile } : {},
 		parentLeafId: source.leafId
 	};
@@ -1636,34 +1821,25 @@ function captureSessionForkSource(manager, mode) {
 		ok: false,
 		reason: "unsupported-version"
 	};
-	const branch = manager.getBranch(leafId);
-	if (branch.at(-1)?.id !== leafId) return {
+	if (manager.getBranch(leafId).at(-1)?.id !== leafId) return {
 		ok: false,
 		reason: "branch-mismatch"
 	};
-	const sourceSessionId = manager.getSessionId();
-	if (!sourceSessionId.trim()) return {
+	if (!manager.getSessionId().trim()) return {
 		ok: false,
 		reason: "no-session-id"
 	};
-	const terminalSource = Object.freeze({
-		kind: "terminal-pi-fork",
-		sourceSessionId,
-		sourceLeafId: leafId,
-		snapshotJsonl: `${[header, ...branch].map((record) => JSON.stringify(record)).join("\n")}\n`
-	});
 	const sessionFile = manager.getSessionFile();
 	return {
 		ok: true,
 		source: {
 			leafId,
-			terminalSource,
 			...readableSessionFile(sessionFile) ? { sessionFile } : {}
 		}
 	};
 }
 function resolveEffectiveContext(taskInput, agent) {
-	return taskInput.sessionFile ? CONTEXT_FRESH : taskInput.context ?? agent.defaultContext ?? CONTEXT_FRESH;
+	return taskInput.context ?? agent.defaultContext ?? CONTEXT_FRESH;
 }
 const DEFAULT_PARALLEL_CONCURRENCY = 4;
 /**
@@ -1673,14 +1849,13 @@ const DEFAULT_PARALLEL_CONCURRENCY = 4;
 * soon as its child confirms it started, and the child then runs detached. So
 * `runWithConcurrency` throttles how fast children are STARTED, not how many
 * are running - `{tasks: [8], concurrency: 4}` ends up with eight live model
-* processes, not four. 8 matches the sibling implementation's
-* `PI_TEAM_MATE_MAX_PARALLEL`.
+* processes, not four. 30 lets one call fan a whole swarm out.
 *
 * This is a per-call declaration limit and nothing more. What actually bounds
 * live children across concurrent calls is `AdmissionGate`
 * (`runs/shared/admissionGate.ts`), which every spawn passes through.
 */
-const DEFAULT_PARALLEL_MAX_TASKS = 8;
+const DEFAULT_PARALLEL_MAX_TASKS = 30;
 /**
 * Process-wide ceiling on children ALIVE at once.
 *
@@ -1711,14 +1886,14 @@ function bestEffortRuntimeWarnings(runtime, agentConfig, excludeTools) {
 		...agentConfig.skills?.length || agentConfig.skillPath?.length ? ["skills"] : [],
 		...agentConfig.extensions !== void 0 || agentConfig.subagentOnlyExtensions?.length ? ["extensions"] : []
 	];
-	if (unsupportedResources.length > 0) warnings.push(`Doom Team cannot project or enforce configured Pi ${unsupportedResources.join(", ")} on runtime '${runtime}'.`);
+	if (unsupportedResources.length > 0) warnings.push(`Po Team cannot project or enforce configured Pi ${unsupportedResources.join(", ")} on runtime '${runtime}'.`);
 	if (agentConfig.skills?.length) warnings.push(`Configured skills were not injected: ${agentConfig.skills.join(", ")}.`);
 	if (excludeTools?.length) warnings.push(`Runtime '${runtime}' cannot enforce Team package tool exclusions; launched best effort for: ${excludeTools.join(", ")}.`);
 	return warnings;
 }
 function readWorkflowPreferences(payload) {
 	if (payload === void 0) return {};
-	const invalid = (detail) => new DoomTeamExpectedError(ERROR_CODE_INVALID_REQUEST, `WORKFLOW_RUN_CONFIG ${detail}`, false, "Provide a JSON object with optional nonblank subagentModel and recognized subagentThinking.");
+	const invalid = (detail) => new PoTeamExpectedError(ERROR_CODE_INVALID_REQUEST, `WORKFLOW_RUN_CONFIG ${detail}`, false, "Provide a JSON object with optional nonblank subagentModel and recognized subagentThinking.");
 	let value;
 	try {
 		value = JSON.parse(payload);
@@ -1736,29 +1911,40 @@ function readWorkflowPreferences(payload) {
 	if (preferences.subagentThinking && !THINKING_LEVELS.some((level) => level === preferences.subagentThinking)) throw invalid(`subagentThinking must be one of: ${THINKING_LEVELS.join(", ")}.`);
 	return preferences;
 }
-function resolvedModelSelection(taskInput, agentConfig, runtime, parentModel, availableModels, teamPackageModels, preferences) {
+function resolvedModelSelection(taskInput, agentConfig, runtime, parentModel, availableModels, teamPackageModels, preferences, planning = {}, teamThinking) {
 	const parentModelId = isPiRuntime(runtime) && parentModel ? `${parentModel.provider}/${parentModel.id}` : void 0;
 	const agentModels = [...agentConfig.modelSource?.scope === "package" ? [] : [agentConfig.model], ...agentConfig.fallbackModels ?? []];
 	const candidates = (isPiRuntime(runtime) ? [
 		taskInput.model,
 		preferences.subagentModel,
+		planning.subagentModel,
 		...agentModels,
 		...teamPackageModels ?? [],
 		parentModelId
 	] : [
 		taskInput.model,
 		preferences.subagentModel,
+		planning.subagentModel,
 		...agentModels,
 		...teamPackageModels ?? []
 	]).filter((candidate) => Boolean(candidate?.trim()));
 	const [primaryModel, ...fallbackModels] = candidates;
 	const agentThinking = typeof agentConfig.thinking === "string" ? agentConfig.thinking : void 0;
-	if (!preferences.subagentModel && !preferences.subagentThinking) return {
-		primaryModel,
-		fallbackModels,
-		model: selectAvailableModel(primaryModel, fallbackModels, availableModels),
-		thinking: agentThinking
+	const teamThinkingFor = (model) => {
+		if (agentConfig.thinking === false || !teamThinking) return void 0;
+		const info = findModelInfo(model, availableModels);
+		return info && !getSupportedThinkingLevels(info).some((level) => level === teamThinking) ? void 0 : teamThinking;
 	};
+	if (!preferences.subagentModel && !preferences.subagentThinking && !planning.subagentModel && !planning.subagentThinking) {
+		const model = selectAvailableModel(primaryModel, fallbackModels, availableModels);
+		const selectedSuffix = model ? splitKnownThinkingSuffix(model).thinkingSuffix.slice(1) : void 0;
+		return {
+			primaryModel,
+			fallbackModels,
+			model,
+			thinking: agentThinking ?? (selectedSuffix || void 0) ?? teamThinkingFor(model)
+		};
+	}
 	let model;
 	let selectedCandidate;
 	for (const candidate of candidates) {
@@ -1770,11 +1956,13 @@ function resolvedModelSelection(taskInput, agentConfig, runtime, parentModel, av
 	}
 	const selectedSuffix = model ? splitKnownThinkingSuffix(model).thinkingSuffix.slice(1) : void 0;
 	const explicitThinking = selectedCandidate === taskInput.model ? selectedSuffix : void 0;
-	const thinking = explicitThinking || preferences.subagentThinking || selectedSuffix || agentThinking;
-	const workflowThinking = !explicitThinking && (preferences.subagentThinking || selectedCandidate === preferences.subagentModel && selectedSuffix);
+	const planningThinking = !planning.subagentModel || selectedCandidate === planning.subagentModel ? planning.subagentThinking : void 0;
+	const preferredThinking = (!preferences.subagentModel || selectedCandidate === preferences.subagentModel || selectedCandidate === taskInput.model ? preferences.subagentThinking : void 0) || planningThinking;
+	const thinking = explicitThinking || preferredThinking || selectedSuffix || agentThinking || teamThinkingFor(model);
+	const workflowThinking = !explicitThinking && (preferredThinking || selectedCandidate === preferences.subagentModel && selectedSuffix);
 	const modelInfo = findModelInfo(model, availableModels);
-	if (isPiRuntime(runtime) && workflowThinking && modelInfo && !getSupportedThinkingLevels(modelInfo).some((level) => level === thinking)) throw new DoomTeamExpectedError(ERROR_CODE_INVALID_REQUEST, `WORKFLOW_RUN_CONFIG thinking '${thinking}' is unsupported by model '${modelInfo.fullId}'.`, false, `Choose a supported thinking level: ${getSupportedThinkingLevels(modelInfo).join(", ")}.`);
-	if (model && selectedSuffix && !explicitThinking && preferences.subagentThinking) model = splitKnownThinkingSuffix(model).baseModel;
+	if (isPiRuntime(runtime) && workflowThinking && modelInfo && !getSupportedThinkingLevels(modelInfo).some((level) => level === thinking)) throw new PoTeamExpectedError(ERROR_CODE_INVALID_REQUEST, `Subagent thinking '${thinking}' is unsupported by model '${modelInfo.fullId}'.`, false, `Choose a supported thinking level: ${getSupportedThinkingLevels(modelInfo).join(", ")}.`);
+	if (model && selectedSuffix && !explicitThinking && preferredThinking) model = splitKnownThinkingSuffix(model).baseModel;
 	return {
 		primaryModel,
 		fallbackModels,
@@ -1800,7 +1988,8 @@ var SpawnPlanner = class {
 	nativeRuns;
 	teamChannel;
 	environment;
-	constructor(agents, spawner, policies = new SubagentCapabilityPolicyStore(), skills, reportConcurrencyEvent, _mcpToolResolver, admission, childSessions, nativeRuns, teamChannel, environment = {}) {
+	agentConfig;
+	constructor(agents, spawner, policies = new SubagentCapabilityPolicyStore(), skills, reportConcurrencyEvent, _mcpToolResolver, admission, childSessions, nativeRuns, teamChannel, environment = {}, agentConfig) {
 		this.agents = agents;
 		this.spawner = spawner;
 		this.policies = policies;
@@ -1811,6 +2000,7 @@ var SpawnPlanner = class {
 		this.nativeRuns = nativeRuns;
 		this.teamChannel = teamChannel;
 		this.environment = environment;
+		this.agentConfig = agentConfig;
 	}
 	generateRunId() {
 		return crypto.randomUUID();
@@ -1820,15 +2010,9 @@ var SpawnPlanner = class {
 		try {
 			stat = fs.statSync(cwd);
 		} catch {
-			throw new DoomTeamExpectedError(ERROR_CODE_INVALID_REQUEST, `Working directory '${cwd}' does not exist.`, false, "Retry with an existing directory.");
+			throw new PoTeamExpectedError(ERROR_CODE_INVALID_REQUEST, `Working directory '${cwd}' does not exist.`, false, "Retry with an existing directory.");
 		}
-		if (!stat.isDirectory()) throw new DoomTeamExpectedError(ERROR_CODE_INVALID_REQUEST, `Working directory '${cwd}' is not a directory.`, false, "Retry with an existing directory.");
-	}
-	resolveTeamPackageExcludeTools() {
-		return resolveActiveTeamPackageConfig()?.config.excludeTools;
-	}
-	resolveTeamPackageModels() {
-		return resolveActiveTeamModelSpecs();
+		if (!stat.isDirectory()) throw new PoTeamExpectedError(ERROR_CODE_INVALID_REQUEST, `Working directory '${cwd}' is not a directory.`, false, "Retry with an existing directory.");
 	}
 	executableAvailable(command) {
 		if (path.isAbsolute(command) || command.includes(path.sep)) try {
@@ -1848,17 +2032,17 @@ var SpawnPlanner = class {
 	}
 	resolveTaskList(request) {
 		const hasSingle = request.single !== void 0;
-		if (hasSingle === (request.tasks !== void 0)) throw new DoomTeamExpectedError(ERROR_CODE_INVALID_REQUEST, "A run requires exactly one of internal single or tasks representations.", false, "Submit a non-empty requests array.");
+		if (hasSingle === (request.tasks !== void 0)) throw new PoTeamExpectedError(ERROR_CODE_INVALID_REQUEST, "A run requires exactly one of internal single or tasks representations.", false, "Submit a non-empty requests array.");
 		if (hasSingle) return [request.single];
-		if (!request.tasks || request.tasks.length === 0) throw new DoomTeamExpectedError(ERROR_CODE_INVALID_REQUEST, "A run requires at least one entry in its requests collection.", false, "Submit a non-empty requests array.");
+		if (!request.tasks || request.tasks.length === 0) throw new PoTeamExpectedError(ERROR_CODE_INVALID_REQUEST, "A run requires at least one entry in its requests collection.", false, "Submit a non-empty requests array.");
 		return request.tasks;
 	}
-	resolveAgentOrThrow(name, cwd, scope) {
-		const resolved = this.agents.find(cwd, scope, name);
-		if (!resolved) throw new DoomTeamExpectedError(ERROR_CODE_AGENT_NOT_FOUND, `Unknown agent '${name}'.`, false, "Call subagent({\"action\":\"agents\"}) and retry with an exact name.");
+	async resolveAgentOrThrow(name, cwd, scope) {
+		const resolved = await this.agents.find(cwd, scope, name);
+		if (!resolved) throw new PoTeamExpectedError(ERROR_CODE_AGENT_NOT_FOUND, `Unknown agent '${name}'.`, false, "Call subagent({\"action\":\"agents\"}) and retry with an exact name.");
 		return resolved;
 	}
-	resolveExecutableAgent(taskInput, cwd, scope) {
+	async resolveExecutableAgent(taskInput, cwd, scope) {
 		if (!taskInput.inlineAgent) return this.resolveAgentOrThrow(taskInput.agent, cwd, scope);
 		return {
 			name: taskInput.agent.trim(),
@@ -1952,12 +2136,12 @@ var SpawnPlanner = class {
 	* the module header.
 	*/
 	async spawnOneChild(input) {
-		const { runId, operationId, agentConfig, identity, capabilityCeiling, excludeTools, teamPackageModels, workflowPreferences, taskInput, childIndex, fanout, fallbackCwd, parentSessionId, parentForkSource, sessionScope, environment, parentSessionFile, maxLiveRuns, admissionTimeoutMs, handshakeTimeoutMs, artifacts, artifactDir, availableModels, parentModel, runtime, runtimes, skillProjectionCache } = input;
+		const { runId, operationId, agentConfig, identity, capabilityCeiling, excludeTools, teamPackageModels, teamThinking, workflowPreferences, planningPreferences, taskInput, childIndex, fanout, fallbackCwd, parentSessionId, parentForkSource, sessionScope, environment, parentSessionFile, maxLiveRuns, admissionTimeoutMs, handshakeTimeoutMs, artifacts, artifactDir, availableModels, parentModel, runtime, runtimes, skillProjectionCache, sender } = input;
 		const cwd = taskInput.cwd ?? fallbackCwd;
 		const task = taskInput.task ?? "";
 		const effectiveContext = resolveEffectiveContext(taskInput, agentConfig);
 		const effectiveRuntime = taskInput.runtime ?? runtime ?? agentConfig.runtime ?? "pi";
-		const modelSelection = resolvedModelSelection(taskInput, agentConfig, effectiveRuntime, parentModel, availableModels, teamPackageModels, workflowPreferences);
+		const modelSelection = resolvedModelSelection(taskInput, agentConfig, effectiveRuntime, parentModel, availableModels, teamPackageModels, workflowPreferences, planningPreferences, teamThinking);
 		if (modelSelection.primaryModel && availableModels !== void 0 && !modelSelection.model) return {
 			agent: agentConfig.name,
 			identity: identity.identity,
@@ -1979,7 +2163,11 @@ var SpawnPlanner = class {
 				error: error instanceof Error ? error.message : String(error)
 			};
 		}
-		const warnings = [...skillProjection.warnings, ...bestEffortRuntimeWarnings(effectiveRuntime, agentConfig, excludeTools)];
+		const warnings = [
+			...modelSelection.primaryModel && modelSelection.model && !selectAvailableModel(modelSelection.primaryModel, [], availableModels) ? [`[fallback] ${modelSelection.primaryModel} is unavailable. Using ${modelSelection.model}.`] : [],
+			...skillProjection.warnings,
+			...bestEffortRuntimeWarnings(effectiveRuntime, agentConfig, excludeTools)
+		];
 		const warning = warnings.length > 0 ? warnings.join(" ") : void 0;
 		const spawnInput = {
 			runId,
@@ -1994,7 +2182,6 @@ var SpawnPlanner = class {
 			sessionScope,
 			...parentSessionFile ? { parentSessionFile } : {},
 			piArgs: {
-				...taskInput.sessionFile ? { sessionFile: taskInput.sessionFile } : {},
 				...modelSelection.model ? { model: modelSelection.model } : {},
 				...capabilityCeiling ? { capabilityCeiling } : {},
 				...effectiveContext === CONTEXT_FORK && parentSessionId ? { parentSessionId } : {}
@@ -2006,7 +2193,7 @@ var SpawnPlanner = class {
 			runtimes
 		};
 		const admission = this.admission;
-		if (!admission) throw new Error("Doom Team spawn admission is not configured.");
+		if (!admission) throw new Error("Po Team spawn admission is not configured.");
 		let ticket;
 		try {
 			ticket = await admission.admit({
@@ -2028,11 +2215,8 @@ var SpawnPlanner = class {
 			if (isPiRuntime(effectiveRuntime)) {
 				if (!this.nativeRuns || !this.childSessions?.get()) throw new Error("The native Team run coordinator is unavailable.");
 				const scope = sessionScope;
-				const source = taskInput.sessionFile ? {
-					kind: "v4-restore",
-					sessionFile: taskInput.sessionFile
-				} : effectiveContext === CONTEXT_FORK ? parentForkSource ?? (() => {
-					throw new Error("Native fork input requires an immutable terminal Pi snapshot.");
+				const source = effectiveContext === CONTEXT_FORK ? parentForkSource ?? (() => {
+					throw new Error("Native fork input requires the parent session's branch.");
 				})() : { kind: "fresh" };
 				const intercom = this.teamChannel?.createNativeChildIntercom({
 					rootSessionId: scope.rootSessionId,
@@ -2055,6 +2239,8 @@ var SpawnPlanner = class {
 						source,
 						agent: agentConfig.name,
 						task,
+						...warning ? { meta: { warning } } : {},
+						sender: sender ?? MAIN_AGENT_SENDER,
 						cwd,
 						...modelSelection.model ? { model: modelSelection.model } : {},
 						...typeof modelSelection.thinking === "string" ? { thinking: modelSelection.thinking } : {},
@@ -2071,7 +2257,9 @@ var SpawnPlanner = class {
 						environment
 					}, {
 						identity: identity.identity,
-						inline: identity.inline
+						inline: identity.inline,
+						...agentConfig.description ? { agentDescription: agentConfig.description } : {},
+						...agentConfig.filePath ? { agentFilePath: agentConfig.filePath } : {}
 					});
 				} catch (error) {
 					intercom?.dispose?.();
@@ -2113,71 +2301,67 @@ var SpawnPlanner = class {
 		}
 	}
 	async spawn(request, config) {
+		if (!this.agentConfig) throw new PoTeamExpectedError("runtime_unavailable", "Team agent configuration is not loaded yet.", true, "Retry after the session configuration is ready.");
+		const team = await this.agentConfig.current();
 		const tasks = this.resolveTaskList(request);
 		const workflowPreferences = readWorkflowPreferences(request.environment?.WORKFLOW_RUN_CONFIG ?? this.environment.WORKFLOW_RUN_CONFIG);
+		const planningConfig = request.parentSelection?.state?.["minor-mode"]?.includes("plan") ? team.planningSubagents : void 0;
+		const planningPreferences = {
+			subagentModel: planningConfig?.model,
+			subagentThinking: planningConfig?.thinking
+		};
 		const fanout = tasks.length > 1;
-		const teamPackageExcludeTools = this.resolveTeamPackageExcludeTools();
-		const teamPackageModels = this.resolveTeamPackageModels();
+		const teamPackageExcludeTools = team.excludeTools ? [...team.excludeTools] : void 0;
+		const teamPackageModels = team.models;
 		const capabilityCeiling = this.policies.resolve();
 		const depthCheck = preflightSubagentDepth(request.currentDepth ?? resolveCurrentSubagentDepth(), config);
-		if (depthCheck.error) throw new DoomTeamExpectedError(ERROR_CODE_UNSUPPORTED_OPERATION, depthCheck.error, false, "Give each child a self-contained task within the Team package policy.");
+		if (depthCheck.error) throw new PoTeamExpectedError(ERROR_CODE_UNSUPPORTED_OPERATION, depthCheck.error, false, "Give each child a self-contained task within the Team package policy.");
 		const maxTasks = config.parallel?.maxTasks ?? DEFAULT_PARALLEL_MAX_TASKS;
-		if (tasks.length > maxTasks) throw new DoomTeamExpectedError(ERROR_CODE_INVALID_REQUEST, `Run requested ${tasks.length} tasks, but at most ${maxTasks} may be declared in one call. Concurrency throttles how fast they start, not how many run.`, false, "Send at most that many requests in this call and wait for them, or raise parallel.maxTasks in the subagent config. Splitting the same width across extra calls does not raise the live-child ceiling.");
+		if (tasks.length > maxTasks) throw new PoTeamExpectedError(ERROR_CODE_INVALID_REQUEST, `Run requested ${tasks.length} tasks, but at most ${maxTasks} may be declared in one call. Concurrency throttles how fast they start, not how many run.`, false, "Send at most that many requests in this call and wait for them, or raise parallel.maxTasks in the subagent config. Splitting the same width across extra calls does not raise the live-child ceiling.");
 		for (const taskInput of tasks) {
-			if (!taskInput.task?.trim()) throw new DoomTeamExpectedError(ERROR_CODE_INVALID_REQUEST, `Run request for '${taskInput.agent}' requires a nonblank task.`, false, "Provide a self-contained nonblank task.");
-			if (taskInput.inlineAgent && !taskInput.inlineAgent.systemPrompt.trim()) throw new DoomTeamExpectedError(ERROR_CODE_INVALID_REQUEST, `Inline agent '${taskInput.agent}' requires a nonblank system prompt.`, false, "Provide a focused read-only exploration role.");
+			if (!taskInput.task?.trim()) throw new PoTeamExpectedError(ERROR_CODE_INVALID_REQUEST, `Run request for '${taskInput.agent}' requires a nonblank task.`, false, "Provide a self-contained nonblank task.");
+			if (taskInput.inlineAgent && !taskInput.inlineAgent.systemPrompt.trim()) throw new PoTeamExpectedError(ERROR_CODE_INVALID_REQUEST, `Inline agent '${taskInput.agent}' requires a nonblank system prompt.`, false, "Provide a focused read-only exploration role.");
 		}
 		const resolvedAgentCache = /* @__PURE__ */ new Map();
-		const resolvedAgents = tasks.map((taskInput) => {
-			if (taskInput.inlineAgent) return this.resolveExecutableAgent(taskInput, taskInput.cwd ?? request.cwd, request.agentScope);
+		const resolvedAgents = [];
+		for (const taskInput of tasks) {
 			const cacheKey = [
 				request.agentScope,
 				canonicalizeDiscoveryCwd(taskInput.cwd ?? request.cwd),
 				taskInput.agent
 			].join("\0");
-			const cached = resolvedAgentCache.get(cacheKey);
-			if (cached) return cached;
-			const resolved = this.resolveExecutableAgent(taskInput, taskInput.cwd ?? request.cwd, request.agentScope);
-			resolvedAgentCache.set(cacheKey, resolved);
-			return resolved;
-		});
+			let resolved = taskInput.inlineAgent ? void 0 : resolvedAgentCache.get(cacheKey);
+			if (!resolved) {
+				resolved = await this.resolveExecutableAgent(taskInput, taskInput.cwd ?? request.cwd, request.agentScope);
+				if (!taskInput.inlineAgent) resolvedAgentCache.set(cacheKey, resolved);
+			}
+			resolvedAgents.push(resolved);
+		}
 		for (const [index, taskInput] of tasks.entries()) {
 			const effectiveContext = resolveEffectiveContext(taskInput, resolvedAgents[index]);
 			const runtime = taskInput.runtime ?? request.runtime ?? resolvedAgents[index].runtime ?? "pi";
 			if (effectiveContext === CONTEXT_FORK) {
-				if (!isPiRuntime(runtime)) throw new DoomTeamExpectedError(ERROR_CODE_UNSUPPORTED_CONTEXT, `Fork context requires ${PI_RUNTIME_REQUIREMENT} for '${taskInput.agent}'.`, false, "Use a Pi agent for fork context or explicitly request a fresh run.");
-				if (!request.parentForkSource) throw new DoomTeamExpectedError(ERROR_CODE_UNSUPPORTED_CONTEXT, `Fork context is unavailable for '${taskInput.agent}': ${describeForkFailure(request.parentForkFailure)}.`, false, "Use an active Pi session with a completed parent turn or explicitly request a fresh run.");
+				if (!isPiRuntime(runtime)) throw new PoTeamExpectedError(ERROR_CODE_UNSUPPORTED_CONTEXT, `Fork context requires ${PI_RUNTIME_REQUIREMENT} for '${taskInput.agent}'.`, false, "Use a Pi agent for fork context or explicitly request a fresh run.");
+				if (!request.parentForkSource) throw new PoTeamExpectedError(ERROR_CODE_UNSUPPORTED_CONTEXT, `Fork context is unavailable for '${taskInput.agent}': ${describeForkFailure(request.parentForkFailure)}.`, false, "Use an active Pi session with a completed parent turn or explicitly request a fresh run.");
 			}
 		}
-		if (request.preallocatedRunIds && request.preallocatedRunIds.length !== tasks.length) throw new DoomTeamExpectedError(ERROR_CODE_OPERATION_CONFLICT, "The operation journal run-id count does not match the request count.", false, "Submit the run as a new tool call.");
+		if (request.preallocatedRunIds && request.preallocatedRunIds.length !== tasks.length) throw new PoTeamExpectedError(ERROR_CODE_OPERATION_CONFLICT, "The operation journal run-id count does not match the request count.", false, "Submit the run as a new tool call.");
 		const runIds = request.preallocatedRunIds ?? tasks.map(() => this.generateRunId());
-		const identities = tasks.map((taskInput, index) => {
-			const inline = taskInput.inlineAgent !== void 0;
-			if (!taskInput.identity) return claimAgentIdentity(request.sessionScope, {
-				agent: resolvedAgents[index].name,
-				inline,
-				runId: runIds[index]
-			});
-			adoptAgentIdentity(request.sessionScope, taskInput.identity, runIds[index]);
-			return {
-				identity: taskInput.identity,
-				name: "",
-				role: roleFromAgent(resolvedAgents[index].name),
-				number: 0,
-				inline,
-				persisted: true
-			};
-		});
+		const identities = tasks.map((taskInput, index) => claimAgentIdentity(request.sessionScope, {
+			agent: resolvedAgents[index].name,
+			inline: taskInput.inlineAgent !== void 0,
+			runId: runIds[index]
+		}));
 		const runtimes = resolveRuntimeTable(config.runtimes);
 		for (const [index, taskInput] of tasks.entries()) {
 			const agent = resolvedAgents[index];
 			const cwd = taskInput.cwd ?? request.cwd;
 			this.validateCwd(cwd);
 			const runtime = taskInput.runtime ?? request.runtime ?? agent.runtime ?? "pi";
-			const modelSelection = resolvedModelSelection(taskInput, agent, runtime, request.parentModel, request.availableModels, teamPackageModels, workflowPreferences);
-			if (modelSelection.primaryModel && request.availableModels !== void 0 && !modelSelection.model) throw new DoomTeamExpectedError(ERROR_CODE_MODEL_UNAVAILABLE, `No authenticated model is available for '${agent.name}'.`, false, "Authenticate the requested model or choose an available model.");
-			if (taskInput.inlineAgent && !isPiRuntime(runtime)) throw new DoomTeamExpectedError(ERROR_CODE_UNSUPPORTED_OPERATION, `Inline agent '${taskInput.agent}' requires ${PI_RUNTIME_REQUIREMENT} to enforce its read-only tools.`, false, "Remove the runtime override or use a discovered external-runtime agent without inlineAgent.");
-			if (capabilityCeiling && !isPiRuntime(runtime)) throw new DoomTeamExpectedError(ERROR_CODE_UNSUPPORTED_OPERATION, `Runtime '${runtime}' cannot enforce the active capability ceiling.`, false, `Use ${PI_RUNTIME_REQUIREMENT} while plan mode or another capability ceiling is active.`);
+			const modelSelection = resolvedModelSelection(taskInput, agent, runtime, request.parentModel, request.availableModels, teamPackageModels, workflowPreferences, planningPreferences, team.thinking);
+			if (modelSelection.primaryModel && request.availableModels !== void 0 && !modelSelection.model) throw new PoTeamExpectedError(ERROR_CODE_MODEL_UNAVAILABLE, `No authenticated model is available for '${agent.name}'.`, false, "Authenticate the requested model or choose an available model.");
+			if (taskInput.inlineAgent && !isPiRuntime(runtime)) throw new PoTeamExpectedError(ERROR_CODE_UNSUPPORTED_OPERATION, `Inline agent '${taskInput.agent}' requires ${PI_RUNTIME_REQUIREMENT} to enforce its read-only tools.`, false, "Remove the runtime override or use a discovered external-runtime agent without inlineAgent.");
+			if (capabilityCeiling && !isPiRuntime(runtime)) throw new PoTeamExpectedError(ERROR_CODE_UNSUPPORTED_OPERATION, `Runtime '${runtime}' cannot enforce the active capability ceiling.`, false, `Use ${PI_RUNTIME_REQUIREMENT} while plan mode or another capability ceiling is active.`);
 			if (!isPiRuntime(runtime)) {
 				let command;
 				try {
@@ -2186,9 +2370,9 @@ var SpawnPlanner = class {
 						cwd
 					}).command;
 				} catch (error) {
-					throw new DoomTeamExpectedError(ERROR_CODE_RUNTIME_UNAVAILABLE, error instanceof Error ? error.message : String(error), false, `Configure a valid external runtime or use ${PI_RUNTIME_REQUIREMENT}.`);
+					throw new PoTeamExpectedError(ERROR_CODE_RUNTIME_UNAVAILABLE, error instanceof Error ? error.message : String(error), false, `Configure a valid external runtime or use ${PI_RUNTIME_REQUIREMENT}.`);
 				}
-				if (!this.executableAvailable(command)) throw new DoomTeamExpectedError(ERROR_CODE_RUNTIME_UNAVAILABLE, `Executable '${command}' for runtime '${runtime}' is unavailable.`, false, `Install the executable, configure its absolute path, or use ${PI_RUNTIME_REQUIREMENT}.`);
+				if (!this.executableAvailable(command)) throw new PoTeamExpectedError(ERROR_CODE_RUNTIME_UNAVAILABLE, `Executable '${command}' for runtime '${runtime}' is unavailable.`, false, `Install the executable, configure its absolute path, or use ${PI_RUNTIME_REQUIREMENT}.`);
 			}
 		}
 		const concurrency = fanout ? request.concurrency ?? config.parallel?.concurrency ?? DEFAULT_PARALLEL_CONCURRENCY : 1;
@@ -2202,7 +2386,9 @@ var SpawnPlanner = class {
 			identity: identities[childIndex],
 			excludeTools: teamPackageExcludeTools,
 			teamPackageModels,
+			teamThinking: team.thinking,
 			workflowPreferences,
+			planningPreferences,
 			capabilityCeiling,
 			taskInput,
 			childIndex,
@@ -2211,6 +2397,7 @@ var SpawnPlanner = class {
 			parentSessionId: request.parentSessionId,
 			parentForkSource: request.parentForkSource,
 			sessionScope: request.sessionScope,
+			...request.sender ? { sender: request.sender } : {},
 			environment: request.environment ?? {},
 			parentSessionFile: request.parentSessionFile,
 			maxLiveRuns,
@@ -2236,7 +2423,7 @@ var SpawnPlanner = class {
 //#endregion
 //#region src/services/delegationBridge/index.ts
 /**
-* Serves `doom-task` through Team's session-bound delegation service: turn a
+* Serves `po-task` through Team's session-bound delegation service: turn a
 * request into a spawned run, report its progress, and settle it exactly once.
 *
 * WHY THIS IS NOT IN `pi.ts`:
@@ -2266,7 +2453,7 @@ const DELEGATION_PROGRESS_INTERVAL_MS = 250;
 const SETTLED_DELEGATION_WINDOW = 256;
 /**
 * Terminal states, named because they are an external contract with
-* `doom-task`'s `DelegationManager`, which branches on the exact strings.
+* `po-task`'s `DelegationManager`, which branches on the exact strings.
 */
 const STATUS_COMPLETED = "completed";
 const STATUS_CANCELLED = "cancelled";
@@ -2288,7 +2475,7 @@ function createDelegationBridge(deps) {
 		entry.disposeProgress?.();
 		active.delete(entry.requestId);
 		rememberSettled(entry.requestId);
-		ctx.emit(DOOM_DELEGATION_FINISHED_EVENT, result);
+		ctx.emit(PO_DELEGATION_FINISHED_EVENT, result);
 	};
 	/** Ask the run to stop. Returns the failure message when the request itself failed. */
 	const stop = (entry, reason) => {
@@ -2319,7 +2506,13 @@ function createDelegationBridge(deps) {
 					timeoutWarningSent = true;
 					const secondsRemaining = Math.max(1, Math.ceil(warningLeadMs / 1e3));
 					const secondsLabel = `${secondsRemaining} second${secondsRemaining === 1 ? "" : "s"}`;
-					deps.management.steer(runId, `This delegation will time out in about ${secondsLabel}. Stop exploring now, complete the highest-value remaining work, and return a concise result before the deadline. If you cannot finish, return verified findings and blockers immediately.`).catch(() => void 0);
+					deps.management.steer(runId, {
+						text: `This delegation will time out in about ${secondsLabel}. Stop exploring now, complete the highest-value remaining work, and return a concise result before the deadline. If you cannot finish, return verified findings and blockers immediately.`,
+						sender: {
+							kind: "system",
+							name: "Po"
+						}
+					}).catch(() => void 0);
 					worked = true;
 				}
 				const progressKey = [
@@ -2332,7 +2525,7 @@ function createDelegationBridge(deps) {
 				].map((value) => String(value)).join(":");
 				if (progressKey === lastProgress) return worked;
 				lastProgress = progressKey;
-				ctx.emit(DOOM_DELEGATION_UPDATED_EVENT, {
+				ctx.emit(PO_DELEGATION_UPDATED_EVENT, {
 					requestId: entry.requestId,
 					runId,
 					...job.status !== void 0 ? { status: job.status } : {},
@@ -2407,7 +2600,7 @@ function createDelegationBridge(deps) {
 			settled: false
 		};
 		active.set(request.requestId, entry);
-		ctx.emit(DOOM_DELEGATION_ACCEPTED_EVENT, { requestId: request.requestId });
+		ctx.emit(PO_DELEGATION_ACCEPTED_EVENT, { requestId: request.requestId });
 		try {
 			const forkSource = await session.captureForkSource?.();
 			const outcome = (await deps.planner.spawn({
@@ -2422,8 +2615,10 @@ function createDelegationBridge(deps) {
 				agentScope: "both",
 				sessionScope: session.sessionScope,
 				parentSessionId: session.sessionId,
+				parentSelection: session.parentSelection,
+				environment: session.environment,
 				...forkRequestFields(forkSource),
-				availableModels: session.availableModels,
+				availableModels: await session.availableModels(),
 				...session.parentModel ? { parentModel: session.parentModel } : {}
 			}, deps.loadConfig())).outcomes[0];
 			if (!outcome?.runId) {
@@ -2446,10 +2641,15 @@ function createDelegationBridge(deps) {
 				return;
 			}
 			entry.runtimeStartedAt = Date.now();
-			ctx.emit(DOOM_DELEGATION_STARTED_EVENT, {
+			ctx.emit(PO_DELEGATION_STARTED_EVENT, {
 				requestId: request.requestId,
 				runId: outcome.runId
 			});
+			if (outcome.warning) try {
+				await session.reportWarning?.(outcome.warning);
+			} catch (error) {
+				process.emitWarning(`Delegation warning could not be delivered: ${error instanceof Error ? error.message : String(error)}`);
+			}
 			await monitor(entry, request, ctx, jobs, session.sessionId, session.sessionScope);
 		} catch (error) {
 			finish(entry, {
@@ -2477,15 +2677,15 @@ function createDelegationBridge(deps) {
 		createService(ctx, session) {
 			const service = {
 				sessionId: session.sessionId,
-				generation: `doom-delegation:${crypto.randomUUID()}`,
+				generation: `po-delegation:${crypto.randomUUID()}`,
 				async request(request) {
 					if (!Check(DelegationRequestSchema, request)) throw new TypeError("Invalid delegation request.");
-					ctx.emit(DOOM_DELEGATION_REQUESTED_EVENT, request);
+					ctx.emit(PO_DELEGATION_REQUESTED_EVENT, request);
 					await onRequested(request, ctx, session);
 				},
 				cancel(request) {
 					if (!Check(DelegationCancelSchema, request)) throw new TypeError("Invalid delegation cancel request.");
-					ctx.emit(DOOM_DELEGATION_CANCELLED_EVENT, request);
+					ctx.emit(PO_DELEGATION_CANCELLED_EVENT, request);
 					onCancelled(request.requestId, request.reason, ctx);
 				}
 			};
@@ -2588,10 +2788,10 @@ function resolveRunnerEntry(builtRelativePath, sourceRelativePath, stem) {
 			if (fs.existsSync(builtCandidate)) return builtCandidate;
 			const sourceCandidate = path.join(directory, "src", `${sourceRelativePath}.ts`);
 			if (fs.existsSync(sourceCandidate)) return sourceCandidate;
-			throw new Error(`Doom Team runner '${stem}' is unavailable at '${builtCandidate}' or '${sourceCandidate}'.`);
+			throw new Error(`Po Team runner '${stem}' is unavailable at '${builtCandidate}' or '${sourceCandidate}'.`);
 		}
 		const parent = path.dirname(directory);
-		if (parent === directory) throw new Error(`Could not locate the Doom Team package root for runner '${stem}'.`);
+		if (parent === directory) throw new Error(`Could not locate the Po Team package root for runner '${stem}'.`);
 		directory = parent;
 	}
 }
@@ -2788,8 +2988,8 @@ const FABLE_STAGE = {
 	interrupted: "interrupted"
 };
 const FABLE_EVENT = {
-	stageStarted: "doom_team.fable_stage_started",
-	finished: "doom_team.fable_finished"
+	stageStarted: "po_team.fable_stage_started",
+	finished: "po_team.fable_finished"
 };
 const SESSION_ENDED_REASON = "Fable bridge session ended.";
 const FABLE_ERROR = {
@@ -2979,7 +3179,7 @@ function createFablePlanBridge(deps) {
 			return Object.freeze({
 				...provider,
 				sessionId: session.sessionId,
-				generation: `doom-fable-plan:${crypto.randomUUID()}`
+				generation: `po-fable-plan:${crypto.randomUUID()}`
 			});
 		},
 		abandonAll() {
@@ -3167,7 +3367,7 @@ function parseTeamToolParams(raw) {
 	if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw invalidRequest("Intercom params must be an object.", "Use one documented intercom action shape.");
 	const params = raw;
 	const action = TEAM_ACTIONS.find((candidate) => candidate === params.action);
-	if (!action) throw new DoomTeamExpectedError("unsupported_operation", `Unsupported intercom action: ${String(params.action)}.`, false, "Use members, send, ask, pending, or reply.");
+	if (!action) throw new PoTeamExpectedError("unsupported_operation", `Unsupported intercom action: ${String(params.action)}.`, false, "Use members, send, ask, pending, or reply.");
 	if (!isOptionalString(params.to) || !isOptionalString(params.message) || !isOptionalString(params.requestId)) throw invalidRequest("Intercom to, message and requestId values must be strings.", "Correct the action fields and retry.");
 	const allowed = new Set(action === "members" || action === "pending" ? ["action"] : action === "reply" ? [
 		"action",
@@ -3280,7 +3480,14 @@ var NativeTeamDirectChannel = class {
 			bindRuntime: (runtime) => {
 				const member = this.members.get(memberId);
 				if (!member || disposed) throw new Error(`Native team member '${memberId}' is no longer active.`);
-				member.deliver = (message) => runtime.steer(message.content);
+				member.deliver = ({ content, details: { from } }) => runtime.steer({
+					text: content,
+					sender: from.role === "main" ? MAIN_AGENT_SENDER : {
+						kind: "agent",
+						id: from.runId ?? from.name,
+						name: from.name
+					}
+				});
 				return {
 					name: NATIVE_TEAM_TOOL_NAME,
 					description: "Communicate with active native agents in this root session.",
@@ -3378,7 +3585,7 @@ var NativeTeamDirectChannel = class {
 		if (params.action === "reply") {
 			const request = this.asks.get(params.requestId ?? "");
 			const asker = request && this.members.get(request.fromMemberId);
-			if (!request || request.toMemberId !== memberId || !asker) throw new DoomTeamExpectedError("recipient_not_found", `No open intercom ask matches requestId '${params.requestId}'. It may already be answered, or its asker has finished.`, false, "Call intercom({\"action\":\"pending\"}) and retry with an exact requestId, or continue without replying.");
+			if (!request || request.toMemberId !== memberId || !asker) throw new PoTeamExpectedError("recipient_not_found", `No open intercom ask matches requestId '${params.requestId}'. It may already be answered, or its asker has finished.`, false, "Call intercom({\"action\":\"pending\"}) and retry with an exact requestId, or continue without replying.");
 			await this.deliver(asker, formatDirectMessage(member.context, "reply", request.id, message));
 			this.closeAsk(request);
 			return {
@@ -3393,7 +3600,7 @@ var NativeTeamDirectChannel = class {
 			};
 		}
 		const target = this.findMember(params.to);
-		if (!target) throw new DoomTeamExpectedError("recipient_not_found", `Active intercom member '${params.to}' was not found.`, true, "Call intercom({\"action\":\"members\"}) and retry with an active member id.");
+		if (!target) throw new PoTeamExpectedError("recipient_not_found", `Active intercom member '${params.to}' was not found.`, true, "Call intercom({\"action\":\"members\"}) and retry with an active member id.");
 		const messageId = operationMessageId(memberId, operationId);
 		const isAsk = params.action === "ask";
 		const result = () => ({
@@ -3463,15 +3670,15 @@ var NativeTeamDirectChannel = class {
 	}
 	async deliver(target, message) {
 		const id = target.context.memberId;
-		if (this.members.get(id) !== target) throw new DoomTeamExpectedError("communication_unavailable", `Intercom member '${id}' has finished.`, false, "Call intercom({\"action\":\"members\"}) to see who is active.");
-		if (!target.deliver) throw new DoomTeamExpectedError("communication_unavailable", `Intercom member '${id}' is not ready.`, true, "Retry after the child session starts.");
+		if (this.members.get(id) !== target) throw new PoTeamExpectedError("communication_unavailable", `Intercom member '${id}' has finished.`, false, "Call intercom({\"action\":\"members\"}) to see who is active.");
+		if (!target.deliver) throw new PoTeamExpectedError("communication_unavailable", `Intercom member '${id}' is not ready.`, true, "Retry after the child session starts.");
 		target.inFlight += 1;
 		try {
 			await target.deliver(message);
 			target.delivered = true;
 		} catch (error) {
-			if (error instanceof DoomTeamExpectedError) throw error;
-			throw new DoomTeamExpectedError("communication_unavailable", `Intercom member '${id}' could not receive the message: ${error instanceof Error ? error.message : String(error)}`, true, "Retry shortly, or continue without it.");
+			if (error instanceof PoTeamExpectedError) throw error;
+			throw new PoTeamExpectedError("communication_unavailable", `Intercom member '${id}' could not receive the message: ${error instanceof Error ? error.message : String(error)}`, true, "Retry shortly, or continue without it.");
 		} finally {
 			target.inFlight -= 1;
 			target.release?.(true);
@@ -3498,7 +3705,7 @@ var TeamChannelRuntime = class {
 	}
 	execute(operationId, rawParams) {
 		const context = this.context;
-		if (!context || !this.directChannel) throw new DoomTeamExpectedError("communication_unavailable", "Intercom is not active for this session.", true, "Wait for session startup or reload Doom Team.");
+		if (!context || !this.directChannel) throw new PoTeamExpectedError("communication_unavailable", "Intercom is not active for this session.", true, "Wait for session startup or reload Po Team.");
 		return this.directChannel.execute(context.memberId, operationId, rawParams);
 	}
 	bindMainSession(rootSessionId) {
@@ -3555,51 +3762,80 @@ var NativeTeamChannelService = class {
 };
 //#endregion
 //#region src/services/headlessIntercomTool/index.ts
+/**
+* Finds the peer a `to` value names: its session ID first, then its session
+* name, ignoring case, so an agent can use the name a person typed. A name two
+* peers share is refused with their IDs rather than guessed.
+*/
+function resolvePeer(peers, to) {
+	const byId = peers.find((peer) => peer.sessionId === to);
+	if (byId !== void 0) return byId;
+	const wanted = to.toLowerCase();
+	const named = peers.filter((peer) => peer.name.trim().toLowerCase() === wanted);
+	if (named.length > 1) throw invalidRequest(`${String(named.length)} sessions are named "${to}".`, `Send to one session ID: ${named.map((peer) => peer.sessionId).join(", ")}.`);
+	return named[0];
+}
+function describePeerLine(peer) {
+	const details = [
+		`session ${peer.sessionId}`,
+		...peer.profile === void 0 ? [] : [`profile ${peer.profile}`],
+		...peer.sharedGroups.length === 0 ? [] : [`shared groups: ${peer.sharedGroups.join(", ")}`]
+	];
+	return `- ${peer.name.trim() === "" ? peer.sessionId : peer.name} (${details.join("; ")}): use send; it can reply to you the same way`;
+}
 function createHeadlessIntercomTool(channel, sessions) {
 	return {
 		name: "intercom",
 		label: "Intercom",
 		description: "Communicate with active agents and related live sessions.",
 		parameters: TeamToolParamsSchema,
-		promptGuidelines: ["Send only new progress, blockers, or decisions. Do not repeat task briefs or delegation instructions.", "Use members to find related sessions, then send to their session ID to delegate work such as workflow recovery. Session peers use send, not ask/reply."],
+		promptGuidelines: ["Send only new progress, blockers, or decisions. Do not repeat task briefs or delegation instructions.", "Use members to find related sessions by the names people give them, then send to that name or its session ID. Session peers use send, not ask/reply, and can send back."],
 		executionMode: "serial",
 		async execute(toolCallId, parameters, signal, onUpdate) {
 			const params = parseTeamToolParams(parameters);
 			const peers = channel.current() === void 0 ? [] : sessions?.peers() ?? [];
 			const to = params.to?.trim();
-			if (sessions !== void 0 && to !== void 0 && peers.includes(to)) {
-				if (params.action !== "send") throw invalidRequest("Session peers support send only.", "Use send with the session ID.");
+			const knownId = channel.current() !== void 0 && to !== void 0 && sessions?.canCommunicate(to) === true;
+			const teamMember = to !== void 0 && channel.snapshot().members.some((member) => member.name === to) && !knownId && !peers.some((peer) => peer.sessionId === to);
+			const peer = sessions === void 0 || to === void 0 || teamMember ? void 0 : knownId ? peers.find((candidate) => candidate.sessionId === to) : resolvePeer(peers, to);
+			const recipientId = knownId ? to : peer?.sessionId;
+			if (sessions !== void 0 && recipientId !== void 0) {
+				if (params.action !== "send") throw invalidRequest("Session peers support send only.", "Use send with the session name or ID.");
 				const message = validateMessage(params.message);
 				const delivery = sessions.delivery();
 				if (delivery === void 0) throw new Error("Session delivery is unavailable.");
+				const senderName = sessions.name?.()?.trim() || sessions.sessionId;
+				const toName = peer?.name.trim() || recipientId;
 				const receipt = await delivery.deliver({
 					deliveryId: `intercom:${sessions.sessionId}:${toolCallId}`,
-					recipientKey: to,
+					recipientKey: recipientId,
 					kind: "intercom_message",
-					prompt: `Message from session ${sessions.sessionId} via intercom.\n\n${message}\n\nReply using intercom({ action: "send", to: "${sessions.sessionId}", message: "..." }).`,
+					prompt: `Message from session ${senderName} via intercom.\n\n${message}\n\nReply using intercom({ action: "send", to: ${JSON.stringify(senderName)}, message: "..." }).`,
 					delivery: "steer"
 				});
 				return {
 					content: [{
 						type: "text",
-						text: `Message queued for session ${to}.`
+						text: `Message queued for session ${toName}.`
 					}],
 					details: {
 						...receipt,
-						to
+						to: recipientId,
+						toName
 					}
 				};
 			}
-			const result = toDoomHeadlessToolResult(await channel.execute(toolCallId, parameters, signal, onUpdate && ((partial) => onUpdate(toDoomHeadlessToolResult(partial)))));
+			const result = toPoHeadlessToolResult(await channel.execute(toolCallId, parameters, signal, onUpdate && ((partial) => onUpdate(toPoHeadlessToolResult(partial)))));
 			if (params.action !== "members" || peers.length === 0) return result;
 			return {
 				...result,
 				content: [...result.content, {
 					type: "text",
-					text: peers.map((id) => `- ${id}: related session (send only)`).join("\n")
+					text: peers.map(describePeerLine).join("\n")
 				}],
-				details: { members: [...channel.snapshot().members, ...peers.map((id) => ({
-					name: id,
+				details: { members: [...channel.snapshot().members, ...peers.map((peer) => ({
+					name: peer.name || peer.sessionId,
+					sessionId: peer.sessionId,
 					role: "session"
 				}))] }
 			};
@@ -3721,6 +3957,7 @@ var AsyncJobTracker = class {
 			startedAt: projection.startedAt,
 			updatedAt: projection.updatedAt,
 			...projection.error === void 0 ? {} : { error: projection.error },
+			...projection.promptWithheld ? { promptWithheld: true } : {},
 			...projection.summary === void 0 ? {} : { summary: projection.summary },
 			...projection.tokens === void 0 ? {} : { tokens: projection.tokens },
 			...projection.cost === void 0 ? {} : { cost: projection.cost },
@@ -3932,7 +4169,7 @@ function formatDuration(ms) {
 */
 const MAX_RETAINED_EVENTS = 1e3;
 const NEWLINE_BYTE = 10;
-function isRecord$1(value) {
+function isRecord$2(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseLine(line) {
@@ -3940,7 +4177,7 @@ function parseLine(line) {
 	if (!trimmed) return void 0;
 	try {
 		const parsed = JSON.parse(trimmed);
-		return isRecord$1(parsed) ? parsed : void 0;
+		return isRecord$2(parsed) ? parsed : void 0;
 	} catch {
 		return;
 	}
@@ -3975,7 +4212,7 @@ function parseArgsPayload(payload) {
 	if (!payload) return void 0;
 	try {
 		const parsed = JSON.parse(payload);
-		return isRecord$1(parsed) ? parsed : void 0;
+		return isRecord$2(parsed) ? parsed : void 0;
 	} catch {
 		return;
 	}
@@ -4170,125 +4407,63 @@ function readFleetTranscript(transcriptPath) {
 		warning: tail.warning
 	} : { events: tail.events };
 }
-//#endregion
-//#region src/services/suspendedRuns/index.ts
+function contentText(content) {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content.flatMap((part) => isRecord$2(part) && part.type === "text" && typeof part.text === "string" ? [part.text] : []).join("\n");
+}
 /**
-* Runs stopped by a session shutdown, and enough about each to start it again.
-*
-* WHY EVERY SHUTDOWN SUSPENDS, WITH NO SPECIAL CASE FOR `reload`:
-* Pi emits `session_shutdown` for `quit`, `reload`, `new`, `resume` and `fork`.
-* An earlier design kept children alive across `reload` alone, on the grounds
-* that `/domains`, `/major-mode` and `/profile` reload the extension rather than
-* change the session. That is true, and it still makes `reload` the one case
-* behaving differently from the other four - which is a rule someone has to
-* remember, and a branch that silently does the wrong thing if Pi ever adds a
-* sixth reason. Suspending uniformly costs a respawn on reload and removes the
-* special case; restore is cheap because the child continues its own transcript
-* rather than starting over.
-*
-* WHY RESTORE IS OFFERED AND NEVER AUTOMATIC:
-* Reopening a session would otherwise spawn N processes and start spending
-* tokens on tasks that may be days stale. `session_start` reports what is
-* suspended; something explicit has to ask for it back.
-*
-* AVOID:
-* - Auto-restoring from any lifecycle event
-* - Recording a suspended run without its `sessionFile`; without it a restore
-*   restarts the work instead of continuing it
+* Events of a native run's durable transcript page, so a native run renders through the same tail as a file
+* transcript. Entries are projected messages: `{ type: 'message', timestamp, message }` with Pi message roles.
 */
-const SUSPENDED_RUN_VERSION = 1;
-const JSON_SUFFIX = ".json";
-function suspendedPath(scope, runId) {
-	return path.join(scopeSuspendedDir(scope), `${runId}${JSON_SUFFIX}`);
-}
-function suspendRun(scope, record) {
-	writeAtomicJson(suspendedPath(scope, record.runId), {
-		version: SUSPENDED_RUN_VERSION,
-		...record
-	});
-}
-function parseSuspendedRun(raw) {
-	let parsed;
-	try {
-		parsed = JSON.parse(raw);
-	} catch {
-		return;
-	}
-	const result = parseVersioned(parsed, [SUSPENDED_RUN_VERSION]);
-	return result.ok && typeof result.value.runId === "string" ? result.value : void 0;
-}
-function listSuspendedRuns(scope) {
-	let entries;
-	try {
-		entries = fs.readdirSync(scopeSuspendedDir(scope));
-	} catch {
-		return [];
-	}
-	const runs = [];
+function fleetEventsFromEntries(entries) {
+	const events = [];
+	const calls = /* @__PURE__ */ new Map();
 	for (const entry of entries) {
-		if (!entry.endsWith(JSON_SUFFIX)) continue;
-		let run;
-		try {
-			run = parseSuspendedRun(fs.readFileSync(path.join(scopeSuspendedDir(scope), entry), "utf-8"));
-		} catch {
-			continue;
+		if (!isRecord$2(entry) || entry.type !== "message" || !isRecord$2(entry.message)) continue;
+		const message = entry.message;
+		const at = typeof entry.timestamp === "number" ? entry.timestamp : 0;
+		if (message.role === "user") {
+			const text = contentText(message.content);
+			if (text.trim()) events.push({
+				kind: "user",
+				at,
+				text
+			});
+		} else if (message.role === "assistant") {
+			const parts = splitAssistantContent(message.content);
+			for (const thinking of parts?.thinking ?? []) events.push({
+				kind: "thinking",
+				at,
+				text: thinking
+			});
+			if (parts?.text.trim()) events.push({
+				kind: "assistant",
+				at,
+				text: parts.text,
+				...typeof message.model === "string" ? { model: message.model } : {}
+			});
+			for (const part of Array.isArray(message.content) ? message.content : []) {
+				if (!isRecord$2(part) || part.type !== "toolCall" || typeof part.id !== "string") continue;
+				const event = {
+					kind: "tool",
+					at,
+					text: "",
+					...typeof part.name === "string" ? { name: part.name } : {},
+					status: "running",
+					...isRecord$2(part.arguments) ? { args: part.arguments } : {}
+				};
+				calls.set(part.id, event);
+				events.push(event);
+			}
+		} else if (message.role === "toolResult" && typeof message.toolCallId === "string") {
+			const call = calls.get(message.toolCallId);
+			if (!call) continue;
+			call.result = contentText(message.content);
+			call.status = message.isError === true ? "error" : "ok";
 		}
-		if (run) runs.push(run);
-	}
-	return runs.sort((left, right) => left.suspendedAt - right.suspendedAt);
-}
-async function listSuspendedRunsAsync(scope) {
-	let entries;
-	try {
-		entries = await fs.promises.readdir(scopeSuspendedDir(scope));
-	} catch {
-		return [];
-	}
-	const runs = [];
-	for (const entry of entries) {
-		if (!entry.endsWith(JSON_SUFFIX)) continue;
-		try {
-			const run = parseSuspendedRun(await fs.promises.readFile(path.join(scopeSuspendedDir(scope), entry), "utf-8"));
-			if (run) runs.push(run);
-		} catch {}
-	}
-	return runs.sort((left, right) => left.suspendedAt - right.suspendedAt);
-}
-/** Drop a record once its run has been restored, or explicitly discarded. */
-function clearSuspendedRun(scope, runId) {
-	try {
-		fs.rmSync(suspendedPath(scope, runId), { force: true });
-	} catch {}
-}
-/** Whether an explicit restore can safely continue this exact run. */
-function isSuspendedRunResumable(run) {
-	if (run.runtime !== "pi" || !run.agent.trim() || !run.task.trim() || !run.cwd.trim() || !run.sessionFile) return false;
-	try {
-		fs.accessSync(run.sessionFile, fs.constants.R_OK);
-		return true;
-	} catch {
-		return false;
 	}
-}
-/** The identity prefix for a suspended line, empty for a record written before identities existed. */
-function suspendedLabel(run) {
-	const label = formatAgentIdentity(run.identity, run.inline);
-	return label ? `${label}, ` : "";
-}
-/** One line per suspended run, for the report `session_start` prints. */
-function formatSuspendedRuns(runs) {
-	if (runs.length === 0) return "";
-	const lines = runs.map((run) => {
-		const continues = isSuspendedRunResumable(run) ? "resumable" : "not resumable";
-		return `- ${run.runId} (${suspendedLabel(run)}${run.agent}, ${run.runtime}, ${continues}): ${run.task.split("\n")[0]}`;
-	});
-	const noun = runs.length === 1 ? "subagent" : "subagents";
-	return [
-		`${runs.length} suspended ${noun} from this session:`,
-		...lines,
-		"",
-		"They are stopped. Restore one with subagent {\"action\":\"restore\",\"id\":\"<run-id>\"}, or leave them."
-	].join("\n");
+	return events;
 }
 function age(job, now) {
 	return job.startedAt ? formatDuration(Math.max(0, now - job.startedAt)) : "unknown";
@@ -4299,8 +4474,8 @@ function age(job, now) {
 * Takes `now` rather than calling `Date.now()` so a test asserting rendered
 * ages does not have to freeze global time.
 */
-function formatFleetView(jobs, now = Date.now(), suspended = []) {
-	if (jobs.length === 0 && suspended.length === 0) return "No runs tracked in this session. A run appears here once it has been launched from this session.";
+function formatFleetView(jobs, now = Date.now()) {
+	if (jobs.length === 0) return "No runs tracked in this session. A run appears here once it has been launched from this session.";
 	const lines = [`${jobs.length} active run${jobs.length === 1 ? "" : "s"}:`];
 	for (const job of jobs) {
 		const parts = [`- ${job.runId}`];
@@ -4311,18 +4486,8 @@ function formatFleetView(jobs, now = Date.now(), suspended = []) {
 		if (job.error) parts.push(`error: ${job.error}`);
 		lines.push(parts.join(" · "));
 	}
-	if (suspended.length > 0) {
-		lines.push("", `${suspended.length} suspended run${suspended.length === 1 ? "" : "s"}:`);
-		for (const run of suspended) {
-			const recovery = isSuspendedRunResumable(run) ? `restore with { action: "restore", id: "${run.runId}" }` : "not resumable; submit a new explicit run";
-			const label = formatAgentIdentity(run.identity, run.inline);
-			lines.push(`- ${run.runId} (${label ? `${label}, ` : ""}${run.agent}, ${run.runtime}): ${recovery}`);
-		}
-	}
-	if (jobs.length > 0) {
-		lines.push("");
-		lines.push(`Inspect one with { action: "status", id: "<run id>", transcriptLines: 80 }.`);
-	}
+	lines.push("");
+	lines.push(`Inspect one with { action: "status", id: "<run id>", transcriptLines: 80 }.`);
 	return lines.join("\n");
 }
 /** Tool output shown to the model, bounded so one long result cannot crowd out the rest of the tail. */
@@ -4355,11 +4520,25 @@ function formatEvent(event) {
 */
 function formatRunTranscript(status, maxLines) {
 	const transcriptPath = status?.transcriptPath;
-	if (!transcriptPath) return status ? "This run has no transcript. Artifacts were disabled for it (artifacts: false), so nothing was recorded." : "No status found for this run, so there is no transcript to read.";
+	if (!transcriptPath) return status ? "This run has no transcript to read." : "No status found for this run, so there is no transcript to read.";
 	const transcript = readFleetTranscript(transcriptPath);
 	if (transcript.warning) return `Transcript at '${transcriptPath}' could not be read: ${transcript.warning}`;
 	if (transcript.events.length === 0) return `Transcript at '${transcriptPath}' is empty. The run has not written anything yet.`;
-	const rendered = transcript.events.flatMap((event) => formatEvent(event).split("\n"));
+	return formatTail(transcript.events, maxLines);
+}
+/**
+* A native run's transcript tail, read from its durable conversation rather than a file.
+*
+* ponytail: `entries` is one page of the newest entries, so the "of N lines" count covers that page, not the
+* whole run; read older pages first if a caller needs the full count.
+*/
+function formatNativeRunTranscript(entries, maxLines) {
+	const events = fleetEventsFromEntries(entries);
+	if (events.length === 0) return "The run has no transcript entries yet.";
+	return formatTail(events, maxLines);
+}
+function formatTail(events, maxLines) {
+	const rendered = events.flatMap((event) => formatEvent(event).split("\n"));
 	const kept = rendered.slice(-maxLines);
 	const dropped = rendered.length - kept.length;
 	return [
@@ -4407,7 +4586,7 @@ function startOperation(scope, operationId, args, runIds) {
 	} catch (error) {
 		if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) throw error;
 		const existing = readRecord(file);
-		if (existing.argumentHash !== argumentHash) throw new DoomTeamExpectedError("operation_conflict", `Operation '${operationId}' was already used with different arguments.`, false, "Submit the operation as a new tool call.");
+		if (existing.argumentHash !== argumentHash) throw new PoTeamExpectedError("operation_conflict", `Operation '${operationId}' was already used with different arguments.`, false, "Submit the operation as a new tool call.");
 		return {
 			kind: "replay",
 			record: existing
@@ -4444,7 +4623,6 @@ function progressMessage(params) {
 		case SUBAGENT_ACTIONS.run: return `Starting ${params.requests.length} subagent${params.requests.length === 1 ? "" : "s"}...`;
 		case SUBAGENT_ACTIONS.steer: return `Steering subagent ${params.id}...`;
 		case SUBAGENT_ACTIONS.stop: return `Requesting stop for subagent ${params.id}...`;
-		case SUBAGENT_ACTIONS.restore: return `Restoring subagent ${params.id}...`;
 		default: return;
 	}
 }
@@ -4472,12 +4650,6 @@ function publicAgent(agent) {
 		...tools.length ? { tools } : {}
 	};
 }
-function publicSuspendedRun(run) {
-	return {
-		...run,
-		resumable: isSuspendedRunResumable(run)
-	};
-}
 /** One agent in full, as the model reads it. Shared with the headless tool. */
 function formatAgentDetail(agent) {
 	const detail = publicAgent(agent);
@@ -4507,7 +4679,7 @@ function validateParams(input) {
 		requireNonblank(record, "id", action);
 		requireNonblank(record, "message", action);
 	}
-	if (action === SUBAGENT_ACTIONS.stop || action === SUBAGENT_ACTIONS.restore) requireNonblank(record, "id", action);
+	if (action === SUBAGENT_ACTIONS.stop) requireNonblank(record, "id", action);
 	return raw;
 }
 var SubagentToolService = class {
@@ -4572,7 +4744,7 @@ var SubagentToolService = class {
 		const operation = startOperation(scope, operationId, params, params.requests.map(() => randomUUID()));
 		if (operation.kind === "replay") {
 			if (operation.record.state === "completed" && operation.record.result) return operation.record.result;
-			throw new DoomTeamExpectedError("delivery_unconfirmed", `Operation '${operationId}' is already pending for runs: ${operation.record.runIds.join(", ")}.`, true, "Call subagent({\"action\":\"status\"}) and do not submit the run again.");
+			throw new PoTeamExpectedError("delivery_unconfirmed", `Operation '${operationId}' is already pending for runs: ${operation.record.runIds.join(", ")}.`, true, "Call subagent({\"action\":\"status\"}) and do not submit the run again.");
 		}
 		const result = this.trackOutcomes(await this.planner.spawn(this.buildSpawnRequest(operationId, params, ctx, operation.record.runIds), loadConfig().config), ctx);
 		const started = result.outcomes.filter((outcome) => outcome.runId);
@@ -4580,7 +4752,7 @@ var SubagentToolService = class {
 		const outcomeLines = result.outcomes.map((outcome) => {
 			return `- ${formatAgentIdentity(outcome.identity, outcome.inline) ?? outcome.agent}: ${outcome.runId ? outcome.runId : `failed: ${outcome.error ?? "unknown error"}`}${outcome.warning ? `\n  Warning: ${outcome.warning}` : ""}`;
 		});
-		if (started.length === 0 && failed.length > 0) throw new DoomTeamExpectedError("runtime_unavailable", `No requested subagent started.\n${outcomeLines.join("\n")}`, true, "Correct the reported launch failures. If an agent name is uncertain, call subagent({\"action\":\"agents\"}) before retrying only corrected requests.");
+		if (started.length === 0 && failed.length > 0) throw new PoTeamExpectedError("runtime_unavailable", `No requested subagent started.\n${outcomeLines.join("\n")}`, true, "Correct the reported launch failures. If an agent name is uncertain, call subagent({\"action\":\"agents\"}) before retrying only corrected requests.");
 		const subagentLabel = result.outcomes.length === 1 ? "subagent" : "subagents";
 		const summary = failed.length === 0 ? `Started ${started.length} ${subagentLabel}:` : `Started ${started.length}/${result.outcomes.length} ${subagentLabel}; ${failed.length} failed:`;
 		const next = failed.length === 0 ? "Completion will arrive asynchronously. Continue only non-overlapping work, or end your turn." : "Completion will arrive asynchronously for started runs. Do not resubmit them; retry only corrected failed entries.";
@@ -4597,44 +4769,35 @@ var SubagentToolService = class {
 		completeOperation(scope, operationId, operation.record, response);
 		return response;
 	}
-	executeAgents(params, ctx) {
+	async executeAgents(params, ctx) {
 		const cwd = params.cwd ?? ctx.cwd;
 		const scope = scopeOrDefault(params.scope);
 		if (!params.name) {
-			const result = this.discovery.discover(cwd, scope);
+			const result = await this.discovery.discover(cwd, scope);
 			return textResult(formatAgentList(result.agents), { agents: result.agents.map(publicAgent) });
 		}
-		const agent = this.discovery.find(cwd, scope, params.name);
+		const agent = await this.discovery.find(cwd, scope, params.name);
 		if (!agent) {
-			const candidates = this.discovery.discover(cwd, scope).agents.map((candidate) => candidate.name).toSorted();
-			throw new DoomTeamExpectedError("agent_not_found", `No executable agent matches '${params.name}'.${candidates.length ? ` Available: ${candidates.join(", ")}.` : ""}`, false, "Call subagent({\"action\":\"agents\"}) and retry with an exact name.");
+			const candidates = (await this.discovery.discover(cwd, scope)).agents.map((candidate) => candidate.name).toSorted();
+			throw new PoTeamExpectedError("agent_not_found", `No executable agent matches '${params.name}'.${candidates.length ? ` Available: ${candidates.join(", ")}.` : ""}`, false, "Call subagent({\"action\":\"agents\"}) and retry with an exact name.");
 		}
 		return textResult(formatAgentDetail(agent), { agent: publicAgent(agent) });
 	}
-	async executeManagement(params, ctx, signal, preallocatedRunIds, operationId) {
+	async executeManagement(params, ctx, signal) {
 		const scope = this.sessionScope(ctx);
 		this.management.bindSessionScope(scope);
 		const jobs = this.tracker.forSession(ctx.sessionManager.getSessionId(), scope);
 		switch (params.action) {
 			case SUBAGENT_ACTIONS.status: {
-				const suspendedRuns = listSuspendedRuns(scope);
 				if (!("id" in params)) {
 					if ("transcriptLines" in params && params.transcriptLines !== void 0) throw invalidRequest("transcriptLines requires a run id.", "Add id or omit transcriptLines for fleet status.");
 					const runs = jobs.list();
-					return textResult(formatFleetView(runs, Date.now(), suspendedRuns), {
-						fleet: runs,
-						suspended: suspendedRuns.map(publicSuspendedRun)
-					});
+					return textResult(formatFleetView(runs, Date.now()), { fleet: runs });
 				}
 				const runId = params.id;
 				if (!runId) throw invalidRequest("transcriptLines requires a run id.", "Add id or omit transcriptLines for fleet status.");
-				const suspended = suspendedRuns.find((run) => run.runId === runId);
-				if (suspended && params.transcriptLines === void 0) {
-					const recovery = isSuspendedRunResumable(suspended) ? `Restore it with { action: "restore", id: "${suspended.runId}" }.` : "It is not resumable; submit a new explicit run.";
-					return textResult(`Run '${suspended.runId}' is suspended. ${recovery}`, { suspended: publicSuspendedRun(suspended) });
-				}
 				const result = this.management.status(runId);
-				if (!result.status && !result.runDir && !result.resultPath && !suspended) throw new DoomTeamExpectedError("run_not_found", `No run matches '${runId}'.`, false, "Call subagent({\"action\":\"status\"}) and retry with an exact id.");
+				if (!result.status && !result.runDir && !result.resultPath) throw new PoTeamExpectedError("run_not_found", `No run matches '${runId}'.`, false, "Call subagent({\"action\":\"status\"}) and retry with an exact id.");
 				if (params.transcriptLines !== void 0) return textResult(formatRunTranscript(result.status, params.transcriptLines ?? 80), { transcript: { runId: result.runId } });
 				return textResult(result.status ? `Run '${result.runId}': ${result.status.state}` : `Run '${result.runId}' has no status yet.`, { status: result });
 			}
@@ -4646,44 +4809,13 @@ var SubagentToolService = class {
 			case SUBAGENT_ACTIONS.steer: {
 				const id = resolveTrackedRunId(jobs, params.id);
 				const runtime = jobs.get(id)?.runtime;
-				if (runtime && !isPiRuntime(runtime)) throw new DoomTeamExpectedError("unsupported_operation", `Run '${id}' uses '${runtime}', which does not support steering.`, false, `Use subagent({"action":"stop","id":"${id}"}) to terminate it.`);
-				const result = await this.management.steer(id, params.message, void 0, signal);
+				if (runtime && !isPiRuntime(runtime)) throw new PoTeamExpectedError("unsupported_operation", `Run '${id}' uses '${runtime}', which does not support steering.`, false, `Use subagent({"action":"stop","id":"${id}"}) to terminate it.`);
+				const result = await this.management.steer(id, {
+					text: params.message,
+					sender: MAIN_AGENT_SENDER
+				}, void 0, signal);
 				return textResult(`Steer request '${result.requestId}' for '${id}' is ${result.state}: ${result.message}`, { steer: result });
 			}
-			case SUBAGENT_ACTIONS.suspended: {
-				const runs = listSuspendedRuns(scope);
-				return textResult(runs.length ? formatSuspendedRuns(runs) : "No suspended subagents in this session.", { suspended: runs.map(publicSuspendedRun) });
-			}
-			case SUBAGENT_ACTIONS.restore: {
-				const record = listSuspendedRuns(scope).find((run) => run.runId === params.id);
-				if (!record) throw new DoomTeamExpectedError("run_not_found", `No suspended run matches '${params.id}'.`, false, "Call subagent({\"action\":\"suspended\"}) and retry with an exact id.");
-				if (!isSuspendedRunResumable(record)) throw new DoomTeamExpectedError("not_resumable", `Suspended run '${params.id}' does not have complete, readable Pi recovery state.`, false, "Submit a new explicit run request instead of restoring this record.");
-				const outcome = this.trackOutcomes(await this.planner.spawn({
-					single: {
-						agent: record.agent,
-						...record.inlineAgent ? { inlineAgent: record.inlineAgent } : {},
-						task: record.task,
-						cwd: record.cwd,
-						...record.model ? { model: record.model } : {},
-						sessionFile: record.sessionFile,
-						...record.identity ? { identity: record.identity } : {}
-					},
-					cwd: record.cwd,
-					agentScope: "both",
-					sessionScope: scope,
-					parentSessionId: ctx.sessionManager.getSessionId(),
-					availableModels: authenticatedModelInfos(ctx.modelRegistry),
-					...operationId ? { operationId } : {},
-					...preallocatedRunIds ? { preallocatedRunIds } : {}
-				}, loadConfig().config), ctx).outcomes[0];
-				if (!outcome?.runId) throw new DoomTeamExpectedError("not_resumable", `Could not restore '${params.id}': ${outcome?.error ?? "the spawn produced no run."}`, true, "Inspect suspended state, then submit a new explicit run if recovery is not possible.");
-				clearSuspendedRun(scope, params.id);
-				const restoredAs = formatAgentIdentity(outcome.identity, outcome.inline) ?? outcome.runId;
-				return textResult(`Restored '${params.id}' as '${restoredAs}' (${outcome.runId}), continuing its transcript.`, { restore: {
-					...outcome,
-					restoredFrom: params.id
-				} });
-			}
 		}
 	}
 	async execute(id, rawParams, signal, onUpdate, ctx) {
@@ -4692,22 +4824,22 @@ var SubagentToolService = class {
 		if (progress) onUpdate?.(progressResult(progress, params.action));
 		if (params.action === SUBAGENT_ACTIONS.run) return this.executeRun(id, params, ctx);
 		if (params.action === SUBAGENT_ACTIONS.agents) return this.executeAgents(params, ctx);
-		if (!(params.action === SUBAGENT_ACTIONS.steer || params.action === SUBAGENT_ACTIONS.stop || params.action === SUBAGENT_ACTIONS.restore)) return this.executeManagement(params, ctx, signal);
+		if (!(params.action === SUBAGENT_ACTIONS.steer || params.action === SUBAGENT_ACTIONS.stop)) return this.executeManagement(params, ctx, signal);
 		const scope = this.sessionScope(ctx);
 		this.management.bindSessionScope(scope);
-		const operation = startOperation(scope, id, params, params.action === SUBAGENT_ACTIONS.restore ? [randomUUID()] : []);
+		const operation = startOperation(scope, id, params, []);
 		if (operation.kind === "replay") {
 			if (operation.record.state === "completed" && operation.record.result) return operation.record.result;
-			throw new DoomTeamExpectedError("delivery_unconfirmed", `Operation '${id}' is already pending.`, true, "Inspect run status before retrying this control operation.");
+			throw new PoTeamExpectedError("delivery_unconfirmed", `Operation '${id}' is already pending.`, true, "Inspect run status before retrying this control operation.");
 		}
-		const response = await this.executeManagement(params, ctx, signal, operation.record.runIds, id);
+		const response = await this.executeManagement(params, ctx, signal);
 		completeOperation(scope, id, operation.record, response);
 		return response;
 	}
 };
 //#endregion
 //#region src/services/headlessSubagentTool/index.ts
-const SUBAGENT_DESCRIPTION = "Discover agents, start and manage persistent background subagent runs, and inspect suspended work.";
+const SUBAGENT_DESCRIPTION = "Discover agents, start and manage persistent background subagent runs.";
 /**
 * Every result carries the text the MODEL reads and the structured details the
 * cockpit card reads. The text is always given explicitly: a serialized detail
@@ -4750,18 +4882,17 @@ function createHeadlessSubagentTool(runtime, initialExecution) {
 		label: "Subagent",
 		description: SUBAGENT_DESCRIPTION,
 		parameters: SubagentToolSchema,
-		promptSnippet: "Discover, run, inspect, steer, stop, and restore persistent subagents",
-		promptGuidelines: ["Runs are persistent background work. Do not resubmit a run that already returned an id.", "Use status or suspended before retrying a failed or interrupted operation."],
+		promptSnippet: "Discover, run, inspect, steer, and stop persistent subagents",
+		promptGuidelines: ["Runs are persistent background work. Do not resubmit a run that already returned an id.", "Use status before retrying a failed or interrupted operation."],
 		executionMode: "serial",
 		async execute(_toolCallId, parameters, signal, onUpdate, execution = initialExecution) {
 			try {
 				const params = validateParams(parameters);
-				const availableModels = execution.getAvailableModels?.().map(toModelInfo) ?? (execution.model ? [toModelInfo(execution.model)] : []);
 				if (params.action === SUBAGENT_ACTIONS.agents) {
 					const scope = scopeOf(params.scope);
-					const agents = runtime.discovery.discover(params.cwd ?? execution.cwd, scope).agents;
-					const selected = params.name ? runtime.discovery.find(params.cwd ?? execution.cwd, scope, params.name) : void 0;
-					if (params.name && !selected) throw new DoomTeamExpectedError("agent_not_found", `No executable agent matches '${params.name}'.`, false, "Call subagent({\"action\":\"agents\"}) and retry with an exact agent name.");
+					const agents = (await runtime.discovery.discover(params.cwd ?? execution.cwd, scope)).agents;
+					const selected = params.name ? await runtime.discovery.find(params.cwd ?? execution.cwd, scope, params.name) : void 0;
+					if (params.name && !selected) throw new PoTeamExpectedError("agent_not_found", `No executable agent matches '${params.name}'.`, false, "Call subagent({\"action\":\"agents\"}) and retry with an exact agent name.");
 					if (selected) return result(formatAgentDetail(selected), { agents: [publicAgent(selected)] });
 					return result(formatAgentList(agents), { agents: agents.map((agent) => ({
 						name: agent.name,
@@ -4790,9 +4921,10 @@ function createHeadlessSubagentTool(runtime, initialExecution) {
 						sessionScope: createSessionScope(execution.sessionId),
 						environment: execution.environment,
 						parentSessionId: execution.sessionId,
+						parentSelection: execution.selection,
 						...params.concurrency === void 0 ? {} : { concurrency: params.concurrency },
 						...params.artifacts === void 0 ? {} : { artifacts: params.artifacts },
-						availableModels,
+						availableModels: await availableModelInfos(execution),
 						...execution.model ? { parentModel: execution.model } : {},
 						...parentForkSource ? { parentForkSource } : {}
 					}, loadConfig().config);
@@ -4808,19 +4940,13 @@ function createHeadlessSubagentTool(runtime, initialExecution) {
 						return result(formatFleetView(runs), { runs });
 					}
 					const status = runtime.management.statusAsync ? await runtime.management.statusAsync(params.id) : runtime.management.status(params.id);
-					return result([status.status ? [`Run '${status.runId}': ${status.status.state}`, status.status.summary ? `Summary: ${status.status.summary}` : void 0].filter((line) => line !== void 0).join("\n") : `Run '${status.runId}' has no status yet.`, params.transcriptLines === void 0 ? void 0 : formatRunTranscript(status.status, params.transcriptLines)].filter((text) => text !== void 0).join("\n\n"), {
+					const statusText = status.status ? [`Run '${status.runId}': ${status.status.state}`, status.status.summary ? `Summary: ${status.status.summary}` : void 0].filter((line) => line !== void 0).join("\n") : `Run '${status.runId}' has no status yet.`;
+					const nativeEntries = params.transcriptLines === void 0 || status.status?.transcriptPath !== void 0 ? void 0 : await runtime.nativeRuns.readTranscript(execution.sessionId, status.runId, params.transcriptLines);
+					return result([statusText, params.transcriptLines === void 0 ? void 0 : nativeEntries !== void 0 ? formatNativeRunTranscript(nativeEntries, params.transcriptLines) : formatRunTranscript(status.status, params.transcriptLines)].filter((text) => text !== void 0).join("\n\n"), {
 						runId: status.runId,
 						status: status.status
 					});
 				}
-				if (params.action === SUBAGENT_ACTIONS.suspended) {
-					const suspended = listSuspendedRuns(createSessionScope(execution.sessionId));
-					const text = suspended.length ? formatSuspendedRuns(suspended) : "No suspended subagents in this session.";
-					return result(text, {
-						suspended,
-						text
-					});
-				}
 				const id = resolveTrackedRunId(jobs, params.id);
 				if (params.action === SUBAGENT_ACTIONS.stop) {
 					const control = await runtime.management.stop(id, params.reason);
@@ -4829,40 +4955,14 @@ function createHeadlessSubagentTool(runtime, initialExecution) {
 						control
 					});
 				}
-				if (params.action === SUBAGENT_ACTIONS.steer) {
-					const steer = await runtime.management.steer(id, params.message, void 0, signal);
-					return result(`Steer request '${steer.requestId}' for '${id}' is ${steer.state}: ${steer.message}`, {
-						runId: id,
-						steer
-					});
-				}
-				const suspended = listSuspendedRuns(createSessionScope(execution.sessionId)).find((item) => item.runId === params.id);
-				if (!suspended) throw new Error(`No suspended run matches '${params.id}'.`);
-				if (!isSuspendedRunResumable(suspended)) throw new Error(`Suspended run '${params.id}' is not resumable.`);
-				const outcome = (await runtime.spawnPlanner.spawn({
-					single: {
-						agent: suspended.agent,
-						...suspended.inlineAgent ? { inlineAgent: suspended.inlineAgent } : {},
-						task: suspended.task,
-						cwd: suspended.cwd,
-						...suspended.model ? { model: suspended.model } : {},
-						sessionFile: suspended.sessionFile,
-						...suspended.identity ? { identity: suspended.identity } : {}
-					},
-					cwd: suspended.cwd,
-					agentScope: "both",
-					sessionScope: createSessionScope(execution.sessionId),
-					environment: execution.environment,
-					runtime: "pi",
-					parentSessionId: execution.sessionId,
-					availableModels
-				}, loadConfig().config)).outcomes[0];
-				if (!outcome?.runId) throw new Error(`Could not restore '${params.id}': ${outcome?.error ?? "the spawn produced no run."}`);
-				clearSuspendedRun(createSessionScope(execution.sessionId), params.id);
-				return result(`Restored '${params.id}' as '${outcome.runId}', continuing its transcript.`, { restore: {
-					...outcome,
-					restoredFrom: params.id
-				} });
+				const steer = await runtime.management.steer(id, {
+					text: params.message,
+					sender: MAIN_AGENT_SENDER
+				}, void 0, signal);
+				return result(`Steer request '${steer.requestId}' for '${id}' is ${steer.state}: ${steer.message}`, {
+					runId: id,
+					steer
+				});
 			} catch (error) {
 				const message = error instanceof Error ? error.message : String(error);
 				return result(message, message, true);
@@ -4872,7 +4972,7 @@ function createHeadlessSubagentTool(runtime, initialExecution) {
 }
 //#endregion
 //#region src/services/mcpTools/index.ts
-const TEAM_MCP_TOOLS_SERVICE = "doom/team-mcp-tools";
+const TEAM_MCP_TOOLS_SERVICE = "po/team-mcp-tools";
 function mountMcpTools(tools) {
 	return (context) => {
 		context.plugin((providerContext) => {
@@ -4922,7 +5022,7 @@ function subscribeNativeRunProjection(sessionId, listener) {
 		if (closed) return;
 		closed = true;
 		projection.listeners.delete(listener);
-		if (projection.listeners.size === 0 && projection.runs.size === 0) sessions.delete(sessionId);
+		if (projection.listeners.size === 0 && projection.runs.size === 0 && sessions.get(sessionId) === projection) sessions.delete(sessionId);
 	};
 }
 //#endregion
@@ -5138,7 +5238,7 @@ function formatGroupedCompletion(details) {
 *
 * Separate from `formatSingleCompletion` because the two have different
 * readers. That one is written for the model and embeds the run's full result
-* preview; this one goes to `DoomHeadlessClient.notify`, which collapses every
+* preview; this one goes to `PoHeadlessClient.notify`, which collapses every
 * newline to a space and truncates at 4096 characters
 * (`packages/core/po-core/src/schemas/notification.ts`), and on the web
 * additionally drives a browser notification. Feeding the model-facing text to
@@ -5211,7 +5311,7 @@ function buildCompletionDetails(result) {
 * The custom-message type the parent renders completions under. The literal is
 * shared by the producer here and the TUI renderer registered for it
 * (`(frontend)/message/_lib/subagent-notify.cli.ts`, which draws through
-* `completionNotice.ts`), and by the headless facet, which persists the same
+* `completionNotice.ts`), and by the server plugin, which persists the same
 * type as a session entry so a cockpit transcript records what was delivered.
 */
 const SUBAGENT_NOTIFY_MESSAGE_TYPE = "subagent-notify";
@@ -5337,41 +5437,149 @@ function active(job) {
 		"stopped"
 	])).has(job.status);
 }
-function suspendedRecord(job, reason, suspendedAt) {
+/**
+* Stops the live external runs of a session that ends. A native run is a conversation of the session's own
+* Harness and resumes with it, so it is left alone.
+*/
+async function stopScopeRuns(options) {
+	const jobs = options.jobs.filter((job) => !job.native && active(job));
+	const outcomes = await Promise.allSettled(jobs.map((job) => options.stop(job.runId, options.reason)));
 	return {
-		runId: job.runId,
-		agent: job.agent ?? "unknown",
-		...job.identity === void 0 ? {} : { identity: job.identity },
-		...job.inline === void 0 ? {} : { inline: job.inline },
-		runtime: job.runtime ?? (job.native ? "pi" : "external"),
-		task: job.task ?? "",
-		cwd: job.cwd ?? "",
-		...job.status === void 0 ? {} : { lastStatus: job.status },
-		...job.sessionFile === void 0 ? {} : { sessionFile: job.sessionFile },
-		suspendedAt,
-		reason
+		stopped: jobs.map((job) => job.runId),
+		unstoppable: jobs.filter((_, index) => outcomes[index]?.status === "rejected").map((job) => job.runId)
 	};
 }
-/** Persist resumable metadata, then stop every live run through its typed owner. */
-async function suspendScopeRuns(options) {
-	const jobs = options.jobs.filter(active);
-	const suspendedAt = options.now?.() ?? Date.now();
-	for (const job of jobs) suspendRun(options.scope, suspendedRecord(job, options.reason, suspendedAt));
-	const outcomes = await Promise.allSettled(jobs.map((job) => options.stop(job.runId, options.reason)));
+//#endregion
+//#region src/schemas/team/packageConfig.ts
+const PO_TEAM_PACKAGE = "@agimon-ai/po-team";
+const TEAM_CONFIG_KEYS = ["models", "excludeTools"];
+const TEAM_MODEL_KEYS = ["model", "thinking"];
+const THINKING_VALUES = /* @__PURE__ */ new Set([
+	"off",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+]);
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assertKnownKeys(value, keys, location) {
+	const unsupported = Object.keys(value).filter((key) => !keys.includes(key));
+	if (unsupported.length > 0) throw new Error(`${location} has unsupported field(s): ${unsupported.join(", ")}`);
+}
+/** Validate and normalize one Team-owned package configuration mapping. */
+function parseTeamPackageConfig(value, location) {
+	if (!isRecord$1(value)) throw new Error(`${location} must be a mapping`);
+	assertKnownKeys(value, TEAM_CONFIG_KEYS, location);
+	const hasModels = Object.hasOwn(value, "models");
+	const hasExcludeTools = Object.hasOwn(value, "excludeTools");
+	if (!hasModels && !hasExcludeTools) throw new Error(`${location} must define models or excludeTools`);
+	let models;
+	if (hasModels) {
+		if (!Array.isArray(value.models) || value.models.length === 0) throw new Error(`${location}.models must be a non-empty array`);
+		models = value.models.map((entry, index) => {
+			const entryLocation = `${location}.models[${index}]`;
+			if (!isRecord$1(entry)) throw new Error(`${entryLocation} must be a mapping`);
+			assertKnownKeys(entry, TEAM_MODEL_KEYS, entryLocation);
+			if (typeof entry.model !== "string" || !entry.model.trim()) throw new Error(`${entryLocation}.model must be a non-empty string`);
+			if (entry.thinking !== void 0 && (typeof entry.thinking !== "string" || !THINKING_VALUES.has(entry.thinking))) throw new Error(`${entryLocation}.thinking must be one of: ${[...THINKING_VALUES].join(", ")}`);
+			return {
+				model: entry.model.trim(),
+				...entry.thinking ? { thinking: entry.thinking } : {}
+			};
+		});
+	}
+	let excludeTools;
+	if (hasExcludeTools) {
+		if (!Array.isArray(value.excludeTools) || value.excludeTools.length === 0) throw new Error(`${location}.excludeTools must be a non-empty array`);
+		excludeTools = [...new Set(value.excludeTools.map((entry, index) => {
+			if (typeof entry !== "string" || !entry.trim()) throw new Error(`${location}.excludeTools[${index}] must be a non-empty string`);
+			return entry.trim();
+		}))];
+	}
 	return {
-		suspended: jobs.map((job) => job.runId),
-		unstoppable: jobs.filter((_, index) => outcomes[index]?.status === "rejected").map((job) => job.runId)
+		...models ? { models } : {},
+		...excludeTools ? { excludeTools } : {}
 	};
 }
-/** Async form used by session startup. */
-async function openScopeAsync(scope) {
+/** Merge Team configurations contributed by selected layers in selection order. */
+function mergeTeamPackageConfigurations(entries) {
+	let models;
+	const excludeTools = /* @__PURE__ */ new Set();
+	let hasExcludeTools = false;
+	for (const entry of entries) {
+		const location = `Package "${entry.specifier}" config in layer "${entry.layer}" of .po/modes.yaml`;
+		const next = parseTeamPackageConfig(entry.config, location);
+		if (next.models) models = next.models.map((model) => ({ ...model }));
+		if (next.excludeTools) {
+			hasExcludeTools = true;
+			for (const tool of next.excludeTools) excludeTools.add(tool);
+		}
+	}
+	if (!models && !hasExcludeTools) return void 0;
 	return {
-		pruned: [],
-		reaped: 0,
-		suspended: await listSuspendedRunsAsync(scope)
+		...models ? { models } : {},
+		...hasExcludeTools ? { excludeTools: [...excludeTools] } : {}
 	};
 }
 //#endregion
+//#region src/services/teamAgentConfig/index.ts
+const PO_TEAM_AGENT_CONFIG_SERVICE = "po/team-agent-config";
+/** Normalize Team's ordered models without duplicating a known thinking suffix. */
+function teamModelSpecs(config) {
+	return config?.models?.map(({ model, thinking }) => thinking ? `${model.replace(/:(?:off|minimal|low|medium|high|xhigh|max)$/, "")}:${thinking}` : model);
+}
+/** Session-local Team policy, loaded once for each injected config snapshot. */
+var TeamAgentConfigService = class {
+	io;
+	snapshot;
+	loads = /* @__PURE__ */ new WeakMap();
+	constructor(io) {
+		this.io = io;
+	}
+	bind(snapshot) {
+		this.snapshot = snapshot;
+		return () => {
+			if (this.snapshot === snapshot) this.snapshot = void 0;
+		};
+	}
+	current() {
+		if (!this.snapshot) return Promise.reject(new PoTeamExpectedError("runtime_unavailable", "Team agent configuration is not loaded yet.", true, "Retry after the session configuration is ready."));
+		const snapshot = this.snapshot();
+		const cached = this.loads.get(snapshot);
+		if (cached) return cached;
+		const load = this.load(snapshot).catch((error) => {
+			this.loads.delete(snapshot);
+			throw error;
+		});
+		this.loads.set(snapshot, load);
+		return load;
+	}
+	currentOrUndefined() {
+		return this.snapshot ? this.current() : Promise.resolve(void 0);
+	}
+	async load(snapshot) {
+		const { fs, homeDirectory, environment } = this.io;
+		if (!snapshot.harness.root) return { planningSubagents: snapshot.settings.modes?.planning?.subagents };
+		const modes = await readMajorModesConfig(fs, snapshot.harness.root, BACKGROUND_CONTEXT, {
+			homeDirectory,
+			environment
+		});
+		const configurations = await readPackageConfigurations(fs, modes, [...snapshot.harness.layers], PO_TEAM_PACKAGE, BACKGROUND_CONTEXT);
+		const config = mergeTeamPackageConfigurations(configurations);
+		return {
+			models: teamModelSpecs(config),
+			thinking: config?.models?.[0]?.thinking,
+			excludeTools: config?.excludeTools,
+			planningSubagents: snapshot.settings.modes?.planning?.subagents,
+			...config ? { path: configurations.at(-1)?.filePath ?? path.join(snapshot.harness.root, ".po", "modes.yaml") } : {}
+		};
+	}
+};
+//#endregion
 //#region src/services/directRunBackgroundWork/index.ts
 const PROVIDER_NAME = "team-direct-runs";
 /** Publish direct Team runs owned by exactly one Pi session. */
@@ -5399,7 +5607,7 @@ function assertPolicy(policy) {
 /** Publishes Team's capability intersection store through a Cordis service. */
 function createSubagentPolicyService(store) {
 	const service = {
-		generation: `doom-subagent-policy:${crypto.randomUUID()}`,
+		generation: `po-subagent-policy:${crypto.randomUUID()}`,
 		register(initialPolicy) {
 			assertPolicy(initialPolicy);
 			const owner = initialPolicy.owner;
@@ -5431,7 +5639,7 @@ function createSubagentPolicyService(store) {
 //#region src/services/teamCollaboration/index.ts
 /** Mount every Team-owned collaboration capability in one session fiber. */
 function teamCollaborationPlugin(ctx, config) {
-	const backgroundWork = readDoomBackgroundWorkService(ctx);
+	const backgroundWork = readPoBackgroundWorkService(ctx);
 	if (backgroundWork === void 0) throw new Error("Team requires the Po Session foundation.");
 	const subagentPolicy = createSubagentPolicyService(config.policies);
 	const delegation = config.delegation.createService(ctx, config.session);
@@ -5441,28 +5649,28 @@ function teamCollaborationPlugin(ctx, config) {
 		cwd: config.session.cwd,
 		environment: config.session.environment
 	});
-	ctx.provide(DOOM_SUBAGENT_POLICY_SERVICE, subagentPolicy);
-	ctx.provide(DOOM_DELEGATION_SERVICE, delegation);
-	ctx.provide(DOOM_FABLE_PLAN_SERVICE, fablePlan);
+	ctx.provide(PO_SUBAGENT_POLICY_SERVICE, subagentPolicy);
+	ctx.provide(PO_DELEGATION_SERVICE, delegation);
+	ctx.provide(PO_FABLE_PLAN_SERVICE, fablePlan);
 	registerDirectRunBackgroundWork(ctx, backgroundWork, config.session.sessionId, config.directRunTracker);
 	if (config.observeDelegation) {
-		ctx.on(DOOM_DELEGATION_REQUESTED_EVENT, (event) => config.observeDelegation?.({
+		ctx.on(PO_DELEGATION_REQUESTED_EVENT, (event) => config.observeDelegation?.({
 			kind: "requested",
 			event
 		}));
-		ctx.on(DOOM_DELEGATION_STARTED_EVENT, (event) => config.observeDelegation?.({
+		ctx.on(PO_DELEGATION_STARTED_EVENT, (event) => config.observeDelegation?.({
 			kind: "started",
 			event
 		}));
-		ctx.on(DOOM_DELEGATION_UPDATED_EVENT, (event) => config.observeDelegation?.({
+		ctx.on(PO_DELEGATION_UPDATED_EVENT, (event) => config.observeDelegation?.({
 			kind: "updated",
 			event
 		}));
-		ctx.on(DOOM_DELEGATION_FINISHED_EVENT, (event) => config.observeDelegation?.({
+		ctx.on(PO_DELEGATION_FINISHED_EVENT, (event) => config.observeDelegation?.({
 			kind: "finished",
 			event
 		}));
-		ctx.on(DOOM_DELEGATION_CANCELLED_EVENT, (event) => config.observeDelegation?.({
+		ctx.on(PO_DELEGATION_CANCELLED_EVENT, (event) => config.observeDelegation?.({
 			kind: "cancelled",
 			event
 		}));
@@ -5533,11 +5741,11 @@ var ManagementActions = class {
 		if (exact) return exact;
 		const matches = runs.filter((run) => run.runId.startsWith(id));
 		if (matches.length === 1) return matches[0];
-		if (matches.length > 1) throw new DoomTeamExpectedError("run_not_found", `Multiple current-session runs match '${id}'.`, false, "Retry with a longer run id.");
+		if (matches.length > 1) throw new PoTeamExpectedError("run_not_found", `Multiple current-session runs match '${id}'.`, false, "Retry with a longer run id.");
 	}
 	requireActiveJob(id) {
 		const job = this.resolveJob(id);
-		if (!job) throw new DoomTeamExpectedError("run_not_found", `No active run matches '${id}'.`, false, "Call subagent({\"action\":\"status\"}) and retry with an exact run id.");
+		if (!job) throw new PoTeamExpectedError("run_not_found", `No active run matches '${id}'.`, false, "Call subagent({\"action\":\"status\"}) and retry with an exact run id.");
 		return job;
 	}
 	status(id) {
@@ -5551,7 +5759,20 @@ var ManagementActions = class {
 		};
 	}
 	async statusAsync(id) {
-		return this.status(id);
+		const live = this.status(id);
+		if (live.status || !this.nativeRuns?.reported) return live;
+		const run = await this.nativeRuns.reported(id);
+		if (!run?.state) return live;
+		return {
+			...live,
+			status: statusProjection({
+				runId: id,
+				agent: run.agent,
+				task: run.task,
+				status: run.state,
+				native: true
+			})
+		};
 	}
 	list() {
 		return { runs: this.sessionJobs().list() };
@@ -5567,11 +5788,11 @@ var ManagementActions = class {
 		const job = this.requireActiveJob(id);
 		const requestId = randomUUID();
 		if (job.native) {
-			if (!this.nativeRuns?.get(scope.rootSessionId, job.runId)) throw new DoomTeamExpectedError("run_not_found", `Native run '${job.runId}' is no longer active.`, false, "List active runs and retry with a current run id.");
+			if (!this.nativeRuns?.get(scope.rootSessionId, job.runId)) throw new PoTeamExpectedError("run_not_found", `Native run '${job.runId}' is no longer active.`, false, "List active runs and retry with a current run id.");
 			await this.nativeRuns.stop(scope.rootSessionId, job.runId, reason);
 			return { requestId };
 		}
-		if (!this.externalProcesses?.has(scope, job.runId)) throw new DoomTeamExpectedError("run_not_found", `External run '${job.runId}' is no longer active.`, false, "List active runs and retry with a current run id.");
+		if (!this.externalProcesses?.has(scope, job.runId)) throw new PoTeamExpectedError("run_not_found", `External run '${job.runId}' is no longer active.`, false, "List active runs and retry with a current run id.");
 		await this.externalProcesses.control(scope, job.runId, {
 			command,
 			requestId,
@@ -5585,7 +5806,7 @@ var ManagementActions = class {
 		const requestId = randomUUID();
 		const index = targetIndex ?? 0;
 		if (job.native) {
-			if (!this.nativeRuns?.get(scope.rootSessionId, job.runId)) throw new DoomTeamExpectedError("run_not_found", `Native run '${job.runId}' is no longer active.`, false, "List active runs and retry with a current run id.");
+			if (!this.nativeRuns?.get(scope.rootSessionId, job.runId)) throw new PoTeamExpectedError("run_not_found", `Native run '${job.runId}' is no longer active.`, false, "List active runs and retry with a current run id.");
 			await this.nativeRuns.steer(scope.rootSessionId, job.runId, message, signal);
 			return {
 				requestId,
@@ -5594,11 +5815,11 @@ var ManagementActions = class {
 				message: "Native child accepted the steer request."
 			};
 		}
-		if (!this.externalProcesses?.has(scope, job.runId)) throw new DoomTeamExpectedError("run_not_found", `External run '${job.runId}' is no longer active.`, false, "List active runs and retry with a current run id.");
+		if (!this.externalProcesses?.has(scope, job.runId)) throw new PoTeamExpectedError("run_not_found", `External run '${job.runId}' is no longer active.`, false, "List active runs and retry with a current run id.");
 		const acknowledgement = await this.externalProcesses.control(scope, job.runId, {
 			command: "steer",
 			requestId,
-			message,
+			message: typeof message === "string" ? message : message.text,
 			targetIndex: index
 		});
 		if (!acknowledgement) return {
@@ -5645,140 +5866,6 @@ var McpDirectToolResolverBinding = class {
 	}
 };
 //#endregion
-//#region src/services/nativeRunCoordinator/index.ts
-function terminalState(event) {
-	return event.state === "completed" || event.state === "failed" || event.state === "stopped" ? event.state : void 0;
-}
-function entryKey(sessionId, runId) {
-	return JSON.stringify([sessionId, runId]);
-}
-var NativeRunCoordinator = class {
-	childSessions;
-	tracker;
-	notifier;
-	projection;
-	entries = /* @__PURE__ */ new Map();
-	closed = false;
-	closing;
-	constructor(childSessions, tracker, notifier, projection) {
-		this.childSessions = childSessions;
-		this.tracker = tracker;
-		this.notifier = notifier;
-		this.projection = projection;
-	}
-	async start(sessionId, request, identity) {
-		if (this.closed) throw new Error("The native Team run coordinator is closed.");
-		if (!sessionId.trim()) throw new Error("Native child runs require a session identity.");
-		const service = this.childSessions?.get();
-		if (!service) throw new Error("The in-process Pi child-session service is unavailable.");
-		const handle = await service.start(request);
-		if (this.closed) {
-			await handle.dispose();
-			throw new Error("The native Team run coordinator closed during child startup.");
-		}
-		const entry = {
-			sessionId,
-			scope: request.scope,
-			request,
-			...identity ? { identity } : {},
-			handle,
-			terminal: false
-		};
-		const key = entryKey(sessionId, request.runId);
-		this.entries.set(key, entry);
-		try {
-			const unsubscribe = handle.subscribe((event) => this.onEvent(entry, event));
-			if (entry.terminal) unsubscribe();
-			else entry.unsubscribe = unsubscribe;
-			return handle;
-		} catch (error) {
-			this.entries.delete(key);
-			await handle.dispose().catch(() => void 0);
-			throw error;
-		}
-	}
-	get(sessionId, runId) {
-		return this.entries.get(entryKey(sessionId, runId))?.handle;
-	}
-	status(sessionId, runId) {
-		return this.tracker.getNative(sessionId, runId);
-	}
-	async steer(sessionId, runId, message, signal) {
-		const handle = this.get(sessionId, runId);
-		if (!handle) throw new Error(`No active native run matches '${runId}'.`);
-		await handle.steer(message, signal);
-	}
-	async stop(sessionId, runId, reason) {
-		const handle = this.get(sessionId, runId);
-		if (!handle) throw new Error(`No active native run matches '${runId}'.`);
-		await handle.stop(reason);
-	}
-	async close() {
-		this.closed = true;
-		this.closing ??= (async () => {
-			const active = [...this.entries.values()];
-			const outcomes = await Promise.allSettled(active.map((entry) => entry.handle.dispose()));
-			for (const entry of active) {
-				entry.unsubscribe?.();
-				this.entries.delete(entryKey(entry.sessionId, entry.request.runId));
-			}
-			const failures = outcomes.filter((outcome) => outcome.status === "rejected").map((outcome) => outcome.reason);
-			if (failures.length) throw new AggregateError(failures, "Native Team run shutdown failed.");
-		})();
-		return this.closing;
-	}
-	onEvent(entry, event) {
-		entry.startedAt ??= event.timestamp;
-		const status = terminalState(event);
-		const projection = {
-			runId: event.runId,
-			agent: entry.request.agent,
-			...entry.identity ? {
-				identity: entry.identity.identity,
-				inline: entry.identity.inline
-			} : {},
-			task: entry.request.task,
-			cwd: entry.request.cwd,
-			runtime: "pi",
-			status: event.state === "starting" ? "queued" : event.state === "running" ? "running" : event.state,
-			startedAt: entry.startedAt,
-			updatedAt: event.timestamp,
-			...event.cost === void 0 ? {} : { cost: event.cost },
-			...event.sessionFile ? { sessionFile: event.sessionFile } : {},
-			...event.message ? {
-				error: status === "failed" || status === "stopped" ? event.message : void 0,
-				summary: event.message
-			} : {}
-		};
-		this.tracker.upsertNative(entry.sessionId, entry.scope, projection);
-		this.projection?.publish(entry.sessionId, projection);
-		if (!status || entry.terminal) return;
-		entry.terminal = true;
-		entry.unsubscribe?.();
-		this.entries.delete(entryKey(entry.sessionId, entry.request.runId));
-		const result = {
-			runId: entry.request.runId,
-			agent: entry.request.agent,
-			...entry.identity ? {
-				identity: entry.identity.identity,
-				inline: entry.identity.inline
-			} : {},
-			task: entry.request.task,
-			cwd: entry.request.cwd,
-			runtime: "pi",
-			state: status,
-			success: status === "completed",
-			summary: event.message ?? (status === "completed" ? "Native child run completed." : `Native child run ${status}.`),
-			durationMs: Math.max(0, event.timestamp - (this.tracker.getNative(entry.sessionId, entry.request.runId)?.startedAt ?? event.timestamp)),
-			sessionId: entry.sessionId,
-			...event.sessionFile ? { sessionFile: event.sessionFile } : {}
-		};
-		if (this.notifier) this.notifier.deliver(result).then((delivered) => {
-			if (delivered) this.tracker.acknowledgeHandoff(entry.sessionId, entry.request.runId);
-		}).catch(() => void 0);
-	}
-};
-//#endregion
 //#region src/services/pollScheduler/index.ts
 /**
 * One master tick that drives every background subscriber in the runner
@@ -6094,14 +6181,14 @@ function createTeamExtensionRuntime(reportConcurrencyEvent, options) {
 	const subagentWaiter = new SubagentWaiter(asyncJobTracker);
 	const externalProcesses = new ExternalProcessIpc();
 	const asyncSubagentSpawner = new AsyncSubagentSpawner(externalProcesses);
-	const discovery = new AgentDiscoveryService(options.environment);
+	const discovery = new AgentDiscoveryService(options.discoveryIo, options.agentConfig);
 	const skills = new SkillDiscoveryService();
 	const capabilityPolicies = new SubagentCapabilityPolicyStore();
 	const mcpToolResolver = new McpDirectToolResolverBinding();
 	const completionNotifier = new CompletionNotifier();
 	const nativeRuns = new NativeRunCoordinator(options.childSessions, asyncJobTracker, completionNotifier, options.nativeRunProjection);
 	const teamChannel = new NativeTeamChannelService();
-	const spawnPlanner = new SpawnPlanner(discovery, asyncSubagentSpawner, capabilityPolicies, skills, report, mcpToolResolver, admission, options.childSessions, nativeRuns, teamChannel, options.environment);
+	const spawnPlanner = new SpawnPlanner(discovery, asyncSubagentSpawner, capabilityPolicies, skills, report, mcpToolResolver, admission, options.childSessions, nativeRuns, teamChannel, options.environment, options.agentConfig);
 	const management = new ManagementActions(asyncJobTracker, nativeRuns, externalProcesses);
 	const onExternalEvent = (event) => {
 		const sessionId = event.scope.rootSessionId;
@@ -6158,6 +6245,7 @@ function createTeamExtensionRuntime(reportConcurrencyEvent, options) {
 		subagentWaiter,
 		asyncSubagentSpawner,
 		discovery,
+		agentConfig: options.agentConfig,
 		skills,
 		spawnPlanner,
 		completionNotifier,
@@ -6239,12 +6327,16 @@ function presentTrackedRun(run) {
 		state: runState(run.status),
 		rawState: run.status,
 		task: run.task ?? "",
+		...run.promptWithheld ? { promptWithheld: true } : {},
 		cwd: run.cwd ?? "",
 		startedAt: run.startedAt,
 		...TERMINAL_RUN_STATES.has(run.status) ? { endedAt: lastUpdate } : {},
 		lastUpdate,
 		tail: [],
-		...run.sessionFile === void 0 ? {} : { sessionFile: run.sessionFile },
+		canSteer: false,
+		...run.tokens === void 0 ? {} : { tokens: run.tokens },
+		...run.toolCount === void 0 ? {} : { toolCount: run.toolCount },
+		...run.cost === void 0 ? {} : { cost: run.cost },
 		...run.summary === void 0 ? {} : { summary: run.summary },
 		...run.error === void 0 ? {} : { error: run.error }
 	};
@@ -6255,6 +6347,8 @@ function presentNativeRun(run) {
 		agent: run.agent,
 		...run.identity === void 0 ? {} : { identity: run.identity },
 		...run.inline === void 0 ? {} : { inline: run.inline },
+		...run.agentDescription === void 0 ? {} : { agentDescription: run.agentDescription },
+		...run.agentFilePath === void 0 ? {} : { agentFilePath: run.agentFilePath },
 		state: runState(run.status),
 		rawState: run.status,
 		task: run.task,
@@ -6263,7 +6357,14 @@ function presentNativeRun(run) {
 		...TERMINAL_RUN_STATES.has(run.status) ? { endedAt: run.updatedAt } : {},
 		lastUpdate: run.updatedAt,
 		tail: [],
-		...run.sessionFile === void 0 ? {} : { sessionFile: run.sessionFile },
+		...run.model === void 0 ? {} : {
+			model: run.model,
+			modelSource: "runtime"
+		},
+		...run.thinking === void 0 ? {} : { thinking: run.thinking },
+		...run.tokens === void 0 ? {} : { tokens: run.tokens },
+		...run.toolCount === void 0 ? {} : { toolCount: run.toolCount },
+		...run.cost === void 0 ? {} : { cost: run.cost },
 		...run.summary === void 0 ? {} : { summary: run.summary },
 		...run.error === void 0 ? {} : { error: run.error }
 	};
@@ -6273,7 +6374,7 @@ function publishRuns(directEvents, sessionId, jobs, nativeRuns) {
 	runs.push(...[...nativeRuns.values()].map(presentNativeRun));
 	directEvents.publish(SUBAGENT_RUNS_TYPE, sessionId, { runs });
 }
-const TEAM_COST_STATUS = "doom-team-cost";
+const TEAM_COST_STATUS = "po-team-cost";
 const COST_DECIMALS = 6;
 function updateTeamCost(client, jobs, nativeRuns, costs, previousText, attached, force = false) {
 	const trackedCosts = /* @__PURE__ */ new Map();
@@ -6293,20 +6394,20 @@ function updateTeamCost(client, jobs, nativeRuns, costs, previousText, attached,
 function recordDelegationObservation(telemetry, observation) {
 	if (observation.kind === "requested") {
 		const { event } = observation;
-		telemetry.recordEvent("doom_team.delegation_requested", {
+		telemetry.recordEvent("po_team.delegation_requested", {
 			"agent.name": event.agent,
 			"task.id": event.taskId,
 			mode: event.runMode ?? "foreground"
 		});
 	} else if (observation.kind === "started") {
 		const { event } = observation;
-		telemetry.recordEvent("doom_team.child_started", {
+		telemetry.recordEvent("po_team.child_started", {
 			"run.id": event.runId,
 			outcome: "started"
 		});
 	} else if (observation.kind === "updated") {
 		const { event } = observation;
-		telemetry.recordEvent("doom_team.delegation_updated", {
+		telemetry.recordEvent("po_team.delegation_updated", {
 			"run.id": event.runId,
 			"team.tool_count": event.toolCount ?? 0,
 			"team.duration_ms": event.durationMs ?? 0,
@@ -6315,40 +6416,58 @@ function recordDelegationObservation(telemetry, observation) {
 		});
 	} else if (observation.kind === "finished") {
 		const { event } = observation;
-		telemetry.recordEvent("doom_team.delegation_finished", {
+		telemetry.recordEvent("po_team.delegation_finished", {
 			"run.id": event.runId,
 			"team.tool_count": event.toolCount ?? 0,
 			"team.duration_ms": event.durationMs ?? 0,
 			outcome: event.status
 		});
-	} else telemetry.recordEvent("doom_team.delegation_cancelled", { outcome: "cancelled" });
+	} else telemetry.recordEvent("po_team.delegation_cancelled", { outcome: "cancelled" });
 }
 const root = defineRoot(({ context, host: serverHost, agent: host }) => {
 	if (!host) throw new Error("Team session requires the headless host.");
-	if (serverHost.context.environment === void 0) throw new Error("Team headless facet requires an admitted session environment.");
+	if (serverHost.context.environment === void 0) throw new Error("Team server plugin requires an admitted session environment.");
 	const directEvents = serverHost.context.directEvents;
-	if (directEvents === void 0) throw new Error("Team headless facet requires host-owned direct events.");
+	if (directEvents === void 0) throw new Error("Team server plugin requires host-owned direct events.");
 	const execution = {
 		...host.context,
 		get model() {
 			return host.context.model;
+		},
+		get selection() {
+			return host.context.selection;
 		}
 	};
 	const sessionPeers = /* @__PURE__ */ new Set();
 	const stopPeerDiscovery = serverHost.context.sessionCommunication?.onPeerReady((id) => sessionPeers.add(id));
-	const telemetry = createDoomTelemetry({
-		serviceName: "doom-team",
+	const telemetry = createPoTelemetry({
+		serviceName: "po-team",
 		packageName: "@agimon-ai/po-team",
 		cwd: execution.cwd,
 		env: serverHost.context.environment,
 		enableLogs: true,
 		enableTraces: true
 	});
+	const environment = serverHost.context.environment;
+	const fs = requirePoFs(context);
+	const homeDirectory = environment.HOME ?? nodeHost.homeDirectory();
 	const runtime = createTeamExtensionRuntime((event, attributes) => {
 		telemetry.recordEvent(event, attributes);
 	}, {
-		environment: serverHost.context.environment,
-		childSessions: { get: () => readDoomChildSessionService(context) },
+		environment,
+		discoveryIo: {
+			fs,
+			context: BACKGROUND_CONTEXT,
+			environment,
+			homeDirectory,
+			configDirName: getConfigDirName(environment)
+		},
+		agentConfig: new TeamAgentConfigService({
+			fs,
+			environment,
+			homeDirectory
+		}),
+		childSessions: { get: () => readPoChildSessionService(context) },
 		nativeRunProjection
 	});
 	const scope = createSessionScope(execution.sessionId);
@@ -6371,9 +6490,6 @@ const root = defineRoot(({ context, host: serverHost, agent: host }) => {
 			telemetry.recordEvent(event, attributes);
 		}
 	});
-	let ownedReadiness;
-	let ready;
-	const startupAbort = new AbortController();
 	const nativeRuns = /* @__PURE__ */ new Map();
 	const childCosts = /* @__PURE__ */ new Map();
 	let costText;
@@ -6411,7 +6527,8 @@ const root = defineRoot(({ context, host: serverHost, agent: host }) => {
 			});
 			if (options?.triggerTurn === false) return;
 			if (!execution.session.admitPrompt) throw new Error("The session cannot admit a completion prompt.");
-			await execution.session.admitPrompt(message.content, "steer");
+			const runIds = details.map((detail) => detail.runId).toSorted();
+			await execution.session.admitPrompt(message.content, "steer", void 0, runIds.length ? `subagent-report:${runIds.join(",")}` : void 0);
 		});
 		deliveries = delivery.catch(() => void 0);
 		return delivery;
@@ -6424,16 +6541,26 @@ const root = defineRoot(({ context, host: serverHost, agent: host }) => {
 		});
 		if (options?.triggerTurn === false) return;
 		const delivery = deliveries.then(async () => {
-			if (!execution.session.admitPrompt) throw new Error("The session cannot admit an intercom message.");
-			await execution.session.admitPrompt(text, "steer");
+			if (!execution.session.admitMessage) throw new Error("The session cannot admit an intercom message.");
+			await execution.session.admitMessage({
+				type: message.customType,
+				text,
+				display: message.display,
+				details: message.details
+			}, "steer");
 		});
 		deliveries = delivery.catch(() => void 0);
 		return delivery;
 	} });
 	const intercom = createHeadlessIntercomTool(channel, {
 		sessionId: execution.sessionId,
-		peers: () => [...sessionPeers].filter((id) => serverHost.context.sessionService?.canCommunicate?.(execution.sessionId, id) === true),
-		delivery: () => readDoomSessionDelivery(context)
+		name: () => serverHost.context.sessionCommunication?.sessionName,
+		peers: () => [...sessionPeers].filter((id) => serverHost.context.sessionService?.canCommunicate?.(execution.sessionId, id) === true).flatMap((id) => {
+			const peer = serverHost.context.sessionCommunication?.describePeer?.(id);
+			return peer === void 0 ? [] : [peer];
+		}),
+		canCommunicate: (id) => serverHost.context.sessionService?.canCommunicate?.(execution.sessionId, id) === true,
+		delivery: () => readPoSessionDelivery(context)
 	});
 	const serverService = (ctx) => {
 		ctx.plugin((providerContext) => {
@@ -6443,12 +6570,18 @@ const root = defineRoot(({ context, host: serverHost, agent: host }) => {
 					sessionScope: scope,
 					cwd: execution.cwd,
 					environment: serverHost.context.environment,
-					get availableModels() {
-						return execution.getAvailableModels?.().map(toModelInfo) ?? (execution.model ? [toModelInfo(execution.model)] : []);
+					availableModels: () => availableModelInfos(execution),
+					repoRoot: execution.repoRoot,
+					get parentSelection() {
+						return execution.selection;
 					},
 					get parentModel() {
 						return execution.model;
 					},
+					reportWarning: (body) => execution.client.notify({
+						body,
+						level: "warning"
+					}),
 					captureForkSource: () => execution.session.forkSource?.()
 				},
 				directRunTracker: runtime.asyncJobTracker,
@@ -6457,9 +6590,16 @@ const root = defineRoot(({ context, host: serverHost, agent: host }) => {
 				policies: runtime.capabilityPolicies,
 				observeDelegation: (observation) => recordDelegationObservation(telemetry, observation)
 			});
-			providerContext.inject([DOOM_MCP_TOOL_RESOLVER_SERVICE], (resolverContext) => runtime.mcpToolResolver.bind(requireDoomMcpToolResolver(resolverContext)));
-			providerContext.inject([DOOM_CONTEXT_CONTRIBUTIONS_SERVICE], (contributionContext) => {
-				const registration = requireDoomContextContributions(contributionContext).register({
+			providerContext.inject([PO_CONFIG_SERVICE], (configContext) => {
+				const config = configContext.get(PO_CONFIG_SERVICE);
+				if (!config) throw new Error("Team requires the session Po config service.");
+				const unbind = runtime.agentConfig.bind(() => config.getSnapshot());
+				publishCatalog();
+				return unbind;
+			});
+			providerContext.inject([PO_MCP_TOOL_RESOLVER_SERVICE], (resolverContext) => runtime.mcpToolResolver.bind(requirePoMcpToolResolver(resolverContext)));
+			providerContext.inject([PO_CONTEXT_CONTRIBUTIONS_SERVICE], (contributionContext) => {
+				const registration = requirePoContextContributions(contributionContext).register({
 					source: "@agimon-ai/po-team",
 					id: "runtime",
 					label: "Team",
@@ -6468,30 +6608,96 @@ const root = defineRoot(({ context, host: serverHost, agent: host }) => {
 				});
 				return () => registration.dispose();
 			});
-			ready = (readDoomReadinessCoordinator(providerContext) ?? (ownedReadiness = createDoomReadinessCoordinator({ notify: (notification) => execution.client.notify({
-				level: "warning",
-				body: notification.error?.message ?? notification.diagnostics.join("; ")
-			}) }))).start("@agimon-ai/po-team", `team:${execution.sessionId}:${crypto.randomUUID()}`, async (signal) => {
-				signal.throwIfAborted();
-				startupAbort.signal.throwIfAborted();
-				const opened = await openScopeAsync(scope);
-				signal.throwIfAborted();
-				startupAbort.signal.throwIfAborted();
-				if (opened.suspended.length) await execution.client.notify({
-					body: formatSuspendedRuns(opened.suspended),
-					level: "info"
-				});
-				telemetry.recordEvent("doom_team.runs_restored", {
-					"team.suspended_count": opened.suspended.length,
-					"team.pruned_count": opened.pruned.length,
-					"team.reaped_count": opened.reaped,
-					outcome: "reported"
-				});
-				return { value: void 0 };
+		});
+	};
+	const publishCatalog = async () => {
+		if (!activityAttached) return;
+		try {
+			const discovered = (await runtime.discovery.discover(execution.cwd, "both")).agents;
+			const models = (await runtime.agentConfig.currentOrUndefined())?.models ?? [];
+			if (!activityAttached) return;
+			directEvents.publish(SUBAGENT_CATALOG_TYPE, execution.sessionId, {
+				cwd: execution.cwd,
+				agents: presentCatalog(discovered),
+				models: catalogModels(discovered, [...models])
 			});
+		} catch (error) {
+			if (!activityAttached) return;
+			directEvents.publish(SUBAGENT_CATALOG_TYPE, execution.sessionId, {
+				cwd: execution.cwd,
+				agents: [],
+				models: [],
+				warning: error instanceof Error ? error.message : String(error)
+			});
+		}
+	};
+	const activity = {
+		name: "@agimon-ai/po-team",
+		async start(activityContext) {
+			activityAttached = true;
+			publishCost(true);
+			publishRunSnapshot();
+			await publishCatalog();
+			try {
+				channel.bindMainSession(activityContext.sessionId);
+				return () => {
+					if (!activityAttached) return;
+					activityAttached = false;
+					channel.dispose();
+					execution.client.setStatus(TEAM_COST_STATUS, void 0);
+				};
+			} catch (error) {
+				activityAttached = false;
+				execution.client.setStatus(TEAM_COST_STATUS, void 0);
+				throw error;
+			}
+		}
+	};
+	/**
+	* Re-attaches the runs this session stored before a restart. Called from `session_start`, once the session can
+	* take a completion and before its Harness resumes: a running child gets its lane and intercom back first, and
+	* a finished one reports its completion now.
+	*/
+	const restoreRuns = async () => {
+		const report = (subject, error) => execution.client.notify({
+			body: `${subject}: ${error instanceof Error ? error.message : String(error)}`,
+			level: "warning"
+		});
+		let stored = [];
+		try {
+			stored = await readPoChildSessionService(context)?.stored?.() ?? [];
+		} catch (error) {
+			await report("Stored subagent runs could not be read", error);
+		}
+		let restored = 0;
+		for (const run of stored) {
+			const identity = storedRunIdentity(run);
+			const intercom = run.settled ? void 0 : runtime.teamChannel.createNativeChildIntercom({
+				rootSessionId: run.request.scope.rootSessionId,
+				agent: run.request.agent,
+				...identity ? {
+					identity: identity.identity,
+					inline: identity.inline
+				} : {},
+				runId: run.request.runId,
+				task: {
+					id: run.request.runId,
+					subject: run.request.task
+				}
+			});
+			try {
+				await runtime.nativeRuns.restore(run.request.parentSessionId, run, intercom);
+				restored += 1;
+			} catch (error) {
+				intercom?.dispose?.();
+				await report(`Subagent run ${run.request.runId} could not resume`, error);
+			}
+		}
+		telemetry.recordEvent("po_team.runs_restored", {
+			"team.restored_count": restored,
+			outcome: "restored"
 		});
 	};
-	const environment = serverHost.context.environment;
 	return {
 		value: {
 			runtime,
@@ -6502,96 +6708,63 @@ const root = defineRoot(({ context, host: serverHost, agent: host }) => {
 			channel,
 			intercom,
 			directEvents,
-			environment: serverHost.context.environment
+			environment: serverHost.context.environment,
+			restoreRuns
 		},
 		services: [
 			(context) => {
-				if (readDoomBackgroundWorkService(context) === void 0) provideBackgroundWorkService(context);
+				if (readPoBackgroundWorkService(context) === void 0) provideBackgroundWorkService(context);
 			},
 			serverService,
+			(context) => context.provide(PO_TEAM_AGENT_CONFIG_SERVICE, runtime.agentConfig),
+			(context) => context.provide(PO_CHILD_SESSION_LABELS_SERVICE, { labelFor: (runId) => nativeRuns.get(runId)?.identity }),
 			mountMcpTools([intercom, createHeadlessSubagentTool(runtime, execution)])
 		],
-		activities: [{
-			name: "@agimon-ai/po-team",
-			async start(activityContext) {
-				activityAttached = true;
-				publishCost(true);
-				publishRunSnapshot();
-				try {
-					const discovered = runtime.discovery.discover(execution.cwd, "both").agents;
-					directEvents.publish(SUBAGENT_CATALOG_TYPE, execution.sessionId, {
-						cwd: execution.cwd,
-						agents: presentCatalog(discovered),
-						models: catalogModels(discovered, resolveActiveTeamModelSpecs(environment) ?? [])
-					});
-				} catch (error) {
-					directEvents.publish(SUBAGENT_CATALOG_TYPE, execution.sessionId, {
-						cwd: execution.cwd,
-						agents: [],
-						models: [],
-						warning: error instanceof Error ? error.message : String(error)
-					});
-				}
-				try {
-					channel.bindMainSession(activityContext.sessionId);
-					return () => {
-						if (!activityAttached) return;
-						activityAttached = false;
-						channel.dispose();
-						execution.client.setStatus(TEAM_COST_STATUS, void 0);
-					};
-				} catch (error) {
-					activityAttached = false;
-					execution.client.setStatus(TEAM_COST_STATUS, void 0);
-					throw error;
-				}
-			}
-		}],
+		activities: [activity],
 		async onStart() {
 			runtime.pollScheduler.start();
-			telemetry.recordEvent("doom_team.session_started", { "team.root_session": resolveRootSessionId(execution.sessionId, environment) === execution.sessionId });
-			if (!ready) throw new Error("Team readiness was not installed.");
-			await Promise.allSettled([ready.wait()]);
+			telemetry.recordEvent("po_team.session_started", { "team.root_session": resolveRootSessionId(execution.sessionId, environment) === execution.sessionId });
 		},
 		async onDispose() {
 			disposing = true;
-			startupAbort.abort(/* @__PURE__ */ new Error("Team session ended."));
-			await Promise.allSettled([...ready ? [ready.wait()] : [], ...ownedReadiness ? [ownedReadiness.dispose()] : []]);
 			activityAttached = false;
-			stopPeerDiscovery?.();
-			sessionPeers.clear();
-			execution.client.setStatus(TEAM_COST_STATUS, void 0);
-			channel.dispose();
-			runtime.completionNotifier.dispose();
-			const suspension = suspendScopeRuns({
-				scope,
-				reason: "headless session ended",
-				jobs: jobs.list(),
-				stop: (runId, reason) => runtime.management.stop(runId, reason)
-			});
-			const nativeShutdown = runtime.nativeRuns.close().finally(() => nativeRunProjection.dispose(execution.sessionId));
-			const outcomes = await Promise.allSettled([suspension, nativeShutdown]);
-			for (const outcome of outcomes) if (outcome.status === "rejected") process.emitWarning(`Could not shut down headless Team runs: ${String(outcome.reason)}`);
-			unsubscribeCostTracker();
-			unsubscribeCostNative();
-			nativeRuns.clear();
-			childCosts.clear();
-			costText = void 0;
-			bridge.abandonAll();
-			fablePlan.abandonAll();
-			runtime.capabilityPolicies.clear();
-			runtime.management.releaseSessionScope(scope);
-			runtime.dispose();
-			runtime.asyncJobTracker.stop();
-			runtime.pollScheduler.stop();
-			const suspended = outcomes[0];
-			await telemetry.recordEvent("doom_team.session_finished", {
-				reason: "headless session ended",
-				"team.suspended_count": suspended?.status === "fulfilled" ? suspended.value?.suspended.length ?? 0 : 0,
-				"team.unstoppable_count": suspended?.status === "fulfilled" ? suspended.value?.unstoppable.length ?? 0 : 0,
-				outcome: suspended?.status === "fulfilled" && !suspended.value?.unstoppable.length ? "suspended" : "degraded"
-			});
-			await telemetry.shutdown();
+			let stoppedRuns;
+			await runCleanups([
+				() => stopPeerDiscovery?.(),
+				() => sessionPeers.clear(),
+				() => execution.client.setStatus(TEAM_COST_STATUS, void 0),
+				() => channel.dispose(),
+				() => runtime.completionNotifier.dispose(),
+				async () => {
+					stoppedRuns = await stopScopeRuns({
+						reason: "headless session ended",
+						jobs: jobs.list(),
+						stop: (runId, reason) => runtime.management.stop(runId, reason)
+					});
+				},
+				() => runCleanups([() => runtime.nativeRuns.close(), () => nativeRunProjection.dispose(execution.sessionId)], "Native Team runs cleanup failed."),
+				unsubscribeCostTracker,
+				unsubscribeCostNative,
+				() => nativeRuns.clear(),
+				() => childCosts.clear(),
+				() => {
+					costText = void 0;
+				},
+				() => bridge.abandonAll(),
+				() => fablePlan.abandonAll(),
+				() => runtime.capabilityPolicies.clear(),
+				() => runtime.management.releaseSessionScope(scope),
+				() => runtime.dispose(),
+				() => runtime.asyncJobTracker.stop(),
+				() => runtime.pollScheduler.stop(),
+				() => telemetry.recordEvent("po_team.session_finished", {
+					reason: "headless session ended",
+					"team.stopped_count": stoppedRuns?.stopped.length ?? 0,
+					"team.unstoppable_count": stoppedRuns?.unstoppable.length ?? 0,
+					outcome: stoppedRuns && !stoppedRuns.unstoppable.length ? "stopped" : "degraded"
+				}),
+				() => telemetry.shutdown()
+			], "Team cleanup failed.");
 		}
 	};
 });
@@ -6657,13 +6830,9 @@ var subagent_catalog_default = defineChannel(createSubagentCatalogChannel);
 var subagent_catalog_server_default = defineChannel(subagent_catalog_default);
 //#endregion
 //#region src/extensions/(backend)/channel/_lib/subagent-runs.ts
-const RUN_ID_PATTERN = /^[\w.-]+$/;
 function isSubagentRunsPayload(value) {
 	return typeof value === "object" && value !== null && Array.isArray(value.runs);
 }
-function publicPayload(payload) {
-	return { runs: payload.runs.map(({ sessionFile: _sessionFile, ...run }) => run) };
-}
 /**
 * The built-in subagents data channel consumes current state from the
 * host-owned direct event bus. Its bounded latest replay seeds late subscribers.
@@ -6678,16 +6847,34 @@ function createSubagentsChannel() {
 			const publish = (scope, payload) => {
 				if (scopes.get(scope.sessionId) !== scope) return;
 				latest.set(scope.sessionId, payload);
-				host.publish(scope.sessionId, publicPayload(payload));
+				host.publish(scope.sessionId, payload);
 			};
 			return {
-				payloadFor(scope) {
-					const payload = scopes.has(scope.sessionId) ? latest.get(scope.sessionId) : void 0;
-					return payload === void 0 ? void 0 : publicPayload(payload);
+				homeFor(scope) {
+					const payload = latest.get(scope.sessionId);
+					if (!payload) return {
+						coverage: "unavailable",
+						entities: []
+					};
+					return {
+						coverage: payload.runs.length > HOME_ENTITY_LIMIT ? "partial" : "ready",
+						entities: payload.runs.slice(0, HOME_ENTITY_LIMIT).map((run) => ({
+							id: createHash("sha256").update(JSON.stringify([
+								scope.workspaceId ?? scope.cwd,
+								scope.sessionId,
+								run.runId,
+								run.startedAt
+							])).digest("hex"),
+							kind: run.state === "failed" ? "failure" : run.state === "done" ? "completed" : run.state === "stopped" ? "paused" : run.state,
+							title: (run.taskRef || run.task || run.agent).slice(0, 160),
+							...(run.error || run.currentTool)?.trim() ? { detail: (run.error || run.currentTool).slice(0, 320) } : {},
+							updatedAt: new Date(run.lastUpdate).toISOString(),
+							sessionId: scope.sessionId
+						}))
+					};
 				},
-				threadJournal(scope, runId) {
-					if (!RUN_ID_PATTERN.test(runId)) return void 0;
-					return (latest.get(scope.sessionId)?.runs.find((run) => run.runId === runId))?.sessionFile;
+				payloadFor(scope) {
+					return scopes.has(scope.sessionId) ? latest.get(scope.sessionId) : void 0;
 				},
 				sessionAdded(scope) {
 					subscriptions.get(scope.sessionId)?.();
@@ -6743,16 +6930,11 @@ function isStopRequest(value) {
 }
 /** The typed error's text carries a recovery hint written for the model, so a missing run gets a sentence for people. */
 function controlFailure(error) {
-	if (error instanceof DoomTeamExpectedError && error.code === "run_not_found") return Response.json({ error: "This run is not active." }, { status: 404 });
+	if (error instanceof PoTeamExpectedError && error.code === "run_not_found") return Response.json({ error: "This run is not active." }, { status: 404 });
 	return Response.json({ error: error instanceof Error ? error.message : String(error) }, { status: 409 });
 }
 /** Serves catalog discovery, run launch, and run steer and stop from the selected session process, never through a parent prompt. */
 function createTeamApiHandler(options) {
-	const discovery = new AgentDiscoveryService(options.environment);
-	const read = options.read ?? ((cwd) => ({
-		agents: discovery.discover(cwd, "both").agents,
-		models: resolveActiveTeamModelSpecs(options.environment) ?? []
-	}));
 	return {
 		async fetch(request) {
 			const url = new URL(request.url);
@@ -6803,8 +6985,8 @@ function createTeamApiHandler(options) {
 			}
 			if (request.method !== "GET" || url.pathname !== "/catalog") return Response.json({ error: "Not found." }, { status: 404 });
 			try {
-				discovery.invalidate();
-				const snapshot = read(options.cwd);
+				options.invalidate?.();
+				const snapshot = await options.read(options.cwd);
 				return Response.json({
 					cwd: options.cwd,
 					agents: presentCatalog(snapshot.agents),
@@ -6837,9 +7019,11 @@ function createTeamSessionApi(runtime, execution) {
 			sessionScope: scope,
 			environment: execution.environment,
 			parentSessionId: execution.sessionId,
+			parentSelection: execution.selection,
 			...parentForkSource ? { parentForkSource } : {},
-			availableModels: execution.model ? [toModelInfo(execution.model)] : [],
-			...execution.model ? { parentModel: execution.model } : {}
+			availableModels: await availableModelInfos(execution),
+			...execution.model ? { parentModel: execution.model } : {},
+			sender: HUMAN_SENDER
 		}, loadConfig().config)).outcomes[0];
 		if (!outcome?.runId) throw new Error(outcome?.error ?? "The agent did not start.");
 		jobs.track(outcome.runId, outcome.identity ? {
@@ -6852,9 +7036,16 @@ function createTeamSessionApi(runtime, execution) {
 		basePath: TEAM_API_BASE_PATH,
 		start: () => createTeamApiHandler({
 			cwd: execution.cwd,
-			environment: execution.environment,
+			read: async (cwd) => ({
+				agents: (await runtime.discovery.discover(cwd, "both")).agents,
+				models: [...(await runtime.agentConfig.currentOrUndefined())?.models ?? []]
+			}),
+			invalidate: () => runtime.discovery.invalidate(),
 			launch,
-			steer: (request, signal) => runtime.management.steer(request.runId, request.message, void 0, signal),
+			steer: (request, signal) => runtime.management.steer(request.runId, {
+				text: request.message,
+				sender: HUMAN_SENDER
+			}, void 0, signal),
 			stop: (request) => runtime.management.stop(request.runId)
 		})
 	};
@@ -6864,6 +7055,12 @@ var route_server_default$1 = (context) => createTeamSessionApi(context.root.runt
 //#region src/extensions/workspaces/sessions/(backend)/api/route.server.ts
 var route_server_default = defineRoute(route_server_default$1);
 //#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/sessionStart.server.ts
+var sessionStart_server_default = defineHook(({ root }) => ({
+	event: "session_start",
+	handle: () => root.restoreRuns()
+}));
+//#endregion
 //#region src/extensions/workspaces/sessions/(backend)/resource/_lib/team.server.ts
 /**
 * The roster the model is allowed to see.
@@ -6872,7 +7069,7 @@ var route_server_default = defineRoute(route_server_default$1);
 * `TeamMemberContext`, whose `token` is a session capability documented as never
 * leaving the direct context. A context resource is pasted into the system prompt,
 * sent to the provider and persisted, so the raw struct must not be serialized here.
-* `formatTeamContextSnapshot` is the same projection the Pi facet renders.
+* `formatTeamContextSnapshot` is the same projection the Pi extension renders.
 */
 var team_server_default$1 = (context) => ({
 	name: "po/team",
@@ -6894,21 +7091,24 @@ var subagent_server_default = defineServerTool((context) => createHeadlessSubage
 //#endregion
 //#region generated/server.ts
 const at = (value, context) => typeof value === "function" ? value(context) : value;
+/* v8 ignore next -- generated normalization branch */
+const defined = (values) => values.filter((value) => value !== void 0);
 const via = (identity, value) => value === void 0 ? void 0 : {
 	...identity,
 	...value
 };
-const facet = defineServerPlugin({
+const serverPlugin = defineServerPlugin({
 	name: "@agimon-ai/po-team",
 	providerOverrides: composeServerProviderOverrides(root_server_default),
+	injects: composeRootInjects({ session: [root_server_default] }),
 	global: () => ({ get channels() {
 		return [() => via({ frameType: "subagent_catalog" }, subagent_catalog_server_default()), () => via({ frameType: "subagent_runs" }, subagent_runs_server_default())];
 	} }),
-	workspace: () => ({ get channels() {
-		return [() => via({ frameType: "subagent_catalog" }, subagent_catalog_server_default()), () => via({ frameType: "subagent_runs" }, subagent_runs_server_default())];
+	workspace: (context) => ({ get channels() {
+		return defined([context.hosted("global") ? void 0 : () => via({ frameType: "subagent_catalog" }, subagent_catalog_server_default()), context.hosted("global") ? void 0 : () => via({ frameType: "subagent_runs" }, subagent_runs_server_default())]);
 	} }),
 	session: async (context) => {
-		const scopeSession = await root_server_default(context);
+		const scopeSession = await context.scopeRoot("session", root_server_default, context);
 		const contextSession = {
 			...context,
 			root: scopeSession.value
@@ -6919,7 +7119,10 @@ const facet = defineServerPlugin({
 				return [at(route_server_default, contextSession)];
 			},
 			get channels() {
-				return [() => via({ frameType: "subagent_catalog" }, subagent_catalog_server_default()), () => via({ frameType: "subagent_runs" }, subagent_runs_server_default())];
+				return defined([context.hosted("global") ? void 0 : () => via({ frameType: "subagent_catalog" }, subagent_catalog_server_default()), context.hosted("global") ? void 0 : () => via({ frameType: "subagent_runs" }, subagent_runs_server_default())]);
+			},
+			get hooks() {
+				return [via({ event: "session_start" }, at(sessionStart_server_default, contextSession))];
 			},
 			get resources() {
 				return [at(team_server_default, contextSession)];
@@ -6935,6 +7138,6 @@ const facet = defineServerPlugin({
 	}
 });
 //#endregion
-export { facet as default, facet };
+export { serverPlugin as default, serverPlugin };
 
 //# sourceMappingURL=server.mjs.map