@poolzin/pool-bot 2026.2.21 → 2026.2.22

package/dist/agents/tools/web-shared.js

@@ -14,8 +14,9 @@ export function normalizeCacheKey(value) {
 }
 export function readCache(cache, key) {
     const entry = cache.get(key);
-    if (!entry)
+    if (!entry) {
         return null;
+    }
     if (Date.now() > entry.expiresAt) {
         cache.delete(key);
         return null;
@@ -23,12 +24,14 @@ export function readCache(cache, key) {
     return { value: entry.value, cached: true };
 }
 export function writeCache(cache, key, value, ttlMs) {
-    if (ttlMs <= 0)
+    if (ttlMs <= 0) {
         return;
+    }
     if (cache.size >= DEFAULT_CACHE_MAX_ENTRIES) {
         const oldest = cache.keys().next();
-        if (!oldest.done)
+        if (!oldest.done) {
             cache.delete(oldest.value);
+        }
     }
     cache.set(key, {
         value,
@@ -37,10 +40,11 @@ export function writeCache(cache, key, value, ttlMs) {
     });
 }
 export function withTimeout(signal, timeoutMs) {
-    if (timeoutMs <= 0)
+    if (timeoutMs <= 0) {
         return signal ?? new AbortController().signal;
+    }
     const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const timer = setTimeout(controller.abort.bind(controller), timeoutMs);
     if (signal) {
         signal.addEventListener("abort", () => {
             clearTimeout(timer);
@@ -52,11 +56,70 @@ export function withTimeout(signal, timeoutMs) {
     }, { once: true });
     return controller.signal;
 }
-export async function readResponseText(res) {
+export async function readResponseText(res, options) {
+    const maxBytesRaw = options?.maxBytes;
+    const maxBytes = typeof maxBytesRaw === "number" && Number.isFinite(maxBytesRaw) && maxBytesRaw > 0
+        ? Math.floor(maxBytesRaw)
+        : undefined;
+    const body = res.body;
+    if (maxBytes &&
+        body &&
+        typeof body === "object" &&
+        "getReader" in body &&
+        typeof body.getReader === "function") {
+        const reader = body.getReader();
+        const decoder = new TextDecoder();
+        let bytesRead = 0;
+        let truncated = false;
+        const parts = [];
+        try {
+            while (true) {
+                const { value, done } = await reader.read();
+                if (done) {
+                    break;
+                }
+                if (!value || value.byteLength === 0) {
+                    continue;
+                }
+                let chunk = value;
+                if (bytesRead + chunk.byteLength > maxBytes) {
+                    const remaining = Math.max(0, maxBytes - bytesRead);
+                    if (remaining <= 0) {
+                        truncated = true;
+                        break;
+                    }
+                    chunk = chunk.subarray(0, remaining);
+                    truncated = true;
+                }
+                bytesRead += chunk.byteLength;
+                parts.push(decoder.decode(chunk, { stream: true }));
+                if (truncated || bytesRead >= maxBytes) {
+                    truncated = true;
+                    break;
+                }
+            }
+        }
+        catch {
+            // Best-effort: return whatever we decoded so far.
+        }
+        finally {
+            if (truncated) {
+                try {
+                    await reader.cancel();
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+        parts.push(decoder.decode());
+        return { text: parts.join(""), truncated, bytesRead };
+    }
     try {
-        return await res.text();
+        const text = await res.text();
+        return { text, truncated: false, bytesRead: text.length };
     }
     catch {
-        return "";
+        return { text: "", truncated: false, bytesRead: 0 };
     }
 }

package/dist/agents/usage.js

@@ -1,18 +1,22 @@
 const asFiniteNumber = (value) => {
-    if (typeof value !== "number")
+    if (typeof value !== "number") {
         return undefined;
-    if (!Number.isFinite(value))
+    }
+    if (!Number.isFinite(value)) {
         return undefined;
+    }
     return value;
 };
 export function hasNonzeroUsage(usage) {
-    if (!usage)
+    if (!usage) {
         return false;
+    }
     return [usage.input, usage.output, usage.cacheRead, usage.cacheWrite, usage.total].some((v) => typeof v === "number" && Number.isFinite(v) && v > 0);
 }
 export function normalizeUsage(raw) {
-    if (!raw)
+    if (!raw) {
         return undefined;
+    }
     const input = asFiniteNumber(raw.input ?? raw.inputTokens ?? raw.input_tokens ?? raw.promptTokens ?? raw.prompt_tokens);
     const output = asFiniteNumber(raw.output ??
         raw.outputTokens ??
@@ -48,23 +52,28 @@ export function derivePromptTokens(usage) {
     return sum > 0 ? sum : undefined;
 }
 export function deriveSessionTotalTokens(params) {
+    const promptOverride = params.promptTokens;
+    const hasPromptOverride = typeof promptOverride === "number" && Number.isFinite(promptOverride) && promptOverride > 0;
     const usage = params.usage;
-    if (!usage) {
+    if (!usage && !hasPromptOverride) {
         return undefined;
     }
-    const input = usage.input ?? 0;
-    const promptTokens = derivePromptTokens({
-        input: usage.input,
-        cacheRead: usage.cacheRead,
-        cacheWrite: usage.cacheWrite,
-    });
-    let total = promptTokens ?? usage.total ?? input;
+    const input = usage?.input ?? 0;
+    const promptTokens = hasPromptOverride
+        ? promptOverride
+        : derivePromptTokens({
+            input: usage?.input,
+            cacheRead: usage?.cacheRead,
+            cacheWrite: usage?.cacheWrite,
+        });
+    let total = promptTokens ?? usage?.total ?? input;
     if (!(total > 0)) {
         return undefined;
     }
-    const contextTokens = params.contextTokens;
-    if (typeof contextTokens === "number" && Number.isFinite(contextTokens) && contextTokens > 0) {
-        total = Math.min(total, contextTokens);
-    }
+    // NOTE: Do NOT clamp total to contextTokens here. The stored totalTokens
+    // should reflect the actual token count (or best estimate). Clamping causes
+    // /status to display contextTokens/contextTokens (100%) when the accumulated
+    // input exceeds the context window, hiding the real usage. The display layer
+    // (formatTokens in status.ts) already caps the percentage at 999%.
     return total;
 }

package/dist/auto-reply/commands-registry.data.js

@@ -1,7 +1,7 @@
 import { listChannelDocks } from "../channels/dock.js";
 import { getActivePluginRegistry } from "../plugins/runtime.js";
-import { listThinkingLevels } from "./thinking.js";
 import { COMMAND_ARG_FORMATTERS } from "./commands-args.js";
+import { listThinkingLevels } from "./thinking.js";
 function defineChatCommand(command) {
     const aliases = (command.textAliases ?? (command.textAlias ? [command.textAlias] : []))
         .map((alias) => alias.trim())
@@ -40,11 +40,13 @@ function registerAlias(commands, key, ...aliases) {
     const existing = new Set(command.textAliases.map((alias) => alias.trim().toLowerCase()));
     for (const alias of aliases) {
         const trimmed = alias.trim();
-        if (!trimmed)
+        if (!trimmed) {
             continue;
+        }
         const lowered = trimmed.toLowerCase();
-        if (existing.has(lowered))
+        if (existing.has(lowered)) {
             continue;
+        }
         existing.add(lowered);
         command.textAliases.push(trimmed);
     }
@@ -164,6 +166,22 @@ function buildChatCommands() {
             acceptsArgs: true,
             category: "status",
         }),
+        defineChatCommand({
+            key: "export-session",
+            nativeName: "export-session",
+            description: "Export current session to HTML file with full system prompt.",
+            textAliases: ["/export-session", "/export"],
+            acceptsArgs: true,
+            category: "status",
+            args: [
+                {
+                    name: "path",
+                    description: "Output path (default: workspace)",
+                    type: "string",
+                    required: false,
+                },
+            ],
+        }),
         defineChatCommand({
             key: "tts",
             nativeName: "tts",
@@ -216,15 +234,15 @@ function buildChatCommands() {
         defineChatCommand({
             key: "subagents",
             nativeName: "subagents",
-            description: "List/stop/log/info subagent runs for this session.",
+            description: "List, kill, log, spawn, or steer subagent runs for this session.",
             textAlias: "/subagents",
             category: "management",
             args: [
                 {
                     name: "action",
-                    description: "list | stop | log | info | send",
+                    description: "list | kill | log | info | send | steer | spawn",
                     type: "string",
-                    choices: ["list", "stop", "log", "info", "send"],
+                    choices: ["list", "kill", "log", "info", "send", "steer", "spawn"],
                 },
                 {
                     name: "target",
@@ -240,6 +258,41 @@ function buildChatCommands() {
             ],
             argsMenu: "auto",
         }),
+        defineChatCommand({
+            key: "kill",
+            nativeName: "kill",
+            description: "Kill a running subagent (or all).",
+            textAlias: "/kill",
+            category: "management",
+            args: [
+                {
+                    name: "target",
+                    description: "Label, run id, index, or all",
+                    type: "string",
+                },
+            ],
+            argsMenu: "auto",
+        }),
+        defineChatCommand({
+            key: "steer",
+            nativeName: "steer",
+            description: "Send guidance to a running subagent.",
+            textAlias: "/steer",
+            category: "management",
+            args: [
+                {
+                    name: "target",
+                    description: "Label, run id, or index",
+                    type: "string",
+                },
+                {
+                    name: "message",
+                    description: "Steering message",
+                    type: "string",
+                    captureRemaining: true,
+                },
+            ],
+        }),
         defineChatCommand({
             key: "config",
             nativeName: "config",
@@ -322,7 +375,7 @@ function buildChatCommands() {
         defineChatCommand({
             key: "restart",
             nativeName: "restart",
-            description: "Restart Poolbot.",
+            description: "Restart Pool Bot.",
             textAlias: "/restart",
             category: "tools",
         }),
@@ -376,9 +429,9 @@ function buildChatCommands() {
         }),
         defineChatCommand({
             key: "compact",
+            nativeName: "compact",
             description: "Compact the session context.",
             textAlias: "/compact",
-            scope: "text",
             category: "session",
             args: [
                 {
@@ -461,12 +514,31 @@ function buildChatCommands() {
             category: "options",
             args: [
                 {
-                    name: "options",
-                    description: "host=... security=... ask=... node=...",
+                    name: "host",
+                    description: "sandbox, gateway, or node",
+                    type: "string",
+                    choices: ["sandbox", "gateway", "node"],
+                },
+                {
+                    name: "security",
+                    description: "deny, allowlist, or full",
+                    type: "string",
+                    choices: ["deny", "allowlist", "full"],
+                },
+                {
+                    name: "ask",
+                    description: "off, on-miss, or always",
+                    type: "string",
+                    choices: ["off", "on-miss", "always"],
+                },
+                {
+                    name: "node",
+                    description: "Node id or name",
                     type: "string",
                 },
             ],
             argsParsing: "none",
+            formatArgs: COMMAND_ARG_FORMATTERS.exec,
         }),
         defineChatCommand({
             key: "model",
@@ -548,13 +620,15 @@ function buildChatCommands() {
     registerAlias(commands, "verbose", "/v");
     registerAlias(commands, "reasoning", "/reason");
     registerAlias(commands, "elevated", "/elev");
+    registerAlias(commands, "steer", "/tell");
     assertCommandRegistry(commands);
     return commands;
 }
 export function getChatCommands() {
     const registry = getActivePluginRegistry();
-    if (cachedCommands && registry === cachedRegistry)
+    if (cachedCommands && registry === cachedRegistry) {
         return cachedCommands;
+    }
     const commands = buildChatCommands();
     cachedCommands = commands;
     cachedRegistry = registry;

package/dist/auto-reply/dispatch.js

@@ -1,40 +1,59 @@
-import { finalizeInboundContext } from "./reply/inbound-context.js";
 import { dispatchReplyFromConfig } from "./reply/dispatch-from-config.js";
+import { finalizeInboundContext } from "./reply/inbound-context.js";
 import { createReplyDispatcher, createReplyDispatcherWithTyping, } from "./reply/reply-dispatcher.js";
+export async function withReplyDispatcher(params) {
+    try {
+        return await params.run();
+    }
+    finally {
+        // Ensure dispatcher reservations are always released on every exit path.
+        params.dispatcher.markComplete();
+        try {
+            await params.dispatcher.waitForIdle();
+        }
+        finally {
+            await params.onSettled?.();
+        }
+    }
+}
 export async function dispatchInboundMessage(params) {
     const finalized = finalizeInboundContext(params.ctx);
-    return await dispatchReplyFromConfig({
-        ctx: finalized,
-        cfg: params.cfg,
+    return await withReplyDispatcher({
         dispatcher: params.dispatcher,
-        replyOptions: params.replyOptions,
-        replyResolver: params.replyResolver,
+        run: () => dispatchReplyFromConfig({
+            ctx: finalized,
+            cfg: params.cfg,
+            dispatcher: params.dispatcher,
+            replyOptions: params.replyOptions,
+            replyResolver: params.replyResolver,
+        }),
     });
 }
 export async function dispatchInboundMessageWithBufferedDispatcher(params) {
     const { dispatcher, replyOptions, markDispatchIdle } = createReplyDispatcherWithTyping(params.dispatcherOptions);
-    const result = await dispatchInboundMessage({
-        ctx: params.ctx,
-        cfg: params.cfg,
-        dispatcher,
-        replyResolver: params.replyResolver,
-        replyOptions: {
-            ...params.replyOptions,
-            ...replyOptions,
-        },
-    });
-    markDispatchIdle();
-    return result;
+    try {
+        return await dispatchInboundMessage({
+            ctx: params.ctx,
+            cfg: params.cfg,
+            dispatcher,
+            replyResolver: params.replyResolver,
+            replyOptions: {
+                ...params.replyOptions,
+                ...replyOptions,
+            },
+        });
+    }
+    finally {
+        markDispatchIdle();
+    }
 }
 export async function dispatchInboundMessageWithDispatcher(params) {
     const dispatcher = createReplyDispatcher(params.dispatcherOptions);
-    const result = await dispatchInboundMessage({
+    return await dispatchInboundMessage({
         ctx: params.ctx,
         cfg: params.cfg,
         dispatcher,
         replyResolver: params.replyResolver,
         replyOptions: params.replyOptions,
     });
-    await dispatcher.waitForIdle();
-    return result;
 }

package/dist/auto-reply/reply/abort.js

@@ -1,27 +1,76 @@
 import { resolveSessionAgentId } from "../../agents/agent-scope.js";
 import { abortEmbeddedPiRun } from "../../agents/pi-embedded.js";
-import { listSubagentRunsForRequester } from "../../agents/subagent-registry.js";
+import { listSubagentRunsForRequester, markSubagentRunTerminated, } from "../../agents/subagent-registry.js";
+import { resolveInternalSessionKey, resolveMainSessionAlias, } from "../../agents/tools/sessions-helpers.js";
 import { loadSessionStore, resolveStorePath, updateSessionStore, } from "../../config/sessions.js";
+import { logVerbose } from "../../globals.js";
 import { parseAgentSessionKey } from "../../routing/session-key.js";
 import { resolveCommandAuthorization } from "../command-auth.js";
 import { normalizeCommandBody } from "../commands-registry.js";
-import { logVerbose } from "../../globals.js";
 import { stripMentions, stripStructuralPrefixes } from "./mentions.js";
 import { clearSessionQueues } from "./queue.js";
-import { resolveInternalSessionKey, resolveMainSessionAlias, } from "../../agents/tools/sessions-helpers.js";
 const ABORT_TRIGGERS = new Set(["stop", "esc", "abort", "wait", "exit", "interrupt"]);
 const ABORT_MEMORY = new Map();
+const ABORT_MEMORY_MAX = 2000;
 export function isAbortTrigger(text) {
-    if (!text)
+    if (!text) {
         return false;
+    }
     const normalized = text.trim().toLowerCase();
     return ABORT_TRIGGERS.has(normalized);
 }
+export function isAbortRequestText(text, options) {
+    if (!text) {
+        return false;
+    }
+    const normalized = normalizeCommandBody(text, options).trim();
+    if (!normalized) {
+        return false;
+    }
+    return normalized.toLowerCase() === "/stop" || isAbortTrigger(normalized);
+}
 export function getAbortMemory(key) {
-    return ABORT_MEMORY.get(key);
+    const normalized = key.trim();
+    if (!normalized) {
+        return undefined;
+    }
+    return ABORT_MEMORY.get(normalized);
+}
+function pruneAbortMemory() {
+    if (ABORT_MEMORY.size <= ABORT_MEMORY_MAX) {
+        return;
+    }
+    const excess = ABORT_MEMORY.size - ABORT_MEMORY_MAX;
+    let removed = 0;
+    for (const entryKey of ABORT_MEMORY.keys()) {
+        ABORT_MEMORY.delete(entryKey);
+        removed += 1;
+        if (removed >= excess) {
+            break;
+        }
+    }
 }
 export function setAbortMemory(key, value) {
-    ABORT_MEMORY.set(key, value);
+    const normalized = key.trim();
+    if (!normalized) {
+        return;
+    }
+    if (!value) {
+        ABORT_MEMORY.delete(normalized);
+        return;
+    }
+    // Refresh insertion order so active keys are less likely to be evicted.
+    if (ABORT_MEMORY.has(normalized)) {
+        ABORT_MEMORY.delete(normalized);
+    }
+    ABORT_MEMORY.set(normalized, true);
+    pruneAbortMemory();
+}
+export function getAbortMemorySizeForTest() {
+    return ABORT_MEMORY.size;
+}
+export function resetAbortMemoryForTest() {
+    ABORT_MEMORY.clear();
 }
 export function formatAbortReplyText(stoppedSubagents) {
     if (typeof stoppedSubagents !== "number" || stoppedSubagents <= 0) {
@@ -31,58 +80,76 @@ export function formatAbortReplyText(stoppedSubagents) {
     return `⚙️ Agent was aborted. Stopped ${stoppedSubagents} ${label}.`;
 }
 function resolveSessionEntryForKey(store, sessionKey) {
-    if (!store || !sessionKey)
+    if (!store || !sessionKey) {
         return {};
+    }
     const direct = store[sessionKey];
-    if (direct)
+    if (direct) {
         return { entry: direct, key: sessionKey };
+    }
     return {};
 }
 function resolveAbortTargetKey(ctx) {
     const target = ctx.CommandTargetSessionKey?.trim();
-    if (target)
+    if (target) {
         return target;
+    }
     const sessionKey = ctx.SessionKey?.trim();
     return sessionKey || undefined;
 }
 function normalizeRequesterSessionKey(cfg, key) {
     const cleaned = key?.trim();
-    if (!cleaned)
+    if (!cleaned) {
         return undefined;
+    }
     const { mainKey, alias } = resolveMainSessionAlias(cfg);
     return resolveInternalSessionKey({ key: cleaned, alias, mainKey });
 }
 export function stopSubagentsForRequester(params) {
     const requesterKey = normalizeRequesterSessionKey(params.cfg, params.requesterSessionKey);
-    if (!requesterKey)
+    if (!requesterKey) {
         return { stopped: 0 };
+    }
     const runs = listSubagentRunsForRequester(requesterKey);
-    if (runs.length === 0)
+    if (runs.length === 0) {
         return { stopped: 0 };
+    }
     const storeCache = new Map();
     const seenChildKeys = new Set();
     let stopped = 0;
     for (const run of runs) {
-        if (run.endedAt)
-            continue;
         const childKey = run.childSessionKey?.trim();
-        if (!childKey || seenChildKeys.has(childKey))
+        if (!childKey || seenChildKeys.has(childKey)) {
             continue;
-        seenChildKeys.add(childKey);
-        const cleared = clearSessionQueues([childKey]);
-        const parsed = parseAgentSessionKey(childKey);
-        const storePath = resolveStorePath(params.cfg.session?.store, { agentId: parsed?.agentId });
-        let store = storeCache.get(storePath);
-        if (!store) {
-            store = loadSessionStore(storePath);
-            storeCache.set(storePath, store);
         }
-        const entry = store[childKey];
-        const sessionId = entry?.sessionId;
-        const aborted = sessionId ? abortEmbeddedPiRun(sessionId) : false;
-        if (aborted || cleared.followupCleared > 0 || cleared.laneCleared > 0) {
-            stopped += 1;
+        seenChildKeys.add(childKey);
+        if (!run.endedAt) {
+            const cleared = clearSessionQueues([childKey]);
+            const parsed = parseAgentSessionKey(childKey);
+            const storePath = resolveStorePath(params.cfg.session?.store, { agentId: parsed?.agentId });
+            let store = storeCache.get(storePath);
+            if (!store) {
+                store = loadSessionStore(storePath);
+                storeCache.set(storePath, store);
+            }
+            const entry = store[childKey];
+            const sessionId = entry?.sessionId;
+            const aborted = sessionId ? abortEmbeddedPiRun(sessionId) : false;
+            const markedTerminated = markSubagentRunTerminated({
+                runId: run.runId,
+                childSessionKey: childKey,
+                reason: "killed",
+            }) > 0;
+            if (markedTerminated || aborted || cleared.followupCleared > 0 || cleared.laneCleared > 0) {
+                stopped += 1;
+            }
         }
+        // Cascade: also stop any sub-sub-agents spawned by this child.
+        const cascadeResult = stopSubagentsForRequester({
+            cfg: params.cfg,
+            requesterSessionKey: childKey,
+        });
+        stopped += cascadeResult.stopped;
     }
     if (stopped > 0) {
         logVerbose(`abort: stopped ${stopped} subagent run(s) for ${requesterKey}`);
@@ -100,18 +167,19 @@ export async function tryFastAbortFromMessage(params) {
     const raw = stripStructuralPrefixes(ctx.CommandBody ?? ctx.RawBody ?? ctx.Body ?? "");
     const isGroup = ctx.ChatType?.trim().toLowerCase() === "group";
     const stripped = isGroup ? stripMentions(raw, ctx, cfg, agentId) : raw;
-    const normalized = normalizeCommandBody(stripped);
-    const abortRequested = normalized === "/stop" || isAbortTrigger(stripped);
-    if (!abortRequested)
+    const abortRequested = isAbortRequestText(stripped);
+    if (!abortRequested) {
         return { handled: false, aborted: false };
+    }
     const commandAuthorized = ctx.CommandAuthorized;
     const auth = resolveCommandAuthorization({
         ctx,
         cfg,
         commandAuthorized,
     });
-    if (!auth.isAuthorizedSender)
+    if (!auth.isAuthorizedSender) {
         return { handled: false, aborted: false };
+    }
     const abortKey = targetKey ?? auth.from ?? auth.to;
     const requesterSessionKey = targetKey ?? ctx.SessionKey ?? abortKey;
     if (targetKey) {
@@ -130,8 +198,9 @@ export async function tryFastAbortFromMessage(params) {
             store[key] = entry;
             await updateSessionStore(storePath, (nextStore) => {
                 const nextEntry = nextStore[key] ?? entry;
-                if (!nextEntry)
+                if (!nextEntry) {
                     return;
+                }
                 nextEntry.abortedLastRun = true;
                 nextEntry.updatedAt = Date.now();
                 nextStore[key] = nextEntry;