slk 0.14.0 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49e4f58fdf9277102ef5ac4903270d820c4bd2f375bf6255a03efea91859de53
-  data.tar.gz: 86b10dfa38811794ec3d45aeed3ecf9c824f9f547c3149b0f43b4ae61cbeb60a
+  metadata.gz: '080abcf262e2c943cb01e3fe6fc5619ee0921d93d4418deeb5f42d6fc4154a92'
+  data.tar.gz: 762989ed0de46ef13372d550a80517bf2c3c7ce73eaf916c8d78fafd5d6e6f57
 SHA512:
-  metadata.gz: 26de21e406bb3185e64ee5db5ced45e964c0ccd5228369a869902f4dbf871d1185aace9ac132433c4ed384185a38f7ffd9a4670fb6dfd5bba269c4c539f1f5b7
-  data.tar.gz: a90f52d2c400a48d2bd0ea4b87c6219ba689642ac6a13c73be11a5fee7164bc4783f17f628045d678d906a1d743629255a50a5d1ded4d9e2216b0d00e9f3cf55
+  metadata.gz: bc5bc2aafe45a6ab8a20fac51086e426d2586012be06b82d87fa3560597386b6d0a504a1489b8b75cf9af5c00627dd7b10a2714af8479fee37202408963e10b8
+  data.tar.gz: a835b18a0a8155c73d2618fa484393dcfaf9b11fbbd0583530209b810e0cadd09ddf45fa5618c54a75f9581dfd0a165d35257cd6faa0add128c08a51d03b0047

data/CHANGELOG.md

@@ -7,6 +7,26 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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

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

@@ -26,6 +26,7 @@ module Slk
         in ['team'] then dump_team
         in ['schema'] then dump_schema
         in ['thread', url] then dump_thread(url)
+        in ['channel', target] then dump_channel(target)
         else unknown_action
         end
       end
@@ -61,7 +62,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 +70,18 @@ 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
+
+      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 +128,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>')
         1
       end
 
@@ -135,6 +145,7 @@ 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)
 
           USER
             (none) | me      Self

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/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/cache_store.rb

@@ -110,16 +110,23 @@ module Slk
         result
       end
 
+      # Group DM mpdm-* slugs are never returned (older versions cached them),
+      # so callers fall through to a real label.
       def get_channel_name(workspace_name, channel_id)
         load_channel_cache(workspace_name)
         cache = @channel_cache[workspace_name] || {}
-        result = cache.key(channel_id)
+        result = cache.find { |name, id| id == channel_id && !group_dm_slug?(name) }&.first
         log_cache_access('channel_name', workspace_name, channel_id, result)
         result
       end
 
+      # Refuses group DM mpdm-* slugs: they are Slack's internal names, not
+      # what people type or see. Writing drops any slugs cached before this.
       def set_channel(workspace_name, channel_name, channel_id)
-        @channel_cache[workspace_name] ||= {}
+        return if group_dm_slug?(channel_name)
+
+        load_channel_cache(workspace_name)
+        @channel_cache[workspace_name].reject! { |name, _id| group_dm_slug?(name) }
         @channel_cache[workspace_name][channel_name] = channel_id
         save_channel_cache(workspace_name)
       end
@@ -184,6 +191,10 @@ module Slk
 
       private
 
+      def group_dm_slug?(name)
+        name.to_s.match?(Support::GroupDmName::SLUG)
+      end
+
       def load_user_cache(workspace_name)
         return if @user_cache.key?(workspace_name)
 

