@gaodefa/daocore 2026.5.25 → 2026.5.26

package/dist/reply-delivery-DZGfRh-W.js

@@ -0,0 +1,196 @@
+import { c as normalizeOptionalString } from "./string-coerce-DyL154ka.js";
+import { t as sanitizeAssistantVisibleText } from "./assistant-visible-text-BoF6Ixue.js";
+import { m as resolveSendableOutboundReplyParts } from "./reply-payload-DMPQsrQC.js";
+import { t as buildOutboundSessionContext } from "./session-context-B3TnD7i3.js";
+import "./string-coerce-runtime-DcopKqDR.js";
+import { t as resolveAgentAvatar } from "./identity-avatar-MYcY1ERI.js";
+import "./outbound-runtime-BKk14yAR.js";
+import "./text-chunking-CAiWc6uE.js";
+import "./agent-runtime-Dp0RDnX1.js";
+import { d as sendDurableMessageBatch } from "./channel-message-BntYSBp1.js";
+import { i as resolveTimestampMs } from "./format-DZW075F7.js";
+import { o as sendVoiceMessageDiscord } from "./send-Dwv2Ss6m.js";
+import { t as sendMessageDiscord } from "./send.outbound-CrfOJYBL.js";
+import { t as resolveDiscordSenderIdentity } from "./sender-identity-CRiRZfVr.js";
+//#region extensions/discord/src/monitor/reply-context.ts
+function resolveReplyContext(message, resolveDiscordMessageText) {
+	const referenced = message.referencedMessage;
+	if (!referenced?.author) return null;
+	const referencedText = resolveDiscordMessageText(referenced, { includeForwarded: true });
+	if (!referencedText) return null;
+	const sender = resolveDiscordSenderIdentity({
+		author: referenced.author,
+		pluralkitInfo: null
+	});
+	return {
+		id: referenced.id,
+		channelId: referenced.channelId,
+		sender: sender.tag ?? sender.label ?? "unknown",
+		senderId: referenced.author.id,
+		senderName: referenced.author.username ?? void 0,
+		senderTag: sender.tag ?? void 0,
+		memberRoleIds: (() => {
+			const roles = referenced.member?.roles;
+			return Array.isArray(roles) ? roles.map((roleId) => roleId) : void 0;
+		})(),
+		body: referencedText,
+		timestamp: resolveTimestampMs(referenced.timestamp)
+	};
+}
+function buildDirectLabel(author, tagOverride) {
+	return `${(tagOverride?.trim() || resolveDiscordSenderIdentity({
+		author,
+		pluralkitInfo: null
+	}).tag) ?? "unknown"} user id:${author.id}`;
+}
+function buildGuildLabel(params) {
+	const { guild, channelName, channelId } = params;
+	return `${guild?.name ?? "Guild"} #${channelName} channel id:${channelId}`;
+}
+//#endregion
+//#region extensions/discord/src/monitor/reply-safety.ts
+const DISCORD_INTERNAL_TRACE_LINE_RE = /^(?:>\s*)?(?:📊|🛠️|📖|📝|🔍|🔎|⚙️)\s*(?:Session Status|Exec|Read|Edit|Write|Patch|Search|Open|Click|Find|Screenshot|Update Plan|Tool Call|Tool Result|Function Call|Shell|Command)\s*:/i;
+const DISCORD_INTERNAL_COMPACT_COMMAND_TRACE_LINE_RE = /^(?:>\s*)?🛠️\s*(?:(?:(?:elevated|pty)\b\s*(?:·|,)\s*)+)?(?:`{1,2}\s*\S|(?:run|check|fetch|pull|push|view|show|list|switch|create|merge|rebase|stage|restore|reset|stash|search|find|print|copy|move|remove|install|start|cd|git|pnpm|npm|yarn|bun|node|python|python3|bash|sh)\b)/i;
+const DISCORD_INTERNAL_CHANNEL_LINE_RE = /^(?:>\s*)?(?:analysis|commentary|tool[-_ ]?call|tool[-_ ]?result|function[-_ ]?call|thinking|reasoning)\s*[:=]/i;
+function hasNonEmptyRecord(value) {
+	return Boolean(value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length > 0);
+}
+function hasInteractiveOrPresentationBlocks(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	const record = value;
+	if (typeof record.title === "string" && record.title.trim().length > 0) return true;
+	return Array.isArray(record.blocks) && record.blocks.length > 0;
+}
+function hasNonTextReplyPayloadContent(payload) {
+	return payload.audioAsVoice === true || hasNonEmptyRecord(payload.channelData) || hasInteractiveOrPresentationBlocks(payload.interactive) || hasInteractiveOrPresentationBlocks(payload.presentation);
+}
+function stripDiscordInternalTraceLines(text) {
+	let inFence = false;
+	const kept = [];
+	for (const line of text.split(/\r?\n/)) {
+		if (/^\s*```/.test(line)) {
+			inFence = !inFence;
+			kept.push(line);
+			continue;
+		}
+		if (!inFence) {
+			const trimmed = line.trim();
+			if (DISCORD_INTERNAL_TRACE_LINE_RE.test(trimmed) || DISCORD_INTERNAL_COMPACT_COMMAND_TRACE_LINE_RE.test(trimmed) || DISCORD_INTERNAL_CHANNEL_LINE_RE.test(trimmed)) continue;
+		}
+		kept.push(line);
+	}
+	return kept.join("\n");
+}
+function collapseExcessBlankLines(text) {
+	return text.replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n");
+}
+function sanitizeDiscordFrontChannelText(text) {
+	return collapseExcessBlankLines(stripDiscordInternalTraceLines(sanitizeAssistantVisibleText(text))).trim();
+}
+function sanitizeDiscordFrontChannelReplyPayloads(payloads, options = {}) {
+	const preserveVerboseToolProgress = options.kind === "tool";
+	const safePayloads = [];
+	for (const payload of payloads) {
+		const safeText = typeof payload.text === "string" ? preserveVerboseToolProgress ? collapseExcessBlankLines(sanitizeAssistantVisibleText(payload.text)).trim() : sanitizeDiscordFrontChannelText(payload.text) : payload.text;
+		const nextPayload = safeText === payload.text ? payload : {
+			...payload,
+			text: safeText || void 0
+		};
+		if (!resolveSendableOutboundReplyParts(nextPayload).hasContent && !hasNonTextReplyPayloadContent(nextPayload)) continue;
+		safePayloads.push(nextPayload);
+	}
+	return safePayloads;
+}
+//#endregion
+//#region extensions/discord/src/monitor/reply-delivery.ts
+function resolveTargetChannelId(target) {
+	if (!target.startsWith("channel:")) return;
+	return target.slice(8).trim() || void 0;
+}
+function resolveBoundThreadBinding(params) {
+	const sessionKey = params.sessionKey?.trim();
+	if (!params.threadBindings || !sessionKey) return;
+	const targetChannelId = resolveTargetChannelId(params.target);
+	if (!targetChannelId) return;
+	return params.threadBindings.listBySessionKey(sessionKey).find((entry) => entry.threadId === targetChannelId);
+}
+function resolveBindingIdentity(cfg, binding) {
+	if (!binding) return;
+	const identity = { name: (`🤖 ${binding.label?.trim() || binding.agentId}`.trim() || "🤖 agent").slice(0, 80) };
+	try {
+		const avatar = resolveAgentAvatar(cfg, binding.agentId);
+		if (avatar.kind === "remote") identity.avatarUrl = avatar.url;
+	} catch {}
+	return identity;
+}
+function createDiscordDeliveryDeps(params) {
+	return {
+		discord: (to, text, opts) => sendMessageDiscord(to, text, {
+			...opts,
+			cfg: opts?.cfg ?? params.cfg,
+			token: params.token,
+			rest: params.rest
+		}),
+		discordVoice: (to, audioPath, opts) => sendVoiceMessageDiscord(to, audioPath, {
+			...opts,
+			cfg: opts?.cfg ?? params.cfg,
+			token: params.token,
+			rest: params.rest
+		})
+	};
+}
+function resolveDiscordDeliveryOptions(params) {
+	const binding = resolveBoundThreadBinding({
+		threadBindings: params.threadBindings,
+		sessionKey: params.sessionKey,
+		target: params.target
+	});
+	return {
+		to: binding ? `channel:${binding.channelId}` : params.target,
+		threadId: binding?.threadId,
+		agentId: binding?.agentId,
+		identity: resolveBindingIdentity(params.cfg, binding),
+		mediaAccess: params.mediaLocalRoots?.length ? { localRoots: params.mediaLocalRoots } : void 0,
+		replyToMode: params.replyToMode ?? "all",
+		formatting: {
+			textLimit: params.textLimit,
+			maxLinesPerMessage: params.maxLinesPerMessage,
+			tableMode: params.tableMode,
+			chunkMode: params.chunkMode
+		}
+	};
+}
+async function deliverDiscordReply(params) {
+	params.runtime;
+	const delivery = resolveDiscordDeliveryOptions(params);
+	const payloads = sanitizeDiscordFrontChannelReplyPayloads(params.replies, { kind: params.kind });
+	if (payloads.length === 0) return;
+	const send = await sendDurableMessageBatch({
+		cfg: params.cfg,
+		channel: "discord",
+		to: delivery.to,
+		accountId: params.accountId,
+		payloads,
+		replyToId: normalizeOptionalString(params.replyToId),
+		replyToMode: delivery.replyToMode,
+		formatting: delivery.formatting,
+		threadId: delivery.threadId,
+		identity: delivery.identity,
+		deps: createDiscordDeliveryDeps({
+			cfg: params.cfg,
+			token: params.token,
+			rest: params.rest
+		}),
+		mediaAccess: delivery.mediaAccess,
+		session: buildOutboundSessionContext({
+			cfg: params.cfg,
+			sessionKey: params.sessionKey,
+			agentId: delivery.agentId,
+			requesterAccountId: params.accountId
+		})
+	});
+	if (send.status === "failed" || send.status === "partial_failed") throw send.error;
+	if ((send.status === "sent" ? send.results : []).length === 0) throw new Error(`discord final reply produced no delivered message for ${delivery.to}`);
+}
+//#endregion
+export { resolveReplyContext as i, buildDirectLabel as n, buildGuildLabel as r, deliverDiscordReply as t };

