@pixelzx/genesis 2026.6.27 → 2026.6.29

package/dist/routes-cv4VrQu1.js

@@ -0,0 +1,2 @@
+import { t as registerBrowserRoutes } from "./routes-ClkLAuU2.js";
+export { registerBrowserRoutes };

package/dist/rpc-05cw0vNh.js

@@ -0,0 +1,61 @@
+import { a as normalizeLowercaseStringOrEmpty, d as normalizeStringifiedOptionalString } from "./string-coerce-DPP_aYVc.js";
+import { i as parsePairingList, r as parseNodeList, t as resolveNodeFromNodeList } from "./node-resolve-DPo9C_sW.js";
+import { randomUUID } from "node:crypto";
+//#region src/cli/nodes-cli/format.ts
+function formatPermissions(raw) {
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+	const entries = Object.entries(raw).map(([key, value]) => [normalizeStringifiedOptionalString(key) ?? "", value === true]).filter(([key]) => key.length > 0).toSorted((a, b) => a[0].localeCompare(b[0]));
+	if (entries.length === 0) return null;
+	return `[${entries.map(([key, granted]) => `${key}=${granted ? "yes" : "no"}`).join(", ")}]`;
+}
+//#endregion
+//#region src/cli/nodes-cli/rpc.ts
+let nodesCliRpcRuntimePromise;
+async function loadNodesCliRpcRuntime() {
+	nodesCliRpcRuntimePromise ??= import("./rpc.runtime-DhFlfCMB.js");
+	return nodesCliRpcRuntimePromise;
+}
+const nodesCallOpts = (cmd, defaults) => cmd.option("--url <url>", "Gateway WebSocket URL (defaults to gateway.remote.url when configured)").option("--token <token>", "Gateway token (if required)").option("--timeout <ms>", "Timeout in ms", String(defaults?.timeoutMs ?? 1e4)).option("--json", "Output JSON", false);
+const callGatewayCli = async (method, opts, params, callOpts) => {
+	return await (await loadNodesCliRpcRuntime()).callGatewayCliRuntime(method, opts, params, callOpts);
+};
+function buildNodeInvokeParams(params) {
+	const invokeParams = {
+		nodeId: params.nodeId,
+		command: params.command,
+		params: params.params,
+		idempotencyKey: params.idempotencyKey ?? randomUUID()
+	};
+	if (typeof params.timeoutMs === "number" && Number.isFinite(params.timeoutMs)) invokeParams.timeoutMs = params.timeoutMs;
+	return invokeParams;
+}
+function unauthorizedHintForMessage(message) {
+	const haystack = normalizeLowercaseStringOrEmpty(message);
+	if (haystack.includes("unauthorizedclient") || haystack.includes("bridge client is not authorized") || haystack.includes("unsigned bridge clients are not allowed")) return [
+		"peekaboo bridge rejected the client.",
+		"sign the peekaboo CLI (TeamID Y5PE65HELJ) or launch the host with",
+		"PEEKABOO_ALLOW_UNSIGNED_SOCKET_CLIENTS=1 for local dev."
+	].join(" ");
+	return null;
+}
+async function resolveNodeId(opts, query) {
+	return (await resolveNode(opts, query)).nodeId;
+}
+async function resolveNode(opts, query) {
+	let nodes = [];
+	try {
+		nodes = parseNodeList(await callGatewayCli("node.list", opts, {}));
+	} catch {
+		const { paired } = parsePairingList(await callGatewayCli("node.pair.list", opts, {}));
+		nodes = paired.map((n) => ({
+			nodeId: n.nodeId,
+			displayName: n.displayName,
+			platform: n.platform,
+			version: n.version,
+			remoteIp: n.remoteIp
+		}));
+	}
+	return resolveNodeFromNodeList(nodes, query);
+}
+//#endregion
+export { resolveNodeId as a, resolveNode as i, callGatewayCli as n, unauthorizedHintForMessage as o, nodesCallOpts as r, formatPermissions as s, buildNodeInvokeParams as t };

package/dist/rpc.runtime-DhFlfCMB.js

