slk 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eec8154512ee9815597065ac68471bfd2ad55535191d4057e55ae4d942f15f66
-  data.tar.gz: 3fe2bdbe0fa65ce0b0ee4a529531a38c59f78c674eed08f22d5d40b833b79150
+  metadata.gz: c7db83e915de4b86bafd0cc62e8a67fdaee0dcd9209cb94a1f8fd6a5a2704c46
+  data.tar.gz: eb25d2aafaa23a51016e64c2f5eb40c0117aeacb829d784caff9a50078946992
 SHA512:
-  metadata.gz: e9a595db19f0748ccb42a4ec436dffa0fe4bbb4d1fbff0514f659cee09a8fb1db2c5258cdd7e74252972c2029e63de0082a2cadf33d96f98dff1681717680e88
-  data.tar.gz: 0e33aa2ec6319fe88433dffe30865d0c17306da34cf136aebd1e9b17e9bb42d9bc5447748914751a74e48f43883bfe3cc404fb657cfaf33c2abdf7db369d2e9a
+  metadata.gz: 2d928dbf2906c22dc3ad108503c6ef4bfaeb68c29c0ed562dcd27e3515cf1468df426801dc6f7e73a3c2f9bb47d79fd7bf90054b3a9fc424453a35e8f60fd75d
+  data.tar.gz: 93850e6e114cd1634ce2546631b1c370eb94731ff284eb29c05c458a533f16fb1229afde2ca27f60e6ea2e00d12828d6db17342f1d336350cc59d5ae788cc1bb

data/CHANGELOG.md

@@ -5,6 +5,30 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+## [0.11.0] - 2026-09-23
+
+### Changed
+
+- `slk sent` now expands your sent-message search hits into conversations: full paginated threads and DMs, merged channel windows (5 messages before and 30 minutes after your posts), and replies to your top-level posts. It groups by conversation and caps displayed messages with `--max` (default 200, `0` for all). `--before` and `--after-minutes` tune channel windows. `--mine` keeps the previous flat timeline and JSON shape.
+- `slk sent --json` now returns `{date, range, conversations}`. Each conversation includes its workspace, channel, type, thread timestamp, `last_speaker_is_me`, `dropped_messages`, and chronological messages with sender, name, text, and `mine`. `channel_name` remains Slack's raw value; `channel_label` is the resolved display label for DMs and channels. The sender-only format remains available through `--mine --json`, with `channel_label` added to counts.
+
+- `slk sent` text now wraps to the interactive terminal's width (or `--width N`), with indented reply and context continuations; `--no-wrap` disables wrapping. The redundant `▶` marker on your own messages and the last-speaker status lines are gone from text output; JSON still includes `last_speaker_is_me`. Thread headings now show the thread ID instead of repeating the parent message; channel and DM headings keep their readable names. A thin divider separates conversations without splitting context from new messages. Orphaned replies put their parent reference on a separate line so long thread IDs do not steal the message's wrap width.
+
+### Added
+
+- `slk sent --changed-since TIME` shows a stateless diff of conversations you participated in over `--lookback DAYS` (default 7). TIME accepts local `H:MM` or `HH:MM`, ISO datetime, Slack epoch/ts, or `90m`/`2h`/`1d`; clock times use the latest local occurrence (yesterday when that time has not arrived today). Search discovers conversations, but exact-timestamp history and replies determine what changed: old threads and DMs with new replies appear even when you did not post today. Channel chatter alone does not count; channel windows are fetched only for your own new top-level posts. Changed output orders conversations by latest activity, newest at the bottom, and includes up to `--context N` earlier messages (default 2). Text marks older context with `·` without a separate cutoff divider; JSON labels each new message. JSON adds `changed_since: {iso, ts}`, `lookback_days`, per-conversation `new_count` and `new_from_others`, and per-message `new`, retaining the flat, timestamp-sorted `thread_ts` contract. Thread subscriptions contribute unread followed threads when available. A paginated history scan per watched channel identifies active thread roots from Slack's `latest_reply` (rather than probing every root); quiet DMs use a one-message history probe. Edits/reactions do not change message timestamps; conversations you never posted in and very recent posts missing from Slack's search index remain blind spots.
+- `slk sent [today|yesterday|YYYY-MM-DD]` finds conversations you posted in, across workspaces by default. `--since YYYY-MM-DD` searches through today, `-w` selects a workspace, and `--mine` shows only your indexed messages in a flat chronological timeline with per-channel counts. Slack's index can lag, excludes deleted messages, and uses your profile timezone for date operators; DM history bounds use your local timezone.
+
+### Fixed
+
+- `slk sent` now orders conversations with exact Slack timestamps and workspace/channel/thread tie-breakers, so identical start times stay deterministic across platforms.
+- `slk sent --changed-since` no longer silently omits followed threads when their lookup fails due to network, rate-limit, authentication, or malformed-response errors. Unsupported or unauthorized-to-use subscription views still fall back to search-derived conversations. Sender lookup caches the authenticated user ID and reports a workspace-specific API error if Slack omits it. Deleted threads are recognized by Slack's error code, not message text, and invalid-time errors are limited to actual input conversions. Text wrapping falls back to 72 columns if a terminal cannot report its width.
+- `slk sent` now includes the first post of each channel window in Slack history (and expands its replies), displays DM names even for threads, resolves group-DM participants, and shows file-only thread parents through file labels. Expanded replies now appear nested beneath their parent in text output, while JSON remains flat and timestamp-sorted with `thread_ts` links.
+- Attachment and unfurl preview titles, authors, text, and image labels now decode HTML entities like message bodies.
+- `slk search --all` now searches every workspace and tags each result. Search paginates past Slack's 100-result page size when `-n` requests more, and warns when the requested limit cuts off matches.
+
 ## [0.10.0] - 2026-09-18
 
 ### Added

