claude-threads 1.31.1 → 1.32.0

package/CHANGELOG.md

@@ -5,6 +5,21 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+## [1.32.0] - 2026-09-01
+
+### Added
+- **Slack: shared event source — one Socket Mode connection per app** (#502, thanks @kaza). Slack round-robins Socket Mode envelopes across all of an app's open connections, so a second `SlackClient` on the same app token silently steals events from the first. Now exactly one client (the parent) owns the socket; other clients register as secondaries and receive their channels' events injected by the parent — Web API calls stay independent per instance. The parent mirrors connection state onto secondaries (idempotently re-armed across disconnects), and on reconnect, missed-message recovery runs for the parent and every registered secondary. Zero behavior change for existing single-channel configs; this is the mechanism that unblocks DM auto-discovery on Slack and other multi-channel consumers.
+
+## [1.31.2] - 2026-08-30
+
+### Added
+- **The approval posture of a routine or watch is now visible and changeable after creation.** `!routines` / `!watches` listings show each item's posture inline (👍 approvals · ✅ autonomous), and a new owner-gated `!routines approval <n> on|off` / `!watches approval <n> on|off` flips it — `off` makes an item run autonomously, `on` restores per-action approval. Turning a watch autonomous is the same sensitive choice the creation card gates behind the owner and an explicit ✅, so the flip command is owner-gated too; the safe approvals-required posture stays the default for older data.
+
+### Security
+- **Active-session thread-id lookups are now scoped by `platformId`**, completing the cross-platform privacy boundary that 1.31.0/1.31.1 established for the persisted store. `SessionRegistry.findByThreadId` takes an optional `platformId` and resolves O(1) against the composite key when given; the message router (`handleMessage`) and the in-session authorization check (`isUserAllowedInSession`) now pass it, so a thread id that collides across platforms can no longer resolve to — or authorize a user against — another platform's *active* session, and the router and auth check always agree on which session a message belongs to. Defense-in-depth: real Mattermost (26-char) and Slack (dotted-ts) ids don't collide today.
+
 ## [1.31.1] - 2026-08-29
 
 ### Security

package/README.md

@@ -126,9 +126,9 @@ Type `!help` in any session thread:
 | `!remember <text>`                          | Save a note to the channel's shared memory                                               |
 | `!memory`                                   | Show channel memory (`forget <n\|text>` removes entries)                                 |
 | `!routine <schedule, task>`                 | Schedule a recurring routine in natural language (confirmed with 👍)                     |
-| `!routines`                                 | List routines (`pause\|resume\|delete\|run <n>` to manage)                               |
+| `!routines`                                 | List routines (`pause\|resume\|delete\|run <n>`, `approval <n> on\|off` to manage)       |
 | `!watch <when ..., task>`                   | Create an event trigger in natural language (confirmed with 👍)                          |
-| `!watches`                                  | List event triggers (`pause\|resume\|delete <n>` to manage)                             |
+| `!watches`                                  | List event triggers (`pause\|resume\|delete <n>`, `approval <n> on\|off` to manage)      |
 | `!update`                                   | Show auto-update status (`!update now` / `!update defer`)                                |
 | `!bug <desc>`                               | Report a bug with context (creates a GitHub issue)                                       |
 | `!approve`                                  | Approve pending plan (alternative to 👍; also `!yes`)                                    |

package/dist/index.js

@@ -65227,6 +65227,9 @@ async function postRoutineConfirmation(session, ctx, parsed, requestedBy, opts =
   });
   sessionLog4(session).info(`\uD83D\uDD58 Routine proposal posted for @${requestedBy}${opts.proposedByAgent ? " (agent-proposed)" : ""}: "${parsed.name}"`);
 }
+function postureMarker(item) {
+  return item.requireApproval === false ? " · ✅ autonomous" : " · \uD83D\uDC4D approvals";
+}
 async function manageListItems(session, args, username, flavor) {
   const formatter = session.platform.getFormatter();
   const trimmed = args?.trim();
@@ -65244,13 +65247,32 @@ async function manageListItems(session, args, username, flavor) {
 ` + `${lines.join(`
 `)}
 
-` + `${formatter.formatItalic(`Manage with ${"`" + cmd + " " + flavor.actions + " <n>`"}.`)}`);
+` + `${formatter.formatItalic(`Manage with ${"`" + cmd + " " + flavor.actions + " <n>`"}; set approval posture with ${"`" + cmd + " approval <n> on|off`"}.`)}`);
     session.threadLogger?.logCommand(flavor.command, "list", username);
     return;
   }
