clawdbot 2026.1.4-1

package/dist/auto-reply/model.js

@@ -0,0 +1,14 @@
+export function extractModelDirective(body) {
+    if (!body)
+        return { cleaned: "", hasDirective: false };
+    const match = body.match(/(?:^|\s)\/model(?=$|\s|:)\s*:?\s*([A-Za-z0-9_.:-]+(?:\/[A-Za-z0-9_.:-]+)?)?/i);
+    const rawModel = match?.[1]?.trim();
+    const cleaned = match
+        ? body.replace(match[0], "").replace(/\s+/g, " ").trim()
+        : body.trim();
+    return {
+        cleaned,
+        rawModel,
+        hasDirective: !!match,
+    };
+}

package/dist/auto-reply/reply/abort.js

@@ -0,0 +1,14 @@
+const ABORT_TRIGGERS = new Set(["stop", "esc", "abort", "wait", "exit"]);
+const ABORT_MEMORY = new Map();
+export function isAbortTrigger(text) {
+    if (!text)
+        return false;
+    const normalized = text.trim().toLowerCase();
+    return ABORT_TRIGGERS.has(normalized);
+}
+export function getAbortMemory(key) {
+    return ABORT_MEMORY.get(key);
+}
+export function setAbortMemory(key, value) {
+    ABORT_MEMORY.set(key, value);
+}

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

