@poolzin/pool-bot 2026.2.17 → 2026.2.18

package/dist/agents/subagent-announce-queue.js

@@ -2,6 +2,31 @@ import { defaultRuntime } from "../runtime.js";
 import { deliveryContextKey, normalizeDeliveryContext, } from "../utils/delivery-context.js";
 import { applyQueueDropPolicy, buildCollectPrompt, buildQueueSummaryPrompt, hasCrossChannelItems, waitForQueueDebounce, } from "../utils/queue-helpers.js";
 const ANNOUNCE_QUEUES = new Map();
+function previewQueueSummaryPrompt(queue) {
+    return buildQueueSummaryPrompt({
+        state: {
+            dropPolicy: queue.dropPolicy,
+            droppedCount: queue.droppedCount,
+            summaryLines: [...queue.summaryLines],
+        },
+        noun: "announce",
+    });
+}
+function clearQueueSummaryState(queue) {
+    queue.droppedCount = 0;
+    queue.summaryLines = [];
+}
+export function resetAnnounceQueuesForTests() {
+    // Test isolation: other suites may leave a draining queue behind in the worker.
+    // Clearing the map alone isn't enough because drain loops capture `queue` by reference.
+    for (const queue of ANNOUNCE_QUEUES.values()) {
+        queue.items.length = 0;
+        queue.summaryLines.length = 0;
+        queue.droppedCount = 0;
+        queue.lastEnqueuedAt = 0;
+    }
+    ANNOUNCE_QUEUES.clear();
+}
 function getAnnounceQueue(key, settings, send) {
     const existing = ANNOUNCE_QUEUES.get(key);
     if (existing) {
@@ -35,8 +60,9 @@ function getAnnounceQueue(key, settings, send) {
 }
 function scheduleAnnounceDrain(key) {
     const queue = ANNOUNCE_QUEUES.get(key);
-    if (!queue || queue.draining)
+    if (!queue || queue.draining) {
         return;
+    }
     queue.draining = true;
     void (async () => {
         try {
@@ -45,29 +71,35 @@ function scheduleAnnounceDrain(key) {
                 await waitForQueueDebounce(queue);
                 if (queue.mode === "collect") {
                     if (forceIndividualCollect) {
-                        const next = queue.items.shift();
-                        if (!next)
+                        const next = queue.items[0];
+                        if (!next) {
                             break;
+                        }
                         await queue.send(next);
+                        queue.items.shift();
                         continue;
                     }
                     const isCrossChannel = hasCrossChannelItems(queue.items, (item) => {
-                        if (!item.origin)
+                        if (!item.origin) {
                             return {};
-                        if (!item.originKey)
+                        }
+                        if (!item.originKey) {
                             return { cross: true };
+                        }
                         return { key: item.originKey };
                     });
                     if (isCrossChannel) {
                         forceIndividualCollect = true;
-                        const next = queue.items.shift();
-                        if (!next)
+                        const next = queue.items[0];
+                        if (!next) {
                             break;
+                        }
                         await queue.send(next);
+                        queue.items.shift();
                         continue;
                     }
-                    const items = queue.items.splice(0, queue.items.length);
-                    const summary = buildQueueSummaryPrompt({ state: queue, noun: "announce" });
+                    const items = queue.items.slice();
+                    const summary = previewQueueSummaryPrompt(queue);
                     const prompt = buildCollectPrompt({
                         title: "[Queued announce messages while agent was busy]",
                         items,
@@ -75,26 +107,38 @@ function scheduleAnnounceDrain(key) {
                         renderItem: (item, idx) => `---\nQueued #${idx + 1}\n${item.prompt}`.trim(),
                     });
                     const last = items.at(-1);
-                    if (!last)
+                    if (!last) {
                         break;
+                    }
                     await queue.send({ ...last, prompt });
+                    queue.items.splice(0, items.length);
+                    if (summary) {
+                        clearQueueSummaryState(queue);
+                    }
                     continue;
                 }
-                const summaryPrompt = buildQueueSummaryPrompt({ state: queue, noun: "announce" });
+                const summaryPrompt = previewQueueSummaryPrompt(queue);
                 if (summaryPrompt) {
-                    const next = queue.items.shift();
-                    if (!next)
+                    const next = queue.items[0];
+                    if (!next) {
                         break;
+                    }
                     await queue.send({ ...next, prompt: summaryPrompt });
+                    queue.items.shift();
+                    clearQueueSummaryState(queue);
                     continue;
                 }
-                const next = queue.items.shift();
-                if (!next)
+                const next = queue.items[0];
+                if (!next) {
                     break;
+                }
                 await queue.send(next);
+                queue.items.shift();
             }
         }
         catch (err) {
+            // Keep items in queue and retry after debounce; avoid hot-loop retries.
+            queue.lastEnqueuedAt = Date.now();
             defaultRuntime.error?.(`announce queue drain failed for ${key}: ${String(err)}`);
         }
         finally {

package/dist/agents/subagent-depth.js

@@ -0,0 +1,137 @@
+import fs from "node:fs";
+import JSON5 from "json5";
+import { resolveStorePath } from "../config/sessions/paths.js";
+import { getSubagentDepth, parseAgentSessionKey } from "../sessions/session-key-utils.js";
+import { resolveDefaultAgentId } from "./agent-scope.js";
+function normalizeSpawnDepth(value) {
+    if (typeof value === "number") {
+        return Number.isInteger(value) && value >= 0 ? value : undefined;
+    }
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (!trimmed) {
+            return undefined;
+        }
+        const numeric = Number(trimmed);
+        return Number.isInteger(numeric) && numeric >= 0 ? numeric : undefined;
+    }
+    return undefined;
+}
+function normalizeSessionKey(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed || undefined;
+}
+function readSessionStore(storePath) {
+    try {
+        const raw = fs.readFileSync(storePath, "utf-8");
+        const parsed = JSON5.parse(raw);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // ignore missing/invalid stores
+    }
+    return {};
+}
+function buildKeyCandidates(rawKey, cfg) {
+    if (!cfg) {
+        return [rawKey];
+    }
+    if (rawKey === "global" || rawKey === "unknown") {
+        return [rawKey];
+    }
+    if (parseAgentSessionKey(rawKey)) {
+        return [rawKey];
+    }
+    const defaultAgentId = resolveDefaultAgentId(cfg);
+    const prefixed = `agent:${defaultAgentId}:${rawKey}`;
+    return prefixed === rawKey ? [rawKey] : [rawKey, prefixed];
+}
+function findEntryBySessionId(store, sessionId) {
+    const normalizedSessionId = normalizeSessionKey(sessionId);
+    if (!normalizedSessionId) {
+        return undefined;
+    }
+    for (const entry of Object.values(store)) {
+        const candidateSessionId = normalizeSessionKey(entry?.sessionId);
+        if (candidateSessionId && candidateSessionId === normalizedSessionId) {
+            return entry;
+        }
+    }
+    return undefined;
+}
+function resolveEntryForSessionKey(params) {
+    const candidates = buildKeyCandidates(params.sessionKey, params.cfg);
+    if (params.store) {
+        for (const key of candidates) {
+            const entry = params.store[key];
+            if (entry) {
+                return entry;
+            }
+        }
+        return findEntryBySessionId(params.store, params.sessionKey);
+    }
+    if (!params.cfg) {
+        return undefined;
+    }
+    for (const key of candidates) {
+        const parsed = parseAgentSessionKey(key);
+        if (!parsed?.agentId) {
+            continue;
+        }
+        const storePath = resolveStorePath(params.cfg.session?.store, { agentId: parsed.agentId });
+        let store = params.cache.get(storePath);
+        if (!store) {
+            store = readSessionStore(storePath);
+            params.cache.set(storePath, store);
+        }
+        const entry = store[key] ?? findEntryBySessionId(store, params.sessionKey);
+        if (entry) {
+            return entry;
+        }
+    }
+    return undefined;
+}
+export function getSubagentDepthFromSessionStore(sessionKey, opts) {
+    const raw = (sessionKey ?? "").trim();
+    const fallbackDepth = getSubagentDepth(raw);
+    if (!raw) {
+        return fallbackDepth;
+    }
+    const cache = new Map();
+    const visited = new Set();
+    const depthFromStore = (key) => {
+        const normalizedKey = normalizeSessionKey(key);
+        if (!normalizedKey) {
+            return undefined;
+        }
+        if (visited.has(normalizedKey)) {
+            return undefined;
+        }
+        visited.add(normalizedKey);
+        const entry = resolveEntryForSessionKey({
+            sessionKey: normalizedKey,
+            cfg: opts?.cfg,
+            store: opts?.store,
+            cache,
+        });
+        const storedDepth = normalizeSpawnDepth(entry?.spawnDepth);
+        if (storedDepth !== undefined) {
+            return storedDepth;
+        }
+        const spawnedBy = normalizeSessionKey(entry?.spawnedBy);
+        if (!spawnedBy) {
+            return undefined;
+        }
+        const parentDepth = depthFromStore(spawnedBy);
+        if (parentDepth !== undefined) {
+            return parentDepth + 1;
+        }
+        return getSubagentDepth(spawnedBy) + 1;
+    };
+    return depthFromStore(raw) ?? fallbackDepth;
+}