@@ -0,0 +1,21 @@
+import { i as GATEWAY_CLIENT_NAMES, r as GATEWAY_CLIENT_MODES } from "./client-info-CjxzJxIU.js";
+import { r as callGateway } from "./call-J2wbwzLi.js";
+import { n as withProgress } from "./progress-DwK5aAgj.js";
+//#region src/cli/nodes-cli/rpc.runtime.ts
+async function callGatewayCliRuntime(method, opts, params, callOpts) {
+	return await withProgress({
+		label: `Nodes ${method}`,
+		indeterminate: true,
+		enabled: opts.json !== true
+	}, async () => await callGateway({
+		url: opts.url,
+		token: opts.token,
+		method,
+		params,
+		timeoutMs: callOpts?.transportTimeoutMs ?? Number(opts.timeout ?? 1e4),
+		clientName: GATEWAY_CLIENT_NAMES.CLI,
+		mode: GATEWAY_CLIENT_MODES.CLI
+	}));
+}
+//#endregion
+export { callGatewayCliRuntime };

package/dist/rpc.runtime.js

@@ -1 +1 @@
-export * from "./rpc.runtime-DEqSCvK_.js";
+export * from "./rpc.runtime-DhFlfCMB.js";

package/dist/run-delivery.runtime-B_9TxqQA.js

