tide-commander 1.146.0 → 1.147.1

package/dist/assets/{web-5BrjMiIU.js → web-B-xc0c6e.js}

@@ -1 +1 @@
-import{c$ as t}from"./main-BhpZ8DMy.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class o extends t{constructor(){super(),this.handleVisibilityChange=()=>{const e={isActive:document.hidden!==!0};this.notifyListeners("appStateChange",e),document.hidden?this.notifyListeners("pause",null):this.notifyListeners("resume",null)},document.addEventListener("visibilitychange",this.handleVisibilityChange,!1)}exitApp(){throw this.unimplemented("Not implemented on web.")}async getInfo(){throw this.unimplemented("Not implemented on web.")}async getLaunchUrl(){return{url:""}}async getState(){return{isActive:document.hidden!==!0}}async minimizeApp(){throw this.unimplemented("Not implemented on web.")}async toggleBackButtonHandler(){throw this.unimplemented("Not implemented on web.")}async getAppLanguage(){return{value:navigator.language.split("-")[0].toLowerCase()}}}export{o as AppWeb};
+import{c$ as t}from"./main-Bp6V_-sL.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class o extends t{constructor(){super(),this.handleVisibilityChange=()=>{const e={isActive:document.hidden!==!0};this.notifyListeners("appStateChange",e),document.hidden?this.notifyListeners("pause",null):this.notifyListeners("resume",null)},document.addEventListener("visibilitychange",this.handleVisibilityChange,!1)}exitApp(){throw this.unimplemented("Not implemented on web.")}async getInfo(){throw this.unimplemented("Not implemented on web.")}async getLaunchUrl(){return{url:""}}async getState(){return{isActive:document.hidden!==!0}}async minimizeApp(){throw this.unimplemented("Not implemented on web.")}async toggleBackButtonHandler(){throw this.unimplemented("Not implemented on web.")}async getAppLanguage(){return{value:navigator.language.split("-")[0].toLowerCase()}}}export{o as AppWeb};

package/dist/assets/{web-Cx4v8f8d.js → web-BuDeKWBN.js}

@@ -1 +1 @@
-import{c$ as a}from"./main-BhpZ8DMy.js";import{ImpactStyle as i,NotificationType as r}from"./index-DtUDyvyC.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class h extends a{constructor(){super(...arguments),this.selectionStarted=!1}async impact(t){const e=this.patternForImpact(t==null?void 0:t.style);this.vibrateWithPattern(e)}async notification(t){const e=this.patternForNotification(t==null?void 0:t.type);this.vibrateWithPattern(e)}async vibrate(t){const e=(t==null?void 0:t.duration)||300;this.vibrateWithPattern([e])}async selectionStart(){this.selectionStarted=!0}async selectionChanged(){this.selectionStarted&&this.vibrateWithPattern([70])}async selectionEnd(){this.selectionStarted=!1}patternForImpact(t=i.Heavy){return t===i.Medium?[43]:t===i.Light?[20]:[61]}patternForNotification(t=r.Success){return t===r.Warning?[30,40,30,50,60]:t===r.Error?[27,45,50]:[35,65,21]}vibrateWithPattern(t){if(navigator.vibrate)navigator.vibrate(t);else throw this.unavailable("Browser does not support the vibrate API")}}export{h as HapticsWeb};
+import{c$ as a}from"./main-Bp6V_-sL.js";import{ImpactStyle as i,NotificationType as r}from"./index-xBtKu0I8.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class h extends a{constructor(){super(...arguments),this.selectionStarted=!1}async impact(t){const e=this.patternForImpact(t==null?void 0:t.style);this.vibrateWithPattern(e)}async notification(t){const e=this.patternForNotification(t==null?void 0:t.type);this.vibrateWithPattern(e)}async vibrate(t){const e=(t==null?void 0:t.duration)||300;this.vibrateWithPattern([e])}async selectionStart(){this.selectionStarted=!0}async selectionChanged(){this.selectionStarted&&this.vibrateWithPattern([70])}async selectionEnd(){this.selectionStarted=!1}patternForImpact(t=i.Heavy){return t===i.Medium?[43]:t===i.Light?[20]:[61]}patternForNotification(t=r.Success){return t===r.Warning?[30,40,30,50,60]:t===r.Error?[27,45,50]:[35,65,21]}vibrateWithPattern(t){if(navigator.vibrate)navigator.vibrate(t);else throw this.unavailable("Browser does not support the vibrate API")}}export{h as HapticsWeb};

package/dist/assets/{web-DpsRRzsh.js → web-DlzqHyn8.js}

