@poolzin/pool-bot 2026.3.25 → 2026.3.27

package/dist/auto-reply/auto-reply/reply/agent-runner-memory.js

@@ -0,0 +1,160 @@
+import crypto from "node:crypto";
+import { resolveAgentModelFallbacksOverride } from "../../agents/agent-scope.js";
+import { runWithModelFallback } from "../../agents/model-fallback.js";
+import { isCliProvider } from "../../agents/model-selection.js";
+import { runEmbeddedPiAgent } from "../../agents/pi-embedded.js";
+import { resolveSandboxConfigForAgent, resolveSandboxRuntimeStatus } from "../../agents/sandbox.js";
+import { resolveAgentIdFromSessionKey, updateSessionStoreEntry, } from "../../config/sessions.js";
+import { logVerbose } from "../../globals.js";
+import { registerAgentRunContext } from "../../infra/agent-events.js";
+import { buildThreadingToolContext, resolveEnforceFinalTag } from "./agent-runner-utils.js";
+import { resolveMemoryFlushContextWindowTokens, resolveMemoryFlushSettings, shouldRunMemoryFlush, } from "./memory-flush.js";
+import { incrementCompactionCount } from "./session-updates.js";
+export async function runMemoryFlushIfNeeded(params) {
+    const memoryFlushSettings = resolveMemoryFlushSettings(params.cfg);
+    if (!memoryFlushSettings)
+        return params.sessionEntry;
+    const memoryFlushWritable = (() => {
+        if (!params.sessionKey)
+            return true;
+        const runtime = resolveSandboxRuntimeStatus({
+            cfg: params.cfg,
+            sessionKey: params.sessionKey,
+        });
+        if (!runtime.sandboxed)
+            return true;
+        const sandboxCfg = resolveSandboxConfigForAgent(params.cfg, runtime.agentId);
+        return sandboxCfg.workspaceAccess === "rw";
+    })();
+    const shouldFlushMemory = memoryFlushSettings &&
+        memoryFlushWritable &&
+        !params.isHeartbeat &&
+        !isCliProvider(params.followupRun.run.provider, params.cfg) &&
+        shouldRunMemoryFlush({
+            entry: params.sessionEntry ??
+                (params.sessionKey ? params.sessionStore?.[params.sessionKey] : undefined),
+            contextWindowTokens: resolveMemoryFlushContextWindowTokens({
+                modelId: params.followupRun.run.model ?? params.defaultModel,
+                agentCfgContextTokens: params.agentCfgContextTokens,
+            }),
+            reserveTokensFloor: memoryFlushSettings.reserveTokensFloor,
+            softThresholdTokens: memoryFlushSettings.softThresholdTokens,
+        });
+    if (!shouldFlushMemory)
+        return params.sessionEntry;
+    let activeSessionEntry = params.sessionEntry;
+    const activeSessionStore = params.sessionStore;
+    const flushRunId = crypto.randomUUID();
+    if (params.sessionKey) {
+        registerAgentRunContext(flushRunId, {
+            sessionKey: params.sessionKey,
+            verboseLevel: params.resolvedVerboseLevel,
+        });
+    }
+    let memoryCompactionCompleted = false;
+    const flushSystemPrompt = [
+        params.followupRun.run.extraSystemPrompt,
+        memoryFlushSettings.systemPrompt,
+    ]
+        .filter(Boolean)
+        .join("\n\n");
+    try {
+        await runWithModelFallback({
+            cfg: params.followupRun.run.config,
+            provider: params.followupRun.run.provider,
+            model: params.followupRun.run.model,
+            agentDir: params.followupRun.run.agentDir,
+            fallbacksOverride: resolveAgentModelFallbacksOverride(params.followupRun.run.config, resolveAgentIdFromSessionKey(params.followupRun.run.sessionKey)),
+            run: (provider, model) => {
+                const authProfileId = provider === params.followupRun.run.provider
+                    ? params.followupRun.run.authProfileId
+                    : undefined;
+                return runEmbeddedPiAgent({
+                    sessionId: params.followupRun.run.sessionId,
+                    sessionKey: params.sessionKey,
+                    messageProvider: params.sessionCtx.Provider?.trim().toLowerCase() || undefined,
+                    agentAccountId: params.sessionCtx.AccountId,
+                    messageTo: params.sessionCtx.OriginatingTo ?? params.sessionCtx.To,
+                    messageThreadId: params.sessionCtx.MessageThreadId ?? undefined,
+                    // Provider threading context for tool auto-injection
+                    ...buildThreadingToolContext({
+                        sessionCtx: params.sessionCtx,
+                        config: params.followupRun.run.config,
+                        hasRepliedRef: params.opts?.hasRepliedRef,
+                    }),
+                    senderId: params.sessionCtx.SenderId?.trim() || undefined,
+                    senderName: params.sessionCtx.SenderName?.trim() || undefined,
+                    senderUsername: params.sessionCtx.SenderUsername?.trim() || undefined,
+                    senderE164: params.sessionCtx.SenderE164?.trim() || undefined,
+                    sessionFile: params.followupRun.run.sessionFile,
+                    workspaceDir: params.followupRun.run.workspaceDir,
+                    agentDir: params.followupRun.run.agentDir,
+                    config: params.followupRun.run.config,
+                    skillsSnapshot: params.followupRun.run.skillsSnapshot,
+                    prompt: memoryFlushSettings.prompt,
+                    extraSystemPrompt: flushSystemPrompt,
+                    ownerNumbers: params.followupRun.run.ownerNumbers,
+                    enforceFinalTag: resolveEnforceFinalTag(params.followupRun.run, provider),
+                    provider,
+                    model,
+                    authProfileId,
+                    authProfileIdSource: authProfileId
+                        ? params.followupRun.run.authProfileIdSource
+                        : undefined,
+                    thinkLevel: params.followupRun.run.thinkLevel,
+                    verboseLevel: params.followupRun.run.verboseLevel,
+                    reasoningLevel: params.followupRun.run.reasoningLevel,
+                    execOverrides: params.followupRun.run.execOverrides,
+                    bashElevated: params.followupRun.run.bashElevated,
+                    timeoutMs: params.followupRun.run.timeoutMs,
+                    runId: flushRunId,
+                    onAgentEvent: (evt) => {
+                        if (evt.stream === "compaction") {
+                            const phase = typeof evt.data.phase === "string" ? evt.data.phase : "";
+                            const willRetry = Boolean(evt.data.willRetry);
+                            if (phase === "end" && !willRetry) {
+                                memoryCompactionCompleted = true;
+                            }
+                        }
+                    },
+                });
+            },
+        });
+        let memoryFlushCompactionCount = activeSessionEntry?.compactionCount ??
+            (params.sessionKey ? activeSessionStore?.[params.sessionKey]?.compactionCount : 0) ??
+            0;
+        if (memoryCompactionCompleted) {
+            const nextCount = await incrementCompactionCount({
+                sessionEntry: activeSessionEntry,
+                sessionStore: activeSessionStore,
+                sessionKey: params.sessionKey,
+                storePath: params.storePath,
+            });
+            if (typeof nextCount === "number") {
+                memoryFlushCompactionCount = nextCount;
+            }
+        }
+        if (params.storePath && params.sessionKey) {
+            try {
+                const updatedEntry = await updateSessionStoreEntry({
+                    storePath: params.storePath,
+                    sessionKey: params.sessionKey,
+                    update: async () => ({
+                        memoryFlushAt: Date.now(),
+                        memoryFlushCompactionCount,
+                    }),
+                });
+                if (updatedEntry) {
+                    activeSessionEntry = updatedEntry;
+                }
+            }
+            catch (err) {
+                logVerbose(`failed to persist memory flush metadata: ${String(err)}`);
+            }
+        }
+    }
+    catch (err) {
+        logVerbose(`memory flush run failed: ${String(err)}`);
+    }
+    return activeSessionEntry;
+}

