@vibe-lark/larkpal 0.1.85 → 0.1.86

package/dist/subagent-announce-L5WsQatW-CQWI9GMd.mjs

@@ -0,0 +1,344 @@
+import { c as normalizeOptionalString } from "./home-dir-C44RaPME-CBRS4HLP.mjs";
+import { C as SILENT_REPLY_TOKEN, D as stripLeadingSilentToken, E as startsWithSilentToken, O as stripSilentToken, T as isSilentReplyText, n as getSubagentDepthFromSessionStore } from "./target-parsing-loaded-DKkb6jJY-BMD4CkpS.mjs";
+import { n as loadConfig } from "./io-CH2g3vsv-BOGlLlB8.mjs";
+import { C as isEmbeddedPiRunActive, T as formatAgentInternalEventsForPrompt, _ as isAnnounceSkip, a as loadRequesterSessionEntry, b as waitForSubagentRunOutcome, c as resolveSubagentAnnounceTimeoutMs, d as applySubagentWaitOutcome, f as buildChildCompletionFindings, g as filterCurrentDirectChildCompletionRows, h as dedupeLatestChildCompletionRows, i as deliverSubagentAnnouncement, l as resolveSubagentCompletionOrigin, m as captureSubagentCompletionReply, n as buildAnnounceIdFromChildRun, o as loadSessionEntryByKey, p as buildCompactAnnounceStatsLine, r as buildAnnounceIdempotencyKey, s as resolveAnnounceOrigin, t as buildSubagentSystemPrompt, u as runAnnounceDeliveryWithRetry, v as readLatestSubagentOutputWithRetry, w as waitForEmbeddedPiRunEnd, y as readSubagentOutput } from "./subagent-system-prompt-C1qnN--K-DpnTFP47.mjs";
+import { t as INTERNAL_MESSAGE_CHANNEL } from "./message-channel-core-DTA--Gjh-CY4Tkb7N.mjs";
+import "./message-channel-Bk_YHfQg-AeNrPPpp.mjs";
+import { P as defaultRuntime } from "./manifest-registry-_hxKCS2K-CZdeyN0f.mjs";
+import { r as isCronSessionKey } from "./session-key-Cn2QoOyX-CuHbJMgR.mjs";
+import { r as normalizeDeliveryContext } from "./delivery-context.shared-j5hC5qb1-CI83RXXZ.mjs";
+import { t as callGateway } from "./call-DimWbpgJ-ColD4W-y.mjs";
+//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/subagent-announce-L5WsQatW.js
+const defaultSubagentAnnounceDeps = {
+	callGateway,
+	loadConfig,
+	loadSubagentRegistryRuntime
+};
+let subagentAnnounceDeps = defaultSubagentAnnounceDeps;
+let subagentRegistryRuntimePromise = null;
+function loadSubagentRegistryRuntime() {
+	subagentRegistryRuntimePromise ??= import("./subagent-announce.registry.runtime-DiqZyeTs-BKuniyi3.mjs");
+	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";
+		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 && !failedTerminalOutcome) {
+			const fallbackReply = normalizeOptionalString(params.fallbackReply);
+			const fallbackIsSilent = Boolean(fallbackReply) && (isAnnounceSkip(fallbackReply) || isSilentReplyText(fallbackReply, "NO_REPLY"));
+			if (!reply) reply = await readSubagentOutput(params.childSessionKey, outcome);
+			if (!reply?.trim()) 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 };

package/dist/subagent-announce.registry.runtime-DiqZyeTs-BKuniyi3.mjs