package/dist/reply-runtime-BdCPL-OF.js

@@ -0,0 +1,11 @@
+import "./dispatch-DvZRbIrc.js";
+import "./heartbeat-0BSacHYL.js";
+import "./chunk-DirkQqDP.js";
+import "./inbound-dedupe-CGI36mFX.js";
+import "./reply-dispatcher-C3a0y_0v.js";
+import "./provider-dispatcher-DyJDef6y.js";
+import "./abort-By0wxKlI.js";
+import "./get-reply-Co-_Qlr-.js";
+import "./btw-command-bRTCmdd_.js";
+import "./conversation-label-generator-hlqPMoWC.js";
+export {};

package/dist/reply-runtime-DuaOZ9MH.d.ts

@@ -0,0 +1,34 @@
+import { r as DaoCoreConfig } from "./types.daocore-kp8IyikH.js";
+import { n as GetReplyOptions, s as ReplyPayload } from "./get-reply-options.types-BXrapyJ-.js";
+import { n as MsgContext, t as FinalizedMsgContext } from "./templating-DNuykHor.js";
+import { n as ReplyDispatcher } from "./reply-dispatcher.types-DxImExDW.js";
+import { r as GetReplyFromConfig, t as DispatchFromConfigResult } from "./dispatch-from-config.types-BaH1qQQT.js";
+import { i as ReplyDispatcherWithTypingOptions, r as ReplyDispatcherOptions } from "./provider-dispatcher.types-BAVJXl4y.js";
+//#region src/auto-reply/dispatch.d.ts
+type DispatchInboundResult = DispatchFromConfigResult;
+declare function dispatchInboundMessage(params: {
+  ctx: MsgContext | FinalizedMsgContext;
+  cfg: DaoCoreConfig;
+  dispatcher: ReplyDispatcher;
+  replyOptions?: Omit<GetReplyOptions, "onBlockReply">;
+  replyResolver?: GetReplyFromConfig;
+}): Promise<DispatchInboundResult>;
+declare function dispatchInboundMessageWithBufferedDispatcher(params: {
+  ctx: MsgContext | FinalizedMsgContext;
+  cfg: DaoCoreConfig;
+  dispatcherOptions: ReplyDispatcherWithTypingOptions;
+  replyOptions?: Omit<GetReplyOptions, "onBlockReply">;
+  replyResolver?: GetReplyFromConfig;
+}): Promise<DispatchInboundResult>;
+declare function dispatchInboundMessageWithDispatcher(params: {
+  ctx: MsgContext | FinalizedMsgContext;
+  cfg: DaoCoreConfig;
+  dispatcherOptions: ReplyDispatcherOptions;
+  replyOptions?: Omit<GetReplyOptions, "onBlockReply">;
+  replyResolver?: GetReplyFromConfig;
+}): Promise<DispatchInboundResult>;
+//#endregion
+//#region src/auto-reply/heartbeat-reply-payload.d.ts
+declare function resolveHeartbeatReplyPayload(replyResult: ReplyPayload | ReplyPayload[] | undefined): ReplyPayload | undefined;
+//#endregion
+export { dispatchInboundMessageWithDispatcher as i, dispatchInboundMessage as n, dispatchInboundMessageWithBufferedDispatcher as r, resolveHeartbeatReplyPayload as t };

