claude-threads 0.19.2 → 0.20.0

package/CHANGELOG.md

@@ -7,6 +7,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.20.0] - 2026-01-01
+
+### Added
+- **Sticky message improvements** - Enhanced the channel sticky message with active sessions
+  - Shows display name in bold (e.g., **Anne**) instead of username
+  - Added session description below the title (generated by Claude)
+  - Added install hint: `npm i -g claude-threads` in footer
+  - Periodic refresh every 60 seconds to keep relative times current
+  - Auto-cleanup of old sticky messages from failed runs at startup
+
+### Fixed
+- **Sticky message updates on session end** - Message now updates when sessions are:
+  - Canceled via `!stop` or ❌ reaction
+  - Paused/interrupted via `!escape` or ⏸️ reaction
+  - Killed due to timeout
+  - Failed to start or resume
+- **Race condition in sticky updates** - Added mutex to prevent duplicate sticky posts when multiple updates happen concurrently
+
 ## [0.19.2] - 2026-01-01
 
 ### Added

package/dist/index.js

@@ -13289,9 +13289,11 @@ class MattermostClient extends EventEmitter {
     this.allowedUsers = platformConfig.allowedUsers;
   }
   normalizePlatformUser(mattermostUser) {
+    const displayName = mattermostUser.first_name || mattermostUser.nickname || mattermostUser.username;
     return {
       id: mattermostUser.id,
       username: mattermostUser.username,
+      displayName,
       email: mattermostUser.email
     };
   }