@@ -0,0 +1,28 @@
+import { r as normalizeDeliveryContext } from "./delivery-context.shared-j5hC5qb1-CI83RXXZ.mjs";
+import { a as countPendingDescendantRunsExcludingRunFromRuns, c as isSubagentSessionRunActiveFromRuns, d as resolveRequesterForChildSessionFromRuns, i as getLatestSubagentRunByChildSessionKey, l as listRunsForRequesterFromRuns, m as subagentRuns, n as replaceSubagentRunAfterSteer, o as countPendingDescendantRunsFromRuns, p as shouldIgnorePostCompletionAnnounceForSessionFromRuns, r as countActiveDescendantRuns, s as getSubagentRunsSnapshotForRead } from "./subagent-registry-steer-runtime-DFgZFC0j-BhBz0roy.mjs";
+//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/subagent-announce.registry.runtime-DiqZyeTs.js
+function resolveRequesterForChildSession(childSessionKey) {
+	const resolved = resolveRequesterForChildSessionFromRuns(getSubagentRunsSnapshotForRead(subagentRuns), childSessionKey);
+	if (!resolved) return null;
+	return {
+		requesterSessionKey: resolved.requesterSessionKey,
+		requesterOrigin: normalizeDeliveryContext(resolved.requesterOrigin)
+	};
+}
+function isSubagentSessionRunActive(childSessionKey) {
+	return isSubagentSessionRunActiveFromRuns(subagentRuns, childSessionKey);
+}
+function shouldIgnorePostCompletionAnnounceForSession(childSessionKey) {
+	return shouldIgnorePostCompletionAnnounceForSessionFromRuns(getSubagentRunsSnapshotForRead(subagentRuns), childSessionKey);
+}
+function listSubagentRunsForRequester(requesterSessionKey, options) {
+	return listRunsForRequesterFromRuns(subagentRuns, requesterSessionKey, options);
+}
+function countPendingDescendantRuns(rootSessionKey) {
+	return countPendingDescendantRunsFromRuns(getSubagentRunsSnapshotForRead(subagentRuns), rootSessionKey);
+}
+function countPendingDescendantRunsExcludingRun(rootSessionKey, excludeRunId) {
+	return countPendingDescendantRunsExcludingRunFromRuns(getSubagentRunsSnapshotForRead(subagentRuns), rootSessionKey, excludeRunId);
+}
+//#endregion
+export { countActiveDescendantRuns, countPendingDescendantRuns, countPendingDescendantRunsExcludingRun, getLatestSubagentRunByChildSessionKey, isSubagentSessionRunActive, listSubagentRunsForRequester, replaceSubagentRunAfterSteer, resolveRequesterForChildSession, shouldIgnorePostCompletionAnnounceForSession };

package/dist/subagent-registry-steer-runtime-DFgZFC0j-BhBz0roy.mjs

