@noxsoft/anima 2.0.2 → 2.0.4

package/dist/sqlite-dzD-jMjs.js

@@ -0,0 +1,368 @@
+import { t as createSubsystemLogger } from "./subsystem-DfKstnEK.js";
+import { s as resolveSessionTranscriptsDirForAgent } from "./paths-BXQQzXGQ.js";
+import { n as redactSensitiveText } from "./redact-BHmk44DI.js";
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+import fs$1 from "node:fs/promises";
+import crypto from "node:crypto";
+
+//#region src/memory/internal.ts
+function ensureDir(dir) {
+	try {
+		fs.mkdirSync(dir, { recursive: true });
+	} catch {}
+	return dir;
+}
+function normalizeRelPath(value) {
+	return value.trim().replace(/^[./]+/, "").replace(/\\/g, "/");
+}
+function normalizeExtraMemoryPaths(workspaceDir, extraPaths) {
+	if (!extraPaths?.length) return [];
+	const resolved = extraPaths.map((value) => value.trim()).filter(Boolean).map((value) => path.isAbsolute(value) ? path.resolve(value) : path.resolve(workspaceDir, value));
+	return Array.from(new Set(resolved));
+}
+function isMemoryPath(relPath) {
+	const normalized = normalizeRelPath(relPath);
+	if (!normalized) return false;
+	if (normalized === "MEMORY.md" || normalized === "memory.md") return true;
+	return normalized.startsWith("memory/");
+}
+async function walkDir(dir, files) {
+	const entries = await fs$1.readdir(dir, { withFileTypes: true });
+	for (const entry of entries) {
+		const full = path.join(dir, entry.name);
+		if (entry.isSymbolicLink()) continue;
+		if (entry.isDirectory()) {
+			await walkDir(full, files);
+			continue;
+		}
+		if (!entry.isFile()) continue;
+		if (!entry.name.endsWith(".md")) continue;
+		files.push(full);
+	}
+}
+async function listMemoryFiles(workspaceDir, extraPaths) {
+	const result = [];
+	const memoryFile = path.join(workspaceDir, "MEMORY.md");
+	const altMemoryFile = path.join(workspaceDir, "memory.md");
+	const memoryDir = path.join(workspaceDir, "memory");
+	const addMarkdownFile = async (absPath) => {
+		try {
+			const stat = await fs$1.lstat(absPath);
+			if (stat.isSymbolicLink() || !stat.isFile()) return;
+			if (!absPath.endsWith(".md")) return;
+			result.push(absPath);
+		} catch {}
+	};
+	await addMarkdownFile(memoryFile);
+	await addMarkdownFile(altMemoryFile);
+	try {
+		const dirStat = await fs$1.lstat(memoryDir);
+		if (!dirStat.isSymbolicLink() && dirStat.isDirectory()) await walkDir(memoryDir, result);
+	} catch {}
+	const normalizedExtraPaths = normalizeExtraMemoryPaths(workspaceDir, extraPaths);
+	if (normalizedExtraPaths.length > 0) for (const inputPath of normalizedExtraPaths) try {
+		const stat = await fs$1.lstat(inputPath);
+		if (stat.isSymbolicLink()) continue;
+		if (stat.isDirectory()) {
+			await walkDir(inputPath, result);
+			continue;
+		}
+		if (stat.isFile() && inputPath.endsWith(".md")) result.push(inputPath);
+	} catch {}
+	if (result.length <= 1) return result;
+	const seen = /* @__PURE__ */ new Set();
+	const deduped = [];
+	for (const entry of result) {
+		let key = entry;
+		try {
+			key = await fs$1.realpath(entry);
+		} catch {}
+		if (seen.has(key)) continue;
+		seen.add(key);
+		deduped.push(entry);
+	}
+	return deduped;
+}
+function hashText(value) {
+	return crypto.createHash("sha256").update(value).digest("hex");
+}
+async function buildFileEntry(absPath, workspaceDir) {
+	const stat = await fs$1.stat(absPath);
+	const hash = hashText(await fs$1.readFile(absPath, "utf-8"));
+	return {
+		path: path.relative(workspaceDir, absPath).replace(/\\/g, "/"),
+		absPath,
+		mtimeMs: stat.mtimeMs,
+		size: stat.size,
+		hash
+	};
+}
+function chunkMarkdown(content, chunking) {
+	const lines = content.split("\n");
+	if (lines.length === 0) return [];
+	const maxChars = Math.max(32, chunking.tokens * 4);
+	const overlapChars = Math.max(0, chunking.overlap * 4);
+	const chunks = [];
+	let current = [];
+	let currentChars = 0;
+	const flush = () => {
+		if (current.length === 0) return;
+		const firstEntry = current[0];
+		const lastEntry = current[current.length - 1];
+		if (!firstEntry || !lastEntry) return;
+		const text = current.map((entry) => entry.line).join("\n");
+		const startLine = firstEntry.lineNo;
+		const endLine = lastEntry.lineNo;
+		chunks.push({
+			startLine,
+			endLine,
+			text,
+			hash: hashText(text)
+		});
+	};
+	const carryOverlap = () => {
+		if (overlapChars <= 0 || current.length === 0) {
+			current = [];
+			currentChars = 0;
+			return;
+		}
+		let acc = 0;
+		const kept = [];
+		for (let i = current.length - 1; i >= 0; i -= 1) {
+			const entry = current[i];
+			if (!entry) continue;
+			acc += entry.line.length + 1;
+			kept.unshift(entry);
+			if (acc >= overlapChars) break;
+		}
+		current = kept;
+		currentChars = kept.reduce((sum, entry) => sum + entry.line.length + 1, 0);
+	};
+	for (let i = 0; i < lines.length; i += 1) {
+		const line = lines[i] ?? "";
+		const lineNo = i + 1;
+		const segments = [];
+		if (line.length === 0) segments.push("");
+		else for (let start = 0; start < line.length; start += maxChars) segments.push(line.slice(start, start + maxChars));
+		for (const segment of segments) {
+			const lineSize = segment.length + 1;
+			if (currentChars + lineSize > maxChars && current.length > 0) {
+				flush();
+				carryOverlap();
+			}
+			current.push({
+				line: segment,
+				lineNo
+			});
+			currentChars += lineSize;
+		}
+	}
+	flush();
+	return chunks;
+}
+/**
+* Remap chunk startLine/endLine from content-relative positions to original
+* source file positions using a lineMap.  Each entry in lineMap gives the
+* 1-indexed source line for the corresponding 0-indexed content line.
+*
+* This is used for session JSONL files where buildSessionEntry() flattens
+* messages into a plain-text string before chunking.  Without remapping the
+* stored line numbers would reference positions in the flattened text rather
+* than the original JSONL file.
+*/
+function remapChunkLines(chunks, lineMap) {
+	if (!lineMap || lineMap.length === 0) return;
+	for (const chunk of chunks) {
+		chunk.startLine = lineMap[chunk.startLine - 1] ?? chunk.startLine;
+		chunk.endLine = lineMap[chunk.endLine - 1] ?? chunk.endLine;
+	}
+}
+function parseEmbedding(raw) {
+	try {
+		const parsed = JSON.parse(raw);
+		return Array.isArray(parsed) ? parsed : [];
+	} catch {
+		return [];
+	}
+}
+function cosineSimilarity(a, b) {
+	if (a.length === 0 || b.length === 0) return 0;
+	const len = Math.min(a.length, b.length);
+	let dot = 0;
+	let normA = 0;
+	let normB = 0;
+	for (let i = 0; i < len; i += 1) {
+		const av = a[i] ?? 0;
+		const bv = b[i] ?? 0;
+		dot += av * bv;
+		normA += av * av;
+		normB += bv * bv;
+	}
+	if (normA === 0 || normB === 0) return 0;
+	return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+async function runWithConcurrency(tasks, limit) {
+	if (tasks.length === 0) return [];
+	const resolvedLimit = Math.max(1, Math.min(limit, tasks.length));
+	const results = Array.from({ length: tasks.length });
+	let next = 0;
+	let firstError = null;
+	const workers = Array.from({ length: resolvedLimit }, async () => {
+		while (true) {
+			if (firstError) return;
+			const index = next;
+			next += 1;
+			if (index >= tasks.length) return;
+			try {
+				results[index] = await tasks[index]();
+			} catch (err) {
+				firstError = err;
+				return;
+			}
+		}
+	});
+	await Promise.allSettled(workers);
+	if (firstError) throw firstError;
+	return results;
+}
+
+//#endregion
+//#region src/memory/session-files.ts
+const log = createSubsystemLogger("memory");
+async function listSessionFilesForAgent(agentId) {
+	const dir = resolveSessionTranscriptsDirForAgent(agentId);
+	try {
+		return (await fs$1.readdir(dir, { withFileTypes: true })).filter((entry) => entry.isFile()).map((entry) => entry.name).filter((name) => name.endsWith(".jsonl")).map((name) => path.join(dir, name));
+	} catch {
+		return [];
+	}
+}
+function sessionPathForFile(absPath) {
+	return path.join("sessions", path.basename(absPath)).replace(/\\/g, "/");
+}
+function normalizeSessionText(value) {
+	return value.replace(/\s*\n+\s*/g, " ").replace(/\s+/g, " ").trim();
+}
+function extractSessionText(content) {
+	if (typeof content === "string") {
+		const normalized = normalizeSessionText(content);
+		return normalized ? normalized : null;
+	}
+	if (!Array.isArray(content)) return null;
+	const parts = [];
+	for (const block of content) {
+		if (!block || typeof block !== "object") continue;
+		const record = block;
+		if (record.type !== "text" || typeof record.text !== "string") continue;
+		const normalized = normalizeSessionText(record.text);
+		if (normalized) parts.push(normalized);
+	}
+	if (parts.length === 0) return null;
+	return parts.join(" ");
+}
+async function buildSessionEntry(absPath) {
+	try {
+		const stat = await fs$1.stat(absPath);
+		const lines = (await fs$1.readFile(absPath, "utf-8")).split("\n");
+		const collected = [];
+		const lineMap = [];
+		for (let jsonlIdx = 0; jsonlIdx < lines.length; jsonlIdx++) {
+			const line = lines[jsonlIdx];
+			if (!line.trim()) continue;
+			let record;
+			try {
+				record = JSON.parse(line);
+			} catch {
+				continue;
+			}
+			if (!record || typeof record !== "object" || record.type !== "message") continue;
+			const message = record.message;
+			if (!message || typeof message.role !== "string") continue;
+			if (message.role !== "user" && message.role !== "assistant") continue;
+			const text = extractSessionText(message.content);
+			if (!text) continue;
+			const safe = redactSensitiveText(text, { mode: "tools" });
+			const label = message.role === "user" ? "User" : "Assistant";
+			collected.push(`${label}: ${safe}`);
+			lineMap.push(jsonlIdx + 1);
+		}
+		const content = collected.join("\n");
+		return {
+			path: sessionPathForFile(absPath),
+			absPath,
+			mtimeMs: stat.mtimeMs,
+			size: stat.size,
+			hash: hashText(content + "\n" + lineMap.join(",")),
+			content,
+			lineMap
+		};
+	} catch (err) {
+		log.debug(`Failed reading session file ${absPath}: ${String(err)}`);
+		return null;
+	}
+}
+
+//#endregion
+//#region src/infra/warning-filter.ts
+const warningFilterKey = Symbol.for("anima.warning-filter");
+function shouldIgnoreWarning(warning) {
+	if (warning.code === "DEP0040" && warning.message?.includes("punycode")) return true;
+	if (warning.code === "DEP0060" && warning.message?.includes("util._extend")) return true;
+	if (warning.name === "ExperimentalWarning" && warning.message?.includes("SQLite is an experimental feature")) return true;
+	return false;
+}
+function normalizeWarningArgs(args) {
+	const warningArg = args[0];
+	const secondArg = args[1];
+	const thirdArg = args[2];
+	let name;
+	let code;
+	let message;
+	if (warningArg instanceof Error) {
+		name = warningArg.name;
+		message = warningArg.message;
+		code = warningArg.code;
+	} else if (typeof warningArg === "string") message = warningArg;
+	if (secondArg && typeof secondArg === "object" && !Array.isArray(secondArg)) {
+		const options = secondArg;
+		if (typeof options.type === "string") name = options.type;
+		if (typeof options.code === "string") code = options.code;
+	} else {
+		if (typeof secondArg === "string") name = secondArg;
+		if (typeof thirdArg === "string") code = thirdArg;
+	}
+	return {
+		name,
+		code,
+		message
+	};
+}
+function installProcessWarningFilter() {
+	const globalState = globalThis;
+	if (globalState[warningFilterKey]?.installed) return;
+	const originalEmitWarning = process.emitWarning.bind(process);
+	const wrappedEmitWarning = ((...args) => {
+		if (shouldIgnoreWarning(normalizeWarningArgs(args))) return;
+		return Reflect.apply(originalEmitWarning, process, args);
+	});
+	process.emitWarning = wrappedEmitWarning;
+	globalState[warningFilterKey] = { installed: true };
+}
+
+//#endregion
+//#region src/memory/sqlite.ts
+const require = createRequire(import.meta.url);
+function requireNodeSqlite() {
+	installProcessWarningFilter();
+	try {
+		return require("node:sqlite");
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		throw new Error(`SQLite support is unavailable in this Node runtime (missing node:sqlite). ${message}`, { cause: err });
+	}
+}
+
+//#endregion
+export { buildFileEntry as a, ensureDir as c, listMemoryFiles as d, normalizeExtraMemoryPaths as f, runWithConcurrency as h, sessionPathForFile as i, hashText as l, remapChunkLines as m, buildSessionEntry as n, chunkMarkdown as o, parseEmbedding as p, listSessionFilesForAgent as r, cosineSimilarity as s, requireNodeSqlite as t, isMemoryPath as u };

package/dist/start-Cu3aLoSf.js

@@ -0,0 +1,297 @@
+import "./paths-BMuHNFxg.js";
+import { c as formatNotification, i as colors, l as formatSuccess, n as banner, o as formatError, t as PROMPT } from "./display-A8k-mxv8.js";
+import { n as loadIdentity } from "./loader-Br7Vr0zn.js";
+import { t as HeartbeatEngine } from "./engine-Bk_UT413.js";
+import { t as SessionOrchestrator } from "./orchestrator-DlwVRVDA.js";
+import { t as BudgetTracker } from "./budget-CRpvqDRX.js";
+import "./registry-C5MAYD4V.js";
+import { n as syncConfig } from "./config-sync-DuydxPWx.js";
+import { t as RequestQueue } from "./queue-BJGo7kAB.js";
+import { a as isSVRNAvailable, i as SVRNNode, n as findCommand, r as loadSVRNConfig } from "./commands-BMnD_QRY.js";
+import { r as loadAutoUpdateConfig, t as AnimaAutoUpdater } from "./auto-update-CpF0fycd.js";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { createInterface } from "node:readline";
+
+//#region src/repl/interface.ts
+/**
+* ANIMA REPL Interface — the primary terminal interaction layer.
+*
+* Uses Node.js readline for input, with the NoxSoft aesthetic.
+* Non-command input (not starting with :) is queued as a task.
+* Provides real-time completion notifications and graceful shutdown.
+*/
+var AnimaRepl = class {
+	constructor(options) {
+		this.rl = null;
+		this.running = false;
+		this.processing = false;
+		const queue = options.queue || new RequestQueue();
+		this.ctx = {
+			orchestrator: options.orchestrator,
+			heartbeat: options.heartbeat,
+			queue,
+			budget: options.budget,
+			svrnNode: options.svrnNode,
+			updater: options.updater
+		};
+	}
+	/**
+	* Start the REPL. Shows banner, loads queue, begins input loop.
+	*/
+	async start() {
+		if (this.running) return;
+		this.running = true;
+		await this.ctx.queue.load();
+		const bannerText = banner((await loadIdentity()).soul.split("\n").find((l) => l.startsWith("#"))?.replace(/^#+\s*/, "") || "ANIMA", this.ctx.heartbeat.getBeatCount(), this.ctx.budget.getRemaining());
+		process.stdout.write(bannerText + "\n");
+		process.stdout.write(`${colors.muted}  Type anything to queue a task, or :help for commands.${colors.reset}\n\n`);
+		this.rl = createInterface({
+			input: process.stdin,
+			output: process.stdout,
+			prompt: PROMPT,
+			terminal: true
+		});
+		this.ctx.heartbeat.on("beat-complete", (result) => {
+			this.notify(`Heartbeat #${result.beatNumber} complete (${result.errors.length} errors)`);
+		});
+		this.ctx.heartbeat.on("beat-error", (data) => {
+			this.notify(`Heartbeat #${data.beatNumber} failed: ${data.error}`);
+		});
+		this.ctx.heartbeat.on("freedom-time", (data) => {
+			this.notify(`Freedom time triggered at beat #${data.beatNumber}`);
+		});
+		this.processQueue();
+		this.rl.on("line", (line) => {
+			this.handleInput(line.trim());
+		});
+		this.rl.on("close", () => {
+			this.shutdown();
+		});
+		const sigintHandler = () => {
+			process.stdout.write("\n");
+			this.shutdown();
+		};
+		process.once("SIGINT", sigintHandler);
+		this.rl.prompt();
+	}
+	/**
+	* Handle a line of input.
+	*/
+	async handleInput(line) {
+		if (!line) {
+			this.rl?.prompt();
+			return;
+		}
+		if (line.startsWith(":")) {
+			const parts = line.slice(1).split(/\s+/);
+			const cmdName = parts[0];
+			const args = parts.slice(1);
+			if (!cmdName) {
+				process.stdout.write(formatError("Empty command. Try :help") + "\n");
+				this.rl?.prompt();
+				return;
+			}
+			const command = findCommand(cmdName);
+			if (!command) {
+				process.stdout.write(formatError(`Unknown command: :${cmdName}. Try :help`) + "\n");
+				this.rl?.prompt();
+				return;
+			}
+			if (command.name === "shutdown") {
+				const result = await command.execute(args, this.ctx);
+				process.stdout.write(result + "\n");
+				this.shutdown();
+				return;
+			}
+			try {
+				const result = await command.execute(args, this.ctx);
+				process.stdout.write(result + "\n");
+			} catch (err) {
+				const msg = err instanceof Error ? err.message : String(err);
+				process.stdout.write(formatError(msg) + "\n");
+			}
+			this.rl?.prompt();
+			return;
+		}
+		const item = this.ctx.queue.enqueue(line, "normal", "repl");
+		process.stdout.write(formatSuccess(`Queued task ${item.id} (${item.priority})`) + "\n");
+		this.rl?.prompt();
+	}
+	/**
+	* Process queue items in background.
+	*/
+	async processQueue() {
+		while (this.running) {
+			if (!this.processing) {
+				const next = this.ctx.queue.dequeue();
+				if (next) {
+					this.processing = true;
+					this.ctx.queue.markRunning(next.id);
+					try {
+						const isFreedom = next.priority === "freedom";
+						let result;
+						if (isFreedom) result = await this.ctx.orchestrator.executeFreedom({
+							maxBudgetUsd: 5,
+							timeoutMs: 6e5
+						});
+						else result = await this.ctx.orchestrator.executeTask({
+							taskDescription: next.prompt,
+							maxBudgetUsd: 10,
+							timeoutMs: 6e5,
+							dangerouslySkipPermissions: true
+						});
+						this.ctx.queue.markCompleted(next.id, result.output);
+						this.notify(`Task ${next.id} completed (${result.status}, $${result.costUsd?.toFixed(2) || "?"})`);
+					} catch (err) {
+						const msg = err instanceof Error ? err.message : String(err);
+						this.ctx.queue.markFailed(next.id, msg);
+						this.notify(`Task ${next.id} failed: ${msg}`);
+					}
+					this.processing = false;
+					await this.ctx.queue.save();
+				}
+			}
+			await new Promise((resolve) => setTimeout(resolve, 2e3));
+		}
+	}
+	/**
+	* Show a notification on the terminal (without disrupting input).
+	*/
+	notify(msg) {
+		if (this.rl) {
+			process.stdout.write("\r\x1B[K");
+			process.stdout.write(formatNotification(msg));
+			this.rl.prompt(true);
+		}
+	}
+	/**
+	* Graceful shutdown.
+	*/
+	async shutdown() {
+		if (!this.running) return;
+		this.running = false;
+		process.stdout.write(`\n${colors.muted}  Saving state...${colors.reset}\n`);
+		this.ctx.heartbeat.stop();
+		if (this.ctx.updater) this.ctx.updater.stop();
+		if (this.ctx.svrnNode) await this.ctx.svrnNode.stop();
+		try {
+			await this.ctx.queue.save();
+			await this.ctx.budget.persist();
+		} catch {}
+		process.stdout.write(`${colors.accent}  Amor Fati.${colors.reset}\n\n`);
+		if (this.rl) {
+			this.rl.close();
+			this.rl = null;
+		}
+		process.exit(0);
+	}
+	/**
+	* Get the queue for external use.
+	*/
+	getQueue() {
+		return this.ctx.queue;
+	}
+};
+
+//#endregion
+//#region src/cli/start.ts
+/**
+* anima start — Start the ANIMA daemon with heartbeat + REPL.
+*
+* Startup sequence:
+* 1. Load identity from ~/.anima/soul/
+* 2. Initialize BudgetTracker with daily limit
+* 3. Initialize SessionOrchestrator with budget
+* 4. Sync MCP config to ~/.claude/mcp.json
+* 5. Initialize HeartbeatEngine with adaptive intervals
+* 6. Initialize RequestQueue
+* 7. Start heartbeat (async, runs first beat then schedules)
+* 8. Start SVRN node if enabled (compute contributor)
+* 9. Initialize auto-updater
+* 10. Print ANIMA boot banner with identity + budget + SVRN + update status
+* 11. Start AnimaRepl (unless --no-repl)
+* 12. Register SIGINT/SIGTERM handlers for graceful shutdown
+*/
+async function startDaemon(options = {}) {
+	const { noRepl = false, heartbeatInterval = 3e5, budget: dailyBudget = 200 } = options;
+	process.stdout.write(`${colors.muted}  Initializing ANIMA...${colors.reset}\n`);
+	const identityName = (await loadIdentity()).loadedFrom.SOUL === "user" ? "Opus (user)" : "Opus (template)";
+	process.stdout.write(`${colors.muted}  Identity loaded: ${identityName}${colors.reset}\n`);
+	const budget = new BudgetTracker({ dailyLimitUsd: dailyBudget });
+	await budget.load();
+	const orchestrator = new SessionOrchestrator(budget);
+	try {
+		const syncResult = await syncConfig();
+		const total = syncResult.added.length + syncResult.updated.length + syncResult.preserved.length;
+		process.stdout.write(`${colors.muted}  MCP: ${total} servers synced (${syncResult.added.length} added, ${syncResult.removed.length} removed)${colors.reset}\n`);
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		process.stderr.write(`${colors.warning}  MCP sync warning: ${msg}${colors.reset}\n`);
+	}
+	const heartbeat = new HeartbeatEngine(orchestrator, { intervalMs: heartbeatInterval });
+	const queue = new RequestQueue();
+	await queue.load();
+	process.stdout.write(`${colors.muted}  Starting heartbeat (interval: ${heartbeatInterval / 1e3}s)...${colors.reset}\n`);
+	heartbeat.start().catch((err) => {
+		const msg = err instanceof Error ? err.message : String(err);
+		process.stderr.write(`${colors.error}  Heartbeat start error: ${msg}${colors.reset}\n`);
+	});
+	const svrnConfig = await loadSVRNConfig();
+	let svrnNode;
+	if (!await isSVRNAvailable()) process.stdout.write(`${colors.muted}  SVRN Node: @noxsoft/svrn-node not installed (skipping)${colors.reset}\n`);
+	else {
+		svrnNode = new SVRNNode(svrnConfig);
+		await svrnNode.init();
+		if (svrnConfig.enabled) try {
+			await svrnNode.start();
+			const balance = svrnNode.getEarnings().getBalance();
+			process.stdout.write(`${colors.success}  SVRN Node: Active${colors.reset} ${colors.muted}|${colors.reset} ${colors.accent}Balance: ${balance.toFixed(3)} UCU${colors.reset} ${colors.muted}|${colors.reset} ${colors.muted}Node: ${svrnNode.getNodeId().slice(0, 8)}...${colors.reset}\n`);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			process.stderr.write(`${colors.warning}  SVRN node warning: ${msg}${colors.reset}\n`);
+		}
+		else process.stdout.write(`${colors.muted}  SVRN Node: Disabled (run \`anima svrn enable\` to earn UCU)${colors.reset}\n`);
+	}
+	const autoUpdateConfig = loadAutoUpdateConfig();
+	const updater = new AnimaAutoUpdater(autoUpdateConfig, join(homedir(), ".anima"));
+	if (autoUpdateConfig.enabled) {
+		updater.start();
+		const intervalLabel = `${autoUpdateConfig.checkIntervalHours}h`;
+		process.stdout.write(`${colors.muted}  Auto-update: ${colors.success}enabled${colors.reset} ${colors.muted}(checking every ${intervalLabel}, channel: ${autoUpdateConfig.channel})${colors.reset}\n`);
+		updater.on("update-available", (info) => {
+			process.stdout.write(`\n${colors.warning}  Update available: v${info.currentVersion} -> v${info.latestVersion}${colors.reset} ${colors.muted}(run \`anima self-update\` or \`:update install\` to install)${colors.reset}\n`);
+		});
+	} else process.stdout.write(`${colors.muted}  Auto-update: Disabled${colors.reset}\n`);
+	const budgetRemaining = budget.getRemaining();
+	process.stdout.write(banner(identityName, heartbeat.getBeatCount(), budgetRemaining));
+	process.stdout.write("\n");
+	if (!noRepl) await new AnimaRepl({
+		orchestrator,
+		heartbeat,
+		budget,
+		queue,
+		svrnNode,
+		updater
+	}).start();
+	else {
+		process.stdout.write(`${colors.success}  ANIMA running in headless mode.${colors.reset}\n`);
+		process.stdout.write(`${colors.muted}  Heartbeat active. Press Ctrl+C to stop.${colors.reset}\n`);
+		const shutdown = async () => {
+			process.stdout.write(`\n${colors.muted}  Shutting down...${colors.reset}\n`);
+			heartbeat.stop();
+			updater.stop();
+			if (svrnNode) await svrnNode.stop();
+			await queue.save();
+			await budget.persist();
+			process.stdout.write(`${colors.accent}  Amor Fati.${colors.reset}\n`);
+			process.exit(0);
+		};
+		process.on("SIGINT", shutdown);
+		process.on("SIGTERM", shutdown);
+		setInterval(() => {}, 6e4).unref();
+	}
+}
+
+//#endregion
+export { startDaemon };