@poolzin/pool-bot 2026.3.25 → 2026.3.26

package/dist/auto-reply/auto-reply/reply/commands-context-report.js

@@ -0,0 +1,295 @@
+import { resolveSessionAgentIds } from "../../agents/agent-scope.js";
+import { resolveBootstrapMaxChars } from "../../agents/pi-embedded-helpers.js";
+import { createPoolbotCodingTools } from "../../agents/pi-tools.js";
+import { resolveSandboxRuntimeStatus } from "../../agents/sandbox.js";
+import { buildWorkspaceSkillSnapshot } from "../../agents/skills.js";
+import { getSkillsSnapshotVersion } from "../../agents/skills/refresh.js";
+import { buildAgentSystemPrompt } from "../../agents/system-prompt.js";
+import { buildSystemPromptReport } from "../../agents/system-prompt-report.js";
+import { buildSystemPromptParams } from "../../agents/system-prompt-params.js";
+import { resolveDefaultModelForAgent } from "../../agents/model-selection.js";
+import { buildToolSummaryMap } from "../../agents/tool-summaries.js";
+import { resolveBootstrapContextForRun } from "../../agents/bootstrap-files.js";
+import { getRemoteSkillEligibility } from "../../infra/skills-remote.js";
+import { buildTtsSystemPromptHint } from "../../tts/tts.js";
+function estimateTokensFromChars(chars) {
+    return Math.ceil(Math.max(0, chars) / 4);
+}
+function formatInt(n) {
+    return new Intl.NumberFormat("en-US").format(n);
+}
+function formatCharsAndTokens(chars) {
+    return `${formatInt(chars)} chars (~${formatInt(estimateTokensFromChars(chars))} tok)`;
+}
+function parseContextArgs(commandBodyNormalized) {
+    if (commandBodyNormalized === "/context")
+        return "";
+    if (commandBodyNormalized.startsWith("/context "))
+        return commandBodyNormalized.slice(8).trim();
+    return "";
+}
+function formatListTop(entries, cap) {
+    const sorted = [...entries].sort((a, b) => b.value - a.value);
+    const top = sorted.slice(0, cap);
+    const omitted = Math.max(0, sorted.length - top.length);
+    const lines = top.map((e) => `- ${e.name}: ${formatCharsAndTokens(e.value)}`);
+    return { lines, omitted };
+}
+async function resolveContextReport(params) {
+    const existing = params.sessionEntry?.systemPromptReport;
+    if (existing && existing.source === "run")
+        return existing;
+    const workspaceDir = params.workspaceDir;
+    const bootstrapMaxChars = resolveBootstrapMaxChars(params.cfg);
+    const { bootstrapFiles, contextFiles: injectedFiles } = await resolveBootstrapContextForRun({
+        workspaceDir,
+        config: params.cfg,
+        sessionKey: params.sessionKey,
+        sessionId: params.sessionEntry?.sessionId,
+    });
+    const skillsSnapshot = (() => {
+        try {
+            return buildWorkspaceSkillSnapshot(workspaceDir, {
+                config: params.cfg,
+                eligibility: { remote: getRemoteSkillEligibility() },
+                snapshotVersion: getSkillsSnapshotVersion(workspaceDir),
+            });
+        }
+        catch {
+            return { prompt: "", skills: [], resolvedSkills: [] };
+        }
+    })();
+    const skillsPrompt = skillsSnapshot.prompt ?? "";
+    const sandboxRuntime = resolveSandboxRuntimeStatus({
+        cfg: params.cfg,
+        sessionKey: params.ctx.SessionKey ?? params.sessionKey,
+    });
+    const tools = (() => {
+        try {
+            return createPoolbotCodingTools({
+                config: params.cfg,
+                workspaceDir,
+                sessionKey: params.sessionKey,
+                messageProvider: params.command.channel,
+                groupId: params.sessionEntry?.groupId ?? undefined,
+                groupChannel: params.sessionEntry?.groupChannel ?? undefined,
+                groupSpace: params.sessionEntry?.space ?? undefined,
+                spawnedBy: params.sessionEntry?.spawnedBy ?? undefined,
+                senderIsOwner: params.command.senderIsOwner,
+                modelProvider: params.provider,
+                modelId: params.model,
+            });
+        }
+        catch {
+            return [];
+        }
+    })();
+    const toolSummaries = buildToolSummaryMap(tools);
+    const toolNames = tools.map((t) => t.name);
+    const { sessionAgentId } = resolveSessionAgentIds({
+        sessionKey: params.sessionKey,
+        config: params.cfg,
+    });
+    const defaultModelRef = resolveDefaultModelForAgent({
+        cfg: params.cfg,
+        agentId: sessionAgentId,
+    });
+    const defaultModelLabel = `${defaultModelRef.provider}/${defaultModelRef.model}`;
+    const { runtimeInfo, userTimezone, userTime, userTimeFormat } = buildSystemPromptParams({
+        config: params.cfg,
+        agentId: sessionAgentId,
+        workspaceDir,
+        cwd: process.cwd(),
+        runtime: {
+            host: "unknown",
+            os: "unknown",
+            arch: "unknown",
+            node: process.version,
+            model: `${params.provider}/${params.model}`,
+            defaultModel: defaultModelLabel,
+        },
+    });
+    const sandboxInfo = sandboxRuntime.sandboxed
+        ? {
+            enabled: true,
+            workspaceDir,
+            workspaceAccess: "rw",
+            elevated: {
+                allowed: params.elevated.allowed,
+                defaultLevel: (params.resolvedElevatedLevel ?? "off"),
+            },
+        }
+        : { enabled: false };
+    const ttsHint = params.cfg ? buildTtsSystemPromptHint(params.cfg) : undefined;
+    const systemPrompt = buildAgentSystemPrompt({
+        workspaceDir,
+        defaultThinkLevel: params.resolvedThinkLevel,
+        reasoningLevel: params.resolvedReasoningLevel,
+        extraSystemPrompt: undefined,
+        ownerNumbers: undefined,
+        reasoningTagHint: false,
+        toolNames,
+        toolSummaries,
+        modelAliasLines: [],
+        userTimezone,
+        userTime,
+        userTimeFormat,
+        contextFiles: injectedFiles,
+        skillsPrompt,
+        heartbeatPrompt: undefined,
+        ttsHint,
+        runtimeInfo,
+        sandboxInfo,
+    });
+    return buildSystemPromptReport({
+        source: "estimate",
+        generatedAt: Date.now(),
+        sessionId: params.sessionEntry?.sessionId,
+        sessionKey: params.sessionKey,
+        provider: params.provider,
+        model: params.model,
+        workspaceDir,
+        bootstrapMaxChars,
+        sandbox: { mode: sandboxRuntime.mode, sandboxed: sandboxRuntime.sandboxed },
+        systemPrompt,
+        bootstrapFiles,
+        injectedFiles,
+        skillsPrompt,
+        tools,
+    });
+}
+export async function buildContextReply(params) {
+    const args = parseContextArgs(params.command.commandBodyNormalized);
+    const sub = args.split(/\s+/).filter(Boolean)[0]?.toLowerCase() ?? "";
+    if (!sub || sub === "help") {
+        return {
+            text: [
+                "🧠 /context",
+                "",
+                "What counts as context (high-level), plus a breakdown mode.",
+                "",
+                "Try:",
+                "- /context list   (short breakdown)",
+                "- /context detail (per-file + per-tool + per-skill + system prompt size)",
+                "- /context json   (same, machine-readable)",
+                "",
+                "Inline shortcut = a command token inside a normal message (e.g. “hey /status”). It runs immediately (allowlisted senders only) and is stripped before the model sees the remaining text.",
+            ].join("\n"),
+        };
+    }
+    const report = await resolveContextReport(params);
+    const session = {
+        totalTokens: params.sessionEntry?.totalTokens ?? null,
+        inputTokens: params.sessionEntry?.inputTokens ?? null,
+        outputTokens: params.sessionEntry?.outputTokens ?? null,
+        contextTokens: params.contextTokens ?? null,
+    };
+    if (sub === "json") {
+        return { text: JSON.stringify({ report, session }, null, 2) };
+    }
+    if (sub !== "list" && sub !== "show" && sub !== "detail" && sub !== "deep") {
+        return {
+            text: [
+                "Unknown /context mode.",
+                "Use: /context, /context list, /context detail, or /context json",
+            ].join("\n"),
+        };
+    }
+    const fileLines = report.injectedWorkspaceFiles.map((f) => {
+        const status = f.missing ? "MISSING" : f.truncated ? "TRUNCATED" : "OK";
+        const raw = f.missing ? "0" : formatCharsAndTokens(f.rawChars);
+        const injected = f.missing ? "0" : formatCharsAndTokens(f.injectedChars);
+        return `- ${f.name}: ${status} | raw ${raw} | injected ${injected}`;
+    });
+    const sandboxLine = `Sandbox: mode=${report.sandbox?.mode ?? "unknown"} sandboxed=${report.sandbox?.sandboxed ?? false}`;
+    const toolSchemaLine = `Tool schemas (JSON): ${formatCharsAndTokens(report.tools.schemaChars)} (counts toward context; not shown as text)`;
+    const toolListLine = `Tool list (system prompt text): ${formatCharsAndTokens(report.tools.listChars)}`;
+    const skillNameSet = new Set(report.skills.entries.map((s) => s.name));
+    const skillNames = Array.from(skillNameSet);
+    const toolNames = report.tools.entries.map((t) => t.name);
+    const formatNameList = (names, cap) => names.length <= cap
+        ? names.join(", ")
+        : `${names.slice(0, cap).join(", ")}, … (+${names.length - cap} more)`;
+    const skillsLine = `Skills list (system prompt text): ${formatCharsAndTokens(report.skills.promptChars)} (${skillNameSet.size} skills)`;
+    const skillsNamesLine = skillNameSet.size
+        ? `Skills: ${formatNameList(skillNames, 20)}`
+        : "Skills: (none)";
+    const toolsNamesLine = toolNames.length
+        ? `Tools: ${formatNameList(toolNames, 30)}`
+        : "Tools: (none)";
+    const systemPromptLine = `System prompt (${report.source}): ${formatCharsAndTokens(report.systemPrompt.chars)} (Project Context ${formatCharsAndTokens(report.systemPrompt.projectContextChars)})`;
+    const workspaceLabel = report.workspaceDir ?? params.workspaceDir;
+    const bootstrapMaxLabel = typeof report.bootstrapMaxChars === "number"
+        ? `${formatInt(report.bootstrapMaxChars)} chars`
+        : "? chars";
+    const totalsLine = session.totalTokens != null
+        ? `Session tokens (cached): ${formatInt(session.totalTokens)} total / ctx=${session.contextTokens ?? "?"}`
+        : `Session tokens (cached): unknown / ctx=${session.contextTokens ?? "?"}`;
+    if (sub === "detail" || sub === "deep") {
+        const perSkill = formatListTop(report.skills.entries.map((s) => ({ name: s.name, value: s.blockChars })), 30);
+        const perToolSchema = formatListTop(report.tools.entries.map((t) => ({ name: t.name, value: t.schemaChars })), 30);
+        const perToolSummary = formatListTop(report.tools.entries.map((t) => ({ name: t.name, value: t.summaryChars })), 30);
+        const toolPropsLines = report.tools.entries
+            .filter((t) => t.propertiesCount != null)
+            .sort((a, b) => (b.propertiesCount ?? 0) - (a.propertiesCount ?? 0))
+            .slice(0, 30)
+            .map((t) => `- ${t.name}: ${t.propertiesCount} params`);
+        return {
+            text: [
+                "🧠 Context breakdown (detailed)",
+                `Workspace: ${workspaceLabel}`,
+                `Bootstrap max/file: ${bootstrapMaxLabel}`,
+                sandboxLine,
+                systemPromptLine,
+                "",
+                "Injected workspace files:",
+                ...fileLines,
+                "",
+                skillsLine,
+                skillsNamesLine,
+                ...(perSkill.lines.length ? ["Top skills (prompt entry size):", ...perSkill.lines] : []),
+                ...(perSkill.omitted ? [`… (+${perSkill.omitted} more skills)`] : []),
+                "",
+                toolListLine,
+                toolSchemaLine,
+                toolsNamesLine,
+                "Top tools (schema size):",
+                ...perToolSchema.lines,
+                ...(perToolSchema.omitted ? [`… (+${perToolSchema.omitted} more tools)`] : []),
+                "",
+                "Top tools (summary text size):",
+                ...perToolSummary.lines,
+                ...(perToolSummary.omitted ? [`… (+${perToolSummary.omitted} more tools)`] : []),
+                ...(toolPropsLines.length ? ["", "Tools (param count):", ...toolPropsLines] : []),
+                "",
+                totalsLine,
+                "",
+                "Inline shortcut: a command token inside normal text (e.g. “hey /status”) that runs immediately (allowlisted senders only) and is stripped before the model sees the remaining message.",
+            ]
+                .filter(Boolean)
+                .join("\n"),
+        };
+    }
+    return {
+        text: [
+            "🧠 Context breakdown",
+            `Workspace: ${workspaceLabel}`,
+            `Bootstrap max/file: ${bootstrapMaxLabel}`,
+            sandboxLine,
+            systemPromptLine,
+            "",
+            "Injected workspace files:",
+            ...fileLines,
+            "",
+            skillsLine,
+            skillsNamesLine,
+            toolListLine,
+            toolSchemaLine,
+            toolsNamesLine,
+            "",
+            totalsLine,
+            "",
+            "Inline shortcut: a command token inside normal text (e.g. “hey /status”) that runs immediately (allowlisted senders only) and is stripped before the model sees the remaining message.",
+        ].join("\n"),
+    };
+}

