@poolzin/pool-bot 2026.3.25 → 2026.3.26

package/dist/commands-subagents/action-agents.js

@@ -0,0 +1,44 @@
+import { getThreadBindingManager } from "../../../discord/monitor/thread-bindings.js";
+import { formatRunLabel, sortSubagentRuns } from "../subagents-utils.js";
+import { isDiscordSurface, resolveDiscordAccountId, stopWithText, } from "./shared.js";
+export function handleSubagentsAgentsAction(ctx) {
+    const { params, requesterKey, runs } = ctx;
+    const isDiscord = isDiscordSurface(params);
+    const accountId = isDiscord ? resolveDiscordAccountId(params) : undefined;
+    const threadBindings = accountId ? getThreadBindingManager(accountId) : null;
+    const visibleRuns = sortSubagentRuns(runs).filter((entry) => {
+        if (!entry.endedAt) {
+            return true;
+        }
+        return Boolean(threadBindings?.listBySessionKey(entry.childSessionKey)[0]);
+    });
+    const lines = ["agents:", "-----"];
+    if (visibleRuns.length === 0) {
+        lines.push("(none)");
+    }
+    else {
+        let index = 1;
+        for (const entry of visibleRuns) {
+            const threadBinding = threadBindings?.listBySessionKey(entry.childSessionKey)[0];
+            const bindingText = threadBinding
+                ? `thread:${threadBinding.threadId}`
+                : isDiscord
+                    ? "unbound"
+                    : "bindings available on discord";
+            lines.push(`${index}. ${formatRunLabel(entry)} (${bindingText})`);
+            index += 1;
+        }
+    }
+    if (threadBindings) {
+        const acpBindings = threadBindings
+            .listBindings()
+            .filter((entry) => entry.targetKind === "acp" && entry.targetSessionKey === requesterKey);
+        if (acpBindings.length > 0) {
+            lines.push("", "acp/session bindings:", "-----");
+            for (const binding of acpBindings) {
+                lines.push(`- ${binding.label ?? binding.targetSessionKey} (thread:${binding.threadId}, session:${binding.targetSessionKey})`);
+            }
+        }
+    }
+    return stopWithText(lines.join("\n"));
+}

package/dist/commands-subagents/action-focus.js

@@ -0,0 +1,64 @@
+import { getThreadBindingManager, resolveThreadBindingIntroText, resolveThreadBindingThreadName, } from "../../../discord/monitor/thread-bindings.js";
+import { isDiscordSurface, resolveDiscordAccountId, resolveDiscordChannelIdForFocus, resolveFocusTargetSession, stopWithText, } from "./shared.js";
+export async function handleSubagentsFocusAction(ctx) {
+    const { params, runs, restTokens } = ctx;
+    if (!isDiscordSurface(params)) {
+        return stopWithText("⚠️ /focus is only available on Discord.");
+    }
+    const token = restTokens.join(" ").trim();
+    if (!token) {
+        return stopWithText("Usage: /focus <subagent-label|session-key|session-id|session-label>");
+    }
+    const accountId = resolveDiscordAccountId(params);
+    const threadBindings = getThreadBindingManager(accountId);
+    if (!threadBindings) {
+        return stopWithText("⚠️ Discord thread bindings are unavailable for this account.");
+    }
+    const focusTarget = await resolveFocusTargetSession({ runs, token });
+    if (!focusTarget) {
+        return stopWithText(`⚠️ Unable to resolve focus target: ${token}`);
+    }
+    const currentThreadId = params.ctx.MessageThreadId != null ? String(params.ctx.MessageThreadId).trim() : "";
+    const parentChannelId = currentThreadId ? undefined : resolveDiscordChannelIdForFocus(params);
+    if (!currentThreadId && !parentChannelId) {
+        return stopWithText("⚠️ Could not resolve a Discord channel for /focus.");
+    }
+    const senderId = params.command.senderId?.trim() || "";
+    if (currentThreadId) {
+        const existingBinding = threadBindings.getByThreadId(currentThreadId);
+        if (existingBinding &&
+            existingBinding.boundBy &&
+            existingBinding.boundBy !== "system" &&
+            senderId &&
+            senderId !== existingBinding.boundBy) {
+            return stopWithText(`⚠️ Only ${existingBinding.boundBy} can refocus this thread.`);
+        }
+    }
+    const label = focusTarget.label || token;
+    const binding = await threadBindings.bindTarget({
+        threadId: currentThreadId || undefined,
+        channelId: parentChannelId,
+        createThread: !currentThreadId,
+        threadName: resolveThreadBindingThreadName({
+            agentId: focusTarget.agentId,
+            label,
+        }),
+        targetKind: focusTarget.targetKind,
+        targetSessionKey: focusTarget.targetSessionKey,
+        agentId: focusTarget.agentId,
+        label,
+        boundBy: senderId || "unknown",
+        introText: resolveThreadBindingIntroText({
+            agentId: focusTarget.agentId,
+            label,
+            sessionTtlMs: threadBindings.getSessionTtlMs(),
+        }),
+    });
+    if (!binding) {
+        return stopWithText("⚠️ Failed to bind a Discord thread to the target session.");
+    }
+    const actionText = currentThreadId
+        ? `bound this thread to ${binding.targetSessionKey}`
+        : `created thread ${binding.threadId} and bound it to ${binding.targetSessionKey}`;
+    return stopWithText(`✅ ${actionText} (${binding.targetKind}).`);
+}