data/lib/slk/services/channel_lookup.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Slk
+  module Services
+    # Finds a conversation id from a name typed as `#name`.
+    #
+    # Order: the channel cache, then every page of the conversations you
+    # belong to (users.conversations: public and private channels plus group
+    # DMs, so a named group DM such as "ifams review" resolves), then one page
+    # of conversations.list for public channels you have not joined. That
+    # last step is only one page, as before: the full workspace list runs to
+    # thousands of channels at 100 per page.
+    #
+    # A channel wins over a named group DM with the same name. A group DM is
+    # cached only after a full scan finds no channel of that name among yours.
+    class ChannelLookup
+      MEMBER_TYPES = 'public_channel,private_channel,mpim'
+      MAX_PAGES = 50
+
+      def initialize(runner:, cache_store:)
+        @runner = runner
+        @cache = cache_store
+      end
+
+      # @param workspace [Models::Workspace]
+      # @param name [String] channel or group DM name, without the leading #
+      # @return [String, nil] the conversation id, or nil if none matches
+      def find_id(workspace, name)
+        @cache.get_channel_id(workspace.name, name) || lookup(workspace, name)
+      end
+
+      private
+
+      def lookup(workspace, name)
+        channel = member_conversation(workspace, name) || listed_channel(workspace, name)
+        return nil unless channel
+
+        @cache.set_channel(workspace.name, channel['name'], channel['id'])
+        channel['id']
+      end
+
+      def member_conversation(workspace, name)
+        group_dm = nil
+        each_member_page(workspace) do |conversations|
+          conversations.each do |conversation|
+            next unless name_matches?(conversation, name)
+            return conversation unless conversation['is_mpim']
+
+            group_dm ||= conversation
+          end
+        end
+        group_dm
+      end
+
+      def each_member_page(workspace)
+        api = @runner.users_api(workspace.name)
+        cursor = nil
+        MAX_PAGES.times do
+          response = api.conversations(cursor: cursor, types: MEMBER_TYPES, exclude_archived: true)
+          yield response['channels'] || []
+          cursor = response.dig('response_metadata', 'next_cursor').to_s
+          break if cursor.empty?
+        end
+      end
+
+      def listed_channel(workspace, name)
+        channels = @runner.conversations_api(workspace.name).list['channels'] || []
+        channels.find { |channel| name_matches?(channel, name) }
+      end
+
+      # Channel names are lowercase; a group DM's name keeps whatever case
+      # it was given, so "#IFAMS Review" and "#ifams review" both find it.
+      def name_matches?(conversation, name)
+        conversation['name'].to_s.casecmp?(name)
+      end
+    end
+  end
+end

data/lib/slk/services/group_dm_label.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Slk
+  module Services
+    # Header label for a group DM in unread and catchup (conversation and
+    # thread headers). A named group DM
+    # shows its name ("#ifams review"); any other shows the people in it
+    # besides you ("@Ada Lovelace, Grace Hopper") rather than the opaque
+    # mpdm-* slug. One conversations.info per chat, remembered for the run.
+    class GroupDmLabel
+      def initialize(runner:, on_debug: nil)
+        @runner = runner
+        @on_debug = on_debug
+        @labels = {}
+        @self_ids = {}
+      end
+
+      # @return [String] "#name", "@names", or "#<channel id>" if Slack refuses
+      def label(workspace, channel_id)
+        @labels[[workspace.name, channel_id]] ||= fetch_label(workspace, channel_id)
+      end
+
+      # @return [String, nil] a label already worked out this run, if any
+      def known(workspace, channel_id)
+        @labels[[workspace.name, channel_id]]
+      end
+
+      # Same label when the caller already holds conversations.info's channel.
+      def label_from(workspace, channel_id, channel)
+        @labels[[workspace.name, channel_id]] ||= label_for(workspace, channel) || "##{channel_id}"
+      end
+
+      private
+
+      def fetch_label(workspace, channel_id)
+        channel = @runner.conversations_api(workspace.name).info(channel: channel_id)['channel'] || {}
+        label_for(workspace, channel) || "##{channel_id}"
+      rescue ApiError => e
+        @on_debug&.call("Group DM lookup failed for #{channel_id}: #{e.message}")
+        "##{channel_id}"
+      end
+
+      def label_for(workspace, channel)
+        named = Support::GroupDmName.custom(channel)
+        return "##{named}" if named
+
+        names = member_names(workspace, channel['members'] || [])
+        return "@#{names.join(', ')}" if names.any?
+
+        "##{channel['name']}" unless channel['name'].to_s.empty?
+      end
+
+      def member_names(workspace, members)
+        self_id = self_user_id(workspace)
+        others = members.reject { |id| id == self_id }
+        others = members if others.empty?
+        others.map { |id| user_name(workspace, id) }
+      end
+
+      def user_name(workspace, user_id)
+        UserLookup.new(cache_store: @runner.cache_store, workspace: workspace,
+                       api_client: @runner.api_client, on_debug: @on_debug).resolve_name_or_bot(user_id) || user_id
+      end
+
+      # Same meta key the sent and who commands use, so one auth.test serves all.
+      def self_user_id(workspace)
+        @self_ids.fetch(workspace.name) do
+          @self_ids[workspace.name] = @runner.cache_store.get_meta(workspace.name, 'self_user_id') ||
+                                      fetch_self_user_id(workspace)
+        end
+      end
+
+      def fetch_self_user_id(workspace)
+        id = @runner.client_api(workspace.name).auth_test['user_id']
+        @runner.cache_store.set_meta(workspace.name, 'self_user_id', id) if id
+        id
+      rescue ApiError => e
+        @on_debug&.call("Could not identify self in #{workspace.name}: #{e.message}")
+        nil
+      end
+    end
+  end
+end

data/lib/slk/services/huddle_channel_label.rb

@@ -38,11 +38,19 @@ module Slk
 
       def label_from(workspace, channel_id, channel)
         return 'DM' if channel['is_im']
-        return 'group DM' if channel['is_mpim']
+        return group_label(channel) if channel['is_mpim']
 
         named_label(workspace, channel_id, channel['name'])
       end
 
