@pixelzx/genesis 2026.6.4 → 2026.6.5

package/dist/subagent-control-CxR0WRrx.js

@@ -0,0 +1,506 @@
+import { i as formatErrorMessage } from "./errors-CufR9eHH.js";
+import { r as logVerbose } from "./globals-wYf9_gv5.js";
+import { o as isSubagentSessionKey, s as parseAgentSessionKey } from "./session-key-utils-DDwuwYKT.js";
+import { r as INTERNAL_MESSAGE_CHANNEL } from "./message-channel-core-BUIi495-.js";
+import "./message-channel-bhWoqTRw.js";
+import { u as resolveStorePath } from "./paths-CV1IubzZ.js";
+import { t as loadSessionStore } from "./store-load-CZTVJ-lZ.js";
+import { o as updateSessionStore } from "./store-4uu5L7Eg.js";
+import { i as subagentRuns, t as getSubagentRunsSnapshotForRead } from "./subagent-registry-state-BaNdOh6U.js";
+import { c as listSubagentRunsForController, n as getLatestSubagentRunByChildSessionKey } from "./subagent-registry-read-ddSiFqfz.js";
+import { r as callGateway } from "./call-wY43fzOF.js";
+import { o as resolveInternalSessionKey, s as resolveMainSessionAlias } from "./sessions-helpers-CDfOVWe3.js";
+import { n as resolveStoredSubagentCapabilities } from "./subagent-capabilities-C-tlzXAY.js";
+import { t as AGENT_LANE_SUBAGENT } from "./lanes-Mh2RlV0y.js";
+import { a as waitForAgentRunAndReadUpdatedAssistantReply, r as readLatestAssistantReplySnapshot } from "./run-wait-DHizeptL.js";
+import { d as markSubagentRunForSteerRestart, f as markSubagentRunTerminated, i as countPendingDescendantRuns, m as replaceSubagentRunAfterSteer, t as clearSubagentRunSteerRestart } from "./subagent-registry-CjMWjRCE.js";
+import { c as sortSubagentRuns, o as resolveSubagentLabel, s as resolveSubagentTargetFromRuns } from "./subagents-format-BB0We-UK.js";
+import { a as resolveSessionEntryForKey, t as buildLatestSubagentRunIndex } from "./subagent-list-AQdPLbhL.js";
+import crypto from "node:crypto";
+const MAX_RECENT_MINUTES = 1440;
+const MAX_STEER_MESSAGE_CHARS = 4e3;
+const STEER_ABORT_SETTLE_TIMEOUT_MS = 5e3;
+const SUBAGENT_REPLY_HISTORY_LIMIT = 50;
+const steerRateLimit = /* @__PURE__ */ new Map();
+let subagentControlDeps = {
+	callGateway,
+	updateSessionStore
+};
+let subagentControlRuntimePromise = null;
+function loadSubagentControlRuntime() {
+	subagentControlRuntimePromise ??= import("./subagent-control.runtime-5fnq08Py.js");
+	return subagentControlRuntimePromise;
+}
+async function resolveSubagentControlRuntime() {
+	if (subagentControlDeps.abortEmbeddedPiRun && subagentControlDeps.clearSessionQueues) return {
+		abortEmbeddedPiRun: subagentControlDeps.abortEmbeddedPiRun,
+		clearSessionQueues: subagentControlDeps.clearSessionQueues
+	};
+	const runtime = await loadSubagentControlRuntime();
+	return {
+		abortEmbeddedPiRun: subagentControlDeps.abortEmbeddedPiRun ?? runtime.abortEmbeddedPiRun,
+		clearSessionQueues: subagentControlDeps.clearSessionQueues ?? runtime.clearSessionQueues
+	};
+}
+function resolveSubagentController(params) {
+	const { mainKey, alias } = resolveMainSessionAlias(params.cfg);
+	const callerSessionKey = resolveInternalSessionKey({
+		key: params.agentSessionKey?.trim() || alias,
+		alias,
+		mainKey
+	});
+	if (!isSubagentSessionKey(callerSessionKey)) return {
+		controllerSessionKey: callerSessionKey,
+		callerSessionKey,
+		callerIsSubagent: false,
+		controlScope: "children"
+	};
+	return {
+		controllerSessionKey: callerSessionKey,
+		callerSessionKey,
+		callerIsSubagent: true,
+		controlScope: resolveStoredSubagentCapabilities(callerSessionKey, { cfg: params.cfg }).controlScope
+	};
+}
+function listControlledSubagentRuns(controllerSessionKey) {
+	const key = controllerSessionKey.trim();
+	if (!key) return [];
+	const latestByChildSessionKey = buildLatestSubagentRunIndex(getSubagentRunsSnapshotForRead(subagentRuns)).latestByChildSessionKey;
+	return sortSubagentRuns(Array.from(latestByChildSessionKey.values()).filter((entry) => {
+		return (entry.controllerSessionKey?.trim() || entry.requesterSessionKey?.trim()) === key;
+	}));
+}
+function ensureControllerOwnsRun(params) {
+	if ((params.entry.controllerSessionKey?.trim() || params.entry.requesterSessionKey) === params.controller.controllerSessionKey) return;
+	return "Subagents can only control runs spawned from their own session.";
+}
+async function killSubagentRun(params) {
+	if (params.entry.endedAt) return { killed: false };
+	const childSessionKey = params.entry.childSessionKey;
+	const resolved = resolveSessionEntryForKey({
+		cfg: params.cfg,
+		key: childSessionKey,
+		cache: params.cache
+	});
+	const sessionId = resolved.entry?.sessionId;
+	const runtime = await resolveSubagentControlRuntime();
+	const aborted = sessionId ? runtime.abortEmbeddedPiRun(sessionId) : false;
+	const cleared = runtime.clearSessionQueues([childSessionKey, sessionId]);
+	if (cleared.followupCleared > 0 || cleared.laneCleared > 0) logVerbose(`subagents control kill: cleared followups=${cleared.followupCleared} lane=${cleared.laneCleared} keys=${cleared.keys.join(",")}`);
+	if (resolved.entry) try {
+		await subagentControlDeps.updateSessionStore(resolved.storePath, (store) => {
+			const current = store[childSessionKey];
+			if (!current) return;
+			current.abortedLastRun = true;
+			current.updatedAt = Date.now();
+			store[childSessionKey] = current;
+		});
+	} catch (error) {
+		logVerbose(`subagents control kill: failed to persist abortedLastRun for ${childSessionKey}: ${formatErrorMessage(error)}`);
+	}
+	return {
+		killed: markSubagentRunTerminated({
+			runId: params.entry.runId,
+			childSessionKey,
+			reason: "killed"
+		}) > 0 || aborted || cleared.followupCleared > 0 || cleared.laneCleared > 0,
+		sessionId
+	};
+}
+async function cascadeKillChildren(params) {
+	const childRunsBySessionKey = /* @__PURE__ */ new Map();
+	for (const run of listSubagentRunsForController(params.parentChildSessionKey)) {
+		const childKey = run.childSessionKey?.trim();
+		if (!childKey) continue;
+		const latest = getLatestSubagentRunByChildSessionKey(childKey);
+		const latestControllerSessionKey = latest?.controllerSessionKey?.trim() || latest?.requesterSessionKey?.trim();
+		if (!latest || latest.runId !== run.runId || latestControllerSessionKey !== params.parentChildSessionKey) continue;
+		const existing = childRunsBySessionKey.get(childKey);
+		if (!existing || run.createdAt >= existing.createdAt) childRunsBySessionKey.set(childKey, run);
+	}
+	const childRuns = Array.from(childRunsBySessionKey.values());
+	const seenChildSessionKeys = params.seenChildSessionKeys ?? /* @__PURE__ */ new Set();
+	let killed = 0;
+	const labels = [];
+	for (const run of childRuns) {
+		const childKey = run.childSessionKey?.trim();
+		if (!childKey || seenChildSessionKeys.has(childKey)) continue;
+		seenChildSessionKeys.add(childKey);
+		if (!run.endedAt) {
+			if ((await killSubagentRun({
+				cfg: params.cfg,
+				entry: run,
+				cache: params.cache
+			})).killed) {
+				killed += 1;
+				labels.push(resolveSubagentLabel(run));
+			}
+		}
+		const cascade = await cascadeKillChildren({
+			cfg: params.cfg,
+			parentChildSessionKey: childKey,
+			cache: params.cache,
+			seenChildSessionKeys
+		});
+		killed += cascade.killed;
+		labels.push(...cascade.labels);
+	}
+	return {
+		killed,
+		labels
+	};
+}
+async function killAllControlledSubagentRuns(params) {
+	if (params.controller.controlScope !== "children") return {
+		status: "forbidden",
+		error: "Leaf subagents cannot control other sessions.",
+		killed: 0,
+		labels: []
+	};
+	const cache = /* @__PURE__ */ new Map();
+	const seenChildSessionKeys = /* @__PURE__ */ new Set();
+	const killedLabels = [];
+	let killed = 0;
+	for (const entry of params.runs) {
+		const childKey = entry.childSessionKey?.trim();
+		if (!childKey || seenChildSessionKeys.has(childKey)) continue;
+		const currentEntry = getLatestSubagentRunByChildSessionKey(childKey);
+		if (!currentEntry || currentEntry.runId !== entry.runId) continue;
+		seenChildSessionKeys.add(childKey);
+		if (!currentEntry.endedAt) {
+			if ((await killSubagentRun({
+				cfg: params.cfg,
+				entry: currentEntry,
+				cache
+			})).killed) {
+				killed += 1;
+				killedLabels.push(resolveSubagentLabel(currentEntry));
+			}
+		}
+		const cascade = await cascadeKillChildren({
+			cfg: params.cfg,
+			parentChildSessionKey: childKey,
+			cache,
+			seenChildSessionKeys
+		});
+		killed += cascade.killed;
+		killedLabels.push(...cascade.labels);
+	}
+	return {
+		status: "ok",
+		killed,
+		labels: killedLabels
+	};
+}
+async function killControlledSubagentRun(params) {
+	const ownershipError = ensureControllerOwnsRun({
+		controller: params.controller,
+		entry: params.entry
+	});
+	if (ownershipError) return {
+		status: "forbidden",
+		runId: params.entry.runId,
+		sessionKey: params.entry.childSessionKey,
+		error: ownershipError
+	};
+	if (params.controller.controlScope !== "children") return {
+		status: "forbidden",
+		runId: params.entry.runId,
+		sessionKey: params.entry.childSessionKey,
+		error: "Leaf subagents cannot control other sessions."
+	};
+	const currentEntry = getLatestSubagentRunByChildSessionKey(params.entry.childSessionKey);
+	if (!currentEntry || currentEntry.runId !== params.entry.runId) return {
+		status: "done",
+		runId: params.entry.runId,
+		sessionKey: params.entry.childSessionKey,
+		label: resolveSubagentLabel(params.entry),
+		text: `${resolveSubagentLabel(params.entry)} is already finished.`
+	};
+	const killCache = /* @__PURE__ */ new Map();
+	const stopResult = await killSubagentRun({
+		cfg: params.cfg,
+		entry: currentEntry,
+		cache: killCache
+	});
+	const seenChildSessionKeys = /* @__PURE__ */ new Set();
+	const targetChildKey = params.entry.childSessionKey?.trim();
+	if (targetChildKey) seenChildSessionKeys.add(targetChildKey);
+	const cascade = await cascadeKillChildren({
+		cfg: params.cfg,
+		parentChildSessionKey: params.entry.childSessionKey,
+		cache: killCache,
+		seenChildSessionKeys
+	});
+	if (!stopResult.killed && cascade.killed === 0) return {
+		status: "done",
+		runId: params.entry.runId,
+		sessionKey: params.entry.childSessionKey,
+		label: resolveSubagentLabel(params.entry),
+		text: `${resolveSubagentLabel(params.entry)} is already finished.`
+	};
+	const cascadeText = cascade.killed > 0 ? ` (+ ${cascade.killed} descendant${cascade.killed === 1 ? "" : "s"})` : "";
+	return {
+		status: "ok",
+		runId: params.entry.runId,
+		sessionKey: params.entry.childSessionKey,
+		label: resolveSubagentLabel(params.entry),
+		cascadeKilled: cascade.killed,
+		cascadeLabels: cascade.killed > 0 ? cascade.labels : void 0,
+		text: stopResult.killed ? `killed ${resolveSubagentLabel(params.entry)}${cascadeText}.` : `killed ${cascade.killed} descendant${cascade.killed === 1 ? "" : "s"} of ${resolveSubagentLabel(params.entry)}.`
+	};
+}
+async function killSubagentRunAdmin(params) {
+	const targetSessionKey = params.sessionKey.trim();
+	if (!targetSessionKey) return {
+		found: false,
+		killed: false
+	};
+	const entry = getLatestSubagentRunByChildSessionKey(targetSessionKey);
+	if (!entry) return {
+		found: false,
+		killed: false
+	};
+	const killCache = /* @__PURE__ */ new Map();
+	const stopResult = await killSubagentRun({
+		cfg: params.cfg,
+		entry,
+		cache: killCache
+	});
+	const seenChildSessionKeys = new Set([targetSessionKey]);
+	const cascade = await cascadeKillChildren({
+		cfg: params.cfg,
+		parentChildSessionKey: targetSessionKey,
+		cache: killCache,
+		seenChildSessionKeys
+	});
+	return {
+		found: true,
+		killed: stopResult.killed || cascade.killed > 0,
+		runId: entry.runId,
+		sessionKey: entry.childSessionKey,
+		cascadeKilled: cascade.killed,
+		cascadeLabels: cascade.killed > 0 ? cascade.labels : void 0
+	};
+}
+async function steerControlledSubagentRun(params) {
+	const ownershipError = ensureControllerOwnsRun({
+		controller: params.controller,
+		entry: params.entry
+	});
+	if (ownershipError) return {
+		status: "forbidden",
+		runId: params.entry.runId,
+		sessionKey: params.entry.childSessionKey,
+		error: ownershipError
+	};
+	if (params.controller.controlScope !== "children") return {
+		status: "forbidden",
+		runId: params.entry.runId,
+		sessionKey: params.entry.childSessionKey,
+		error: "Leaf subagents cannot control other sessions."
+	};
+	const targetHasPendingDescendants = countPendingDescendantRuns(params.entry.childSessionKey) > 0;
+	if (params.entry.endedAt && !targetHasPendingDescendants) return {
+		status: "done",
+		runId: params.entry.runId,
+		sessionKey: params.entry.childSessionKey,
+		text: `${resolveSubagentLabel(params.entry)} is already finished.`
+	};
+	if (params.controller.callerSessionKey === params.entry.childSessionKey) return {
+		status: "forbidden",
+		runId: params.entry.runId,
+		sessionKey: params.entry.childSessionKey,
+		error: "Subagents cannot steer themselves."
+	};
+	const currentEntry = getLatestSubagentRunByChildSessionKey(params.entry.childSessionKey);
+	const currentHasPendingDescendants = currentEntry && countPendingDescendantRuns(currentEntry.childSessionKey) > 0;
+	if (!currentEntry || currentEntry.runId !== params.entry.runId || currentEntry.endedAt && !currentHasPendingDescendants) return {
+		status: "done",
+		runId: params.entry.runId,
+		sessionKey: params.entry.childSessionKey,
+		text: `${resolveSubagentLabel(params.entry)} is already finished.`
+	};
+	const rateKey = `${params.controller.callerSessionKey}:${params.entry.childSessionKey}`;
+	if (process.env.VITEST !== "true") {
+		const now = Date.now();
+		if (now - (steerRateLimit.get(rateKey) ?? 0) < 2e3) return {
+			status: "rate_limited",
+			runId: params.entry.runId,
+			sessionKey: params.entry.childSessionKey,
+			error: "Steer rate limit exceeded. Wait a moment before sending another steer."
+		};
+		steerRateLimit.set(rateKey, now);
+	}
+	markSubagentRunForSteerRestart(params.entry.runId);
+	const targetSession = resolveSessionEntryForKey({
+		cfg: params.cfg,
+		key: params.entry.childSessionKey,
+		cache: /* @__PURE__ */ new Map()
+	});
+	const sessionId = typeof targetSession.entry?.sessionId === "string" && targetSession.entry.sessionId.trim() ? targetSession.entry.sessionId.trim() : void 0;
+	if (sessionId) (await resolveSubagentControlRuntime()).abortEmbeddedPiRun(sessionId);
+	const cleared = (await resolveSubagentControlRuntime()).clearSessionQueues([params.entry.childSessionKey, sessionId]);
+	if (cleared.followupCleared > 0 || cleared.laneCleared > 0) logVerbose(`subagents control steer: cleared followups=${cleared.followupCleared} lane=${cleared.laneCleared} keys=${cleared.keys.join(",")}`);
+	try {
+		await subagentControlDeps.callGateway({
+			method: "agent.wait",
+			params: {
+				runId: params.entry.runId,
+				timeoutMs: STEER_ABORT_SETTLE_TIMEOUT_MS
+			},
+			timeoutMs: STEER_ABORT_SETTLE_TIMEOUT_MS + 2e3
+		});
+	} catch {}
+	const idempotencyKey = crypto.randomUUID();
+	let runId = idempotencyKey;
+	try {
+		const response = await subagentControlDeps.callGateway({
+			method: "agent",
+			params: {
+				message: params.message,
+				sessionKey: params.entry.childSessionKey,
+				sessionId,
+				idempotencyKey,
+				deliver: false,
+				channel: INTERNAL_MESSAGE_CHANNEL,
+				lane: AGENT_LANE_SUBAGENT,
+				timeout: 0
+			},
+			timeoutMs: 1e4
+		});
+		if (typeof response?.runId === "string" && response.runId) runId = response.runId;
+	} catch (err) {
+		clearSubagentRunSteerRestart(params.entry.runId);
+		const error = formatErrorMessage(err);
+		return {
+			status: "error",
+			runId,
+			sessionKey: params.entry.childSessionKey,
+			sessionId,
+			error
+		};
+	}
+	if (!replaceSubagentRunAfterSteer({
+		previousRunId: params.entry.runId,
+		nextRunId: runId,
+		fallback: params.entry,
+		runTimeoutSeconds: params.entry.runTimeoutSeconds ?? 0
+	})) {
+		clearSubagentRunSteerRestart(params.entry.runId);
+		return {
+			status: "error",
+			runId,
+			sessionKey: params.entry.childSessionKey,
+			sessionId,
+			error: "failed to replace steered subagent run"
+		};
+	}
+	return {
+		status: "accepted",
+		runId,
+		sessionKey: params.entry.childSessionKey,
+		sessionId,
+		mode: "restart",
+		label: resolveSubagentLabel(params.entry),
+		text: `steered ${resolveSubagentLabel(params.entry)}.`
+	};
+}
+async function sendControlledSubagentMessage(params) {
+	const ownershipError = ensureControllerOwnsRun({
+		controller: params.controller,
+		entry: params.entry
+	});
+	if (ownershipError) return {
+		status: "forbidden",
+		error: ownershipError
+	};
+	if (params.controller.controlScope !== "children") return {
+		status: "forbidden",
+		error: "Leaf subagents cannot control other sessions."
+	};
+	const currentEntry = getLatestSubagentRunByChildSessionKey(params.entry.childSessionKey);
+	if (!currentEntry || currentEntry.runId !== params.entry.runId) return {
+		status: "done",
+		runId: params.entry.runId,
+		text: `${resolveSubagentLabel(params.entry)} is already finished.`
+	};
+	const targetSessionKey = params.entry.childSessionKey;
+	const parsed = parseAgentSessionKey(targetSessionKey);
+	const targetSessionEntry = loadSessionStore(resolveStorePath(params.cfg.session?.store, { agentId: parsed?.agentId }))[targetSessionKey];
+	const targetSessionId = typeof targetSessionEntry?.sessionId === "string" && targetSessionEntry.sessionId.trim() ? targetSessionEntry.sessionId.trim() : void 0;
+	const idempotencyKey = crypto.randomUUID();
+	let runId = idempotencyKey;
+	try {
+		const baselineReply = await readLatestAssistantReplySnapshot({
+			sessionKey: targetSessionKey,
+			limit: SUBAGENT_REPLY_HISTORY_LIMIT,
+			callGateway: subagentControlDeps.callGateway
+		});
+		const response = await subagentControlDeps.callGateway({
+			method: "agent",
+			params: {
+				message: params.message,
+				sessionKey: targetSessionKey,
+				sessionId: targetSessionId,
+				idempotencyKey,
+				deliver: false,
+				channel: INTERNAL_MESSAGE_CHANNEL,
+				lane: AGENT_LANE_SUBAGENT,
+				timeout: 0
+			},
+			timeoutMs: 1e4
+		});
+		const responseRunId = typeof response?.runId === "string" ? response.runId : void 0;
+		if (responseRunId) runId = responseRunId;
+		const result = await waitForAgentRunAndReadUpdatedAssistantReply({
+			runId,
+			sessionKey: targetSessionKey,
+			timeoutMs: 3e4,
+			limit: SUBAGENT_REPLY_HISTORY_LIMIT,
+			baseline: baselineReply,
+			callGateway: subagentControlDeps.callGateway
+		});
+		if (result.status === "timeout") return {
+			status: "timeout",
+			runId
+		};
+		if (result.status === "error") return {
+			status: "error",
+			runId,
+			error: result.error ?? "unknown error"
+		};
+		return {
+			status: "ok",
+			runId,
+			replyText: result.replyText
+		};
+	} catch (err) {
+		const error = formatErrorMessage(err);
+		return {
+			status: "error",
+			runId,
+			error
+		};
+	}
+}
+function resolveControlledSubagentTarget(runs, token, options) {
+	return resolveSubagentTargetFromRuns({
+		runs,
+		token,
+		recentWindowMinutes: options?.recentMinutes ?? 30,
+		label: (entry) => resolveSubagentLabel(entry),
+		isActive: options?.isActive,
+		errors: {
+			missingTarget: "Missing subagent target.",
+			invalidIndex: (value) => `Invalid subagent index: ${value}`,
+			unknownSession: (value) => `Unknown subagent session: ${value}`,
+			ambiguousLabel: (value) => `Ambiguous subagent label: ${value}`,
+			ambiguousLabelPrefix: (value) => `Ambiguous subagent label prefix: ${value}`,
+			ambiguousRunIdPrefix: (value) => `Ambiguous subagent run id prefix: ${value}`,
+			unknownTarget: (value) => `Unknown subagent target: ${value}`
+		}
+	});
+}
+//#endregion
+export { killSubagentRunAdmin as a, resolveSubagentController as c, killControlledSubagentRun as i, sendControlledSubagentMessage as l, MAX_STEER_MESSAGE_CHARS as n, listControlledSubagentRuns as o, killAllControlledSubagentRuns as r, resolveControlledSubagentTarget as s, MAX_RECENT_MINUTES as t, steerControlledSubagentRun as u };