package/dist/reply.runtime-BcbRKxzJ.js

@@ -0,0 +1,2 @@
+import { t as getReplyFromConfig } from "./get-reply-Co-_Qlr-.js";
+export { getReplyFromConfig };

package/dist/reply.runtime.js

@@ -1 +1 @@
-export * from "./reply.runtime-l7NTyCh5.js";
+export * from "./reply.runtime-BcbRKxzJ.js";

package/dist/request-Ca681Kt1.js

@@ -0,0 +1,54 @@
+import { n as CodexAppServerRpcError } from "./client-B5IcAlfB.js";
+import { a as getSharedCodexAppServerClient, i as createIsolatedCodexAppServerClient, o as withTimeout } from "./shared-client-Mc7bTBoQ.js";
+import { t as resolveCodexAppServerDirectSandboxBypassBlock } from "./sandbox-guard-BeQW1CTX.js";
+//#region extensions/codex/src/app-server/capabilities.ts
+const CODEX_CONTROL_METHODS = {
+	account: "account/read",
+	compact: "thread/compact/start",
+	feedback: "feedback/upload",
+	listMcpServers: "mcpServerStatus/list",
+	listSkills: "skills/list",
+	listThreads: "thread/list",
+	rateLimits: "account/rateLimits/read",
+	resumeThread: "thread/resume",
+	review: "review/start"
+};
+function describeControlFailure(error) {
+	if (isUnsupportedControlError(error)) return "unsupported by this Codex app-server";
+	return error instanceof Error ? error.message : String(error);
+}
+function isUnsupportedControlError(error) {
+	return error instanceof CodexAppServerRpcError && error.code === -32601;
+}
+//#endregion
+//#region extensions/codex/src/app-server/request.ts
+async function requestCodexAppServerJson(params) {
+	const sandboxBlock = resolveCodexAppServerDirectSandboxBypassBlock({
+		method: params.method,
+		requestParams: params.requestParams,
+		config: params.config,
+		sessionKey: params.sessionKey,
+		sessionId: params.sessionId
+	});
+	if (sandboxBlock) throw new Error(sandboxBlock);
+	const timeoutMs = params.timeoutMs ?? 6e4;
+	return await withTimeout((async () => {
+		const client = await (params.isolated ? createIsolatedCodexAppServerClient : getSharedCodexAppServerClient)({
+			startOptions: params.startOptions,
+			timeoutMs,
+			authProfileId: params.authProfileId,
+			agentDir: params.agentDir,
+			config: params.config
+		});
+		try {
+			return await client.request(params.method, params.requestParams, { timeoutMs });
+		} finally {
+			if (params.isolated) await client.closeAndWait({
+				exitTimeoutMs: 2e3,
+				forceKillDelayMs: 250
+			});
+		}
+	})(), timeoutMs, `codex app-server ${params.method} timed out`);
+}
+//#endregion
+export { CODEX_CONTROL_METHODS as n, describeControlFailure as r, requestCodexAppServerJson as t };