package/dist/commands-subagents/action-help.js

@@ -0,0 +1,4 @@
+import { buildSubagentsHelp, stopWithText } from "./shared.js";
+export function handleSubagentsHelpAction() {
+    return stopWithText(buildSubagentsHelp());
+}

package/dist/commands-subagents/action-info.js

@@ -0,0 +1,45 @@
+import { loadSessionStore, resolveStorePath } from "../../../config/sessions.js";
+import { formatDurationCompact } from "../../../shared/subagents-format.js";
+import { formatRunLabel } from "../subagents-utils.js";
+import { formatTimestampWithAge, loadSubagentSessionEntry, resolveDisplayStatus, resolveSubagentEntryForToken, stopWithText, } from "./shared.js";
+export function handleSubagentsInfoAction(ctx) {
+    const { params, runs, restTokens } = ctx;
+    const target = restTokens[0];
+    if (!target) {
+        return stopWithText("ℹ️ Usage: /subagents info <id|#>");
+    }
+    const targetResolution = resolveSubagentEntryForToken(runs, target);
+    if ("reply" in targetResolution) {
+        return targetResolution.reply;
+    }
+    const run = targetResolution.entry;
+    const { entry: sessionEntry } = loadSubagentSessionEntry(params, run.childSessionKey, {
+        loadSessionStore,
+        resolveStorePath,
+    });
+    const runtime = run.startedAt && Number.isFinite(run.startedAt)
+        ? (formatDurationCompact((run.endedAt ?? Date.now()) - run.startedAt) ?? "n/a")
+        : "n/a";
+    const outcome = run.outcome
+        ? `${run.outcome.status}${run.outcome.error ? ` (${run.outcome.error})` : ""}`
+        : "n/a";
+    const lines = [
+        "ℹ️ Subagent info",
+        `Status: ${resolveDisplayStatus(run)}`,
+        `Label: ${formatRunLabel(run)}`,
+        `Task: ${run.task}`,
+        `Run: ${run.runId}`,
+        `Session: ${run.childSessionKey}`,
+        `SessionId: ${sessionEntry?.sessionId ?? "n/a"}`,
+        `Transcript: ${sessionEntry?.sessionFile ?? "n/a"}`,
+        `Runtime: ${runtime}`,
+        `Created: ${formatTimestampWithAge(run.createdAt)}`,
+        `Started: ${formatTimestampWithAge(run.startedAt)}`,
+        `Ended: ${formatTimestampWithAge(run.endedAt)}`,
+        `Cleanup: ${run.cleanup}`,
+        run.archiveAtMs ? `Archive: ${formatTimestampWithAge(run.archiveAtMs)}` : undefined,
+        run.cleanupHandled ? "Cleanup handled: yes" : undefined,
+        `Outcome: ${outcome}`,
+    ].filter(Boolean);
+    return stopWithText(lines.join("\n"));
+}

