@poolzin/pool-bot 2026.2.24 → 2026.2.26

package/dist/auto-reply/reply/commands-session.js

@@ -1,28 +1,24 @@
 import { abortEmbeddedPiRun } from "../../agents/pi-embedded.js";
+import { parseDurationMs } from "../../cli/parse-duration.js";
+import { isRestartEnabled } from "../../config/commands.js";
 import { updateSessionStore } from "../../config/sessions.js";
+import { formatThreadBindingTtlLabel, getThreadBindingManager, setThreadBindingTtlBySessionKey, } from "../../discord/monitor/thread-bindings.js";
 import { logVerbose } from "../../globals.js";
 import { createInternalHookEvent, triggerInternalHook } from "../../hooks/internal-hooks.js";
 import { scheduleGatewaySigusr1Restart, triggerPoolbotRestart } from "../../infra/restart.js";
+import { loadCostUsageSummary, loadSessionCostSummary } from "../../infra/session-cost-usage.js";
+import { formatTokenCount, formatUsd } from "../../utils/usage-format.js";
 import { parseActivationCommand } from "../group-activation.js";
 import { parseSendPolicyCommand } from "../send-policy.js";
 import { normalizeUsageDisplay, resolveResponseUsageMode } from "../thinking.js";
-import { loadCostUsageSummary, loadSessionCostSummary } from "../../infra/session-cost-usage.js";
-import { formatTokenCount, formatUsd } from "../../utils/usage-format.js";
-import { formatAbortReplyText, isAbortTrigger, setAbortMemory, stopSubagentsForRequester, } from "./abort.js";
+import { formatAbortReplyText, isAbortTrigger, resolveSessionEntryForKey, setAbortMemory, stopSubagentsForRequester, } from "./abort.js";
 import { clearSessionQueues } from "./queue.js";
