@poolzin/pool-bot 2026.1.38 → 2026.2.0

package/dist/memory/backend-config.js

@@ -0,0 +1,207 @@
+import path from "node:path";
+import { resolveAgentWorkspaceDir } from "../agents/agent-scope.js";
+import { parseDurationMs } from "../cli/parse-duration.js";
+import { resolveUserPath } from "../utils.js";
+import { splitShellArgs } from "../utils/shell-argv.js";
+const DEFAULT_BACKEND = "builtin";
+const DEFAULT_CITATIONS = "auto";
+const DEFAULT_QMD_INTERVAL = "5m";
+const DEFAULT_QMD_DEBOUNCE_MS = 15_000;
+const DEFAULT_QMD_TIMEOUT_MS = 4_000;
+const DEFAULT_QMD_EMBED_INTERVAL = "60m";
+const DEFAULT_QMD_COMMAND_TIMEOUT_MS = 30_000;
+const DEFAULT_QMD_UPDATE_TIMEOUT_MS = 120_000;
+const DEFAULT_QMD_EMBED_TIMEOUT_MS = 120_000;
+const DEFAULT_QMD_LIMITS = {
+    maxResults: 6,
+    maxSnippetChars: 700,
+    maxInjectedChars: 4_000,
+    timeoutMs: DEFAULT_QMD_TIMEOUT_MS,
+};
+const DEFAULT_QMD_SCOPE = {
+    default: "deny",
+    rules: [
+        {
+            action: "allow",
+            match: { chatType: "direct" },
+        },
+    ],
+};
+function sanitizeName(input) {
+    const lower = input.toLowerCase().replace(/[^a-z0-9-]+/g, "-");
+    const trimmed = lower.replace(/^-+|-+$/g, "");
+    return trimmed || "collection";
+}
+function ensureUniqueName(base, existing) {
+    let name = sanitizeName(base);
+    if (!existing.has(name)) {
+        existing.add(name);
+        return name;
+    }
+    let suffix = 2;
+    while (existing.has(`${name}-${suffix}`)) {
+        suffix += 1;
+    }
+    const unique = `${name}-${suffix}`;
+    existing.add(unique);
+    return unique;
+}
+function resolvePath(raw, workspaceDir) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        throw new Error("path required");
+    }
+    if (trimmed.startsWith("~") || path.isAbsolute(trimmed)) {
+        return path.normalize(resolveUserPath(trimmed));
+    }
+    return path.normalize(path.resolve(workspaceDir, trimmed));
+}
+function resolveIntervalMs(raw) {
+    const value = raw?.trim();
+    if (!value) {
+        return parseDurationMs(DEFAULT_QMD_INTERVAL, { defaultUnit: "m" });
+    }
+    try {
+        return parseDurationMs(value, { defaultUnit: "m" });
+    }
+    catch {
+        return parseDurationMs(DEFAULT_QMD_INTERVAL, { defaultUnit: "m" });
+    }
+}
+function resolveEmbedIntervalMs(raw) {
+    const value = raw?.trim();
+    if (!value) {
+        return parseDurationMs(DEFAULT_QMD_EMBED_INTERVAL, { defaultUnit: "m" });
+    }
+    try {
+        return parseDurationMs(value, { defaultUnit: "m" });
+    }
+    catch {
+        return parseDurationMs(DEFAULT_QMD_EMBED_INTERVAL, { defaultUnit: "m" });
+    }
+}
+function resolveDebounceMs(raw) {
+    if (typeof raw === "number" && Number.isFinite(raw) && raw >= 0) {
+        return Math.floor(raw);
+    }
+    return DEFAULT_QMD_DEBOUNCE_MS;
+}
+function resolveTimeoutMs(raw, fallback) {
+    if (typeof raw === "number" && Number.isFinite(raw) && raw > 0) {
+        return Math.floor(raw);
+    }
+    return fallback;
+}
+function resolveLimits(raw) {
+    const parsed = { ...DEFAULT_QMD_LIMITS };
+    if (raw?.maxResults && raw.maxResults > 0) {
+        parsed.maxResults = Math.floor(raw.maxResults);
+    }
+    if (raw?.maxSnippetChars && raw.maxSnippetChars > 0) {
+        parsed.maxSnippetChars = Math.floor(raw.maxSnippetChars);
+    }
+    if (raw?.maxInjectedChars && raw.maxInjectedChars > 0) {
+        parsed.maxInjectedChars = Math.floor(raw.maxInjectedChars);
+    }
+    if (raw?.timeoutMs && raw.timeoutMs > 0) {
+        parsed.timeoutMs = Math.floor(raw.timeoutMs);
+    }
+    return parsed;
+}
+function resolveSessionConfig(cfg, workspaceDir) {
+    const enabled = Boolean(cfg?.enabled);
+    const exportDirRaw = cfg?.exportDir?.trim();
+    const exportDir = exportDirRaw ? resolvePath(exportDirRaw, workspaceDir) : undefined;
+    const retentionDays = cfg?.retentionDays && cfg.retentionDays > 0 ? Math.floor(cfg.retentionDays) : undefined;
+    return {
+        enabled,
+        exportDir,
+        retentionDays,
+    };
+}
+function resolveCustomPaths(rawPaths, workspaceDir, existing) {
+    if (!rawPaths?.length) {
+        return [];
+    }
+    const collections = [];
+    rawPaths.forEach((entry, index) => {
+        const trimmedPath = entry?.path?.trim();
+        if (!trimmedPath) {
+            return;
+        }
+        let resolved;
+        try {
+            resolved = resolvePath(trimmedPath, workspaceDir);
+        }
+        catch {
+            return;
+        }
+        const pattern = entry.pattern?.trim() || "**/*.md";
+        const baseName = entry.name?.trim() || `custom-${index + 1}`;
+        const name = ensureUniqueName(baseName, existing);
+        collections.push({
+            name,
+            path: resolved,
+            pattern,
+            kind: "custom",
+        });
+    });
+    return collections;
+}
+function resolveDefaultCollections(include, workspaceDir, existing) {
+    if (!include) {
+        return [];
+    }
+    const entries = [
+        { path: workspaceDir, pattern: "MEMORY.md", base: "memory-root" },
+        { path: workspaceDir, pattern: "memory.md", base: "memory-alt" },
+        { path: path.join(workspaceDir, "memory"), pattern: "**/*.md", base: "memory-dir" },
+    ];
+    return entries.map((entry) => ({
+        name: ensureUniqueName(entry.base, existing),
+        path: entry.path,
+        pattern: entry.pattern,
+        kind: "memory",
+    }));
+}
+export function resolveMemoryBackendConfig(params) {
+    const backend = params.cfg.memory?.backend ?? DEFAULT_BACKEND;
+    const citations = params.cfg.memory?.citations ?? DEFAULT_CITATIONS;
+    if (backend !== "qmd") {
+        return { backend: "builtin", citations };
+    }
+    const workspaceDir = resolveAgentWorkspaceDir(params.cfg, params.agentId);
+    const qmdCfg = params.cfg.memory?.qmd;
+    const includeDefaultMemory = qmdCfg?.includeDefaultMemory !== false;
+    const nameSet = new Set();
+    const collections = [
+        ...resolveDefaultCollections(includeDefaultMemory, workspaceDir, nameSet),
+        ...resolveCustomPaths(qmdCfg?.paths, workspaceDir, nameSet),
+    ];
+    const rawCommand = qmdCfg?.command?.trim() || "qmd";
+    const parsedCommand = splitShellArgs(rawCommand);
+    const command = parsedCommand?.[0] || rawCommand.split(/\s+/)[0] || "qmd";
+    const resolved = {
+        command,
+        collections,
+        includeDefaultMemory,
+        sessions: resolveSessionConfig(qmdCfg?.sessions, workspaceDir),
+        update: {
+            intervalMs: resolveIntervalMs(qmdCfg?.update?.interval),
+            debounceMs: resolveDebounceMs(qmdCfg?.update?.debounceMs),
+            onBoot: qmdCfg?.update?.onBoot !== false,
+            waitForBootSync: qmdCfg?.update?.waitForBootSync === true,
+            embedIntervalMs: resolveEmbedIntervalMs(qmdCfg?.update?.embedInterval),
+            commandTimeoutMs: resolveTimeoutMs(qmdCfg?.update?.commandTimeoutMs, DEFAULT_QMD_COMMAND_TIMEOUT_MS),
+            updateTimeoutMs: resolveTimeoutMs(qmdCfg?.update?.updateTimeoutMs, DEFAULT_QMD_UPDATE_TIMEOUT_MS),
+            embedTimeoutMs: resolveTimeoutMs(qmdCfg?.update?.embedTimeoutMs, DEFAULT_QMD_EMBED_TIMEOUT_MS),
+        },
+        limits: resolveLimits(qmdCfg?.limits),
+        scope: qmdCfg?.scope ?? DEFAULT_QMD_SCOPE,
+    };
+    return {
+        backend: "qmd",
+        citations,
+        qmd: resolved,
+    };
+}