package/dist/commands-subagents/action-kill.js

@@ -0,0 +1,60 @@
+import { abortEmbeddedPiRun } from "../../../agents/pi-embedded.js";
+import { markSubagentRunTerminated } from "../../../agents/subagent-registry.js";
+import { loadSessionStore, resolveStorePath, updateSessionStore, } from "../../../config/sessions.js";
+import { logVerbose } from "../../../globals.js";
+import { stopSubagentsForRequester } from "../abort.js";
+import { clearSessionQueues } from "../queue.js";
+import { formatRunLabel } from "../subagents-utils.js";
+import { COMMAND, loadSubagentSessionEntry, resolveSubagentEntryForToken, stopWithText, } from "./shared.js";
+export async function handleSubagentsKillAction(ctx) {
+    const { params, handledPrefix, requesterKey, runs, restTokens } = ctx;
+    const target = restTokens[0];
+    if (!target) {
+        return stopWithText(handledPrefix === COMMAND ? "Usage: /subagents kill <id|#|all>" : "Usage: /kill <id|#|all>");
+    }
+    if (target === "all" || target === "*") {
+        stopSubagentsForRequester({
+            cfg: params.cfg,
+            requesterSessionKey: requesterKey,
+        });
+        return { shouldContinue: false };
+    }
+    const targetResolution = resolveSubagentEntryForToken(runs, target);
+    if ("reply" in targetResolution) {
+        return targetResolution.reply;
+    }
+    if (targetResolution.entry.endedAt) {
+        return stopWithText(`${formatRunLabel(targetResolution.entry)} is already finished.`);
+    }
+    const childKey = targetResolution.entry.childSessionKey;
+    const { storePath, store, entry } = loadSubagentSessionEntry(params, childKey, {
+        loadSessionStore,
+        resolveStorePath,
+    });
+    const sessionId = entry?.sessionId;
+    if (sessionId) {
+        abortEmbeddedPiRun(sessionId);
+    }
+    const cleared = clearSessionQueues([childKey, sessionId]);
+    if (cleared.followupCleared > 0 || cleared.laneCleared > 0) {
+        logVerbose(`subagents kill: cleared followups=${cleared.followupCleared} lane=${cleared.laneCleared} keys=${cleared.keys.join(",")}`);
+    }
+    if (entry) {
+        entry.abortedLastRun = true;
+        entry.updatedAt = Date.now();
+        store[childKey] = entry;
+        await updateSessionStore(storePath, (nextStore) => {
+            nextStore[childKey] = entry;
+        });
+    }
+    markSubagentRunTerminated({
+        runId: targetResolution.entry.runId,
+        childSessionKey: childKey,
+        reason: "killed",
+    });
+    stopSubagentsForRequester({
+        cfg: params.cfg,
+        requesterSessionKey: childKey,
+    });
+    return { shouldContinue: false };
+}

package/dist/commands-subagents/action-list.js

@@ -0,0 +1,44 @@
+import { loadSessionStore, resolveStorePath } from "../../../config/sessions.js";
+import { sortSubagentRuns } from "../subagents-utils.js";
+import { RECENT_WINDOW_MINUTES, formatSubagentListLine, loadSubagentSessionEntry, stopWithText, } from "./shared.js";
+export function handleSubagentsListAction(ctx) {
+    const { params, runs } = ctx;
+    const sorted = sortSubagentRuns(runs);
+    const now = Date.now();
+    const recentCutoff = now - RECENT_WINDOW_MINUTES * 60_000;
+    const storeCache = new Map();
+    let index = 1;
+    const mapRuns = (entries, runtimeMs) => entries.map((entry) => {
+        const { entry: sessionEntry } = loadSubagentSessionEntry(params, entry.childSessionKey, {
+            loadSessionStore,
+            resolveStorePath,
+        }, storeCache);
+        const line = formatSubagentListLine({
+            entry,
+            index,
+            runtimeMs: runtimeMs(entry),
+            sessionEntry,
+        });
+        index += 1;
+        return line;
+    });
+    const activeEntries = sorted.filter((entry) => !entry.endedAt);
+    const activeLines = mapRuns(activeEntries, (entry) => now - (entry.startedAt ?? entry.createdAt));
+    const recentEntries = sorted.filter((entry) => !!entry.endedAt && (entry.endedAt ?? 0) >= recentCutoff);
+    const recentLines = mapRuns(recentEntries, (entry) => (entry.endedAt ?? now) - (entry.startedAt ?? entry.createdAt));
+    const lines = ["active subagents:", "-----"];
+    if (activeLines.length === 0) {
+        lines.push("(none)");
+    }
+    else {
+        lines.push(activeLines.join("\n"));
+    }
+    lines.push("", `recent subagents (last ${RECENT_WINDOW_MINUTES}m):`, "-----");
+    if (recentLines.length === 0) {
+        lines.push("(none)");
+    }
+    else {
+        lines.push(recentLines.join("\n"));
+    }
+    return stopWithText(lines.join("\n"));
+}