package/dist/auto-reply/auto-reply/reply/agent-runner-payloads.js

@@ -0,0 +1,85 @@
+import { logVerbose } from "../../globals.js";
+import { stripHeartbeatToken } from "../heartbeat.js";
+import { SILENT_REPLY_TOKEN } from "../tokens.js";
+import { formatBunFetchSocketError, isBunFetchSocketError } from "./agent-runner-utils.js";
+import { createBlockReplyPayloadKey } from "./block-reply-pipeline.js";
+import { parseReplyDirectives } from "./reply-directives.js";
+import { applyReplyThreading, filterMessagingToolDuplicates, isRenderablePayload, shouldSuppressMessagingToolReplies, } from "./reply-payloads.js";
+export function buildReplyPayloads(params) {
+    let didLogHeartbeatStrip = params.didLogHeartbeatStrip;
+    const sanitizedPayloads = params.isHeartbeat
+        ? params.payloads
+        : params.payloads.flatMap((payload) => {
+            let text = payload.text;
+            if (payload.isError && text && isBunFetchSocketError(text)) {
+                text = formatBunFetchSocketError(text);
+            }
+            if (!text || !text.includes("HEARTBEAT_OK")) {
+                return [{ ...payload, text }];
+            }
+            const stripped = stripHeartbeatToken(text, { mode: "message" });
+            if (stripped.didStrip && !didLogHeartbeatStrip) {
+                didLogHeartbeatStrip = true;
+                logVerbose("Stripped stray HEARTBEAT_OK token from reply");
+            }
+            const hasMedia = Boolean(payload.mediaUrl) || (payload.mediaUrls?.length ?? 0) > 0;
+            if (stripped.shouldSkip && !hasMedia)
+                return [];
+            return [{ ...payload, text: stripped.text }];
+        });
+    const replyTaggedPayloads = applyReplyThreading({
+        payloads: sanitizedPayloads,
+        replyToMode: params.replyToMode,
+        replyToChannel: params.replyToChannel,
+        currentMessageId: params.currentMessageId,
+    })
+        .map((payload) => {
+        const parsed = parseReplyDirectives(payload.text ?? "", {
+            currentMessageId: params.currentMessageId,
+            silentToken: SILENT_REPLY_TOKEN,
+        });
+        const mediaUrls = payload.mediaUrls ?? parsed.mediaUrls;
+        const mediaUrl = payload.mediaUrl ?? parsed.mediaUrl ?? mediaUrls?.[0];
+        return {
+            ...payload,
+            text: parsed.text ? parsed.text : undefined,
+            mediaUrls,
+            mediaUrl,
+            replyToId: payload.replyToId ?? parsed.replyToId,
+            replyToTag: payload.replyToTag || parsed.replyToTag,
+            replyToCurrent: payload.replyToCurrent || parsed.replyToCurrent,
+            audioAsVoice: Boolean(payload.audioAsVoice || parsed.audioAsVoice),
+        };
+    })
+        .filter(isRenderablePayload);
+    // Drop final payloads only when block streaming succeeded end-to-end.
+    // If streaming aborted (e.g., timeout), fall back to final payloads.
+    const shouldDropFinalPayloads = params.blockStreamingEnabled &&
+        Boolean(params.blockReplyPipeline?.didStream()) &&
+        !params.blockReplyPipeline?.isAborted();
+    const messagingToolSentTexts = params.messagingToolSentTexts ?? [];
+    const messagingToolSentTargets = params.messagingToolSentTargets ?? [];
+    const suppressMessagingToolReplies = shouldSuppressMessagingToolReplies({
+        messageProvider: params.messageProvider,
+        messagingToolSentTargets,
+        originatingTo: params.originatingTo,
+        accountId: params.accountId,
+    });
+    const dedupedPayloads = filterMessagingToolDuplicates({
+        payloads: replyTaggedPayloads,
+        sentTexts: messagingToolSentTexts,
+    });
+    // Filter out payloads already sent via pipeline or directly during tool flush.
+    const filteredPayloads = shouldDropFinalPayloads
+        ? []
+        : params.blockStreamingEnabled
+            ? dedupedPayloads.filter((payload) => !params.blockReplyPipeline?.hasSentPayload(payload))
+            : params.directlySentBlockKeys?.size
+                ? dedupedPayloads.filter((payload) => !params.directlySentBlockKeys.has(createBlockReplyPayloadKey(payload)))
+                : dedupedPayloads;
+    const replyPayloads = suppressMessagingToolReplies ? [] : filteredPayloads;
+    return {
+        replyPayloads,
+        didLogHeartbeatStrip,
+    };
+}

