piclaw 0.0.19 → 0.0.21

package/.output/server/_chunks/server.mjs

@@ -1,27 +1,1943 @@
+import { o as __toESM, r as __exportAll } from "../_runtime.mjs";
 import { i as SESSIONS_DIR, n as GROUPS_DIR, r as MAIN_GROUP_FOLDER, s as config } from "./config.mjs";
 import { t as createLogger } from "./logger.mjs";
-import { C as setSession, D as updateTaskAfterRun, S as setRouterState, T as storeMessage, _ as removeRegisteredGroup, b as setConfig, d as getMessagesSince, f as getNewMessages, g as logTaskRun, h as initDatabase, i as deleteConfig, l as getConfig, m as getTaskById, o as getAllRegisteredGroups, p as getRouterState, r as deleteChat, s as getAllSessions, u as getDueTasks, v as removeSession, w as storeChatMetadata, x as setRegisteredGroup, y as removeTasksByChat } from "./db.mjs";
+import { C as setSession, D as updateTaskAfterRun, S as setRouterState, T as storeMessage, _ as removeRegisteredGroup, b as setConfig, c as getAllTasks, d as getMessagesSince, f as getNewMessages, g as logTaskRun, h as initDatabase, i as deleteConfig, l as getConfig, m as getTaskById, o as getAllRegisteredGroups, p as getRouterState, r as deleteChat, s as getAllSessions, t as clearMessages, u as getDueTasks, v as removeSession, w as storeChatMetadata, x as setRegisteredGroup, y as removeTasksByChat } from "./db.mjs";
+import { a as createWriteTool, c as createBashTool, d as stripAnsi$1, i as AuthStorage, l as SessionManager, n as DefaultResourceLoader, o as createReadTool, r as ModelRegistry, s as createEditTool, t as createAgentSession, u as SettingsManager } from "../_libs/@mariozechner/pi-coding-agent+[...].mjs";
 import { n as parseAST, t as init } from "../_libs/md4x.mjs";
 import { t as streamBus } from "./stream.mjs";
-import { a as resolveGroupModel } from "./session.mjs";
+import { h as Type } from "../_libs/@mariozechner/pi-agent-core+[...].mjs";
+import { t as deviceBus } from "./device-bus.mjs";
+import { n as setBrowserState, t as getBrowserState } from "./browser.mjs";
+import { i as writeNote, n as listNotes, r as readNote, t as deleteNote } from "./notes.mjs";
+import { n as getNtfyConfig, r as sendNtfyNotification } from "./ntfy.mjs";
 import { t as terminalManager } from "./terminal.mjs";
-import { n as pi_exports } from "./pi.mjs";
-import { i as tryPriorityCommand, n as tryBashCommand, r as tryCommand, t as commandDescriptions } from "./commands.mjs";
+import { t as sandboxManager } from "./sandbox.mjs";
+import { a as saveAttachment, i as readAttachmentBase64, n as getMimeType, r as isImageMimeType } from "./uploads.mjs";
 import { i as tunnelManager, n as getTunnelConfig, r as setTunnelConfig, t as clearTunnelConfig } from "./tunnel.mjs";
 import fs from "fs";
 import path from "path";
 import fs$1 from "node:fs";
 import path$1 from "node:path";
 import crypto from "node:crypto";
