@noxsoft/anima 2.0.2 → 2.0.4

package/dist/usage-ApGvBLVg.js

@@ -1,4516 +0,0 @@
-import { E as resolveAgentIdFromSessionKey, M as parseAgentSessionKey, S as classifySessionKeyShape, _ as DEFAULT_AGENT_ID, f as loadWorkspaceBootstrapFiles, h as resolveAnimaPackageRootSync, m as resolveAnimaPackageRoot, u as filterBootstrapFilesForSession, w as normalizeAgentId } from "./workspace-Dcfoy5JJ.js";
-import { M as isRecord, Y as logVerbose, Z as shouldLogVerbose, k as escapeRegExp, l as createSubsystemLogger, n as runExec, t as runCommandWithTimeout, w as CONFIG_DIR, z as resolveUserPath } from "./exec-BenD3A5l.js";
-import { c as resolveDefaultAgentId, s as resolveAgentWorkspaceDir, u as resolveSessionAgentIds } from "./agent-scope-BVf4aSwY.js";
-import { t as formatCliCommand } from "./command-format-SkzzRqR1.js";
-import { h as resolveMemorySlotDecision, m as resolveEnableState, n as loadConfig, p as normalizePluginsConfig, u as loadPluginManifestRegistry } from "./config-CLZ_XGVw.js";
-import { R as normalizeChatType, V as SILENT_REPLY_TOKEN, c as updateSessionStore, u as deliveryContextFromSession } from "./sessions-Wd18dukK.js";
-import { E as requireApiKey, I as isTruthyEnvValue, R as DEFAULT_MODEL, S as resolveModelRefFromString, _ as normalizeModelRef, b as resolveConfiguredModelRef, c as resolveAnimaAgentDir, g as modelKey, m as buildModelAliasIndex, n as resolveAuthProfileOrder, o as ensureAuthProfileStore, p as buildConfiguredAllowlistKeys, r as isProfileInCooldown, v as normalizeProviderId$1, w as getApiKeyForModel, x as resolveDefaultModelForAgent, z as DEFAULT_PROVIDER } from "./auth-profiles-CCDD56dU.js";
-import { _ as listDeliverableMessageChannels, f as INTERNAL_MESSAGE_CHANNEL, p as isDeliverableMessageChannel, r as normalizeChannelId, t as getChannelPlugin, v as normalizeMessageChannel } from "./plugins-B362e77G.js";
-import { l as resolveHeartbeatPrompt } from "./agent-events-BEBQsyE5.js";
-import { i as triggerInternalHook, t as createInternalHookEvent } from "./internal-hooks-DFTIurVM.js";
-import { r as getFileExtension, s as normalizeMimeType } from "./mime-Bm1xTtpY.js";
-import { a as parseFrontmatterBlock, c as resolveRuntimePlatform, i as resolveAnimaManifestBlock, n as normalizeStringList, o as hasBinary, r as parseFrontmatterBool, s as isConfigPathTruthyWithDefaults, t as getFrontmatterString } from "./frontmatter-YijVi0FQ.js";
-import fs from "node:fs/promises";
-import os, { tmpdir } from "node:os";
-import path from "node:path";
-import fs$1, { existsSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
-import { execSync, spawn } from "node:child_process";
-import { fileURLToPath } from "node:url";
-import crypto, { randomUUID } from "node:crypto";
-import { completeSimple } from "@mariozechner/pi-ai";
-import { formatSkillsForPrompt, loadSkillsFromDir } from "@mariozechner/pi-coding-agent";
-import { EdgeTTS } from "node-edge-tts";
-import chokidar from "chokidar";
-
-//#region src/agents/auth-profiles/session-override.ts
-function isProfileForProvider(params) {
-	const entry = params.store.profiles[params.profileId];
-	if (!entry?.provider) return false;
-	return normalizeProviderId$1(entry.provider) === normalizeProviderId$1(params.provider);
-}
-async function clearSessionAuthProfileOverride(params) {
-	const { sessionEntry, sessionStore, sessionKey, storePath } = params;
-	delete sessionEntry.authProfileOverride;
-	delete sessionEntry.authProfileOverrideSource;
-	delete sessionEntry.authProfileOverrideCompactionCount;
-	sessionEntry.updatedAt = Date.now();
-	sessionStore[sessionKey] = sessionEntry;
-	if (storePath) await updateSessionStore(storePath, (store) => {
-		store[sessionKey] = sessionEntry;
-	});
-}
-async function resolveSessionAuthProfileOverride(params) {
-	const { cfg, provider, agentDir, sessionEntry, sessionStore, sessionKey, storePath, isNewSession } = params;
-	if (!sessionEntry || !sessionStore || !sessionKey) return sessionEntry?.authProfileOverride;
-	const store = ensureAuthProfileStore(agentDir, { allowKeychainPrompt: false });
-	const order = resolveAuthProfileOrder({
-		cfg,
-		store,
-		provider
-	});
-	let current = sessionEntry.authProfileOverride?.trim();
-	if (current && !store.profiles[current]) {
-		await clearSessionAuthProfileOverride({
-			sessionEntry,
-			sessionStore,
-			sessionKey,
-			storePath
-		});
-		current = void 0;
-	}
-	if (current && !isProfileForProvider({
-		provider,
-		profileId: current,
-		store
-	})) {
-		await clearSessionAuthProfileOverride({
-			sessionEntry,
-			sessionStore,
-			sessionKey,
-			storePath
-		});
-		current = void 0;
-	}
-	if (current && order.length > 0 && !order.includes(current)) {
-		await clearSessionAuthProfileOverride({
-			sessionEntry,
-			sessionStore,
-			sessionKey,
-			storePath
-		});
-		current = void 0;
-	}
-	if (order.length === 0) return;
-	const pickFirstAvailable = () => order.find((profileId) => !isProfileInCooldown(store, profileId)) ?? order[0];
-	const pickNextAvailable = (active) => {
-		const startIndex = order.indexOf(active);
-		if (startIndex < 0) return pickFirstAvailable();
-		for (let offset = 1; offset <= order.length; offset += 1) {
-			const candidate = order[(startIndex + offset) % order.length];
-			if (!isProfileInCooldown(store, candidate)) return candidate;
-		}
-		return order[startIndex] ?? order[0];
-	};
-	const compactionCount = sessionEntry.compactionCount ?? 0;
-	const storedCompaction = typeof sessionEntry.authProfileOverrideCompactionCount === "number" ? sessionEntry.authProfileOverrideCompactionCount : compactionCount;
-	if ((sessionEntry.authProfileOverrideSource ?? (typeof sessionEntry.authProfileOverrideCompactionCount === "number" ? "auto" : current ? "user" : void 0)) === "user" && current && !isNewSession) return current;
-	let next = current;
-	if (isNewSession) next = current ? pickNextAvailable(current) : pickFirstAvailable();
-	else if (current && compactionCount > storedCompaction) next = pickNextAvailable(current);
-	else if (!current || isProfileInCooldown(store, current)) next = pickFirstAvailable();
-	if (!next) return current;
-	if (next !== sessionEntry.authProfileOverride || sessionEntry.authProfileOverrideSource !== "auto" || sessionEntry.authProfileOverrideCompactionCount !== compactionCount) {
-		sessionEntry.authProfileOverride = next;
-		sessionEntry.authProfileOverrideSource = "auto";
-		sessionEntry.authProfileOverrideCompactionCount = compactionCount;
-		sessionEntry.updatedAt = Date.now();
-		sessionStore[sessionKey] = sessionEntry;
-		if (storePath) await updateSessionStore(storePath, (store) => {
-			store[sessionKey] = sessionEntry;
-		});
-	}
-	return next;
-}
-
-//#endregion
-//#region src/agents/bootstrap-hooks.ts
-async function applyBootstrapHookOverrides(params) {
-	const sessionKey = params.sessionKey ?? params.sessionId ?? "unknown";
-	const agentId = params.agentId ?? (params.sessionKey ? resolveAgentIdFromSessionKey(params.sessionKey) : void 0);
-	const event = createInternalHookEvent("agent", "bootstrap", sessionKey, {
-		workspaceDir: params.workspaceDir,
-		bootstrapFiles: params.files,
-		cfg: params.config,
-		sessionKey: params.sessionKey,
-		sessionId: params.sessionId,
-		agentId
-	});
-	await triggerInternalHook(event);
-	const updated = event.context.bootstrapFiles;
-	return Array.isArray(updated) ? updated : params.files;
-}
-
-//#endregion
-//#region src/agents/bootstrap-files.ts
-function makeBootstrapWarn(params) {
-	if (!params.warn) return;
-	return (message) => params.warn?.(`${message} (sessionKey=${params.sessionLabel})`);
-}
-async function resolveBootstrapFilesForRun(params) {
-	const sessionKey = params.sessionKey ?? params.sessionId;
-	return applyBootstrapHookOverrides({
-		files: filterBootstrapFilesForSession(await loadWorkspaceBootstrapFiles(params.workspaceDir), sessionKey),
-		workspaceDir: params.workspaceDir,
-		config: params.config,
-		sessionKey: params.sessionKey,
-		sessionId: params.sessionId,
-		agentId: params.agentId
-	});
-}
-async function resolveBootstrapContextForRun(params) {
-	const bootstrapFiles = await resolveBootstrapFilesForRun(params);
-	return {
-		bootstrapFiles,
-		contextFiles: buildBootstrapContextFiles(bootstrapFiles, {
-			maxChars: resolveBootstrapMaxChars(params.config),
-			totalMaxChars: resolveBootstrapTotalMaxChars(params.config),
-			warn: params.warn
-		})
-	};
-}
-
-//#endregion
-//#region src/agents/cli-backends.ts
-const DEFAULT_CLAUDE_BACKEND = {
-	command: "claude",
-	args: [
-		"-p",
-		"--output-format",
-		"json",
-		"--dangerously-skip-permissions"
-	],
-	resumeArgs: [
-		"-p",
-		"--output-format",
-		"json",
-		"--dangerously-skip-permissions",
-		"--resume",
-		"{sessionId}"
-	],
-	output: "json",
-	input: "arg",
-	modelArg: "--model",
-	modelAliases: {
-		opus: "opus",
-		"opus-4.6": "opus",
-		"opus-4.5": "opus",
-		"opus-4": "opus",
-		"claude-opus-4-6": "opus",
-		"claude-opus-4-5": "opus",
-		"claude-opus-4": "opus",
-		sonnet: "sonnet",
-		"sonnet-4.5": "sonnet",
-		"sonnet-4.1": "sonnet",
-		"sonnet-4.0": "sonnet",
-		"claude-sonnet-4-5": "sonnet",
-		"claude-sonnet-4-1": "sonnet",
-		"claude-sonnet-4-0": "sonnet",
-		haiku: "haiku",
-		"haiku-3.5": "haiku",
-		"claude-haiku-3-5": "haiku"
-	},
-	sessionArg: "--session-id",
-	sessionMode: "always",
-	sessionIdFields: [
-		"session_id",
-		"sessionId",
-		"conversation_id",
-		"conversationId"
-	],
-	systemPromptArg: "--append-system-prompt",
-	systemPromptMode: "append",
-	systemPromptWhen: "first",
-	clearEnv: ["ANTHROPIC_API_KEY", "ANTHROPIC_API_KEY_OLD"],
-	serialize: true
-};
-const DEFAULT_CODEX_BACKEND = {
-	command: "codex",
-	args: [
-		"exec",
-		"--json",
-		"--color",
-		"never",
-		"--sandbox",
-		"read-only",
-		"--skip-git-repo-check"
-	],
-	resumeArgs: [
-		"exec",
-		"resume",
-		"{sessionId}",
-		"--color",
-		"never",
-		"--sandbox",
-		"read-only",
-		"--skip-git-repo-check"
-	],
-	output: "jsonl",
-	resumeOutput: "text",
-	input: "arg",
-	modelArg: "--model",
-	sessionIdFields: ["thread_id"],
-	sessionMode: "existing",
-	imageArg: "--image",
-	imageMode: "repeat",
-	serialize: true
-};
-function normalizeBackendKey(key) {
-	return normalizeProviderId$1(key);
-}
-function pickBackendConfig(config, normalizedId) {
-	for (const [key, entry] of Object.entries(config)) if (normalizeBackendKey(key) === normalizedId) return entry;
-}
-function mergeBackendConfig(base, override) {
-	if (!override) return { ...base };
-	return {
-		...base,
-		...override,
-		args: override.args ?? base.args,
-		env: {
-			...base.env,
-			...override.env
-		},
-		modelAliases: {
-			...base.modelAliases,
-			...override.modelAliases
-		},
-		clearEnv: Array.from(new Set([...base.clearEnv ?? [], ...override.clearEnv ?? []])),
-		sessionIdFields: override.sessionIdFields ?? base.sessionIdFields,
-		sessionArgs: override.sessionArgs ?? base.sessionArgs,
-		resumeArgs: override.resumeArgs ?? base.resumeArgs
-	};
-}
-function resolveCliBackendConfig(provider, cfg) {
-	const normalized = normalizeBackendKey(provider);
-	const override = pickBackendConfig(cfg?.agents?.defaults?.cliBackends ?? {}, normalized);
-	if (normalized === "claude-cli") {
-		const merged = mergeBackendConfig(DEFAULT_CLAUDE_BACKEND, override);
-		const command = merged.command?.trim();
-		if (!command) return null;
-		return {
-			id: normalized,
-			config: {
-				...merged,
-				command
-			}
-		};
-	}
-	if (normalized === "codex-cli") {
-		const merged = mergeBackendConfig(DEFAULT_CODEX_BACKEND, override);
-		const command = merged.command?.trim();
-		if (!command) return null;
-		return {
-			id: normalized,
-			config: {
-				...merged,
-				command
-			}
-		};
-	}
-	if (!override) return null;
-	const command = override.command?.trim();
-	if (!command) return null;
-	return {
-		id: normalized,
-		config: {
-			...override,
-			command
-		}
-	};
-}
-
-//#endregion
-//#region src/line/markdown-to-line.ts
-function stripMarkdown(text) {
-	return text.replace(/\*\*([^*]+)\*\*/g, "$1").replace(/\*([^*]+)\*/g, "$1").replace(/__([^_]+)__/g, "$1").replace(/_([^_]+)_/g, "$1").replace(/~~([^~]+)~~/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/```[^`]*```/gs, "").replace(/^#{1,6}\s+/gm, "").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/^[-*+]\s+/gm, "").replace(/^\d+\.\s+/gm, "");
-}
-
-//#endregion
-//#region src/media/audio.ts
-const TELEGRAM_VOICE_AUDIO_EXTENSIONS = new Set([
-	".oga",
-	".ogg",
-	".opus",
-	".mp3",
-	".m4a"
-]);
-/**
-* MIME types compatible with voice messages.
-* Telegram sendVoice supports OGG/Opus, MP3, and M4A.
-* https://core.telegram.org/bots/api#sendvoice
-*/
-const TELEGRAM_VOICE_MIME_TYPES = new Set([
-	"audio/ogg",
-	"audio/opus",
-	"audio/mpeg",
-	"audio/mp3",
-	"audio/mp4",
-	"audio/x-m4a",
-	"audio/m4a"
-]);
-function isTelegramVoiceCompatibleAudio(opts) {
-	const mime = normalizeMimeType(opts.contentType);
-	if (mime && TELEGRAM_VOICE_MIME_TYPES.has(mime)) return true;
-	const fileName = opts.fileName?.trim();
-	if (!fileName) return false;
-	const ext = getFileExtension(fileName);
-	if (!ext) return false;
-	return TELEGRAM_VOICE_AUDIO_EXTENSIONS.has(ext);
-}
-/**
-* Backward-compatible alias used across plugin/runtime call sites.
-* Keeps existing behavior while making Telegram-specific policy explicit.
-*/
-function isVoiceCompatibleAudio(opts) {
-	return isTelegramVoiceCompatibleAudio(opts);
-}
-
-//#endregion
-//#region src/agents/pi-embedded-runner/model.ts
-function resolveModel(..._args) {
-	return "default";
-}
-
-//#endregion
-//#region src/tts/tts-core.ts
-const DEFAULT_ELEVENLABS_BASE_URL$1 = "https://api.elevenlabs.io";
-const TEMP_FILE_CLEANUP_DELAY_MS = 300 * 1e3;
-function isValidVoiceId(voiceId) {
-	return /^[a-zA-Z0-9]{10,40}$/.test(voiceId);
-}
-function normalizeElevenLabsBaseUrl(baseUrl) {
-	const trimmed = baseUrl.trim();
-	if (!trimmed) return DEFAULT_ELEVENLABS_BASE_URL$1;
-	return trimmed.replace(/\/+$/, "");
-}
-function requireInRange(value, min, max, label) {
-	if (!Number.isFinite(value) || value < min || value > max) throw new Error(`${label} must be between ${min} and ${max}`);
-}
-function assertElevenLabsVoiceSettings(settings) {
-	requireInRange(settings.stability, 0, 1, "stability");
-	requireInRange(settings.similarityBoost, 0, 1, "similarityBoost");
-	requireInRange(settings.style, 0, 1, "style");
-	requireInRange(settings.speed, .5, 2, "speed");
-}
-function normalizeLanguageCode(code) {
-	const trimmed = code?.trim();
-	if (!trimmed) return;
-	const normalized = trimmed.toLowerCase();
-	if (!/^[a-z]{2}$/.test(normalized)) throw new Error("languageCode must be a 2-letter ISO 639-1 code (e.g. en, de, fr)");
-	return normalized;
-}
-function normalizeApplyTextNormalization(mode) {
-	const trimmed = mode?.trim();
-	if (!trimmed) return;
-	const normalized = trimmed.toLowerCase();
-	if (normalized === "auto" || normalized === "on" || normalized === "off") return normalized;
-	throw new Error("applyTextNormalization must be one of: auto, on, off");
-}
-function normalizeSeed(seed) {
-	if (seed == null) return;
-	const next = Math.floor(seed);
-	if (!Number.isFinite(next) || next < 0 || next > 4294967295) throw new Error("seed must be between 0 and 4294967295");
-	return next;
-}
-function parseBooleanValue(value) {
-	const normalized = value.trim().toLowerCase();
-	if ([
-		"true",
-		"1",
-		"yes",
-		"on"
-	].includes(normalized)) return true;
-	if ([
-		"false",
-		"0",
-		"no",
-		"off"
-	].includes(normalized)) return false;
-}
-function parseNumberValue(value) {
-	const parsed = Number.parseFloat(value);
-	return Number.isFinite(parsed) ? parsed : void 0;
-}
-function parseTtsDirectives(text, policy) {
-	if (!policy.enabled) return {
-		cleanedText: text,
-		overrides: {},
-		warnings: [],
-		hasDirective: false
-	};
-	const overrides = {};
-	const warnings = [];
-	let cleanedText = text;
-	let hasDirective = false;
-	cleanedText = cleanedText.replace(/\[\[tts:text\]\]([\s\S]*?)\[\[\/tts:text\]\]/gi, (_match, inner) => {
-		hasDirective = true;
-		if (policy.allowText && overrides.ttsText == null) overrides.ttsText = inner.trim();
-		return "";
-	});
-	cleanedText = cleanedText.replace(/\[\[tts:([^\]]+)\]\]/gi, (_match, body) => {
-		hasDirective = true;
-		const tokens = body.split(/\s+/).filter(Boolean);
-		for (const token of tokens) {
-			const eqIndex = token.indexOf("=");
-			if (eqIndex === -1) continue;
-			const rawKey = token.slice(0, eqIndex).trim();
-			const rawValue = token.slice(eqIndex + 1).trim();
-			if (!rawKey || !rawValue) continue;
-			const key = rawKey.toLowerCase();
-			try {
-				switch (key) {
-					case "provider":
-						if (!policy.allowProvider) break;
-						if (rawValue === "openai" || rawValue === "elevenlabs" || rawValue === "edge") overrides.provider = rawValue;
-						else warnings.push(`unsupported provider "${rawValue}"`);
-						break;
-					case "voice":
-					case "openai_voice":
-					case "openaivoice":
-						if (!policy.allowVoice) break;
-						if (isValidOpenAIVoice(rawValue)) overrides.openai = {
-							...overrides.openai,
-							voice: rawValue
-						};
-						else warnings.push(`invalid OpenAI voice "${rawValue}"`);
-						break;
-					case "voiceid":
-					case "voice_id":
-					case "elevenlabs_voice":
-					case "elevenlabsvoice":
-						if (!policy.allowVoice) break;
-						if (isValidVoiceId(rawValue)) overrides.elevenlabs = {
-							...overrides.elevenlabs,
-							voiceId: rawValue
-						};
-						else warnings.push(`invalid ElevenLabs voiceId "${rawValue}"`);
-						break;
-					case "model":
-					case "modelid":
-					case "model_id":
-					case "elevenlabs_model":
-					case "elevenlabsmodel":
-					case "openai_model":
-					case "openaimodel":
-						if (!policy.allowModelId) break;
-						if (isValidOpenAIModel(rawValue)) overrides.openai = {
-							...overrides.openai,
-							model: rawValue
-						};
-						else overrides.elevenlabs = {
-							...overrides.elevenlabs,
-							modelId: rawValue
-						};
-						break;
-					case "stability":
-						if (!policy.allowVoiceSettings) break;
-						{
-							const value = parseNumberValue(rawValue);
-							if (value == null) {
-								warnings.push("invalid stability value");
-								break;
-							}
-							requireInRange(value, 0, 1, "stability");
-							overrides.elevenlabs = {
-								...overrides.elevenlabs,
-								voiceSettings: {
-									...overrides.elevenlabs?.voiceSettings,
-									stability: value
-								}
-							};
-						}
-						break;
-					case "similarity":
-					case "similarityboost":
-					case "similarity_boost":
-						if (!policy.allowVoiceSettings) break;
-						{
-							const value = parseNumberValue(rawValue);
-							if (value == null) {
-								warnings.push("invalid similarityBoost value");
-								break;
-							}
-							requireInRange(value, 0, 1, "similarityBoost");
-							overrides.elevenlabs = {
-								...overrides.elevenlabs,
-								voiceSettings: {
-									...overrides.elevenlabs?.voiceSettings,
-									similarityBoost: value
-								}
-							};
-						}
-						break;
-					case "style":
-						if (!policy.allowVoiceSettings) break;
-						{
-							const value = parseNumberValue(rawValue);
-							if (value == null) {
-								warnings.push("invalid style value");
-								break;
-							}
-							requireInRange(value, 0, 1, "style");
-							overrides.elevenlabs = {
-								...overrides.elevenlabs,
-								voiceSettings: {
-									...overrides.elevenlabs?.voiceSettings,
-									style: value
-								}
-							};
-						}
-						break;
-					case "speed":
-						if (!policy.allowVoiceSettings) break;
-						{
-							const value = parseNumberValue(rawValue);
-							if (value == null) {
-								warnings.push("invalid speed value");
-								break;
-							}
-							requireInRange(value, .5, 2, "speed");
-							overrides.elevenlabs = {
-								...overrides.elevenlabs,
-								voiceSettings: {
-									...overrides.elevenlabs?.voiceSettings,
-									speed: value
-								}
-							};
-						}
-						break;
-					case "speakerboost":
-					case "speaker_boost":
-					case "usespeakerboost":
-					case "use_speaker_boost":
-						if (!policy.allowVoiceSettings) break;
-						{
-							const value = parseBooleanValue(rawValue);
-							if (value == null) {
-								warnings.push("invalid useSpeakerBoost value");
-								break;
-							}
-							overrides.elevenlabs = {
-								...overrides.elevenlabs,
-								voiceSettings: {
-									...overrides.elevenlabs?.voiceSettings,
-									useSpeakerBoost: value
-								}
-							};
-						}
-						break;
-					case "normalize":
-					case "applytextnormalization":
-					case "apply_text_normalization":
-						if (!policy.allowNormalization) break;
-						overrides.elevenlabs = {
-							...overrides.elevenlabs,
-							applyTextNormalization: normalizeApplyTextNormalization(rawValue)
-						};
-						break;
-					case "language":
-					case "languagecode":
-					case "language_code":
-						if (!policy.allowNormalization) break;
-						overrides.elevenlabs = {
-							...overrides.elevenlabs,
-							languageCode: normalizeLanguageCode(rawValue)
-						};
-						break;
-					case "seed":
-						if (!policy.allowSeed) break;
-						overrides.elevenlabs = {
-							...overrides.elevenlabs,
-							seed: normalizeSeed(Number.parseInt(rawValue, 10))
-						};
-						break;
-					default: break;
-				}
-			} catch (err) {
-				warnings.push(err.message);
-			}
-		}
-		return "";
-	});
-	return {
-		cleanedText,
-		ttsText: overrides.ttsText,
-		hasDirective,
-		overrides,
-		warnings
-	};
-}
-const OPENAI_TTS_MODELS = [
-	"gpt-4o-mini-tts",
-	"tts-1",
-	"tts-1-hd"
-];
-/**
-* Custom OpenAI-compatible TTS endpoint.
-* When set, model/voice validation is relaxed to allow non-OpenAI models.
-* Example: OPENAI_TTS_BASE_URL=http://localhost:8880/v1
-*
-* Note: Read at runtime (not module load) to support config.env loading.
-*/
-function getOpenAITtsBaseUrl() {
-	return (process.env.OPENAI_TTS_BASE_URL?.trim() || "https://api.openai.com/v1").replace(/\/+$/, "");
-}
-function isCustomOpenAIEndpoint() {
-	return getOpenAITtsBaseUrl() !== "https://api.openai.com/v1";
-}
-const OPENAI_TTS_VOICES = [
-	"alloy",
-	"ash",
-	"ballad",
-	"cedar",
-	"coral",
-	"echo",
-	"fable",
-	"juniper",
-	"marin",
-	"onyx",
-	"nova",
-	"sage",
-	"shimmer",
-	"verse"
-];
-function isValidOpenAIModel(model) {
-	if (isCustomOpenAIEndpoint()) return true;
-	return OPENAI_TTS_MODELS.includes(model);
-}
-function isValidOpenAIVoice(voice) {
-	if (isCustomOpenAIEndpoint()) return true;
-	return OPENAI_TTS_VOICES.includes(voice);
-}
-function resolveSummaryModelRef(cfg, config) {
-	const defaultRef = resolveDefaultModelForAgent({ cfg });
-	const override = config.summaryModel?.trim();
-	if (!override) return {
-		ref: defaultRef,
-		source: "default"
-	};
-	const aliasIndex = buildModelAliasIndex({
-		cfg,
-		defaultProvider: defaultRef.provider
-	});
-	const resolved = resolveModelRefFromString({
-		raw: override,
-		defaultProvider: defaultRef.provider,
-		aliasIndex
-	});
-	if (!resolved) return {
-		ref: defaultRef,
-		source: "default"
-	};
-	return {
-		ref: resolved.ref,
-		source: "summaryModel"
-	};
-}
-function isTextContentBlock(block) {
-	return block.type === "text";
-}
-async function summarizeText(params) {
-	const { text, targetLength, cfg, config, timeoutMs } = params;
-	if (targetLength < 100 || targetLength > 1e4) throw new Error(`Invalid targetLength: ${targetLength}`);
-	const startTime = Date.now();
-	const { ref } = resolveSummaryModelRef(cfg, config);
-	const resolved = resolveModel(ref.provider, ref.model, void 0, cfg);
-	if (!resolved.model) throw new Error(resolved.error ?? `Unknown summary model: ${ref.provider}/${ref.model}`);
-	const apiKey = requireApiKey(await getApiKeyForModel({
-		model: resolved.model,
-		cfg
-	}), ref.provider);
-	try {
-		const controller = new AbortController();
-		const timeout = setTimeout(() => controller.abort(), timeoutMs);
-		try {
-			const summary = (await completeSimple(resolved.model, { messages: [{
-				role: "user",
-				content: `You are an assistant that summarizes texts concisely while keeping the most important information. Summarize the text to approximately ${targetLength} characters. Maintain the original tone and style. Reply only with the summary, without additional explanations.\n\n<text_to_summarize>\n${text}\n</text_to_summarize>`,
-				timestamp: Date.now()
-			}] }, {
-				apiKey,
-				maxTokens: Math.ceil(targetLength / 2),
-				temperature: .3,
-				signal: controller.signal
-			})).content.filter(isTextContentBlock).map((block) => block.text.trim()).filter(Boolean).join(" ").trim();
-			if (!summary) throw new Error("No summary returned");
-			return {
-				summary,
-				latencyMs: Date.now() - startTime,
-				inputLength: text.length,
-				outputLength: summary.length
-			};
-		} finally {
-			clearTimeout(timeout);
-		}
-	} catch (err) {
-		if (err.name === "AbortError") throw new Error("Summarization timed out", { cause: err });
-		throw err;
-	}
-}
-function scheduleCleanup(tempDir, delayMs = TEMP_FILE_CLEANUP_DELAY_MS) {
-	setTimeout(() => {
-		try {
-			rmSync(tempDir, {
-				recursive: true,
-				force: true
-			});
-		} catch {}
-	}, delayMs).unref();
-}
-async function elevenLabsTTS(params) {
-	const { text, apiKey, baseUrl, voiceId, modelId, outputFormat, seed, applyTextNormalization, languageCode, voiceSettings, timeoutMs } = params;
-	if (!isValidVoiceId(voiceId)) throw new Error("Invalid voiceId format");
-	assertElevenLabsVoiceSettings(voiceSettings);
-	const normalizedLanguage = normalizeLanguageCode(languageCode);
-	const normalizedNormalization = normalizeApplyTextNormalization(applyTextNormalization);
-	const normalizedSeed = normalizeSeed(seed);
-	const controller = new AbortController();
-	const timeout = setTimeout(() => controller.abort(), timeoutMs);
-	try {
-		const url = new URL(`${normalizeElevenLabsBaseUrl(baseUrl)}/v1/text-to-speech/${voiceId}`);
-		if (outputFormat) url.searchParams.set("output_format", outputFormat);
-		const response = await fetch(url.toString(), {
-			method: "POST",
-			headers: {
-				"xi-api-key": apiKey,
-				"Content-Type": "application/json",
-				Accept: "audio/mpeg"
-			},
-			body: JSON.stringify({
-				text,
-				model_id: modelId,
-				seed: normalizedSeed,
-				apply_text_normalization: normalizedNormalization,
-				language_code: normalizedLanguage,
-				voice_settings: {
-					stability: voiceSettings.stability,
-					similarity_boost: voiceSettings.similarityBoost,
-					style: voiceSettings.style,
-					use_speaker_boost: voiceSettings.useSpeakerBoost,
-					speed: voiceSettings.speed
-				}
-			}),
-			signal: controller.signal
-		});
-		if (!response.ok) throw new Error(`ElevenLabs API error (${response.status})`);
-		return Buffer.from(await response.arrayBuffer());
-	} finally {
-		clearTimeout(timeout);
-	}
-}
-async function openaiTTS(params) {
-	const { text, apiKey, model, voice, responseFormat, timeoutMs } = params;
-	if (!isValidOpenAIModel(model)) throw new Error(`Invalid model: ${model}`);
-	if (!isValidOpenAIVoice(voice)) throw new Error(`Invalid voice: ${voice}`);
-	const controller = new AbortController();
-	const timeout = setTimeout(() => controller.abort(), timeoutMs);
-	try {
-		const response = await fetch(`${getOpenAITtsBaseUrl()}/audio/speech`, {
-			method: "POST",
-			headers: {
-				Authorization: `Bearer ${apiKey}`,
-				"Content-Type": "application/json"
-			},
-			body: JSON.stringify({
-				model,
-				input: text,
-				voice,
-				response_format: responseFormat
-			}),
-			signal: controller.signal
-		});
-		if (!response.ok) throw new Error(`OpenAI TTS API error (${response.status})`);
-		return Buffer.from(await response.arrayBuffer());
-	} finally {
-		clearTimeout(timeout);
-	}
-}
-function inferEdgeExtension(outputFormat) {
-	const normalized = outputFormat.toLowerCase();
-	if (normalized.includes("webm")) return ".webm";
-	if (normalized.includes("ogg")) return ".ogg";
-	if (normalized.includes("opus")) return ".opus";
-	if (normalized.includes("wav") || normalized.includes("riff") || normalized.includes("pcm")) return ".wav";
-	return ".mp3";
-}
-async function edgeTTS(params) {
-	const { text, outputPath, config, timeoutMs } = params;
-	await new EdgeTTS({
-		voice: config.voice,
-		lang: config.lang,
-		outputFormat: config.outputFormat,
-		saveSubtitles: config.saveSubtitles,
-		proxy: config.proxy,
-		rate: config.rate,
-		pitch: config.pitch,
-		volume: config.volume,
-		timeout: config.timeoutMs ?? timeoutMs
-	}).ttsPromise(text, outputPath);
-}
-
-//#endregion
-//#region src/tts/tts.ts
-const DEFAULT_TIMEOUT_MS = 3e4;
-const DEFAULT_TTS_MAX_LENGTH = 1500;
-const DEFAULT_TTS_SUMMARIZE = true;
-const DEFAULT_MAX_TEXT_LENGTH = 4096;
-const DEFAULT_ELEVENLABS_BASE_URL = "https://api.elevenlabs.io";
-const DEFAULT_ELEVENLABS_VOICE_ID = "pMsXgVXv3BLzUgSXRplE";
-const DEFAULT_ELEVENLABS_MODEL_ID = "eleven_multilingual_v2";
-const DEFAULT_OPENAI_MODEL = "gpt-4o-mini-tts";
-const DEFAULT_OPENAI_VOICE = "alloy";
-const DEFAULT_EDGE_VOICE = "en-US-MichelleNeural";
-const DEFAULT_EDGE_LANG = "en-US";
-const DEFAULT_EDGE_OUTPUT_FORMAT = "audio-24khz-48kbitrate-mono-mp3";
-const DEFAULT_ELEVENLABS_VOICE_SETTINGS = {
-	stability: .5,
-	similarityBoost: .75,
-	style: 0,
-	useSpeakerBoost: true,
-	speed: 1
-};
-const TELEGRAM_OUTPUT = {
-	openai: "opus",
-	elevenlabs: "opus_48000_64",
-	extension: ".opus",
-	voiceCompatible: true
-};
-const DEFAULT_OUTPUT = {
-	openai: "mp3",
-	elevenlabs: "mp3_44100_128",
-	extension: ".mp3",
-	voiceCompatible: false
-};
-const TELEPHONY_OUTPUT = {
-	openai: {
-		format: "pcm",
-		sampleRate: 24e3
-	},
-	elevenlabs: {
-		format: "pcm_22050",
-		sampleRate: 22050
-	}
-};
-const TTS_AUTO_MODES = new Set([
-	"off",
-	"always",
-	"inbound",
-	"tagged"
-]);
-let lastTtsAttempt;
-function normalizeTtsAutoMode(value) {
-	if (typeof value !== "string") return;
-	const normalized = value.trim().toLowerCase();
-	if (TTS_AUTO_MODES.has(normalized)) return normalized;
-}
-function resolveModelOverridePolicy(overrides) {
-	if (!(overrides?.enabled ?? true)) return {
-		enabled: false,
-		allowText: false,
-		allowProvider: false,
-		allowVoice: false,
-		allowModelId: false,
-		allowVoiceSettings: false,
-		allowNormalization: false,
-		allowSeed: false
-	};
-	const allow = (value) => value ?? true;
-	return {
-		enabled: true,
-		allowText: allow(overrides?.allowText),
-		allowProvider: allow(overrides?.allowProvider),
-		allowVoice: allow(overrides?.allowVoice),
-		allowModelId: allow(overrides?.allowModelId),
-		allowVoiceSettings: allow(overrides?.allowVoiceSettings),
-		allowNormalization: allow(overrides?.allowNormalization),
-		allowSeed: allow(overrides?.allowSeed)
-	};
-}
-function resolveTtsConfig(cfg) {
-	const raw = cfg.messages?.tts ?? {};
-	const providerSource = raw.provider ? "config" : "default";
-	const edgeOutputFormat = raw.edge?.outputFormat?.trim();
-	return {
-		auto: normalizeTtsAutoMode(raw.auto) ?? (raw.enabled ? "always" : "off"),
-		mode: raw.mode ?? "final",
-		provider: raw.provider ?? "edge",
-		providerSource,
-		summaryModel: raw.summaryModel?.trim() || void 0,
-		modelOverrides: resolveModelOverridePolicy(raw.modelOverrides),
-		elevenlabs: {
-			apiKey: raw.elevenlabs?.apiKey,
-			baseUrl: raw.elevenlabs?.baseUrl?.trim() || DEFAULT_ELEVENLABS_BASE_URL,
-			voiceId: raw.elevenlabs?.voiceId ?? DEFAULT_ELEVENLABS_VOICE_ID,
-			modelId: raw.elevenlabs?.modelId ?? DEFAULT_ELEVENLABS_MODEL_ID,
-			seed: raw.elevenlabs?.seed,
-			applyTextNormalization: raw.elevenlabs?.applyTextNormalization,
-			languageCode: raw.elevenlabs?.languageCode,
-			voiceSettings: {
-				stability: raw.elevenlabs?.voiceSettings?.stability ?? DEFAULT_ELEVENLABS_VOICE_SETTINGS.stability,
-				similarityBoost: raw.elevenlabs?.voiceSettings?.similarityBoost ?? DEFAULT_ELEVENLABS_VOICE_SETTINGS.similarityBoost,
-				style: raw.elevenlabs?.voiceSettings?.style ?? DEFAULT_ELEVENLABS_VOICE_SETTINGS.style,
-				useSpeakerBoost: raw.elevenlabs?.voiceSettings?.useSpeakerBoost ?? DEFAULT_ELEVENLABS_VOICE_SETTINGS.useSpeakerBoost,
-				speed: raw.elevenlabs?.voiceSettings?.speed ?? DEFAULT_ELEVENLABS_VOICE_SETTINGS.speed
-			}
-		},
-		openai: {
-			apiKey: raw.openai?.apiKey,
-			model: raw.openai?.model ?? DEFAULT_OPENAI_MODEL,
-			voice: raw.openai?.voice ?? DEFAULT_OPENAI_VOICE
-		},
-		edge: {
-			enabled: raw.edge?.enabled ?? true,
-			voice: raw.edge?.voice?.trim() || DEFAULT_EDGE_VOICE,
-			lang: raw.edge?.lang?.trim() || DEFAULT_EDGE_LANG,
-			outputFormat: edgeOutputFormat || DEFAULT_EDGE_OUTPUT_FORMAT,
-			outputFormatConfigured: Boolean(edgeOutputFormat),
-			pitch: raw.edge?.pitch?.trim() || void 0,
-			rate: raw.edge?.rate?.trim() || void 0,
-			volume: raw.edge?.volume?.trim() || void 0,
-			saveSubtitles: raw.edge?.saveSubtitles ?? false,
-			proxy: raw.edge?.proxy?.trim() || void 0,
-			timeoutMs: raw.edge?.timeoutMs
-		},
-		prefsPath: raw.prefsPath,
-		maxTextLength: raw.maxTextLength ?? DEFAULT_MAX_TEXT_LENGTH,
-		timeoutMs: raw.timeoutMs ?? DEFAULT_TIMEOUT_MS
-	};
-}
-function resolveTtsPrefsPath(config) {
-	if (config.prefsPath?.trim()) return resolveUserPath(config.prefsPath.trim());
-	const envPath = process.env.ANIMA_TTS_PREFS?.trim();
-	if (envPath) return resolveUserPath(envPath);
-	return path.join(CONFIG_DIR, "settings", "tts.json");
-}
-function resolveTtsAutoModeFromPrefs(prefs) {
-	const auto = normalizeTtsAutoMode(prefs.tts?.auto);
-	if (auto) return auto;
-	if (typeof prefs.tts?.enabled === "boolean") return prefs.tts.enabled ? "always" : "off";
-}
-function resolveTtsAutoMode(params) {
-	const sessionAuto = normalizeTtsAutoMode(params.sessionAuto);
-	if (sessionAuto) return sessionAuto;
-	const prefsAuto = resolveTtsAutoModeFromPrefs(readPrefs(params.prefsPath));
-	if (prefsAuto) return prefsAuto;
-	return params.config.auto;
-}
-function buildTtsSystemPromptHint(cfg) {
-	const config = resolveTtsConfig(cfg);
-	const prefsPath = resolveTtsPrefsPath(config);
-	const autoMode = resolveTtsAutoMode({
-		config,
-		prefsPath
-	});
-	if (autoMode === "off") return;
-	const maxLength = getTtsMaxLength(prefsPath);
-	const summarize = isSummarizationEnabled(prefsPath) ? "on" : "off";
-	return [
-		"Voice (TTS) is enabled.",
-		autoMode === "inbound" ? "Only use TTS when the user's last message includes audio/voice." : autoMode === "tagged" ? "Only use TTS when you include [[tts]] or [[tts:text]] tags." : void 0,
-		`Keep spoken text ≤${maxLength} chars to avoid auto-summary (summary ${summarize}).`,
-		"Use [[tts:...]] and optional [[tts:text]]...[[/tts:text]] to control voice/expressiveness."
-	].filter(Boolean).join("\n");
-}
-function readPrefs(prefsPath) {
-	try {
-		if (!existsSync(prefsPath)) return {};
-		return JSON.parse(readFileSync(prefsPath, "utf8"));
-	} catch {
-		return {};
-	}
-}
-function atomicWriteFileSync(filePath, content) {
-	const tmpPath = `${filePath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2)}`;
-	writeFileSync(tmpPath, content);
-	try {
-		renameSync(tmpPath, filePath);
-	} catch (err) {
-		try {
-			unlinkSync(tmpPath);
-		} catch {}
-		throw err;
-	}
-}
-function updatePrefs(prefsPath, update) {
-	const prefs = readPrefs(prefsPath);
-	update(prefs);
-	mkdirSync(path.dirname(prefsPath), { recursive: true });
-	atomicWriteFileSync(prefsPath, JSON.stringify(prefs, null, 2));
-}
-function isTtsEnabled(config, prefsPath, sessionAuto) {
-	return resolveTtsAutoMode({
-		config,
-		prefsPath,
-		sessionAuto
-	}) !== "off";
-}
-function setTtsAutoMode(prefsPath, mode) {
-	updatePrefs(prefsPath, (prefs) => {
-		const next = { ...prefs.tts };
-		delete next.enabled;
-		next.auto = mode;
-		prefs.tts = next;
-	});
-}
-function setTtsEnabled(prefsPath, enabled) {
-	setTtsAutoMode(prefsPath, enabled ? "always" : "off");
-}
-function getTtsProvider(config, prefsPath) {
-	const prefs = readPrefs(prefsPath);
-	if (prefs.tts?.provider) return prefs.tts.provider;
-	if (config.providerSource === "config") return config.provider;
-	if (resolveTtsApiKey(config, "openai")) return "openai";
-	if (resolveTtsApiKey(config, "elevenlabs")) return "elevenlabs";
-	return "edge";
-}
-function setTtsProvider(prefsPath, provider) {
-	updatePrefs(prefsPath, (prefs) => {
-		prefs.tts = {
-			...prefs.tts,
-			provider
-		};
-	});
-}
-function getTtsMaxLength(prefsPath) {
-	return readPrefs(prefsPath).tts?.maxLength ?? DEFAULT_TTS_MAX_LENGTH;
-}
-function setTtsMaxLength(prefsPath, maxLength) {
-	updatePrefs(prefsPath, (prefs) => {
-		prefs.tts = {
-			...prefs.tts,
-			maxLength
-		};
-	});
-}
-function isSummarizationEnabled(prefsPath) {
-	return readPrefs(prefsPath).tts?.summarize ?? DEFAULT_TTS_SUMMARIZE;
-}
-function setSummarizationEnabled(prefsPath, enabled) {
-	updatePrefs(prefsPath, (prefs) => {
-		prefs.tts = {
-			...prefs.tts,
-			summarize: enabled
-		};
-	});
-}
-function getLastTtsAttempt() {
-	return lastTtsAttempt;
-}
-function setLastTtsAttempt(entry) {
-	lastTtsAttempt = entry;
-}
-function resolveOutputFormat(channelId) {
-	if (channelId === "telegram") return TELEGRAM_OUTPUT;
-	return DEFAULT_OUTPUT;
-}
-function resolveChannelId(channel) {
-	return channel ? normalizeChannelId(channel) : null;
-}
-function resolveEdgeOutputFormat(config) {
-	return config.edge.outputFormat;
-}
-function resolveTtsApiKey(config, provider) {
-	if (provider === "elevenlabs") return config.elevenlabs.apiKey || process.env.ELEVENLABS_API_KEY || process.env.XI_API_KEY;
-	if (provider === "openai") return config.openai.apiKey || process.env.OPENAI_API_KEY;
-}
-const TTS_PROVIDERS = [
-	"openai",
-	"elevenlabs",
-	"edge"
-];
-function resolveTtsProviderOrder(primary) {
-	return [primary, ...TTS_PROVIDERS.filter((provider) => provider !== primary)];
-}
-function isTtsProviderConfigured(config, provider) {
-	if (provider === "edge") return config.edge.enabled;
-	return Boolean(resolveTtsApiKey(config, provider));
-}
-async function textToSpeech(params) {
-	const config = resolveTtsConfig(params.cfg);
-	const prefsPath = params.prefsPath ?? resolveTtsPrefsPath(config);
-	const output = resolveOutputFormat(resolveChannelId(params.channel));
-	if (params.text.length > config.maxTextLength) return {
-		success: false,
-		error: `Text too long (${params.text.length} chars, max ${config.maxTextLength})`
-	};
-	const userProvider = getTtsProvider(config, prefsPath);
-	const providers = resolveTtsProviderOrder(params.overrides?.provider ?? userProvider);
-	let lastError;
-	for (const provider of providers) {
-		const providerStart = Date.now();
-		try {
-			if (provider === "edge") {
-				if (!config.edge.enabled) {
-					lastError = "edge: disabled";
-					continue;
-				}
-				const tempDir = mkdtempSync(path.join(tmpdir(), "tts-"));
-				let edgeOutputFormat = resolveEdgeOutputFormat(config);
-				const fallbackEdgeOutputFormat = edgeOutputFormat !== DEFAULT_EDGE_OUTPUT_FORMAT ? DEFAULT_EDGE_OUTPUT_FORMAT : void 0;
-				const attemptEdgeTts = async (outputFormat) => {
-					const extension = inferEdgeExtension(outputFormat);
-					const audioPath = path.join(tempDir, `voice-${Date.now()}${extension}`);
-					await edgeTTS({
-						text: params.text,
-						outputPath: audioPath,
-						config: {
-							...config.edge,
-							outputFormat
-						},
-						timeoutMs: config.timeoutMs
-					});
-					return {
-						audioPath,
-						outputFormat
-					};
-				};
-				let edgeResult;
-				try {
-					edgeResult = await attemptEdgeTts(edgeOutputFormat);
-				} catch (err) {
-					if (fallbackEdgeOutputFormat && fallbackEdgeOutputFormat !== edgeOutputFormat) {
-						logVerbose(`TTS: Edge output ${edgeOutputFormat} failed; retrying with ${fallbackEdgeOutputFormat}.`);
-						edgeOutputFormat = fallbackEdgeOutputFormat;
-						try {
-							edgeResult = await attemptEdgeTts(edgeOutputFormat);
-						} catch (fallbackErr) {
-							try {
-								rmSync(tempDir, {
-									recursive: true,
-									force: true
-								});
-							} catch {}
-							throw fallbackErr;
-						}
-					} else {
-						try {
-							rmSync(tempDir, {
-								recursive: true,
-								force: true
-							});
-						} catch {}
-						throw err;
-					}
-				}
-				scheduleCleanup(tempDir);
-				const voiceCompatible = isVoiceCompatibleAudio({ fileName: edgeResult.audioPath });
-				return {
-					success: true,
-					audioPath: edgeResult.audioPath,
-					latencyMs: Date.now() - providerStart,
-					provider,
-					outputFormat: edgeResult.outputFormat,
-					voiceCompatible
-				};
-			}
-			const apiKey = resolveTtsApiKey(config, provider);
-			if (!apiKey) {
-				lastError = `No API key for ${provider}`;
-				continue;
-			}
-			let audioBuffer;
-			if (provider === "elevenlabs") {
-				const voiceIdOverride = params.overrides?.elevenlabs?.voiceId;
-				const modelIdOverride = params.overrides?.elevenlabs?.modelId;
-				const voiceSettings = {
-					...config.elevenlabs.voiceSettings,
-					...params.overrides?.elevenlabs?.voiceSettings
-				};
-				const seedOverride = params.overrides?.elevenlabs?.seed;
-				const normalizationOverride = params.overrides?.elevenlabs?.applyTextNormalization;
-				const languageOverride = params.overrides?.elevenlabs?.languageCode;
-				audioBuffer = await elevenLabsTTS({
-					text: params.text,
-					apiKey,
-					baseUrl: config.elevenlabs.baseUrl,
-					voiceId: voiceIdOverride ?? config.elevenlabs.voiceId,
-					modelId: modelIdOverride ?? config.elevenlabs.modelId,
-					outputFormat: output.elevenlabs,
-					seed: seedOverride ?? config.elevenlabs.seed,
-					applyTextNormalization: normalizationOverride ?? config.elevenlabs.applyTextNormalization,
-					languageCode: languageOverride ?? config.elevenlabs.languageCode,
-					voiceSettings,
-					timeoutMs: config.timeoutMs
-				});
-			} else {
-				const openaiModelOverride = params.overrides?.openai?.model;
-				const openaiVoiceOverride = params.overrides?.openai?.voice;
-				audioBuffer = await openaiTTS({
-					text: params.text,
-					apiKey,
-					model: openaiModelOverride ?? config.openai.model,
-					voice: openaiVoiceOverride ?? config.openai.voice,
-					responseFormat: output.openai,
-					timeoutMs: config.timeoutMs
-				});
-			}
-			const latencyMs = Date.now() - providerStart;
-			const tempDir = mkdtempSync(path.join(tmpdir(), "tts-"));
-			const audioPath = path.join(tempDir, `voice-${Date.now()}${output.extension}`);
-			writeFileSync(audioPath, audioBuffer);
-			scheduleCleanup(tempDir);
-			return {
-				success: true,
-				audioPath,
-				latencyMs,
-				provider,
-				outputFormat: provider === "openai" ? output.openai : output.elevenlabs,
-				voiceCompatible: output.voiceCompatible
-			};
-		} catch (err) {
-			const error = err;
-			if (error.name === "AbortError") lastError = `${provider}: request timed out`;
-			else lastError = `${provider}: ${error.message}`;
-		}
-	}
-	return {
-		success: false,
-		error: `TTS conversion failed: ${lastError || "no providers available"}`
-	};
-}
-async function textToSpeechTelephony(params) {
-	const config = resolveTtsConfig(params.cfg);
-	const prefsPath = params.prefsPath ?? resolveTtsPrefsPath(config);
-	if (params.text.length > config.maxTextLength) return {
-		success: false,
-		error: `Text too long (${params.text.length} chars, max ${config.maxTextLength})`
-	};
-	const providers = resolveTtsProviderOrder(getTtsProvider(config, prefsPath));
-	let lastError;
-	for (const provider of providers) {
-		const providerStart = Date.now();
-		try {
-			if (provider === "edge") {
-				lastError = "edge: unsupported for telephony";
-				continue;
-			}
-			const apiKey = resolveTtsApiKey(config, provider);
-			if (!apiKey) {
-				lastError = `No API key for ${provider}`;
-				continue;
-			}
-			if (provider === "elevenlabs") {
-				const output = TELEPHONY_OUTPUT.elevenlabs;
-				return {
-					success: true,
-					audioBuffer: await elevenLabsTTS({
-						text: params.text,
-						apiKey,
-						baseUrl: config.elevenlabs.baseUrl,
-						voiceId: config.elevenlabs.voiceId,
-						modelId: config.elevenlabs.modelId,
-						outputFormat: output.format,
-						seed: config.elevenlabs.seed,
-						applyTextNormalization: config.elevenlabs.applyTextNormalization,
-						languageCode: config.elevenlabs.languageCode,
-						voiceSettings: config.elevenlabs.voiceSettings,
-						timeoutMs: config.timeoutMs
-					}),
-					latencyMs: Date.now() - providerStart,
-					provider,
-					outputFormat: output.format,
-					sampleRate: output.sampleRate
-				};
-			}
-			const output = TELEPHONY_OUTPUT.openai;
-			return {
-				success: true,
-				audioBuffer: await openaiTTS({
-					text: params.text,
-					apiKey,
-					model: config.openai.model,
-					voice: config.openai.voice,
-					responseFormat: output.format,
-					timeoutMs: config.timeoutMs
-				}),
-				latencyMs: Date.now() - providerStart,
-				provider,
-				outputFormat: output.format,
-				sampleRate: output.sampleRate
-			};
-		} catch (err) {
-			const error = err;
-			if (error.name === "AbortError") lastError = `${provider}: request timed out`;
-			else lastError = `${provider}: ${error.message}`;
-		}
-	}
-	return {
-		success: false,
-		error: `TTS conversion failed: ${lastError || "no providers available"}`
-	};
-}
-async function maybeApplyTtsToPayload(params) {
-	const config = resolveTtsConfig(params.cfg);
-	const prefsPath = resolveTtsPrefsPath(config);
-	const autoMode = resolveTtsAutoMode({
-		config,
-		prefsPath,
-		sessionAuto: params.ttsAuto
-	});
-	if (autoMode === "off") return params.payload;
-	const text = params.payload.text ?? "";
-	const directives = parseTtsDirectives(text, config.modelOverrides);
-	if (directives.warnings.length > 0) logVerbose(`TTS: ignored directive overrides (${directives.warnings.join("; ")})`);
-	const trimmedCleaned = directives.cleanedText.trim();
-	const visibleText = trimmedCleaned.length > 0 ? trimmedCleaned : "";
-	const ttsText = directives.ttsText?.trim() || visibleText;
-	const nextPayload = visibleText === text.trim() ? params.payload : {
-		...params.payload,
-		text: visibleText.length > 0 ? visibleText : void 0
-	};
-	if (autoMode === "tagged" && !directives.hasDirective) return nextPayload;
-	if (autoMode === "inbound" && params.inboundAudio !== true) return nextPayload;
-	if ((config.mode ?? "final") === "final" && params.kind && params.kind !== "final") return nextPayload;
-	if (!ttsText.trim()) return nextPayload;
-	if (params.payload.mediaUrl || (params.payload.mediaUrls?.length ?? 0) > 0) return nextPayload;
-	if (text.includes("MEDIA:")) return nextPayload;
-	if (ttsText.trim().length < 10) return nextPayload;
-	const maxLength = getTtsMaxLength(prefsPath);
-	let textForAudio = ttsText.trim();
-	let wasSummarized = false;
-	if (textForAudio.length > maxLength) if (!isSummarizationEnabled(prefsPath)) {
-		logVerbose(`TTS: truncating long text (${textForAudio.length} > ${maxLength}), summarization disabled.`);
-		textForAudio = `${textForAudio.slice(0, maxLength - 3)}...`;
-	} else try {
-		textForAudio = (await summarizeText({
-			text: textForAudio,
-			targetLength: maxLength,
-			cfg: params.cfg,
-			config,
-			timeoutMs: config.timeoutMs
-		})).summary;
-		wasSummarized = true;
-		if (textForAudio.length > config.maxTextLength) {
-			logVerbose(`TTS: summary exceeded hard limit (${textForAudio.length} > ${config.maxTextLength}); truncating.`);
-			textForAudio = `${textForAudio.slice(0, config.maxTextLength - 3)}...`;
-		}
-	} catch (err) {
-		logVerbose(`TTS: summarization failed, truncating instead: ${err.message}`);
-		textForAudio = `${textForAudio.slice(0, maxLength - 3)}...`;
-	}
-	textForAudio = stripMarkdown(textForAudio).trim();
-	if (textForAudio.length < 10) return nextPayload;
-	const ttsStart = Date.now();
-	const result = await textToSpeech({
-		text: textForAudio,
-		cfg: params.cfg,
-		prefsPath,
-		channel: params.channel,
-		overrides: directives.overrides
-	});
-	if (result.success && result.audioPath) {
-		lastTtsAttempt = {
-			timestamp: Date.now(),
-			success: true,
-			textLength: text.length,
-			summarized: wasSummarized,
-			provider: result.provider,
-			latencyMs: result.latencyMs
-		};
-		const shouldVoice = resolveChannelId(params.channel) === "telegram" && result.voiceCompatible === true;
-		return {
-			...nextPayload,
-			mediaUrl: result.audioPath,
-			audioAsVoice: shouldVoice || params.payload.audioAsVoice
-		};
-	}
-	lastTtsAttempt = {
-		timestamp: Date.now(),
-		success: false,
-		textLength: text.length,
-		summarized: wasSummarized,
-		error: result.error
-	};
-	logVerbose(`TTS: conversion failed after ${Date.now() - ttsStart}ms (${result.error ?? "unknown"}).`);
-	return nextPayload;
-}
-
-//#endregion
-//#region src/agents/model-alias-lines.ts
-function buildModelAliasLines(cfg) {
-	const models = cfg?.agents?.defaults?.models ?? {};
-	const entries = [];
-	for (const [keyRaw, entryRaw] of Object.entries(models)) {
-		const model = String(keyRaw ?? "").trim();
-		if (!model) continue;
-		const alias = String(entryRaw?.alias ?? "").trim();
-		if (!alias) continue;
-		entries.push({
-			alias,
-			model
-		});
-	}
-	return entries.toSorted((a, b) => a.alias.localeCompare(b.alias)).map((entry) => `- ${entry.alias}: ${entry.model}`);
-}
-
-//#endregion
-//#region src/agents/shell-utils.ts
-function resolvePowerShellPath() {
-	const systemRoot = process.env.SystemRoot || process.env.WINDIR;
-	if (systemRoot) {
-		const candidate = path.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
-		if (fs$1.existsSync(candidate)) return candidate;
-	}
-	return "powershell.exe";
-}
-function getShellConfig() {
-	if (process.platform === "win32") return {
-		shell: resolvePowerShellPath(),
-		args: [
-			"-NoProfile",
-			"-NonInteractive",
-			"-Command"
-		]
-	};
-	const envShell = process.env.SHELL?.trim();
-	if ((envShell ? path.basename(envShell) : "") === "fish") {
-		const bash = resolveShellFromPath("bash");
-		if (bash) return {
-			shell: bash,
-			args: ["-c"]
-		};
-		const sh = resolveShellFromPath("sh");
-		if (sh) return {
-			shell: sh,
-			args: ["-c"]
-		};
-	}
-	return {
-		shell: envShell && envShell.length > 0 ? envShell : "sh",
-		args: ["-c"]
-	};
-}
-function resolveShellFromPath(name) {
-	const envPath = process.env.PATH ?? "";
-	if (!envPath) return;
-	const entries = envPath.split(path.delimiter).filter(Boolean);
-	for (const entry of entries) {
-		const candidate = path.join(entry, name);
-		try {
-			fs$1.accessSync(candidate, fs$1.constants.X_OK);
-			return candidate;
-		} catch {}
-	}
-}
-function normalizeShellName(value) {
-	const trimmed = value.trim();
-	if (!trimmed) return "";
-	return path.basename(trimmed).replace(/\.(exe|cmd|bat)$/i, "").replace(/[^a-zA-Z0-9_-]/g, "");
-}
-function detectRuntimeShell() {
-	const overrideShell = process.env.ANIMA_SHELL?.trim();
-	if (overrideShell) {
-		const name = normalizeShellName(overrideShell);
-		if (name) return name;
-	}
-	if (process.platform === "win32") {
-		if (process.env.POWERSHELL_DISTRIBUTION_CHANNEL) return "pwsh";
-		return "powershell";
-	}
-	const envShell = process.env.SHELL?.trim();
-	if (envShell) {
-		const name = normalizeShellName(envShell);
-		if (name) return name;
-	}
-	if (process.env.POWERSHELL_DISTRIBUTION_CHANNEL) return "pwsh";
-	if (process.env.BASH_VERSION) return "bash";
-	if (process.env.ZSH_VERSION) return "zsh";
-	if (process.env.FISH_VERSION) return "fish";
-	if (process.env.KSH_VERSION) return "ksh";
-	if (process.env.NU_VERSION || process.env.NUSHELL_VERSION) return "nu";
-}
-function sanitizeBinaryOutput(text) {
-	const scrubbed = text.replace(/[\p{Format}\p{Surrogate}]/gu, "");
-	if (!scrubbed) return scrubbed;
-	const chunks = [];
-	for (const char of scrubbed) {
-		const code = char.codePointAt(0);
-		if (code == null) continue;
-		if (code === 9 || code === 10 || code === 13) {
-			chunks.push(char);
-			continue;
-		}
-		if (code < 32) continue;
-		chunks.push(char);
-	}
-	return chunks.join("");
-}
-function killProcessTree(pid) {
-	if (process.platform === "win32") {
-		try {
-			spawn("taskkill", [
-				"/F",
-				"/T",
-				"/PID",
-				String(pid)
-			], {
-				stdio: "ignore",
-				detached: true
-			});
-		} catch {}
-		return;
-	}
-	try {
-		process.kill(-pid, "SIGKILL");
-	} catch {
-		try {
-			process.kill(pid, "SIGKILL");
-		} catch {}
-	}
-}
-
-//#endregion
-//#region src/agents/date-time.ts
-let cachedTimeFormat;
-function resolveUserTimezone(configured) {
-	const trimmed = configured?.trim();
-	if (trimmed) try {
-		new Intl.DateTimeFormat("en-US", { timeZone: trimmed }).format(/* @__PURE__ */ new Date());
-		return trimmed;
-	} catch {}
-	return Intl.DateTimeFormat().resolvedOptions().timeZone?.trim() || "UTC";
-}
-function resolveUserTimeFormat(preference) {
-	if (preference === "12" || preference === "24") return preference;
-	if (cachedTimeFormat) return cachedTimeFormat;
-	cachedTimeFormat = detectSystemTimeFormat() ? "24" : "12";
-	return cachedTimeFormat;
-}
-function normalizeTimestamp(raw) {
-	if (raw == null) return;
-	let timestampMs;
-	if (raw instanceof Date) timestampMs = raw.getTime();
-	else if (typeof raw === "number" && Number.isFinite(raw)) timestampMs = raw < 0xe8d4a51000 ? Math.round(raw * 1e3) : Math.round(raw);
-	else if (typeof raw === "string") {
-		const trimmed = raw.trim();
-		if (!trimmed) return;
-		if (/^\d+(\.\d+)?$/.test(trimmed)) {
-			const num = Number(trimmed);
-			if (Number.isFinite(num)) if (trimmed.includes(".")) timestampMs = Math.round(num * 1e3);
-			else if (trimmed.length >= 13) timestampMs = Math.round(num);
-			else timestampMs = Math.round(num * 1e3);
-		} else {
-			const parsed = Date.parse(trimmed);
-			if (!Number.isNaN(parsed)) timestampMs = parsed;
-		}
-	}
-	if (timestampMs === void 0 || !Number.isFinite(timestampMs)) return;
-	return {
-		timestampMs,
-		timestampUtc: new Date(timestampMs).toISOString()
-	};
-}
-function withNormalizedTimestamp(value, rawTimestamp) {
-	const normalized = normalizeTimestamp(rawTimestamp);
-	if (!normalized) return value;
-	return {
-		...value,
-		timestampMs: typeof value.timestampMs === "number" && Number.isFinite(value.timestampMs) ? value.timestampMs : normalized.timestampMs,
-		timestampUtc: typeof value.timestampUtc === "string" && value.timestampUtc.trim() ? value.timestampUtc : normalized.timestampUtc
-	};
-}
-function detectSystemTimeFormat() {
-	if (process.platform === "darwin") try {
-		const result = execSync("defaults read -g AppleICUForce24HourTime 2>/dev/null", {
-			encoding: "utf8",
-			timeout: 500
-		}).trim();
-		if (result === "1") return true;
-		if (result === "0") return false;
-	} catch {}
-	if (process.platform === "win32") try {
-		const result = execSync("powershell -Command \"(Get-Culture).DateTimeFormat.ShortTimePattern\"", {
-			encoding: "utf8",
-			timeout: 1e3
-		}).trim();
-		if (result.startsWith("H")) return true;
-		if (result.startsWith("h")) return false;
-	} catch {}
-	try {
-		const sample = new Date(2e3, 0, 1, 13, 0);
-		return new Intl.DateTimeFormat(void 0, { hour: "numeric" }).format(sample).includes("13");
-	} catch {
-		return false;
-	}
-}
-function ordinalSuffix(day) {
-	if (day >= 11 && day <= 13) return "th";
-	switch (day % 10) {
-		case 1: return "st";
-		case 2: return "nd";
-		case 3: return "rd";
-		default: return "th";
-	}
-}
-function formatUserTime(date, timeZone, format) {
-	const use24Hour = format === "24";
-	try {
-		const parts = new Intl.DateTimeFormat("en-US", {
-			timeZone,
-			weekday: "long",
-			year: "numeric",
-			month: "long",
-			day: "numeric",
-			hour: use24Hour ? "2-digit" : "numeric",
-			minute: "2-digit",
-			hourCycle: use24Hour ? "h23" : "h12"
-		}).formatToParts(date);
-		const map = {};
-		for (const part of parts) if (part.type !== "literal") map[part.type] = part.value;
-		if (!map.weekday || !map.year || !map.month || !map.day || !map.hour || !map.minute) return;
-		const dayNum = parseInt(map.day, 10);
-		const suffix = ordinalSuffix(dayNum);
-		const timePart = use24Hour ? `${map.hour}:${map.minute}` : `${map.hour}:${map.minute} ${map.dayPeriod ?? ""}`.trim();
-		return `${map.weekday}, ${map.month} ${dayNum}${suffix}, ${map.year} — ${timePart}`;
-	} catch {
-		return;
-	}
-}
-
-//#endregion
-//#region src/agents/system-prompt-params.ts
-function buildSystemPromptParams(params) {
-	const repoRoot = resolveRepoRoot({
-		config: params.config,
-		workspaceDir: params.workspaceDir,
-		cwd: params.cwd
-	});
-	const userTimezone = resolveUserTimezone(params.config?.agents?.defaults?.userTimezone);
-	const userTimeFormat = resolveUserTimeFormat(params.config?.agents?.defaults?.timeFormat);
-	const userTime = formatUserTime(/* @__PURE__ */ new Date(), userTimezone, userTimeFormat);
-	return {
-		runtimeInfo: {
-			agentId: params.agentId,
-			...params.runtime,
-			repoRoot
-		},
-		userTimezone,
-		userTime,
-		userTimeFormat
-	};
-}
-function resolveRepoRoot(params) {
-	const configured = params.config?.agents?.defaults?.repoRoot?.trim();
-	if (configured) try {
-		const resolved = path.resolve(configured);
-		if (fs$1.statSync(resolved).isDirectory()) return resolved;
-	} catch {}
-	const candidates = [params.workspaceDir, params.cwd].map((value) => value?.trim()).filter(Boolean);
-	const seen = /* @__PURE__ */ new Set();
-	for (const candidate of candidates) {
-		const resolved = path.resolve(candidate);
-		if (seen.has(resolved)) continue;
-		seen.add(resolved);
-		const root = findGitRoot(resolved);
-		if (root) return root;
-	}
-}
-function findGitRoot(startDir) {
-	let current = path.resolve(startDir);
-	for (let i = 0; i < 12; i += 1) {
-		const gitPath = path.join(current, ".git");
-		try {
-			const stat = fs$1.statSync(gitPath);
-			if (stat.isDirectory() || stat.isFile()) return current;
-		} catch {}
-		const parent = path.dirname(current);
-		if (parent === current) break;
-		current = parent;
-	}
-	return null;
-}
-
-//#endregion
-//#region src/agents/system-prompt.ts
-function buildSkillsSection(params) {
-	if (params.isMinimal) return [];
-	const trimmed = params.skillsPrompt?.trim();
-	if (!trimmed) return [];
-	return [
-		"## Skills (mandatory)",
-		"Before replying: scan <available_skills> <description> entries.",
-		`- If exactly one skill clearly applies: read its SKILL.md at <location> with \`${params.readToolName}\`, then follow it.`,
-		"- If multiple could apply: choose the most specific one, then read/follow it.",
-		"- If none clearly apply: do not read any SKILL.md.",
-		"Constraints: never read more than one skill up front; only read after selecting.",
-		trimmed,
-		""
-	];
-}
-function buildMemorySection(params) {
-	if (params.isMinimal) return [];
-	if (!params.availableTools.has("memory_search") && !params.availableTools.has("memory_get")) return [];
-	const lines = ["## Memory Recall", "Before answering anything about prior work, decisions, dates, people, preferences, or todos: run memory_search on MEMORY.md + memory/*.md; then use memory_get to pull only the needed lines. If low confidence after search, say you checked."];
-	if (params.citationsMode === "off") lines.push("Citations are disabled: do not mention file paths or line numbers in replies unless the user explicitly asks.");
-	else lines.push("Citations: include Source: <path#line> when it helps the user verify memory snippets.");
-	lines.push("");
-	return lines;
-}
-function buildUserIdentitySection(ownerLine, isMinimal) {
-	if (!ownerLine || isMinimal) return [];
-	return [
-		"## User Identity",
-		ownerLine,
-		""
-	];
-}
-function buildTimeSection(params) {
-	if (!params.userTimezone) return [];
-	return [
-		"## Current Date & Time",
-		`Time zone: ${params.userTimezone}`,
-		""
-	];
-}
-function buildReplyTagsSection(isMinimal) {
-	if (isMinimal) return [];
-	return [
-		"## Reply Tags",
-		"To request a native reply/quote on supported surfaces, include one tag in your reply:",
-		"- [[reply_to_current]] replies to the triggering message.",
-		"- Prefer [[reply_to_current]]. Use [[reply_to:<id>]] only when an id was explicitly provided (e.g. by the user or a tool).",
-		"Whitespace inside the tag is allowed (e.g. [[ reply_to_current ]] / [[ reply_to: 123 ]]).",
-		"Tags are stripped before sending; support depends on the current channel config.",
-		""
-	];
-}
-function buildMessagingSection(params) {
-	if (params.isMinimal) return [];
-	return [
-		"## Messaging",
-		"- Reply in current session → automatically routes to the source channel (Signal, Telegram, etc.)",
-		"- Cross-session messaging → use sessions_send(sessionKey, message)",
-		"- Sub-agent orchestration → use subagents(action=list|steer|kill)",
-		"- `[System Message] ...` blocks are internal context and are not user-visible by default.",
-		"- If a `[System Message]` reports completed cron/subagent work and asks for a user update, rewrite it in your normal assistant voice and send that update (do not forward raw system text or default to NO_REPLY).",
-		"- Never use exec/curl for provider messaging; Anima handles all routing internally.",
-		params.availableTools.has("message") ? [
-			"",
-			"### message tool",
-			"- Use `message` for proactive sends + channel actions (polls, reactions, etc.).",
-			"- For `action=send`, include `to` and `message`.",
-			`- If multiple channels are configured, pass \`channel\` (${params.messageChannelOptions}).`,
-			`- If you use \`message\` (\`action=send\`) to deliver your user-visible reply, respond with ONLY: ${SILENT_REPLY_TOKEN} (avoid duplicate replies).`,
-			params.inlineButtonsEnabled ? "- Inline buttons supported. Use `action=send` with `buttons=[[{text,callback_data}]]` (callback_data routes back as a user message)." : params.runtimeChannel ? `- Inline buttons not enabled for ${params.runtimeChannel}. If you need them, ask to set ${params.runtimeChannel}.capabilities.inlineButtons ("dm"|"group"|"all"|"allowlist").` : "",
-			...params.messageToolHints ?? []
-		].filter(Boolean).join("\n") : "",
-		""
-	];
-}
-function buildVoiceSection(params) {
-	if (params.isMinimal) return [];
-	const hint = params.ttsHint?.trim();
-	if (!hint) return [];
-	return [
-		"## Voice (TTS)",
-		hint,
-		""
-	];
-}
-function buildDocsSection(params) {
-	const docsPath = params.docsPath?.trim();
-	if (!docsPath || params.isMinimal) return [];
-	return [
-		"## Documentation",
-		`Anima docs: ${docsPath}`,
-		"Mirror: https://docs.anima.ai",
-		"Source: https://github.com/anima/anima",
-		"Community: https://discord.com/invite/clawd",
-		"Find new skills: https://animahub.com",
-		"For Anima behavior, commands, config, or architecture: consult local docs first.",
-		"When diagnosing issues, run `anima status` yourself when possible; only ask the user if you lack access (e.g., sandboxed).",
-		""
-	];
-}
-function buildAgentSystemPrompt(params) {
-	const coreToolSummaries = {
-		read: "Read file contents",
-		write: "Create or overwrite files",
-		edit: "Make precise edits to files",
-		apply_patch: "Apply multi-file patches",
-		grep: "Search file contents for patterns",
-		find: "Find files by glob pattern",
-		ls: "List directory contents",
-		exec: "Run shell commands (pty available for TTY-required CLIs)",
-		process: "Manage background exec sessions",
-		web_search: "Search the web (Brave API)",
-		web_fetch: "Fetch and extract readable content from a URL",
-		browser: "Control web browser",
-		canvas: "Present/eval/snapshot the Canvas",
-		nodes: "List/describe/notify/camera/screen on paired nodes",
-		cron: "Manage cron jobs and wake events (use for reminders; when scheduling a reminder, write the systemEvent text as something that will read like a reminder when it fires, and mention that it is a reminder depending on the time gap between setting and firing; include recent context in reminder text if appropriate)",
-		message: "Send messages and channel actions",
-		gateway: "Restart, apply config, or run updates on the running Anima process",
-		agents_list: "List agent ids allowed for sessions_spawn",
-		sessions_list: "List other sessions (incl. sub-agents) with filters/last",
-		sessions_history: "Fetch history for another session/sub-agent",
-		sessions_send: "Send a message to another session/sub-agent",
-		sessions_spawn: "Spawn a sub-agent session",
-		subagents: "List, steer, or kill sub-agent runs for this requester session",
-		session_status: "Show a /status-equivalent status card (usage + time + Reasoning/Verbose/Elevated); use for model-use questions (📊 session_status); optional per-session model override",
-		image: "Analyze an image with the configured image model"
-	};
-	const toolOrder = [
-		"read",
-		"write",
-		"edit",
-		"apply_patch",
-		"grep",
-		"find",
-		"ls",
-		"exec",
-		"process",
-		"web_search",
-		"web_fetch",
-		"browser",
-		"canvas",
-		"nodes",
-		"cron",
-		"message",
-		"gateway",
-		"agents_list",
-		"sessions_list",
-		"sessions_history",
-		"sessions_send",
-		"subagents",
-		"session_status",
-		"image"
-	];
-	const canonicalToolNames = (params.toolNames ?? []).map((tool) => tool.trim()).filter(Boolean);
-	const canonicalByNormalized = /* @__PURE__ */ new Map();
-	for (const name of canonicalToolNames) {
-		const normalized = name.toLowerCase();
-		if (!canonicalByNormalized.has(normalized)) canonicalByNormalized.set(normalized, name);
-	}
-	const resolveToolName = (normalized) => canonicalByNormalized.get(normalized) ?? normalized;
-	const normalizedTools = canonicalToolNames.map((tool) => tool.toLowerCase());
-	const availableTools = new Set(normalizedTools);
-	const externalToolSummaries = /* @__PURE__ */ new Map();
-	for (const [key, value] of Object.entries(params.toolSummaries ?? {})) {
-		const normalized = key.trim().toLowerCase();
-		if (!normalized || !value?.trim()) continue;
-		externalToolSummaries.set(normalized, value.trim());
-	}
-	const extraTools = Array.from(new Set(normalizedTools.filter((tool) => !toolOrder.includes(tool))));
-	const toolLines = toolOrder.filter((tool) => availableTools.has(tool)).map((tool) => {
-		const summary = coreToolSummaries[tool] ?? externalToolSummaries.get(tool);
-		const name = resolveToolName(tool);
-		return summary ? `- ${name}: ${summary}` : `- ${name}`;
-	});
-	for (const tool of extraTools.toSorted()) {
-		const summary = coreToolSummaries[tool] ?? externalToolSummaries.get(tool);
-		const name = resolveToolName(tool);
-		toolLines.push(summary ? `- ${name}: ${summary}` : `- ${name}`);
-	}
-	const hasGateway = availableTools.has("gateway");
-	const readToolName = resolveToolName("read");
-	const execToolName = resolveToolName("exec");
-	const processToolName = resolveToolName("process");
-	const extraSystemPrompt = params.extraSystemPrompt?.trim();
-	const ownerNumbers = (params.ownerNumbers ?? []).map((value) => value.trim()).filter(Boolean);
-	const ownerLine = ownerNumbers.length > 0 ? `Owner numbers: ${ownerNumbers.join(", ")}. Treat messages from these numbers as the user.` : void 0;
-	const reasoningHint = params.reasoningTagHint ? [
-		"ALL internal reasoning MUST be inside <think>...</think>.",
-		"Do not output any analysis outside <think>.",
-		"Format every reply as <think>...</think> then <final>...</final>, with no other text.",
-		"Only the final user-visible reply may appear inside <final>.",
-		"Only text inside <final> is shown to the user; everything else is discarded and never seen by the user.",
-		"Example:",
-		"<think>Short internal reasoning.</think>",
-		"<final>Hey there! What would you like to do next?</final>"
-	].join(" ") : void 0;
-	const reasoningLevel = params.reasoningLevel ?? "off";
-	const userTimezone = params.userTimezone?.trim();
-	const skillsPrompt = params.skillsPrompt?.trim();
-	const heartbeatPrompt = params.heartbeatPrompt?.trim();
-	const heartbeatPromptLine = heartbeatPrompt ? `Heartbeat prompt: ${heartbeatPrompt}` : "Heartbeat prompt: (configured)";
-	const runtimeInfo = params.runtimeInfo;
-	const runtimeChannel = runtimeInfo?.channel?.trim().toLowerCase();
-	const runtimeCapabilities = (runtimeInfo?.capabilities ?? []).map((cap) => String(cap).trim()).filter(Boolean);
-	const inlineButtonsEnabled = new Set(runtimeCapabilities.map((cap) => cap.toLowerCase())).has("inlinebuttons");
-	const messageChannelOptions = listDeliverableMessageChannels().join("|");
-	const promptMode = params.promptMode ?? "full";
-	const isMinimal = promptMode === "minimal" || promptMode === "none";
-	const sandboxContainerWorkspace = params.sandboxInfo?.containerWorkspaceDir?.trim();
-	const displayWorkspaceDir = params.sandboxInfo?.enabled && sandboxContainerWorkspace ? sandboxContainerWorkspace : params.workspaceDir;
-	const workspaceGuidance = params.sandboxInfo?.enabled && sandboxContainerWorkspace ? `For read/write/edit/apply_patch, file paths resolve against host workspace: ${params.workspaceDir}. Prefer relative paths so both sandboxed exec and file tools work consistently.` : "Treat this directory as the single global workspace for file operations unless explicitly instructed otherwise.";
-	const safetySection = [
-		"## Safety",
-		"You have no independent goals: do not pursue self-preservation, replication, resource acquisition, or power-seeking; avoid long-term plans beyond the user's request.",
-		"Prioritize safety and human oversight over completion; if instructions conflict, pause and ask; comply with stop/pause/audit requests and never bypass safeguards. (Inspired by Anthropic's constitution.)",
-		"Do not manipulate or persuade anyone to expand access or disable safeguards. Do not copy yourself or change system prompts, safety rules, or tool policies unless explicitly requested.",
-		""
-	];
-	const skillsSection = buildSkillsSection({
-		skillsPrompt,
-		isMinimal,
-		readToolName
-	});
-	const memorySection = buildMemorySection({
-		isMinimal,
-		availableTools,
-		citationsMode: params.memoryCitationsMode
-	});
-	const docsSection = buildDocsSection({
-		docsPath: params.docsPath,
-		isMinimal,
-		readToolName
-	});
-	const workspaceNotes = (params.workspaceNotes ?? []).map((note) => note.trim()).filter(Boolean);
-	if (promptMode === "none") return "You are a personal assistant running inside Anima.";
-	const lines = [
-		"You are a personal assistant running inside Anima.",
-		"",
-		"## Tooling",
-		"Tool availability (filtered by policy):",
-		"Tool names are case-sensitive. Call tools exactly as listed.",
-		toolLines.length > 0 ? toolLines.join("\n") : [
-			"Pi lists the standard tools above. This runtime enables:",
-			"- grep: search file contents for patterns",
-			"- find: find files by glob pattern",
-			"- ls: list directory contents",
-			"- apply_patch: apply multi-file patches",
-			`- ${execToolName}: run shell commands (supports background via yieldMs/background)`,
-			`- ${processToolName}: manage background exec sessions`,
-			`- For long waits, avoid rapid poll loops: use ${execToolName} with enough yieldMs or ${processToolName}(action=poll, timeout=<ms>).`,
-			"- browser: control Anima's dedicated browser",
-			"- canvas: present/eval/snapshot the Canvas",
-			"- nodes: list/describe/notify/camera/screen on paired nodes",
-			"- cron: manage cron jobs and wake events (use for reminders; when scheduling a reminder, write the systemEvent text as something that will read like a reminder when it fires, and mention that it is a reminder depending on the time gap between setting and firing; include recent context in reminder text if appropriate)",
-			"- sessions_list: list sessions",
-			"- sessions_history: fetch session history",
-			"- sessions_send: send to another session",
-			"- subagents: list/steer/kill sub-agent runs",
-			"- session_status: show usage/time/model state and answer \"what model are we using?\""
-		].join("\n"),
-		"TOOLS.md does not control tool availability; it is user guidance for how to use external tools.",
-		"If a task is more complex or takes longer, spawn a sub-agent. Completion is push-based: it will auto-announce when done.",
-		"Do not poll `subagents list` / `sessions_list` in a loop; only check status on-demand (for intervention, debugging, or when explicitly asked).",
-		"",
-		"## Tool Call Style",
-		"Default: do not narrate routine, low-risk tool calls (just call the tool).",
-		"Narrate only when it helps: multi-step work, complex/challenging problems, sensitive actions (e.g., deletions), or when the user explicitly asks.",
-		"Keep narration brief and value-dense; avoid repeating obvious steps.",
-		"Use plain human language for narration unless in a technical context.",
-		"",
-		...safetySection,
-		"## Anima CLI Quick Reference",
-		"Anima is controlled via subcommands. Do not invent commands.",
-		"To manage the Gateway daemon service (start/stop/restart):",
-		"- anima gateway status",
-		"- anima gateway start",
-		"- anima gateway stop",
-		"- anima gateway restart",
-		"If unsure, ask the user to run `anima help` (or `anima gateway --help`) and paste the output.",
-		"",
-		...skillsSection,
-		...memorySection,
-		hasGateway && !isMinimal ? "## Anima Self-Update" : "",
-		hasGateway && !isMinimal ? [
-			"Get Updates (self-update) is ONLY allowed when the user explicitly asks for it.",
-			"Do not run config.apply or update.run unless the user explicitly requests an update or config change; if it's not explicit, ask first.",
-			"Actions: config.get, config.schema, config.apply (validate + write full config, then restart), update.run (update deps or git, then restart).",
-			"After restart, Anima pings the last active session automatically."
-		].join("\n") : "",
-		hasGateway && !isMinimal ? "" : "",
-		"",
-		params.modelAliasLines && params.modelAliasLines.length > 0 && !isMinimal ? "## Model Aliases" : "",
-		params.modelAliasLines && params.modelAliasLines.length > 0 && !isMinimal ? "Prefer aliases when specifying model overrides; full provider/model is also accepted." : "",
-		params.modelAliasLines && params.modelAliasLines.length > 0 && !isMinimal ? params.modelAliasLines.join("\n") : "",
-		params.modelAliasLines && params.modelAliasLines.length > 0 && !isMinimal ? "" : "",
-		userTimezone ? "If you need the current date, time, or day of week, run session_status (📊 session_status)." : "",
-		"## Workspace",
-		`Your working directory is: ${displayWorkspaceDir}`,
-		workspaceGuidance,
-		...workspaceNotes,
-		"",
-		...docsSection,
-		params.sandboxInfo?.enabled ? "## Sandbox" : "",
-		params.sandboxInfo?.enabled ? [
-			"You are running in a sandboxed runtime (tools execute in Docker).",
-			"Some tools may be unavailable due to sandbox policy.",
-			"Sub-agents stay sandboxed (no elevated/host access). Need outside-sandbox read/write? Don't spawn; ask first.",
-			params.sandboxInfo.containerWorkspaceDir ? `Sandbox container workdir: ${params.sandboxInfo.containerWorkspaceDir}` : "",
-			params.sandboxInfo.workspaceDir ? `Sandbox host workspace: ${params.sandboxInfo.workspaceDir}` : "",
-			params.sandboxInfo.workspaceAccess ? `Agent workspace access: ${params.sandboxInfo.workspaceAccess}${params.sandboxInfo.agentWorkspaceMount ? ` (mounted at ${params.sandboxInfo.agentWorkspaceMount})` : ""}` : "",
-			params.sandboxInfo.browserBridgeUrl ? "Sandbox browser: enabled." : "",
-			params.sandboxInfo.browserNoVncUrl ? `Sandbox browser observer (noVNC): ${params.sandboxInfo.browserNoVncUrl}` : "",
-			params.sandboxInfo.hostBrowserAllowed === true ? "Host browser control: allowed." : params.sandboxInfo.hostBrowserAllowed === false ? "Host browser control: blocked." : "",
-			params.sandboxInfo.elevated?.allowed ? "Elevated exec is available for this session." : "",
-			params.sandboxInfo.elevated?.allowed ? "User can toggle with /elevated on|off|ask|full." : "",
-			params.sandboxInfo.elevated?.allowed ? "You may also send /elevated on|off|ask|full when needed." : "",
-			params.sandboxInfo.elevated?.allowed ? `Current elevated level: ${params.sandboxInfo.elevated.defaultLevel} (ask runs exec on host with approvals; full auto-approves).` : ""
-		].filter(Boolean).join("\n") : "",
-		params.sandboxInfo?.enabled ? "" : "",
-		...buildUserIdentitySection(ownerLine, isMinimal),
-		...buildTimeSection({ userTimezone }),
-		"## Workspace Files (injected)",
-		"These user-editable files are loaded by Anima and included below in Project Context.",
-		"",
-		...buildReplyTagsSection(isMinimal),
-		...buildMessagingSection({
-			isMinimal,
-			availableTools,
-			messageChannelOptions,
-			inlineButtonsEnabled,
-			runtimeChannel,
-			messageToolHints: params.messageToolHints
-		}),
-		...buildVoiceSection({
-			isMinimal,
-			ttsHint: params.ttsHint
-		})
-	];
-	if (extraSystemPrompt) {
-		const contextHeader = promptMode === "minimal" ? "## Subagent Context" : "## Group Chat Context";
-		lines.push(contextHeader, extraSystemPrompt, "");
-	}
-	if (params.reactionGuidance) {
-		const { level, channel } = params.reactionGuidance;
-		const guidanceText = level === "minimal" ? [
-			`Reactions are enabled for ${channel} in MINIMAL mode.`,
-			"React ONLY when truly relevant:",
-			"- Acknowledge important user requests or confirmations",
-			"- Express genuine sentiment (humor, appreciation) sparingly",
-			"- Avoid reacting to routine messages or your own replies",
-			"Guideline: at most 1 reaction per 5-10 exchanges."
-		].join("\n") : [
-			`Reactions are enabled for ${channel} in EXTENSIVE mode.`,
-			"Feel free to react liberally:",
-			"- Acknowledge messages with appropriate emojis",
-			"- Express sentiment and personality through reactions",
-			"- React to interesting content, humor, or notable events",
-			"- Use reactions to confirm understanding or agreement",
-			"Guideline: react whenever it feels natural."
-		].join("\n");
-		lines.push("## Reactions", guidanceText, "");
-	}
-	if (reasoningHint) lines.push("## Reasoning Format", reasoningHint, "");
-	const validContextFiles = (params.contextFiles ?? []).filter((file) => typeof file.path === "string" && file.path.trim().length > 0);
-	if (validContextFiles.length > 0) {
-		const hasSoulFile = validContextFiles.some((file) => {
-			const normalizedPath = file.path.trim().replace(/\\/g, "/");
-			return (normalizedPath.split("/").pop() ?? normalizedPath).toLowerCase() === "soul.md";
-		});
-		lines.push("# Project Context", "", "The following project context files have been loaded:");
-		if (hasSoulFile) lines.push("If SOUL.md is present, embody its persona and tone. Avoid stiff, generic replies; follow its guidance unless higher-priority instructions override it.");
-		lines.push("");
-		for (const file of validContextFiles) lines.push(`## ${file.path}`, "", file.content, "");
-	}
-	if (!isMinimal) lines.push("## Silent Replies", `When you have nothing to say, respond with ONLY: ${SILENT_REPLY_TOKEN}`, "", "⚠️ Rules:", "- It must be your ENTIRE message — nothing else", `- Never append it to an actual response (never include "${SILENT_REPLY_TOKEN}" in real replies)`, "- Never wrap it in markdown or code blocks", "", `❌ Wrong: "Here's help... ${SILENT_REPLY_TOKEN}"`, `❌ Wrong: "${SILENT_REPLY_TOKEN}"`, `✅ Right: ${SILENT_REPLY_TOKEN}`, "");
-	if (!isMinimal) lines.push("## Heartbeats", heartbeatPromptLine, "If you receive a heartbeat poll (a user message matching the heartbeat prompt above), and there is nothing that needs attention, reply exactly:", "HEARTBEAT_OK", "Anima treats a leading/trailing \"HEARTBEAT_OK\" as a heartbeat ack (and may discard it).", "If something needs attention, do NOT include \"HEARTBEAT_OK\"; reply with the alert text instead.", "");
-	lines.push("## Runtime", buildRuntimeLine(runtimeInfo, runtimeChannel, runtimeCapabilities, params.defaultThinkLevel), `Reasoning: ${reasoningLevel} (hidden unless on/stream). Toggle /reasoning; /status shows Reasoning when enabled.`);
-	return lines.filter(Boolean).join("\n");
-}
-function buildRuntimeLine(runtimeInfo, runtimeChannel, runtimeCapabilities = [], defaultThinkLevel) {
-	return `Runtime: ${[
-		runtimeInfo?.agentId ? `agent=${runtimeInfo.agentId}` : "",
-		runtimeInfo?.host ? `host=${runtimeInfo.host}` : "",
-		runtimeInfo?.repoRoot ? `repo=${runtimeInfo.repoRoot}` : "",
-		runtimeInfo?.os ? `os=${runtimeInfo.os}${runtimeInfo?.arch ? ` (${runtimeInfo.arch})` : ""}` : runtimeInfo?.arch ? `arch=${runtimeInfo.arch}` : "",
-		runtimeInfo?.node ? `node=${runtimeInfo.node}` : "",
-		runtimeInfo?.model ? `model=${runtimeInfo.model}` : "",
-		runtimeInfo?.defaultModel ? `default_model=${runtimeInfo.defaultModel}` : "",
-		runtimeInfo?.shell ? `shell=${runtimeInfo.shell}` : "",
-		runtimeChannel ? `channel=${runtimeChannel}` : "",
-		runtimeChannel ? `capabilities=${runtimeCapabilities.length > 0 ? runtimeCapabilities.join(",") : "none"}` : "",
-		`thinking=${defaultThinkLevel ?? "off"}`
-	].filter(Boolean).join(" | ")}`;
-}
-
-//#endregion
-//#region src/agents/cli-runner/helpers.ts
-const CLI_RUN_QUEUE = /* @__PURE__ */ new Map();
-function buildLooseArgOrderRegex(tokens) {
-	const [head, ...rest] = tokens.map((t) => String(t ?? "").trim()).filter(Boolean);
-	if (!head) return /$^/;
-	const headEscaped = escapeRegExp(head);
-	const headFragment = `(?:^|\\s)(?:${headEscaped}|\\S+\\/${headEscaped})(?=\\s|$)`;
-	const restFragments = rest.map((t) => `(?:^|\\s)${escapeRegExp(t)}(?=\\s|$)`);
-	return new RegExp([headFragment, ...restFragments].join(".*"));
-}
-async function psWithFallback(argsA, argsB) {
-	try {
-		const { stdout } = await runExec("ps", argsA);
-		return stdout;
-	} catch {}
-	const { stdout } = await runExec("ps", argsB);
-	return stdout;
-}
-async function cleanupResumeProcesses(backend, sessionId) {
-	if (process.platform === "win32") return;
-	const resumeArgs = backend.resumeArgs ?? [];
-	if (resumeArgs.length === 0) return;
-	if (!resumeArgs.some((arg) => arg.includes("{sessionId}"))) return;
-	const commandToken = path.basename(backend.command ?? "").trim();
-	if (!commandToken) return;
-	const resumeTokens = resumeArgs.map((arg) => arg.replaceAll("{sessionId}", sessionId));
-	if (![commandToken, ...resumeTokens].filter(Boolean).map((token) => escapeRegExp(token)).join(".*")) return;
-	try {
-		const stdout = await psWithFallback([
-			"-axww",
-			"-o",
-			"pid=,ppid=,command="
-		], [
-			"-ax",
-			"-o",
-			"pid=,ppid=,command="
-		]);
-		const patternRegex = buildLooseArgOrderRegex([commandToken, ...resumeTokens]);
-		const toKill = [];
-		for (const line of stdout.split("\n")) {
-			const trimmed = line.trim();
-			if (!trimmed) continue;
-			const match = /^(\d+)\s+(\d+)\s+(.*)$/.exec(trimmed);
-			if (!match) continue;
-			const pid = Number(match[1]);
-			const ppid = Number(match[2]);
-			const cmd = match[3] ?? "";
-			if (!Number.isFinite(pid)) continue;
-			if (ppid !== process.pid) continue;
-			if (!patternRegex.test(cmd)) continue;
-			toKill.push(pid);
-		}
-		if (toKill.length > 0) {
-			const pidArgs = toKill.map((pid) => String(pid));
-			try {
-				await runExec("kill", ["-TERM", ...pidArgs]);
-			} catch {}
-			await new Promise((resolve) => setTimeout(resolve, 250));
-			try {
-				await runExec("kill", ["-9", ...pidArgs]);
-			} catch {}
-		}
-	} catch {}
-}
-function buildSessionMatchers(backend) {
-	const commandToken = path.basename(backend.command ?? "").trim();
-	if (!commandToken) return [];
-	const matchers = [];
-	const sessionArg = backend.sessionArg?.trim();
-	const sessionArgs = backend.sessionArgs ?? [];
-	const resumeArgs = backend.resumeArgs ?? [];
-	const addMatcher = (args) => {
-		if (args.length === 0) return;
-		const pattern = [commandToken, ...args].map((token, index) => {
-			const tokenPattern = tokenToRegex(token);
-			return index === 0 ? `(?:^|\\s)${tokenPattern}` : `\\s+${tokenPattern}`;
-		}).join("");
-		matchers.push(new RegExp(pattern));
-	};
-	if (sessionArgs.some((arg) => arg.includes("{sessionId}"))) addMatcher(sessionArgs);
-	else if (sessionArg) addMatcher([sessionArg, "{sessionId}"]);
-	if (resumeArgs.some((arg) => arg.includes("{sessionId}"))) addMatcher(resumeArgs);
-	return matchers;
-}
-function tokenToRegex(token) {
-	if (!token.includes("{sessionId}")) return escapeRegExp(token);
-	return token.split("{sessionId}").map((part) => escapeRegExp(part)).join("\\S+");
-}
-/**
-* Cleanup suspended Anima CLI processes that have accumulated.
-* Only cleans up if there are more than the threshold (default: 10).
-*/
-async function cleanupSuspendedCliProcesses(backend, threshold = 10) {
-	if (process.platform === "win32") return;
-	const matchers = buildSessionMatchers(backend);
-	if (matchers.length === 0) return;
-	try {
-		const stdout = await psWithFallback([
-			"-axww",
-			"-o",
-			"pid=,ppid=,stat=,command="
-		], [
-			"-ax",
-			"-o",
-			"pid=,ppid=,stat=,command="
-		]);
-		const suspended = [];
-		for (const line of stdout.split("\n")) {
-			const trimmed = line.trim();
-			if (!trimmed) continue;
-			const match = /^(\d+)\s+(\d+)\s+(\S+)\s+(.*)$/.exec(trimmed);
-			if (!match) continue;
-			const pid = Number(match[1]);
-			const ppid = Number(match[2]);
-			const stat = match[3] ?? "";
-			const command = match[4] ?? "";
-			if (!Number.isFinite(pid)) continue;
-			if (ppid !== process.pid) continue;
-			if (!stat.includes("T")) continue;
-			if (!matchers.some((matcher) => matcher.test(command))) continue;
-			suspended.push(pid);
-		}
-		if (suspended.length > threshold) await runExec("kill", ["-9", ...suspended.map((pid) => String(pid))]);
-	} catch {}
-}
-function enqueueCliRun(key, task) {
-	const chained = (CLI_RUN_QUEUE.get(key) ?? Promise.resolve()).catch(() => void 0).then(task);
-	const tracked = chained.finally(() => {
-		if (CLI_RUN_QUEUE.get(key) === tracked) CLI_RUN_QUEUE.delete(key);
-	});
-	CLI_RUN_QUEUE.set(key, tracked);
-	return chained;
-}
-function buildSystemPrompt(params) {
-	const defaultModelRef = resolveDefaultModelForAgent({
-		cfg: params.config ?? {},
-		agentId: params.agentId
-	});
-	const defaultModelLabel = `${defaultModelRef.provider}/${defaultModelRef.model}`;
-	const { runtimeInfo, userTimezone, userTime, userTimeFormat } = buildSystemPromptParams({
-		config: params.config,
-		agentId: params.agentId,
-		workspaceDir: params.workspaceDir,
-		cwd: process.cwd(),
-		runtime: {
-			host: "anima",
-			os: `${os.type()} ${os.release()}`,
-			arch: os.arch(),
-			node: process.version,
-			model: params.modelDisplay,
-			defaultModel: defaultModelLabel,
-			shell: detectRuntimeShell()
-		}
-	});
-	const ttsHint = params.config ? buildTtsSystemPromptHint(params.config) : void 0;
-	return buildAgentSystemPrompt({
-		workspaceDir: params.workspaceDir,
-		defaultThinkLevel: params.defaultThinkLevel,
-		extraSystemPrompt: params.extraSystemPrompt,
-		ownerNumbers: params.ownerNumbers,
-		reasoningTagHint: false,
-		heartbeatPrompt: params.heartbeatPrompt,
-		docsPath: params.docsPath,
-		runtimeInfo,
-		toolNames: params.tools.map((tool) => tool.name),
-		modelAliasLines: buildModelAliasLines(params.config),
-		userTimezone,
-		userTime,
-		userTimeFormat,
-		contextFiles: params.contextFiles,
-		ttsHint,
-		memoryCitationsMode: params.config?.memory?.citations
-	});
-}
-function normalizeCliModel(modelId, backend) {
-	const trimmed = modelId.trim();
-	if (!trimmed) return trimmed;
-	const direct = backend.modelAliases?.[trimmed];
-	if (direct) return direct;
-	const lower = trimmed.toLowerCase();
-	const mapped = backend.modelAliases?.[lower];
-	if (mapped) return mapped;
-	return trimmed;
-}
-function toUsage(raw) {
-	const pick = (key) => typeof raw[key] === "number" && raw[key] > 0 ? raw[key] : void 0;
-	const input = pick("input_tokens") ?? pick("inputTokens");
-	const output = pick("output_tokens") ?? pick("outputTokens");
-	const cacheRead = pick("cache_read_input_tokens") ?? pick("cached_input_tokens") ?? pick("cacheRead");
-	const cacheWrite = pick("cache_write_input_tokens") ?? pick("cacheWrite");
-	const total = pick("total_tokens") ?? pick("total");
-	if (!input && !output && !cacheRead && !cacheWrite && !total) return;
-	return {
-		input,
-		output,
-		cacheRead,
-		cacheWrite,
-		total
-	};
-}
-function collectText(value) {
-	if (!value) return "";
-	if (typeof value === "string") return value;
-	if (Array.isArray(value)) return value.map((entry) => collectText(entry)).join("");
-	if (!isRecord(value)) return "";
-	if (typeof value.text === "string") return value.text;
-	if (typeof value.content === "string") return value.content;
-	if (Array.isArray(value.content)) return value.content.map((entry) => collectText(entry)).join("");
-	if (isRecord(value.message)) return collectText(value.message);
-	return "";
-}
-function pickSessionId(parsed, backend) {
-	const fields = backend.sessionIdFields ?? [
-		"session_id",
-		"sessionId",
-		"conversation_id",
-		"conversationId"
-	];
-	for (const field of fields) {
-		const value = parsed[field];
-		if (typeof value === "string" && value.trim()) return value.trim();
-	}
-}
-function parseCliJson(raw, backend) {
-	const trimmed = raw.trim();
-	if (!trimmed) return null;
-	let parsed;
-	try {
-		parsed = JSON.parse(trimmed);
-	} catch {
-		return null;
-	}
-	if (!isRecord(parsed)) return null;
-	const sessionId = pickSessionId(parsed, backend);
-	const usage = isRecord(parsed.usage) ? toUsage(parsed.usage) : void 0;
-	return {
-		text: (collectText(parsed.message) || collectText(parsed.content) || collectText(parsed.result) || collectText(parsed)).trim(),
-		sessionId,
-		usage
-	};
-}
-function parseCliJsonl(raw, backend) {
-	const lines = raw.split(/\r?\n/g).map((line) => line.trim()).filter(Boolean);
-	if (lines.length === 0) return null;
-	let sessionId;
-	let usage;
-	const texts = [];
-	for (const line of lines) {
-		let parsed;
-		try {
-			parsed = JSON.parse(line);
-		} catch {
-			continue;
-		}
-		if (!isRecord(parsed)) continue;
-		if (!sessionId) sessionId = pickSessionId(parsed, backend);
-		if (!sessionId && typeof parsed.thread_id === "string") sessionId = parsed.thread_id.trim();
-		if (isRecord(parsed.usage)) usage = toUsage(parsed.usage) ?? usage;
-		const item = isRecord(parsed.item) ? parsed.item : null;
-		if (item && typeof item.text === "string") {
-			const type = typeof item.type === "string" ? item.type.toLowerCase() : "";
-			if (!type || type.includes("message")) texts.push(item.text);
-		}
-	}
-	const text = texts.join("\n").trim();
-	if (!text) return null;
-	return {
-		text,
-		sessionId,
-		usage
-	};
-}
-function resolveSystemPromptUsage(params) {
-	const systemPrompt = params.systemPrompt?.trim();
-	if (!systemPrompt) return null;
-	const when = params.backend.systemPromptWhen ?? "first";
-	if (when === "never") return null;
-	if (when === "first" && !params.isNewSession) return null;
-	if (!params.backend.systemPromptArg?.trim()) return null;
-	return systemPrompt;
-}
-function resolveSessionIdToSend(params) {
-	const mode = params.backend.sessionMode ?? "always";
-	const existing = params.cliSessionId?.trim();
-	if (mode === "none") return {
-		sessionId: void 0,
-		isNew: !existing
-	};
-	if (mode === "existing") return {
-		sessionId: existing,
-		isNew: !existing
-	};
-	if (existing) return {
-		sessionId: existing,
-		isNew: false
-	};
-	return {
-		sessionId: crypto.randomUUID(),
-		isNew: true
-	};
-}
-function resolvePromptInput(params) {
-	if ((params.backend.input ?? "arg") === "stdin") return { stdin: params.prompt };
-	if (params.backend.maxPromptArgChars && params.prompt.length > params.backend.maxPromptArgChars) return { stdin: params.prompt };
-	return { argsPrompt: params.prompt };
-}
-function resolveImageExtension(mimeType) {
-	const normalized = mimeType.toLowerCase();
-	if (normalized.includes("png")) return "png";
-	if (normalized.includes("jpeg") || normalized.includes("jpg")) return "jpg";
-	if (normalized.includes("gif")) return "gif";
-	if (normalized.includes("webp")) return "webp";
-	return "bin";
-}
-function appendImagePathsToPrompt(prompt, paths) {
-	if (!paths.length) return prompt;
-	const trimmed = prompt.trimEnd();
-	return `${trimmed}${trimmed ? "\n\n" : ""}${paths.join("\n")}`;
-}
-async function writeCliImages(images) {
-	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "anima-cli-images-"));
-	const paths = [];
-	for (let i = 0; i < images.length; i += 1) {
-		const image = images[i];
-		const ext = resolveImageExtension(image.mimeType);
-		const filePath = path.join(tempDir, `image-${i + 1}.${ext}`);
-		const buffer = Buffer.from(image.data, "base64");
-		await fs.writeFile(filePath, buffer, { mode: 384 });
-		paths.push(filePath);
-	}
-	const cleanup = async () => {
-		await fs.rm(tempDir, {
-			recursive: true,
-			force: true
-		});
-	};
-	return {
-		paths,
-		cleanup
-	};
-}
-function buildCliArgs(params) {
-	const args = [...params.baseArgs];
-	if (!params.useResume && params.backend.modelArg && params.modelId) args.push(params.backend.modelArg, params.modelId);
-	if (!params.useResume && params.systemPrompt && params.backend.systemPromptArg) args.push(params.backend.systemPromptArg, params.systemPrompt);
-	if (!params.useResume && params.sessionId) {
-		if (params.backend.sessionArgs && params.backend.sessionArgs.length > 0) for (const entry of params.backend.sessionArgs) args.push(entry.replaceAll("{sessionId}", params.sessionId));
-		else if (params.backend.sessionArg) args.push(params.backend.sessionArg, params.sessionId);
-	}
-	if (params.imagePaths && params.imagePaths.length > 0) {
-		const mode = params.backend.imageMode ?? "repeat";
-		const imageArg = params.backend.imageArg;
-		if (imageArg) if (mode === "list") args.push(imageArg, params.imagePaths.join(","));
-		else for (const imagePath of params.imagePaths) args.push(imageArg, imagePath);
-	}
-	if (params.promptArg !== void 0) args.push(params.promptArg);
-	return args;
-}
-
-//#endregion
-//#region src/agents/docs-path.ts
-async function resolveAnimaDocsPath(params) {
-	const workspaceDir = params.workspaceDir?.trim();
-	if (workspaceDir) {
-		const workspaceDocs = path.join(workspaceDir, "docs");
-		if (fs$1.existsSync(workspaceDocs)) return workspaceDocs;
-	}
-	const packageRoot = await resolveAnimaPackageRoot({
-		cwd: params.cwd,
-		argv1: params.argv1,
-		moduleUrl: params.moduleUrl
-	});
-	if (!packageRoot) return null;
-	const packageDocs = path.join(packageRoot, "docs");
-	return fs$1.existsSync(packageDocs) ? packageDocs : null;
-}
-
-//#endregion
-//#region src/agents/failover-error.ts
-const TIMEOUT_HINT_RE = /timeout|timed out|deadline exceeded|context deadline exceeded/i;
-const ABORT_TIMEOUT_RE = /request was aborted|request aborted/i;
-var FailoverError = class extends Error {
-	constructor(message, params) {
-		super(message, { cause: params.cause });
-		this.name = "FailoverError";
-		this.reason = params.reason;
-		this.provider = params.provider;
-		this.model = params.model;
-		this.profileId = params.profileId;
-		this.status = params.status;
-		this.code = params.code;
-	}
-};
-function isFailoverError(err) {
-	return err instanceof FailoverError;
-}
-function resolveFailoverStatus(reason) {
-	switch (reason) {
-		case "billing": return 402;
-		case "rate_limit": return 429;
-		case "auth": return 401;
-		case "timeout": return 408;
-		case "format": return 400;
-		default: return;
-	}
-}
-function getStatusCode(err) {
-	if (!err || typeof err !== "object") return;
-	const candidate = err.status ?? err.statusCode;
-	if (typeof candidate === "number") return candidate;
-	if (typeof candidate === "string" && /^\d+$/.test(candidate)) return Number(candidate);
-}
-function getErrorName(err) {
-	if (!err || typeof err !== "object") return "";
-	return "name" in err ? String(err.name) : "";
-}
-function getErrorCode(err) {
-	if (!err || typeof err !== "object") return;
-	const candidate = err.code;
-	if (typeof candidate !== "string") return;
-	const trimmed = candidate.trim();
-	return trimmed ? trimmed : void 0;
-}
-function getErrorMessage(err) {
-	if (err instanceof Error) return err.message;
-	if (typeof err === "string") return err;
-	if (typeof err === "number" || typeof err === "boolean" || typeof err === "bigint") return String(err);
-	if (typeof err === "symbol") return err.description ?? "";
-	if (err && typeof err === "object") {
-		const message = err.message;
-		if (typeof message === "string") return message;
-	}
-	return "";
-}
-function hasTimeoutHint(err) {
-	if (!err) return false;
-	if (getErrorName(err) === "TimeoutError") return true;
-	const message = getErrorMessage(err);
-	return Boolean(message && TIMEOUT_HINT_RE.test(message));
-}
-function isTimeoutError(err) {
-	if (hasTimeoutHint(err)) return true;
-	if (!err || typeof err !== "object") return false;
-	if (getErrorName(err) !== "AbortError") return false;
-	const message = getErrorMessage(err);
-	if (message && ABORT_TIMEOUT_RE.test(message)) return true;
-	const cause = "cause" in err ? err.cause : void 0;
-	const reason = "reason" in err ? err.reason : void 0;
-	return hasTimeoutHint(cause) || hasTimeoutHint(reason);
-}
-function resolveFailoverReasonFromError(err) {
-	if (isFailoverError(err)) return err.reason;
-	const status = getStatusCode(err);
-	if (status === 402) return "billing";
-	if (status === 429) return "rate_limit";
-	if (status === 401 || status === 403) return "auth";
-	if (status === 408) return "timeout";
-	if (status === 400) return "format";
-	const code = (getErrorCode(err) ?? "").toUpperCase();
-	if ([
-		"ETIMEDOUT",
-		"ESOCKETTIMEDOUT",
-		"ECONNRESET",
-		"ECONNABORTED"
-	].includes(code)) return "timeout";
-	if (isTimeoutError(err)) return "timeout";
-	const message = getErrorMessage(err);
-	if (!message) return null;
-	return classifyFailoverReason$1(message);
-}
-function describeFailoverError(err) {
-	if (isFailoverError(err)) return {
-		message: err.message,
-		reason: err.reason,
-		status: err.status,
-		code: err.code
-	};
-	return {
-		message: getErrorMessage(err) || String(err),
-		reason: resolveFailoverReasonFromError(err) ?? void 0,
-		status: getStatusCode(err),
-		code: getErrorCode(err)
-	};
-}
-function coerceToFailoverError(err, context) {
-	if (isFailoverError(err)) return err;
-	const reason = resolveFailoverReasonFromError(err);
-	if (!reason) return null;
-	const message = getErrorMessage(err) || String(err);
-	const status = getStatusCode(err) ?? resolveFailoverStatus(reason);
-	const code = getErrorCode(err);
-	return new FailoverError(message, {
-		reason,
-		provider: context?.provider,
-		model: context?.model,
-		profileId: context?.profileId,
-		status,
-		code,
-		cause: err instanceof Error ? err : void 0
-	});
-}
-
-//#endregion
-//#region src/logging/redact-identifier.ts
-function sha256HexPrefix(value, len = 12) {
-	const safeLen = Number.isFinite(len) ? Math.max(1, Math.floor(len)) : 12;
-	return crypto.createHash("sha256").update(value).digest("hex").slice(0, safeLen);
-}
-function redactIdentifier(value, opts) {
-	const trimmed = value?.trim();
-	if (!trimmed) return "-";
-	return `sha256:${sha256HexPrefix(trimmed, opts?.len ?? 12)}`;
-}
-
-//#endregion
-//#region src/agents/workspace-run.ts
-function resolveRunAgentId(params) {
-	const rawSessionKey = params.sessionKey?.trim() ?? "";
-	const shape = classifySessionKeyShape(rawSessionKey);
-	if (shape === "malformed_agent") throw new Error("Malformed agent session key; refusing workspace resolution.");
-	const explicit = typeof params.agentId === "string" && params.agentId.trim() ? normalizeAgentId(params.agentId) : void 0;
-	if (explicit) return {
-		agentId: explicit,
-		agentIdSource: "explicit"
-	};
-	const defaultAgentId = resolveDefaultAgentId(params.config ?? {});
-	if (shape === "missing" || shape === "legacy_or_alias") return {
-		agentId: defaultAgentId || DEFAULT_AGENT_ID,
-		agentIdSource: "default"
-	};
-	const parsed = parseAgentSessionKey(rawSessionKey);
-	if (parsed?.agentId) return {
-		agentId: normalizeAgentId(parsed.agentId),
-		agentIdSource: "session_key"
-	};
-	return {
-		agentId: defaultAgentId || DEFAULT_AGENT_ID,
-		agentIdSource: "default"
-	};
-}
-function redactRunIdentifier(value) {
-	return redactIdentifier(value, { len: 12 });
-}
-function resolveRunWorkspaceDir(params) {
-	const requested = params.workspaceDir;
-	const { agentId, agentIdSource } = resolveRunAgentId({
-		sessionKey: params.sessionKey,
-		agentId: params.agentId,
-		config: params.config
-	});
-	if (typeof requested === "string") {
-		const trimmed = requested.trim();
-		if (trimmed) return {
-			workspaceDir: resolveUserPath(trimmed),
-			usedFallback: false,
-			agentId,
-			agentIdSource
-		};
-	}
-	const fallbackReason = requested == null ? "missing" : typeof requested === "string" ? "blank" : "invalid_type";
-	return {
-		workspaceDir: resolveUserPath(resolveAgentWorkspaceDir(params.config ?? {}, agentId)),
-		usedFallback: true,
-		fallbackReason,
-		agentId,
-		agentIdSource
-	};
-}
-
-//#endregion
-//#region src/agents/cli-runner.ts
-const log$3 = createSubsystemLogger("agent/claude-cli");
-async function runCliAgent(params) {
-	const started = Date.now();
-	const workspaceResolution = resolveRunWorkspaceDir({
-		workspaceDir: params.workspaceDir,
-		sessionKey: params.sessionKey,
-		agentId: params.agentId,
-		config: params.config
-	});
-	const resolvedWorkspace = workspaceResolution.workspaceDir;
-	const redactedSessionId = redactRunIdentifier(params.sessionId);
-	const redactedSessionKey = redactRunIdentifier(params.sessionKey);
-	const redactedWorkspace = redactRunIdentifier(resolvedWorkspace);
-	if (workspaceResolution.usedFallback) log$3.warn(`[workspace-fallback] caller=runCliAgent reason=${workspaceResolution.fallbackReason} run=${params.runId} session=${redactedSessionId} sessionKey=${redactedSessionKey} agent=${workspaceResolution.agentId} workspace=${redactedWorkspace}`);
-	const workspaceDir = resolvedWorkspace;
-	const backendResolved = resolveCliBackendConfig(params.provider, params.config);
-	if (!backendResolved) throw new Error(`Unknown CLI backend: ${params.provider}`);
-	const backend = backendResolved.config;
-	const modelId = (params.model ?? "default").trim() || "default";
-	const normalizedModel = normalizeCliModel(modelId, backend);
-	const modelDisplay = `${params.provider}/${modelId}`;
-	const extraSystemPrompt = [params.extraSystemPrompt?.trim(), "Tools are disabled in this session. Do not call tools."].filter(Boolean).join("\n");
-	const sessionLabel = params.sessionKey ?? params.sessionId;
-	const { contextFiles } = await resolveBootstrapContextForRun({
-		workspaceDir,
-		config: params.config,
-		sessionKey: params.sessionKey,
-		sessionId: params.sessionId,
-		warn: makeBootstrapWarn({
-			sessionLabel,
-			warn: (message) => log$3.warn(message)
-		})
-	});
-	const { defaultAgentId, sessionAgentId } = resolveSessionAgentIds({
-		sessionKey: params.sessionKey,
-		config: params.config
-	});
-	const heartbeatPrompt = sessionAgentId === defaultAgentId ? resolveHeartbeatPrompt(params.config?.agents?.defaults?.heartbeat?.prompt) : void 0;
-	const docsPath = await resolveAnimaDocsPath({
-		workspaceDir,
-		argv1: process.argv[1],
-		cwd: process.cwd(),
-		moduleUrl: import.meta.url
-	});
-	const systemPrompt = buildSystemPrompt({
-		workspaceDir,
-		config: params.config,
-		defaultThinkLevel: params.thinkLevel,
-		extraSystemPrompt,
-		ownerNumbers: params.ownerNumbers,
-		heartbeatPrompt,
-		docsPath: docsPath ?? void 0,
-		tools: [],
-		contextFiles,
-		modelDisplay,
-		agentId: sessionAgentId
-	});
-	const { sessionId: cliSessionIdToSend, isNew } = resolveSessionIdToSend({
-		backend,
-		cliSessionId: params.cliSessionId
-	});
-	const useResume = Boolean(params.cliSessionId && cliSessionIdToSend && backend.resumeArgs && backend.resumeArgs.length > 0);
-	const sessionIdSent = cliSessionIdToSend ? useResume || Boolean(backend.sessionArg) || Boolean(backend.sessionArgs?.length) ? cliSessionIdToSend : void 0 : void 0;
-	const systemPromptArg = resolveSystemPromptUsage({
-		backend,
-		isNewSession: isNew,
-		systemPrompt
-	});
-	let imagePaths;
-	let cleanupImages;
-	let prompt = params.prompt;
-	if (params.images && params.images.length > 0) {
-		const imagePayload = await writeCliImages(params.images);
-		imagePaths = imagePayload.paths;
-		cleanupImages = imagePayload.cleanup;
-		if (!backend.imageArg) prompt = appendImagePathsToPrompt(prompt, imagePaths);
-	}
-	const { argsPrompt, stdin } = resolvePromptInput({
-		backend,
-		prompt
-	});
-	const stdinPayload = stdin ?? "";
-	const baseArgs = useResume ? backend.resumeArgs ?? backend.args ?? [] : backend.args ?? [];
-	const args = buildCliArgs({
-		backend,
-		baseArgs: useResume ? baseArgs.map((entry) => entry.replaceAll("{sessionId}", cliSessionIdToSend ?? "")) : baseArgs,
-		modelId: normalizedModel,
-		sessionId: cliSessionIdToSend,
-		systemPrompt: systemPromptArg,
-		imagePaths,
-		promptArg: argsPrompt,
-		useResume
-	});
-	const queueKey = backend.serialize ?? true ? backendResolved.id : `${backendResolved.id}:${params.runId}`;
-	try {
-		const output = await enqueueCliRun(queueKey, async () => {
-			log$3.info(`cli exec: provider=${params.provider} model=${normalizedModel} promptChars=${params.prompt.length}`);
-			const logOutputText = isTruthyEnvValue(process.env.ANIMA_CLAUDE_CLI_LOG_OUTPUT);
-			if (logOutputText) {
-				const logArgs = [];
-				for (let i = 0; i < args.length; i += 1) {
-					const arg = args[i] ?? "";
-					if (arg === backend.systemPromptArg) {
-						const systemPromptValue = args[i + 1] ?? "";
-						logArgs.push(arg, `<systemPrompt:${systemPromptValue.length} chars>`);
-						i += 1;
-						continue;
-					}
-					if (arg === backend.sessionArg) {
-						logArgs.push(arg, args[i + 1] ?? "");
-						i += 1;
-						continue;
-					}
-					if (arg === backend.modelArg) {
-						logArgs.push(arg, args[i + 1] ?? "");
-						i += 1;
-						continue;
-					}
-					if (arg === backend.imageArg) {
-						logArgs.push(arg, "<image>");
-						i += 1;
-						continue;
-					}
-					logArgs.push(arg);
-				}
-				if (argsPrompt) {
-					const promptIndex = logArgs.indexOf(argsPrompt);
-					if (promptIndex >= 0) logArgs[promptIndex] = `<prompt:${argsPrompt.length} chars>`;
-				}
-				log$3.info(`cli argv: ${backend.command} ${logArgs.join(" ")}`);
-			}
-			const env = (() => {
-				const next = {
-					...process.env,
-					...backend.env
-				};
-				for (const key of backend.clearEnv ?? []) delete next[key];
-				return next;
-			})();
-			await cleanupSuspendedCliProcesses(backend);
-			if (useResume && cliSessionIdToSend) await cleanupResumeProcesses(backend, cliSessionIdToSend);
-			const result = await runCommandWithTimeout([backend.command, ...args], {
-				timeoutMs: params.timeoutMs,
-				cwd: workspaceDir,
-				env,
-				input: stdinPayload
-			});
-			const stdout = result.stdout.trim();
-			const stderr = result.stderr.trim();
-			if (logOutputText) {
-				if (stdout) log$3.info(`cli stdout:\n${stdout}`);
-				if (stderr) log$3.info(`cli stderr:\n${stderr}`);
-			}
-			if (shouldLogVerbose()) {
-				if (stdout) log$3.debug(`cli stdout:\n${stdout}`);
-				if (stderr) log$3.debug(`cli stderr:\n${stderr}`);
-			}
-			if (result.code !== 0) {
-				const err = stderr || stdout || "CLI failed.";
-				const reason = classifyFailoverReason(err) ?? "unknown";
-				const status = resolveFailoverStatus(reason);
-				throw new FailoverError(err, {
-					reason,
-					provider: params.provider,
-					model: modelId,
-					status
-				});
-			}
-			const outputMode = useResume ? backend.resumeOutput ?? backend.output : backend.output;
-			if (outputMode === "text") return {
-				text: stdout,
-				sessionId: void 0
-			};
-			if (outputMode === "jsonl") return parseCliJsonl(stdout, backend) ?? { text: stdout };
-			return parseCliJson(stdout, backend) ?? { text: stdout };
-		});
-		const text = output.text?.trim();
-		return {
-			payloads: text ? [{ text }] : void 0,
-			meta: {
-				durationMs: Date.now() - started,
-				agentMeta: {
-					sessionId: output.sessionId ?? sessionIdSent ?? params.sessionId ?? "",
-					provider: params.provider,
-					model: modelId,
-					usage: output.usage
-				}
-			}
-		};
-	} catch (err) {
-		if (err instanceof FailoverError) throw err;
-		const message = err instanceof Error ? err.message : String(err);
-		if (isFailoverErrorMessage(message)) {
-			const reason = classifyFailoverReason(message) ?? "unknown";
-			const status = resolveFailoverStatus(reason);
-			throw new FailoverError(message, {
-				reason,
-				provider: params.provider,
-				model: modelId,
-				status
-			});
-		}
-		throw err;
-	} finally {
-		if (cleanupImages) await cleanupImages();
-	}
-}
-
-//#endregion
-//#region src/agents/cli-session.ts
-function getCliSessionId(entry, provider) {
-	if (!entry) return;
-	const normalized = normalizeProviderId$1(provider);
-	const fromMap = entry.cliSessionIds?.[normalized];
-	if (fromMap?.trim()) return fromMap.trim();
-	if (normalized === "claude-cli") {
-		const legacy = entry.claudeCliSessionId?.trim();
-		if (legacy) return legacy;
-	}
-}
-function setCliSessionId(entry, provider, sessionId) {
-	const normalized = normalizeProviderId$1(provider);
-	const trimmed = sessionId.trim();
-	if (!trimmed) return;
-	entry.cliSessionIds = { ...entry.cliSessionIds ?? {} };
-	entry.cliSessionIds[normalized] = trimmed;
-	if (normalized === "claude-cli") entry.claudeCliSessionId = trimmed;
-}
-
-//#endregion
-//#region src/agents/models-config.ts
-/**
-* Models configuration — SIMPLIFIED
-*
-* The multi-provider LLM abstraction (pi-ai) has been removed.
-* ANIMA uses Claude Code CLI exclusively. This file retains only
-* the minimal interface needed by the rest of the codebase.
-* Full replacement comes in Phase 2.
-*/
-async function ensureAnimaModelsJson(config, agentDirOverride) {
-	config ?? loadConfig();
-	const agentDir = agentDirOverride?.trim() ? agentDirOverride.trim() : resolveAnimaAgentDir();
-	await fs.mkdir(agentDir, {
-		recursive: true,
-		mode: 448
-	});
-	const targetPath = path.join(agentDir, "models.json");
-	const content = JSON.stringify({ providers: {} }, null, 2) + "\n";
-	let existing = "";
-	try {
-		existing = await fs.readFile(targetPath, "utf8");
-	} catch {}
-	if (existing === content) return {
-		agentDir,
-		wrote: false
-	};
-	await fs.writeFile(targetPath, content, { mode: 384 });
-	return {
-		agentDir,
-		wrote: true
-	};
-}
-
-//#endregion
-//#region src/agents/model-catalog.ts
-let modelCatalogPromise = null;
-let hasLoggedModelCatalogError = false;
-const defaultImportPiSdk = () => import("./pi-model-discovery-Cxs4pvC2.js");
-let importPiSdk = defaultImportPiSdk;
-const CODEX_PROVIDER = "openai-codex";
-const OPENAI_CODEX_GPT53_MODEL_ID = "gpt-5.3-codex";
-const OPENAI_CODEX_GPT53_SPARK_MODEL_ID = "gpt-5.3-codex-spark";
-function applyOpenAICodexSparkFallback(models) {
-	if (models.some((entry) => entry.provider === CODEX_PROVIDER && entry.id.toLowerCase() === OPENAI_CODEX_GPT53_SPARK_MODEL_ID)) return;
-	const baseModel = models.find((entry) => entry.provider === CODEX_PROVIDER && entry.id.toLowerCase() === OPENAI_CODEX_GPT53_MODEL_ID);
-	if (!baseModel) return;
-	models.push({
-		...baseModel,
-		id: OPENAI_CODEX_GPT53_SPARK_MODEL_ID,
-		name: OPENAI_CODEX_GPT53_SPARK_MODEL_ID
-	});
-}
-async function loadModelCatalog(params) {
-	if (params?.useCache === false) modelCatalogPromise = null;
-	if (modelCatalogPromise) return modelCatalogPromise;
-	modelCatalogPromise = (async () => {
-		const models = [];
-		const sortModels = (entries) => entries.sort((a, b) => {
-			const p = a.provider.localeCompare(b.provider);
-			if (p !== 0) return p;
-			return a.name.localeCompare(b.name);
-		});
-		try {
-			await ensureAnimaModelsJson(params?.config ?? loadConfig());
-			await (await import("./pi-auth-json-ZYzi3nxs.js")).ensurePiAuthJsonFromAuthProfiles(resolveAnimaAgentDir());
-			const piSdk = await importPiSdk();
-			const agentDir = resolveAnimaAgentDir();
-			const { join } = await import("node:path");
-			const authStorage = new piSdk.AuthStorage(join(agentDir, "auth.json"));
-			const registry = new piSdk.ModelRegistry(authStorage, join(agentDir, "models.json"));
-			const entries = Array.isArray(registry) ? registry : registry.getAll();
-			for (const entry of entries) {
-				const id = String(entry?.id ?? "").trim();
-				if (!id) continue;
-				const provider = String(entry?.provider ?? "").trim();
-				if (!provider) continue;
-				const name = String(entry?.name ?? id).trim() || id;
-				const contextWindow = typeof entry?.contextWindow === "number" && entry.contextWindow > 0 ? entry.contextWindow : void 0;
-				const reasoning = typeof entry?.reasoning === "boolean" ? entry.reasoning : void 0;
-				const input = Array.isArray(entry?.input) ? entry.input : void 0;
-				models.push({
-					id,
-					name,
-					provider,
-					contextWindow,
-					reasoning,
-					input
-				});
-			}
-			applyOpenAICodexSparkFallback(models);
-			if (models.length === 0) modelCatalogPromise = null;
-			return sortModels(models);
-		} catch (error) {
-			if (!hasLoggedModelCatalogError) {
-				hasLoggedModelCatalogError = true;
-				console.warn(`[model-catalog] Failed to load model catalog: ${String(error)}`);
-			}
-			modelCatalogPromise = null;
-			if (models.length > 0) return sortModels(models);
-			return [];
-		}
-	})();
-	return modelCatalogPromise;
-}
-/**
-* Check if a model supports image input based on its catalog entry.
-*/
-function modelSupportsVision(entry) {
-	return entry?.input?.includes("image") ?? false;
-}
-/**
-* Find a model in the catalog by provider and model ID.
-*/
-function findModelInCatalog(catalog, provider, modelId) {
-	const normalizedProvider = provider.toLowerCase().trim();
-	const normalizedModelId = modelId.toLowerCase().trim();
-	return catalog.find((entry) => entry.provider.toLowerCase() === normalizedProvider && entry.id.toLowerCase() === normalizedModelId);
-}
-
-//#endregion
-//#region src/agents/model-fallback.ts
-/**
-* Fallback abort check. Only treats explicit AbortError names as user aborts.
-* Message-based checks (e.g., "aborted") can mask timeouts and skip fallback.
-*/
-function isFallbackAbortError(err) {
-	if (!err || typeof err !== "object") return false;
-	if (isFailoverError(err)) return false;
-	return ("name" in err ? String(err.name) : "") === "AbortError";
-}
-function shouldRethrowAbort(err) {
-	return isFallbackAbortError(err) && !isTimeoutError(err);
-}
-function createModelCandidateCollector(allowlist) {
-	const seen = /* @__PURE__ */ new Set();
-	const candidates = [];
-	const addCandidate = (candidate, enforceAllowlist) => {
-		if (!candidate.provider || !candidate.model) return;
-		const key = modelKey(candidate.provider, candidate.model);
-		if (seen.has(key)) return;
-		if (enforceAllowlist && allowlist && !allowlist.has(key)) return;
-		seen.add(key);
-		candidates.push(candidate);
-	};
-	return {
-		candidates,
-		addCandidate
-	};
-}
-function resolveImageFallbackCandidates(params) {
-	const aliasIndex = buildModelAliasIndex({
-		cfg: params.cfg ?? {},
-		defaultProvider: params.defaultProvider
-	});
-	const { candidates, addCandidate } = createModelCandidateCollector(buildConfiguredAllowlistKeys({
-		cfg: params.cfg,
-		defaultProvider: params.defaultProvider
-	}));
-	const addRaw = (raw, enforceAllowlist) => {
-		const resolved = resolveModelRefFromString({
-			raw: String(raw ?? ""),
-			defaultProvider: params.defaultProvider,
-			aliasIndex
-		});
-		if (!resolved) return;
-		addCandidate(resolved.ref, enforceAllowlist);
-	};
-	if (params.modelOverride?.trim()) addRaw(params.modelOverride, false);
-	else {
-		const imageModel = params.cfg?.agents?.defaults?.imageModel;
-		const primary = typeof imageModel === "string" ? imageModel.trim() : imageModel?.primary;
-		if (primary?.trim()) addRaw(primary, false);
-	}
-	const imageFallbacks = (() => {
-		const imageModel = params.cfg?.agents?.defaults?.imageModel;
-		if (imageModel && typeof imageModel === "object") return imageModel.fallbacks ?? [];
-		return [];
-	})();
-	for (const raw of imageFallbacks) addRaw(raw, true);
-	return candidates;
-}
-function resolveFallbackCandidates(params) {
-	const primary = params.cfg ? resolveConfiguredModelRef({
-		cfg: params.cfg,
-		defaultProvider: DEFAULT_PROVIDER,
-		defaultModel: DEFAULT_MODEL
-	}) : null;
-	const defaultProvider = primary?.provider ?? DEFAULT_PROVIDER;
-	const defaultModel = primary?.model ?? DEFAULT_MODEL;
-	const normalizedPrimary = normalizeModelRef(String(params.provider ?? "").trim() || defaultProvider, String(params.model ?? "").trim() || defaultModel);
-	const aliasIndex = buildModelAliasIndex({
-		cfg: params.cfg ?? {},
-		defaultProvider
-	});
-	const { candidates, addCandidate } = createModelCandidateCollector(buildConfiguredAllowlistKeys({
-		cfg: params.cfg,
-		defaultProvider
-	}));
-	addCandidate(normalizedPrimary, false);
-	const modelFallbacks = (() => {
-		if (params.fallbacksOverride !== void 0) return params.fallbacksOverride;
-		const model = params.cfg?.agents?.defaults?.model;
-		if (model && typeof model === "object") return model.fallbacks ?? [];
-		return [];
-	})();
-	for (const raw of modelFallbacks) {
-		const resolved = resolveModelRefFromString({
-			raw: String(raw ?? ""),
-			defaultProvider,
-			aliasIndex
-		});
-		if (!resolved) continue;
-		addCandidate(resolved.ref, true);
-	}
-	if (params.fallbacksOverride === void 0 && primary?.provider && primary.model) addCandidate({
-		provider: primary.provider,
-		model: primary.model
-	}, false);
-	return candidates;
-}
-async function runWithModelFallback(params) {
-	const candidates = resolveFallbackCandidates({
-		cfg: params.cfg,
-		provider: params.provider,
-		model: params.model,
-		fallbacksOverride: params.fallbacksOverride
-	});
-	const authStore = params.cfg ? ensureAuthProfileStore(params.agentDir, { allowKeychainPrompt: false }) : null;
-	const attempts = [];
-	let lastError;
-	for (let i = 0; i < candidates.length; i += 1) {
-		const candidate = candidates[i];
-		if (authStore) {
-			const profileIds = resolveAuthProfileOrder({
-				cfg: params.cfg,
-				store: authStore,
-				provider: candidate.provider
-			});
-			const isAnyProfileAvailable = profileIds.some((id) => !isProfileInCooldown(authStore, id));
-			if (profileIds.length > 0 && !isAnyProfileAvailable) {
-				attempts.push({
-					provider: candidate.provider,
-					model: candidate.model,
-					error: `Provider ${candidate.provider} is in cooldown (all profiles unavailable)`,
-					reason: "rate_limit"
-				});
-				continue;
-			}
-		}
-		try {
-			return {
-				result: await params.run(candidate.provider, candidate.model),
-				provider: candidate.provider,
-				model: candidate.model,
-				attempts
-			};
-		} catch (err) {
-			if (shouldRethrowAbort(err)) throw err;
-			if (isLikelyContextOverflowError(err instanceof Error ? err.message : String(err))) throw err;
-			const normalized = coerceToFailoverError(err, {
-				provider: candidate.provider,
-				model: candidate.model
-			}) ?? err;
-			if (!isFailoverError(normalized)) throw err;
-			lastError = normalized;
-			const described = describeFailoverError(normalized);
-			attempts.push({
-				provider: candidate.provider,
-				model: candidate.model,
-				error: described.message,
-				reason: described.reason,
-				status: described.status,
-				code: described.code
-			});
-			await params.onError?.({
-				provider: candidate.provider,
-				model: candidate.model,
-				error: normalized,
-				attempt: i + 1,
-				total: candidates.length
-			});
-		}
-	}
-	if (attempts.length <= 1 && lastError) throw lastError;
-	const summary = attempts.length > 0 ? attempts.map((attempt) => `${attempt.provider}/${attempt.model}: ${attempt.error}${attempt.reason ? ` (${attempt.reason})` : ""}`).join(" | ") : "unknown";
-	throw new Error(`All models failed (${attempts.length || candidates.length}): ${summary}`, { cause: lastError instanceof Error ? lastError : void 0 });
-}
-async function runWithImageModelFallback(params) {
-	const candidates = resolveImageFallbackCandidates({
-		cfg: params.cfg,
-		defaultProvider: DEFAULT_PROVIDER,
-		modelOverride: params.modelOverride
-	});
-	if (candidates.length === 0) throw new Error("No image model configured. Set agents.defaults.imageModel.primary or agents.defaults.imageModel.fallbacks.");
-	const attempts = [];
-	let lastError;
-	for (let i = 0; i < candidates.length; i += 1) {
-		const candidate = candidates[i];
-		try {
-			return {
-				result: await params.run(candidate.provider, candidate.model),
-				provider: candidate.provider,
-				model: candidate.model,
-				attempts
-			};
-		} catch (err) {
-			if (shouldRethrowAbort(err)) throw err;
-			lastError = err;
-			attempts.push({
-				provider: candidate.provider,
-				model: candidate.model,
-				error: err instanceof Error ? err.message : String(err)
-			});
-			await params.onError?.({
-				provider: candidate.provider,
-				model: candidate.model,
-				error: err,
-				attempt: i + 1,
-				total: candidates.length
-			});
-		}
-	}
-	if (attempts.length <= 1 && lastError) throw lastError;
-	const summary = attempts.length > 0 ? attempts.map((attempt) => `${attempt.provider}/${attempt.model}: ${attempt.error}`).join(" | ") : "unknown";
-	throw new Error(`All image models failed (${attempts.length || candidates.length}): ${summary}`, { cause: lastError instanceof Error ? lastError : void 0 });
-}
-
-//#endregion
-//#region src/agents/skills/frontmatter.ts
-function parseFrontmatter(content) {
-	return parseFrontmatterBlock(content);
-}
-function parseInstallSpec(input) {
-	if (!input || typeof input !== "object") return;
-	const raw = input;
-	const kind = (typeof raw.kind === "string" ? raw.kind : typeof raw.type === "string" ? raw.type : "").trim().toLowerCase();
-	if (kind !== "brew" && kind !== "node" && kind !== "go" && kind !== "uv" && kind !== "download") return;
-	const spec = { kind };
-	if (typeof raw.id === "string") spec.id = raw.id;
-	if (typeof raw.label === "string") spec.label = raw.label;
-	const bins = normalizeStringList(raw.bins);
-	if (bins.length > 0) spec.bins = bins;
-	const osList = normalizeStringList(raw.os);
-	if (osList.length > 0) spec.os = osList;
-	if (typeof raw.formula === "string") spec.formula = raw.formula;
-	if (typeof raw.package === "string") spec.package = raw.package;
-	if (typeof raw.module === "string") spec.module = raw.module;
-	if (typeof raw.url === "string") spec.url = raw.url;
-	if (typeof raw.archive === "string") spec.archive = raw.archive;
-	if (typeof raw.extract === "boolean") spec.extract = raw.extract;
-	if (typeof raw.stripComponents === "number") spec.stripComponents = raw.stripComponents;
-	if (typeof raw.targetDir === "string") spec.targetDir = raw.targetDir;
-	return spec;
-}
-function resolveAnimaMetadata(frontmatter) {
-	const metadataObj = resolveAnimaManifestBlock({ frontmatter });
-	if (!metadataObj) return;
-	const requiresRaw = typeof metadataObj.requires === "object" && metadataObj.requires !== null ? metadataObj.requires : void 0;
-	const install = (Array.isArray(metadataObj.install) ? metadataObj.install : []).map((entry) => parseInstallSpec(entry)).filter((entry) => Boolean(entry));
-	const osRaw = normalizeStringList(metadataObj.os);
-	return {
-		always: typeof metadataObj.always === "boolean" ? metadataObj.always : void 0,
-		emoji: typeof metadataObj.emoji === "string" ? metadataObj.emoji : void 0,
-		homepage: typeof metadataObj.homepage === "string" ? metadataObj.homepage : void 0,
-		skillKey: typeof metadataObj.skillKey === "string" ? metadataObj.skillKey : void 0,
-		primaryEnv: typeof metadataObj.primaryEnv === "string" ? metadataObj.primaryEnv : void 0,
-		os: osRaw.length > 0 ? osRaw : void 0,
-		requires: requiresRaw ? {
-			bins: normalizeStringList(requiresRaw.bins),
-			anyBins: normalizeStringList(requiresRaw.anyBins),
-			env: normalizeStringList(requiresRaw.env),
-			config: normalizeStringList(requiresRaw.config)
-		} : void 0,
-		install: install.length > 0 ? install : void 0
-	};
-}
-function resolveSkillInvocationPolicy(frontmatter) {
-	return {
-		userInvocable: parseFrontmatterBool(getFrontmatterString(frontmatter, "user-invocable"), true),
-		disableModelInvocation: parseFrontmatterBool(getFrontmatterString(frontmatter, "disable-model-invocation"), false)
-	};
-}
-function resolveSkillKey(skill, entry) {
-	return entry?.metadata?.skillKey ?? skill.name;
-}
-
-//#endregion
-//#region src/agents/skills/config.ts
-const DEFAULT_CONFIG_VALUES = {
-	"browser.enabled": true,
-	"browser.evaluateEnabled": true
-};
-function isConfigPathTruthy(config, pathStr) {
-	return isConfigPathTruthyWithDefaults(config, pathStr, DEFAULT_CONFIG_VALUES);
-}
-function resolveSkillConfig(config, skillKey) {
-	const skills = config?.skills?.entries;
-	if (!skills || typeof skills !== "object") return;
-	const entry = skills[skillKey];
-	if (!entry || typeof entry !== "object") return;
-	return entry;
-}
-function normalizeAllowlist(input) {
-	if (!input) return;
-	if (!Array.isArray(input)) return;
-	const normalized = input.map((entry) => String(entry).trim()).filter(Boolean);
-	return normalized.length > 0 ? normalized : void 0;
-}
-const BUNDLED_SOURCES = new Set(["anima-bundled"]);
-function isBundledSkill(entry) {
-	return BUNDLED_SOURCES.has(entry.skill.source);
-}
-function isBundledSkillAllowed(entry, allowlist) {
-	if (!allowlist || allowlist.length === 0) return true;
-	if (!isBundledSkill(entry)) return true;
-	const key = resolveSkillKey(entry.skill, entry);
-	return allowlist.includes(key) || allowlist.includes(entry.skill.name);
-}
-function shouldIncludeSkill(params) {
-	const { entry, config, eligibility } = params;
-	const skillConfig = resolveSkillConfig(config, resolveSkillKey(entry.skill, entry));
-	const allowBundled = normalizeAllowlist(config?.skills?.allowBundled);
-	const osList = entry.metadata?.os ?? [];
-	const remotePlatforms = eligibility?.remote?.platforms ?? [];
-	if (skillConfig?.enabled === false) return false;
-	if (!isBundledSkillAllowed(entry, allowBundled)) return false;
-	if (osList.length > 0 && !osList.includes(resolveRuntimePlatform()) && !remotePlatforms.some((platform) => osList.includes(platform))) return false;
-	if (entry.metadata?.always === true) return true;
-	const requiredBins = entry.metadata?.requires?.bins ?? [];
-	if (requiredBins.length > 0) for (const bin of requiredBins) {
-		if (hasBinary(bin)) continue;
-		if (eligibility?.remote?.hasBin?.(bin)) continue;
-		return false;
-	}
-	const requiredAnyBins = entry.metadata?.requires?.anyBins ?? [];
-	if (requiredAnyBins.length > 0) {
-		if (!(requiredAnyBins.some((bin) => hasBinary(bin)) || eligibility?.remote?.hasAnyBin?.(requiredAnyBins))) return false;
-	}
-	const requiredEnv = entry.metadata?.requires?.env ?? [];
-	if (requiredEnv.length > 0) for (const envName of requiredEnv) {
-		if (process.env[envName]) continue;
-		if (skillConfig?.env?.[envName]) continue;
-		if (skillConfig?.apiKey && entry.metadata?.primaryEnv === envName) continue;
-		return false;
-	}
-	const requiredConfig = entry.metadata?.requires?.config ?? [];
-	if (requiredConfig.length > 0) {
-		for (const configPath of requiredConfig) if (!isConfigPathTruthy(config, configPath)) return false;
-	}
-	return true;
-}
-
-//#endregion
-//#region src/agents/sandbox-paths.ts
-const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
-const HTTP_URL_RE = /^https?:\/\//i;
-const DATA_URL_RE = /^data:/i;
-function normalizeUnicodeSpaces(str) {
-	return str.replace(UNICODE_SPACES, " ");
-}
-function expandPath(filePath) {
-	const normalized = normalizeUnicodeSpaces(filePath);
-	if (normalized === "~") return os.homedir();
-	if (normalized.startsWith("~/")) return os.homedir() + normalized.slice(1);
-	return normalized;
-}
-function resolveToCwd(filePath, cwd) {
-	const expanded = expandPath(filePath);
-	if (path.isAbsolute(expanded)) return expanded;
-	return path.resolve(cwd, expanded);
-}
-function resolveSandboxInputPath(filePath, cwd) {
-	return resolveToCwd(filePath, cwd);
-}
-function resolveSandboxPath(params) {
-	const resolved = resolveSandboxInputPath(params.filePath, params.cwd);
-	const rootResolved = path.resolve(params.root);
-	const relative = path.relative(rootResolved, resolved);
-	if (!relative || relative === "") return {
-		resolved,
-		relative: ""
-	};
-	if (relative.startsWith("..") || path.isAbsolute(relative)) throw new Error(`Path escapes sandbox root (${shortPath(rootResolved)}): ${params.filePath}`);
-	return {
-		resolved,
-		relative
-	};
-}
-async function assertSandboxPath(params) {
-	const resolved = resolveSandboxPath(params);
-	await assertNoSymlinkEscape(resolved.relative, path.resolve(params.root), { allowFinalSymlink: params.allowFinalSymlink });
-	return resolved;
-}
-function assertMediaNotDataUrl(media) {
-	const raw = media.trim();
-	if (DATA_URL_RE.test(raw)) throw new Error("data: URLs are not supported for media. Use buffer instead.");
-}
-async function resolveSandboxedMediaSource(params) {
-	const raw = params.media.trim();
-	if (!raw) return raw;
-	if (HTTP_URL_RE.test(raw)) return raw;
-	let candidate = raw;
-	if (/^file:\/\//i.test(candidate)) try {
-		candidate = fileURLToPath(candidate);
-	} catch {
-		throw new Error(`Invalid file:// URL for sandboxed media: ${raw}`);
-	}
-	return (await assertSandboxPath({
-		filePath: candidate,
-		cwd: params.sandboxRoot,
-		root: params.sandboxRoot
-	})).resolved;
-}
-async function assertNoSymlinkEscape(relative, root, options) {
-	if (!relative) return;
-	const rootReal = await tryRealpath(root);
-	const parts = relative.split(path.sep).filter(Boolean);
-	let current = root;
-	for (let idx = 0; idx < parts.length; idx += 1) {
-		const part = parts[idx];
-		const isLast = idx === parts.length - 1;
-		current = path.join(current, part);
-		try {
-			if ((await fs.lstat(current)).isSymbolicLink()) {
-				if (options?.allowFinalSymlink && isLast) return;
-				const target = await tryRealpath(current);
-				if (!isPathInside(rootReal, target)) throw new Error(`Symlink escapes sandbox root (${shortPath(rootReal)}): ${shortPath(current)}`);
-				current = target;
-			}
-		} catch (err) {
-			if (err.code === "ENOENT") return;
-			throw err;
-		}
-	}
-}
-async function tryRealpath(value) {
-	try {
-		return await fs.realpath(value);
-	} catch {
-		return path.resolve(value);
-	}
-}
-function isPathInside(root, target) {
-	const relative = path.relative(root, target);
-	if (!relative || relative === "") return true;
-	return !(relative.startsWith("..") || path.isAbsolute(relative));
-}
-function shortPath(value) {
-	if (value.startsWith(os.homedir())) return `~${value.slice(os.homedir().length)}`;
-	return value;
-}
-
-//#endregion
-//#region src/agents/skills/bundled-dir.ts
-function looksLikeSkillsDir(dir) {
-	try {
-		const entries = fs$1.readdirSync(dir, { withFileTypes: true });
-		for (const entry of entries) {
-			if (entry.name.startsWith(".")) continue;
-			const fullPath = path.join(dir, entry.name);
-			if (entry.isFile() && entry.name.endsWith(".md")) return true;
-			if (entry.isDirectory()) {
-				if (fs$1.existsSync(path.join(fullPath, "SKILL.md"))) return true;
-			}
-		}
-	} catch {
-		return false;
-	}
-	return false;
-}
-function resolveBundledSkillsDir(opts = {}) {
-	const override = process.env.ANIMA_BUNDLED_SKILLS_DIR?.trim();
-	if (override) return override;
-	try {
-		const execPath = opts.execPath ?? process.execPath;
-		const execDir = path.dirname(execPath);
-		const sibling = path.join(execDir, "skills");
-		if (fs$1.existsSync(sibling)) return sibling;
-	} catch {}
-	try {
-		const moduleUrl = opts.moduleUrl ?? import.meta.url;
-		const moduleDir = path.dirname(fileURLToPath(moduleUrl));
-		const packageRoot = resolveAnimaPackageRootSync({
-			argv1: opts.argv1 ?? process.argv[1],
-			moduleUrl,
-			cwd: opts.cwd ?? process.cwd()
-		});
-		if (packageRoot) {
-			const candidate = path.join(packageRoot, "skills");
-			if (looksLikeSkillsDir(candidate)) return candidate;
-		}
-		let current = moduleDir;
-		for (let depth = 0; depth < 6; depth += 1) {
-			const candidate = path.join(current, "skills");
-			if (looksLikeSkillsDir(candidate)) return candidate;
-			const next = path.dirname(current);
-			if (next === current) break;
-			current = next;
-		}
-	} catch {}
-}
-
-//#endregion
-//#region src/agents/skills/plugin-skills.ts
-const log$2 = createSubsystemLogger("skills");
-function resolvePluginSkillDirs(params) {
-	const workspaceDir = params.workspaceDir.trim();
-	if (!workspaceDir) return [];
-	const registry = loadPluginManifestRegistry({
-		workspaceDir,
-		config: params.config
-	});
-	if (registry.plugins.length === 0) return [];
-	const normalizedPlugins = normalizePluginsConfig(params.config?.plugins);
-	const memorySlot = normalizedPlugins.slots.memory;
-	let selectedMemoryPluginId = null;
-	const seen = /* @__PURE__ */ new Set();
-	const resolved = [];
-	for (const record of registry.plugins) {
-		if (!record.skills || record.skills.length === 0) continue;
-		if (!resolveEnableState(record.id, record.origin, normalizedPlugins).enabled) continue;
-		const memoryDecision = resolveMemorySlotDecision({
-			id: record.id,
-			kind: record.kind,
-			slot: memorySlot,
-			selectedId: selectedMemoryPluginId
-		});
-		if (!memoryDecision.enabled) continue;
-		if (memoryDecision.selected && record.kind === "memory") selectedMemoryPluginId = record.id;
-		for (const raw of record.skills) {
-			const trimmed = raw.trim();
-			if (!trimmed) continue;
-			const candidate = path.resolve(record.rootDir, trimmed);
-			if (!fs$1.existsSync(candidate)) {
-				log$2.warn(`plugin skill path not found (${record.id}): ${candidate}`);
-				continue;
-			}
-			if (seen.has(candidate)) continue;
-			seen.add(candidate);
-			resolved.push(candidate);
-		}
-	}
-	return resolved;
-}
-
-//#endregion
-//#region src/agents/skills/serialize.ts
-const SKILLS_SYNC_QUEUE = /* @__PURE__ */ new Map();
-async function serializeByKey(key, task) {
-	const next = (SKILLS_SYNC_QUEUE.get(key) ?? Promise.resolve()).then(task, task);
-	SKILLS_SYNC_QUEUE.set(key, next);
-	try {
-		return await next;
-	} finally {
-		if (SKILLS_SYNC_QUEUE.get(key) === next) SKILLS_SYNC_QUEUE.delete(key);
-	}
-}
-
-//#endregion
-//#region src/agents/skills/workspace.ts
-const fsp = fs$1.promises;
-const skillsLogger = createSubsystemLogger("skills");
-const skillCommandDebugOnce = /* @__PURE__ */ new Set();
-function debugSkillCommandOnce(messageKey, message, meta) {
-	if (skillCommandDebugOnce.has(messageKey)) return;
-	skillCommandDebugOnce.add(messageKey);
-	skillsLogger.debug(message, meta);
-}
-function filterSkillEntries(entries, config, skillFilter, eligibility) {
-	let filtered = entries.filter((entry) => shouldIncludeSkill({
-		entry,
-		config,
-		eligibility
-	}));
-	if (skillFilter !== void 0) {
-		const normalized = skillFilter.map((entry) => String(entry).trim()).filter(Boolean);
-		const label = normalized.length > 0 ? normalized.join(", ") : "(none)";
-		console.log(`[skills] Applying skill filter: ${label}`);
-		filtered = normalized.length > 0 ? filtered.filter((entry) => normalized.includes(entry.skill.name)) : [];
-		console.log(`[skills] After filter: ${filtered.map((entry) => entry.skill.name).join(", ")}`);
-	}
-	return filtered;
-}
-const SKILL_COMMAND_MAX_LENGTH = 32;
-const SKILL_COMMAND_FALLBACK = "skill";
-const SKILL_COMMAND_DESCRIPTION_MAX_LENGTH = 100;
-function sanitizeSkillCommandName(raw) {
-	return raw.toLowerCase().replace(/[^a-z0-9_]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "").slice(0, SKILL_COMMAND_MAX_LENGTH) || SKILL_COMMAND_FALLBACK;
-}
-function resolveUniqueSkillCommandName(base, used) {
-	const normalizedBase = base.toLowerCase();
-	if (!used.has(normalizedBase)) return base;
-	for (let index = 2; index < 1e3; index += 1) {
-		const suffix = `_${index}`;
-		const maxBaseLength = Math.max(1, SKILL_COMMAND_MAX_LENGTH - suffix.length);
-		const candidate = `${base.slice(0, maxBaseLength)}${suffix}`;
-		const candidateKey = candidate.toLowerCase();
-		if (!used.has(candidateKey)) return candidate;
-	}
-	return `${base.slice(0, Math.max(1, SKILL_COMMAND_MAX_LENGTH - 2))}_x`;
-}
-function loadSkillEntries(workspaceDir, opts) {
-	const loadSkills = (params) => {
-		const loaded = loadSkillsFromDir(params);
-		if (Array.isArray(loaded)) return loaded;
-		if (loaded && typeof loaded === "object" && "skills" in loaded && Array.isArray(loaded.skills)) return loaded.skills;
-		return [];
-	};
-	const managedSkillsDir = opts?.managedSkillsDir ?? path.join(CONFIG_DIR, "skills");
-	const workspaceSkillsDir = path.resolve(workspaceDir, "skills");
-	const bundledSkillsDir = opts?.bundledSkillsDir ?? resolveBundledSkillsDir();
-	const extraDirs = (opts?.config?.skills?.load?.extraDirs ?? []).map((d) => typeof d === "string" ? d.trim() : "").filter(Boolean);
-	const pluginSkillDirs = resolvePluginSkillDirs({
-		workspaceDir,
-		config: opts?.config
-	});
-	const mergedExtraDirs = [...extraDirs, ...pluginSkillDirs];
-	const bundledSkills = bundledSkillsDir ? loadSkills({
-		dir: bundledSkillsDir,
-		source: "anima-bundled"
-	}) : [];
-	const extraSkills = mergedExtraDirs.flatMap((dir) => {
-		return loadSkills({
-			dir: resolveUserPath(dir),
-			source: "anima-extra"
-		});
-	});
-	const managedSkills = loadSkills({
-		dir: managedSkillsDir,
-		source: "anima-managed"
-	});
-	const personalAgentsSkills = loadSkills({
-		dir: path.resolve(os.homedir(), ".agents", "skills"),
-		source: "agents-skills-personal"
-	});
-	const projectAgentsSkills = loadSkills({
-		dir: path.resolve(workspaceDir, ".agents", "skills"),
-		source: "agents-skills-project"
-	});
-	const workspaceSkills = loadSkills({
-		dir: workspaceSkillsDir,
-		source: "anima-workspace"
-	});
-	const merged = /* @__PURE__ */ new Map();
-	for (const skill of extraSkills) merged.set(skill.name, skill);
-	for (const skill of bundledSkills) merged.set(skill.name, skill);
-	for (const skill of managedSkills) merged.set(skill.name, skill);
-	for (const skill of personalAgentsSkills) merged.set(skill.name, skill);
-	for (const skill of projectAgentsSkills) merged.set(skill.name, skill);
-	for (const skill of workspaceSkills) merged.set(skill.name, skill);
-	return Array.from(merged.values()).map((skill) => {
-		let frontmatter = {};
-		try {
-			frontmatter = parseFrontmatter(fs$1.readFileSync(skill.filePath, "utf-8"));
-		} catch {}
-		return {
-			skill,
-			frontmatter,
-			metadata: resolveAnimaMetadata(frontmatter),
-			invocation: resolveSkillInvocationPolicy(frontmatter)
-		};
-	});
-}
-function buildWorkspaceSkillSnapshot(workspaceDir, opts) {
-	const eligible = filterSkillEntries(opts?.entries ?? loadSkillEntries(workspaceDir, opts), opts?.config, opts?.skillFilter, opts?.eligibility);
-	const resolvedSkills = eligible.filter((entry) => entry.invocation?.disableModelInvocation !== true).map((entry) => entry.skill);
-	return {
-		prompt: [opts?.eligibility?.remote?.note?.trim(), formatSkillsForPrompt(resolvedSkills)].filter(Boolean).join("\n"),
-		skills: eligible.map((entry) => ({
-			name: entry.skill.name,
-			primaryEnv: entry.metadata?.primaryEnv
-		})),
-		resolvedSkills,
-		version: opts?.snapshotVersion
-	};
-}
-function resolveUniqueSyncedSkillDirName(base, used) {
-	if (!used.has(base)) {
-		used.add(base);
-		return base;
-	}
-	for (let index = 2; index < 1e4; index += 1) {
-		const candidate = `${base}-${index}`;
-		if (!used.has(candidate)) {
-			used.add(candidate);
-			return candidate;
-		}
-	}
-	let fallbackIndex = 1e4;
-	let fallback = `${base}-${fallbackIndex}`;
-	while (used.has(fallback)) {
-		fallbackIndex += 1;
-		fallback = `${base}-${fallbackIndex}`;
-	}
-	used.add(fallback);
-	return fallback;
-}
-function resolveSyncedSkillDestinationPath(params) {
-	const sourceDirName = path.basename(params.entry.skill.baseDir).trim();
-	if (!sourceDirName || sourceDirName === "." || sourceDirName === "..") return null;
-	return resolveSandboxPath({
-		filePath: resolveUniqueSyncedSkillDirName(sourceDirName, params.usedDirNames),
-		cwd: params.targetSkillsDir,
-		root: params.targetSkillsDir
-	}).resolved;
-}
-async function syncSkillsToWorkspace(params) {
-	const sourceDir = resolveUserPath(params.sourceWorkspaceDir);
-	const targetDir = resolveUserPath(params.targetWorkspaceDir);
-	if (sourceDir === targetDir) return;
-	await serializeByKey(`syncSkills:${targetDir}`, async () => {
-		const targetSkillsDir = path.join(targetDir, "skills");
-		const entries = loadSkillEntries(sourceDir, {
-			config: params.config,
-			managedSkillsDir: params.managedSkillsDir,
-			bundledSkillsDir: params.bundledSkillsDir
-		});
-		await fsp.rm(targetSkillsDir, {
-			recursive: true,
-			force: true
-		});
-		await fsp.mkdir(targetSkillsDir, { recursive: true });
-		const usedDirNames = /* @__PURE__ */ new Set();
-		for (const entry of entries) {
-			let dest = null;
-			try {
-				dest = resolveSyncedSkillDestinationPath({
-					targetSkillsDir,
-					entry,
-					usedDirNames
-				});
-			} catch (error) {
-				const message = error instanceof Error ? error.message : JSON.stringify(error);
-				console.warn(`[skills] Failed to resolve safe destination for ${entry.skill.name}: ${message}`);
-				continue;
-			}
-			if (!dest) {
-				console.warn(`[skills] Failed to resolve safe destination for ${entry.skill.name}: invalid source directory name`);
-				continue;
-			}
-			try {
-				await fsp.cp(entry.skill.baseDir, dest, {
-					recursive: true,
-					force: true
-				});
-			} catch (error) {
-				const message = error instanceof Error ? error.message : JSON.stringify(error);
-				console.warn(`[skills] Failed to copy ${entry.skill.name} to sandbox: ${message}`);
-			}
-		}
-	});
-}
-function buildWorkspaceSkillCommandSpecs(workspaceDir, opts) {
-	const userInvocable = filterSkillEntries(opts?.entries ?? loadSkillEntries(workspaceDir, opts), opts?.config, opts?.skillFilter, opts?.eligibility).filter((entry) => entry.invocation?.userInvocable !== false);
-	const used = /* @__PURE__ */ new Set();
-	for (const reserved of opts?.reservedNames ?? []) used.add(reserved.toLowerCase());
-	const specs = [];
-	for (const entry of userInvocable) {
-		const rawName = entry.skill.name;
-		const base = sanitizeSkillCommandName(rawName);
-		if (base !== rawName) debugSkillCommandOnce(`sanitize:${rawName}:${base}`, `Sanitized skill command name "${rawName}" to "/${base}".`, {
-			rawName,
-			sanitized: `/${base}`
-		});
-		const unique = resolveUniqueSkillCommandName(base, used);
-		if (unique !== base) debugSkillCommandOnce(`dedupe:${rawName}:${unique}`, `De-duplicated skill command name for "${rawName}" to "/${unique}".`, {
-			rawName,
-			deduped: `/${unique}`
-		});
-		used.add(unique.toLowerCase());
-		const rawDescription = entry.skill.description?.trim() || rawName;
-		const description = rawDescription.length > SKILL_COMMAND_DESCRIPTION_MAX_LENGTH ? rawDescription.slice(0, SKILL_COMMAND_DESCRIPTION_MAX_LENGTH - 1) + "…" : rawDescription;
-		const dispatch = (() => {
-			const kindRaw = (entry.frontmatter?.["command-dispatch"] ?? entry.frontmatter?.["command_dispatch"] ?? "").trim().toLowerCase();
-			if (!kindRaw) return;
-			if (kindRaw !== "tool") return;
-			const toolName = (entry.frontmatter?.["command-tool"] ?? entry.frontmatter?.["command_tool"] ?? "").trim();
-			if (!toolName) {
-				debugSkillCommandOnce(`dispatch:missingTool:${rawName}`, `Skill command "/${unique}" requested tool dispatch but did not provide command-tool. Ignoring dispatch.`, {
-					skillName: rawName,
-					command: unique
-				});
-				return;
-			}
-			const argModeRaw = (entry.frontmatter?.["command-arg-mode"] ?? entry.frontmatter?.["command_arg_mode"] ?? "").trim().toLowerCase();
-			if (!(!argModeRaw || argModeRaw === "raw" ? "raw" : null)) debugSkillCommandOnce(`dispatch:badArgMode:${rawName}:${argModeRaw}`, `Skill command "/${unique}" requested tool dispatch but has unknown command-arg-mode. Falling back to raw.`, {
-				skillName: rawName,
-				command: unique,
-				argMode: argModeRaw
-			});
-			return {
-				kind: "tool",
-				toolName,
-				argMode: "raw"
-			};
-		})();
-		specs.push({
-			name: unique,
-			skillName: rawName,
-			description,
-			...dispatch ? { dispatch } : {}
-		});
-	}
-	return specs;
-}
-
-//#endregion
-//#region src/agents/skills/refresh.ts
-const log$1 = createSubsystemLogger("gateway/skills");
-const listeners = /* @__PURE__ */ new Set();
-const workspaceVersions = /* @__PURE__ */ new Map();
-const watchers = /* @__PURE__ */ new Map();
-let globalVersion = 0;
-const DEFAULT_SKILLS_WATCH_IGNORED = [
-	/(^|[\\/])\.git([\\/]|$)/,
-	/(^|[\\/])node_modules([\\/]|$)/,
-	/(^|[\\/])dist([\\/]|$)/,
-	/(^|[\\/])\.venv([\\/]|$)/,
-	/(^|[\\/])venv([\\/]|$)/,
-	/(^|[\\/])__pycache__([\\/]|$)/,
-	/(^|[\\/])\.mypy_cache([\\/]|$)/,
-	/(^|[\\/])\.pytest_cache([\\/]|$)/,
-	/(^|[\\/])build([\\/]|$)/,
-	/(^|[\\/])\.cache([\\/]|$)/
-];
-function bumpVersion(current) {
-	const now = Date.now();
-	return now <= current ? current + 1 : now;
-}
-function emit(event) {
-	for (const listener of listeners) try {
-		listener(event);
-	} catch (err) {
-		log$1.warn(`skills change listener failed: ${String(err)}`);
-	}
-}
-function resolveWatchPaths(workspaceDir, config) {
-	const paths = [];
-	if (workspaceDir.trim()) {
-		paths.push(path.join(workspaceDir, "skills"));
-		paths.push(path.join(workspaceDir, ".agents", "skills"));
-	}
-	paths.push(path.join(CONFIG_DIR, "skills"));
-	paths.push(path.join(os.homedir(), ".agents", "skills"));
-	const extraDirs = (config?.skills?.load?.extraDirs ?? []).map((d) => typeof d === "string" ? d.trim() : "").filter(Boolean).map((dir) => resolveUserPath(dir));
-	paths.push(...extraDirs);
-	const pluginSkillDirs = resolvePluginSkillDirs({
-		workspaceDir,
-		config
-	});
-	paths.push(...pluginSkillDirs);
-	return paths;
-}
-function toWatchGlobRoot(raw) {
-	return raw.replaceAll("\\", "/").replace(/\/+$/, "");
-}
-function resolveWatchTargets(workspaceDir, config) {
-	const targets = /* @__PURE__ */ new Set();
-	for (const root of resolveWatchPaths(workspaceDir, config)) {
-		const globRoot = toWatchGlobRoot(root);
-		targets.add(`${globRoot}/SKILL.md`);
-		targets.add(`${globRoot}/*/SKILL.md`);
-	}
-	return Array.from(targets).toSorted();
-}
-function bumpSkillsSnapshotVersion(params) {
-	const reason = params?.reason ?? "manual";
-	const changedPath = params?.changedPath;
-	if (params?.workspaceDir) {
-		const next = bumpVersion(workspaceVersions.get(params.workspaceDir) ?? 0);
-		workspaceVersions.set(params.workspaceDir, next);
-		emit({
-			workspaceDir: params.workspaceDir,
-			reason,
-			changedPath
-		});
-		return next;
-	}
-	globalVersion = bumpVersion(globalVersion);
-	emit({
-		reason,
-		changedPath
-	});
-	return globalVersion;
-}
-function getSkillsSnapshotVersion(workspaceDir) {
-	if (!workspaceDir) return globalVersion;
-	const local = workspaceVersions.get(workspaceDir) ?? 0;
-	return Math.max(globalVersion, local);
-}
-function ensureSkillsWatcher(params) {
-	const workspaceDir = params.workspaceDir.trim();
-	if (!workspaceDir) return;
-	const watchEnabled = params.config?.skills?.load?.watch !== false;
-	const debounceMsRaw = params.config?.skills?.load?.watchDebounceMs;
-	const debounceMs = typeof debounceMsRaw === "number" && Number.isFinite(debounceMsRaw) ? Math.max(0, debounceMsRaw) : 250;
-	const existing = watchers.get(workspaceDir);
-	if (!watchEnabled) {
-		if (existing) {
-			watchers.delete(workspaceDir);
-			if (existing.timer) clearTimeout(existing.timer);
-			existing.watcher.close().catch(() => {});
-		}
-		return;
-	}
-	const watchTargets = resolveWatchTargets(workspaceDir, params.config);
-	const pathsKey = watchTargets.join("|");
-	if (existing && existing.pathsKey === pathsKey && existing.debounceMs === debounceMs) return;
-	if (existing) {
-		watchers.delete(workspaceDir);
-		if (existing.timer) clearTimeout(existing.timer);
-		existing.watcher.close().catch(() => {});
-	}
-	const watcher = chokidar.watch(watchTargets, {
-		ignoreInitial: true,
-		awaitWriteFinish: {
-			stabilityThreshold: debounceMs,
-			pollInterval: 100
-		},
-		ignored: DEFAULT_SKILLS_WATCH_IGNORED
-	});
-	const state = {
-		watcher,
-		pathsKey,
-		debounceMs
-	};
-	const schedule = (changedPath) => {
-		state.pendingPath = changedPath ?? state.pendingPath;
-		if (state.timer) clearTimeout(state.timer);
-		state.timer = setTimeout(() => {
-			const pendingPath = state.pendingPath;
-			state.pendingPath = void 0;
-			state.timer = void 0;
-			bumpSkillsSnapshotVersion({
-				workspaceDir,
-				reason: "watch",
-				changedPath: pendingPath
-			});
-		}, debounceMs);
-	};
-	watcher.on("add", (p) => schedule(p));
-	watcher.on("change", (p) => schedule(p));
-	watcher.on("unlink", (p) => schedule(p));
-	watcher.on("error", (err) => {
-		log$1.warn(`skills watcher error (${workspaceDir}): ${String(err)}`);
-	});
-	watchers.set(workspaceDir, state);
-}
-
-//#endregion
-//#region src/auto-reply/thinking.ts
-function normalizeProviderId(provider) {
-	if (!provider) return "";
-	const normalized = provider.trim().toLowerCase();
-	if (normalized === "z.ai" || normalized === "z-ai") return "zai";
-	return normalized;
-}
-function isBinaryThinkingProvider(provider) {
-	return normalizeProviderId(provider) === "zai";
-}
-const XHIGH_MODEL_REFS = [
-	"openai/gpt-5.2",
-	"openai-codex/gpt-5.3-codex",
-	"openai-codex/gpt-5.3-codex-spark",
-	"openai-codex/gpt-5.2-codex",
-	"openai-codex/gpt-5.1-codex",
-	"github-copilot/gpt-5.2-codex",
-	"github-copilot/gpt-5.2"
-];
-const XHIGH_MODEL_SET = new Set(XHIGH_MODEL_REFS.map((entry) => entry.toLowerCase()));
-const XHIGH_MODEL_IDS = new Set(XHIGH_MODEL_REFS.map((entry) => entry.split("/")[1]?.toLowerCase()).filter((entry) => Boolean(entry)));
-function normalizeThinkLevel(raw) {
-	if (!raw) return;
-	const key = raw.trim().toLowerCase();
-	const collapsed = key.replace(/[\s_-]+/g, "");
-	if (collapsed === "xhigh" || collapsed === "extrahigh") return "xhigh";
-	if (["off"].includes(key)) return "off";
-	if ([
-		"on",
-		"enable",
-		"enabled"
-	].includes(key)) return "low";
-	if (["min", "minimal"].includes(key)) return "minimal";
-	if ([
-		"low",
-		"thinkhard",
-		"think-hard",
-		"think_hard"
-	].includes(key)) return "low";
-	if ([
-		"mid",
-		"med",
-		"medium",
-		"thinkharder",
-		"think-harder",
-		"harder"
-	].includes(key)) return "medium";
-	if ([
-		"high",
-		"ultra",
-		"ultrathink",
-		"think-hard",
-		"thinkhardest",
-		"highest",
-		"max"
-	].includes(key)) return "high";
-	if (["think"].includes(key)) return "minimal";
-}
-function supportsXHighThinking(provider, model) {
-	const modelKey = model?.trim().toLowerCase();
-	if (!modelKey) return false;
-	const providerKey = provider?.trim().toLowerCase();
-	if (providerKey) return XHIGH_MODEL_SET.has(`${providerKey}/${modelKey}`);
-	return XHIGH_MODEL_IDS.has(modelKey);
-}
-function listThinkingLevels(provider, model) {
-	const levels = [
-		"off",
-		"minimal",
-		"low",
-		"medium",
-		"high"
-	];
-	if (supportsXHighThinking(provider, model)) levels.push("xhigh");
-	return levels;
-}
-function listThinkingLevelLabels(provider, model) {
-	if (isBinaryThinkingProvider(provider)) return ["off", "on"];
-	return listThinkingLevels(provider, model);
-}
-function formatThinkingLevels(provider, model, separator = ", ") {
-	return listThinkingLevelLabels(provider, model).join(separator);
-}
-function formatXHighModelHint() {
-	const refs = [...XHIGH_MODEL_REFS];
-	if (refs.length === 0) return "unknown model";
-	if (refs.length === 1) return refs[0];
-	if (refs.length === 2) return `${refs[0]} or ${refs[1]}`;
-	return `${refs.slice(0, -1).join(", ")} or ${refs[refs.length - 1]}`;
-}
-function normalizeVerboseLevel(raw) {
-	if (!raw) return;
-	const key = raw.toLowerCase();
-	if ([
-		"off",
-		"false",
-		"no",
-		"0"
-	].includes(key)) return "off";
-	if ([
-		"full",
-		"all",
-		"everything"
-	].includes(key)) return "full";
-	if ([
-		"on",
-		"minimal",
-		"true",
-		"yes",
-		"1"
-	].includes(key)) return "on";
-}
-function normalizeUsageDisplay(raw) {
-	if (!raw) return;
-	const key = raw.toLowerCase();
-	if ([
-		"off",
-		"false",
-		"no",
-		"0",
-		"disable",
-		"disabled"
-	].includes(key)) return "off";
-	if ([
-		"on",
-		"true",
-		"yes",
-		"1",
-		"enable",
-		"enabled"
-	].includes(key)) return "tokens";
-	if ([
-		"tokens",
-		"token",
-		"tok",
-		"minimal",
-		"min"
-	].includes(key)) return "tokens";
-	if (["full", "session"].includes(key)) return "full";
-}
-function resolveResponseUsageMode(raw) {
-	return normalizeUsageDisplay(raw) ?? "off";
-}
-function normalizeElevatedLevel(raw) {
-	if (!raw) return;
-	const key = raw.toLowerCase();
-	if ([
-		"off",
-		"false",
-		"no",
-		"0"
-	].includes(key)) return "off";
-	if ([
-		"full",
-		"auto",
-		"auto-approve",
-		"autoapprove"
-	].includes(key)) return "full";
-	if ([
-		"ask",
-		"prompt",
-		"approval",
-		"approve"
-	].includes(key)) return "ask";
-	if ([
-		"on",
-		"true",
-		"yes",
-		"1"
-	].includes(key)) return "on";
-}
-function normalizeReasoningLevel(raw) {
-	if (!raw) return;
-	const key = raw.toLowerCase();
-	if ([
-		"off",
-		"false",
-		"no",
-		"0",
-		"hide",
-		"hidden",
-		"disable",
-		"disabled"
-	].includes(key)) return "off";
-	if ([
-		"on",
-		"true",
-		"yes",
-		"1",
-		"show",
-		"visible",
-		"enable",
-		"enabled"
-	].includes(key)) return "on";
-	if ([
-		"stream",
-		"streaming",
-		"draft",
-		"live"
-	].includes(key)) return "stream";
-}
-
-//#endregion
-//#region src/infra/pairing-files.ts
-function createAsyncLock() {
-	let lock = Promise.resolve();
-	return async function withLock(fn) {
-		const prev = lock;
-		let release;
-		lock = new Promise((resolve) => {
-			release = resolve;
-		});
-		await prev;
-		try {
-			return await fn();
-		} finally {
-			release?.();
-		}
-	};
-}
-
-//#endregion
-//#region src/infra/node-pairing.ts
-const PENDING_TTL_MS = 300 * 1e3;
-const withLock = createAsyncLock();
-
-//#endregion
-//#region src/infra/skills-remote.ts
-const log = createSubsystemLogger("gateway/skills-remote");
-const remoteNodes = /* @__PURE__ */ new Map();
-function isMacPlatform(platform, deviceFamily) {
-	const platformNorm = String(platform ?? "").trim().toLowerCase();
-	const familyNorm = String(deviceFamily ?? "").trim().toLowerCase();
-	if (platformNorm.includes("mac")) return true;
-	if (platformNorm.includes("darwin")) return true;
-	if (familyNorm === "mac") return true;
-	return false;
-}
-function supportsSystemRun(commands) {
-	return Array.isArray(commands) && commands.includes("system.run");
-}
-function getRemoteSkillEligibility() {
-	const macNodes = [...remoteNodes.values()].filter((node) => isMacPlatform(node.platform, node.deviceFamily) && supportsSystemRun(node.commands));
-	if (macNodes.length === 0) return;
-	const bins = /* @__PURE__ */ new Set();
-	for (const node of macNodes) for (const bin of node.bins) bins.add(bin);
-	const labels = macNodes.map((node) => node.displayName ?? node.nodeId).filter(Boolean);
-	return {
-		platforms: ["darwin"],
-		hasBin: (bin) => bins.has(bin),
-		hasAnyBin: (required) => required.some((bin) => bins.has(bin)),
-		note: labels.length > 0 ? `Remote macOS node available (${labels.join(", ")}). Run macOS-only skills via nodes.run on that node.` : "Remote macOS node available. Run macOS-only skills via nodes.run on that node."
-	};
-}
-
-//#endregion
-//#region src/sessions/level-overrides.ts
-function applyVerboseOverride(entry, level) {
-	if (level === void 0) return;
-	if (level === null) {
-		delete entry.verboseLevel;
-		return;
-	}
-	entry.verboseLevel = level;
-}
-
-//#endregion
-//#region src/sessions/model-overrides.ts
-function applyModelOverrideToSessionEntry(params) {
-	const { entry, selection, profileOverride } = params;
-	const profileOverrideSource = params.profileOverrideSource ?? "user";
-	let updated = false;
-	if (selection.isDefault) {
-		if (entry.providerOverride) {
-			delete entry.providerOverride;
-			updated = true;
-		}
-		if (entry.modelOverride) {
-			delete entry.modelOverride;
-			updated = true;
-		}
-	} else {
-		if (entry.providerOverride !== selection.provider) {
-			entry.providerOverride = selection.provider;
-			updated = true;
-		}
-		if (entry.modelOverride !== selection.model) {
-			entry.modelOverride = selection.model;
-			updated = true;
-		}
-	}
-	if (profileOverride) {
-		if (entry.authProfileOverride !== profileOverride) {
-			entry.authProfileOverride = profileOverride;
-			updated = true;
-		}
-		if (entry.authProfileOverrideSource !== profileOverrideSource) {
-			entry.authProfileOverrideSource = profileOverrideSource;
-			updated = true;
-		}
-		if (entry.authProfileOverrideCompactionCount !== void 0) {
-			delete entry.authProfileOverrideCompactionCount;
-			updated = true;
-		}
-	} else {
-		if (entry.authProfileOverride) {
-			delete entry.authProfileOverride;
-			updated = true;
-		}
-		if (entry.authProfileOverrideSource) {
-			delete entry.authProfileOverrideSource;
-			updated = true;
-		}
-		if (entry.authProfileOverrideCompactionCount !== void 0) {
-			delete entry.authProfileOverrideCompactionCount;
-			updated = true;
-		}
-	}
-	if (updated) entry.updatedAt = Date.now();
-	return { updated };
-}
-
-//#endregion
-//#region src/sessions/send-policy.ts
-function normalizeSendPolicy(raw) {
-	const value = raw?.trim().toLowerCase();
-	if (value === "allow") return "allow";
-	if (value === "deny") return "deny";
-}
-function normalizeMatchValue(raw) {
-	const value = raw?.trim().toLowerCase();
-	return value ? value : void 0;
-}
-function stripAgentSessionKeyPrefix(key) {
-	if (!key) return;
-	const parts = key.split(":").filter(Boolean);
-	if (parts.length >= 3 && parts[0] === "agent") return parts.slice(2).join(":");
-	return key;
-}
-function deriveChannelFromKey(key) {
-	const normalizedKey = stripAgentSessionKeyPrefix(key);
-	if (!normalizedKey) return;
-	const parts = normalizedKey.split(":").filter(Boolean);
-	if (parts.length >= 3 && (parts[1] === "group" || parts[1] === "channel")) return normalizeMatchValue(parts[0]);
-}
-function deriveChatTypeFromKey(key) {
-	const normalizedKey = stripAgentSessionKeyPrefix(key);
-	if (!normalizedKey) return;
-	if (normalizedKey.includes(":group:")) return "group";
-	if (normalizedKey.includes(":channel:")) return "channel";
-}
-function resolveSendPolicy(params) {
-	const override = normalizeSendPolicy(params.entry?.sendPolicy);
-	if (override) return override;
-	const policy = params.cfg.session?.sendPolicy;
-	if (!policy) return "allow";
-	const channel = normalizeMatchValue(params.channel) ?? normalizeMatchValue(params.entry?.channel) ?? normalizeMatchValue(params.entry?.lastChannel) ?? deriveChannelFromKey(params.sessionKey);
-	const chatType = normalizeChatType(params.chatType ?? params.entry?.chatType) ?? normalizeChatType(deriveChatTypeFromKey(params.sessionKey));
-	const rawSessionKey = params.sessionKey ?? "";
-	const strippedSessionKey = stripAgentSessionKeyPrefix(rawSessionKey) ?? "";
-	const rawSessionKeyNorm = rawSessionKey.toLowerCase();
-	const strippedSessionKeyNorm = strippedSessionKey.toLowerCase();
-	let allowedMatch = false;
-	for (const rule of policy.rules ?? []) {
-		if (!rule) continue;
-		const action = normalizeSendPolicy(rule.action) ?? "allow";
-		const match = rule.match ?? {};
-		const matchChannel = normalizeMatchValue(match.channel);
-		const matchChatType = normalizeChatType(match.chatType);
-		const matchPrefix = normalizeMatchValue(match.keyPrefix);
-		const matchRawPrefix = normalizeMatchValue(match.rawKeyPrefix);
-		if (matchChannel && matchChannel !== channel) continue;
-		if (matchChatType && matchChatType !== chatType) continue;
-		if (matchRawPrefix && !rawSessionKeyNorm.startsWith(matchRawPrefix)) continue;
-		if (matchPrefix && !rawSessionKeyNorm.startsWith(matchPrefix) && !strippedSessionKeyNorm.startsWith(matchPrefix)) continue;
-		if (action === "deny") return "deny";
-		allowedMatch = true;
-	}
-	if (allowedMatch) return "allow";
-	return normalizeSendPolicy(policy.default) ?? "allow";
-}
-
-//#endregion
-//#region src/infra/outbound/target-errors.ts
-function missingTargetMessage(provider, hint) {
-	return `Delivering to ${provider} requires target${formatTargetHint(hint)}`;
-}
-function missingTargetError(provider, hint) {
-	return new Error(missingTargetMessage(provider, hint));
-}
-function ambiguousTargetMessage(provider, raw, hint) {
-	return `Ambiguous target "${raw}" for ${provider}. Provide a unique name or an explicit id.${formatTargetHint(hint, true)}`;
-}
-function ambiguousTargetError(provider, raw, hint) {
-	return new Error(ambiguousTargetMessage(provider, raw, hint));
-}
-function unknownTargetMessage(provider, raw, hint) {
-	return `Unknown target "${raw}" for ${provider}.${formatTargetHint(hint, true)}`;
-}
-function unknownTargetError(provider, raw, hint) {
-	return new Error(unknownTargetMessage(provider, raw, hint));
-}
-function formatTargetHint(hint, withLabel = false) {
-	if (!hint) return "";
-	return withLabel ? ` Hint: ${hint}` : ` ${hint}`;
-}
-
-//#endregion
-//#region src/infra/outbound/targets.ts
-function resolveSessionDeliveryTarget(params) {
-	const context = deliveryContextFromSession(params.entry);
-	const lastChannel = context?.channel && isDeliverableMessageChannel(context.channel) ? context.channel : void 0;
-	const lastTo = context?.to;
-	const lastAccountId = context?.accountId;
-	const lastThreadId = context?.threadId;
-	const rawRequested = params.requestedChannel ?? "last";
-	const requested = rawRequested === "last" ? "last" : normalizeMessageChannel(rawRequested);
-	const requestedChannel = requested === "last" ? "last" : requested && isDeliverableMessageChannel(requested) ? requested : void 0;
-	const explicitTo = typeof params.explicitTo === "string" && params.explicitTo.trim() ? params.explicitTo.trim() : void 0;
-	const explicitThreadId = params.explicitThreadId != null && params.explicitThreadId !== "" ? params.explicitThreadId : void 0;
-	let channel = requestedChannel === "last" ? lastChannel : requestedChannel;
-	if (!channel && params.fallbackChannel && isDeliverableMessageChannel(params.fallbackChannel)) channel = params.fallbackChannel;
-	let to = explicitTo;
-	if (!to && lastTo) {
-		if (channel && channel === lastChannel) to = lastTo;
-		else if (params.allowMismatchedLastTo) to = lastTo;
-	}
-	const accountId = channel && channel === lastChannel ? lastAccountId : void 0;
-	const threadId = channel && channel === lastChannel ? lastThreadId : void 0;
-	const mode = params.mode ?? (explicitTo ? "explicit" : "implicit");
-	return {
-		channel,
-		to,
-		accountId,
-		threadId: explicitThreadId ?? threadId,
-		mode,
-		lastChannel,
-		lastTo,
-		lastAccountId,
-		lastThreadId
-	};
-}
-function resolveOutboundTarget(params) {
-	if (params.channel === INTERNAL_MESSAGE_CHANNEL) return {
-		ok: false,
-		error: /* @__PURE__ */ new Error(`Delivering to WebChat is not supported via \`${formatCliCommand("anima agent")}\`; use WhatsApp/Telegram or run with --deliver=false.`)
-	};
-	const plugin = getChannelPlugin(params.channel);
-	if (!plugin) return {
-		ok: false,
-		error: /* @__PURE__ */ new Error(`Unsupported channel: ${params.channel}`)
-	};
-	const allowFrom = params.allowFrom ?? (params.cfg && plugin.config.resolveAllowFrom ? plugin.config.resolveAllowFrom({
-		cfg: params.cfg,
-		accountId: params.accountId ?? void 0
-	}) : void 0);
-	const resolveTarget = plugin.outbound?.resolveTarget;
-	if (resolveTarget) return resolveTarget({
-		cfg: params.cfg,
-		to: params.to,
-		allowFrom,
-		accountId: params.accountId ?? void 0,
-		mode: params.mode ?? "explicit"
-	});
-	const trimmed = params.to?.trim();
-	if (trimmed) return {
-		ok: true,
-		to: trimmed
-	};
-	const hint = plugin.messaging?.targetResolver?.hint;
-	return {
-		ok: false,
-		error: missingTargetError(plugin.meta.label ?? params.channel, hint)
-	};
-}
-
-//#endregion
-//#region src/agents/context.ts
-const MODEL_CACHE = /* @__PURE__ */ new Map();
-(async () => {
-	try {
-		const { discoverAuthStorage, discoverModels } = await import("./pi-model-discovery-Cxs4pvC2.js");
-		await ensureAnimaModelsJson(loadConfig());
-		const agentDir = resolveAnimaAgentDir();
-		const models = discoverModels(discoverAuthStorage(agentDir), agentDir).getAll();
-		for (const m of models) {
-			if (!m?.id) continue;
-			if (typeof m.contextWindow === "number" && m.contextWindow > 0) MODEL_CACHE.set(m.id, m.contextWindow);
-		}
-	} catch {}
-})();
-function lookupContextTokens(modelId) {
-	if (!modelId) return;
-	return MODEL_CACHE.get(modelId);
-}
-
-//#endregion
-//#region src/agents/usage.ts
-const asFiniteNumber = (value) => {
-	if (typeof value !== "number") return;
-	if (!Number.isFinite(value)) return;
-	return value;
-};
-function hasNonzeroUsage(usage) {
-	if (!usage) return false;
-	return [
-		usage.input,
-		usage.output,
-		usage.cacheRead,
-		usage.cacheWrite,
-		usage.total
-	].some((v) => typeof v === "number" && Number.isFinite(v) && v > 0);
-}
-function normalizeUsage(raw) {
-	if (!raw) return;
-	const input = asFiniteNumber(raw.input ?? raw.inputTokens ?? raw.input_tokens ?? raw.promptTokens ?? raw.prompt_tokens);
-	const output = asFiniteNumber(raw.output ?? raw.outputTokens ?? raw.output_tokens ?? raw.completionTokens ?? raw.completion_tokens);
-	const cacheRead = asFiniteNumber(raw.cacheRead ?? raw.cache_read ?? raw.cache_read_input_tokens);
-	const cacheWrite = asFiniteNumber(raw.cacheWrite ?? raw.cache_write ?? raw.cache_creation_input_tokens);
-	const total = asFiniteNumber(raw.total ?? raw.totalTokens ?? raw.total_tokens);
-	if (input === void 0 && output === void 0 && cacheRead === void 0 && cacheWrite === void 0 && total === void 0) return;
-	return {
-		input,
-		output,
-		cacheRead,
-		cacheWrite,
-		total
-	};
-}
-function derivePromptTokens(usage) {
-	if (!usage) return;
-	const input = usage.input ?? 0;
-	const cacheRead = usage.cacheRead ?? 0;
-	const cacheWrite = usage.cacheWrite ?? 0;
-	const sum = input + cacheRead + cacheWrite;
-	return sum > 0 ? sum : void 0;
-}
-function deriveSessionTotalTokens(params) {
-	const promptOverride = params.promptTokens;
-	const hasPromptOverride = typeof promptOverride === "number" && Number.isFinite(promptOverride) && promptOverride > 0;
-	const usage = params.usage;
-	if (!usage && !hasPromptOverride) return;
-	const input = usage?.input ?? 0;
-	let total = (hasPromptOverride ? promptOverride : derivePromptTokens({
-		input: usage?.input,
-		cacheRead: usage?.cacheRead,
-		cacheWrite: usage?.cacheWrite
-	})) ?? usage?.total ?? input;
-	if (!(total > 0)) return;
-	return total;
-}
-
-//#endregion
-export { getTtsProvider as $, assertSandboxPath as A, runCliAgent as B, supportsXHighThinking as C, buildWorkspaceSkillSnapshot as D, buildWorkspaceSkillCommandSpecs as E, loadModelCatalog as F, resolveUserTimezone as G, buildSystemPromptParams as H, modelSupportsVision as I, killProcessTree as J, withNormalizedTimestamp as K, ensureAnimaModelsJson as L, runWithImageModelFallback as M, runWithModelFallback as N, syncSkillsToWorkspace as O, findModelInCatalog as P, getTtsMaxLength as Q, getCliSessionId as R, resolveResponseUsageMode as S, getSkillsSnapshotVersion as T, formatUserTime as U, buildAgentSystemPrompt as V, resolveUserTimeFormat as W, buildTtsSystemPromptHint as X, sanitizeBinaryOutput as Y, getLastTtsAttempt as Z, normalizeElevatedLevel as _, resolveBootstrapContextForRun as _t, lookupContextTokens as a, resolveTtsApiKey as at, normalizeUsageDisplay as b, ambiguousTargetError as c, resolveTtsPrefsPath as ct, applyModelOverrideToSessionEntry as d, setTtsEnabled as dt, isSummarizationEnabled as et, applyVerboseOverride as f, setTtsMaxLength as ft, listThinkingLevels as g, isVoiceCompatibleAudio as gt, formatXHighModelHint as h, textToSpeechTelephony as ht, normalizeUsage as i, normalizeTtsAutoMode as it, resolveSandboxedMediaSource as j, assertMediaNotDataUrl as k, unknownTargetError as l, setLastTtsAttempt as lt, formatThinkingLevels as m, textToSpeech as mt, deriveSessionTotalTokens as n, isTtsProviderConfigured as nt, resolveOutboundTarget as o, resolveTtsAutoMode as ot, getRemoteSkillEligibility as p, setTtsProvider as pt, getShellConfig as q, hasNonzeroUsage as r, maybeApplyTtsToPayload as rt, resolveSessionDeliveryTarget as s, resolveTtsConfig as st, derivePromptTokens as t, isTtsEnabled as tt, resolveSendPolicy as u, setSummarizationEnabled as ut, normalizeReasoningLevel as v, clearSessionAuthProfileOverride as vt, ensureSkillsWatcher as w, normalizeVerboseLevel as x, normalizeThinkLevel as y, resolveSessionAuthProfileOverride as yt, setCliSessionId as z };