package/dist/commands-subagents/action-log.js

@@ -0,0 +1,29 @@
+import { callGateway } from "../../../gateway/call.js";
+import { formatRunLabel } from "../subagents-utils.js";
+import { formatLogLines, resolveSubagentEntryForToken, stopWithText, stripToolMessages, } from "./shared.js";
+export async function handleSubagentsLogAction(ctx) {
+    const { runs, restTokens } = ctx;
+    const target = restTokens[0];
+    if (!target) {
+        return stopWithText("📜 Usage: /subagents log <id|#> [limit]");
+    }
+    const includeTools = restTokens.some((token) => token.toLowerCase() === "tools");
+    const limitToken = restTokens.find((token) => /^\d+$/.test(token));
+    const limit = limitToken ? Math.min(200, Math.max(1, Number.parseInt(limitToken, 10))) : 20;
+    const targetResolution = resolveSubagentEntryForToken(runs, target);
+    if ("reply" in targetResolution) {
+        return targetResolution.reply;
+    }
+    const history = await callGateway({
+        method: "chat.history",
+        params: { sessionKey: targetResolution.entry.childSessionKey, limit },
+    });
+    const rawMessages = Array.isArray(history?.messages) ? history.messages : [];
+    const filtered = includeTools ? rawMessages : stripToolMessages(rawMessages);
+    const lines = formatLogLines(filtered);
+    const header = `📜 Subagent log: ${formatRunLabel(targetResolution.entry)}`;
+    if (lines.length === 0) {
+        return stopWithText(`${header}\n(no messages)`);
+    }
+    return stopWithText([header, ...lines].join("\n"));
+}

package/dist/commands-subagents/action-send.js