package/dist/resolve-allowlist-DWjCzDq1.js

@@ -0,0 +1,220 @@
+import { a as normalizeLowercaseStringOrEmpty, s as normalizeOptionalLowercaseString } from "./string-coerce-DyL154ka.js";
+import "./string-coerce-runtime-DcopKqDR.js";
+import { a as mapAllowlistResolutionInputs } from "./allow-from-BsbZfqm-.js";
+import { c as normalizeQuery, f as resolveGraphToken, o as listChannelsForTeam, s as listTeamsByName, t as searchGraphUsers } from "./graph-users-CF7Dlee2.js";
+//#region extensions/msteams/src/resolve-allowlist.ts
+function stripProviderPrefix(raw) {
+	return raw.replace(/^(msteams|teams):/i, "");
+}
+function normalizeMSTeamsMessagingTarget(raw) {
+	let trimmed = raw.trim();
+	if (!trimmed) return;
+	trimmed = stripProviderPrefix(trimmed).trim();
+	if (/^conversation:/i.test(trimmed)) {
+		const id = trimmed.slice(13).trim();
+		return id ? `conversation:${id}` : void 0;
+	}
+	if (/^user:/i.test(trimmed)) {
+		const id = trimmed.slice(5).trim();
+		return id ? `user:${id}` : void 0;
+	}
+	return trimmed || void 0;
+}
+function normalizeMSTeamsUserInput(raw) {
+	return stripProviderPrefix(raw).replace(/^(user|conversation):/i, "").trim();
+}
+function parseMSTeamsConversationId(raw) {
+	const trimmed = stripProviderPrefix(raw).trim();
+	if (!/^conversation:/i.test(trimmed)) return null;
+	return trimmed.slice(13).trim();
+}
+/**
+* Detect whether a raw target string looks like a Microsoft Teams conversation
+* or user id that cron announce delivery and other explicit-target paths can
+* forward verbatim to the channel adapter.
+*
+* Accepts both prefixed and bare formats:
+* - `conversation:<id>` — explicit conversation prefix
+* - `user:<aad-guid>`   — user id (16+ hex chars, UUID-like)
+* - `19:abc@thread.tacv2` / `19:abc@thread.skype` — channel / legacy group
+* - `19:{userId}_{appId}@unq.gbl.spaces` — Graph 1:1 chat thread format
+* - `a:1xxx` — Bot Framework personal (1:1) chat id
+* - `8:orgid:xxx` — Bot Framework org-scoped personal chat id
+* - `29:xxx` — Bot Framework user id
+*
+* Display-name user targets such as `user:John Smith` intentionally return
+* false so that the Graph API directory lookup still runs for them.
+*/
+function looksLikeMSTeamsTargetId(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return false;
+	if (/^conversation:/i.test(trimmed)) return true;
+	if (/^user:/i.test(trimmed)) {
+		const id = trimmed.slice(5).trim();
+		return /^[0-9a-fA-F-]{16,}$/.test(id);
+	}
+	if (/^19:.+@thread\.(tacv2|skype)$/i.test(trimmed)) return true;
+	if (/^19:.+@unq\.gbl\.spaces$/i.test(trimmed)) return true;
+	if (/^a:1[A-Za-z0-9_-]+$/i.test(trimmed)) return true;
+	if (/^8:orgid:[A-Za-z0-9-]+$/i.test(trimmed)) return true;
+	if (/^29:[A-Za-z0-9_-]+$/i.test(trimmed)) return true;
+	return /@thread\b/i.test(trimmed);
+}
+function normalizeMSTeamsTeamKey(raw) {
+	return stripProviderPrefix(raw).replace(/^team:/i, "").trim() || void 0;
+}
+function normalizeMSTeamsChannelKey(raw) {
+	return (raw?.trim().replace(/^#/, "").trim() ?? "") || void 0;
+}
+function normalizeMSTeamsConversationTargetId(raw) {
+	const trimmed = stripProviderPrefix(raw).trim();
+	return parseMSTeamsConversationId(trimmed) ?? trimmed;
+}
+function looksLikeMSTeamsThreadConversationId(raw) {
+	const normalized = normalizeMSTeamsConversationTargetId(raw);
+	return /^19:.+@thread\./i.test(normalized);
+}
+function parseMSTeamsTeamChannelInput(raw) {
+	const trimmed = stripProviderPrefix(raw).trim();
+	if (!trimmed) return {};
+	const parts = trimmed.split("/");
+	const team = normalizeMSTeamsTeamKey(parts[0] ?? "");
+	const channel = parts.length > 1 ? normalizeMSTeamsChannelKey(parts.slice(1).join("/")) : void 0;
+	return {
+		...team ? { team } : {},
+		...channel ? { channel } : {}
+	};
+}
+function parseMSTeamsTeamEntry(raw) {
+	const { team, channel } = parseMSTeamsTeamChannelInput(raw);
+	if (!team) return null;
+	return {
+		teamKey: team,
+		...channel ? { channelKey: channel } : {}
+	};
+}
+async function resolveMSTeamsChannelAllowlist(params) {
+	let tokenPromise;
+	const getToken = () => {
+		tokenPromise ??= resolveGraphToken(params.cfg);
+		return tokenPromise;
+	};
+	return await mapAllowlistResolutionInputs({
+		inputs: params.entries,
+		mapInput: async (input) => {
+			const { team, channel } = parseMSTeamsTeamChannelInput(input);
+			if (!team) return {
+				input,
+				resolved: false
+			};
+			if (looksLikeMSTeamsThreadConversationId(team)) {
+				const teamId = normalizeMSTeamsConversationTargetId(team);
+				if (!channel) return {
+					input,
+					resolved: true,
+					teamId,
+					teamName: teamId
+				};
+				if (!looksLikeMSTeamsThreadConversationId(channel)) return {
+					input,
+					resolved: false,
+					teamId,
+					teamName: teamId,
+					note: "channel id required for conversation-id team"
+				};
+				const channelId = normalizeMSTeamsConversationTargetId(channel);
+				return {
+					input,
+					resolved: true,
+					teamId,
+					teamName: teamId,
+					channelId,
+					channelName: channelId
+				};
+			}
+			const token = await getToken();
+			const teams = /^[0-9a-fA-F-]{16,}$/.test(team) ? [{
+				id: team,
+				displayName: team
+			}] : await listTeamsByName(token, team);
+			if (teams.length === 0) return {
+				input,
+				resolved: false,
+				note: "team not found"
+			};
+			const teamMatch = teams[0];
+			const graphTeamId = teamMatch.id?.trim();
+			const teamName = teamMatch.displayName?.trim() || team;
+			if (!graphTeamId) return {
+				input,
+				resolved: false,
+				note: "team id missing"
+			};
+			let teamChannels = [];
+			try {
+				teamChannels = await listChannelsForTeam(token, graphTeamId);
+			} catch {}
+			const teamId = teamChannels.find((ch) => normalizeOptionalLowercaseString(ch.displayName) === "general")?.id?.trim() || graphTeamId;
+			if (!channel) return {
+				input,
+				resolved: true,
+				teamId,
+				teamName,
+				note: teams.length > 1 ? "multiple teams; chose first" : void 0
+			};
+			const normalizedChannel = normalizeOptionalLowercaseString(channel);
+			const channelMatch = teamChannels.find((item) => item.id === channel) ?? teamChannels.find((item) => normalizeOptionalLowercaseString(item.displayName) === normalizedChannel) ?? teamChannels.find((item) => normalizeLowercaseStringOrEmpty(item.displayName ?? "").includes(normalizedChannel ?? ""));
+			if (!channelMatch?.id) return {
+				input,
+				resolved: false,
+				note: "channel not found"
+			};
+			return {
+				input,
+				resolved: true,
+				teamId,
+				teamName,
+				channelId: channelMatch.id,
+				channelName: channelMatch.displayName ?? channel,
+				note: teamChannels.length > 1 ? "multiple channels; chose first" : void 0
+			};
+		}
+	});
+}
+async function resolveMSTeamsUserAllowlist(params) {
+	const token = await resolveGraphToken(params.cfg);
+	return await mapAllowlistResolutionInputs({
+		inputs: params.entries,
+		mapInput: async (input) => {
+			const query = normalizeQuery(normalizeMSTeamsUserInput(input));
+			if (!query) return {
+				input,
+				resolved: false
+			};
+			if (/^[0-9a-fA-F-]{16,}$/.test(query)) return {
+				input,
+				resolved: true,
+				id: query
+			};
+			const users = await searchGraphUsers({
+				token,
+				query,
+				top: 10
+			});
+			const match = users[0];
+			if (!match?.id) return {
+				input,
+				resolved: false
+			};
+			return {
+				input,
+				resolved: true,
+				id: match.id,
+				name: match.displayName ?? void 0,
+				note: users.length > 1 ? "multiple matches; chose first" : void 0
+			};
+		}
+	});
+}
+//#endregion
+export { parseMSTeamsTeamChannelInput as a, resolveMSTeamsUserAllowlist as c, parseMSTeamsConversationId as i, normalizeMSTeamsMessagingTarget as n, parseMSTeamsTeamEntry as o, normalizeMSTeamsUserInput as r, resolveMSTeamsChannelAllowlist as s, looksLikeMSTeamsTargetId as t };

package/dist/result-fallback-classifier-BWIh0wzc.js

@@ -0,0 +1,79 @@
+import { a as isGpt5ModelId } from "./gpt5-prompt-overlay-ijXG4a4G.js";
+import { r as isSilentReplyPayloadText } from "./tokens-D8MVQSp9.js";
+import { d as hasOutboundDeliveryEvidence, f as hasVisibleAgentPayload } from "./subagent-announce-delivery-jcxPIfNG.js";
+//#region src/agents/pi-embedded-runner/result-fallback-classifier.ts
+const EMPTY_TERMINAL_REPLY_RE = /Agent couldn't generate a response/i;
+const PLAN_ONLY_TERMINAL_REPLY_RE = /Agent stopped after repeated plan-only turns/i;
+function isEmbeddedPiRunResult(value) {
+	return Boolean(value && typeof value === "object" && "meta" in value && value.meta && typeof value.meta === "object");
+}
+function hasDeliberateSilentTerminalReply(result) {
+	if (result.meta.error?.kind === "hook_block") return true;
+	return [result.meta.finalAssistantRawText, result.meta.finalAssistantVisibleText].some((text) => typeof text === "string" && isSilentReplyPayloadText(text));
+}
+function classifyHarnessResult(params) {
+	switch (params.result.meta.agentHarnessResultClassification) {
+		case "empty": return {
+			message: `${params.provider}/${params.model} ended without a visible assistant reply`,
+			reason: "format",
+			code: "empty_result"
+		};
+		case "reasoning-only": return {
+			message: `${params.provider}/${params.model} ended with reasoning only`,
+			reason: "format",
+			code: "reasoning_only_result"
+		};
+		case "planning-only": return {
+			message: `${params.provider}/${params.model} exhausted plan-only retries without taking action`,
+			reason: "format",
+			code: "planning_only_result"
+		};
+		default: return null;
+	}
+}
+function classifyEmbeddedPiRunResultForModelFallback(params) {
+	if (!isEmbeddedPiRunResult(params.result)) return null;
+	if (params.result.meta.aborted || params.hasDirectlySentBlockReply === true || params.hasBlockReplyPipelineOutput === true || hasVisibleAgentPayload(params.result, {
+		includeErrorPayloads: false,
+		includeReasoningPayloads: false
+	})) return null;
+	if (hasOutboundDeliveryEvidence(params.result)) return null;
+	const harnessClassification = classifyHarnessResult({
+		provider: params.provider,
+		model: params.model,
+		result: params.result
+	});
+	if (harnessClassification) return harnessClassification;
+	const payloads = params.result.payloads ?? [];
+	const errorText = payloads.filter((payload) => payload?.isError === true).map((payload) => typeof payload.text === "string" ? payload.text : "").join("\n");
+	if (EMPTY_TERMINAL_REPLY_RE.test(errorText)) return {
+		message: `${params.provider}/${params.model} ended with an incomplete terminal response`,
+		reason: "format",
+		code: "incomplete_result"
+	};
+	if (!isGpt5ModelId(params.model)) return null;
+	if (payloads.length === 0 && hasDeliberateSilentTerminalReply(params.result)) return null;
+	if (payloads.length === 0) return {
+		message: `${params.provider}/${params.model} ended without a visible assistant reply`,
+		reason: "format",
+		code: "empty_result"
+	};
+	if (payloads.every((payload) => payload.isReasoning === true)) return {
+		message: `${params.provider}/${params.model} ended with reasoning only`,
+		reason: "format",
+		code: "reasoning_only_result"
+	};
+	if (PLAN_ONLY_TERMINAL_REPLY_RE.test(errorText)) return {
+		message: `${params.provider}/${params.model} exhausted plan-only retries without taking action`,
+		reason: "format",
+		code: "planning_only_result"
+	};
+	if (!EMPTY_TERMINAL_REPLY_RE.test(errorText)) return null;
+	return {
+		message: `${params.provider}/${params.model} ended with an incomplete terminal response`,
+		reason: "format",
+		code: "incomplete_result"
+	};
+}
+//#endregion
+export { classifyEmbeddedPiRunResultForModelFallback as t };

package/dist/root-help-8a3TWleF.js

@@ -0,0 +1,43 @@
+import { C as collectUniqueCommandDescriptors, S as addCommandDescriptorsToProgram, h as getSubCliEntries, v as getCoreCliCommandDescriptors } from "./argv-BGyjKEXu.js";
+import { n as VERSION } from "./version-j6aVEPCK.js";
+import { t as configureProgramHelp } from "./help-BgDd1atJ.js";
+import { t as getPluginCliCommandDescriptors } from "./cli-C2GeKxjx.js";
+import { Command } from "commander";
+//#region src/cli/program/root-help.ts
+async function buildRootHelpProgram(renderOptions) {
+	const program = new Command();
+	configureProgramHelp(program, {
+		programVersion: VERSION,
+		channelOptions: [],
+		messageChannelOptions: "",
+		agentChannelOptions: ""
+	});
+	const pluginDescriptors = renderOptions?.includePluginDescriptors === true || renderOptions?.config ? await getPluginCliCommandDescriptors(renderOptions.config, renderOptions.env, { pluginSdkResolution: renderOptions.pluginSdkResolution }) : [];
+	addCommandDescriptorsToProgram(program, collectUniqueCommandDescriptors([
+		getCoreCliCommandDescriptors(),
+		getSubCliEntries(),
+		pluginDescriptors
+	]));
+	return program;
+}
+async function renderRootHelpText(renderOptions) {
+	const program = await buildRootHelpProgram(renderOptions);
+	let output = "";
+	const originalWrite = process.stdout.write.bind(process.stdout);
+	const captureWrite = ((chunk) => {
+		output += String(chunk);
+		return true;
+	});
+	process.stdout.write = captureWrite;
+	try {
+		program.outputHelp();
+	} finally {
+		process.stdout.write = originalWrite;
+	}
+	return output;
+}
+async function outputRootHelp(renderOptions) {
+	process.stdout.write(await renderRootHelpText(renderOptions));
+}
+//#endregion
+export { outputRootHelp };