@tloncorp/openclaw 0.1.0 → 0.4.0

package/dist/src/monitor/index.js

@@ -1,20 +1,45 @@
+import { createTypingCallbacks } from "openclaw/plugin-sdk/channel-runtime";
+import { configureGatewayStatus, gatewayStart } from "@tloncorp/api";
 import { format } from "node:util";
+import { getEffectiveOwnerShip, setEffectiveOwnerShip } from "../effective-owner.js";
+import { getGatewayStatusManager, computeLeaseUntil, ACTIVE_WINDOW_SECS, OFFLINE_REPLY_COOLDOWN_SECS, } from "../gateway-status.js";
+import { registerPersistCallback, syncPendingNudgeFromStore, getPendingNudge, clearPendingNudge, setPendingNudge, isNudgeEligible, } from "../pending-nudge.js";
 import { getTlonRuntime } from "../runtime.js";
+import { setSessionRole } from "../session-roles.js";
 import { createSettingsManager } from "../settings.js";
 import { normalizeShip, parseChannelNest } from "../targets.js";
+import { createTlonTelemetry } from "../telemetry.js";
 import { resolveTlonAccount } from "../types.js";
+import { configureTlonApiWithPoke } from "../urbit/api-client.js";
 import { authenticate } from "../urbit/auth.js";
 import { ssrfPolicyFromAllowPrivateNetwork } from "../urbit/context.js";
-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 { markdownToStory } from "../urbit/story.js";
+import { createPendingApproval, formatApprovalRequest, formatApprovalConfirmation, findPendingApproval, removePendingApproval, pruneExpired, formatBlockedList, formatPendingList, isExpired, emojiToApprovalAction, normalizeNotificationId, } from "./approval.js";
+import { setBridge, removeBridge } from "./command-bridge.js";
+import { createComputingPresenceTracker } from "./computing-presence.js";
 import { fetchAllChannels, fetchInitData } from "./discovery.js";
-import { cacheMessage, lookupCachedMessage, getChannelHistory, fetchThreadHistory } from "./history.js";
-import { downloadMessageImages } from "./media.js";
+import { cacheMessage, lookupCachedMessage, getChannelHistory, fetchChannelHistory, fetchThreadHistory, } from "./history.js";
+import { downloadMessageImages, parseBlobData, formatBlobAnnotations, downloadBlobAttachments, } from "./media.js";
+import { createNudgeRunner, shouldStartNudgeRunner } from "./nudge-runner.js";
+import { clearShadowsForAccount, getLastNudgeStageShadow, getLastOwnerActivity, ownerActivityFromSettings, setLastNudgeStageShadow, setLastOwnerActivity, } from "./nudge-state.js";
+import { createOwnerReplyPersistenceQueue } from "./owner-reply-persistence.js";
+import { createPendingNudgePersistenceQueue } from "./pending-nudge-persistence.js";
 import { createProcessedMessageTracker } from "./processed-messages.js";
-import { extractMessageText, extractCites, formatModelName, isBotMentioned, stripBotMention, isDmAllowed, isSummarizationRequest, } from "./utils.js";
+import { resolveSettingsMirrorSync } from "./settings-sync.js";
+import { extractMessageText, extractCites, formatModelName, isBotMentioned, stripBotMention, isDmAllowed, isSummarizationRequest, sanitizeMessageText, } from "./utils.js";
+/** Refresh stale settings subscription state periodically as a fallback for silently-dead SSE subscriptions. */
+const SETTINGS_REFRESH_INTERVAL_MS = 5 * 60 * 1000;
+/**
+ * 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.
@@ -112,10 +137,14 @@ export async function monitorTlonProvider(opts = {}) {
     });
     // Configure @tloncorp/api's global client to use the SSE client's poke for all send operations
     configureTlonApiWithPoke(api.poke.bind(api), botShipName, account.url);
+    const computingPresence = createComputingPresenceTracker({ runtime });
     const processedTracker = createProcessedMessageTracker(2000);
     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),
@@ -131,10 +160,36 @@ export async function monitorTlonProvider(opts = {}) {
     let effectiveOwnerShip = account.ownerShip
         ? normalizeShip(account.ownerShip)
         : null;
+    setEffectiveOwnerShip(account.accountId, effectiveOwnerShip);
     let pendingApprovals = [];
     let currentSettings = {};
+    // Tracks whether pendingNudge has been successfully rehydrated from the settings
+    // store (or locally set/cleared). While false, refresh is allowed to recover a
+    // persisted pendingNudge that was missed due to a transient startup scry failure.
+    // Once true, the in-memory state is authoritative and refresh cannot clobber it.
+    let pendingNudgeRehydrated = false;
+    /** Set pending nudge and take ownership so refresh cannot clobber. */
+    const setLocalPendingNudge = (accountId, nudge) => {
+        setPendingNudge(accountId, nudge);
+        pendingNudgeRehydrated = true;
+    };
+    /** Clear pending nudge and take ownership so refresh cannot resurrect stale store data. */
+    const clearLocalPendingNudge = (accountId) => {
+        clearPendingNudge(accountId);
+        pendingNudgeRehydrated = true;
+    };
+    const telemetry = createTlonTelemetry({
+        config: account.telemetry,
+        runtime,
+    });
     // 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;
@@ -143,14 +198,15 @@ export async function monitorTlonProvider(opts = {}) {
     // Sanitize nickname to prevent format injection
     function sanitizeNickname(nickname) {
         return nickname
-            .replace(/[\[\]()]/g, "") // Remove format-breaking chars
+            .replace(/[[\]()]/g, "") // Remove format-breaking chars
             .slice(0, 50); // Reasonable length limit
     }
     // Format a ship with nickname if available
     function formatShipWithNickname(ship) {
         const nickname = nicknameCache.get(ship);
-        if (!nickname)
+        if (!nickname) {
             return ship;
+        }
         const sanitized = sanitizeNickname(nickname);
         return sanitized ? `${ship} (${sanitized})` : ship;
     }
@@ -160,9 +216,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));
             }
         }
     }