@@ -0,0 +1,119 @@
+import crypto from "node:crypto";
+import { AGENT_LANE_SUBAGENT } from "../../../agents/lanes.js";
+import { abortEmbeddedPiRun } from "../../../agents/pi-embedded.js";
+import { clearSubagentRunSteerRestart, replaceSubagentRunAfterSteer, markSubagentRunForSteerRestart, } from "../../../agents/subagent-registry.js";
+import { loadSessionStore, resolveStorePath } from "../../../config/sessions.js";
+import { callGateway } from "../../../gateway/call.js";
+import { logVerbose } from "../../../globals.js";
+import { INTERNAL_MESSAGE_CHANNEL } from "../../../utils/message-channel.js";
+import { clearSessionQueues } from "../queue.js";
+import { formatRunLabel } from "../subagents-utils.js";
+import { COMMAND, STEER_ABORT_SETTLE_TIMEOUT_MS, extractAssistantText, loadSubagentSessionEntry, resolveSubagentEntryForToken, stopWithText, stripToolMessages, } from "./shared.js";
+export async function handleSubagentsSendAction(ctx, steerRequested) {
+    const { params, handledPrefix, runs, restTokens } = ctx;
+    const target = restTokens[0];
+    const message = restTokens.slice(1).join(" ").trim();
+    if (!target || !message) {
+        return stopWithText(steerRequested
+            ? handledPrefix === COMMAND
+                ? "Usage: /subagents steer <id|#> <message>"
+                : `Usage: ${handledPrefix} <id|#> <message>`
+            : "Usage: /subagents send <id|#> <message>");
+    }
+    const targetResolution = resolveSubagentEntryForToken(runs, target);
+    if ("reply" in targetResolution) {
+        return targetResolution.reply;
+    }
+    if (steerRequested && targetResolution.entry.endedAt) {
+        return stopWithText(`${formatRunLabel(targetResolution.entry)} is already finished.`);
+    }
+    const { entry: targetSessionEntry } = loadSubagentSessionEntry(params, targetResolution.entry.childSessionKey, {
+        loadSessionStore,
+        resolveStorePath,
+    });
+    const targetSessionId = typeof targetSessionEntry?.sessionId === "string" && targetSessionEntry.sessionId.trim()
+        ? targetSessionEntry.sessionId.trim()
+        : undefined;
+    if (steerRequested) {
+        markSubagentRunForSteerRestart(targetResolution.entry.runId);
+        if (targetSessionId) {
+            abortEmbeddedPiRun(targetSessionId);
+        }
+        const cleared = clearSessionQueues([targetResolution.entry.childSessionKey, targetSessionId]);
+        if (cleared.followupCleared > 0 || cleared.laneCleared > 0) {
+            logVerbose(`subagents steer: cleared followups=${cleared.followupCleared} lane=${cleared.laneCleared} keys=${cleared.keys.join(",")}`);
+        }
+        try {
+            await callGateway({
+                method: "agent.wait",
+                params: {
+                    runId: targetResolution.entry.runId,
+                    timeoutMs: STEER_ABORT_SETTLE_TIMEOUT_MS,
+                },
+                timeoutMs: STEER_ABORT_SETTLE_TIMEOUT_MS + 2_000,
+            });
+        }
+        catch {
+            // Continue even if wait fails; steer should still be attempted.
+        }
+    }
+    const idempotencyKey = crypto.randomUUID();
+    let runId = idempotencyKey;
+    try {
+        const response = await callGateway({
+            method: "agent",
+            params: {
+                message,
+                sessionKey: targetResolution.entry.childSessionKey,
+                sessionId: targetSessionId,
+                idempotencyKey,
+                deliver: false,
+                channel: INTERNAL_MESSAGE_CHANNEL,
+                lane: AGENT_LANE_SUBAGENT,
+                timeout: 0,
+            },
+            timeoutMs: 10_000,
+        });
+        const responseRunId = typeof response?.runId === "string" ? response.runId : undefined;
+        if (responseRunId) {
+            runId = responseRunId;
+        }
+    }
+    catch (err) {
+        if (steerRequested) {
+            clearSubagentRunSteerRestart(targetResolution.entry.runId);
+        }
+        const messageText = err instanceof Error ? err.message : typeof err === "string" ? err : "error";
+        return stopWithText(`send failed: ${messageText}`);
+    }
+    if (steerRequested) {
+        replaceSubagentRunAfterSteer({
+            previousRunId: targetResolution.entry.runId,
+            nextRunId: runId,
+            fallback: targetResolution.entry,
+            runTimeoutSeconds: targetResolution.entry.runTimeoutSeconds ?? 0,
+        });
+        return stopWithText(`steered ${formatRunLabel(targetResolution.entry)} (run ${runId.slice(0, 8)}).`);
+    }
+    const waitMs = 30_000;
+    const wait = await callGateway({
+        method: "agent.wait",
+        params: { runId, timeoutMs: waitMs },
+        timeoutMs: waitMs + 2000,
+    });
+    if (wait?.status === "timeout") {
+        return stopWithText(`⏳ Subagent still running (run ${runId.slice(0, 8)}).`);
+    }
+    if (wait?.status === "error") {
+        const waitError = typeof wait.error === "string" ? wait.error : "unknown error";
+        return stopWithText(`⚠️ Subagent error: ${waitError} (run ${runId.slice(0, 8)}).`);
+    }
+    const history = await callGateway({
+        method: "chat.history",
+        params: { sessionKey: targetResolution.entry.childSessionKey, limit: 50 },
+    });
+    const filtered = stripToolMessages(Array.isArray(history?.messages) ? history.messages : []);
+    const last = filtered.length > 0 ? filtered[filtered.length - 1] : undefined;
+    const replyText = last ? extractAssistantText(last) : undefined;
+    return stopWithText(replyText ?? `✅ Sent to ${formatRunLabel(targetResolution.entry)} (run ${runId.slice(0, 8)}).`);
+}