@@ -13425,6 +13427,16 @@ class MattermostClient extends EventEmitter {
   async deletePost(postId) {
     await this.api("DELETE", `/posts/${postId}`);
   }
+  async pinPost(postId) {
+    await this.api("POST", `/posts/${postId}/pin`);
+  }
+  async unpinPost(postId) {
+    await this.api("POST", `/posts/${postId}/unpin`);
+  }
+  async getPinnedPosts() {
+    const response = await this.api("GET", `/channels/${this.channelId}/pinned`);
+    return response.order || [];
+  }
   async getThreadHistory(threadId, options) {
     try {
       const response = await this.api("GET", `/posts/${threadId}/thread`);
@@ -13513,7 +13525,11 @@ class MattermostClient extends EventEmitter {
         if (post.channel_id !== this.channelId)
           return;
         this.getUser(post.user_id).then((user) => {
-          this.emit("message", this.normalizePlatformPost(post), user);
+          const normalizedPost = this.normalizePlatformPost(post);
+          this.emit("message", normalizedPost, user);
+          if (!post.root_id) {
+            this.emit("channel_post", normalizedPost, user);
+          }
         });
       } catch (err) {
         wsLogger.debug(`Failed to parse post: ${err}`);
@@ -13716,11 +13732,37 @@ class SessionStore {
     return staleIds;
   }
   clear() {
-    this.writeAtomic({ version: STORE_VERSION, sessions: {} });
+    const data = this.loadRaw();
+    this.writeAtomic({ version: STORE_VERSION, sessions: {}, stickyPostIds: data.stickyPostIds });
     if (this.debug) {
       console.log("  [persist] Cleared all sessions");
     }
   }
+  saveStickyPostId(platformId, postId) {
+    const data = this.loadRaw();
+    if (!data.stickyPostIds) {
+      data.stickyPostIds = {};
+    }
+    data.stickyPostIds[platformId] = postId;
+    this.writeAtomic(data);
+    if (this.debug) {
+      console.log(`  [persist] Saved sticky post ID for ${platformId}: ${postId.substring(0, 8)}...`);
+    }
+  }
+  getStickyPostIds() {
+    const data = this.loadRaw();
+    return new Map(Object.entries(data.stickyPostIds || {}));
+  }
+  removeStickyPostId(platformId) {
+    const data = this.loadRaw();
+    if (data.stickyPostIds && data.stickyPostIds[platformId]) {
+      delete data.stickyPostIds[platformId];
+      this.writeAtomic(data);
+      if (this.debug) {
+        console.log(`  [persist] Removed sticky post ID for ${platformId}`);
+      }
+    }
+  }
   findByThread(platformId, threadId) {
     const sessionId = `${platformId}:${threadId}`;
     const data = this.loadRaw();
@@ -14822,7 +14864,7 @@ function handleEvent(session, event, ctx) {
           handleExitPlanMode(session, block.id, ctx);
           hasSpecialTool = true;
         } else if (block.name === "TodoWrite") {
-          handleTodoWrite(session, block.input);
+          handleTodoWrite(session, block.input, ctx);
         } else if (block.name === "Task") {
           handleTaskStart(session, block.id, block.input, ctx);
         } else if (block.name === "AskUserQuestion") {
@@ -14865,7 +14907,27 @@ function formatEvent(session, e, ctx) {
       const parts = [];
       for (const block of msg?.content || []) {
         if (block.type === "text" && block.text) {
-          const text = block.text.replace(/<thinking>[\s\S]*?<\/thinking>/g, "").trim();
+          let text = block.text.replace(/<thinking>[\s\S]*?<\/thinking>/g, "").trim();
+          const titleMatch = text.match(/\[SESSION_TITLE:\s*([^\]]+)\]/);
+          if (titleMatch) {
+            const newTitle = titleMatch[1].trim();
+            if (newTitle !== session.sessionTitle) {
+              session.sessionTitle = newTitle;
+              ctx.persistSession(session);
+              ctx.updateStickyMessage().catch(() => {});
+            }
+            text = text.replace(/\[SESSION_TITLE:\s*[^\]]+\]\s*/g, "").trim();
+          }
+          const descMatch = text.match(/\[SESSION_DESCRIPTION:\s*([^\]]+)\]/);
+          if (descMatch) {
+            const newDesc = descMatch[1].trim();
+            if (newDesc !== session.sessionDescription) {
+              session.sessionDescription = newDesc;
+              ctx.persistSession(session);
+              ctx.updateStickyMessage().catch(() => {});
+            }
+            text = text.replace(/\[SESSION_DESCRIPTION:\s*[^\]]+\]\s*/g, "").trim();
+          }
           if (text)
             parts.push(text);
         } else if (block.type === "tool_use" && block.name) {
@@ -14965,7 +15027,7 @@ async function handleExitPlanMode(session, toolUseId, ctx) {
   session.pendingApproval = { postId: post.id, type: "plan", toolUseId };
   ctx.stopTyping(session);
 }
-async function handleTodoWrite(session, input) {
+async function handleTodoWrite(session, input, ctx) {
   const todos = input.todos;
   if (!todos || todos.length === 0) {
     session.tasksCompleted = true;
@@ -15046,6 +15108,7 @@ async function handleTodoWrite(session, input) {
       const post = await session.platform.createInteractivePost(displayMessage, [TASK_TOGGLE_EMOJIS[0]], session.threadId);
       session.tasksPostId = post.id;
     }
+    ctx.updateStickyMessage().catch(() => {});
   } catch (err) {
     console.error("  \u26A0\uFE0F Failed to update tasks:", err);
   }
@@ -15326,6 +15389,9 @@ class ClaudeCli extends EventEmitter2 {
     if (this.options.chrome) {
       args.push("--chrome");
     }
+    if (this.options.appendSystemPrompt) {
+      args.push("--append-system-prompt", this.options.appendSystemPrompt);
+    }
     if (this.debug) {
       console.log(`  [claude] Starting: ${claudePath} ${args.slice(0, 5).join(" ")}...`);
     }
@@ -18917,7 +18983,7 @@ async function cancelSession(session, username, ctx) {
   const shortId = session.threadId.substring(0, 8);
   console.log(`  \uD83D\uDED1 Session (${shortId}\u2026) cancelled by @${username}`);
   await session.platform.createPost(`\uD83D\uDED1 **Session cancelled** by @${username}`, session.threadId);
-  ctx.killSession(session.threadId);
+  await ctx.killSession(session.threadId);
 }
 async function interruptSession(session, username) {
   if (!session.claude.isRunning()) {
@@ -19336,7 +19402,34 @@ function findPersistedByThreadId(persisted, threadId) {
   }
   return;
 }
-async function startSession(options, username, replyToPostId, platformId, ctx) {
+var CHAT_PLATFORM_PROMPT = `
+You are running inside a chat platform (like Mattermost or Slack). Users interact with you through chat messages in a thread.
+
+SESSION METADATA: At the START of your first response, include metadata about this session:
+
+[SESSION_TITLE: <short title>]
+[SESSION_DESCRIPTION: <brief description>]
+
+Title requirements:
+- 3-7 words maximum
+- Descriptive of the main task/topic
+- Written in imperative form (e.g., "Fix login bug", "Add dark mode")
+- Do NOT include quotes
+
+Description requirements:
+- 1-2 sentences explaining what you're helping with
+- Summarize the current work or goal
+- Keep it under 100 characters
+
+You can update both later if the session focus changes significantly.
+
+Example: If the user asks "help me debug why the tests are failing", respond with:
+[SESSION_TITLE: Debug failing tests]
+[SESSION_DESCRIPTION: Investigating test failures and fixing broken assertions in the test suite.]
+
+Then continue with your normal response.
+`.trim();
+async function startSession(options, username, displayName, replyToPostId, platformId, ctx) {
   const threadId = replyToPostId || "";
   const existingSessionId = ctx.getSessionId(platformId, threadId);
   const existingSession = ctx.sessions.get(existingSessionId);
@@ -19372,7 +19465,8 @@ async function startSession(options, username, replyToPostId, platformId, ctx) {
     sessionId: claudeSessionId,
     resume: false,
     chrome: ctx.chromeEnabled,
-    platformConfig: platformMcpConfig
+    platformConfig: platformMcpConfig,
+    appendSystemPrompt: CHAT_PLATFORM_PROMPT
   };
   const claude = new ClaudeCli(cliOptions);
   const session = {
@@ -19382,6 +19476,7 @@ async function startSession(options, username, replyToPostId, platformId, ctx) {
     platform,
     claudeSessionId,
     startedBy: username,
+    startedByDisplayName: displayName,
     startedAt: new Date,
     lastActivityAt: new Date,
     sessionNumber: ctx.sessions.size + 1,
@@ -19408,7 +19503,8 @@ async function startSession(options, username, replyToPostId, platformId, ctx) {
     isResumed: false,
     wasInterrupted: false,
     inProgressTaskStart: null,
-    activeToolStarts: new Map
+    activeToolStarts: new Map,
+    firstPrompt: options.prompt
   };
   ctx.sessions.set(sessionId, session);
   ctx.registerPost(post.id, actualThreadId);
@@ -19416,6 +19512,7 @@ async function startSession(options, username, replyToPostId, platformId, ctx) {
   console.log(`  \u25B6 Session #${ctx.sessions.size} started (${shortId}\u2026) by @${username}`);
   keepAlive.sessionStarted();
   await ctx.updateSessionHeader(session);
+  await ctx.updateStickyMessage();
   ctx.startTyping(session);
   claude.on("event", (e) => ctx.handleEvent(sessionId, e));
   claude.on("exit", (code) => ctx.handleExit(sessionId, code));
@@ -19426,9 +19523,9 @@ async function startSession(options, username, replyToPostId, platformId, ctx) {
     ctx.stopTyping(session);
     await session.platform.createPost(`\u274C ${err}`, actualThreadId);
     ctx.sessions.delete(session.sessionId);
+    await ctx.updateStickyMessage();
     return;
   }
-  session.firstPrompt = options.prompt;
   const shouldPrompt = await ctx.shouldPromptForWorktree(session);
   if (shouldPrompt) {
     session.queuedPrompt = options.prompt;
@@ -19480,6 +19577,7 @@ Please start a new session.`, state.threadId);
   const sessionId = ctx.getSessionId(platformId, state.threadId);
   const skipPerms = ctx.skipPermissions && !state.forceInteractivePermissions;
   const platformMcpConfig = platform.getMcpConfig();
+  const needsTitlePrompt = !state.sessionTitle;
   const cliOptions = {
     workingDir: state.workingDir,
     threadId: state.threadId,
@@ -19487,7 +19585,8 @@ Please start a new session.`, state.threadId);
     sessionId: state.claudeSessionId,
     resume: true,
     chrome: ctx.chromeEnabled,
-    platformConfig: platformMcpConfig
+    platformConfig: platformMcpConfig,
+    appendSystemPrompt: needsTitlePrompt ? CHAT_PLATFORM_PROMPT : undefined
   };
   const claude = new ClaudeCli(cliOptions);
   const session = {
@@ -19497,6 +19596,7 @@ Please start a new session.`, state.threadId);
     platform,
     claudeSessionId: state.claudeSessionId,
     startedBy: state.startedBy,
+    startedByDisplayName: state.startedByDisplayName,
     startedAt: new Date(state.startedAt),
     lastActivityAt: new Date,
     sessionNumber: state.sessionNumber,
@@ -19529,7 +19629,9 @@ Please start a new session.`, state.threadId);
     worktreePromptDisabled: state.worktreePromptDisabled,
     queuedPrompt: state.queuedPrompt,
     firstPrompt: state.firstPrompt,
-    needsContextPromptOnNextMessage: state.needsContextPromptOnNextMessage
+    needsContextPromptOnNextMessage: state.needsContextPromptOnNextMessage,
+    sessionTitle: state.sessionTitle,
+    sessionDescription: state.sessionDescription
   };
   ctx.sessions.set(sessionId, session);
   if (state.sessionStartPostId) {
@@ -19544,6 +19646,7 @@ Please start a new session.`, state.threadId);
     await session.platform.createPost(`\uD83D\uDD04 **Session resumed** after bot restart (v${VERSION})
 *Reconnected to Claude session. You can continue where you left off.*`, state.threadId);
     await ctx.updateSessionHeader(session);
+    await ctx.updateStickyMessage();
     ctx.persistSession(session);
   } catch (err) {
     console.error(`  \u274C Failed to resume session ${shortId}...:`, err);
@@ -19553,6 +19656,7 @@ Please start a new session.`, state.threadId);
       await session.platform.createPost(`\u26A0\uFE0F **Could not resume previous session.** Starting fresh.
 *Your previous conversation context is preserved, but Claude needs to re-read it.*`, state.threadId);
     } catch {}
+    await ctx.updateStickyMessage();
   }
 }
 async function sendFollowUp(session, message, files, ctx) {
@@ -19636,6 +19740,7 @@ async function handleExit(sessionId, code, ctx) {
       await session.platform.createPost(`\u2139\uFE0F Session paused. Send a new message to continue.`, session.threadId);
     } catch {}
     console.log(`  \u23F8\uFE0F Session paused (${shortId}\u2026) \u2014 ${ctx.sessions.size} active`);
+    await ctx.updateStickyMessage();
     return;
   }
   if (session.isResumed && code !== 0) {
@@ -19650,6 +19755,7 @@ async function handleExit(sessionId, code, ctx) {
     try {
       await session.platform.createPost(`\u26A0\uFE0F **Session resume failed** (exit code ${code}). The session data is preserved - try restarting the bot.`, session.threadId);
     } catch {}
+    await ctx.updateStickyMessage();
     return;
   }
   console.log(`  [exit] Session ${shortId}... normal exit, cleaning up`);
@@ -19675,8 +19781,9 @@ async function handleExit(sessionId, code, ctx) {
     console.log(`  [exit] Session ${shortId}... non-zero exit, preserving for potential retry`);
   }
   console.log(`  \u25A0 Session ended (${shortId}\u2026) \u2014 ${ctx.sessions.size} active`);
+  await ctx.updateStickyMessage();
 }
-function killSession(session, unpersist, ctx) {
+async function killSession(session, unpersist, ctx) {
   const shortId = session.threadId.substring(0, 8);
   if (!unpersist) {
     session.isRestarting = true;
@@ -19694,6 +19801,7 @@ function killSession(session, unpersist, ctx) {
     ctx.unpersistSession(session.threadId);
   }
   console.log(`  \u2716 Session killed (${shortId}\u2026) \u2014 ${ctx.sessions.size} active`);
+  await ctx.updateStickyMessage();
 }
 function killAllSessions(ctx) {
   for (const session of ctx.sessions.values()) {
@@ -19719,7 +19827,7 @@ async function cleanupIdleSessions(timeoutMs, warningMs, ctx) {
         ctx.persistSession(session);
         ctx.registerPost(timeoutPost.id, session.threadId);
       } catch {}
-      killSession(session, false, ctx);
+      await killSession(session, false, ctx);
       continue;
     }
     const warningThresholdMs = timeoutMs - warningMs;
@@ -20250,6 +20358,239 @@ function clearContextPromptTimeout(pending) {
   }
 }
 
+// src/session/sticky-message.ts
+var stickyPostIds = new Map;
+var needsBump = new Map;
+var updateLocks = new Map;
+var sessionStore = null;
+function initialize(store) {
+  sessionStore = store;
+  const persistedIds = store.getStickyPostIds();
+  for (const [platformId, postId] of persistedIds) {
+    stickyPostIds.set(platformId, postId);
+  }
+  if (persistedIds.size > 0) {
+    console.log(`  \uD83D\uDCCC Restored ${persistedIds.size} sticky post ID(s) from persistence`);
+  }
+}
+function formatRelativeTime(date) {
+  const now = Date.now();
+  const diff = now - date.getTime();
+  const minutes = Math.floor(diff / 60000);
+  const hours = Math.floor(minutes / 60);
+  if (minutes < 1)
+    return "just now";
+  if (minutes < 60)
+    return `${minutes}m ago`;
+  if (hours < 24)
+    return `${hours}h ago`;
+  return `${Math.floor(hours / 24)}d ago`;
+}
+function getTaskProgress(session) {
+  if (!session.lastTasksContent)
+    return null;
+  const match = session.lastTasksContent.match(/\((\d+)\/(\d+)/);
+  if (match) {
+    return `${match[1]}/${match[2]}`;
+  }
+  return null;
+}
+function getSessionTopic(session) {
+  if (session.sessionTitle) {
+    return session.sessionTitle;
+  }
+  return formatTopicFromPrompt(session.firstPrompt);
+}
+function formatTopicFromPrompt(prompt) {
+  if (!prompt)
+    return "_No topic_";
+  let cleaned = prompt.replace(/^@[\w-]+\s*/g, "").trim();
+  if (cleaned.startsWith("!")) {
+    return "_No topic_";
+  }
+  cleaned = cleaned.replace(/\s+/g, " ");
+  if (cleaned.length > 50) {
+    cleaned = cleaned.substring(0, 47) + "\u2026";
+  }
+  return cleaned || "_No topic_";
+}
+function buildStickyMessage(sessions, platformId) {
+  const platformSessions = [...sessions.values()].filter((s) => s.platformId === platformId);
+  if (platformSessions.length === 0) {
+    return [
+      "---",
+      "**Active Claude Threads**",
+      "",
+      "_No active sessions_",
+      "",
+      "_Mention me to start a session_ \xB7 `npm i -g claude-threads`"
+    ].join(`
+`);
+  }
+  platformSessions.sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime());
+  const count = platformSessions.length;
+  const lines = [
+    "---",
+    `**Active Claude Threads** (${count})`,
+    ""
+  ];
+  for (const session of platformSessions) {
+    const topic = getSessionTopic(session);
+    const threadLink = `[${topic}](/_redirect/pl/${session.threadId})`;
+    const displayName = session.startedByDisplayName || session.startedBy;
+    const time = formatRelativeTime(session.startedAt);
+    const taskProgress = getTaskProgress(session);
+    const progressStr = taskProgress ? ` \xB7 ${taskProgress}` : "";
+    lines.push(`\u25B8 ${threadLink} \xB7 **${displayName}**${progressStr} \xB7 ${time}`);
+    if (session.sessionDescription) {
+      lines.push(`   _${session.sessionDescription}_`);
+    }
+  }
+  lines.push("");
+  lines.push("_Mention me to start a session_ \xB7 `npm i -g claude-threads`");
+  return lines.join(`
+`);
+}
+var DEBUG = process.env.DEBUG === "1";
+async function updateStickyMessage(platform, sessions) {
+  const platformId = platform.platformId;
+  const pendingUpdate = updateLocks.get(platformId);
+  if (pendingUpdate) {
+    await pendingUpdate;
+  }
+  let releaseLock;
+  const lock = new Promise((resolve6) => {
+    releaseLock = resolve6;
+  });
+  updateLocks.set(platformId, lock);
+  try {
+    await updateStickyMessageImpl(platform, sessions);
+  } finally {
+    releaseLock();
+    updateLocks.delete(platformId);
+  }
+}
+async function updateStickyMessageImpl(platform, sessions) {
+  if (DEBUG) {
+    const platformSessions = [...sessions.values()].filter((s) => s.platformId === platform.platformId);
+    console.log(`[sticky] updateStickyMessage called for ${platform.platformId}, ${platformSessions.length} sessions`);
+    for (const s of platformSessions) {
+      console.log(`[sticky]   - ${s.sessionId}: title="${s.sessionTitle}" firstPrompt="${s.firstPrompt?.substring(0, 30)}..."`);
+    }
+  }
+  const content = buildStickyMessage(sessions, platform.platformId);
+  const existingPostId = stickyPostIds.get(platform.platformId);
+  const shouldBump = needsBump.get(platform.platformId) ?? false;
+  if (DEBUG) {
+    console.log(`[sticky] existingPostId: ${existingPostId || "(none)"}, needsBump: ${shouldBump}`);
+    console.log(`[sticky] content preview: ${content.substring(0, 100).replace(/\n/g, "\\n")}...`);
+  }
+  try {
+    if (existingPostId && !shouldBump) {
+      if (DEBUG)
+        console.log(`[sticky] Updating existing post in place...`);
+      try {
+        await platform.updatePost(existingPostId, content);
+        try {
+          await platform.pinPost(existingPostId);
+          if (DEBUG)
+            console.log(`[sticky] Re-pinned post`);
+        } catch (pinErr) {
+          if (DEBUG)
+            console.log(`[sticky] Re-pin failed (might already be pinned):`, pinErr);
+        }
+        if (DEBUG)
+          console.log(`[sticky] Updated successfully`);
+        return;
+      } catch (err) {
+        if (DEBUG)
+          console.log(`[sticky] Update failed, will create new:`, err);
+      }
+    }
+    needsBump.set(platform.platformId, false);
+    if (existingPostId) {
+      if (DEBUG)
+        console.log(`[sticky] Unpinning and deleting existing post ${existingPostId.substring(0, 8)}...`);
+      try {
+        await platform.unpinPost(existingPostId);
+        if (DEBUG)
+          console.log(`[sticky] Unpinned successfully`);
+      } catch (err) {
+        if (DEBUG)
+          console.log(`[sticky] Unpin failed (probably already unpinned):`, err);
+      }
+      try {
+        await platform.deletePost(existingPostId);
+        if (DEBUG)
+          console.log(`[sticky] Deleted successfully`);
+      } catch (err) {
+        if (DEBUG)
+          console.log(`[sticky] Delete failed (probably already deleted):`, err);
+      }
+      stickyPostIds.delete(platform.platformId);
+    }
+    if (DEBUG)
+      console.log(`[sticky] Creating new post...`);
+    const post = await platform.createPost(content);
+    stickyPostIds.set(platform.platformId, post.id);
+    try {
+      await platform.pinPost(post.id);
+      if (DEBUG)
+        console.log(`[sticky] Pinned post successfully`);
+    } catch (err) {
+      if (DEBUG)
+        console.log(`[sticky] Failed to pin post:`, err);
+    }
+    if (sessionStore) {
+      sessionStore.saveStickyPostId(platform.platformId, post.id);
+    }
+    console.log(`  \uD83D\uDCCC Created sticky message for ${platform.platformId}: ${post.id.substring(0, 8)}...`);
+  } catch (err) {
+    console.error(`  \u26A0\uFE0F Failed to update sticky message for ${platform.platformId}:`, err);
+  }
+}
+async function updateAllStickyMessages(platforms, sessions) {
+  const updates = [...platforms.values()].map((platform) => updateStickyMessage(platform, sessions));
+  await Promise.all(updates);
+}
+function markNeedsBump(platformId) {
+  needsBump.set(platformId, true);
+}
+async function cleanupOldStickyMessages(platform, botUserId) {
+  const currentStickyId = stickyPostIds.get(platform.platformId);
+  try {
+    const pinnedPostIds = await platform.getPinnedPosts();
+    if (DEBUG)
+      console.log(`[sticky] Found ${pinnedPostIds.length} pinned posts, current sticky: ${currentStickyId?.substring(0, 8) || "(none)"}`);
+    for (const postId of pinnedPostIds) {
+      if (postId === currentStickyId)
+        continue;
+      try {
+        const post = await platform.getPost(postId);
+        if (!post)
+          continue;
+        if (post.userId === botUserId) {
+          if (DEBUG)
+            console.log(`[sticky] Cleaning up old sticky: ${postId.substring(0, 8)}...`);
+          try {
+            await platform.unpinPost(postId);
+            await platform.deletePost(postId);
+            console.log(`  \uD83E\uDDF9 Cleaned up old sticky message: ${postId.substring(0, 8)}...`);
+          } catch (err) {
+            if (DEBUG)
+              console.log(`[sticky] Failed to cleanup ${postId}:`, err);
+          }
+        }
+      } catch (err) {
+        if (DEBUG)
+          console.log(`[sticky] Could not check post ${postId}:`, err);
+      }
+    }
+  } catch (err) {
+    console.error(`  \u26A0\uFE0F Failed to cleanup old sticky messages:`, err);
+  }
+}
+
 // src/session/types.ts
 var MAX_SESSIONS = parseInt(process.env.MAX_SESSIONS || "5", 10);
 var SESSION_TIMEOUT_MS = parseInt(process.env.SESSION_TIMEOUT_MS || "1800000", 10);
@@ -20275,6 +20616,9 @@ class SessionManager {
     this.worktreeMode = worktreeMode;
     this.cleanupTimer = setInterval(() => {
       cleanupIdleSessions(SESSION_TIMEOUT_MS, SESSION_WARNING_MS, this.getLifecycleContext()).catch((err) => console.error("  [cleanup] Error during idle session cleanup:", err));
+      if (this.sessions.size > 0) {
+        this.updateStickyMessage().catch((err) => console.error("  [sticky] Error during periodic refresh:", err));
+      }
     }, 60000);
   }
   addPlatform(platformId, client) {
@@ -20285,6 +20629,10 @@ class SessionManager {
         this.handleReaction(platformId, reaction.postId, reaction.emojiName, user.username);
       }
     });
+    client.on("channel_post", () => {
+      markNeedsBump(platformId);
+      this.updateStickyMessage();
+    });
     console.log(`  \uD83D\uDCE1 Platform "${platformId}" registered`);
   }
   removePlatform(platformId) {
@@ -20317,7 +20665,8 @@ class SessionManager {
       postWorktreePrompt: (s, r) => this.postWorktreePrompt(s, r),
       buildMessageContent: (t, p, f) => this.buildMessageContent(t, p, f),
       offerContextPrompt: (s, q, e) => this.offerContextPrompt(s, q, e),
-      bumpTasksToBottom: (s) => this.bumpTasksToBottom(s)
+      bumpTasksToBottom: (s) => this.bumpTasksToBottom(s),
+      updateStickyMessage: () => this.updateStickyMessage()
     };
   }
   getEventContext() {
@@ -20328,7 +20677,9 @@ class SessionManager {
       startTyping: (s) => this.startTyping(s),
       stopTyping: (s) => this.stopTyping(s),
       appendContent: (s, t) => this.appendContent(s, t),
-      bumpTasksToBottom: (s) => this.bumpTasksToBottom(s)
+      bumpTasksToBottom: (s) => this.bumpTasksToBottom(s),
+      updateStickyMessage: () => this.updateStickyMessage(),
+      persistSession: (s) => this.persistSession(s)
     };
   }
   getReactionContext() {
@@ -20584,6 +20935,7 @@ class SessionManager {
       threadId: session.threadId,
       claudeSessionId: session.claudeSessionId,
       startedBy: session.startedBy,
+      startedByDisplayName: session.startedByDisplayName,
       startedAt: session.startedAt.toISOString(),
       lastActivityAt: session.lastActivityAt.toISOString(),
       sessionNumber: session.sessionNumber,
@@ -20603,7 +20955,9 @@ class SessionManager {
       firstPrompt: session.firstPrompt,
       pendingContextPrompt: persistedContextPrompt,
       needsContextPromptOnNextMessage: session.needsContextPromptOnNextMessage,
-      timeoutPostId: session.timeoutPostId
+      timeoutPostId: session.timeoutPostId,
+      sessionTitle: session.sessionTitle,
+      sessionDescription: session.sessionDescription
     };
     this.sessionStore.save(session.sessionId, state);
   }
@@ -20613,21 +20967,35 @@ class SessionManager {
   async updateSessionHeader(session) {
     await updateSessionHeader(session, this.getCommandContext());
   }
+  async updateStickyMessage() {
+    await updateAllStickyMessages(this.platforms, this.sessions);
+  }
   async initialize() {
+    initialize(this.sessionStore);
+    for (const platform of this.platforms.values()) {
+      try {
+        const botUser = await platform.getBotUser();
+        await cleanupOldStickyMessages(platform, botUser.id);
+      } catch (err) {
+        console.error(`  \u26A0\uFE0F Failed to cleanup old sticky messages for ${platform.platformId}:`, err);
+      }
+    }
     const staleIds = this.sessionStore.cleanStale(SESSION_TIMEOUT_MS * 2);
     if (staleIds.length > 0) {
       console.log(`  \uD83E\uDDF9 Cleaned ${staleIds.length} stale session(s) from persistence`);
     }
     const persisted = this.sessionStore.load();
-    if (persisted.size === 0)
-      return;
-    console.log(`  \uD83D\uDD04 Found ${persisted.size} persisted session(s), attempting resume...`);
-    for (const state of persisted.values()) {
-      await resumeSession(state, this.getLifecycleContext());
+    console.log(`  [persist] Loaded ${persisted.size} session(s)`);
+    if (persisted.size > 0) {
+      console.log(`  \uD83D\uDD04 Attempting to resume ${persisted.size} persisted session(s)...`);
+      for (const state of persisted.values()) {
+        await resumeSession(state, this.getLifecycleContext());
+      }
     }
+    await this.updateStickyMessage();
   }
-  async startSession(options, username, replyToPostId, platformId = "default") {
-    await startSession(options, username, replyToPostId, platformId, this.getLifecycleContext());
+  async startSession(options, username, replyToPostId, platformId = "default", displayName) {
+    await startSession(options, username, displayName, replyToPostId, platformId, this.getLifecycleContext());
   }
   findSessionByThreadId(threadId) {
     for (const session of this.sessions.values()) {
@@ -20670,11 +21038,11 @@ class SessionManager {
   getPersistedSession(threadId) {
     return this.findPersistedByThreadId(threadId);
   }
-  killSession(threadId, unpersist = true) {
+  async killSession(threadId, unpersist = true) {
     const session = this.findSessionByThreadId(threadId);
     if (!session)
       return;
-    killSession(session, unpersist, this.getLifecycleContext());
+    await killSession(session, unpersist, this.getLifecycleContext());
   }
   killAllSessions() {
     killAllSessions(this.getLifecycleContext());
@@ -20809,8 +21177,8 @@ class SessionManager {
     }
     return session.sessionAllowedUsers.has(username) || session.platform.isUserAllowed(username);
   }
-  async startSessionWithWorktree(options, branch, username, replyToPostId, platformId = "default") {
-    await this.startSession(options, username, replyToPostId, platformId);
+  async startSessionWithWorktree(options, branch, username, replyToPostId, platformId = "default", displayName) {
+    await this.startSession(options, username, replyToPostId, platformId, displayName);
     const threadId = replyToPostId || "";
     const session = this.sessions.get(this.getSessionId(platformId, threadId));
     if (session) {
@@ -21105,10 +21473,10 @@ Release notes not available. See [GitHub releases](https://github.com/anneschuth
       if (branchMatch) {
         const branch = branchMatch[1];
         const cleanedPrompt = prompt.replace(/(?:on branch|!worktree)\s+\S+/i, "").trim();
-        await session.startSessionWithWorktree({ prompt: cleanedPrompt || prompt, files }, branch, username, threadRoot);
+        await session.startSessionWithWorktree({ prompt: cleanedPrompt || prompt, files }, branch, username, threadRoot, platformConfig.id, user?.displayName);
         return;
       }
-      await session.startSession({ prompt, files }, username, threadRoot);
+      await session.startSession({ prompt, files }, username, threadRoot, platformConfig.id, user?.displayName);
     } catch (err) {
       console.error("  \u274C Error handling message:", err);
       try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-threads",
-  "version": "0.19.2",
+  "version": "0.20.0",
   "description": "Share Claude Code sessions live in a Mattermost channel with interactive features",
   "main": "dist/index.js",
   "type": "module",