@pixelzx/genesis 2026.5.10-2 → 2026.5.10-3

package/dist/status.summary-CZhlDozR.js

@@ -0,0 +1,214 @@
+import { s as resolveRuntimeServiceVersion } from "./version-BoqlEm3e.js";
+import { o as parseAgentSessionKey } from "./session-key-utils-BT0y7mVK.js";
+import { n as DEFAULT_MODEL, r as DEFAULT_PROVIDER } from "./defaults-DM8yIn8C.js";
+import { i as resolveMainSessionKey } from "./main-session-DzrcDgxY.js";
+import { u as resolveStorePath } from "./paths-DD6L4IvS.js";
+import { l as resolveSessionTotalTokens } from "./types-Bx9yhV03.js";
+import { r as resolveHeartbeatSummaryForAgent } from "./heartbeat-summary-Dri6qdcY.js";
+import { a as createLazyRuntimeSurface } from "./lazy-runtime-02MY_g6C.js";
+import { i as hasConfiguredChannelsForReadOnlyScope } from "./channel-plugin-ids-DzY3O6B5.js";
+import { c as peekSystemEvents } from "./system-events-C6NkuE_K.js";
+import { n as readSessionStoreReadOnly, t as listGatewayAgentsBasic } from "./agent-list-COThniwf.js";
+//#region src/commands/status.summary.ts
+let channelSummaryModulePromise;
+let linkChannelModulePromise;
+let configIoModulePromise;
+let taskRegistryMaintenanceModulePromise;
+function loadChannelSummaryModule() {
+	channelSummaryModulePromise ??= import("./channel-summary-CblcbQad.js");
+	return channelSummaryModulePromise;
+}
+function loadLinkChannelModule() {
+	linkChannelModulePromise ??= import("./status.link-channel-Cp2KZtvf.js");
+	return linkChannelModulePromise;
+}
+const loadStatusSummaryRuntimeModule = createLazyRuntimeSurface(() => import("./commands/status.summary.runtime.js"), ({ statusSummaryRuntime }) => statusSummaryRuntime);
+function loadConfigIoModule() {
+	configIoModulePromise ??= import("./io-CKqfW_GT.js");
+	return configIoModulePromise;
+}
+function loadTaskRegistryMaintenanceModule() {
+	taskRegistryMaintenanceModulePromise ??= import("./task-registry.maintenance-BKCkUElL.js");
+	return taskRegistryMaintenanceModulePromise;
+}
+const buildFlags = (entry) => {
+	if (!entry) return [];
+	const flags = [];
+	const think = entry?.thinkingLevel;
+	if (typeof think === "string" && think.length > 0) flags.push(`think:${think}`);
+	const verbose = entry?.verboseLevel;
+	if (typeof verbose === "string" && verbose.length > 0) flags.push(`verbose:${verbose}`);
+	if (typeof entry?.fastMode === "boolean") flags.push(entry.fastMode ? "fast" : "fast:off");
+	const reasoning = entry?.reasoningLevel;
+	if (typeof reasoning === "string" && reasoning.length > 0) flags.push(`reasoning:${reasoning}`);
+	const elevated = entry?.elevatedLevel;
+	if (typeof elevated === "string" && elevated.length > 0) flags.push(`elevated:${elevated}`);
+	if (entry?.systemSent) flags.push("system");
+	if (entry?.abortedLastRun) flags.push("aborted");
+	const sessionId = entry?.sessionId;
+	if (typeof sessionId === "string" && sessionId.length > 0) flags.push(`id:${sessionId}`);
+	return flags;
+};
+function redactSensitiveStatusSummary(summary) {
+	return {
+		...summary,
+		sessions: {
+			...summary.sessions,
+			paths: [],
+			defaults: {
+				model: null,
+				contextTokens: null
+			},
+			recent: [],
+			byAgent: summary.sessions.byAgent.map((entry) => ({
+				...entry,
+				path: "[redacted]",
+				recent: []
+			}))
+		}
+	};
+}
+async function getStatusSummary(options = {}) {
+	const { includeSensitive = true, includeChannelSummary = true } = options;
+	const { classifySessionKey, resolveConfiguredStatusModelRef, resolveContextTokensForModel, resolveSessionModelRef } = await loadStatusSummaryRuntimeModule();
+	const cfg = options.config ?? (await loadConfigIoModule()).loadConfig();
+	const channelScopeConfig = options.sourceConfig === void 0 ? { config: cfg } : {
+		config: cfg,
+		activationSourceConfig: options.sourceConfig
+	};
+	const needsChannelPlugins = includeChannelSummary && hasConfiguredChannelsForReadOnlyScope(channelScopeConfig);
+	const linkContext = needsChannelPlugins ? await loadLinkChannelModule().then(({ resolveLinkChannelContext }) => resolveLinkChannelContext(cfg, { sourceConfig: options.sourceConfig })) : null;
+	const agentList = listGatewayAgentsBasic(cfg);
+	const heartbeatAgents = agentList.agents.map((agent) => {
+		const summary = resolveHeartbeatSummaryForAgent(cfg, agent.id);
+		return {
+			agentId: agent.id,
+			enabled: summary.enabled,
+			every: summary.every,
+			everyMs: summary.everyMs
+		};
+	});
+	const channelSummary = needsChannelPlugins ? await loadChannelSummaryModule().then(({ buildChannelSummary }) => buildChannelSummary(cfg, {
+		colorize: true,
+		includeAllowFrom: true,
+		sourceConfig: options.sourceConfig
+	})) : [];
+	const queuedSystemEvents = peekSystemEvents(resolveMainSessionKey(cfg));
+	const taskMaintenanceModule = await loadTaskRegistryMaintenanceModule();
+	const tasks = taskMaintenanceModule.getInspectableTaskRegistrySummary();
+	const taskAudit = taskMaintenanceModule.getInspectableTaskAuditSummary();
+	const resolved = resolveConfiguredStatusModelRef({
+		cfg,
+		defaultProvider: DEFAULT_PROVIDER,
+		defaultModel: DEFAULT_MODEL
+	});
+	const configModel = resolved.model ?? "gpt-5.5";
+	const configContextTokens = resolveContextTokensForModel({
+		cfg,
+		provider: resolved.provider ?? "openai",
+		model: configModel,
+		contextTokensOverride: cfg.agents?.defaults?.contextTokens,
+		fallbackContextTokens: 2e5,
+		allowAsyncLoad: false
+	}) ?? 2e5;
+	const now = Date.now();
+	const storeCache = /* @__PURE__ */ new Map();
+	const loadStore = (storePath) => {
+		const cached = storeCache.get(storePath);
+		if (cached) return cached;
+		const store = readSessionStoreReadOnly(storePath);
+		storeCache.set(storePath, store);
+		return store;
+	};
+	const buildSessionRows = (store, opts = {}) => Object.entries(store).filter(([key]) => key !== "global" && key !== "unknown").map(([key, entry]) => {
+		const updatedAt = entry?.updatedAt ?? null;
+		const age = updatedAt ? now - updatedAt : null;
+		const resolvedModel = resolveSessionModelRef(cfg, entry, opts.agentIdOverride);
+		const model = resolvedModel.model ?? configModel ?? null;
+		const contextTokens = resolveContextTokensForModel({
+			cfg,
+			provider: resolvedModel.provider,
+			model,
+			contextTokensOverride: entry?.contextTokens,
+			fallbackContextTokens: configContextTokens ?? void 0,
+			allowAsyncLoad: false
+		}) ?? null;
+		const total = resolveSessionTotalTokens(entry);
+		const totalTokensFresh = typeof entry?.totalTokens === "number" ? entry?.totalTokensFresh !== false : false;
+		const remaining = contextTokens != null && total !== void 0 ? Math.max(0, contextTokens - total) : null;
+		const pct = contextTokens && contextTokens > 0 && total !== void 0 ? Math.min(999, Math.round(total / contextTokens * 100)) : null;
+		const parsedAgentId = parseAgentSessionKey(key)?.agentId;
+		return {
+			agentId: opts.agentIdOverride ?? parsedAgentId,
+			key,
+			kind: classifySessionKey(key, entry),
+			sessionId: entry?.sessionId,
+			updatedAt,
+			age,
+			thinkingLevel: entry?.thinkingLevel,
+			fastMode: entry?.fastMode,
+			verboseLevel: entry?.verboseLevel,
+			traceLevel: entry?.traceLevel,
+			reasoningLevel: entry?.reasoningLevel,
+			elevatedLevel: entry?.elevatedLevel,
+			systemSent: entry?.systemSent,
+			abortedLastRun: entry?.abortedLastRun,
+			inputTokens: entry?.inputTokens,
+			outputTokens: entry?.outputTokens,
+			cacheRead: entry?.cacheRead,
+			cacheWrite: entry?.cacheWrite,
+			totalTokens: total ?? null,
+			totalTokensFresh,
+			remainingTokens: remaining,
+			percentUsed: pct,
+			model,
+			contextTokens,
+			flags: buildFlags(entry)
+		};
+	}).sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0));
+	const paths = /* @__PURE__ */ new Set();
+	const byAgent = agentList.agents.map((agent) => {
+		const storePath = resolveStorePath(cfg.session?.store, { agentId: agent.id });
+		paths.add(storePath);
+		const sessions = buildSessionRows(loadStore(storePath), { agentIdOverride: agent.id });
+		return {
+			agentId: agent.id,
+			path: storePath,
+			count: sessions.length,
+			recent: sessions.slice(0, 10)
+		};
+	});
+	const allSessions = Array.from(paths).flatMap((storePath) => buildSessionRows(loadStore(storePath))).toSorted((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0));
+	const recent = allSessions.slice(0, 10);
+	const totalSessions = allSessions.length;
+	const summary = {
+		runtimeVersion: resolveRuntimeServiceVersion(process.env),
+		linkChannel: linkContext ? {
+			id: linkContext.plugin.id,
+			label: linkContext.plugin.meta.label ?? "Channel",
+			linked: linkContext.linked,
+			authAgeMs: linkContext.authAgeMs
+		} : void 0,
+		heartbeat: {
+			defaultAgentId: agentList.defaultId,
+			agents: heartbeatAgents
+		},
+		channelSummary,
+		queuedSystemEvents,
+		tasks,
+		taskAudit,
+		sessions: {
+			paths: Array.from(paths),
+			count: totalSessions,
+			defaults: {
+				model: configModel ?? null,
+				contextTokens: configContextTokens ?? null
+			},
+			recent,
+			byAgent
+		}
+	};
+	return includeSensitive ? summary : redactSensitiveStatusSummary(summary);
+}
+//#endregion
+export { redactSensitiveStatusSummary as n, getStatusSummary as t };