@@ -1 +1 @@
-import{c$ as s}from"./main-BhpZ8DMy.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class l extends s{constructor(){super(...arguments),this.pending=[],this.deliveredNotifications=[],this.hasNotificationSupport=()=>{if(!("Notification"in window)||!Notification.requestPermission)return!1;if(Notification.permission!=="granted")try{new Notification("")}catch(i){if(i instanceof Error&&i.name==="TypeError")return!1}return!0}}async getDeliveredNotifications(){const i=[];for(const t of this.deliveredNotifications){const e={title:t.title,id:parseInt(t.tag),body:t.body};i.push(e)}return{notifications:i}}async removeDeliveredNotifications(i){for(const t of i.notifications){const e=this.deliveredNotifications.find(n=>n.tag===String(t.id));e==null||e.close(),this.deliveredNotifications=this.deliveredNotifications.filter(()=>!e)}}async removeAllDeliveredNotifications(){for(const i of this.deliveredNotifications)i.close();this.deliveredNotifications=[]}async createChannel(){throw this.unimplemented("Not implemented on web.")}async deleteChannel(){throw this.unimplemented("Not implemented on web.")}async listChannels(){throw this.unimplemented("Not implemented on web.")}async schedule(i){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");for(const t of i.notifications)this.sendNotification(t);return{notifications:i.notifications.map(t=>({id:t.id}))}}async getPending(){return{notifications:this.pending}}async registerActionTypes(){throw this.unimplemented("Not implemented on web.")}async cancel(i){this.pending=this.pending.filter(t=>!i.notifications.find(e=>e.id===t.id))}async areEnabled(){const{display:i}=await this.checkPermissions();return{value:i==="granted"}}async changeExactNotificationSetting(){throw this.unimplemented("Not implemented on web.")}async checkExactNotificationSetting(){throw this.unimplemented("Not implemented on web.")}async requestPermissions(){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");return{display:this.transformNotificationPermission(await Notification.requestPermission())}}async checkPermissions(){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");return{display:this.transformNotificationPermission(Notification.permission)}}transformNotificationPermission(i){switch(i){case"granted":return"granted";case"denied":return"denied";default:return"prompt"}}sendPending(){var i;const t=[],e=new Date().getTime();for(const n of this.pending)!((i=n.schedule)===null||i===void 0)&&i.at&&n.schedule.at.getTime()<=e&&(this.buildNotification(n),t.push(n));this.pending=this.pending.filter(n=>!t.find(o=>o===n))}sendNotification(i){var t;if(!((t=i.schedule)===null||t===void 0)&&t.at){const e=i.schedule.at.getTime()-new Date().getTime();this.pending.push(i),setTimeout(()=>{this.sendPending()},e);return}this.buildNotification(i)}buildNotification(i){const t=new Notification(i.title,{body:i.body,tag:String(i.id)});return t.addEventListener("click",this.onClick.bind(this,i),!1),t.addEventListener("show",this.onShow.bind(this,i),!1),t.addEventListener("close",()=>{this.deliveredNotifications=this.deliveredNotifications.filter(()=>!this)},!1),this.deliveredNotifications.push(t),t}onClick(i){const t={actionId:"tap",notification:i};this.notifyListeners("localNotificationActionPerformed",t)}onShow(i){this.notifyListeners("localNotificationReceived",i)}}export{l as LocalNotificationsWeb};
+import{c$ as s}from"./main-Bp6V_-sL.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class l extends s{constructor(){super(...arguments),this.pending=[],this.deliveredNotifications=[],this.hasNotificationSupport=()=>{if(!("Notification"in window)||!Notification.requestPermission)return!1;if(Notification.permission!=="granted")try{new Notification("")}catch(i){if(i instanceof Error&&i.name==="TypeError")return!1}return!0}}async getDeliveredNotifications(){const i=[];for(const t of this.deliveredNotifications){const e={title:t.title,id:parseInt(t.tag),body:t.body};i.push(e)}return{notifications:i}}async removeDeliveredNotifications(i){for(const t of i.notifications){const e=this.deliveredNotifications.find(n=>n.tag===String(t.id));e==null||e.close(),this.deliveredNotifications=this.deliveredNotifications.filter(()=>!e)}}async removeAllDeliveredNotifications(){for(const i of this.deliveredNotifications)i.close();this.deliveredNotifications=[]}async createChannel(){throw this.unimplemented("Not implemented on web.")}async deleteChannel(){throw this.unimplemented("Not implemented on web.")}async listChannels(){throw this.unimplemented("Not implemented on web.")}async schedule(i){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");for(const t of i.notifications)this.sendNotification(t);return{notifications:i.notifications.map(t=>({id:t.id}))}}async getPending(){return{notifications:this.pending}}async registerActionTypes(){throw this.unimplemented("Not implemented on web.")}async cancel(i){this.pending=this.pending.filter(t=>!i.notifications.find(e=>e.id===t.id))}async areEnabled(){const{display:i}=await this.checkPermissions();return{value:i==="granted"}}async changeExactNotificationSetting(){throw this.unimplemented("Not implemented on web.")}async checkExactNotificationSetting(){throw this.unimplemented("Not implemented on web.")}async requestPermissions(){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");return{display:this.transformNotificationPermission(await Notification.requestPermission())}}async checkPermissions(){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");return{display:this.transformNotificationPermission(Notification.permission)}}transformNotificationPermission(i){switch(i){case"granted":return"granted";case"denied":return"denied";default:return"prompt"}}sendPending(){var i;const t=[],e=new Date().getTime();for(const n of this.pending)!((i=n.schedule)===null||i===void 0)&&i.at&&n.schedule.at.getTime()<=e&&(this.buildNotification(n),t.push(n));this.pending=this.pending.filter(n=>!t.find(o=>o===n))}sendNotification(i){var t;if(!((t=i.schedule)===null||t===void 0)&&t.at){const e=i.schedule.at.getTime()-new Date().getTime();this.pending.push(i),setTimeout(()=>{this.sendPending()},e);return}this.buildNotification(i)}buildNotification(i){const t=new Notification(i.title,{body:i.body,tag:String(i.id)});return t.addEventListener("click",this.onClick.bind(this,i),!1),t.addEventListener("show",this.onShow.bind(this,i),!1),t.addEventListener("close",()=>{this.deliveredNotifications=this.deliveredNotifications.filter(()=>!this)},!1),this.deliveredNotifications.push(t),t}onClick(i){const t={actionId:"tap",notification:i};this.notifyListeners("localNotificationActionPerformed",t)}onShow(i){this.notifyListeners("localNotificationReceived",i)}}export{l as LocalNotificationsWeb};

