claude-threads 1.0.2 → 1.0.4

package/dist/index.js

@@ -14758,7 +14758,7 @@ var require_react_reconciler_development = __commonJS((exports, module) => {
       return hook.checkDCE ? true : false;
     }
     function setIsStrictModeForDevtools(newIsStrictMode) {
-      typeof log28 === "function" && unstable_setDisableYieldValue2(newIsStrictMode);
+      typeof log29 === "function" && unstable_setDisableYieldValue2(newIsStrictMode);
       if (injectedHook && typeof injectedHook.setStrictMode === "function")
         try {
           injectedHook.setStrictMode(rendererID, newIsStrictMode);
@@ -22842,7 +22842,7 @@ Check the render method of %s.`, getComponentNameFromFiber(current) || "Unknown"
     var fiberStack = [];
     var index$jscomp$0 = -1, emptyContextObject = {};
     Object.freeze(emptyContextObject);
-    var clz32 = Math.clz32 ? Math.clz32 : clz32Fallback, log$1 = Math.log, LN2 = Math.LN2, nextTransitionUpdateLane = 256, nextTransitionDeferredLane = 262144, nextRetryLane = 4194304, scheduleCallback$3 = Scheduler.unstable_scheduleCallback, cancelCallback$1 = Scheduler.unstable_cancelCallback, shouldYield = Scheduler.unstable_shouldYield, requestPaint = Scheduler.unstable_requestPaint, now$1 = Scheduler.unstable_now, ImmediatePriority = Scheduler.unstable_ImmediatePriority, UserBlockingPriority = Scheduler.unstable_UserBlockingPriority, NormalPriority$1 = Scheduler.unstable_NormalPriority, IdlePriority = Scheduler.unstable_IdlePriority, log28 = Scheduler.log, unstable_setDisableYieldValue2 = Scheduler.unstable_setDisableYieldValue, rendererID = null, injectedHook = null, hasLoggedError = false, isDevToolsPresent = typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined", lastResetTime = 0;
+    var clz32 = Math.clz32 ? Math.clz32 : clz32Fallback, log$1 = Math.log, LN2 = Math.LN2, nextTransitionUpdateLane = 256, nextTransitionDeferredLane = 262144, nextRetryLane = 4194304, scheduleCallback$3 = Scheduler.unstable_scheduleCallback, cancelCallback$1 = Scheduler.unstable_cancelCallback, shouldYield = Scheduler.unstable_shouldYield, requestPaint = Scheduler.unstable_requestPaint, now$1 = Scheduler.unstable_now, ImmediatePriority = Scheduler.unstable_ImmediatePriority, UserBlockingPriority = Scheduler.unstable_UserBlockingPriority, NormalPriority$1 = Scheduler.unstable_NormalPriority, IdlePriority = Scheduler.unstable_IdlePriority, log29 = Scheduler.log, unstable_setDisableYieldValue2 = Scheduler.unstable_setDisableYieldValue, rendererID = null, injectedHook = null, hasLoggedError = false, isDevToolsPresent = typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined", lastResetTime = 0;
     if (typeof performance === "object" && typeof performance.now === "function") {
       var localPerformance = performance;
       var getCurrentTime = function() {
@@ -27449,12 +27449,12 @@ var require_backend = __commonJS((exports, module) => {
           }
           return (r === "string" ? String : Number)(t);
         }
-        var EventEmitter6 = /* @__PURE__ */ function() {
-          function EventEmitter7() {
-            _classCallCheck(this, EventEmitter7);
+        var EventEmitter5 = /* @__PURE__ */ function() {
+          function EventEmitter6() {
+            _classCallCheck(this, EventEmitter6);
             _defineProperty(this, "listenersMap", new Map);
           }
-          return _createClass(EventEmitter7, [{
+          return _createClass(EventEmitter6, [{
             key: "addListener",
             value: function addListener(event, listener) {
               var listeners = this.listenersMap.get(event);
@@ -30882,7 +30882,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               } while (this._messageQueue.length);
             }
           }]);
-        }(EventEmitter6);
+        }(EventEmitter5);
         const src_bridge = Bridge;
         function storage_localStorageGetItem(key) {
           try {
@@ -31736,7 +31736,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               this._bridge.send("unsupportedRendererVersion");
             }
           }]);
-        }(EventEmitter6);
+        }(EventEmitter5);
         function DevToolsConsolePatching_typeof(o) {
           "@babel/helpers - typeof";
           return DevToolsConsolePatching_typeof = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(o2) {
@@ -46392,7 +46392,7 @@ async function setupSlackPlatform(id, existing) {
   }
 }
 
-// src/platform/mattermost/client.ts
+// src/platform/base-client.ts
 import { EventEmitter } from "events";
 
 // src/utils/logger.ts
@@ -46468,6 +46468,114 @@ ${err.stack || err.message}` : msg;
 var mcpLogger = createLogger("MCP", true);
 var wsLogger = createLogger("ws", false);
 
+// src/platform/base-client.ts
+var log = createLogger("base-client");
+
+class BasePlatformClient extends EventEmitter {
+  allowedUsers = [];
+  botName = "";
+  isIntentionalDisconnect = false;
+  isReconnecting = false;
+  heartbeatInterval = null;
+  lastMessageAt = Date.now();
+  HEARTBEAT_INTERVAL_MS = 30000;
+  HEARTBEAT_TIMEOUT_MS = 60000;
+  reconnectAttempts = 0;
+  maxReconnectAttempts = 10;
+  reconnectDelay = 1000;
+  isUserAllowed(username) {
+    if (this.allowedUsers.length === 0) {
+      return true;
+    }
+    return this.allowedUsers.includes(username);
+  }
+  getBotName() {
+    return this.botName;
+  }
+  async createInteractivePost(message, reactions, threadId) {
+    const post = await this.createPost(message, threadId);
+    for (const emoji of reactions) {
+      try {
+        await this.addReaction(post.id, emoji);
+      } catch (err) {
+        log.warn(`Failed to add reaction ${emoji}: ${err}`);
+      }
+    }
+    return post;
+  }
+  disconnect() {
+    wsLogger.info("Disconnecting (intentional)");
+    this.isIntentionalDisconnect = true;
+    this.stopHeartbeat();
+    this.forceCloseConnection();
+  }
+  prepareForReconnect() {
+    wsLogger.debug("Preparing for reconnect (resetting intentional disconnect flag)");
+    this.isIntentionalDisconnect = false;
+    this.reconnectAttempts = 0;
+  }
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.lastMessageAt = Date.now();
+    this.heartbeatInterval = setInterval(() => {
+      const silentFor = Date.now() - this.lastMessageAt;
+      if (silentFor > this.HEARTBEAT_TIMEOUT_MS) {
+        log.warn(`Connection dead (no activity for ${Math.round(silentFor / 1000)}s), reconnecting...`);
+        this.stopHeartbeat();
+        this.forceCloseConnection();
+        return;
+      }
+      wsLogger.debug(`Heartbeat check (last activity ${Math.round(silentFor / 1000)}s ago)`);
+    }, this.HEARTBEAT_INTERVAL_MS);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+  }
+  scheduleReconnect() {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      log.error("Max reconnection attempts reached");
+      return;
+    }
+    this.forceCloseConnection();
+    this.isReconnecting = true;
+    this.reconnectAttempts++;
+    const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
+    log.info(`Reconnecting... (attempt ${this.reconnectAttempts})`);
+    this.emit("reconnecting", this.reconnectAttempts);
+    setTimeout(() => {
+      this.connect().catch((err) => {
+        log.error(`Reconnection failed: ${err}`);
+      });
+    }, delay);
+  }
+  onConnectionEstablished() {
+    this.reconnectAttempts = 0;
+    this.startHeartbeat();
+    this.emit("connected");
+    if (this.isReconnecting) {
+      this.recoverMissedMessages().catch((err) => {
+        log.warn(`Failed to recover missed messages: ${err}`);
+      });
+    }
+    this.isReconnecting = false;
+  }
+  onConnectionClosed() {
+    this.stopHeartbeat();
+    this.emit("disconnected");
+    if (!this.isIntentionalDisconnect) {
+      wsLogger.debug("Scheduling reconnect...");
+      this.scheduleReconnect();
+    } else {
+      wsLogger.debug("Intentional disconnect, not reconnecting");
+    }
+  }
+  updateLastMessageTime() {
+    this.lastMessageAt = Date.now();
+  }
+}
 // src/utils/format.ts
 function extractThreadId(sessionId) {
   const colonIndex = sessionId.indexOf(":");
@@ -46731,9 +46839,9 @@ ${code}
 }
 
 // src/platform/mattermost/client.ts
-var log = createLogger("mattermost");
+var log2 = createLogger("mattermost");
 
-class MattermostClient extends EventEmitter {
+class MattermostClient extends BasePlatformClient {
   platformId;
   platformType = "mattermost";
   displayName;
@@ -46741,21 +46849,10 @@ class MattermostClient extends EventEmitter {
   url;
   token;
   channelId;
-  botName;
-  allowedUsers;
-  reconnectAttempts = 0;
-  maxReconnectAttempts = 10;
-  reconnectDelay = 1000;
   userCache = new Map;
   botUserId = null;
   formatter = new MattermostFormatter;
-  heartbeatInterval = null;
-  lastMessageAt = Date.now();
-  HEARTBEAT_INTERVAL_MS = 30000;
-  HEARTBEAT_TIMEOUT_MS = 60000;
   lastProcessedPostId = null;
-  isReconnecting = false;
-  isIntentionalDisconnect = false;
   constructor(platformConfig) {
     super();
     this.platformId = platformConfig.id;
@@ -46812,7 +46909,7 @@ class MattermostClient extends EventEmitter {
     const hasFileIds = post.file_ids && post.file_ids.length > 0;
     const hasFileMetadata = post.metadata?.files && post.metadata.files.length > 0;
     if (hasFileIds && !hasFileMetadata) {
-      log.debug(`Post ${formatShortId(post.id)} has ${post.file_ids.length} file(s), fetching metadata`);
+      log2.debug(`Post ${formatShortId(post.id)} has ${post.file_ids.length} file(s), fetching metadata`);
       try {
         const files = [];
         for (const fileId of post.file_ids) {
@@ -46820,7 +46917,7 @@ class MattermostClient extends EventEmitter {
             const file = await this.api("GET", `/files/${fileId}/info`);
             files.push(file);
           } catch (err) {
-            log.warn(`Failed to fetch file info for ${fileId}: ${err}`);
+            log2.warn(`Failed to fetch file info for ${fileId}: ${err}`);
           }
         }
         if (files.length > 0) {
@@ -46828,10 +46925,10 @@ class MattermostClient extends EventEmitter {
             ...post.metadata,
             files
           };
-          log.debug(`Enriched post ${formatShortId(post.id)} with ${files.length} file(s)`);
+          log2.debug(`Enriched post ${formatShortId(post.id)} with ${files.length} file(s)`);
         }
       } catch (err) {
-        log.warn(`Failed to fetch file metadata for post ${formatShortId(post.id)}: ${err}`);
+        log2.warn(`Failed to fetch file metadata for post ${formatShortId(post.id)}: ${err}`);
       }
     }
     const user = await this.getUser(post.user_id);
@@ -46845,7 +46942,7 @@ class MattermostClient extends EventEmitter {
   RETRY_DELAY_MS = 500;
   async api(method, path, body, retryCount = 0, options) {
     const url = `${this.url}/api/v4${path}`;
-    log.debug(`API ${method} ${path}`);
+    log2.debug(`API ${method} ${path}`);
     const response = await fetch(url, {
       method,
       headers: {
@@ -46858,19 +46955,19 @@ class MattermostClient extends EventEmitter {
       const text = await response.text();
       if (response.status === 500 && retryCount < this.MAX_RETRIES) {
         const delay = this.RETRY_DELAY_MS * Math.pow(2, retryCount);
-        log.warn(`API ${method} ${path} failed with 500, retrying in ${delay}ms (attempt ${retryCount + 1}/${this.MAX_RETRIES})`);
+        log2.warn(`API ${method} ${path} failed with 500, retrying in ${delay}ms (attempt ${retryCount + 1}/${this.MAX_RETRIES})`);
         await new Promise((resolve2) => setTimeout(resolve2, delay));
         return this.api(method, path, body, retryCount + 1, options);
       }
       const isSilent = options?.silent?.includes(response.status);
       if (isSilent) {
-        log.debug(`API ${method} ${path} failed: ${response.status} (expected)`);
+        log2.debug(`API ${method} ${path} failed: ${response.status} (expected)`);
       } else {
-        log.warn(`API ${method} ${path} failed: ${response.status} ${text.substring(0, 100)}`);
+        log2.warn(`API ${method} ${path} failed: ${response.status} ${text.substring(0, 100)}`);
       }
       throw new Error(`Mattermost API error ${response.status}: ${text}`);
     }
-    log.debug(`API ${method} ${path} \u2192 ${response.status}`);
+    log2.debug(`API ${method} ${path} \u2192 ${response.status}`);
     return response.json();
   }
   async getBotUser() {
@@ -46881,28 +46978,28 @@ class MattermostClient extends EventEmitter {
   async getUser(userId) {
     const cached = this.userCache.get(userId);
     if (cached) {
-      log.debug(`User ${userId} found in cache: @${cached.username}`);
+      log2.debug(`User ${userId} found in cache: @${cached.username}`);
       return this.normalizePlatformUser(cached);
     }
     try {
       const user = await this.api("GET", `/users/${userId}`);
       this.userCache.set(userId, user);
-      log.debug(`User ${userId} fetched: @${user.username}`);
+      log2.debug(`User ${userId} fetched: @${user.username}`);
       return this.normalizePlatformUser(user);
     } catch (err) {
-      log.warn(`Failed to get user ${userId}: ${err}`);
+      log2.warn(`Failed to get user ${userId}: ${err}`);
       return null;
     }
   }
   async getUserByUsername(username) {
     try {
-      log.debug(`Looking up user by username: @${username}`);
+      log2.debug(`Looking up user by username: @${username}`);
       const user = await this.api("GET", `/users/username/${username}`);
       this.userCache.set(user.id, user);
-      log.debug(`User @${username} found: ${user.id}`);
+      log2.debug(`User @${username} found: ${user.id}`);
       return this.normalizePlatformUser(user);
     } catch (err) {
-      log.warn(`User @${username} not found: ${err}`);
+      log2.warn(`User @${username} not found: ${err}`);
       return null;
     }
   }
@@ -46924,7 +47021,7 @@ class MattermostClient extends EventEmitter {
     return this.normalizePlatformPost(post);
   }
   async addReaction(postId, emojiName) {
-    log.debug(`Adding reaction :${emojiName}: to post ${postId.substring(0, 8)}`);
+    log2.debug(`Adding reaction :${emojiName}: to post ${postId.substring(0, 8)}`);
     await this.api("POST", "/reactions", {
       user_id: this.botUserId,
       post_id: postId,
@@ -46932,22 +47029,11 @@ class MattermostClient extends EventEmitter {
     });
   }
   async removeReaction(postId, emojiName) {
-    log.debug(`Removing reaction :${emojiName}: from post ${postId.substring(0, 8)}`);
+    log2.debug(`Removing reaction :${emojiName}: from post ${postId.substring(0, 8)}`);
     await this.api("DELETE", `/users/${this.botUserId}/posts/${postId}/reactions/${emojiName}`);
   }
-  async createInteractivePost(message, reactions, threadId) {
-    const post = await this.createPost(message, threadId);
-    for (const emoji of reactions) {
-      try {
-        await this.addReaction(post.id, emoji);
-      } catch (err) {
-        log.warn(`Failed to add reaction ${emoji}: ${err}`);
-      }
-    }
-    return post;
-  }
   async downloadFile(fileId) {
-    log.debug(`Downloading file ${fileId}`);
+    log2.debug(`Downloading file ${fileId}`);
     const url = `${this.url}/api/v4/files/${fileId}`;
     const response = await fetch(url, {
       headers: {
@@ -46955,11 +47041,11 @@ class MattermostClient extends EventEmitter {
       }
     });
     if (!response.ok) {
-      log.warn(`Failed to download file ${fileId}: ${response.status}`);
+      log2.warn(`Failed to download file ${fileId}: ${response.status}`);
       throw new Error(`Failed to download file ${fileId}: ${response.status}`);
     }
     const arrayBuffer = await response.arrayBuffer();
-    log.debug(`Downloaded file ${fileId}: ${arrayBuffer.byteLength} bytes`);
+    log2.debug(`Downloaded file ${fileId}: ${arrayBuffer.byteLength} bytes`);
     return Buffer.from(arrayBuffer);
   }
   async getFileInfo(fileId) {
@@ -46968,24 +47054,24 @@ class MattermostClient extends EventEmitter {
   }
   async getPost(postId) {
     try {
-      log.debug(`Fetching post ${postId.substring(0, 8)}`);
+      log2.debug(`Fetching post ${postId.substring(0, 8)}`);
       const post = await this.api("GET", `/posts/${postId}`);
       return this.normalizePlatformPost(post);
     } catch (err) {
-      log.debug(`Post ${postId.substring(0, 8)} not found: ${err}`);
+      log2.debug(`Post ${postId.substring(0, 8)} not found: ${err}`);
       return null;
     }
   }
   async deletePost(postId) {
-    log.debug(`Deleting post ${postId.substring(0, 8)}`);
+    log2.debug(`Deleting post ${postId.substring(0, 8)}`);
     await this.api("DELETE", `/posts/${postId}`);
   }
   async pinPost(postId) {
-    log.debug(`Pinning post ${postId.substring(0, 8)}`);
+    log2.debug(`Pinning post ${postId.substring(0, 8)}`);
     await this.api("POST", `/posts/${postId}/pin`);
   }
   async unpinPost(postId) {
-    log.debug(`Unpinning post ${postId.substring(0, 8)}`);
+    log2.debug(`Unpinning post ${postId.substring(0, 8)}`);
     try {
       await this.api("POST", `/posts/${postId}/unpin`, undefined, 0, { silent: [403, 404] });
     } catch (err) {
@@ -47029,7 +47115,7 @@ class MattermostClient extends EventEmitter {
       }
       return messages;
     } catch (err) {
-      log.warn(`Failed to get thread history for ${threadId}: ${err}`);
+      log2.warn(`Failed to get thread history for ${threadId}: ${err}`);
       return [];
     }
   }
@@ -47048,7 +47134,7 @@ class MattermostClient extends EventEmitter {
       posts.sort((a, b) => (a.createAt ?? 0) - (b.createAt ?? 0));
       return posts;
     } catch (err) {
-      log.warn(`Failed to get channel posts after ${afterPostId}: ${err}`);
+      log2.warn(`Failed to get channel posts after ${afterPostId}: ${err}`);
       return [];
     }
   }
@@ -47070,21 +47156,13 @@ class MattermostClient extends EventEmitter {
         }
       };
       this.ws.onmessage = (event) => {
-        this.lastMessageAt = Date.now();
+        this.updateLastMessageTime();
         try {
           const data = typeof event.data === "string" ? event.data : event.data.toString();
           const wsEvent = JSON.parse(data);
           this.handleEvent(wsEvent);
           if (wsEvent.event === "hello") {
-            this.reconnectAttempts = 0;
-            this.startHeartbeat();
-            this.emit("connected");
-            if (this.isReconnecting && this.lastProcessedPostId) {
-              this.recoverMissedMessages().catch((err) => {
-                log.warn(`Failed to recover missed messages: ${err}`);
-              });
-            }
-            this.isReconnecting = false;
+            this.onConnectionEstablished();
             resolve2();
           }
         } catch (err) {
@@ -47093,14 +47171,7 @@ class MattermostClient extends EventEmitter {
       };
       this.ws.onclose = (event) => {
         wsLogger.info(`WebSocket disconnected (code: ${event.code}, reason: ${event.reason || "none"}, clean: ${event.wasClean})`);
-        this.stopHeartbeat();
-        this.emit("disconnected");
-        if (!this.isIntentionalDisconnect) {
-          wsLogger.debug("Scheduling reconnect...");
-          this.scheduleReconnect();
-        } else {
-          wsLogger.debug("Intentional disconnect, not reconnecting");
-        }
+        this.onConnectionClosed();
       };
       this.ws.onerror = (event) => {
         wsLogger.warn(`WebSocket error: ${event}`);
@@ -47158,55 +47229,31 @@ class MattermostClient extends EventEmitter {
       }
     }
   }
-  scheduleReconnect() {
-    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
-      log.error("Max reconnection attempts reached");
-      return;
-    }
-    this.isReconnecting = true;
-    this.reconnectAttempts++;
-    const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
-    log.info(`Reconnecting... (attempt ${this.reconnectAttempts})`);
-    this.emit("reconnecting", this.reconnectAttempts);
-    setTimeout(() => {
-      this.connect().catch((err) => {
-        log.error(`Reconnection failed: ${err}`);
-      });
-    }, delay);
-  }
-  startHeartbeat() {
-    this.stopHeartbeat();
-    this.lastMessageAt = Date.now();
-    this.heartbeatInterval = setInterval(() => {
-      const silentFor = Date.now() - this.lastMessageAt;
-      if (silentFor > this.HEARTBEAT_TIMEOUT_MS) {
-        log.warn(`Connection dead (no activity for ${Math.round(silentFor / 1000)}s), reconnecting...`);
-        this.stopHeartbeat();
-        if (this.ws) {
+  forceCloseConnection() {
+    if (this.ws) {
+      this.ws.onopen = null;
+      this.ws.onmessage = null;
+      this.ws.onclose = null;
+      this.ws.onerror = null;
+      if (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING) {
+        try {
           this.ws.close();
-        }
-        return;
+        } catch {}
       }
-      wsLogger.debug(`Heartbeat check (last activity ${Math.round(silentFor / 1000)}s ago)`);
-    }, this.HEARTBEAT_INTERVAL_MS);
-  }
-  stopHeartbeat() {
-    if (this.heartbeatInterval) {
-      clearInterval(this.heartbeatInterval);
-      this.heartbeatInterval = null;
+      this.ws = null;
     }
   }
   async recoverMissedMessages() {
     if (!this.lastProcessedPostId) {
       return;
     }
-    log.info(`Recovering missed messages after post ${this.lastProcessedPostId}...`);
+    log2.info(`Recovering missed messages after post ${this.lastProcessedPostId}...`);
     const missedPosts = await this.getChannelPostsAfter(this.lastProcessedPostId);
     if (missedPosts.length === 0) {
-      log.info("No missed messages to recover");
+      log2.info("No missed messages to recover");
       return;
     }
-    log.info(`Recovered ${missedPosts.length} missed message(s)`);
+    log2.info(`Recovered ${missedPosts.length} missed message(s)`);
     for (const post of missedPosts) {
       this.lastProcessedPostId = post.id;
       const user = await this.getUser(post.userId);
@@ -47216,12 +47263,6 @@ class MattermostClient extends EventEmitter {
       }
     }
   }
-  isUserAllowed(username) {
-    if (this.allowedUsers.length === 0) {
-      return true;
-    }
-    return this.allowedUsers.includes(username);
-  }
   isBotMentioned(message) {
     const botName = escapeRegExp(this.botName);
     const mentionPattern = new RegExp(`(^|\\s)@${botName}\\b`, "i");
@@ -47231,9 +47272,6 @@ class MattermostClient extends EventEmitter {
     const botName = escapeRegExp(this.botName);
     return message.replace(new RegExp(`(^|\\s)@${botName}\\b`, "gi"), " ").trim();
   }
-  getBotName() {
-    return this.botName;
-  }
   getMcpConfig() {
     return {
       type: "mattermost",
@@ -47264,24 +47302,7 @@ class MattermostClient extends EventEmitter {
       }
     }));
   }
-  disconnect() {
-    wsLogger.info("Disconnecting WebSocket (intentional)");
-    this.isIntentionalDisconnect = true;
-    this.stopHeartbeat();
-    if (this.ws) {
-      this.ws.close();
-      this.ws = null;
-    }
-  }
-  prepareForReconnect() {
-    wsLogger.debug("Preparing for reconnect (resetting intentional disconnect flag)");
-    this.isIntentionalDisconnect = false;
-    this.reconnectAttempts = 0;
-  }
 }
-// src/platform/slack/client.ts
-import { EventEmitter as EventEmitter2 } from "events";
-
 // src/platform/slack/formatter.ts
 class SlackFormatter {
   formatBold(text) {
@@ -47352,9 +47373,9 @@ ${code}
 }
 
 // src/platform/slack/client.ts
-var log2 = createLogger("slack");
+var log3 = createLogger("slack");
 
-class SlackClient extends EventEmitter2 {
+class SlackClient extends BasePlatformClient {
   platformId;
   platformType = "slack";
   displayName;
@@ -47362,25 +47383,14 @@ class SlackClient extends EventEmitter2 {
   botToken;
   appToken;
   channelId;
-  botName;
-  allowedUsers;
   skipPermissions;
   apiUrl;
-  reconnectAttempts = 0;
-  maxReconnectAttempts = 10;
-  reconnectDelay = 1000;
-  isIntentionalDisconnect = false;
-  isReconnecting = false;
   reconnectTimeout = null;
   userCache = new Map;
   usernameToIdCache = new Map;
   botUserId = null;
   botUser = null;
   teamUrl = null;
-  heartbeatInterval = null;
-  lastMessageAt = Date.now();
-  HEARTBEAT_INTERVAL_MS = 30000;
-  HEARTBEAT_TIMEOUT_MS = 60000;
   lastProcessedTs = null;
   processedMessages = new Set;
   MAX_PROCESSED_MESSAGES = 1000;
@@ -47437,13 +47447,13 @@ class SlackClient extends EventEmitter2 {
       const now = Date.now();
       if (now < this.rateLimitRetryAfter) {
         const waitTime = this.rateLimitRetryAfter - now;
-        log2.debug(`Rate limited, waiting ${waitTime}ms`);
+        log3.debug(`Rate limited, waiting ${waitTime}ms`);
         await new Promise((resolve2) => setTimeout(resolve2, waitTime));
       }
       this.rateLimitDelay = 0;
     }
     const url = `${this.apiUrl}/${endpoint}`;
-    log2.debug(`API ${method} ${endpoint}`);
+    log3.debug(`API ${method} ${endpoint}`);
     const headers = {
       Authorization: `Bearer ${this.botToken}`,
       "Content-Type": "application/json; charset=utf-8"
@@ -47455,25 +47465,25 @@ class SlackClient extends EventEmitter2 {
     });
     if (response.status === 429) {
       if (retryCount >= this.MAX_RATE_LIMIT_RETRIES) {
-        log2.error(`Rate limit max retries (${this.MAX_RATE_LIMIT_RETRIES}) exceeded for ${endpoint}`);
+        log3.error(`Rate limit max retries (${this.MAX_RATE_LIMIT_RETRIES}) exceeded for ${endpoint}`);
         throw new Error(`Slack API rate limit exceeded after ${this.MAX_RATE_LIMIT_RETRIES} retries`);
       }
       const retryAfter = parseInt(response.headers.get("Retry-After") || "5", 10);
       this.rateLimitDelay = retryAfter * 1000;
       this.rateLimitRetryAfter = Date.now() + this.rateLimitDelay;
-      log2.warn(`Rate limited by Slack, retrying after ${retryAfter}s (attempt ${retryCount + 1}/${this.MAX_RATE_LIMIT_RETRIES})`);
+      log3.warn(`Rate limited by Slack, retrying after ${retryAfter}s (attempt ${retryCount + 1}/${this.MAX_RATE_LIMIT_RETRIES})`);
       await new Promise((resolve2) => setTimeout(resolve2, this.rateLimitDelay));
       return this.api(method, endpoint, body, retryCount + 1);
     }
     if (!response.ok) {
       const text = await response.text();
-      log2.warn(`API ${method} ${endpoint} failed: ${response.status} ${text.substring(0, 100)}`);
+      log3.warn(`API ${method} ${endpoint} failed: ${response.status} ${text.substring(0, 100)}`);
       throw new Error(`Slack API error ${response.status}: ${text}`);
     }
     const data = await response.json();
     if (!data.ok) {
       if (!expectedErrors.includes(data.error || "")) {
-        log2.warn(`API ${method} ${endpoint} error: ${data.error}`);
+        log3.warn(`API ${method} ${endpoint} error: ${data.error}`);
       }
       throw new Error(`Slack API error: ${data.error}`);
     }
@@ -47481,7 +47491,7 @@ class SlackClient extends EventEmitter2 {
   }
   async appApi(method, endpoint, body) {
     const url = `${this.apiUrl}/${endpoint}`;
-    log2.debug(`App API ${method} ${endpoint}`);
+    log3.debug(`App API ${method} ${endpoint}`);
     const headers = {
       Authorization: `Bearer ${this.appToken}`,
       "Content-Type": "application/json; charset=utf-8"
@@ -47534,22 +47544,19 @@ class SlackClient extends EventEmitter2 {
         wsLogger.info("Socket Mode: WebSocket connected, waiting for hello...");
       };
       this.ws.onmessage = (event) => {
-        this.lastMessageAt = Date.now();
+        this.updateLastMessageTime();
         try {
           const data = typeof event.data === "string" ? event.data : event.data.toString();
           const envelope = JSON.parse(data);
           this.handleSocketModeEvent(envelope);
           if (envelope.type === "hello") {
             clearTimeout(connectionTimeout);
-            this.reconnectAttempts = 0;
-            this.startHeartbeat();
-            this.emit("connected");
+            this.onConnectionEstablished();
             if (this.isReconnecting && this.lastProcessedTs) {
               this.recoverMissedMessages().catch((err) => {
-                log2.warn(`Failed to recover missed messages: ${err}`);
+                log3.warn(`Failed to recover missed messages: ${err}`);
               });
             }
-            this.isReconnecting = false;
             doResolve();
           }
         } catch (err) {
@@ -47559,8 +47566,6 @@ class SlackClient extends EventEmitter2 {
       this.ws.onclose = (event) => {
         clearTimeout(connectionTimeout);
         wsLogger.info(`Socket Mode: WebSocket disconnected (code: ${event.code}, reason: ${event.reason || "none"}, clean: ${event.wasClean})`);
-        this.stopHeartbeat();
-        this.emit("disconnected");
         if (!settled) {
           wsLogger.warn(`WebSocket closed before hello event (code: ${event.code}, reason: ${event.reason || "none"})`);
         }
@@ -47568,9 +47573,10 @@ class SlackClient extends EventEmitter2 {
         const serverShutdown = event.reason?.toLowerCase().includes("server shutting down");
         const connectionReplaced = event.reason?.toLowerCase().includes("new connection replacing");
         if (!this.isIntentionalDisconnect && !serverShutdown && !connectionReplaced) {
-          wsLogger.debug("Scheduling reconnect...");
-          this.scheduleReconnect();
+          this.onConnectionClosed();
         } else {
+          this.stopHeartbeat();
+          this.emit("disconnected");
           if (serverShutdown) {
             wsLogger.debug("Server shutdown detected, not reconnecting");
           } else if (connectionReplaced) {
@@ -47644,7 +47650,7 @@ class SlackClient extends EventEmitter2 {
           this.emit("channel_post", post, user);
         }
       }).catch((err) => {
-        log2.warn(`Failed to get user for message event: ${err}`);
+        log3.warn(`Failed to get user for message event: ${err}`);
         this.emit("message", post, null);
       });
     }
@@ -47664,7 +47670,7 @@ class SlackClient extends EventEmitter2 {
       this.getUser(event.user || "").then((user) => {
         this.emit("reaction", reaction, user);
       }).catch((err) => {
-        log2.warn(`Failed to get user for reaction event: ${err}`);
+        log3.warn(`Failed to get user for reaction event: ${err}`);
         this.emit("reaction", reaction, null);
       });
     }
@@ -47684,24 +47690,39 @@ class SlackClient extends EventEmitter2 {
       this.getUser(event.user || "").then((user) => {
         this.emit("reaction_removed", reaction, user);
       }).catch((err) => {
-        log2.warn(`Failed to get user for reaction_removed event: ${err}`);
+        log3.warn(`Failed to get user for reaction_removed event: ${err}`);
         this.emit("reaction_removed", reaction, null);
       });
     }
   }
-  scheduleReconnect() {
-    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
-      log2.error("Max reconnection attempts reached");
-      return;
+  forceCloseConnection() {
+    if (this.ws) {
+      this.ws.onopen = null;
+      this.ws.onmessage = null;
+      this.ws.onclose = null;
+      this.ws.onerror = null;
+      if (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING) {
+        try {
+          this.ws.close();
+        } catch {}
+      }
+      this.ws = null;
     }
+  }
+  scheduleReconnect() {
     if (this.reconnectTimeout) {
       clearTimeout(this.reconnectTimeout);
       this.reconnectTimeout = null;
     }
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      log3.error("Max reconnection attempts reached");
+      return;
+    }
+    this.forceCloseConnection();
     this.isReconnecting = true;
     this.reconnectAttempts++;
     const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
-    log2.info(`Reconnecting... (attempt ${this.reconnectAttempts})`);
+    wsLogger.info(`Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
     this.emit("reconnecting", this.reconnectAttempts);
     this.reconnectTimeout = setTimeout(() => {
       this.reconnectTimeout = null;
@@ -47710,45 +47731,24 @@ class SlackClient extends EventEmitter2 {
         return;
       }
       this.connect().catch((err) => {
-        log2.error(`Reconnection failed: ${err}`);
+        wsLogger.error(`Reconnection failed: ${err}`);
+        this.scheduleReconnect();
       });
     }, delay);
   }
-  startHeartbeat() {
-    this.stopHeartbeat();
-    this.lastMessageAt = Date.now();
-    this.heartbeatInterval = setInterval(() => {
-      const silentFor = Date.now() - this.lastMessageAt;
-      if (silentFor > this.HEARTBEAT_TIMEOUT_MS) {
-        log2.warn(`Connection dead (no activity for ${Math.round(silentFor / 1000)}s), reconnecting...`);
-        this.stopHeartbeat();
-        if (this.ws) {
-          this.ws.close();
-        }
-        return;
-      }
-      wsLogger.debug(`Heartbeat check (last activity ${Math.round(silentFor / 1000)}s ago)`);
-    }, this.HEARTBEAT_INTERVAL_MS);
-  }
-  stopHeartbeat() {
-    if (this.heartbeatInterval) {
-      clearInterval(this.heartbeatInterval);
-      this.heartbeatInterval = null;
-    }
-  }
   async recoverMissedMessages() {
     if (!this.lastProcessedTs) {
       return;
     }
-    log2.info(`Recovering missed messages after ts ${this.lastProcessedTs}...`);
+    log3.info(`Recovering missed messages after ts ${this.lastProcessedTs}...`);
     try {
       const response = await this.api("GET", `conversations.history?channel=${this.channelId}&oldest=${this.lastProcessedTs}&inclusive=false&limit=100`);
       const messages = response.messages || [];
       if (messages.length === 0) {
-        log2.info("No missed messages to recover");
+        log3.info("No missed messages to recover");
         return;
       }
-      log2.info(`Recovered ${messages.length} missed message(s)`);
+      log3.info(`Recovered ${messages.length} missed message(s)`);
       const sortedMessages = messages.sort((a, b) => parseFloat(a.ts) - parseFloat(b.ts));
       for (const message of sortedMessages) {
         if (message.user === this.botUserId || message.bot_id) {
@@ -47763,7 +47763,7 @@ class SlackClient extends EventEmitter2 {
         }
       }
     } catch (err) {
-      log2.warn(`Failed to recover missed messages: ${err}`);
+      log3.warn(`Failed to recover missed messages: ${err}`);
     }
   }
   disconnect() {
@@ -47774,15 +47774,7 @@ class SlackClient extends EventEmitter2 {
       clearTimeout(this.reconnectTimeout);
       this.reconnectTimeout = null;
     }
-    if (this.ws) {
-      this.ws.close();
-      this.ws = null;
-    }
-  }
-  prepareForReconnect() {
-    wsLogger.debug("Preparing for reconnect (resetting intentional disconnect flag)");
-    this.isIntentionalDisconnect = false;
-    this.reconnectAttempts = 0;
+    this.forceCloseConnection();
   }
   async fetchBotUser() {
     const response = await this.api("POST", "auth.test");
@@ -47805,17 +47797,17 @@ class SlackClient extends EventEmitter2 {
     }
     const cached = this.userCache.get(userId);
     if (cached) {
-      log2.debug(`User ${userId} found in cache: @${cached.name}`);
+      log3.debug(`User ${userId} found in cache: @${cached.name}`);
       return this.normalizePlatformUser(cached);
     }
     try {
       const response = await this.api("GET", `users.info?user=${userId}`);
       this.userCache.set(userId, response.user);
       this.usernameToIdCache.set(response.user.name, userId);
-      log2.debug(`User ${userId} fetched: @${response.user.name}`);
+      log3.debug(`User ${userId} fetched: @${response.user.name}`);
       return this.normalizePlatformUser(response.user);
     } catch (err) {
-      log2.warn(`Failed to get user ${userId}: ${err}`);
+      log3.warn(`Failed to get user ${userId}: ${err}`);
       return null;
     }
   }
@@ -47825,7 +47817,7 @@ class SlackClient extends EventEmitter2 {
       return this.getUser(cachedId);
     }
     try {
-      log2.debug(`Looking up user by username: @${username}`);
+      log3.debug(`Looking up user by username: @${username}`);
       let cursor;
       do {
         const params = cursor ? `cursor=${cursor}&limit=200` : "limit=200";
@@ -47834,28 +47826,19 @@ class SlackClient extends EventEmitter2 {
           this.userCache.set(user.id, user);
           this.usernameToIdCache.set(user.name, user.id);
           if (user.name === username) {
-            log2.debug(`User @${username} found: ${user.id}`);
+            log3.debug(`User @${username} found: ${user.id}`);
             return this.normalizePlatformUser(user);
           }
         }
         cursor = response.response_metadata?.next_cursor;
       } while (cursor);
-      log2.warn(`User @${username} not found`);
+      log3.warn(`User @${username} not found`);
       return null;
     } catch (err) {
-      log2.warn(`Failed to lookup user @${username}: ${err}`);
+      log3.warn(`Failed to lookup user @${username}: ${err}`);
       return null;
     }
   }
-  isUserAllowed(username) {
-    if (this.allowedUsers.length === 0) {
-      return true;
-    }
-    return this.allowedUsers.includes(username);
-  }
-  getBotName() {
-    return this.botName;
-  }
   getMcpConfig() {
     return {
       type: "slack",
@@ -47919,17 +47902,6 @@ class SlackClient extends EventEmitter2 {
       createAt: Math.floor(parseFloat(response.ts) * 1000)
     };
   }
-  async createInteractivePost(message, reactions, threadId) {
-    const post = await this.createPost(message, threadId, { unfurl: false });
-    for (const emoji of reactions) {
-      try {
-        await this.addReaction(post.id, emoji);
-      } catch (err) {
-        log2.warn(`Failed to add reaction ${emoji}: ${err}`);
-      }
-    }
-    return post;
-  }
   async getPost(postId) {
     try {
       const response = await this.api("GET", `conversations.history?channel=${this.channelId}&latest=${postId}&oldest=${postId}&inclusive=true&limit=1`);
@@ -47938,19 +47910,19 @@ class SlackClient extends EventEmitter2 {
       }
       return null;
     } catch (err) {
-      log2.debug(`Post ${postId.substring(0, 12)} not found: ${err}`);
+      log3.debug(`Post ${postId.substring(0, 12)} not found: ${err}`);
       return null;
     }
   }
   async deletePost(postId) {
-    log2.debug(`Deleting post ${postId.substring(0, 12)}`);
+    log3.debug(`Deleting post ${postId.substring(0, 12)}`);
     await this.api("POST", "chat.delete", {
       channel: this.channelId,
       ts: postId
     });
   }
   async pinPost(postId) {
-    log2.debug(`Pinning post ${postId.substring(0, 12)}`);
+    log3.debug(`Pinning post ${postId.substring(0, 12)}`);
     try {
       await this.api("POST", "pins.add", {
         channel: this.channelId,
@@ -47958,14 +47930,14 @@ class SlackClient extends EventEmitter2 {
       }, 0, ["already_pinned"]);
     } catch (err) {
       if (err instanceof Error && err.message.includes("already_pinned")) {
-        log2.debug(`Post ${postId.substring(0, 12)} already pinned`);
+        log3.debug(`Post ${postId.substring(0, 12)} already pinned`);
         return;
       }
       throw err;
     }
   }
   async unpinPost(postId) {
-    log2.debug(`Unpinning post ${postId.substring(0, 12)}`);
+    log3.debug(`Unpinning post ${postId.substring(0, 12)}`);
     try {
       await this.api("POST", "pins.remove", {
         channel: this.channelId,
@@ -47973,7 +47945,7 @@ class SlackClient extends EventEmitter2 {
       }, 0, ["no_pin"]);
     } catch (err) {
       if (err instanceof Error && err.message.includes("no_pin")) {
-        log2.debug(`Post ${postId.substring(0, 12)} was not pinned`);
+        log3.debug(`Post ${postId.substring(0, 12)} was not pinned`);
         return;
       }
       throw err;
@@ -47991,7 +47963,7 @@ class SlackClient extends EventEmitter2 {
     if (message.length <= maxLength) {
       return message;
     }
-    log2.warn(`Truncating message from ${message.length} to ~${maxLength} chars`);
+    log3.warn(`Truncating message from ${message.length} to ~${maxLength} chars`);
     return truncateMessageSafely(message, maxLength, "_... (truncated)_");
   }
   async getThreadHistory(threadId, options) {
@@ -48016,13 +47988,13 @@ class SlackClient extends EventEmitter2 {
       messages.sort((a, b) => a.createAt - b.createAt);
       return messages;
     } catch (err) {
-      log2.warn(`Failed to get thread history for ${threadId}: ${err}`);
+      log3.warn(`Failed to get thread history for ${threadId}: ${err}`);
       return [];
     }
   }
   async addReaction(postId, emojiName) {
     const name = getEmojiName(emojiName);
-    log2.debug(`Adding reaction :${name}: to post ${postId.substring(0, 12)}`);
+    log3.debug(`Adding reaction :${name}: to post ${postId.substring(0, 12)}`);
     await this.api("POST", "reactions.add", {
       channel: this.channelId,
       timestamp: postId,
@@ -48031,7 +48003,7 @@ class SlackClient extends EventEmitter2 {
   }
   async removeReaction(postId, emojiName) {
     const name = getEmojiName(emojiName);
-    log2.debug(`Removing reaction :${name}: from post ${postId.substring(0, 12)}`);
+    log3.debug(`Removing reaction :${name}: from post ${postId.substring(0, 12)}`);
     await this.api("POST", "reactions.remove", {
       channel: this.channelId,
       timestamp: postId,
@@ -48057,7 +48029,7 @@ class SlackClient extends EventEmitter2 {
   }
   sendTyping(_threadId) {}
   async downloadFile(fileId) {
-    log2.debug(`Downloading file ${fileId}`);
+    log3.debug(`Downloading file ${fileId}`);
     const fileInfo = await this.api("GET", `files.info?file=${fileId}`);
     const downloadUrl = fileInfo.file.url_private_download || fileInfo.file.url_private;
     if (!downloadUrl) {
@@ -48069,11 +48041,11 @@ class SlackClient extends EventEmitter2 {
       }
     });
     if (!response.ok) {
-      log2.warn(`Failed to download file ${fileId}: ${response.status}`);
+      log3.warn(`Failed to download file ${fileId}: ${response.status}`);
       throw new Error(`Failed to download file ${fileId}: ${response.status}`);
     }
     const arrayBuffer = await response.arrayBuffer();
-    log2.debug(`Downloaded file ${fileId}: ${arrayBuffer.byteLength} bytes`);
+    log3.debug(`Downloaded file ${fileId}: ${arrayBuffer.byteLength} bytes`);
     return Buffer.from(arrayBuffer);
   }
   async getFileInfo(fileId) {
@@ -48082,10 +48054,10 @@ class SlackClient extends EventEmitter2 {
   }
 }
 // src/mattermost/api.ts
-var log3 = createLogger("mm-api");
+var log4 = createLogger("mm-api");
 async function mattermostApi(config, method, path, body) {
   const url = `${config.url}/api/v4${path}`;
-  log3.debug(`API ${method} ${path}`);
+  log4.debug(`API ${method} ${path}`);
   const response = await fetch(url, {
     method,
     headers: {
@@ -48096,10 +48068,10 @@ async function mattermostApi(config, method, path, body) {
   });
   if (!response.ok) {
     const text = await response.text();
-    log3.warn(`API ${method} ${path} failed: ${response.status} ${text.substring(0, 100)}`);
+    log4.warn(`API ${method} ${path} failed: ${response.status} ${text.substring(0, 100)}`);
     throw new Error(`Mattermost API error ${response.status}: ${text}`);
   }
-  log3.debug(`API ${method} ${path} \u2192 ${response.status}`);
+  log4.debug(`API ${method} ${path} \u2192 ${response.status}`);
   return response.json();
 }
 async function getMe(config) {
@@ -48109,7 +48081,7 @@ async function getUser(config, userId) {
   try {
     return await mattermostApi(config, "GET", `/users/${userId}`);
   } catch (err) {
-    log3.debug(`Failed to get user ${userId}: ${err}`);
+    log4.debug(`Failed to get user ${userId}: ${err}`);
     return null;
   }
 }
@@ -48144,7 +48116,7 @@ async function createInteractivePost(config, channelId, message, reactions, root
     try {
       await addReaction(config, post.id, botUserId, emoji);
     } catch (err) {
-      log3.warn(`Failed to add reaction ${emoji}: ${err}`);
+      log4.warn(`Failed to add reaction ${emoji}: ${err}`);
     }
   }
   return post;
@@ -48488,13 +48460,13 @@ class SlackPermissionApi {
   }
 }
 // src/session/manager.ts
-import { EventEmitter as EventEmitter5 } from "events";
+import { EventEmitter as EventEmitter4 } from "events";
 
 // src/persistence/session-store.ts
 import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2, renameSync } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join2 } from "path";
-var log4 = createLogger("persist");
+var log5 = createLogger("persist");
 var STORE_VERSION = 2;
 var DEFAULT_CONFIG_DIR = join2(homedir2(), ".config", "claude-threads");
 var DEFAULT_SESSIONS_FILE = join2(DEFAULT_CONFIG_DIR, "sessions.json");
@@ -48519,13 +48491,13 @@ class SessionStore {
   load() {
     const sessions = new Map;
     if (!existsSync3(this.sessionsFile)) {
-      log4.debug("No sessions file found");
+      log5.debug("No sessions file found");
       return sessions;
     }
     try {
       const data = JSON.parse(readFileSync3(this.sessionsFile, "utf-8"));
       if (data.version === 1) {
-        log4.info("Migrating sessions from v1 to v2 (adding platformId)");
+        log5.info("Migrating sessions from v1 to v2 (adding platformId)");
         const newSessions = {};
         for (const [_oldKey, session] of Object.entries(data.sessions)) {
           const v1Session = session;
@@ -48539,7 +48511,7 @@ class SessionStore {
         data.version = 2;
         this.writeAtomic(data);
       } else if (data.version !== STORE_VERSION) {
-        log4.warn(`Sessions file version ${data.version} not supported, starting fresh`);
+        log5.warn(`Sessions file version ${data.version} not supported, starting fresh`);
         return sessions;
       }
       for (const session of Object.values(data.sessions)) {
@@ -48548,9 +48520,9 @@ class SessionStore {
         const sessionId = `${session.platformId}:${session.threadId}`;
         sessions.set(sessionId, session);
       }
-      log4.debug(`Loaded ${sessions.size} active session(s)`);
+      log5.debug(`Loaded ${sessions.size} active session(s)`);
     } catch (err) {
-      log4.error(`Failed to load sessions: ${err}`);
+      log5.error(`Failed to load sessions: ${err}`);
     }
     return sessions;
   }
@@ -48559,7 +48531,7 @@ class SessionStore {
     data.sessions[sessionId] = session;
     this.writeAtomic(data);
     const shortId = sessionId.substring(0, 20);
-    log4.debug(`Saved session ${shortId}...`);
+    log5.debug(`Saved session ${shortId}...`);
   }
   remove(sessionId) {
     const data = this.loadRaw();
@@ -48567,7 +48539,7 @@ class SessionStore {
       delete data.sessions[sessionId];
       this.writeAtomic(data);
       const shortId = sessionId.substring(0, 20);
-      log4.debug(`Removed session ${shortId}...`);
+      log5.debug(`Removed session ${shortId}...`);
     }
   }
   softDelete(sessionId) {
@@ -48576,7 +48548,7 @@ class SessionStore {
       data.sessions[sessionId].cleanedAt = new Date().toISOString();
       this.writeAtomic(data);
       const shortId = sessionId.substring(0, 20);
-      log4.debug(`Soft-deleted session ${shortId}...`);
+      log5.debug(`Soft-deleted session ${shortId}...`);
     }
   }
   cleanStale(maxAgeMs) {
@@ -48594,7 +48566,7 @@ class SessionStore {
     }
     if (staleIds.length > 0) {
       this.writeAtomic(data);
-      log4.debug(`Soft-deleted ${staleIds.length} stale session(s)`);
+      log5.debug(`Soft-deleted ${staleIds.length} stale session(s)`);
     }
     return staleIds;
   }
@@ -48613,7 +48585,7 @@ class SessionStore {
     }
     if (removedCount > 0) {
       this.writeAtomic(data);
-      log4.debug(`Permanently removed ${removedCount} old session(s) from history`);
+      log5.debug(`Permanently removed ${removedCount} old session(s) from history`);
     }
     return removedCount;
   }
@@ -48640,7 +48612,7 @@ class SessionStore {
   clear() {
     const data = this.loadRaw();
     this.writeAtomic({ version: STORE_VERSION, sessions: {}, stickyPostIds: data.stickyPostIds });
-    log4.debug("Cleared all sessions");
+    log5.debug("Cleared all sessions");
   }
   saveStickyPostId(platformId, postId) {
     const data = this.loadRaw();
@@ -48649,7 +48621,7 @@ class SessionStore {
     }
     data.stickyPostIds[platformId] = postId;
     this.writeAtomic(data);
-    log4.debug(`Saved sticky post ID for ${platformId}: ${postId.substring(0, 8)}...`);
+    log5.debug(`Saved sticky post ID for ${platformId}: ${postId.substring(0, 8)}...`);
   }
   getStickyPostIds() {
     const data = this.loadRaw();
@@ -48660,7 +48632,7 @@ class SessionStore {
     if (data.stickyPostIds && data.stickyPostIds[platformId]) {
       delete data.stickyPostIds[platformId];
       this.writeAtomic(data);
-      log4.debug(`Removed sticky post ID for ${platformId}`);
+      log5.debug(`Removed sticky post ID for ${platformId}`);
     }
   }
   getPlatformEnabledState() {
@@ -48678,7 +48650,7 @@ class SessionStore {
     }
     data.platformEnabledState[platformId] = enabled;
     this.writeAtomic(data);
-    log4.debug(`Set platform ${platformId} enabled state to ${enabled}`);
+    log5.debug(`Set platform ${platformId} enabled state to ${enabled}`);
   }
   findByThread(platformId, threadId) {
     const sessionId = `${platformId}:${threadId}`;
@@ -48724,7 +48696,7 @@ import { join as join5 } from "path";
 import { existsSync as existsSync4, mkdirSync as mkdirSync3, appendFileSync, readdirSync, statSync, unlinkSync, rmdirSync, readFileSync as readFileSync4 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join3, dirname as dirname3 } from "path";
-var log5 = createLogger("thread-log");
+var log6 = createLogger("thread-log");
 var LOGS_BASE_DIR = join3(homedir3(), ".claude-threads", "logs");
 
 class ThreadLoggerImpl {
@@ -48754,7 +48726,7 @@ class ThreadLoggerImpl {
       this.flushTimer = setInterval(() => {
         this.flushSync();
       }, this.flushIntervalMs);
-      log5.debug(`Thread logger initialized: ${this.logPath}`);
+      log6.debug(`Thread logger initialized: ${this.logPath}`);
     }
   }
   isEnabled() {
@@ -48868,7 +48840,7 @@ class ThreadLoggerImpl {
       this.flushTimer = null;
     }
     this.flushSync();
-    log5.debug(`Thread logger closed: ${this.logPath}`);
+    log6.debug(`Thread logger closed: ${this.logPath}`);
   }
   addEntry(entry) {
     this.buffer.push(entry);
@@ -48886,7 +48858,7 @@ class ThreadLoggerImpl {
       appendFileSync(this.logPath, lines, "utf8");
       this.buffer = [];
     } catch (err) {
-      log5.error(`Failed to flush thread log: ${err}`);
+      log6.error(`Failed to flush thread log: ${err}`);
     }
   }
 }
@@ -48937,25 +48909,25 @@ function cleanupOldLogs(retentionDays = 30) {
           if (fileStat.mtimeMs < cutoffMs) {
             unlinkSync(filePath);
             deletedCount++;
-            log5.debug(`Deleted old log file: ${filePath}`);
+            log6.debug(`Deleted old log file: ${filePath}`);
           }
         } catch (err) {
-          log5.warn(`Failed to check/delete log file ${filePath}: ${err}`);
+          log6.warn(`Failed to check/delete log file ${filePath}: ${err}`);
         }
       }
       try {
         const remaining = readdirSync(platformDir);
         if (remaining.length === 0) {
           rmdirSync(platformDir);
-          log5.debug(`Removed empty platform log directory: ${platformDir}`);
+          log6.debug(`Removed empty platform log directory: ${platformDir}`);
         }
       } catch {}
     }
     if (deletedCount > 0) {
-      log5.info(`Cleaned up ${deletedCount} old log file(s)`);
+      log6.info(`Cleaned up ${deletedCount} old log file(s)`);
     }
   } catch (err) {
-    log5.error(`Failed to clean up old logs: ${err}`);
+    log6.error(`Failed to clean up old logs: ${err}`);
   }
   return deletedCount;
 }
@@ -48964,16 +48936,16 @@ function getLogFilePath(platformId, sessionId) {
 }
 function readRecentLogEntries(platformId, sessionId, maxLines = 50) {
   const logPath = getLogFilePath(platformId, sessionId);
-  log5.debug(`Reading log entries from: ${logPath}`);
+  log6.debug(`Reading log entries from: ${logPath}`);
   if (!existsSync4(logPath)) {
-    log5.debug(`Log file does not exist: ${logPath}`);
+    log6.debug(`Log file does not exist: ${logPath}`);
     return [];
   }
   try {
     const content = readFileSync4(logPath, "utf8");
     const lines = content.trim().split(`
 `);
-    log5.debug(`Log file has ${lines.length} lines`);
+    log6.debug(`Log file has ${lines.length} lines`);
     const recentLines = lines.slice(-maxLines);
     const entries = [];
     for (const line of recentLines) {
@@ -48983,10 +48955,10 @@ function readRecentLogEntries(platformId, sessionId, maxLines = 50) {
         entries.push(JSON.parse(line));
       } catch {}
     }
-    log5.debug(`Parsed ${entries.length} log entries`);
+    log6.debug(`Parsed ${entries.length} log entries`);
     return entries;
   } catch (err) {
-    log5.error(`Failed to read log file: ${err}`);
+    log6.error(`Failed to read log file: ${err}`);
     return [];
   }
 }
@@ -48997,11 +48969,11 @@ import { randomUUID } from "crypto";
 import * as path from "path";
 import * as fs from "fs/promises";
 import { homedir as homedir4 } from "os";
-var log6 = createLogger("git-wt");
+var log7 = createLogger("git-wt");
 var WORKTREES_DIR = path.join(homedir4(), ".claude-threads", "worktrees");
 async function execGit(args, cwd) {
   const cmd = `git ${args.join(" ")}`;
-  log6.debug(`Executing: ${cmd}`);
+  log7.debug(`Executing: ${cmd}`);
   return new Promise((resolve2, reject) => {
     const proc = spawn("git", args, { cwd });
     let stdout = "";
@@ -49014,15 +48986,15 @@ async function execGit(args, cwd) {
     });
     proc.on("close", (code) => {
       if (code === 0) {
-        log6.debug(`${cmd} \u2192 success`);
+        log7.debug(`${cmd} \u2192 success`);
         resolve2(stdout.trim());
       } else {
-        log6.debug(`${cmd} \u2192 failed (code=${code}): ${stderr.substring(0, 100) || stdout.substring(0, 100)}`);
+        log7.debug(`${cmd} \u2192 failed (code=${code}): ${stderr.substring(0, 100) || stdout.substring(0, 100)}`);
         reject(new Error(`git ${args.join(" ")} failed: ${stderr || stdout}`));
       }
     });
     proc.on("error", (err) => {
-      log6.warn(`${cmd} \u2192 error: ${err}`);
+      log7.warn(`${cmd} \u2192 error: ${err}`);
       reject(err);
     });
   });
@@ -49032,7 +49004,7 @@ async function isGitRepository(dir) {
     await execGit(["rev-parse", "--git-dir"], dir);
     return true;
   } catch (err) {
-    log6.debug(`Not a git repository: ${dir} (${err})`);
+    log7.debug(`Not a git repository: ${dir} (${err})`);
     return false;
   }
 }
@@ -49167,7 +49139,7 @@ async function detectWorktreeInfo(workingDir) {
     const branchOutput = await execGit(["rev-parse", "--abbrev-ref", "HEAD"], workingDir);
     const branch = branchOutput?.trim();
     if (!branch) {
-      log6.debug(`Could not detect branch for worktree at ${workingDir}`);
+      log7.debug(`Could not detect branch for worktree at ${workingDir}`);
       return null;
     }
     const gitDirOutput = await execGit(["rev-parse", "--git-common-dir"], workingDir);
@@ -49179,45 +49151,45 @@ async function detectWorktreeInfo(workingDir) {
         repoRoot = repoRoot.slice(0, -4);
       }
     }
-    log6.debug(`Detected worktree: path=${workingDir}, branch=${branch}, repoRoot=${repoRoot}`);
+    log7.debug(`Detected worktree: path=${workingDir}, branch=${branch}, repoRoot=${repoRoot}`);
     return {
       worktreePath: workingDir,
       branch,
       repoRoot: repoRoot || workingDir
     };
   } catch (err) {
-    log6.debug(`Failed to detect worktree info for ${workingDir}: ${err}`);
+    log7.debug(`Failed to detect worktree info for ${workingDir}: ${err}`);
     return null;
   }
 }
 async function createWorktree(repoRoot, branch, targetDir) {
-  log6.info(`Creating worktree for branch '${branch}' at ${targetDir}`);
+  log7.info(`Creating worktree for branch '${branch}' at ${targetDir}`);
   const parentDir = path.dirname(targetDir);
-  log6.debug(`Creating parent directory: ${parentDir}`);
+  log7.debug(`Creating parent directory: ${parentDir}`);
   await fs.mkdir(parentDir, { recursive: true });
   const exists = await branchExists(repoRoot, branch);
   if (exists) {
-    log6.debug(`Branch '${branch}' exists, adding worktree`);
+    log7.debug(`Branch '${branch}' exists, adding worktree`);
     await execGit(["worktree", "add", targetDir, branch], repoRoot);
   } else {
-    log6.debug(`Branch '${branch}' does not exist, creating with worktree`);
+    log7.debug(`Branch '${branch}' does not exist, creating with worktree`);
     await execGit(["worktree", "add", "-b", branch, targetDir], repoRoot);
   }
-  log6.info(`Worktree created successfully: ${targetDir}`);
+  log7.info(`Worktree created successfully: ${targetDir}`);
   return targetDir;
 }
 async function removeWorktree(repoRoot, worktreePath) {
-  log6.info(`Removing worktree: ${worktreePath}`);
+  log7.info(`Removing worktree: ${worktreePath}`);
   try {
     await execGit(["worktree", "remove", worktreePath], repoRoot);
-    log6.debug("Worktree removed cleanly");
+    log7.debug("Worktree removed cleanly");
   } catch (err) {
-    log6.debug(`Clean remove failed (${err}), trying force remove`);
+    log7.debug(`Clean remove failed (${err}), trying force remove`);
     await execGit(["worktree", "remove", "--force", worktreePath], repoRoot);
   }
-  log6.debug("Pruning stale worktree references");
+  log7.debug("Pruning stale worktree references");
   await execGit(["worktree", "prune"], repoRoot);
-  log6.info("Worktree removed and pruned successfully");
+  log7.info("Worktree removed and pruned successfully");
 }
 async function findWorktreeByBranch(repoRoot, branch) {
   const worktrees = await listWorktrees(repoRoot);
@@ -49258,14 +49230,14 @@ async function writeMetadataStore(store) {
     await fs.mkdir(path.dirname(METADATA_STORE_PATH), { recursive: true });
     await fs.writeFile(METADATA_STORE_PATH, JSON.stringify(store, null, 2), "utf-8");
   } catch (err) {
-    log6.warn(`Failed to write worktree metadata store: ${err}`);
+    log7.warn(`Failed to write worktree metadata store: ${err}`);
   }
 }
 async function writeWorktreeMetadata(worktreePath, metadata) {
   const store = await readMetadataStore();
   store[worktreePath] = metadata;
   await writeMetadataStore(store);
-  log6.debug(`Wrote worktree metadata for: ${worktreePath}`);
+  log7.debug(`Wrote worktree metadata for: ${worktreePath}`);
 }
 async function readWorktreeMetadata(worktreePath) {
   const store = await readMetadataStore();
@@ -49288,12 +49260,12 @@ async function removeWorktreeMetadata(worktreePath) {
   if (store[worktreePath]) {
     delete store[worktreePath];
     await writeMetadataStore(store);
-    log6.debug(`Removed worktree metadata for: ${worktreePath}`);
+    log7.debug(`Removed worktree metadata for: ${worktreePath}`);
   }
 }
 
 // src/cleanup/scheduler.ts
-var log7 = createLogger("cleanup");
+var log8 = createLogger("cleanup");
 var DEFAULT_CLEANUP_INTERVAL_MS = 60 * 60 * 1000;
 var MAX_WORKTREE_AGE_MS = 24 * 60 * 60 * 1000;
 
@@ -49316,17 +49288,17 @@ class CleanupScheduler {
   }
   start() {
     if (this.isRunning) {
-      log7.debug("Cleanup scheduler already running");
+      log8.debug("Cleanup scheduler already running");
       return;
     }
     this.isRunning = true;
-    log7.info(`Cleanup scheduler started (interval: ${Math.round(this.intervalMs / 60000)}min)`);
+    log8.info(`Cleanup scheduler started (interval: ${Math.round(this.intervalMs / 60000)}min)`);
     this.runCleanup().catch((err) => {
-      log7.warn(`Initial cleanup failed: ${err}`);
+      log8.warn(`Initial cleanup failed: ${err}`);
     });
     this.timer = setInterval(() => {
       this.runCleanup().catch((err) => {
-        log7.warn(`Periodic cleanup failed: ${err}`);
+        log8.warn(`Periodic cleanup failed: ${err}`);
       });
     }, this.intervalMs);
   }
@@ -49336,11 +49308,11 @@ class CleanupScheduler {
       this.timer = null;
     }
     this.isRunning = false;
-    log7.debug("Cleanup scheduler stopped");
+    log8.debug("Cleanup scheduler stopped");
   }
   async runCleanup() {
     const startTime = Date.now();
-    log7.debug("Running background cleanup...");
+    log8.debug("Running background cleanup...");
     const stats = {
       logsDeleted: 0,
       worktreesCleaned: 0,
@@ -49366,9 +49338,9 @@ class CleanupScheduler {
     const elapsed = Date.now() - startTime;
     const totalCleaned = stats.logsDeleted + stats.worktreesCleaned + stats.metadataCleaned;
     if (totalCleaned > 0 || stats.errors.length > 0) {
-      log7.info(`Cleanup completed in ${elapsed}ms: ` + `${stats.logsDeleted} logs, ${stats.worktreesCleaned} worktrees, ${stats.metadataCleaned} metadata` + (stats.errors.length > 0 ? ` (${stats.errors.length} errors)` : ""));
+      log8.info(`Cleanup completed in ${elapsed}ms: ` + `${stats.logsDeleted} logs, ${stats.worktreesCleaned} worktrees, ${stats.metadataCleaned} metadata` + (stats.errors.length > 0 ? ` (${stats.errors.length} errors)` : ""));
     } else {
-      log7.debug(`Cleanup completed in ${elapsed}ms (nothing to clean)`);
+      log8.debug(`Cleanup completed in ${elapsed}ms (nothing to clean)`);
     }
     return stats;
   }
@@ -49381,7 +49353,7 @@ class CleanupScheduler {
         const deleted = cleanupOldLogs(this.logRetentionDays);
         resolve2(deleted);
       } catch (err) {
-        log7.warn(`Log cleanup error: ${err}`);
+        log8.warn(`Log cleanup error: ${err}`);
         resolve2(0);
       }
     });
@@ -49390,7 +49362,7 @@ class CleanupScheduler {
     const worktreesDir = getWorktreesDir();
     const result = { cleaned: 0, metadata: 0 };
     if (!existsSync5(worktreesDir)) {
-      log7.debug("No worktrees directory exists, nothing to clean");
+      log8.debug("No worktrees directory exists, nothing to clean");
       return result;
     }
     const persisted = this.sessionStore.load();
@@ -49408,7 +49380,7 @@ class CleanupScheduler {
           continue;
         const worktreePath = join5(worktreesDir, entry.name);
         if (activeWorktrees.has(worktreePath)) {
-          log7.debug(`Worktree in use by persisted session, skipping: ${entry.name}`);
+          log8.debug(`Worktree in use by persisted session, skipping: ${entry.name}`);
           continue;
         }
         const meta = await readWorktreeMetadata(worktreePath);
@@ -49418,7 +49390,7 @@ class CleanupScheduler {
           const lastActivity = new Date(meta.lastActivityAt).getTime();
           const age = now - lastActivity;
           if (meta.sessionId && age < this.maxWorktreeAgeMs) {
-            log7.debug(`Worktree has active session (${Math.round(age / 60000)}min old), skipping: ${entry.name}`);
+            log8.debug(`Worktree has active session (${Math.round(age / 60000)}min old), skipping: ${entry.name}`);
             continue;
           }
           const merged = age >= this.maxWorktreeAgeMs ? await isBranchMerged(meta.repoRoot, meta.branch).catch(() => false) : false;
@@ -49429,7 +49401,7 @@ class CleanupScheduler {
             shouldCleanup = true;
             cleanupReason = `inactive for ${Math.round(age / 3600000)}h`;
           } else {
-            log7.debug(`Worktree recent (${Math.round(age / 60000)}min old), skipping: ${entry.name}`);
+            log8.debug(`Worktree recent (${Math.round(age / 60000)}min old), skipping: ${entry.name}`);
             continue;
           }
         } else {
@@ -49438,7 +49410,7 @@ class CleanupScheduler {
         }
         if (!shouldCleanup)
           continue;
-        log7.info(`Cleaning worktree (${cleanupReason}): ${entry.name}`);
+        log8.info(`Cleaning worktree (${cleanupReason}): ${entry.name}`);
         try {
           if (meta?.repoRoot) {
             await removeWorktree(meta.repoRoot, worktreePath);
@@ -49449,19 +49421,19 @@ class CleanupScheduler {
           await removeWorktreeMetadata(worktreePath);
           result.metadata++;
         } catch (err) {
-          log7.warn(`Failed to clean orphaned worktree ${entry.name}: ${err}`);
+          log8.warn(`Failed to clean orphaned worktree ${entry.name}: ${err}`);
           try {
             await rm(worktreePath, { recursive: true, force: true });
             result.cleaned++;
             await removeWorktreeMetadata(worktreePath);
             result.metadata++;
           } catch (rmErr) {
-            log7.error(`Failed to force remove worktree ${entry.name}: ${rmErr}`);
+            log8.error(`Failed to force remove worktree ${entry.name}: ${rmErr}`);
           }
         }
       }
     } catch (err) {
-      log7.warn(`Failed to scan worktrees directory: ${err}`);
+      log8.warn(`Failed to scan worktrees directory: ${err}`);
     }
     return result;
   }
@@ -49528,13 +49500,13 @@ function getSessionStatus(session) {
 
 // src/claude/cli.ts
 import { spawn as spawn2 } from "child_process";
-import { EventEmitter as EventEmitter3 } from "events";
+import { EventEmitter as EventEmitter2 } from "events";
 import { resolve as resolve2, dirname as dirname5 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { existsSync as existsSync6, readFileSync as readFileSync5, watchFile, unwatchFile, unlinkSync as unlinkSync2, statSync as statSync2, readdirSync as readdirSync2 } from "fs";
 import { tmpdir } from "os";
 import { join as join6 } from "path";
-var log8 = createLogger("claude");
+var log9 = createLogger("claude");
 function cleanupBrowserBridgeSockets() {
   try {
     const tempDir = tmpdir();
@@ -49546,17 +49518,17 @@ function cleanupBrowserBridgeSockets() {
           const stats = statSync2(filePath);
           if (stats.isSocket()) {
             unlinkSync2(filePath);
-            log8.debug(`Removed stale browser bridge socket: ${file}`);
+            log9.debug(`Removed stale browser bridge socket: ${file}`);
           }
         } catch {}
       }
     }
   } catch (err) {
-    log8.debug(`Browser bridge cleanup failed: ${err}`);
+    log9.debug(`Browser bridge cleanup failed: ${err}`);
   }
 }
 
-class ClaudeCli extends EventEmitter3 {
+class ClaudeCli extends EventEmitter2 {
   process = null;
   options;
   buffer = "";
@@ -50207,7 +50179,7 @@ import { existsSync as existsSync10 } from "fs";
 
 // src/utils/keep-alive.ts
 import { spawn as spawn3 } from "child_process";
-var log9 = createLogger("keepalive");
+var log10 = createLogger("keepalive");
 
 class KeepAliveManager {
   activeSessionCount = 0;
@@ -50222,7 +50194,7 @@ class KeepAliveManager {
     if (!enabled && this.keepAliveProcess) {
       this.stopKeepAlive();
     }
-    log9.debug(`Keep-alive ${enabled ? "enabled" : "disabled"}`);
+    log10.debug(`Keep-alive ${enabled ? "enabled" : "disabled"}`);
   }
   isEnabled() {
     return this.enabled;
@@ -50232,7 +50204,7 @@ class KeepAliveManager {
   }
   sessionStarted() {
     this.activeSessionCount++;
-    log9.debug(`Session started (${this.activeSessionCount} active)`);
+    log10.debug(`Session started (${this.activeSessionCount} active)`);
     if (this.activeSessionCount === 1) {
       this.startKeepAlive();
     }
@@ -50241,7 +50213,7 @@ class KeepAliveManager {
     if (this.activeSessionCount > 0) {
       this.activeSessionCount--;
     }
-    log9.debug(`Session ended (${this.activeSessionCount} active)`);
+    log10.debug(`Session ended (${this.activeSessionCount} active)`);
     if (this.activeSessionCount === 0) {
       this.stopKeepAlive();
     }
@@ -50255,11 +50227,11 @@ class KeepAliveManager {
   }
   startKeepAlive() {
     if (!this.enabled) {
-      log9.debug("Keep-alive disabled, skipping");
+      log10.debug("Keep-alive disabled, skipping");
       return;
     }
     if (this.keepAliveProcess) {
-      log9.debug("Keep-alive already running");
+      log10.debug("Keep-alive already running");
       return;
     }
     switch (this.platform) {
@@ -50273,12 +50245,12 @@ class KeepAliveManager {
         this.startWindowsKeepAlive();
         break;
       default:
-        log9.warn(`Keep-alive not supported on ${this.platform}`);
+        log10.warn(`Keep-alive not supported on ${this.platform}`);
     }
   }
   stopKeepAlive() {
     if (this.keepAliveProcess) {
-      log9.debug("Stopping keep-alive");
+      log10.debug("Stopping keep-alive");
       this.keepAliveProcess.kill();
       this.keepAliveProcess = null;
     }
@@ -50290,18 +50262,18 @@ class KeepAliveManager {
         detached: false
       });
       this.keepAliveProcess.on("error", (err) => {
-        log9.error(`Failed to start caffeinate: ${err.message}`);
+        log10.error(`Failed to start caffeinate: ${err.message}`);
         this.keepAliveProcess = null;
       });
       this.keepAliveProcess.on("exit", (code) => {
         if (code !== null && code !== 0 && this.activeSessionCount > 0) {
-          log9.debug(`caffeinate exited with code ${code}`);
+          log10.debug(`caffeinate exited with code ${code}`);
         }
         this.keepAliveProcess = null;
       });
-      log9.info("Sleep prevention active (caffeinate)");
+      log10.info("Sleep prevention active (caffeinate)");
     } catch (err) {
-      log9.error(`Failed to start caffeinate: ${err}`);
+      log10.error(`Failed to start caffeinate: ${err}`);
     }
   }
   startLinuxKeepAlive() {
@@ -50317,19 +50289,19 @@ class KeepAliveManager {
         detached: false
       });
       this.keepAliveProcess.on("error", (err) => {
-        log9.debug(`systemd-inhibit not available: ${err.message}`);
+        log10.debug(`systemd-inhibit not available: ${err.message}`);
         this.keepAliveProcess = null;
         this.startLinuxKeepAliveFallback();
       });
       this.keepAliveProcess.on("exit", (code) => {
         if (code !== null && code !== 0 && this.activeSessionCount > 0) {
-          log9.debug(`systemd-inhibit exited with code ${code}`);
+          log10.debug(`systemd-inhibit exited with code ${code}`);
         }
         this.keepAliveProcess = null;
       });
-      log9.info("Sleep prevention active (systemd-inhibit)");
+      log10.info("Sleep prevention active (systemd-inhibit)");
     } catch (err) {
-      log9.debug(`Failed to start systemd-inhibit: ${err}`);
+      log10.debug(`Failed to start systemd-inhibit: ${err}`);
       this.startLinuxKeepAliveFallback();
     }
   }
@@ -50343,15 +50315,15 @@ class KeepAliveManager {
         detached: false
       });
       this.keepAliveProcess.on("error", (err) => {
-        log9.warn(`Linux keep-alive fallback not available: ${err.message}`);
+        log10.warn(`Linux keep-alive fallback not available: ${err.message}`);
         this.keepAliveProcess = null;
       });
       this.keepAliveProcess.on("exit", () => {
         this.keepAliveProcess = null;
       });
-      log9.info("Sleep prevention active (xdg-screensaver)");
+      log10.info("Sleep prevention active (xdg-screensaver)");
     } catch (err) {
-      log9.warn(`Linux keep-alive not available: ${err}`);
+      log10.warn(`Linux keep-alive not available: ${err}`);
     }
   }
   startWindowsKeepAlive() {
@@ -50376,25 +50348,25 @@ class KeepAliveManager {
         windowsHide: true
       });
       this.keepAliveProcess.on("error", (err) => {
-        log9.warn(`Windows keep-alive not available: ${err.message}`);
+        log10.warn(`Windows keep-alive not available: ${err.message}`);
         this.keepAliveProcess = null;
       });
       this.keepAliveProcess.on("exit", (code) => {
         if (code !== null && code !== 0 && this.activeSessionCount > 0) {
-          log9.debug(`PowerShell keep-alive exited with code ${code}`);
+          log10.debug(`PowerShell keep-alive exited with code ${code}`);
         }
         this.keepAliveProcess = null;
       });
-      log9.info("Sleep prevention active (SetThreadExecutionState)");
+      log10.info("Sleep prevention active (SetThreadExecutionState)");
     } catch (err) {
-      log9.warn(`Windows keep-alive not available: ${err}`);
+      log10.warn(`Windows keep-alive not available: ${err}`);
     }
   }
 }
 var keepAlive = new KeepAliveManager;
 
 // src/utils/error-handler/index.ts
-var log10 = createLogger("error");
+var log11 = createLogger("error");
 
 class SessionError extends Error {
   sessionId;
@@ -50420,19 +50392,19 @@ async function handleError(error, context, severity = "recoverable") {
   const sessionPart = sessionId ? ` (${formatShortId(sessionId)})` : "";
   const logMessage = `${context.action}${sessionPart}: ${message}`;
   if (severity === "recoverable") {
-    log10.warn(logMessage);
+    log11.warn(logMessage);
   } else {
-    log10.error(logMessage, error instanceof Error ? error : undefined);
+    log11.error(logMessage, error instanceof Error ? error : undefined);
   }
   if (context.details) {
-    log10.debugJson("Error details", context.details);
+    log11.debugJson("Error details", context.details);
   }
   if (context.notifyUser && context.session) {
     try {
       const fmt = context.session.platform.getFormatter();
       await context.session.platform.createPost(`\u26A0\uFE0F ${fmt.formatBold("Error")}: ${context.action} failed. Please try again.`, context.session.threadId);
     } catch (notifyError) {
-      log10.warn(`Could not notify user: ${notifyError}`);
+      log11.warn(`Could not notify user: ${notifyError}`);
     }
   }
   if (severity === "session-fatal" || severity === "system-fatal") {
@@ -50459,7 +50431,7 @@ async function logAndNotify(error, context) {
 }
 function logSilentError(context, error) {
   const message = error instanceof Error ? error.message : String(error);
-  log10.debug(`[${context}] Silently caught: ${message}`);
+  log11.debug(`[${context}] Silently caught: ${message}`);
 }
 
 // src/utils/session-log.ts
@@ -50474,8 +50446,8 @@ function createSessionLog(baseLog) {
 
 // src/operations/post-helpers/index.ts
 init_emoji();
-var log11 = createLogger("helpers");
-var sessionLog = createSessionLog(log11);
+var log12 = createLogger("helpers");
+var sessionLog = createSessionLog(log12);
 var POST_TYPES = {
   info: "",
   success: "\u2705",
@@ -50558,7 +50530,7 @@ function updateLastMessage(session, post2) {
 
 // src/claude/quick-query.ts
 import { spawn as spawn4 } from "child_process";
-var log12 = createLogger("query");
+var log13 = createLogger("query");
 async function quickQuery(options) {
   const {
     prompt,
@@ -50574,7 +50546,7 @@ async function quickQuery(options) {
     args.push("--system-prompt", systemPrompt);
   }
   args.push(prompt);
-  log12.debug(`Quick query: model=${model}, timeout=${timeout}ms, prompt="${prompt.substring(0, 50)}..."`);
+  log13.debug(`Quick query: model=${model}, timeout=${timeout}ms, prompt="${prompt.substring(0, 50)}..."`);
   return new Promise((resolve4) => {
     let stdout = "";
     let stderr = "";
@@ -50588,7 +50560,7 @@ async function quickQuery(options) {
       if (!resolved) {
         resolved = true;
         proc.kill("SIGTERM");
-        log12.debug(`Quick query timed out after ${timeout}ms`);
+        log13.debug(`Quick query timed out after ${timeout}ms`);
         resolve4({
           success: false,
           error: "timeout",
@@ -50606,7 +50578,7 @@ async function quickQuery(options) {
       if (!resolved) {
         resolved = true;
         clearTimeout(timeoutId);
-        log12.debug(`Quick query error: ${err.message}`);
+        log13.debug(`Quick query error: ${err.message}`);
         resolve4({
           success: false,
           error: err.message,
@@ -50620,14 +50592,14 @@ async function quickQuery(options) {
         clearTimeout(timeoutId);
         const durationMs = Date.now() - startTime;
         if (code === 0 && stdout.trim()) {
-          log12.debug(`Quick query success: ${durationMs}ms, ${stdout.length} chars`);
+          log13.debug(`Quick query success: ${durationMs}ms, ${stdout.length} chars`);
           resolve4({
             success: true,
             response: stdout.trim(),
             durationMs
           });
         } else {
-          log12.debug(`Quick query failed: code=${code}, stderr=${stderr.substring(0, 100)}`);
+          log13.debug(`Quick query failed: code=${code}, stderr=${stderr.substring(0, 100)}`);
           resolve4({
             success: false,
             error: stderr || `exit code ${code}`,
@@ -50641,7 +50613,7 @@ async function quickQuery(options) {
 }
 
 // src/operations/suggestions/title.ts
-var log13 = createLogger("title");
+var log14 = createLogger("title");
 var SUGGESTION_TIMEOUT = 15000;
 var MIN_TITLE_LENGTH = 3;
 var MAX_TITLE_LENGTH = 50;
@@ -50705,32 +50677,32 @@ function parseMetadata(response) {
   const titleMatch = response.match(/TITLE:\s*(.+)/i);
   const descMatch = response.match(/DESC:\s*(.+)/i);
   if (!titleMatch || !descMatch) {
-    log13.debug("Failed to parse title/description from response");
+    log14.debug("Failed to parse title/description from response");
     return null;
   }
   let title = titleMatch[1].trim();
   let description = descMatch[1].trim();
   if (title.length < MIN_TITLE_LENGTH) {
-    log13.debug(`Title too short: ${title.length} chars`);
+    log14.debug(`Title too short: ${title.length} chars`);
     return null;
   }
   if (title.length > MAX_TITLE_LENGTH) {
-    log13.debug(`Title too long (${title.length} chars), truncating`);
+    log14.debug(`Title too long (${title.length} chars), truncating`);
     title = truncateAtWord(title, MAX_TITLE_LENGTH);
   }
   if (description.length < MIN_DESC_LENGTH) {
-    log13.debug(`Description too short: ${description.length} chars`);
+    log14.debug(`Description too short: ${description.length} chars`);
     return null;
   }
   if (description.length > MAX_DESC_LENGTH) {
-    log13.debug(`Description too long (${description.length} chars), truncating`);
+    log14.debug(`Description too long (${description.length} chars), truncating`);
     description = truncateAtWord(description, MAX_DESC_LENGTH);
   }
   return { title, description };
 }
 async function suggestSessionMetadata(context) {
   const logContext = typeof context === "string" ? context.substring(0, 50) : context.originalTask.substring(0, 50);
-  log13.debug(`Suggesting title for: "${logContext}..."`);
+  log14.debug(`Suggesting title for: "${logContext}..."`);
   try {
     const result = await quickQuery({
       prompt: buildTitlePrompt(context),
@@ -50738,22 +50710,22 @@ async function suggestSessionMetadata(context) {
       timeout: SUGGESTION_TIMEOUT
     });
     if (!result.success || !result.response) {
-      log13.debug(`Title suggestion failed: ${result.error || "no response"}`);
+      log14.debug(`Title suggestion failed: ${result.error || "no response"}`);
       return null;
     }
     const metadata = parseMetadata(result.response);
     if (metadata) {
-      log13.debug(`Got title: "${metadata.title}" (${result.durationMs}ms)`);
+      log14.debug(`Got title: "${metadata.title}" (${result.durationMs}ms)`);
     }
     return metadata;
   } catch (err) {
-    log13.debug(`Title suggestion error: ${err}`);
+    log14.debug(`Title suggestion error: ${err}`);
     return null;
   }
 }
 
 // src/operations/suggestions/tag.ts
-var log14 = createLogger("tags");
+var log15 = createLogger("tags");
 var SUGGESTION_TIMEOUT2 = 15000;
 var MAX_TAGS = 3;
 var VALID_TAGS = [
@@ -50785,7 +50757,7 @@ function parseTags(response) {
   return [...new Set(tags)].slice(0, MAX_TAGS);
 }
 async function suggestSessionTags(userMessage) {
-  log14.debug(`Suggesting tags for: "${userMessage.substring(0, 50)}..."`);
+  log15.debug(`Suggesting tags for: "${userMessage.substring(0, 50)}..."`);
   try {
     const result = await quickQuery({
       prompt: buildTagPrompt(userMessage),
@@ -50793,14 +50765,14 @@ async function suggestSessionTags(userMessage) {
       timeout: SUGGESTION_TIMEOUT2
     });
     if (!result.success || !result.response) {
-      log14.debug(`Tag suggestion failed: ${result.error || "no response"}`);
+      log15.debug(`Tag suggestion failed: ${result.error || "no response"}`);
       return [];
     }
     const tags = parseTags(result.response);
-    log14.debug(`Got tags: ${tags.join(", ")} (${result.durationMs}ms)`);
+    log15.debug(`Got tags: ${tags.join(", ")} (${result.durationMs}ms)`);
     return tags;
   } catch (err) {
-    log14.debug(`Tag suggestion error: ${err}`);
+    log15.debug(`Tag suggestion error: ${err}`);
     return [];
   }
 }
@@ -53893,11 +53865,11 @@ class BugReportExecutor extends BaseExecutor {
 }
 // src/operations/executors/worktree-prompt.ts
 init_emoji();
-var log15 = createLogger("wt-prompt");
+var log16 = createLogger("wt-prompt");
 // src/operations/message-manager-events.ts
-import { EventEmitter as EventEmitter4 } from "events";
+import { EventEmitter as EventEmitter3 } from "events";
 
-class TypedEventEmitter extends EventEmitter4 {
+class TypedEventEmitter extends EventEmitter3 {
   emit(event, data) {
     return super.emit(event, data);
   }
@@ -53922,7 +53894,7 @@ function createMessageManagerEvents() {
 }
 
 // src/operations/message-manager.ts
-var log16 = createLogger("msg-mgr");
+var log17 = createLogger("msg-mgr");
 
 class MessageManager {
   platform;
@@ -54010,7 +53982,7 @@ class MessageManager {
     });
   }
   async handleEvent(event) {
-    const logger = log16.forSession(this.sessionId);
+    const logger = log17.forSession(this.sessionId);
     const transformCtx = {
       sessionId: this.sessionId,
       formatter: this.platform.getFormatter(),
@@ -54060,7 +54032,7 @@ class MessageManager {
     }
   }
   async executeOperation(op) {
-    const logger = log16.forSession(this.sessionId);
+    const logger = log17.forSession(this.sessionId);
     const ctx = this.getExecutorContext();
     try {
       if (isContentOp(op)) {
@@ -54128,7 +54100,7 @@ class MessageManager {
       threadId: this.threadId,
       platform: this.platform,
       formatter: this.platform.getFormatter(),
-      logger: log16.forSession(this.sessionId),
+      logger: log17.forSession(this.sessionId),
       postTracker: this.postTracker,
       contentBreaker: this.contentBreaker,
       threadLogger: this.session.threadLogger,
@@ -54339,13 +54311,13 @@ class MessageManager {
     return this.systemExecutor.postSuccess(message, this.getExecutorContext());
   }
   async prepareForUserMessage() {
-    const logger = log16.forSession(this.sessionId);
+    const logger = log17.forSession(this.sessionId);
     logger.debug("Preparing for new user message");
     await this.closeCurrentPost();
     await this.bumpTaskList();
   }
   async handleUserMessage(message, files, username, displayName) {
-    const logger = log16.forSession(this.sessionId);
+    const logger = log17.forSession(this.sessionId);
     if (!this.session.claude.isRunning()) {
       logger.debug("Claude not running, ignoring user message");
       return false;
@@ -54368,7 +54340,7 @@ class MessageManager {
     return this.session;
   }
   async handleReaction(postId, emoji, user, action) {
-    const logger = log16.forSession(this.sessionId);
+    const logger = log17.forSession(this.sessionId);
     const ctx = this.getExecutorContext();
     logger.debug(`Routing reaction: postId=${postId}, emoji=${emoji}, user=${user}, action=${action}`);
     if (await this.questionApprovalExecutor.handleReaction(postId, emoji, user, action, ctx)) {
@@ -54676,7 +54648,7 @@ function formatPullRequestLink(url, formatter) {
 }
 
 // src/operations/sticky-message/handler.ts
-var log17 = createLogger("sticky");
+var log18 = createLogger("sticky");
 var botStartedAt = new Date;
 function getPendingPrompts(session) {
   const prompts2 = [];
@@ -54751,21 +54723,21 @@ function initialize(store) {
     stickyPostIds.set(platformId, postId);
   }
   if (persistedIds.size > 0) {
-    log17.info(`\uD83D\uDCCC Restored ${persistedIds.size} sticky post ID(s) from persistence`);
+    log18.info(`\uD83D\uDCCC Restored ${persistedIds.size} sticky post ID(s) from persistence`);
   }
 }
 function setPlatformPaused(platformId, paused) {
   if (paused) {
     pausedPlatforms.set(platformId, true);
-    log17.debug(`Platform ${platformId} marked as paused`);
+    log18.debug(`Platform ${platformId} marked as paused`);
   } else {
     pausedPlatforms.delete(platformId);
-    log17.debug(`Platform ${platformId} marked as active`);
+    log18.debug(`Platform ${platformId} marked as active`);
   }
 }
 function setShuttingDown(shuttingDown) {
   isShuttingDown = shuttingDown;
-  log17.debug(`Bot shutdown state: ${shuttingDown}`);
+  log18.debug(`Bot shutdown state: ${shuttingDown}`);
 }
 function getTaskContent(session) {
   const taskState = session.messageManager?.getTaskListState();
@@ -55044,64 +55016,89 @@ async function updateStickyMessage(platform, sessions, config) {
     updateLocks.delete(platformId);
   }
 }
+async function validateLastMessageIds(platform, sessions) {
+  const sessionsWithLastMessage = sessions.filter((s) => s.lastMessageId);
+  if (sessionsWithLastMessage.length === 0) {
+    return;
+  }
+  const validationPromises = sessionsWithLastMessage.map(async (session) => {
+    const lastMessageId = session.lastMessageId;
+    if (!lastMessageId)
+      return;
+    try {
+      const post2 = await platform.getPost(lastMessageId);
+      if (!post2) {
+        log18.debug(`lastMessageId ${lastMessageId.substring(0, 8)} for session ${session.sessionId} was deleted, clearing`);
+        session.lastMessageId = undefined;
+        session.lastMessageTs = undefined;
+      }
+    } catch (err) {
+      log18.debug(`Failed to validate lastMessageId for session ${session.sessionId}, clearing: ${err}`);
+      session.lastMessageId = undefined;
+      session.lastMessageTs = undefined;
+    }
+  });
+  await Promise.all(validationPromises);
+}
 async function updateStickyMessageImpl(platform, sessions, config) {
   const platformSessions = [...sessions.values()].filter((s) => s.platformId === platform.platformId);
-  log17.debug(`updateStickyMessage for ${platform.platformId}, ${platformSessions.length} sessions`);
+  log18.debug(`updateStickyMessage for ${platform.platformId}, ${platformSessions.length} sessions`);
   for (const s of platformSessions) {
-    log17.debug(`  - ${s.sessionId}: title="${s.sessionTitle}" firstPrompt="${s.firstPrompt?.substring(0, 30)}..."`);
+    log18.debug(`  - ${s.sessionId}: title="${s.sessionTitle}" firstPrompt="${s.firstPrompt?.substring(0, 30)}..."`);
   }
+  await validateLastMessageIds(platform, platformSessions);
   const formatter = platform.getFormatter();
   const content = await buildStickyMessage(sessions, platform.platformId, config, formatter, (threadId) => platform.getThreadLink(threadId));
   const existingPostId = stickyPostIds.get(platform.platformId);
   const shouldBump = needsBump.get(platform.platformId) ?? false;
-  log17.debug(`existingPostId: ${existingPostId || "(none)"}, needsBump: ${shouldBump}`);
+  log18.debug(`existingPostId: ${existingPostId || "(none)"}, needsBump: ${shouldBump}`);
   try {
     if (existingPostId && !shouldBump) {
-      log17.debug(`Updating existing post in place...`);
+      log18.debug(`Updating existing post in place...`);
       try {
         await platform.updatePost(existingPostId, content);
         try {
           await platform.pinPost(existingPostId);
-          log17.debug(`Re-pinned post`);
+          log18.debug(`Re-pinned post`);
         } catch (pinErr) {
-          log17.debug(`Re-pin failed (might already be pinned): ${pinErr}`);
+          log18.debug(`Re-pin failed (might already be pinned): ${pinErr}`);
         }
-        log17.debug(`Updated successfully`);
+        log18.debug(`Updated successfully`);
         return;
       } catch (err) {
-        log17.debug(`Update failed, will create new: ${err}`);
+        log18.debug(`Update failed, will create new: ${err}`);
       }
     }
     needsBump.set(platform.platformId, false);
     if (existingPostId) {
-      log17.debug(`Unpinning and deleting existing post ${existingPostId.substring(0, 8)}...`);
+      log18.debug(`Unpinning and deleting existing post ${existingPostId.substring(0, 8)}...`);
       try {
         await platform.unpinPost(existingPostId);
-        log17.debug(`Unpinned successfully`);
+        log18.debug(`Unpinned successfully`);
       } catch (err) {
-        log17.debug(`Unpin failed (probably already unpinned): ${err}`);
+        log18.debug(`Unpin failed (probably already unpinned): ${err}`);
       }
       try {
         await platform.deletePost(existingPostId);
-        log17.debug(`Deleted successfully`);
+        log18.debug(`Deleted successfully`);
       } catch (err) {
-        log17.debug(`Delete failed (probably already deleted): ${err}`);
+        log18.debug(`Delete failed (probably already deleted): ${err}`);
       }
       stickyPostIds.delete(platform.platformId);
     }
-    log17.debug(`Creating new post...`);
+    log18.debug(`Creating new post...`);
     const post2 = await platform.createPost(content);
     stickyPostIds.set(platform.platformId, post2.id);
     try {
       await platform.pinPost(post2.id);
-      log17.debug(`Pinned post successfully`);
+      log18.debug(`Pinned post successfully`);
     } catch (err) {
-      log17.debug(`Failed to pin post: ${err}`);
+      log18.debug(`Failed to pin post: ${err}`);
     }
     if (sessionStore) {
       sessionStore.saveStickyPostId(platform.platformId, post2.id);
     }
-    log17.info(`\uD83D\uDCCC Created sticky message for ${platform.platformId}: ${formatShortId(post2.id)}`);
+    log18.info(`\uD83D\uDCCC Created sticky message for ${platform.platformId}: ${formatShortId(post2.id)}`);
     const excludePostIds = new Set;
     if (sessionStore) {
       for (const session of sessionStore.load().values()) {
@@ -55117,10 +55114,10 @@ async function updateStickyMessageImpl(platform, sessions, config) {
     }
     const botUser = await platform.getBotUser();
     cleanupOldStickyMessages(platform, botUser.id, false, excludePostIds).catch((err) => {
-      log17.debug(`Background cleanup failed: ${err}`);
+      log18.debug(`Background cleanup failed: ${err}`);
     });
   } catch (err) {
-    log17.error(`Failed to update sticky message for ${platform.platformId}`, err instanceof Error ? err : undefined);
+    log18.error(`Failed to update sticky message for ${platform.platformId}`, err instanceof Error ? err : undefined);
   }
 }
 async function updateAllStickyMessages(platforms, sessions, config) {
@@ -55145,7 +55142,7 @@ async function cleanupOldStickyMessages(platform, botUserId, forceRun = false, e
   if (!forceRun) {
     const lastRun = lastCleanupTime.get(platformId) || 0;
     if (now - lastRun < CLEANUP_THROTTLE_MS) {
-      log17.debug(`Cleanup throttled for ${platformId} (last run ${Math.round((now - lastRun) / 1000)}s ago)`);
+      log18.debug(`Cleanup throttled for ${platformId} (last run ${Math.round((now - lastRun) / 1000)}s ago)`);
       return;
     }
   }
@@ -55155,31 +55152,31 @@ async function cleanupOldStickyMessages(platform, botUserId, forceRun = false, e
     const pinnedPostIds = await platform.getPinnedPosts();
     const recentPinnedIds = pinnedPostIds.filter((id) => id !== currentStickyId && !excludePostIds?.has(id) && isRecentPost(id));
     if (recentPinnedIds.length === 0) {
-      log17.debug(`No recent pinned posts to check (${pinnedPostIds.length} total, current: ${currentStickyId?.substring(0, 8) || "(none)"})`);
+      log18.debug(`No recent pinned posts to check (${pinnedPostIds.length} total, current: ${currentStickyId?.substring(0, 8) || "(none)"})`);
       return;
     }
-    log17.debug(`Checking ${recentPinnedIds.length} recent pinned posts (of ${pinnedPostIds.length} total)`);
+    log18.debug(`Checking ${recentPinnedIds.length} recent pinned posts (of ${pinnedPostIds.length} total)`);
     for (const postId of recentPinnedIds) {
       try {
         const post2 = await platform.getPost(postId);
         if (!post2)
           continue;
         if (post2.userId === botUserId) {
-          log17.debug(`Cleaning up old sticky: ${postId.substring(0, 8)}...`);
+          log18.debug(`Cleaning up old sticky: ${postId.substring(0, 8)}...`);
           try {
             await platform.unpinPost(postId);
             await platform.deletePost(postId);
-            log17.info(`\uD83E\uDDF9 Cleaned up old sticky message: ${postId.substring(0, 8)}...`);
+            log18.info(`\uD83E\uDDF9 Cleaned up old sticky message: ${postId.substring(0, 8)}...`);
           } catch (err) {
-            log17.debug(`Failed to cleanup ${postId}: ${err}`);
+            log18.debug(`Failed to cleanup ${postId}: ${err}`);
           }
         }
       } catch (err) {
-        log17.debug(`Could not check post ${postId}: ${err}`);
+        log18.debug(`Could not check post ${postId}: ${err}`);
       }
     }
   } catch (err) {
-    log17.error(`Failed to cleanup old sticky messages`, err instanceof Error ? err : undefined);
+    log18.error(`Failed to cleanup old sticky messages`, err instanceof Error ? err : undefined);
   }
 }
 // src/operations/bug-report/handler.ts
@@ -59249,8 +59246,8 @@ function getUpdateInfo() {
 
 // src/operations/commands/handler.ts
 init_emoji();
-var log18 = createLogger("commands");
-var sessionLog2 = createSessionLog(log18);
+var log19 = createLogger("commands");
+var sessionLog2 = createSessionLog(log19);
 async function restartClaudeSession(session, cliOptions, ctx, actionName) {
   ctx.ops.stopTyping(session);
   transitionTo(session, "restarting");
@@ -59583,7 +59580,6 @@ async function updateSessionHeader(session, ctx) {
 `);
   const postId = session.sessionStartPostId;
   await updatePost2(session, postId, msg);
-  session.platform.pinPost(postId).catch(() => {});
 }
 async function showUpdateStatus(session, updateManager, ctx) {
   const formatter = session.platform.getFormatter();
@@ -59721,7 +59717,7 @@ async function handleBugReportApproval(session, isApproved, username) {
 import { exec as exec3 } from "child_process";
 import { promisify as promisify3 } from "util";
 var execAsync2 = promisify3(exec3);
-var log19 = createLogger("branch");
+var log20 = createLogger("branch");
 var SUGGESTION_TIMEOUT3 = 15000;
 var MAX_SUGGESTIONS = 3;
 async function getCurrentBranch3(workingDir) {
@@ -59770,7 +59766,7 @@ function parseBranchSuggestions(response) {
   return lines.slice(0, MAX_SUGGESTIONS);
 }
 async function suggestBranchNames(workingDir, userMessage) {
-  log19.debug(`Suggesting branch names for: "${userMessage.substring(0, 50)}..."`);
+  log20.debug(`Suggesting branch names for: "${userMessage.substring(0, 50)}..."`);
   try {
     const [currentBranch, recentCommits] = await Promise.all([
       getCurrentBranch3(workingDir),
@@ -59784,22 +59780,22 @@ async function suggestBranchNames(workingDir, userMessage) {
       workingDir
     });
     if (!result.success || !result.response) {
-      log19.debug(`Branch suggestion failed: ${result.error || "no response"}`);
+      log20.debug(`Branch suggestion failed: ${result.error || "no response"}`);
       return [];
     }
     const suggestions = parseBranchSuggestions(result.response);
-    log19.debug(`Got ${suggestions.length} branch suggestions: ${suggestions.join(", ")}`);
+    log20.debug(`Got ${suggestions.length} branch suggestions: ${suggestions.join(", ")}`);
     return suggestions;
   } catch (err) {
-    log19.debug(`Branch suggestion error: ${err}`);
+    log20.debug(`Branch suggestion error: ${err}`);
     return [];
   }
 }
 
 // src/operations/worktree/handler.ts
 import { randomUUID as randomUUID3 } from "crypto";
-var log20 = createLogger("worktree");
-var sessionLog3 = createSessionLog(log20);
+var log21 = createLogger("worktree");
+var sessionLog3 = createSessionLog(log21);
 function parseWorktreeError(error) {
   const message = error instanceof Error ? error.message : String(error);
   const lowerMessage = message.toLowerCase();
@@ -60327,8 +60323,8 @@ async function cleanupWorktreeCommand(session, username, hasOtherSessionsUsingWo
   }
 }
 // src/operations/events/handler.ts
-var log21 = createLogger("events");
-var sessionLog4 = createSessionLog(log21);
+var log22 = createLogger("events");
+var sessionLog4 = createSessionLog(log22);
 function detectAndExecuteClaudeCommands(text, session, ctx) {
   const parsed = parseClaudeCommand(text);
   if (parsed && isClaudeAllowedCommand(parsed.command)) {
@@ -60571,8 +60567,8 @@ function createSessionContext(config, state, ops) {
 }
 // src/operations/context-prompt/handler.ts
 init_emoji();
-var log22 = createLogger("context");
-var sessionLog5 = createSessionLog(log22);
+var log23 = createLogger("context");
+var sessionLog5 = createSessionLog(log23);
 var CONTEXT_PROMPT_TIMEOUT_MS = 30000;
 var CONTEXT_OPTIONS = [3, 5, 10];
 var contextPromptTimeouts = new Map;
@@ -60758,7 +60754,7 @@ async function offerContextPrompt(session, queuedPrompt, queuedFiles, ctx, exclu
   return true;
 }
 // src/operations/streaming/handler.ts
-var log23 = createLogger("streaming");
+var log24 = createLogger("streaming");
 async function buildMessageContent(text, platform, files, debug = false) {
   const imageFiles = files?.filter((f) => f.mimeType.startsWith("image/") && ["image/jpeg", "image/png", "image/gif", "image/webp"].includes(f.mimeType)) || [];
   if (imageFiles.length === 0) {
@@ -60768,7 +60764,7 @@ async function buildMessageContent(text, platform, files, debug = false) {
   for (const file of imageFiles) {
     try {
       if (!platform.downloadFile) {
-        log23.warn(`Platform does not support file downloads, skipping ${file.name}`);
+        log24.warn(`Platform does not support file downloads, skipping ${file.name}`);
         continue;
       }
       const buffer = await platform.downloadFile(file.id);
@@ -60782,10 +60778,10 @@ async function buildMessageContent(text, platform, files, debug = false) {
         }
       });
       if (debug) {
-        log23.debug(`Attached image: ${file.name} (${file.mimeType}, ${Math.round(buffer.length / 1024)}KB)`);
+        log24.debug(`Attached image: ${file.name} (${file.mimeType}, ${Math.round(buffer.length / 1024)}KB)`);
       }
     } catch (err) {
-      log23.error(`Failed to download image ${file.name}: ${err}`);
+      log24.error(`Failed to download image ${file.name}: ${err}`);
     }
   }
   if (text) {
@@ -60811,8 +60807,8 @@ function stopTyping(session) {
   }
 }
 // src/session/lifecycle.ts
-var log24 = createLogger("lifecycle");
-var sessionLog6 = createSessionLog(log24);
+var log25 = createLogger("lifecycle");
+var sessionLog6 = createSessionLog(log25);
 function mutableSessions(ctx) {
   return ctx.state.sessions;
 }
@@ -60971,35 +60967,76 @@ function createMessageManager(session, ctx) {
   });
   return messageManager;
 }
+var METADATA_RETRY_DELAY_MS = 2000;
+var METADATA_MAX_RETRIES = 2;
+async function attemptMetadataFetch(session, prompt, ctx, attempt = 1, options = {}) {
+  const sessionId = session.sessionId;
+  const suggestMetadataFn = options.suggestMetadata ?? suggestSessionMetadata;
+  const suggestTagsFn = options.suggestTags ?? suggestSessionTags;
+  const [metadata, tags] = await Promise.all([
+    suggestMetadataFn(prompt),
+    suggestTagsFn(prompt)
+  ]);
+  const currentSession = ctx.state.sessions.get(sessionId);
+  if (!currentSession) {
+    sessionLog6(session).debug("Session gone before metadata suggestions completed");
+    return { success: false, metadataSet: false, tagsSet: false };
+  }
+  let metadataSet = false;
+  let tagsSet = false;
+  let updated = false;
+  if (metadata && !currentSession.sessionTitle) {
+    currentSession.sessionTitle = metadata.title;
+    currentSession.sessionDescription = metadata.description;
+    sessionLog6(currentSession).debug(`Set title: "${metadata.title}" (attempt ${attempt})`);
+    metadataSet = true;
+    updated = true;
+  } else if (currentSession.sessionTitle) {
+    metadataSet = true;
+  }
+  if (tags.length > 0 && (!currentSession.sessionTags || currentSession.sessionTags.length === 0)) {
+    currentSession.sessionTags = tags;
+    sessionLog6(currentSession).debug(`Set tags: ${tags.join(", ")} (attempt ${attempt})`);
+    tagsSet = true;
+    updated = true;
+  } else if (currentSession.sessionTags && currentSession.sessionTags.length > 0) {
+    tagsSet = true;
+  }
+  if (updated) {
+    ctx.ops.persistSession(currentSession);
+    await ctx.ops.updateStickyMessage();
+    await ctx.ops.updateSessionHeader(currentSession);
+  }
+  return { success: metadataSet && tagsSet, metadataSet, tagsSet };
+}
 function fireMetadataSuggestions(session, prompt, ctx) {
   (async () => {
     try {
-      const sessionId = session.sessionId;
-      const [metadata, tags] = await Promise.all([
-        suggestSessionMetadata(prompt),
-        suggestSessionTags(prompt)
-      ]);
-      const currentSession = ctx.state.sessions.get(sessionId);
-      if (!currentSession) {
-        sessionLog6(session).debug("Session gone before metadata suggestions completed");
-        return;
-      }
-      let updated = false;
-      if (metadata && !currentSession.sessionTitle) {
-        currentSession.sessionTitle = metadata.title;
-        currentSession.sessionDescription = metadata.description;
-        sessionLog6(currentSession).debug(`Set title: "${metadata.title}"`);
-        updated = true;
-      }
-      if (tags.length > 0 && (!currentSession.sessionTags || currentSession.sessionTags.length === 0)) {
-        currentSession.sessionTags = tags;
-        sessionLog6(currentSession).debug(`Set tags: ${tags.join(", ")}`);
-        updated = true;
-      }
-      if (updated) {
-        ctx.ops.persistSession(currentSession);
-        await ctx.ops.updateStickyMessage();
-        await ctx.ops.updateSessionHeader(currentSession);
+      let result = await attemptMetadataFetch(session, prompt, ctx, 1);
+      let attempt = 1;
+      while (!result.success && attempt < METADATA_MAX_RETRIES + 1) {
+        attempt++;
+        const currentSession = ctx.state.sessions.get(session.sessionId);
+        if (!currentSession) {
+          sessionLog6(session).debug("Session gone, stopping metadata retries");
+          return;
+        }
+        const missing = [];
+        if (!result.metadataSet)
+          missing.push("title/description");
+        if (!result.tagsSet)
+          missing.push("tags");
+        sessionLog6(session).debug(`Retrying metadata fetch for ${missing.join(", ")} (attempt ${attempt}/${METADATA_MAX_RETRIES + 1})`);
+        await new Promise((resolve6) => setTimeout(resolve6, METADATA_RETRY_DELAY_MS));
+        result = await attemptMetadataFetch(session, prompt, ctx, attempt);
+      }
+      if (!result.success) {
+        const missing = [];
+        if (!result.metadataSet)
+          missing.push("title/description");
+        if (!result.tagsSet)
+          missing.push("tags");
+        sessionLog6(session).debug(`Metadata fetch incomplete after ${attempt} attempts: missing ${missing.join(", ")}`);
       }
     } catch (err) {
       sessionLog6(session).debug(`Metadata suggestion error: ${err}`);
@@ -61153,9 +61190,6 @@ ${CHAT_PLATFORM_PROMPT}`;
   fireMetadataSuggestions(session, options.prompt, ctx);
   keepAlive.sessionStarted();
   await ctx.ops.updateSessionHeader(session);
-  if (session.sessionStartPostId) {
-    await platform.pinPost(session.sessionStartPostId).catch(() => {});
-  }
   await ctx.ops.updateStickyMessage();
   ctx.ops.startTyping(session);
   claude.on("event", (e) => ctx.ops.handleEvent(sessionId, e));
@@ -61199,28 +61233,28 @@ async function resumeSession(state, ctx) {
       !state.claudeSessionId && "claudeSessionId",
       !state.workingDir && "workingDir"
     ].filter(Boolean).join(", ");
-    log24.warn(`Skipping session with missing required fields: ${missing}`);
+    log25.warn(`Skipping session with missing required fields: ${missing}`);
     return;
   }
   const shortId = state.threadId.substring(0, 8);
   const platforms = ctx.state.platforms;
   const platform = platforms.get(state.platformId);
   if (!platform) {
-    log24.warn(`Platform ${state.platformId} not registered, skipping resume for ${shortId}...`);
+    log25.warn(`Platform ${state.platformId} not registered, skipping resume for ${shortId}...`);
     return;
   }
   const threadPost = await platform.getPost(state.threadId);
   if (!threadPost) {
-    log24.warn(`Thread ${shortId}... deleted, skipping resume`);
+    log25.warn(`Thread ${shortId}... deleted, skipping resume`);
     ctx.state.sessionStore.remove(`${state.platformId}:${state.threadId}`);
     return;
   }
   if (ctx.state.sessions.size >= ctx.config.maxSessions) {
-    log24.warn(`Max sessions reached, skipping resume for ${shortId}...`);
+    log25.warn(`Max sessions reached, skipping resume for ${shortId}...`);
     return;
   }
   if (!existsSync10(state.workingDir)) {
-    log24.warn(`Working directory ${state.workingDir} no longer exists, skipping resume for ${shortId}...`);
+    log25.warn(`Working directory ${state.workingDir} no longer exists, skipping resume for ${shortId}...`);
     ctx.state.sessionStore.remove(`${state.platformId}:${state.threadId}`);
     const resumeFormatter = platform.getFormatter();
     const tempSession = {
@@ -61303,7 +61337,7 @@ ${CHAT_PLATFORM_PROMPT}`;
         worktreePath: detected.worktreePath,
         branch: detected.branch
       };
-      log24.info(`Auto-detected worktree info for resumed session: branch=${detected.branch}`);
+      log25.info(`Auto-detected worktree info for resumed session: branch=${detected.branch}`);
     }
   }
   session.messageManager = createMessageManager(session, ctx);
@@ -61355,13 +61389,10 @@ ${sessionFormatter.formatItalic("Reconnected to Claude session. You can continue
       await post(session, "resume", restartMsg);
     }
     await ctx.ops.updateSessionHeader(session);
-    if (session.sessionStartPostId) {
-      await session.platform.pinPost(session.sessionStartPostId).catch(() => {});
-    }
     await ctx.ops.updateStickyMessage();
     ctx.ops.persistSession(session);
   } catch (err) {
-    log24.error(`Failed to resume session ${shortId}`, err instanceof Error ? err : undefined);
+    log25.error(`Failed to resume session ${shortId}`, err instanceof Error ? err : undefined);
     ctx.ops.emitSessionRemove(sessionId);
     mutableSessions(ctx).delete(sessionId);
     ctx.state.sessionStore.remove(sessionId);
@@ -61396,18 +61427,18 @@ async function resumePausedSession(threadId, message, files, ctx) {
   const persisted = ctx.state.sessionStore.load();
   const state = findPersistedByThreadId(persisted, threadId);
   if (!state) {
-    log24.debug(`No persisted session found for ${threadId.substring(0, 8)}...`);
+    log25.debug(`No persisted session found for ${threadId.substring(0, 8)}...`);
     return;
   }
   const shortId = threadId.substring(0, 8);
-  log24.info(`\uD83D\uDD04 Resuming paused session ${shortId}... for new message`);
+  log25.info(`\uD83D\uDD04 Resuming paused session ${shortId}... for new message`);
   await resumeSession(state, ctx);
   const session = ctx.ops.findSessionByThreadId(threadId);
   if (session && session.claude.isRunning() && session.messageManager) {
     session.messageCount++;
     await session.messageManager.handleUserMessage(message, files, state.startedBy);
   } else {
-    log24.warn(`Failed to resume session ${shortId}..., could not send message`);
+    log25.warn(`Failed to resume session ${shortId}..., could not send message`);
   }
 }
 async function handleExit(sessionId, code, ctx) {
@@ -61415,7 +61446,7 @@ async function handleExit(sessionId, code, ctx) {
   const shortId = sessionId.substring(0, 8);
   sessionLog6(session).debug(`handleExit called code=${code} isShuttingDown=${ctx.state.isShuttingDown}`);
   if (!session) {
-    log24.debug(`Session ${shortId}... not found (already cleaned up)`);
+    log25.debug(`Session ${shortId}... not found (already cleaned up)`);
     return;
   }
   if (isSessionRestarting(session)) {
@@ -61608,7 +61639,7 @@ async function cleanupIdleSessions(timeoutMs, warningMs, ctx) {
 }
 
 // src/operations/monitor/handler.ts
-var log25 = createLogger("monitor");
+var log26 = createLogger("monitor");
 var DEFAULT_INTERVAL_MS = 60 * 1000;
 
 class SessionMonitor {
@@ -61630,14 +61661,14 @@ class SessionMonitor {
   }
   start() {
     if (this.isRunning) {
-      log25.debug("Session monitor already running");
+      log26.debug("Session monitor already running");
       return;
     }
     this.isRunning = true;
-    log25.debug(`Session monitor started (interval: ${this.intervalMs / 1000}s)`);
+    log26.debug(`Session monitor started (interval: ${this.intervalMs / 1000}s)`);
     this.timer = setInterval(() => {
       this.runCheck().catch((err) => {
-        log25.error(`Error during session monitoring: ${err}`);
+        log26.error(`Error during session monitoring: ${err}`);
       });
     }, this.intervalMs);
   }
@@ -61647,7 +61678,7 @@ class SessionMonitor {
       this.timer = null;
     }
     this.isRunning = false;
-    log25.debug("Session monitor stopped");
+    log26.debug("Session monitor stopped");
   }
   async runCheck() {
     await cleanupIdleSessions(this.sessionTimeoutMs, this.sessionWarningMs, this.getContext());
@@ -61770,9 +61801,9 @@ class SessionRegistry {
 }
 
 // src/session/manager.ts
-var log26 = createLogger("manager");
+var log27 = createLogger("manager");
 
-class SessionManager extends EventEmitter5 {
+class SessionManager extends EventEmitter4 {
   platforms = new Map;
   workingDir;
   skipPermissions;
@@ -61835,7 +61866,7 @@ class SessionManager extends EventEmitter5 {
       markNeedsBump(platformId);
       this.updateStickyMessage();
     });
-    log26.info(`\uD83D\uDCE1 Platform "${platformId}" registered`);
+    log27.info(`\uD83D\uDCE1 Platform "${platformId}" registered`);
   }
   removePlatform(platformId) {
     this.platforms.delete(platformId);
@@ -61851,7 +61882,7 @@ class SessionManager extends EventEmitter5 {
     if (users) {
       users.add(sessionId);
     }
-    log26.debug(`Registered session ${sessionId.substring(0, 20)} as worktree user for ${worktreePath}`);
+    log27.debug(`Registered session ${sessionId.substring(0, 20)} as worktree user for ${worktreePath}`);
   }
   unregisterWorktreeUser(worktreePath, sessionId) {
     const users = this.worktreeUsers.get(worktreePath);
@@ -61998,7 +62029,7 @@ class SessionManager extends EventEmitter5 {
       return false;
     }
     const shortId = persistedSession.threadId.substring(0, 8);
-    log26.info(`\uD83D\uDD04 Resuming session ${shortId}... via emoji reaction by @${username}`);
+    log27.info(`\uD83D\uDD04 Resuming session ${shortId}... via emoji reaction by @${username}`);
     await resumeSession(persistedSession, this.getContext());
     return true;
   }
@@ -62028,7 +62059,7 @@ class SessionManager extends EventEmitter5 {
       }
       if (session.lastError?.postId === postId && isBugReportEmoji(emojiName)) {
         if (session.startedBy === username || session.platform.isUserAllowed(username) || session.sessionAllowedUsers.has(username)) {
-          log26.info(`\uD83D\uDC1B @${username} triggered bug report from error reaction`);
+          log27.info(`\uD83D\uDC1B @${username} triggered bug report from error reaction`);
           await reportBug(session, undefined, username, this.getContext(), session.lastError);
           return;
         }
@@ -62188,11 +62219,11 @@ class SessionManager extends EventEmitter5 {
       }
     }
     if (sessionsToKill.length === 0) {
-      log26.info(`No active sessions to pause for platform ${platformId}`);
+      log27.info(`No active sessions to pause for platform ${platformId}`);
       await this.updateStickyMessage();
       return;
     }
-    log26.info(`\u23F8\uFE0F Pausing ${sessionsToKill.length} session(s) for platform ${platformId}`);
+    log27.info(`\u23F8\uFE0F Pausing ${sessionsToKill.length} session(s) for platform ${platformId}`);
     for (const session of sessionsToKill) {
       try {
         const fmt = session.platform.getFormatter();
@@ -62208,9 +62239,9 @@ class SessionManager extends EventEmitter5 {
         session.claude.kill();
         this.registry.unregister(session.sessionId);
         this.emitSessionRemove(session.sessionId);
-        log26.info(`\u23F8\uFE0F Paused session ${session.threadId.substring(0, 8)}`);
+        log27.info(`\u23F8\uFE0F Paused session ${session.threadId.substring(0, 8)}`);
       } catch (err) {
-        log26.warn(`Failed to pause session ${session.threadId}: ${err}`);
+        log27.warn(`Failed to pause session ${session.threadId}: ${err}`);
       }
     }
     for (const session of sessionsToKill) {
@@ -62231,17 +62262,17 @@ class SessionManager extends EventEmitter5 {
       sessionsToResume.push(state);
     }
     if (sessionsToResume.length === 0) {
-      log26.info(`No paused sessions to resume for platform ${platformId}`);
+      log27.info(`No paused sessions to resume for platform ${platformId}`);
       await this.updateStickyMessage();
       return;
     }
-    log26.info(`\u25B6\uFE0F Resuming ${sessionsToResume.length} paused session(s) for platform ${platformId}`);
+    log27.info(`\u25B6\uFE0F Resuming ${sessionsToResume.length} paused session(s) for platform ${platformId}`);
     for (const state of sessionsToResume) {
       try {
         await resumeSession(state, this.getContext());
-        log26.info(`\u25B6\uFE0F Resumed session ${state.threadId.substring(0, 8)}`);
+        log27.info(`\u25B6\uFE0F Resumed session ${state.threadId.substring(0, 8)}`);
       } catch (err) {
-        log26.warn(`Failed to resume session ${state.threadId}: ${err}`);
+        log27.warn(`Failed to resume session ${state.threadId}: ${err}`);
       }
     }
     await this.updateStickyMessage();
@@ -62253,14 +62284,14 @@ class SessionManager extends EventEmitter5 {
     const sessionTimeoutMs = this.limits.sessionTimeoutMinutes * 60 * 1000;
     const staleIds = this.sessionStore.cleanStale(sessionTimeoutMs * 2);
     if (staleIds.length > 0) {
-      log26.info(`\uD83E\uDDF9 Soft-deleted ${staleIds.length} stale session(s) (kept for history)`);
+      log27.info(`\uD83E\uDDF9 Soft-deleted ${staleIds.length} stale session(s) (kept for history)`);
     }
     const removedCount = this.sessionStore.cleanHistory();
     if (removedCount > 0) {
-      log26.info(`\uD83D\uDDD1\uFE0F Permanently removed ${removedCount} old session(s) from history`);
+      log27.info(`\uD83D\uDDD1\uFE0F Permanently removed ${removedCount} old session(s) from history`);
     }
     const persisted = this.sessionStore.load();
-    log26.info(`\uD83D\uDCC2 Loaded ${persisted.size} session(s) from persistence`);
+    log27.info(`\uD83D\uDCC2 Loaded ${persisted.size} session(s) from persistence`);
     const excludePostIdsByPlatform = new Map;
     for (const session of persisted.values()) {
       const platformId = session.platformId;
@@ -62280,10 +62311,10 @@ class SessionManager extends EventEmitter5 {
       const excludePostIds = excludePostIdsByPlatform.get(platform.platformId);
       platform.getBotUser().then((botUser) => {
         cleanupOldStickyMessages(platform, botUser.id, true, excludePostIds).catch((err) => {
-          log26.warn(`Failed to cleanup old sticky messages for ${platform.platformId}: ${err}`);
+          log27.warn(`Failed to cleanup old sticky messages for ${platform.platformId}: ${err}`);
         });
       }).catch((err) => {
-        log26.warn(`Failed to get bot user for cleanup on ${platform.platformId}: ${err}`);
+        log27.warn(`Failed to get bot user for cleanup on ${platform.platformId}: ${err}`);
       });
     }
     if (persisted.size > 0) {
@@ -62297,10 +62328,10 @@ class SessionManager extends EventEmitter5 {
         }
       }
       if (pausedToSkip.length > 0) {
-        log26.info(`\u23F8\uFE0F ${pausedToSkip.length} session(s) remain paused (waiting for user message)`);
+        log27.info(`\u23F8\uFE0F ${pausedToSkip.length} session(s) remain paused (waiting for user message)`);
       }
       if (activeToResume.length > 0) {
-        log26.info(`\uD83D\uDD04 Attempting to resume ${activeToResume.length} active session(s)...`);
+        log27.info(`\uD83D\uDD04 Attempting to resume ${activeToResume.length} active session(s)...`);
         for (const state of activeToResume) {
           await resumeSession(state, this.getContext());
         }
@@ -62586,7 +62617,7 @@ class SessionManager extends EventEmitter5 {
         const message = messageBuilder(formatter);
         await post(session, "info", message);
       } catch (err) {
-        log26.warn(`Failed to broadcast to session ${session.threadId}: ${err}`);
+        log27.warn(`Failed to broadcast to session ${session.threadId}: ${err}`);
       }
     }
   }
@@ -62605,7 +62636,7 @@ class SessionManager extends EventEmitter5 {
         session.messageManager?.setPendingUpdatePrompt({ postId: post2.id });
         this.registerPost(post2.id, session.threadId);
       } catch (err) {
-        log26.warn(`Failed to post ask message to ${threadId}: ${err}`);
+        log27.warn(`Failed to post ask message to ${threadId}: ${err}`);
       }
     }
   }
@@ -66982,7 +67013,7 @@ var instances_default = instances;
 
 // node_modules/ink/build/components/App.js
 var import_react12 = __toESM(require_react(), 1);
-import { EventEmitter as EventEmitter7 } from "events";
+import { EventEmitter as EventEmitter6 } from "events";
 import process19 from "process";
 
 // node_modules/ink/build/components/AppContext.js
@@ -66995,11 +67026,11 @@ var AppContext_default = AppContext;
 
 // node_modules/ink/build/components/StdinContext.js
 var import_react3 = __toESM(require_react(), 1);
-import { EventEmitter as EventEmitter6 } from "events";
+import { EventEmitter as EventEmitter5 } from "events";
 import process16 from "process";
 var StdinContext = import_react3.createContext({
   stdin: process16.stdin,
-  internal_eventEmitter: new EventEmitter6,
+  internal_eventEmitter: new EventEmitter5,
   setRawMode() {},
   isRawModeSupported: false,
   internal_exitOnCtrlC: true
@@ -67217,7 +67248,7 @@ class App extends import_react12.PureComponent {
     error: undefined
   };
   rawModeEnabledCount = 0;
-  internal_eventEmitter = new EventEmitter7;
+  internal_eventEmitter = new EventEmitter6;
   isRawModeSupported() {
     return this.props.stdin.isTTY;
   }
@@ -71118,9 +71149,8 @@ function Platforms({ platforms }) {
         !platform2.enabled ? /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
           dimColor: true,
           children: "\u25CB"
-        }, undefined, false, undefined, this) : platform2.reconnecting ? /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
-          color: "yellow",
-          children: "\u25CC"
+        }, undefined, false, undefined, this) : platform2.reconnecting ? /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Spinner2, {
+          type: "dots"
         }, undefined, false, undefined, this) : platform2.connected ? /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
           color: "green",
           children: "\u25CF"
@@ -71136,30 +71166,20 @@ function Platforms({ platforms }) {
             platform2.botName
           ]
         }, undefined, true, undefined, this),
-        platform2.reconnecting ? /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(jsx_dev_runtime3.Fragment, {
-          children: [
-            /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Spinner2, {
-              type: "dots"
-            }, undefined, false, undefined, this),
-            /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
-              color: "yellow",
-              children: [
-                "reconnecting (",
-                platform2.reconnectAttempts,
-                ")"
-              ]
-            }, undefined, true, undefined, this)
-          ]
-        }, undefined, true, undefined, this) : /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(jsx_dev_runtime3.Fragment, {
+        /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
+          dimColor: true,
+          children: "on"
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
+          dimColor: !platform2.enabled,
+          children: platform2.displayName
+        }, undefined, false, undefined, this),
+        platform2.reconnecting && /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
+          dimColor: true,
           children: [
-            /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
-              dimColor: true,
-              children: "on"
-            }, undefined, false, undefined, this),
-            /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
-              dimColor: !platform2.enabled,
-              children: platform2.displayName
-            }, undefined, false, undefined, this)
+            "(retry ",
+            platform2.reconnectAttempts,
+            ")"
           ]
         }, undefined, true, undefined, this)
       ]
@@ -71192,29 +71212,29 @@ function SessionLog({ logs, maxLines = 20 }) {
   return /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Box_default, {
     flexDirection: "column",
     flexShrink: 0,
-    children: displayLogs.map((log27) => /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Box_default, {
+    children: displayLogs.map((log28) => /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Box_default, {
       flexShrink: 0,
       children: [
         /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text, {
-          color: getColorForLevel(log27.level),
+          color: getColorForLevel(log28.level),
           dimColor: true,
           wrap: "truncate",
           children: [
             "[",
-            padComponent(log27.component),
+            padComponent(log28.component),
             "]"
           ]
         }, undefined, true, undefined, this),
         /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text, {
-          color: getColorForLevel(log27.level),
+          color: getColorForLevel(log28.level),
           wrap: "truncate",
           children: [
             " ",
-            log27.message
+            log28.message
           ]
         }, undefined, true, undefined, this)
       ]
-    }, log27.id, true, undefined, this))
+    }, log28.id, true, undefined, this))
   }, undefined, false, undefined, this);
 }
 // src/ui/components/Footer.tsx
@@ -71712,7 +71732,7 @@ function LogPanel({ logs, maxLines = 10, focused = false }) {
   const scrollRef = import_react59.default.useRef(null);
   const { stdout } = use_stdout_default();
   const isDebug = process.env.DEBUG === "1";
-  const displayLogs = logs.filter((log27) => isDebug || log27.level !== "debug");
+  const displayLogs = logs.filter((log28) => isDebug || log28.level !== "debug");
   const visibleLogs = displayLogs.slice(-Math.max(maxLines * 3, 100));
   import_react59.default.useEffect(() => {
     const handleResize = () => scrollRef.current?.remeasure();
@@ -71752,25 +71772,25 @@ function LogPanel({ logs, maxLines = 10, focused = false }) {
     overflow: "hidden",
     children: /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(ScrollView, {
       ref: scrollRef,
-      children: visibleLogs.map((log27) => /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Box_default, {
+      children: visibleLogs.map((log28) => /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Box_default, {
         children: [
           /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Text, {
             dimColor: true,
             children: [
               "[",
-              padComponent2(log27.component),
+              padComponent2(log28.component),
               "]"
             ]
           }, undefined, true, undefined, this),
           /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Text, {
-            color: getLevelColor(log27.level),
+            color: getLevelColor(log28.level),
             children: [
               " ",
-              log27.message
+              log28.message
             ]
           }, undefined, true, undefined, this)
         ]
-      }, log27.id, true, undefined, this))
+      }, log28.id, true, undefined, this))
     }, undefined, false, undefined, this)
   }, undefined, false, undefined, this);
 }
@@ -72287,10 +72307,10 @@ function useAppState(initialConfig) {
     });
   }, []);
   const getLogsForSession = import_react60.useCallback((sessionId) => {
-    return state.logs.filter((log27) => log27.sessionId === sessionId);
+    return state.logs.filter((log28) => log28.sessionId === sessionId);
   }, [state.logs]);
   const getGlobalLogs = import_react60.useCallback(() => {
-    return state.logs.filter((log27) => !log27.sessionId);
+    return state.logs.filter((log28) => !log28.sessionId);
   }, [state.logs]);
   const togglePlatformEnabled = import_react60.useCallback((platformId) => {
     let newEnabled = false;
@@ -73286,11 +73306,11 @@ Release notes not available. See ${formatter.formatLink("GitHub releases", "http
 }
 
 // src/auto-update/manager.ts
-import { EventEmitter as EventEmitter10 } from "events";
+import { EventEmitter as EventEmitter9 } from "events";
 
 // src/auto-update/checker.ts
-import { EventEmitter as EventEmitter8 } from "events";
-var log27 = createLogger("checker");
+import { EventEmitter as EventEmitter7 } from "events";
+var log28 = createLogger("checker");
 var PACKAGE_NAME = "claude-threads";
 function compareVersions(a, b) {
   const partsA = a.replace(/^v/, "").split(".").map(Number);
@@ -73313,18 +73333,18 @@ async function fetchLatestVersion() {
       }
     });
     if (!response.ok) {
-      log27.warn(`Failed to fetch latest version: HTTP ${response.status}`);
+      log28.warn(`Failed to fetch latest version: HTTP ${response.status}`);
       return null;
     }
     const data = await response.json();
     return data.version ?? null;
   } catch (err) {
-    log27.warn(`Failed to fetch latest version: ${err}`);
+    log28.warn(`Failed to fetch latest version: ${err}`);
     return null;
   }
 }
 
-class UpdateChecker extends EventEmitter8 {
+class UpdateChecker extends EventEmitter7 {
   config;
   checkInterval = null;
   lastCheck = null;
@@ -73336,38 +73356,38 @@ class UpdateChecker extends EventEmitter8 {
   }
   start() {
     if (!this.config.enabled) {
-      log27.debug("Auto-update disabled, not starting checker");
+      log28.debug("Auto-update disabled, not starting checker");
       return;
     }
     setTimeout(() => {
       this.check().catch((err) => {
-        log27.warn(`Initial update check failed: ${err}`);
+        log28.warn(`Initial update check failed: ${err}`);
       });
     }, 5000);
     const intervalMs = this.config.checkIntervalMinutes * 60 * 1000;
     this.checkInterval = setInterval(() => {
       this.check().catch((err) => {
-        log27.warn(`Periodic update check failed: ${err}`);
+        log28.warn(`Periodic update check failed: ${err}`);
       });
     }, intervalMs);
-    log27.info(`\uD83D\uDD04 Update checker started (every ${this.config.checkIntervalMinutes} minutes)`);
+    log28.info(`\uD83D\uDD04 Update checker started (every ${this.config.checkIntervalMinutes} minutes)`);
   }
   stop() {
     if (this.checkInterval) {
       clearInterval(this.checkInterval);
       this.checkInterval = null;
     }
-    log27.debug("Update checker stopped");
+    log28.debug("Update checker stopped");
   }
   async check() {
     if (this.isChecking) {
-      log27.debug("Check already in progress, skipping");
+      log28.debug("Check already in progress, skipping");
       return this.lastUpdateInfo;
     }
     this.isChecking = true;
     this.emit("check:start");
     try {
-      log27.debug("Checking for updates...");
+      log28.debug("Checking for updates...");
       const latestVersion2 = await fetchLatestVersion();
       if (!latestVersion2) {
         this.emit("check:complete", false);
@@ -73384,18 +73404,18 @@ class UpdateChecker extends EventEmitter8 {
           detectedAt: new Date
         };
         if (!this.lastUpdateInfo || this.lastUpdateInfo.latestVersion !== latestVersion2) {
-          log27.info(`\uD83C\uDD95 Update available: v${currentVersion} \u2192 v${latestVersion2}`);
+          log28.info(`\uD83C\uDD95 Update available: v${currentVersion} \u2192 v${latestVersion2}`);
           this.lastUpdateInfo = updateInfo;
           this.emit("update", updateInfo);
         }
         this.emit("check:complete", true);
         return updateInfo;
       }
-      log27.debug(`Up to date (v${currentVersion})`);
+      log28.debug(`Up to date (v${currentVersion})`);
       this.emit("check:complete", false);
       return null;
     } catch (err) {
-      log27.warn(`Update check failed: ${err}`);
+      log28.warn(`Update check failed: ${err}`);
       this.emit("check:error", err);
       return null;
     } finally {
@@ -73419,7 +73439,7 @@ class UpdateChecker extends EventEmitter8 {
 }
 
 // src/auto-update/scheduler.ts
-import { EventEmitter as EventEmitter9 } from "events";
+import { EventEmitter as EventEmitter8 } from "events";
 
 // src/auto-update/types.ts
 var RESTART_EXIT_CODE = 42;
@@ -73465,9 +73485,9 @@ function isInScheduledWindow(window2) {
 }
 
 // src/auto-update/scheduler.ts
-var log28 = createLogger("scheduler");
+var log29 = createLogger("scheduler");
 
-class UpdateScheduler extends EventEmitter9 {
+class UpdateScheduler extends EventEmitter8 {
   config;
   getSessionActivity;
   getActiveThreadIds;
@@ -73489,7 +73509,7 @@ class UpdateScheduler extends EventEmitter9 {
   scheduleUpdate(updateInfo) {
     this.pendingUpdate = updateInfo;
     if (this.config.autoRestartMode === "immediate") {
-      log28.info("Immediate mode: triggering update now");
+      log29.info("Immediate mode: triggering update now");
       this.emit("ready", updateInfo);
       return;
     }
@@ -73502,19 +73522,19 @@ class UpdateScheduler extends EventEmitter9 {
     this.scheduledRestartAt = null;
     this.askApprovals.clear();
     this.askStartTime = null;
-    log28.debug("Update schedule cancelled");
+    log29.debug("Update schedule cancelled");
   }
   deferUpdate(minutes) {
     const deferUntil = new Date(Date.now() + minutes * 60 * 1000);
     this.scheduledRestartAt = null;
     this.idleStartTime = null;
     this.emit("deferred", deferUntil);
-    log28.info(`Update deferred until ${deferUntil.toLocaleTimeString()}`);
+    log29.info(`Update deferred until ${deferUntil.toLocaleTimeString()}`);
     return deferUntil;
   }
   recordAskResponse(threadId, approved) {
     this.askApprovals.set(threadId, approved);
-    log28.debug(`Thread ${threadId.substring(0, 8)} ${approved ? "approved" : "denied"} update`);
+    log29.debug(`Thread ${threadId.substring(0, 8)} ${approved ? "approved" : "denied"} update`);
     this.checkAskCondition();
   }
   getScheduledRestartAt() {
@@ -73535,7 +73555,7 @@ class UpdateScheduler extends EventEmitter9 {
       return;
     this.checkCondition();
     this.checkTimer = setInterval(() => this.checkCondition(), 1e4);
-    log28.debug(`Started checking for ${this.config.autoRestartMode} condition`);
+    log29.debug(`Started checking for ${this.config.autoRestartMode} condition`);
   }
   stopChecking() {
     if (this.checkTimer) {
@@ -73566,17 +73586,17 @@ class UpdateScheduler extends EventEmitter9 {
     if (activity.activeSessionCount === 0) {
       if (!this.idleStartTime) {
         this.idleStartTime = new Date;
-        log28.debug("No active sessions, starting idle timer");
+        log29.debug("No active sessions, starting idle timer");
       }
       const idleMs = Date.now() - this.idleStartTime.getTime();
       const requiredMs = this.config.idleTimeoutMinutes * 60 * 1000;
       if (idleMs >= requiredMs) {
-        log28.info(`Idle for ${this.config.idleTimeoutMinutes} minutes, triggering update`);
+        log29.info(`Idle for ${this.config.idleTimeoutMinutes} minutes, triggering update`);
         this.triggerCountdown();
       }
     } else {
       if (this.idleStartTime) {
-        log28.debug("Sessions became active, resetting idle timer");
+        log29.debug("Sessions became active, resetting idle timer");
         this.idleStartTime = null;
       }
     }
@@ -73587,7 +73607,7 @@ class UpdateScheduler extends EventEmitter9 {
       const quietMs = Date.now() - activity.lastActivityAt.getTime();
       const requiredMs = this.config.quietTimeoutMinutes * 60 * 1000;
       if (quietMs >= requiredMs && !activity.anySessionBusy) {
-        log28.info(`Sessions quiet for ${this.config.quietTimeoutMinutes} minutes, triggering update`);
+        log29.info(`Sessions quiet for ${this.config.quietTimeoutMinutes} minutes, triggering update`);
         this.triggerCountdown();
       }
     } else if (activity.activeSessionCount === 0) {
@@ -73597,7 +73617,7 @@ class UpdateScheduler extends EventEmitter9 {
       const idleMs = Date.now() - this.idleStartTime.getTime();
       const requiredMs = this.config.quietTimeoutMinutes * 60 * 1000;
       if (idleMs >= requiredMs) {
-        log28.info("No sessions and quiet timeout reached, triggering update");
+        log29.info("No sessions and quiet timeout reached, triggering update");
         this.triggerCountdown();
       }
     }
@@ -73608,13 +73628,13 @@ class UpdateScheduler extends EventEmitter9 {
     }
     const activity = this.getSessionActivity();
     if (activity.activeSessionCount === 0) {
-      log28.info("Within scheduled window and no active sessions, triggering update");
+      log29.info("Within scheduled window and no active sessions, triggering update");
       this.triggerCountdown();
     } else if (activity.lastActivityAt) {
       const quietMs = Date.now() - activity.lastActivityAt.getTime();
       const requiredMs = this.config.idleTimeoutMinutes * 60 * 1000;
       if (quietMs >= requiredMs && !activity.anySessionBusy) {
-        log28.info("Within scheduled window and sessions quiet, triggering update");
+        log29.info("Within scheduled window and sessions quiet, triggering update");
         this.triggerCountdown();
       }
     }
@@ -73622,14 +73642,14 @@ class UpdateScheduler extends EventEmitter9 {
   checkAskCondition() {
     const threadIds = this.getActiveThreadIds();
     if (threadIds.length === 0) {
-      log28.info("No active threads, proceeding with update");
+      log29.info("No active threads, proceeding with update");
       this.triggerCountdown();
       return;
     }
     if (!this.askStartTime && this.pendingUpdate) {
       this.askStartTime = new Date;
       this.postAskMessage(threadIds, this.pendingUpdate.latestVersion).catch((err) => {
-        log28.warn(`Failed to post ask message: ${err}`);
+        log29.warn(`Failed to post ask message: ${err}`);
       });
       return;
     }
@@ -73642,12 +73662,12 @@ class UpdateScheduler extends EventEmitter9 {
         denials++;
     }
     if (approvals > threadIds.length / 2) {
-      log28.info(`Majority approved (${approvals}/${threadIds.length}), triggering update`);
+      log29.info(`Majority approved (${approvals}/${threadIds.length}), triggering update`);
       this.triggerCountdown();
       return;
     }
     if (denials > threadIds.length / 2) {
-      log28.info(`Majority denied (${denials}/${threadIds.length}), deferring update`);
+      log29.info(`Majority denied (${denials}/${threadIds.length}), deferring update`);
       this.deferUpdate(60);
       return;
     }
@@ -73655,7 +73675,7 @@ class UpdateScheduler extends EventEmitter9 {
       const elapsedMs = Date.now() - this.askStartTime.getTime();
       const timeoutMs = this.config.askTimeoutMinutes * 60 * 1000;
       if (elapsedMs >= timeoutMs) {
-        log28.info(`Ask timeout reached (${this.config.askTimeoutMinutes} min), triggering update`);
+        log29.info(`Ask timeout reached (${this.config.askTimeoutMinutes} min), triggering update`);
         this.triggerCountdown();
       }
     }
@@ -73675,7 +73695,7 @@ class UpdateScheduler extends EventEmitter9 {
         this.emit("ready", this.pendingUpdate);
       }
     }, 1000);
-    log28.info("Update countdown started (60 seconds)");
+    log29.info("Update countdown started (60 seconds)");
   }
   stopCountdown() {
     if (this.countdownTimer) {
@@ -73690,7 +73710,7 @@ import { spawn as spawn6 } from "child_process";
 import { existsSync as existsSync12, readFileSync as readFileSync9, writeFileSync as writeFileSync5, mkdirSync as mkdirSync4 } from "fs";
 import { dirname as dirname8, resolve as resolve6 } from "path";
 import { homedir as homedir5 } from "os";
-var log29 = createLogger("installer");
+var log30 = createLogger("installer");
 var STATE_PATH = resolve6(homedir5(), ".config", "claude-threads", UPDATE_STATE_FILENAME);
 var PACKAGE_NAME2 = "claude-threads";
 function loadUpdateState() {
@@ -73700,7 +73720,7 @@ function loadUpdateState() {
       return JSON.parse(content);
     }
   } catch (err) {
-    log29.warn(`Failed to load update state: ${err}`);
+    log30.warn(`Failed to load update state: ${err}`);
   }
   return {};
 }
@@ -73711,9 +73731,9 @@ function saveUpdateState(state) {
       mkdirSync4(dir, { recursive: true });
     }
     writeFileSync5(STATE_PATH, JSON.stringify(state, null, 2), "utf-8");
-    log29.debug("Update state saved");
+    log30.debug("Update state saved");
   } catch (err) {
-    log29.warn(`Failed to save update state: ${err}`);
+    log30.warn(`Failed to save update state: ${err}`);
   }
 }
 function clearUpdateState() {
@@ -73722,7 +73742,7 @@ function clearUpdateState() {
       writeFileSync5(STATE_PATH, "{}", "utf-8");
     }
   } catch (err) {
-    log29.warn(`Failed to clear update state: ${err}`);
+    log30.warn(`Failed to clear update state: ${err}`);
   }
 }
 function checkJustUpdated() {
@@ -73754,7 +73774,7 @@ function clearRuntimeSettings() {
   }
 }
 async function installVersion(version) {
-  log29.info(`\uD83D\uDCE6 Installing ${PACKAGE_NAME2}@${version}...`);
+  log30.info(`\uD83D\uDCE6 Installing ${PACKAGE_NAME2}@${version}...`);
   saveUpdateState({
     previousVersion: VERSION,
     targetVersion: version,
@@ -73765,7 +73785,7 @@ async function installVersion(version) {
     const useBun = process.platform !== "win32";
     const cmd = useBun ? "bun" : "npm.cmd";
     const args = useBun ? ["install", "-g", `${PACKAGE_NAME2}@${version}`] : ["install", "-g", `${PACKAGE_NAME2}@${version}`];
-    log29.debug(`Using ${useBun ? "bun" : "npm"} for installation`);
+    log30.debug(`Using ${useBun ? "bun" : "npm"} for installation`);
     const child = spawn6(cmd, args, {
       stdio: ["ignore", "pipe", "pipe"],
       env: {
@@ -73783,7 +73803,7 @@ async function installVersion(version) {
     });
     child.on("close", (code) => {
       if (code === 0) {
-        log29.info(`\u2705 Successfully installed ${PACKAGE_NAME2}@${version}`);
+        log30.info(`\u2705 Successfully installed ${PACKAGE_NAME2}@${version}`);
         saveUpdateState({
           previousVersion: VERSION,
           targetVersion: version,
@@ -73793,20 +73813,20 @@ async function installVersion(version) {
         resolve7({ success: true });
       } else {
         const errorMsg = stderr || stdout || `Exit code: ${code}`;
-        log29.error(`\u274C Installation failed: ${errorMsg}`);
+        log30.error(`\u274C Installation failed: ${errorMsg}`);
         clearUpdateState();
         resolve7({ success: false, error: errorMsg });
       }
     });
     child.on("error", (err) => {
-      log29.error(`\u274C Failed to spawn npm: ${err}`);
+      log30.error(`\u274C Failed to spawn npm: ${err}`);
       clearUpdateState();
       resolve7({ success: false, error: err.message });
     });
     setTimeout(() => {
       if (child.exitCode === null) {
         child.kill();
-        log29.error("\u274C Installation timed out");
+        log30.error("\u274C Installation timed out");
         clearUpdateState();
         resolve7({ success: false, error: "Installation timed out" });
       }
@@ -73847,9 +73867,9 @@ class UpdateInstaller {
 }
 
 // src/auto-update/manager.ts
-var log30 = createLogger("updater");
+var log31 = createLogger("updater");
 
-class AutoUpdateManager extends EventEmitter10 {
+class AutoUpdateManager extends EventEmitter9 {
   config;
   callbacks;
   checker;
@@ -73870,23 +73890,23 @@ class AutoUpdateManager extends EventEmitter10 {
   }
   start() {
     if (!this.config.enabled) {
-      log30.info("Auto-update is disabled");
+      log31.info("Auto-update is disabled");
       return;
     }
     const updateResult = this.installer.checkJustUpdated();
     if (updateResult) {
-      log30.info(`\uD83C\uDF89 Updated from v${updateResult.previousVersion} to v${updateResult.currentVersion}`);
+      log31.info(`\uD83C\uDF89 Updated from v${updateResult.previousVersion} to v${updateResult.currentVersion}`);
       this.callbacks.broadcastUpdate((fmt) => `\uD83C\uDF89 ${fmt.formatBold("Bot updated")} from v${updateResult.previousVersion} to v${updateResult.currentVersion}`).catch((err) => {
-        log30.warn(`Failed to broadcast update notification: ${err}`);
+        log31.warn(`Failed to broadcast update notification: ${err}`);
       });
     }
     this.checker.start();
-    log30.info(`\uD83D\uDD04 Auto-update manager started (mode: ${this.config.autoRestartMode})`);
+    log31.info(`\uD83D\uDD04 Auto-update manager started (mode: ${this.config.autoRestartMode})`);
   }
   stop() {
     this.checker.stop();
     this.scheduler.stop();
-    log30.debug("Auto-update manager stopped");
+    log31.debug("Auto-update manager stopped");
   }
   getState() {
     return { ...this.state };
@@ -73900,10 +73920,10 @@ class AutoUpdateManager extends EventEmitter10 {
   async forceUpdate() {
     const updateInfo = this.state.updateInfo || await this.checker.check();
     if (!updateInfo) {
-      log30.info("No update available");
+      log31.info("No update available");
       return;
     }
-    log30.info("Forcing immediate update");
+    log31.info("Forcing immediate update");
     await this.performUpdate(updateInfo);
   }
   deferUpdate(minutes = 60) {
@@ -73958,7 +73978,7 @@ class AutoUpdateManager extends EventEmitter10 {
       await this.callbacks.broadcastUpdate((fmt) => `\u2705 ${fmt.formatBold("Update installed")} - restarting now. ${fmt.formatItalic("Sessions will resume automatically.")}`).catch(() => {});
       await new Promise((resolve7) => setTimeout(resolve7, 1000));
       await this.callbacks.prepareForRestart();
-      log30.info(`\uD83D\uDD04 Restarting for update to v${updateInfo.latestVersion}`);
+      log31.info(`\uD83D\uDD04 Restarting for update to v${updateInfo.latestVersion}`);
       process.stdout.write("\x1B[2J\x1B[H");
       process.stdout.write("\x1B[?25h");
       process.exit(RESTART_EXIT_CODE);