data/lib/slk/api/conversations.rb

@@ -15,17 +15,21 @@ module Slk
         @api.post(@workspace, 'conversations.list', params)
       end
 
-      def history(channel:, limit: 20, cursor: nil, oldest: nil, latest: nil)
+      # rubocop:disable Metrics/ParameterLists
+      def history(channel:, limit: 20, cursor: nil, oldest: nil, latest: nil, inclusive: false)
         params = { channel: channel, limit: limit }
         params[:cursor] = cursor if cursor
         params[:oldest] = oldest if oldest
         params[:latest] = latest if latest
+        params[:inclusive] = true if inclusive
         @api.post(@workspace, 'conversations.history', params)
       end
+      # rubocop:enable Metrics/ParameterLists
 
-      def replies(channel:, timestamp:, limit: 100, cursor: nil)
+      def replies(channel:, timestamp:, limit: 100, cursor: nil, oldest: nil)
         params = { channel: channel, ts: timestamp, limit: limit }
         params[:cursor] = cursor if cursor
+        params[:oldest] = oldest if oldest
         # Use form encoding - some workspaces (Enterprise Grid) require it
         @api.post_form(@workspace, 'conversations.replies', params)
       end

data/lib/slk/cli.rb

@@ -15,6 +15,7 @@ module Slk
       'activity' => Commands::Activity,
       'later' => Commands::Later,
       'search' => Commands::Search,
+      'sent' => Commands::Sent,
       'preset' => Commands::Preset,
       'workspaces' => Commands::Workspaces,
       'cache' => Commands::Cache,

data/lib/slk/commands/help.rb

@@ -12,6 +12,7 @@ module Slk
         ['dnd', 'Manage Do Not Disturb'],
         ['messages', 'Read channel or DM messages'],
         ['search', 'Search messages across channels'],
+        ['sent', 'Show your sent messages across workspaces'],
         ['unread', 'View and clear unread messages'],
         ['activity', 'Show activity feed (reactions, mentions, threads)'],
         ['later', 'Show saved "Later" items'],
@@ -84,6 +85,7 @@ module Slk
             slk status schedule "Vet" 1p-3p  Schedule a status (am/pm or 24h)
             slk dnd 1h                       Enable DND for 1 hour
             slk messages #general            Read channel messages
+            slk sent                         Show messages you sent today
             slk preset meeting               Apply preset
         EXAMPLES
       end

data/lib/slk/commands/search.rb

@@ -41,8 +41,8 @@ module Slk
       # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/AbcSize
       def handle_option(arg, args, remaining)
         case arg