package/dist/auto-reply/auto-reply/reply/agent-runner-utils.js

@@ -0,0 +1,101 @@
+import { getChannelDock } from "../../channels/dock.js";
+import { normalizeAnyChannelId, normalizeChannelId } from "../../channels/registry.js";
+import { isReasoningTagProvider } from "../../utils/provider-utils.js";
+import { estimateUsageCost, formatTokenCount, formatUsd } from "../../utils/usage-format.js";
+const BUN_FETCH_SOCKET_ERROR_RE = /socket connection was closed unexpectedly/i;
+/**
+ * Build provider-specific threading context for tool auto-injection.
+ */
+export function buildThreadingToolContext(params) {
+    const { sessionCtx, config, hasRepliedRef } = params;
+    if (!config)
+        return {};
+    const rawProvider = sessionCtx.Provider?.trim().toLowerCase();
+    if (!rawProvider)
+        return {};
+    const provider = normalizeChannelId(rawProvider) ?? normalizeAnyChannelId(rawProvider);
+    // Fallback for unrecognized/plugin channels (e.g., BlueBubbles before plugin registry init)
+    const dock = provider ? getChannelDock(provider) : undefined;
+    if (!dock?.threading?.buildToolContext) {
+        return {
+            currentChannelId: sessionCtx.To?.trim() || undefined,
+            currentChannelProvider: provider ?? rawProvider,
+            hasRepliedRef,
+        };
+    }
+    const context = dock.threading.buildToolContext({
+        cfg: config,
+        accountId: sessionCtx.AccountId,
+        context: {
+            Channel: sessionCtx.Provider,
+            From: sessionCtx.From,
+            To: sessionCtx.To,
+            ChatType: sessionCtx.ChatType,
+            ReplyToId: sessionCtx.ReplyToId,
+            ThreadLabel: sessionCtx.ThreadLabel,
+            MessageThreadId: sessionCtx.MessageThreadId,
+        },
+        hasRepliedRef,
+    }) ?? {};
+    return {
+        ...context,
+        currentChannelProvider: provider, // guaranteed non-null since dock exists
+    };
+}
+export const isBunFetchSocketError = (message) => Boolean(message && BUN_FETCH_SOCKET_ERROR_RE.test(message));
+export const formatBunFetchSocketError = (message) => {
+    const trimmed = message.trim();
+    return [
+        "⚠️ LLM connection failed. This could be due to server issues, network problems, or context length exceeded (e.g., with local LLMs like LM Studio). Original error:",
+        "```",
+        trimmed || "Unknown error",
+        "```",
+    ].join("\n");
+};
+export const formatResponseUsageLine = (params) => {
+    const usage = params.usage;
+    if (!usage)
+        return null;
+    const input = usage.input;
+    const output = usage.output;
+    if (typeof input !== "number" && typeof output !== "number")
+        return null;
+    const inputLabel = typeof input === "number" ? formatTokenCount(input) : "?";
+    const outputLabel = typeof output === "number" ? formatTokenCount(output) : "?";
+    const cost = params.showCost && typeof input === "number" && typeof output === "number"
+        ? estimateUsageCost({
+            usage: {
+                input,
+                output,
+                cacheRead: usage.cacheRead,
+                cacheWrite: usage.cacheWrite,
+            },
+            cost: params.costConfig,
+        })
+        : undefined;
+    const costLabel = params.showCost ? formatUsd(cost) : undefined;
+    const suffix = costLabel ? ` · est ${costLabel}` : "";
+    return `Usage: ${inputLabel} in / ${outputLabel} out${suffix}`;
+};
+export const appendUsageLine = (payloads, line) => {
+    let index = -1;
+    for (let i = payloads.length - 1; i >= 0; i -= 1) {
+        if (payloads[i]?.text) {
+            index = i;
+            break;
+        }
+    }
+    if (index === -1)
+        return [...payloads, { text: line }];
+    const existing = payloads[index];
+    const existingText = existing.text ?? "";
+    const separator = existingText.endsWith("\n") ? "" : "\n";
+    const next = {
+        ...existing,
+        text: `${existingText}${separator}${line}`,
+    };
+    const updated = payloads.slice();
+    updated[index] = next;
+    return updated;
+};
+export const resolveEnforceFinalTag = (run, provider) => Boolean(run.enforceFinalTag || isReasoningTagProvider(provider));