@@ -171,12 +228,12 @@ export async function monitorTlonProvider(opts = {}) {
     }
     // Fetch all contacts to populate nickname cache
     try {
-        const allContacts = await api.scry("/contacts/v1/all.json");
+        const allContacts = (await api.scry("/contacts/v1/all.json"));
         if (allContacts && typeof allContacts === "object") {
             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 +244,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 +303,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 {
@@ -259,11 +337,28 @@ export async function monitorTlonProvider(opts = {}) {
             }
         }
     }
+    // Clear stale in-memory pending-nudge state before settings load.
+    // If load fails during a same-process restart, we should not keep attributing
+    // owner replies against a previous monitor run's record.
+    syncPendingNudgeFromStore(account.accountId, null);
+    // Drop stale per-process shadows from any prior run in the same process.
+    // Mirrors the same-process-restart reasoning as the pending-nudge sync above.
+    clearShadowsForAccount(account.accountId);
     // Load settings from settings store (hot-reloadable config)
     try {
-        currentSettings = await settingsManager.load();
-        // Migrate file config to settings store if not already present
-        await migrateConfigToSettings();
+        const loadResult = await settingsManager.load();
+        currentSettings = loadResult.settings;
+        // Only seed file config into %settings when the startup snapshot is fresh.
+        // On a transient startup scry failure, `load()` preserves the last known
+        // snapshot (or `{}` on first load). Running migration against a stale
+        // snapshot would treat every persisted override as absent and clobber it
+        // with file-backed values once the settings agent recovers.
+        if (loadResult.fresh) {
+            await migrateConfigToSettings();
+        }
+        else {
+            runtime.log?.("[tlon] Skipping config->settings migration on stale startup snapshot");
+        }
         // Apply settings overrides
         // Note: groupChannels from settings store are merged AFTER discovery runs (below)
         if (currentSettings.defaultAuthorizedShips?.length) {
@@ -273,9 +368,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;
@@ -294,8 +389,21 @@ export async function monitorTlonProvider(opts = {}) {
         }
         if (currentSettings.ownerShip) {
             effectiveOwnerShip = normalizeShip(currentSettings.ownerShip);
+            setEffectiveOwnerShip(account.accountId, effectiveOwnerShip);
             runtime.log?.(`[tlon] Using ownerShip from settings store: ${effectiveOwnerShip}`);
         }
+        // Rehydrate pending nudge from settings store only if the scry returned real data.
+        // On fallback (scry failure), leave pendingNudgeRehydrated false so the refresh
+        // recovery path can still pick up a persisted pendingNudge later.
+        if (loadResult.fresh) {
+            syncPendingNudgeFromStore(account.accountId, currentSettings.pendingNudge ?? null);
+            pendingNudgeRehydrated = true;
+        }
+        // Seed nudge shadows from the loaded settings snapshot. Missing fields
+        // seed the shadow as absent / 0 — the tick short-circuits on null
+        // activity, which is correct for a cold startup with an empty store.
+        setLastOwnerActivity(account.accountId, ownerActivityFromSettings(currentSettings));
+        setLastNudgeStageShadow(account.accountId, currentSettings.lastNudgeStage ?? 0);
         if (currentSettings.pendingApprovals?.length) {
             pendingApprovals = currentSettings.pendingApprovals;
             runtime.log?.(`[tlon] Loaded ${pendingApprovals.length} pending approval(s) from settings`);
@@ -304,6 +412,97 @@ export async function monitorTlonProvider(opts = {}) {
     catch (err) {
         runtime.log?.(`[tlon] Settings store not available, using file config: ${String(err)}`);
     }
+    const pendingNudgePersistence = createPendingNudgePersistenceQueue(async (nudge) => {
+        try {
+            if (nudge) {
+                await api.poke({
+                    app: "settings",
+                    mark: "settings-event",
+                    json: {
+                        "put-entry": {
+                            desk: "moltbot",
+                            "bucket-key": "tlon",
+                            "entry-key": "pendingNudge",
+                            value: JSON.stringify(nudge),
+                        },
+                    },
+                });
+            }
+            else {
+                await api.poke({
+                    app: "settings",
+                    mark: "settings-event",
+                    json: {
+                        "del-entry": {
+                            desk: "moltbot",
+                            "bucket-key": "tlon",
+                            "entry-key": "pendingNudge",
+                        },
+                    },
+                });
+            }
+        }
+        catch (err) {
+            runtime.error?.(nudge
+                ? `[tlon] Failed to persist pendingNudge: ${String(err)}`
+                : `[tlon] Failed to clear pendingNudge: ${String(err)}`);
+        }
+    });
+    // Register per-account persist callback for pending nudge writes.
+    registerPersistCallback(account.accountId, (nudge) => {
+        pendingNudgePersistence.enqueue(nudge);
+    });
+    const ownerReplyPersistence = createOwnerReplyPersistenceQueue(api, {
+        error: (msg) => runtime.error?.(msg),
+    });
+    let nudgeRunner = null;
+    // Clear expired pending nudge on startup (after persist callback is registered so del-entry fires).
+    const rehydratedNudge = getPendingNudge(account.accountId);
+    if (rehydratedNudge && !isNudgeEligible(rehydratedNudge)) {
+        const ageMs = Date.now() - rehydratedNudge.sentAt;
+        clearLocalPendingNudge(account.accountId);
+        runtime.log?.(`[tlon] Cleared expired pending nudge on startup (stage ${rehydratedNudge.stage}, age ${ageMs}ms)`);
+    }
+    // ── Gateway-status: non-blocking background activation ──────
+    // getGatewayStatusManager() returns null when multi-account or zero accounts configured
+    // (see index.ts registration gate).
+    const gsManager = getGatewayStatusManager();
+    if (gsManager && effectiveOwnerShip) {
+        const capturedOwnerShip = effectiveOwnerShip;
+        const signal = opts.abortSignal;
+        // Fire-and-forget: wait for gateway_start signal, then activate.
+        // Does NOT block monitor startup — discovery, subscriptions, etc. proceed immediately.
+        void (async () => {
+            try {
+                const raced = await Promise.race([
+                    gsManager.waitForGatewayStart().then(() => "started"),
+                    ...(signal
+                        ? [
+                            new Promise((r) => signal.addEventListener("abort", () => r("aborted"), { once: true })),
+                        ]
+                        : []),
+                ]);
+                if (raced !== "started" || gsManager.stopped) {
+                    return;
+                }
+                await configureGatewayStatus({
+                    owner: capturedOwnerShip,
+                    activeWindowSecs: ACTIVE_WINDOW_SECS,
+                    offlineReplyCooldownSecs: OFFLINE_REPLY_COOLDOWN_SECS,
+                });
+                await gatewayStart({
+                    bootId: gsManager.bootId,
+                    leaseUntil: computeLeaseUntil(),
+                });
+                gsManager.markActivated();
+                gsManager.startHeartbeat();
+                runtime.log?.(`[gateway-status] activated (bootId=${gsManager.bootId}, owner=${capturedOwnerShip})`);
+            }
+            catch (err) {
+                runtime.error?.(`[gateway-status] start failed: ${String(err)}`);
+            }
+        })();
+    }
     // Run channel discovery AFTER settings are loaded (so settings store value is used)
     if (effectiveAutoDiscoverChannels) {
         try {
@@ -315,6 +514,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 +630,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 +706,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 +735,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)}`);
@@ -503,6 +746,11 @@ export async function monitorTlonProvider(opts = {}) {
     async function unblockShip(ship) {
         const normalizedShip = normalizeShip(ship);
         try {
+            const blocked = await isShipBlocked(normalizedShip);
+            if (!blocked) {
+                runtime.log?.(`[tlon] Ship ${normalizedShip} is not blocked; skipping unblock`);
+                return true;
+            }
             await api.poke({
                 app: "chat",
                 mark: "chat-unblock-ship",
@@ -516,24 +764,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 +843,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({
@@ -590,15 +882,15 @@ export async function monitorTlonProvider(opts = {}) {
                             messageContent: approval.originalMessage.messageContent,
                             isGroup: false,
                             timestamp: approval.originalMessage.timestamp,
+                            blobField: approval.originalMessage.blob,
                         });
                     }
                     break;
                 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,17 +899,17 @@ 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,
+                                blobField: approval.originalMessage.blob,
                             });
                         }
                     }
                     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 +921,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 +946,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"));
-        }
-        else {
-            // Denied - just remove from pending, no notification to requester
-            await sendOwnerNotification(formatApprovalConfirmation(approval, "deny"));
+            await removeFromDmAllowlist(approval.requestingShip);
         }
-        // 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 +1015,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,
@@ -746,42 +1030,73 @@ export async function monitorTlonProvider(opts = {}) {
         if (isGroup) {
             messageText = stripBotMention(messageText, botShipName);
         }
-        // Track owner interaction timestamp for heartbeat engagement recovery.
-        // Store both epoch ms (for code) and ISO date (for LLM — models can't reliably convert epoch).
+        // Track owner interaction timestamp for the nudge scheduler.
+        // The shadows update synchronously; the durable %settings writes happen
+        // in the background via an ordered queue so the owner-DM hot path never
+        // waits on an Urbit RTT.
         if (isOwner(senderShip)) {
-            const isoDate = new Date(timestamp).toISOString().split("T")[0]; // YYYY-MM-DD
-            Promise.all([
-                api.poke({
-                    app: "settings",
-                    mark: "settings-event",
-                    json: {
-                        "put-entry": {
-                            desk: "moltbot",
-                            "bucket-key": "tlon",
-                            "entry-key": "lastOwnerMessageAt",
-                            value: timestamp,
-                        },
-                    },
-                }),
-                api.poke({
-                    app: "settings",
-                    mark: "settings-event",
-                    json: {
-                        "put-entry": {
-                            desk: "moltbot",
-                            "bucket-key": "tlon",
-                            "entry-key": "lastOwnerMessageDate",
-                            value: isoDate,
-                        },
-                    },
-                }),
-            ])
-                .then(() => {
-                runtime.log?.(`[tlon] Updated lastOwnerMessageAt: ${timestamp} (${isoDate})`);
-            })
-                .catch((err) => {
-                runtime.error?.(`[tlon] Failed to update lastOwnerMessageAt: ${String(err)}`);
+            const isoDate = new Date(timestamp).toISOString().split("T")[0] ?? ""; // YYYY-MM-DD
+            // (1a) Synchronous shadow: owner activity. Updated FIRST so any tick
+            //      that observes both shadows sees "activity-first" ordering.
+            setLastOwnerActivity(account.accountId, { at: timestamp, date: isoDate });
+            // Check for pending nudge re-engagement. Stage is cleared on ANY owner
+            // reply when the stage shadow is non-zero (or pendingNudge is present)
+            // so the next inactivity cycle can send the same stage again. Gating on
+            // `pendingNudge` alone would miss the in-flight-tick race: the scheduler
+            // pokes `lastNudgeStage` and sets the shadow before `sendDm()`, but
+            // only writes `pendingNudge` after the send resolves — so a reply that
+            // lands in that window would otherwise leave the stage stuck.
+            const pending = getPendingNudge(account.accountId);
+            const shadowStage = getLastNudgeStageShadow(account.accountId) ?? 0;
+            const willClearStage = shadowStage > 0 || Boolean(pending);
+            // (1b) Synchronous shadow: stage cleared (only when we'd clear).
+            if (willClearStage) {
+                setLastNudgeStageShadow(account.accountId, 0);
+            }
+            // (2) Enqueue durable writes. The queue awaits the put-entries before
+            //     issuing the del-entry on the wire, closing the crash-consistency
+            //     gap. The handler does NOT await the queue.
+            ownerReplyPersistence.enqueue({
+                at: timestamp,
+                date: isoDate,
+                clearStage: willClearStage,
             });
+            if (pending) {
+                if (isNudgeEligible(pending, timestamp)) {
+                    const reengagedAt = timestamp;
+                    telemetry?.captureHeartbeatReengagement({
+                        ownerShip: pending.ownerShip,
+                        botShip: account.ship ?? "",
+                        nudgeStage: pending.stage,
+                        nudgeSentAt: pending.sentAt,
+                        reengagedAt,
+                        reengagementDelayMs: reengagedAt - pending.sentAt,
+                        channel: "tlon",
+                        accountId: pending.accountId,
+                    });
+                    runtime.log?.(`[tlon] Heartbeat nudge re-engagement: stage ${pending.stage}, delay ${reengagedAt - pending.sentAt}ms`);
+                }
+                else {
+                    runtime.log?.(`[tlon] Pending nudge expired (stage ${pending.stage}, sent ${pending.sentAt})`);
+                }
+                clearLocalPendingNudge(account.accountId);
+            }
+            // Inject reply context for the agent when the reply appears to be a
+            // response to a recent, eligible nudge.
+            //
+            // Restricted to DMs (`!isGroup`). The nudge itself was sent as a DM,
+            // so prefacing a channel/group reply with DM-only context — including
+            // the verbatim nudge `content` — would leak that context into an
+            // unrelated public conversation.
+            if (pending && isNudgeEligible(pending, timestamp) && !isGroup) {
+                const sentIso = new Date(pending.sentAt).toISOString();
+                const contentBlock = pending.content ? `Message content:\n\n${pending.content}\n\n` : "";
+                messageText =
+                    `[Context: You recently sent ${pending.ownerShip} a stage-${pending.stage} ` +
+                        `re-engagement nudge at ${sentIso}. ${contentBlock}` +
+                        `The owner's reply below may be responding to that nudge.]\n\n` +
+                        messageText;
+            }
         }
         // Download any images from the message content
         let attachments = [];
@@ -796,14 +1111,39 @@ export async function monitorTlonProvider(opts = {}) {
                 runtime.log?.(`[tlon] Failed to download images: ${error?.message ?? String(error)}`);
             }
         }
+        // Parse and handle blob attachments (files, voice memos, videos)
+        const blobData = parseBlobData(params.blobField);
+        if (blobData) {
+            // Add text annotations so the agent knows what was attached
+            const blobAnnotations = formatBlobAnnotations(blobData);
+            if (blobAnnotations) {
+                messageText = blobAnnotations + "\n" + messageText;
+                runtime.log?.(`[tlon] Added blob annotations: ${blobAnnotations} attachment(s)`);
+            }
+            // Download blob files as attachments
+            try {
+                const { attachments: blobAttachments, notices: blobDownloadNotices } = await downloadBlobAttachments(blobData);
+                if (blobDownloadNotices.length > 0) {
+                    messageText = blobDownloadNotices.join("\n") + "\n" + messageText;
+                    runtime.log?.(`[tlon] Skipped oversized blob attachment(s): ${blobDownloadNotices.join(" | ")}`);
+                }
+                if (blobAttachments.length > 0) {
+                    attachments = attachments.concat(blobAttachments);
+                    runtime.log?.(`[tlon] Downloaded blob attachment(s) ${JSON.stringify(blobAttachments)}`);
+                }
+            }
+            catch (error) {
+                runtime.log?.(`[tlon] Failed to download blob attachments: ${error?.message ?? String(error)}`);
+            }
+        }
         // Fetch thread context when entering a thread for the first time
         if (isThreadReply && parentId && groupChannel) {
             try {
                 const threadHistory = await fetchThreadHistory(api, groupChannel, parentId, 20, runtime);
                 if (threadHistory.length > 0) {
                     const threadContext = threadHistory
-                        .slice(-10) // Last 10 messages for context
-                        .map((msg) => `${msg.author}: ${msg.content}`)
+                        .slice(-20) // Last 20 thread messages for context
+                        .map((msg) => `${formatShipWithNickname(msg.author)}: ${sanitizeMessageText(msg.content)}`)
                         .join("\n");
                     // Prepend thread context to the message
                     // Include note about ongoing conversation for agent judgment
@@ -817,6 +1157,31 @@ export async function monitorTlonProvider(opts = {}) {
                 // Continue without thread context - not critical
             }
         }
+        // Fetch recent channel history on mention (non-thread) so the agent has
+        // context about what the channel has been discussing.
+        if (isGroup && groupChannel && !isThreadReply) {
+            try {
+                const recentHistory = await fetchChannelHistory(api, groupChannel, 20, runtime);
+                if (recentHistory.length > 0) {
+                    // Filter out the current message itself (avoid duplication)
+                    const contextMessages = recentHistory
+                        .filter((msg) => msg.id !== params.messageId)
+                        .slice(0, 20)
+                        .toReversed() // oldest first for natural reading order
+                        .map((msg) => `${formatShipWithNickname(msg.author)}: ${sanitizeMessageText(msg.content)}`)
+                        .join("\n");
+                    if (contextMessages) {
+                        const contextNote = `[Recent channel activity - ${recentHistory.length} messages. Use this context to understand what's being discussed.]`;
+                        messageText = `${contextNote}\n\n${contextMessages}\n\n[Current message (mentioned you)]\n${messageText}`;
+                        runtime?.log?.(`[tlon] Added channel context (${recentHistory.length} messages) to mention in ${groupChannel}`);
+                    }
+                }
+            }
+            catch (error) {
+                runtime?.log?.(`[tlon] Could not fetch channel context: ${error?.message ?? String(error)}`);
+                // Continue without channel context - not critical
+            }
+        }
         if (isGroup && groupChannel && isSummarizationRequest(messageText)) {
             try {
                 const history = await getChannelHistory(api, groupChannel, 50, runtime);
@@ -824,6 +1189,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 +1197,7 @@ export async function monitorTlonProvider(opts = {}) {
                     }
                     else {
                         await sendDm({
+                            botProfile: getBotProfile(),
                             fromShip: botShipName,
                             toShip: senderShip,
                             text: noHistoryMsg,
@@ -839,7 +1206,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 +1220,19 @@ 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 +1267,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,10 +1277,14 @@ 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}`
             : `${senderDisplay} [${senderRole}]`;
+        const attachmentCount = attachments.length;
         // Compute command authorization for slash commands (owner-only)
         const shouldComputeAuth = core.channel.commands.shouldComputeCommandAuthorized(messageText, cfg);
         let commandAuthorized = false;
@@ -945,11 +1323,10 @@ export async function monitorTlonProvider(opts = {}) {
             body: bodyWithAttachments,
         });
         // Use raw text (no thread context) for command detection so "/status" is recognized
-        const commandBody = isGroup
-            ? stripBotMention(rawMessageText, botShipName)
-            : rawMessageText;
+        const commandBody = isGroup ? stripBotMention(rawMessageText, botShipName) : rawMessageText;
         const ctxPayload = core.channel.reply.finalizeInboundContext({
             Body: body,
+            BodyForAgent: bodyWithAttachments,
             RawBody: messageText,
             CommandBody: commandBody,
             From: isGroup ? `tlon:group:${groupChannel}` : `tlon:${senderShip}`,
@@ -966,65 +1343,196 @@ export async function monitorTlonProvider(opts = {}) {
             Provider: "tlon",
             Surface: "tlon",
             MessageSid: messageId,
-            // Include downloaded media attachments
-            ...(attachments.length > 0 && { Attachments: attachments }),
+            // Include downloaded media attachments (MediaPaths/MediaUrls/MediaTypes for OpenClaw media pipeline)
+            ...(attachments.length > 0 && {
+                MediaPaths: attachments.map((a) => a.path),
+                MediaUrls: attachments.map((a) => a.path),
+                MediaTypes: attachments.map((a) => a.contentType),
+            }),
             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) }),
         });
         const dispatchStartTime = Date.now();
+        const replyTelemetry = telemetry?.startReply({
+            sessionKey: route.sessionKey,
+            ownerShip: effectiveOwnerShip,
+            botShip: botShipName,
+            chatType: isGroup ? "groupChannel" : "dm",
+            isThreadReply: Boolean(isThreadReply),
+            senderRole,
+            attachmentCount,
+        });
+        let selectedProvider = null;
+        let selectedModel = null;
+        let selectedThinkLevel = null;
+        let deliveredMessageCount = 0;
+        let replyCharCount = 0;
+        let replyWordCount = 0;
+        let replyMediaCount = 0;
         const responsePrefix = core.channel.reply.resolveEffectiveMessagesConfig(cfg, route.agentId).responsePrefix;
         const humanDelay = core.channel.reply.resolveHumanDelayConfig(cfg, route.agentId);
-        await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
-            ctx: ctxPayload,
-            cfg,
-            dispatcherOptions: {
-                responsePrefix,
-                humanDelay,
-                deliver: async (payload) => {
-                    let replyText = payload.text;
-                    if (!replyText) {
-                        return;
-                    }
-                    // Use settings store value if set, otherwise fall back to file config
-                    const showSignature = effectiveShowModelSig;
-                    if (showSignature) {
-                        const modelInfo = payload.metadata?.model ||
-                            payload.model ||
-                            route.model ||
-                            cfg.agents?.defaults?.model?.primary;
-                        replyText = `${replyText}\n\n_[Generated by ${formatModelName(modelInfo)}]_`;
-                    }
-                    if (isGroup && groupChannel) {
-                        // Send to any channel type (chat, heap, diary) using the nest directly
-                        await sendChannelPost({
-                            fromShip: botShipName,
-                            nest: groupChannel,
-                            story: markdownToStory(replyText),
-                            replyToId: deliverParentId ?? undefined,
-                        });
-                        // Track thread participation for future replies without mention
-                        if (deliverParentId) {
-                            participatedThreads.add(String(deliverParentId));
-                            runtime.log?.(`[tlon] Now tracking thread for future replies: ${deliverParentId}`);
-                        }
-                    }
-                    else {
-                        await sendDm({ fromShip: botShipName, toShip: senderShip, text: replyText, replyToId: deliverParentId ? String(deliverParentId) : undefined });
-                    }
+        const presenceConversationId = isGroup ? (groupChannel ?? null) : senderShip;
+        const presenceRunId = String(messageId);
+        const typingCallbacks = presenceConversationId
+            ? createTypingCallbacks({
+                start: async () => {
+                    await computingPresence.refreshRun({
+                        conversationId: presenceConversationId,
+                        runId: presenceRunId,
+                    });
+                },
+                stop: async () => {
+                    await computingPresence.stopRun({
+                        conversationId: presenceConversationId,
+                        runId: presenceRunId,
+                    });
+                },
+                onStartError: (err) => {
+                    runtime.error?.(`[tlon] Failed to start computing presence for ${presenceConversationId}: ${err instanceof Error ? (err.stack ?? err.message) : String(err)}`);
                 },
-                onError: (err, info) => {
-                    const dispatchDuration = Date.now() - dispatchStartTime;
-                    runtime.error?.(`[tlon] ${info.kind} reply failed after ${dispatchDuration}ms: ${String(err)}`);
+                onStopError: (err) => {
+                    runtime.error?.(`[tlon] Failed to stop computing presence for ${presenceConversationId}: ${err instanceof Error ? (err.stack ?? err.message) : String(err)}`);
                 },
+                keepaliveIntervalMs: 20_000,
+            })
+            : undefined;
+        const replyOptions = {
+            onModelSelected: ({ provider, model, thinkLevel }) => {
+                selectedProvider = provider;
+                selectedModel = model;
+                selectedThinkLevel = thinkLevel ?? null;
             },
-        });
+            ...(presenceConversationId
+                ? {
+                    onAssistantMessageStart: async () => {
+                        await computingPresence.clearToolCalls({
+                            conversationId: presenceConversationId,
+                            runId: presenceRunId,
+                        });
+                    },
+                    onToolStart: async (payload) => {
+                        await computingPresence.addToolCall({
+                            conversationId: presenceConversationId,
+                            runId: presenceRunId,
+                            toolName: payload.name,
+                        });
+                    },
+                }
+                : {}),
+        };
+        let dispatchResult;
+        let dispatchError;
+        try {
+            dispatchResult = await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+                ctx: ctxPayload,
+                cfg,
+                replyOptions,
+                dispatcherOptions: {
+                    responsePrefix,
+                    humanDelay,
+                    typingCallbacks,
+                    deliver: async (payload) => {
+                        let replyText = payload.text;
+                        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 = selectedModel ||
+                                payload.metadata?.model ||
+                                payload.model ||
+                                route.model ||
+                                (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),
+                                replyToId: deliverParentId ?? undefined,
+                            });
+                            // Track thread participation for future replies without mention
+                            if (deliverParentId) {
+                                participatedThreads.add(String(deliverParentId));
+                                runtime.log?.(`[tlon] Now tracking thread for future replies: ${deliverParentId}`);
+                            }
+                        }
+                        else {
+                            await sendDm({
+                                botProfile: getBotProfile(),
+                                fromShip: botShipName,
+                                toShip: senderShip,
+                                text: replyText,
+                                replyToId: deliverParentId ? String(deliverParentId) : undefined,
+                            });
+                        }
+                        if (presenceConversationId) {
+                            await computingPresence.stopRun({
+                                conversationId: presenceConversationId,
+                                runId: presenceRunId,
+                            });
+                        }
+                        deliveredMessageCount += 1;
+                        replyCharCount += replyText.length;
+                        replyWordCount += replyText.trim() ? replyText.trim().split(/\s+/).length : 0;
+                        replyMediaCount += Array.isArray(payload.mediaUrls)
+                            ? payload.mediaUrls.length
+                            : payload.mediaUrl
+                                ? 1
+                                : 0;
+                    },
+                    onError: (err, info) => {
+                        const dispatchDuration = Date.now() - dispatchStartTime;
+                        runtime.error?.(`[tlon] ${info.kind} reply failed after ${dispatchDuration}ms: ${String(err)}`);
+                    },
+                },
+            });
+        }
+        catch (error) {
+            dispatchError = error;
+            throw error;
+        }
+        finally {
+            await replyTelemetry?.capture({
+                deliveredMessageCount,
+                replyCharCount,
+                replyWordCount,
+                replyMediaCount,
+                dispatchDurationMs: Date.now() - dispatchStartTime,
+                queuedFinal: dispatchResult?.queuedFinal ?? false,
+                queuedFinalCount: dispatchResult?.counts.final ?? 0,
+                queuedBlockCount: dispatchResult?.counts.block ?? 0,
+                provider: selectedProvider,
+                model: selectedModel,
+                thinkLevel: selectedThinkLevel,
+                dispatchError,
+            });
+        }
     };
     // Track which channels we're interested in for filtering firehose events
     const watchedChannels = new Set(groupChannels);
     const _watchedDMs = new Set();
-    // Firehose handler for all channel messages (/v2)
+    // Firehose handler for all channel messages (/v4)
     const handleChannelsFirehose = async (event) => {
         try {
             const nest = event?.nest;
@@ -1056,8 +1564,9 @@ export async function monitorTlonProvider(opts = {}) {
                     : (response?.post?.id ?? "unknown");
                 for (const [reactShip, reactEmoji] of Object.entries(effectiveReacts)) {
                     const ship = normalizeShip(reactShip);
-                    if (!ship || ship === botShipName)
+                    if (!ship || ship === botShipName) {
                         continue;
+                    }
                     try {
                         const route = core.channel.routing.resolveAgentRoute({
                             cfg,
@@ -1070,7 +1579,9 @@ export async function monitorTlonProvider(opts = {}) {
                         const contentSnippet = cached?.content
                             ? ` (message: "${cached.content.substring(0, 200)}${cached.content.length > 200 ? "..." : ""}")`
                             : "";
-                        const authorInfo = cached?.author ? ` (by ${formatShipWithNickname(cached.author)})` : "";
+                        const authorInfo = cached?.author
+                            ? ` (by ${formatShipWithNickname(cached.author)})`
+                            : "";
                         const reactorDisplay = formatShipWithNickname(ship);
                         const eventText = `Tlon reaction in ${nest}: ${reactEmoji} by ${reactorDisplay} on post ${postId}${authorInfo}${contentSnippet}`;
                         runtime.log?.(`[tlon] REACTION: ${eventText}`);
@@ -1080,9 +1591,7 @@ export async function monitorTlonProvider(opts = {}) {
                             // Include context so agent knows what was reacted to, since we're
                             // deliberately omitting thread context (parentId) to avoid the agent
                             // suppressing responses when it sees its own message in thread history.
-                            const reactionParentId = replyReacts
-                                ? (response?.post?.id ?? postId)
-                                : postId;
+                            const reactionParentId = replyReacts ? (response?.post?.id ?? postId) : postId;
                             const reactText = cached?.content
                                 ? `${reactEmoji} (reacting to: "${cached.content}")`
                                 : reactEmoji;
@@ -1116,17 +1625,17 @@ 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 replyEssay = response?.post?.["r-post"]?.reply?.["r-reply"]?.set?.["reply-essay"];
+            const content = replyEssay || essay;
+            if (!content) {
                 return;
             }
-            const content = memo || essay;
-            const isThreadReply = Boolean(memo);
+            const isThreadReply = Boolean(replyEssay);
             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;
             }
@@ -1134,7 +1643,8 @@ export async function monitorTlonProvider(opts = {}) {
             const citedContent = await resolveAllCites(content.content);
             const rawText = extractMessageText(content.content);
             const messageText = citedContent + rawText;
-            if (!messageText.trim()) {
+            const hasBlob = Boolean(content?.blob);
+            if (!messageText.trim() && !hasBlob) {
                 return;
             }
             // Cache ALL messages (including bot's own) so reaction lookups have context
@@ -1144,10 +1654,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
@@ -1158,13 +1676,33 @@ export async function monitorTlonProvider(opts = {}) {
             // 2. Thread replies where we've participated - respond if relevant (let agent decide)
             const mentioned = isBotMentioned(messageText, botShipName, botNickname ?? undefined);
             const inParticipatedThread = isThreadReply && parentId && participatedThreads.has(String(parentId));
-            if (!mentioned && !inParticipatedThread) {
+            const isOwnerBlob = hasBlob && isOwner(senderShip);
+            if (!mentioned && !inParticipatedThread && !isOwnerBlob) {
                 return;
             }
             // Log why we're responding
-            if (inParticipatedThread && !mentioned) {
+            if (isOwnerBlob && !mentioned && !inParticipatedThread) {
+                runtime.log?.(`[tlon] Responding to owner blob-only message in ${nest}`);
+            }
+            else 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`);
@@ -1188,8 +1726,9 @@ export async function monitorTlonProvider(opts = {}) {
                                     timestamp: content.sent || Date.now(),
                                     parentId: parentId ?? undefined,
                                     isThreadReply,
+                                    blob: content.blob ?? undefined,
                                 },
-                            });
+                            }, pendingApprovals.map((a) => a.id));
                             await queueApprovalRequest(approval);
                         }
                         else {
@@ -1205,6 +1744,7 @@ export async function monitorTlonProvider(opts = {}) {
                 senderShip,
                 messageText,
                 messageContent: content.content, // Pass raw content for media extraction
+                blobField: content.blob,
                 isGroup: true,
                 channelNest: nest,
                 hostShip: parsed?.hostShip,
@@ -1218,7 +1758,7 @@ export async function monitorTlonProvider(opts = {}) {
             runtime.error?.(`[tlon] Error handling channel firehose event: ${error?.message ?? String(error)}`);
         }
     };
-    // Firehose handler for all DM messages (/v3)
+    // Firehose handler for all DM messages (/v4)
     // Track which DM invites we've already processed to avoid duplicate accepts
     const processedDmInvites = new Set();
     const handleChatFirehose = async (event) => {
@@ -1268,7 +1808,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 +1830,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({
@@ -1326,7 +1891,9 @@ export async function monitorTlonProvider(opts = {}) {
                             const contentSnippet = cached?.content
                                 ? ` (message: "${cached.content.substring(0, 200)}${cached.content.length > 200 ? "..." : ""}")`
                                 : "";
-                            const authorInfo = cached?.author ? ` (by ${formatShipWithNickname(cached.author)})` : "";
+                            const authorInfo = cached?.author
+                                ? ` (by ${formatShipWithNickname(cached.author)})`
+                                : "";
                             const reactorDisplay = formatShipWithNickname(reactAuthor);
                             const eventText = `Tlon DM reaction ${action}: ${reactEmoji} by ${reactorDisplay} on message ${messageId}${authorInfo}${contentSnippet}`;
                             core.system.enqueueSystemEvent(eventText, {
@@ -1342,19 +1909,19 @@ export async function monitorTlonProvider(opts = {}) {
                 }
                 return;
             }
-            // Extract memo from DM thread reply
-            const dmReplyMemo = dmReply?.delta?.add?.memo;
+            // Extract reply-essay from DM thread reply
+            const dmReplyEssay = dmReply?.delta?.add?.["reply-essay"];
             const dmReplyParentId = dmReply ? event.id : undefined;
-            const isDmThreadReply = Boolean(dmReplyMemo);
-            const dmContent = essay || dmReplyMemo;
+            const isDmThreadReply = Boolean(dmReplyEssay);
+            const dmContent = essay || dmReplyEssay;
             // For DM thread replies, extract the reply's own ID (distinct from the parent post ID)
             // The reply ID may be in dmReply.id, or we construct it from author/sent
             let dmReplyOwnId;
             if (isDmThreadReply && dmReply) {
                 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}`;
+                if (!dmReplyOwnId && dmReplyEssay?.author && dmReplyEssay?.sent) {
+                    dmReplyOwnId = `${normalizeShip(extractAuthorShip(dmReplyEssay.author))}/${dmReplyEssay.sent}`;
                 }
             }
             if (!dmContent) {
@@ -1365,7 +1932,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
@@ -1394,25 +1961,10 @@ export async function monitorTlonProvider(opts = {}) {
             const citedContent = await resolveAllCites(dmContent.content);
             const rawText = extractMessageText(dmContent.content);
             const messageText = citedContent + rawText;
-            if (!messageText.trim()) {
+            const hasBlob = Boolean(dmContent?.blob);
+            if (!messageText.trim() && !hasBlob) {
                 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})` : ""}`);
@@ -1421,6 +1973,7 @@ export async function monitorTlonProvider(opts = {}) {
                     senderShip,
                     messageText,
                     messageContent: dmContent.content,
+                    blobField: dmContent.blob,
                     isGroup: false,
                     timestamp: dmContent.sent || Date.now(),
                     parentId: dmReplyParentId,
@@ -1441,8 +1994,9 @@ export async function monitorTlonProvider(opts = {}) {
                             messageText,
                             messageContent: dmContent.content,
                             timestamp: dmContent.sent || Date.now(),
+                            blob: dmContent.blob ?? undefined,
                         },
-                    });
+                    }, pendingApprovals.map((a) => a.id));
                     await queueApprovalRequest(approval);
                 }
                 else {
@@ -1455,6 +2009,7 @@ export async function monitorTlonProvider(opts = {}) {
                 senderShip,
                 messageText,
                 messageContent: dmContent.content, // Pass raw content for media extraction
+                blobField: dmContent.blob,
                 isGroup: false,
                 timestamp: dmContent.sent || Date.now(),
                 parentId: dmReplyParentId,
@@ -1467,11 +2022,11 @@ export async function monitorTlonProvider(opts = {}) {
     };
     try {
         runtime.log?.("[tlon] Subscribing to firehose updates...");
-        // Subscribe to channels firehose (/v2)
+        // Subscribe to channels firehose (/v4)
         await api.subscribe({
             app: "channels",
-            path: "/v2",
-            event: handleChannelsFirehose,
+            path: "/v4",
+            event: (data) => handleChannelsFirehose(data),
             err: (error) => {
                 runtime.error?.(`[tlon] Channels firehose error: ${String(error)}`);
             },
@@ -1479,12 +2034,12 @@ export async function monitorTlonProvider(opts = {}) {
                 runtime.log?.("[tlon] Channels firehose quit received, SSE client will resubscribe");
             },
         });
-        runtime.log?.("[tlon] Subscribed to channels firehose (/v2)");
-        // Subscribe to chat/DM firehose (/v3)
+        runtime.log?.("[tlon] Subscribed to channels firehose (/v4)");
+        // Subscribe to chat/DM firehose (/v4)
         await api.subscribe({
             app: "chat",
-            path: "/v3",
-            event: handleChatFirehose,
+            path: "/v4",
+            event: (data) => handleChatFirehose(data),
             err: (error) => {
                 runtime.error?.(`[tlon] Chat firehose error: ${String(error)}`);
             },
@@ -1492,7 +2047,7 @@ export async function monitorTlonProvider(opts = {}) {
                 runtime.log?.("[tlon] Chat firehose quit received, SSE client will resubscribe");
             },
         });
-        runtime.log?.("[tlon] Subscribed to chat firehose (/v3)");
+        runtime.log?.("[tlon] Subscribed to chat firehose (/v4)");
         // Subscribe to contacts updates to track nickname changes
         await api.subscribe({
             app: "contacts",
@@ -1502,18 +2057,24 @@ 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 +2083,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);
@@ -1543,8 +2104,34 @@ export async function monitorTlonProvider(opts = {}) {
         });
         runtime.log?.("[tlon] Subscribed to contacts updates (/v1/news)");
         // Subscribe to settings store for hot-reloading config
-        settingsManager.onChange((newSettings) => {
-            currentSettings = newSettings;
+        const applySettingsSnapshot = (newSettings, source, opts = {}) => {
+            const prevSettings = currentSettings;
+            // If pendingNudge has been rehydrated (startup succeeded or monitor has locally
+            // set/cleared it), the in-memory state is authoritative — refreshes cannot clobber
+            // it or resurrect stale store echoes. If not yet rehydrated (startup scry failed),
+            // allow the store value through so refresh can recover the persisted record.
+            let effectivePendingNudge;
+            if (pendingNudgeRehydrated) {
+                effectivePendingNudge = getPendingNudge(account.accountId) ?? undefined;
+            }
+            else if (newSettings.pendingNudge) {
+                syncPendingNudgeFromStore(account.accountId, newSettings.pendingNudge);
+                pendingNudgeRehydrated = true;
+                effectivePendingNudge = newSettings.pendingNudge;
+                runtime.log?.("[tlon] Settings refresh: recovered persisted pendingNudge after startup failure");
+            }
+            else {
+                effectivePendingNudge = undefined;
+            }
+            const nextRuntimeSettings = {
+                ...newSettings,
+                pendingNudge: effectivePendingNudge,
+            };
+            if (source === "refresh" &&
+                JSON.stringify(prevSettings) === JSON.stringify(nextRuntimeSettings)) {
+                currentSettings = nextRuntimeSettings;
+                return;
+            }
             // Update watched channels if settings changed
             if (newSettings.groupChannels?.length) {
                 const newChannels = newSettings.groupChannels;
@@ -1557,11 +2144,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) {
@@ -1594,20 +2180,68 @@ export async function monitorTlonProvider(opts = {}) {
                 effectiveAutoDiscoverChannels = newSettings.autoDiscoverChannels;
                 runtime.log?.(`[tlon] Settings: autoDiscoverChannels = ${effectiveAutoDiscoverChannels}`);
             }
-            // Update owner ship
-            if (newSettings.ownerShip !== undefined) {
-                effectiveOwnerShip = newSettings.ownerShip
-                    ? normalizeShip(newSettings.ownerShip)
-                    : account.ownerShip
-                        ? normalizeShip(account.ownerShip)
-                        : null;
+            // ownerShip is applied on both live subscription and refresh.
+            // pendingNudge is only rehydrated from the store during startup load. Once the
+            // monitor is running, the in-memory pending state is authoritative so refreshes
+            // cannot clobber live state or resurrect stale store echoes.
+            const sync = resolveSettingsMirrorSync({
+                prevSettings,
+                newSettings,
+                fileConfigOwnerShip: account.ownerShip ? normalizeShip(account.ownerShip) : null,
+            });
+            if (sync.ownerShipChanged) {
+                effectiveOwnerShip = sync.effectiveOwnerShip;
                 runtime.log?.(`[tlon] Settings: ownerShip = ${effectiveOwnerShip}`);
+                setEffectiveOwnerShip(account.accountId, effectiveOwnerShip);
+            }
+            // Reconcile the scheduler's owner-activity shadow with live settings
+            // changes. Subscription events are authoritative (real-time ship echo
+            // of a poke, admin override, test harness seeding). Refresh updates
+            // are trusted only when `load()` returned `{ fresh: true }` — on
+            // `fresh: false` the manager preserves the last-known snapshot, which
+            // may not yet reflect a locally observed owner reply the ship hasn't
+            // echoed back, so clobbering the shadow from that path would regress
+            // the fix that motivated the shadow in the first place.
+            //
+            // Gating on a prev/new diff means a subscription event for some
+            // unrelated key (e.g. channelRules) cannot reset the shadow via the
+            // snapshot's unchanged owner-activity fields.
+            const shadowReconcileTrusted = source === "subscription" || opts.fresh === true;
+            const ownerActivityChanged = prevSettings.lastOwnerMessageAt !== newSettings.lastOwnerMessageAt ||
+                prevSettings.lastOwnerMessageDate !== newSettings.lastOwnerMessageDate;
+            if (shadowReconcileTrusted && ownerActivityChanged) {
+                setLastOwnerActivity(account.accountId, ownerActivityFromSettings(newSettings));
+                runtime.log?.(`[tlon] nudge: reconciled lastOwnerActivity shadow from ${source} (at=${newSettings.lastOwnerMessageAt ?? "null"})`);
+            }
+            // Reconcile the scheduler's stage shadow with live `lastNudgeStage`
+            // changes for the same trust-and-diff reasons as the activity branch
+            // above. Without this, an external `%settings` clear (or admin
+            // lower) cannot move the in-memory guard down — the runner's
+            // `resolveAuthoritativeStage()` currently uses the shadow as the
+            // authoritative stage, so a stuck-high shadow suppresses later
+            // same-stage nudges.
+            //
+            // Trust gate: subscription events are real-time and only fire when
+            // storage actually transitioned, so they cannot represent a stale
+            // post-poke read. Refresh is trusted only when `load()` returned
+            // `{ fresh: true }`, matching the activity-shadow rule. Scry is
+            // still useful for drift logging, but it is not part of the
+            // runner's stage guard today.
+            const stageChanged = prevSettings.lastNudgeStage !== newSettings.lastNudgeStage;
+            if (shadowReconcileTrusted && stageChanged) {
+                const nextStage = (newSettings.lastNudgeStage ?? 0);
+                setLastNudgeStageShadow(account.accountId, nextStage);
+                runtime.log?.(`[tlon] nudge: reconciled lastNudgeStageShadow from ${source} (stage=${nextStage})`);
             }
             // Update pending approvals
             if (newSettings.pendingApprovals !== undefined) {
                 pendingApprovals = newSettings.pendingApprovals;
                 runtime.log?.(`[tlon] Settings: pendingApprovals updated (${pendingApprovals.length} items)`);
             }
+            currentSettings = nextRuntimeSettings;
+        };
+        settingsManager.onChange((newSettings) => {
+            applySettingsSnapshot(newSettings, "subscription");
         });
         try {
             await settingsManager.startSubscription();
@@ -1803,7 +2437,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 +2457,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 +2551,73 @@ 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 both authorization state and heartbeat telemetry mirrors stale.
+        const settingsRefreshInterval = setInterval(async () => {
+            if (opts.abortSignal?.aborted) {
+                return;
+            }
+            try {
+                const refreshResult = await settingsManager.load();
+                applySettingsSnapshot(refreshResult.settings, "refresh", { fresh: refreshResult.fresh });
+            }
+            catch (err) {
+                runtime.error?.(`[tlon] Settings refresh failed: ${String(err)}`);
+            }
+        }, SETTINGS_REFRESH_INTERVAL_MS);
+        // Plugin-owned re-engagement nudge scheduler. Owns tick lifecycle and
+        // reentrancy; runs independently of LLM heartbeat.
+        //
+        // Gating is computed by the pure `shouldStartNudgeRunner` helper; see
+        // that function for the two invariants (explicit opt-in flag + exactly
+        // one configured Tlon account).
+        //
+        // `TLON_NUDGE_TICK_INTERVAL_MS` exists so the integration harness can
+        // drive ticks on a short cadence without rebuilding the plugin; in
+        // production the default 15-minute interval applies.
+        const nudgeStartDecision = shouldStartNudgeRunner(cfg);
+        if (!nudgeStartDecision.start) {
+            runtime.log?.(`[tlon] nudge: scheduler disabled — ${nudgeStartDecision.detail}`);
+        }
+        else {
+            const intervalEnv = process.env.TLON_NUDGE_TICK_INTERVAL_MS;
+            const intervalMsOverride = intervalEnv ? Number(intervalEnv) : NaN;
+            nudgeRunner = createNudgeRunner({
+                accountId: account.accountId,
+                botShip: botShipName,
+                api,
+                cfg,
+                getSettings: () => currentSettings,
+                getEffectiveOwnerShip,
+                getLastOwnerActivity,
+                getLastNudgeStageShadow,
+                setLastNudgeStageShadow,
+                setLocalPendingNudge,
+                sendDm,
+                getBotProfile,
+                telemetry,
+                runtime,
+                abortSignal: opts.abortSignal,
+                ownerReplyPersistence,
+                ...(Number.isFinite(intervalMsOverride) && intervalMsOverride > 0
+                    ? { intervalMs: intervalMsOverride }
+                    : {}),
+            });
+            nudgeRunner.start();
+        }
         if (opts.abortSignal) {
             const signal = opts.abortSignal;
             await new Promise((resolve) => {
                 signal.addEventListener("abort", () => {
                     clearInterval(pollInterval);
+                    clearInterval(settingsRefreshInterval);
+                    // Kick off scheduler shutdown; don't block the event-handler
+                    // callback. The `finally` block awaits the same stop promise
+                    // before draining the persistence queues and closing the
+                    // api, so any in-flight tick is guaranteed to settle first.
+                    void nudgeRunner?.stop();
+                    gsManager?.stopHeartbeat();
                     resolve(null);
                 }, { once: true });
             });
@@ -1929,6 +2627,17 @@ export async function monitorTlonProvider(opts = {}) {
         }
     }
     finally {
+        removeBridge(accountKey, commandBridge);
+        // Await the scheduler drain before flushing persistence queues.
+        // `stop()` waits for any in-flight tick to finish so its final
+        // `setLocalPendingNudge` / `enqueueStageClear` / etc. writes land
+        // inside the queues we flush below, rather than leaking into a
+        // half-closed api after cleanup.
+        await nudgeRunner?.stop();
+        await ownerReplyPersistence.flush();
+        await pendingNudgePersistence.flush();
+        clearShadowsForAccount(account.accountId);
+        await telemetry?.close();
         try {
             await api?.close();
         }