@tloncorp/openclaw 0.4.1 → 0.4.3

package/dist/src/monitor/index.js

@@ -3,11 +3,12 @@ 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 { handleOwnerListenCommand } from "../owner-listen-command.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 { canonicalizeNest, normalizeShip, parseChannelNest } from "../targets.js";
 import { createTlonTelemetry } from "../telemetry.js";
 import { resolveTlonAccount } from "../types.js";
 import { configureTlonApiWithPoke } from "../urbit/api-client.js";
@@ -20,7 +21,7 @@ import { createPendingApproval, formatApprovalRequest, formatApprovalConfirmatio
 import { setBridge, removeBridge } from "./command-bridge.js";
 import { createComputingPresenceTracker } from "./computing-presence.js";
 import { fetchAllChannels, fetchInitData } from "./discovery.js";
-import { cacheMessage, lookupCachedMessage, getChannelHistory, fetchChannelHistory, fetchThreadHistory, } from "./history.js";
+import { cacheMessage, buildThreadContextMessage, lookupCachedMessage, getChannelHistory, fetchChannelHistory, fetchThreadContextHistory, } 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";
@@ -28,7 +29,7 @@ import { createOwnerReplyPersistenceQueue } from "./owner-reply-persistence.js";
 import { createPendingNudgePersistenceQueue } from "./pending-nudge-persistence.js";
 import { createProcessedMessageTracker } from "./processed-messages.js";
 import { resolveSettingsMirrorSync } from "./settings-sync.js";
-import { extractMessageText, extractCites, formatModelName, isBotMentioned, stripBotMention, isDmAllowed, isSummarizationRequest, sanitizeMessageText, } from "./utils.js";
+import { extractMessageText, extractCites, formatModelName, isBotMentioned, isOwnerListenSlashCommand, stripBotMention, isDmAllowed, isSummarizationRequest, sanitizeMessageText, shouldEngageInGroup, } 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;
 /**
@@ -161,6 +162,19 @@ export async function monitorTlonProvider(opts = {}) {
         ? normalizeShip(account.ownerShip)
         : null;
     setEffectiveOwnerShip(account.accountId, effectiveOwnerShip);
+    let effectiveOwnerListenEnabled = account.ownerListenEnabled ?? true;
+    // Canonicalize on every read so an entry stored from a slightly-off user
+    // input (e.g. missing "~" or wrong case) still matches incoming nest events.
+    const canonicalizeNestList = (list) => {
+        const out = new Set();
+        for (const raw of list) {
+            const canonical = canonicalizeNest(raw);
+            if (canonical)
+                out.add(canonical);
+        }
+        return [...out];
+    };
+    let effectiveOwnerListenDisabled = new Set(canonicalizeNestList(account.ownerListenDisabledChannels ?? []));
     let pendingApprovals = [];
     let currentSettings = {};
     // Tracks whether pendingNudge has been successfully rehydrated from the settings
@@ -392,6 +406,14 @@ export async function monitorTlonProvider(opts = {}) {
             setEffectiveOwnerShip(account.accountId, effectiveOwnerShip);
             runtime.log?.(`[tlon] Using ownerShip from settings store: ${effectiveOwnerShip}`);
         }
+        if (currentSettings.ownerListenEnabled !== undefined) {
+            effectiveOwnerListenEnabled = currentSettings.ownerListenEnabled;
+            runtime.log?.(`[tlon] Using ownerListenEnabled from settings store: ${effectiveOwnerListenEnabled}`);
+        }
+        if (currentSettings.ownerListenDisabledChannels !== undefined) {
+            effectiveOwnerListenDisabled = new Set(canonicalizeNestList(currentSettings.ownerListenDisabledChannels));
+            runtime.log?.(`[tlon] Loaded ${effectiveOwnerListenDisabled.size} owner-listen-disabled channel(s) from settings`);
+        }
         // 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.
@@ -478,7 +500,9 @@ export async function monitorTlonProvider(opts = {}) {
                     gsManager.waitForGatewayStart().then(() => "started"),
                     ...(signal
                         ? [
-                            new Promise((r) => signal.addEventListener("abort", () => r("aborted"), { once: true })),
+                            new Promise((r) => signal.addEventListener("abort", () => r("aborted"), {
+                                once: true,
+                            })),
                         ]
                         : []),
                 ]);
@@ -661,7 +685,10 @@ export async function monitorTlonProvider(opts = {}) {
     async function addToChannelAllowlist(ship, channelNest) {
         const normalizedShip = normalizeShip(ship);
         const channelRules = currentSettings.channelRules ?? {};
-        const rule = channelRules[channelNest] ?? { mode: "restricted", allowedShips: [] };
+        const rule = channelRules[channelNest] ?? {
+            mode: "restricted",
+            allowedShips: [],
+        };
         const allowedShips = [...(rule.allowedShips ?? [])]; // Clone to avoid mutation
         if (!allowedShips.includes(normalizedShip)) {
             allowedShips.push(normalizedShip);
@@ -990,6 +1017,88 @@ export async function monitorTlonProvider(opts = {}) {
             const success = await unblockShip(ship);
             return success ? `Unblocked ${ship}.` : `Failed to unblock ${ship}.`;
         },
+        // ── Owner-listen controls ────────────────────────────────────────────
+        isOwnedChannel(nest) {
+            // Canonicalize first so case variants in user input (e.g.
+            // `chat/~ZOD/general`) match the lowercase owner/bot ship strings.
+            const canonical = canonicalizeNest(nest);
+            if (!canonical) {
+                return false;
+            }
+            const parsed = parseChannelNest(canonical);
+            if (!parsed) {
+                return false;
+            }
+            return parsed.hostShip === effectiveOwnerShip || parsed.hostShip === botShipName;
+        },
+        getOwnerListenGlobal() {
+            return effectiveOwnerListenEnabled;
+        },
+        async setOwnerListenGlobal(enabled) {
+            effectiveOwnerListenEnabled = enabled;
+            try {
+                await api.poke({
+                    app: "settings",
+                    mark: "settings-event",
+                    json: {
+                        "put-entry": {
+                            desk: "moltbot",
+                            "bucket-key": "tlon",
+                            "entry-key": "ownerListenEnabled",
+                            value: enabled,
+                        },
+                    },
+                });
+                runtime.log?.(`[tlon] ownerListenEnabled → ${enabled}`);
+            }
+            catch (err) {
+                runtime.error?.(`[tlon] Failed to persist ownerListenEnabled: ${String(err)}`);
+            }
+            return enabled;
+        },
+        isOwnerListenDisabled(nest) {
+            const canonical = canonicalizeNest(nest);
+            if (!canonical) {
+                return false;
+            }
+            return effectiveOwnerListenDisabled.has(canonical);
+        },
+        async setOwnerListenDisabled(nest, disabled) {
+            const canonical = canonicalizeNest(nest);
+            if (!canonical) {
+                runtime.error?.(`[tlon] setOwnerListenDisabled: cannot parse nest ${nest}`);
+                return !disabled;
+            }
+            if (disabled) {
+                effectiveOwnerListenDisabled.add(canonical);
+            }
+            else {
+                effectiveOwnerListenDisabled.delete(canonical);
+            }
+            const list = [...effectiveOwnerListenDisabled];
+            try {
+                await api.poke({
+                    app: "settings",
+                    mark: "settings-event",
+                    json: {
+                        "put-entry": {
+                            desk: "moltbot",
+                            "bucket-key": "tlon",
+                            "entry-key": "ownerListenDisabledChannels",
+                            value: list,
+                        },
+                    },
+                });
+                runtime.log?.(`[tlon] ownerListenDisabledChannels → [${list.join(", ")}]`);
+            }
+            catch (err) {
+                runtime.error?.(`[tlon] Failed to persist ownerListenDisabledChannels: ${String(err)}`);
+            }
+            return !disabled;
+        },
+        listOwnerListenDisabled() {
+            return [...effectiveOwnerListenDisabled];
+        },
     };
     setBridge(accountKey, commandBridge);
     // Check if a ship is the owner (always allowed to DM)
@@ -1139,17 +1248,16 @@ export async function monitorTlonProvider(opts = {}) {
         // 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(-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
-                    const contextNote = `[Thread conversation - ${threadHistory.length} previous replies. You are participating in this thread. Only respond if relevant or helpful - you don't need to reply to every message.]`;
-                    messageText = `${contextNote}\n\n[Previous messages]\n${threadContext}\n\n[Current message]\n${messageText}`;
-                    runtime?.log?.(`[tlon] Added thread context (${threadHistory.length} replies) to message`);
+                const threadContextHistory = await fetchThreadContextHistory(api, groupChannel, parentId, 20, runtime);
+                if (threadContextHistory.length > 0) {
+                    const threadContextMessage = buildThreadContextMessage(threadContextHistory, messageText, {
+                        formatAuthor: formatShipWithNickname,
+                        sanitizeContent: sanitizeMessageText,
+                    });
+                    if (threadContextMessage) {
+                        messageText = threadContextMessage.messageText;
+                        runtime?.log?.(`[tlon] Added thread context (${threadContextMessage.contextMessages.length} messages, parent included) to message`);
+                    }
                 }
             }
             catch (error) {
@@ -1352,7 +1460,10 @@ export async function monitorTlonProvider(opts = {}) {
             OriginatingChannel: "tlon",
             OriginatingTo: `tlon:${isGroup ? groupChannel : senderShip}`,
             // Include thread context for automatic reply routing
-            ...(parentId && { MessageThreadId: String(parentId), ReplyToId: String(parentId) }),
+            ...(parentId && {
+                MessageThreadId: String(parentId),
+                ReplyToId: String(parentId),
+            }),
         });
         const dispatchStartTime = Date.now();
         const replyTelemetry = telemetry?.startReply({
@@ -1541,7 +1652,8 @@ export async function monitorTlonProvider(opts = {}) {
             }
             // Auto-watch channels from firehose: if we receive events for a channel,
             // the bot is a member of the group — add it to watchedChannels automatically.
-            if (!watchedChannels.has(nest) && (nest.startsWith("chat/") || nest.startsWith("heap/"))) {
+            if (!watchedChannels.has(nest) &&
+                (nest.startsWith("chat/") || nest.startsWith("heap/") || nest.startsWith("diary/"))) {
                 watchedChannels.add(nest);
                 runtime.log?.(`[tlon] Auto-watching channel from firehose: ${nest}`);
             }
@@ -1671,17 +1783,59 @@ export async function monitorTlonProvider(opts = {}) {
                 ? response?.post?.["r-post"]?.reply?.["r-reply"]?.set?.seal
                 : response?.post?.["r-post"]?.set?.seal;
             const parentId = seal?.["parent-id"] || seal?.parent || null;
+            const parsedDispatchNest = parseChannelNest(nest);
+            // Control-plane escape hatch: owner-listen may be disabled, but the owner
+            // still needs a no-mention way to turn it back on from the same owned
+            // channel. Handle the exact slash command before the normal engagement
+            // gate, without waking the agent/model for ordinary chatter.
+            if (isOwnerListenSlashCommand(rawText) &&
+                isOwner(senderShip) &&
+                parsedDispatchNest &&
+                (parsedDispatchNest.hostShip === effectiveOwnerShip ||
+                    parsedDispatchNest.hostShip === botShipName)) {
+                const args = rawText
+                    .trim()
+                    .replace(/^\/owner-listen(?:\s+|$)/i, "")
+                    .trim();
+                const replyText = await handleOwnerListenCommand(commandBridge, args, `tlon:group:${nest}`);
+                await sendChannelPost({
+                    botProfile: getBotProfile(),
+                    fromShip: botShipName,
+                    nest,
+                    story: markdownToStory(replyText),
+                    replyToId: parentId ?? undefined,
+                });
+                return;
+            }
             // Check if we should respond:
             // 1. Direct mention always triggers response
             // 2. Thread replies where we've participated - respond if relevant (let agent decide)
+            // 3. Owner blob-only message (image/file with no text from owner)
+            // 4. Owner-listen: owner posts in an owner/bot-hosted channel and the
+            //    channel is not in the per-channel disabled list
             const mentioned = isBotMentioned(messageText, botShipName, botNickname ?? undefined);
-            const inParticipatedThread = isThreadReply && parentId && participatedThreads.has(String(parentId));
+            const inParticipatedThread = Boolean(isThreadReply && parentId && participatedThreads.has(String(parentId)));
             const isOwnerBlob = hasBlob && isOwner(senderShip);
-            if (!mentioned && !inParticipatedThread && !isOwnerBlob) {
+            const engageDecision = shouldEngageInGroup({
+                mentioned,
+                inParticipatedThread,
+                isOwnerBlob,
+                senderShip,
+                ownerShip: effectiveOwnerShip,
+                botShipName,
+                channelNest: nest,
+                groupHost: parsedDispatchNest?.hostShip ?? null,
+                ownerListenEnabled: effectiveOwnerListenEnabled,
+                ownerListenDisabledChannels: effectiveOwnerListenDisabled,
+            });
+            if (!engageDecision.engage) {
                 return;
             }
             // Log why we're responding
-            if (isOwnerBlob && !mentioned && !inParticipatedThread) {
+            if (engageDecision.reason === "owner-owned") {
+                runtime.log?.(`[tlon] Owner ${senderShip} heard without mention in owned channel ${nest}`);
+            }
+            else if (isOwnerBlob && !mentioned && !inParticipatedThread) {
                 runtime.log?.(`[tlon] Responding to owner blob-only message in ${nest}`);
             }
             else if (inParticipatedThread && !mentioned) {
@@ -2180,6 +2334,14 @@ export async function monitorTlonProvider(opts = {}) {
                 effectiveAutoDiscoverChannels = newSettings.autoDiscoverChannels;
                 runtime.log?.(`[tlon] Settings: autoDiscoverChannels = ${effectiveAutoDiscoverChannels}`);
             }
+            if (newSettings.ownerListenEnabled !== undefined) {
+                effectiveOwnerListenEnabled = newSettings.ownerListenEnabled;
+                runtime.log?.(`[tlon] Settings: ownerListenEnabled = ${effectiveOwnerListenEnabled}`);
+            }
+            if (newSettings.ownerListenDisabledChannels !== undefined) {
+                effectiveOwnerListenDisabled = new Set(canonicalizeNestList(newSettings.ownerListenDisabledChannels));
+                runtime.log?.(`[tlon] Settings: ownerListenDisabledChannels updated (${effectiveOwnerListenDisabled.size} channel(s) disabled)`);
+            }
             // 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
@@ -2229,7 +2391,7 @@ export async function monitorTlonProvider(opts = {}) {
             // runner's stage guard today.
             const stageChanged = prevSettings.lastNudgeStage !== newSettings.lastNudgeStage;
             if (shadowReconcileTrusted && stageChanged) {
-                const nextStage = (newSettings.lastNudgeStage ?? 0);
+                const nextStage = newSettings.lastNudgeStage ?? 0;
                 setLastNudgeStageShadow(account.accountId, nextStage);
                 runtime.log?.(`[tlon] nudge: reconciled lastNudgeStageShadow from ${source} (stage=${nextStage})`);
             }
@@ -2292,8 +2454,10 @@ export async function monitorTlonProvider(opts = {}) {
                             if (event.channels && typeof event.channels === "object") {
                                 const channels = event.channels;
                                 for (const [channelNest, _channelData] of Object.entries(channels)) {
-                                    // Only monitor chat and heap channels
-                                    if (!channelNest.startsWith("chat/") && !channelNest.startsWith("heap/")) {
+                                    // Only monitor chat, heap, and diary channels
+                                    if (!channelNest.startsWith("chat/") &&
+                                        !channelNest.startsWith("heap/") &&
+                                        !channelNest.startsWith("diary/")) {
                                         continue;
                                     }
                                     // If this is a new channel we're not watching yet, add it
@@ -2334,7 +2498,9 @@ export async function monitorTlonProvider(opts = {}) {
                                 const join = event.join;
                                 if (join.channels) {
                                     for (const channelNest of join.channels) {
-                                        if (!channelNest.startsWith("chat/") && !channelNest.startsWith("heap/")) {
+                                        if (!channelNest.startsWith("chat/") &&
+                                            !channelNest.startsWith("heap/") &&
+                                            !channelNest.startsWith("diary/")) {
                                             continue;
                                         }
                                         if (!watchedChannels.has(channelNest)) {
@@ -2560,7 +2726,9 @@ export async function monitorTlonProvider(opts = {}) {
             }
             try {
                 const refreshResult = await settingsManager.load();
-                applySettingsSnapshot(refreshResult.settings, "refresh", { fresh: refreshResult.fresh });
+                applySettingsSnapshot(refreshResult.settings, "refresh", {
+                    fresh: refreshResult.fresh,
+                });
             }
             catch (err) {
                 runtime.error?.(`[tlon] Settings refresh failed: ${String(err)}`);