-        when '-n', '--limit' then @options[:limit] = require_value(arg, args).to_i
-        when '--page' then @options[:page] = require_value(arg, args).to_i
+        when '-n', '--limit' then @options[:limit] = positive_integer(arg, args)
+        when '--page' then @options[:page] = positive_integer(arg, args)
         when '--in' then @options[:in_channel] = require_value(arg, args)
         when '--from' then @options[:from_user] = require_value(arg, args)
         when '--after' then @options[:after_date] = require_value(arg, args)
@@ -56,11 +56,19 @@ module Slk
 
       def require_value(option, args)
         value = args.shift
-        raise ArgumentError, "#{option} requires a value" unless value
+        raise ArgumentError, "#{option} requires a value" unless value && !value.start_with?('-')
 
         value
       end
 
+      def positive_integer(option, args)
+        value = require_value(option, args)
+        number = Integer(value, exception: false)
+        raise ArgumentError, "#{option} expects a positive integer" unless number&.positive?
+
+        number
+      end
+
       def help_text
         help = Support::HelpFormatter.new('slk search <query> [options]')
         help.description('Search messages across channels and DMs.')
@@ -84,11 +92,12 @@ module Slk
 
       def add_options_section(help)
         help.section('OPTIONS') do |s|
-          s.option('-n, --limit N', 'Number of results (default: 20, max: 100)')
-          s.option('--page N', 'Page number for pagination')
+          s.option('-n, --limit N', 'Results per workspace (default: 20; paginates past 100)')
+          s.option('--page N', 'Starting page in each workspace')
           s.option('--threads', 'Show thread replies inline')
           s.option('--json', 'Output as JSON')
-          s.option('-w, --workspace', 'Specify workspace')
+          s.option('-w, --workspace NAME', 'Specify workspace')
+          s.option('--all', 'Search every workspace (results tagged by workspace)')
           s.option('-v, --verbose', 'Show debug information')
           s.option('-q, --quiet', 'Suppress output')
         end
@@ -110,23 +119,19 @@ module Slk
         1
       end
 
-      # rubocop:disable Metrics/MethodLength
       def search_and_display(query)
-        workspace = target_workspaces.first
-        full_query = build_query(query)
+        raise ArgumentError, 'Use either --all or --workspace, not both' if @options[:all] && @options[:workspace]
 
+        full_query = build_query(query)
         debug("Searching: #{full_query}")
-        response = runner.search_api(workspace.name).messages(
-          query: full_query,
-          count: @options[:limit],
-          page: @options[:page]
-        )
-
-        results = parse_results(response)
-        display_results(results, workspace, response)
+        searches = target_workspaces.map do |workspace|
+          [workspace, Services::SearchPages.new(runner.search_api(workspace.name)).fetch(
+            query: full_query, limit: @options[:limit], page: @options[:page]
+          )]
+        end
+        display_results(searches)
         0
       end
-      # rubocop:enable Metrics/MethodLength
 
       def build_query(base_query)
         parts = [base_query]
@@ -138,47 +143,50 @@ module Slk
         parts.join(' ')
       end
 
-      def parse_results(response)
-        matches = response.dig('messages', 'matches') || []
-        matches.map { |m| Models::SearchResult.from_api(m) }
-      end
-
-      def display_results(results, workspace, response)
+      def display_results(searches)
         if @options[:json]
-          output_json_results(results, response)
+          output_json_results(searches)
         else
-          display_text_results(results, workspace, response)
+          display_text_results(searches)
         end
       end
 
-      def output_json_results(results, response)
-        pagination = response.dig('messages', 'pagination') || {}
-        output_json({
-                      results: results.map(&:to_h),
-                      pagination: {
-                        page: pagination['page'],
-                        page_count: pagination['page_count'],
-                        total_count: pagination['total_count']
-                      }
-                    })
+      def output_json_results(searches)
+        results = searches.flat_map do |workspace, data|
+          data[:results].map { |result| result.to_h.merge(workspace: workspace.name) }
+        end
+        output_json(results: results, pagination: json_pagination(searches))
       end
 
-      def display_text_results(results, workspace, response)
-        show_pagination_info(response) if @options[:verbose]
-
-        if results.empty?
-          puts 'No results found.'
-          return
+      def json_pagination(searches)
+        pages = searches.to_h do |workspace, data|
+          [workspace.name, data[:pagination].merge('truncated' => data[:truncated] == true)]
         end
+        searches.length == 1 ? pages.values.first : pages
+      end
 
