slk 0.13.0 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cbd57363408aa79edfa6cbbe3e875034d2fbcb9e3c2a7ec8ea1e9acea30c9167
-  data.tar.gz: bf9ab8b668ad9d04191ddb9b63a1c502d3652059c3b5bbc16113dff1d94eb8bc
+  metadata.gz: '080abcf262e2c943cb01e3fe6fc5619ee0921d93d4418deeb5f42d6fc4154a92'
+  data.tar.gz: 762989ed0de46ef13372d550a80517bf2c3c7ce73eaf916c8d78fafd5d6e6f57
 SHA512:
-  metadata.gz: 71d05dc4a9f5b46c49e5a14cad5c5e9b79042ece234142bb16f53dde80da67a5beafd1a2af0f30ef33b2bb8ef5381d64393979e640c996810bb536005e9a8180
-  data.tar.gz: 49956b5f79adb5e03f4bac033109626a315f9a1326904e321d4dcf2e17d189d7ac500bb820e2dab52199243d916c204b6ecef94b0c445c8287d591bdd1bfaa20
+  metadata.gz: bc5bc2aafe45a6ab8a20fac51086e426d2586012be06b82d87fa3560597386b6d0a504a1489b8b75cf9af5c00627dd7b10a2714af8479fee37202408963e10b8
+  data.tar.gz: a835b18a0a8155c73d2618fa484393dcfaf9b11fbbd0583530209b810e0cadd09ddf45fa5618c54a75f9581dfd0a165d35257cd6faa0add128c08a51d03b0047

data/CHANGELOG.md

@@ -7,6 +7,34 @@ 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
+
+- `slk huddles` lists active huddles. Slack has no huddle list, so it reads `huddle_state` from `users.list` and groups people who share a `huddle_state_call_id`. Channel names are filled in when Slack sends a channel id. Primary workspace by default; `--all` scans every workspace at the same time, each on its own connection, and drops people who are not in a huddle as each page arrives. `--json` prints the call id, channel, and participants.
+- Slack API responses are requested gzip-compressed. A `users.list` page is the bulk of a huddle scan, and compression is the difference between a large JSON document and a fraction of that on the wire.
+- `slk who` shows huddle state. The profile cache is an hour old, so the state is read live from `users.info` and the cached copy is ignored. `default_unset` is omitted. A channel name is added when Slack sends a channel id.
+
 ## [0.13.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
@@ -220,6 +223,24 @@ slk cache populate        # Pre-populate user cache
 slk cache clear           # Clear all caches
 ```
 
+### Huddles
+
+```bash
+slk huddles            # Active huddles on the primary workspace
+slk huddles --all      # Every workspace
+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
+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`
+shows the same state on the profile card, read live so the hour-long profile
+cache cannot leave someone in a huddle they have already left.
+
 ### Deactivations
 
 ```bash

data/lib/slk/api/users.rb

@@ -68,13 +68,25 @@ module Slk
       # total after each page, for progress and debug output.
       def list_all(limit: 1000, &progress)
         members = []
+        list_each(limit: limit) do |page, total|
+          members.concat(page)
+          progress&.call(total)
+        end
+        members
+      end
+
+      # Yields each page and the running total, then drops the page. A caller
+      # that only wants a few members should not have to retain the roster.
+      def list_each(limit: 1000)
         cursor = nil
+        total = 0
         loop do
           response = list(cursor: cursor, limit: limit)
-          members.concat(response['members'] || [])
-          progress&.call(members.size)
+          page = response['members'] || []
+          total += page.size
+          yield page, total
           cursor = next_cursor(response, cursor)
-          break members unless cursor
+          break unless cursor
         end
       end
 
@@ -131,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/cli.rb

@@ -24,6 +24,7 @@ module Slk
       'help' => Commands::Help,
       'debug' => Commands::Debug,
       'who' => Commands::Who,
+      'huddles' => Commands::Huddles,
       'org' => Commands::Org,
       'deactivations' => Commands::Deactivations
     }.freeze

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

@@ -18,6 +18,7 @@ module Slk
         ['activity', 'Show activity feed (reactions, mentions, threads)'],
         ['later', 'Show saved "Later" items'],
         ['who', 'Show a user profile'],
+        ['huddles', 'List active huddles'],
         ['deactivations', 'Show who left the workspace, and when'],
         ['preset', 'Manage and apply status presets'],
         ['workspaces', 'Manage Slack workspaces'],

