@gaodefa/daocore 2026.5.74 → 2026.5.75

package/dist/sticker-cache-CyXfXSnD.js

@@ -0,0 +1,206 @@
+import { a as normalizeLowercaseStringOrEmpty } from "./string-coerce-DyL154ka.js";
+import { v as resolveStateDir } from "./paths-ZwPDM6zn.js";
+import { r as logVerbose } from "./globals-DhGeOA1P.js";
+import { C as findModelInCatalog } from "./model-selection-shared-BZqZE4Cv.js";
+import { s as resolveDefaultModelForAgent } from "./model-selection-CGiHa_L6.js";
+import { i as modelSupportsVision, n as loadModelCatalog } from "./model-catalog-BOACK0i0.js";
+import { r as saveJsonFile, t as loadJsonFile } from "./json-store-GaAZLixM.js";
+import { u as resolveApiKeyForProvider } from "./model-auth-C3y3XLEi.js";
+import { n as resolveAutoMediaKeyProviders, r as resolveDefaultMediaModel } from "./defaults--eGW7xm6.js";
+import { r as resolveAutoImageModel } from "./runner-BVacSOsz.js";
+import "./runtime-env-BSECk1Nm.js";
+import "./string-coerce-runtime-DcopKqDR.js";
+import "./state-paths-C63v_0Tp.js";
+import "./media-runtime-BII00FWc.js";
+import "./agent-runtime-DDBYT9PU.js";
+import { t as getTelegramRuntime } from "./runtime-D-PBTM2d.js";
+import path from "node:path";
+//#region extensions/telegram/src/sticker-cache-store.ts
+const CACHE_VERSION = 1;
+function getCacheFile() {
+	return path.join(resolveStateDir(), "telegram", "sticker-cache.json");
+}
+function loadCache() {
+	const data = loadJsonFile(getCacheFile());
+	if (!data || typeof data !== "object") return {
+		version: CACHE_VERSION,
+		stickers: {}
+	};
+	const cache = data;
+	if (cache.version !== CACHE_VERSION) return {
+		version: CACHE_VERSION,
+		stickers: {}
+	};
+	return cache;
+}
+function saveCache(cache) {
+	saveJsonFile(getCacheFile(), cache);
+}
+function normalizeStickerSearchText(value) {
+	return typeof value === "string" ? value.trim().toLowerCase() : "";
+}
+/**
+* Get a cached sticker by its unique ID.
+*/
+function getCachedSticker(fileUniqueId) {
+	return loadCache().stickers[fileUniqueId] ?? null;
+}
+/**
+* Add or update a sticker in the cache.
+*/
+function cacheSticker(sticker) {
+	const cache = loadCache();
+	cache.stickers[sticker.fileUniqueId] = sticker;
+	saveCache(cache);
+}
+/**
+* Search cached stickers by text query (fuzzy match on description + emoji + setName).
+*/
+function searchStickers(query, limit = 10) {
+	const cache = loadCache();
+	const queryLower = normalizeStickerSearchText(query);
+	const results = [];
+	for (const sticker of Object.values(cache.stickers)) {
+		let score = 0;
+		const descLower = normalizeStickerSearchText(sticker.description);
+		if (descLower.includes(queryLower)) score += 10;
+		const queryWords = queryLower.split(/\s+/).filter(Boolean);
+		const descWords = descLower.split(/\s+/);
+		for (const qWord of queryWords) if (descWords.some((dWord) => dWord.includes(qWord))) score += 5;
+		if (sticker.emoji && query.includes(sticker.emoji)) score += 8;
+		if (normalizeStickerSearchText(sticker.setName).includes(queryLower)) score += 3;
+		if (score > 0) results.push({
+			sticker,
+			score
+		});
+	}
+	return results.toSorted((a, b) => b.score - a.score).slice(0, limit).map((r) => r.sticker);
+}
+/**
+* Get all cached stickers (for debugging/listing).
+*/
+function getAllCachedStickers() {
+	const cache = loadCache();
+	return Object.values(cache.stickers);
+}
+/**
+* Get cache statistics.
+*/
+function getCacheStats() {
+	const cache = loadCache();
+	const stickers = Object.values(cache.stickers);
+	if (stickers.length === 0) return { count: 0 };
+	const sorted = [...stickers].toSorted((a, b) => new Date(a.cachedAt).getTime() - new Date(b.cachedAt).getTime());
+	return {
+		count: stickers.length,
+		oldestAt: sorted[0]?.cachedAt,
+		newestAt: sorted[sorted.length - 1]?.cachedAt
+	};
+}
+//#endregion
+//#region extensions/telegram/src/sticker-cache.ts
+const STICKER_DESCRIPTION_PROMPT = "Describe this sticker image in 1-2 sentences. Focus on what the sticker depicts (character, object, action, emotion). Be concise and objective.";
+function isMinimaxVlmProvider(provider) {
+	const normalized = normalizeLowercaseStringOrEmpty(provider);
+	return normalized === "minimax" || normalized === "minimax-cn" || normalized === "minimax-portal" || normalized === "minimax-portal-cn";
+}
+/**
+* Describe a sticker image using vision API.
+* Auto-detects an available vision provider based on configured API keys.
+* Returns null if no vision provider is available.
+*/
+async function describeStickerImage(params) {
+	const { imagePath, cfg, agentDir, agentId } = params;
+	const defaultModel = resolveDefaultModelForAgent({
+		cfg,
+		agentId
+	});
+	let activeModel = void 0;
+	let catalog = [];
+	try {
+		catalog = await loadModelCatalog({ config: cfg });
+		if (modelSupportsVision(findModelInCatalog(catalog, defaultModel.provider, defaultModel.model))) {
+			const model = isMinimaxVlmProvider(defaultModel.provider) ? resolveDefaultMediaModel({
+				cfg,
+				providerId: defaultModel.provider,
+				capability: "image",
+				includeConfiguredImageModels: false
+			}) : defaultModel.model;
+			if (model) activeModel = {
+				provider: defaultModel.provider,
+				model
+			};
+		}
+	} catch {}
+	const hasProviderKey = async (provider) => {
+		try {
+			await resolveApiKeyForProvider({
+				provider,
+				cfg,
+				agentDir
+			});
+			return true;
+		} catch {
+			return false;
+		}
+	};
+	const autoProviders = resolveAutoMediaKeyProviders({
+		cfg,
+		capability: "image"
+	});
+	const selectCatalogModel = (provider) => {
+		const entries = catalog.filter((entry) => normalizeLowercaseStringOrEmpty(entry.provider) === normalizeLowercaseStringOrEmpty(provider) && modelSupportsVision(entry));
+		if (entries.length === 0) return;
+		const defaultId = resolveDefaultMediaModel({
+			cfg,
+			providerId: provider,
+			capability: "image",
+			includeConfiguredImageModels: !isMinimaxVlmProvider(provider)
+		});
+		const preferred = entries.find((entry) => entry.id === defaultId);
+		if (isMinimaxVlmProvider(provider)) return preferred;
+		return preferred ?? entries[0];
+	};
+	let resolved = null;
+	if (activeModel && autoProviders.includes(activeModel.provider) && await hasProviderKey(activeModel.provider)) resolved = activeModel;
+	if (!resolved) for (const provider of autoProviders) {
+		if (!await hasProviderKey(provider)) continue;
+		const entry = selectCatalogModel(provider);
+		if (entry) {
+			resolved = {
+				provider,
+				model: entry.id
+			};
+			break;
+		}
+	}
+	if (!resolved) resolved = await resolveAutoImageModel({
+		cfg,
+		agentDir,
+		activeModel
+	});
+	if (!resolved?.model) {
+		logVerbose("telegram: no vision provider available for sticker description");
+		return null;
+	}
+	const { provider, model } = resolved;
+	logVerbose(`telegram: describing sticker with ${provider}/${model}`);
+	try {
+		return (await getTelegramRuntime().mediaUnderstanding.describeImageFileWithModel({
+			filePath: imagePath,
+			mime: "image/webp",
+			cfg,
+			agentDir,
+			provider,
+			model,
+			prompt: STICKER_DESCRIPTION_PROMPT,
+			maxTokens: 150,
+			timeoutMs: 3e4
+		})).text ?? null;
+	} catch (err) {
+		logVerbose(`telegram: failed to describe sticker: ${String(err)}`);
+		return null;
+	}
+}
+//#endregion
+export { getCachedSticker as a, getCacheStats as i, cacheSticker as n, searchStickers as o, getAllCachedStickers as r, describeStickerImage as t };