package/dist/index.html

@@ -22,7 +22,7 @@
     <link rel="icon" type="image/png" sizes="16x16" href="/assets/icons/favicon-16x16.png" />
     <link rel="apple-touch-icon" sizes="180x180" href="/assets/icons/apple-touch-icon.png" />
     <title>Tide Commander</title>
-    <script type="module" crossorigin src="/assets/main-BhpZ8DMy.js"></script>
+    <script type="module" crossorigin src="/assets/main-Bp6V_-sL.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/vendor-react--Eh9ivFN.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-three-Chj50gSY.js">
     <link rel="stylesheet" crossorigin href="/assets/main-ijcbyjBn.css">

package/dist/locales/en/config.json

@@ -568,7 +568,8 @@
     "autoUpdatePackageManagerNotice": "Auto-update only supports npm-installed globals. Detected: {{pm}}.",
     "unattendedTitle": "Automatic updates",
     "unattendedDesc": "Install updates automatically when no agent is working (checks every 30 min)",
-    "unattendedPendingRestart": "v{{version}} installed — will restart as soon as all agents are idle"
+    "unattendedPendingRestart": "v{{version}} installed — will restart as soon as all agents are idle",
+    "unattendedUnsupported": "Only available for npm global installs (runs on the server, not in dev mode)"
   },
   "updateBanner": {
     "newVersion": "New version v{{version}} available",

package/dist/locales/es/config.json

@@ -315,7 +315,8 @@
     "claudeCodeCredit": "por Anthropic, el motor de IA",
     "unattendedTitle": "Actualizaciones automáticas",
     "unattendedDesc": "Instalar actualizaciones automáticamente cuando ningún agente esté trabajando (revisa cada 30 min)",
-    "unattendedPendingRestart": "v{{version}} instalada — se reiniciará en cuanto todos los agentes estén libres"
+    "unattendedPendingRestart": "v{{version}} instalada — se reiniciará en cuanto todos los agentes estén libres",
+    "unattendedUnsupported": "Solo disponible en instalaciones globales de npm (corre en el servidor, no en modo dev)"
   },
   "shortcuts": {
     "pressKeys": "Presione teclas...",

package/dist/src/packages/server/data/event-queries.js

@@ -78,6 +78,30 @@ function slackRowToEvent(row) {
         integrationInstanceId: row.integration_instance_id ?? 'default',
     };
 }