package/dist/auto-reply/auto-reply/reply/bash-command.js

@@ -0,0 +1,338 @@
+import { resolveSessionAgentId } from "../../agents/agent-scope.js";
+import { getFinishedSession, getSession, markExited } from "../../agents/bash-process-registry.js";
+import { createExecTool } from "../../agents/bash-tools.js";
+import { resolveSandboxRuntimeStatus } from "../../agents/sandbox.js";
+import { killProcessTree } from "../../agents/shell-utils.js";
+import { isCommandFlagEnabled } from "../../config/commands.js";
+import { logVerbose } from "../../globals.js";
+import { clampInt } from "../../utils.js";
+import { buildDisabledCommandReply } from "./command-gates.js";
+import { formatElevatedUnavailableMessage } from "./elevated-unavailable.js";
+import { stripMentions, stripStructuralPrefixes } from "./mentions.js";
+const CHAT_BASH_SCOPE_KEY = "chat:bash";
+const DEFAULT_FOREGROUND_MS = 2000;
+const MAX_FOREGROUND_MS = 30_000;
+let activeJob = null;
+function resolveForegroundMs(cfg) {
+    const raw = cfg.commands?.bashForegroundMs;
+    if (typeof raw !== "number" || Number.isNaN(raw)) {
+        return DEFAULT_FOREGROUND_MS;
+    }
+    return clampInt(raw, 0, MAX_FOREGROUND_MS);
+}
+function formatSessionSnippet(sessionId) {
+    const trimmed = sessionId.trim();
+    if (trimmed.length <= 12) {
+        return trimmed;
+    }
+    return `${trimmed.slice(0, 8)}…`;
+}
+function formatOutputBlock(text) {
+    const trimmed = text.trim();
+    if (!trimmed) {
+        return "(no output)";
+    }
+    return `\`\`\`txt\n${trimmed}\n\`\`\``;
+}
+function parseBashRequest(raw) {
+    const trimmed = raw.trimStart();
+    let restSource = "";
+    if (trimmed.toLowerCase().startsWith("/bash")) {
+        const match = trimmed.match(/^\/bash(?:\s*:\s*|\s+|$)([\s\S]*)$/i);
+        if (!match) {
+            return null;
+        }
+        restSource = match[1] ?? "";
+    }
+    else if (trimmed.startsWith("!")) {
+        restSource = trimmed.slice(1);
+        if (restSource.trimStart().startsWith(":")) {
+            restSource = restSource.trimStart().slice(1);
+        }
+    }
+    else {
+        return null;
+    }
+    const rest = restSource.trimStart();
+    if (!rest) {
+        return { action: "help" };
+    }
+    const tokenMatch = rest.match(/^(\S+)(?:\s+([\s\S]+))?$/);
+    const token = tokenMatch?.[1]?.trim() ?? "";
+    const remainder = tokenMatch?.[2]?.trim() ?? "";
+    const lowered = token.toLowerCase();
+    if (lowered === "poll") {
+        return { action: "poll", sessionId: remainder || undefined };
+    }
+    if (lowered === "stop") {
+        return { action: "stop", sessionId: remainder || undefined };
+    }
+    if (lowered === "help") {
+        return { action: "help" };
+    }
+    return { action: "run", command: rest };
+}
+function resolveRawCommandBody(params) {
+    const source = params.ctx.CommandBody ?? params.ctx.RawBody ?? params.ctx.Body ?? "";
+    const stripped = stripStructuralPrefixes(source);
+    return params.isGroup
+        ? stripMentions(stripped, params.ctx, params.cfg, params.agentId)
+        : stripped;
+}
+function getScopedSession(sessionId) {
+    const running = getSession(sessionId);
+    if (running && running.scopeKey === CHAT_BASH_SCOPE_KEY) {
+        return { running };
+    }
+    const finished = getFinishedSession(sessionId);
+    if (finished && finished.scopeKey === CHAT_BASH_SCOPE_KEY) {
+        return { finished };
+    }
+    return {};
+}
+function ensureActiveJobState() {
+    if (!activeJob) {
+        return null;
+    }
+    if (activeJob.state === "starting") {
+        return activeJob;
+    }
+    const { running, finished } = getScopedSession(activeJob.sessionId);
+    if (running) {
+        return activeJob;
+    }
+    if (finished) {
+        activeJob = null;
+        return null;
+    }
+    activeJob = null;
+    return null;
+}
+function attachActiveWatcher(sessionId) {
+    if (!activeJob || activeJob.state !== "running") {
+        return;
+    }
+    if (activeJob.sessionId !== sessionId) {
+        return;
+    }
+    if (activeJob.watcherAttached) {
+        return;
+    }
+    const { running } = getScopedSession(sessionId);
+    const child = running?.child;
+    if (!child) {
+        return;
+    }
+    activeJob.watcherAttached = true;
+    child.once("close", () => {
+        if (activeJob?.state === "running" && activeJob.sessionId === sessionId) {
+            activeJob = null;
+        }
+    });
+}
+function buildUsageReply() {
+    return {
+        text: [
+            "⚙️ Usage:",
+            "- ! <command>",
+            "- !poll | ! poll",
+            "- !stop | ! stop",
+            "- /bash ... (alias; same subcommands as !)",
+        ].join("\n"),
+    };
+}
+export async function handleBashChatCommand(params) {
+    if (!isCommandFlagEnabled(params.cfg, "bash")) {
+        return buildDisabledCommandReply({
+            label: "bash",
+            configKey: "bash",
+            docsUrl: "https://docs.molt.bot/tools/slash-commands#config",
+        });
+    }
+    const agentId = params.agentId ??
+        resolveSessionAgentId({
+            sessionKey: params.sessionKey,
+            config: params.cfg,
+        });
+    if (!params.elevated.enabled || !params.elevated.allowed) {
+        const runtimeSandboxed = resolveSandboxRuntimeStatus({
+            cfg: params.cfg,
+            sessionKey: params.ctx.SessionKey,
+        }).sandboxed;
+        return {
+            text: formatElevatedUnavailableMessage({
+                runtimeSandboxed,
+                failures: params.elevated.failures,
+                sessionKey: params.ctx.SessionKey,
+            }),
+        };
+    }
+    const rawBody = resolveRawCommandBody({
+        ctx: params.ctx,
+        cfg: params.cfg,
+        agentId,
+        isGroup: params.isGroup,
+    }).trim();
+    const request = parseBashRequest(rawBody);
+    if (!request) {
+        return { text: "⚠️ Unrecognized bash request." };
+    }
+    const liveJob = ensureActiveJobState();
+    if (request.action === "help") {
+        return buildUsageReply();
+    }
+    if (request.action === "poll") {
+        const sessionId = request.sessionId?.trim() || (liveJob?.state === "running" ? liveJob.sessionId : "");
+        if (!sessionId) {
+            return { text: "⚙️ No active bash job." };
+        }
+        const { running, finished } = getScopedSession(sessionId);
+        if (running) {
+            attachActiveWatcher(sessionId);
+            const runtimeSec = Math.max(0, Math.floor((Date.now() - running.startedAt) / 1000));
+            const tail = running.tail || "(no output yet)";
+            return {
+                text: [
+                    `⚙️ bash still running (session ${formatSessionSnippet(sessionId)}, ${runtimeSec}s).`,
+                    formatOutputBlock(tail),
+                    "Hint: !stop (or /bash stop)",
+                ].join("\n"),
+            };
+        }
+        if (finished) {
+            if (activeJob?.state === "running" && activeJob.sessionId === sessionId) {
+                activeJob = null;
+            }
+            const exitLabel = finished.exitSignal
+                ? `signal ${String(finished.exitSignal)}`
+                : `code ${String(finished.exitCode ?? 0)}`;
+            const prefix = finished.status === "completed" ? "⚙️" : "⚠️";
+            return {
+                text: [
+                    `${prefix} bash finished (session ${formatSessionSnippet(sessionId)}).`,
+                    `Exit: ${exitLabel}`,
+                    formatOutputBlock(finished.aggregated || finished.tail),
+                ].join("\n"),
+            };
+        }
+        if (activeJob?.state === "running" && activeJob.sessionId === sessionId) {
+            activeJob = null;
+        }
+        return {
+            text: `⚙️ No bash session found for ${formatSessionSnippet(sessionId)}.`,
+        };
+    }
+    if (request.action === "stop") {
+        const sessionId = request.sessionId?.trim() || (liveJob?.state === "running" ? liveJob.sessionId : "");
+        if (!sessionId) {
+            return { text: "⚙️ No active bash job." };
+        }
+        const { running } = getScopedSession(sessionId);
+        if (!running) {
+            if (activeJob?.state === "running" && activeJob.sessionId === sessionId) {
+                activeJob = null;
+            }
+            return {
+                text: `⚙️ No running bash job found for ${formatSessionSnippet(sessionId)}.`,
+            };
+        }
+        if (!running.backgrounded) {
+            return {
+                text: `⚠️ Session ${formatSessionSnippet(sessionId)} is not backgrounded.`,
+            };
+        }
+        const pid = running.pid ?? running.child?.pid;
+        if (pid) {
+            killProcessTree(pid);
+        }
+        markExited(running, null, "SIGKILL", "failed");
+        if (activeJob?.state === "running" && activeJob.sessionId === sessionId) {
+            activeJob = null;
+        }
+        return {
+            text: `⚙️ bash stopped (session ${formatSessionSnippet(sessionId)}).`,
+        };
+    }
+    // request.action === "run"
+    if (liveJob) {
+        const label = liveJob.state === "running" ? formatSessionSnippet(liveJob.sessionId) : "starting";
+        return {
+            text: `⚠️ A bash job is already running (${label}). Use !poll / !stop (or /bash poll / /bash stop).`,
+        };
+    }
+    const commandText = request.command.trim();
+    if (!commandText) {
+        return buildUsageReply();
+    }
+    activeJob = {
+        state: "starting",
+        startedAt: Date.now(),
+        command: commandText,
+    };
+    try {
+        const foregroundMs = resolveForegroundMs(params.cfg);
+        const shouldBackgroundImmediately = foregroundMs <= 0;
+        const timeoutSec = params.cfg.tools?.exec?.timeoutSec;
+        const notifyOnExit = params.cfg.tools?.exec?.notifyOnExit;
+        const notifyOnExitEmptySuccess = params.cfg.tools?.exec?.notifyOnExitEmptySuccess;
+        const execTool = createExecTool({
+            scopeKey: CHAT_BASH_SCOPE_KEY,
+            allowBackground: true,
+            timeoutSec,
+            sessionKey: params.sessionKey,
+            notifyOnExit,
+            notifyOnExitEmptySuccess,
+            elevated: {
+                enabled: params.elevated.enabled,
+                allowed: params.elevated.allowed,
+                defaultLevel: "on",
+            },
+        });
+        const result = await execTool.execute("chat-bash", {
+            command: commandText,
+            background: shouldBackgroundImmediately,
+            yieldMs: shouldBackgroundImmediately ? undefined : foregroundMs,
+            timeout: timeoutSec,
+            elevated: true,
+        });
+        if (result.details?.status === "running") {
+            const sessionId = result.details.sessionId;
+            activeJob = {
+                state: "running",
+                sessionId,
+                startedAt: result.details.startedAt,
+                command: commandText,
+                watcherAttached: false,
+            };
+            attachActiveWatcher(sessionId);
+            const snippet = formatSessionSnippet(sessionId);
+            logVerbose(`Started bash session ${snippet}: ${commandText}`);
+            return {
+                text: `⚙️ bash started (session ${sessionId}). Still running; use !poll / !stop (or /bash poll / /bash stop).`,
+            };
+        }
+        // Completed in foreground.
+        activeJob = null;
+        const exitCode = result.details?.status === "completed" ? result.details.exitCode : 0;
+        const output = result.details?.status === "completed"
+            ? result.details.aggregated
+            : result.content.map((chunk) => (chunk.type === "text" ? chunk.text : "")).join("\n");
+        return {
+            text: [
+                `⚙️ bash: ${commandText}`,
+                `Exit: ${exitCode}`,
+                formatOutputBlock(output || "(no output)"),
+            ].join("\n"),
+        };
+    }
+    catch (err) {
+        activeJob = null;
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            text: [`⚠️ bash failed: ${commandText}`, formatOutputBlock(message)].join("\n"),
+        };
+    }
+}
+export function resetBashChatCommandForTests() {
+    activeJob = null;
+}