package/dist/memory/embeddings.js

@@ -160,7 +160,7 @@ function formatLocalSetupError(err) {
         "To enable local embeddings:",
         "1) Use Node 22 LTS (recommended for installs/updates)",
         missing
-            ? "2) Reinstall Moltbot (this should install node-llama-cpp): npm i -g poolbot@latest"
+            ? "2) Reinstall Poolbot (this should install node-llama-cpp): npm i -g poolbot@latest"
             : null,
         "3) If you use pnpm: pnpm approve-builds (select node-llama-cpp), then pnpm rebuild node-llama-cpp",
         'Or set agents.defaults.memorySearch.provider = "openai" (remote).',

package/dist/memory/index.js

@@ -1,6 +1 @@
-/**
- * Memory Search - Public Exports
- * Legacy system only (PME removed 2026-02-03)
- */
-// Legacy memory search system
 export { getMemorySearchManager } from "./search-manager.js";

package/dist/memory/manager.js

@@ -157,7 +157,6 @@ export class MemoryIndexManager {
             this.sessionWarm.add(key);
     }
     async search(query, opts) {
-        const searchStart = Date.now();
         void this.warmSession(opts?.sessionKey);
         if (this.settings.sync.onSearch && (this.dirty || this.sessionsDirty)) {
             void this.sync({ reason: "search" }).catch((err) => {
@@ -180,17 +179,7 @@ export class MemoryIndexManager {
             ? await this.searchVector(queryVec, candidates).catch(() => [])
             : [];
         if (!hybrid.enabled) {
-            const results = vectorResults.filter((entry) => entry.score >= minScore).slice(0, maxResults);
-            const searchDuration = Date.now() - searchStart;
-            log.debug("memory search performance", {
-                query: cleaned.substring(0, 50),
-                durationMs: searchDuration,
-                resultCount: results.length,
-                provider: this.provider.id,
-                model: this.provider.model,
-                hybrid: false,
-            });
-            return results;
+            return vectorResults.filter((entry) => entry.score >= minScore).slice(0, maxResults);
         }
         const merged = this.mergeHybridResults({
             vector: vectorResults,
@@ -198,19 +187,7 @@ export class MemoryIndexManager {
             vectorWeight: hybrid.vectorWeight,
             textWeight: hybrid.textWeight,
         });
-        const results = merged.filter((entry) => entry.score >= minScore).slice(0, maxResults);
-        const searchDuration = Date.now() - searchStart;
-        log.debug("memory search performance", {
-            query: cleaned.substring(0, 50),
-            durationMs: searchDuration,
-            resultCount: results.length,
-            provider: this.provider.id,
-            model: this.provider.model,
-            hybrid: true,
-            keywordResults: keywordResults.length,
-            vectorResults: vectorResults.length,
-        });
-        return results;
+        return merged.filter((entry) => entry.score >= minScore).slice(0, maxResults);
     }
     async searchVector(queryVec, limit) {
         const results = await searchVector({
@@ -333,6 +310,7 @@ export class MemoryIndexManager {
             return sources.map((source) => ({ source, ...bySource.get(source) }));
         })();
         return {
+            backend: "builtin",
             files: files?.c ?? 0,
             chunks: chunks?.c ?? 0,
             dirty: this.dirty,

package/dist/memory/types.js

@@ -0,0 +1 @@
+export {};

package/dist/node-host/runner.js

@@ -13,7 +13,7 @@ import { createBrowserControlContext, startBrowserControlServiceFromConfig, } fr
 import { createBrowserRouteDispatcher } from "../browser/routes/dispatcher.js";
 import { detectMime } from "../media/mime.js";
 import { resolveAgentConfig } from "../agents/agent-scope.js";
-import { ensureMoltbotCliOnPath } from "../infra/path-env.js";
+import { ensurePoolbotCliOnPath } from "../infra/path-env.js";
 import { VERSION } from "../version.js";
 import { GATEWAY_CLIENT_MODES, GATEWAY_CLIENT_NAMES } from "../utils/message-channel.js";
 import { ensureNodeHostConfig, saveNodeHostConfig } from "./config.js";
@@ -296,7 +296,7 @@ function resolveEnvPath(env) {
     return raw.split(path.delimiter).filter(Boolean);
 }
 function ensureNodePathEnv() {
-    ensureMoltbotCliOnPath({ pathEnv: process.env.PATH ?? "" });
+    ensurePoolbotCliOnPath({ pathEnv: process.env.PATH ?? "" });
     const current = process.env.PATH ?? "";
     if (current.trim())
         return current;

package/dist/pairing/pairing-messages.js

@@ -2,7 +2,7 @@ import { formatCliCommand } from "../cli/command-format.js";
 export function buildPairingReply(params) {
     const { channel, idLine, code } = params;
     return [
-        "Moltbot: access not configured.",
+        "Poolbot: access not configured.",
         "",
         idLine,
         "",

package/dist/plugins/discovery.js

@@ -58,7 +58,7 @@ function addCandidate(params) {
         packageVersion: manifest?.version?.trim() || undefined,
         packageDescription: manifest?.description?.trim() || undefined,
         packageDir: params.packageDir,
-        packageMoltbot: getPackageManifestMetadata(manifest ?? undefined),
+        packagePoolbot: getPackageManifestMetadata(manifest ?? undefined),
     });
 }
 function discoverInDirectory(params) {

package/dist/plugins/install.js

@@ -21,7 +21,7 @@ function safeDirName(input) {
 function safeFileName(input) {
     return safeDirName(input);
 }
-async function ensureMoltbotExtensions(manifest) {
+async function ensurePoolbotExtensions(manifest) {
     const extensions = manifest.poolbot?.extensions ?? manifest[LEGACY_MANIFEST_KEY]?.extensions;
     if (!Array.isArray(extensions)) {
         throw new Error("package.json missing poolbot.extensions");
@@ -56,7 +56,7 @@ async function installPluginFromPackageDir(params) {
     }
     let extensions;
     try {
-        extensions = await ensureMoltbotExtensions(manifest);
+        extensions = await ensurePoolbotExtensions(manifest);
     }
     catch (err) {
         return { ok: false, error: String(err) };

package/dist/plugins/update.js

@@ -26,7 +26,7 @@ function resolveBundledPluginSources(params) {
         const pluginId = manifest.manifest.id;
         if (bundled.has(pluginId))
             continue;
-        const npmSpec = candidate.packageMoltbot?.install?.npmSpec?.trim() ||
+        const npmSpec = candidate.packagePoolbot?.install?.npmSpec?.trim() ||
             candidate.packageName?.trim() ||
             undefined;
         bundled.set(pluginId, {

package/dist/security/audit.js

@@ -65,7 +65,7 @@ async function collectFilesystemFindings(params) {
                 checkId: "fs.state_dir.perms_world_writable",
                 severity: "critical",
                 title: "State dir is world-writable",
-                detail: `${formatPermissionDetail(params.stateDir, stateDirPerms)}; other users can write into your Moltbot state.`,
+                detail: `${formatPermissionDetail(params.stateDir, stateDirPerms)}; other users can write into your Poolbot state.`,
                 remediation: formatPermissionRemediation({
                     targetPath: params.stateDir,
                     perms: stateDirPerms,
@@ -80,7 +80,7 @@ async function collectFilesystemFindings(params) {
                 checkId: "fs.state_dir.perms_group_writable",
                 severity: "warn",
                 title: "State dir is group-writable",
-                detail: `${formatPermissionDetail(params.stateDir, stateDirPerms)}; group users can write into your Moltbot state.`,
+                detail: `${formatPermissionDetail(params.stateDir, stateDirPerms)}; group users can write into your Poolbot state.`,
                 remediation: formatPermissionRemediation({
                     targetPath: params.stateDir,
                     perms: stateDirPerms,

package/dist/shared/text/reasoning-tags.js

@@ -1,28 +1,70 @@
 const QUICK_TAG_RE = /<\s*\/?\s*(?:think(?:ing)?|thought|antthinking|final)\b/i;
-const FINAL_TAG_RE = /<\s*\/?\s*final\b[^>]*>/gi;
-const THINKING_TAG_RE = /<\s*(\/?)\s*(?:think(?:ing)?|thought|antthinking)\b[^>]*>/gi;
+const FINAL_TAG_RE = /<\s*\/?\s*final\b[^<>]*>/gi;
+const THINKING_TAG_RE = /<\s*(\/?)\s*(?:think(?:ing)?|thought|antthinking)\b[^<>]*>/gi;
+function findCodeRegions(text) {
+    const regions = [];
+    const fencedRe = /(^|\n)(```|~~~)[^\n]*\n[\s\S]*?(?:\n\2(?:\n|$)|$)/g;
+    for (const match of text.matchAll(fencedRe)) {
+        const start = (match.index ?? 0) + match[1].length;
+        regions.push({ start, end: start + match[0].length - match[1].length });
+    }
+    const inlineRe = /`+[^`]+`+/g;
+    for (const match of text.matchAll(inlineRe)) {
+        const start = match.index ?? 0;
+        const end = start + match[0].length;
+        const insideFenced = regions.some((r) => start >= r.start && end <= r.end);
+        if (!insideFenced) {
+            regions.push({ start, end });
+        }
+    }
+    regions.sort((a, b) => a.start - b.start);
+    return regions;
+}
+function isInsideCode(pos, regions) {
+    return regions.some((r) => pos >= r.start && pos < r.end);
+}
 function applyTrim(value, mode) {
-    if (mode === "none")
+    if (mode === "none") {
         return value;
-    if (mode === "start")
+    }
+    if (mode === "start") {
         return value.trimStart();
+    }
     return value.trim();
 }
 export function stripReasoningTagsFromText(text, options) {
-    if (!text)
+    if (!text) {
         return text;
-    if (!QUICK_TAG_RE.test(text))
+    }
+    if (!QUICK_TAG_RE.test(text)) {
         return text;
+    }
     const mode = options?.mode ?? "strict";
     const trimMode = options?.trim ?? "both";
     let cleaned = text;
     if (FINAL_TAG_RE.test(cleaned)) {
         FINAL_TAG_RE.lastIndex = 0;
-        cleaned = cleaned.replace(FINAL_TAG_RE, "");
+        const finalMatches = [];
+        const preCodeRegions = findCodeRegions(cleaned);
+        for (const match of cleaned.matchAll(FINAL_TAG_RE)) {
+            const start = match.index ?? 0;
+            finalMatches.push({
+                start,
+                length: match[0].length,
+                inCode: isInsideCode(start, preCodeRegions),
+            });
+        }
+        for (let i = finalMatches.length - 1; i >= 0; i--) {
+            const m = finalMatches[i];
+            if (!m.inCode) {
+                cleaned = cleaned.slice(0, m.start) + cleaned.slice(m.start + m.length);
+            }
+        }
     }
     else {
         FINAL_TAG_RE.lastIndex = 0;
     }
+    const codeRegions = findCodeRegions(cleaned);
     THINKING_TAG_RE.lastIndex = 0;
     let result = "";
     let lastIndex = 0;
@@ -30,6 +72,9 @@ export function stripReasoningTagsFromText(text, options) {
     for (const match of cleaned.matchAll(THINKING_TAG_RE)) {
         const idx = match.index ?? 0;
         const isClose = match[1] === "/";
+        if (isInsideCode(idx, codeRegions)) {
+            continue;
+        }
         if (!inThinking) {
             result += cleaned.slice(lastIndex, idx);
             if (!isClose) {

package/dist/slack/monitor/message-handler/prepare.js

@@ -350,10 +350,16 @@ export async function prepareSlackMessage(params) {
         });
     }
     const slackTo = isDirectMessage ? `user:${message.user}` : `channel:${message.channel}`;
-    // SECURITY: Do NOT include channel topic/purpose in system prompt
-    // Channel metadata is user-controlled and can cause prompt injection
-    // Only include channelConfig.systemPrompt (admin-controlled)
-    const groupSystemPrompt = channelConfig?.systemPrompt?.trim() || undefined;
+    const channelDescription = [channelInfo?.topic, channelInfo?.purpose]
+        .map((entry) => entry?.trim())
+        .filter((entry) => Boolean(entry))
+        .filter((entry, index, list) => list.indexOf(entry) === index)
+        .join("\n");
+    const systemPromptParts = [
+        channelDescription ? `Channel description: ${channelDescription}` : null,
+        channelConfig?.systemPrompt?.trim() || null,
+    ].filter((entry) => Boolean(entry));
+    const groupSystemPrompt = systemPromptParts.length > 0 ? systemPromptParts.join("\n\n") : undefined;
     let threadStarterBody;
     let threadLabel;
     let threadStarterMedia = null;

package/dist/slack/monitor/slash.js

@@ -288,10 +288,16 @@ export function registerSlackMonitorSlashCommands(params) {
                     id: isDirectMessage ? command.user_id : command.channel_id,
                 },
             });
-            // SECURITY: Do NOT include channel topic/purpose in system prompt
-            // Channel metadata is user-controlled and can cause prompt injection
-            // Only include channelConfig.systemPrompt (admin-controlled)
-            const groupSystemPrompt = channelConfig?.systemPrompt?.trim() || undefined;
+            const channelDescription = [channelInfo?.topic, channelInfo?.purpose]
+                .map((entry) => entry?.trim())
+                .filter((entry) => Boolean(entry))
+                .filter((entry, index, list) => list.indexOf(entry) === index)
+                .join("\n");
+            const systemPromptParts = [
+                channelDescription ? `Channel description: ${channelDescription}` : null,
+                channelConfig?.systemPrompt?.trim() || null,
+            ].filter((entry) => Boolean(entry));
+            const groupSystemPrompt = systemPromptParts.length > 0 ? systemPromptParts.join("\n\n") : undefined;
             const ctxPayload = finalizeInboundContext({
                 Body: prompt,
                 RawBody: prompt,

package/dist/tailscale/detect.js

@@ -0,0 +1,146 @@
+import { execSync } from "node:child_process";
+import fs from "node:fs/promises";
+import os from "node:os";
+/**
+ * Check if Tailscale is installed by looking for the binary.
+ */
+async function isTailscaleInstalled() {
+    try {
+        const platform = os.platform();
+        const possiblePaths = [];
+        if (platform === "linux") {
+            possiblePaths.push("/usr/bin/tailscale", "/usr/local/bin/tailscale");
+        }
+        else if (platform === "darwin") {
+            possiblePaths.push("/Applications/Tailscale.app/Contents/MacOS/Tailscale", "/usr/local/bin/tailscale");
+        }
+        else if (platform === "win32") {
+            possiblePaths.push("C:\\Program Files\\Tailscale\\tailscale.exe", "C:\\ProgramData\\chocolatey\\lib\\tailscale\\tools\\tailscale.exe");
+        }
+        for (const binPath of possiblePaths) {
+            try {
+                await fs.access(binPath);
+                return true;
+            }
+            catch {
+                continue;
+            }
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Run tailscale status command and parse output.
+ */
+async function getTailscaleStatus() {
+    try {
+        const platform = os.platform();
+        const binPath = platform === "win32"
+            ? "tailscale.exe"
+            : platform === "darwin"
+                ? "/Applications/Tailscale.app/Contents/MacOS/Tailscale"
+                : "tailscale";
+        const timeout = 5000;
+        const result = execSync(`"${binPath}" status --json`, {
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "pipe"],
+            timeout,
+        });
+        const status = JSON.parse(result.trim());
+        // Extract useful info from Tailscale status JSON
+        const self = status.Self || {};
+        const backendState = status.BackendState || "";
+        return {
+            installed: true,
+            running: backendState === "Running",
+            ip: self.TailscaleIPs?.[0],
+            dnsName: self.DNSName,
+            hostname: self.HostName,
+            tailnet: status.MagicsockName || status.TailnetName,
+            online: self.Online ?? false,
+            canServe: true, // If running, can serve
+            canFunnel: self.Capabilities?.map.includes("funnel") ?? false,
+        };
+    }
+    catch (err) {
+        // If command fails, return minimal info
+        return {
+            installed: await isTailscaleInstalled(),
+            running: false,
+            canServe: false,
+            canFunnel: false,
+            online: false,
+        };
+    }
+}
+/**
+ * Auto-detect Tailscale configuration and recommend settings.
+ *
+ * This is a SAFE detection function - it only reads status and never
+ * modifies configuration. Recommendations are purely advisory.
+ *
+ * @returns Tailscale auto-detection result
+ */
+export async function detectTailscaleConfig() {
+    const info = {
+        installed: await isTailscaleInstalled(),
+        running: false,
+        canServe: false,
+        canFunnel: false,
+        online: false,
+    };
+    if (!info.installed) {
+        return { detected: false };
+    }
+    // Get detailed status if installed
+    const status = await getTailscaleStatus();
+    Object.assign(info, status);
+    // Generate recommendations based on detected state
+    const recommended = info.online
+        ? {
+            mode: info.canFunnel ? "funnel" : "serve",
+            bind: "tailnet",
+            port: 18789,
+            reason: info.canFunnel
+                ? "Tailscale is online and supports funnel (public access)"
+                : "Tailscale is online - use serve for private tailnet access",
+        }
+        : info.running
+            ? {
+                mode: "off",
+                bind: "loopback",
+                port: 18789,
+                reason: "Tailscale is installed but offline - use loopback bind",
+            }
+            : undefined;
+    return {
+        detected: true,
+        info,
+        recommended,
+    };
+}
+/**
+ * Get a human-readable summary of Tailscale detection.
+ */
+export function formatTailscaleDetection(result) {
+    if (!result.detected || !result.info) {
+        return "Tailscale: Not installed";
+    }
+    const { info, recommended } = result;
+    const parts = [];
+    parts.push(`Tailscale: ${info.installed ? "Installed" : "Not installed"}`);
+    parts.push(`Status: ${info.running ? (info.online ? "Online" : "Offline") : "Not running"}`);
+    if (info.online && info.ip) {
+        parts.push(`IP: ${info.ip}`);
+    }
+    if (info.dnsName) {
+        parts.push(`DNS: ${info.dnsName}`);
+    }
+    if (recommended) {
+        parts.push(`\nRecommendation: ${recommended.mode} (${recommended.reason})`);
+    }
+    return parts.join(" | ");
+}

package/dist/telegram/bot-message-context.js

@@ -141,7 +141,7 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
                             await withTelegramApiErrorLogging({
                                 operation: "sendMessage",
                                 fn: () => bot.api.sendMessage(chatId, [
-                                    "Moltbot: access not configured.",
+                                    "Poolbot: access not configured.",
                                     "",
                                     `Your Telegram user id: ${telegramUserId}`,
                                     "",

package/dist/test-helpers/workspace.js

@@ -0,0 +1,11 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+export async function makeTempWorkspace(prefix = "poolbot-workspace-") {
+    return fs.mkdtemp(path.join(os.tmpdir(), prefix));
+}
+export async function writeWorkspaceFile(params) {
+    const filePath = path.join(params.dir, params.name);
+    await fs.writeFile(filePath, params.content, "utf-8");
+    return filePath;
+}