package/dist/commands-subagents/action-spawn.js

@@ -0,0 +1,52 @@
+import { spawnSubagentDirect } from "../../../agents/subagent-spawn.js";
+import { stopWithText } from "./shared.js";
+export async function handleSubagentsSpawnAction(ctx) {
+    const { params, requesterKey, restTokens } = ctx;
+    const agentId = restTokens[0];
+    const taskParts = [];
+    let model;
+    let thinking;
+    for (let i = 1; i < restTokens.length; i++) {
+        if (restTokens[i] === "--model" && i + 1 < restTokens.length) {
+            i += 1;
+            model = restTokens[i];
+        }
+        else if (restTokens[i] === "--thinking" && i + 1 < restTokens.length) {
+            i += 1;
+            thinking = restTokens[i];
+        }
+        else {
+            taskParts.push(restTokens[i]);
+        }
+    }
+    const task = taskParts.join(" ").trim();
+    if (!agentId || !task) {
+        return stopWithText("Usage: /subagents spawn <agentId> <task> [--model <model>] [--thinking <level>]");
+    }
+    const commandTo = typeof params.command.to === "string" ? params.command.to.trim() : "";
+    const originatingTo = typeof params.ctx.OriginatingTo === "string" ? params.ctx.OriginatingTo.trim() : "";
+    const fallbackTo = typeof params.ctx.To === "string" ? params.ctx.To.trim() : "";
+    const normalizedTo = originatingTo || commandTo || fallbackTo || undefined;
+    const result = await spawnSubagentDirect({
+        task,
+        agentId,
+        model,
+        thinking,
+        mode: "run",
+        cleanup: "keep",
+        expectsCompletionMessage: true,
+    }, {
+        agentSessionKey: requesterKey,
+        agentChannel: params.ctx.OriginatingChannel ?? params.command.channel,
+        agentAccountId: params.ctx.AccountId,
+        agentTo: normalizedTo,
+        agentThreadId: params.ctx.MessageThreadId,
+        agentGroupId: params.sessionEntry?.groupId ?? null,
+        agentGroupChannel: params.sessionEntry?.groupChannel ?? null,
+        agentGroupSpace: params.sessionEntry?.space ?? null,
+    });
+    if (result.status === "accepted") {
+        return stopWithText(`Spawned subagent ${agentId} (session ${result.childSessionKey}, run ${result.runId?.slice(0, 8)}).`);
+    }
+    return stopWithText(`Spawn failed: ${result.error ?? result.status}`);
+}

package/dist/commands-subagents/action-unfocus.js

@@ -0,0 +1,30 @@
+import { getThreadBindingManager } from "../../../discord/monitor/thread-bindings.js";
+import { isDiscordSurface, resolveDiscordAccountId, stopWithText, } from "./shared.js";
+export function handleSubagentsUnfocusAction(ctx) {
+    const { params } = ctx;
+    if (!isDiscordSurface(params)) {
+        return stopWithText("⚠️ /unfocus is only available on Discord.");
+    }
+    const threadId = params.ctx.MessageThreadId != null ? String(params.ctx.MessageThreadId) : "";
+    if (!threadId.trim()) {
+        return stopWithText("⚠️ /unfocus must be run inside a Discord thread.");
+    }
+    const threadBindings = getThreadBindingManager(resolveDiscordAccountId(params));
+    if (!threadBindings) {
+        return stopWithText("⚠️ Discord thread bindings are unavailable for this account.");
+    }
+    const binding = threadBindings.getByThreadId(threadId);
+    if (!binding) {
+        return stopWithText("ℹ️ This thread is not currently focused.");
+    }
+    const senderId = params.command.senderId?.trim() || "";
+    if (binding.boundBy && binding.boundBy !== "system" && senderId && senderId !== binding.boundBy) {
+        return stopWithText(`⚠️ Only ${binding.boundBy} can unfocus this thread.`);
+    }
+    threadBindings.unbindThread({
+        threadId,
+        reason: "manual",
+        sendFarewell: true,
+    });
+    return stopWithText("✅ Thread unfocused.");
+}