fengming 0.3.7 → 0.3.9

package/dist/attempt.prompt-helpers-ByKj-vQ7.js

@@ -0,0 +1,543 @@
+import { c as normalizeOptionalString } from "./string-coerce-DKw2K5wM.js";
+import { a as isSubagentSessionKey, i as isCronSessionKey, l as parseRawSessionConversationRef } from "./session-key-utils-CdfsDYvz.js";
+import { a as normalizeOptionalAgentRuntimeId } from "./agent-runtime-id-DMrPVcZQ.js";
+import { d as resolveSelectedOpenAIRuntimeProvider, s as openAIProviderUsesCodexRuntimeByDefault } from "./openai-codex-routing-CJw0IxWE.js";
+import { C as drainPluginNextTurnInjectionContext } from "./loader-Ct7uZnva.js";
+import { c as joinPresentTextSegments } from "./hook-runner-global-De3loPgD.js";
+import { N as buildPluginAgentTurnPrepareContext } from "./runtime-CQgf-ok4.js";
+import { n as derivePromptTokens } from "./usage-B1VvYcZy.js";
+import { c as buildActiveMediaGenerationTaskPromptContextForSession, i as buildActiveMusicGenerationTaskPromptContextForSession, s as buildActiveImageGenerationTaskPromptContextForSession } from "./fengming-tools-DBLsJfsf.js";
+import { t as log } from "./logger-D_qbOBRF.js";
+import { n as normalizeStructuredPromptSection } from "./prompt-cache-stability-BpSRjx-n.js";
+import { n as prependSystemPromptAdditionAfterCacheBoundary } from "./system-prompt-cache-boundary-Dlr-f5oA.js";
+import { n as resolveProcessToolScopeKey } from "./agent-tools-CET9usCz.js";
+import { c as resolveEffectiveToolFsWorkspaceOnly } from "./local-roots-B0mKVk2X.js";
+import { o as deriveSessionName } from "./bash-tools.shared-Bb5t2u25.js";
+import { l as listRunningSessions } from "./bash-process-registry-DExu0hla.js";
+import { t as resolveHeartbeatPromptForSystemPrompt } from "./heartbeat-system-prompt-Di1gIFws.js";
+import { t as resolveBoundAgentIdForSession } from "./session-agent-binding-CVv1ueok.js";
+//#region src/plugins/hook-agent-context.ts
+const TARGET_PREFIXES = new Set([
+	"channel",
+	"chat",
+	"direct",
+	"dm",
+	"group",
+	"thread",
+	"user"
+]);
+function normalizeKey(value) {
+	return (value ?? "").trim().toLowerCase();
+}
+function stripConversationPrefix(value, ...providers) {
+	const text = normalizeOptionalString(value);
+	if (!text) return;
+	const separatorIndex = text.indexOf(":");
+	if (separatorIndex === -1) return text;
+	const prefix = normalizeKey(text.slice(0, separatorIndex));
+	const suffix = normalizeOptionalString(text.slice(separatorIndex + 1));
+	if (!suffix) return text;
+	if (TARGET_PREFIXES.has(prefix) || providers.some((provider) => prefix === normalizeKey(provider))) return suffix;
+	return text;
+}
+function resolveAgentHookChannelId(params) {
+	const provider = normalizeOptionalString(params.messageProvider);
+	const messageChannel = normalizeOptionalString(params.messageChannel);
+	const parsed = parseRawSessionConversationRef(params.sessionKey);
+	if (parsed?.rawId) return parsed.rawId;
+	const metadataChannel = stripConversationPrefix(params.currentChannelId ?? void 0, provider, messageChannel) ?? stripConversationPrefix(params.messageTo ?? void 0, provider, messageChannel);
+	if (metadataChannel && normalizeKey(metadataChannel) !== normalizeKey(provider)) return metadataChannel;
+	const strippedMessageChannel = stripConversationPrefix(params.messageChannel ?? void 0, provider, messageChannel);
+	if (strippedMessageChannel && normalizeKey(strippedMessageChannel) !== normalizeKey(provider)) return strippedMessageChannel;
+	return messageChannel ?? provider;
+}
+function buildAgentHookContextChannelFields(params) {
+	return {
+		messageProvider: normalizeOptionalString(params.messageProvider),
+		channelId: resolveAgentHookChannelId(params)
+	};
+}
+//#endregion
+//#region src/agents/bash-process-references.ts
+const DEFAULT_ACTIVE_PROCESS_LIMIT = 8;
+const MAX_COMMAND_LABEL_CHARS = 140;
+function truncate(value, maxChars) {
+	if (value.length <= maxChars) return value;
+	if (maxChars <= 1) return value.slice(0, maxChars);
+	return `${value.slice(0, Math.max(0, maxChars - 3))}...`;
+}
+function listActiveProcessSessionReferences(params) {
+	const scopeKey = params.scopeKey?.trim();
+	if (!scopeKey) return [];
+	const now = params.now ?? Date.now();
+	const limit = typeof params.limit === "number" && Number.isFinite(params.limit) && params.limit > 0 ? Math.floor(params.limit) : DEFAULT_ACTIVE_PROCESS_LIMIT;
+	return listRunningSessions().filter((session) => session.backgrounded).filter((session) => session.scopeKey === scopeKey).toSorted((left, right) => right.startedAt - left.startedAt).slice(0, limit).map((session) => ({
+		sessionId: session.id,
+		status: "running",
+		pid: session.pid ?? session.child?.pid,
+		startedAt: session.startedAt,
+		runtimeMs: Math.max(0, now - session.startedAt),
+		cwd: session.cwd,
+		command: session.command,
+		name: truncate(deriveSessionName(session.command) || session.command, MAX_COMMAND_LABEL_CHARS),
+		tail: session.tail,
+		truncated: session.truncated
+	}));
+}
+//#endregion
+//#region src/agents/embedded-agent-runner/context-engine-capabilities.ts
+/**
+* Build host-owned capabilities that are bound to one context-engine runtime call.
+*/
+function resolveContextEngineCapabilities(params) {
+	const sessionKey = normalizeOptionalString(params.sessionKey);
+	const agentId = resolveBoundAgentIdForSession({
+		config: params.config,
+		sessionKey,
+		agentId: params.agentId
+	});
+	const contextEnginePluginId = normalizeOptionalString(params.contextEnginePluginId);
+	return { llm: { complete: async (request) => {
+		const { createRuntimeLlm } = await import("./runtime-llm.runtime.js");
+		return await createRuntimeLlm({
+			getConfig: () => params.config,
+			authority: {
+				caller: {
+					kind: "context-engine",
+					id: params.purpose
+				},
+				requiresBoundAgent: true,
+				...sessionKey ? { sessionKey } : {},
+				...agentId ? { agentId } : {},
+				...params.authProfileId ? { preferredProfile: params.authProfileId } : {},
+				...contextEnginePluginId ? { pluginIdForPolicy: contextEnginePluginId } : {},
+				allowAgentIdOverride: false,
+				allowModelOverride: false,
+				allowComplete: true
+			}
+		}).complete(request);
+	} } };
+}
+//#endregion
+//#region src/agents/hook-system-context-boundary.ts
+const HOOK_SYSTEM_CONTEXT_HEADER = "FengMing plugin-injected system context. This block is not workspace file content.";
+function wrapPluginSystemContextSection(value) {
+	if (typeof value !== "string") return;
+	const normalized = normalizeStructuredPromptSection(value);
+	if (!normalized) return;
+	return `---\n\n${HOOK_SYSTEM_CONTEXT_HEADER}\n\n${normalized}\n\n---`;
+}
+//#endregion
+//#region src/agents/video-generation-task-status.ts
+const VIDEO_GENERATION_TASK_KIND = "video_generation";
+const VIDEO_GENERATION_SOURCE_PREFIX = "video_generate";
+function buildActiveVideoGenerationTaskPromptContextForSession(sessionKey) {
+	return buildActiveMediaGenerationTaskPromptContextForSession({
+		sessionKey,
+		taskKind: VIDEO_GENERATION_TASK_KIND,
+		sourcePrefix: VIDEO_GENERATION_SOURCE_PREFIX,
+		nounLabel: "Video generation",
+		toolName: "video_generate",
+		completionLabel: "videos"
+	});
+}
+//#endregion
+//#region src/agents/embedded-agent-runner/compaction-runtime-context.ts
+/**
+* Resolve the effective compaction target from config, falling back to the
+* caller-supplied provider/model and optionally applying runtime defaults.
+*/
+function resolveEmbeddedCompactionTarget(params) {
+	const provider = params.provider?.trim() || params.defaultProvider;
+	const model = params.modelId?.trim() || params.defaultModel;
+	const override = params.config?.agents?.defaults?.compaction?.model?.trim();
+	const resolveTargetProviders = (targetProvider, authProfileId) => {
+		if (!targetProvider) return {};
+		const useCodexHarnessRuntime = shouldUseCodexRuntimeProviderForCompaction({
+			config: params.config,
+			provider: targetProvider,
+			harnessRuntime: params.harnessRuntime
+		});
+		const runtimeProvider = resolveSelectedOpenAIRuntimeProvider({
+			provider: targetProvider,
+			harnessRuntime: (useCodexHarnessRuntime ? params.harnessRuntime : "fengming") ?? void 0,
+			authProfileId,
+			config: params.config
+		});
+		const routedRuntimeProvider = runtimeProvider === targetProvider ? void 0 : runtimeProvider;
+		return {
+			runtimeProvider: routedRuntimeProvider,
+			contextProvider: useCodexHarnessRuntime ? routedRuntimeProvider : void 0
+		};
+	};
+	if (!override) {
+		const authProfileId = params.authProfileId ?? void 0;
+		return {
+			provider,
+			...resolveTargetProviders(provider, authProfileId),
+			model,
+			authProfileId
+		};
+	}
+	const slashIdx = override.indexOf("/");
+	if (slashIdx > 0) {
+		const overrideProvider = override.slice(0, slashIdx).trim();
+		const overrideModel = override.slice(slashIdx + 1).trim() || params.defaultModel;
+		const authProfileId = overrideProvider !== (params.provider ?? "")?.trim() ? void 0 : params.authProfileId ?? void 0;
+		return {
+			provider: overrideProvider,
+			...resolveTargetProviders(overrideProvider, authProfileId),
+			model: overrideModel,
+			authProfileId
+		};
+	}
+	const authProfileId = params.authProfileId ?? void 0;
+	return {
+		provider,
+		...resolveTargetProviders(provider, authProfileId),
+		model: override,
+		authProfileId
+	};
+}
+function shouldUseCodexRuntimeProviderForCompaction(params) {
+	if (normalizeOptionalAgentRuntimeId(params.harnessRuntime) !== "codex") return false;
+	if (!openAIProviderUsesCodexRuntimeByDefault(params)) return false;
+	return true;
+}
+function buildEmbeddedCompactionRuntimeContext(params) {
+	const resolved = resolveEmbeddedCompactionTarget({
+		config: params.config,
+		provider: params.provider,
+		modelId: params.modelId,
+		authProfileId: params.authProfileId,
+		harnessRuntime: params.harnessRuntime
+	});
+	const agentHarnessId = params.harnessRuntime?.trim() || void 0;
+	const processScopeKey = params.sessionKey?.trim();
+	const activeProcessSessions = params.activeProcessSessions ?? listActiveProcessSessionReferences({ scopeKey: processScopeKey });
+	return {
+		sessionKey: params.sessionKey ?? void 0,
+		messageChannel: params.messageChannel ?? void 0,
+		messageProvider: params.messageProvider ?? void 0,
+		agentAccountId: params.agentAccountId ?? void 0,
+		currentChannelId: params.currentChannelId ?? void 0,
+		currentThreadTs: params.currentThreadTs ?? void 0,
+		currentMessageId: params.currentMessageId ?? void 0,
+		authProfileId: resolved.authProfileId,
+		agentHarnessId,
+		workspaceDir: params.workspaceDir,
+		cwd: params.cwd ?? void 0,
+		agentDir: params.agentDir,
+		config: params.config,
+		skillsSnapshot: params.skillsSnapshot,
+		senderIsOwner: params.senderIsOwner,
+		senderId: params.senderId ?? void 0,
+		provider: resolved.provider,
+		runtimeProvider: resolved.runtimeProvider,
+		model: resolved.model,
+		modelFallbacksOverride: params.modelFallbacksOverride,
+		thinkLevel: params.thinkLevel,
+		reasoningLevel: params.reasoningLevel,
+		bashElevated: params.bashElevated,
+		extraSystemPrompt: params.extraSystemPrompt,
+		sourceReplyDeliveryMode: params.sourceReplyDeliveryMode,
+		ownerNumbers: params.ownerNumbers,
+		...activeProcessSessions.length > 0 ? { activeProcessSessions } : {}
+	};
+}
+//#endregion
+//#region src/agents/embedded-agent-runner/run/trigger-policy.ts
+const DEFAULT_EMBEDDED_RUN_TRIGGER_POLICY = { injectHeartbeatPrompt: false };
+const EMBEDDED_RUN_TRIGGER_POLICY = { heartbeat: { injectHeartbeatPrompt: true } };
+function shouldInjectHeartbeatPromptForTrigger(trigger) {
+	return (trigger ? EMBEDDED_RUN_TRIGGER_POLICY[trigger] : void 0)?.injectHeartbeatPrompt ?? DEFAULT_EMBEDDED_RUN_TRIGGER_POLICY.injectHeartbeatPrompt;
+}
+//#endregion
+//#region src/agents/embedded-agent-runner/run/attempt.prompt-helpers.ts
+const PROMPT_BUILD_DRAIN_CACHE_MAX = 256;
+const promptBuildDrainCache = /* @__PURE__ */ new Map();
+function rememberDrainedInjections(runId, injections) {
+	if (promptBuildDrainCache.has(runId)) promptBuildDrainCache.delete(runId);
+	else if (promptBuildDrainCache.size >= PROMPT_BUILD_DRAIN_CACHE_MAX) {
+		const oldest = promptBuildDrainCache.keys().next().value;
+		if (oldest !== void 0) promptBuildDrainCache.delete(oldest);
+	}
+	promptBuildDrainCache.set(runId, injections);
+}
+/**
+* Releases the per-run drained-injection cache. Call when a run terminates so
+* the cap stays headroom for active runs.
+*/
+function forgetPromptBuildDrainCacheForRun(runId) {
+	if (runId) promptBuildDrainCache.delete(runId);
+}
+async function resolvePromptBuildHookResult(params) {
+	const runId = params.hookCtx.runId;
+	const cachedInjections = runId ? promptBuildDrainCache.get(runId) : void 0;
+	const queuedContext = cachedInjections ? {
+		queuedInjections: cachedInjections,
+		...buildPluginAgentTurnPrepareContext({ queuedInjections: cachedInjections })
+	} : await drainPluginNextTurnInjectionContext({
+		cfg: params.config,
+		sessionKey: params.hookCtx.sessionKey
+	});
+	if (runId && !cachedInjections) rememberDrainedInjections(runId, queuedContext.queuedInjections);
+	const turnPrepareResult = params.hookRunner?.runAgentTurnPrepare && params.hookRunner.hasHooks("agent_turn_prepare") ? await params.hookRunner.runAgentTurnPrepare({
+		prompt: params.prompt,
+		messages: params.messages,
+		queuedInjections: queuedContext.queuedInjections
+	}, params.hookCtx).catch((hookErr) => {
+		log.warn(`agent_turn_prepare hook failed: ${String(hookErr)}`);
+	}) : void 0;
+	const heartbeatContribution = params.hookCtx.trigger === "heartbeat" && params.hookRunner?.runHeartbeatPromptContribution && params.hookRunner.hasHooks("heartbeat_prompt_contribution") ? await params.hookRunner.runHeartbeatPromptContribution({
+		sessionKey: params.hookCtx.sessionKey,
+		agentId: params.hookCtx.agentId,
+		heartbeatName: "heartbeat"
+	}, params.hookCtx).catch((hookErr) => {
+		log.warn(`heartbeat_prompt_contribution hook failed: ${String(hookErr)}`);
+	}) : void 0;
+	const promptBuildResult = params.hookRunner?.hasHooks("before_prompt_build") ? await params.hookRunner.runBeforePromptBuild({
+		prompt: params.prompt,
+		messages: params.messages
+	}, params.hookCtx).catch((hookErr) => {
+		log.warn(`before_prompt_build hook failed: ${String(hookErr)}`);
+	}) : void 0;
+	const beforeAgentStartResult = params.beforeAgentStartResult ?? (params.hookRunner?.hasHooks("before_agent_start") ? await params.hookRunner.runBeforeAgentStart({
+		prompt: params.prompt,
+		messages: params.messages
+	}, params.hookCtx).catch((hookErr) => {
+		log.warn(`deprecated before_agent_start hook failed during prompt build: ${String(hookErr)}`);
+	}) : void 0);
+	return {
+		systemPrompt: promptBuildResult?.systemPrompt ?? beforeAgentStartResult?.systemPrompt,
+		prependContext: joinPresentTextSegments([
+			queuedContext.prependContext,
+			turnPrepareResult?.prependContext,
+			heartbeatContribution?.prependContext,
+			promptBuildResult?.prependContext,
+			beforeAgentStartResult?.prependContext
+		]),
+		appendContext: joinPresentTextSegments([
+			queuedContext.appendContext,
+			turnPrepareResult?.appendContext,
+			heartbeatContribution?.appendContext,
+			promptBuildResult?.appendContext,
+			beforeAgentStartResult?.appendContext
+		]),
+		prependSystemContext: joinPresentTextSegments([wrapPluginSystemContextSection(promptBuildResult?.prependSystemContext), wrapPluginSystemContextSection(beforeAgentStartResult?.prependSystemContext)]),
+		appendSystemContext: joinPresentTextSegments([wrapPluginSystemContextSection(promptBuildResult?.appendSystemContext), wrapPluginSystemContextSection(beforeAgentStartResult?.appendSystemContext)])
+	};
+}
+function resolvePromptModeForSession(sessionKey) {
+	if (!sessionKey) return "full";
+	return isSubagentSessionKey(sessionKey) || isCronSessionKey(sessionKey) ? "minimal" : "full";
+}
+function shouldInjectHeartbeatPrompt(params) {
+	return params.isDefaultAgent && shouldInjectHeartbeatPromptForTrigger(params.trigger) && Boolean(resolveHeartbeatPromptForSystemPrompt({
+		config: params.config,
+		agentId: params.agentId,
+		defaultAgentId: params.defaultAgentId
+	}));
+}
+function shouldWarnOnOrphanedUserRepair(trigger) {
+	return trigger === "user" || trigger === "manual";
+}
+function resolvePromptSubmissionSkipReason(params) {
+	if (params.prompt.trim().length > 0 || params.imageCount > 0) return null;
+	return params.messages.some(hasVisiblePromptHistory) ? "blank_user_prompt" : "empty_prompt_history_images";
+}
+function hasVisiblePromptHistory(message) {
+	if (!message || typeof message !== "object") return false;
+	const record = message;
+	if (record.role !== "user" && record.role !== "assistant") return false;
+	return hasNonEmptyContent(record.content);
+}
+function hasNonEmptyContent(content) {
+	if (typeof content === "string") return content.trim().length > 0;
+	if (Array.isArray(content)) return content.some(hasNonEmptyContent);
+	if (!content || typeof content !== "object") return false;
+	const record = content;
+	return hasNonEmptyContent(record.text) || hasNonEmptyContent(record.content);
+}
+const QUEUED_USER_MESSAGE_MARKER = "[Queued user message that arrived while the previous turn was still active]";
+const MAX_STRUCTURED_MEDIA_REF_CHARS = 300;
+const MAX_STRUCTURED_JSON_STRING_CHARS = 300;
+const MAX_STRUCTURED_JSON_DEPTH = 4;
+const MAX_STRUCTURED_JSON_ARRAY_ITEMS = 16;
+const MAX_STRUCTURED_JSON_OBJECT_KEYS = 32;
+function summarizeStructuredMediaRef(label, value) {
+	if (typeof value !== "string") return;
+	const trimmed = value.trim();
+	if (!trimmed) return;
+	const dataUriMatch = trimmed.match(/^data:([^;,]+)?(?:;[^,]*)?,/i);
+	if (dataUriMatch) return `[${label}] inline data URI (${dataUriMatch[1]?.trim() || "unknown"}, ${trimmed.length} chars)`;
+	if (trimmed.length > MAX_STRUCTURED_MEDIA_REF_CHARS) return `[${label}] ${trimmed.slice(0, MAX_STRUCTURED_MEDIA_REF_CHARS)}... (${trimmed.length} chars)`;
+	return `[${label}] ${trimmed}`;
+}
+function summarizeStructuredJsonString(value) {
+	const mediaSummary = summarizeStructuredMediaRef("value", value);
+	if (mediaSummary?.includes("inline data URI")) return mediaSummary;
+	const trimmed = value.trim();
+	if (trimmed.length > MAX_STRUCTURED_JSON_STRING_CHARS) return `${trimmed.slice(0, MAX_STRUCTURED_JSON_STRING_CHARS)}... (${trimmed.length} chars)`;
+	return value;
+}
+function sanitizeStructuredJsonValue(value, depth = 0, seen = /* @__PURE__ */ new WeakSet()) {
+	if (typeof value === "string") return summarizeStructuredJsonString(value);
+	if (!value || typeof value !== "object") return value;
+	if (seen.has(value)) return "[circular]";
+	if (depth >= MAX_STRUCTURED_JSON_DEPTH) return "[max depth]";
+	seen.add(value);
+	if (Array.isArray(value)) {
+		const limited = value.slice(0, MAX_STRUCTURED_JSON_ARRAY_ITEMS).map((item) => sanitizeStructuredJsonValue(item, depth + 1, seen));
+		if (value.length > MAX_STRUCTURED_JSON_ARRAY_ITEMS) limited.push(`[${value.length - MAX_STRUCTURED_JSON_ARRAY_ITEMS} more items]`);
+		seen.delete(value);
+		return limited;
+	}
+	const output = {};
+	let copied = 0;
+	let skipped = 0;
+	for (const key in value) {
+		if (!Object.hasOwn(value, key)) continue;
+		if (copied >= MAX_STRUCTURED_JSON_OBJECT_KEYS) {
+			skipped += 1;
+			continue;
+		}
+		output[key] = sanitizeStructuredJsonValue(value[key], depth + 1, seen);
+		copied += 1;
+	}
+	if (skipped > 0) output["__truncated"] = `${skipped} more keys`;
+	seen.delete(value);
+	return output;
+}
+function stringifyStructuredJsonFallback(part) {
+	try {
+		const serialized = JSON.stringify(sanitizeStructuredJsonValue(part));
+		if (!serialized || serialized === "{}") return;
+		const withoutInlineData = serialized.replace(/data:[^"'\\\s]+/gi, (match) => `[inline data URI: ${match.length} chars]`);
+		return withoutInlineData.length > 1e3 ? `${withoutInlineData.slice(0, 1e3)}... (${withoutInlineData.length} chars)` : withoutInlineData;
+	} catch {
+		return;
+	}
+}
+function stringifyStructuredContentPart(part) {
+	if (!part || typeof part !== "object") return;
+	const record = part;
+	if (record.type === "text") return (typeof record.text === "string" ? record.text.trim() : "") || void 0;
+	if (record.type === "image_url") {
+		const imageUrl = record.image_url;
+		return summarizeStructuredMediaRef("image_url", typeof imageUrl === "string" ? imageUrl : imageUrl && typeof imageUrl === "object" ? imageUrl.url : void 0);
+	}
+	if (record.type === "image" || record.type === "input_image") return summarizeStructuredMediaRef(record.type, record.url) ?? summarizeStructuredMediaRef(record.type, record.source);
+	if (typeof record.type === "string") {
+		const typedRef = summarizeStructuredMediaRef(record.type, record.audio_url) ?? summarizeStructuredMediaRef(record.type, record.media_url) ?? summarizeStructuredMediaRef(record.type, record.url) ?? summarizeStructuredMediaRef(record.type, record.source);
+		if (typedRef) return typedRef;
+	}
+	return stringifyStructuredJsonFallback(part);
+}
+function extractUserMessagePromptText(content) {
+	if (typeof content === "string") return content.trim() || void 0;
+	if (!Array.isArray(content)) return;
+	return content.flatMap((part) => {
+		const text = stringifyStructuredContentPart(part);
+		return text ? [text] : [];
+	}).join("\n").trim() || void 0;
+}
+function promptAlreadyIncludesQueuedUserMessage(prompt, orphanText) {
+	const normalizedPrompt = prompt.replace(/\r\n/g, "\n");
+	const normalizedOrphanText = orphanText.replace(/\r\n/g, "\n").trim();
+	if (!normalizedOrphanText) return false;
+	const queuedBlockPrefix = `${QUEUED_USER_MESSAGE_MARKER}\n${normalizedOrphanText}`;
+	return normalizedPrompt === queuedBlockPrefix || normalizedPrompt.startsWith(`${queuedBlockPrefix}\n`) || normalizedPrompt.includes(`\n${queuedBlockPrefix}\n`) || `\n${normalizedPrompt}\n`.includes(`\n${normalizedOrphanText}\n`);
+}
+function mergeOrphanedTrailingUserPrompt(params) {
+	const orphanText = extractUserMessagePromptText(params.leafMessage.content);
+	if (!orphanText) return {
+		prompt: params.prompt,
+		merged: false,
+		removeLeaf: true
+	};
+	if (promptAlreadyIncludesQueuedUserMessage(params.prompt, orphanText)) return {
+		prompt: params.prompt,
+		merged: false,
+		removeLeaf: true
+	};
+	return {
+		prompt: [
+			QUEUED_USER_MESSAGE_MARKER,
+			orphanText,
+			"",
+			params.prompt
+		].join("\n"),
+		merged: true,
+		removeLeaf: true
+	};
+}
+function resolveAttemptFsWorkspaceOnly(params) {
+	return resolveEffectiveToolFsWorkspaceOnly({
+		cfg: params.config,
+		agentId: params.sessionAgentId
+	});
+}
+function prependSystemPromptAddition(params) {
+	return prependSystemPromptAdditionAfterCacheBoundary(params);
+}
+function resolveAttemptPrependSystemContext(params) {
+	return joinPresentTextSegments([...params.trigger === "user" || params.trigger === "manual" ? [
+		buildActiveImageGenerationTaskPromptContextForSession(params.sessionKey),
+		buildActiveVideoGenerationTaskPromptContextForSession(params.sessionKey),
+		buildActiveMusicGenerationTaskPromptContextForSession(params.sessionKey)
+	] : [], params.hookPrependSystemContext]);
+}
+/** Build runtime context passed into context-engine afterTurn hooks. */
+function buildAfterTurnRuntimeContext(params) {
+	return {
+		...buildEmbeddedCompactionRuntimeContext({
+			sessionKey: params.attempt.sessionKey,
+			messageChannel: params.attempt.messageChannel,
+			messageProvider: params.attempt.messageProvider,
+			agentAccountId: params.attempt.agentAccountId,
+			currentChannelId: params.attempt.currentChannelId,
+			currentThreadTs: params.attempt.currentThreadTs,
+			currentMessageId: params.attempt.currentMessageId,
+			authProfileId: params.attempt.authProfileId,
+			workspaceDir: params.workspaceDir,
+			cwd: params.cwd,
+			agentDir: params.agentDir,
+			config: params.attempt.config,
+			skillsSnapshot: params.attempt.skillsSnapshot,
+			senderId: params.attempt.senderId,
+			provider: params.attempt.provider,
+			modelId: params.attempt.modelId,
+			harnessRuntime: params.attempt.agentHarnessId,
+			thinkLevel: params.attempt.thinkLevel,
+			reasoningLevel: params.attempt.reasoningLevel,
+			bashElevated: params.attempt.bashElevated,
+			extraSystemPrompt: params.attempt.extraSystemPrompt,
+			ownerNumbers: params.attempt.ownerNumbers,
+			activeProcessSessions: listActiveProcessSessionReferences({ scopeKey: resolveProcessToolScopeKey({
+				sessionKey: params.attempt.sandboxSessionKey?.trim() || params.attempt.sessionKey,
+				sessionId: params.attempt.sessionId,
+				agentId: params.activeAgentId
+			}) })
+		}),
+		...resolveContextEngineCapabilities({
+			config: params.attempt.config,
+			sessionKey: params.attempt.sessionKey,
+			agentId: params.activeAgentId,
+			authProfileId: params.attempt.authProfileId,
+			contextEnginePluginId: params.contextEnginePluginId,
+			purpose: "context-engine.after-turn"
+		}),
+		...typeof params.tokenBudget === "number" && Number.isFinite(params.tokenBudget) && params.tokenBudget > 0 ? { tokenBudget: Math.floor(params.tokenBudget) } : {},
+		...typeof params.currentTokenCount === "number" && Number.isFinite(params.currentTokenCount) && params.currentTokenCount > 0 ? { currentTokenCount: Math.floor(params.currentTokenCount) } : {},
+		...params.promptCache ? { promptCache: params.promptCache } : {}
+	};
+}
+function buildAfterTurnRuntimeContextFromUsage(params) {
+	return buildAfterTurnRuntimeContext({
+		...params,
+		currentTokenCount: derivePromptTokens(params.lastCallUsage)
+	});
+}
+//#endregion
+export { listActiveProcessSessionReferences as _, prependSystemPromptAddition as a, resolvePromptBuildHookResult as c, shouldInjectHeartbeatPrompt as d, shouldWarnOnOrphanedUserRepair as f, resolveContextEngineCapabilities as g, wrapPluginSystemContextSection as h, mergeOrphanedTrailingUserPrompt as i, resolvePromptModeForSession as l, resolveEmbeddedCompactionTarget as m, buildAfterTurnRuntimeContextFromUsage as n, resolveAttemptFsWorkspaceOnly as o, buildEmbeddedCompactionRuntimeContext as p, forgetPromptBuildDrainCacheForRun as r, resolveAttemptPrependSystemContext as s, buildAfterTurnRuntimeContext as t, resolvePromptSubmissionSkipReason as u, buildAgentHookContextChannelFields as v };

package/dist/auto-reply/reply/commands-crestodian.d.ts

@@ -1,4 +1,4 @@
-import { n as CommandHandler } from "../../commands-types-B67CsqXf.js";
+import { n as CommandHandler } from "../../commands-types-MXHhrssO.js";
 
 //#region src/auto-reply/reply/commands-crestodian.d.ts
 declare const handleCrestodianCommand: CommandHandler;

package/dist/binding-routing-EGRNvRC4.js

@@ -0,0 +1,113 @@
+import { r as isCronRunSessionKey } from "./session-key-utils-CdfsDYvz.js";
+import { d as resolveAgentIdFromSessionKey } from "./session-key-CJf5_zWs.js";
+import { r as logVerbose } from "./globals-BMM_rcFF.js";
+import { n as getSessionBindingService } from "./session-binding-service-BjjMIxQb.js";
+import { n as deriveLastRoutePolicy } from "./resolve-route-BiiTEeds.js";
+import { n as resolveConfiguredBinding } from "./binding-registry-BefkJK2t.js";
+import { t as ensureConfiguredBindingTargetReady } from "./binding-targets-B9vYS8n6.js";
+//#region src/channels/plugins/binding-routing.ts
+const CONFIGURED_BINDING_ROUTE_READY_TIMEOUT_MS = 3e4;
+function resolveConfiguredBindingConversationRef(params) {
+	if ("conversation" in params) return params.conversation;
+	return {
+		channel: params.channel,
+		accountId: params.accountId,
+		conversationId: params.conversationId,
+		parentConversationId: params.parentConversationId
+	};
+}
+function isPluginOwnedRuntimeBindingRecord(record) {
+	const metadata = record?.metadata;
+	if (!metadata || typeof metadata !== "object") return false;
+	return metadata.pluginBindingOwner === "plugin" && typeof metadata.pluginId === "string" && typeof metadata.pluginRoot === "string";
+}
+function resolveConfiguredBindingRoute(params) {
+	const bindingResolution = resolveConfiguredBinding({
+		cfg: params.cfg,
+		conversation: resolveConfiguredBindingConversationRef(params)
+	}) ?? null;
+	if (!bindingResolution) return {
+		bindingResolution: null,
+		route: params.route
+	};
+	const boundSessionKey = bindingResolution.statefulTarget.sessionKey.trim();
+	if (!boundSessionKey) return {
+		bindingResolution,
+		route: params.route
+	};
+	const boundAgentId = resolveAgentIdFromSessionKey(boundSessionKey) || bindingResolution.statefulTarget.agentId;
+	return {
+		bindingResolution,
+		boundSessionKey,
+		boundAgentId,
+		route: {
+			...params.route,
+			sessionKey: boundSessionKey,
+			agentId: boundAgentId,
+			lastRoutePolicy: deriveLastRoutePolicy({
+				sessionKey: boundSessionKey,
+				mainSessionKey: params.route.mainSessionKey
+			}),
+			matchedBy: "binding.channel"
+		}
+	};
+}
+function resolveRuntimeConversationBindingRoute(params) {
+	const bindingRecord = getSessionBindingService().resolveByConversation(resolveConfiguredBindingConversationRef(params));
+	const boundSessionKey = bindingRecord?.targetSessionKey?.trim();
+	if (!bindingRecord || !boundSessionKey) return {
+		bindingRecord: null,
+		route: params.route
+	};
+	if (isCronRunSessionKey(boundSessionKey)) {
+		logVerbose(`ignored runtime conversation binding ${bindingRecord.bindingId} to isolated cron run session ${boundSessionKey}`);
+		return {
+			bindingRecord: null,
+			route: params.route
+		};
+	}
+	getSessionBindingService().touch(bindingRecord.bindingId);
+	if (isPluginOwnedRuntimeBindingRecord(bindingRecord)) return {
+		bindingRecord,
+		route: params.route
+	};
+	const boundAgentId = resolveAgentIdFromSessionKey(boundSessionKey) || params.route.agentId;
+	return {
+		bindingRecord,
+		boundSessionKey,
+		boundAgentId,
+		route: {
+			...params.route,
+			sessionKey: boundSessionKey,
+			agentId: boundAgentId,
+			lastRoutePolicy: deriveLastRoutePolicy({
+				sessionKey: boundSessionKey,
+				mainSessionKey: params.route.mainSessionKey
+			}),
+			matchedBy: "binding.channel"
+		}
+	};
+}
+async function ensureConfiguredBindingRouteReady(params) {
+	const readyPromise = ensureConfiguredBindingTargetReady(params);
+	let timer;
+	const timeoutToken = Symbol("configured-binding-route-ready-timeout");
+	const timeoutPromise = new Promise((resolve) => {
+		timer = setTimeout(() => resolve(timeoutToken), CONFIGURED_BINDING_ROUTE_READY_TIMEOUT_MS);
+		timer.unref?.();
+	});
+	try {
+		const result = await Promise.race([readyPromise, timeoutPromise]);
+		if (result !== timeoutToken) return result;
+		logVerbose(`configured binding route ready check timed out after ${CONFIGURED_BINDING_ROUTE_READY_TIMEOUT_MS / 1e3}s`);
+		readyPromise.then((lateResult) => logVerbose(`configured binding route ready check settled after timeout (ok=${lateResult.ok})`), (err) => logVerbose(`configured binding route ready check rejected after timeout: ${String(err)}`));
+		return {
+			ok: false,
+			error: "Configured binding route ready check timed out"
+		};
+	} finally {
+		clearTimeout(timer);
+	}
+}
+//#endregion
+export { resolveConfiguredBindingRoute as n, resolveRuntimeConversationBindingRoute as r, ensureConfiguredBindingRouteReady as t };