@@ -0,0 +1,371 @@
+import crypto from "node:crypto";
+import { lookupContextTokens } from "../../agents/context.js";
+import { DEFAULT_CONTEXT_TOKENS } from "../../agents/defaults.js";
+import { runWithModelFallback } from "../../agents/model-fallback.js";
+import { queueEmbeddedPiMessage, runEmbeddedPiAgent, } from "../../agents/pi-embedded.js";
+import { loadSessionStore, saveSessionStore, } from "../../config/sessions.js";
+import { logVerbose } from "../../globals.js";
+import { registerAgentRunContext } from "../../infra/agent-events.js";
+import { defaultRuntime } from "../../runtime.js";
+import { stripHeartbeatToken } from "../heartbeat.js";
+import { normalizeVerboseLevel } from "../thinking.js";
+import { SILENT_REPLY_TOKEN } from "../tokens.js";
+import { createFollowupRunner } from "./followup-runner.js";
+import { enqueueFollowupRun, scheduleFollowupDrain, } from "./queue.js";
+import { extractReplyToTag } from "./reply-tags.js";
+export async function runReplyAgent(params) {
+    const { commandBody, followupRun, queueKey, resolvedQueue, shouldSteer, shouldFollowup, isActive, isStreaming, opts, typing, sessionEntry, sessionStore, sessionKey, storePath, defaultModel, agentCfgContextTokens, resolvedVerboseLevel, isNewSession, blockStreamingEnabled, blockReplyChunking, resolvedBlockStreamingBreak, sessionCtx, shouldInjectGroupIntro, } = params;
+    const shouldEmitToolResult = () => {
+        if (!sessionKey || !storePath) {
+            return resolvedVerboseLevel === "on";
+        }
+        try {
+            const store = loadSessionStore(storePath);
+            const entry = store[sessionKey];
+            const current = normalizeVerboseLevel(entry?.verboseLevel);
+            if (current)
+                return current === "on";
+        }
+        catch {
+            // ignore store read failures
+        }
+        return resolvedVerboseLevel === "on";
+    };
+    const streamedPayloadKeys = new Set();
+    const pendingStreamedPayloadKeys = new Set();
+    const pendingBlockTasks = new Set();
+    let didStreamBlockReply = false;
+    const buildPayloadKey = (payload) => {
+        const text = payload.text?.trim() ?? "";
+        const mediaList = payload.mediaUrls?.length
+            ? payload.mediaUrls
+            : payload.mediaUrl
+                ? [payload.mediaUrl]
+                : [];
+        return JSON.stringify({
+            text,
+            mediaList,
+            replyToId: payload.replyToId ?? null,
+        });
+    };
+    if (shouldSteer && isStreaming) {
+        const steered = queueEmbeddedPiMessage(followupRun.run.sessionId, followupRun.prompt);
+        if (steered && !shouldFollowup) {
+            if (sessionEntry && sessionStore && sessionKey) {
+                sessionEntry.updatedAt = Date.now();
+                sessionStore[sessionKey] = sessionEntry;
+                if (storePath) {
+                    await saveSessionStore(storePath, sessionStore);
+                }
+            }
+            typing.cleanup();
+            return undefined;
+        }
+    }
+    if (isActive && (shouldFollowup || resolvedQueue.mode === "steer")) {
+        enqueueFollowupRun(queueKey, followupRun, resolvedQueue);
+        if (sessionEntry && sessionStore && sessionKey) {
+            sessionEntry.updatedAt = Date.now();
+            sessionStore[sessionKey] = sessionEntry;
+            if (storePath) {
+                await saveSessionStore(storePath, sessionStore);
+            }
+        }
+        typing.cleanup();
+        return undefined;
+    }
+    const runFollowupTurn = createFollowupRunner({
+        opts,
+        typing,
+        sessionEntry,
+        sessionStore,
+        sessionKey,
+        storePath,
+        defaultModel,
+        agentCfgContextTokens,
+    });
+    const finalizeWithFollowup = (value) => {
+        scheduleFollowupDrain(queueKey, runFollowupTurn);
+        return value;
+    };
+    let didLogHeartbeatStrip = false;
+    try {
+        const runId = crypto.randomUUID();
+        if (sessionKey) {
+            registerAgentRunContext(runId, { sessionKey });
+        }
+        let runResult;
+        let fallbackProvider = followupRun.run.provider;
+        let fallbackModel = followupRun.run.model;
+        try {
+            const fallbackResult = await runWithModelFallback({
+                cfg: followupRun.run.config,
+                provider: followupRun.run.provider,
+                model: followupRun.run.model,
+                run: (provider, model) => runEmbeddedPiAgent({
+                    sessionId: followupRun.run.sessionId,
+                    sessionKey,
+                    surface: sessionCtx.Surface?.trim().toLowerCase() || undefined,
+                    sessionFile: followupRun.run.sessionFile,
+                    workspaceDir: followupRun.run.workspaceDir,
+                    config: followupRun.run.config,
+                    skillsSnapshot: followupRun.run.skillsSnapshot,
+                    prompt: commandBody,
+                    extraSystemPrompt: followupRun.run.extraSystemPrompt,
+                    ownerNumbers: followupRun.run.ownerNumbers,
+                    enforceFinalTag: followupRun.run.enforceFinalTag,
+                    provider,
+                    model,
+                    thinkLevel: followupRun.run.thinkLevel,
+                    verboseLevel: followupRun.run.verboseLevel,
+                    bashElevated: followupRun.run.bashElevated,
+                    timeoutMs: followupRun.run.timeoutMs,
+                    runId,
+                    blockReplyBreak: resolvedBlockStreamingBreak,
+                    blockReplyChunking,
+                    onPartialReply: opts?.onPartialReply
+                        ? async (payload) => {
+                            let text = payload.text;
+                            if (!opts?.isHeartbeat && text?.includes("HEARTBEAT_OK")) {
+                                const stripped = stripHeartbeatToken(text, {
+                                    mode: "message",
+                                });
+                                if (stripped.didStrip && !didLogHeartbeatStrip) {
+                                    didLogHeartbeatStrip = true;
+                                    logVerbose("Stripped stray HEARTBEAT_OK token from reply");
+                                }
+                                if (stripped.shouldSkip &&
+                                    (payload.mediaUrls?.length ?? 0) === 0) {
+                                    return;
+                                }
+                                text = stripped.text;
+                            }
+                            await typing.startTypingOnText(text);
+                            await opts.onPartialReply?.({
+                                text,
+                                mediaUrls: payload.mediaUrls,
+                            });
+                        }
+                        : undefined,
+                    onBlockReply: blockStreamingEnabled && opts?.onBlockReply
+                        ? async (payload) => {
+                            let text = payload.text;
+                            if (!opts?.isHeartbeat && text?.includes("HEARTBEAT_OK")) {
+                                const stripped = stripHeartbeatToken(text, {
+                                    mode: "message",
+                                });
+                                if (stripped.didStrip && !didLogHeartbeatStrip) {
+                                    didLogHeartbeatStrip = true;
+                                    logVerbose("Stripped stray HEARTBEAT_OK token from reply");
+                                }
+                                const hasMedia = (payload.mediaUrls?.length ?? 0) > 0;
+                                if (stripped.shouldSkip && !hasMedia)
+                                    return;
+                                text = stripped.text;
+                            }
+                            const tagResult = extractReplyToTag(text, sessionCtx.MessageSid);
+                            const cleaned = tagResult.cleaned || undefined;
+                            const hasMedia = (payload.mediaUrls?.length ?? 0) > 0;
+                            if (!cleaned && !hasMedia)
+                                return;
+                            if (cleaned?.trim() === SILENT_REPLY_TOKEN && !hasMedia)
+                                return;
+                            const blockPayload = {
+                                text: cleaned,
+                                mediaUrls: payload.mediaUrls,
+                                mediaUrl: payload.mediaUrls?.[0],
+                                replyToId: tagResult.replyToId,
+                            };
+                            const payloadKey = buildPayloadKey(blockPayload);
+                            if (streamedPayloadKeys.has(payloadKey) ||
+                                pendingStreamedPayloadKeys.has(payloadKey)) {
+                                return;
+                            }
+                            pendingStreamedPayloadKeys.add(payloadKey);
+                            const task = (async () => {
+                                await typing.startTypingOnText(cleaned);
+                                await opts.onBlockReply?.(blockPayload);
+                            })()
+                                .then(() => {
+                                streamedPayloadKeys.add(payloadKey);
+                                didStreamBlockReply = true;
+                            })
+                                .catch((err) => {
+                                logVerbose(`block reply delivery failed: ${String(err)}`);
+                            })
+                                .finally(() => {
+                                pendingStreamedPayloadKeys.delete(payloadKey);
+                            });
+                            pendingBlockTasks.add(task);
+                            void task.finally(() => pendingBlockTasks.delete(task));
+                        }
+                        : undefined,
+                    shouldEmitToolResult,
+                    onToolResult: opts?.onToolResult
+                        ? async (payload) => {
+                            let text = payload.text;
+                            if (!opts?.isHeartbeat && text?.includes("HEARTBEAT_OK")) {
+                                const stripped = stripHeartbeatToken(text, {
+                                    mode: "message",
+                                });
+                                if (stripped.didStrip && !didLogHeartbeatStrip) {
+                                    didLogHeartbeatStrip = true;
+                                    logVerbose("Stripped stray HEARTBEAT_OK token from reply");
+                                }
+                                if (stripped.shouldSkip &&
+                                    (payload.mediaUrls?.length ?? 0) === 0) {
+                                    return;
+                                }
+                                text = stripped.text;
+                            }
+                            await typing.startTypingOnText(text);
+                            await opts.onToolResult?.({
+                                text,
+                                mediaUrls: payload.mediaUrls,
+                            });
+                        }
+                        : undefined,
+                }),
+            });
+            runResult = fallbackResult.result;
+            fallbackProvider = fallbackResult.provider;
+            fallbackModel = fallbackResult.model;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const isContextOverflow = /context.*overflow|too large|context window/i.test(message);
+            defaultRuntime.error(`Embedded agent failed before reply: ${message}`);
+            return finalizeWithFollowup({
+                text: isContextOverflow
+                    ? "⚠️ Context overflow - conversation too long. Starting fresh might help!"
+                    : `⚠️ Agent failed before reply: ${message}. Check gateway logs for details.`,
+            });
+        }
+        if (shouldInjectGroupIntro &&
+            sessionEntry &&
+            sessionStore &&
+            sessionKey &&
+            sessionEntry.groupActivationNeedsSystemIntro) {
+            sessionEntry.groupActivationNeedsSystemIntro = false;
+            sessionEntry.updatedAt = Date.now();
+            sessionStore[sessionKey] = sessionEntry;
+            if (storePath) {
+                await saveSessionStore(storePath, sessionStore);
+            }
+        }
+        const payloadArray = runResult.payloads ?? [];
+        if (payloadArray.length === 0)
+            return finalizeWithFollowup(undefined);
+        if (pendingBlockTasks.size > 0) {
+            await Promise.allSettled(pendingBlockTasks);
+        }
+        const sanitizedPayloads = opts?.isHeartbeat
+            ? payloadArray
+            : payloadArray.flatMap((payload) => {
+                const text = payload.text;
+                if (!text || !text.includes("HEARTBEAT_OK"))
+                    return [payload];
+                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 = sanitizedPayloads
+            .map((payload) => {
+            const { cleaned, replyToId } = extractReplyToTag(payload.text, sessionCtx.MessageSid);
+            return {
+                ...payload,
+                text: cleaned ? cleaned : undefined,
+                replyToId: replyToId ?? payload.replyToId,
+            };
+        })
+            .filter((payload) => payload.text ||
+            payload.mediaUrl ||
+            (payload.mediaUrls && payload.mediaUrls.length > 0));
+        const shouldDropFinalPayloads = blockStreamingEnabled && didStreamBlockReply;
+        const filteredPayloads = shouldDropFinalPayloads
+            ? []
+            : blockStreamingEnabled
+                ? replyTaggedPayloads.filter((payload) => !streamedPayloadKeys.has(buildPayloadKey(payload)))
+                : replyTaggedPayloads;
+        if (filteredPayloads.length === 0)
+            return finalizeWithFollowup(undefined);
+        const shouldSignalTyping = filteredPayloads.some((payload) => {
+            const trimmed = payload.text?.trim();
+            if (trimmed && trimmed !== SILENT_REPLY_TOKEN)
+                return true;
+            if (payload.mediaUrl)
+                return true;
+            if (payload.mediaUrls && payload.mediaUrls.length > 0)
+                return true;
+            return false;
+        });
+        if (shouldSignalTyping) {
+            await typing.startTypingLoop();
+        }
+        if (sessionStore && sessionKey) {
+            const usage = runResult.meta.agentMeta?.usage;
+            const modelUsed = runResult.meta.agentMeta?.model ?? fallbackModel ?? defaultModel;
+            const providerUsed = runResult.meta.agentMeta?.provider ??
+                fallbackProvider ??
+                followupRun.run.provider;
+            const contextTokensUsed = agentCfgContextTokens ??
+                lookupContextTokens(modelUsed) ??
+                sessionEntry?.contextTokens ??
+                DEFAULT_CONTEXT_TOKENS;
+            if (usage) {
+                const entry = sessionEntry ?? sessionStore[sessionKey];
+                if (entry) {
+                    const input = usage.input ?? 0;
+                    const output = usage.output ?? 0;
+                    const promptTokens = input + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
+                    const nextEntry = {
+                        ...entry,
+                        inputTokens: input,
+                        outputTokens: output,
+                        totalTokens: promptTokens > 0 ? promptTokens : (usage.total ?? input),
+                        modelProvider: providerUsed,
+                        model: modelUsed,
+                        contextTokens: contextTokensUsed ?? entry.contextTokens,
+                        updatedAt: Date.now(),
+                    };
+                    sessionStore[sessionKey] = nextEntry;
+                    if (storePath) {
+                        await saveSessionStore(storePath, sessionStore);
+                    }
+                }
+            }
+            else if (modelUsed || contextTokensUsed) {
+                const entry = sessionEntry ?? sessionStore[sessionKey];
+                if (entry) {
+                    sessionStore[sessionKey] = {
+                        ...entry,
+                        modelProvider: providerUsed ?? entry.modelProvider,
+                        model: modelUsed ?? entry.model,
+                        contextTokens: contextTokensUsed ?? entry.contextTokens,
+                    };
+                    if (storePath) {
+                        await saveSessionStore(storePath, sessionStore);
+                    }
+                }
+            }
+        }
+        // If verbose is enabled and this is a new session, prepend a session hint.
+        let finalPayloads = filteredPayloads;
+        if (resolvedVerboseLevel === "on" && isNewSession) {
+            finalPayloads = [
+                { text: `🧭 New session: ${followupRun.run.sessionId}` },
+                ...finalPayloads,
+            ];
+        }
+        return finalizeWithFollowup(finalPayloads.length === 1 ? finalPayloads[0] : finalPayloads);
+    }
+    finally {
+        typing.cleanup();
+    }
+}

package/dist/auto-reply/reply/block-streaming.js

@@ -0,0 +1,34 @@
+import { resolveTextChunkLimit } from "../chunk.js";
+const DEFAULT_BLOCK_STREAM_MIN = 800;
+const DEFAULT_BLOCK_STREAM_MAX = 1200;
+const BLOCK_CHUNK_SURFACES = new Set([
+    "whatsapp",
+    "telegram",
+    "discord",
+    "slack",
+    "signal",
+    "imessage",
+    "webchat",
+]);
+function normalizeChunkSurface(surface) {
+    if (!surface)
+        return undefined;
+    const cleaned = surface.trim().toLowerCase();
+    return BLOCK_CHUNK_SURFACES.has(cleaned)
+        ? cleaned
+        : undefined;
+}
+export function resolveBlockStreamingChunking(cfg, surface) {
+    const surfaceKey = normalizeChunkSurface(surface);
+    const textLimit = resolveTextChunkLimit(cfg, surfaceKey);
+    const chunkCfg = cfg?.agent?.blockStreamingChunk;
+    const maxRequested = Math.max(1, Math.floor(chunkCfg?.maxChars ?? DEFAULT_BLOCK_STREAM_MAX));
+    const maxChars = Math.max(1, Math.min(maxRequested, textLimit));
+    const minRequested = Math.max(1, Math.floor(chunkCfg?.minChars ?? DEFAULT_BLOCK_STREAM_MIN));
+    const minChars = Math.min(minRequested, maxChars);
+    const breakPreference = chunkCfg?.breakPreference === "newline" ||
+        chunkCfg?.breakPreference === "sentence"
+        ? chunkCfg.breakPreference
+        : "paragraph";
+    return { minChars, maxChars, breakPreference };
+}

package/dist/auto-reply/reply/body.js

@@ -0,0 +1,29 @@
+import { saveSessionStore } from "../../config/sessions.js";
+import { setAbortMemory } from "./abort.js";
+export async function applySessionHints(params) {
+    let prefixedBodyBase = params.baseBody;
+    const abortedHint = params.abortedLastRun
+        ? "Note: The previous agent run was aborted by the user. Resume carefully or ask for clarification."
+        : "";
+    if (abortedHint) {
+        prefixedBodyBase = `${abortedHint}\n\n${prefixedBodyBase}`;
+        if (params.sessionEntry && params.sessionStore && params.sessionKey) {
+            params.sessionEntry.abortedLastRun = false;
+            params.sessionEntry.updatedAt = Date.now();
+            params.sessionStore[params.sessionKey] = params.sessionEntry;
+            if (params.storePath) {
+                await saveSessionStore(params.storePath, params.sessionStore);
+            }
+        }
+        else if (params.abortKey) {
+            setAbortMemory(params.abortKey, false);
+        }
+    }
+    const messageIdHint = params.messageId?.trim()
+        ? `[message_id: ${params.messageId.trim()}]`
+        : "";
+    if (messageIdHint) {
+        prefixedBodyBase = `${prefixedBodyBase}\n${messageIdHint}`;
+    }
+    return prefixedBodyBase;
+}

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

@@ -0,0 +1,207 @@
+import { saveSessionStore, } from "../../config/sessions.js";
+import { logVerbose } from "../../globals.js";
+import { triggerClawdbotRestart } from "../../infra/restart.js";
+import { resolveSendPolicy } from "../../sessions/send-policy.js";
+import { normalizeE164 } from "../../utils.js";
+import { resolveHeartbeatSeconds } from "../../web/reconnect.js";
+import { getWebAuthAgeMs, webAuthExists } from "../../web/session.js";
+import { normalizeGroupActivation, parseActivationCommand, } from "../group-activation.js";
+import { parseSendPolicyCommand } from "../send-policy.js";
+import { buildStatusMessage } from "../status.js";
+import { isAbortTrigger, setAbortMemory } from "./abort.js";
+import { stripMentions } from "./mentions.js";
+export function buildCommandContext(params) {
+    const { ctx, cfg, sessionKey, isGroup, triggerBodyNormalized } = params;
+    const surface = (ctx.Surface ?? "").trim().toLowerCase();
+    const isWhatsAppSurface = surface === "whatsapp" ||
+        (ctx.From ?? "").startsWith("whatsapp:") ||
+        (ctx.To ?? "").startsWith("whatsapp:");
+    const configuredAllowFrom = isWhatsAppSurface
+        ? cfg.whatsapp?.allowFrom
+        : undefined;
+    const from = (ctx.From ?? "").replace(/^whatsapp:/, "");
+    const to = (ctx.To ?? "").replace(/^whatsapp:/, "");
+    const defaultAllowFrom = isWhatsAppSurface &&
+        (!configuredAllowFrom || configuredAllowFrom.length === 0) &&
+        to
+        ? [to]
+        : undefined;
+    const allowFrom = configuredAllowFrom && configuredAllowFrom.length > 0
+        ? configuredAllowFrom
+        : defaultAllowFrom;
+    const abortKey = sessionKey ?? (from || undefined) ?? (to || undefined);
+    const rawBodyNormalized = triggerBodyNormalized;
+    const commandBodyNormalized = isGroup
+        ? stripMentions(rawBodyNormalized, ctx, cfg)
+        : rawBodyNormalized;
+    const senderE164 = normalizeE164(ctx.SenderE164 ?? "");
+    const ownerCandidates = isWhatsAppSurface
+        ? (allowFrom ?? []).filter((entry) => entry && entry !== "*")
+        : [];
+    if (isWhatsAppSurface && ownerCandidates.length === 0 && to) {
+        ownerCandidates.push(to);
+    }
+    const ownerList = ownerCandidates
+        .map((entry) => normalizeE164(entry))
+        .filter((entry) => Boolean(entry));
+    const isOwnerSender = Boolean(senderE164) && ownerList.includes(senderE164 ?? "");
+    return {
+        surface,
+        isWhatsAppSurface,
+        ownerList,
+        isOwnerSender,
+        senderE164: senderE164 || undefined,
+        abortKey,
+        rawBodyNormalized,
+        commandBodyNormalized,
+        from: from || undefined,
+        to: to || undefined,
+    };
+}
+export async function handleCommands(params) {
+    const { cfg, command, sessionEntry, sessionStore, sessionKey, storePath, sessionScope, workspaceDir, defaultGroupActivation, resolvedThinkLevel, resolvedVerboseLevel, resolveDefaultThinkingLevel, model, contextTokens, isGroup, } = params;
+    const activationCommand = parseActivationCommand(command.commandBodyNormalized);
+    const sendPolicyCommand = parseSendPolicyCommand(command.commandBodyNormalized);
+    if (activationCommand.hasCommand) {
+        if (!isGroup) {
+            return {
+                shouldContinue: false,
+                reply: { text: "⚙️ Group activation only applies to group chats." },
+            };
+        }
+        if (!command.isOwnerSender) {
+            logVerbose(`Ignoring /activation from non-owner in group: ${command.senderE164 || "<unknown>"}`);
+            return { shouldContinue: false };
+        }
+        if (!activationCommand.mode) {
+            return {
+                shouldContinue: false,
+                reply: { text: "⚙️ Usage: /activation mention|always" },
+            };
+        }
+        if (sessionEntry && sessionStore && sessionKey) {
+            sessionEntry.groupActivation = activationCommand.mode;
+            sessionEntry.groupActivationNeedsSystemIntro = true;
+            sessionEntry.updatedAt = Date.now();
+            sessionStore[sessionKey] = sessionEntry;
+            if (storePath) {
+                await saveSessionStore(storePath, sessionStore);
+            }
+        }
+        return {
+            shouldContinue: false,
+            reply: { text: `⚙️ Group activation set to ${activationCommand.mode}.` },
+        };
+    }
+    if (sendPolicyCommand.hasCommand) {
+        if (!command.isOwnerSender) {
+            logVerbose(`Ignoring /send from non-owner: ${command.senderE164 || "<unknown>"}`);
+            return { shouldContinue: false };
+        }
+        if (!sendPolicyCommand.mode) {
+            return {
+                shouldContinue: false,
+                reply: { text: "⚙️ Usage: /send on|off|inherit" },
+            };
+        }
+        if (sessionEntry && sessionStore && sessionKey) {
+            if (sendPolicyCommand.mode === "inherit") {
+                delete sessionEntry.sendPolicy;
+            }
+            else {
+                sessionEntry.sendPolicy = sendPolicyCommand.mode;
+            }
+            sessionEntry.updatedAt = Date.now();
+            sessionStore[sessionKey] = sessionEntry;
+            if (storePath) {
+                await saveSessionStore(storePath, sessionStore);
+            }
+        }
+        const label = sendPolicyCommand.mode === "inherit"
+            ? "inherit"
+            : sendPolicyCommand.mode === "allow"
+                ? "on"
+                : "off";
+        return {
+            shouldContinue: false,
+            reply: { text: `⚙️ Send policy set to ${label}.` },
+        };
+    }
+    if (command.commandBodyNormalized === "/restart" ||
+        command.commandBodyNormalized === "restart" ||
+        command.commandBodyNormalized.startsWith("/restart ")) {
+        if (isGroup && !command.isOwnerSender) {
+            logVerbose(`Ignoring /restart from non-owner in group: ${command.senderE164 || "<unknown>"}`);
+            return { shouldContinue: false };
+        }
+        const restartMethod = triggerClawdbotRestart();
+        return {
+            shouldContinue: false,
+            reply: {
+                text: `⚙️ Restarting clawdbot via ${restartMethod}; give me a few seconds to come back online.`,
+            },
+        };
+    }
+    if (command.commandBodyNormalized === "/status" ||
+        command.commandBodyNormalized === "status" ||
+        command.commandBodyNormalized.startsWith("/status ")) {
+        if (isGroup && !command.isOwnerSender) {
+            logVerbose(`Ignoring /status from non-owner in group: ${command.senderE164 || "<unknown>"}`);
+            return { shouldContinue: false };
+        }
+        const webLinked = await webAuthExists();
+        const webAuthAgeMs = getWebAuthAgeMs();
+        const heartbeatSeconds = resolveHeartbeatSeconds(cfg, undefined);
+        const groupActivation = isGroup
+            ? (normalizeGroupActivation(sessionEntry?.groupActivation) ??
+                defaultGroupActivation())
+            : undefined;
+        const statusText = buildStatusMessage({
+            agent: {
+                model,
+                contextTokens,
+                thinkingDefault: cfg.agent?.thinkingDefault,
+                verboseDefault: cfg.agent?.verboseDefault,
+            },
+            workspaceDir,
+            sessionEntry,
+            sessionKey,
+            sessionScope,
+            storePath,
+            groupActivation,
+            resolvedThink: resolvedThinkLevel ?? (await resolveDefaultThinkingLevel()),
+            resolvedVerbose: resolvedVerboseLevel,
+            webLinked,
+            webAuthAgeMs,
+            heartbeatSeconds,
+        });
+        return { shouldContinue: false, reply: { text: statusText } };
+    }
+    const abortRequested = isAbortTrigger(command.rawBodyNormalized);
+    if (abortRequested) {
+        if (sessionEntry && sessionStore && sessionKey) {
+            sessionEntry.abortedLastRun = true;
+            sessionEntry.updatedAt = Date.now();
+            sessionStore[sessionKey] = sessionEntry;
+            if (storePath) {
+                await saveSessionStore(storePath, sessionStore);
+            }
+        }
+        else if (command.abortKey) {
+            setAbortMemory(command.abortKey, true);
+        }
+        return { shouldContinue: false, reply: { text: "⚙️ Agent was aborted." } };
+    }
+    const sendPolicy = resolveSendPolicy({
+        cfg,
+        entry: sessionEntry,
+        sessionKey,
+        surface: sessionEntry?.surface ?? command.surface,
+        chatType: sessionEntry?.chatType,
+    });
+    if (sendPolicy === "deny") {
+        logVerbose(`Send blocked by policy for session ${sessionKey ?? "unknown"}`);
+        return { shouldContinue: false };
+    }
+    return { shouldContinue: true };
+}