package/dist/auto-reply/auto-reply/reply/commands-context.js

@@ -0,0 +1,30 @@
+import { resolveCommandAuthorization } from "../command-auth.js";
+import { normalizeCommandBody } from "../commands-registry.js";
+import { stripMentions } from "./mentions.js";
+export function buildCommandContext(params) {
+    const { ctx, cfg, agentId, sessionKey, isGroup, triggerBodyNormalized } = params;
+    const auth = resolveCommandAuthorization({
+        ctx,
+        cfg,
+        commandAuthorized: params.commandAuthorized,
+    });
+    const surface = (ctx.Surface ?? ctx.Provider ?? "").trim().toLowerCase();
+    const channel = (ctx.Provider ?? surface).trim().toLowerCase();
+    const abortKey = sessionKey ?? (auth.from || undefined) ?? (auth.to || undefined);
+    const rawBodyNormalized = triggerBodyNormalized;
+    const commandBodyNormalized = normalizeCommandBody(isGroup ? stripMentions(rawBodyNormalized, ctx, cfg, agentId) : rawBodyNormalized);
+    return {
+        surface,
+        channel,
+        channelId: auth.providerId,
+        ownerList: auth.ownerList,
+        senderIsOwner: auth.senderIsOwner,
+        isAuthorizedSender: auth.isAuthorizedSender,
+        senderId: auth.senderId,
+        abortKey,
+        rawBodyNormalized,
+        commandBodyNormalized,
+        from: auth.from,
+        to: auth.to,
+    };
+}