package/dist/subagent-announce-DQNhTREe.js

@@ -0,0 +1,351 @@
+import { c as normalizeOptionalString } from "./string-coerce-C1IzJjqi.js";
+import { n as defaultRuntime } from "./runtime-CQ7eH0le.js";
+import { a as loadConfig } from "./io-BEkyPF5u.js";
+import { i as isCronSessionKey } from "./session-key-utils-BT0y7mVK.js";
+import { r as INTERNAL_MESSAGE_CHANNEL } from "./message-channel-core-CtbksRwN.js";
+import "./message-channel-BbI8d0sw.js";
+import { i as normalizeDeliveryContext } from "./delivery-context.shared-Bddxu9DN.js";
+import { a as isSilentReplyText, c as stripSilentToken, n as SILENT_REPLY_TOKEN, o as startsWithSilentToken, s as stripLeadingSilentToken } from "./tokens-Bq9TB3gs.js";
+import { r as callGateway } from "./call-BNALogg6.js";
+import "./delivery-context-Bj_usnQD.js";
+import { a as getSubagentDepthFromSessionStore } from "./subagent-capabilities-CANCl5Vx.js";
+import { t as formatAgentInternalEventsForPrompt } from "./internal-events-3alBxRdy.js";
+import { a as resolveSubagentAnnounceTimeoutMs, c as resolveAnnounceOrigin, i as loadSessionEntryByKey, l as buildAnnounceIdFromChildRun, o as resolveSubagentCompletionOrigin, r as loadRequesterSessionEntry, s as runAnnounceDeliveryWithRetry, t as deliverSubagentAnnouncement, u as buildAnnounceIdempotencyKey } from "./subagent-announce-delivery-DzexQBXL.js";
+import { a as isEmbeddedPiRunActive, f as waitForEmbeddedPiRunEnd } from "./runs-um_OdYKT.js";
+import { a as dedupeLatestChildCompletionRows, c as readSubagentOutput, i as captureSubagentCompletionReply, l as waitForSubagentRunOutcome, m as isAnnounceSkip, n as buildChildCompletionFindings, o as filterCurrentDirectChildCompletionRows, r as buildCompactAnnounceStatsLine, s as readLatestSubagentOutputWithRetry, t as applySubagentWaitOutcome } from "./subagent-announce-output-DHdUIOLb.js";
+import { t as buildSubagentSystemPrompt } from "./subagent-system-prompt-Bwspp0Dy.js";
+//#region src/agents/subagent-announce.ts
+const defaultSubagentAnnounceDeps = {
+	callGateway,
+	loadConfig,
+	loadSubagentRegistryRuntime
+};
+let subagentAnnounceDeps = defaultSubagentAnnounceDeps;
+let subagentRegistryRuntimePromise = null;
+function loadSubagentRegistryRuntime() {
+	subagentRegistryRuntimePromise ??= import("./subagent-announce.registry.runtime-BND2DLsz.js");
+	return subagentRegistryRuntimePromise;
+}
+function buildAnnounceReplyInstruction(params) {
+	if (params.requesterIsSubagent) return `Convert this completion into a concise internal orchestration update for your parent agent in your own words. Keep this internal context private (don't mention system/log/stats/session details or announce type). If this result is duplicate or no update is needed, reply ONLY: ${SILENT_REPLY_TOKEN}.`;
+	if (params.expectsCompletionMessage) return `A completed ${params.announceType} is ready for user delivery. Convert the result above into your normal assistant voice and send that user-facing update now. Keep this internal context private (don't mention system/log/stats/session details or announce type).`;
+	return `A completed ${params.announceType} is ready for user delivery. Convert the result above into your normal assistant voice and send that user-facing update now. Keep this internal context private (don't mention system/log/stats/session details or announce type), and do not copy the internal event text verbatim. Reply ONLY: ${SILENT_REPLY_TOKEN} if this exact result was already delivered to the user in this same turn.`;
+}
+function buildAnnounceSteerMessage(events) {
+	return formatAgentInternalEventsForPrompt(events) || "A background task finished. Process the completion update now.";
+}
+function hasUsableSessionEntry(entry) {
+	if (!entry || typeof entry !== "object") return false;
+	const sessionId = entry.sessionId;
+	return typeof sessionId !== "string" || sessionId.trim() !== "";
+}
+function buildDescendantWakeMessage(params) {
+	return [
+		"[Subagent Context] Your prior run ended while waiting for descendant subagent completions.",
+		"[Subagent Context] All pending descendants for that run have now settled.",
+		"[Subagent Context] Continue your workflow using these results. Spawn more subagents if needed, otherwise send your final answer.",
+		"",
+		`Task: ${params.taskLabel}`,
+		"",
+		params.findings
+	].join("\n");
+}
+const WAKE_RUN_SUFFIX = ":wake";
+function stripWakeRunSuffixes(runId) {
+	let next = runId.trim();
+	while (next.endsWith(WAKE_RUN_SUFFIX)) next = next.slice(0, -5);
+	return next || runId.trim();
+}
+function isWakeContinuationRun(runId) {
+	const trimmed = runId.trim();
+	if (!trimmed) return false;
+	return stripWakeRunSuffixes(trimmed) !== trimmed;
+}
+function stripAndClassifyReply(text) {
+	let result = text;
+	let didStrip = false;
+	const hasLeadingSilentToken = startsWithSilentToken(result, SILENT_REPLY_TOKEN);
+	if (hasLeadingSilentToken) {
+		result = stripLeadingSilentToken(result, SILENT_REPLY_TOKEN);
+		didStrip = true;
+	}
+	if (hasLeadingSilentToken || result.toLowerCase().includes("NO_REPLY".toLowerCase())) {
+		result = stripSilentToken(result, SILENT_REPLY_TOKEN);
+		didStrip = true;
+	}
+	if (didStrip && (!result.trim() || isSilentReplyText(result, "NO_REPLY") || isAnnounceSkip(result))) return null;
+	return result;
+}
+async function wakeSubagentRunAfterDescendants(params) {
+	if (params.signal?.aborted) return false;
+	if (!hasUsableSessionEntry(loadSessionEntryByKey(params.childSessionKey))) return false;
+	const announceTimeoutMs = resolveSubagentAnnounceTimeoutMs(subagentAnnounceDeps.loadConfig());
+	const wakeMessage = buildDescendantWakeMessage({
+		findings: params.findings,
+		taskLabel: params.taskLabel
+	});
+	let wakeRunId = "";
+	try {
+		wakeRunId = normalizeOptionalString((await runAnnounceDeliveryWithRetry({
+			operation: "descendant wake agent call",
+			signal: params.signal,
+			run: async () => await subagentAnnounceDeps.callGateway({
+				method: "agent",
+				params: {
+					sessionKey: params.childSessionKey,
+					message: wakeMessage,
+					deliver: false,
+					inputProvenance: {
+						kind: "inter_session",
+						sourceSessionKey: params.childSessionKey,
+						sourceChannel: "webchat",
+						sourceTool: "subagent_announce"
+					},
+					idempotencyKey: buildAnnounceIdempotencyKey(`${params.announceId}:wake`)
+				},
+				timeoutMs: announceTimeoutMs
+			})
+		}))?.runId) ?? "";
+	} catch {
+		return false;
+	}
+	if (!wakeRunId) return false;
+	const { replaceSubagentRunAfterSteer } = await loadSubagentRegistryRuntime();
+	return replaceSubagentRunAfterSteer({
+		previousRunId: params.runId,
+		nextRunId: wakeRunId,
+		preserveFrozenResultFallback: true
+	});
+}
+async function runSubagentAnnounceFlow(params) {
+	let didAnnounce = false;
+	const expectsCompletionMessage = params.expectsCompletionMessage === true;
+	const announceType = params.announceType ?? "subagent task";
+	let shouldDeleteChildSession = params.cleanup === "delete";
+	try {
+		let targetRequesterSessionKey = params.requesterSessionKey;
+		let targetRequesterOrigin = normalizeDeliveryContext(params.requesterOrigin);
+		const childSessionId = (() => {
+			const entry = loadSessionEntryByKey(params.childSessionKey);
+			return typeof entry?.sessionId === "string" && entry.sessionId.trim() ? entry.sessionId.trim() : void 0;
+		})();
+		const settleTimeoutMs = Math.min(Math.max(params.timeoutMs, 1), 12e4);
+		let reply = params.roundOneReply;
+		let outcome = params.outcome;
+		if (childSessionId && isEmbeddedPiRunActive(childSessionId)) {
+			if (!await waitForEmbeddedPiRunEnd(childSessionId, settleTimeoutMs) && isEmbeddedPiRunActive(childSessionId)) {
+				shouldDeleteChildSession = false;
+				return false;
+			}
+		}
+		if (!reply && params.waitForCompletion !== false) {
+			const applied = applySubagentWaitOutcome({
+				wait: await waitForSubagentRunOutcome(params.childRunId, settleTimeoutMs),
+				outcome,
+				startedAt: params.startedAt,
+				endedAt: params.endedAt
+			});
+			outcome = applied.outcome;
+			params.startedAt = applied.startedAt;
+			params.endedAt = applied.endedAt;
+		}
+		if (!outcome) outcome = { status: "unknown" };
+		const failedTerminalOutcome = outcome.status === "error";
+		const allowFailedOutputCapture = !failedTerminalOutcome || !params.roundOneReply && !params.fallbackReply;
+		if (failedTerminalOutcome) reply = void 0;
+		let requesterDepth = getSubagentDepthFromSessionStore(targetRequesterSessionKey);
+		const requesterIsInternalSession = () => requesterDepth >= 1 || isCronSessionKey(targetRequesterSessionKey);
+		let childCompletionFindings;
+		let subagentRegistryRuntime;
+		try {
+			subagentRegistryRuntime = await subagentAnnounceDeps.loadSubagentRegistryRuntime();
+			if (requesterDepth >= 1 && subagentRegistryRuntime.shouldIgnorePostCompletionAnnounceForSession(targetRequesterSessionKey)) return true;
+			if (Math.max(0, subagentRegistryRuntime.countPendingDescendantRuns(params.childSessionKey)) > 0 && announceType !== "cron job") {
+				shouldDeleteChildSession = false;
+				return false;
+			}
+			if (typeof subagentRegistryRuntime.listSubagentRunsForRequester === "function") {
+				const directChildren = subagentRegistryRuntime.listSubagentRunsForRequester(params.childSessionKey, { requesterRunId: params.childRunId });
+				if (Array.isArray(directChildren) && directChildren.length > 0) childCompletionFindings = buildChildCompletionFindings(dedupeLatestChildCompletionRows(filterCurrentDirectChildCompletionRows(directChildren, {
+					requesterSessionKey: params.childSessionKey,
+					getLatestSubagentRunByChildSessionKey: subagentRegistryRuntime.getLatestSubagentRunByChildSessionKey
+				})));
+			}
+		} catch {}
+		const announceId = buildAnnounceIdFromChildRun({
+			childSessionKey: params.childSessionKey,
+			childRunId: params.childRunId
+		});
+		const childRunAlreadyWoken = isWakeContinuationRun(params.childRunId);
+		if (params.wakeOnDescendantSettle === true && childCompletionFindings?.trim() && !childRunAlreadyWoken) {
+			const wakeAnnounceId = buildAnnounceIdFromChildRun({
+				childSessionKey: params.childSessionKey,
+				childRunId: stripWakeRunSuffixes(params.childRunId)
+			});
+			if (await wakeSubagentRunAfterDescendants({
+				runId: params.childRunId,
+				childSessionKey: params.childSessionKey,
+				taskLabel: params.label || params.task || "task",
+				findings: childCompletionFindings,
+				announceId: wakeAnnounceId,
+				signal: params.signal
+			})) {
+				shouldDeleteChildSession = false;
+				return true;
+			}
+		}
+		if (!childCompletionFindings) {
+			const fallbackReply = failedTerminalOutcome ? void 0 : normalizeOptionalString(params.fallbackReply);
+			const fallbackIsSilent = Boolean(fallbackReply) && (isAnnounceSkip(fallbackReply) || isSilentReplyText(fallbackReply, "NO_REPLY"));
+			if (!reply && allowFailedOutputCapture) reply = await readSubagentOutput(params.childSessionKey, outcome);
+			if (!reply?.trim() && allowFailedOutputCapture) reply = await readLatestSubagentOutputWithRetry({
+				sessionKey: params.childSessionKey,
+				maxWaitMs: params.timeoutMs,
+				outcome
+			});
+			if (!reply?.trim() && fallbackReply && !fallbackIsSilent) reply = fallbackReply;
+			if (outcome?.status === "timeout" && reply?.trim() && params.waitForCompletion !== false) try {
+				const applied = applySubagentWaitOutcome({
+					wait: await waitForSubagentRunOutcome(params.childRunId, 0),
+					outcome,
+					startedAt: params.startedAt,
+					endedAt: params.endedAt
+				});
+				outcome = applied.outcome;
+				params.startedAt = applied.startedAt;
+				params.endedAt = applied.endedAt;
+			} catch {}
+			if (isAnnounceSkip(reply) || isSilentReplyText(reply, "NO_REPLY")) if (fallbackReply && !fallbackIsSilent) {
+				const cleaned = stripAndClassifyReply(fallbackReply);
+				if (cleaned === null) return true;
+				reply = cleaned;
+			} else return true;
+			else if (reply) {
+				const cleaned = stripAndClassifyReply(reply);
+				if (cleaned === null) if (fallbackReply && !fallbackIsSilent) {
+					const cleanedFallback = stripAndClassifyReply(fallbackReply);
+					if (cleanedFallback === null) return true;
+					reply = cleanedFallback;
+				} else return true;
+				else reply = cleaned;
+			}
+		}
+		if (!outcome) outcome = { status: "unknown" };
+		const statusLabel = outcome.status === "ok" ? "completed successfully" : outcome.status === "timeout" ? "timed out" : outcome.status === "error" ? `failed: ${outcome.error || "unknown error"}` : "finished with unknown status";
+		const taskLabel = params.label || params.task || "task";
+		const announceSessionId = childSessionId || "unknown";
+		const findings = childCompletionFindings || reply || "(no output)";
+		let requesterIsSubagent = requesterIsInternalSession();
+		if (requesterIsSubagent) {
+			const { isSubagentSessionRunActive, resolveRequesterForChildSession, shouldIgnorePostCompletionAnnounceForSession } = subagentRegistryRuntime ?? await loadSubagentRegistryRuntime();
+			if (!isSubagentSessionRunActive(targetRequesterSessionKey)) {
+				if (shouldIgnorePostCompletionAnnounceForSession(targetRequesterSessionKey)) return true;
+				if (!hasUsableSessionEntry(loadSessionEntryByKey(targetRequesterSessionKey))) {
+					const fallback = resolveRequesterForChildSession(targetRequesterSessionKey);
+					if (!fallback?.requesterSessionKey) {
+						shouldDeleteChildSession = false;
+						return false;
+					}
+					targetRequesterSessionKey = fallback.requesterSessionKey;
+					targetRequesterOrigin = normalizeDeliveryContext(fallback.requesterOrigin) ?? targetRequesterOrigin;
+					requesterDepth = getSubagentDepthFromSessionStore(targetRequesterSessionKey);
+					requesterIsSubagent = requesterIsInternalSession();
+				}
+			}
+		}
+		const replyInstruction = buildAnnounceReplyInstruction({
+			requesterIsSubagent,
+			announceType,
+			expectsCompletionMessage
+		});
+		const statsLine = await buildCompactAnnounceStatsLine({
+			sessionKey: params.childSessionKey,
+			startedAt: params.startedAt,
+			endedAt: params.endedAt
+		});
+		const internalEvents = [{
+			type: "task_completion",
+			source: announceType === "cron job" ? "cron" : "subagent",
+			childSessionKey: params.childSessionKey,
+			childSessionId: announceSessionId,
+			announceType,
+			taskLabel,
+			status: outcome.status,
+			statusLabel,
+			result: findings,
+			statsLine,
+			replyInstruction
+		}];
+		const triggerMessage = buildAnnounceSteerMessage(internalEvents);
+		let directOrigin = targetRequesterOrigin;
+		if (!requesterIsSubagent) {
+			const { entry } = loadRequesterSessionEntry(targetRequesterSessionKey);
+			directOrigin = resolveAnnounceOrigin(entry, targetRequesterOrigin);
+		}
+		const completionDirectOrigin = expectsCompletionMessage && !requesterIsSubagent ? await resolveSubagentCompletionOrigin({
+			childSessionKey: params.childSessionKey,
+			requesterSessionKey: targetRequesterSessionKey,
+			requesterOrigin: directOrigin,
+			childRunId: params.childRunId,
+			spawnMode: params.spawnMode,
+			expectsCompletionMessage
+		}) : targetRequesterOrigin;
+		const directIdempotencyKey = buildAnnounceIdempotencyKey(announceId);
+		const delivery = await deliverSubagentAnnouncement({
+			requesterSessionKey: targetRequesterSessionKey,
+			announceId,
+			triggerMessage,
+			steerMessage: triggerMessage,
+			internalEvents,
+			summaryLine: taskLabel,
+			requesterSessionOrigin: targetRequesterOrigin,
+			requesterOrigin: expectsCompletionMessage && !requesterIsSubagent ? completionDirectOrigin : targetRequesterOrigin,
+			completionDirectOrigin,
+			directOrigin,
+			sourceSessionKey: params.childSessionKey,
+			sourceChannel: INTERNAL_MESSAGE_CHANNEL,
+			sourceTool: "subagent_announce",
+			targetRequesterSessionKey,
+			requesterIsSubagent,
+			expectsCompletionMessage,
+			bestEffortDeliver: params.bestEffortDeliver,
+			directIdempotencyKey,
+			signal: params.signal
+		});
+		didAnnounce = delivery.delivered;
+		if (!delivery.delivered && delivery.path === "direct" && delivery.error) defaultRuntime.error?.(`Subagent completion direct announce failed for run ${params.childRunId}: ${delivery.error}`);
+	} catch (err) {
+		defaultRuntime.error?.(`Subagent announce failed: ${String(err)}`);
+	} finally {
+		if (params.label) try {
+			await subagentAnnounceDeps.callGateway({
+				method: "sessions.patch",
+				params: {
+					key: params.childSessionKey,
+					label: params.label
+				},
+				timeoutMs: 1e4
+			});
+		} catch {}
+		if (shouldDeleteChildSession) try {
+			await subagentAnnounceDeps.callGateway({
+				method: "sessions.delete",
+				params: {
+					key: params.childSessionKey,
+					deleteTranscript: true,
+					emitLifecycleHooks: params.spawnMode === "session"
+				},
+				timeoutMs: 1e4
+			});
+		} catch {}
+	}
+	return didAnnounce;
+}
+const __testing = { setDepsForTest(overrides) {
+	subagentAnnounceDeps = overrides ? {
+		...defaultSubagentAnnounceDeps,
+		...overrides
+	} : defaultSubagentAnnounceDeps;
+} };
+//#endregion
+export { __testing, buildSubagentSystemPrompt, captureSubagentCompletionReply, runSubagentAnnounceFlow };