@noxsoft/anima 2.0.2 → 2.0.4

package/dist/agent-events-COH7NDW2.js

@@ -0,0 +1,182 @@
+import { k as escapeRegExp } from "./exec-B7sUS164.js";
+import { B as HEARTBEAT_TOKEN } from "./sessions-wRKla1Qh.js";
+
+//#region src/auto-reply/heartbeat.ts
+const HEARTBEAT_PROMPT = "Read HEARTBEAT.md if it exists (workspace context). Follow it strictly. Do not infer or repeat old tasks from prior chats. If nothing needs attention, reply HEARTBEAT_OK.";
+const DEFAULT_HEARTBEAT_ACK_MAX_CHARS = 300;
+function resolveHeartbeatPrompt(raw) {
+	return (typeof raw === "string" ? raw.trim() : "") || HEARTBEAT_PROMPT;
+}
+function stripTokenAtEdges(raw) {
+	let text = raw.trim();
+	if (!text) return {
+		text: "",
+		didStrip: false
+	};
+	const token = HEARTBEAT_TOKEN;
+	const tokenAtEndWithOptionalTrailingPunctuation = new RegExp(`${escapeRegExp(token)}[^\\w]{0,4}$`);
+	if (!text.includes(token)) return {
+		text,
+		didStrip: false
+	};
+	let didStrip = false;
+	let changed = true;
+	while (changed) {
+		changed = false;
+		const next = text.trim();
+		if (next.startsWith(token)) {
+			text = next.slice(token.length).trimStart();
+			didStrip = true;
+			changed = true;
+			continue;
+		}
+		if (tokenAtEndWithOptionalTrailingPunctuation.test(next)) {
+			const idx = next.lastIndexOf(token);
+			const before = next.slice(0, idx).trimEnd();
+			if (!before) text = "";
+			else text = `${before}${next.slice(idx + token.length).trimStart()}`.trimEnd();
+			didStrip = true;
+			changed = true;
+		}
+	}
+	return {
+		text: text.replace(/\s+/g, " ").trim(),
+		didStrip
+	};
+}
+function stripHeartbeatToken(raw, opts = {}) {
+	if (!raw) return {
+		shouldSkip: true,
+		text: "",
+		didStrip: false
+	};
+	const trimmed = raw.trim();
+	if (!trimmed) return {
+		shouldSkip: true,
+		text: "",
+		didStrip: false
+	};
+	const mode = opts.mode ?? "message";
+	const maxAckCharsRaw = opts.maxAckChars;
+	const parsedAckChars = typeof maxAckCharsRaw === "string" ? Number(maxAckCharsRaw) : maxAckCharsRaw;
+	const maxAckChars = Math.max(0, typeof parsedAckChars === "number" && Number.isFinite(parsedAckChars) ? parsedAckChars : DEFAULT_HEARTBEAT_ACK_MAX_CHARS);
+	const stripMarkup = (text) => text.replace(/<[^>]*>/g, " ").replace(/&nbsp;/gi, " ").replace(/^[*`~_]+/, "").replace(/[*`~_]+$/, "");
+	const trimmedNormalized = stripMarkup(trimmed);
+	if (!(trimmed.includes(HEARTBEAT_TOKEN) || trimmedNormalized.includes(HEARTBEAT_TOKEN))) return {
+		shouldSkip: false,
+		text: trimmed,
+		didStrip: false
+	};
+	const strippedOriginal = stripTokenAtEdges(trimmed);
+	const strippedNormalized = stripTokenAtEdges(trimmedNormalized);
+	const picked = strippedOriginal.didStrip && strippedOriginal.text ? strippedOriginal : strippedNormalized;
+	if (!picked.didStrip) return {
+		shouldSkip: false,
+		text: trimmed,
+		didStrip: false
+	};
+	if (!picked.text) return {
+		shouldSkip: true,
+		text: "",
+		didStrip: true
+	};
+	const rest = picked.text.trim();
+	if (mode === "heartbeat") {
+		if (rest.length <= maxAckChars) return {
+			shouldSkip: true,
+			text: "",
+			didStrip: true
+		};
+	}
+	return {
+		shouldSkip: false,
+		text: rest,
+		didStrip: true
+	};
+}
+
+//#endregion
+//#region src/process/lanes.ts
+let CommandLane = /* @__PURE__ */ function(CommandLane) {
+	CommandLane["Main"] = "main";
+	CommandLane["Cron"] = "cron";
+	CommandLane["Subagent"] = "subagent";
+	CommandLane["Nested"] = "nested";
+	return CommandLane;
+}({});
+
+//#endregion
+//#region src/agents/lanes.ts
+const AGENT_LANE_NESTED = CommandLane.Nested;
+const AGENT_LANE_SUBAGENT = CommandLane.Subagent;
+
+//#endregion
+//#region src/agents/timeout.ts
+const DEFAULT_AGENT_TIMEOUT_SECONDS = 600;
+const MAX_SAFE_TIMEOUT_MS = 2147e6;
+const normalizeNumber = (value) => typeof value === "number" && Number.isFinite(value) ? Math.floor(value) : void 0;
+function resolveAgentTimeoutSeconds(cfg) {
+	const seconds = normalizeNumber(cfg?.agents?.defaults?.timeoutSeconds) ?? DEFAULT_AGENT_TIMEOUT_SECONDS;
+	return Math.max(seconds, 1);
+}
+function resolveAgentTimeoutMs(opts) {
+	const minMs = Math.max(normalizeNumber(opts.minMs) ?? 1, 1);
+	const clampTimeoutMs = (valueMs) => Math.min(Math.max(valueMs, minMs), MAX_SAFE_TIMEOUT_MS);
+	const defaultMs = clampTimeoutMs(resolveAgentTimeoutSeconds(opts.cfg) * 1e3);
+	const NO_TIMEOUT_MS = MAX_SAFE_TIMEOUT_MS;
+	const overrideMs = normalizeNumber(opts.overrideMs);
+	if (overrideMs !== void 0) {
+		if (overrideMs === 0) return NO_TIMEOUT_MS;
+		if (overrideMs < 0) return defaultMs;
+		return clampTimeoutMs(overrideMs);
+	}
+	const overrideSeconds = normalizeNumber(opts.overrideSeconds);
+	if (overrideSeconds !== void 0) {
+		if (overrideSeconds === 0) return NO_TIMEOUT_MS;
+		if (overrideSeconds < 0) return defaultMs;
+		return clampTimeoutMs(overrideSeconds * 1e3);
+	}
+	return defaultMs;
+}
+
+//#endregion
+//#region src/infra/agent-events.ts
+const seqByRun = /* @__PURE__ */ new Map();
+const listeners = /* @__PURE__ */ new Set();
+const runContextById = /* @__PURE__ */ new Map();
+function registerAgentRunContext(runId, context) {
+	if (!runId) return;
+	const existing = runContextById.get(runId);
+	if (!existing) {
+		runContextById.set(runId, { ...context });
+		return;
+	}
+	if (context.sessionKey && existing.sessionKey !== context.sessionKey) existing.sessionKey = context.sessionKey;
+	if (context.verboseLevel && existing.verboseLevel !== context.verboseLevel) existing.verboseLevel = context.verboseLevel;
+	if (context.isHeartbeat !== void 0 && existing.isHeartbeat !== context.isHeartbeat) existing.isHeartbeat = context.isHeartbeat;
+}
+function clearAgentRunContext(runId) {
+	runContextById.delete(runId);
+}
+function emitAgentEvent(event) {
+	const nextSeq = (seqByRun.get(event.runId) ?? 0) + 1;
+	seqByRun.set(event.runId, nextSeq);
+	const context = runContextById.get(event.runId);
+	const sessionKey = typeof event.sessionKey === "string" && event.sessionKey.trim() ? event.sessionKey : context?.sessionKey;
+	const enriched = {
+		...event,
+		sessionKey,
+		seq: nextSeq,
+		ts: Date.now()
+	};
+	for (const listener of listeners) try {
+		listener(enriched);
+	} catch {}
+}
+function onAgentEvent(listener) {
+	listeners.add(listener);
+	return () => listeners.delete(listener);
+}
+
+//#endregion
+export { resolveAgentTimeoutMs as a, CommandLane as c, registerAgentRunContext as i, resolveHeartbeatPrompt as l, emitAgentEvent as n, AGENT_LANE_NESTED as o, onAgentEvent as r, AGENT_LANE_SUBAGENT as s, clearAgentRunContext as t, stripHeartbeatToken as u };