package/dist/auto-reply/auto-reply/reply/commands-core.js

@@ -0,0 +1,151 @@
+import fs from "node:fs/promises";
+import { logVerbose } from "../../globals.js";
+import { createInternalHookEvent, triggerInternalHook } from "../../hooks/internal-hooks.js";
+import { getGlobalHookRunner } from "../../plugins/hook-runner-global.js";
+import { resolveSendPolicy } from "../../sessions/send-policy.js";
+import { shouldHandleTextCommands } from "../commands-registry.js";
+import { handleAllowlistCommand } from "./commands-allowlist.js";
+import { handleApproveCommand } from "./commands-approve.js";
+import { handleBashCommand } from "./commands-bash.js";
+import { handleCompactCommand } from "./commands-compact.js";
+import { handleConfigCommand, handleDebugCommand } from "./commands-config.js";
+import { handleCommandsListCommand, handleContextCommand, handleExportSessionCommand, handleHelpCommand, handleStatusCommand, handleWhoamiCommand, } from "./commands-info.js";
+import { handleModelsCommand } from "./commands-models.js";
+import { handlePluginCommand } from "./commands-plugin.js";
+import { handleAbortTrigger, handleActivationCommand, handleRestartCommand, handleSessionCommand, handleSendPolicyCommand, handleStopCommand, handleUsageCommand, } from "./commands-session.js";
+import { handleSubagentsCommand } from "./commands-subagents.js";
+import { handleTtsCommands } from "./commands-tts.js";
+import { routeReply } from "./route-reply.js";
+let HANDLERS = null;
+export async function handleCommands(params) {
+    if (HANDLERS === null) {
+        HANDLERS = [
+            // Plugin commands are processed first, before built-in commands
+            handlePluginCommand,
+            handleBashCommand,
+            handleActivationCommand,
+            handleSendPolicyCommand,
+            handleUsageCommand,
+            handleSessionCommand,
+            handleRestartCommand,
+            handleTtsCommands,
+            handleHelpCommand,
+            handleCommandsListCommand,
+            handleStatusCommand,
+            handleAllowlistCommand,
+            handleApproveCommand,
+            handleContextCommand,
+            handleExportSessionCommand,
+            handleWhoamiCommand,
+            handleSubagentsCommand,
+            handleConfigCommand,
+            handleDebugCommand,
+            handleModelsCommand,
+            handleStopCommand,
+            handleCompactCommand,
+            handleAbortTrigger,
+        ];
+    }
+    const resetMatch = params.command.commandBodyNormalized.match(/^\/(new|reset)(?:\s|$)/);
+    const resetRequested = Boolean(resetMatch);
+    if (resetRequested && !params.command.isAuthorizedSender) {
+        logVerbose(`Ignoring /reset from unauthorized sender: ${params.command.senderId || "<unknown>"}`);
+        return { shouldContinue: false };
+    }
+    // Trigger internal hook for reset/new commands
+    if (resetRequested && params.command.isAuthorizedSender) {
+        const commandAction = resetMatch?.[1] ?? "new";
+        const hookEvent = createInternalHookEvent("command", commandAction, params.sessionKey ?? "", {
+            sessionEntry: params.sessionEntry,
+            previousSessionEntry: params.previousSessionEntry,
+            commandSource: params.command.surface,
+            senderId: params.command.senderId,
+            cfg: params.cfg, // Pass config for LLM slug generation
+        });
+        await triggerInternalHook(hookEvent);
+        // Send hook messages immediately if present
+        if (hookEvent.messages.length > 0) {
+            // Use OriginatingChannel/To if available, otherwise fall back to command channel/from
+            // oxlint-disable-next-line typescript/no-explicit-any
+            const channel = params.ctx.OriginatingChannel || params.command.channel;
+            // For replies, use 'from' (the sender) not 'to' (which might be the bot itself)
+            const to = params.ctx.OriginatingTo || params.command.from || params.command.to;
+            if (channel && to) {
+                const hookReply = { text: hookEvent.messages.join("\n\n") };
+                await routeReply({
+                    payload: hookReply,
+                    channel: channel,
+                    to: to,
+                    sessionKey: params.sessionKey,
+                    accountId: params.ctx.AccountId,
+                    threadId: params.ctx.MessageThreadId,
+                    cfg: params.cfg,
+                });
+            }
+        }
+        // Fire before_reset plugin hook — extract memories before session history is lost
+        const hookRunner = getGlobalHookRunner();
+        if (hookRunner?.hasHooks("before_reset")) {
+            const prevEntry = params.previousSessionEntry;
+            const sessionFile = prevEntry?.sessionFile;
+            // Fire-and-forget: read old session messages and run hook
+            void (async () => {
+                try {
+                    const messages = [];
+                    if (sessionFile) {
+                        const content = await fs.readFile(sessionFile, "utf-8");
+                        for (const line of content.split("\n")) {
+                            if (!line.trim()) {
+                                continue;
+                            }
+                            try {
+                                const entry = JSON.parse(line);
+                                if (entry.type === "message" && entry.message) {
+                                    messages.push(entry.message);
+                                }
+                            }
+                            catch {
+                                // skip malformed lines
+                            }
+                        }
+                    }
+                    else {
+                        logVerbose("before_reset: no session file available, firing hook with empty messages");
+                    }
+                    await hookRunner.runBeforeReset({ sessionFile, messages, reason: commandAction }, {
+                        agentId: params.sessionKey?.split(":")[0] ?? "main",
+                        sessionKey: params.sessionKey,
+                        sessionId: prevEntry?.sessionId,
+                        workspaceDir: params.workspaceDir,
+                    });
+                }
+                catch (err) {
+                    logVerbose(`before_reset hook failed: ${String(err)}`);
+                }
+            })();
+        }
+    }
+    const allowTextCommands = shouldHandleTextCommands({
+        cfg: params.cfg,
+        surface: params.command.surface,
+        commandSource: params.ctx.CommandSource,
+    });
+    for (const handler of HANDLERS) {
+        const result = await handler(params, allowTextCommands);
+        if (result) {
+            return result;
+        }
+    }
+    const sendPolicy = resolveSendPolicy({
+        cfg: params.cfg,
+        entry: params.sessionEntry,
+        sessionKey: params.sessionKey,
+        channel: params.sessionEntry?.channel ?? params.command.channel,
+        chatType: params.sessionEntry?.chatType,
+    });
+    if (sendPolicy === "deny") {
+        logVerbose(`Send blocked by policy for session ${params.sessionKey ?? "unknown"}`);
+        return { shouldContinue: false };
+    }
+    return { shouldContinue: true };
+}