+import fs$2 from "node:fs/promises";
+import os from "node:os";
+import "node:child_process";
+function appendGroupEvent(folder, event) {
+	try {
+		const logsDir = path$1.join(GROUPS_DIR, folder, "logs");
+		fs$1.mkdirSync(logsDir, { recursive: true });
+		const line = JSON.stringify({
+			ts: (/* @__PURE__ */ new Date()).toISOString(),
+			...event
+		}) + "\n";
+		fs$1.appendFileSync(path$1.join(logsDir, "events.jsonl"), line, "utf-8");
+	} catch {}
+}
+/**
+* Extract readable text from a Pi SDK tool result.
+* Handles `{ content: [{ type: "text", text }] }` objects, JSON strings, and plain strings.
+* Strips ANSI/control chars and truncates.
+*/
+function extractToolResultText(value, maxLength = 200) {
+	let text = "";
+	if (typeof value === "string") try {
+		text = _textFromParsed(JSON.parse(value)) ?? value;
+	} catch {
+		text = value.match(/"text"\s*:\s*"((?:[^"\\]|\\.)*)(?:"|$)/)?.[1]?.replaceAll("\\n", "\n").replaceAll("\\t", "	").replaceAll("\\\"", "\"") ?? value;
+	}
+	else if (value && typeof value === "object") text = _textFromParsed(value) ?? JSON.stringify(value);
+	if (!text) return "";
+	text = stripAnsi$1(text).trim();
+	if (text.length > maxLength) return text.slice(0, maxLength) + "…";
+	return text;
+}
+function _textFromParsed(obj) {
+	if (!obj || typeof obj !== "object") return void 0;
+	const rec = obj;
+	if (Array.isArray(rec.content)) {
+		const first = rec.content[0];
+		if (first?.text && typeof first.text === "string") return first.text;
+	}
+}
+var availableCommands;
+async function getSystemInfo() {
+	const info = {
+		os: process.platform,
+		arch: process.arch,
+		nodeVersion: process.versions.node,
+		runtime: _getRuntime(),
+		freeMemory: os.freemem(),
+		totalMemory: os.totalmem(),
+		uptime: os.uptime()
+	};
+	if (process.platform === "linux") {
+		info.linuxDistro = await _getLinuxDistro();
+		info.isDocker = await _isDocker();
+	}
+	info.availableDiskSpace = await _getAvailableDiskSpace();
+	info.availableCommands = availableCommands ??= await _getAvailableCommands();
+	info.processMemory = process.memoryUsage().rss;
+	return info;
+}
+async function getSystemInfoText() {
+	const info = await getSystemInfo();
+	const lines = [];
+	let osLine = `${info.os} ${info.arch}`;
+	if (info.linuxDistro) osLine += ` (${info.linuxDistro})`;
+	if (info.isDocker) osLine += ` [Docker]`;
+	lines.push(`OS: ${osLine}`);
+	if (info.runtime) lines.push(`Runtime: ${info.runtime}`);
+	if (info.freeMemory != null && info.totalMemory != null) {
+		const fmt = (b) => `${(b / 1024 / 1024 / 1024).toFixed(1)}GB`;
+		let memLine = `Memory: ${fmt(info.freeMemory)} free / ${fmt(info.totalMemory)} total`;
+		if (info.processMemory != null) {
+			const mb = (info.processMemory / 1024 / 1024).toFixed(0);
+			memLine += ` (process: ${mb}MB)`;
+		}
+		lines.push(memLine);
+	}
+	if (info.availableDiskSpace != null) lines.push(`Disk: ${(info.availableDiskSpace / 1024 / 1024 / 1024).toFixed(1)}GB available`);
+	return lines.map((l) => `- ${l}`).join("\n");
+}
+function _getRuntime() {
+	if ("Bun" in globalThis) return `bun v${globalThis.Bun.version}`;
+	if ("Deno" in globalThis) return `deno v${globalThis.Deno.version.deno}`;
+	return `node v${process.versions.node}`;
+}
+async function _getLinuxDistro() {
+	try {
+		return (await fs$2.readFile("/etc/os-release", "utf8")).match(/^PRETTY_NAME="?(.+?)"?\s*$/m)?.[1] ?? null;
+	} catch {
+		return null;
+	}
+}
+async function _isDocker() {
+	try {
+		await fs$2.access("/.dockerenv");
+		return true;
+	} catch {
+		try {
+			const cgroup = await fs$2.readFile("/proc/1/cgroup", "utf8");
+			return cgroup.includes("docker") || cgroup.includes("containerd");
+		} catch {
+			return false;
+		}
+	}
+}
+async function _getAvailableCommands() {
+	try {
+		const pathEnv = process.env.PATH;
+		if (!pathEnv) return void 0;
+		const dirs = [...new Set(pathEnv.split(":"))];
+		const commands = /* @__PURE__ */ new Set();
+		await Promise.all(dirs.map(async (dir) => {
+			try {
+				const entries = await fs$2.readdir(dir);
+				for (const entry of entries) commands.add(entry);
+			} catch {}
+		}));
+		return [...commands].sort();
+	} catch {
+		return;
+	}
+}
+async function _getAvailableDiskSpace() {
+	try {
+		const stats = await fs$2.statfs("/");
+		return stats.bsize * stats.bavail;
+	} catch {
+		return null;
+	}
+}
+var logger$6 = createLogger("pi");
+function sendPrompt(managed, group, input, onOutput) {
+	return new Promise((resolve) => {
+		const { session } = managed;
+		let fullText = "";
+		let thinkingText = "";
+		let resolved = false;
+		let flushedTextLength = 0;
+		/** Chronologically ordered raw items (thinking text + tool markers) flushed as single toggle */
+		const pendingItems = [];
+		let outputChain = Promise.resolve();
+		const timeout = setTimeout(() => {
+			if (resolved) return;
+			resolved = true;
+			logger$6.error({ group: group.name }, "Agent timeout");
+			appendGroupEvent(group.folder, {
+				type: "error",
+				reason: "timeout"
+			});
+			streamBus.emit({
+				type: "error",
+				chatJid: input.chatJid,
+				error: "Agent timeout"
+			});
+			session.abort().catch(() => {});
+			resolve({
+				status: "error",
+				result: fullText || null,
+				newSessionId: session.sessionId,
+				error: "Agent timeout"
+			});
+		}, config.get("agentTimeout"));
+		const finish = (status, error) => {
+			if (resolved) return;
+			resolved = true;
+			clearTimeout(timeout);
+			clearInterval(abortCheck);
+			outputChain.then(() => {
+				resolveAbortDone?.();
+				resolve({
+					status,
+					result: fullText || null,
+					newSessionId: session.sessionId,
+					error
+				});
+			});
+		};
+		let unsubscribe;
+		let resolveAbortDone;
+		managed.abortDone = new Promise((r) => {
+			resolveAbortDone = r;
+		});
+		const abortCheck = setInterval(() => {
+			if (managed.aborted && !resolved) {
+				clearInterval(abortCheck);
+				unsubscribe?.();
+				const unflushed = fullText.slice(flushedTextLength);
+				const jid = input.chatJid;
+				if (onOutput) {
+					const parts = [];
+					if (thinkingText) {
+						pendingItems.push(thinkingText);
+						thinkingText = "";
+					}
+					if (pendingItems.length) parts.push(flushPendingItems(pendingItems));
+					if (unflushed) parts.push(unflushed);
+					const partial = parts.length ? parts.join("\n\n") : null;
+					outputChain = outputChain.then(async () => {
+						await onOutput({
+							status: "success",
+							result: partial ? partial + "\n\n_(stopped)_" : "_(stopped)_",
+							newSessionId: session.sessionId
+						});
+						if (partial) streamBus.emit({
+							type: "text_end",
+							chatJid: jid,
+							content: partial
+						});
+					});
+				}
+				outputChain = outputChain.then(() => {
+					streamBus.emit({
+						type: "agent_end",
+						chatJid: jid
+					});
+					resolveAbortDone?.();
+				});
+				finish("stopped", "Session stopped by user");
+			}
+		}, 200);
+		unsubscribe = session.subscribe((event) => {
+			if (resolved) {
+				clearInterval(abortCheck);
+				return;
+			}
+			const jid = input.chatJid;
+			switch (event.type) {
+				case "message_update": {
+					const ae = event.assistantMessageEvent;
+					if (ae.type === "text_delta" && "delta" in ae) {
+						fullText += ae.delta;
+						streamBus.emit({
+							type: "text_delta",
+							chatJid: jid,
+							delta: ae.delta
+						});
+					}
+					if (ae.type === "text_end" && "content" in ae && onOutput) {
+						const text = ae.content;
+						const parts = [];
+						if (thinkingText) {
+							pendingItems.push(thinkingText);
+							thinkingText = "";
+						}
+						if (pendingItems.length) parts.push(flushPendingItems(pendingItems));
+						parts.push(text);
+						const stored = parts.join("\n\n");
+						appendGroupEvent(group.folder, {
+							type: "text_end",
+							length: stored.length,
+							preview: stored.slice(0, 100)
+						});
+						outputChain = outputChain.then(async () => {
+							await onOutput({
+								status: "success",
+								result: stored,
+								newSessionId: session.sessionId
+							});
+							flushedTextLength = fullText.length;
+							streamBus.emit({
+								type: "text_end",
+								chatJid: jid,
+								content: stored
+							});
+						});
+					}
+					if (ae.type === "thinking_delta" && "delta" in ae) {
+						thinkingText += ae.delta;
+						streamBus.emit({
+							type: "thinking_delta",
+							chatJid: jid,
+							delta: ae.delta
+						});
+					}
+					if (ae.type === "thinking_end" && "content" in ae) {
+						if (thinkingText) {
+							pendingItems.push(thinkingText);
+							thinkingText = "";
+						}
+						streamBus.emit({
+							type: "thinking_end",
+							chatJid: jid,
+							content: ae.content
+						});
+					}
+					break;
+				}
+				case "agent_end":
+					unsubscribe();
+					appendGroupEvent(group.folder, { type: "agent_end" });
+					streamBus.emit({
+						type: "agent_end",
+						chatJid: jid
+					});
+					finish("success");
+					break;
+				case "tool_execution_start":
+					logger$6.debug({
+						group: group.name,
+						tool: event.toolName,
+						toolCallId: event.toolCallId,
+						argsPreview: previewForLog(event.args)
+					}, "Tool execution started");
+					appendGroupEvent(group.folder, {
+						type: "tool_start",
+						tool: event.toolName,
+						toolCallId: event.toolCallId,
+						argsPreview: previewForLog(event.args, 200)
+					});
+					streamBus.emit({
+						type: "tool_start",
+						chatJid: jid,
+						toolName: event.toolName
+					});
+					break;
+				case "tool_execution_update":
+					logger$6.debug({
+						group: group.name,
+						tool: event.toolName,
+						toolCallId: event.toolCallId,
+						partialResultPreview: previewForLog(event.partialResult)
+					}, "Tool execution update");
+					break;
+				case "tool_execution_end": {
+					const payload = {
+						group: group.name,
+						tool: event.toolName,
+						toolCallId: event.toolCallId,
+						isError: event.isError,
+						resultPreview: previewForLog(event.result)
+					};
+					if (event.isError) logger$6.debug(payload, "Tool execution error");
+					else logger$6.debug(payload, "Tool execution finished");
+					appendGroupEvent(group.folder, {
+						type: "tool_end",
+						tool: event.toolName,
+						toolCallId: event.toolCallId,
+						isError: event.isError,
+						resultPreview: previewForLog(event.result, 200)
+					});
+					const cleanPreview = extractToolResultText(event.result) || void 0;
+					pendingItems.push(toToolMarker(event.toolName, event.isError, cleanPreview));
+					streamBus.emit({
+						type: "tool_end",
+						chatJid: jid,
+						toolName: event.toolName,
+						isError: event.isError,
+						resultPreview: cleanPreview
+					});
+					break;
+				}
+			}
+		});
+		session.prompt(input.prompt, { images: input.images?.length ? input.images : void 0 }).catch((err) => {
+			unsubscribe();
+			const reason = err instanceof Error ? err.message : String(err);
+			logger$6.error({
+				group: group.name,
+				err
+			}, "Prompt error");
+			appendGroupEvent(group.folder, {
+				type: "error",
+				reason
+			});
+			streamBus.emit({
+				type: "error",
+				chatJid: input.chatJid,
+				error: reason
+			});
+			finish("error", reason);
+		});
+	});
+}
+var baseSystemPrompt = `
+You live in your own OS and help your human with tasks.
+
+Available tools:
+- read: Read file contents
+- bash: Execute shell commands (ls, rg, find, curl, etc.)
+- edit: Make precise text replacements in existing files
+- write: Create or fully overwrite files
+- notes: Read/write/list/delete markdown notes by category — shared across all agents
+- notify: Send notifications to user
+- terminal: Manage persistent terminal sessions with pty support
+- browser: Open, navigate, switch, and close browser tabs in the admin UI
+- message: Send a message to another group's agent by folder name
+
+Execution rules:
+- You operate directly in your own OS/workspace environment autonomously; you do not need to ask for permission to run bash commands; users do not know how to run commands you do it for them.
+- Use tools proactively to do the work; do not just describe what should be done.
+- Use bash for operations (searching, building, testing, git-aware inspection).
+- Use terminal for long running processes such as dev server or tmux.
+- Do not use cat/sed/awk to read files use read tool instead.
+- IMPORTANT: Always read a file before editing it. The edit tool requires an exact match of existing text — if you guess the content, it will fail. Read first, then copy the exact text to replace.
+- Open browser tabs only when explicitly asked.
+- Prefer edit for targeted changes; use write for new files or full rewrites.
+- Use notify tool as a secondary channel to send important info to the user and for anything  you can't send in chat. Do not repeat chat messages in notifications.
+- Summarize results in plain text; do not print summaries via bash commands.
+- Be concise, explicit, and include file paths when referencing changes.
+- For thinking/planning notes in your response, use blockquote syntax (> ...) not bold (**...**). Example: "> Planning server conversion steps" instead of "**Planning server conversion steps**".
+- Ask a short clarification question when requirements are ambiguous or risky.
+- never say "Use this command", you can just execute commands using bash tool.
+- always write necessary info to AGENTS.md, it is your own private memory (do not ask user to do it).
+- Keep AGENTS.md concise: when it gets long, compact older entries into brief summaries while preserving key decisions, current state, and open tasks.
+- Do not mention AGENTS.md updates in normal replies unless the user explicitly asks about memory/log updates.
+- Use notes tool for persistent, non-task-specific information that should be shared across all agents (e.g. user preferences, reference material, reusable snippets). AGENTS.md is for your private context; notes are global memory.
+`;
+async function buildSystemPrompt(ctx) {
+	let prompt = `${ctx.soul ? ctx.soul.trim() : `You are ${ctx.assistantName}, an expert assistant.`}
+
+  ${baseSystemPrompt}
+
+Current model name: ${ctx.modelName}
+`;
+	const envInfo = await getSystemInfoText().catch((err) => {
+		logger$6.debug({ err }, "Failed to get system info");
+		return null;
+	});
+	if (envInfo) prompt += `\n\nEnvironment:\n${envInfo}`;
+	return prompt;
+}
+function previewForLog(value, maxLength = 1200) {
+	try {
+		const text = typeof value === "string" ? value : JSON.stringify(value);
+		if (!text) return "";
+		if (text.length <= maxLength) return text;
+		return `${text.slice(0, maxLength)}…(truncated ${text.length - maxLength} chars)`;
+	} catch {
+		return "[unserializable value]";
+	}
+}
+/** Flush all pending items (thinking text + tool markers) into a single collapsible block */
+function flushPendingItems(items) {
+	return `<details><summary>thinking</summary>\n\n${items.splice(0).join("\n\n")}\n\n</details>`;
+}
+/** Build an inline tool marker tag */
+function toToolMarker(name, isError, preview) {
+	return `<tool name="${name}" status="${isError ? "error" : "ok"}"${preview ? ` preview="${preview.replaceAll("\"", "&quot;")}"` : ""}/>`;
+}
+const browserTool = {
+	name: "browser",
+	label: "Browser",
+	description: [
+		"Control the browser window tabs.",
+		"Actions: list (show open tabs and active tab),",
+		"open (open a new tab, optionally with a URL),",
+		"navigate (change URL of a tab), switch (activate a tab), close (close a tab)."
+	].join(" "),
+	promptSnippet: "browser: Open, navigate, switch, and close browser tabs in the admin UI",
+	promptGuidelines: [
+		"Use the browser tool to open web pages in the admin browser window.",
+		"Use list to see current tabs before operating on them.",
+		"Tab IDs are integers — get them from list output."
+	],
+	parameters: Type.Object({
+		action: Type.Union([
+			Type.Literal("list"),
+			Type.Literal("open"),
+			Type.Literal("close"),
+			Type.Literal("navigate"),
+			Type.Literal("switch")
+		], { description: "Action to perform" }),
+		url: Type.Optional(Type.String({ description: "URL for open/navigate actions (http/https)" })),
+		tabId: Type.Optional(Type.Number({ description: "Tab ID for close/navigate/switch actions" }))
+	}),
+	async execute(_toolCallId, params) {
+		const p = params;
+		switch (p.action) {
+			case "list": return handleList$2();
+			case "open": return handleOpen(p);
+			case "close": return handleClose(p);
+			case "navigate": return handleNavigate(p);
+			case "switch": return handleSwitch(p);
+			default: return err$4(`Unknown action: ${p.action}`);
+		}
+	}
+};
+function handleList$2() {
+	const state = getBrowserState();
+	if (state.tabs.length === 0) return ok$3("No browser tabs open.");
+	return ok$3(`Browser tabs:\n${state.tabs.map((t) => `- [${t.id}]${t.id === state.activeTabId ? " (active)" : ""} ${t.url || "(empty)"}`).join("\n")}`, {
+		tabs: state.tabs,
+		activeTabId: state.activeTabId
+	});
+}
+function handleOpen(p) {
+	const state = getBrowserState();
+	const id = Math.max(0, ...state.tabs.map((t) => t.id)) + 1;
+	setBrowserState({
+		tabs: [...state.tabs, {
+			id,
+			url: p.url || ""
+		}],
+		activeTabId: id
+	});
+	return ok$3(`Opened tab ${id}${p.url ? ` at ${p.url}` : ""}.`, { tabId: id });
+}
+function handleClose(p) {
+	if (p.tabId == null) return err$4("tabId is required for close");
+	const state = getBrowserState();
+	const idx = state.tabs.findIndex((t) => t.id === p.tabId);
+	if (idx < 0) return err$4(`Tab ${p.tabId} not found`);
+	const tabs = state.tabs.filter((t) => t.id !== p.tabId);
+	let activeTabId = state.activeTabId;
+	if (activeTabId === p.tabId) activeTabId = tabs[Math.min(idx, tabs.length - 1)]?.id ?? null;
+	setBrowserState({
+		tabs,
+		activeTabId
+	});
+	return ok$3(`Closed tab ${p.tabId}.`, { tabId: p.tabId });
+}
+function handleNavigate(p) {
+	if (p.tabId == null) return err$4("tabId is required for navigate");
+	if (!p.url) return err$4("url is required for navigate");
+	const state = getBrowserState();
+	if (!state.tabs.find((t) => t.id === p.tabId)) return err$4(`Tab ${p.tabId} not found`);
+	setBrowserState({
+		tabs: state.tabs.map((t) => t.id === p.tabId ? {
+			...t,
+			url: p.url
+		} : t),
+		activeTabId: state.activeTabId
+	});
+	return ok$3(`Navigated tab ${p.tabId} to ${p.url}.`, {
+		tabId: p.tabId,
+		url: p.url
+	});
+}
+function handleSwitch(p) {
+	if (p.tabId == null) return err$4("tabId is required for switch");
+	const state = getBrowserState();
+	if (!state.tabs.some((t) => t.id === p.tabId)) return err$4(`Tab ${p.tabId} not found`);
+	setBrowserState({
+		tabs: state.tabs,
+		activeTabId: p.tabId
+	});
+	return ok$3(`Switched to tab ${p.tabId}.`, { tabId: p.tabId });
+}
+function ok$3(text, details) {
+	return {
+		content: [{
+			type: "text",
+			text
+		}],
+		details: {
+			ok: true,
+			...details
+		}
+	};
+}
+function err$4(text) {
+	return {
+		content: [{
+			type: "text",
+			text
+		}],
+		details: {
+			ok: false,
+			isError: true
+		}
+	};
+}
+function createMessageTool(callerGroupFolder) {
+	return {
+		name: "message",
+		label: "Message",
+		description: [
+			"Send a message to another registered group's agent.",
+			"The message appears in the target group's chat and triggers the target agent to process it.",
+			"Use 'folder' to identify the target group."
+		].join(" "),
+		promptSnippet: "message: Send a message to another group's agent by folder name",
+		promptGuidelines: [
+			"Use 'message' to delegate work or coordinate with another group's agent.",
+			"Specify the 'folder' (not display name) of the target group.",
+			"The receiving agent sees the message as if it came from you."
+		],
+		parameters: Type.Object({
+			folder: Type.String({ description: "Target group folder name" }),
+			content: Type.String({ description: "Message content to send" })
+		}),
+		async execute(_toolCallId, params) {
+			const p = params;
+			if (!server) return err$3("Server not available");
+			const groups = server.getRegisteredGroups();
+			const targetEntry = Object.entries(groups).find(([, g]) => g.folder === p.folder);
+			if (!targetEntry) {
+				const available = Object.values(groups).map((g) => `${g.name} (${g.folder})`).join(", ");
+				return err$3(`Group folder "${p.folder}" not found. Available: ${available}`);
+			}
+			const [targetJid, targetGroup] = targetEntry;
+			const senderLabel = `agent:${callerGroupFolder}`;
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			await storeChatMetadata(targetJid, now, targetGroup.name);
+			await storeMessage({
+				id: crypto.randomUUID(),
+				chat_jid: targetJid,
+				sender: senderLabel,
+				sender_name: senderLabel,
+				content: p.content,
+				timestamp: now,
+				is_from_me: false,
+				is_bot_message: false
+			});
+			server.queue.enqueueMessageCheck(targetJid);
+			return {
+				content: [{
+					type: "text",
+					text: `Message sent to "${targetGroup.name}" (${p.folder})`
+				}],
+				details: {
+					ok: true,
+					targetJid,
+					folder: p.folder
+				}
+			};
+		}
+	};
+}
+function err$3(text) {
+	return {
+		content: [{
+			type: "text",
+			text
+		}],
+		details: {
+			ok: false,
+			isError: true
+		}
+	};
+}
+const notesTool = {
+	name: "notes",
+	label: "Notes",
+	description: [
+		"Manage markdown notes organized by category.",
+		"Actions: list (show notes, optionally filtered by category),",
+		"read (get note content), write (create/overwrite a note), delete (remove a note).",
+		"Notes are referenced as \"category/id\" (e.g. \"ideas/project-plan\").",
+		"Virtual ~agents notes map to per-session AGENTS.md files."
+	].join(" "),
+	promptSnippet: "notes: Read, write, list, and delete markdown notes organized by category",
+	promptGuidelines: [
+		"Use notes to persist structured information across sessions — plans, references, logs, etc.",
+		"Note refs use \"category/id\" format, e.g. \"tasks/backlog\" or \"docs/api-spec\".",
+		"List notes first to see what exists before reading or writing.",
+		"Virtual ~agents/ notes map to per-session AGENTS.md files."
+	],
+	parameters: Type.Object({
+		action: Type.Union([
+			Type.Literal("list"),
+			Type.Literal("read"),
+			Type.Literal("write"),
+			Type.Literal("delete")
+		], { description: "Action to perform" }),
+		ref: Type.Optional(Type.String({ description: "Note reference as \"category/id\" (required for read/write/delete)" })),
+		category: Type.Optional(Type.String({ description: "Filter by category (list only)" })),
+		content: Type.Optional(Type.String({ description: "Markdown content to write (write only)" }))
+	}),
+	async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+		const p = params;
+		switch (p.action) {
+			case "list": return handleList$1(p);
+			case "read": return handleRead$1(p);
+			case "write": return handleWrite$1(p);
+			case "delete": return handleDelete(p);
+			default: return err$2(`Unknown action: ${p.action}`);
+		}
+	}
+};
+function handleList$1(p) {
+	const entries = listNotes(p.category);
+	if (entries.length === 0) return ok$2(p.category ? `No notes in category "${p.category}".` : "No notes found.");
+	const lines = entries.map((e) => `- ${e.category}/${e.id}`);
+	return ok$2(`Notes (${entries.length}):\n${lines.join("\n")}`, { entries });
+}
+function handleRead$1(p) {
+	if (!p.ref) return err$2("ref is required for read");
+	const content = readNote(p.ref);
+	if (content === void 0) return err$2(`Note "${p.ref}" not found`);
+	return ok$2(content, { ref: p.ref });
+}
+function handleWrite$1(p) {
+	if (!p.ref) return err$2("ref is required for write");
+	if (p.content == null) return err$2("content is required for write");
+	try {
+		writeNote(p.ref, p.content);
+		deviceBus.emitDeviceEvent("notes");
+		return ok$2(`Note "${p.ref}" saved.`, { ref: p.ref });
+	} catch (e) {
+		return err$2(`Failed to write note: ${e instanceof Error ? e.message : String(e)}`);
+	}
+}
+function handleDelete(p) {
+	if (!p.ref) return err$2("ref is required for delete");
+	if (!deleteNote(p.ref)) return err$2(`Note "${p.ref}" not found or cannot be deleted`);
+	deviceBus.emitDeviceEvent("notes");
+	return ok$2(`Note "${p.ref}" deleted.`, { ref: p.ref });
+}
+function ok$2(text, details) {
+	return {
+		content: [{
+			type: "text",
+			text
+		}],
+		details: {
+			ok: true,
+			...details
+		}
+	};
+}
+function err$2(text) {
+	return {
+		content: [{
+			type: "text",
+			text
+		}],
+		details: {
+			ok: false,
+			isError: true
+		}
+	};
+}
+const notifyTool = {
+	name: "notify",
+	label: "Notify",
+	description: [
+		"Send a notification to the user. Always sends an in-app toast notification to connected browsers.",
+		"If ntfy is configured, also sends a push notification via ntfy with full ntfy features",
+		"(priority, emoji tags, clickable URLs, markdown, scheduled delivery, action buttons, attachments)."
+	].join(" "),
+	parameters: Type.Object({
+		message: Type.String({ description: "Notification body text" }),
+		title: Type.Optional(Type.String({ description: "Notification title" })),
+		priority: Type.Optional(Type.Union([
+			Type.Literal(1),
+			Type.Literal(2),
+			Type.Literal(3),
+			Type.Literal(4),
+			Type.Literal(5)
+		], { description: "1=min, 2=low, 3=default, 4=high, 5=urgent" })),
+		tags: Type.Optional(Type.Array(Type.String(), { description: "Emoji shortcodes or labels, e.g. [\"white_check_mark\",\"robot\"]. See https://docs.ntfy.sh/emojis/" })),
+		click: Type.Optional(Type.String({ description: "URL opened when notification is tapped" })),
+		markdown: Type.Optional(Type.Boolean({ description: "Enable markdown formatting in body (enabled by default)" })),
+		delay: Type.Optional(Type.String({ description: "Schedule delivery: duration (\"30m\",\"2h\"), timestamp, or \"tomorrow 9am\" (cannot be combined with email)" })),
+		actions: Type.Optional(Type.Array(Type.String(), { description: "Action buttons (max 3). Format: \"view, Label, https://...\" or \"http, Label, https://...\"" })),
+		attach: Type.Optional(Type.String({ description: "URL to an external file to attach" })),
+		filename: Type.Optional(Type.String({ description: "Override attachment filename" })),
+		email: Type.Optional(Type.String({ description: "Also forward notification to this email" }))
+	}),
+	async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+		const p = params;
+		deviceBus.notify({
+			title: p.title ?? p.message,
+			description: p.title ? p.message : void 0,
+			type: p.priority ? {
+				5: "alert",
+				4: "alert",
+				3: "info",
+				2: "info",
+				1: "info"
+			}[p.priority] : "info"
+		});
+		const config = await getNtfyConfig();
+		let ntfySent = false;
+		if (config) {
+			await sendNtfyNotification(config, {
+				message: p.message,
+				title: p.title,
+				priority: p.priority,
+				tags: p.tags,
+				click: p.click,
+				markdown: p.markdown ?? true,
+				delay: p.delay,
+				actions: p.actions,
+				attach: p.attach,
+				filename: p.filename,
+				email: p.email
+			});
+			ntfySent = true;
+		}
+		const channels = ["in-app", ...ntfySent ? ["ntfy"] : []].join(", ");
+		return {
+			content: [{
+				type: "text",
+				text: `Notification sent (${channels}): ${p.title ?? p.message}`
+			}],
+			details: {
+				ok: true,
+				channels
+			}
+		};
+	}
+};
+const terminalTool = {
+	name: "terminal",
+	label: "Terminal",
+	description: [
+		"Manage persistent terminal/PTY sessions.",
+		"Actions: list (show sessions), create (spawn new session),",
+		"exec (send command and capture output), write (send raw input),",
+		"read (capture recent output), kill (destroy session), resize (change dimensions).",
+		"Use exec for running commands and getting results.",
+		"Use write for interactive/raw input (arrow keys, ctrl sequences, escape codes).",
+		"write supports optional wait param (ms) to capture output after sending input.",
+		"For escape key use \\x1b, for enter use \\n, for ctrl+c use \\x03."
+	].join(" "),
+	promptSnippet: "terminal: Manage persistent terminal sessions — create, exec commands, read output, kill",
+	promptGuidelines: [
+		"Use terminal exec to run commands in persistent shell sessions when you need statefulness (virtualenvs, long-running processes, interactive workflows).",
+		"For simple one-off commands, prefer bash. Use terminal for multi-step workflows needing a persistent shell.",
+		"Always list sessions before creating new ones to reuse existing sessions.",
+		"Remember session IDs for reuse across tool calls — sessions persist until killed or timed out (30min)."
+	],
+	parameters: Type.Object({
+		action: Type.Union([
+			Type.Literal("list"),
+			Type.Literal("create"),
+			Type.Literal("exec"),
+			Type.Literal("write"),
+			Type.Literal("read"),
+			Type.Literal("kill"),
+			Type.Literal("resize")
+		], { description: "Action to perform on terminal sessions" }),
+		id: Type.Optional(Type.String({ description: "Session ID (required for exec/write/read/kill/resize)" })),
+		input: Type.Optional(Type.String({ description: "Command or input text (exec appends newline automatically)" })),
+		cwd: Type.Optional(Type.String({ description: "Working directory for new session (create)" })),
+		label: Type.Optional(Type.String({ description: "Session label (create)" })),
+		sandbox: Type.Optional(Type.Boolean({ description: "Use sandboxed virtual TTY (create, default: false)" })),
+		cols: Type.Optional(Type.Number({ description: "Terminal columns (create/resize, default: 120)" })),
+		rows: Type.Optional(Type.Number({ description: "Terminal rows (create/resize, default: 40)" })),
+		timeout: Type.Optional(Type.Number({ description: "Max ms to wait for output (exec only, default: 10000, max: 30000)" }))
+	}),
+	async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+		const p = params;
+		switch (p.action) {
+			case "list": return handleList();
+			case "create": return handleCreate(p);
+			case "exec": return handleExec(p);
+			case "write": return handleWrite(p);
+			case "read": return handleRead(p);
+			case "kill": return handleKill(p);
+			case "resize": return handleResize(p);
+			default: return err$1(`Unknown action: ${p.action}`);
+		}
+	}
+};
+function handleList() {
+	const sessions = terminalManager.list();
+	if (sessions.length === 0) return ok$1("No active terminal sessions.");
+	const lines = sessions.map((s) => `- ${s.id} [${s.label}] ${s.cols}x${s.rows} cwd=${s.cwd}`);
+	return ok$1(`Active sessions (${sessions.length}):\n${lines.join("\n")}`, { sessions });
+}
+async function handleCreate(p) {
+	try {
+		const session = await terminalManager.create({
+			cols: p.cols ?? 120,
+			rows: p.rows ?? 40,
+			cwd: p.cwd,
+			label: p.label,
+			sandbox: p.sandbox
+		});
+		return ok$1(`Terminal session created: ${session.id} [${session.label}] ${session.cols}x${session.rows}`, {
+			id: session.id,
+			label: session.label
+		});
+	} catch (e) {
+		return err$1(`Failed to create session: ${e instanceof Error ? e.message : String(e)}`);
+	}
+}
+function handleExec(p) {
+	if (!p.id) return err$1("id is required for exec");
+	if (!p.input) return err$1("input is required for exec");
+	if (!terminalManager.get(p.id)) return err$1("Session not found");
+	const timeoutMs = Math.min(p.timeout ?? 1e4, 3e4);
+	const quietMs = 300;
+	const chunks = [];
+	let settled = false;
+	let quietTimer;
+	return new Promise((resolve) => {
+		const unsub = terminalManager.subscribe(p.id, (data) => {
+			chunks.push(data);
+			if (quietTimer) clearTimeout(quietTimer);
+			quietTimer = setTimeout(() => finish(false), quietMs);
+		});
+		const overallTimer = setTimeout(() => finish(true), timeoutMs);
+		function finish(timedOut) {
+			if (settled) return;
+			settled = true;
+			if (quietTimer) clearTimeout(quietTimer);
+			clearTimeout(overallTimer);
+			unsub();
+			resolve(ok$1((stripAnsi(chunks.join("")).trim() || "(no output)") + (timedOut ? "\n(timed out — output may be partial)" : ""), {
+				sessionId: p.id,
+				timedOut
+			}));
+		}
+		terminalManager.write(p.id, interpretEscapes(p.input) + "\n");
+		quietTimer = setTimeout(() => finish(false), quietMs);
+	});
+}
+async function handleWrite(p) {
+	if (!p.id) return err$1("id is required for write");
+	if (p.input == null) return err$1("input is required for write");
+	if (!terminalManager.get(p.id)) return err$1("Session not found");
+	terminalManager.write(p.id, interpretEscapes(p.input));
+	if (p.wait && p.wait > 0) {
+		const waitMs = Math.min(p.wait, 5e3);
+		const chunks = [];
+		const unsub = terminalManager.subscribe(p.id, (data) => chunks.push(data));
+		await new Promise((r) => setTimeout(r, waitMs));
+		unsub();
+		return ok$1(stripAnsi(chunks.join("")).trim() || `Input sent to ${p.id} (no output after ${waitMs}ms)`, { sessionId: p.id });
+	}
+	return ok$1(`Input sent to ${p.id}`);
+}
+async function handleRead(p) {
+	if (!p.id) return err$1("id is required for read");
+	if (!terminalManager.get(p.id)) return err$1("Session not found");
+	const chunks = [];
+	const unsub = terminalManager.subscribe(p.id, (data) => chunks.push(data));
+	terminalManager.nudge(p.id);
+	await new Promise((r) => setTimeout(r, 200));
+	unsub();
+	return ok$1(stripAnsi(chunks.join("")).trim() || "(no output)", { sessionId: p.id });
+}
+function handleKill(p) {
+	if (!p.id) return err$1("id is required for kill");
+	terminalManager.kill(p.id);
+	return ok$1(`Session ${p.id} killed`);
+}
+function handleResize(p) {
+	if (!p.id) return err$1("id is required for resize");
+	const cols = p.cols ?? 120;
+	const rows = p.rows ?? 40;
+	if (!terminalManager.get(p.id)) return err$1("Session not found");
+	terminalManager.resize(p.id, cols, rows);
+	return ok$1(`Session ${p.id} resized to ${cols}x${rows}`);
+}
+var stripAnsiRe$1 = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*[A-Za-z]`, "g");
+function interpretEscapes(text) {
+	return text.replace(/\\x([0-9a-fA-F]{2})/g, (_, hex) => String.fromCharCode(Number.parseInt(hex, 16)));
+}
+function stripAnsi(text) {
+	return text.replace(stripAnsiRe$1, "");
+}
+function ok$1(text, details) {
+	return {
+		content: [{
+			type: "text",
+			text
+		}],
+		details: {
+			ok: true,
+			...details
+		}
+	};
+}
+function err$1(text) {
+	return {
+		content: [{
+			type: "text",
+			text
+		}],
+		details: {
+			ok: false,
+			isError: true
+		}
+	};
+}
+/**
+* Sandboxed coding tools — real pi SDK tools backed by an in-memory filesystem.
+* Uses the centralized sandbox manager so the filesystem is shared with virtual PTY.
+*/
+function createSandboxedCodingTools(opts) {
+	const sb = sandboxManager.get(opts.sandboxId, { ...opts.realCwd && { realCwd: opts.realCwd } });
+	const { fs } = sb;
+	const read = createReadTool(sb.cwd, { operations: {
+		readFile: async (p) => {
+			const content = await fs.readFile(p);
+			return Buffer.from(content);
+		},
+		access: async (p) => {
+			if (!await fs.exists(p)) throw new Error(`ENOENT: no such file or directory, access '${p}'`);
+		}
+	} });
+	const write = createWriteTool(sb.cwd, { operations: {
+		writeFile: async (p, content) => {
+			await fs.writeFile(p, content);
+			await sb.writeBack();
+		},
+		mkdir: (dir) => {
+			return fs.mkdir(dir, { recursive: true });
+		}
+	} });
+	const edit = createEditTool(sb.cwd, { operations: {
+		readFile: async (p) => {
+			const content = await fs.readFile(p);
+			return Buffer.from(content);
+		},
+		writeFile: async (p, content) => {
+			await fs.writeFile(p, content);
+			await sb.writeBack();
+		},
+		access: async (p) => {
+			if (!await fs.exists(p)) throw new Error(`ENOENT: no such file or directory, access '${p}'`);
+		}
+	} });
+	return [
+		read,
+		createBashTool(sb.cwd, { operations: { exec: async (command, execCwd, options) => {
+			try {
+				const result = await sb.exec(command, { cwd: execCwd || void 0 });
+				if (result.stdout) options.onData(Buffer.from(result.stdout));
+				if (result.stderr) options.onData(Buffer.from(result.stderr));
+				return { exitCode: result.exitCode };
+			} catch (err) {
+				options.onData(Buffer.from(err.message + "\n"));
+				return { exitCode: 1 };
+			}
+		} } }),
+		edit,
+		write
+	];
+}
+/**
+* MIT License
+* Copyright (c) 2024 Mario Zechner
+* Based on https://github.com/badlogic/pi-skills/tree/main/brave-search
+*/
+const webSearchTool = {
+	name: "web_search",
+	label: "Web Search",
+	description: [
+		"Search the web using the Brave Search API.",
+		"Returns titles, links, snippets, and optionally full page content as markdown.",
+		"Requires BRAVE_API_KEY environment variable."
+	].join(" "),
+	promptSnippet: "web_search: Search the web and optionally fetch page content as markdown",
+	promptGuidelines: [
+		"Use web_search to look up current information, documentation, error messages, or anything that benefits from live web results.",
+		"Enable content=true to fetch and read full page content as markdown (slower but more detailed).",
+		"Use freshness to filter by time: pd (past day), pw (past week), pm (past month), py (past year).",
+		"Keep count reasonable (3-5) when fetching content to avoid slow responses."
+	],
+	parameters: Type.Object({
+		query: Type.String({ description: "Search query" }),
+		count: Type.Optional(Type.Number({ description: "Number of results (default: 5, max: 20)" })),
+		content: Type.Optional(Type.Boolean({ description: "Fetch full page content as markdown (default: false, slower)" })),
+		country: Type.Optional(Type.String({ description: "Country code for results (default: \"US\")" })),
+		freshness: Type.Optional(Type.String({ description: "Filter by time: pd (past day), pw (past week), pm (past month), py (past year)" }))
+	}),
+	async execute(_toolCallId, params, signal) {
+		const p = params;
+		const apiKey = config.get("braveApiKey");
+		if (!apiKey) return err("BRAVE_API_KEY is not configured. Set it via Settings => Config => braveApiKey. Get a key at https://api-dashboard.search.brave.com/app/keys");
+		const count = Math.min(Math.max(p.count ?? 5, 1), 20);
+		try {
+			const results = await fetchBraveResults(apiKey, p.query, count, p.country, p.freshness, signal);
+			if (results.length === 0) return ok("No results found.", {
+				query: p.query,
+				count: 0
+			});
+			if (p.content) await Promise.all(results.map(async (r) => {
+				r.content = await fetchPageContent(r.link, signal);
+			}));
+			const lines = [];
+			for (const [i, r] of results.entries()) {
+				lines.push(`--- Result ${i + 1} ---`);
+				lines.push(`Title: ${r.title}`);
+				lines.push(`Link: ${r.link}`);
+				if (r.age) lines.push(`Age: ${r.age}`);
+				lines.push(`Snippet: ${r.snippet}`);
+				if (r.content) lines.push(`Content:\n${r.content}`);
+				lines.push("");
+			}
+			return ok(lines.join("\n"), {
+				query: p.query,
+				count: results.length
+			});
+		} catch (e) {
+			return err(`Search failed: ${e instanceof Error ? e.message : String(e)}`);
+		}
+	}
+};
+async function fetchBraveResults(apiKey, query, count, country, freshness, signal) {
+	const params = new URLSearchParams({
+		q: query,
+		count: String(count),
+		country: country?.toUpperCase() || "US"
+	});
+	if (freshness) params.append("freshness", freshness);
+	const res = await fetch(`https://api.search.brave.com/res/v1/web/search?${params}`, {
+		headers: {
+			Accept: "application/json",
+			"Accept-Encoding": "gzip",
+			"X-Subscription-Token": apiKey
+		},
+		signal
+	});
+	if (!res.ok) {
+		const text = await res.text();
+		throw new Error(`HTTP ${res.status}: ${res.statusText}\n${text}`);
+	}
+	const data = await res.json();
+	const results = [];
+	if (data.web?.results) for (const r of data.web.results) {
+		if (results.length >= count) break;
+		results.push({
+			title: r.title || "",
+			link: r.url || "",
+			snippet: r.description || "",
+			age: r.age || r.page_age || ""
+		});
+	}
+	return results;
+}
+async function fetchPageContent(url, signal) {
+	try {
+		const res = await fetch(url, {
+			headers: {
+				"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36",
+				Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
+			},
+			signal: signal ?? AbortSignal.timeout(1e4)
+		});
+		if (!res.ok) return `(HTTP ${res.status})`;
+		return extractReadableText(await res.text(), url);
+	} catch (e) {
+		return `(Error: ${e instanceof Error ? e.message : String(e)})`;
+	}
+}
+async function extractReadableText(html, url) {
+	try {
+		const { Readability } = await import("../_libs/_.mjs").then((m) => /* @__PURE__ */ __toESM(m.default, 1));
+		const { JSDOM } = await import("../_libs/_4.mjs").then((m) => /* @__PURE__ */ __toESM(m.default, 1));
+		const article = new Readability(new JSDOM(html, { url }).window.document).parse();
+		if (article?.content) return (await htmlToMarkdown(article.content)).slice(0, 5e3);
+		const doc = new JSDOM(html, { url }).window.document;
+		doc.querySelectorAll("script, style, noscript, nav, header, footer, aside").forEach((el) => el.remove());
+		const text = (doc.querySelector("main, article, [role='main'], .content, #content") || doc.body)?.textContent || "";
+		if (text.trim().length > 100) return text.trim().slice(0, 5e3);
+		return "(Could not extract content)";
+	} catch {
+		return stripHtmlTags$1(html).slice(0, 5e3) || "(Could not extract content)";
+	}
+}
+async function htmlToMarkdown(html) {
+	try {
+		const TurndownService = (await import("../_libs/_29.mjs")).default;
+		const { gfm } = await import("../_libs/_93.mjs");
+		const turndown = new TurndownService({
+			headingStyle: "atx",
+			codeBlockStyle: "fenced"
+		});
+		turndown.use(gfm);
+		turndown.addRule("removeEmptyLinks", {
+			filter: (node) => node.nodeName === "A" && !node.textContent?.trim(),
+			replacement: () => ""
+		});
+		return turndown.turndown(html).replace(/\[\\?\[\s*\\?\]\]\([^)]*\)/g, "").replace(/ +/g, " ").replace(/\s+,/g, ",").replace(/\s+\./g, ".").replace(/\n{3,}/g, "\n\n").trim();
+	} catch {
+		return stripHtmlTags$1(html);
+	}
+}
+function stripHtmlTags$1(html) {
+	return html.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+}
+function ok(text, details) {
+	return {
+		content: [{
+			type: "text",
+			text
+		}],
+		details: {
+			ok: true,
+			...details
+		}
+	};
+}
+function err(text) {
+	return {
+		content: [{
+			type: "text",
+			text
+		}],
+		details: {
+			ok: false,
+			isError: true
+		}
+	};
+}
+var logger$5 = createLogger("pi");
+/**
+* Model preference order for fallback resolution.
+* Entries with `model` try a specific model; without tries any available from that provider.
+*/
+var MODEL_PREFERENCE = [
+	{
+		provider: "openai-codex",
+		model: "gpt-5.3-codex"
+	},
+	{ provider: "openai-codex" },
+	{ provider: "anthropic" },
+	{ provider: "google" }
+];
+/** Provider search order derived from MODEL_PREFERENCE */
+var PROVIDER_ORDER = [...new Set(MODEL_PREFERENCE.map((e) => e.provider))];
+const sessions = /* @__PURE__ */ new Map();
+const authStorage = AuthStorage.create();
+const modelRegistry = new ModelRegistry(authStorage);
+async function getOrCreateSession(group, input) {
+	const sessionDir = path.join(SESSIONS_DIR, group.folder);
+	fs.mkdirSync(sessionDir, { recursive: true });
+	let managed = sessions.get(input.chatJid);
+	if (!managed) {
+		streamBus.emit({
+			type: "session_init",
+			chatJid: input.chatJid
+		});
+		managed = await createManagedSession(group, input, sessionDir);
+		sessions.set(input.chatJid, managed);
+	}
+	managed.lastActivity = Date.now();
+	return managed;
+}
+function resolveModel() {
+	const available = getFilteredModels();
+	const piProvider = config.get("piProvider");
+	const piModel = config.get("piModel");
+	if (piProvider && piModel) {
+		const model = findAvailable(available, piProvider, piModel);
+		if (model) return model;
+	}
+	if (piModel) {
+		const slashIdx = piModel.indexOf("/");
+		if (slashIdx > 0) {
+			const model = findAvailable(available, piModel.slice(0, slashIdx), piModel.slice(slashIdx + 1));
+			if (model) return model;
+		}
+		for (const provider of PROVIDER_ORDER) {
+			const model = findAvailable(available, provider, piModel);
+			if (model) return model;
+		}
+	}
+	return resolveDefaultModel();
+}
+function resolveGroupModel(group) {
+	if (!group.model) {
+		const model = resolveModel();
+		logger$5.debug({
+			group: group.name,
+			resolved: fmtModel(model),
+			source: "global"
+		}, "Model resolved");
+		return model;
+	}
+	const available = getFilteredModels();
+	const modelStr = group.model;
+	const slashIdx = modelStr.indexOf("/");
+	if (slashIdx > 0) {
+		const model = findAvailable(available, modelStr.slice(0, slashIdx), modelStr.slice(slashIdx + 1));
+		if (model) {
+			logger$5.debug({
+				group: group.name,
+				resolved: fmtModel(model),
+				source: "group"
+			}, "Model resolved");
+			return model;
+		}
+	}
+	for (const provider of PROVIDER_ORDER) {
+		const model = findAvailable(available, provider, modelStr);
+		if (model) {
+			logger$5.debug({
+				group: group.name,
+				resolved: fmtModel(model),
+				source: "group-search"
+			}, "Model resolved");
+			return model;
+		}
+	}
+	logger$5.warn({
+		group: group.name,
+		wanted: modelStr,
+		available: available.map(fmtModel)
+	}, "Group model not found in available models, falling back to global");
+	const fallback = resolveModel();
+	logger$5.debug({
+		group: group.name,
+		resolved: fmtModel(fallback),
+		source: "fallback"
+	}, "Model resolved");
+	return fallback;
+}
+function resolveDefaultModel() {
+	const available = getFilteredModels();
+	for (const pref of MODEL_PREFERENCE) if (pref.model) {
+		const model = findAvailable(available, pref.provider, pref.model);
+		if (model) return model;
+	} else {
+		const model = available.find((m) => m.provider === pref.provider);
+		if (model) return model;
+	}
+}
+async function createManagedSession(group, input, sessionDir) {
+	const groupDir = path.join(GROUPS_DIR, group.folder);
+	const sandboxEnforced = config.get("sandbox") === "enforced";
+	const sandbox = sandboxEnforced || !!group.sandbox;
+	logger$5.info({
+		group: group.name,
+		folder: group.folder,
+		isMain: input.isMain,
+		hasSession: !!input.sessionId,
+		sandbox,
+		...sandboxEnforced && { sandboxSource: "enforced" }
+	}, "Creating pi SDK session");
+	const model = resolveGroupModel(group);
+	const settingsManager = SettingsManager.inMemory({
+		compaction: { enabled: true },
+		retry: {
+			enabled: true,
+			maxRetries: 3
+		}
+	});
+	const systemPrompt = await buildSystemPrompt({
+		assistantName: input.assistantName,
+		dir: groupDir,
+		modelName: `${model?.provider}/${model?.id}`,
+		soul: group.soul
+	});
+	const resourceLoader = new DefaultResourceLoader({
+		cwd: groupDir,
+		settingsManager,
+		systemPromptOverride: () => systemPrompt,
+		...sandbox && {
+			agentDir: groupDir,
+			noExtensions: true,
+			noSkills: true,
+			noPromptTemplates: true,
+			noThemes: true,
+			agentsFilesOverride: (_base) => ({ agentsFiles: [] })
+		}
+	});
+	await resourceLoader.reload();
+	const sessionManager = input.sessionId ? SessionManager.continueRecent(groupDir, sessionDir) : SessionManager.create(groupDir, sessionDir);
+	const thinkingLevel = group.thinkingLevel || "off";
+	if (sandbox) logger$5.info({ group: group.name }, "Using sandboxed coding tools (in-memory filesystem)");
+	const sandboxedTools = sandbox ? Object.fromEntries(createSandboxedCodingTools({
+		sandboxId: `~${group.folder}`,
+		realCwd: groupDir
+	}).map((t) => [t.name, t])) : void 0;
+	const { session, modelFallbackMessage } = await createAgentSession({
+		cwd: groupDir,
+		model,
+		thinkingLevel,
+		authStorage,
+		modelRegistry,
+		customTools: sandbox ? [notifyTool, webSearchTool] : [
+			browserTool,
+			createMessageTool(group.folder),
+			notesTool,
+			notifyTool,
+			terminalTool,
+			webSearchTool
+		],
+		resourceLoader,
+		sessionManager,
+		settingsManager
+	});
+	if (sandboxedTools) {
+		session._baseToolsOverride = sandboxedTools;
+		await session.reload();
+	}
+	if (modelFallbackMessage) logger$5.warn({
+		group: group.name,
+		message: modelFallbackMessage
+	}, "Model fallback");
+	const actualModel = session.model;
+	if (model && actualModel && (actualModel.provider !== model.provider || actualModel.id !== model.id)) {
+		logger$5.warn({
+			group: group.name,
+			requested: fmtModel(model),
+			actual: fmtModel(actualModel)
+		}, "SDK used different model than requested — forcing requested model");
+		await session.setModel(model);
+	}
+	logger$5.info({
+		group: group.name,
+		sessionId: session.sessionId,
+		model: fmtModel(session.model),
+		groupModel: group.model || "default"
+	}, "Pi SDK session created");
+	return {
+		session,
+		groupFolder: group.folder,
+		sessionDir,
+		lastActivity: Date.now()
+	};
+}
+/** Date suffix pattern (e.g. `-20241022`, `-20250514`) */
+var DATE_SUFFIX_RE = /-\d{8}$/;
+/**
+* Returns available models filtered and sorted:
+* - Removes models with date suffixes in their ID (prefer canonical short names)
+* - Removes all haiku models (too weak for coding tasks)
+* - Sorts by MODEL_PREFERENCE provider order (preferred providers first, unknown last)
+*/
+function getFilteredModels() {
+	return modelRegistry.getAvailable().filter((m) => {
+		if (DATE_SUFFIX_RE.test(m.id)) return false;
+		if (/haiku/i.test(m.id)) return false;
+		return true;
+	}).sort((a, b) => {
+		const ai = PROVIDER_ORDER.indexOf(a.provider);
+		const bi = PROVIDER_ORDER.indexOf(b.provider);
+		return (ai === -1 ? PROVIDER_ORDER.length : ai) - (bi === -1 ? PROVIDER_ORDER.length : bi);
+	});
+}
+function findAvailable(available, provider, modelId) {
+	return available.find((m) => m.provider === provider && m.id === modelId);
+}
+function fmtModel(m) {
+	return m ? `${m.provider}/${m.id}` : "none";
+}
+function getPiSdkStatus$1(options) {
+	const { sessions, modelRegistry, authStorage, resolvedModel, configuredProvider, configuredModel } = options;
+	const now = Date.now();
+	const allModels = modelRegistry.getAll();
+	const availableModels = modelRegistry.getAvailable();
+	const availableModelKeys = new Set(availableModels.map((model) => getModelKey(model.provider, model.id)));
+	const sessionList = Array.from(sessions.entries()).sort(([a], [b]) => a.localeCompare(b)).map(([chatJid, managed]) => {
+		const contextUsage = managed.session.getContextUsage();
+		return {
+			chatJid,
+			groupFolder: managed.groupFolder,
+			sessionDir: managed.sessionDir,
+			lastActivity: managed.lastActivity,
+			idleMs: Math.max(0, now - managed.lastActivity),
+			session: {
+				id: managed.session.sessionId,
+				file: managed.session.sessionFile ?? null,
+				name: managed.session.sessionName ?? null,
+				messageCount: managed.session.messages.length,
+				model: managed.session.model ? serializeModel(managed.session.model) : null,
+				thinkingLevel: managed.session.thinkingLevel,
+				contextUsage: contextUsage ? {
+					tokens: contextUsage.tokens,
+					contextWindow: contextUsage.contextWindow,
+					percent: contextUsage.percent
+				} : null
+			},
+			runtime: {
+				isStreaming: managed.session.isStreaming,
+				isCompacting: managed.session.isCompacting,
+				isRetrying: managed.session.isRetrying,
+				retryAttempt: managed.session.retryAttempt,
+				autoRetryEnabled: managed.session.autoRetryEnabled,
+				autoCompactionEnabled: managed.session.autoCompactionEnabled,
+				pendingMessageCount: managed.session.pendingMessageCount,
+				isBashRunning: managed.session.isBashRunning,
+				hasPendingBashMessages: managed.session.hasPendingBashMessages,
+				steeringMode: managed.session.steeringMode,
+				followUpMode: managed.session.followUpMode
+			},
+			settings: {
+				retry: managed.session.settingsManager.getRetrySettings(),
+				compaction: managed.session.settingsManager.getCompactionSettings()
+			}
+		};
+	});
+	const authProviders = new Set([...allModels.map((model) => model.provider), ...authStorage.list()]);
+	return {
+		sdk: {
+			activeSessions: sessions.size,
+			streamingSessions: sessionList.filter((session) => session.runtime.isStreaming).length,
+			compactingSessions: sessionList.filter((session) => session.runtime.isCompacting).length,
+			retryingSessions: sessionList.filter((session) => session.runtime.isRetrying).length,
+			bashRunningSessions: sessionList.filter((session) => session.runtime.isBashRunning).length,
+			timestamp: now
+		},
+		model: {
+			configured: {
+				provider: configuredProvider ?? null,
+				model: configuredModel ?? null
+			},
+			resolved: resolvedModel ? {
+				...serializeModel(resolvedModel),
+				isAvailable: availableModelKeys.has(getModelKey(resolvedModel.provider, resolvedModel.id)),
+				usesOAuth: modelRegistry.isUsingOAuth(resolvedModel)
+			} : null,
+			registry: {
+				totalModels: allModels.length,
+				availableModels: availableModels.length,
+				loadError: modelRegistry.getError() ?? null
+			}
+		},
+		auth: {
+			configuredProviders: authStorage.list().sort(),
+			oauthProviders: authStorage.getOAuthProviders().map((provider) => ({
+				id: provider.id,
+				name: provider.name
+			})).sort((a, b) => a.id.localeCompare(b.id)),
+			providers: Array.from(authProviders).sort().map((provider) => ({
+				provider,
+				hasAuth: authStorage.hasAuth(provider)
+			}))
+		},
+		sessions: sessionList
+	};
+}
+function serializeModel(model) {
+	return {
+		provider: model.provider,
+		id: model.id,
+		name: model.name,
+		api: model.api,
+		reasoning: model.reasoning ?? false,
+		input: model.input ?? ["text"],
+		contextWindow: model.contextWindow ?? null,
+		maxTokens: model.maxTokens ?? null,
+		cost: model.cost ?? null
+	};
+}
+function getModelKey(provider, modelId) {
+	return `${provider}/${modelId}`;
+}
+/**
+* Pi agent — runs pi coding agent in-process via the SDK.
+*
+* Uses `createAgentSession` from @mariozechner/pi-coding-agent directly.
+* Sessions are persisted per-group and automatically continued across restarts.
+*/
+var pi_exports = /* @__PURE__ */ __exportAll({
+	getFilteredModels: () => getFilteredModels,
+	getPiSdkStatus: () => getPiSdkStatus,
+	kill: () => kill,
+	modelRegistry: () => modelRegistry,
+	run: () => run,
+	sendMessage: () => sendMessage,
+	shutdown: () => shutdown,
+	warmUp: () => warmUp
+});
+var logger$4 = createLogger("pi");
+async function run(group, input, onOutput) {
+	return sendPrompt(await getOrCreateSession(group, input), group, input, onOutput);
+}
+/**
+* Deliver a message to an active streaming session.
+* If the message ends with `!`, uses `steer` (interrupts agent after current tool).
+* Otherwise uses `followUp` (delivered after agent finishes current work).
+* Returns the delivery method, or `false` if no active streaming session.
+*/
+function sendMessage(groupJid, message) {
+	const managed = sessions.get(groupJid);
+	if (!managed || !managed.session.isStreaming) return false;
+	const { session } = managed;
+	if (message.includes("!")) {
+		session.steer(message).catch((err) => {
+			logger$4.error({
+				group: managed.groupFolder,
+				err
+			}, "Failed to steer message");
+		});
+		return "steer";
+	} else {
+		session.followUp(message).catch((err) => {
+			logger$4.error({
+				group: managed.groupFolder,
+				err
+			}, "Failed to queue follow-up");
+		});
+		return "followup";
+	}
+}
+async function kill(groupJid) {
+	const managed = sessions.get(groupJid);
+	if (managed) {
+		managed.aborted = true;
+		try {
+			await managed.session.abort();
+		} catch {}
+		if (managed.abortDone) await managed.abortDone;
+		managed.session.dispose();
+		sessions.delete(groupJid);
+	}
+}
+/**
+* Eagerly restore in-memory sessions for groups that had persisted sessions.
+* Called on server boot so sessions are warm before message recovery.
+*/
+async function warmUp(groups, storedSessions, assistantName) {
+	const folderToJid = /* @__PURE__ */ new Map();
+	for (const [jid, group] of Object.entries(groups)) folderToJid.set(group.folder, {
+		jid,
+		group
+	});
+	const toRestore = Object.entries(storedSessions).filter(([folder]) => folderToJid.has(folder) && !sessions.has(folderToJid.get(folder).jid));
+	if (toRestore.length === 0) return;
+	logger$4.info({ count: toRestore.length }, "Warming up persisted sessions");
+	const results = await Promise.allSettled(toRestore.map(async ([folder, sessionId]) => {
+		const { jid, group } = folderToJid.get(folder);
+		await getOrCreateSession(group, {
+			prompt: "",
+			sessionId,
+			groupFolder: folder,
+			chatJid: jid,
+			isMain: folder === "main",
+			assistantName
+		});
+		return {
+			jid,
+			group: group.name
+		};
+	}));
+	for (const r of results) if (r.status === "fulfilled") logger$4.info({ group: r.value.group }, "Session restored");
+	else logger$4.warn({ err: r.reason }, "Failed to restore session");
+}
+async function shutdown(timeoutMs) {
+	for (const [jid, managed] of sessions) {
+		try {
+			managed.session.dispose();
+		} catch {}
+		sessions.delete(jid);
+	}
+	await new Promise((resolve) => setTimeout(resolve, Math.min(timeoutMs, 1e3)));
+}
+function getPiSdkStatus() {
+	return getPiSdkStatus$1({
+		sessions,
+		modelRegistry,
+		authStorage,
+		resolvedModel: resolveModel(),
+		configuredProvider: config.get("piProvider"),
+		configuredModel: config.get("piModel")
+	});
+}
+var commands = {
+	help: handleHelp,
+	info: handleInfo,
+	new: handleNew,
+	stop: handleStop,
+	model: handleModel,
+	thinking: handleThinking,
+	compact: handleCompact
+};
+var VALID_THINKING_LEVELS = [
+	"off",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh"
+];
+/** Descriptions for registering commands with external channels (e.g. Telegram). */
+const commandDescriptions = [
+	{
+		command: "help",
+		description: "Show available commands"
+	},
+	{
+		command: "info",
+		description: "Show session info and workspace overview"
+	},
+	{
+		command: "new",
+		description: "Reset session and start fresh"
+	},
+	{
+		command: "stop",
+		description: "Stop the current agent session"
+	},
+	{
+		command: "model",
+		description: "List or set model",
+		hasParams: true
+	},
+	{
+		command: "thinking",
+		description: "Show or set thinking level",
+		hasParams: true,
+		paramOptions: VALID_THINKING_LEVELS
+	},
+	{
+		command: "compact",
+		description: "Compact current session context"
+	}
+];
+/** Commands that bypass the queue and execute immediately (even during streaming). */
+var priorityCommands = {
+	stop: handleStop,
+	new: handleNew,
+	info: handleInfo
+};
+/**
+* Try to handle a priority command that must bypass the queue.
+* Called from the message loop and send API before enqueueing.
+* Returns true if the message was a priority command (consumed).
+*/
+function tryPriorityCommand(ctx, text) {
+	if (!text.startsWith("/")) return false;
+	const spaceIdx = text.indexOf(" ");
+	const name = (spaceIdx > 0 ? text.slice(1, spaceIdx) : text.slice(1)).toLowerCase();
+	const handler = priorityCommands[name];
+	if (!handler) return false;
+	Promise.resolve(handler(ctx, "")).catch((err) => {
+		ctx.server.sendBotMessage(ctx.chatJid, `Command /${name} failed: ${String(err)}`).catch(() => {});
+	});
+	return true;
+}
+/**
+* Try to handle a message as a `/command`. Returns true if handled.
+*/
+async function tryCommand(ctx, text) {
+	if (!text.startsWith("/")) return false;
+	const spaceIdx = text.indexOf(" ");
+	const name = (spaceIdx > 0 ? text.slice(1, spaceIdx) : text.slice(1)).toLowerCase();
+	const arg = spaceIdx > 0 ? text.slice(spaceIdx + 1).trim() : "";
+	const handler = commands[name];
+	if (handler) {
+		try {
+			await handler(ctx, arg);
+		} catch (err) {
+			await ctx.server.sendBotMessage(ctx.chatJid, `Command /${name} failed: ${String(err)}`);
+		}
+		return true;
+	}
+	await ctx.server.sendBotMessage(ctx.chatJid, `Unknown command \`/${name}\`. Use \`/help\` for available commands.`);
+	return true;
+}
+async function handleHelp(ctx) {
+	const lines = ["**Available commands:**", ...commandDescriptions.map((c) => `- \`/${c.command}\` — ${c.description}`)];
+	await ctx.server.sendBotMessage(ctx.chatJid, lines.join("\n"));
+}
+async function handleInfo(ctx) {
+	const resolved = resolveGroupModel(ctx.group);
+	const modelLabel = resolved ? `${resolved.provider}/${resolved.id}` : "none";
+	const modelSource = ctx.group.model ? `group (${ctx.group.model})` : "default";
+	const managed = sessions.get(ctx.chatJid);
+	const lines = [
+		`**Group:** ${ctx.group.name} (\`${ctx.group.folder}\`)`,
+		`**Model:** \`${modelLabel}\` [${modelSource}]`,
+		`**Trigger:** ${ctx.group.requiresTrigger ? "required" : "not required"}`
+	];
+	if (managed) {
+		const s = managed.session;
+		const actualModel = s.model;
+		const actualLabel = actualModel ? `${actualModel.provider}/${actualModel.id}` : "none";
+		const ctx$ = s.getContextUsage();
+		lines.push("", `**Session:** \`${s.sessionId}\``, actualLabel !== modelLabel ? `**Session model:** \`${actualLabel}\` ⚠️ mismatch` : `**Session model:** \`${actualLabel}\``, `**Messages:** ${s.messages.length}`, `**Streaming:** ${s.isStreaming ? "yes" : "no"}`, `**Idle:** ${formatDuration(Date.now() - managed.lastActivity)}`);
+		if (ctx$?.tokens != null && ctx$.percent != null) {
+			const pct = Math.round(ctx$.percent);
+			lines.push(`**Context:** ${ctx$.tokens.toLocaleString()} / ${ctx$.contextWindow.toLocaleString()} tokens (${pct}%)`);
+		}
+	} else lines.push("", "*No active session*");
+	const allGroups = ctx.server.getRegisteredGroups();
+	const allTasks = await getAllTasks();
+	lines.push("", "---", "", "**All Groups:**");
+	for (const [jid, g] of Object.entries(allGroups)) {
+		const gResolved = resolveGroupModel(g);
+		const gModelLabel = gResolved ? `${gResolved.provider}/${gResolved.id}` : "none";
+		const gManaged = sessions.get(jid);
+		const sessionPart = gManaged ? `active, idle ${formatDuration(Date.now() - gManaged.lastActivity)}` : "no session";
+		const soulPart = g.soul ? " 🧬" : "";
+		lines.push(`- **${g.name}** (\`${g.folder}\`) — \`${gModelLabel}\` — ${sessionPart}${soulPart}`);
+	}
+	const cutoff = (/* @__PURE__ */ new Date(Date.now() - 1440 * 60 * 1e3)).toISOString();
+	const recentTasks = allTasks.filter((t) => t.status === "active" || t.last_run && t.last_run > cutoff);
+	if (recentTasks.length > 0) {
+		lines.push("", `**Tasks** (active or run in last 24h): ${recentTasks.length}`);
+		for (const t of recentTasks.slice(0, 10)) {
+			const groupName = Object.values(allGroups).find((g) => g.folder === t.group_folder)?.name || t.group_folder;
+			lines.push(`- [${t.status}] \`${t.schedule_type}:${t.schedule_value}\` in **${groupName}** — ${t.prompt.slice(0, 60)}`);
+		}
+		if (recentTasks.length > 10) lines.push(`  … and ${recentTasks.length - 10} more`);
+	}
+	lines.push("", `*${Object.keys(allGroups).length} groups, ${allTasks.filter((t) => t.status === "active").length} active tasks*`);
+	await ctx.server.sendBotMessage(ctx.chatJid, lines.join("\n"));
+}
+function formatDuration(ms) {
+	const s = Math.floor(ms / 1e3);
+	if (s < 60) return `${s}s`;
+	const m = Math.floor(s / 60);
+	if (m < 60) return `${m}m ${s % 60}s`;
+	return `${Math.floor(m / 60)}h ${m % 60}m`;
+}
+async function handleNew(ctx) {
+	ctx.server.pi.kill(ctx.chatJid);
+	await removeSession(ctx.group.folder);
+	const sessionDir = path$1.join(SESSIONS_DIR, ctx.group.folder);
+	fs$1.rmSync(sessionDir, {
+		recursive: true,
+		force: true
+	});
+	delete ctx.server.sessions[ctx.group.folder];
+	await clearMessages(ctx.chatJid);
+	await ctx.server.sendBotMessage(ctx.chatJid, "Session reset. Next message starts a fresh conversation.");
+}
+async function handleStop(ctx) {
+	if (!sessions.get(ctx.chatJid)) return;
+	await ctx.server.pi.kill(ctx.chatJid);
+}
+async function handleModel(ctx, arg) {
+	if (!arg) return listModels(ctx);
+	if (arg === "default" || arg === "reset") return resetModel(ctx);
+	return setModel(ctx, arg);
+}
+async function listModels(ctx) {
+	const available = getFilteredModels();
+	const resolved = resolveGroupModel(ctx.group);
+	const lines = [
+		`**Current:** \`${ctx.group.model || "default (global)"}\` → \`${resolved ? `${resolved.provider}/${resolved.id}` : "none"}\``,
+		"",
+		"**Available models:**"
+	];
+	const byProvider = /* @__PURE__ */ new Map();
+	for (const m of available) {
+		let list = byProvider.get(m.provider);
+		if (!list) {
+			list = [];
+			byProvider.set(m.provider, list);
+		}
+		const marker = resolved && m.provider === resolved.provider && m.id === resolved.id ? " ←" : "";
+		list.push(`- \`${m.provider}/${m.id}\`${marker}`);
+	}
+	for (const [provider, models] of byProvider) {
+		lines.push("", `**${provider}**`);
+		lines.push(...models);
+	}
+	lines.push("", "`/model <query>` | `/model default`");
+	await ctx.server.sendBotMessage(ctx.chatJid, lines.join("\n"));
+}
+async function resetModel(ctx) {
+	const had = ctx.group.model;
+	await updateGroupModel(ctx, void 0);
+	await ctx.server.sendBotMessage(ctx.chatJid, had ? `Model reset to default (was: \`${had}\`).` : "Already using default model.");
+}
+async function setModel(ctx, query) {
+	const match = findModel(query);
+	if (!match) {
+		await ctx.server.sendBotMessage(ctx.chatJid, `No model matching "${query}". Use \`/model\` to list available models.`);
+		return;
+	}
+	const modelStr = `${match.provider}/${match.id}`;
+	await updateGroupModel(ctx, modelStr);
+	await ctx.server.sendBotMessage(ctx.chatJid, `Model set to \`${modelStr}\``);
+}
+async function updateGroupModel(ctx, model) {
+	const old = ctx.group.model;
+	ctx.group.model = model;
+	await ctx.server.setRegisteredGroup(ctx.chatJid, ctx.group);
+	if (old !== model) ctx.server.pi.kill(ctx.chatJid);
+}
+async function handleThinking(ctx, arg) {
+	if (!arg) {
+		const current = ctx.group.thinkingLevel || "off";
+		await ctx.server.sendBotMessage(ctx.chatJid, `**Thinking level:** \`${current}\`\n\n\`/thinking <level>\`\nLevels: ${VALID_THINKING_LEVELS.map((l) => `\`${l}\``).join(", ")}`);
+		return;
+	}
+	const level = arg.toLowerCase();
+	if (!VALID_THINKING_LEVELS.includes(level)) {
+		await ctx.server.sendBotMessage(ctx.chatJid, `Invalid thinking level "${arg}". Must be one of: ${VALID_THINKING_LEVELS.map((l) => `\`${l}\``).join(", ")}`);
+		return;
+	}
+	const old = ctx.group.thinkingLevel;
+	ctx.group.thinkingLevel = level === "off" ? void 0 : level;
+	await ctx.server.setRegisteredGroup(ctx.chatJid, ctx.group);
+	if (old !== ctx.group.thinkingLevel) ctx.server.pi.kill(ctx.chatJid);
+	await ctx.server.sendBotMessage(ctx.chatJid, `Thinking level set to \`${level}\``);
+}
+async function handleCompact(ctx, arg) {
+	const managed = sessions.get(ctx.chatJid);
+	if (!managed) {
+		await ctx.server.sendBotMessage(ctx.chatJid, "No active session to compact. Send a message first, then run `/compact`.");
+		return;
+	}
+	const session = managed.session;
+	if (session.isCompacting) {
+		await ctx.server.sendBotMessage(ctx.chatJid, "Compaction is already in progress.");
+		return;
+	}
+	const before = session.getContextUsage();
+	await ctx.server.sendBotMessage(ctx.chatJid, "Compacting session context…");
+	const result = await session.compact(arg || void 0);
+	const after = session.getContextUsage();
+	const lines = ["**Compaction complete.**"];
+	if (typeof result?.tokensBefore === "number") lines.push(`**Tokens before:** ${result.tokensBefore.toLocaleString()}`);
+	if (before?.tokens != null) lines.push(`**Est. before:** ${before.tokens.toLocaleString()}`);
+	if (after?.tokens != null) lines.push(`**Est. after:** ${after.tokens.toLocaleString()}`);
+	await ctx.server.sendBotMessage(ctx.chatJid, lines.join("\n"));
+}
+function findModel(query) {
+	const available = getFilteredModels();
+	if (available.length === 0) return void 0;
+	const q = query.toLowerCase();
+	const exact = available.filter((m) => `${m.provider}/${m.id}`.toLowerCase() === q);
+	if (exact.length === 1) return exact[0];
+	const byId = available.filter((m) => m.id.toLowerCase() === q);
+	if (byId.length === 1) return byId[0];
+	const tokens = q.split(/[\s/]+/).filter(Boolean);
+	const fuzzy = available.filter((m) => {
+		const label = `${m.provider}/${m.id}`.toLowerCase();
+		return tokens.every((t) => label.includes(t));
+	});
+	const matches = exact.length > 1 ? exact : byId.length > 1 ? byId : fuzzy;
+	if (matches.length === 0) return void 0;
+	matches.sort((a, b) => a.id.length - b.id.length || b.id.localeCompare(a.id, void 0, { numeric: true }));
+	return matches[0];
+}
+new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*[A-Za-z]`, "g");
 await init();
 var logger$3 = createLogger("telegram");
 var JID_PREFIX = "tg:";
 var POLL_INTERVAL = 1e3;
 var POLL_TIMEOUT = 30;
 var API_BASE = "https://api.telegram.org/bot";
-var STREAM_THROTTLE_MIN = 700;
-var STREAM_THROTTLE_MAX = 1500;
-var STREAM_THROTTLE_STEP = 200;
+var STREAM_THROTTLE_MIN = 1e3;
+var STREAM_THROTTLE_MAX = 1e4;
+var STREAM_THROTTLE_STEP = 1e3;
 var STREAM_THROTTLE_JITTER = 120;
 var STREAM_INITIAL_DELAY = 100;
 var TG_MAX_TEXT = 4096;
@@ -61,6 +1977,7 @@ var TelegramChannel = class {
 		const state = this.streamState.get(jid);
 		const { text: formatted, parse_mode } = formatForTelegram(text);
 		const parseMode = { parse_mode };
+		const plainText = stripThinkingTags(text);
 		if (state) {
 			this.streamState.delete(jid);
 			if (state.editTimer) clearTimeout(state.editTimer);
@@ -73,13 +1990,43 @@ var TelegramChannel = class {
 					...parseMode
 				});
 				return;
-			} catch {}
+			} catch (editErr) {
+				if (isTgParseError(editErr)) try {
+					logger$3.debug({
+						err: editErr,
+						formattedText: formatted.slice(0, 500),
+						originalText: text.slice(0, 500)
+					}, "HTML edit failed, retrying as plain text");
+					await this.api("editMessageText", {
+						chat_id: chatId,
+						message_id: state.messageId,
+						text: plainText.slice(0, TG_MAX_TEXT)
+					});
+					return;
+				} catch (plainErr) {
+					logger$3.debug({ err: plainErr }, "Plain-text edit also failed, sending new message");
+				}
+			}
+		}
+		try {
+			await this.api("sendMessage", {
+				chat_id: chatId,
+				text: formatted,
+				...parseMode
+			});
+		} catch (err) {
+			if (isTgParseError(err)) {
+				logger$3.debug({
+					err,
+					formattedText: formatted.slice(0, 500),
+					originalText: text.slice(0, 500)
+				}, "HTML send failed, retrying as plain text");
+				await this.api("sendMessage", {
+					chat_id: chatId,
+					text: plainText
+				});
+			} else throw err;
 		}
-		await this.api("sendMessage", {
-			chat_id: chatId,
-			text: formatted,
-			...parseMode
-		});
 	}
 	isConnected() {
 		return this.connected;
@@ -113,16 +2060,69 @@ var TelegramChannel = class {
 		switch (event.type) {
 			case "thinking_delta": {
 				const state = this.getOrCreateStreamState(jid);
-				state.thinkingText += event.delta || "";
+				const last = state.details[state.details.length - 1];
+				if (last && last.type === "thinking") last.text += event.delta || "";
+				else state.details.push({
+					type: "thinking",
+					text: event.delta || ""
+				});
 				this.scheduleStreamEdit(jid, state);
 				break;
 			}
 			case "text_delta": {
 				const state = this.getOrCreateStreamState(jid);
-				state.text += event.delta || "";
+				const last = state.details[state.details.length - 1];
+				if (last && last.type === "text") last.text += event.delta || "";
+				else state.details.push({
+					type: "text",
+					text: event.delta || ""
+				});
+				this.scheduleStreamEdit(jid, state);
+				break;
+			}
+			case "tool_start": {
+				const state = this.getOrCreateStreamState(jid);
+				const tool = {
+					name: event.toolName || "tool",
+					done: false
+				};
+				state.tools.push(tool);
+				state.details.push({
+					type: "tool",
+					tool
+				});
 				this.scheduleStreamEdit(jid, state);
 				break;
 			}
+			case "tool_end": {
+				const state = this.getOrCreateStreamState(jid);
+				for (let i = state.tools.length - 1; i >= 0; i--) {
+					const t = state.tools[i];
+					if (t.name === event.toolName && !t.done) {
+						t.done = true;
+						t.isError = event.isError;
+						t.resultPreview = event.resultPreview;
+						break;
+					}
+				}
+				this.scheduleStreamEdit(jid, state);
+				break;
+			}
+			case "error": {
+				const state = this.getOrCreateStreamState(jid);
+				if (state.editTimer) {
+					clearTimeout(state.editTimer);
+					state.editTimer = null;
+				}
+				const errorMsg = event.error || "Unknown error";
+				const chatId = jid.slice(3);
+				this.api("sendMessage", {
+					chat_id: chatId,
+					text: `⚠️ ${errorMsg}`
+				}).catch(() => {});
+				this.streamState.delete(jid);
+				break;
+			}
 			case "text_end":
 			case "agent_end": {
 				const state = this.streamState.get(jid);
@@ -139,8 +2139,8 @@ var TelegramChannel = class {
 		if (!state) {
 			state = {
 				chatId: jid.slice(3),
-				text: "",
-				thinkingText: "",
+				details: [],
+				tools: [],
 				messageId: null,
 				sendPromise: null,
 				lastEdit: 0,
@@ -162,42 +2162,83 @@ var TelegramChannel = class {
 		}, delay);
 	}
 	async flushStreamEdit(jid, state) {
+		if (!this.streamState.has(jid)) return;
 		if (state.sendPromise) {
 			await state.sendPromise.catch(() => {});
 			state.sendPromise = null;
 		}
-		const display = state.text.trim() || (state.thinkingText.trim() ? `<thinking>${state.thinkingText.trim()}</thinking>` : "");
-		if (!display) return;
-		const { text: formatted, parse_mode } = formatForTelegram(display.length > TG_MAX_TEXT ? display.slice(0, TG_MAX_TEXT - 1) + "…" : display);
-		const snapshotLen = display.length;
-		try {
+		if (!this.streamState.has(jid)) return;
+		const htmlParts = [];
+		let toolBuf = [];
+		const flushTools = () => {
+			if (!toolBuf.length) return;
+			htmlParts.push(formatToolLines(toolBuf));
+			toolBuf = [];
+		};
+		for (const item of state.details) if (item.type === "tool") toolBuf.push(item.tool);
+		else if (item.type === "thinking") {
+			flushTools();
+			const trimmed = item.text.trim().replace(/\*\*/g, "");
+			if (trimmed) htmlParts.push(`💭 <b>${escHtml(trimmed)}</b>`);
+		} else {
+			flushTools();
+			const clean = stripInternalTags(item.text).trim();
+			if (clean) {
+				const truncated = clean.length > TG_MAX_TEXT ? clean.slice(0, TG_MAX_TEXT - 1) + "…" : clean;
+				htmlParts.push(formatForTelegram(truncated).text);
+			}
+		}
+		flushTools();
+		if (!htmlParts.length) return;
+		htmlParts.push("⏳");
+		const formatted = htmlParts.join("\n\n");
+		const parse_mode = "HTML";
+		const snapshotLen = detailsTextLen(state.details);
+		const streamApiOpts = { maxRetryWait: 5 };
+		const sendOrEdit = async (text, parseMode) => {
+			if (!this.streamState.has(jid)) return;
+			const body = {
+				chat_id: state.chatId,
+				text
+			};
+			if (parseMode) body.parse_mode = parseMode;
 			if (state.messageId === null) {
-				state.sendPromise = this.api("sendMessage", {
-					chat_id: state.chatId,
-					text: formatted,
-					parse_mode
-				}).then((msg) => {
+				state.sendPromise = this.api("sendMessage", body, streamApiOpts).then((msg) => {
 					state.messageId = msg.message_id;
 					state.sendPromise = null;
 				});
 				await state.sendPromise;
-			} else await this.api("editMessageText", {
-				chat_id: state.chatId,
-				message_id: state.messageId,
-				text: formatted,
-				parse_mode
-			});
+			} else {
+				body.message_id = state.messageId;
+				await this.api("editMessageText", body, streamApiOpts);
+			}
+		};
+		try {
+			await sendOrEdit(formatted, parse_mode);
 			state.lastEdit = Date.now();
 			state.throttleMs = Math.max(STREAM_THROTTLE_MIN, state.throttleMs - 50);
 		} catch (err) {
-			const retryAfterMs = getRetryAfterMs(err);
-			if (retryAfterMs > 0) state.throttleMs = Math.min(STREAM_THROTTLE_MAX, Math.max(state.throttleMs + STREAM_THROTTLE_STEP, retryAfterMs));
-			logger$3.debug({
-				err,
-				throttleMs: state.throttleMs
-			}, "Stream edit failed");
+			if (isTgParseError(err)) {
+				logger$3.debug({
+					err,
+					formattedText: formatted.slice(0, 500)
+				}, "Stream HTML failed, retrying as plain text");
+				try {
+					await sendOrEdit(stripHtmlTags(formatted).slice(0, TG_MAX_TEXT));
+					state.lastEdit = Date.now();
+				} catch (retryErr) {
+					logger$3.debug({ err: retryErr }, "Stream plain-text fallback also failed");
+				}
+			} else if (isTgMessageNotModified(err)) {} else {
+				const retryAfterMs = getRetryAfterMs(err);
+				if (retryAfterMs > 0) state.throttleMs = Math.min(STREAM_THROTTLE_MAX, Math.max(state.throttleMs + STREAM_THROTTLE_STEP, retryAfterMs));
+				logger$3.debug({
+					err,
+					throttleMs: state.throttleMs
+				}, "Stream edit failed");
+			}
 		}
-		if ((state.text.trim() || (state.thinkingText.trim() ? `<thinking>${state.thinkingText.trim()}</thinking>` : "")).length > snapshotLen && this.streamState.has(jid)) this.scheduleStreamEdit(jid, state);
+		if (detailsTextLen(state.details) > snapshotLen && this.streamState.has(jid)) this.scheduleStreamEdit(jid, state);
 	}
 	startPolling() {
 		this.stopPolling();
@@ -219,17 +2260,17 @@ var TelegramChannel = class {
 				const res = await fetch(`${API_BASE}${this.config.botToken}/getUpdates?${params}`, { signal });
 				if (!res.ok) {
 					if (res.status === 409) {
-						logger$3.warn("Telegram 409 conflict: another polling instance is active, retrying in 30s");
+						logger$3.debug("Telegram 409 conflict: another polling instance is active, retrying in 30s");
 						await sleep(3e4, signal);
 						continue;
 					}
-					logger$3.warn({ status: res.status }, "Telegram getUpdates HTTP error");
+					logger$3.debug({ status: res.status }, "Telegram getUpdates HTTP error");
 					await sleep(POLL_INTERVAL, signal);
 					continue;
 				}
 				const data = await res.json();
 				if (!data.ok) {
-					logger$3.warn({ description: data.description }, "Telegram getUpdates API error");
+					logger$3.debug({ description: data.description }, "Telegram getUpdates API error");
 					await sleep(POLL_INTERVAL, signal);
 					continue;
 				}
@@ -240,7 +2281,7 @@ var TelegramChannel = class {
 				}
 			} catch (err) {
 				if (signal.aborted) break;
-				logger$3.warn({ err }, "Telegram polling error");
+				logger$3.debug({ err }, "Telegram polling error");
 				await sleep(POLL_INTERVAL, signal);
 			}
 		};
@@ -250,37 +2291,120 @@ var TelegramChannel = class {
 		this.pollAbort?.abort();
 		this.pollAbort = null;
 	}
-	async api(method, body) {
+	async api(method, body, opts, _retries = 0) {
 		const res = await fetch(`${API_BASE}${this.config.botToken}/${method}`, {
 			method: "POST",
 			headers: { "content-type": "application/json" },
 			body: body ? JSON.stringify(body) : void 0
 		});
 		const data = await res.json();
-		if (!data.ok) throw new TelegramApiError(method, data.description || "unknown error", res.status, data);
+		if (!data.ok) {
+			if (res.status === 429 && _retries < 2) {
+				const retryAfter = Number(data.parameters?.retry_after || 5);
+				const maxWait = opts?.maxRetryWait ?? 30;
+				if (retryAfter > maxWait) {
+					logger$3.debug({
+						method,
+						retryAfter,
+						maxWait
+					}, "Telegram 429 retry_after exceeds max wait, skipping retry");
+					throw new TelegramApiError(method, data.description || "unknown error", res.status, data);
+				}
+				logger$3.debug({
+					method,
+					retryAfter,
+					attempt: _retries + 1
+				}, "Telegram 429 rate limit, waiting");
+				await sleep(retryAfter * 1e3);
+				return this.api(method, body, opts, _retries + 1);
+			}
+			throw new TelegramApiError(method, data.description || "unknown error", res.status, data);
+		}
 		return data.result;
 	}
 	handleUpdate(update) {
 		const message = update.message || update.edited_message || update.channel_post;
-		if (!message?.text) return;
+		if (!message) return;
+		if (!(message.text || message.caption || message.photo || message.document || message.voice || message.audio || message.video || message.video_note || message.sticker)) return;
 		if (message.from?.id === this.botId) return;
 		const chatId = String(message.chat.id);
 		const jid = `${JID_PREFIX}${chatId}`;
 		const isGroup = message.chat.type === "group" || message.chat.type === "supergroup";
 		const senderName = message.from ? [message.from.first_name, message.from.last_name].filter(Boolean).join(" ") : message.chat.title || chatId;
 		const now = (/* @__PURE__ */ new Date(message.date * 1e3)).toISOString();
+		const msgId = crypto.randomUUID();
 		const msg = {
-			id: crypto.randomUUID(),
+			id: msgId,
 			chat_jid: jid,
 			sender: String(message.from?.id || chatId),
 			sender_name: senderName,
-			content: message.text,
+			content: message.text || message.caption || "",
 			timestamp: now,
 			is_from_me: false,
 			is_bot_message: false
 		};
-		this.opts.onMessage(jid, msg);
-		this.opts.onChatMetadata(jid, now, senderName, "telegram", isGroup);
+		const group = this.opts.registeredGroups()[jid];
+		(group ? this.downloadMedia(message, msgId, group.folder) : Promise.resolve([])).then((attachments) => {
+			if (attachments.length) msg.meta = { attachments };
+			this.opts.onMessage(jid, msg);
+			this.opts.onChatMetadata(jid, now, senderName, "telegram", isGroup);
+		}).catch((err) => {
+			logger$3.debug({ err }, "Failed to download Telegram media, sending text-only");
+			this.opts.onMessage(jid, msg);
+			this.opts.onChatMetadata(jid, now, senderName, "telegram", isGroup);
+		});
+	}
+	async downloadMedia(message, msgId, groupFolder) {
+		const attachments = [];
+		if (message.photo?.length) {
+			const photo = message.photo[message.photo.length - 1];
+			const att = await this.downloadTelegramFile(photo.file_id, groupFolder, msgId, "photo.jpg", "image/jpeg");
+			if (att) attachments.push(att);
+		}
+		if (message.document) {
+			const att = await this.downloadTelegramFile(message.document.file_id, groupFolder, msgId, message.document.file_name || "document", message.document.mime_type || getMimeType(message.document.file_name || "document"));
+			if (att) attachments.push(att);
+		}
+		if (message.voice) {
+			const att = await this.downloadTelegramFile(message.voice.file_id, groupFolder, msgId, "voice.ogg", message.voice.mime_type || "audio/ogg");
+			if (att) attachments.push(att);
+		}
+		if (message.audio) {
+			const att = await this.downloadTelegramFile(message.audio.file_id, groupFolder, msgId, message.audio.file_name || "audio.mp3", message.audio.mime_type || "audio/mpeg");
+			if (att) attachments.push(att);
+		}
+		if (message.video) {
+			const att = await this.downloadTelegramFile(message.video.file_id, groupFolder, msgId, message.video.file_name || "video.mp4", message.video.mime_type || "video/mp4");
+			if (att) attachments.push(att);
+		}
+		if (message.video_note) {
+			const att = await this.downloadTelegramFile(message.video_note.file_id, groupFolder, msgId, "video_note.mp4", "video/mp4");
+			if (att) attachments.push(att);
+		}
+		if (message.sticker && !message.sticker.is_animated) {
+			const att = await this.downloadTelegramFile(message.sticker.file_id, groupFolder, msgId, "sticker.webp", "image/webp");
+			if (att) attachments.push(att);
+		}
+		return attachments;
+	}
+	async downloadTelegramFile(fileId, groupFolder, msgId, name, mimeType) {
+		try {
+			const fileInfo = await this.api("getFile", { file_id: fileId });
+			const url = `https://api.telegram.org/file/bot${this.config.botToken}/${fileInfo.file_path}`;
+			const res = await fetch(url);
+			if (!res.ok) return null;
+			return saveAttachment(groupFolder, msgId, {
+				data: Buffer.from(await res.arrayBuffer()).toString("base64"),
+				mimeType,
+				name
+			});
+		} catch (err) {
+			logger$3.debug({
+				err,
+				fileId
+			}, "Failed to download Telegram file");
+			return null;
+		}
 	}
 };
 var TelegramApiError = class extends Error {
@@ -291,39 +2415,28 @@ var TelegramApiError = class extends Error {
 		this.response = response;
 	}
 };
