@poolzin/pool-bot 2026.2.7 → 2026.2.8

package/dist/agents/pi-embedded-subscribe.js

@@ -1,6 +1,7 @@
 import { parseReplyDirectives } from "../auto-reply/reply/reply-directives.js";
 import { createStreamingDirectiveAccumulator } from "../auto-reply/reply/streaming-directives.js";
 import { formatToolAggregate } from "../auto-reply/tool-meta.js";
+import { emitAgentEvent } from "../infra/agent-events.js";
 import { createSubsystemLogger } from "../logging/subsystem.js";
 import { buildCodeSpanIndex, createInlineCodeState } from "../markdown/code-spans.js";
 import { EmbeddedBlockChunker } from "./pi-embedded-block-chunker.js";
@@ -46,7 +47,9 @@ export function subscribeEmbeddedPiSession(params) {
         compactionInFlight: false,
         pendingCompactionRetry: 0,
         compactionRetryResolve: undefined,
+        compactionRetryReject: undefined,
         compactionRetryPromise: null,
+        unsubscribed: false,
         messagingToolSentTexts: [],
         messagingToolSentTextsNormalized: [],
         messagingToolSentTargets: [],
@@ -168,8 +171,12 @@ export function subscribeEmbeddedPiSession(params) {
     };
     const ensureCompactionPromise = () => {
         if (!state.compactionRetryPromise) {
-            state.compactionRetryPromise = new Promise((resolve) => {
+            state.compactionRetryPromise = new Promise((resolve, reject) => {
                 state.compactionRetryResolve = resolve;
+                state.compactionRetryReject = reject;
+            });
+            state.compactionRetryPromise.catch((err) => {
+                log.debug(`compaction promise rejected (no waiter): ${String(err)}`);
             });
         }
     };
@@ -185,6 +192,7 @@ export function subscribeEmbeddedPiSession(params) {
         if (state.pendingCompactionRetry === 0 && !state.compactionInFlight) {
             state.compactionRetryResolve?.();
             state.compactionRetryResolve = undefined;
+            state.compactionRetryReject = undefined;
             state.compactionRetryPromise = null;
         }
     };
@@ -192,6 +200,7 @@ export function subscribeEmbeddedPiSession(params) {
         if (state.pendingCompactionRetry === 0 && !state.compactionInFlight) {
             state.compactionRetryResolve?.();
             state.compactionRetryResolve = undefined;
+            state.compactionRetryReject = undefined;
             state.compactionRetryPromise = null;
         }
     };
@@ -460,7 +469,17 @@ export function subscribeEmbeddedPiSession(params) {
         if (formatted === state.lastStreamedReasoning) {
             return;
         }
+        const prior = state.lastStreamedReasoning ?? "";
+        const delta = formatted.startsWith(prior) ? formatted.slice(prior.length) : formatted;
         state.lastStreamedReasoning = formatted;
+        emitAgentEvent({
+            runId: params.runId,
+            stream: "thinking",
+            data: {
+                text: formatted,
+                delta,
+            },
+        });
         void params.onReasoningStream({
             text: formatted,
         });
@@ -478,12 +497,19 @@ export function subscribeEmbeddedPiSession(params) {
         pendingMessagingTargets.clear();
         resetAssistantMessageState(0);
     };
+    const noteLastAssistant = (msg) => {
+        if (msg?.role === "assistant") {
+            state.lastAssistant = msg;
+        }
+    };
     const ctx = {
         params,
         state,
         log,
         blockChunking,
         blockChunker,
+        hookRunner: params.hookRunner,
+        noteLastAssistant,
         shouldEmitToolResult,
         shouldEmitToolOutput,
         emitToolSummary,
@@ -507,12 +533,30 @@ export function subscribeEmbeddedPiSession(params) {
         getUsageTotals,
         getCompactionCount: () => compactionCount,
     };
-    const unsubscribe = params.session.subscribe(createEmbeddedPiSessionEventHandler(ctx));
+    const sessionUnsubscribe = params.session.subscribe(createEmbeddedPiSessionEventHandler(ctx));
+    const unsubscribe = () => {
+        if (state.unsubscribed) {
+            return;
+        }
+        state.unsubscribed = true;
+        if (state.compactionRetryPromise) {
+            log.debug(`unsubscribe: rejecting compaction wait runId=${params.runId}`);
+            const reject = state.compactionRetryReject;
+            state.compactionRetryResolve = undefined;
+            state.compactionRetryReject = undefined;
+            state.compactionRetryPromise = null;
+            const abortErr = new Error("Unsubscribed during compaction");
+            abortErr.name = "AbortError";
+            reject?.(abortErr);
+        }
+        sessionUnsubscribe();
+    };
     return {
         assistantTexts,
         toolMetas,
         unsubscribe,
         isCompacting: () => state.compactionInFlight || state.pendingCompactionRetry > 0,
+        isCompactionInFlight: () => state.compactionInFlight,
         getMessagingToolSentTexts: () => messagingToolSentTexts.slice(),
         getMessagingToolSentTargets: () => messagingToolSentTargets.slice(),
         // Returns true if any messaging tool successfully sent a message.
@@ -523,15 +567,26 @@ export function subscribeEmbeddedPiSession(params) {
         getUsageTotals,
         getCompactionCount: () => compactionCount,
         waitForCompactionRetry: () => {
+            if (state.unsubscribed) {
+                const err = new Error("Unsubscribed during compaction wait");
+                err.name = "AbortError";
+                return Promise.reject(err);
+            }
             if (state.compactionInFlight || state.pendingCompactionRetry > 0) {
                 ensureCompactionPromise();
                 return state.compactionRetryPromise ?? Promise.resolve();
             }
-            return new Promise((resolve) => {
+            return new Promise((resolve, reject) => {
                 queueMicrotask(() => {
+                    if (state.unsubscribed) {
+                        const err = new Error("Unsubscribed during compaction wait");
+                        err.name = "AbortError";
+                        reject(err);
+                        return;
+                    }
                     if (state.compactionInFlight || state.pendingCompactionRetry > 0) {
                         ensureCompactionPromise();
-                        void (state.compactionRetryPromise ?? Promise.resolve()).then(resolve);
+                        void (state.compactionRetryPromise ?? Promise.resolve()).then(resolve, reject);
                     }
                     else {
                         resolve();

package/dist/agents/tool-mutation.js

@@ -0,0 +1,164 @@
+const MUTATING_TOOL_NAMES = new Set([
+    "write",
+    "edit",
+    "apply_patch",
+    "exec",
+    "bash",
+    "process",
+    "message",
+    "sessions_send",
+    "cron",
+    "gateway",
+    "canvas",
+    "nodes",
+    "session_status",
+]);
+const READ_ONLY_ACTIONS = new Set([
+    "get",
+    "list",
+    "read",
+    "status",
+    "show",
+    "fetch",
+    "search",
+    "query",
+    "view",
+    "poll",
+    "log",
+    "inspect",
+    "check",
+    "probe",
+]);
+const PROCESS_MUTATING_ACTIONS = new Set(["write", "send_keys", "submit", "paste", "kill"]);
+const MESSAGE_MUTATING_ACTIONS = new Set([
+    "send",
+    "reply",
+    "thread_reply",
+    "threadreply",
+    "edit",
+    "delete",
+    "react",
+    "pin",
+    "unpin",
+]);
+function asRecord(value) {
+    return value && typeof value === "object" ? value : undefined;
+}
+function normalizeActionName(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const normalized = value
+        .trim()
+        .toLowerCase()
+        .replace(/[\s-]+/g, "_");
+    return normalized || undefined;
+}
+function normalizeFingerprintValue(value) {
+    if (typeof value === "string") {
+        const normalized = value.trim();
+        return normalized ? normalized.toLowerCase() : undefined;
+    }
+    if (typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") {
+        return String(value).toLowerCase();
+    }
+    return undefined;
+}
+export function isLikelyMutatingToolName(toolName) {
+    const normalized = toolName.trim().toLowerCase();
+    if (!normalized) {
+        return false;
+    }
+    return (MUTATING_TOOL_NAMES.has(normalized) ||
+        normalized.endsWith("_actions") ||
+        normalized.startsWith("message_") ||
+        normalized.includes("send"));
+}
+export function isMutatingToolCall(toolName, args) {
+    const normalized = toolName.trim().toLowerCase();
+    const record = asRecord(args);
+    const action = normalizeActionName(record?.action);
+    switch (normalized) {
+        case "write":
+        case "edit":
+        case "apply_patch":
+        case "exec":
+        case "bash":
+        case "sessions_send":
+            return true;
+        case "process":
+            return action != null && PROCESS_MUTATING_ACTIONS.has(action);
+        case "message":
+            return ((action != null && MESSAGE_MUTATING_ACTIONS.has(action)) ||
+                typeof record?.content === "string" ||
+                typeof record?.message === "string");
+        case "session_status":
+            return typeof record?.model === "string" && record.model.trim().length > 0;
+        default: {
+            if (normalized === "cron" || normalized === "gateway" || normalized === "canvas") {
+                return action == null || !READ_ONLY_ACTIONS.has(action);
+            }
+            if (normalized === "nodes") {
+                return action == null || action !== "list";
+            }
+            if (normalized.endsWith("_actions")) {
+                return action == null || !READ_ONLY_ACTIONS.has(action);
+            }
+            if (normalized.startsWith("message_") || normalized.includes("send")) {
+                return true;
+            }
+            return false;
+        }
+    }
+}
+export function buildToolActionFingerprint(toolName, args, meta) {
+    if (!isMutatingToolCall(toolName, args)) {
+        return undefined;
+    }
+    const normalizedTool = toolName.trim().toLowerCase();
+    const record = asRecord(args);
+    const action = normalizeActionName(record?.action);
+    const parts = [`tool=${normalizedTool}`];
+    if (action) {
+        parts.push(`action=${action}`);
+    }
+    for (const key of [
+        "path",
+        "filePath",
+        "oldPath",
+        "newPath",
+        "to",
+        "target",
+        "messageId",
+        "sessionKey",
+        "jobId",
+        "id",
+        "model",
+    ]) {
+        const value = normalizeFingerprintValue(record?.[key]);
+        if (value) {
+            parts.push(`${key.toLowerCase()}=${value}`);
+        }
+    }
+    const normalizedMeta = meta?.trim().replace(/\s+/g, " ").toLowerCase();
+    if (normalizedMeta) {
+        parts.push(`meta=${normalizedMeta}`);
+    }
+    return parts.join("|");
+}
+export function buildToolMutationState(toolName, args, meta) {
+    const actionFingerprint = buildToolActionFingerprint(toolName, args, meta);
+    return {
+        mutatingAction: actionFingerprint != null,
+        actionFingerprint,
+    };
+}
+export function isSameToolMutationAction(existing, next) {
+    if (existing.actionFingerprint != null || next.actionFingerprint != null) {
+        // For mutating flows, fail closed: only clear when both fingerprints exist and match.
+        return (existing.actionFingerprint != null &&
+            next.actionFingerprint != null &&
+            existing.actionFingerprint === next.actionFingerprint);
+    }
+    return existing.toolName === next.toolName && (existing.meta ?? "") === (next.meta ?? "");
+}

package/dist/agents/tool-policy-pipeline.js

@@ -0,0 +1,69 @@
+import { filterToolsByPolicy } from "./pi-tools.policy.js";
+import { buildPluginToolGroups, expandPolicyWithPluginGroups, normalizeToolName, stripPluginOnlyAllowlist, } from "./tool-policy.js";
+export function buildDefaultToolPolicyPipelineSteps(params) {
+    const agentId = params.agentId?.trim();
+    const profile = params.profile?.trim();
+    const providerProfile = params.providerProfile?.trim();
+    return [
+        {
+            policy: params.profilePolicy,
+            label: profile ? `tools.profile (${profile})` : "tools.profile",
+            stripPluginOnlyAllowlist: true,
+        },
+        {
+            policy: params.providerProfilePolicy,
+            label: providerProfile
+                ? `tools.byProvider.profile (${providerProfile})`
+                : "tools.byProvider.profile",
+            stripPluginOnlyAllowlist: true,
+        },
+        { policy: params.globalPolicy, label: "tools.allow", stripPluginOnlyAllowlist: true },
+        {
+            policy: params.globalProviderPolicy,
+            label: "tools.byProvider.allow",
+            stripPluginOnlyAllowlist: true,
+        },
+        {
+            policy: params.agentPolicy,
+            label: agentId ? `agents.${agentId}.tools.allow` : "agent tools.allow",
+            stripPluginOnlyAllowlist: true,
+        },
+        {
+            policy: params.agentProviderPolicy,
+            label: agentId ? `agents.${agentId}.tools.byProvider.allow` : "agent tools.byProvider.allow",
+            stripPluginOnlyAllowlist: true,
+        },
+        { policy: params.groupPolicy, label: "group tools.allow", stripPluginOnlyAllowlist: true },
+    ];
+}
+export function applyToolPolicyPipeline(params) {
+    const coreToolNames = new Set(params.tools
+        .filter((tool) => !params.toolMeta(tool))
+        .map((tool) => normalizeToolName(tool.name))
+        .filter(Boolean));
+    const pluginGroups = buildPluginToolGroups({
+        tools: params.tools,
+        toolMeta: params.toolMeta,
+    });
+    let filtered = params.tools;
+    for (const step of params.steps) {
+        if (!step.policy) {
+            continue;
+        }
+        let policy = step.policy;
+        if (step.stripPluginOnlyAllowlist) {
+            const resolved = stripPluginOnlyAllowlist(policy, pluginGroups, coreToolNames);
+            if (resolved.unknownAllowlist.length > 0) {
+                const entries = resolved.unknownAllowlist.join(", ");
+                const suffix = resolved.strippedAllowlist
+                    ? "Ignoring allowlist so core tools remain available. Use tools.alsoAllow for additive plugin tool enablement."
+                    : "These entries won't match any tool unless the plugin is enabled.";
+                params.warn(`tools: ${step.label} allowlist contains unknown entries (${entries}). ${suffix}`);
+            }
+            policy = resolved.policy;
+        }
+        const expanded = expandPolicyWithPluginGroups(policy, pluginGroups);
+        filtered = expanded ? filterToolsByPolicy(filtered, expanded) : filtered;
+    }
+    return filtered;
+}

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "2026.2.7",
-  "commit": "60f0895a4604c140b6e6d000fc7141252efe40e9",
-  "builtAt": "2026-02-15T06:21:58.829Z"
+  "version": "2026.2.8",
+  "commit": "4f7a76b8949932fd105f49e6b89efd93bc69d3cc",
+  "builtAt": "2026-02-15T16:46:23.867Z"
 }

package/dist/cli/gateway-cli/run-loop.js

@@ -1,6 +1,8 @@
 import { acquireGatewayLock } from "../../infra/gateway-lock.js";
 import { consumeGatewaySigusr1RestartAuthorization, isGatewaySigusr1RestartExternallyAllowed, } from "../../infra/restart.js";
 import { createSubsystemLogger } from "../../logging/subsystem.js";
+import { getActiveTaskCount, resetAllLanes, waitForActiveTasks, } from "../../process/command-queue.js";
+import { createRestartIterationHook } from "../../process/restart-recovery.js";
 const gatewayLog = createSubsystemLogger("gateway");
 export async function runGatewayLoop(params) {
     const lock = await acquireGatewayLock();
@@ -12,6 +14,8 @@ export async function runGatewayLoop(params) {
         process.removeListener("SIGINT", onSigint);
         process.removeListener("SIGUSR1", onSigusr1);
     };
+    const DRAIN_TIMEOUT_MS = 30_000;
+    const SHUTDOWN_TIMEOUT_MS = 5_000;
     const request = (action, signal) => {
         if (shuttingDown) {
             gatewayLog.info(`received ${signal} during shutdown; ignoring`);
@@ -20,13 +24,30 @@ export async function runGatewayLoop(params) {
         shuttingDown = true;
         const isRestart = action === "restart";
         gatewayLog.info(`received ${signal}; ${isRestart ? "restarting" : "shutting down"}`);
+        // Allow extra time for draining active turns on restart.
+        const forceExitMs = isRestart ? DRAIN_TIMEOUT_MS + SHUTDOWN_TIMEOUT_MS : SHUTDOWN_TIMEOUT_MS;
         const forceExitTimer = setTimeout(() => {
             gatewayLog.error("shutdown timed out; exiting without full cleanup");
             cleanupSignals();
             params.runtime.exit(0);
-        }, 5000);
+        }, forceExitMs);
         void (async () => {
             try {
+                // On restart, wait for in-flight agent turns to finish before
+                // tearing down the server so buffered messages are delivered.
+                if (isRestart) {
+                    const activeTasks = getActiveTaskCount();
+                    if (activeTasks > 0) {
+                        gatewayLog.info(`draining ${activeTasks} active task(s) before restart (timeout ${DRAIN_TIMEOUT_MS}ms)`);
+                        const { drained } = await waitForActiveTasks(DRAIN_TIMEOUT_MS);
+                        if (drained) {
+                            gatewayLog.info("all active tasks drained");
+                        }
+                        else {
+                            gatewayLog.warn("drain timeout reached; proceeding with restart");
+                        }
+                    }
+                }
                 await server?.close({
                     reason: isRestart ? "gateway restarting" : "gateway stopping",
                     restartExpectedMs: isRestart ? 1500 : null,
@@ -39,6 +60,7 @@ export async function runGatewayLoop(params) {
                 clearTimeout(forceExitTimer);
                 server = null;
                 if (isRestart) {
+                    // In-process restart (no process-respawn in pool-bot).
                     shuttingDown = false;
                     restartResolver?.();
                 }
@@ -70,10 +92,20 @@ export async function runGatewayLoop(params) {
     process.on("SIGINT", onSigint);
     process.on("SIGUSR1", onSigusr1);
     try {
+        const onIteration = createRestartIterationHook(() => {
+            // After an in-process restart (SIGUSR1), reset command-queue lane state.
+            // Interrupted tasks from the previous lifecycle may have left `active`
+            // counts elevated (their finally blocks never ran), permanently blocking
+            // new work from draining. This must happen here — at the restart
+            // coordinator level — rather than inside individual subsystem init
+            // functions, to avoid surprising cross-cutting side effects.
+            resetAllLanes();
+        });
         // Keep process alive; SIGUSR1 triggers an in-process restart (no supervisor required).
         // SIGTERM/SIGINT still exit after a graceful shutdown.
         // eslint-disable-next-line no-constant-condition
         while (true) {
+            onIteration();
             server = await params.start();
             await new Promise((resolve) => {
                 restartResolver = resolve;

package/dist/gateway/auth.js

@@ -1,11 +1,6 @@
-import { timingSafeEqual } from "node:crypto";
+import { safeEqualSecret } from "../security/secret-equal.js";
 import { readTailscaleWhoisIdentity } from "../infra/tailscale.js";
 import { isTrustedProxyAddress, parseForwardedForClientIp, resolveGatewayClientIp } from "./net.js";
-function safeEqual(a, b) {
-    if (a.length !== b.length)
-        return false;
-    return timingSafeEqual(Buffer.from(a), Buffer.from(b));
-}
 function normalizeLogin(login) {
     return login.trim().toLowerCase();
 }
@@ -175,7 +170,7 @@ export async function authorizeGatewayConnect(params) {
         if (!connectAuth?.token) {
             return { ok: false, reason: "token_missing" };
         }
-        if (!safeEqual(connectAuth.token, auth.token)) {
+        if (!safeEqualSecret(connectAuth.token, auth.token)) {
             return { ok: false, reason: "token_mismatch" };
         }
         return { ok: true, method: "token" };
@@ -188,7 +183,7 @@ export async function authorizeGatewayConnect(params) {
         if (!password) {
             return { ok: false, reason: "password_missing" };
         }
-        if (!safeEqual(password, auth.password)) {
+        if (!safeEqualSecret(password, auth.password)) {
             return { ok: false, reason: "password_mismatch" };
         }
         return { ok: true, method: "password" };

package/dist/media-understanding/runner.js

@@ -477,10 +477,18 @@ async function resolveActiveModelEntry(params) {
     catch {
         return null;
     }
+    // Use the default vision/video model for the provider rather than the
+    // user's chat model — the chat model (e.g. glm-4.7) may not support
+    // vision, while the provider has a dedicated model (e.g. glm-4.6v).
+    const model = params.capability === "image"
+        ? (DEFAULT_IMAGE_MODELS[providerId] ?? params.activeModel?.model)
+        : params.capability === "audio"
+            ? (DEFAULT_AUDIO_MODELS[providerId] ?? params.activeModel?.model)
+            : params.activeModel?.model;
     return {
         type: "provider",
         provider: providerId,
-        model: params.activeModel?.model,
+        model,
     };
 }
 function trimOutput(text, maxChars) {