@agimon-ai/po-team 0.0.0-alpha.30 → 0.0.0-alpha.32

package/dist/extensions/server.cjs

@@ -32,14 +32,233 @@ let _agimon_ai_po_core_contextContributions = require("@agimon-ai/po-core/contex
 let _agimon_ai_po_core_mcpToolResolver = require("@agimon-ai/po-core/mcpToolResolver");
 let _agimon_ai_po_core_telemetry = require("@agimon-ai/po-core/telemetry");
 let _agimon_ai_po_session = require("@agimon-ai/po-session");
-let typebox_value = require("typebox/value");
 let node_crypto = require("node:crypto");
+let typebox_value = require("typebox/value");
 let node_child_process = require("node:child_process");
 let node_url = require("node:url");
 let _agimon_ai_po_core_headless = require("@agimon-ai/po-core/headless");
 let _agimon_ai_po_config_majorModes = require("@agimon-ai/po-config/majorModes");
 require("@agimon-ai/po-core/cordisHost");
 let _agimon_ai_po_core_hubChannel = require("@agimon-ai/po-core/hubChannel");
+//#region src/constants/awaitedInlineRun.ts
+const AWAITED_INLINE_CHILD_GUIDANCE = "You are an inline agent owned by the parent workflow step. Write the requested artifacts and evidence. Never record workflow complete, fix, or fail decisions. Do not launch or delegate agents. The parent owns all step decisions and bookkeeping.";
+//#endregion
+//#region src/services/modelInfo/index.ts
+/**
+* Model identity and thinking-level resolution.
+*
+* DESIGN PATTERNS:
+* - A model string may carry a thinking level as a `:level` suffix. Only suffixes
+*   in THINKING_LEVELS are recognised, so a model id that legitimately contains a
+*   colon (`openrouter/vendor:free`) is never mistaken for a thinking request
+* - `max` is excluded from the default supported set because a model only offers
+*   it when its thinkingLevelMap says so explicitly
+*
+* AVOID:
+* - Splitting a model string on the first colon; the suffix is at the end
+* - Assuming a missing thinkingLevelMap means "no thinking"; it means "unknown",
+*   which is treated as the standard set
+*/
+const THINKING_LEVELS = [
+	"off",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+const THINKING_SUFFIX_SEPARATOR = ":";
+const PROVIDER_SEPARATOR$1 = "/";
+function toModelInfo(model) {
+	return {
+		provider: model.provider,
+		id: model.id,
+		fullId: `${model.provider}${PROVIDER_SEPARATOR$1}${model.id}`,
+		api: model.api,
+		reasoning: model.reasoning,
+		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 {
+		baseModel: model,
+		thinkingSuffix: ""
+	};
+	const suffix = THINKING_LEVELS.find((level) => level === model.substring(colonIdx + 1));
+	if (!suffix) return {
+		baseModel: model,
+		thinkingSuffix: ""
+	};
+	return {
+		baseModel: model.substring(0, colonIdx),
+		thinkingSuffix: `${THINKING_SUFFIX_SEPARATOR}${suffix}`
+	};
+}
+function findModelInfo(model, availableModels, preferredProvider) {
+	if (!model || !availableModels || availableModels.length === 0) return void 0;
+	const { baseModel } = splitKnownThinkingSuffix(model);
+	const exact = availableModels.find((entry) => entry.fullId === baseModel);
+	if (exact) return exact;
+	const matches = availableModels.filter((entry) => entry.id === baseModel);
+	if (preferredProvider) {
+		const preferred = matches.find((entry) => entry.provider === preferredProvider);
+		if (preferred) return preferred;
+	}
+	return matches.length === 1 ? matches[0] : void 0;
+}
+function getSupportedThinkingLevels(model) {
+	if (!model) return THINKING_LEVELS.filter((level) => level !== "max");
+	if (model.reasoning === false) return ["off"];
+	if (!model.thinkingLevelMap) return THINKING_LEVELS.filter((level) => level !== "max");
+	return THINKING_LEVELS.filter((level) => {
+		const mapped = model.thinkingLevelMap?.[level];
+		if (mapped === null) return false;
+		if (level === "xhigh" || level === "max") return mapped !== void 0;
+		return true;
+	});
+}
+//#endregion
+//#region src/services/awaitedInlineRun/index.ts
+const DEFAULT_TIMEOUT_MS$2 = 18e5;
+const MAX_TIMEOUT_MS = 72e5;
+function validate(input) {
+	if (!input || typeof input !== "object" || Array.isArray(input)) throw new Error("team.run requires an object.");
+	const value = input;
+	for (const key of ["systemPrompt", "task"]) if (typeof value[key] !== "string" || !value[key].trim()) throw new Error(`team.run requires a nonblank ${key}.`);
+	if (value.model !== void 0 && (typeof value.model !== "string" || !value.model.trim())) throw new Error("team.run model must be a nonblank string.");
+	if (value.timeoutMs !== void 0 && (typeof value.timeoutMs !== "number" || !Number.isSafeInteger(value.timeoutMs) || value.timeoutMs <= 0 || value.timeoutMs > MAX_TIMEOUT_MS)) throw new Error(`team.run timeoutMs must be an integer from 1 to ${MAX_TIMEOUT_MS}.`);
+	return {
+		systemPrompt: value.systemPrompt.trim(),
+		task: value.task.trim(),
+		...typeof value.model === "string" ? { model: value.model.trim() } : {},
+		...typeof value.timeoutMs === "number" ? { timeoutMs: value.timeoutMs } : {}
+	};
+}
+/** Session-owned adapter over the existing planner and coordinator, with no child completion messages. */
+function createAwaitedInlineRunner(options) {
+	const lifetime = new AbortController();
+	const active = /* @__PURE__ */ new Set();
+	const execute = async (input, parentSignal) => {
+		let runId;
+		const notify = (status) => {
+			if (!runId) return;
+			try {
+				options.emit?.({
+					sessionId: options.execution.sessionId,
+					runId,
+					status
+				});
+			} catch {}
+		};
+		const finish = (result) => {
+			notify(result.status);
+			return result;
+		};
+		let waiter;
+		let timer;
+		let removeAbort;
+		let signal;
+		try {
+			const params = validate(input);
+			const deadline = new AbortController();
+			timer = setTimeout(() => deadline.abort(/* @__PURE__ */ new Error(`Inline agent timed out after ${params.timeoutMs ?? DEFAULT_TIMEOUT_MS$2}ms.`)), params.timeoutMs ?? DEFAULT_TIMEOUT_MS$2);
+			timer.unref?.();
+			signal = AbortSignal.any([
+				parentSignal,
+				lifetime.signal,
+				deadline.signal
+			]);
+			signal.throwIfAborted();
+			const execution = options.execution;
+			const models = await availableModelInfos(execution);
+			signal.throwIfAborted();
+			runId = crypto.randomUUID();
+			notify("running");
+			waiter = options.coordinator.waitFor(execution.sessionId, runId);
+			const outcome = (await options.planner.spawn({
+				single: {
+					agent: "inline",
+					inlineAgent: { systemPrompt: `${params.systemPrompt}\n\n${AWAITED_INLINE_CHILD_GUIDANCE}` },
+					task: params.task,
+					...params.model ? { model: params.model } : {}
+				},
+				cwd: execution.cwd,
+				agentScope: "both",
+				sessionScope: require_atomicJson.createSessionScope(execution.sessionId),
+				environment: execution.environment,
+				parentSessionId: execution.sessionId,
+				parentSelection: execution.selection,
+				...execution.model ? { parentModel: execution.model } : {},
+				availableModels: models,
+				preallocatedRunIds: [runId],
+				awaitedInline: true,
+				signal
+			}, options.config)).outcomes[0];
+			if (!outcome?.runId) throw new Error(outcome?.error ?? "The inline agent did not start.");
+			const aborted = new Promise((resolve) => {
+				const abort = () => resolve(void 0);
+				signal.addEventListener("abort", abort, { once: true });
+				removeAbort = () => signal.removeEventListener("abort", abort);
+				if (signal.aborted) abort();
+			});
+			const completion = await Promise.race([waiter.result, aborted]);
+			if (completion) return finish(completion);
+			const reason = signal.reason instanceof Error ? signal.reason.message : "The inline agent was cancelled.";
+			const child = options.coordinator.get(execution.sessionId, runId);
+			if (child) await child.stop(reason);
+			const stopped = await waiter.result;
+			return finish(stopped.status === "failed" ? stopped : {
+				...stopped,
+				status: "stopped",
+				error: reason
+			});
+		} catch (error) {
+			let cleanupError;
+			if (runId) {
+				const child = options.coordinator.get(options.execution.sessionId, runId);
+				if (child) try {
+					await child.stop("The owning inline run failed or was cancelled.");
+				} catch (stopError) {
+					cleanupError = stopError;
+				}
+				const status = options.coordinator.status(options.execution.sessionId, runId)?.status;
+				if (status === "completed" || status === "failed" || status === "stopped") await waiter?.result;
+			}
+			const failure = cleanupError ?? error;
+			return finish({
+				...runId ? { runId } : {},
+				status: cleanupError ? "failed" : signal?.aborted ? "stopped" : "failed",
+				output: "",
+				error: failure instanceof Error ? failure.message : String(failure)
+			});
+		} finally {
+			clearTimeout(timer);
+			removeAbort?.();
+			waiter?.dispose();
+		}
+	};
+	return {
+		run(input, signal) {
+			const pending = execute(input, signal);
+			active.add(pending);
+			pending.finally(() => active.delete(pending));
+			return pending;
+		},
+		async close() {
+			lifetime.abort(/* @__PURE__ */ new Error("The owning Team session is shutting down."));
+			await Promise.all(active);
+		}
+	};
+}
+//#endregion
 //#region src/services/config/index.ts
 /**
 * `subagent` tool config file: read/write, and the scoped `ExtensionConfig`
@@ -81,8 +300,8 @@ const ARTIFACT_DIR_PREFERENCES = /* @__PURE__ */ new Set([
 	"session",
 	"temp"
 ]);
-function getConfigPath() {
-	return node_path.join(require_agentDiscovery.getAgentDir(), "extensions", "subagent", "config.json");
+function getConfigPath(environment) {
+	return node_path.join(require_agentDiscovery.getAgentDir(environment), "extensions", "subagent", "config.json");
 }
 function readConfigForUpdate(configPath = getConfigPath()) {
 	if (!node_fs.existsSync(configPath)) return {};
@@ -124,8 +343,8 @@ function configStamp(configPath) {
 	}
 }
 /** Never throws. A malformed config degrades to defaults, reported via `loadError` rather than `console.*`. */
-function loadConfig() {
-	const configPath = getConfigPath();
+function loadConfig(environment) {
+	const configPath = getConfigPath(environment);
 	const stamp = configStamp(configPath);
 	if (configCache?.path === configPath && configCache.stamp === stamp) return configCache.loaded;
 	let loaded;
@@ -167,14 +386,28 @@ var AdmissionGate = class {
 	admit(request) {
 		const admission = this.queue.then(() => this.waitForSlot(request), () => this.waitForSlot(request));
 		this.queue = admission.then(() => void 0, () => void 0);
-		return admission;
+		const signal = request.signal;
+		if (!signal) return admission;
+		return new Promise((resolve, reject) => {
+			const abort = () => reject(signal.reason ?? /* @__PURE__ */ new Error("Child admission was aborted."));
+			signal.addEventListener("abort", abort, { once: true });
+			if (signal.aborted) abort();
+			admission.then((ticket) => {
+				if (signal.aborted) {
+					ticket.release();
+					abort();
+				} else resolve(ticket);
+			}, reject).finally(() => signal.removeEventListener("abort", abort));
+		});
 	}
 	async waitForSlot(request) {
 		const deadline = this.now() + request.timeoutMs;
 		const waitStartedAt = this.now();
 		let waited = false;
 		for (;;) {
+			request.signal?.throwIfAborted();
 			const live = await this.countLiveRuns(request.sessionScope) + this.reserved;
+			request.signal?.throwIfAborted();
 			if (live < request.maxLiveRuns) {
 				this.reserved += 1;
 				return this.ticket();
@@ -1070,89 +1303,6 @@ function invalidRequest(message, recovery) {
 	return new PoTeamExpectedError("invalid_request", message, false, recovery);
 }
 //#endregion
-//#region src/services/modelInfo/index.ts
-/**
-* Model identity and thinking-level resolution.
-*
-* DESIGN PATTERNS:
-* - A model string may carry a thinking level as a `:level` suffix. Only suffixes
-*   in THINKING_LEVELS are recognised, so a model id that legitimately contains a
-*   colon (`openrouter/vendor:free`) is never mistaken for a thinking request
-* - `max` is excluded from the default supported set because a model only offers
-*   it when its thinkingLevelMap says so explicitly
-*
-* AVOID:
-* - Splitting a model string on the first colon; the suffix is at the end
-* - Assuming a missing thinkingLevelMap means "no thinking"; it means "unknown",
-*   which is treated as the standard set
-*/
-const THINKING_LEVELS = [
-	"off",
-	"minimal",
-	"low",
-	"medium",
-	"high",
-	"xhigh",
-	"max"
-];
-const THINKING_SUFFIX_SEPARATOR = ":";
-const PROVIDER_SEPARATOR$1 = "/";
-function toModelInfo(model) {
-	return {
-		provider: model.provider,
-		id: model.id,
-		fullId: `${model.provider}${PROVIDER_SEPARATOR$1}${model.id}`,
-		api: model.api,
-		reasoning: model.reasoning,
-		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 {
-		baseModel: model,
-		thinkingSuffix: ""
-	};
-	const suffix = THINKING_LEVELS.find((level) => level === model.substring(colonIdx + 1));
-	if (!suffix) return {
-		baseModel: model,
-		thinkingSuffix: ""
-	};
-	return {
-		baseModel: model.substring(0, colonIdx),
-		thinkingSuffix: `${THINKING_SUFFIX_SEPARATOR}${suffix}`
-	};
-}
-function findModelInfo(model, availableModels, preferredProvider) {
-	if (!model || !availableModels || availableModels.length === 0) return void 0;
-	const { baseModel } = splitKnownThinkingSuffix(model);
-	const exact = availableModels.find((entry) => entry.fullId === baseModel);
-	if (exact) return exact;
-	const matches = availableModels.filter((entry) => entry.id === baseModel);
-	if (preferredProvider) {
-		const preferred = matches.find((entry) => entry.provider === preferredProvider);
-		if (preferred) return preferred;
-	}
-	return matches.length === 1 ? matches[0] : void 0;
-}
-function getSupportedThinkingLevels(model) {
-	if (!model) return THINKING_LEVELS.filter((level) => level !== "max");
-	if (model.reasoning === false) return ["off"];
-	if (!model.thinkingLevelMap) return THINKING_LEVELS.filter((level) => level !== "max");
-	return THINKING_LEVELS.filter((level) => {
-		const mapped = model.thinkingLevelMap?.[level];
-		if (mapped === null) return false;
-		if (level === "xhigh" || level === "max") return mapped !== void 0;
-		return true;
-	});
-}
-//#endregion
 //#region src/services/modelResolution/index.ts
 /**
 * Resolving a loosely-spelled model name to a canonical `provider/id`.
@@ -1424,6 +1574,8 @@ function storedRunIdentity(run) {
 	return {
 		identity: meta.identity,
 		inline: meta.inline === true,
+		...meta.awaited === true ? { awaited: true } : {},
+		...meta.delivery === "silent" ? { delivery: "silent" } : {},
 		...typeof meta.agentDescription === "string" ? { agentDescription: meta.agentDescription } : {},
 		...typeof meta.agentFilePath === "string" ? { agentFilePath: meta.agentFilePath } : {}
 	};
@@ -1434,6 +1586,8 @@ var NativeRunCoordinator = class {
 	notifier;
 	projection;
 	entries = /* @__PURE__ */ new Map();
+	waiters = /* @__PURE__ */ new Map();
+	handoffs = /* @__PURE__ */ new Set();
 	closed = false;
 	closing;
 	constructor(childSessions, tracker, notifier, projection) {
@@ -1448,26 +1602,55 @@ var NativeRunCoordinator = class {
 		if (!service) throw new Error("The in-process Pi child-session service is unavailable.");
 		return service;
 	}
-	async start(sessionId, request, identity) {
+	async start(sessionId, request, identity, signal) {
+		signal?.throwIfAborted();
 		if (!sessionId.trim()) throw new Error("Native child runs require a session identity.");
-		const handle = await this.service().start({
+		const childRequest = {
 			...request,
 			...identity ? { meta: {
 				...request.meta,
 				...JSON.parse(JSON.stringify(identity))
 			} } : {}
-		});
+		};
+		const service = this.service();
+		const handle = await (signal ? service.start(childRequest, signal) : service.start(childRequest));
 		return this.adopt(sessionId, request.scope, request, handle, identity);
 	}
 	async restore(sessionId, run, intercom) {
 		const service = this.service();
+		if (storedRunIdentity(run)?.awaited) {
+			if (!service.abandon) throw new Error("This child-session service cannot abandon orphaned awaited runs.");
+			await service.abandon(run.request.runId);
+			const message = "Interrupted: the owning code-mode continuation did not survive the session restart.";
+			const projection = {
+				runId: run.request.runId,
+				agent: run.request.agent,
+				identity: storedRunIdentity(run)?.identity,
+				inline: true,
+				task: run.request.task,
+				cwd: run.request.cwd,
+				runtime: "pi",
+				status: "stopped",
+				startedAt: Date.now(),
+				updatedAt: Date.now(),
+				summary: message,
+				error: message
+			};
+			this.tracker.upsertNative(sessionId, run.request.scope, projection);
+			this.projection?.publish(sessionId, projection);
+			this.tracker.acknowledgeHandoff(sessionId, run.request.runId);
+			return;
+		}
 		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();
+			if (identity?.awaited) {
+				await handle.stop("The owning Team session closed during child startup.");
+				await this.childSessions?.get()?.markReported?.(request.runId);
+			} else await handle.dispose();
 			throw new Error("The native Team run coordinator closed during child startup.");
 		}
 		const entry = {
@@ -1491,6 +1674,16 @@ var NativeRunCoordinator = class {
 			throw error;
 		}
 	}
+	/** Register before launch, so even a synchronously completed child cannot race the waiter. */
+	waitFor(sessionId, runId) {
+		if (this.closed) throw new Error("The native Team run coordinator is closed.");
+		const key = entryKey(sessionId, runId);
+		if (this.waiters.has(key)) throw new Error(`Native run '${runId}' already has a completion waiter.`);
+		return {
+			result: new Promise((resolve) => this.waiters.set(key, resolve)),
+			dispose: () => this.waiters.delete(key)
+		};
+	}
 	get(sessionId, runId) {
 		return this.entries.get(entryKey(sessionId, runId))?.handle;
 	}
@@ -1529,10 +1722,16 @@ var NativeRunCoordinator = class {
 		this.closing ??= (async () => {
 			const active = [...this.entries.values()];
 			for (const entry of active) {
+				if (entry.identity?.awaited) continue;
 				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);
+			const outcomes = await Promise.allSettled(active.map(async (entry) => {
+				if (entry.identity?.awaited) await entry.handle.stop("The owning Team session is shutting down.");
+				else await entry.handle.dispose();
+			}));
+			await Promise.all(this.handoffs);
+			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;
@@ -1587,6 +1786,33 @@ var NativeRunCoordinator = class {
 			durationMs: Math.max(0, event.timestamp - (this.tracker.getNative(entry.sessionId, entry.request.runId)?.startedAt ?? event.timestamp)),
 			sessionId: entry.sessionId
 		};
+		if (entry.identity?.delivery === "silent" || entry.identity?.awaited) {
+			const key = entryKey(entry.sessionId, entry.request.runId);
+			const finish = async () => {
+				let completion = {
+					runId: entry.request.runId,
+					status,
+					output: status === "completed" ? event.message ?? "" : "",
+					...status === "completed" ? {} : { error: event.message ?? `Native child run ${status}.` }
+				};
+				try {
+					await this.childSessions?.get()?.markReported?.(entry.request.runId);
+					this.tracker.acknowledgeHandoff(entry.sessionId, entry.request.runId);
+				} catch (error) {
+					completion = {
+						...completion,
+						status: "failed",
+						error: `Could not acknowledge child completion: ${error instanceof Error ? error.message : String(error)}`
+					};
+				}
+				this.waiters.get(key)?.(completion);
+				this.waiters.delete(key);
+			};
+			const handoff = finish();
+			this.handoffs.add(handoff);
+			handoff.finally(() => this.handoffs.delete(handoff));
+			return;
+		}
 		if (this.notifier) this.notifier.deliver(result).then(async (delivered) => {
 			if (!delivered) return;
 			this.tracker.acknowledgeHandoff(entry.sessionId, entry.request.runId);
@@ -2051,15 +2277,15 @@ var SpawnPlanner = class {
 		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;
 	}
-	async resolveExecutableAgent(taskInput, cwd, scope) {
+	async resolveExecutableAgent(taskInput, cwd, scope, inheritParent = false) {
 		if (!taskInput.inlineAgent) return this.resolveAgentOrThrow(taskInput.agent, cwd, scope);
 		return {
 			name: taskInput.agent.trim(),
 			systemPromptMode: "append",
 			inheritProjectContext: true,
-			inheritSkills: false,
+			inheritSkills: inheritParent,
 			systemPrompt: taskInput.inlineAgent.systemPrompt.trim(),
-			tools: [...INLINE_AGENT_TOOLS],
+			...inheritParent ? {} : { tools: [...INLINE_AGENT_TOOLS] },
 			defaultContext: CONTEXT_FRESH,
 			runtime: "pi"
 		};
@@ -2145,7 +2371,7 @@ var SpawnPlanner = class {
 	* the module header.
 	*/
 	async spawnOneChild(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 { runId, awaitedInline, silent, signal, 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);
@@ -2199,7 +2425,8 @@ var SpawnPlanner = class {
 			...artifacts !== void 0 ? { artifacts } : {},
 			...artifactDir !== void 0 ? { artifactDir } : {},
 			runtime: effectiveRuntime,
-			runtimes
+			runtimes,
+			...silent ? { internal: true } : {}
 		};
 		const admission = this.admission;
 		if (!admission) throw new Error("Po Team spawn admission is not configured.");
@@ -2209,6 +2436,7 @@ var SpawnPlanner = class {
 				sessionScope,
 				maxLiveRuns,
 				timeoutMs: admissionTimeoutMs,
+				...signal ? { signal } : {},
 				...this.reportConcurrencyEvent ? { report: this.reportConcurrencyEvent } : {}
 			});
 		} catch (error) {
@@ -2221,13 +2449,14 @@ var SpawnPlanner = class {
 			};
 		}
 		try {
+			signal?.throwIfAborted();
 			if (isPiRuntime(effectiveRuntime)) {
 				if (!this.nativeRuns || !this.childSessions?.get()) throw new Error("The native Team run coordinator is unavailable.");
 				const scope = sessionScope;
 				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({
+				const intercom = awaitedInline ? void 0 : this.teamChannel?.createNativeChildIntercom({
 					rootSessionId: scope.rootSessionId,
 					agent: agentConfig.name,
 					identity: identity.identity,
@@ -2267,9 +2496,13 @@ var SpawnPlanner = class {
 					}, {
 						identity: identity.identity,
 						inline: identity.inline,
+						...awaitedInline ? {
+							awaited: true,
+							delivery: "silent"
+						} : silent ? { delivery: "silent" } : {},
 						...agentConfig.description ? { agentDescription: agentConfig.description } : {},
 						...agentConfig.filePath ? { agentFilePath: agentConfig.filePath } : {}
-					});
+					}, signal);
 				} catch (error) {
 					intercom?.dispose?.();
 					throw error;
@@ -2312,7 +2545,9 @@ 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();
+		request.signal?.throwIfAborted();
 		const tasks = this.resolveTaskList(request);
+		if (request.awaitedInline && tasks.some((task) => !task.inlineAgent)) throw new Error("Awaited Team runs require inline agents.");
 		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 = {
@@ -2320,7 +2555,15 @@ var SpawnPlanner = class {
 			subagentThinking: planningConfig?.thinking
 		};
 		const fanout = tasks.length > 1;
-		const teamPackageExcludeTools = team.excludeTools ? [...team.excludeTools] : void 0;
+		const teamPackageExcludeTools = request.awaitedInline ? [.../* @__PURE__ */ new Set([
+			...team.excludeTools ?? [],
+			"exec",
+			"discover",
+			"exec_background",
+			"exec_cancel",
+			"subagent",
+			"intercom"
+		])] : team.excludeTools ? [...team.excludeTools] : void 0;
 		const teamPackageModels = team.models;
 		const capabilityCeiling = this.policies.resolve();
 		const depthCheck = preflightSubagentDepth(request.currentDepth ?? resolveCurrentSubagentDepth(), config);
@@ -2341,7 +2584,7 @@ var SpawnPlanner = class {
 			].join("\0");
 			let resolved = taskInput.inlineAgent ? void 0 : resolvedAgentCache.get(cacheKey);
 			if (!resolved) {
-				resolved = await this.resolveExecutableAgent(taskInput, taskInput.cwd ?? request.cwd, request.agentScope);
+				resolved = await this.resolveExecutableAgent(taskInput, taskInput.cwd ?? request.cwd, request.agentScope, request.awaitedInline);
 				if (!taskInput.inlineAgent) resolvedAgentCache.set(cacheKey, resolved);
 			}
 			resolvedAgents.push(resolved);
@@ -2390,6 +2633,9 @@ var SpawnPlanner = class {
 		const skillProjectionCache = /* @__PURE__ */ new Map();
 		return { outcomes: (await runWithConcurrency(tasks.map((taskInput, childIndex) => () => this.spawnOneChild({
 			runId: runIds[childIndex],
+			awaitedInline: request.awaitedInline,
+			silent: request.silent,
+			signal: request.signal,
 			operationId: request.operationId,
 			agentConfig: resolvedAgents[childIndex],
 			identity: identities[childIndex],
@@ -2407,7 +2653,7 @@ var SpawnPlanner = class {
 			parentForkSource: request.parentForkSource,
 			sessionScope: request.sessionScope,
 			...request.sender ? { sender: request.sender } : {},
-			environment: request.environment ?? {},
+			environment: request.awaitedInline ? Object.fromEntries(Object.entries(request.environment ?? {}).filter(([key]) => key !== "WORKFLOW_DECISION_FILE")) : request.environment ?? {},
 			parentSessionFile: request.parentSessionFile,
 			maxLiveRuns,
 			admissionTimeoutMs,
@@ -2628,7 +2874,8 @@ function createDelegationBridge(deps) {
 				environment: session.environment,
 				...forkRequestFields(forkSource),
 				availableModels: await session.availableModels(),
-				...session.parentModel ? { parentModel: session.parentModel } : {}
+				...session.parentModel ? { parentModel: session.parentModel } : {},
+				...request.internal ? { silent: true } : {}
 			}, deps.loadConfig())).outcomes[0];
 			if (!outcome?.runId) {
 				finish(entry, {
@@ -5740,18 +5987,27 @@ declare const team: {
   members(): TeamMember[];
   /** Tracked runs. Finished runs drop off 10 minutes after acknowledgement. */
   runs(): TeamRun[];
+  /** Await one inline agent. Inherits capabilities except delegation and parent-bound code mode. Never rejects. */
+  run(input: { systemPrompt: string; task: string; model?: string; timeoutMs?: number }): Promise<{
+    runId?: string; status: 'completed' | 'failed' | 'stopped'; output: string; error?: string;
+  }>;
 };`;
-/** Session-owned read-only state. Direct tools retain all mutation capabilities. */
+/** Session-owned state and awaited inline runs. Direct tools retain discovery and management. */
 function createTeamNamespace(options) {
 	return {
 		name: "team",
-		summary: "Read native team members and tracked runs in this session with team.members() and team.runs().",
+		summary: "Read team members and runs, or await an inline agent with team.run().",
 		declarations: DECLARATIONS,
 		bind(run) {
 			if (run.sessionId !== options.sessionId) throw new Error("Team namespace belongs to another session.");
 			let disposed = false;
-			run.onDispose(() => {
+			const lifetime = new AbortController();
+			const signal = AbortSignal.any([run.signal, lifetime.signal]);
+			const active = /* @__PURE__ */ new Set();
+			run.onDispose(async () => {
 				disposed = true;
+				lifetime.abort(/* @__PURE__ */ new Error("Team code-mode run is disposed."));
+				await Promise.all(active);
 			});
 			const check = () => {
 				run.signal.throwIfAborted();
@@ -5789,6 +6045,24 @@ function createTeamNamespace(options) {
 				check();
 				return snapshot;
 			};
+			members.run = (input) => {
+				const pending = (async () => {
+					try {
+						check();
+						if (!options.run) throw new Error("Awaited inline agents are unavailable on this host.");
+						return JSON.parse(JSON.stringify(await options.run(input, signal)));
+					} catch (error) {
+						return {
+							status: signal.aborted ? "stopped" : "failed",
+							output: "",
+							error: error instanceof Error ? error.message : String(error)
+						};
+					}
+				})();
+				active.add(pending);
+				pending.finally(() => active.delete(pending));
+				return pending;
+			};
 			return members;
 		}
 	};
@@ -6563,6 +6837,10 @@ const root = (0, _agimon_ai_po_core_extensionFile.defineRoot)(({ context, host:
 	const environment = serverHost.context.environment;
 	const fs = (0, _agimon_ai_po_core_platform.requirePoFs)(context);
 	const homeDirectory = environment.HOME ?? _agimon_ai_po_core_platform.nodeHost.homeDirectory();
+	const sessionConfig = loadConfig({
+		...environment,
+		HOME: homeDirectory
+	}).config;
 	const runtime = createTeamExtensionRuntime((event, attributes) => {
 		telemetry.recordEvent(event, attributes);
 	}, {
@@ -6582,6 +6860,13 @@ const root = (0, _agimon_ai_po_core_extensionFile.defineRoot)(({ context, host:
 		childSessions: { get: () => (0, _agimon_ai_po_core_childSession.readPoChildSessionService)(context) },
 		nativeRunProjection
 	});
+	const awaitedInline = createAwaitedInlineRunner({
+		execution,
+		planner: runtime.spawnPlanner,
+		coordinator: runtime.nativeRuns,
+		config: sessionConfig,
+		emit: (event) => context.emit(_agimon_ai_po_core_delegation.PO_TEAM_INLINE_RUN_EVENT, event)
+	});
 	const scope = require_atomicJson.createSessionScope(execution.sessionId);
 	runtime.management.bindSessionScope(scope);
 	const jobs = runtime.asyncJobTracker.forSession(execution.sessionId, scope);
@@ -6591,7 +6876,7 @@ const root = (0, _agimon_ai_po_core_extensionFile.defineRoot)(({ context, host:
 		waiter: runtime.subagentWaiter,
 		scheduler: runtime.pollScheduler,
 		tracker: runtime.asyncJobTracker,
-		loadConfig: () => loadConfig().config
+		loadConfig: () => sessionConfig
 	});
 	const fablePlan = createFablePlanBridge({
 		spawner: runtime.asyncSubagentSpawner,
@@ -6707,6 +6992,7 @@ const root = (0, _agimon_ai_po_core_extensionFile.defineRoot)(({ context, host:
 					sessionId: execution.sessionId,
 					channel,
 					jobs,
+					run: (input, signal) => awaitedInline.run(input, signal),
 					assertAvailable: () => {
 						if (disposing) throw new Error("Team session is disposing.");
 					}
@@ -6795,7 +7081,7 @@ const root = (0, _agimon_ai_po_core_extensionFile.defineRoot)(({ context, host:
 		let restored = 0;
 		for (const run of stored) {
 			const identity = storedRunIdentity(run);
-			const intercom = run.settled ? void 0 : runtime.teamChannel.createNativeChildIntercom({
+			const intercom = run.settled || identity?.awaited ? void 0 : runtime.teamChannel.createNativeChildIntercom({
 				rootSessionId: run.request.scope.rootSessionId,
 				agent: run.request.agent,
 				...identity ? {
@@ -6853,6 +7139,7 @@ const root = (0, _agimon_ai_po_core_extensionFile.defineRoot)(({ context, host:
 			activityAttached = false;
 			let stoppedRuns;
 			await (0, _agimon_ai_po_core_extensionFile.runCleanups)([
+				() => awaitedInline.close(),
 				() => stopPeerDiscovery?.(),
 				() => sessionPeers.clear(),
 				() => execution.client.setStatus(TEAM_COST_STATUS, void 0),