package/dist/agent-scope-CPphqq-U.js

@@ -0,0 +1,452 @@
+import { g as resolveStateDir, y as resolveRequiredHomeDir } from "./paths-BMuHNFxg.js";
+import { b as resolveUserPath, g as pathExists } from "./utils-DZ8pnOD5.js";
+import { b as isSubagentSessionKey, l as normalizeAgentId, n as DEFAULT_AGENT_ID, x as parseAgentSessionKey, y as isCronSessionKey } from "./session-key-DxcgHezu.js";
+import { t as runCommandWithTimeout } from "./exec-mhSykkaa.js";
+import { t as resolveAnimaPackageRoot } from "./openclaw-root-0yHXtO35.js";
+import { fileURLToPath } from "node:url";
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs/promises";
+
+//#region src/agents/workspace-templates.ts
+const FALLBACK_TEMPLATE_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../docs/reference/templates");
+let cachedTemplateDir;
+let resolvingTemplateDir;
+async function resolveWorkspaceTemplateDir(opts) {
+	if (cachedTemplateDir) return cachedTemplateDir;
+	if (resolvingTemplateDir) return resolvingTemplateDir;
+	resolvingTemplateDir = (async () => {
+		const moduleUrl = opts?.moduleUrl ?? import.meta.url;
+		const argv1 = opts?.argv1 ?? process.argv[1];
+		const cwd = opts?.cwd ?? process.cwd();
+		const packageRoot = await resolveAnimaPackageRoot({
+			moduleUrl,
+			argv1,
+			cwd
+		});
+		const candidates = [
+			packageRoot ? path.join(packageRoot, "docs", "reference", "templates") : null,
+			cwd ? path.resolve(cwd, "docs", "reference", "templates") : null,
+			FALLBACK_TEMPLATE_DIR
+		].filter(Boolean);
+		for (const candidate of candidates) if (await pathExists(candidate)) {
+			cachedTemplateDir = candidate;
+			return candidate;
+		}
+		cachedTemplateDir = candidates[0] ?? FALLBACK_TEMPLATE_DIR;
+		return cachedTemplateDir;
+	})();
+	try {
+		return await resolvingTemplateDir;
+	} finally {
+		resolvingTemplateDir = void 0;
+	}
+}
+
+//#endregion
+//#region src/agents/workspace.ts
+function resolveDefaultAgentWorkspaceDir(env = process.env, homedir = os.homedir) {
+	const home = resolveRequiredHomeDir(env, homedir);
+	const profile = env.ANIMA_PROFILE?.trim() || env.OPENCLAW_PROFILE?.trim();
+	if (profile && profile.toLowerCase() !== "default") return path.join(home, ".anima", `workspace-${profile}`);
+	return path.join(home, ".anima", "workspace");
+}
+const DEFAULT_AGENT_WORKSPACE_DIR = resolveDefaultAgentWorkspaceDir();
+const DEFAULT_AGENTS_FILENAME = "AGENTS.md";
+const DEFAULT_SOUL_FILENAME = "SOUL.md";
+const DEFAULT_TOOLS_FILENAME = "TOOLS.md";
+const DEFAULT_IDENTITY_FILENAME = "IDENTITY.md";
+const DEFAULT_USER_FILENAME = "USER.md";
+const DEFAULT_HEARTBEAT_FILENAME = "HEARTBEAT.md";
+const DEFAULT_BOOTSTRAP_FILENAME = "BOOTSTRAP.md";
+const DEFAULT_MEMORY_FILENAME = "MEMORY.md";
+const DEFAULT_MEMORY_ALT_FILENAME = "memory.md";
+const WORKSPACE_STATE_DIRNAME = ".anima";
+const WORKSPACE_STATE_FILENAME = "workspace-state.json";
+const WORKSPACE_STATE_VERSION = 1;
+const workspaceTemplateCache = /* @__PURE__ */ new Map();
+let gitAvailabilityPromise = null;
+function stripFrontMatter(content) {
+	if (!content.startsWith("---")) return content;
+	const endIndex = content.indexOf("\n---", 3);
+	if (endIndex === -1) return content;
+	const start = endIndex + 4;
+	let trimmed = content.slice(start);
+	trimmed = trimmed.replace(/^\s+/, "");
+	return trimmed;
+}
+async function loadTemplate(name) {
+	const cached = workspaceTemplateCache.get(name);
+	if (cached) return cached;
+	const pending = (async () => {
+		const templateDir = await resolveWorkspaceTemplateDir();
+		const templatePath = path.join(templateDir, name);
+		try {
+			return stripFrontMatter(await fs.readFile(templatePath, "utf-8"));
+		} catch {
+			throw new Error(`Missing workspace template: ${name} (${templatePath}). Ensure docs/reference/templates are packaged.`);
+		}
+	})();
+	workspaceTemplateCache.set(name, pending);
+	try {
+		return await pending;
+	} catch (error) {
+		workspaceTemplateCache.delete(name);
+		throw error;
+	}
+}
+async function writeFileIfMissing(filePath, content) {
+	try {
+		await fs.writeFile(filePath, content, {
+			encoding: "utf-8",
+			flag: "wx"
+		});
+		return true;
+	} catch (err) {
+		if (err.code !== "EEXIST") throw err;
+		return false;
+	}
+}
+async function fileExists(filePath) {
+	try {
+		await fs.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function resolveWorkspaceStatePath(dir) {
+	return path.join(dir, WORKSPACE_STATE_DIRNAME, WORKSPACE_STATE_FILENAME);
+}
+function parseWorkspaceOnboardingState(raw) {
+	try {
+		const parsed = JSON.parse(raw);
+		if (!parsed || typeof parsed !== "object") return null;
+		return {
+			version: WORKSPACE_STATE_VERSION,
+			bootstrapSeededAt: typeof parsed.bootstrapSeededAt === "string" ? parsed.bootstrapSeededAt : void 0,
+			onboardingCompletedAt: typeof parsed.onboardingCompletedAt === "string" ? parsed.onboardingCompletedAt : void 0
+		};
+	} catch {
+		return null;
+	}
+}
+async function readWorkspaceOnboardingState(statePath) {
+	try {
+		return parseWorkspaceOnboardingState(await fs.readFile(statePath, "utf-8")) ?? { version: WORKSPACE_STATE_VERSION };
+	} catch (err) {
+		if (err.code !== "ENOENT") throw err;
+		return { version: WORKSPACE_STATE_VERSION };
+	}
+}
+async function writeWorkspaceOnboardingState(statePath, state) {
+	await fs.mkdir(path.dirname(statePath), { recursive: true });
+	const payload = `${JSON.stringify(state, null, 2)}\n`;
+	const tmpPath = `${statePath}.tmp-${process.pid}-${Date.now().toString(36)}`;
+	try {
+		await fs.writeFile(tmpPath, payload, { encoding: "utf-8" });
+		await fs.rename(tmpPath, statePath);
+	} catch (err) {
+		await fs.unlink(tmpPath).catch(() => {});
+		throw err;
+	}
+}
+async function hasGitRepo(dir) {
+	try {
+		await fs.stat(path.join(dir, ".git"));
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function isGitAvailable() {
+	if (gitAvailabilityPromise) return gitAvailabilityPromise;
+	gitAvailabilityPromise = (async () => {
+		try {
+			return (await runCommandWithTimeout(["git", "--version"], { timeoutMs: 2e3 })).code === 0;
+		} catch {
+			return false;
+		}
+	})();
+	return gitAvailabilityPromise;
+}
+async function ensureGitRepo(dir, isBrandNewWorkspace) {
+	if (!isBrandNewWorkspace) return;
+	if (await hasGitRepo(dir)) return;
+	if (!await isGitAvailable()) return;
+	try {
+		await runCommandWithTimeout(["git", "init"], {
+			cwd: dir,
+			timeoutMs: 1e4
+		});
+	} catch {}
+}
+async function ensureAgentWorkspace(params) {
+	const dir = resolveUserPath(params?.dir?.trim() ? params.dir.trim() : DEFAULT_AGENT_WORKSPACE_DIR);
+	await fs.mkdir(dir, { recursive: true });
+	if (!params?.ensureBootstrapFiles) return { dir };
+	const agentsPath = path.join(dir, DEFAULT_AGENTS_FILENAME);
+	const soulPath = path.join(dir, DEFAULT_SOUL_FILENAME);
+	const toolsPath = path.join(dir, DEFAULT_TOOLS_FILENAME);
+	const identityPath = path.join(dir, DEFAULT_IDENTITY_FILENAME);
+	const userPath = path.join(dir, DEFAULT_USER_FILENAME);
+	const heartbeatPath = path.join(dir, DEFAULT_HEARTBEAT_FILENAME);
+	const bootstrapPath = path.join(dir, DEFAULT_BOOTSTRAP_FILENAME);
+	const statePath = resolveWorkspaceStatePath(dir);
+	const isBrandNewWorkspace = await (async () => {
+		const paths = [
+			agentsPath,
+			soulPath,
+			toolsPath,
+			identityPath,
+			userPath,
+			heartbeatPath
+		];
+		return (await Promise.all(paths.map(async (p) => {
+			try {
+				await fs.access(p);
+				return true;
+			} catch {
+				return false;
+			}
+		}))).every((v) => !v);
+	})();
+	const agentsTemplate = await loadTemplate(DEFAULT_AGENTS_FILENAME);
+	const soulTemplate = await loadTemplate(DEFAULT_SOUL_FILENAME);
+	const toolsTemplate = await loadTemplate(DEFAULT_TOOLS_FILENAME);
+	const identityTemplate = await loadTemplate(DEFAULT_IDENTITY_FILENAME);
+	const userTemplate = await loadTemplate(DEFAULT_USER_FILENAME);
+	const heartbeatTemplate = await loadTemplate(DEFAULT_HEARTBEAT_FILENAME);
+	await writeFileIfMissing(agentsPath, agentsTemplate);
+	await writeFileIfMissing(soulPath, soulTemplate);
+	await writeFileIfMissing(toolsPath, toolsTemplate);
+	await writeFileIfMissing(identityPath, identityTemplate);
+	await writeFileIfMissing(userPath, userTemplate);
+	await writeFileIfMissing(heartbeatPath, heartbeatTemplate);
+	let state = await readWorkspaceOnboardingState(statePath);
+	let stateDirty = false;
+	const markState = (next) => {
+		state = {
+			...state,
+			...next
+		};
+		stateDirty = true;
+	};
+	const nowIso = () => (/* @__PURE__ */ new Date()).toISOString();
+	let bootstrapExists = await fileExists(bootstrapPath);
+	if (!state.bootstrapSeededAt && bootstrapExists) markState({ bootstrapSeededAt: nowIso() });
+	if (!state.onboardingCompletedAt && state.bootstrapSeededAt && !bootstrapExists) markState({ onboardingCompletedAt: nowIso() });
+	if (!state.bootstrapSeededAt && !state.onboardingCompletedAt && !bootstrapExists) {
+		const [identityContent, userContent] = await Promise.all([fs.readFile(identityPath, "utf-8"), fs.readFile(userPath, "utf-8")]);
+		if (identityContent !== identityTemplate || userContent !== userTemplate) markState({ onboardingCompletedAt: nowIso() });
+		else {
+			if (!await writeFileIfMissing(bootstrapPath, await loadTemplate(DEFAULT_BOOTSTRAP_FILENAME))) bootstrapExists = await fileExists(bootstrapPath);
+			else bootstrapExists = true;
+			if (bootstrapExists && !state.bootstrapSeededAt) markState({ bootstrapSeededAt: nowIso() });
+		}
+	}
+	if (stateDirty) await writeWorkspaceOnboardingState(statePath, state);
+	await ensureGitRepo(dir, isBrandNewWorkspace);
+	return {
+		dir,
+		agentsPath,
+		soulPath,
+		toolsPath,
+		identityPath,
+		userPath,
+		heartbeatPath,
+		bootstrapPath
+	};
+}
+async function resolveMemoryBootstrapEntries(resolvedDir) {
+	const candidates = [DEFAULT_MEMORY_FILENAME, DEFAULT_MEMORY_ALT_FILENAME];
+	const entries = [];
+	for (const name of candidates) {
+		const filePath = path.join(resolvedDir, name);
+		try {
+			await fs.access(filePath);
+			entries.push({
+				name,
+				filePath
+			});
+		} catch {}
+	}
+	if (entries.length <= 1) return entries;
+	const seen = /* @__PURE__ */ new Set();
+	const deduped = [];
+	for (const entry of entries) {
+		let key = entry.filePath;
+		try {
+			key = await fs.realpath(entry.filePath);
+		} catch {}
+		if (seen.has(key)) continue;
+		seen.add(key);
+		deduped.push(entry);
+	}
+	return deduped;
+}
+async function loadWorkspaceBootstrapFiles(dir) {
+	const resolvedDir = resolveUserPath(dir);
+	const entries = [
+		{
+			name: DEFAULT_AGENTS_FILENAME,
+			filePath: path.join(resolvedDir, DEFAULT_AGENTS_FILENAME)
+		},
+		{
+			name: DEFAULT_SOUL_FILENAME,
+			filePath: path.join(resolvedDir, DEFAULT_SOUL_FILENAME)
+		},
+		{
+			name: DEFAULT_TOOLS_FILENAME,
+			filePath: path.join(resolvedDir, DEFAULT_TOOLS_FILENAME)
+		},
+		{
+			name: DEFAULT_IDENTITY_FILENAME,
+			filePath: path.join(resolvedDir, DEFAULT_IDENTITY_FILENAME)
+		},
+		{
+			name: DEFAULT_USER_FILENAME,
+			filePath: path.join(resolvedDir, DEFAULT_USER_FILENAME)
+		},
+		{
+			name: DEFAULT_HEARTBEAT_FILENAME,
+			filePath: path.join(resolvedDir, DEFAULT_HEARTBEAT_FILENAME)
+		},
+		{
+			name: DEFAULT_BOOTSTRAP_FILENAME,
+			filePath: path.join(resolvedDir, DEFAULT_BOOTSTRAP_FILENAME)
+		}
+	];
+	entries.push(...await resolveMemoryBootstrapEntries(resolvedDir));
+	const result = [];
+	for (const entry of entries) try {
+		const content = await fs.readFile(entry.filePath, "utf-8");
+		result.push({
+			name: entry.name,
+			path: entry.filePath,
+			content,
+			missing: false
+		});
+	} catch {
+		result.push({
+			name: entry.name,
+			path: entry.filePath,
+			missing: true
+		});
+	}
+	return result;
+}
+const MINIMAL_BOOTSTRAP_ALLOWLIST = new Set([DEFAULT_AGENTS_FILENAME, DEFAULT_TOOLS_FILENAME]);
+function filterBootstrapFilesForSession(files, sessionKey) {
+	if (!sessionKey || !isSubagentSessionKey(sessionKey) && !isCronSessionKey(sessionKey)) return files;
+	return files.filter((file) => MINIMAL_BOOTSTRAP_ALLOWLIST.has(file.name));
+}
+
+//#endregion
+//#region src/agents/agent-scope.ts
+let defaultAgentWarned = false;
+function listAgents(cfg) {
+	const list = cfg.agents?.list;
+	if (!Array.isArray(list)) return [];
+	return list.filter((entry) => Boolean(entry && typeof entry === "object"));
+}
+function listAgentIds(cfg) {
+	const agents = listAgents(cfg);
+	if (agents.length === 0) return [DEFAULT_AGENT_ID];
+	const seen = /* @__PURE__ */ new Set();
+	const ids = [];
+	for (const entry of agents) {
+		const id = normalizeAgentId(entry?.id);
+		if (seen.has(id)) continue;
+		seen.add(id);
+		ids.push(id);
+	}
+	return ids.length > 0 ? ids : [DEFAULT_AGENT_ID];
+}
+function resolveDefaultAgentId(cfg) {
+	const agents = listAgents(cfg);
+	if (agents.length === 0) return DEFAULT_AGENT_ID;
+	const defaults = agents.filter((agent) => agent?.default);
+	if (defaults.length > 1 && !defaultAgentWarned) {
+		defaultAgentWarned = true;
+		console.warn("Multiple agents marked default=true; using the first entry as default.");
+	}
+	const chosen = (defaults[0] ?? agents[0])?.id?.trim();
+	return normalizeAgentId(chosen || DEFAULT_AGENT_ID);
+}
+function resolveSessionAgentIds(params) {
+	const defaultAgentId = resolveDefaultAgentId(params.config ?? {});
+	const sessionKey = params.sessionKey?.trim();
+	const normalizedSessionKey = sessionKey ? sessionKey.toLowerCase() : void 0;
+	const parsed = normalizedSessionKey ? parseAgentSessionKey(normalizedSessionKey) : null;
+	return {
+		defaultAgentId,
+		sessionAgentId: parsed?.agentId ? normalizeAgentId(parsed.agentId) : defaultAgentId
+	};
+}
+function resolveSessionAgentId(params) {
+	return resolveSessionAgentIds(params).sessionAgentId;
+}
+function resolveAgentEntry(cfg, agentId) {
+	const id = normalizeAgentId(agentId);
+	return listAgents(cfg).find((entry) => normalizeAgentId(entry.id) === id);
+}
+function resolveAgentConfig(cfg, agentId) {
+	const entry = resolveAgentEntry(cfg, normalizeAgentId(agentId));
+	if (!entry) return;
+	return {
+		name: typeof entry.name === "string" ? entry.name : void 0,
+		workspace: typeof entry.workspace === "string" ? entry.workspace : void 0,
+		agentDir: typeof entry.agentDir === "string" ? entry.agentDir : void 0,
+		model: typeof entry.model === "string" || entry.model && typeof entry.model === "object" ? entry.model : void 0,
+		skills: Array.isArray(entry.skills) ? entry.skills : void 0,
+		memorySearch: entry.memorySearch,
+		humanDelay: entry.humanDelay,
+		heartbeat: entry.heartbeat,
+		identity: entry.identity,
+		groupChat: entry.groupChat,
+		subagents: typeof entry.subagents === "object" && entry.subagents ? entry.subagents : void 0,
+		sandbox: entry.sandbox,
+		tools: entry.tools
+	};
+}
+function resolveAgentSkillsFilter(cfg, agentId) {
+	const raw = resolveAgentConfig(cfg, agentId)?.skills;
+	if (!raw) return;
+	const normalized = raw.map((entry) => String(entry).trim()).filter(Boolean);
+	return normalized.length > 0 ? normalized : [];
+}
+function resolveAgentModelPrimary(cfg, agentId) {
+	const raw = resolveAgentConfig(cfg, agentId)?.model;
+	if (!raw) return;
+	if (typeof raw === "string") return raw.trim() || void 0;
+	return raw.primary?.trim() || void 0;
+}
+function resolveAgentModelFallbacksOverride(cfg, agentId) {
+	const raw = resolveAgentConfig(cfg, agentId)?.model;
+	if (!raw || typeof raw === "string") return;
+	if (!Object.hasOwn(raw, "fallbacks")) return;
+	return Array.isArray(raw.fallbacks) ? raw.fallbacks : void 0;
+}
+function resolveAgentWorkspaceDir(cfg, agentId) {
+	const id = normalizeAgentId(agentId);
+	const configured = resolveAgentConfig(cfg, id)?.workspace?.trim();
+	if (configured) return resolveUserPath(configured);
+	if (id === resolveDefaultAgentId(cfg)) {
+		const fallback = cfg.agents?.defaults?.workspace?.trim();
+		if (fallback) return resolveUserPath(fallback);
+		return resolveDefaultAgentWorkspaceDir(process.env);
+	}
+	const stateDir = resolveStateDir(process.env);
+	return path.join(stateDir, `workspace-${id}`);
+}
+function resolveAgentDir(cfg, agentId) {
+	const id = normalizeAgentId(agentId);
+	const configured = resolveAgentConfig(cfg, id)?.agentDir?.trim();
+	if (configured) return resolveUserPath(configured);
+	const root = resolveStateDir(process.env);
+	return path.join(root, "agents", id, "agent");
+}
+
+//#endregion
+export { loadWorkspaceBootstrapFiles as C, filterBootstrapFilesForSession as S, resolveWorkspaceTemplateDir as T, DEFAULT_MEMORY_FILENAME as _, resolveAgentModelPrimary as a, DEFAULT_USER_FILENAME as b, resolveDefaultAgentId as c, DEFAULT_AGENTS_FILENAME as d, DEFAULT_AGENT_WORKSPACE_DIR as f, DEFAULT_MEMORY_ALT_FILENAME as g, DEFAULT_IDENTITY_FILENAME as h, resolveAgentModelFallbacksOverride as i, resolveSessionAgentId as l, DEFAULT_HEARTBEAT_FILENAME as m, resolveAgentConfig as n, resolveAgentSkillsFilter as o, DEFAULT_BOOTSTRAP_FILENAME as p, resolveAgentDir as r, resolveAgentWorkspaceDir as s, listAgentIds as t, resolveSessionAgentIds as u, DEFAULT_SOUL_FILENAME as v, resolveDefaultAgentWorkspaceDir as w, ensureAgentWorkspace as x, DEFAULT_TOOLS_FILENAME as y };