+  const approvalMatch = trimmed.match(/^approval\s+(\d+)\s+(on|off)$/i);
+  if (approvalMatch) {
+    const [, indexArg2, mode] = approvalMatch;
+    const item2 = flavor.list()[parseInt(indexArg2, 10) - 1];
+    if (!item2) {
+      await post(session, "warning", `${flavor.emoji} No ${flavor.noun.toLowerCase()} ${indexArg2}. See ${formatter.formatCode(cmd)}.`);
+      return;
+    }
+    if (!await requireSessionOwner(session, username, `manage ${flavor.command}`)) {
+      return;
+    }
+    const requireApproval = mode.toLowerCase() === "on";
+    await flavor.update(item2.id, { requireApproval });
+    await post(session, "success", requireApproval ? `\uD83D\uDC4D ${flavor.noun} ${formatter.formatBold(item2.name)} will ask for approval before each action.` : `✅ ${flavor.noun} ${formatter.formatBold(item2.name)} will run autonomously — no approval prompts. Only leave this on for triggers you fully trust.`);
+    sessionLog4(session).info(`${flavor.emoji} @${username}: ${cmd} approval ${indexArg2} ${mode.toLowerCase()} ("${item2.name}")`);
+    auditCommand(session, flavor.command, `approval ${indexArg2} ${mode.toLowerCase()}`, username);
+    session.threadLogger?.logCommand(flavor.command, `approval ${indexArg2} ${mode.toLowerCase()}`, username);
+    return;
+  }
   const match = trimmed.match(new RegExp(`^(${flavor.actions})\\s+(\\d+)$`, "i"));
   if (!match) {
-    await post(session, "warning", `${flavor.emoji} Usage: ${formatter.formatCode(cmd)} or ${formatter.formatCode(`${cmd} ${flavor.actions} <n>`)}`);
+    await post(session, "warning", `${flavor.emoji} Usage: ${formatter.formatCode(cmd)}, ${formatter.formatCode(`${cmd} ${flavor.actions} <n>`)} or ${formatter.formatCode(`${cmd} approval <n> on|off`)}`);
     return;
   }
   const [, action, indexArg] = match;
