@tloncorp/openclaw 0.1.0 → 0.2.0

package/dist/src/monitor/index.js

@@ -1,5 +1,6 @@
 import { format } from "node:util";
 import { getTlonRuntime } from "../runtime.js";
+import { setSessionRole } from "../session-roles.js";
 import { createSettingsManager } from "../settings.js";
 import { normalizeShip, parseChannelNest } from "../targets.js";
 import { resolveTlonAccount } from "../types.js";
@@ -9,12 +10,22 @@ import { configureTlonApiWithPoke } from "../urbit/api-client.js";
 import { sendDm, sendChannelPost } from "../urbit/send.js";
 import { markdownToStory } from "../urbit/story.js";
 import { UrbitSSEClient } from "../urbit/sse-client.js";
-import { createPendingApproval, formatApprovalRequest, formatApprovalConfirmation, parseApprovalResponse, isApprovalResponse, findPendingApproval, removePendingApproval, parseAdminCommand, isAdminCommand, formatBlockedList, formatPendingList, } from "./approval.js";
+import { createPendingApproval, formatApprovalRequest, formatApprovalConfirmation, findPendingApproval, removePendingApproval, pruneExpired, formatBlockedList, formatPendingList, isExpired, emojiToApprovalAction, normalizeNotificationId, } from "./approval.js";
+import { setBridge, removeBridge } from "./command-bridge.js";
 import { fetchAllChannels, fetchInitData } from "./discovery.js";
 import { cacheMessage, lookupCachedMessage, getChannelHistory, fetchThreadHistory } from "./history.js";
 import { downloadMessageImages } from "./media.js";
 import { createProcessedMessageTracker } from "./processed-messages.js";