-        results.each_with_index do |result, index|
+      def display_text_results(searches)
+        searches.each { |workspace, data| report_search(workspace, data) }
+        entries = searches.flat_map { |workspace, data| data[:results].map { |result| [result, workspace] } }
+        return puts 'No results found.' if entries.empty?
+
+        entries.each_with_index do |(result, workspace), index|
           display_single_result(result, workspace)
-          puts if index < results.length - 1
+          puts if index < entries.length - 1
         end
       end
 
+      def report_search(workspace, data)
+        show_pagination_info(data[:pagination], workspace) if @options[:verbose]
+        return unless data[:truncated]
+
+        total = data[:pagination]['total_count']
+        quantity = total ? "#{data[:results].length} of #{total}" : data[:results].length.to_s
+        warn("#{workspace.name}: Showing #{quantity} matches; raise -n for more.")
+      end
+
       def display_single_result(result, workspace)
-        runner.search_formatter.display_result(result, workspace, format_options)
+        runner.search_formatter.display_result(result, workspace, format_options.merge(workspace_label: @options[:all]))
         show_thread_replies(result, workspace) if should_show_thread?(result)
       end
 
@@ -209,13 +217,12 @@ module Slk
         lines[1..].each { |line| puts "    #{line}" }
       end
 
-      def show_pagination_info(response)
-        pagination = response.dig('messages', 'pagination') || {}
+      def show_pagination_info(pagination, workspace)
         total = pagination['total_count'] || 0
         page = pagination['page'] || 1
         page_count = pagination['page_count'] || 1
 
-        debug("Page #{page}/#{page_count} (#{total} total results)")
+        debug("#{workspace.name}: Page #{page}/#{page_count} (#{total} total results)")
       end
     end
     # rubocop:enable Metrics/ClassLength

data/lib/slk/commands/sent.rb

