slk 0.14.0 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49e4f58fdf9277102ef5ac4903270d820c4bd2f375bf6255a03efea91859de53
-  data.tar.gz: 86b10dfa38811794ec3d45aeed3ecf9c824f9f547c3149b0f43b4ae61cbeb60a
+  metadata.gz: 5edea2fd65213e0875f06f53729966f8658ae880bd38321bd9a9d8980200c07a
+  data.tar.gz: 7a532e0e1991807962aae21099ad2e9c2c98b03a364dc3e6db90ebf7f2fdabf6
 SHA512:
-  metadata.gz: 26de21e406bb3185e64ee5db5ced45e964c0ccd5228369a869902f4dbf871d1185aace9ac132433c4ed384185a38f7ffd9a4670fb6dfd5bba269c4c539f1f5b7
-  data.tar.gz: a90f52d2c400a48d2bd0ea4b87c6219ba689642ac6a13c73be11a5fee7164bc4783f17f628045d678d906a1d743629255a50a5d1ded4d9e2216b0d00e9f3cf55
+  metadata.gz: 256c73b33433f9488bfcd1333c14f57e953e80fea54a07500239933cdf2129e682beb5d18cc3ab6f730d77570fd103ea77ab2b2ad7f2f8386d80924e6240f5e1
+  data.tar.gz: 388ffeef9e34949a549fb4cc7bcd8560e7132ad9ebde68b189c7dccfac5b749e3e21445c41fea2f614e5a3f1f179101b45b15727a219a3ab289d916aa0cb4f8a

data/CHANGELOG.md

@@ -7,6 +7,36 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.16.0] - 2026-10-29
+
+### Added
+
+- `slk debug huddle <call id|user>` (hidden command) prints the raw `huddles.get` response. A user is resolved to the call in their profile's `huddle_state_call_id`.
+
+### Fixed
+
+- `slk huddles` and `slk who` show the huddle's channel again. Slack stopped sending `huddle_state_channel_id` on profiles, so every huddle read "channel unknown". The call id is now looked up with `huddles.get`, which also adds Slack Connect guests missing from `users.list`. Huddles in conversations you can't see still show "channel unknown". Room and guest-name lookups run on four connections per workspace, about 3× faster than one at a time.
+
+## [0.15.0] - 2026-10-13
+
+### Added
+
+- Named group DMs ("named chats") show under their name, such as `#ifams review`, in `slk search`, `slk sent` (header and JSON `channel_label`), and `slk huddles`. Before, search showed `<@ifams review>`, sent listed the members, and huddles showed `group DM`. Slack reports these as `is_mpim` with `properties.has_custom_mpdm_name`. Search results carry no `properties`, so a group DM whose name is not an `mpdm-*` slug also counts as named. These commands don't cache a named group DM by name, because a chat can be renamed or share a name with a real channel.
+- `slk debug channel <id|url|#name>` (hidden command) prints the raw `conversations.info` response.
+
+### Fixed
+
+- `slk unread` and `slk catchup` now show group DMs. Slack lists them under `mpims` in `client.counts`, and both commands only read `ims` and `channels`, so a group DM's unreads never appeared. A named group DM is headed by its name (`#ifams review`); any other by the people in it besides you (`@Ada Lovelace, Grace Hopper`). A muted group DM is skipped like a muted channel unless `--muted` is passed. `slk unread --json` adds a `group_dms` array of `{id, mentions, label}`.
+- `slk unread clear` and `slk catchup --batch` now mark group DMs read, and their summaries count them ("Cleared 2 DMs, 1 group DMs, 5 channels and 3 threads"). `unread clear` also reports DMs, which it marked but did not count.
+- Thread headers in `slk unread` and `slk catchup` show a group DM the same way: `#ifams review` for a named one, `@Ada Lovelace, Grace Hopper` for others. Before, they showed the raw `#mpdm-ada--eric--grace-1` slug, and cached it. A slug that other commands already cached is ignored.
+- `slk activity` shows a group DM as `#ifams review` when it is named and `@Ada Lovelace, Grace Hopper` otherwise, in text and in `--json` `channel_name`. Before, it showed and cached the raw `#mpdm-…` slug. Legacy `G…` conversations now show their real name too; they read "Group DM" only when Slack won't say what they are.
+- `slk messages --json` and `slk thread --json` fill `channel_name` from one `conversations.info` lookup when the name isn't cached: `ifams review` for a named group DM, `@Ada Lovelace, Grace Hopper` for others, never the `mpdm-…` slug. DMs and `--no-names` still use the cache only. `slk thread subscribe` and `unsubscribe` name the conversation the same way.
+- `slk messages "#name"`, `slk unread clear "#name"`, and `slk debug channel "#name"` now find named group DMs (`slk messages "#ifams review"`) and any channel you belong to. Lookup pages through `users.conversations` (channels, private channels, and group DMs; archived excluded) and matches names without regard to case. Before, it read one page of `conversations.list`, which Slack caps at 100 channels and which leaves out group DMs. A channel wins over a named group DM with the same name. Public channels you have not joined still fall back to that one page.
+- The channel cache no longer stores group DM `mpdm-*` slugs. These are Slack's internal names, not names anyone types. Slugs cached by older versions are ignored when names are read, and dropped the next time the cache is written. `slk activity` and channel mentions in messages also stop caching named group DMs by name, the same as `slk huddles`.
+- Writing to the channel cache before reading from it no longer replaces the file with just the new entry.
+- `slk unread` no longer prints "No unread messages" after listing unread DMs when no channel is unread.
+- `slk unread clear "#general"` printed "Marked ##general"; it now prints one `#`.
+
 ## [0.14.0] - 2026-10-09
 
 ### Added