package/dist/auto-reply/auto-reply/reply/commands-export-session.js

@@ -0,0 +1,163 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { SessionManager } from "@mariozechner/pi-coding-agent";
+import { resolveDefaultSessionStorePath, resolveSessionFilePath, } from "../../config/sessions/paths.js";
+import { loadSessionStore } from "../../config/sessions/store.js";
+import { resolveCommandsSystemPromptBundle } from "./commands-system-prompt.js";
+// Export HTML templates are bundled with this module
+const EXPORT_HTML_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), "export-html");
+function loadTemplate(fileName) {
+    return fs.readFileSync(path.join(EXPORT_HTML_DIR, fileName), "utf-8");
+}
+function generateHtml(sessionData) {
+    const template = loadTemplate("template.html");
+    const templateCss = loadTemplate("template.css");
+    const templateJs = loadTemplate("template.js");
+    const markedJs = loadTemplate(path.join("vendor", "marked.min.js"));
+    const hljsJs = loadTemplate(path.join("vendor", "highlight.min.js"));
+    // Use pi-mono dark theme colors (matching their theme/dark.json)
+    const themeVars = `
+    --cyan: #00d7ff;
+    --blue: #5f87ff;
+    --green: #b5bd68;
+    --red: #cc6666;
+    --yellow: #ffff00;
+    --gray: #808080;
+    --dimGray: #666666;
+    --darkGray: #505050;
+    --accent: #8abeb7;
+    --selectedBg: #3a3a4a;
+    --userMsgBg: #343541;
+    --toolPendingBg: #282832;
+    --toolSuccessBg: #283228;
+    --toolErrorBg: #3c2828;
+    --customMsgBg: #2d2838;
+    --text: #e0e0e0;
+    --dim: #666666;
+    --muted: #808080;
+    --border: #5f87ff;
+    --borderAccent: #00d7ff;
+    --borderMuted: #505050;
+    --success: #b5bd68;
+    --error: #cc6666;
+    --warning: #ffff00;
+    --thinkingText: #808080;
+    --userMessageBg: #343541;
+    --userMessageText: #e0e0e0;
+    --customMessageBg: #2d2838;
+    --customMessageText: #e0e0e0;
+    --customMessageLabel: #9575cd;
+    --toolTitle: #e0e0e0;
+    --toolOutput: #808080;
+    --mdHeading: #f0c674;
+    --mdLink: #81a2be;
+    --mdLinkUrl: #666666;
+    --mdCode: #8abeb7;
+    --mdCodeBlock: #b5bd68;
+  `;
+    const bodyBg = "#1e1e28";
+    const containerBg = "#282832";
+    const infoBg = "#343541";
+    // Base64 encode session data
+    const sessionDataBase64 = Buffer.from(JSON.stringify(sessionData)).toString("base64");
+    // Build CSS with theme variables
+    const css = templateCss
+        .replace("/* {{THEME_VARS}} */", themeVars.trim())
+        .replace("/* {{BODY_BG_DECL}} */", `--body-bg: ${bodyBg};`)
+        .replace("/* {{CONTAINER_BG_DECL}} */", `--container-bg: ${containerBg};`)
+        .replace("/* {{INFO_BG_DECL}} */", `--info-bg: ${infoBg};`);
+    return template
+        .replace("{{CSS}}", css)
+        .replace("{{JS}}", templateJs)
+        .replace("{{SESSION_DATA}}", sessionDataBase64)
+        .replace("{{MARKED_JS}}", markedJs)
+        .replace("{{HIGHLIGHT_JS}}", hljsJs);
+}
+function parseExportArgs(commandBodyNormalized) {
+    const normalized = commandBodyNormalized.trim();
+    if (normalized === "/export-session" || normalized === "/export") {
+        return {};
+    }
+    const args = normalized.replace(/^\/(export-session|export)\s*/, "").trim();
+    // First non-flag argument is the output path
+    const outputPath = args.split(/\s+/).find((part) => !part.startsWith("-"));
+    return { outputPath };
+}
+export async function buildExportSessionReply(params) {
+    const args = parseExportArgs(params.command.commandBodyNormalized);
+    // 1. Resolve session file
+    const sessionEntry = params.sessionEntry;
+    if (!sessionEntry?.sessionId) {
+        return { text: "❌ No active session found." };
+    }
+    const storePath = resolveDefaultSessionStorePath(params.agentId);
+    const store = loadSessionStore(storePath, { skipCache: true });
+    const entry = store[params.sessionKey];
+    if (!entry?.sessionId) {
+        return { text: `❌ Session not found: ${params.sessionKey}` };
+    }
+    let sessionFile;
+    try {
+        sessionFile = resolveSessionFilePath(entry.sessionId, entry, {
+            agentId: params.agentId,
+            sessionsDir: path.dirname(storePath),
+        });
+    }
+    catch (err) {
+        return {
+            text: `❌ Failed to resolve session file: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    if (!fs.existsSync(sessionFile)) {
+        return { text: `❌ Session file not found: ${sessionFile}` };
+    }
+    // 2. Load session entries
+    const sessionManager = SessionManager.open(sessionFile);
+    const entries = sessionManager.getEntries();
+    const header = sessionManager.getHeader();
+    const leafId = sessionManager.getLeafId();
+    // 3. Build full system prompt
+    const { systemPrompt, tools } = await resolveCommandsSystemPromptBundle(params);
+    // 4. Prepare session data
+    const sessionData = {
+        header,
+        entries,
+        leafId,
+        systemPrompt,
+        tools: tools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters,
+        })),
+    };
+    // 5. Generate HTML
+    const html = generateHtml(sessionData);
+    // 6. Determine output path
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    const defaultFileName = `poolbot-session-${entry.sessionId.slice(0, 8)}-${timestamp}.html`;
+    const outputPath = args.outputPath
+        ? path.resolve(args.outputPath.startsWith("~")
+            ? args.outputPath.replace("~", process.env.HOME ?? "")
+            : args.outputPath)
+        : path.join(params.workspaceDir, defaultFileName);
+    // Ensure directory exists
+    const outputDir = path.dirname(outputPath);
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    // 7. Write file
+    fs.writeFileSync(outputPath, html, "utf-8");
+    const relativePath = path.relative(params.workspaceDir, outputPath);
+    const displayPath = relativePath.startsWith("..") ? outputPath : relativePath;
+    return {
+        text: [
+            "✅ Session exported!",
+            "",
+            `📄 File: ${displayPath}`,
+            `📊 Entries: ${entries.length}`,
+            `🧠 System prompt: ${systemPrompt.length.toLocaleString()} chars`,
+            `🔧 Tools: ${tools.length}`,
+        ].join("\n"),
+    };
+}