@@ -0,0 +1,211 @@
+import { d as readStringValue } from "./home-dir-C44RaPME-CBRS4HLP.mjs";
+import { o as resolveStateDir } from "./paths-D92DjaZ--CTOESW2b.mjs";
+import { r as normalizeDeliveryContext } from "./delivery-context.shared-j5hC5qb1-CI83RXXZ.mjs";
+import { n as saveJsonFile, t as loadJsonFile } from "./json-file-BQRNuxmK-DhJM5NsG.mjs";
+import path from "node:path";
+import os from "node:os";
+//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/subagent-registry-state-ByShCGTk.js
+const subagentRuns = /* @__PURE__ */ new Map();
+function listRunsForRequesterFromRuns(runs, requesterSessionKey, options) {
+	const key = requesterSessionKey.trim();
+	if (!key) return [];
+	const requesterRunId = options?.requesterRunId?.trim();
+	const requesterRun = requesterRunId ? runs.get(requesterRunId) : void 0;
+	const requesterRunMatchesScope = requesterRun && requesterRun.childSessionKey === key ? requesterRun : void 0;
+	const lowerBound = requesterRunMatchesScope?.startedAt ?? requesterRunMatchesScope?.createdAt;
+	const upperBound = requesterRunMatchesScope?.endedAt;
+	return [...runs.values()].filter((entry) => {
+		if (entry.requesterSessionKey !== key) return false;
+		if (typeof lowerBound === "number" && entry.createdAt < lowerBound) return false;
+		if (typeof upperBound === "number" && entry.createdAt > upperBound) return false;
+		return true;
+	});
+}
+function findLatestRunForChildSession(runs, childSessionKey) {
+	const key = childSessionKey.trim();
+	if (!key) return;
+	let latest;
+	for (const entry of runs.values()) {
+		if (entry.childSessionKey !== key) continue;
+		if (!latest || entry.createdAt > latest.createdAt) latest = entry;
+	}
+	return latest;
+}
+function isSubagentSessionRunActiveFromRuns(runs, childSessionKey) {
+	const latest = findLatestRunForChildSession(runs, childSessionKey);
+	return Boolean(latest && typeof latest.endedAt !== "number");
+}
+function resolveRequesterForChildSessionFromRuns(runs, childSessionKey) {
+	const latest = findLatestRunForChildSession(runs, childSessionKey);
+	if (!latest) return null;
+	return {
+		requesterSessionKey: latest.requesterSessionKey,
+		requesterOrigin: latest.requesterOrigin
+	};
+}
+function shouldIgnorePostCompletionAnnounceForSessionFromRuns(runs, childSessionKey) {
+	const latest = findLatestRunForChildSession(runs, childSessionKey);
+	return Boolean(latest && latest.spawnMode !== "session" && typeof latest.endedAt === "number" && typeof latest.cleanupCompletedAt === "number" && latest.cleanupCompletedAt >= latest.endedAt);
+}
+function forEachDescendantRun(runs, rootSessionKey, visitor) {
+	const root = rootSessionKey.trim();
+	if (!root) return false;
+	const pending = [root];
+	const visited = new Set([root]);
+	for (let index = 0; index < pending.length; index += 1) {
+		const requester = pending[index];
+		if (!requester) continue;
+		const latestByChildSessionKey = /* @__PURE__ */ new Map();
+		for (const [runId, entry] of runs.entries()) {
+			if (entry.requesterSessionKey !== requester) continue;
+			const childKey = entry.childSessionKey.trim();
+			const existing = latestByChildSessionKey.get(childKey);
+			if (!existing || entry.createdAt > existing[1].createdAt) latestByChildSessionKey.set(childKey, [runId, entry]);
+		}
+		for (const [runId, entry] of latestByChildSessionKey.values()) {
+			const latestForChildSession = findLatestRunForChildSession(runs, entry.childSessionKey);
+			if (!latestForChildSession || latestForChildSession.runId !== runId || latestForChildSession.requesterSessionKey !== requester) continue;
+			visitor(runId, entry);
+			const childKey = entry.childSessionKey.trim();
+			if (!childKey || visited.has(childKey)) continue;
+			visited.add(childKey);
+			pending.push(childKey);
+		}
+	}
+	return true;
+}
+function countActiveDescendantRunsFromRuns(runs, rootSessionKey) {
+	let count = 0;
+	if (!forEachDescendantRun(runs, rootSessionKey, (_runId, entry) => {
+		if (typeof entry.endedAt !== "number") count += 1;
+	})) return 0;
+	return count;
+}
+function countPendingDescendantRunsInternal(runs, rootSessionKey, excludeRunId) {
+	const excludedRunId = excludeRunId?.trim();
+	let count = 0;
+	if (!forEachDescendantRun(runs, rootSessionKey, (runId, entry) => {
+		const runEnded = typeof entry.endedAt === "number";
+		const cleanupCompleted = typeof entry.cleanupCompletedAt === "number";
+		if ((!runEnded || !cleanupCompleted) && runId !== excludedRunId) count += 1;
+	})) return 0;
+	return count;
+}
+function countPendingDescendantRunsFromRuns(runs, rootSessionKey) {
+	return countPendingDescendantRunsInternal(runs, rootSessionKey);
+}
+function countPendingDescendantRunsExcludingRunFromRuns(runs, rootSessionKey, excludeRunId) {
+	return countPendingDescendantRunsInternal(runs, rootSessionKey, excludeRunId);
+}
+const REGISTRY_VERSION = 2;
+function resolveSubagentStateDir(env = process.env) {
+	if (env.OPENCLAW_STATE_DIR?.trim()) return resolveStateDir(env);
+	if (env.VITEST || env.NODE_ENV === "test") return path.join(os.tmpdir(), "openclaw-test-state", String(process.pid));
+	return resolveStateDir(env);
+}
+function resolveSubagentRegistryPath() {
+	return path.join(resolveSubagentStateDir(process.env), "subagents", "runs.json");
+}
+function loadSubagentRegistryFromDisk() {
+	const raw = loadJsonFile(resolveSubagentRegistryPath());
+	if (!raw || typeof raw !== "object") return /* @__PURE__ */ new Map();
+	const record = raw;
+	if (record.version !== 1 && record.version !== 2) return /* @__PURE__ */ new Map();
+	const runsRaw = record.runs;
+	if (!runsRaw || typeof runsRaw !== "object") return /* @__PURE__ */ new Map();
+	const out = /* @__PURE__ */ new Map();
+	const isLegacy = record.version === 1;
+	let migrated = false;
+	for (const [runId, entry] of Object.entries(runsRaw)) {
+		if (!entry || typeof entry !== "object") continue;
+		const typed = entry;
+		if (!typed.runId || typeof typed.runId !== "string") continue;
+		const legacyCompletedAt = isLegacy && typeof typed.announceCompletedAt === "number" ? typed.announceCompletedAt : void 0;
+		const cleanupCompletedAt = typeof typed.cleanupCompletedAt === "number" ? typed.cleanupCompletedAt : legacyCompletedAt;
+		const cleanupHandled = typeof typed.cleanupHandled === "boolean" ? typed.cleanupHandled : isLegacy ? Boolean(typed.announceHandled ?? cleanupCompletedAt) : void 0;
+		const requesterOrigin = normalizeDeliveryContext(typed.requesterOrigin ?? {
+			channel: readStringValue(typed.requesterChannel),
+			accountId: readStringValue(typed.requesterAccountId)
+		});
+		const childSessionKey = readStringValue(typed.childSessionKey)?.trim() ?? "";
+		const requesterSessionKey = readStringValue(typed.requesterSessionKey)?.trim() ?? "";
+		const controllerSessionKey = readStringValue(typed.controllerSessionKey)?.trim() || requesterSessionKey;
+		if (!childSessionKey || !requesterSessionKey) continue;
+		const { announceCompletedAt: _announceCompletedAt, announceHandled: _announceHandled, requesterChannel: _channel, requesterAccountId: _accountId, ...rest } = typed;
+		out.set(runId, {
+			...rest,
+			childSessionKey,
+			requesterSessionKey,
+			controllerSessionKey,
+			requesterOrigin,
+			cleanupCompletedAt,
+			cleanupHandled,
+			spawnMode: typed.spawnMode === "session" ? "session" : "run"
+		});
+		if (isLegacy) migrated = true;
+	}
+	if (migrated) try {
+		saveSubagentRegistryToDisk(out);
+	} catch {}
+	return out;
+}
+function saveSubagentRegistryToDisk(runs) {
+	const pathname = resolveSubagentRegistryPath();
+	const serialized = {};
+	for (const [runId, entry] of runs.entries()) serialized[runId] = entry;
+	saveJsonFile(pathname, {
+		version: REGISTRY_VERSION,
+		runs: serialized
+	});
+}
+function persistSubagentRunsToDisk(runs) {
+	try {
+		saveSubagentRegistryToDisk(runs);
+	} catch {}
+}
+function restoreSubagentRunsFromDisk(params) {
+	const restored = loadSubagentRegistryFromDisk();
+	if (restored.size === 0) return 0;
+	let added = 0;
+	for (const [runId, entry] of restored.entries()) {
+		if (!runId || !entry) continue;
+		if (params.mergeOnly && params.runs.has(runId)) continue;
+		params.runs.set(runId, entry);
+		added += 1;
+	}
+	return added;
+}
+function getSubagentRunsSnapshotForRead(inMemoryRuns) {
+	const merged = /* @__PURE__ */ new Map();
+	if (process.env.OPENCLAW_TEST_READ_SUBAGENT_RUNS_FROM_DISK === "1" || !(process.env.VITEST || false)) try {
+		for (const [runId, entry] of loadSubagentRegistryFromDisk().entries()) merged.set(runId, entry);
+	} catch {}
+	for (const [runId, entry] of inMemoryRuns.entries()) merged.set(runId, entry);
+	return merged;
+}
+//#endregion
+//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/subagent-registry-read-D7OQcNDJ.js
+function countActiveDescendantRuns(rootSessionKey) {
+	return countActiveDescendantRunsFromRuns(getSubagentRunsSnapshotForRead(subagentRuns), rootSessionKey);
+}
+function getLatestSubagentRunByChildSessionKey(childSessionKey) {
+	const key = childSessionKey.trim();
+	if (!key) return null;
+	let latest = null;
+	for (const entry of getSubagentRunsSnapshotForRead(subagentRuns).values()) {
+		if (entry.childSessionKey !== key) continue;
+		if (!latest || entry.createdAt > latest.createdAt) latest = entry;
+	}
+	return latest;
+}
+//#endregion
+//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/subagent-registry-steer-runtime-DFgZFC0j.js
+let replaceSubagentRunAfterSteerImpl = null;
+function configureSubagentRegistrySteerRuntime(params) {
+	replaceSubagentRunAfterSteerImpl = params.replaceSubagentRunAfterSteer;
+}
+function replaceSubagentRunAfterSteer(params) {
+	return replaceSubagentRunAfterSteerImpl?.(params) ?? false;
+}
+//#endregion
+export { countPendingDescendantRunsExcludingRunFromRuns as a, isSubagentSessionRunActiveFromRuns as c, resolveRequesterForChildSessionFromRuns as d, restoreSubagentRunsFromDisk as f, getLatestSubagentRunByChildSessionKey as i, listRunsForRequesterFromRuns as l, subagentRuns as m, replaceSubagentRunAfterSteer as n, countPendingDescendantRunsFromRuns as o, shouldIgnorePostCompletionAnnounceForSessionFromRuns as p, countActiveDescendantRuns as r, getSubagentRunsSnapshotForRead as s, configureSubagentRegistrySteerRuntime as t, persistSubagentRunsToDisk as u };