@@ -0,0 +1,288 @@
+# frozen_string_literal: true
+
+module Slk
+  module Commands
+    # All indexed messages sent by the authenticated user on a date/range.
+    # rubocop:disable Metrics/ClassLength
+    class Sent < Base
+      def execute
+        result = validate_options
+        return result if result
+
+        run_sent
+      rescue ApiError => e
+        error("Sent search failed: #{e.message}")
+        1
+      end
+
+      protected
+
+      def default_options
+        super.merge(since: nil, mine: false, changed_since: nil, lookback: 7, context: 2,
+                    before: Services::SentConversations::DEFAULT_BEFORE,
+                    after_minutes: Services::SentConversations::DEFAULT_AFTER_MINUTES,
+                    max: Services::SentConversations::DEFAULT_MAX)
+      end
+
+      def default_width
+        return nil unless $stdout.tty?
+
+        columns = IO.console&.winsize&.last
+        columns&.positive? ? columns : super
+      rescue SystemCallError, IOError, NotImplementedError
+        super
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+      def handle_option(arg, args, remaining)
+        case arg
+        when '--since' then @options[:since] = option_value(arg, args)
+        when '--changed-since' then @options[:changed_since] = option_value(arg, args)
+        when '--lookback' then @options[:lookback] = positive_integer(arg, args)
+        when '--context' then @options[:context] = nonnegative_integer(arg, args)
+        when '--mine' then @options[:mine] = true
+        when '--before' then @options[:before] = before_limit(arg, args)
+        when '--after-minutes' then @options[:after_minutes] = nonnegative_integer(arg, args)
+        when '--max' then @options[:max] = nonnegative_integer(arg, args)
+        else super
+        end
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+
+      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      def help_text
+        help = Support::HelpFormatter.new('slk sent [today|yesterday|YYYY-MM-DD] [options]')
+        help.description('Catch up on conversations you posted in, across all workspaces.')
+        help.note('Search is indexed: very recent and deleted messages may be missing.')
+        help.note('Dates/DM history bounds use your local clock; Slack search uses your profile timezone.')
+        help.note('Long --since ranges can be slow (search is rate-limited; 429s retry once).')
+        help.note('Conversations you only read or were mentioned in but never posted in are out of scope.')
+        help.note('A future --mentions flag could seed mentioned conversations via to:me search.')
+        help.note('JSON: {date, range, conversations:[{workspace, channel_id, channel_name, channel_label, type,')
+        help.note('thread_ts, last_speaker_is_me, dropped_messages, messages:[{ts, user,')
+        help.note('user_name, text, mine, thread_ts}]}]}; --mine keeps counts/results JSON,')
+        help.note('with channel_label added to counts. channel_name remains the raw Slack name.')
+        help.note('JSON messages stay flat and timestamp-sorted; thread_ts links replies to their parent.')
+        help.note('Text output nests expanded replies under their parent, even when sent later, and wraps')
+        help.note('to the terminal width on a TTY. Use --width N to override or --no-wrap to disable.')
+        help.note('Thread headings show the thread ID; channel and DM headings keep their readable names.')
+        help.note('A thin divider separates conversations, not messages within a conversation.')
+        help.note('For --changed-since, H:MM or HH:MM means the most recent local occurrence: if that time has not')
+        help.note('arrived today, it means yesterday. Dated timestamps in the future are rejected.')
+        help.note('--changed-since is stateless: exact-ts history/replies detect new messages; search only finds')
+        help.note('the watch set. Edits/reactions do not change ts and are invisible. Search index lag may')
+        help.note('omit posts from the last few minutes. Conversations you never posted in remain out of scope.')
+        help.note('Unread followed threads supplement the watch set when available; --lookback must include')
+        help.note('the days you posted in any other threads you want to watch.')
+        help.note('Changed text marks earlier context with · and puts the most recently active conversation last.')
+        help.note('A wide lookback checks many thread roots and can take minutes under Slack rate limits.')
+        help.note('Changed JSON adds changed_since:{iso, ts}, lookback_days, new_count, new_from_others,')
+        help.note('and per-message new. Its messages stay flat and timestamp-sorted with thread_ts links.')
+        help.section('OPTIONS') do |s|
+          s.option('--since YYYY-MM-DD', 'From this date through today (inclusive)')
+          s.option('--changed-since TIME', 'Only changed conversations (H:MM/HH:MM, ISO, epoch, 90m, 2h, 1d)')
+          s.option('--lookback DAYS', 'Days of sent messages to watch (default: 7; changed mode)')
+          s.option('--context N', 'Earlier messages per changed conversation (default: 2)')
+          s.option('--mine', 'Only your messages, flat timeline with counts (previous behavior)')
+          s.option('--before N', 'Channel messages before a window (default: 5, max: 200)')
+          s.option('--after-minutes N', 'Channel window after each post (default: 30)')
+          s.option('--max N', 'Messages per conversation (default: 200; 0 for all)')
+          s.option('-w, --workspace NAME', 'Search one workspace instead of all')
+          s.option('--all', 'Search all workspaces (default)')
+          s.option('--json', 'Output conversations as JSON (or counts/results with --mine)')
+          s.option('--width N', 'Wrap text at N columns (default: terminal width on TTY)')
+          s.option('--no-wrap', 'Disable text wrapping')
+        end
+        help.section('EXAMPLES') do |s|
+          s.example('slk sent', 'Today in all workspaces')
+          s.example('slk sent yesterday', 'Yesterday in all workspaces')
+          s.example('slk sent 2026-09-19', 'One specific day')
+          s.example('slk sent --since 2026-09-15', 'From Sep 15 through today')
+          s.example('slk sent --mine --json', 'Only your sent messages, flat JSON')
+          s.example('slk sent --changed-since 15:17 --lookback 3', 'Diff watched conversations since 15:17')
+        end
+        help.render
+      end
+      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+      private
+
+      def run_sent
+        raise UsageError, 'Use either --all or --workspace, not both.' if @options[:all] && @options[:workspace]
+
+        return run_changes if @options[:changed_since]
+
+        query = date_query
+        entries = collect_entries(query)
+        @options[:mine] ? emit(entries, query) : emit_context(entries)
+        0
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def run_changes
+        validate_changed_options
+        since = Support::CheckInTime.parse(@options[:changed_since])
+        entries = collect_entries(changed_query)
+        changes = Services::SentChanges.new(
+          runner: runner, since: since, context: @options[:context], max: @options[:max],
+          before: @options[:before], after_minutes: @options[:after_minutes]
+        ).collect(entries, workspaces: selected_workspaces)
+        Formatters::SentFormatter.new(runner: runner, options: format_options).display_changes(
+          changes, changed_since: since, lookback_days: @options[:lookback], json: @options[:json]
+        )
+        0
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      def validate_changed_options
+        if positional_args.any? || @options[:since]
+          raise UsageError, 'Use --changed-since alone, not with a date or --since.'
+        end
+        raise UsageError, 'Use --changed-since without --mine.' if @options[:mine]
+      end
+
+      def changed_query
+        start_date = Date.today - (@options[:lookback] - 1)
+        "from:me after:#{start_date - 1} before:#{Date.today + 1}"
+      end
+
+      def positive_integer(flag, args)
+        number = nonnegative_integer(flag, args)
+        raise UsageError, "#{flag} expects a positive integer." if number.zero?
+
+        number
+      end
+
+      def before_limit(flag, args)
+        number = nonnegative_integer(flag, args)
+        raise UsageError, '--before must be at most 200.' if number > 200
+
+        number
+      end
+
+      def nonnegative_integer(flag, args)
+        value = option_value(flag, args)
+        number = Integer(value, exception: false)
+        raise UsageError, "#{flag} expects a non-negative integer." unless number && !number.negative?
+
+        number
+      end
+
+      def date_query
+        raise UsageError, 'Use either a date or --since, not both.' if @options[:since] && positional_args.any?
+        raise UsageError, 'Expected one date: today, yesterday, or YYYY-MM-DD.' if positional_args.length > 1
+
+        @options[:since] ? range_query : day_query
+      end
+
+      def range_query
+        since = parse_date(@options[:since])
+        raise UsageError, '--since must not be in the future.' if since > Date.today
+
+        "from:me after:#{since - 1} before:#{Date.today + 1}"
+      end
+
+      def day_query
+        date = case positional_args.first
+               when nil, 'today' then Date.today
+               when 'yesterday' then Date.today - 1
+               else parse_date(positional_args.first)
+               end
+        "from:me on:#{date}"
+      end
+
+      def parse_date(value)
+        raise UsageError, "Invalid date: #{value.inspect}. Use YYYY-MM-DD." unless value.match?(/\A\d{4}-\d{2}-\d{2}\z/)
+
+        Date.iso8601(value)
+      rescue Date::Error
+        raise UsageError, "Invalid date: #{value.inspect}. Use YYYY-MM-DD."
+      end
+
+      def collect_entries(query)
+        entries = selected_workspaces.flat_map { |workspace| fetch_workspace(workspace, query) }
+        entries.sort_by { |workspace, result| [result.ts.to_f, workspace.name, result.channel_id.to_s] }
+      end
+
+      def selected_workspaces
+        @options[:workspace] ? [runner.workspace(@options[:workspace])] : runner.all_workspaces
+      end
+
+      def fetch_workspace(workspace, query)
+        pages = Services::SearchPages.new(runner.search_api(workspace.name)).fetch(query: query, sort_dir: 'asc')
+        pages[:results].map { |result| [workspace, result] }
+      end
+
+      def emit_context(entries)
+        start_date, end_date = selected_dates
+        conversations = Services::SentConversations.new(
+          runner: runner, start_date: start_date, end_date: end_date,
+          before: @options[:before], after_minutes: @options[:after_minutes], max: @options[:max]
+        ).collect(entries)
+        Formatters::SentFormatter.new(runner: runner, options: format_options).display(
+          conversations, start_date: start_date, end_date: end_date, json: @options[:json]
+        )
+      end
+
+      def selected_dates
+        return [parse_date(@options[:since]), Date.today] if @options[:since]
+
+        date = case positional_args.first
+               when nil, 'today' then Date.today
+               when 'yesterday' then Date.today - 1
+               else parse_date(positional_args.first)
+               end
+        [date, date]
+      end
+
+      def emit(entries, query)
+        counts = entries.group_by { |workspace, result| [workspace.name, result.channel_id] }
+        if @options[:json]
+          output_json(query: query, counts: json_counts(counts), results: entries.map do |workspace, result|
+            result.to_h.merge(workspace: workspace.name)
+          end)
+        else
+          display_counts(counts, entries)
+        end
+      end
+
+      def json_counts(counts)
+        counts.map do |(workspace, channel_id), group|
+          result = group.first.last
+          { workspace: workspace, channel_id: channel_id, channel_name: result.channel_name,
+            channel_label: destination_label(runner.workspace(workspace), result),
+            channel_type: result.channel_type, count: group.size }
+        end
+      end
+
+      def display_counts(counts, entries)
+        if entries.empty?
+          puts 'No sent messages found.'
+          return
+        end
+
+        counts.each_value { |group| display_count(group) }
+        puts
+        entries.each { |workspace, result| display_entry(workspace, result) }
+      end
+
+      def display_entry(workspace, result)
+        options = format_options.merge(workspace_label: true, channel_label: destination_label(workspace, result))
+        runner.search_formatter.display_result(result, workspace, options)
+      end
+
+      def display_count(group)
+        workspace, result = group.first
+        puts "[#{workspace.name}] #{destination_label(workspace, result)}: #{group.size}"
+      end
+
+      def destination_label(workspace, result)
+        runner.sent_channel_label.label(
+          workspace: workspace, type: result.channel_type, name: result.channel_name,
+          channel_id: result.channel_id, self_user_id: result.user_id, self_username: result.username
+        )
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/slk/formatters/attachment_formatter.rb