+      # A named group DM shows its name but stays out of the channel cache:
+      # the name can be changed at any time and can match a real channel's
+      # name, and the cache maps names to ids, so `#name` would go to the chat.
+      def group_label(channel)
+        name = Support::GroupDmName.custom(channel)
+        name ? "##{name}" : 'group DM'
+      end
+
       def named_label(workspace, channel_id, name)
         return nil if name.to_s.empty?
 

data/lib/slk/services/sent_channel_label.rb

@@ -5,6 +5,7 @@ module Slk
     # Resolves sent-conversation destinations while retaining raw channel IDs
     # and names in JSON. Group DMs need member lookup: their Slack name is an
     # opaque mpdm-* slug, not a user ID that MentionReplacer can resolve.
+    # Named group DMs ("named chats") skip that and show as #name.
     class SentChannelLabel
       USER_ID_PATTERN = /\A[UW][A-Z0-9]+\z/
 
@@ -28,6 +29,9 @@ module Slk
       private
 
       def group_label(workspace, channel_id, name, self_user_id, self_username)
+        named = Support::GroupDmName.label(name)
+        return named if named
+
         names = group_member_names(workspace, channel_id, self_user_id)
         return "@#{names.join(', ')}" if names.any?
 

data/lib/slk/services/target_resolver.rb

@@ -66,19 +66,8 @@ module Slk
       end
 
       def resolve_channel(workspace, name)
-        cached = @cache.get_channel_id(workspace.name, name)
-        return cached if cached
-
-        fetch_and_cache_channel(workspace, name)
-      end
-
-      def fetch_and_cache_channel(workspace, name)
-        channels = @runner.conversations_api(workspace.name).list['channels'] || []
-        channel = channels.find { |c| c['name'] == name }
-        raise ConfigError, "Channel not found: ##{name}" unless channel
-
-        @cache.set_channel(workspace.name, name, channel['id'])
-        channel['id']
+        ChannelLookup.new(runner: @runner, cache_store: @cache).find_id(workspace, name) ||
+          raise(ConfigError, "Channel not found: ##{name}")
       end
 
       def resolve_dm(workspace, username)

data/lib/slk/services/unread_marker.rb

@@ -14,13 +14,15 @@ module Slk
 
       # Mark all unreads in a workspace, return counts
       # @param options [Hash] :muted - include muted channels
-      # @return [Hash] { dms: count, channels: count, threads: count }
+      # @return [Hash] { dms: count, group_dms: count, channels: count, threads: count }
       def mark_all(options: {})
         counts = @client.counts
+        muted_ids = options[:muted] ? [] : @users.muted_channels
 
         {
           dms: mark_dms(counts['ims'] || []),
-          channels: mark_channels(counts['channels'] || [], muted: options[:muted]),
+          group_dms: mark_channels(counts['mpims'] || [], muted_ids),
+          channels: mark_channels(counts['channels'] || [], muted_ids),
           threads: mark_threads
         }
       end
@@ -44,13 +46,14 @@ module Slk
         count
       end
 
-      def mark_channels(channels, muted: false)
-        muted_ids = muted ? [] : @users.muted_channels
+      # Channels and group DMs (client.counts `mpims`): a muted group DM is
+      # skipped the same way a muted channel is.
+      def mark_channels(channels, muted_ids)
         count = 0
 
         channels.each do |channel|
           next unless channel['has_unreads']
-          next if !muted && muted_ids.include?(channel['id'])
+          next if muted_ids.include?(channel['id'])
 
           count += 1 if mark_conversation(channel['id'])
         end

data/lib/slk/support/group_dm_name.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Slk
+  module Support
+    # Group DMs can be given a name in Slack ("named chats"). They are still
+    # mpims, but `name` holds what the user typed ("ifams review") rather
+    # than the generated mpdm-alice--bob-1 slug. conversations.info flags them
+    # with properties.has_custom_mpdm_name; search.messages sends no
+    # properties, so a name that isn't an mpdm-* slug counts as custom too.
+    module GroupDmName
+      SLUG = /\Ampdm-/
+
+      module_function
+
+      # @param channel [Hash] conversation payload from Slack
+      # @return [String, nil] the custom name, or nil for anything else
+      def custom(channel)
+        return nil unless channel.is_a?(Hash) && channel['is_mpim']
+
+        name = channel['name'].to_s
+        return nil if name.empty?
+        return name if channel.dig('properties', 'has_custom_mpdm_name')
+
+        custom_name?(name) ? name : nil
+      end
+
+      # @param name [String, nil] a group DM's Slack name
+      # @return [Boolean] true when the name was set by a person
+      def custom_name?(name)
+        !name.to_s.empty? && !name.to_s.match?(SLUG)
+      end
+
+      # @return [String, nil] "#name" for a named group DM, else nil
+      def label(name)
+        "##{name}" if custom_name?(name)
+      end
+    end
+  end
+end