@@ -0,0 +1,530 @@
+import { i as formatErrorMessage } from "./errors-CufR9eHH.js";
+import { a as normalizeLowercaseStringOrEmpty, c as normalizeOptionalString, s as normalizeOptionalLowercaseString } from "./string-coerce-DPP_aYVc.js";
+import { i as resolveMainSessionKey, n as resolveAgentMainSessionKey } from "./main-session-DGV-IuVa.js";
+import { n as sleepWithAbort } from "./backoff-CCS8QGr9.js";
+import { o as retireSessionMcpRuntime } from "./pi-bundle-mcp-runtime-DS32_bKh.js";
+import "./pi-bundle-mcp-tools-MVePSeQp.js";
+import { a as isSilentReplyText, c as stripLeadingSilentToken, l as stripSilentToken, n as SILENT_REPLY_TOKEN, o as startsWithSilentToken } from "./tokens-DUMwK-9w.js";
+import { a as normalizeTargetForProvider } from "./target-normalization-DLPtWJgO.js";
+import { a as hasReplyPayloadContent } from "./payload-Wv43Ie-M.js";
+import { _ as resolveDeliveryTarget, l as hasScheduledNextRunAtMs } from "./jobs-D9IyaUDB.js";
+import { t as createCronExecutionId } from "./run-id-DVLkyJr0.js";
+import { n as pickLastNonEmptyTextFromPayloads, r as pickSummaryFromOutput } from "./helpers-BX9NJd9A.js";
+import { n as isLikelyInterimCronMessage, t as expectsSubagentFollowup } from "./subagent-followup-hints-BjJ5NzZg.js";
+//#region src/cron/isolated-agent/delivery-dispatch.ts
+function normalizeDeliveryTarget(channel, to) {
+	const toTrimmed = to.trim();
+	return normalizeTargetForProvider(channel, toTrimmed) ?? toTrimmed;
+}
+function normalizeSilentReplyText(text) {
+	if (!text) return {
+		text,
+		strippedTrailingSilentToken: false
+	};
+	if (isSilentReplyText(text, "NO_REPLY")) return {
+		text: void 0,
+		strippedTrailingSilentToken: false
+	};
+	let next = text;
+	const hasLeadingSilentToken = startsWithSilentToken(next, SILENT_REPLY_TOKEN);
+	if (hasLeadingSilentToken) next = stripLeadingSilentToken(next, SILENT_REPLY_TOKEN);
+	let strippedTrailingSilentToken = false;
+	if (hasLeadingSilentToken || next.toLowerCase().includes("NO_REPLY".toLowerCase())) {
+		const trimmedBefore = next.trim();
+		const stripped = stripSilentToken(next, SILENT_REPLY_TOKEN);
+		strippedTrailingSilentToken = stripped !== trimmedBefore;
+		next = stripped;
+	}
+	if (!next.trim() || isSilentReplyText(next, "NO_REPLY")) return {
+		text: void 0,
+		strippedTrailingSilentToken
+	};
+	return {
+		text: next,
+		strippedTrailingSilentToken
+	};
+}
+function matchesMessagingToolDeliveryTarget(target, delivery) {
+	if (!delivery.channel || !delivery.to || !target.to) return false;
+	const channel = normalizeLowercaseStringOrEmpty(delivery.channel);
+	const provider = normalizeOptionalLowercaseString(target.provider);
+	if (provider && provider !== "message" && provider !== channel) return false;
+	if (delivery.accountId && target.accountId && target.accountId !== delivery.accountId) return false;
+	return normalizeDeliveryTarget(channel, target.to.replace(/:topic:\d+$/, "")) === normalizeDeliveryTarget(channel, delivery.to);
+}
+function resolveCronDeliveryBestEffort(job) {
+	return job.delivery?.bestEffort === true;
+}
+const TRANSIENT_DIRECT_CRON_DELIVERY_ERROR_PATTERNS = [
+	/\berrorcode=unavailable\b/i,
+	/\bstatus\s*[:=]\s*"?unavailable\b/i,
+	/\bUNAVAILABLE\b/,
+	/no active .* listener/i,
+	/gateway not connected/i,
+	/gateway closed \(1006/i,
+	/gateway timeout/i,
+	/\b(econnreset|econnrefused|etimedout|enotfound|ehostunreach|network error)\b/i
+];
+const PERMANENT_DIRECT_CRON_DELIVERY_ERROR_PATTERNS = [
+	/unsupported channel/i,
+	/unknown channel/i,
+	/chat not found/i,
+	/user not found/i,
+	/bot.*not.*member/i,
+	/bot was blocked by the user/i,
+	/forbidden: bot was kicked/i,
+	/recipient is not a valid/i,
+	/outbound not configured for channel/i
+];
+const STALE_CRON_DELIVERY_MAX_START_DELAY_MS = 180 * 6e4;
+let gatewayCallRuntimePromise;
+let deliveryOutboundRuntimePromise;
+let deliverySubagentRegistryRuntimePromise;
+let deliveryLoggerRuntimePromise;
+let subagentFollowupRuntimePromise;
+const COMPLETED_DIRECT_CRON_DELIVERIES = /* @__PURE__ */ new Map();
+async function loadGatewayCallRuntime() {
+	gatewayCallRuntimePromise ??= import("./call.runtime-CyP2bdv0.js");
+	return await gatewayCallRuntimePromise;
+}
+async function loadDeliveryOutboundRuntime() {
+	deliveryOutboundRuntimePromise ??= import("./delivery-outbound.runtime-Dyo6zcqN.js");
+	return await deliveryOutboundRuntimePromise;
+}
+async function loadDeliverySubagentRegistryRuntime() {
+	deliverySubagentRegistryRuntimePromise ??= import("./delivery-subagent-registry.runtime-kF5Q8PAd.js");
+	return await deliverySubagentRegistryRuntimePromise;
+}
+async function loadDeliveryLoggerRuntime() {
+	deliveryLoggerRuntimePromise ??= import("./delivery-logger.runtime-Bf4B_Fz1.js");
+	return await deliveryLoggerRuntimePromise;
+}
+async function loadSubagentFollowupRuntime() {
+	subagentFollowupRuntimePromise ??= import("./subagent-followup.runtime-Be2c3jkr.js");
+	return await subagentFollowupRuntimePromise;
+}
+async function logCronDeliveryWarn(message) {
+	const { logWarn } = await loadDeliveryLoggerRuntime();
+	logWarn(message);
+}
+async function logCronDeliveryError(message) {
+	const { logError } = await loadDeliveryLoggerRuntime();
+	logError(message);
+}
+function logCronDeliveryErrorDeferred(message) {
+	loadDeliveryLoggerRuntime().then(({ logError }) => {
+		logError(message);
+	});
+}
+function cloneDeliveryResults(results) {
+	return results.map((result) => ({
+		...result,
+		...result.meta ? { meta: { ...result.meta } } : {}
+	}));
+}
+function pruneCompletedDirectCronDeliveries(now) {
+	const ttlMs = process.env.GENESIS_TEST_FAST === "1" ? 6e4 : 1440 * 60 * 1e3;
+	for (const [key, entry] of COMPLETED_DIRECT_CRON_DELIVERIES) if (now - entry.ts >= ttlMs) COMPLETED_DIRECT_CRON_DELIVERIES.delete(key);
+	const maxEntries = 2e3;
+	if (COMPLETED_DIRECT_CRON_DELIVERIES.size <= maxEntries) return;
+	const entries = [...COMPLETED_DIRECT_CRON_DELIVERIES.entries()].toSorted((a, b) => a[1].ts - b[1].ts);
+	const toDelete = COMPLETED_DIRECT_CRON_DELIVERIES.size - maxEntries;
+	for (let i = 0; i < toDelete; i += 1) {
+		const oldest = entries[i];
+		if (!oldest) break;
+		COMPLETED_DIRECT_CRON_DELIVERIES.delete(oldest[0]);
+	}
+}
+function resolveCronDeliveryScheduledAtMs(params) {
+	const scheduledAt = params.job.state?.nextRunAtMs;
+	return hasScheduledNextRunAtMs(scheduledAt) ? scheduledAt : params.runStartedAt;
+}
+function resolveCronDeliveryStartDelayMs(params) {
+	return params.runStartedAt - resolveCronDeliveryScheduledAtMs(params);
+}
+function isStaleCronDelivery(params) {
+	return resolveCronDeliveryStartDelayMs(params) > STALE_CRON_DELIVERY_MAX_START_DELAY_MS;
+}
+function rememberCompletedDirectCronDelivery(idempotencyKey, results) {
+	const now = Date.now();
+	COMPLETED_DIRECT_CRON_DELIVERIES.set(idempotencyKey, {
+		ts: now,
+		results: cloneDeliveryResults(results)
+	});
+	pruneCompletedDirectCronDeliveries(now);
+}
+function getCompletedDirectCronDelivery(idempotencyKey) {
+	pruneCompletedDirectCronDeliveries(Date.now());
+	const cached = COMPLETED_DIRECT_CRON_DELIVERIES.get(idempotencyKey);
+	if (!cached) return;
+	return cloneDeliveryResults(cached.results);
+}
+function buildDirectCronDeliveryIdempotencyKey(params) {
+	const executionId = createCronExecutionId(params.jobId, params.runStartedAt);
+	const threadId = params.delivery.threadId == null || params.delivery.threadId === "" ? "" : String(params.delivery.threadId);
+	const accountId = params.delivery.accountId?.trim() ?? "";
+	const normalizedTo = normalizeDeliveryTarget(params.delivery.channel, params.delivery.to);
+	return `cron-direct-delivery:v1:${executionId}:${params.delivery.channel}:${accountId}:${normalizedTo}:${threadId}`;
+}
+function shouldQueueCronAwareness(job, deliveryBestEffort) {
+	return job.sessionTarget === "isolated" && !deliveryBestEffort;
+}
+function resolveCronAwarenessMainSessionKey(params) {
+	return params.cfg.session?.scope === "global" ? resolveMainSessionKey(params.cfg) : resolveAgentMainSessionKey({
+		cfg: params.cfg,
+		agentId: params.agentId
+	});
+}
+async function queueCronAwarenessSystemEvent(params) {
+	const text = params.deliveryPayloads ? pickLastNonEmptyTextFromPayloads(params.deliveryPayloads) : normalizeOptionalString(params.outputText) ?? normalizeOptionalString(params.synthesizedText);
+	if (!text) return;
+	try {
+		const { enqueueSystemEvent } = await loadDeliveryOutboundRuntime();
+		enqueueSystemEvent(text, {
+			sessionKey: resolveCronAwarenessMainSessionKey({
+				cfg: params.cfg,
+				agentId: params.agentId
+			}),
+			contextKey: params.deliveryIdempotencyKey,
+			trusted: false
+		});
+	} catch (err) {
+		await logCronDeliveryWarn(`[cron:${params.jobId}] failed to queue isolated cron awareness for the main session: ${formatErrorMessage(err)}`);
+	}
+}
+function summarizeDirectCronDeliveryError(error) {
+	if (error instanceof Error) return error.message || "error";
+	if (typeof error === "string") return error;
+	try {
+		return JSON.stringify(error) || String(error);
+	} catch {
+		return String(error);
+	}
+}
+function isTransientDirectCronDeliveryError(error) {
+	const message = summarizeDirectCronDeliveryError(error);
+	if (!message) return false;
+	if (PERMANENT_DIRECT_CRON_DELIVERY_ERROR_PATTERNS.some((re) => re.test(message))) return false;
+	return TRANSIENT_DIRECT_CRON_DELIVERY_ERROR_PATTERNS.some((re) => re.test(message));
+}
+function resolveDirectCronRetryDelaysMs() {
+	return [
+		5e3,
+		1e4,
+		2e4
+	];
+}
+async function retryTransientDirectCronDelivery(params) {
+	const retryDelaysMs = resolveDirectCronRetryDelaysMs();
+	let retryIndex = 0;
+	for (;;) {
+		if (params.signal?.aborted) throw new Error("cron delivery aborted");
+		try {
+			return await params.run();
+		} catch (err) {
+			const delayMs = retryDelaysMs[retryIndex];
+			if (delayMs == null || !isTransientDirectCronDeliveryError(err) || params.signal?.aborted) throw err;
+			const nextAttempt = retryIndex + 2;
+			const maxAttempts = retryDelaysMs.length + 1;
+			await logCronDeliveryWarn(`[cron:${params.jobId}] transient direct announce delivery failure, retrying ${nextAttempt}/${maxAttempts} in ${Math.round(delayMs / 1e3)}s: ${summarizeDirectCronDeliveryError(err)}`);
+			retryIndex += 1;
+			await sleepWithAbort(delayMs, params.signal);
+		}
+	}
+}
+async function dispatchCronDelivery(params) {
+	const skipMessagingToolDelivery = params.skipMessagingToolDelivery === true;
+	let summary = params.summary;
+	let outputText = params.outputText;
+	let synthesizedText = params.synthesizedText;
+	let deliveryPayloads = params.deliveryPayloads;
+	let delivered = skipMessagingToolDelivery;
+	let deliveryAttempted = skipMessagingToolDelivery;
+	let directCronSessionDeleted = false;
+	const formatDeliveryTargetError = (error) => params.unverifiedMessagingToolDelivery === true ? `${error}; the agent used the message tool, but Genesis could not verify that message matched the cron delivery target` : error;
+	const failDeliveryTarget = (error) => params.withRunSession({
+		status: "error",
+		error: formatDeliveryTargetError(error),
+		errorKind: "delivery-target",
+		summary,
+		outputText,
+		deliveryAttempted,
+		...params.telemetry
+	});
+	const cleanupDirectCronSessionIfNeeded = async () => {
+		if (!params.job.deleteAfterRun || directCronSessionDeleted) return;
+		try {
+			const { callGateway } = await loadGatewayCallRuntime();
+			await callGateway({
+				method: "sessions.delete",
+				params: {
+					key: params.agentSessionKey,
+					deleteTranscript: true,
+					emitLifecycleHooks: false
+				},
+				timeoutMs: 1e4
+			});
+			directCronSessionDeleted = true;
+		} catch {
+			await retireSessionMcpRuntime({
+				sessionId: params.sessionId,
+				reason: "cron-delete-after-run-fallback"
+			});
+		}
+	};
+	const finishSilentReplyDelivery = async () => {
+		deliveryAttempted = true;
+		await cleanupDirectCronSessionIfNeeded();
+		return params.withRunSession({
+			status: "ok",
+			summary,
+			outputText,
+			delivered: false,
+			deliveryAttempted: true,
+			...params.telemetry
+		});
+	};
+	const deliverViaDirect = async (delivery, options) => {
+		const { buildOutboundSessionContext, createOutboundSendDeps, deliverOutboundPayloads, resolveAgentOutboundIdentity } = await loadDeliveryOutboundRuntime();
+		const identity = resolveAgentOutboundIdentity(params.cfgWithAgentDefaults, params.agentId);
+		const deliveryIdempotencyKey = buildDirectCronDeliveryIdempotencyKey({
+			jobId: params.job.id,
+			runStartedAt: params.runStartedAt,
+			delivery
+		});
+		try {
+			const payloadsForDelivery = (deliveryPayloads.length > 0 ? deliveryPayloads : synthesizedText ? [{ text: synthesizedText }] : []).map((p) => {
+				if (!p.text) return p;
+				const normalized = normalizeSilentReplyText(p.text);
+				return Object.assign({}, p, { text: normalized.strippedTrailingSilentToken ? void 0 : normalized.text });
+			}).filter((p) => hasReplyPayloadContent(p, { trimText: true }));
+			if (payloadsForDelivery.length === 0) return await finishSilentReplyDelivery();
+			if (params.isAborted()) return params.withRunSession({
+				status: "error",
+				error: params.abortReason(),
+				deliveryAttempted,
+				...params.telemetry
+			});
+			if (params.deliveryRequested && isStaleCronDelivery({
+				job: params.job,
+				runStartedAt: params.runStartedAt
+			})) {
+				deliveryAttempted = true;
+				const nowMs = Date.now();
+				const scheduledAtMs = resolveCronDeliveryScheduledAtMs({
+					job: params.job,
+					runStartedAt: params.runStartedAt
+				});
+				const startDelayMs = resolveCronDeliveryStartDelayMs({
+					job: params.job,
+					runStartedAt: params.runStartedAt
+				});
+				await logCronDeliveryWarn(`[cron:${params.job.id}] skipping stale delivery scheduled at ${new Date(scheduledAtMs).toISOString()}, started ${Math.round(startDelayMs / 6e4)}m late, current age ${Math.round((nowMs - scheduledAtMs) / 6e4)}m`);
+				return params.withRunSession({
+					status: "ok",
+					summary,
+					outputText,
+					deliveryAttempted,
+					delivered: false,
+					...params.telemetry
+				});
+			}
+			deliveryAttempted = true;
+			if (getCompletedDirectCronDelivery(deliveryIdempotencyKey)) {
+				delivered = true;
+				return null;
+			}
+			const deliverySession = buildOutboundSessionContext({
+				cfg: params.cfgWithAgentDefaults,
+				agentId: params.agentId,
+				sessionKey: params.agentSessionKey
+			});
+			let hadPartialFailure = false;
+			const onError = params.deliveryBestEffort ? (err, _payload) => {
+				hadPartialFailure = true;
+				logCronDeliveryErrorDeferred(`[cron:${params.job.id}] delivery payload failed (bestEffort): ${formatErrorMessage(err)}`);
+			} : void 0;
+			const runDelivery = async () => await deliverOutboundPayloads({
+				cfg: params.cfgWithAgentDefaults,
+				channel: delivery.channel,
+				to: delivery.to,
+				accountId: delivery.accountId,
+				threadId: delivery.threadId,
+				payloads: payloadsForDelivery,
+				session: deliverySession,
+				identity,
+				bestEffort: params.deliveryBestEffort,
+				deps: createOutboundSendDeps(params.deps),
+				abortSignal: params.abortSignal,
+				onError,
+				skipQueue: true
+			});
+			const deliveryResults = options?.retryTransient ? await retryTransientDirectCronDelivery({
+				jobId: params.job.id,
+				signal: params.abortSignal,
+				run: runDelivery
+			}) : await runDelivery();
+			delivered = deliveryResults.length > 0 && !hadPartialFailure;
+			if (delivered && shouldQueueCronAwareness(params.job, params.deliveryBestEffort)) await queueCronAwarenessSystemEvent({
+				cfg: params.cfgWithAgentDefaults,
+				jobId: params.job.id,
+				agentId: params.agentId,
+				deliveryIdempotencyKey,
+				outputText,
+				synthesizedText,
+				deliveryPayloads: payloadsForDelivery
+			});
+			if (delivered) rememberCompletedDirectCronDelivery(deliveryIdempotencyKey, deliveryResults);
+			return null;
+		} catch (err) {
+			if (!params.deliveryBestEffort) return params.withRunSession({
+				status: "error",
+				summary,
+				outputText,
+				error: String(err),
+				deliveryAttempted,
+				...params.telemetry
+			});
+			await logCronDeliveryError(`[cron:${params.job.id}] delivery failed (bestEffort): ${formatErrorMessage(err)}`);
+			return null;
+		}
+	};
+	const deliverViaDirectAndCleanup = async (delivery, options) => {
+		try {
+			return await deliverViaDirect(delivery, options);
+		} finally {
+			await cleanupDirectCronSessionIfNeeded();
+		}
+	};
+	const finalizeTextDelivery = async (delivery) => {
+		if (!synthesizedText) return null;
+		const initialSynthesizedText = synthesizedText.trim();
+		const expectedSubagentFollowup = expectsSubagentFollowup(initialSynthesizedText);
+		const subagentRegistryRuntime = await loadDeliverySubagentRegistryRuntime();
+		let activeSubagentRuns = subagentRegistryRuntime.countActiveDescendantRuns(params.agentSessionKey);
+		const shouldCheckCompletedDescendants = activeSubagentRuns === 0 && isLikelyInterimCronMessage(initialSynthesizedText);
+		const subagentFollowupRuntime = shouldCheckCompletedDescendants || activeSubagentRuns > 0 || expectedSubagentFollowup ? await loadSubagentFollowupRuntime() : void 0;
+		const completedDescendantReply = shouldCheckCompletedDescendants ? await subagentFollowupRuntime?.readDescendantSubagentFallbackReply({
+			sessionKey: params.agentSessionKey,
+			runStartedAt: params.runStartedAt
+		}) : void 0;
+		const hadDescendants = activeSubagentRuns > 0 || Boolean(completedDescendantReply);
+		if (activeSubagentRuns > 0 || expectedSubagentFollowup) {
+			let finalReply = await subagentFollowupRuntime?.waitForDescendantSubagentSummary({
+				sessionKey: params.agentSessionKey,
+				initialReply: initialSynthesizedText,
+				timeoutMs: params.timeoutMs,
+				observedActiveDescendants: activeSubagentRuns > 0 || expectedSubagentFollowup
+			});
+			activeSubagentRuns = subagentRegistryRuntime.countActiveDescendantRuns(params.agentSessionKey);
+			if (!finalReply && activeSubagentRuns === 0) finalReply = await subagentFollowupRuntime?.readDescendantSubagentFallbackReply({
+				sessionKey: params.agentSessionKey,
+				runStartedAt: params.runStartedAt
+			});
+			if (finalReply && activeSubagentRuns === 0) {
+				outputText = finalReply;
+				summary = pickSummaryFromOutput(finalReply) ?? summary;
+				synthesizedText = finalReply;
+				deliveryPayloads = [{ text: finalReply }];
+			}
+		} else if (completedDescendantReply) {
+			outputText = completedDescendantReply;
+			summary = pickSummaryFromOutput(completedDescendantReply) ?? summary;
+			synthesizedText = completedDescendantReply;
+			deliveryPayloads = [{ text: completedDescendantReply }];
+		}
+		if (activeSubagentRuns > 0) {
+			deliveryAttempted = true;
+			return params.withRunSession({
+				status: "ok",
+				summary,
+				outputText,
+				deliveryAttempted,
+				...params.telemetry
+			});
+		}
+		if (hadDescendants && synthesizedText.trim() === initialSynthesizedText && isLikelyInterimCronMessage(initialSynthesizedText) && !isSilentReplyText(initialSynthesizedText, "NO_REPLY")) {
+			deliveryAttempted = true;
+			return params.withRunSession({
+				status: "ok",
+				summary,
+				outputText,
+				deliveryAttempted,
+				...params.telemetry
+			});
+		}
+		const normalizedSynthesizedText = normalizeSilentReplyText(synthesizedText);
+		if (normalizedSynthesizedText.text === void 0 || normalizedSynthesizedText.strippedTrailingSilentToken) return await finishSilentReplyDelivery();
+		synthesizedText = normalizedSynthesizedText.text;
+		outputText = synthesizedText;
+		if (params.isAborted()) return params.withRunSession({
+			status: "error",
+			error: params.abortReason(),
+			deliveryAttempted,
+			...params.telemetry
+		});
+		return await deliverViaDirectAndCleanup(delivery, { retryTransient: true });
+	};
+	if (params.deliveryRequested && !params.skipHeartbeatDelivery && !skipMessagingToolDelivery) {
+		if (!params.resolvedDelivery.ok) {
+			if (!params.deliveryBestEffort) return {
+				result: failDeliveryTarget(params.resolvedDelivery.error.message),
+				delivered,
+				deliveryAttempted,
+				summary,
+				outputText,
+				synthesizedText,
+				deliveryPayloads
+			};
+			await logCronDeliveryWarn(`[cron:${params.job.id}] ${params.resolvedDelivery.error.message}`);
+			return {
+				result: params.withRunSession({
+					status: "ok",
+					summary,
+					outputText,
+					deliveryAttempted,
+					...params.telemetry
+				}),
+				delivered,
+				deliveryAttempted,
+				summary,
+				outputText,
+				synthesizedText,
+				deliveryPayloads
+			};
+		}
+		if (params.deliveryPayloadHasStructuredContent || params.resolvedDelivery.threadId != null) {
+			const directResult = await deliverViaDirectAndCleanup(params.resolvedDelivery);
+			if (directResult) return {
+				result: directResult,
+				delivered,
+				deliveryAttempted,
+				summary,
+				outputText,
+				synthesizedText,
+				deliveryPayloads
+			};
+		} else {
+			const finalizedTextResult = await finalizeTextDelivery(params.resolvedDelivery);
+			if (finalizedTextResult) return {
+				result: finalizedTextResult,
+				delivered,
+				deliveryAttempted,
+				summary,
+				outputText,
+				synthesizedText,
+				deliveryPayloads
+			};
+		}
+	}
+	return {
+		delivered,
+		deliveryAttempted,
+		summary,
+		outputText,
+		synthesizedText,
+		deliveryPayloads
+	};
+}
+//#endregion
+export { dispatchCronDelivery, matchesMessagingToolDeliveryTarget, resolveCronDeliveryBestEffort, resolveDeliveryTarget };

package/dist/run-delivery.runtime.js

@@ -1 +1 @@
-export * from "./run-delivery.runtime-Ra2LpyjL.js";
+export * from "./run-delivery.runtime-B_9TxqQA.js";

package/dist/run-embedded.runtime-V68HvJT8.js

@@ -0,0 +1,4 @@
+import { r as resolveNestedAgentLane } from "./lanes-CQOYr7ym.js";
+import { t as runEmbeddedPiAgent } from "./pi-embedded-S0ld6lbd.js";
+import { t as resolveFastModeState } from "./fast-mode-CjapnL6q.js";
+export { resolveFastModeState, resolveNestedAgentLane, runEmbeddedPiAgent };

package/dist/run-embedded.runtime.js

@@ -1 +1 @@
-export * from "./run-embedded.runtime-B-b7dF48.js";
+export * from "./run-embedded.runtime-V68HvJT8.js";

package/dist/run-execution-cli.runtime-9NpwQ1uu.js

@@ -0,0 +1,4 @@
+import { i as getCliSessionId } from "./cli-session-Df-biSi0.js";
+import { t as runCliAgent } from "./cli-runner-DkUWaw3u.js";
+import "./cli-runner.runtime-D35_WwIC.js";
+export { getCliSessionId, runCliAgent };

package/dist/run-execution-cli.runtime.js

@@ -1 +1 @@
-export * from "./run-execution-cli.runtime-rzYYRquv.js";
+export * from "./run-execution-cli.runtime-9NpwQ1uu.js";