@@ -32,7 +32,7 @@ module Slk
         format_author(attachment, lines)
         format_text(att_text, lines, options) if att_text && block_images.empty?
         format_image(attachment, lines, options, message_ts: message_ts, index: index) if image_url
-        block_images.each { |img| lines << "> [Image: #{img}]" }
+        format_block_images(block_images, lines)
       end
       # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
@@ -46,9 +46,13 @@ module Slk
         end
       end
 
+      def format_block_images(images, lines)
+        images.each { |img| lines << "> [Image: #{@text_processor.call(img)}]" }
+      end
+
       def format_author(attachment, lines)
         author = attachment['author_name'] || attachment['author_subname']
-        lines << "> #{@output.bold(author)}:" if author
+        lines << "> #{@output.bold(@text_processor.call(author))}:" if author
       end
 
       def format_text(att_text, lines, options)
@@ -73,7 +77,7 @@ module Slk
         else
           image_url = attachment['image_url'] || attachment['thumb_url']
           filename = attachment['title'] || extract_filename(image_url)
-          lines << "> [Image: #{filename}]"
+          lines << "> [Image: #{@text_processor.call(filename)}]"
         end
       end
 

data/lib/slk/formatters/search_formatter.rb

@@ -23,25 +23,38 @@ module Slk
       # Display a single search result
       def display_result(result, workspace, options = {})
         timestamp = @output.blue("[#{format_time(result.timestamp)}]")