data/lib/slk/support/user_resolver.rb

@@ -68,6 +68,8 @@ module Slk
       public
 
       # Resolves a channel ID to a formatted label (@username or #channel)
+      # Group DMs get "#name" when named, else "@other, members", never the
+      # mpdm-* slug that other lookups may have put in the channel cache.
       # @param workspace [Models::Workspace] The workspace to look up in
       # @param channel_id [String] The channel ID
       # @return [String] Formatted label like "@username" or "#channel"
@@ -97,8 +99,11 @@ module Slk
       end
 
       def resolve_channel_label(workspace, channel_id)
+        known = group_dm_label.known(workspace, channel_id)
+        return known if known
+
         cached_name = cache_store.get_channel_name(workspace.name, channel_id)
-        return "##{cached_name}" if cached_name
+        return "##{cached_name}" if cached_name && !cached_name.match?(Support::GroupDmName::SLUG)
 
         fetch_channel_label(workspace, channel_id)
       end
@@ -108,16 +113,27 @@ module Slk
         response = conversations.info(channel: channel_id)
         return "##{channel_id}" unless response['ok'] && response['channel']
 
-        name = response['channel']['name']
-        return "##{channel_id}" unless name
+        channel = response['channel']
+        return group_dm_label.label_from(workspace, channel_id, channel) if channel['is_mpim']
 
-        cache_store.set_channel(workspace.name, name, channel_id)
-        "##{name}"
+        named_channel_label(workspace, channel_id, channel['name'])
       rescue ApiError => e
         debug("Channel info lookup failed for #{channel_id}: #{e.message}")
         "##{channel_id}"
       end
 
+      def named_channel_label(workspace, channel_id, name)
+        return "##{channel_id}" unless name
+
+        cache_store.set_channel(workspace.name, name, channel_id)
+        "##{name}"
+      end
+
+      # One per command run, so a group DM is looked up once for all headers.
+      def group_dm_label
+        @group_dm_label ||= Services::GroupDmLabel.new(runner: runner, on_debug: ->(msg) { debug(msg) })
+      end
+
       def name_from_user_profile(msg)
         return nil unless msg['user_profile']
 

data/lib/slk/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Slk
-  VERSION = '0.14.0'
+  VERSION = '0.15.0'
 end

data/lib/slk.rb

@@ -125,6 +125,8 @@ module Slk
     autoload :HuddleState, 'slk/services/huddle_state'
     autoload :WorkspaceFanout, 'slk/services/workspace_fanout'
     autoload :HuddleChannelLabel, 'slk/services/huddle_channel_label'
+    autoload :GroupDmLabel, 'slk/services/group_dm_label'
+    autoload :ChannelLookup, 'slk/services/channel_lookup'
     autoload :ThreadSubscription, 'slk/services/thread_subscription'
   end
 
@@ -209,6 +211,7 @@ module Slk
     autoload :HelpFormatter, 'slk/support/help_formatter'
     autoload :ErrorLogger, 'slk/support/error_logger'
     autoload :UserResolver, 'slk/support/user_resolver'
+    autoload :GroupDmName, 'slk/support/group_dm_name'
     autoload :TextWrapper, 'slk/support/text_wrapper'
     autoload :InteractivePrompt, 'slk/support/interactive_prompt'
     autoload :DateParser, 'slk/support/date_parser'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: slk
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.15.0
 platform: ruby
 authors:
 - Eric Boehs
@@ -109,6 +109,7 @@ files:
 - lib/slk/services/activity_enricher.rb
 - lib/slk/services/api_client.rb
 - lib/slk/services/cache_store.rb
+- lib/slk/services/channel_lookup.rb
 - lib/slk/services/configuration.rb
 - lib/slk/services/deactivation_scanner.rb
 - lib/slk/services/emoji_downloader.rb
@@ -116,6 +117,7 @@ files:
 - lib/slk/services/encryption.rb
 - lib/slk/services/file_downloader.rb
 - lib/slk/services/gemoji_sync.rb
+- lib/slk/services/group_dm_label.rb
 - lib/slk/services/huddle_channel_label.rb
 - lib/slk/services/huddle_fetch.rb
 - lib/slk/services/huddle_scanner.rb
@@ -149,6 +151,7 @@ files:
 - lib/slk/support/date_parser.rb
 - lib/slk/support/decimal_timestamp.rb
 - lib/slk/support/error_logger.rb
+- lib/slk/support/group_dm_name.rb
 - lib/slk/support/help_formatter.rb
 - lib/slk/support/image_preview.rb
 - lib/slk/support/inline_images.rb