-function resolveSessionEntryForKey(store, sessionKey) {
-    if (!store || !sessionKey)
-        return {};
-    const direct = store[sessionKey];
-    if (direct)
-        return { entry: direct, key: sessionKey };
-    return {};
-}
 function resolveAbortTarget(params) {
     const targetSessionKey = params.ctx.CommandTargetSessionKey?.trim() || params.sessionKey;
     const { entry, key } = resolveSessionEntryForKey(params.sessionStore, targetSessionKey);
-    if (entry && key)
+    if (entry && key) {
         return { entry, key, sessionId: entry.sessionId };
+    }
     if (params.sessionEntry && params.sessionKey) {
         return {
             entry: params.sessionEntry,
@@ -32,12 +28,84 @@ function resolveAbortTarget(params) {
     }
     return { entry: undefined, key: targetSessionKey, sessionId: undefined };
 }
+const SESSION_COMMAND_PREFIX = "/session";
+const SESSION_TTL_OFF_VALUES = new Set(["off", "disable", "disabled", "none", "0"]);
+function isDiscordSurface(params) {
+    const channel = params.ctx.OriginatingChannel ??
+        params.command.channel ??
+        params.ctx.Surface ??
+        params.ctx.Provider;
+    return (String(channel ?? "")
+        .trim()
+        .toLowerCase() === "discord");
+}
+function resolveDiscordAccountId(params) {
+    const accountId = typeof params.ctx.AccountId === "string" ? params.ctx.AccountId.trim() : "";
+    return accountId || "default";
+}
+function resolveSessionCommandUsage() {
+    return "Usage: /session ttl <duration|off> (example: /session ttl 24h)";
+}
+function parseSessionTtlMs(raw) {
+    const normalized = raw.trim().toLowerCase();
+    if (!normalized) {
+        throw new Error("missing ttl");
+    }
+    if (SESSION_TTL_OFF_VALUES.has(normalized)) {
+        return 0;
+    }
+    if (/^\d+(?:\.\d+)?$/.test(normalized)) {
+        const hours = Number(normalized);
+        if (!Number.isFinite(hours) || hours < 0) {
+            throw new Error("invalid ttl");
+        }
+        return Math.round(hours * 60 * 60 * 1000);
+    }
+    return parseDurationMs(normalized, { defaultUnit: "h" });
+}
+function formatSessionExpiry(expiresAt) {
+    return new Date(expiresAt).toISOString();
+}
+async function applyAbortTarget(params) {
+    const { abortTarget } = params;
+    if (abortTarget.sessionId) {
+        abortEmbeddedPiRun(abortTarget.sessionId);
+    }
+    if (abortTarget.entry && params.sessionStore && abortTarget.key) {
+        abortTarget.entry.abortedLastRun = true;
+        abortTarget.entry.updatedAt = Date.now();
+        params.sessionStore[abortTarget.key] = abortTarget.entry;
+        if (params.storePath) {
+            await updateSessionStore(params.storePath, (store) => {
+                store[abortTarget.key] = abortTarget.entry;
+            });
+        }
+    }
+    else if (params.abortKey) {
+        setAbortMemory(params.abortKey, true);
+    }
+}
+async function persistSessionEntry(params) {
+    if (!params.sessionEntry || !params.sessionStore || !params.sessionKey) {
+        return false;
+    }
+    params.sessionEntry.updatedAt = Date.now();
+    params.sessionStore[params.sessionKey] = params.sessionEntry;
+    if (params.storePath) {
+        await updateSessionStore(params.storePath, (store) => {
+            store[params.sessionKey] = params.sessionEntry;
+        });
+    }
+    return true;
+}
 export const handleActivationCommand = async (params, allowTextCommands) => {
-    if (!allowTextCommands)
+    if (!allowTextCommands) {
         return null;
+    }
     const activationCommand = parseActivationCommand(params.command.commandBodyNormalized);
-    if (!activationCommand.hasCommand)
+    if (!activationCommand.hasCommand) {
         return null;
+    }
     if (!params.isGroup) {
         return {
             shouldContinue: false,
@@ -57,13 +125,7 @@ export const handleActivationCommand = async (params, allowTextCommands) => {
     if (params.sessionEntry && params.sessionStore && params.sessionKey) {
         params.sessionEntry.groupActivation = activationCommand.mode;
         params.sessionEntry.groupActivationNeedsSystemIntro = true;
-        params.sessionEntry.updatedAt = Date.now();
-        params.sessionStore[params.sessionKey] = params.sessionEntry;
-        if (params.storePath) {
-            await updateSessionStore(params.storePath, (store) => {
-                store[params.sessionKey] = params.sessionEntry;
-            });
-        }
+        await persistSessionEntry(params);
     }
     return {
         shouldContinue: false,
@@ -73,11 +135,13 @@ export const handleActivationCommand = async (params, allowTextCommands) => {
     };
 };
 export const handleSendPolicyCommand = async (params, allowTextCommands) => {
-    if (!allowTextCommands)
+    if (!allowTextCommands) {
         return null;
+    }
     const sendPolicyCommand = parseSendPolicyCommand(params.command.commandBodyNormalized);
-    if (!sendPolicyCommand.hasCommand)
+    if (!sendPolicyCommand.hasCommand) {
         return null;
+    }
     if (!params.command.isAuthorizedSender) {
         logVerbose(`Ignoring /send from unauthorized sender: ${params.command.senderId || "<unknown>"}`);
         return { shouldContinue: false };
@@ -95,13 +159,7 @@ export const handleSendPolicyCommand = async (params, allowTextCommands) => {
         else {
             params.sessionEntry.sendPolicy = sendPolicyCommand.mode;
         }
-        params.sessionEntry.updatedAt = Date.now();
-        params.sessionStore[params.sessionKey] = params.sessionEntry;
-        if (params.storePath) {
-            await updateSessionStore(params.storePath, (store) => {
-                store[params.sessionKey] = params.sessionEntry;
-            });
-        }
+        await persistSessionEntry(params);
     }
     const label = sendPolicyCommand.mode === "inherit"
         ? "inherit"
@@ -114,11 +172,13 @@ export const handleSendPolicyCommand = async (params, allowTextCommands) => {
     };
 };
 export const handleUsageCommand = async (params, allowTextCommands) => {
-    if (!allowTextCommands)
+    if (!allowTextCommands) {
         return null;
+    }
     const normalized = params.command.commandBodyNormalized;
-    if (normalized !== "/usage" && !normalized.startsWith("/usage "))
+    if (normalized !== "/usage" && !normalized.startsWith("/usage ")) {
         return null;
+    }
     if (!params.command.isAuthorizedSender) {
         logVerbose(`Ignoring /usage from unauthorized sender: ${params.command.senderId || "<unknown>"}`);
         return { shouldContinue: false };
@@ -131,6 +191,7 @@ export const handleUsageCommand = async (params, allowTextCommands) => {
             sessionEntry: params.sessionEntry,
             sessionFile: params.sessionEntry?.sessionFile,
             config: params.cfg,
+            agentId: params.agentId,
         });
         const summary = await loadCostUsageSummary({ days: 30, config: params.cfg });
         const sessionCost = formatUsd(sessionSummary?.totalCost);
@@ -168,17 +229,13 @@ export const handleUsageCommand = async (params, allowTextCommands) => {
     const current = resolveResponseUsageMode(currentRaw);
     const next = requested ?? (current === "off" ? "tokens" : current === "tokens" ? "full" : "off");
     if (params.sessionEntry && params.sessionStore && params.sessionKey) {
-        if (next === "off")
+        if (next === "off") {
             delete params.sessionEntry.responseUsage;
-        else
+        }
+        else {
             params.sessionEntry.responseUsage = next;
-        params.sessionEntry.updatedAt = Date.now();
-        params.sessionStore[params.sessionKey] = params.sessionEntry;
-        if (params.storePath) {
-            await updateSessionStore(params.storePath, (store) => {
-                store[params.sessionKey] = params.sessionEntry;
-            });
         }
+        await persistSessionEntry(params);
     }
     return {
         shouldContinue: false,
@@ -187,20 +244,134 @@ export const handleUsageCommand = async (params, allowTextCommands) => {
         },
     };
 };
+export const handleSessionCommand = async (params, allowTextCommands) => {
+    if (!allowTextCommands) {
+        return null;
+    }
+    const normalized = params.command.commandBodyNormalized;
+    if (!/^\/session(?:\s|$)/.test(normalized)) {
+        return null;
+    }
+    if (!params.command.isAuthorizedSender) {
+        logVerbose(`Ignoring /session from unauthorized sender: ${params.command.senderId || "<unknown>"}`);
+        return { shouldContinue: false };
+    }
+    const rest = normalized.slice(SESSION_COMMAND_PREFIX.length).trim();
+    const tokens = rest.split(/\s+/).filter(Boolean);
+    const action = tokens[0]?.toLowerCase();
+    if (action !== "ttl") {
+        return {
+            shouldContinue: false,
+            reply: { text: resolveSessionCommandUsage() },
+        };
+    }
+    if (!isDiscordSurface(params)) {
+        return {
+            shouldContinue: false,
+            reply: { text: "⚠️ /session ttl is currently available for Discord thread-bound sessions." },
+        };
+    }
+    const threadId = params.ctx.MessageThreadId != null ? String(params.ctx.MessageThreadId).trim() : "";
+    if (!threadId) {
+        return {
+            shouldContinue: false,
+            reply: { text: "⚠️ /session ttl must be run inside a focused Discord thread." },
+        };
+    }
+    const accountId = resolveDiscordAccountId(params);
+    const threadBindings = getThreadBindingManager(accountId);
+    if (!threadBindings) {
+        return {
+            shouldContinue: false,
+            reply: { text: "⚠️ Discord thread bindings are unavailable for this account." },
+        };
+    }
+    const binding = threadBindings.getByThreadId(threadId);
+    if (!binding) {
+        return {
+            shouldContinue: false,
+            reply: { text: "ℹ️ This thread is not currently focused." },
+        };
+    }
+    const ttlArgRaw = tokens.slice(1).join("");
+    if (!ttlArgRaw) {
+        const expiresAt = binding.expiresAt;
+        if (typeof expiresAt === "number" && Number.isFinite(expiresAt) && expiresAt > Date.now()) {
+            return {
+                shouldContinue: false,
+                reply: {
+                    text: `ℹ️ Session TTL active (${formatThreadBindingTtlLabel(expiresAt - Date.now())}, auto-unfocus at ${formatSessionExpiry(expiresAt)}).`,
+                },
+            };
+        }
+        return {
+            shouldContinue: false,
+            reply: { text: "ℹ️ Session TTL is currently disabled for this focused session." },
+        };
+    }
+    const senderId = params.command.senderId?.trim() || "";
+    if (binding.boundBy && binding.boundBy !== "system" && senderId && senderId !== binding.boundBy) {
+        return {
+            shouldContinue: false,
+            reply: { text: `⚠️ Only ${binding.boundBy} can update session TTL for this thread.` },
+        };
+    }
+    let ttlMs;
+    try {
+        ttlMs = parseSessionTtlMs(ttlArgRaw);
+    }
+    catch {
+        return {
+            shouldContinue: false,
+            reply: { text: resolveSessionCommandUsage() },
+        };
+    }
+    const updatedBindings = setThreadBindingTtlBySessionKey({
+        targetSessionKey: binding.targetSessionKey,
+        accountId,
+        ttlMs,
+    });
+    if (updatedBindings.length === 0) {
+        return {
+            shouldContinue: false,
+            reply: { text: "⚠️ Failed to update session TTL for the current binding." },
+        };
+    }
+    if (ttlMs <= 0) {
+        return {
+            shouldContinue: false,
+            reply: {
+                text: `✅ Session TTL disabled for ${updatedBindings.length} binding${updatedBindings.length === 1 ? "" : "s"}.`,
+            },
+        };
+    }
+    const expiresAt = updatedBindings[0]?.expiresAt;
+    const expiryLabel = typeof expiresAt === "number" && Number.isFinite(expiresAt)
+        ? formatSessionExpiry(expiresAt)
+        : "n/a";
+    return {
+        shouldContinue: false,
+        reply: {
+            text: `✅ Session TTL set to ${formatThreadBindingTtlLabel(ttlMs)} for ${updatedBindings.length} binding${updatedBindings.length === 1 ? "" : "s"} (auto-unfocus at ${expiryLabel}).`,
+        },
+    };
+};
 export const handleRestartCommand = async (params, allowTextCommands) => {
-    if (!allowTextCommands)
+    if (!allowTextCommands) {
         return null;
-    if (params.command.commandBodyNormalized !== "/restart")
+    }
+    if (params.command.commandBodyNormalized !== "/restart") {
         return null;
+    }
     if (!params.command.isAuthorizedSender) {
         logVerbose(`Ignoring /restart from unauthorized sender: ${params.command.senderId || "<unknown>"}`);
         return { shouldContinue: false };
     }
-    if (params.cfg.commands?.restart !== true) {
+    if (!isRestartEnabled(params.cfg)) {
         return {
             shouldContinue: false,
             reply: {
-                text: "⚠️ /restart is disabled. Set commands.restart=true to enable.",
+                text: "⚠️ /restart is disabled (commands.restart=false).",
             },
         };
     }
@@ -210,7 +381,7 @@ export const handleRestartCommand = async (params, allowTextCommands) => {
         return {
             shouldContinue: false,
             reply: {
-                text: "⚙️ Restarting poolbot in-process (SIGUSR1); back in a few seconds.",
+                text: "⚙️ Restarting Pool Bot in-process (SIGUSR1); back in a few seconds.",
             },
         };
     }
@@ -227,15 +398,17 @@ export const handleRestartCommand = async (params, allowTextCommands) => {
     return {
         shouldContinue: false,
         reply: {
-            text: `⚙️ Restarting poolbot via ${restartMethod.method}; give me a few seconds to come back online.`,
+            text: `⚙️ Restarting Pool Bot via ${restartMethod.method}; give me a few seconds to come back online.`,
         },
     };
 };
 export const handleStopCommand = async (params, allowTextCommands) => {
-    if (!allowTextCommands)
+    if (!allowTextCommands) {
         return null;
-    if (params.command.commandBodyNormalized !== "/stop")
+    }
+    if (params.command.commandBodyNormalized !== "/stop") {
         return null;
+    }
     if (!params.command.isAuthorizedSender) {
         logVerbose(`Ignoring /stop from unauthorized sender: ${params.command.senderId || "<unknown>"}`);
         return { shouldContinue: false };
@@ -246,26 +419,16 @@ export const handleStopCommand = async (params, allowTextCommands) => {
         sessionEntry: params.sessionEntry,
         sessionStore: params.sessionStore,
     });
-    if (abortTarget.sessionId) {
-        abortEmbeddedPiRun(abortTarget.sessionId);
-    }
     const cleared = clearSessionQueues([abortTarget.key, abortTarget.sessionId]);
     if (cleared.followupCleared > 0 || cleared.laneCleared > 0) {
         logVerbose(`stop: cleared followups=${cleared.followupCleared} lane=${cleared.laneCleared} keys=${cleared.keys.join(",")}`);
     }
-    if (abortTarget.entry && params.sessionStore && abortTarget.key) {
-        abortTarget.entry.abortedLastRun = true;
-        abortTarget.entry.updatedAt = Date.now();
-        params.sessionStore[abortTarget.key] = abortTarget.entry;
-        if (params.storePath) {
-            await updateSessionStore(params.storePath, (store) => {
-                store[abortTarget.key] = abortTarget.entry;
-            });
-        }
-    }
-    else if (params.command.abortKey) {
-        setAbortMemory(params.command.abortKey, true);
-    }
+    await applyAbortTarget({
+        abortTarget,
+        sessionStore: params.sessionStore,
+        storePath: params.storePath,
+        abortKey: params.command.abortKey,
+    });
     // Trigger internal hook for stop command
     const hookEvent = createInternalHookEvent("command", "stop", abortTarget.key ?? params.sessionKey ?? "", {
         sessionEntry: abortTarget.entry ?? params.sessionEntry,
@@ -281,31 +444,23 @@ export const handleStopCommand = async (params, allowTextCommands) => {
     return { shouldContinue: false, reply: { text: formatAbortReplyText(stopped) } };
 };
 export const handleAbortTrigger = async (params, allowTextCommands) => {
-    if (!allowTextCommands)
+    if (!allowTextCommands) {
         return null;
-    if (!isAbortTrigger(params.command.rawBodyNormalized))
+    }
+    if (!isAbortTrigger(params.command.rawBodyNormalized)) {
         return null;
+    }
     const abortTarget = resolveAbortTarget({
         ctx: params.ctx,
         sessionKey: params.sessionKey,
         sessionEntry: params.sessionEntry,
         sessionStore: params.sessionStore,
     });
-    if (abortTarget.sessionId) {
-        abortEmbeddedPiRun(abortTarget.sessionId);
-    }
-    if (abortTarget.entry && params.sessionStore && abortTarget.key) {
-        abortTarget.entry.abortedLastRun = true;
-        abortTarget.entry.updatedAt = Date.now();
-        params.sessionStore[abortTarget.key] = abortTarget.entry;
-        if (params.storePath) {
-            await updateSessionStore(params.storePath, (store) => {
-                store[abortTarget.key] = abortTarget.entry;
-            });
-        }
-    }
-    else if (params.command.abortKey) {
-        setAbortMemory(params.command.abortKey, true);
-    }
+    await applyAbortTarget({
+        abortTarget,
+        sessionStore: params.sessionStore,
+        storePath: params.storePath,
+        abortKey: params.command.abortKey,
+    });
     return { shouldContinue: false, reply: { text: "⚙️ Agent was aborted." } };
 };

package/dist/auto-reply/reply/commands-setunset-standard.js

@@ -0,0 +1,13 @@
+import { parseSlashCommandWithSetUnset } from "./commands-setunset.js";
+export function parseStandardSetUnsetSlashCommand(params) {
+    return parseSlashCommandWithSetUnset({
+        raw: params.raw,
+        slash: params.slash,
+        invalidMessage: params.invalidMessage,
+        usageMessage: params.usageMessage,
+        onKnownAction: params.onKnownAction,
+        onSet: params.onSet ?? ((path, value) => ({ action: "set", path, value })),
+        onUnset: params.onUnset ?? ((path) => ({ action: "unset", path })),
+        onError: params.onError ?? ((message) => ({ action: "error", message })),
+    });
+}

package/dist/auto-reply/reply/commands-setunset.js

@@ -1,3 +1,4 @@
+import { parseSlashCommandOrNull } from "./commands-slash-parse.js";
 import { parseConfigValue } from "./config-value.js";
 export function parseSetUnsetCommand(params) {
     const action = params.action;
@@ -26,3 +27,47 @@ export function parseSetUnsetCommand(params) {
     }
     return { kind: "set", path, value: parsed.value };
 }
+export function parseSetUnsetCommandAction(params) {
+    if (params.action !== "set" && params.action !== "unset") {
+        return null;
+    }
+    const parsed = parseSetUnsetCommand({
+        slash: params.slash,
+        action: params.action,
+        args: params.args,
+    });
+    if (parsed.kind === "error") {
+        return params.onError(parsed.message);
+    }
+    return parsed.kind === "set"
+        ? params.onSet(parsed.path, parsed.value)
+        : params.onUnset(parsed.path);
+}
+export function parseSlashCommandWithSetUnset(params) {
+    const parsed = parseSlashCommandOrNull(params.raw, params.slash, {
+        invalidMessage: params.invalidMessage,
+    });
+    if (!parsed) {
+        return null;
+    }
+    if (!parsed.ok) {
+        return params.onError(parsed.message);
+    }
+    const { action, args } = parsed;
+    const setUnset = parseSetUnsetCommandAction({
+        slash: params.slash,
+        action,
+        args,
+        onSet: params.onSet,
+        onUnset: params.onUnset,
+        onError: params.onError,
+    });
+    if (setUnset) {
+        return setUnset;
+    }
+    const knownAction = params.onKnownAction(action, args);
+    if (knownAction) {
+        return knownAction;
+    }
+    return params.onError(params.usageMessage);
+}

package/dist/auto-reply/reply/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/auto-reply/reply/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/auto-reply/reply/commands-subagents/action-help.js

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