package/dist/sticker-vision.runtime-CfEwepme.js

@@ -0,0 +1,17 @@
+import { C as findModelInCatalog } from "./model-selection-shared-BZqZE4Cv.js";
+import { s as resolveDefaultModelForAgent } from "./model-selection-CGiHa_L6.js";
+import { i as modelSupportsVision, n as loadModelCatalog } from "./model-catalog-BOACK0i0.js";
+import "./agent-runtime-DDBYT9PU.js";
+//#region extensions/telegram/src/sticker-vision.runtime.ts
+async function resolveStickerVisionSupportRuntime(params) {
+	const catalog = await loadModelCatalog({ config: params.cfg });
+	const defaultModel = resolveDefaultModelForAgent({
+		cfg: params.cfg,
+		agentId: params.agentId
+	});
+	const entry = findModelInCatalog(catalog, defaultModel.provider, defaultModel.model);
+	if (!entry) return false;
+	return modelSupportsVision(entry);
+}
+//#endregion
+export { resolveStickerVisionSupportRuntime };

package/dist/sticker-vision.runtime.js

@@ -1 +1 @@
-export * from "./sticker-vision.runtime-Ba4krDPo.js";
+export * from "./sticker-vision.runtime-CfEwepme.js";

package/dist/subagent-announce-DJP9Deag.js