-import { extractMessageText, extractCites, formatModelName, isBotMentioned, stripBotMention, isDmAllowed, isSummarizationRequest, } from "./utils.js";
+import { extractMessageText, extractCites, formatModelName, isBotMentioned, stripBotMention, isDmAllowed, isSummarizationRequest, sanitizeMessageText, } from "./utils.js";
+/**
+ * Extract ship from author field, handling both string (ship) and object (bot-meta) formats.
+ */
+function extractAuthorShip(author) {
+    if (typeof author === "object" && author !== null && "ship" in author) {
+        return author.ship;
+    }
+    return typeof author === "string" ? author : "";
+}
 /**
  * Resolve channel authorization by merging file config with settings store.
  * Settings store takes precedence for fields it defines.
@@ -116,6 +127,11 @@ export async function monitorTlonProvider(opts = {}) {
     let groupChannels = [];
     const channelToGroup = new Map();
     let botNickname = null;
+    let botAvatar = null;
+    // Helper to get bot profile for outbound messages
+    const getBotProfile = () => botNickname || botAvatar
+        ? { nickname: botNickname || "", avatar: botAvatar || "" }
+        : undefined;
     // Settings store manager for hot-reloading config
     const settingsManager = createSettingsManager(api, {
         log: (msg) => runtime.log?.(msg),
@@ -135,6 +151,12 @@ export async function monitorTlonProvider(opts = {}) {
     let currentSettings = {};
     // Track threads we've participated in (by parentId) - respond without mention requirement
     const participatedThreads = new Set();
+    // Track consecutive bot responses per channel/DM for rate limiting
+    // Key: channel nest or dm partner ship, Value: count of consecutive bot messages
+    const consecutiveBotMessages = new Map();
+    // Known bot ships (ships that have sent messages with BotProfile author)
+    const knownBotShips = new Set();
+    const maxBotResponses = account.maxConsecutiveBotResponses ?? 3;
     // Track DM senders per session to detect shared sessions (security warning)
     const dmSendersBySession = new Map();
     let sharedSessionWarningSent = false;
@@ -160,9 +182,10 @@ export async function monitorTlonProvider(opts = {}) {
         if (selfProfile && typeof selfProfile === "object") {
             const profile = selfProfile;
             botNickname = profile.nickname?.value || null;
+            botAvatar = profile.avatar?.value || null;
             if (botNickname) {
                 runtime.log?.(`[tlon] Bot nickname: ${botNickname}`);
-                nicknameCache.set(botShipName, botNickname);
+                nicknameCache.set(botShipName, sanitizeNickname(botNickname));
             }
         }
     }
@@ -176,7 +199,7 @@ export async function monitorTlonProvider(opts = {}) {
             for (const [ship, contact] of Object.entries(allContacts)) {
                 const nickname = contact?.nickname?.value ?? contact?.nickname;
                 if (nickname && typeof nickname === "string") {
-                    nicknameCache.set(normalizeShip(ship), nickname);
+                    nicknameCache.set(normalizeShip(ship), sanitizeNickname(nickname));
                 }
             }
             runtime.log?.(`[tlon] Loaded ${nicknameCache.size} contact nickname(s)`);
@@ -187,6 +210,22 @@ export async function monitorTlonProvider(opts = {}) {
     }
     // Store init foreigns for processing after settings are loaded
     let initForeigns = null;
+    // Group name cache for human-readable display (flag -> title)
+    const groupNameCache = new Map();
+    // Build display context for approval formatting
+    function buildDisplayContext() {
+        const channelNames = new Map();
+        for (const nest of watchedChannels) {
+            const parsed = parseChannelNest(nest);
+            if (parsed) {
+                channelNames.set(nest, parsed.channelName);
+            }
+        }
+        return {
+            channelNames,
+            groupNames: groupNameCache,
+        };
+    }
     // Migrate file config to settings store (seed on first run)
     async function migrateConfigToSettings() {
         const migrations = [
@@ -230,12 +269,17 @@ export async function monitorTlonProvider(opts = {}) {
                 fileValue: account.showModelSignature,
                 settingsValue: currentSettings.showModelSig,
             },
+            {
+                key: "ownerShip",
+                fileValue: account.ownerShip,
+                settingsValue: currentSettings.ownerShip,
+            },
         ];
         for (const { key, fileValue, settingsValue } of migrations) {
             // Only migrate if file has a value and settings store doesn't
             const hasFileValue = Array.isArray(fileValue) ? fileValue.length > 0 : fileValue != null;
             const hasSettingsValue = Array.isArray(settingsValue)
-                ? settingsValue.length > 0
+                ? true // empty array = intentionally set in settings store
                 : settingsValue != null;
             if (hasFileValue && !hasSettingsValue) {
                 try {
@@ -273,9 +317,9 @@ export async function monitorTlonProvider(opts = {}) {
             effectiveAutoDiscoverChannels = currentSettings.autoDiscoverChannels;
             runtime.log?.(`[tlon] Using autoDiscoverChannels from settings store: ${effectiveAutoDiscoverChannels}`);
         }
-        if (currentSettings.dmAllowlist?.length) {
+        if (currentSettings.dmAllowlist !== undefined) {
             effectiveDmAllowlist = currentSettings.dmAllowlist;
-            runtime.log?.(`[tlon] Using dmAllowlist from settings store: ${effectiveDmAllowlist.join(", ")}`);
+            runtime.log?.(`[tlon] Using dmAllowlist from settings store: ${effectiveDmAllowlist.length > 0 ? effectiveDmAllowlist.join(", ") : "(empty)"}`);
         }
         if (currentSettings.showModelSig !== undefined) {
             effectiveShowModelSig = currentSettings.showModelSig;
@@ -315,6 +359,10 @@ export async function monitorTlonProvider(opts = {}) {
             for (const [nest, groupFlag] of initData.channelToGroup) {
                 channelToGroup.set(nest, groupFlag);
             }
+            // Populate group name cache for human-readable display
+            for (const [flag, title] of initData.groupNames) {
+                groupNameCache.set(flag, title);
+            }
             initForeigns = initData.foreigns;
         }
         catch (error) {
@@ -427,6 +475,33 @@ export async function monitorTlonProvider(opts = {}) {
             runtime.error?.(`[tlon] Failed to update dmAllowlist: ${String(err)}`);
         }
     }
+    // Helper to remove ship from dmAllowlist in both memory and settings store
+    async function removeFromDmAllowlist(ship) {
+        const normalizedShip = normalizeShip(ship);
+        const before = effectiveDmAllowlist.length;
+        effectiveDmAllowlist = effectiveDmAllowlist.filter((s) => s !== normalizedShip);
+        if (effectiveDmAllowlist.length === before) {
+            return; // Ship wasn't on the list
+        }
+        try {
+            await api.poke({
+                app: "settings",
+                mark: "settings-event",
+                json: {
+                    "put-entry": {
+                        desk: "moltbot",
+                        "bucket-key": "tlon",
+                        "entry-key": "dmAllowlist",
+                        value: effectiveDmAllowlist,
+                    },
+                },
+            });
+            runtime.log?.(`[tlon] Removed ${normalizedShip} from dmAllowlist`);
+        }
+        catch (err) {
+            runtime.error?.(`[tlon] Failed to update dmAllowlist: ${String(err)}`);
+        }
+    }
     // Helper to update channelRules in settings store
     async function addToChannelAllowlist(ship, channelNest) {
         const normalizedShip = normalizeShip(ship);
@@ -476,12 +551,26 @@ export async function monitorTlonProvider(opts = {}) {
             runtime.error?.(`[tlon] Failed to block ship ${normalizedShip}: ${String(err)}`);
         }
     }
+    /**
+     * Scry the chat agent's blocked ship list with an explicit timeout.
+     * The urbitFetch timeout (30s) may not fire if the underlying connection
+     * stalls (e.g. after a chat-block-ship poke causes the agent to restart).
+     * This wrapper guarantees resolution within SCRY_TIMEOUT_MS.
+     */
+    const SCRY_TIMEOUT_MS = 15_000;
+    async function scryBlockedShips() {
+        const blocked = await Promise.race([
+            api.scry("/chat/blocked.json"),
+            new Promise((_, reject) => setTimeout(() => reject(new Error("blocked list scry timeout")), SCRY_TIMEOUT_MS)),
+        ]);
+        return Array.isArray(blocked) ? blocked : [];
+    }
     // Check if a ship is blocked using Tlon's native block list
     async function isShipBlocked(ship) {
         const normalizedShip = normalizeShip(ship);
         try {
-            const blocked = (await api.scry("/chat/blocked.json"));
-            return Array.isArray(blocked) && blocked.some((s) => normalizeShip(s) === normalizedShip);
+            const blocked = await scryBlockedShips();
+            return blocked.some((s) => normalizeShip(s) === normalizedShip);
         }
         catch (err) {
             runtime.log?.(`[tlon] Failed to check blocked list: ${String(err)}`);
@@ -491,8 +580,7 @@ export async function monitorTlonProvider(opts = {}) {
     // Get all blocked ships
     async function getBlockedShips() {
         try {
-            const blocked = (await api.scry("/chat/blocked.json"));
-            return Array.isArray(blocked) ? blocked : [];
+            return await scryBlockedShips();
         }
         catch (err) {
             runtime.log?.(`[tlon] Failed to get blocked list: ${String(err)}`);
@@ -516,24 +604,65 @@ export async function monitorTlonProvider(opts = {}) {
             return false;
         }
     }
-    // Helper to send DM notification to owner
+    // Helper to send DM notification to owner. Returns the message ID if sent successfully.
     async function sendOwnerNotification(message) {
         if (!effectiveOwnerShip) {
             runtime.log?.("[tlon] No ownerShip configured, cannot send notification");
-            return;
+            return undefined;
         }
         try {
-            await sendDm({
+            const result = await sendDm({
+                botProfile: getBotProfile(),
                 fromShip: botShipName,
                 toShip: effectiveOwnerShip,
                 text: message,
             });
             runtime.log?.(`[tlon] Sent notification to owner ${effectiveOwnerShip}`);
+            return result.messageId;
         }
         catch (err) {
             runtime.error?.(`[tlon] Failed to send notification to owner: ${String(err)}`);
+            return undefined;
         }
     }
+    // Regex to match block directives in agent responses
+    // Format: [BLOCK_USER: ~ship-name | reason for blocking]
+    const blockDirectiveRegex = /\[BLOCK_USER:\s*(~[\w-]+)\s*\|\s*(.+?)\]/g;
+    // Process block directives from agent response and return text with directives stripped
+    async function processBlockDirectives(text, senderShip) {
+        const matches = [...text.matchAll(blockDirectiveRegex)];
+        if (matches.length > 0) {
+            runtime.log?.(`[tlon] Found ${matches.length} block directive(s) in response`);
+            runtime.log?.(`[tlon] Sender ship: "${senderShip}" -> normalized: "${normalizeShip(senderShip)}"`);
+            runtime.log?.(`[tlon] Owner ship: "${effectiveOwnerShip}"`);
+        }
+        for (const match of matches) {
+            const targetShip = normalizeShip(match[1]);
+            const reason = match[2].trim();
+            runtime.log?.(`[tlon] Processing block directive: target="${targetShip}", reason="${reason}"`);
+            // Safety: Never block the owner
+            if (effectiveOwnerShip && targetShip === effectiveOwnerShip) {
+                runtime.log?.(`[tlon] Agent attempted to block owner ship ${targetShip} - ignoring`);
+                continue;
+            }
+            // Only allow blocking the current message sender (not arbitrary third parties)
+            const normalizedSender = normalizeShip(senderShip);
+            if (targetShip !== normalizedSender) {
+                runtime.log?.(`[tlon] Agent tried to block "${targetShip}" but sender is "${normalizedSender}" - ignoring`);
+                continue;
+            }
+            // Block the abusive sender
+            runtime.log?.(`[tlon] Executing block for ${targetShip}...`);
+            await blockShip(targetShip);
+            // Notify owner
+            if (effectiveOwnerShip) {
+                await sendOwnerNotification(`[Agent Action] Blocked ${targetShip}\nReason: ${reason}`);
+            }
+            runtime.log?.(`[tlon] Agent blocked ${targetShip}: ${reason}`);
+        }
+        // Strip directives from visible response
+        return text.replace(blockDirectiveRegex, "").trim();
+    }
     // Queue a new approval request and notify the owner
     async function queueApprovalRequest(approval) {
         // Check if ship is blocked - silently ignore
@@ -554,33 +683,36 @@ export async function monitorTlonProvider(opts = {}) {
                 existing.messagePreview = approval.messagePreview;
             }
             runtime.log?.(`[tlon] Updated existing approval for ${approval.requestingShip} (${approval.type}) - re-sending notification`);
+            // Send notification first, then save once with the notification ID.
+            // Saving before sendOwnerNotification causes a race: the settings subscription
+            // event replaces pendingApprovals in-memory, so the notificationMessageId
+            // set on the old object reference is lost.
+            const existMsg = formatApprovalRequest(existing, buildDisplayContext());
+            const existNotifId = await sendOwnerNotification(existMsg);
+            if (existNotifId) {
+                existing.notificationMessageId = normalizeNotificationId(existNotifId);
+            }
             await savePendingApprovals();
-            const message = formatApprovalRequest(existing);
-            await sendOwnerNotification(message);
             return;
         }
+        // Send notification before saving so notificationMessageId is included
+        // in the single save. See comment above about the settings subscription race.
+        const message = formatApprovalRequest(approval, buildDisplayContext());
+        const notifId = await sendOwnerNotification(message);
+        if (notifId) {
+            approval.notificationMessageId = normalizeNotificationId(notifId);
+        }
         pendingApprovals.push(approval);
         await savePendingApprovals();
-        const message = formatApprovalRequest(approval);
-        await sendOwnerNotification(message);
         runtime.log?.(`[tlon] Queued approval request: ${approval.id} (${approval.type} from ${approval.requestingShip})`);
     }
-    // Process the owner's approval response
-    async function handleApprovalResponse(text) {
-        const parsed = parseApprovalResponse(text);
-        if (!parsed) {
-            return false;
-        }
-        const approval = findPendingApproval(pendingApprovals, parsed.id);
-        if (!approval) {
-            await sendOwnerNotification("No pending approval found" + (parsed.id ? ` for ID: ${parsed.id}` : ""));
-            return true; // Still consumed the message
-        }
-        if (parsed.action === "approve") {
+    // ── Approval action execution ─────────────────────────────────────
+    // Shared by the slash command bridge and the reaction-based approval handler.
+    async function executeApprovalAction(approval, action) {
+        if (action === "approve") {
             switch (approval.type) {
                 case "dm":
                     await addToDmAllowlist(approval.requestingShip);
-                    // Process the original message if available
                     if (approval.originalMessage) {
                         runtime.log?.(`[tlon] Processing original message from ${approval.requestingShip} after approval`);
                         await processMessage({
@@ -596,9 +728,8 @@ export async function monitorTlonProvider(opts = {}) {
                 case "channel":
                     if (approval.channelNest) {
                         await addToChannelAllowlist(approval.requestingShip, approval.channelNest);
-                        // Process the original message if available
                         if (approval.originalMessage) {
-                            const parsed = parseChannelNest(approval.channelNest);
+                            const nest = parseChannelNest(approval.channelNest);
                             runtime.log?.(`[tlon] Processing original message from ${approval.requestingShip} in ${approval.channelNest} after approval`);
                             await processMessage({
                                 messageId: approval.originalMessage.messageId,
@@ -607,8 +738,8 @@ export async function monitorTlonProvider(opts = {}) {
                                 messageContent: approval.originalMessage.messageContent,
                                 isGroup: true,
                                 channelNest: approval.channelNest,
-                                hostShip: parsed?.hostShip,
-                                channelName: parsed?.channelName,
+                                hostShip: nest?.hostShip,
+                                channelName: nest?.channelName,
                                 timestamp: approval.originalMessage.timestamp,
                                 parentId: approval.originalMessage.parentId,
                                 isThreadReply: approval.originalMessage.isThreadReply,
@@ -617,7 +748,6 @@ export async function monitorTlonProvider(opts = {}) {
                     }
                     break;
                 case "group":
-                    // Accept the group invite (don't add to allowlist - each invite requires approval)
                     if (approval.groupFlag) {
                         try {
                             await api.poke({
@@ -629,8 +759,6 @@ export async function monitorTlonProvider(opts = {}) {
                                 },
                             });
                             runtime.log?.(`[tlon] Joined group ${approval.groupFlag} after approval`);
-                            // Immediately discover channels from the newly joined group
-                            // Small delay to allow the join to propagate
                             setTimeout(async () => {
                                 try {
                                     const discoveredChannels = await fetchAllChannels(api, runtime);
@@ -656,58 +784,52 @@ export async function monitorTlonProvider(opts = {}) {
                     }
                     break;
             }
-            await sendOwnerNotification(formatApprovalConfirmation(approval, "approve"));
         }
-        else if (parsed.action === "block") {
-            // Block the ship using Tlon's native blocking
+        else if (action === "block") {
             await blockShip(approval.requestingShip);
-            await sendOwnerNotification(formatApprovalConfirmation(approval, "block"));
+            await removeFromDmAllowlist(approval.requestingShip);
         }
-        else {
-            // Denied - just remove from pending, no notification to requester
-            await sendOwnerNotification(formatApprovalConfirmation(approval, "deny"));
-        }
-        // Remove from pending
+        // "deny" — no side effects beyond removing from pending
         pendingApprovals = removePendingApproval(pendingApprovals, approval.id);
         await savePendingApprovals();
-        return true;
+        return formatApprovalConfirmation(approval, action, buildDisplayContext());
     }
-    // Handle admin commands from owner (unblock, blocked, pending)
-    async function handleAdminCommand(text) {
-        const command = parseAdminCommand(text);
-        if (!command) {
-            return false;
-        }
-        switch (command.type) {
-            case "blocked": {
-                const blockedShips = await getBlockedShips();
-                await sendOwnerNotification(formatBlockedList(blockedShips));
-                runtime.log?.(`[tlon] Owner requested blocked ships list (${blockedShips.length} ships)`);
-                return true;
-            }
-            case "pending": {
-                await sendOwnerNotification(formatPendingList(pendingApprovals));
-                runtime.log?.(`[tlon] Owner requested pending approvals list (${pendingApprovals.length} pending)`);
-                return true;
-            }
-            case "unblock": {
-                const shipToUnblock = command.ship;
-                const isBlocked = await isShipBlocked(shipToUnblock);
-                if (!isBlocked) {
-                    await sendOwnerNotification(`${shipToUnblock} is not blocked.`);
-                    return true;
-                }
-                const success = await unblockShip(shipToUnblock);
-                if (success) {
-                    await sendOwnerNotification(`Unblocked ${shipToUnblock}.`);
-                }
-                else {
-                    await sendOwnerNotification(`Failed to unblock ${shipToUnblock}.`);
-                }
-                return true;
+    // ── Command bridge ──────────────────────────────────────────────────
+    // Exposes approval/admin actions to slash commands registered in index.ts.
+    // Handlers return response text; the slash command framework sends it back.
+    const accountKey = opts.accountId ?? undefined;
+    const commandBridge = {
+        get ownerShip() {
+            return effectiveOwnerShip;
+        },
+        async handleAction(action, id) {
+            // Prune expired approvals
+            pendingApprovals = pruneExpired(pendingApprovals);
+            await savePendingApprovals();
+            const approval = findPendingApproval(pendingApprovals, id);
+            if (!approval) {
+                return "No pending approval found" + (id ? ` for ID: #${id}` : ".");
             }
-        }
-    }
+            return executeApprovalAction(approval, action);
+        },
+        async getPendingList() {
+            return formatPendingList(pendingApprovals, buildDisplayContext());
+        },
+        async getBlockedList() {
+            const blockedShips = await getBlockedShips();
+            return formatBlockedList(blockedShips);
+        },
+        async handleUnblock(ship) {
+            runtime.log?.(`[tlon] handleUnblock: checking if ${ship} is blocked...`);
+            const blocked = await isShipBlocked(ship);
+            if (!blocked) {
+                return `${ship} is not blocked.`;
+            }
+            const success = await unblockShip(ship);
+            return success ? `Unblocked ${ship}.` : `Failed to unblock ${ship}.`;
+        },
+    };
+    setBridge(accountKey, commandBridge);
     // Check if a ship is the owner (always allowed to DM)
     function isOwner(ship) {
         if (!effectiveOwnerShip) {
@@ -731,14 +853,14 @@ export async function monitorTlonProvider(opts = {}) {
         return /^~?[a-z-]+$/i.test(normalized) ? normalized : "";
     }
     const processMessage = async (params) => {
-        const { messageId, senderShip, isGroup, channelNest, hostShip, channelName, timestamp, parentId, isThreadReply, messageContent, } = params;
+        const { messageId, senderShip, isGroup, channelNest, hostShip: _hostShip, channelName: _channelName, timestamp, parentId, isThreadReply, messageContent, } = params;
         // replyParentId overrides parentId for the deliver callback (thread reply routing)
         // but doesn't affect the ctx payload (MessageThreadId/ReplyToId).
         // Used for reactions: agent sees no thread context (so it responds), but
         // the reply is still delivered as a thread reply.
         const deliverParentId = params.replyParentId ?? parentId;
         const groupChannel = channelNest; // For compatibility
-        let messageText = params.messageText;
+        let messageText = sanitizeMessageText(params.messageText);
         const rawMessageText = messageText; // Preserve original before any modifications
         // Strip bot mention EARLY, before thread context is prepended.
         // This ensures [Current message] in thread context won't contain the bot ship name,
@@ -803,7 +925,7 @@ export async function monitorTlonProvider(opts = {}) {
                 if (threadHistory.length > 0) {
                     const threadContext = threadHistory
                         .slice(-10) // Last 10 messages for context
-                        .map((msg) => `${msg.author}: ${msg.content}`)
+                        .map((msg) => `${msg.author}: ${sanitizeMessageText(msg.content)}`)
                         .join("\n");
                     // Prepend thread context to the message
                     // Include note about ongoing conversation for agent judgment
@@ -824,6 +946,7 @@ export async function monitorTlonProvider(opts = {}) {
                     const noHistoryMsg = "I couldn't fetch any messages for this channel. It might be empty or there might be a permissions issue.";
                     if (isGroup && groupChannel) {
                         await sendChannelPost({
+                            botProfile: getBotProfile(),
                             fromShip: botShipName,
                             nest: groupChannel,
                             story: markdownToStory(noHistoryMsg),
@@ -831,6 +954,7 @@ export async function monitorTlonProvider(opts = {}) {
                     }
                     else {
                         await sendDm({
+                            botProfile: getBotProfile(),
                             fromShip: botShipName,
                             toShip: senderShip,
                             text: noHistoryMsg,
@@ -839,7 +963,7 @@ export async function monitorTlonProvider(opts = {}) {
                     return;
                 }
                 const historyText = history
-                    .map((msg) => `[${new Date(msg.timestamp).toLocaleString()}] ${msg.author}: ${msg.content}`)
+                    .map((msg) => `[${new Date(msg.timestamp).toLocaleString()}] ${msg.author}: ${sanitizeMessageText(msg.content)}`)
                     .join("\n");
                 messageText =
                     `Please summarize this channel conversation (${history.length} recent messages):\n\n${historyText}\n\n` +
@@ -853,13 +977,14 @@ export async function monitorTlonProvider(opts = {}) {
                 const errorMsg = `Sorry, I encountered an error while fetching the channel history: ${error?.message ?? String(error)}`;
                 if (isGroup && groupChannel) {
                     await sendChannelPost({
+                        botProfile: getBotProfile(),
                         fromShip: botShipName,
                         nest: groupChannel,
                         story: markdownToStory(errorMsg),
                     });
                 }
                 else {
-                    await sendDm({ fromShip: botShipName, toShip: senderShip, text: errorMsg });
+                    await sendDm({ botProfile: getBotProfile(), fromShip: botShipName, toShip: senderShip, text: errorMsg });
                 }
                 return;
             }
@@ -894,6 +1019,7 @@ export async function monitorTlonProvider(opts = {}) {
                         `Docs: https://docs.openclaw.ai/concepts/session#secure-dm-mode`;
                     // Send async, don't block message processing
                     sendDm({
+                        botProfile: getBotProfile(),
                         fromShip: botShipName,
                         toShip: effectiveOwnerShip,
                         text: warningMsg,
@@ -903,6 +1029,9 @@ export async function monitorTlonProvider(opts = {}) {
             senders.add(senderShip);
         }
         const senderRole = isOwner(senderShip) ? "owner" : "user";
+        // Store role for before_tool_call hook (tool access control)
+        setSessionRole(route.sessionKey, senderRole);
+        runtime.log?.(`[tlon] Stored session role: sessionKey=${route.sessionKey}, role=${senderRole}`);
         const senderDisplay = formatShipWithNickname(senderShip);
         const fromLabel = isGroup
             ? `${senderDisplay} [${senderRole}] in ${channelNest}`
@@ -969,7 +1098,7 @@ export async function monitorTlonProvider(opts = {}) {
             // Include downloaded media attachments
             ...(attachments.length > 0 && { Attachments: attachments }),
             OriginatingChannel: "tlon",
-            OriginatingTo: `tlon:${isGroup ? groupChannel : botShipName}`,
+            OriginatingTo: `tlon:${isGroup ? groupChannel : senderShip}`,
             // Include thread context for automatic reply routing
             ...(parentId && { MessageThreadId: String(parentId), ReplyToId: String(parentId) }),
         });
@@ -987,18 +1116,33 @@ export async function monitorTlonProvider(opts = {}) {
                     if (!replyText) {
                         return;
                     }
+                    // Process any block directives in the response (strips them from text)
+                    replyText = await processBlockDirectives(replyText, senderShip);
+                    if (!replyText) {
+                        return;
+                    } // Response was only a directive
                     // Use settings store value if set, otherwise fall back to file config
                     const showSignature = effectiveShowModelSig;
                     if (showSignature) {
+                        const modelCfg = cfg.agents?.defaults?.model;
                         const modelInfo = payload.metadata?.model ||
                             payload.model ||
                             route.model ||
-                            cfg.agents?.defaults?.model?.primary;
+                            (typeof modelCfg === "string" ? modelCfg : modelCfg?.primary);
                         replyText = `${replyText}\n\n_[Generated by ${formatModelName(modelInfo)}]_`;
                     }
+                    // Add addendum if this is the last response before bot rate limit
+                    if (isGroup && groupChannel && knownBotShips.has(senderShip)) {
+                        const count = consecutiveBotMessages.get(groupChannel) ?? 0;
+                        if (maxBotResponses > 0 && count === maxBotResponses) {
+                            const otherBot = formatShipWithNickname(senderShip);
+                            replyText += `\n\n---\n_This is my last response to ${otherBot} for now. To continue our conversation, someone will need to mention me._`;
+                        }
+                    }
                     if (isGroup && groupChannel) {
                         // Send to any channel type (chat, heap, diary) using the nest directly
                         await sendChannelPost({
+                            botProfile: getBotProfile(),
                             fromShip: botShipName,
                             nest: groupChannel,
                             story: markdownToStory(replyText),
@@ -1011,7 +1155,13 @@ export async function monitorTlonProvider(opts = {}) {
                         }
                     }
                     else {
-                        await sendDm({ fromShip: botShipName, toShip: senderShip, text: replyText, replyToId: deliverParentId ? String(deliverParentId) : undefined });
+                        await sendDm({
+                            botProfile: getBotProfile(),
+                            fromShip: botShipName,
+                            toShip: senderShip,
+                            text: replyText,
+                            replyToId: deliverParentId ? String(deliverParentId) : undefined,
+                        });
                     }
                 },
                 onError: (err, info) => {
@@ -1117,16 +1267,16 @@ export async function monitorTlonProvider(opts = {}) {
             // Handle post responses (new posts and replies)
             const essay = response?.post?.["r-post"]?.set?.essay;
             const memo = response?.post?.["r-post"]?.reply?.["r-reply"]?.set?.memo;
-            if (!essay && !memo) {
+            const content = memo || essay;
+            if (!content) {
                 return;
             }
-            const content = memo || essay;
             const isThreadReply = Boolean(memo);
             const messageId = isThreadReply ? response?.post?.["r-post"]?.reply?.id : response?.post?.id;
             if (!processedTracker.mark(messageId)) {
                 return;
             }
-            const senderShip = normalizeShip(content?.author ?? "");
+            const senderShip = normalizeShip(extractAuthorShip(content?.author));
             if (!senderShip) {
                 return;
             }
@@ -1144,10 +1294,18 @@ export async function monitorTlonProvider(opts = {}) {
                 timestamp: content.sent || Date.now(),
                 id: messageId,
             });
+            // Check if sender is a bot (BotProfile object has ship, nickname, avatar)
+            const authorRaw = content?.author;
+            const isSenderBot = typeof authorRaw === 'object' && authorRaw !== null && 'ship' in authorRaw;
+            if (isSenderBot) {
+                knownBotShips.add(senderShip);
+            }
             // Skip processing bot's own messages (but they're already cached above)
             if (senderShip === botShipName) {
                 return;
             }
+            // Check if sender is a known bot (for rate limiting later)
+            const isKnownBot = isSenderBot || knownBotShips.has(senderShip);
             // Get thread info early for participation check
             const seal = isThreadReply
                 ? response?.post?.["r-post"]?.reply?.["r-reply"]?.set?.seal
@@ -1165,6 +1323,22 @@ export async function monitorTlonProvider(opts = {}) {
             if (inParticipatedThread && !mentioned) {
                 runtime.log?.(`[tlon] Responding to thread we participated in (no mention): ${parentId}`);
             }
+            // Rate limit consecutive bot responses (only in group channels)
+            if (isKnownBot) {
+                const count = (consecutiveBotMessages.get(nest) ?? 0) + 1;
+                consecutiveBotMessages.set(nest, count);
+                runtime.log?.(`[tlon] Bot mention from ${senderShip} in ${nest}: consecutive count = ${count}`);
+                if (maxBotResponses > 0 && count > maxBotResponses) {
+                    runtime.log?.(`[tlon] Rate limiting: skipping response to bot ${senderShip} (count ${count} > limit ${maxBotResponses})`);
+                    return;
+                }
+            }
+            else {
+                // Human mention resets the consecutive bot counter
+                // (requires explicit engagement, not just any human message)
+                consecutiveBotMessages.set(nest, 0);
+                runtime.log?.(`[tlon] Human mention from ${senderShip} in ${nest}: reset bot counter`);
+            }
             // Owner is always allowed
             if (isOwner(senderShip)) {
                 runtime.log?.(`[tlon] Owner ${senderShip} is always allowed in channels`);
@@ -1189,7 +1363,7 @@ export async function monitorTlonProvider(opts = {}) {
                                     parentId: parentId ?? undefined,
                                     isThreadReply,
                                 },
-                            });
+                            }, pendingApprovals.map((a) => a.id));
                             await queueApprovalRequest(approval);
                         }
                         else {
@@ -1268,7 +1442,7 @@ export async function monitorTlonProvider(opts = {}) {
                             type: "dm",
                             requestingShip: ship,
                             messagePreview: "(DM invite - no message yet)",
-                        });
+                        }, pendingApprovals.map((a) => a.id));
                         await queueApprovalRequest(approval);
                         processedDmInvites.add(ship); // Mark as processed to avoid duplicate notifications
                     }
@@ -1290,9 +1464,34 @@ export async function monitorTlonProvider(opts = {}) {
             if (dmAddReact || dmDelReact) {
                 const isAdd = Boolean(dmAddReact);
                 const reactData = dmAddReact || dmDelReact;
-                const reactAuthor = normalizeShip(reactData?.author ?? reactData?.ship ?? "");
-                const reactEmoji = reactData?.react ?? "";
+                const reactAuthor = normalizeShip(extractAuthorShip(reactData?.author) || reactData?.ship || "");
+                const reactEmoji = dmAddReact?.react ?? "";
                 if (reactAuthor && reactAuthor !== botShipName) {
+                    // Check if this is an approval reaction from the owner on a notification message
+                    if (isAdd && isOwner(reactAuthor)) {
+                        const approvalAction = emojiToApprovalAction(reactEmoji);
+                        if (approvalAction) {
+                            const normalizedEventId = normalizeNotificationId(messageId);
+                            const matchedApproval = pendingApprovals.find((a) => a.notificationMessageId === normalizedEventId);
+                            if (matchedApproval) {
+                                if (isExpired(matchedApproval)) {
+                                    runtime.log?.(`[tlon] Ignoring reaction on expired approval #${matchedApproval.id}`);
+                                    // Fall through to normal reaction handling
+                                }
+                                else {
+                                    runtime.log?.(`[tlon] Reaction-based approval: ${reactEmoji} → ${approvalAction} for #${matchedApproval.id}`);
+                                    try {
+                                        const confirmText = await executeApprovalAction(matchedApproval, approvalAction);
+                                        await sendOwnerNotification(confirmText);
+                                    }
+                                    catch (err) {
+                                        runtime.error?.(`[tlon] Reaction approval error: ${String(err)}`);
+                                    }
+                                    return;
+                                }
+                            }
+                        }
+                    }
                     try {
                         const partnerShip = extractDmPartnerShip(whom);
                         const route = core.channel.routing.resolveAgentRoute({
@@ -1354,7 +1553,7 @@ export async function monitorTlonProvider(opts = {}) {
                 dmReplyOwnId = dmReply.id ?? dmReply.delta?.add?.id;
                 // If no explicit reply ID, construct from author/sent (same format as our outbound)
                 if (!dmReplyOwnId && dmReplyMemo?.author && dmReplyMemo?.sent) {
-                    dmReplyOwnId = `${normalizeShip(dmReplyMemo.author)}/${dmReplyMemo.sent}`;
+                    dmReplyOwnId = `${normalizeShip(extractAuthorShip(dmReplyMemo.author))}/${dmReplyMemo.sent}`;
                 }
             }
             if (!dmContent) {
@@ -1365,7 +1564,7 @@ export async function monitorTlonProvider(opts = {}) {
             if (!processedTracker.mark(effectiveMessageId)) {
                 return;
             }
-            const authorShip = normalizeShip(dmContent?.author ?? "");
+            const authorShip = normalizeShip(extractAuthorShip(dmContent?.author));
             const partnerShip = extractDmPartnerShip(whom);
             const senderShip = partnerShip || authorShip;
             // Cache DM messages (including bot's own) so reaction lookups have context
@@ -1397,22 +1596,6 @@ export async function monitorTlonProvider(opts = {}) {
             if (!messageText.trim()) {
                 return;
             }
-            // Check if this is the owner sending an approval response
-            if (isOwner(senderShip) && isApprovalResponse(messageText)) {
-                const handled = await handleApprovalResponse(messageText);
-                if (handled) {
-                    runtime.log?.(`[tlon] Processed approval response from owner: ${messageText}`);
-                    return;
-                }
-            }
-            // Check if this is the owner sending an admin command
-            if (isOwner(senderShip) && isAdminCommand(messageText)) {
-                const handled = await handleAdminCommand(messageText);
-                if (handled) {
-                    runtime.log?.(`[tlon] Processed admin command from owner: ${messageText}`);
-                    return;
-                }
-            }
             // Owner is always allowed to DM (bypass allowlist)
             if (isOwner(senderShip)) {
                 runtime.log?.(`[tlon] Processing DM from owner ${senderShip}${isDmThreadReply ? ` (thread reply, parent=${dmReplyParentId}, replyId=${effectiveMessageId})` : ""}`);
@@ -1442,7 +1625,7 @@ export async function monitorTlonProvider(opts = {}) {
                             messageContent: dmContent.content,
                             timestamp: dmContent.sent || Date.now(),
                         },
-                    });
+                    }, pendingApprovals.map((a) => a.id));
                     await queueApprovalRequest(approval);
                 }
                 else {
@@ -1471,7 +1654,7 @@ export async function monitorTlonProvider(opts = {}) {
         await api.subscribe({
             app: "channels",
             path: "/v2",
-            event: handleChannelsFirehose,
+            event: (data) => handleChannelsFirehose(data),
             err: (error) => {
                 runtime.error?.(`[tlon] Channels firehose error: ${String(error)}`);
             },
@@ -1484,7 +1667,7 @@ export async function monitorTlonProvider(opts = {}) {
         await api.subscribe({
             app: "chat",
             path: "/v3",
-            event: handleChatFirehose,
+            event: (data) => handleChatFirehose(data),
             err: (error) => {
                 runtime.error?.(`[tlon] Chat firehose error: ${String(error)}`);
             },
@@ -1502,18 +1685,23 @@ export async function monitorTlonProvider(opts = {}) {
                     // Look for self profile updates
                     if (event?.self) {
                         const selfUpdate = event.self;
-                        if (selfUpdate?.contact?.nickname?.value !== undefined) {
+                        if (selfUpdate?.contact?.nickname?.value !== undefined || selfUpdate?.contact?.avatar?.value !== undefined) {
                             const newNickname = selfUpdate.contact.nickname.value || null;
                             if (newNickname !== botNickname) {
                                 botNickname = newNickname;
                                 runtime.log?.(`[tlon] Bot nickname updated: ${botNickname}`);
                                 if (botNickname) {
-                                    nicknameCache.set(botShipName, botNickname);
+                                    nicknameCache.set(botShipName, sanitizeNickname(botNickname));
                                 }
                                 else {
                                     nicknameCache.delete(botShipName);
                                 }
                             }
+                            const newAvatar = selfUpdate.contact?.avatar?.value || null;
+                            if (newAvatar !== botAvatar) {
+                                botAvatar = newAvatar;
+                                runtime.log?.(`[tlon] Bot avatar updated: ${botAvatar ? "set" : "cleared"}`);
+                            }
                         }
                     }
                     // Look for peer profile updates (other users)
@@ -1522,7 +1710,7 @@ export async function monitorTlonProvider(opts = {}) {
                         const nickname = event.peer.contact?.nickname?.value ?? event.peer.contact?.nickname;
                         if (ship) {
                             if (nickname && typeof nickname === "string") {
-                                nicknameCache.set(ship, nickname);
+                                nicknameCache.set(ship, sanitizeNickname(nickname));
                             }
                             else {
                                 nicknameCache.delete(ship);
@@ -1557,11 +1745,10 @@ export async function monitorTlonProvider(opts = {}) {
                 // Note: we don't remove channels from watchedChannels to avoid missing messages
                 // during transitions. The authorization check handles access control.
             }
-            // Update DM allowlist
+            // Update DM allowlist — respect empty lists (don't fall back to file config)
             if (newSettings.dmAllowlist !== undefined) {
-                effectiveDmAllowlist =
-                    newSettings.dmAllowlist.length > 0 ? newSettings.dmAllowlist : account.dmAllowlist;
-                runtime.log?.(`[tlon] Settings: dmAllowlist updated to ${effectiveDmAllowlist.join(", ")}`);
+                effectiveDmAllowlist = newSettings.dmAllowlist;
+                runtime.log?.(`[tlon] Settings: dmAllowlist updated to ${effectiveDmAllowlist.length > 0 ? effectiveDmAllowlist.join(", ") : "(empty)"}`);
             }
             // Update model signature setting
             if (newSettings.showModelSig !== undefined) {
@@ -1803,7 +1990,8 @@ export async function monitorTlonProvider(opts = {}) {
                                 type: "group",
                                 requestingShip: inviterShip,
                                 groupFlag,
-                            });
+                                groupTitle: validInvite.preview?.meta?.title,
+                            }, pendingApprovals.map((a) => a.id));
                             await queueApprovalRequest(approval);
                             processedGroupInvites.add(groupFlag);
                         }
@@ -1822,7 +2010,8 @@ export async function monitorTlonProvider(opts = {}) {
                                 type: "group",
                                 requestingShip: inviterShip,
                                 groupFlag,
-                            });
+                                groupTitle: validInvite.preview?.meta?.title,
+                            }, pendingApprovals.map((a) => a.id));
                             await queueApprovalRequest(approval);
                             processedGroupInvites.add(groupFlag);
                         }
@@ -1915,11 +2104,36 @@ export async function monitorTlonProvider(opts = {}) {
                 }
             }
         }, 2 * 60 * 1000);
+        // Periodically re-scry settings as a fallback for stale subscriptions.
+        // The settings subscription can silently die (SSE quit without reconnect),
+        // leaving the in-memory allowlist permanently stale.
+        const settingsRefreshInterval = setInterval(async () => {
+            if (opts.abortSignal?.aborted) {
+                return;
+            }
+            try {
+                const refreshed = await settingsManager.load();
+                if (refreshed.dmAllowlist !== undefined) {
+                    const newList = refreshed.dmAllowlist;
+                    if (JSON.stringify(newList) !== JSON.stringify(effectiveDmAllowlist)) {
+                        effectiveDmAllowlist = newList;
+                        runtime.log?.(`[tlon] Settings refresh: dmAllowlist updated to ${effectiveDmAllowlist.join(", ")}`);
+                    }
+                }
+                if (refreshed.defaultAuthorizedShips !== undefined) {
+                    currentSettings = { ...currentSettings, defaultAuthorizedShips: refreshed.defaultAuthorizedShips };
+                }
+            }
+            catch (err) {
+                runtime.error?.(`[tlon] Settings refresh failed: ${String(err)}`);
+            }
+        }, 5 * 60 * 1000);
         if (opts.abortSignal) {
             const signal = opts.abortSignal;
             await new Promise((resolve) => {
                 signal.addEventListener("abort", () => {
                     clearInterval(pollInterval);
+                    clearInterval(settingsRefreshInterval);
                     resolve(null);
                 }, { once: true });
             });
@@ -1929,6 +2143,7 @@ export async function monitorTlonProvider(opts = {}) {
         }
     }
     finally {
+        removeBridge(accountKey, commandBridge);
         try {
             await api?.close();
         }