data/README.md

@@ -184,8 +184,11 @@ Use `--show-messages` (or `-m`) to preview the actual message content for each a
 slk unread                # Show unread counts
 slk unread clear          # Mark all as read
 slk unread clear general  # Mark channel as read
+slk unread clear "#ifams review"  # Named group DMs work by name too
 ```
 
+Unread DMs, group DMs, channels, and threads are all listed. A named group DM shows under its name (`#ifams review`); others show the people in them.
+
 ### Catchup (Interactive Triage)
 
 ```bash
@@ -229,9 +232,11 @@ slk huddles --json     # Call id, channel, and participants
 ```
 
 Slack has no huddle list. `slk huddles` reads `huddle_state` from `users.list`
-and groups people who share a call id. A huddle with no channel is one Slack
-did not attach to a conversation. People outside the workspace, including some
-Slack Connect guests, are not in the roster and will not appear. The roster is
+and groups people who share a call id. Profiles no longer say which channel a
+huddle is in, so each call id is looked up with `huddles.get` (undocumented),
+which also lists Slack Connect guests missing from the roster. That only works
+for conversations you can see; any other huddle shows "channel unknown" and
+only its roster members. The roster is
 fetched live and is not cached. `--all` scans every workspace at the same time.
 One connection can only read one roster, so each workspace gets its own.
 People who are not in a huddle are dropped as each page arrives. `slk who`

data/lib/slk/api/huddles.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Slk
+  module Api
+    # Wrapper for Slack's undocumented huddles.* endpoints (the web client's).
+    class Huddles
+      def initialize(api_client, workspace)
+        @api = api_client
+        @workspace = workspace
+      end
+
+      # The room for one call id: channels, live participants, has_ended.
+      # Raises not_authorized for a huddle in a conversation the token
+      # cannot see.
+      def get(huddle_id)
+        info(huddle_id)['huddle'] || {}
+      end
+
+      # The whole response, for `slk debug huddle`.
+      def info(huddle_id)
+        @api.post(@workspace, 'huddles.get', { huddle_id: huddle_id })
+      end
+    end
+  end
+end

data/lib/slk/api/users.rb

@@ -143,9 +143,11 @@ module Slk
 
       public
 
-      def conversations(cursor: nil, limit: 1000)
-        params = { limit: limit, types: 'public_channel,private_channel,mpim,im' }
+      def conversations(cursor: nil, limit: 1000, types: 'public_channel,private_channel,mpim,im',
+                        exclude_archived: false)
+        params = { limit: limit, types: types }
         params[:cursor] = cursor if cursor
+        params[:exclude_archived] = true if exclude_archived
         @api.post_form(@workspace, 'users.conversations', params)
       end
     end

data/lib/slk/commands/activity.rb

@@ -109,10 +109,16 @@ module Slk
         Services::ActivityEnricher.new(
           cache_store: cache_store,
           conversations_api: runner.conversations_api(workspace.name),
+          group_dm_label: group_dm_label,
           on_debug: ->(msg) { debug(msg) }
         )
       end
 