@@ -0,0 +1,354 @@
+import { c as normalizeOptionalString } from "./string-coerce-DyL154ka.js";
+import { t as createLazyImportLoader } from "./lazy-promise-Djskx0qC.js";
+import { i as isCronSessionKey } from "./session-key-utils-Ce_xWkNq.js";
+import { n as defaultRuntime } from "./runtime-E_A14BX_.js";
+import { i as getRuntimeConfig } from "./io-Dlv1CClM.js";
+import { r as INTERNAL_MESSAGE_CHANNEL } from "./message-channel-core-C7o0LP7q.js";
+import "./message-channel-CRza_Xs_.js";
+import { r as callGateway } from "./call-D7vSTwli.js";
+import { o as normalizeDeliveryContext } from "./delivery-context.shared-XybGGRNt.js";
+import { _ as waitForEmbeddedPiRunEnd, o as isEmbeddedPiRunActive } from "./runs-fQuppCK3.js";
+import { a as isSilentReplyText, c as stripSilentToken, n as SILENT_REPLY_TOKEN, o as startsWithSilentToken, s as stripLeadingSilentToken } from "./tokens-D8MVQSp9.js";
+import { s as getSubagentDepthFromSessionStore } from "./subagent-capabilities-BMqbhhvL.js";
+import { a as resolveSubagentAnnounceTimeoutMs, i as loadSessionEntryByKey, o as resolveSubagentCompletionOrigin, r as loadRequesterSessionEntry, s as runAnnounceDeliveryWithRetry, t as deliverSubagentAnnouncement } from "./subagent-announce-delivery-djkdPFWz.js";
+import "./delivery-context-BNG7Sxrb.js";
+import { n as formatAgentInternalEventsForPrompt } from "./internal-events-Gz1ipxmh.js";
+import { r as dispatchGatewayMethodInProcess } from "./server-plugins-BZIW7Sn8.js";
+import { a as captureSubagentCompletionReply, c as readLatestSubagentOutputWithRetry, h as isAnnounceSkip, i as buildCompactAnnounceStatsLine, l as readSubagentOutput, n as applySubagentWaitOutcome, o as dedupeLatestChildCompletionRows, r as buildChildCompletionFindings, s as filterCurrentDirectChildCompletionRows, t as deleteSubagentSessionForCleanup, u as waitForSubagentRunOutcome } from "./subagent-session-cleanup-DStloUoa.js";
+import { n as buildAnnounceIdempotencyKey, t as buildAnnounceIdFromChildRun } from "./announce-idempotency-DV6_8Blm.js";
+import { t as buildSubagentSystemPrompt } from "./subagent-system-prompt-BLz6FT3v.js";
+import { t as resolveAnnounceOrigin } from "./subagent-announce-origin-CB1tkSD0.js";
+//#region src/agents/subagent-announce.ts
+const defaultSubagentAnnounceDeps = {
+	callGateway,
+	dispatchGatewayMethodInProcess,
+	getRuntimeConfig,
+	loadSubagentRegistryRuntime
+};
+let subagentAnnounceDeps = defaultSubagentAnnounceDeps;
+const subagentRegistryRuntimeLoader = createLazyImportLoader(() => import("./subagent-announce.registry.runtime.js"));
+function loadSubagentRegistryRuntime() {
+	return subagentRegistryRuntimeLoader.load();
+}
+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 parent review. Review/verify the result above before deciding whether the original task is done. If additional action is required, continue the task or record a follow-up; otherwise send a truthful user-facing update. If the runtime marks this route as message-tool-only, send visible output with the message tool first, then reply ONLY: ${SILENT_REPLY_TOKEN}. Keep this internal context private (don't mention system/log/stats/session details or announce type).`;
+	return `A completed ${params.announceType} is ready for parent review. Review/verify the result above before deciding whether the original task is done. If additional action is required, continue the task or record a follow-up; otherwise send a truthful user-facing update. 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.getRuntimeConfig());
+	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.dispatchGatewayMethodInProcess("agent", {
+				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; ready for parent review" : 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
+		});
+		params.onDeliveryResult?.(delivery);
+		didAnnounce = delivery.delivered;
+		if (!delivery.delivered && delivery.path === "direct" && delivery.error) defaultRuntime.log(`[warn] 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) await deleteSubagentSessionForCleanup({
+			callGateway: subagentAnnounceDeps.callGateway,
+			childSessionKey: params.childSessionKey,
+			spawnMode: params.spawnMode
+		});
+	}
+	return didAnnounce;
+}
+const testing = { setDepsForTest(overrides) {
+	const callGatewayOverride = overrides?.callGateway;
+	const dispatchGatewayMethodInProcessOverride = overrides?.dispatchGatewayMethodInProcess ?? (callGatewayOverride ? (async (method, agentParams, options) => await callGatewayOverride({
+		method,
+		params: agentParams,
+		expectFinal: options?.expectFinal,
+		timeoutMs: options?.timeoutMs
+	})) : void 0);
+	subagentAnnounceDeps = overrides ? {
+		...defaultSubagentAnnounceDeps,
+		...overrides,
+		...dispatchGatewayMethodInProcessOverride ? { dispatchGatewayMethodInProcess: dispatchGatewayMethodInProcessOverride } : {}
+	} : defaultSubagentAnnounceDeps;
+} };
+//#endregion
+export { testing as __testing, testing, buildSubagentSystemPrompt, captureSubagentCompletionReply, runSubagentAnnounceFlow };