-        channel = @output.cyan(resolve_channel(result, workspace))
+        channel = @output.cyan(display_channel_label(result, workspace, options))
         user = @output.bold("#{resolve_user(result, workspace)}:")
         text = prepare_text(result.text, workspace, options)
 
-        @output.puts "#{timestamp} #{channel} #{user} #{text}"
-        display_files(result.files) if result.files&.any?
+        workspace_label = workspace_prefix(workspace, options)
+        @output.puts "#{timestamp} #{workspace_label}#{channel} #{user} #{text}"
+        display_files(result.files, workspace, options) if result.files&.any?
       end
 
-      private
+      # Channel label used by search timelines and per-channel summaries.
+      def channel_label(result, workspace)
+        channel_label_for(result.channel_type, result.channel_name, workspace)
+      end
 
-      def resolve_channel(result, workspace)
-        if result.dm?
-          # For DMs, channel_name is a user ID - resolve it
-          @mentions.replace("<@#{result.channel_name}>", workspace)
+      def channel_label_for(type, name, workspace)
+        if %w[im mpim].include?(type)
+          @mentions.replace("<@#{name}>", workspace)
         else
-          "##{result.channel_name}"
+          "##{name}"
         end
       end
 
+      private
+
+      def display_channel_label(result, workspace, options)
+        options[:channel_label] || channel_label(result, workspace)
+      end
+
+      def workspace_prefix(workspace, options)
+        options[:workspace_label] ? "#{@output.cyan("[#{workspace.name}]")} " : ''
+      end
+
       def resolve_user(result, workspace)
         # If we have a username, use it directly
         return result.username if result.username && !result.username.empty?
@@ -57,9 +70,10 @@ module Slk
         @text_processor.process(text, workspace, options)
       end
 
-      def display_files(files)
+      def display_files(files, workspace, options)
         files.each do |file|
-          @output.puts @output.blue("[Image: #{file[:name]}]")
+          name = prepare_text(file[:name], workspace, options)
+          @output.puts @output.blue("[Image: #{name}]")
         end
       end