@@ -65302,7 +65324,7 @@ async function manageRoutines(session, args, username, ctx) {
     describe: (r, formatter) => {
       const status = r.enabled ? "" : " — ⏸️ paused";
       const last = r.lastRunAt ? ` · last run ${formatIsoMinute(r.lastRunAt)} (${r.lastRunStatus})` : "";
-      return `${formatter.formatBold(r.name)} — ${describeSchedule(r.schedule)} · by ${formatter.formatCode("@" + r.createdBy)}${status}${last}`;
+      return `${formatter.formatBold(r.name)} — ${describeSchedule(r.schedule)} · by ${formatter.formatCode("@" + r.createdBy)}${postureMarker(r)}${status}${last}`;
     },
     list: () => ctx.state.routinesStore.list(platformId),
     update: (id, patch) => ctx.state.routinesStore.update(platformId, id, patch),
@@ -65388,7 +65410,7 @@ async function manageWatches(session, args, username, ctx) {
     describe: (w, formatter) => {
       const status = w.enabled ? "" : " — ⏸️ paused";
       const last = w.lastFiredAt ? ` · last fired ${formatIsoMinute(w.lastFiredAt)} (${w.lastFireStatus})` : "";
-      return `${formatter.formatBold(w.name)} — fires when ${w.condition} · by ${formatter.formatCode("@" + w.createdBy)}${status}${last}`;
+      return `${formatter.formatBold(w.name)} — fires when ${w.condition} · by ${formatter.formatCode("@" + w.createdBy)}${postureMarker(w)}${status}${last}`;
     },
     list: () => ctx.state.watchesStore.list(platformId),
     update: (id, patch) => ctx.state.watchesStore.update(platformId, id, patch),
@@ -67888,7 +67910,10 @@ class SessionRegistry {
   find(platformId, threadId) {
     return this.sessions.get(this.getSessionId(platformId, threadId));
   }
-  findByThreadId(threadId) {
+  findByThreadId(threadId, platformId) {
+    if (platformId !== undefined) {
+      return this.find(platformId, threadId);
+    }
     for (const session of this.sessions.values()) {
       if (session.threadId === threadId) {
         return session;
@@ -71916,8 +71941,13 @@ class SlackClient extends BasePlatformClient {
   rateLimitRetryAfter = 0;
   outboundFiles;
   formatter = new SlackFormatter;
-  constructor(platformConfig) {
+  channelClients = new Map;
+  sharedEventSource;
+  socketConnected = false;
+  constructor(platformConfig, sharedEventSource) {
     super();
+    this.sharedEventSource = sharedEventSource;
+    this.installStateMirror();
     this.platformId = platformConfig.id;
     this.displayName = platformConfig.displayName;
     this.botToken = platformConfig.botToken;
@@ -71931,6 +71961,55 @@ class SlackClient extends BasePlatformClient {
     this.approvals = platformConfig.approvals;
     this.ackReaction = normalizeAckReaction(platformConfig.ackReaction, `platforms[${platformConfig.id}].ackReaction`);
   }
+  stateMirrors = ["connected", "disconnected", "reconnecting"].map((state) => ({
+    state,
+    handler: (...args) => {
+      for (const secondary of this.channelClients.values()) {
+        secondary.emit(state, ...args);
+      }
+    }
+  }));
+  installStateMirror() {
+    for (const { state, handler: handler2 } of this.stateMirrors) {
+      this.off(state, handler2);
+      this.on(state, handler2);
+    }
+  }
+  onConnectionEstablished() {
+    const wasReconnecting = this.isReconnecting;
+    super.onConnectionEstablished();
+    if (!wasReconnecting)
+      return;
+    for (const secondary of this.channelClients.values()) {
+      secondary.recoverMissedMessages().catch((err) => {
+        log40.warn(`Failed to recover missed messages for ${secondary.platformId}: ${err}`);
+      });
+    }
+  }
+  registerChannelClient(channelId, client) {
+    if (channelId === this.channelId) {
+      throw new Error(`registerChannelClient: ${channelId} is the parent's own channel — a secondary there can never receive events`);
+    }
+    this.channelClients.set(channelId, client);
+  }
+  unregisterChannelClient(channelId, client) {
+    if (client && this.channelClients.get(channelId) !== client)
+      return;
+    this.channelClients.delete(channelId);
+  }
+  _injectSlackEvent(event) {
+    this.handleSlackEvent(event);
+  }
+  disconnect() {
+    if (this.sharedEventSource) {
+      this.sharedEventSource.unregisterChannelClient(this.channelId, this);
+    }
+    try {
+      return super.disconnect();
+    } finally {
+      this.installStateMirror();
+    }
+  }
   normalizePlatformUser(slackUser) {
     const displayName = slackUser.profile?.display_name || slackUser.profile?.real_name || slackUser.real_name || slackUser.name;
     return {
@@ -72034,6 +72113,16 @@ class SlackClient extends BasePlatformClient {
     return data;
   }
   async connect() {
+    if (this.sharedEventSource) {
+      await this.fetchBotUser();
+      if (this.isIntentionalDisconnect)
+        return;
+      this.sharedEventSource.registerChannelClient(this.channelId, this);
+      if (this.sharedEventSource.socketConnected) {
+        this.emit("connected");
+      }
+      return;
+    }
     await this.fetchBotUser();
     wsLogger.debug(`Slack bot user ID: ${this.botUserId}`);
     const response = await this.appApi("POST", "apps.connections.open");
@@ -72073,12 +72162,8 @@ class SlackClient extends BasePlatformClient {
           this.handleSocketModeEvent(envelope);
           if (envelope.type === "hello") {
             clearTimeout(connectionTimeout);
+            this.socketConnected = true;
             this.onConnectionEstablished();
-            if (this.isReconnecting && this.lastProcessedTs) {
-              this.recoverMissedMessages().catch((err) => {
-                log40.warn(`Failed to recover missed messages: ${err}`);
-              });
-            }
             doResolve();
           }
         } catch (err) {
@@ -72086,6 +72171,7 @@ class SlackClient extends BasePlatformClient {
         }
       };
       this.ws.onclose = (event) => {
+        this.socketConnected = false;
         clearTimeout(connectionTimeout);
         wsLogger.info(`Socket Mode: WebSocket disconnected (code: ${event.code}, reason: ${event.reason || "none"}, clean: ${event.wasClean})`);
         if (!settled) {
@@ -72137,6 +72223,14 @@ class SlackClient extends BasePlatformClient {
     }
   }
   handleSlackEvent(event) {
+    const eventChannel = event.channel || event.item?.channel;
+    if (eventChannel && eventChannel !== this.channelId) {
+      const secondary = this.channelClients.get(eventChannel);
+      if (secondary) {
+        secondary._injectSlackEvent(event);
+        return;
+      }
+    }
     if (event.type === "message" && (!event.subtype || event.subtype === "file_share")) {
       if (event.user === this.botUserId || event.bot_id) {
         return;
@@ -75431,7 +75525,7 @@ class SessionManager extends EventEmitter4 {
     return session !== undefined && session.claude.isRunning();
   }
   hasPausedSession(threadId, platformId) {
-    if (this.registry.findByThreadId(threadId))
+    if (this.registry.findByThreadId(threadId, platformId))
       return false;
     return this.registry.getPersistedByThreadId(threadId, platformId) !== undefined;
   }
@@ -75743,7 +75837,7 @@ Mention me to start a session in this worktree.`, threadId);
     }
   }
   isUserAllowedInSession(threadId, username, platformId) {
-    const session = this.findSessionByThreadId(threadId);
+    const session = this.registry.find(platformId, threadId);
     if (!session) {
       const persisted = this.getPersistedSession(threadId, platformId);
       if (persisted) {
@@ -85468,7 +85562,7 @@ async function handleMessage(client, session, post2, user, options) {
       await onKill?.(username);
       return;
     }
-    const activeSession = session.registry.findByThreadId(threadRoot);
+    const activeSession = session.registry.findByThreadId(threadRoot, platformId);
     if (activeSession) {
       const sideMentionActive = leadingOtherUserMention(client, message);
       if (sideMentionActive) {

package/dist/mcp/mcp-server.js

@@ -58101,7 +58101,10 @@ class SessionRegistry {
   find(platformId, threadId) {
     return this.sessions.get(this.getSessionId(platformId, threadId));
   }
-  findByThreadId(threadId) {
+  findByThreadId(threadId, platformId) {
+    if (platformId !== undefined) {
+      return this.find(platformId, threadId);
+    }
     for (const session of this.sessions.values()) {
       if (session.threadId === threadId) {
         return session;

package/docs/CONFIGURATION.md

@@ -382,8 +382,12 @@ confirmation says so.
 
 **Managing:**
 
-- `!routines` — numbered list with schedule, creator, and last-run status
+- `!routines` — numbered list with schedule, creator, last-run status, and
+  the approval posture (👍 approvals · ✅ autonomous)
 - `!routines pause|resume|delete <n>` — owner-gated
+- `!routines approval <n> on|off` — owner-gated; flip the approval posture
+  after creation. `on` restores per-action approval, `off` makes each run
+  autonomous (no approval prompts, even on a `skipPermissions` platform)
 - `!routines run <n>` — fire now, outside the schedule (platform-allowed
   users only — not temporarily `!invite`d guests; does not consume the
   period's scheduled fire)
@@ -452,8 +456,12 @@ all three, and **nothing is saved until someone reacts 👍**.
 
 **Managing:**
 
-- `!watches` — numbered list with condition, creator, and last-fire status
+- `!watches` — numbered list with condition, creator, last-fire status, and
+  the approval posture (👍 approvals · ✅ autonomous)
 - `!watches pause|resume|delete <n>` — owner-gated
+- `!watches approval <n> on|off` — owner-gated; flip the approval posture
+  after creation. `off` makes each fire autonomous — reserve it for triggers
+  you fully trust, since a watch fires on channel content anyone can post
 - (No manual `run` — watches are event-driven; use `!routines run` for
   on-demand work.)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-threads",
-  "version": "1.31.1",
+  "version": "1.32.0",
   "description": "Run Claude Code from Slack or Mattermost. Sessions stream live into threads where your whole team can watch and steer.",
   "main": "dist/index.js",
   "type": "module",