@poolzin/pool-bot 2026.2.25 → 2026.2.26

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

@@ -1,6 +1,8 @@
+import { resolveAgentDir, resolveSessionAgentId } from "../../agents/agent-scope.js";
+import { DEFAULT_MODEL, DEFAULT_PROVIDER } from "../../agents/defaults.js";
+import { resolveModelAuthLabel } from "../../agents/model-auth-label.js";
 import { loadModelCatalog } from "../../agents/model-catalog.js";
 import { buildAllowedModelSet, buildModelAliasIndex, normalizeProviderId, resolveConfiguredModelRef, resolveModelRefFromString, } from "../../agents/model-selection.js";
-import { DEFAULT_MODEL, DEFAULT_PROVIDER } from "../../agents/defaults.js";
 import { buildModelsKeyboard, buildProviderKeyboard, calculateTotalPages, getModelsPageSize, } from "../../telegram/model-buttons.js";
 const PAGE_SIZE_DEFAULT = 20;
 const PAGE_SIZE_MAX = 100;
@@ -34,15 +36,17 @@ export async function buildModelsProviderData(cfg) {
     };
     const addRawModelRef = (raw) => {
         const trimmed = raw?.trim();
-        if (!trimmed)
+        if (!trimmed) {
             return;
+        }
         const resolved = resolveModelRefFromString({
             raw: trimmed,
             defaultProvider: resolvedDefault.provider,
             aliasIndex,
         });
-        if (!resolved)
+        if (!resolved) {
             return;
+        }
         add(resolved.ref.provider, resolved.ref.model);
     };
     const addModelConfigEntries = () => {
@@ -78,7 +82,7 @@ export async function buildModelsProviderData(cfg) {
     // curated catalog doesn't know about them (custom providers, dev builds, etc.).
     add(resolvedDefault.provider, resolvedDefault.model);
     addModelConfigEntries();
-    const providers = [...byProvider.keys()].sort();
+    const providers = [...byProvider.keys()].toSorted();
     return { byProvider, providers, resolvedDefault };
 }
 function formatProviderLine(params) {
@@ -101,14 +105,16 @@ function parseModelsArgs(raw) {
         }
         if (lower.startsWith("page=")) {
             const value = Number.parseInt(lower.slice("page=".length), 10);
-            if (Number.isFinite(value) && value > 0)
+            if (Number.isFinite(value) && value > 0) {
                 page = value;
+            }
             continue;
         }
         if (/^[0-9]+$/.test(lower)) {
             const value = Number.parseInt(lower, 10);
-            if (Number.isFinite(value) && value > 0)
+            if (Number.isFinite(value) && value > 0) {
                 page = value;
+            }
         }
     }
     let pageSize = PAGE_SIZE_DEFAULT;
@@ -117,8 +123,9 @@ function parseModelsArgs(raw) {
         if (lower.startsWith("limit=") || lower.startsWith("size=")) {
             const rawValue = lower.slice(lower.indexOf("=") + 1);
             const value = Number.parseInt(rawValue, 10);
-            if (Number.isFinite(value) && value > 0)
+            if (Number.isFinite(value) && value > 0) {
                 pageSize = Math.min(PAGE_SIZE_MAX, value);
+            }
         }
     }
     return {
@@ -128,10 +135,32 @@ function parseModelsArgs(raw) {
         all,
     };
 }
+function resolveProviderLabel(params) {
+    const authLabel = resolveModelAuthLabel({
+        provider: params.provider,
+        cfg: params.cfg,
+        sessionEntry: params.sessionEntry,
+        agentDir: params.agentDir,
+    });
+    if (!authLabel || authLabel === "unknown") {
+        return params.provider;
+    }
+    return `${params.provider} \u00b7 \uD83D\uDD11 ${authLabel}`;
+}
+export function formatModelsAvailableHeader(params) {
+    const providerLabel = resolveProviderLabel({
+        provider: params.provider,
+        cfg: params.cfg,
+        agentDir: params.agentDir,
+        sessionEntry: params.sessionEntry,
+    });
+    return `Models (${providerLabel}) \u2014 ${params.total} available`;
+}
 export async function resolveModelsCommandReply(params) {
     const body = params.commandBodyNormalized.trim();
-    if (!body.startsWith("/models"))
+    if (!body.startsWith("/models")) {
         return null;
+    }
     const argText = body.replace(/^\/models\b/i, "").trim();
     const { provider, page, pageSize, all } = parseModelsArgs(argText);
     const { byProvider, providers } = await buildModelsProviderData(params.cfg);
@@ -172,11 +201,17 @@ export async function resolveModelsCommandReply(params) {
         ];
         return { text: lines.join("\n") };
     }
-    const models = [...(byProvider.get(provider) ?? new Set())].sort();
+    const models = [...(byProvider.get(provider) ?? new Set())].toSorted();
     const total = models.length;
+    const providerLabel = resolveProviderLabel({
+        provider,
+        cfg: params.cfg,
+        agentDir: params.agentDir,
+        sessionEntry: params.sessionEntry,
+    });
     if (total === 0) {
         const lines = [
-            `Models (${provider}) — none`,
+            `Models (${providerLabel}) \u2014 none`,
             "",
             "Browse: /models",
             "Switch: /model <provider/model>",
@@ -196,7 +231,13 @@ export async function resolveModelsCommandReply(params) {
             totalPages,
             pageSize: telegramPageSize,
         });
-        const text = `Models (${provider}) — ${total} available`;
+        const text = formatModelsAvailableHeader({
+            provider,
+            total,
+            cfg: params.cfg,
+            agentDir: params.agentDir,
+            sessionEntry: params.sessionEntry,
+        });
         return {
             text,
             channelData: { telegram: { buttons } },
@@ -218,7 +259,7 @@ export async function resolveModelsCommandReply(params) {
     const startIndex = (safePage - 1) * effectivePageSize;
     const endIndexExclusive = Math.min(total, startIndex + effectivePageSize);
     const pageModels = models.slice(startIndex, endIndexExclusive);
-    const header = `Models (${provider}) — showing ${startIndex + 1}-${endIndexExclusive} of ${total} (page ${safePage}/${pageCount})`;
+    const header = `Models (${providerLabel}) \u2014 showing ${startIndex + 1}-${endIndexExclusive} of ${total} (page ${safePage}/${pageCount})`;
     const lines = [header];
     for (const id of pageModels) {
         lines.push(`- ${provider}/${id}`);
@@ -234,15 +275,25 @@ export async function resolveModelsCommandReply(params) {
     return payload;
 }
 export const handleModelsCommand = async (params, allowTextCommands) => {
-    if (!allowTextCommands)
+    if (!allowTextCommands) {
         return null;
+    }
+    const modelsAgentId = params.agentId ??
+        resolveSessionAgentId({
+            sessionKey: params.sessionKey,
+            config: params.cfg,
+        });
+    const modelsAgentDir = resolveAgentDir(params.cfg, modelsAgentId);
     const reply = await resolveModelsCommandReply({
         cfg: params.cfg,
         commandBodyNormalized: params.command.commandBodyNormalized,
         surface: params.ctx.Surface,
         currentModel: params.model ? `${params.provider}/${params.model}` : undefined,
+        agentDir: modelsAgentDir,
+        sessionEntry: params.sessionEntry,
     });
-    if (!reply)
+    if (!reply) {
         return null;
+    }
     return { reply, shouldContinue: false };
 };

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.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);
+}