data/lib/slk/commands/huddles.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative '../support/help_formatter'
+
+module Slk
+  module Commands
+    # List active huddles by grouping users.list profiles that share a call id.
+    class Huddles < Base
+      def execute
+        result = validate_options
+        return result if result
+        return unexpected_argument if positional_args.any?
+
+        emit(Services::HuddleFetch.new(runner: runner, output: output).call(target_workspaces))
+        0
+      rescue ApiError => e
+        error("API error: #{e.message}")
+      end
+
+      protected
+
+      def help_text
+        help = Support::HelpFormatter.new('slk huddles [options]')
+        help.description('List active huddles.')
+        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.')
+        add_options_section(help)
+        add_examples_section(help)
+        help.render
+      end
+
+      private
+
+      def add_options_section(help)
+        help.section('OPTIONS') do |section|
+          section.option('-w, --workspace NAME', 'Limit to one workspace')
+          section.option('--all', 'Scan every workspace')
+          section.option('--json', 'Call id, channel, and participants')
+        end
+      end
+
+      def add_examples_section(help)
+        help.section('EXAMPLES') do |section|
+          section.example('slk huddles', 'Active huddles on the primary workspace')
+          section.example('slk huddles --all', 'Every configured workspace')
+          section.example('slk huddles --json', 'Machine-readable')
+        end
+      end
+
+      def unexpected_argument
+        error("Unexpected argument: #{positional_args.first}.")
+        1
+      end
+
+      def emit(reports)
+        return output_json(json_documents(reports)) if @options[:json]
+        return if @options[:quiet]
+
+        Formatters::HuddleFormatter.new(output).render(reports, scope: single_workspace_scope(reports))
+      end
+
+      # A primary-only scan is easy to read as "nobody, anywhere" when other
+      # workspaces are configured. Name the one that was actually checked.
+      def single_workspace_scope(reports)
+        return nil unless reports.one?
+        return nil if runner.all_workspaces.size <= 1
+
+        reports.first.workspace
+      end
+
+      # One workspace prints its document alone; several are keyed by name,
+      # matching `slk unread --json`, so the output pipes straight into jq.
+      def json_documents(reports)
+        documents = reports.to_h { |report| [report.workspace, document(report)] }
+        reports.one? ? documents.values.first : documents
+      end
+
+      def document(report)
+        { huddles: report.huddles.map { |huddle| huddle_json(huddle) } }
+      end
+
+      def huddle_json(huddle)
+        {
+          call_id: huddle.call_id,
+          channel_id: huddle.channel_id,
+          channel: huddle.channel,
+          participants: huddle.participants.map { |person| { id: person.id, name: person.name } }
+        }
+      end
+    end
+  end
+end

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

@@ -44,6 +44,8 @@ module Slk
             @handle | name   Resolved via user cache
             Uxxx             Raw user ID
 
+          Huddle state is read live and shown when Slack has one set.
+
           OPTIONS
             --full           Section-grouped layout (Contact, People, About me)
             --json           Raw JSON output
@@ -79,8 +81,26 @@ module Slk
       end
 
       def load_profile(workspace, user_id)
-        runner.profile_resolver(workspace.name, refresh: @options[:refresh])
-              .resolve_with_people(user_id)
+        profile = runner.profile_resolver(workspace.name, refresh: @options[:refresh])
+                        .resolve_with_people(user_id)
+        attach_huddle_channel(workspace, profile)
+      end
+
+      # 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?
+
+        label = huddle_channels.label(workspace, profile.huddle_channel_id)
+        return profile unless label
+
+        Models::Profile.new(**profile.to_h, huddle_channel: label)
+      end
+
+      def huddle_channels
+        @huddle_channels ||= Services::HuddleChannelLabel.new(
+          runner: runner, cache_store: cache_store, on_debug: ->(message) { debug(message) }
+        )
       end
 
       def render_profiles(profiles)

data/lib/slk/formatters/huddle_formatter.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Slk
+  module Formatters
+    # Text for `slk huddles`. A huddle Slack did not attach to a channel is
+    # the names plus "channel unknown", not a guessed conversation.
+    class HuddleFormatter
+      def initialize(output)
+        @output = output
+      end
+
+      def render(reports, scope: nil)
+        reports.each_with_index do |report, index|
+          @output.puts if index.positive?
+          render_report(report, header: reports.size > 1, scope: reports.one? ? scope : nil)
+        end
+      end
+
+      private
+
+      def render_report(report, header:, scope:)
+        @output.puts(@output.bold(report.workspace)) if header
+        @output.puts(summary(report.huddles, scope))
+        report.huddles.each { |huddle| render_huddle(huddle) }
+      end
+
+      def summary(huddles, scope)
+        return "#{with_scope('No active huddles', scope)}." if huddles.empty?
+
+        noun = huddles.one? ? 'huddle' : 'huddles'
+        with_scope("#{huddles.size} active #{noun}", scope)
+      end
+
+      def with_scope(text, scope)
+        scope ? "#{text} on #{scope}" : text
+      end
+
+      def render_huddle(huddle)
+        @output.puts
+        huddle.place ? render_placed(huddle) : render_unplaced(huddle)
+      end
+
+      def render_placed(huddle)
+        @output.puts(@output.bold(huddle.place))
+        huddle.participants.each { |person| @output.puts("  #{person.name}") }
+      end
+
+      def render_unplaced(huddle)
+        @output.puts(huddle.participants.map(&:name).join(', '))
+        @output.puts("  #{@output.gray('channel unknown')}")
+      end
+    end
+  end
+end

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