+/**
+ * Channels + threads with Slack activity since `sinceMs` for one integration
+ * instance. Seeds the polling reconciler's thread registry on startup so
+ * per-thread sweeps survive process restarts. Only rows that carry a
+ * thread_ts count — a thread where an agent engaged always has at least the
+ * bot's own mirrored reply.
+ */
+export function recentSlackThreadActivity(instanceId, sinceMs) {
+    const rows = queryMany(`SELECT channel_id, thread_ts, MAX(received_at) AS last_ms
+       FROM slack_messages
+      WHERE integration_instance_id = ? AND thread_ts IS NOT NULL AND received_at > ?
+      GROUP BY channel_id, thread_ts`, [instanceId, sinceMs]);
+    return rows.map((r) => ({ channelId: r.channel_id, threadTs: r.thread_ts, lastActivityMs: r.last_ms }));
+}
+/**
+ * True when a message with this (channel, ts) is already logged for the given
+ * integration instance. Used by the Slack socket-mode reconciler to skip
+ * messages the live socket already dispatched — including across process
+ * restarts, which the in-memory dedup set alone can't cover.
+ */
+export function hasSlackMessage(instanceId, channelId, ts) {
+    const row = queryOne('SELECT id FROM slack_messages WHERE channel_id = ? AND ts = ? AND integration_instance_id = ? LIMIT 1', [channelId, ts, instanceId]);
+    return row !== undefined;
+}
 export function logSlackMessage(msg) {
     return insertOne('slack_messages', {
         ts: msg.ts,

package/dist/src/packages/server/data/migrations/008_slack_messages_chan_ts_index.sql

@@ -0,0 +1,5 @@
+-- Fast (channel_id, ts) point lookups for the Slack socket-mode reconciler
+-- dedup check: the reconciler re-fetches recent history every cycle and must
+-- cheaply skip messages Socket Mode already dispatched, including across
+-- process restarts (where the in-memory dedup set is empty).
+CREATE INDEX IF NOT EXISTS idx_slack_messages_chan_ts ON slack_messages(channel_id, ts);

package/dist/src/packages/server/index.js

@@ -79,6 +79,8 @@ async function main() {
         eventDb: {
             logTriggerFire: eventQueries.logTriggerFire,
             logSlackMessage: eventQueries.logSlackMessage,
+            hasSlackMessage: eventQueries.hasSlackMessage,
+            recentSlackThreadActivity: eventQueries.recentSlackThreadActivity,
             logWhatsAppMessage: eventQueries.logWhatsAppMessage,
             logEmailMessage: eventQueries.logEmailMessage,
             logApprovalEvent: eventQueries.logApprovalEvent,

package/dist/src/packages/server/integrations/slack/slack-config.js

@@ -18,6 +18,7 @@ const DEFAULT_CONFIG = {
     pollingDmsAlways: true,
     pollingMinMsBetweenCalls: 1500,
     pollingUseSearch: false,
+    socketReconcileEnabled: true,
     mirrorOwnMessages: false,
     reactOnTrigger: true,
     currentMode: 'none',
@@ -194,6 +195,14 @@ export const slackConfigSchema = [
         defaultValue: false,
         group: 'Polling',
     },
+    {
+        key: 'socketReconcileEnabled',
+        label: 'Socket Mode: polling reconciler',
+        type: 'boolean',
+        description: 'When inbound mode is Socket, also run the polling sweep in the background to recover messages the socket dropped (disconnects, ping-timeout flaps, process restarts). Uses the Polling settings above; duplicates are filtered by (channel, ts). Default on.',
+        defaultValue: true,
+        group: 'Polling',
+    },
     {
         key: 'mirrorOwnMessages',
         label: 'Mirror messages I send too',
@@ -251,6 +260,7 @@ export function getConfigValues(secrets, instanceId = DEFAULT_INSTANCE_ID) {
         pollingDmsAlways: config.pollingDmsAlways ?? true,
         pollingMinMsBetweenCalls: config.pollingMinMsBetweenCalls ?? 1500,
         pollingUseSearch: config.pollingUseSearch ?? false,
+        socketReconcileEnabled: config.socketReconcileEnabled ?? true,
         mirrorOwnMessages: config.mirrorOwnMessages ?? false,
         reactOnTrigger: config.reactOnTrigger ?? true,
         currentMode: config.currentMode ?? 'none',
@@ -303,6 +313,9 @@ export async function setConfigValues(values, secrets, instanceId = DEFAULT_INST
     if (typeof values.pollingUseSearch === 'boolean') {
         updates.pollingUseSearch = values.pollingUseSearch;
     }
+    if (typeof values.socketReconcileEnabled === 'boolean') {
+        updates.socketReconcileEnabled = values.socketReconcileEnabled;
+    }
     if (typeof values.mirrorOwnMessages === 'boolean') {
         updates.mirrorOwnMessages = values.mirrorOwnMessages;
     }

package/dist/src/packages/server/integrations/slack/slack-instance.js

@@ -62,9 +62,26 @@ export class SlackInstance {
     nameCache = new SlackNameCache();
     messageListeners = new Set();
     replyWaiters = new Set();
+    /**
+     * (channel:ts) keys already dispatched by THIS process. With the socket +
+     * reconciler hybrid both transports funnel into dispatchInboundMessage, so
+     * every message can arrive twice — the Set (insertion-ordered, capped)
+     * short-circuits the overlap synchronously; the SQLite check in the
+     * dispatcher covers keys dispatched before a restart wiped this Set.
+     */
+    dispatchedKeys = new Set();
+    static DISPATCHED_KEYS_MAX = 4096;
     constructor(id) {
         this.id = id;
     }
+    rememberDispatched(key) {
+        this.dispatchedKeys.add(key);
+        if (this.dispatchedKeys.size > SlackInstance.DISPATCHED_KEYS_MAX) {
+            const oldest = this.dispatchedKeys.values().next().value;
+            if (oldest !== undefined)
+                this.dispatchedKeys.delete(oldest);
+        }
+    }
     setContext(ctx) {
         this.ctx = ctx;
     }
@@ -140,6 +157,16 @@ export class SlackInstance {
                 this.setupSocketHandlers();
                 await this.socketClient.start();
                 this.ctx?.log.info(`Slack[${this.id}] connected as @${botName} (${botUserId}) via socket mode`);
+                if (config.socketReconcileEnabled !== false) {
+                    // Socket Mode has no replay: envelopes dropped during disconnects,
+                    // ping-timeout flaps, or process restarts are lost forever. Run the
+                    // polling sweep alongside as a reconciler — the (channel, ts) dedup
+                    // in dispatchInboundMessage suppresses the overlap, so agents see
+                    // each message exactly once: live via socket, or ≤1 poll cycle
+                    // later if the socket dropped it.
+                    await this.startPollingMode();
+                    this.ctx?.log.info(`Slack[${this.id}] reconciler armed: polling sweep running alongside Socket Mode`);
+                }
             }
             else {
                 await this.startPollingMode();
@@ -174,7 +201,7 @@ export class SlackInstance {
         this.pollingClient = new SlackPollingClient({
             webClient: asPollingWebClient(this.webClient),
             watermarkStore,
-            dispatch: (event) => this.dispatchInboundMessage(event),
+            dispatch: (event) => this.dispatchInboundMessage(event, 'poll'),
             intervalSec: config.pollingIntervalSec ?? 45,
             backfillMessageCap: config.pollingBackfillMessageCap ?? 100,
             backfillSeconds: config.pollingBackfillSeconds ?? 24 * 60 * 60,
@@ -193,6 +220,20 @@ export class SlackInstance {
                 payload: { instanceId: this.id, reason },
             });
         });
+        // Seed thread tracking from recent SQLite history so threads that were
+        // active before this process started are still swept — the in-memory
+        // registry dies with the process, and tsx-watch restarts are frequent.
+        // New registrations re-read from the thread parent and the (channel, ts)
+        // dedup drops what was already delivered, so this also retro-recovers
+        // replies that were lost while no reconciler was watching.
+        const seedSinceMs = Date.now() - 6 * 60 * 60 * 1000;
+        const seeds = this.ctx?.eventDb.recentSlackThreadActivity?.(this.id, seedSinceMs) ?? [];
+        for (const seed of seeds) {
+            this.pollingClient.noteThreadActivity(seed.channelId, seed.threadTs, seed.lastActivityMs);
+        }
+        if (seeds.length > 0) {
+            this.ctx?.log.info(`Slack[${this.id}] thread registry seeded with ${seeds.length} recent thread(s)`);
+        }
         await this.pollingClient.start();
     }
     /**
@@ -257,13 +298,36 @@ export class SlackInstance {
      * subtypes / self / empty messages, logs to SQLite, broadcasts WS, fires
      * trigger listeners, and resolves reply waiters.
      */
-    async dispatchInboundMessage(event) {
+    async dispatchInboundMessage(event, source = 'socket') {
         if (event.subtype && SKIP_MESSAGE_SUBTYPES.has(event.subtype))
             return;
         const hasFiles = Array.isArray(event.files) && event.files.length > 0;
         const text = event.text ?? '';
         if (!text && !hasFiles)
             return;
+        // Hybrid dedup: with the reconciler running alongside Socket Mode, every
+        // message can reach this dispatcher twice (live socket now, polling sweep
+        // ≤1 cycle later). Key on (channel, ts) — unique per Slack message. Both
+        // checks are synchronous (Set + better-sqlite3), so marking BEFORE the
+        // first await closes the in-process socket/poller race; the SQLite check
+        // covers messages dispatched before a restart wiped the in-memory Set.
+        if (event.ts) {
+            const dedupKey = `${event.channel}:${event.ts}`;
+            if (this.dispatchedKeys.has(dedupKey))
+                return;
+            if (this.ctx?.eventDb.hasSlackMessage?.(this.id, event.channel, event.ts)) {
+                this.rememberDispatched(dedupKey);
+                return;
+            }
+            this.rememberDispatched(dedupKey);
+        }
+        // Feed the reconciler's thread registry: any message carrying a thread_ts
+        // marks that thread active so the per-thread sweep keeps watching it —
+        // replies on parents behind the channel watermark never resurface in
+        // conversations.history, so this is the only way polling can see them.
+        if (event.thread_ts && event.thread_ts !== event.ts) {
+            this.pollingClient?.noteThreadActivity(event.channel, event.thread_ts);
+        }
         const config = loadConfig(this.id);
         const isOwnMessage = !!event.user && event.user === config.botUserId;
         // Skip own messages unless this instance is configured to mirror them.
@@ -322,7 +386,7 @@ export class SlackInstance {
         // direction, file count, and resolved-flag for name lookups (Y/N), no
         // names/emails/text.
         const resolvedFlag = `userResolved=${userName && userName !== userId ? 'Y' : 'N'} channelResolved=${channelName ? 'Y' : 'N'}`;
-        this.ctx?.log.info(`Slack[${this.id}] dispatch: channel=${event.channel} user=${userId || '-'} ts=${event.ts} direction=${direction} files=${files?.length ?? 0}${event.thread_ts && event.thread_ts !== event.ts ? ` thread=${event.thread_ts}` : ''} ${resolvedFlag}`);
+        this.ctx?.log.info(`Slack[${this.id}] dispatch: channel=${event.channel} user=${userId || '-'} ts=${event.ts} direction=${direction} via=${source} files=${files?.length ?? 0}${event.thread_ts && event.thread_ts !== event.ts ? ` thread=${event.thread_ts}` : ''} ${resolvedFlag}`);
         this.ctx?.eventDb.logSlackMessage({
             ts: event.ts,
             threadTs: event.thread_ts,

package/dist/src/packages/server/integrations/slack/slack-polling-client.js

@@ -30,6 +30,10 @@
  */
 import { createLogger } from '../../utils/logger.js';
 const log = createLogger('SlackPolling');
+/** Tracked threads expire after this much inactivity. */
+const THREAD_TTL_MS = 6 * 60 * 60 * 1000;
+/** Per-channel cap on tracked threads — oldest activity evicted first. */
+const MAX_TRACKED_THREADS_PER_CHANNEL = 10;
 const DEFAULT_SCHEDULER = {
     setTimeout: (cb, ms) => setTimeout(cb, ms),
     clearTimeout: (h) => clearTimeout(h),
@@ -95,6 +99,16 @@ export class SlackPollingClient {
     channelBackoffUntil = new Map();
     /** ChannelId set known from the most recent list refresh. */
     knownChannels = new Set();
+    /**
+     * Per-thread watermarks ("option 2" of the parent heuristic): channelId →
+     * threadTs → tracking state. `lastTs` is sweep-owned — it only advances as
+     * sweepThreads() reads replies in order, so a mid-thread reply the live
+     * socket dropped is still fetched on the next sweep (the dispatcher's
+     * (channel, ts) dedup drops the ones already delivered). New registrations
+     * start at lastTs = threadTs, i.e. the first sweep re-reads the whole
+     * thread and recovers any hole.
+     */
+    threadRegistry = new Map();
     /**
      * Search-mode only: the newest message `ts` observed in the previous search
      * cycle (dispatched or not). Lets the next cycle stop paging as soon as it
@@ -370,6 +384,119 @@ export class SlackPollingClient {
      *
      * Returns the number of messages dispatched.
      */
+    /**
+     * Register/refresh a tracked thread. Fed by three sources: the parent
+     * heuristic in pollChannel, every dispatched message carrying a thread_ts
+     * (both transports — the instance dispatcher calls this), and the SQLite
+     * seed on startup so tracking survives process restarts.
+     *
+     * Deliberately does NOT advance `lastTs` for known threads — that stays
+     * sweep-owned so a mid-thread reply the socket dropped can't be skipped
+     * because a newer reply arrived live first. `activityMs` defaults to now;
+     * the startup seed passes the stored time so stale threads still expire.
+     */
+    noteThreadActivity(channelId, threadTs, activityMs) {
+        let threads = this.threadRegistry.get(channelId);
+        if (!threads) {
+            threads = new Map();
+            this.threadRegistry.set(channelId, threads);
+        }
+        const existing = threads.get(threadTs);
+        if (existing) {
+            existing.lastActivityMs = Math.max(existing.lastActivityMs, activityMs ?? this.now());
+            return;
+        }
+        if (threads.size >= MAX_TRACKED_THREADS_PER_CHANNEL) {
+            let oldestKey = null;
+            let oldestMs = Infinity;
+            for (const [key, state] of threads) {
+                if (state.lastActivityMs < oldestMs) {
+                    oldestMs = state.lastActivityMs;
+                    oldestKey = key;
+                }
+            }
+            if (oldestKey)
+                threads.delete(oldestKey);
+        }
+        threads.set(threadTs, { lastTs: threadTs, lastActivityMs: activityMs ?? this.now() });
+    }
+    /**
+     * Per-thread watermark sweep: fetch new replies for every tracked thread in
+     * this channel, independently of whether the parent resurfaces in
+     * conversations.history (it never does once the channel watermark passes
+     * it — the exact gap that made "thread replies on old parents" invisible
+     * to polling). Downstream (channel, ts) dedup makes overlap with the live
+     * socket harmless.
+     */
+    async sweepThreads(channelId) {
+        const threads = this.threadRegistry.get(channelId);
+        if (!threads || threads.size === 0)
+            return 0;
+        let dispatched = 0;
+        const nowMs = this.now();
+        for (const [threadTs, state] of threads) {
+            if (!this.running)
+                break;
+            if (nowMs - state.lastActivityMs > THREAD_TTL_MS) {
+                threads.delete(threadTs);
+                continue;
+            }
+            try {
+                const res = await this.paceCall(() => this.webClient.conversations.replies({
+                    channel: channelId,
+                    ts: threadTs,
+                    oldest: state.lastTs,
+                    limit: 100,
+                }));
+                const replies = (res.messages ?? []).filter((r) => !!r && typeof r.ts === 'string' && r.ts !== threadTs && tsGt(r.ts, state.lastTs));
+                if (replies.length === 0)
+                    continue;
+                const ordered = [...replies].sort((a, b) => tsCmp(a.ts, b.ts));
+                for (const reply of ordered) {
+                    const replyEvent = {
+                        ts: reply.ts,
+                        thread_ts: reply.thread_ts ?? threadTs,
+                        channel: channelId,
+                        user: reply.user,
+                        text: reply.text,
+                        subtype: reply.subtype,
+                        files: Array.isArray(reply.files) ? reply.files : undefined,
+                    };
+                    try {
+                        await this.dispatch(replyEvent);
+                        dispatched += 1;
+                    }
+                    catch (err) {
+                        log.error(`dispatch error (thread sweep) channel=${channelId} ts=${reply.ts}: ${describeErr(err)}`);
+                    }
+                    if (tsGt(reply.ts, state.lastTs)) {
+                        state.lastTs = reply.ts;
+                        state.lastActivityMs = nowMs;
+                    }
+                }
+            }
+            catch (err) {
+                if (isInvalidAuthError(err))
+                    throw err;
+                if (isRateLimitedError(err)) {
+                    const seconds = readRetryAfter(err) ?? 60;
+                    const until = this.now() + seconds * 1000;
+                    if (until > this.globalPauseUntil)
+                        this.globalPauseUntil = until;
+                    log.warn(`429 on thread sweep channel=${channelId} thread=${threadTs}, deferred ${seconds}s`);
+                    break; // Remaining threads would hit the same pause — next cycle retries.
+                }
+                const msg = describeErr(err);
+                if (msg.includes('thread_not_found') || msg.includes('message_not_found')) {
+                    threads.delete(threadTs); // Parent deleted — stop tracking.
+                }
+                else {
+                    log.warn(`thread sweep failed channel=${channelId} thread=${threadTs}: ${msg}`);
+                }
+            }
+        }
+        return dispatched;
+    }
     async pollChannel(channelId) {
         const wm = this.watermarkStore.get(channelId);
         const isFirstSight = !wm;
@@ -388,8 +515,15 @@ export class SlackPollingClient {
             limit,
         }));
         const messages = (res.messages ?? []).filter((m) => !!m && typeof m.ts === 'string');
-        if (messages.length === 0)
-            return 0;
+        if (messages.length === 0) {
+            // No new channel-level messages — but replies on tracked threads never
+            // resurface in history, so the thread sweep must still run.
+            const swept = await this.sweepThreads(channelId);
+            if (this.channelBackoffUntil.has(channelId)) {
+                this.channelBackoffUntil.delete(channelId);
+            }
+            return swept;
+        }
         // Slack returns newest-first; dispatch in chronological order so trigger
         // listeners and dedupe see them in real-world order. BigInt sort avoids
         // the precision loss `parseFloat` had on Slack's 16-sig-fig timestamps.
@@ -420,74 +554,21 @@ export class SlackPollingClient {
             if (tsGt(msg.ts, highestTs)) {
                 highestTs = msg.ts;
             }
-            // ─── Cheap thread-reply heuristic ───
-            // If this message is a thread parent (reply_count > 0) and the latest
-            // reply is newer than what we've already seen for this channel, fetch
-            // the new replies. This catches replies in threads whose parent is in
-            // the current cycle's history window — which is the majority case for
-            // active conversations. Older threads with new replies are still
-            // missed (their parent doesn't re-surface in history) — option 2 would
-            // fix that with per-thread watermarks.
-            const parentTs = msg.ts;
-            const replyCount = msg.reply_count ?? 0;
-            const latestReply = msg.latest_reply;
-            const repliesAreNew = !!latestReply && tsGt(latestReply, wm?.lastTs ?? '0');
-            if (replyCount > 0 && repliesAreNew) {
-                const oldestForReplies = wm?.lastTs ?? parentTs;
-                try {
-                    const repliesRes = await this.paceCall(() => this.webClient.conversations.replies({
-                        channel: channelId,
-                        ts: parentTs,
-                        oldest: oldestForReplies,
-                        limit: 100,
-                    }));
-                    const replies = (repliesRes.messages ?? []).filter((r) => !!r && typeof r.ts === 'string' && r.ts !== parentTs);
-                    // conversations.replies returns oldest-first, but be defensive.
-                    const orderedReplies = [...replies].sort((a, b) => tsCmp(a.ts, b.ts));
-                    for (const reply of orderedReplies) {
-                        // Defense: skip ts already at or below the watermark (handles overlap).
-                        if (wm && tsLte(reply.ts, wm.lastTs))
-                            continue;
-                        const replyEvent = {
-                            ts: reply.ts,
-                            thread_ts: reply.thread_ts ?? parentTs,
-                            channel: channelId,
-                            user: reply.user,
-                            text: reply.text,
-                            subtype: reply.subtype,
-                            files: Array.isArray(reply.files) ? reply.files : undefined,
-                        };
-                        try {
-                            await this.dispatch(replyEvent);
-                            dispatched += 1;
-                        }
-                        catch (err) {
-                            log.error(`dispatch error (reply) channel=${channelId} ts=${reply.ts}: ${describeErr(err)}`);
-                        }
-                        if (tsGt(reply.ts, highestTs)) {
-                            highestTs = reply.ts;
-                        }
-                    }
-                }
-                catch (err) {
-                    // 429 / invalid_auth on replies fetch are non-fatal for this cycle —
-                    // we already dispatched the parent. Bubble auth errors to the outer
-                    // caller so the loop halts; rate limits just skip this thread.
-                    if (isInvalidAuthError(err))
-                        throw err;
-                    if (isRateLimitedError(err)) {
-                        const seconds = readRetryAfter(err) ?? 60;
-                        const until = this.now() + seconds * 1000;
-                        if (until > this.globalPauseUntil)
-                            this.globalPauseUntil = until;
-                        log.warn(`429 on conversations.replies channel=${channelId} thread=${parentTs}, deferred ${seconds}s`);
-                    }
-                    else {
-                        log.warn(`replies fetch failed channel=${channelId} thread=${parentTs}: ${describeErr(err)}`);
-                    }
-                }
+            // ─── Thread tracking ───
+            // Any parent with replies gets registered; the per-thread sweep at the
+            // end of this cycle (sweepThreads) is the single path that fetches and
+            // dispatches replies. Once the channel watermark passes the parent it
+            // never resurfaces in history — the registry is what keeps its future
+            // replies visible (the old inline "latest_reply" heuristic could not
+            // see replies on parents behind the watermark).
+            if ((msg.reply_count ?? 0) > 0) {
+                this.noteThreadActivity(channelId, msg.ts);
             }
         }
+        // Sweep tracked threads too. Thread-reply ts values deliberately do NOT
+        // advance the channel watermark here — that stays owned by the history
+        // fetch above; the sweep keeps its own per-thread watermarks.
+        dispatched += await this.sweepThreads(channelId);
         if (highestTs !== (wm?.lastTs ?? '0')) {
             await this.watermarkStore.set(channelId, highestTs);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tide-commander",
-  "version": "1.146.0",
+  "version": "1.147.1",
   "description": "Visual multi-agent orchestrator and manager for Claude Code with 3D/2D interface",
   "repository": {
     "type": "git",