+      # One per run, so each group DM is looked up once however often it appears.
+      def group_dm_label
+        @group_dm_label ||= Services::GroupDmLabel.new(runner: runner, on_debug: ->(msg) { debug(msg) })
+      end
+
       def formatter(workspace)
         Formatters::ActivityFormatter.new(
           output: output,

data/lib/slk/commands/catchup.rb

@@ -106,7 +106,7 @@ module Slk
       def batch_mark_workspace(workspace)
         marker = build_unread_marker(workspace)
         counts = marker.mark_all(options: { muted: @options[:muted] })
-        success("Marked #{counts[:dms]} DMs, #{counts[:channels]} channels, " \
+        success("Marked #{counts[:dms]} DMs, #{counts[:group_dms]} group DMs, #{counts[:channels]} channels, " \
                 "and #{counts[:threads]} threads as read on #{workspace.name}")
       end
 
@@ -145,18 +145,25 @@ module Slk
 
       def gather_unread_items(workspace)
         counts = runner.client_api(workspace.name).counts
-        ims = filter_unread_ims(counts['ims'] || [])
-        channels = filter_unread_channels(workspace, counts['channels'] || [])
-        threads_response = fetch_unread_threads(workspace)
+        muted_ids = muted_channel_ids(workspace)
+        build_items_result(
+          filter_unread_ims(counts['ims'] || []),
+          filter_unread_channels(counts['mpims'] || [], muted_ids),
+          filter_unread_channels(counts['channels'] || [], muted_ids),
+          fetch_unread_threads(workspace)
+        )
+      end
 
-        build_items_result(ims, channels, threads_response)
+      def muted_channel_ids(workspace)
+        @options[:muted] ? [] : runner.users_api(workspace.name).muted_channels
       end
 
-      def build_items_result(ims, channels, threads_response)
+      def build_items_result(ims, group_dms, channels, threads_response)
+        conversations = ims.size + group_dms.size + channels.size
         {
-          ims: ims, channels: channels, threads_response: threads_response,
-          total: ims.size + channels.size + (threads_response ? 1 : 0),
-          empty: ims.empty? && channels.empty? && !threads_response
+          ims: ims, group_dms: group_dms, channels: channels, threads_response: threads_response,
+          total: conversations + (threads_response ? 1 : 0),
+          empty: conversations.zero? && !threads_response
         }
       end
 
@@ -164,8 +171,8 @@ module Slk
         ims.select { |i| i['has_unreads'] }
       end
 
-      def filter_unread_channels(workspace, channels)
-        muted_ids = @options[:muted] ? [] : runner.users_api(workspace.name).muted_channels
+      # Channels and group DMs; a muted group DM is skipped like a muted channel.
+      def filter_unread_channels(channels, muted_ids)
         channels
           .select { |c| c['has_unreads'] || (c['mention_count'] || 0).positive? }
           .reject { |c| muted_ids.include?(c['id']) }
@@ -180,6 +187,7 @@ module Slk
         index = { current: 0, total: items[:total] }
 
         return :quit if process_dms(workspace, items[:ims], index)
+        return :quit if process_group_dms(workspace, items[:group_dms], index)
         return :quit if items[:threads_response] && process_threads_item(workspace, items[:threads_response], index)
         return :quit if process_channels(workspace, items[:channels], index)
 
@@ -196,6 +204,16 @@ module Slk
         false
       end
 
+      def process_group_dms(workspace, group_dms, index)
+        group_dms.each do |group_dm|
+          label = group_dm_label.label(workspace, group_dm['id'])
+          return true if process_conversation(workspace, group_dm, index[:current], index[:total], label) == :quit
+
+          index[:current] += 1
+        end
+        false
+      end
+
       def process_channels(workspace, channels, index)
         channels.each do |channel|
           return true if process_channel(workspace, channel, index[:current], index[:total]) == :quit

data/lib/slk/commands/debug.rb

@@ -25,11 +25,13 @@ module Slk
         in ['profile'] then dump_profile(nil)
         in ['team'] then dump_team
         in ['schema'] then dump_schema
-        in ['thread', url] then dump_thread(url)
+        in [action, target] if TARGET_ACTIONS.key?(action) then send(TARGET_ACTIONS[action], target)
         else unknown_action
         end
       end
 
+      TARGET_ACTIONS = { 'thread' => :dump_thread, 'channel' => :dump_channel, 'huddle' => :dump_huddle }.freeze
+
       private
 
       def dump_profile(user_input)
@@ -61,7 +63,7 @@ module Slk
       # carry `subscribed`/`last_read`?) and subscriptions.thread.get. Each call
       # is captured separately so one failing does not hide the other.
       def dump_thread(url)
-        resolved = resolve_thread(url)
+        resolved = resolve_target(url)
         ts = resolved.thread_ts || resolved.msg_ts
         raise UsageError, 'URL must point to a specific message' unless ts
 
@@ -69,9 +71,38 @@ module Slk
         0
       end
 
-      def resolve_thread(url)
+      # Raw conversations.info: shows the flags labels key off (is_mpim,
+      # properties.has_custom_mpdm_name for named group DMs, is_ext_shared).
+      def dump_channel(target)
+        resolved = resolve_target(target)
+        info = runner.conversations_api(resolved.workspace.name).info(channel: resolved.channel_id)
+        output.puts(JSON.pretty_generate(info))
+        0
+      end
+
+      # Raw huddles.get for a call id (R...), or for the call a user is in
+      # now. Profiles carry only the call id; this is where the channel and
+      # the full participant list (Slack Connect guests too) come from.
+      def dump_huddle(target)
+        workspace = runner.workspace(@options[:workspace])
+        call_id = huddle_call_id(workspace, target)
+        output.puts(JSON.pretty_generate(Api::Huddles.new(api_client, workspace).info(call_id)))
+        0
+      end
+
+      def huddle_call_id(workspace, target)
+        return target if target.match?(/\AR[A-Z0-9]+\z/)
+
+        user_id = resolve_user_id(workspace, target)
+        call_id = runner.users_api(workspace.name).info(user_id).dig('user', 'profile', 'huddle_state_call_id')
+        raise ApiError, "#{target} is not in a huddle" if call_id.to_s.empty?
+
+        call_id
+      end
+
+      def resolve_target(target)
         Services::TargetResolver.new(runner: runner, cache_store: cache_store)
-                                .resolve(url, default_workspace: runner.workspace(@options[:workspace]))
+                                .resolve(target, default_workspace: runner.workspace(@options[:workspace]))
       end
 
       def thread_calls(workspace_name, channel, thread_ts)
@@ -118,7 +149,7 @@ module Slk
 
       def unknown_action
         error("Unknown debug action: #{positional_args.first.inspect}")
-        error('Valid actions: profile [user], team, schema, thread <url>')
+        error('Valid actions: profile [user], team, schema, thread <url>, channel <id|url>, huddle <call|user>')
         1
       end
 
@@ -135,6 +166,8 @@ module Slk
             team             Dump team.info
             schema           Dump team.profile.get
             thread <url>     Dump thread parent + subscriptions.thread.get
+            channel <id|url> Dump conversations.info (also #name)
+            huddle <call|user> Dump huddles.get for a call id (R...) or a user's current call
 
           USER
             (none) | me      Self

data/lib/slk/commands/huddles.rb

@@ -25,7 +25,8 @@ module Slk
         help.note('Slack has no huddle list. This reads huddle_state from users.list')
         help.note('and groups people who share a call id. The roster is fetched live.')
         help.note('Primary workspace only. --all scans every workspace at the same time.')
-        help.note('A Slack Connect guest not in the roster is omitted.')
+        help.note('Channels and Slack Connect guests come from huddles.get, so only')
+        help.note('huddles in conversations you can see get them.')
         add_options_section(help)
         add_examples_section(help)
         help.render

data/lib/slk/commands/messages.rb

@@ -10,6 +10,7 @@ module Slk
     class Messages < Base
       include Support::InlineImages
       include Support::AttachmentFetching
+      include Support::UserResolver
 
       # rubocop:disable Metrics/MethodLength
       def execute
@@ -149,7 +150,7 @@ module Slk
       end
 
       def output_json_messages(messages, workspace, channel_id)
-        format_options = json_format_options(channel_id)
+        format_options = json_format_options(workspace, channel_id)
 
         json_messages = messages.map do |message|
           format_message_as_json(message, workspace, channel_id, format_options)
@@ -158,8 +159,24 @@ module Slk
         output_json(json_messages)
       end
 
-      def json_format_options(channel_id)
-        { no_names: @options[:no_names], reaction_timestamps: @options[:reaction_timestamps], channel_id: channel_id }
+      def json_format_options(workspace, channel_id)
+        { no_names: @options[:no_names], reaction_timestamps: @options[:reaction_timestamps], channel_id: channel_id,
+          channel_name: json_channel_name(workspace, channel_id) }
+      end
+
+      # One lookup per run: a group DM gets its name or "@other, members"
+      # (not its mpdm-* slug). DMs and --no-names keep the cache-only name.
+      def json_channel_name(workspace, channel_id)
+        return nil if @options[:no_names] || channel_id.start_with?('D')
+
+        conversation_label(workspace, channel_id)&.delete_prefix('#')
+      end
+
+      # "#name", "@other, members" for a group DM, or "@user" for a DM;
+      # nil when Slack won't say.
+      def conversation_label(workspace, channel_id)
+        label = resolve_conversation_label(workspace, channel_id)
+        label unless label == "##{channel_id}"
       end
 
       def format_message_as_json(message, workspace, channel_id, format_options)

data/lib/slk/commands/thread.rb

@@ -130,8 +130,7 @@ module Slk
       end
 
       def channel_label(workspace, channel_id)
-        name = cache_store.get_channel_name(workspace.name, channel_id)
-        name ? "##{name}" : channel_id
+        conversation_label(workspace, channel_id) || channel_id
       end
 
       def subscription_error(action, err)

data/lib/slk/commands/unread.rb

@@ -133,6 +133,7 @@ module Slk
 
         {
           unread_ims: filter_unread_ims(counts['ims'] || []),
+          unread_group_dms: filter_unread_channels(counts['mpims'] || [], muted_ids),
           unread_channels: filter_unread_channels(counts['channels'] || [], muted_ids)
         }
       end
@@ -154,10 +155,16 @@ module Slk
       def unread_json(workspace, data)
         {
           channels: data[:unread_channels].map { |c| format_channel_json(workspace, c) },
-          dms: data[:unread_ims].map { |i| format_dm_json(workspace, i) }
+          dms: data[:unread_ims].map { |i| format_dm_json(workspace, i) },
+          group_dms: data[:unread_group_dms].map { |g| format_group_dm_json(workspace, g) }
         }
       end
 
+      def format_group_dm_json(workspace, group_dm)
+        { id: group_dm['id'], mentions: group_dm['mention_count'],
+          label: group_dm_label.label(workspace, group_dm['id']) }
+      end
+
       def format_channel_json(workspace, channel)
         channel_hash = { id: channel['id'], mentions: channel['mention_count'] }
         channel_name = cache_store.get_channel_name(workspace.name, channel['id'])
@@ -180,23 +187,37 @@ module Slk
         formatter = runner.message_formatter
 
         display_unread_dms(workspace, data[:unread_ims], conversations_api, formatter)
-        display_unread_channels(workspace, data[:unread_channels], conversations_api, formatter)
+        display_unread_group_dms(workspace, data[:unread_group_dms], conversations_api, formatter)
+        display_unread_channels(workspace, data, conversations_api, formatter)
         show_threads(workspace, formatter)
       end
 
       def display_unread_dms(workspace, unread_ims, conversations_api, formatter)
         unread_ims.each do |im|
-          mention_count = im['mention_count'] || 0
           user_name = resolve_dm_user_name(workspace, im['id'], conversations_api)
-          puts
-          puts output.bold("@#{user_name}") + (mention_count.positive? ? " (#{mention_count} mentions)" : '')
-          puts
+          print_conversation_header("@#{user_name}", im['mention_count'] || 0)
           show_channel_messages(workspace, im['id'], @options[:limit], conversations_api, formatter)
         end
       end
 
-      def display_unread_channels(workspace, unreads, conversations_api, formatter)
-        return puts('No unread messages') if unreads.empty?
+      def display_unread_group_dms(workspace, group_dms, conversations_api, formatter)
+        group_dms.each do |group_dm|
+          print_conversation_header(group_dm_label.label(workspace, group_dm['id']), group_dm['mention_count'] || 0)
+          show_channel_messages(workspace, group_dm['id'], @options[:limit], conversations_api, formatter)
+        end
+      end
+
+      def print_conversation_header(label, mention_count)
+        puts
+        puts output.bold(label) + (mention_count.positive? ? " (#{mention_count} mentions)" : '')
+        puts
+      end
+
+      # "No unread messages" only when nothing at all is unread, not merely
+      # when the DMs and group DMs above are the only unreads.
+      def display_unread_channels(workspace, data, conversations_api, formatter)
+        unreads = data[:unread_channels]
+        return puts('No unread messages') if [unreads, data[:unread_ims], data[:unread_group_dms]].all?(&:empty?)
 
         unreads.each { |ch| display_channel(workspace, ch, conversations_api, formatter) }
       end
@@ -283,12 +304,13 @@ module Slk
         channel_id = resolve_channel_id(workspace, channel_name)
         return unless unread_marker(workspace).mark_single_channel(channel_id)
 
-        success("Marked ##{channel_name} as read on #{workspace.name}")
+        success("Marked ##{channel_name.delete_prefix('#')} as read on #{workspace.name}")
       end
 
       def clear_all_channels(workspace)
         counts = unread_marker(workspace).mark_all(options: { muted: @options[:muted] })
-        success("Cleared #{counts[:channels]} channels and #{counts[:threads]} threads on #{workspace.name}")
+        success("Cleared #{counts[:dms]} DMs, #{counts[:group_dms]} group DMs, #{counts[:channels]} channels " \
+                "and #{counts[:threads]} threads on #{workspace.name}")
       end
 
       def unread_marker(workspace)
@@ -305,15 +327,8 @@ module Slk
         return channel_name if channel_name.match?(/^[CDG][A-Z0-9]+$/)
 
         name = channel_name.delete_prefix('#')
-        cache_store.get_channel_id(workspace.name, name) || resolve_channel(workspace, name)
-      end
-
-      def resolve_channel(workspace, name)
-        api = runner.conversations_api(workspace.name)
-        response = api.list
-        channels = response['channels'] || []
-        channel = channels.find { |c| c['name'] == name }
-        channel&.dig('id') || raise(ConfigError, "Channel not found: ##{name}")
+        Services::ChannelLookup.new(runner: runner, cache_store: cache_store).find_id(workspace, name) ||
+          raise(ConfigError, "Channel not found: ##{name}")
       end
     end
     # rubocop:enable Metrics/ClassLength

data/lib/slk/commands/who.rb

@@ -89,12 +89,13 @@ module Slk
       # Channel ids are useless on a card. A failed lookup still leaves the
       # state, which is the part Slack always sends.
       def attach_huddle_channel(workspace, profile)
-        return profile if profile.huddle_channel_id.to_s.empty?
+        channel_id = Services::HuddleRoom.new(api_client: api_client, workspace: workspace).channel_for(profile)
+        return profile if channel_id.to_s.empty?
 
-        label = huddle_channels.label(workspace, profile.huddle_channel_id)
+        label = huddle_channels.label(workspace, channel_id)
         return profile unless label
 
-        Models::Profile.new(**profile.to_h, huddle_channel: label)
+        Models::Profile.new(**profile.to_h, huddle_channel_id: channel_id, huddle_channel: label)
       end
 
       def huddle_channels

data/lib/slk/formatters/json_message_formatter.rb

@@ -87,7 +87,7 @@ module Slk
         workspace_name = workspace&.name
         return unless workspace_name
 
-        channel_name = @cache.get_channel_name(workspace_name, options[:channel_id])
+        channel_name = options[:channel_name] || @cache.get_channel_name(workspace_name, options[:channel_id])
         result[:channel_name] = channel_name if channel_name
       end
     end

data/lib/slk/formatters/mention_replacer.rb

@@ -109,14 +109,20 @@ module Slk
         response = Api::Conversations.new(@api, workspace).info(channel: channel_id)
         return nil unless response['ok'] && response['channel']
 
-        name = response['channel']['name']
-        @cache.set_channel(workspace.name, name, channel_id) if name
-        name
+        remember_channel_name(workspace, channel_id, response['channel'])
       rescue ApiError => e
         @on_debug&.call("Channel lookup failed for #{channel_id}: #{e.message}")
         nil
       end
 
+      # Group DMs stay out of the name cache: a named one can be renamed or
+      # share a real channel's name, and an mpdm-* slug isn't a name.
+      def remember_channel_name(workspace, channel_id, channel)
+        name = channel['name']
+        @cache.set_channel(workspace.name, name, channel_id) if name && !channel['is_mpim']
+        name
+      end
+
       def lookup_subteam_handle(workspace, subteam_id)
         cached = @cache.get_subteam(workspace.name, subteam_id)
         return cached if cached

data/lib/slk/formatters/search_formatter.rb

@@ -37,7 +37,11 @@ module Slk
         channel_label_for(result.channel_type, result.channel_name, workspace)
       end
 
+      # Named group DMs show as #name; their name is not a user ID to resolve.
       def channel_label_for(type, name, workspace)
+        named = type == 'mpim' && Support::GroupDmName.label(name)
+        return named if named
+
         if %w[im mpim].include?(type)
           @mentions.replace("<@#{name}>", workspace)
         else

data/lib/slk/models/search_result.rb

@@ -106,6 +106,9 @@ module Slk
       end
 
       def display_channel
+        named = channel_type == 'mpim' && Support::GroupDmName.label(channel_name)
+        return named if named
+
         if dm?
           "@#{channel_name}"
         else

data/lib/slk/services/activity_enricher.rb

@@ -2,11 +2,14 @@
 
 module Slk
   module Services
-    # Enriches activity feed items with resolved user/channel names
+    # Enriches activity feed items with resolved user/channel names.
+    # Group DMs show as "#name" when named, else "@other, members" (given a
+    # GroupDmLabel), never as their mpdm-* slug, and are never cached by name.
     class ActivityEnricher
-      def initialize(cache_store:, conversations_api:, on_debug: nil)
+      def initialize(cache_store:, conversations_api:, group_dm_label: nil, on_debug: nil)
         @cache = cache_store
         @conversations_api = conversations_api
+        @group_dm_label = group_dm_label
         @on_debug = on_debug
       end
 
@@ -40,15 +43,16 @@ module Slk
         @cache.get_user(workspace.name, user_id) || user_id
       end
 
-      # Resolve channel ID to name (with API fallback)
+      # Resolve channel ID to a label (with API fallback). Legacy G ids are
+      # group DMs or old private channels; they read "Group DM" if Slack
+      # won't say which.
       def resolve_channel(workspace, channel_id, with_hash: true)
         return 'DM' if channel_id.start_with?('D')
-        return 'Group DM' if channel_id.start_with?('G')
 
-        name = fetch_channel_name(workspace, channel_id)
-        return channel_id unless name
+        label = channel_label(workspace, channel_id)
+        return channel_id.start_with?('G') ? 'Group DM' : channel_id unless label
 
-        with_hash ? "##{name}" : name
+        with_hash ? label : label.delete_prefix('#')
       end
 
       private
@@ -101,21 +105,37 @@ module Slk
         data['channel_name'] = resolve_channel(workspace, channel_id, with_hash: false) if channel_id
       end
 
-      def fetch_channel_name(workspace, channel_id)
+      def channel_label(workspace, channel_id)
+        known = @group_dm_label&.known(workspace, channel_id)
+        return known if known
+
         cached = @cache.get_channel_name(workspace.name, channel_id)
-        return cached if cached
+        return "##{cached}" if cached
+
+        fetch_channel_label(workspace, channel_id)
+      end
 
+      def fetch_channel_label(workspace, channel_id)
         response = @conversations_api.info(channel: channel_id)
-        return nil unless response['ok'] && response['channel']
+        channel = response['channel'] if response['ok']
+        return nil unless channel
+        return group_dm_label(workspace, channel_id, channel) if channel['is_mpim']
+        return nil unless channel['name']
 
-        name = response['channel']['name']
-        @cache.set_channel(workspace.name, name, channel_id)
-        name
+        @cache.set_channel(workspace.name, channel['name'], channel_id)
+        "##{channel['name']}"
       rescue ApiError => e
         @on_debug&.call("Could not resolve channel #{channel_id}: #{e.message}")
         nil
       end
 
+      def group_dm_label(workspace, channel_id, channel)
+        return @group_dm_label.label_from(workspace, channel_id, channel) if @group_dm_label
+
+        named = Support::GroupDmName.custom(channel)
+        named ? "##{named}" : 'Group DM'
+      end
+
       def debug_missing(item_type, missing_data)
         @on_debug&.call("Could not enrich #{item_type} item - missing #{missing_data} data")
       end

data/lib/slk/services/api_client.rb

@@ -45,7 +45,7 @@ module Slk
         child.on_response = @on_response
         child.on_request_body = @on_request_body
         child.on_response_body = @on_response_body
-        child.share_counter(self)
+        child.share_counter(@counter || self)
         child
       end