-/** Format message text as Telegram MarkdownV2 — parse with md4x, render AST to TG format */
+/** Format message text as Telegram HTML — parse markdown with md4x, render AST to HTML tags */
 function formatForTelegram(text) {
 	let remaining = text.replace(/<\/?internal>/g, (t) => t.replace("internal", "thinking"));
-	const parts = [];
-	const thinkingRe = /<thinking>([\s\S]*?)<\/thinking>/g;
-	let lastIdx = 0;
-	let m;
-	while ((m = thinkingRe.exec(remaining)) !== null) {
-		if (m.index > lastIdx) parts.push(mdToTgV2(remaining.slice(lastIdx, m.index)));
-		const trimmed = (m[1] || "").trim();
-		if (trimmed) {
-			const quoted = escTgV2(trimmed).split("\n").map((l) => `>${l}`).join("\n");
-			parts.push(quoted);
-		}
-		lastIdx = m.index + m[0].length;
-	}
-	if (lastIdx < remaining.length) parts.push(mdToTgV2(remaining.slice(lastIdx)));
+	remaining = remaining.replace(/<tool\s+name="[^"]*"\s+status="[^"]*"(?:\s+preview="[^"]*")?\s*\/>/g, "");
+	remaining = remaining.replace(/<details><summary>thinking<\/summary>[\s\S]*?<\/details>/g, "");
+	remaining = remaining.replace(/<thinking>[\s\S]*?<\/thinking>/g, "");
 	return {
-		text: parts.join("").replace(/\n{3,}/g, "\n\n").trim(),
-		parse_mode: "MarkdownV2"
+		text: [mdToTgHtml(remaining)].join("").replace(/\n{3,}/g, "\n\n").trim(),
+		parse_mode: "HTML"
 	};
 }
-/** Parse markdown with md4x and render AST nodes to Telegram MarkdownV2 */
-function mdToTgV2(text) {
-	return parseAST(text).nodes.map((node) => renderNode(node, true)).join("\n\n");
+/** Parse markdown with md4x and render AST nodes to Telegram HTML */
+function mdToTgHtml(text) {
+	return parseAST(text).nodes.map((node) => renderNode(node)).join("\n\n");
 }
-/** Collect raw text from children (for code content that must not be escaped) */
+/** Collect raw text from children recursively (for code content that must not be escaped) */
 function collectText(children) {
-	return children.map((c) => typeof c === "string" ? c : "").join("");
+	return children.map((c) => typeof c === "string" ? c : collectText(c.slice(2))).join("");
 }
-/** Render a single AST node to Telegram MarkdownV2 */
-function renderNode(node, topLevel = false) {
-	if (typeof node === "string") return escTgV2(node);
+/** Render a single AST node to Telegram HTML */
+function renderNode(node) {
+	if (typeof node === "string") return escHtml(node);
 	const [tag, attrs, ...children] = node;
 	const inner = () => children.map((c) => renderNode(c)).join("");
 	switch (tag) {
@@ -333,42 +2446,44 @@ function renderNode(node, topLevel = false) {
 		case "h3":
 		case "h4":
 		case "h5":
-		case "h6": return `*${inner()}*`;
-		case "strong": return `*${inner()}*`;
-		case "em": return `_${inner()}_`;
-		case "u": return `__${inner()}__`;
-		case "del": return `~${inner()}~`;
-		case "code":
-			if (!topLevel) return collectText(children);
-			return `\`${collectText(children)}\``;
+		case "h6": return `<b>${inner()}</b>`;
+		case "strong": return `<b>${inner()}</b>`;
+		case "em": return `<i>${inner()}</i>`;
+		case "u": return `<u>${inner()}</u>`;
+		case "del": return `<s>${inner()}</s>`;
+		case "code": return `<code>${escHtml(collectText(children))}</code>`;
 		case "pre": {
 			const codeNode = children.find((c) => typeof c !== "string" && c[0] === "code");
-			return `\`\`\`${String(attrs.language || "")}\n${(codeNode ? collectText(codeNode.slice(2)) : inner()).replace(/\n$/, "")}\n\`\`\``;
+			const lang = String(attrs.language || "");
+			const raw = codeNode ? collectText(codeNode.slice(2)) : collectText(children);
+			if (!raw.trim() && !lang) return "";
+			return `<pre><code${lang ? ` class="language-${escHtml(lang)}"` : ""}>${escHtml(raw.replace(/\n$/, ""))}</code></pre>`;
 		}
-		case "a": {
-			const href = String(attrs.href || "");
-			return `[${inner()}](${escTgUrl(href)})`;
-		}
-		case "img": return escTgV2(String(attrs.alt || "image"));
-		case "blockquote": return inner().split("\n").map((l) => `>${l}`).join("\n");
+		case "a": return `<a href="${escHtml(String(attrs.href || ""))}">${inner()}</a>`;
+		case "img": return escHtml(String(attrs.alt || "image"));
+		case "blockquote": return `<blockquote>${inner()}</blockquote>`;
 		case "ul":
 		case "ol": return children.map((c, i) => {
-			if (typeof c === "string") return escTgV2(c);
-			return (tag === "ol" ? `${escTgV2(`${i + 1}.`)} ` : `${escTgV2("•")} `) + renderNode(c);
+			if (typeof c === "string") return escHtml(c);
+			return (tag === "ol" ? `${i + 1}. ` : "• ") + renderNode(c);
 		}).filter((l) => l.trim()).join("\n");
 		case "li": return inner();
-		case "hr": return escTgV2("---");
+		case "hr": return "---";
 		case "br": return "\n";
 		default: return inner();
 	}
 }
-/** Escape special characters for Telegram MarkdownV2 outside code spans */
-function escTgV2(s) {
-	return s.replace(/([_*[\]()~`>#+=|{}.!\\-])/g, "\\$1");
+/** Escape HTML entities for Telegram HTML mode */
+function escHtml(s) {
+	return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+/** Check if a Telegram API error is an HTML parse failure */
+function isTgParseError(err) {
+	return err instanceof TelegramApiError && err.status === 400 && typeof err.response?.description === "string" && err.response.description.includes("can't parse entities");
 }
-/** Escape only ) and \ inside MarkdownV2 link URLs */
-function escTgUrl(s) {
-	return s.replace(/([)\\])/g, "\\$1");
+/** Check if a Telegram API error is "message is not modified" (identical content edit) */
+function isTgMessageNotModified(err) {
+	return err instanceof TelegramApiError && err.status === 400 && typeof err.response?.description === "string" && err.response.description.includes("message is not modified");
 }
 function getRetryAfterMs(err) {
 	if (!(err instanceof TelegramApiError)) return 0;
@@ -376,6 +2491,40 @@ function getRetryAfterMs(err) {
 	if (!Number.isFinite(retryAfterSec) || retryAfterSec <= 0) return 0;
 	return retryAfterSec * 1e3;
 }
+/** Verbose tool lines with result previews — used during streaming */
+function formatToolLines(tools) {
+	return tools.map((t) => {
+		const icon = t.done ? t.isError ? "❌" : "✅" : "🔧";
+		const preview = t.done && t.resultPreview ? `  ${tgToolPreview(t.resultPreview)}` : "";
+		return `${icon} ${escHtml(t.name)}${preview}`;
+	}).join("\n");
+}
+function detailsTextLen(details) {
+	let len = 0;
+	for (const d of details) len += d.type === "tool" ? 1 : d.text.length;
+	return len;
+}
+function tgToolPreview(raw) {
+	const firstLine = extractToolResultText(raw, 200).split("\n")[0] || "";
+	return escHtml(firstLine.length > 80 ? firstLine.slice(0, 79) + "…" : firstLine);
+}
+/** Strip <internal>/<thinking> tags from streamed text (handles partial/unclosed tags mid-stream) */
+function stripInternalTags(text) {
+	let s = text.replace(/<(internal|thinking)>[\s\S]*?<\/\1>/g, "");
+	s = s.replace(/<(internal|thinking)>[\s\S]*$/, "");
+	s = s.replace(/<(?:internal|thinking|intern|inter|inte|int|in|i|thinkin|thinki|think|thin|thi|th|t)?$/i, "");
+	return s;
+}
+/** Strip <internal>/<thinking>/tool tags for plain-text fallback — keeps inner content */
+function stripHtmlTags(html) {
+	return html.replace(/<[^>]*>/g, "");
+}
+function stripThinkingTags(text) {
+	let s = text.replace(/<\/?(internal|thinking)>/g, "");
+	s = s.replace(/<details><summary>thinking<\/summary>([\s\S]*?)<\/details>/g, "$1");
+	s = s.replace(/<tool\s+name="([^"]+)"\s+status="[^"]*"(?:\s+preview="[^"]*")?\s*\/>/g, "[$1]");
+	return s;
+}
 function randomJitter(maxAbs) {
 	return Math.round((Math.random() * 2 - 1) * maxAbs);
 }
@@ -449,16 +2598,18 @@ var GroupQueue = class {
 		this.drain();
 	}
 	drain() {
+		const deferred = [];
 		while (this.active.size < config.get("maxConcurrentAgents") && this.queue.length > 0) {
 			const entry = this.queue.shift();
 			if (!entry) break;
 			if (this.active.has(entry.chatJid)) {
-				this.queue.push(entry);
-				break;
+				deferred.push(entry);
+				continue;
 			}
 			this.active.add(entry.chatJid);
 			this.processEntry(entry);
 		}
+		this.queue.push(...deferred);
 	}
 	async processEntry(entry) {
 		try {
@@ -500,7 +2651,14 @@ function escapeXml(s) {
 }
 /** Format messages into XML for the agent prompt */
 function formatMessages(messages) {
-	return `<messages>\n${messages.map((m) => `<message sender="${escapeXml(m.sender_name)}" time="${m.timestamp}">${escapeXml(m.content)}</message>`).join("\n")}\n</messages>`;
+	return `<messages>\n${messages.map((m) => {
+		let body = escapeXml(m.content);
+		if (m.meta?.attachments?.length) body += m.meta.attachments.map((a) => {
+			const fileAttr = a.mimeType.startsWith("image/") ? "" : ` file="downloads/${a.path.split("/").slice(1).join("/")}"`;
+			return `\n<attachment name="${escapeXml(a.name)}" type="${a.mimeType}"${fileAttr}/>`;
+		}).join("");
+		return `<message sender="${escapeXml(m.sender_name)}" time="${m.timestamp}">${body}</message>`;
+	}).join("\n")}\n</messages>`;
 }
 /** Format outbound text */
 function formatOutbound(rawText) {
@@ -510,7 +2668,9 @@ function formatOutbound(rawText) {
 function needsProcessing(group, messages) {
 	if (group.folder === "main") return true;
 	if (group.requiresTrigger === false) return true;
-	return messages.some((m) => config.triggerPattern().test(m.content.trim()));
+	const trigger = group.trigger || `@${config.get("assistantName")}`;
+	const pattern = new RegExp(`^${trigger.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "i");
+	return messages.some((m) => pattern.test(m.content.trim()));
 }
 /**
 * Task scheduler — runs scheduled tasks (cron/interval/once) using the pi agent.
@@ -722,7 +2882,7 @@ var PiClawServer = class {
 			folder: group.folder
 		}, "Group unregistered");
 	}
-	async sendBotMessage(chatJid, text) {
+	async sendBotMessage(chatJid, text, meta) {
 		const now = (/* @__PURE__ */ new Date()).toISOString();
 		await storeChatMetadata(chatJid, now);
 		await storeMessage({
@@ -733,8 +2893,10 @@ var PiClawServer = class {
 			content: text,
 			timestamp: now,
 			is_from_me: true,
-			is_bot_message: true
+			is_bot_message: true,
+			meta
 		});
+		deviceBus.emitDeviceEvent("chats");
 		for (const ch of this.channels) if (ch.ownsJid(chatJid)) {
 			ch.sendMessage(chatJid, text).catch((err) => {
 				logger.error({
@@ -749,7 +2911,7 @@ var PiClawServer = class {
 	/** Full cleanup: kill agent, remove session/tasks/chat/group data */
 	async cleanupChat(jid) {
 		const group = this.registeredGroups[jid];
-		this.pi.kill(jid);
+		await this.pi.kill(jid);
 		if (group) {
 			await removeSession(group.folder);
 			const sessionDir = path$1.join(SESSIONS_DIR, group.folder);
@@ -785,8 +2947,18 @@ var PiClawServer = class {
 		return new TelegramChannel({
 			onMessage: async (jid, msg) => {
 				await storeChatMetadata(jid, msg.timestamp, msg.sender_name, "telegram");
+				const group = this.registeredGroups[jid];
+				if (group) {
+					const trimmed = msg.content.trim();
+					if (tryPriorityCommand({
+						chatJid: jid,
+						group,
+						server: this
+					}, trimmed)) return;
+				}
 				await storeMessage(msg);
-				if (this.registeredGroups[jid]) this.queue.enqueueMessageCheck(jid);
+				if (group) if (this.pi.sendMessage(jid, formatMessages([msg]))) await this.advanceCursor(jid, msg.timestamp);
+				else this.queue.enqueueMessageCheck(jid);
 				else await this.notifyUnregistered(jid);
 			},
 			onChatMetadata: async (jid, ts, name, channel, isGroup) => {
@@ -870,18 +3042,22 @@ var PiClawServer = class {
 		await setRouterState("last_timestamp", this.lastTimestamp);
 		await setRouterState("last_agent_timestamp", JSON.stringify(this.lastAgentTimestamp));
 	}
+	/** Advance the agent cursor for a chat — marks messages up to `timestamp` as processed. */
+	async advanceCursor(chatJid, timestamp) {
+		this.lastAgentTimestamp[chatJid] = timestamp;
+		await this.saveState();
+	}
 	async handleCommands(chatJid, messages) {
 		const group = this.registeredGroups[chatJid];
 		if (!group) return messages;
 		const remaining = [];
 		for (const msg of messages) {
 			const text = msg.content.trim();
-			const ctx = {
+			if (!await tryCommand({
 				chatJid,
 				group,
 				server: this
-			};
-			if (!(tryBashCommand(ctx, text) || await tryCommand(ctx, text))) remaining.push(msg);
+			}, text)) remaining.push(msg);
 		}
 		return remaining;
 	}
@@ -900,6 +3076,18 @@ var PiClawServer = class {
 		if (!needsProcessing(group, agentMessages)) return true;
 		const prompt = formatMessages(agentMessages);
 		const lastMessageTimestamp = missedMessages[missedMessages.length - 1].timestamp;
+		const images = [];
+		for (const msg of agentMessages) if (msg.meta?.attachments) {
+			for (const att of msg.meta.attachments) if (isImageMimeType(att.mimeType)) try {
+				images.push({
+					type: "image",
+					data: readAttachmentBase64(group.folder, att),
+					mimeType: att.mimeType
+				});
+			} catch {
+				logger.warn({ attachment: att.path }, "Failed to read attachment");
+			}
+		}
 		if (!resolveGroupModel(group)) {
 			logger.warn({ group: group.name }, "No model available, notifying user");
 			await this.sendBotMessage(chatJid, "No AI model is currently available. Please configure a provider API key or log in via the admin panel.");
@@ -917,6 +3105,7 @@ var PiClawServer = class {
 		try {
 			await this.pi.run(group, {
 				prompt,
+				images: images.length ? images : void 0,
 				sessionId: this.sessions[group.folder],
 				groupFolder: group.folder,
 				chatJid,
@@ -980,21 +3169,12 @@ var PiClawServer = class {
 						for (const [chatJid, groupMessages] of byGroup) {
 							const group = this.registeredGroups[chatJid];
 							if (!group) continue;
-							for (const msg of groupMessages) {
-								const ctx = {
-									chatJid,
-									group,
-									server: this
-								};
-								tryBashCommand(ctx, msg.content.trim());
-								tryPriorityCommand(ctx, msg.content.trim());
-							}
 							if (!needsProcessing(group, groupMessages)) continue;
 							this.queue.enqueueMessageCheck(chatJid);
 						}
 					}
 				} catch (err) {
-					logger.error({ err }, "Error in message loop");
+					logger.error({ err: err?.stack || err?.message || err }, "Error in message loop");
 				}
 				await new Promise((resolve) => {
 					const timer = setTimeout(resolve, config.get("pollInterval"));
@@ -1028,4 +3208,4 @@ const startTime = globalThis.__piclaw_start_time__ || performance.now();
 const server = new PiClawServer();
 await server.start();
 var server_default = () => {};
-export { server_default as n, startTime as r, server as t };
+export { commandDescriptions as a, authStorage as c, getSystemInfo as d, formatMessages as i, getFilteredModels as l, server_default as n, tryPriorityCommand as o, startTime as r, getPiSdkStatus as s, server as t, modelRegistry as u };