package/dist/subagent-followup.runtime-XeFe_LA0.js

@@ -0,0 +1,68 @@
+import { o as listDescendantRunsForRequester } from "./subagent-registry-read-ddSiFqfz.js";
+import "./tokens-QeRE8ZG7.js";
+import { n as readLatestAssistantReply, o as waitForAgentRunsToDrain } from "./run-wait-DHizeptL.js";
+import { n as isLikelyInterimCronMessage } from "./subagent-followup-hints-DbPNK_wZ.js";
+//#region src/cron/isolated-agent/subagent-followup.ts
+function resolveCronSubagentTimings() {
+	const fastTestMode = process.env.GENESIS_TEST_FAST === "1";
+	return {
+		waitMinMs: fastTestMode ? 10 : 3e4,
+		finalReplyGraceMs: fastTestMode ? 50 : 5e3,
+		gracePollMs: fastTestMode ? 8 : 200
+	};
+}
+async function readDescendantSubagentFallbackReply(params) {
+	const descendants = listDescendantRunsForRequester(params.sessionKey).filter((entry) => typeof entry.endedAt === "number" && entry.endedAt >= params.runStartedAt && entry.childSessionKey.trim().length > 0).toSorted((a, b) => (a.endedAt ?? 0) - (b.endedAt ?? 0));
+	if (descendants.length === 0) return;
+	const latestByChild = /* @__PURE__ */ new Map();
+	for (const entry of descendants) {
+		const childKey = entry.childSessionKey.trim();
+		if (!childKey) continue;
+		const current = latestByChild.get(childKey);
+		if (!current || (entry.endedAt ?? 0) >= (current.endedAt ?? 0)) latestByChild.set(childKey, entry);
+	}
+	const replies = [];
+	const latestRuns = [...latestByChild.values()].toSorted((a, b) => (a.endedAt ?? 0) - (b.endedAt ?? 0)).slice(-4);
+	for (const entry of latestRuns) {
+		let reply = (await readLatestAssistantReply({ sessionKey: entry.childSessionKey }))?.trim();
+		if (!reply && typeof entry.frozenResultText === "string" && entry.frozenResultText.trim()) reply = entry.frozenResultText.trim();
+		if (!reply || reply.toUpperCase() === "NO_REPLY".toUpperCase()) continue;
+		replies.push(reply);
+	}
+	if (replies.length === 0) return;
+	if (replies.length === 1) return replies[0];
+	return replies.join("\n\n");
+}
+/**
+* Waits for descendant subagents to complete using a push-based approach:
+* each active descendant run is awaited via `agent.wait` (gateway RPC) instead
+* of a busy-poll loop.  After all active runs settle, a short grace period
+* polls the cron agent's session for a post-orchestration synthesis message.
+*/
+async function waitForDescendantSubagentSummary(params) {
+	const timings = resolveCronSubagentTimings();
+	const initialReply = params.initialReply?.trim();
+	const deadline = Date.now() + Math.max(timings.waitMinMs, Math.floor(params.timeoutMs));
+	const getActiveRuns = () => listDescendantRunsForRequester(params.sessionKey).filter((entry) => typeof entry.endedAt !== "number");
+	const initialActiveRuns = getActiveRuns();
+	if (!(params.observedActiveDescendants === true || initialActiveRuns.length > 0)) return initialReply;
+	await waitForAgentRunsToDrain({
+		deadlineAtMs: deadline,
+		initialPendingRunIds: initialActiveRuns.map((entry) => entry.runId),
+		getPendingRunIds: () => getActiveRuns().map((entry) => entry.runId)
+	});
+	const gracePeriodDeadline = Math.min(Date.now() + timings.finalReplyGraceMs, deadline);
+	const resolveUsableLatestReply = async () => {
+		const latest = (await readLatestAssistantReply({ sessionKey: params.sessionKey }))?.trim();
+		if (latest && latest.toUpperCase() !== "NO_REPLY".toUpperCase() && (latest !== initialReply || !isLikelyInterimCronMessage(latest))) return latest;
+	};
+	while (Date.now() < gracePeriodDeadline) {
+		const latest = await resolveUsableLatestReply();
+		if (latest) return latest;
+		await new Promise((resolve) => setTimeout(resolve, timings.gracePollMs));
+	}
+	const latest = await resolveUsableLatestReply();
+	if (latest) return latest;
+}
+//#endregion
+export { readDescendantSubagentFallbackReply, waitForDescendantSubagentSummary };

package/dist/subagent-followup.runtime.js

@@ -1 +1 @@
-export * from "./subagent-followup.runtime-BbA7NPAq.js";
+export * from "./subagent-followup.runtime-XeFe_LA0.js";